1 files changed, 273 insertions, 0 deletions
diff --git a/vespajlib/src/test/java/com/yahoo/slime/JsonFormatTestCase.java b/vespajlib/src/test/java/com/yahoo/slime/JsonFormatTestCase.java
new file mode 100644
index 00000000000..e48a717f150
--- /dev/null
+++ b/vespajlib/src/test/java/com/yahoo/slime/JsonFormatTestCase.java
@@ -0,0 +1,273 @@
+// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.slime;
+
+import com.yahoo.text.Utf8;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class JsonFormatTestCase {
+
+    @Test
+    public void testBasic() {
+        System.out.println("test encoding slime holding a single basic value");
+        {
+            Slime slime = new Slime();
+            slime.setBool(false);
+            verifyEncoding(slime, "false");
+        }
+
+        {
+            Slime slime = new Slime();
+            slime.setBool(true);
+            verifyEncoding(slime, "true");
+        }
+
+        {
+            Slime slime = new Slime();
+            slime.setLong(0);
+            verifyEncoding(slime, "0");
+        }
+        {
+            Slime slime = new Slime();
+            slime.setLong(13);
+            verifyEncoding(slime, "13");
+        }
+        {
+            Slime slime = new Slime();
+            slime.setLong(-123456789);
+            verifyEncoding(slime, "-123456789");
+        }
+        {
+            Slime slime = new Slime();
+            slime.setDouble(0.0);
+            verifyEncoding(slime, "0.0");
+        }
+        {
+            Slime slime = new Slime();
+            slime.setDouble(1.5);
+            verifyEncoding(slime, "1.5");
+        }
+        {
+            Slime slime = new Slime();
+            slime.setString("");
+            verifyEncoding(slime, "\"\"");
+        }
+        {
+            Slime slime = new Slime();
+            slime.setString("fo");
+            verifyEncoding(slime, "\"fo\"");
+        }
+        {
+            Slime slime = new Slime();
+            slime.setString("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+            verifyEncoding(slime, "\"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\"");
+        }
+        {
+            Slime slime = new Slime();
+            slime.setData(new byte[0]);
+            verifyEncoding(slime, "\"0x\"");
+        }
+
+        {
+            Slime slime = new Slime();
+            byte[] data = { 42, -123 };
+            slime.setData(data);
+            String expect = "\"0x2A85\"";
+            verifyEncoding(slime, expect);
+        }
+
+        {
+            Slime slime = new Slime();
+            String expected = "\"my\\nencoded\\rsting\\\\is\\bthe\\fnicest\\t\\\"string\\\"\\u0005\"";
+            slime.setString("my\nencoded\rsting\\is\bthe\fnicest\t\"string\"" + Character.toString((char) 5));
+            verifyEncoding(slime, expected);
+        }
+
+        {
+            Slime slime = new Slime();
+            slime.setDouble(Double.NaN);
+            verifyEncoding(slime, "null");
+            slime.setDouble(Double.NEGATIVE_INFINITY);
+            verifyEncoding(slime, "null");
+            slime.setDouble(Double.POSITIVE_INFINITY);
+            verifyEncoding(slime, "null");
+        }
+    }
+
+    @Test
+    public void testArray() {
+        System.out.println("test encoding slime holding an array of various basic values");
+        Slime slime = new Slime();
+        Cursor c = slime.setArray();
+        byte[] data = { 'd', 'a', 't', 'a' };
+        c.addNix();
+        c.addBool(true);
+        c.addLong(42);
+        c.addDouble(3.5);
+        c.addString("string");
+        c.addData(data);
+
+        verifyEncoding(slime, "[null,true,42,3.5,\"string\",\"0x64617461\"]");
+    }
+
+    @Test
+    public void testObject() {
+        System.out.println("test encoding slime holding an object of various basic values");
+        Slime slime = new Slime();
+        Cursor c = slime.setObject();
+        byte[] data = { 'd', 'a', 't', 'a' };
+        c.setNix("a");
+        c.setBool("b", true);
+        c.setLong("c", 42);
+        c.setDouble("d", 3.5);
+        c.setString("e", "string");
+        c.setData("f", data);
+        verifyEncoding(slime, "{\"a\":null,\"b\":true,\"c\":42,\"d\":3.5,\"e\":\"string\",\"f\":\"0x64617461\"}");
+        String expected = "{\n"
+                        + " \"a\": null,\n"
+                        + " \"b\": true,\n"
+                        + " \"c\": 42,\n"
+                        + " \"d\": 3.5,\n"
+                        + " \"e\": \"string\",\n"
+                        + " \"f\": \"0x64617461\"\n"
+                        + "}\n";
+        verifyEncoding(slime, expected, false);
+    }
+
+    @Test
+    public void testNesting() {
+        System.out.println("test encoding slime holding a more complex structure");
+        Slime slime = new Slime();
+        Cursor c1 = slime.setObject();
+        c1.setLong("bar", 10);
+        Cursor c2 = c1.setArray("foo");
+        c2.addLong(20);
+        Cursor c3 = c2.addObject();
+        c3.setLong("answer", 42);
+        verifyEncoding(slime, "{\"bar\":10,\"foo\":[20,{\"answer\":42}]}");
+    }
+
+    @Test
+    public void testDecodeEncode() {
+        System.out.println("test decoding and encoding a json string yields the same string");
+        verifyEncodeDecode("{\"bar\":10,\"foo\":[20,{\"answer\":42}]}", true);
+        String expected = "{\n"
+                + " \"a\": null,\n"
+                + " \"b\": true,\n"
+                + " \"c\": 42,\n"
+                + " \"d\": 3.5,\n"
+                + " \"e\": \"string\",\n"
+                + " \"f\": \"0x64617461\"\n"
+                + "}\n";
+        verifyEncodeDecode(expected, false);
+    }
+
+    @Test
+    public void testDecodeEncodeUtf8() {
+        final String json = "{\n" +
+                " \"rules\": \"# Use unicode equivalents in java source:\\n" +
+                "        #\\n" +
+                "        #   佳:\u4f73\"\n" +
+                "}\n";
+        verifyEncodeDecode(json, false);
+    }
+
+    @Test
+    public void testDecodeUtf8() {
+        final String str = "\u4f73:\u4f73";
+        final String json = " {\n" +
+                "            \"rules\": \"" + str + "\"\n" +
+                "        }\n";
+
+        Slime slime = new Slime();
+        slime = new JsonDecoder().decode(slime, Utf8.toBytesStd(json));
+        Cursor a = slime.get().field("rules");
+        assertThat(a.asString(), is(str));
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testThatDecodeIsNotImplemented() throws IOException {
+        new JsonFormat(true).decode(null, null);
+    }
+
+    private void verifyEncoding(Slime slime, String expected) {
+        verifyEncoding(slime, expected, true);
+    }
+
+    @Test
+    public void testEncodingUTF8() throws IOException {
+        Slime slime = new Slime();
+        slime.setString("M\u00E6L");
+        ByteArrayOutputStream a = new ByteArrayOutputStream();
+        new JsonFormat(true).encode(a, slime);
+        String val = new String(a.toByteArray(), "UTF-8");
+        assertEquals("\"M\u00E6L\"", val);
+
+        // TODO Some issues with newline
+        /*
+        slime = new Slime();
+        final String str = "# Use unicode equivalents in java source:\n" +
+                "        #\n" +
+                "        #\n" +
+                "        #   佳:\u4f73\n";
+        slime.setString(str);
+        a = new ByteArrayOutputStream();
+        new JsonFormat(true).encode(a, slime);
+        val = new String(a.toByteArray(), "UTF-8");
+        assertEquals(str, val);
+        */
+    }
+
+    private void verifyEncoding(Slime slime, String expected, boolean compact) {
+        try {
+            ByteArrayOutputStream a = new ByteArrayOutputStream();
+            new JsonFormat(compact).encode(a, slime);
+            assertEquals(expected, new String(a.toByteArray(), StandardCharsets.UTF_8));
+        } catch (Exception e) {
+            fail("Exception thrown when encoding slime: " + e.getMessage());
+        }
+    }
+
+    private void verifyEncodeDecode(String json, boolean compact) {
+        try {
+            Slime slime = new Slime();
+            new JsonDecoder().decode(slime, Utf8.toBytesStd(json));
+            ByteArrayOutputStream a = new ByteArrayOutputStream();
+            new JsonFormat(compact).encode(a, slime);
+            assertEquals(json, Utf8.toString(a.toByteArray()));
+        } catch (Exception e) {
+            fail("Exception thrown when encoding slime: " + e.getMessage());
+        }
+    }
+
+    private String formatDecimal(double value) {
+        try {
+            Slime slime = new Slime();
+            slime.setDouble(value);
+            ByteArrayOutputStream a = new ByteArrayOutputStream();
+            new JsonFormat(true).encode(a, slime);
+            return new String(a.toByteArray(), StandardCharsets.UTF_8);
+        } catch (Exception e) {
+            return "";
+        }
+    }
+
+    @Test
+    public void testDecimalFormat() {
+        assertEquals("0.0", formatDecimal(0.0));
+        assertEquals("1.0", formatDecimal(1.0));
+        assertEquals("2.0", formatDecimal(2.0));
+        assertEquals("1.2", formatDecimal(1.2));
+        assertEquals("3.333333", formatDecimal(3.333333));
+        assertEquals("1.0E20", formatDecimal(1e20));
+   }
+}