/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.avro.io;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import org.apache.avro.Schema;
import org.apache.avro.util.Utf8;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@RunWith(Parameterized.class)
public class TestValidatingIO {
enum Encoding {
BINARY,
BLOCKING_BINARY,
JSON,
}
private static final Logger LOG =
LoggerFactory.getLogger(TestValidatingIO.class);
private Encoding eEnc;
private int iSkipL;
private String sJsSch;
private String sCl;
public TestValidatingIO (Encoding enc, int skip, String js, String cls) {
this.eEnc = enc;
this.iSkipL = skip;
this.sJsSch = js;
this.sCl = cls;
}
private static final int COUNT = 1;
@Test
public void testMain() throws IOException {
for (int i = 0; i < COUNT; i++) {
testOnce(new Schema.Parser().parse(sJsSch), sCl, iSkipL, eEnc);
}
}
private void testOnce(Schema schema, String calls,
int skipLevel,
Encoding encoding)
throws IOException {
Object[] values = randomValues(calls);
print(eEnc, iSkipL, schema, schema, values, values);
byte[] bytes = make(schema, calls, values, encoding);
check(schema, bytes, calls, values, skipLevel, encoding);
}
public static byte[] make(Schema sc, String calls,
Object[] values, Encoding encoding) throws IOException {
EncoderFactory factory = EncoderFactory.get();
ByteArrayOutputStream ba = new ByteArrayOutputStream();
Encoder bvo = null;
switch (encoding) {
case BINARY:
bvo = factory.binaryEncoder(ba, null);
break;
case BLOCKING_BINARY:
bvo = factory.blockingBinaryEncoder(ba, null);
break;
case JSON:
bvo = factory.jsonEncoder(sc, ba);
break;
}
Encoder vo = factory.validatingEncoder(sc, bvo);
generate(vo, calls, values);
vo.flush();
return ba.toByteArray();
}
public static class InputScanner {
private final char[] chars;
private int cpos = 0;
public InputScanner(char[] chars) {
this.chars = chars;
}
public boolean next() {
if (cpos < chars.length) {
cpos++;
}
return cpos != chars.length;
}
public char cur() {
return chars[cpos];
}
public boolean isDone() {
return cpos == chars.length;
}
}
public static void generate(Encoder vw, String calls,
Object[] values) throws IOException {
InputScanner cs = new InputScanner(calls.toCharArray());
int p = 0;
while (! cs.isDone()) {
char c = cs.cur();
cs.next();
switch (c) {
case 'N':
vw.writeNull();
break;
case 'B':
boolean b = (Boolean) values[p++];
vw.writeBoolean(b);
break;
case 'I':
int ii = (Integer) values[p++];
vw.writeInt(ii);
break;
case 'L':
long l = (Long) values[p++];
vw.writeLong(l);
break;
case 'F':
float f = (Float) values[p++];
vw.writeFloat(f);
break;
case 'D':
double d = (Double) values[p++];
vw.writeDouble(d);
break;
case 'S':
{
extractInt(cs);
String s = (String) values[p++];
vw.writeString(new Utf8(s));
break;
}
case 'K':
{
extractInt(cs);
String s = (String) values[p++];
vw.writeString(s);
break;
}
case 'b':
{
extractInt(cs);
byte[] bb = (byte[]) values[p++];
vw.writeBytes(bb);
break;
}
case 'f':
{
extractInt(cs);
byte[] bb = (byte[]) values[p++];
vw.writeFixed(bb);
break;
}
case 'e':
{
int e = extractInt(cs);
vw.writeEnum(e);
break;
}
case '[':
vw.writeArrayStart();
break;
case ']':
vw.writeArrayEnd();
break;
case '{':
vw.writeMapStart();
break;
case '}':
vw.writeMapEnd();
break;
case 'c':
vw.setItemCount(extractInt(cs));
break;
case 's':
vw.startItem();
break;
case 'U':
{
vw.writeIndex(extractInt(cs));
break;
}
default:
fail();
break;
}
}
}
public static Object[] randomValues(String calls) {
Random r = new Random(0L);
InputScanner cs = new InputScanner(calls.toCharArray());
List<Object> result = new ArrayList<Object>();
while (! cs.isDone()) {
char c = cs.cur();
cs.next();
switch (c) {
case 'N':
break;
case 'B':
result.add(r.nextBoolean());
break;
case 'I':
result.add(r.nextInt());
break;
case 'L':
result.add(new Long(r.nextInt()));
break;
case 'F':
result.add(new Float(r.nextInt()));
break;
case 'D':
result.add(new Double(r.nextInt()));
break;
case 'S':
case 'K':
result.add(nextString(r, extractInt(cs)));
break;
case 'b':
case 'f':
result.add(nextBytes(r, extractInt(cs)));
break;
case 'e':
case 'c':
case 'U':
extractInt(cs);
case '[':
case ']':
case '{':
case '}':
case 's':
break;
default:
fail();
break;
}
}
return result.toArray();
}
private static int extractInt(InputScanner sc) {
int r = 0;
while (! sc.isDone()) {
if (Character.isDigit(sc.cur())) {
r = r * 10 + sc.cur() - '0';
sc.next();
} else {
break;
}
}
return r;
}
private static byte[] nextBytes(Random r, int length) {
byte[] bb = new byte[length];
r.nextBytes(bb);
return bb;
}
private static String nextString(Random r, int length) {
char[] cc = new char[length];
for (int i = 0; i < length; i++) {
cc[i] = (char) ('A' + r.nextInt(26));
}
return new String(cc);
}
private static void check(Schema sc, byte[] bytes, String calls,
Object[] values, final int skipLevel, Encoding encoding)
throws IOException {
// dump(bytes);
// System.out.println(new String(bytes, "UTF-8"));
Decoder bvi = null;
switch (encoding) {
case BINARY:
case BLOCKING_BINARY:
bvi = DecoderFactory.get().binaryDecoder(bytes, null);
break;
case JSON:
InputStream in = new ByteArrayInputStream(bytes);
bvi = new JsonDecoder(sc, in);
}
Decoder vi = new ValidatingDecoder(sc, bvi);
check(vi, calls, values, skipLevel);
}
public static void check(Decoder vi, String calls,
Object[] values, final int skipLevel) throws IOException {
InputScanner cs = new InputScanner(calls.toCharArray());
int p = 0;
int level = 0;
long[] counts = new long[100];
boolean[] isArray = new boolean[100];
boolean[] isEmpty = new boolean[100];
while (! cs.isDone()) {
final char c = cs.cur();
cs.next();
switch (c) {
case 'N':
vi.readNull();
break;
case 'B':
assertEquals(values[p++], vi.readBoolean());
break;
case 'I':
assertEquals(values[p++], vi.readInt());
break;
case 'L':
assertEquals(values[p++], vi.readLong());
break;
case 'F':
if (!(values[p] instanceof Float)) fail();
float f = (Float) values[p++];
assertEquals(f, vi.readFloat(), Math.abs(f / 1000));
break;
case 'D':
if (!(values[p] instanceof Double)) fail();
double d = (Double) values[p++];
assertEquals(d, vi.readDouble(), Math.abs(d / 1000));
break;
case 'S':
extractInt(cs);
if (level == skipLevel) {
vi.skipString();
p++;
} else {
String s = (String) values[p++];
assertEquals(new Utf8(s), vi.readString(null));
}
break;
case 'K':
extractInt(cs);
if (level == skipLevel) {
vi.skipString();
p++;
} else {
String s = (String) values[p++];
assertEquals(new Utf8(s), vi.readString(null));
}
break;
case 'b':
extractInt(cs);
if (level == skipLevel) {
vi.skipBytes();
p++;
} else {
byte[] bb = (byte[]) values[p++];
ByteBuffer bb2 = vi.readBytes(null);
byte[] actBytes = new byte[bb2.remaining()];
System.arraycopy(bb2.array(), bb2.position(), actBytes,
0, bb2.remaining());
assertArrayEquals(bb, actBytes);
}
break;
case 'f':
{
int len = extractInt(cs);
if (level == skipLevel) {
vi.skipFixed(len);
p++;
} else {
byte[] bb = (byte[]) values[p++];
byte[] actBytes = new byte[len];
vi.readFixed(actBytes);
assertArrayEquals(bb, actBytes);
}
}
break;
case 'e':
{
int e = extractInt(cs);
if (level == skipLevel) {
vi.readEnum();
} else {
assertEquals(e, vi.readEnum());
}
}
break;
case '[':
if (level == skipLevel) {
p += skip(cs, vi, true);
break;
} else {
level++;
counts[level] = vi.readArrayStart();
isArray[level] = true;
isEmpty[level] = counts[level] == 0;
continue;
}
case '{':
if (level == skipLevel) {
p += skip(cs, vi, false);
break;
} else {
level++;
counts[level] = vi.readMapStart();
isArray[level] = false;
isEmpty[level] = counts[level] == 0;
continue;
}
case ']':
assertEquals(0, counts[level]);
if (! isEmpty[level]) {
assertEquals(0, vi.arrayNext());
}
level--;
break;
case '}':
assertEquals(0, counts[level]);
if (! isEmpty[level]) {
assertEquals(0, vi.mapNext());
}
level--;
break;
case 's':
if (counts[level] == 0) {
if (isArray[level]) {
counts[level] = vi.arrayNext();
} else {
counts[level] = vi.mapNext();
}
}
counts[level]--;
continue;
case 'c':
extractInt(cs);
continue;
case 'U':
{
int idx = extractInt(cs);
assertEquals(idx, vi.readIndex());
continue;
}
case 'R':
((ResolvingDecoder) vi).readFieldOrder();
continue;
default:
fail();
}
}
assertEquals(values.length, p);
}
private static int skip(InputScanner cs, Decoder vi, boolean isArray)
throws IOException {
final char end = isArray ? ']' : '}';
if (isArray) {
assertEquals(0, vi.skipArray());
} else if (end == '}'){
assertEquals(0, vi.skipMap());
}
int level = 0;
int p = 0;
while (! cs.isDone()) {
char c = cs.cur();
cs.next();
switch (c) {
case '[':
case '{':
++level;
break;
case ']':
case '}':
if (c == end && level == 0) {
return p;
}
level--;
break;
case 'B':
case 'I':
case 'L':
case 'F':
case 'D':
case 'S':
case 'K':
case 'b':
case 'f':
case 'e':
p++;
break;
}
}
throw new RuntimeException("Don't know how to skip");
}
@Parameterized.Parameters
public static Collection<Object[]> data() {
return Arrays.asList(convertTo2dArray(encodings, skipLevels, testSchemas()));
}
private static Object[][] encodings = new Object[][] {
{ Encoding.BINARY }, { Encoding.BLOCKING_BINARY },
{ Encoding.JSON }
};
private static Object[][] skipLevels = new Object[][] {
{ -1 }, { 0 }, { 1 }, { 2 },
};
public static Object[][] convertTo2dArray(final Object[][]... values) {
ArrayList<Object[]> ret = new ArrayList<Object[]>();
Iterator<Object[]> iter = cartesian(values);
while (iter.hasNext()) {
Object[] objects = iter.next();
ret.add(objects);
}
Object[][] retArrays = new Object[ret.size()][];
for (int i = 0; i < ret.size(); i++) {
retArrays[i] = ret.get(i);
}
return retArrays;
}
/**
* Returns the Cartesian product of input sequences.
*/
public static Iterator<Object[]> cartesian(final Object[][]... values) {
return new Iterator<Object[]>() {
private int[] pos = new int[values.length];
@Override
public boolean hasNext() {
return pos[0] < values[0].length;
}
@Override
public Object[] next() {
Object[][] v = new Object[values.length][];
for (int i = 0; i < v.length; i++) {
v[i] = values[i][pos[i]];
}
for (int i = v.length - 1; i >= 0; i--) {
if (++pos[i] == values[i].length) {
if (i != 0) {
pos[i] = 0;
}
} else {
break;
}
}
return concat(v);
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
/**
* Concatenates the input sequences in order and forms a longer sequence.
*/
public static Object[] concat(Object[]... oo) {
int l = 0;
for (Object[] o : oo) {
l += o.length;
}
Object[] result = new Object[l];
l = 0;
for (Object[] o : oo) {
System.arraycopy(o, 0, result, l, o.length);
l += o.length;
}
return result;
}
/**
* Pastes incoming tables to form a wider table. All incoming tables
* should be of same height.
*/
static Object[][] paste(Object[][]... in) {
Object[][] result = new Object[in[0].length][];
Object[][] cc = new Object[in.length][];
for (int i = 0; i < result.length; i++) {
for (int j = 0; j < cc.length; j++) {
cc[j] = in[j][i];
}
result[i] = concat(cc);
}
return result;
}
public static Object[][] testSchemas() {
/**
* The first argument is a schema.
* The second one is a sequence of (single character) mnemonics:
* N null
* B boolean
* I int
* L long
* F float
* D double
* K followed by integer - key-name (and its length) in a map
* S followed by integer - string and its length
* b followed by integer - bytes and length
* f followed by integer - fixed and length
* c Number of items to follow in an array/map.
* U followed by integer - Union and its branch
* e followed by integer - Enum and its value
* [ Start array
* ] End array
* { Start map
* } End map
* s start item
*/
return new Object[][] {
{ "\"null\"", "N" },
{ "\"boolean\"", "B" },
{ "\"int\"", "I" },
{ "\"long\"", "L" },
{ "\"float\"", "F" },
{ "\"double\"", "D" },
{ "\"string\"", "S0" },
{ "\"string\"", "S10" },
{ "\"bytes\"", "b0" },
{ "\"bytes\"", "b10" },
{ "{\"type\":\"fixed\", \"name\":\"fi\", \"size\": 1}", "f1" },
{ "{\"type\":\"fixed\", \"name\":\"fi\", \"size\": 10}", "f10" },
{ "{\"type\":\"enum\", \"name\":\"en\", \"symbols\":[\"v1\", \"v2\"]}",
"e1" },
{ "{\"type\":\"array\", \"items\": \"boolean\"}", "[]", },
{ "{\"type\":\"array\", \"items\": \"int\"}", "[]", },
{ "{\"type\":\"array\", \"items\": \"long\"}", "[]", },
{ "{\"type\":\"array\", \"items\": \"float\"}", "[]", },
{ "{\"type\":\"array\", \"items\": \"double\"}", "[]", },
{ "{\"type\":\"array\", \"items\": \"string\"}", "[]", },
{ "{\"type\":\"array\", \"items\": \"bytes\"}", "[]", },
{ "{\"type\":\"array\", \"items\":{\"type\":\"fixed\", "
+ "\"name\":\"fi\", \"size\": 10}}", "[]" },
{ "{\"type\":\"array\", \"items\": \"boolean\"}", "[c1sB]" },
{ "{\"type\":\"array\", \"items\": \"int\"}", "[c1sI]" },
{ "{\"type\":\"array\", \"items\": \"long\"}", "[c1sL]" },
{ "{\"type\":\"array\", \"items\": \"float\"}", "[c1sF]" },
{ "{\"type\":\"array\", \"items\": \"double\"}", "[c1sD]" },
{ "{\"type\":\"array\", \"items\": \"string\"}", "[c1sS10]" },
{ "{\"type\":\"array\", \"items\": \"bytes\"}", "[c1sb10]" },
{ "{\"type\":\"array\", \"items\": \"int\"}", "[c1sIc1sI]" },
{ "{\"type\":\"array\", \"items\": \"int\"}", "[c2sIsI]" },
{ "{\"type\":\"array\", \"items\":{\"type\":\"fixed\", "
+ "\"name\":\"fi\", \"size\": 10}}", "[c2sf10sf10]" },
{ "{\"type\":\"map\", \"values\": \"boolean\"}", "{}" },
{ "{\"type\":\"map\", \"values\": \"int\"}", "{}" },
{ "{\"type\":\"map\", \"values\": \"long\"}", "{}" },
{ "{\"type\":\"map\", \"values\": \"float\"}", "{}" },
{ "{\"type\":\"map\", \"values\": \"double\"}", "{}" },
{ "{\"type\":\"map\", \"values\": \"string\"}", "{}" },
{ "{\"type\":\"map\", \"values\": \"bytes\"}", "{}" },
{ "{\"type\":\"map\", \"values\": "
+ "{\"type\":\"array\", \"items\":\"int\"}}", "{}" },
{ "{\"type\":\"map\", \"values\": \"boolean\"}", "{c1sK5B}" },
{ "{\"type\":\"map\", \"values\": \"int\"}", "{c1sK5I}" },
{ "{\"type\":\"map\", \"values\": \"long\"}", "{c1sK5L}" },
{ "{\"type\":\"map\", \"values\": \"float\"}", "{c1sK5F}" },
{ "{\"type\":\"map\", \"values\": \"double\"}", "{c1sK5D}" },
{ "{\"type\":\"map\", \"values\": \"string\"}", "{c1sK5S10}" },
{ "{\"type\":\"map\", \"values\": \"bytes\"}", "{c1sK5b10}" },
{ "{\"type\":\"map\", \"values\": "
+ "{\"type\":\"array\", \"items\":\"int\"}}", "{c1sK5[c3sIsIsI]}" },
{ "{\"type\":\"map\", \"values\": \"boolean\"}",
"{c1sK5Bc2sK5BsK5B}" },
{ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f\", \"type\":\"boolean\"}]}", "B" },
{ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f\", \"type\":\"int\"}]}", "I" },
{ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f\", \"type\":\"long\"}]}", "L" },
{ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f\", \"type\":\"float\"}]}", "F" },
{ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f\", \"type\":\"double\"}]}", "D" },
{ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f\", \"type\":\"string\"}]}", "S10" },
{ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f\", \"type\":\"bytes\"}]}", "b10" },
// multi-field records
{ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f1\", \"type\":\"int\"},"
+ "{\"name\":\"f2\", \"type\":\"double\"},"
+ "{\"name\":\"f3\", \"type\":\"string\"}]}", "IDS10" },
{ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f0\", \"type\":\"null\"},"
+ "{\"name\":\"f1\", \"type\":\"boolean\"},"
+ "{\"name\":\"f2\", \"type\":\"int\"},"
+ "{\"name\":\"f3\", \"type\":\"long\"},"
+ "{\"name\":\"f4\", \"type\":\"float\"},"
+ "{\"name\":\"f5\", \"type\":\"double\"},"
+ "{\"name\":\"f6\", \"type\":\"string\"},"
+ "{\"name\":\"f7\", \"type\":\"bytes\"}]}",
"NBILFDS10b25" },
// record of records
{ "{\"type\":\"record\",\"name\":\"outer\",\"fields\":["
+ "{\"name\":\"f1\", \"type\":{\"type\":\"record\", "
+ "\"name\":\"inner\", \"fields\":["
+ "{\"name\":\"g1\", \"type\":\"int\"}, {\"name\":\"g2\", "
+ "\"type\":\"double\"}]}},"
+ "{\"name\":\"f2\", \"type\":\"string\"},"
+ "{\"name\":\"f3\", \"type\":\"inner\"}]}",
"IDS10ID" },
// record with array
{ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f1\", \"type\":\"long\"},"
+ "{\"name\":\"f2\", "
+ "\"type\":{\"type\":\"array\", \"items\":\"int\"}}]}",
"L[c1sI]" },
// record with map
{ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f1\", \"type\":\"long\"},"
+ "{\"name\":\"f2\", "
+ "\"type\":{\"type\":\"map\", \"values\":\"int\"}}]}",
"L{c1sK5I}" },
// array of records
{ "{\"type\":\"array\", \"items\":"
+ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f1\", \"type\":\"long\"},"
+ "{\"name\":\"f2\", \"type\":\"null\"}]}}",
"[c2sLNsLN]" },
{ "{\"type\":\"array\", \"items\":"
+ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f1\", \"type\":\"long\"},"
+ "{\"name\":\"f2\", "
+ "\"type\":{\"type\":\"array\", \"items\":\"int\"}}]}}",
"[c2sL[c1sI]sL[c2sIsI]]" },
{ "{\"type\":\"array\", \"items\":"
+ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f1\", \"type\":\"long\"},"
+ "{\"name\":\"f2\", "
+ "\"type\":{\"type\":\"map\", \"values\":\"int\"}}]}}",
"[c2sL{c1sK5I}sL{c2sK5IsK5I}]" },
{ "{\"type\":\"array\", \"items\":"
+ "{\"type\":\"record\",\"name\":\"r\",\"fields\":["
+ "{\"name\":\"f1\", \"type\":\"long\"},"
+ "{\"name\":\"f2\", "
+ "\"type\":[\"null\", \"int\"]}]}}",
"[c2sLU0NsLU1I]" },
{ "[\"boolean\"]", "U0B" },
{ "[\"int\"]", "U0I" },
{ "[\"long\"]", "U0L" },
{ "[\"float\"]", "U0F" },
{ "[\"double\"]", "U0D" },
{ "[\"string\"]", "U0S10" },
{ "[\"bytes\"]", "U0b10" },
{ "[\"null\", \"int\"]", "U0N" },
{ "[\"boolean\", \"int\"]", "U0B" },
{ "[\"boolean\", \"int\"]", "U1I" },
{ "[\"boolean\", {\"type\":\"array\", \"items\":\"int\"} ]",
"U0B" },
{ "[\"boolean\", {\"type\":\"array\", \"items\":\"int\"} ]",
"U1[c1sI]" },
// Recursion
{ "{\"type\": \"record\", \"name\": \"Node\", \"fields\": ["
+ "{\"name\":\"label\", \"type\":\"string\"},"
+ "{\"name\":\"children\", \"type\":"
+ "{\"type\": \"array\", \"items\": \"Node\" }}]}",
"S10[c1sS10[]]" },
{ "{\"type\": \"record\", \"name\": \"Lisp\", \"fields\": ["
+ "{\"name\":\"value\", \"type\":[\"null\", \"string\","
+ "{\"type\": \"record\", \"name\": \"Cons\", \"fields\": ["
+ "{\"name\":\"car\", \"type\":\"Lisp\"},"
+ "{\"name\":\"cdr\", \"type\":\"Lisp\"}]}]}]}",
"U0N"},
{ "{\"type\": \"record\", \"name\": \"Lisp\", \"fields\": ["
+ "{\"name\":\"value\", \"type\":[\"null\", \"string\","
+ "{\"type\": \"record\", \"name\": \"Cons\", \"fields\": ["
+ "{\"name\":\"car\", \"type\":\"Lisp\"},"
+ "{\"name\":\"cdr\", \"type\":\"Lisp\"}]}]}]}",
"U1S10"},
{ "{\"type\": \"record\", \"name\": \"Lisp\", \"fields\": ["
+ "{\"name\":\"value\", \"type\":[\"null\", \"string\","
+ "{\"type\": \"record\", \"name\": \"Cons\", \"fields\": ["
+ "{\"name\":\"car\", \"type\":\"Lisp\"},"
+ "{\"name\":\"cdr\", \"type\":\"Lisp\"}]}]}]}",
"U2U1S10U0N"},
// Deep recursion
{ "{\"type\": \"record\", \"name\": \"Node\", \"fields\": ["
+ "{\"name\":\"children\", \"type\":"
+ "{\"type\": \"array\", \"items\": \"Node\" }}]}",
"[c1s[c1s[c1s[c1s[c1s[c1s[c1s[c1s[c1s[c1s[c1s[]]]]]]]]]]]]" },
};
}
static void dump(byte[] bb) {
int col = 0;
for (byte b : bb) {
if (col % 16 == 0) {
System.out.println();
}
col++;
System.out.print(Integer.toHexString(b & 0xff) + " ");
}
System.out.println();
}
static void print(Encoding encoding, int skipLevel, Schema writerSchema,
Schema readerSchema, Object[] writtenValues, Object[] expectedValues) {
LOG.debug("{} Skip Level {}", encoding, skipLevel);
printSchemaAndValues("Writer", writerSchema, writtenValues);
printSchemaAndValues("Reader", readerSchema, expectedValues);
}
private static void printSchemaAndValues(String schemaType, Schema schema, Object[] values) {
LOG.debug("{} Schema {}", schemaType, schema);
for (Object value : values) {
LOG.debug("{} -> {}", value, value.getClass().getSimpleName());
}
}
}