Publish

1 files changed, 435 insertions, 0 deletions

diff --git a/jrt/tests/com/yahoo/jrt/ValuesTest.java b/jrt/tests/com/yahoo/jrt/ValuesTest.java
new file mode 100644
index 00000000000..36320b10993
--- /dev/null
+++ b/jrt/tests/com/yahoo/jrt/ValuesTest.java
@@ -0,0 +1,435 @@
+// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+package com.yahoo.jrt;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+public class ValuesTest extends junit.framework.TestCase {
+
+    public ValuesTest(String name) {
+        super(name);
+    }
+
+    public void testEmpty() {
+        Values src = new Values();
+        assertEquals(src.bytes(), 4);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), 4);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        assertEquals(dst.bytes(), 4);
+    }
+
+    void checkSingleValue(Values v, byte type, int bytes) {
+        assertEquals(v.size(), 1);
+        assertEquals(v.get(0).type(), type);
+        assertEquals(v.bytes(), bytes);
+    }
+
+    public void testInt8() {
+        int byteSize = 4 + 1 + 1;
+        Values src = new Values();
+        src.add(new Int8Value((byte)1));
+        checkSingleValue(src, Value.INT8, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.INT8, byteSize);
+        assertEquals(dst.get(0).asInt8(), (byte)1);
+    }
+
+    public void testInt8Array() {
+        int byteSize = 4 + 1 + 4 + 4;
+        Values src = new Values();
+        byte[] val = { 1, 2, 3, 4 };
+        src.add(new Int8Array(val));
+        checkSingleValue(src, Value.INT8_ARRAY, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.INT8_ARRAY, byteSize);
+        assertTrue(Arrays.equals(dst.get(0).asInt8Array(), val));
+    }
+
+    public void testInt16() {
+        int byteSize = 4 + 1 + 2;
+        Values src = new Values();
+        src.add(new Int16Value((short)2));
+        checkSingleValue(src, Value.INT16, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.INT16, byteSize);
+        assertEquals(dst.get(0).asInt16(), (short)2);
+    }
+
+    public void testInt16Array() {
+        int byteSize = 4 + 1 + 4 + 4 * 2;
+        Values src = new Values();
+        short[] val = { 2, 4, 6, 8 };
+        src.add(new Int16Array(val));
+        checkSingleValue(src, Value.INT16_ARRAY, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.INT16_ARRAY, byteSize);
+        assertTrue(Arrays.equals(dst.get(0).asInt16Array(), val));
+    }
+
+    public void testInt32() {
+        int byteSize = 4 + 1 + 4;
+        Values src = new Values();
+        src.add(new Int32Value(4));
+        checkSingleValue(src, Value.INT32, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.INT32, byteSize);
+        assertEquals(dst.get(0).asInt32(), 4);
+    }
+
+    public void testInt32Array() {
+        int byteSize = 4 + 1 + 4 + 4 * 4;
+        Values src = new Values();
+        int[] val = { 4, 8, 12, 16 };
+        src.add(new Int32Array(val));
+        checkSingleValue(src, Value.INT32_ARRAY, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.INT32_ARRAY, byteSize);
+        assertTrue(Arrays.equals(dst.get(0).asInt32Array(), val));
+    }
+
+    public void testInt64() {
+        int byteSize = 4 + 1 + 8;
+        Values src = new Values();
+        src.add(new Int64Value(8));
+        checkSingleValue(src, Value.INT64, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.INT64, byteSize);
+        assertEquals(dst.get(0).asInt64(), 8);
+    }
+
+    public void testInt64Array() {
+        int byteSize = 4 + 1 + 4 + 4 * 8;
+        Values src = new Values();
+        long[] val = { 8, 16, 24, 32 };
+        src.add(new Int64Array(val));
+        checkSingleValue(src, Value.INT64_ARRAY, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.INT64_ARRAY, byteSize);
+        assertTrue(Arrays.equals(dst.get(0).asInt64Array(), val));
+    }
+
+    public void testFloat() {
+        int byteSize = 4 + 1 + 4;
+        Values src = new Values();
+        src.add(new FloatValue((float)2.5));
+        checkSingleValue(src, Value.FLOAT, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.FLOAT, byteSize);
+        assertTrue(dst.get(0).asFloat() == (float)2.5);
+    }
+
+    public void testFloatArray() {
+        int byteSize = 4 + 1 + 4 + 4 * 4;
+        Values src = new Values();
+        float[] val = { 1.5f, 2.0f, 2.5f, 3.0f };
+        src.add(new FloatArray(val));
+        checkSingleValue(src, Value.FLOAT_ARRAY, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.FLOAT_ARRAY, byteSize);
+        assertTrue(Arrays.equals(dst.get(0).asFloatArray(), val));
+    }
+
+    public void testDouble() {
+        int byteSize = 4 + 1 + 8;
+        Values src = new Values();
+        src.add(new DoubleValue(3.75));
+        checkSingleValue(src, Value.DOUBLE, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.DOUBLE, byteSize);
+        assertTrue(dst.get(0).asDouble() == 3.75);
+    }
+
+    public void testDoubleArray() {
+        int byteSize = 4 + 1 + 4 + 4 * 8;
+        Values src = new Values();
+        double[] val = { 1.25, 1.50, 1.75, 2.00 };
+        src.add(new DoubleArray(val));
+        checkSingleValue(src, Value.DOUBLE_ARRAY, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.DOUBLE_ARRAY, byteSize);
+        assertTrue(Arrays.equals(dst.get(0).asDoubleArray(), val));
+    }
+
+    public void testData() {
+        int byteSize = 4 + 1 + 4 + 4;
+        Values src = new Values();
+        byte[] val = { 1, 2, 3, 4 };
+        src.add(new DataValue(val));
+        checkSingleValue(src, Value.DATA, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.DATA, byteSize);
+        assertTrue(Arrays.equals(dst.get(0).asData(), val));
+    }
+
+    public void testDataArray() {
+        int byteSize = 4 + 1 + 4 + 4 * (4 + 4);
+        Values src = new Values();
+        byte[][] val = {{ 1, 0, 1, 0 },
+                        { 0, 2, 0, 2 },
+                        { 3, 0, 3, 0 },
+                        { 0, 4, 0, 4 }};
+        src.add(new DataArray(val));
+        checkSingleValue(src, Value.DATA_ARRAY, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.DATA_ARRAY, byteSize);
+        assertTrue(Arrays.equals(dst.get(0).asDataArray()[0], val[0]));
+        assertTrue(Arrays.equals(dst.get(0).asDataArray()[1], val[1]));
+        assertTrue(Arrays.equals(dst.get(0).asDataArray()[2], val[2]));
+        assertTrue(Arrays.equals(dst.get(0).asDataArray()[3], val[3]));
+    }
+
+    public void testString1() {
+        int byteSize = 4 + 1 + 4 + 4;
+        Values src = new Values();
+        String val = "test";
+        src.add(new StringValue(val));
+        checkSingleValue(src, Value.STRING, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.STRING, byteSize);
+        assertTrue(dst.get(0).asString().equals("test"));
+    }
+
+    public void testString2() {
+        int byteSize = 4 + 1 + 4 + 7;
+        Values src = new Values();
+        String val = "H" + ((char)229) + "vard";
+        src.add(new StringValue(val));
+        checkSingleValue(src, Value.STRING, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        byte right[] = new byte[] { 0, 0, 0, 1, 's',
+                                    0, 0, 0, 7, 'H',
+                                    (byte)(0xC0 | (0xE5 >> 6)),
+                                    (byte)(0x80 | (0xE5 & 0x3F)),
+                                    'v', 'a', 'r', 'd'
+        };
+        for (int ii = 0; ii < buf.remaining(); ++ii) {
+            assertEquals(buf.get(ii), right[ii]);
+        }
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.STRING, byteSize);
+        assertTrue(dst.get(0).asString().equals("H\u00E5vard"));
+    }
+
+    public void testStringArray() {
+        int byteSize = 4 + 1 + 4 + 4 * 4 + 3 + 3 + 5 + 4;
+        Values src = new Values();
+        String[] val = { "one", "two", "three", "four" };
+        src.add(new StringArray(val));
+        checkSingleValue(src, Value.STRING_ARRAY, byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        checkSingleValue(src, Value.STRING_ARRAY, byteSize);
+        assertTrue(dst.get(0).asStringArray()[0].equals("one"));
+        assertTrue(dst.get(0).asStringArray()[1].equals("two"));
+        assertTrue(dst.get(0).asStringArray()[2].equals("three"));
+        assertTrue(dst.get(0).asStringArray()[3].equals("four"));
+    }
+
+    public void testAllValues() {
+        int byteSize =
+            4 + 16                       // typestring
+            + 1                          // int8
+            + 4 + 4                      // int8 array
+            + 2                          // int16
+            + 4 + 4 * 2                  // int16 array
+            + 4                          // int32
+            + 4 + 4 * 4                  // int32 array
+            + 8                          // int64
+            + 4 + 4 * 8                  // int64 array
+            + 4                          // float
+            + 4 + 4 * 4                  // float array
+            + 8                          // double
+            + 4 + 4 * 8                  // double array
+            + 4 + 4                      // data
+            + 4 + 4 * 4 + 4 + 4 + 4 + 4  // data array
+            + 4 + 4                      // string
+            + 4 + 4 * 4 + 3 + 3 + 5 + 4; // string array
+
+        byte[] dataValue = { 1, 2, 3, 4 };
+        byte[] int8Array = { 1, 2, 3, 4 };
+        short[] int16Array = { 2, 4, 6, 8 };
+        int[] int32Array = { 4, 8, 12, 16 };
+        long[] int64Array = { 8, 16, 24, 32 };
+        float[] floatArray = { 1.5f, 2.0f, 2.5f, 3.0f };
+        double[] doubleArray = { 1.25, 1.50, 1.75, 2.00 };
+        byte[][] dataArray = {{ 1, 0, 1, 0 },
+                              { 0, 2, 0, 2 },
+                              { 3, 0, 3, 0 },
+                              { 0, 4, 0, 4 }};
+        String[] stringArray = { "one", "two", "three", "four" };
+
+        Values src = new Values();
+        src.add(new Int8Value((byte)1));
+        src.add(new Int8Array(int8Array));
+        src.add(new Int16Value((short)2));
+        src.add(new Int16Array(int16Array));
+        src.add(new Int32Value(4));
+        src.add(new Int32Array(int32Array));
+        src.add(new Int64Value(8));
+        src.add(new Int64Array(int64Array));
+        src.add(new FloatValue(2.5f));
+        src.add(new FloatArray(floatArray));
+        src.add(new DoubleValue(3.75));
+        src.add(new DoubleArray(doubleArray));
+        src.add(new DataValue(dataValue));
+        src.add(new DataArray(dataArray));
+        src.add(new StringValue("test"));
+        src.add(new StringArray(stringArray));
+        assertEquals(src.size(), 16);
+        assertEquals(src.bytes(), byteSize);
+
+        ByteBuffer buf = ByteBuffer.allocate(src.bytes());
+        src.encode(buf);
+        buf.flip();
+        assertEquals(buf.remaining(), byteSize);
+
+        Values dst = new Values();
+        dst.decode(buf);
+        assertEquals(dst.get(0).asInt8(), (byte)1);
+        assertTrue(Arrays.equals(dst.get(1).asInt8Array(), int8Array));
+        assertEquals(dst.get(2).asInt16(), (short)2);
+        assertTrue(Arrays.equals(dst.get(3).asInt16Array(), int16Array));
+        assertEquals(dst.get(4).asInt32(), 4);
+        assertTrue(Arrays.equals(dst.get(5).asInt32Array(), int32Array));
+        assertEquals(dst.get(6).asInt64(), 8);
+        assertTrue(Arrays.equals(dst.get(7).asInt64Array(), int64Array));
+        assertTrue(dst.get(8).asFloat() == (float)2.5);
+        assertTrue(Arrays.equals(dst.get(9).asFloatArray(), floatArray));
+        assertTrue(dst.get(10).asDouble() == 3.75);
+        assertTrue(Arrays.equals(dst.get(11).asDoubleArray(), doubleArray));
+        assertTrue(Arrays.equals(dst.get(12).asData(), dataValue));
+        assertTrue(Arrays.equals(dst.get(13).asDataArray()[0], dataArray[0]));
+        assertTrue(Arrays.equals(dst.get(13).asDataArray()[1], dataArray[1]));
+        assertTrue(Arrays.equals(dst.get(13).asDataArray()[2], dataArray[2]));
+        assertTrue(Arrays.equals(dst.get(13).asDataArray()[3], dataArray[3]));
+        assertTrue(dst.get(14).asString().equals("test"));
+        assertTrue(dst.get(15).asStringArray()[0].equals("one"));
+        assertTrue(dst.get(15).asStringArray()[1].equals("two"));
+        assertTrue(dst.get(15).asStringArray()[2].equals("three"));
+        assertTrue(dst.get(15).asStringArray()[3].equals("four"));
+    }
+}