[dnm] sort stringified set elements

Stringified set elements are now outputted in sorted order according to
their stringified representation, where previously the output order was
determined by the record ordinals.

Note that this doesn't sort number elements correctly, e.g.,

```
"10"
"2"
```

Author: kvoli

hollow/src/main/java/com/netflix/hollow/tools/stringifier/HollowRecordJsonStringifier.java

@@ -40,6 +40,7 @@
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Set;
 
 /**
@@ -284,15 +285,28 @@ private void appendSetStringify(Writer writer, HollowDataAccess dataAccess, Holl
 
         int elementOrdinal = iter.next();
 
-        if (elementOrdinal == HollowOrdinalIterator.NO_MORE_ORDINALS) {
+
+        List<Integer> elementOrdinals = new java.util.ArrayList<>();
+        while (elementOrdinal != HollowOrdinalIterator.NO_MORE_ORDINALS) {
+            elementOrdinals.add(elementOrdinal);
+            elementOrdinal = iter.next();
+        }
+
+        elementOrdinals.sort((o1, o2) -> {
+            String element1 = stringify(dataAccess, elementType, o1);
+            String element2 = stringify(dataAccess, elementType, o2);
+            return element1.compareTo(element2);
+        });
+
+        if (elementOrdinals.isEmpty()) {
             writer.append("[]");
         } else {
             boolean firstElement = true;
             writer.append("[");
             if (prettyPrint)
                 writer.append(NEWLINE);
 
-            while(elementOrdinal != HollowOrdinalIterator.NO_MORE_ORDINALS) {
+            for (int ord : elementOrdinals) {
                 if (firstElement)
                     firstElement = false;
                 else
@@ -301,9 +315,7 @@ private void appendSetStringify(Writer writer, HollowDataAccess dataAccess, Holl
                 if (prettyPrint)
                     appendIndentation(writer, indentation);
 
-                appendStringify(writer, dataAccess, elementType, elementOrdinal, indentation);
-
-                elementOrdinal = iter.next();
+                appendStringify(writer, dataAccess, elementType, ord, indentation);
             }
 
             if (prettyPrint) {

hollow/src/main/java/com/netflix/hollow/tools/stringifier/HollowRecordStringifier.java

@@ -38,6 +38,7 @@
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Set;
 
 /**
@@ -184,15 +185,25 @@ private void appendSetStringify(Writer writer, HollowDataAccess dataAccess,
 
         int elementOrdinal = iter.next();
 
+        List<Integer> elementOrdinals = new java.util.ArrayList<>();
         while(elementOrdinal != NO_MORE_ORDINALS) {
+            elementOrdinals.add(elementOrdinal);
+            elementOrdinal = iter.next();
+        }
+
+        elementOrdinals.sort((o1, o2) -> {
+            String element1 = stringify(dataAccess, elementType, o1);
+            String element2 = stringify(dataAccess, elementType, o2);
+            return element1.compareTo(element2);
+        });
+
+        for (Integer sortedElementOrd : elementOrdinals) {
             writer.append(NEWLINE);
 
             appendIndentation(writer, indentation);
             writer.append("e: ");
 
-            appendStringify(writer, dataAccess, elementType, elementOrdinal, indentation);
-
-            elementOrdinal = iter.next();
+            appendStringify(writer, dataAccess, elementType, sortedElementOrd, indentation);
         }
     }
 

hollow/src/test/java/com/netflix/hollow/tools/stringifier/AbstractHollowRecordStringifierTest.java

@@ -24,6 +24,7 @@
 import com.netflix.hollow.core.write.objectmapper.HollowObjectMapper;
 import java.io.IOException;
 import java.io.StringWriter;
+import java.util.Set;
 
 /**
  * Code shared between HollowRecordStringifierTest and HollowRecordJsonStringifierTest.
@@ -73,6 +74,21 @@ public TypeWithNestedNonPrimitive(Double value, TypeWithNonPrimitive nestedType)
         }
     }
 
+    static class TypeWithSetOfPrimitives {
+        private final Set<TypeWithPrimitive> values;
+
+        public TypeWithSetOfPrimitives(Set<TypeWithPrimitive> values) {
+            this.values = values;
+        }
+    }
+
+    static class TypeWithSetOfStrings {
+        private final Set<TypeWithString> values;
+
+        public TypeWithSetOfStrings(Set<TypeWithString> values) {
+            this.values = values;
+        }
+    }
 
     /**
      * Sends instances of a type through the HollowRecordStringifier. This concatenates records

hollow/src/test/java/com/netflix/hollow/tools/stringifier/HollowRecordJsonStringifierTest.java

@@ -206,6 +206,34 @@ public void testStringifyStringWithEscapeChars() throws IOException {
                 stringifyType(TypeWithString.class, true, false, new TypeWithString(testString)));
     }
 
+    @Test
+    public void testStringifySetOfPrimitives() throws IOException {
+        // We expect the set of primitives to be sorted (by their string representation).
+        Assert.assertEquals("Set of primitives should be printed correctly",
+                "[100,200,300]",
+                stringifyType(TypeWithSetOfPrimitives.class, false, false,
+                        new TypeWithSetOfPrimitives(
+                                new java.util.HashSet<>(Arrays.asList(
+                                        new TypeWithPrimitive(100),
+                                        new TypeWithPrimitive(300),
+                                        new TypeWithPrimitive(200)
+                                )))));
+    }
+
+    @Test
+    public void testStringifySetOfStrings() throws IOException {
+        // We expect that the set of strings will be sorted.
+        Assert.assertEquals("Set of strings should be printed correctly",
+                "[\"a\",\"b\",\"c\"]",
+                stringifyType(TypeWithSetOfStrings.class, false, false,
+                        new TypeWithSetOfStrings(
+                                new java.util.HashSet<>(Arrays.asList(
+                                        new TypeWithString("c"),
+                                        new TypeWithString("a"),
+                                        new TypeWithString("b")
+                                )))));
+    }
+
     private static <T> String stringifyType(Class<T> clazz, boolean prettyPrint, boolean expanded, T... instances) throws IOException {
         HollowRecordJsonStringifier stringifier = new HollowRecordJsonStringifier(prettyPrint, !expanded);
         // HollowRecordJsonStringifier stringifier = expanded

hollow/src/test/java/com/netflix/hollow/tools/stringifier/HollowRecordStringifierTest.java

@@ -135,6 +135,38 @@ public void testStringifyIterator() throws IOException {
                         "\n]", writer.toString());
     }
 
+    @Test
+    public void testStringifySetOfPrimitives() throws IOException {
+        // We expect the set of primitives to be sorted (by their string representation).
+        Assert.assertEquals("Set of primitives should be printed correctly",
+                "\n  e: 100\n" +
+                        "  e: 200\n" +
+                        "  e: 300",
+                stringifyType(TypeWithSetOfPrimitives.class, false,
+                        new TypeWithSetOfPrimitives(
+                                new java.util.HashSet<>(Arrays.asList(
+                                        new TypeWithPrimitive(100),
+                                        new TypeWithPrimitive(300),
+                                        new TypeWithPrimitive(200)
+                                )))));
+    }
+
+    @Test
+    public void testStringifySetOfStrings() throws IOException {
+        // We expect the set of strings to be sorted.
+        Assert.assertEquals("Set of strings should be printed correctly",
+                "\n  e: a\n" +
+                        "  e: b\n" +
+                        "  e: c",
+                stringifyType(TypeWithSetOfStrings.class, false,
+                        new TypeWithSetOfStrings(
+                                new java.util.HashSet<>(Arrays.asList(
+                                        new TypeWithString("c"),
+                                        new TypeWithString("a"),
+                                        new TypeWithString("b")
+                                )))));
+    }
+
     private static <T> String stringifyType(Class<T> clazz, boolean expanded, T... instances) throws IOException {
         HollowRecordStringifier stringifier = expanded
             ? new HollowRecordStringifier(true, true, false) : new HollowRecordStringifier();