package com.rtbhouse.utils.avro; import static com.rtbhouse.utils.avro.FastSerdeTestsSupport.createArrayFieldSchema; import static com.rtbhouse.utils.avro.FastSerdeTestsSupport.createEnumSchema; import static com.rtbhouse.utils.avro.FastSerdeTestsSupport.createField; import static com.rtbhouse.utils.avro.FastSerdeTestsSupport.createFixedSchema; import static com.rtbhouse.utils.avro.FastSerdeTestsSupport.createMapFieldSchema; import static com.rtbhouse.utils.avro.FastSerdeTestsSupport.createPrimitiveUnionFieldSchema; import static com.rtbhouse.utils.avro.FastSerdeTestsSupport.createRecord; import static com.rtbhouse.utils.avro.FastSerdeTestsSupport.createUnionField; import static com.rtbhouse.utils.avro.FastSerdeTestsSupport.createUnionSchema; import static com.rtbhouse.utils.avro.FastSerdeTestsSupport.deserializeGeneric; import java.io.ByteArrayOutputStream; import java.io.File; import java.net.URL; import java.net.URLClassLoader; import java.nio.ByteBuffer; import java.nio.file.Files; import java.nio.file.Path; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.avro.Schema; import org.apache.avro.generic.GenericContainer; import org.apache.avro.generic.GenericData; import org.apache.avro.generic.GenericRecord; import org.apache.avro.generic.GenericRecordBuilder; import org.apache.avro.io.BinaryEncoder; import org.apache.avro.io.Decoder; import org.apache.avro.io.DecoderFactory; import org.apache.avro.io.EncoderFactory; import org.apache.avro.util.Utf8; import org.junit.Assert; import org.junit.Before; import org.junit.Test; public class FastGenericSerializerGeneratorTest { private File tempDir; private ClassLoader classLoader; @Before public void prepare() throws Exception { Path tempPath = Files.createTempDirectory("generated"); tempDir = tempPath.toFile(); classLoader = URLClassLoader.newInstance(new URL[]{tempDir.toURI().toURL()}, FastGenericSerializerGeneratorTest.class.getClassLoader()); } @Test public void shouldWritePrimitives() { // given Schema javaLangStringSchema = Schema.create(Schema.Type.STRING); GenericData.setStringType(javaLangStringSchema, GenericData.StringType.String); Schema recordSchema = createRecord("testRecord", createField("testInt", Schema.create(Schema.Type.INT)), createPrimitiveUnionFieldSchema("testIntUnion", Schema.Type.INT), createField("testString", Schema.create(Schema.Type.STRING)), createPrimitiveUnionFieldSchema("testStringUnion", Schema.Type.STRING), createField("testJavaString", javaLangStringSchema), createUnionField("testJavaStringUnion", javaLangStringSchema), createField("testLong", Schema.create(Schema.Type.LONG)), createPrimitiveUnionFieldSchema("testLongUnion", Schema.Type.LONG), createField("testDouble", Schema.create(Schema.Type.DOUBLE)), createPrimitiveUnionFieldSchema("testDoubleUnion", Schema.Type.DOUBLE), createField("testFloat", Schema.create(Schema.Type.FLOAT)), createPrimitiveUnionFieldSchema("testFloatUnion", Schema.Type.FLOAT), createField("testBoolean", Schema.create(Schema.Type.BOOLEAN)), createPrimitiveUnionFieldSchema("testBooleanUnion", Schema.Type.BOOLEAN), createField("testBytes", Schema.create(Schema.Type.BYTES)), createPrimitiveUnionFieldSchema("testBytesUnion", Schema.Type.BYTES)); GenericRecordBuilder builder = new GenericRecordBuilder(recordSchema); builder.set("testInt", 1); builder.set("testIntUnion", 1); builder.set("testString", "aaa"); builder.set("testStringUnion", "aaa"); builder.set("testJavaString", "aaa"); builder.set("testJavaStringUnion", "aaa"); builder.set("testLong", 1L); builder.set("testLongUnion", 1L); builder.set("testDouble", 1.0); builder.set("testDoubleUnion", 1.0); builder.set("testFloat", 1.0f); builder.set("testFloatUnion", 1.0f); builder.set("testBoolean", true); builder.set("testBooleanUnion", true); builder.set("testBytes", ByteBuffer.wrap(new byte[]{0x01, 0x02})); builder.set("testBytesUnion", ByteBuffer.wrap(new byte[]{0x01, 0x02})); // when GenericRecord record = deserializeGeneric(recordSchema, serializeGenericFast(builder.build())); // then Assert.assertEquals(1, record.get("testInt")); Assert.assertEquals(1, record.get("testIntUnion")); Assert.assertEquals("aaa", record.get("testString").toString()); Assert.assertEquals("aaa", record.get("testStringUnion").toString()); Assert.assertEquals("aaa", record.get("testJavaString")); Assert.assertEquals("aaa", record.get("testJavaStringUnion")); Assert.assertEquals(1L, record.get("testLong")); Assert.assertEquals(1L, record.get("testLongUnion")); Assert.assertEquals(1.0, record.get("testDouble")); Assert.assertEquals(1.0, record.get("testDoubleUnion")); Assert.assertEquals(1.0f, record.get("testFloat")); Assert.assertEquals(1.0f, record.get("testFloatUnion")); Assert.assertEquals(true, record.get("testBoolean")); Assert.assertEquals(true, record.get("testBooleanUnion")); Assert.assertEquals(ByteBuffer.wrap(new byte[]{0x01, 0x02}), record.get("testBytes")); Assert.assertEquals(ByteBuffer.wrap(new byte[]{0x01, 0x02}), record.get("testBytesUnion")); } @Test @SuppressWarnings("unchecked") public void shouldWriteFixed() { // given Schema fixedSchema = createFixedSchema("testFixed", 2); Schema recordSchema = createRecord("testRecord", createField("testFixed", fixedSchema), createUnionField("testFixedUnion", fixedSchema), createArrayFieldSchema("testFixedArray", fixedSchema), createArrayFieldSchema("testFixedUnionArray", createUnionSchema(fixedSchema))); GenericRecordBuilder builder = new GenericRecordBuilder(recordSchema); builder.set("testFixed", new GenericData.Fixed(fixedSchema, new byte[]{0x01, 0x02})); builder.set("testFixedUnion", new GenericData.Fixed(fixedSchema, new byte[]{0x03, 0x04})); builder.set("testFixedArray", Arrays.asList(new GenericData.Fixed(fixedSchema, new byte[]{0x05, 0x06}))); builder.set("testFixedUnionArray", Arrays.asList(new GenericData.Fixed(fixedSchema, new byte[]{0x07, 0x08}))); // when GenericRecord record = deserializeGeneric(recordSchema, serializeGenericFast(builder.build())); // then Assert.assertArrayEquals(new byte[]{0x01, 0x02}, ((GenericData.Fixed) record.get("testFixed")).bytes()); Assert.assertArrayEquals(new byte[]{0x03, 0x04}, ((GenericData.Fixed) record.get("testFixedUnion")).bytes()); Assert.assertArrayEquals(new byte[]{0x05, 0x06}, ((List<GenericData.Fixed>) record.get("testFixedArray")).get(0).bytes()); Assert.assertArrayEquals(new byte[]{0x07, 0x08}, ((List<GenericData.Fixed>) record.get("testFixedUnionArray")).get(0).bytes()); } @Test @SuppressWarnings("unchecked") public void shouldWriteEnum() { // given Schema enumSchema = createEnumSchema("testEnum", new String[]{"A", "B"}); Schema recordSchema = createRecord("testRecord", createField("testEnum", enumSchema), createUnionField("testEnumUnion", enumSchema), createArrayFieldSchema("testEnumArray", enumSchema), createArrayFieldSchema("testEnumUnionArray", createUnionSchema(enumSchema))); GenericRecordBuilder builder = new GenericRecordBuilder(recordSchema); builder.set("testEnum", new GenericData.EnumSymbol(enumSchema, "A")); builder.set("testEnumUnion", new GenericData.EnumSymbol(enumSchema, "A")); builder.set("testEnumArray", Arrays.asList(new GenericData.EnumSymbol(enumSchema, "A"))); builder.set("testEnumUnionArray", Arrays.asList(new GenericData.EnumSymbol(enumSchema, "A"))); // when GenericRecord record = deserializeGeneric(recordSchema, serializeGenericFast(builder.build())); // then Assert.assertEquals("A", record.get("testEnum").toString()); Assert.assertEquals("A", record.get("testEnumUnion").toString()); Assert.assertEquals("A", ((List<GenericData.EnumSymbol>) record.get("testEnumArray")).get(0).toString()); Assert.assertEquals("A", ((List<GenericData.EnumSymbol>) record.get("testEnumUnionArray")).get(0).toString()); } @Test public void shouldWriteSubRecordField() { // given Schema subRecordSchema = createRecord("subRecord", createPrimitiveUnionFieldSchema("subField", Schema.Type.STRING)); Schema recordSchema = createRecord("test", createUnionField("record", subRecordSchema), createField("record1", subRecordSchema), createPrimitiveUnionFieldSchema("field", Schema.Type.STRING)); GenericRecordBuilder subRecordBuilder = new GenericRecordBuilder(subRecordSchema); subRecordBuilder.set("subField", "abc"); GenericRecordBuilder builder = new GenericRecordBuilder(recordSchema); builder.set("record", subRecordBuilder.build()); builder.set("record1", subRecordBuilder.build()); builder.set("field", "abc"); // when GenericRecord record = deserializeGeneric(recordSchema, serializeGenericFast(builder.build())); // then Assert.assertEquals("abc", ((GenericRecord) record.get("record")).get("subField").toString()); Assert.assertEquals(subRecordSchema.hashCode(), ((GenericRecord) record.get("record")).getSchema().hashCode()); Assert.assertEquals("abc", ((GenericRecord) record.get("record1")).get("subField").toString()); Assert.assertEquals(subRecordSchema.hashCode(), ((GenericRecord) record.get("record1")).getSchema().hashCode()); Assert.assertEquals("abc", record.get("field").toString()); } @Test @SuppressWarnings("unchecked") public void shouldWriteSubRecordCollectionsField() { // given Schema subRecordSchema = createRecord("subRecord", createPrimitiveUnionFieldSchema("subField", Schema.Type.STRING)); Schema recordSchema = createRecord("test", createArrayFieldSchema("recordsArray", subRecordSchema), createMapFieldSchema("recordsMap", subRecordSchema), createUnionField("recordsArrayUnion", Schema.createArray(createUnionSchema(subRecordSchema))), createUnionField("recordsMapUnion", Schema.createMap(createUnionSchema(subRecordSchema)))); GenericRecordBuilder subRecordBuilder = new GenericRecordBuilder(subRecordSchema); subRecordBuilder.set("subField", "abc"); GenericRecordBuilder builder = new GenericRecordBuilder(recordSchema); List<GenericData.Record> recordsArray = new ArrayList<>(); recordsArray.add(subRecordBuilder.build()); builder.set("recordsArray", recordsArray); builder.set("recordsArrayUnion", recordsArray); Map<String, GenericData.Record> recordsMap = new HashMap<>(); recordsMap.put("1", subRecordBuilder.build()); builder.set("recordsMap", recordsMap); builder.set("recordsMapUnion", recordsMap); // when GenericRecord record = deserializeGeneric(recordSchema, serializeGenericFast(builder.build())); // then Assert.assertEquals("abc", ((List<GenericData.Record>) record.get("recordsArray")).get(0).get("subField").toString()); Assert.assertEquals("abc", ((List<GenericData.Record>) record.get("recordsArrayUnion")).get(0).get("subField").toString()); Assert.assertEquals("abc", ((Map<Utf8, GenericData.Record>) record.get("recordsMap")).get(new Utf8("1")).get("subField") .toString()); Assert.assertEquals("abc", ((Map<Utf8, GenericData.Record>) record.get("recordsMapUnion")).get(new Utf8("1")).get("subField") .toString()); } @Test @SuppressWarnings("unchecked") public void shouldWriteSubRecordComplexCollectionsField() { // given Schema subRecordSchema = createRecord("subRecord", createPrimitiveUnionFieldSchema("subField", Schema.Type.STRING)); Schema recordSchema = createRecord( "test", createArrayFieldSchema("recordsArrayMap", Schema.createMap(createUnionSchema(subRecordSchema))), createMapFieldSchema("recordsMapArray", Schema.createArray(createUnionSchema(subRecordSchema))), createUnionField("recordsArrayMapUnion", Schema.createArray(Schema.createMap(createUnionSchema(subRecordSchema)))), createUnionField("recordsMapArrayUnion", Schema.createMap(Schema.createArray(createUnionSchema(subRecordSchema))))); GenericRecordBuilder subRecordBuilder = new GenericRecordBuilder(subRecordSchema); subRecordBuilder.set("subField", "abc"); GenericRecordBuilder builder = new GenericRecordBuilder(recordSchema); List<Map<String, GenericRecord>> recordsArrayMap = new ArrayList<>(); Map<String, GenericRecord> recordMap = new HashMap<>(); recordMap.put("1", subRecordBuilder.build()); recordsArrayMap.add(recordMap); builder.set("recordsArrayMap", recordsArrayMap); builder.set("recordsArrayMapUnion", recordsArrayMap); Map<String, List<GenericRecord>> recordsMapArray = new HashMap<>(); List<GenericRecord> recordList = new ArrayList<>(); recordList.add(subRecordBuilder.build()); recordsMapArray.put("1", recordList); builder.set("recordsMapArray", recordsMapArray); builder.set("recordsMapArrayUnion", recordsMapArray); // when GenericRecord record = deserializeGeneric(recordSchema, serializeGenericFast(builder.build())); // then Assert.assertEquals("abc", ((List<Map<Utf8, GenericRecord>>) record.get("recordsArrayMap")).get(0).get(new Utf8("1")) .get("subField").toString()); Assert.assertEquals("abc", ((Map<Utf8, List<GenericRecord>>) record.get("recordsMapArray")).get(new Utf8("1")).get(0) .get("subField").toString()); Assert.assertEquals("abc", ((List<Map<Utf8, GenericRecord>>) record.get("recordsArrayMapUnion")).get(0).get(new Utf8("1")) .get("subField").toString()); Assert.assertEquals("abc", ((Map<Utf8, List<GenericRecord>>) record.get("recordsMapArrayUnion")).get(new Utf8("1")).get(0) .get("subField").toString()); } @Test public void shouldWriteMultipleChoiceUnion() { // given Schema subRecordSchema = createRecord("subRecord", createPrimitiveUnionFieldSchema("subField", Schema.Type.STRING)); Schema recordSchema = createRecord( "test", createUnionField("union", subRecordSchema, Schema.create(Schema.Type.STRING), Schema.create(Schema.Type.INT))); GenericRecordBuilder subRecordBuilder = new GenericRecordBuilder(subRecordSchema); subRecordBuilder.set("subField", "abc"); GenericRecordBuilder builder = new GenericRecordBuilder(recordSchema); builder.set("union", subRecordBuilder.build()); // when GenericRecord record = deserializeGeneric(recordSchema, serializeGenericFast(builder.build())); // then Assert.assertEquals("abc", ((GenericData.Record) record.get("union")).get("subField").toString()); // given builder = new GenericRecordBuilder(recordSchema); builder.set("union", new Utf8("abc")); // when record = deserializeGeneric(recordSchema, serializeGenericFast(builder.build())); // then Assert.assertEquals("abc", record.get("union").toString()); // given builder = new GenericRecordBuilder(recordSchema); builder.set("union", 1); // when record = deserializeGeneric(recordSchema, serializeGenericFast(builder.build())); // then Assert.assertEquals(1, record.get("union")); } @Test public void shouldWriteArrayOfPrimitives() { // given Schema stringArraySchema = Schema.createArray(Schema.create(Schema.Type.STRING)); GenericData.Array<String> stringArray = new GenericData.Array<>(0, stringArraySchema); stringArray.add("aaa"); stringArray.add("abc"); Schema intArraySchema = Schema.createArray(Schema.create(Schema.Type.INT)); GenericData.Array<Integer> intArray = new GenericData.Array<>(0, intArraySchema); intArray.add(1); intArray.add(2); Schema longArraySchema = Schema.createArray(Schema.create(Schema.Type.LONG)); GenericData.Array<Long> longArray = new GenericData.Array<>(0, longArraySchema); longArray.add(1L); longArray.add(2L); Schema doubleArraySchema = Schema.createArray(Schema.create(Schema.Type.DOUBLE)); GenericData.Array<Double> doubleArray = new GenericData.Array<>(0, doubleArraySchema); doubleArray.add(1.0); doubleArray.add(2.0); Schema floatArraySchema = Schema.createArray(Schema.create(Schema.Type.FLOAT)); GenericData.Array<Float> floatArray = new GenericData.Array<>(0, floatArraySchema); floatArray.add(1.0f); floatArray.add(2.0f); Schema bytesArraySchema = Schema.createArray(Schema.create(Schema.Type.BYTES)); GenericData.Array<ByteBuffer> bytesArray = new GenericData.Array<>(0, bytesArraySchema); bytesArray.add(ByteBuffer.wrap(new byte[]{0x01})); bytesArray.add(ByteBuffer.wrap(new byte[]{0x02})); // when GenericData.Array<Utf8> resultStringArray = deserializeGeneric(stringArraySchema, serializeGenericFast(stringArray)); GenericData.Array<Integer> resultIntegerArray = deserializeGeneric(intArraySchema, serializeGenericFast(intArray)); GenericData.Array<Long> resultLongArray = deserializeGeneric(longArraySchema, serializeGenericFast(longArray)); GenericData.Array<Double> resultDoubleArray = deserializeGeneric(doubleArraySchema, serializeGenericFast(doubleArray)); GenericData.Array<Float> resultFloatArray = deserializeGeneric(floatArraySchema, serializeGenericFast(floatArray)); GenericData.Array<ByteBuffer> resultBytesArray = deserializeGeneric(bytesArraySchema, serializeGenericFast(bytesArray)); // then Assert.assertEquals(2, resultStringArray.size()); Assert.assertEquals("aaa", resultStringArray.get(0).toString()); Assert.assertEquals("abc", resultStringArray.get(1).toString()); Assert.assertEquals(2, resultIntegerArray.size()); Assert.assertEquals(Integer.valueOf(1), resultIntegerArray.get(0)); Assert.assertEquals(Integer.valueOf(2), resultIntegerArray.get(1)); Assert.assertEquals(2, resultLongArray.size()); Assert.assertEquals(Long.valueOf(1L), resultLongArray.get(0)); Assert.assertEquals(Long.valueOf(2L), resultLongArray.get(1)); Assert.assertEquals(2, resultDoubleArray.size()); Assert.assertEquals(Double.valueOf(1.0), resultDoubleArray.get(0)); Assert.assertEquals(Double.valueOf(2.0), resultDoubleArray.get(1)); Assert.assertEquals(2, resultFloatArray.size()); Assert.assertEquals(Float.valueOf(1f), resultFloatArray.get(0)); Assert.assertEquals(Float.valueOf(2f), resultFloatArray.get(1)); Assert.assertEquals(2, resultBytesArray.size()); Assert.assertEquals(0x01, resultBytesArray.get(0).get()); Assert.assertEquals(0x02, resultBytesArray.get(1).get()); } @Test public void shouldWriteArrayOfRecords() { // given Schema recordSchema = createRecord("record", createPrimitiveUnionFieldSchema("field", Schema.Type.STRING)); Schema arrayRecordSchema = Schema.createArray(recordSchema); GenericRecordBuilder subRecordBuilder = new GenericRecordBuilder(recordSchema); subRecordBuilder.set("field", "abc"); GenericData.Array<GenericData.Record> recordsArray = new GenericData.Array<>(0, arrayRecordSchema); recordsArray.add(subRecordBuilder.build()); recordsArray.add(subRecordBuilder.build()); // when GenericData.Array<GenericRecord> array = deserializeGeneric(arrayRecordSchema, serializeGenericFast(recordsArray)); // then Assert.assertEquals(2, array.size()); Assert.assertEquals("abc", array.get(0).get("field").toString()); Assert.assertEquals("abc", array.get(1).get("field").toString()); // given arrayRecordSchema = Schema.createArray(createUnionSchema(recordSchema)); subRecordBuilder = new GenericRecordBuilder(recordSchema); subRecordBuilder.set("field", "abc"); recordsArray = new GenericData.Array<>(0, arrayRecordSchema); recordsArray.add(subRecordBuilder.build()); recordsArray.add(subRecordBuilder.build()); // when array = deserializeGeneric(arrayRecordSchema, serializeGenericFast(recordsArray)); // then Assert.assertEquals(2, array.size()); Assert.assertEquals("abc", array.get(0).get("field").toString()); Assert.assertEquals("abc", array.get(1).get("field").toString()); } @Test public void shouldWriteMapOfPrimitives() { // given Schema stringMapSchema = Schema.createMap(Schema.create(Schema.Type.STRING)); Map<String, String> stringMap = new HashMap<>(0); stringMap.put("1", "abc"); stringMap.put("2", "aaa"); Schema intMapSchema = Schema.createMap(Schema.create(Schema.Type.INT)); Map<String, Integer> intMap = new HashMap<>(0); intMap.put("1", 1); intMap.put("2", 2); Schema longMapSchema = Schema.createMap(Schema.create(Schema.Type.LONG)); Map<String, Long> longMap = new HashMap<>(0); longMap.put("1", 1L); longMap.put("2", 2L); Schema doubleMapSchema = Schema.createMap(Schema.create(Schema.Type.DOUBLE)); Map<String, Double> doubleMap = new HashMap<>(0); doubleMap.put("1", 1.0); doubleMap.put("2", 2.0); Schema floatMapSchema = Schema.createMap(Schema.create(Schema.Type.FLOAT)); Map<String, Float> floatMap = new HashMap<>(0); floatMap.put("1", 1.0f); floatMap.put("2", 2.0f); Schema bytesMapSchema = Schema.createMap(Schema.create(Schema.Type.BYTES)); Map<String, ByteBuffer> bytesMap = new HashMap<>(0); bytesMap.put("1", ByteBuffer.wrap(new byte[]{0x01})); bytesMap.put("2", ByteBuffer.wrap(new byte[]{0x02})); // when Map<Utf8, Utf8> resultStringMap = deserializeGeneric(stringMapSchema, serializeGenericFast(stringMap, stringMapSchema)); Map<Utf8, Integer> resultIntegerMap = deserializeGeneric(intMapSchema, serializeGenericFast(intMap, intMapSchema)); Map<Utf8, Long> resultLongMap = deserializeGeneric(longMapSchema, serializeGenericFast(longMap, longMapSchema)); Map<Utf8, Double> resultDoubleMap = deserializeGeneric(doubleMapSchema, serializeGenericFast(doubleMap, doubleMapSchema)); Map<Utf8, Float> resultFloatMap = deserializeGeneric(floatMapSchema, serializeGenericFast(floatMap, floatMapSchema)); Map<Utf8, ByteBuffer> resultBytesMap = deserializeGeneric(bytesMapSchema, serializeGenericFast(bytesMap, bytesMapSchema)); // then Assert.assertEquals(2, resultStringMap.size()); Assert.assertEquals("abc", resultStringMap.get(new Utf8("1")).toString()); Assert.assertEquals("aaa", resultStringMap.get(new Utf8("2")).toString()); Assert.assertEquals(2, resultIntegerMap.size()); Assert.assertEquals(Integer.valueOf(1), resultIntegerMap.get(new Utf8("1"))); Assert.assertEquals(Integer.valueOf(2), resultIntegerMap.get(new Utf8("2"))); Assert.assertEquals(2, resultLongMap.size()); Assert.assertEquals(Long.valueOf(1L), resultLongMap.get(new Utf8("1"))); Assert.assertEquals(Long.valueOf(2L), resultLongMap.get(new Utf8("2"))); Assert.assertEquals(2, resultDoubleMap.size()); Assert.assertEquals(Double.valueOf(1.0), resultDoubleMap.get(new Utf8("1"))); Assert.assertEquals(Double.valueOf(2.0), resultDoubleMap.get(new Utf8("2"))); Assert.assertEquals(2, resultFloatMap.size()); Assert.assertEquals(Float.valueOf(1f), resultFloatMap.get(new Utf8("1"))); Assert.assertEquals(Float.valueOf(2f), resultFloatMap.get(new Utf8("2"))); Assert.assertEquals(2, resultBytesMap.size()); Assert.assertEquals(0x01, resultBytesMap.get(new Utf8("1")).get()); Assert.assertEquals(0x02, resultBytesMap.get(new Utf8("2")).get()); } @Test public void shouldWriteMapOfRecords() { // given Schema recordSchema = createRecord("record", createPrimitiveUnionFieldSchema("field", Schema.Type.STRING)); Schema mapRecordSchema = Schema.createMap(recordSchema); GenericRecordBuilder subRecordBuilder = new GenericRecordBuilder(recordSchema); subRecordBuilder.set("field", "abc"); Map<String, GenericData.Record> recordsMap = new HashMap<>(); recordsMap.put("1", subRecordBuilder.build()); recordsMap.put("2", subRecordBuilder.build()); // when Map<Utf8, GenericRecord> map = deserializeGeneric(mapRecordSchema, serializeGenericFast(recordsMap, mapRecordSchema)); // then Assert.assertEquals(2, map.size()); Assert.assertEquals("abc", map.get(new Utf8("1")).get("field").toString()); Assert.assertEquals("abc", map.get(new Utf8("2")).get("field").toString()); // given mapRecordSchema = Schema.createMap(createUnionSchema(recordSchema)); subRecordBuilder = new GenericRecordBuilder(recordSchema); subRecordBuilder.set("field", "abc"); recordsMap = new HashMap<>(); recordsMap.put("1", subRecordBuilder.build()); recordsMap.put("2", subRecordBuilder.build()); // when map = deserializeGeneric(mapRecordSchema, serializeGenericFast(recordsMap, mapRecordSchema)); // then Assert.assertEquals(2, map.size()); Assert.assertEquals("abc", map.get(new Utf8("1")).get("field").toString()); Assert.assertEquals("abc", map.get(new Utf8("2")).get("field").toString()); } @Test public void shouldSerializeNullElementInMap() { // given Schema mapRecordSchema = Schema.createMap(Schema.createUnion( Schema.create(Schema.Type.STRING), Schema.create(Schema.Type.NULL), Schema.create(Schema.Type.INT))); Map<String, Object> records = new HashMap<>(); records.put("0", "0"); records.put("1", null); records.put("2", 2); // when Map<Utf8, Object> map = deserializeGeneric(mapRecordSchema, serializeGenericFast(records, mapRecordSchema)); // then Assert.assertEquals(3, map.size()); Assert.assertEquals(new Utf8("0"), map.get(new Utf8("0"))); Assert.assertNull(map.get(new Utf8("1"))); Assert.assertEquals(2, map.get(new Utf8("2"))); } @Test public void shouldSerializeNullElementInArray() { // given Schema arrayRecordSchema = Schema.createArray(Schema.createUnion( Schema.create(Schema.Type.STRING), Schema.create(Schema.Type.NULL), Schema.create(Schema.Type.INT))); List<Object> records = new ArrayList<>(); records.add("0"); records.add(null); records.add(2); // when List<Object> array = deserializeGeneric(arrayRecordSchema, serializeGenericFast(records, arrayRecordSchema)); // then Assert.assertEquals(3, array.size()); Assert.assertEquals(new Utf8("0"), array.get(0)); Assert.assertNull(array.get(1)); Assert.assertEquals(2, array.get(2)); } private <T extends GenericContainer> Decoder serializeGenericFast(T data) { return serializeGenericFast(data, data.getSchema()); } private <T> Decoder serializeGenericFast(T data, Schema schema) { ByteArrayOutputStream baos = new ByteArrayOutputStream(); BinaryEncoder binaryEncoder = EncoderFactory.get().directBinaryEncoder(baos, null); try { FastGenericSerializerGenerator<T> fastGenericSerializerGenerator = new FastGenericSerializerGenerator<>( schema, tempDir, classLoader, null); FastSerializer<T> fastSerializer = fastGenericSerializerGenerator.generateSerializer(); fastSerializer.serialize(data, binaryEncoder); binaryEncoder.flush(); } catch (Exception e) { throw new RuntimeException(e); } return DecoderFactory.get().binaryDecoder(baos.toByteArray(), null); } }