From 1aa7f688bbec3cebbde345ed4ddc028a013dd278 Mon Sep 17 00:00:00 2001 From: Bob Cotton Date: Wed, 11 Mar 2015 14:06:37 -0600 Subject: [PATCH] AVRO-1649: Teach SchemaCompatability to be more descriptive with failing compatibility checks. Also adds enums to SchemaCompatability.SchemaCompatibilityType for the various compatability checks. --- .../org/apache/avro/SchemaCompatibility.java | 118 ++++++++-------- .../apache/avro/TestSchemaCompatibility.java | 128 ++++++++---------- 2 files changed, 113 insertions(+), 133 deletions(-) diff --git a/lang/java/avro/src/main/java/org/apache/avro/SchemaCompatibility.java b/lang/java/avro/src/main/java/org/apache/avro/SchemaCompatibility.java index e62ea0bfd7b..d5587e35fff 100644 --- a/lang/java/avro/src/main/java/org/apache/avro/SchemaCompatibility.java +++ b/lang/java/avro/src/main/java/org/apache/avro/SchemaCompatibility.java @@ -45,6 +45,8 @@ private SchemaCompatibility() { /** Message to annotate reader/writer schema pairs that are compatible. */ public static final String READER_WRITER_COMPATIBLE_MESSAGE = "Reader schema can always successfully decode data written using the writer schema."; + public static final String READER_WRITER_INCOMPATABLE_MESSAGE = + "Data encoded using writer schema:%n%s%nwill or may fail to decode using reader schema:%n%s%n"; /** * Validates that the provided reader schema can be used to decode avro data written with the @@ -62,28 +64,10 @@ public static SchemaPairCompatibility checkReaderWriterCompatibility( new ReaderWriterCompatiblityChecker() .getCompatibility(reader, writer); - final String message; - switch (compatibility) { - case INCOMPATIBLE: { - message = String.format( - "Data encoded using writer schema:%n%s%n" - + "will or may fail to decode using reader schema:%n%s%n", - writer.toString(true), - reader.toString(true)); - break; - } - case COMPATIBLE: { - message = READER_WRITER_COMPATIBLE_MESSAGE; - break; - } - default: throw new AvroRuntimeException("Unknown compatibility: " + compatibility); - } - return new SchemaPairCompatibility( compatibility, reader, - writer, - message); + writer); } // ----------------------------------------------------------------------------------------------- @@ -282,32 +266,29 @@ private SchemaCompatibilityType calculateCompatibility( case FIXED: { // fixed size and name must match: if (!schemaNameEquals(reader, writer)) { - return SchemaCompatibilityType.INCOMPATIBLE; + return SchemaCompatibilityType.INCOMPATIBLE_NAME; } if (reader.getFixedSize() != writer.getFixedSize()) { - return SchemaCompatibilityType.INCOMPATIBLE; + return SchemaCompatibilityType.INCOMPATIBLE_SIZE; } return SchemaCompatibilityType.COMPATIBLE; } case ENUM: { // enum names must match: if (!schemaNameEquals(reader, writer)) { - return SchemaCompatibilityType.INCOMPATIBLE; + return SchemaCompatibilityType.INCOMPATIBLE_NAME; } // reader symbols must contain all writer symbols: final Set symbols = new HashSet(writer.getEnumSymbols()); symbols.removeAll(reader.getEnumSymbols()); - // TODO: Report a human-readable error. - // if (!symbols.isEmpty()) { - // } return symbols.isEmpty() ? SchemaCompatibilityType.COMPATIBLE - : SchemaCompatibilityType.INCOMPATIBLE; + : SchemaCompatibilityType.INCOMPATIBLE_ENUM_MISSING_FIELDS; } case RECORD: { // record names must match: if (!schemaNameEquals(reader, writer)) { - return SchemaCompatibilityType.INCOMPATIBLE; + return SchemaCompatibilityType.INCOMPATIBLE_NAME; } // Check that each field in the reader record can be populated from the writer record: @@ -318,12 +299,12 @@ private SchemaCompatibilityType calculateCompatibility( // reader field must have a default value. if (readerField.defaultValue() == null) { // reader field has no default value - return SchemaCompatibilityType.INCOMPATIBLE; + return SchemaCompatibilityType.INCOMPATIBLE_MISSING_DEFAULT; } } else { - if (getCompatibility(readerField.schema(), writerField.schema()) - == SchemaCompatibilityType.INCOMPATIBLE) { - return SchemaCompatibilityType.INCOMPATIBLE; + SchemaCompatibilityType compatibilityType = getCompatibility(readerField.schema(), writerField.schema()); + if (!compatibilityType.isCompatible()) { + return compatibilityType; } } } @@ -334,8 +315,9 @@ private SchemaCompatibilityType calculateCompatibility( case UNION: { // Check that each individual branch of the writer union can be decoded: for (final Schema writerBranch : writer.getTypes()) { - if (getCompatibility(reader, writerBranch) == SchemaCompatibilityType.INCOMPATIBLE) { - return SchemaCompatibilityType.INCOMPATIBLE; + SchemaCompatibilityType schemaCompatibilityType = getCompatibility(reader, writerBranch); + if (!schemaCompatibilityType.isCompatible()) { + return schemaCompatibilityType; } } // Each schema in the writer union can be decoded with the reader: @@ -357,19 +339,19 @@ private SchemaCompatibilityType calculateCompatibility( } switch (reader.getType()) { - case NULL: return SchemaCompatibilityType.INCOMPATIBLE; - case BOOLEAN: return SchemaCompatibilityType.INCOMPATIBLE; - case INT: return SchemaCompatibilityType.INCOMPATIBLE; + case NULL: return SchemaCompatibilityType.INCOMPATIBLE_TYPE; + case BOOLEAN: return SchemaCompatibilityType.INCOMPATIBLE_TYPE; + case INT: return SchemaCompatibilityType.INCOMPATIBLE_TYPE; case LONG: { return (writer.getType() == Type.INT) ? SchemaCompatibilityType.COMPATIBLE - : SchemaCompatibilityType.INCOMPATIBLE; + : SchemaCompatibilityType.INCOMPATIBLE_TYPE; } case FLOAT: { return ((writer.getType() == Type.INT) || (writer.getType() == Type.LONG)) ? SchemaCompatibilityType.COMPATIBLE - : SchemaCompatibilityType.INCOMPATIBLE; + : SchemaCompatibilityType.INCOMPATIBLE_TYPE; } case DOUBLE: { @@ -377,15 +359,15 @@ private SchemaCompatibilityType calculateCompatibility( || (writer.getType() == Type.LONG) || (writer.getType() == Type.FLOAT)) ? SchemaCompatibilityType.COMPATIBLE - : SchemaCompatibilityType.INCOMPATIBLE; + : SchemaCompatibilityType.INCOMPATIBLE_TYPE; } - case BYTES: return SchemaCompatibilityType.INCOMPATIBLE; - case STRING: return SchemaCompatibilityType.INCOMPATIBLE; - case ARRAY: return SchemaCompatibilityType.INCOMPATIBLE; - case MAP: return SchemaCompatibilityType.INCOMPATIBLE; - case FIXED: return SchemaCompatibilityType.INCOMPATIBLE; - case ENUM: return SchemaCompatibilityType.INCOMPATIBLE; - case RECORD: return SchemaCompatibilityType.INCOMPATIBLE; + case BYTES: return SchemaCompatibilityType.INCOMPATIBLE_TYPE; + case STRING: return SchemaCompatibilityType.INCOMPATIBLE_TYPE; + case ARRAY: return SchemaCompatibilityType.INCOMPATIBLE_TYPE; + case MAP: return SchemaCompatibilityType.INCOMPATIBLE_TYPE; + case FIXED: return SchemaCompatibilityType.INCOMPATIBLE_TYPE; + case ENUM: return SchemaCompatibilityType.INCOMPATIBLE_TYPE; + case RECORD: return SchemaCompatibilityType.INCOMPATIBLE_TYPE; case UNION: { for (final Schema readerBranch : reader.getTypes()) { if (getCompatibility(readerBranch, writer) == SchemaCompatibilityType.COMPATIBLE) { @@ -393,7 +375,7 @@ private SchemaCompatibilityType calculateCompatibility( } } // No branch in the reader union has been found compatible with the writer schema: - return SchemaCompatibilityType.INCOMPATIBLE; + return SchemaCompatibilityType.INCOMPATIBLE_TYPE; } default: { @@ -408,11 +390,30 @@ private SchemaCompatibilityType calculateCompatibility( * Identifies the type of a schema compatibility result. */ public static enum SchemaCompatibilityType { - COMPATIBLE, - INCOMPATIBLE, + COMPATIBLE(READER_WRITER_COMPATIBLE_MESSAGE), + + INCOMPATIBLE_NAME(READER_WRITER_INCOMPATABLE_MESSAGE + "Schema names must match."), + INCOMPATIBLE_SIZE(READER_WRITER_INCOMPATABLE_MESSAGE + " Fixed schemas are no the same size."), + INCOMPATIBLE_ENUM_MISSING_FIELDS(READER_WRITER_INCOMPATABLE_MESSAGE + " Reader schema is missing ENUM values."), + INCOMPATIBLE_MISSING_DEFAULT(READER_WRITER_INCOMPATABLE_MESSAGE + " New fields must have a default value."), + INCOMPATIBLE_TYPE(READER_WRITER_INCOMPATABLE_MESSAGE + " Schema types are incompatable."), /** Used internally to tag a reader/writer schema pair and prevent recursion. */ - RECURSION_IN_PROGRESS; + RECURSION_IN_PROGRESS(""); + + private final String description; + + SchemaCompatibilityType(String description) { + this.description = description; + } + + protected String description(Schema reader, Schema writer) { + return String.format(description, writer.toString(true), reader.toString(true)); + } + + public boolean isCompatible() { + return this == COMPATIBLE; + } } // ----------------------------------------------------------------------------------------------- @@ -432,26 +433,20 @@ public static final class SchemaPairCompatibility { /** Validated writer schema. */ private final Schema mWriter; - /** Human readable description of this result. */ - private final String mDescription; - /** * Constructs a new instance. * * @param type of the schema compatibility. * @param reader schema that was validated. * @param writer schema that was validated. - * @param description of this compatibility result. */ public SchemaPairCompatibility( SchemaCompatibilityType type, Schema reader, - Schema writer, - String description) { + Schema writer) { mType = type; mReader = reader; mWriter = writer; - mDescription = description; } /** @@ -487,7 +482,7 @@ public Schema getWriter() { * @return a human readable description of this validation result. */ public String getDescription() { - return mDescription; + return mType.description(mReader, mWriter); } /** {@inheritDoc} */ @@ -495,7 +490,7 @@ public String getDescription() { public String toString() { return String.format( "SchemaPairCompatibility{type:%s, readerSchema:%s, writerSchema:%s, description:%s}", - mType, mReader, mWriter, mDescription); + mType, mReader, mWriter, mType.description(mReader, mWriter)); } /** {@inheritDoc} */ @@ -505,8 +500,7 @@ public boolean equals(Object other) { final SchemaPairCompatibility result = (SchemaPairCompatibility) other; return objectsEqual(result.mType, mType) && objectsEqual(result.mReader, mReader) - && objectsEqual(result.mWriter, mWriter) - && objectsEqual(result.mDescription, mDescription); + && objectsEqual(result.mWriter, mWriter); } else { return false; } @@ -515,7 +509,7 @@ && objectsEqual(result.mWriter, mWriter) /** {@inheritDoc} */ @Override public int hashCode() { - return Arrays.hashCode(new Object[]{mType, mReader, mWriter, mDescription}); + return Arrays.hashCode(new Object[]{mType, mReader, mWriter}); } } diff --git a/lang/java/avro/src/test/java/org/apache/avro/TestSchemaCompatibility.java b/lang/java/avro/src/test/java/org/apache/avro/TestSchemaCompatibility.java index c001b335f3f..8bae7b39c39 100644 --- a/lang/java/avro/src/test/java/org/apache/avro/TestSchemaCompatibility.java +++ b/lang/java/avro/src/test/java/org/apache/avro/TestSchemaCompatibility.java @@ -146,19 +146,27 @@ public class TestSchemaCompatibility { private static final class ReaderWriter { private final Schema mReader; private final Schema mWriter; + private final SchemaCompatibilityType mCompatibilityType; - public ReaderWriter(final Schema reader, final Schema writer) { + public ReaderWriter(final Schema reader, final Schema writer, SchemaCompatibilityType schemaCompatibilityType) { mReader = reader; mWriter = writer; + mCompatibilityType = schemaCompatibilityType; } - public Schema getReader() { + public ReaderWriter(final Schema reader, final Schema writer) { + this(reader, writer, SchemaCompatibilityType.COMPATIBLE); + } + + public Schema getReader() { return mReader; } public Schema getWriter() { return mWriter; } + + public SchemaCompatibilityType getSchemaCompatibilityType() { return mCompatibilityType; }; } // ----------------------------------------------------------------------------------------------- @@ -176,8 +184,7 @@ public void testValidateSchemaPairMissingField() throws Exception { new SchemaCompatibility.SchemaPairCompatibility( SchemaCompatibility.SchemaCompatibilityType.COMPATIBLE, reader, - WRITER_SCHEMA, - SchemaCompatibility.READER_WRITER_COMPATIBLE_MESSAGE); + WRITER_SCHEMA); // Test omitting a field. assertEquals(expectedResult, checkReaderWriterCompatibility(reader, WRITER_SCHEMA)); @@ -192,8 +199,7 @@ public void testValidateSchemaPairMissingSecondField() throws Exception { new SchemaCompatibility.SchemaPairCompatibility( SchemaCompatibility.SchemaCompatibilityType.COMPATIBLE, reader, - WRITER_SCHEMA, - SchemaCompatibility.READER_WRITER_COMPATIBLE_MESSAGE); + WRITER_SCHEMA); // Test omitting other field. assertEquals(expectedResult, checkReaderWriterCompatibility(reader, WRITER_SCHEMA)); @@ -209,8 +215,7 @@ public void testValidateSchemaPairAllFields() throws Exception { new SchemaCompatibility.SchemaPairCompatibility( SchemaCompatibility.SchemaCompatibilityType.COMPATIBLE, reader, - WRITER_SCHEMA, - SchemaCompatibility.READER_WRITER_COMPATIBLE_MESSAGE); + WRITER_SCHEMA); // Test with all fields. assertEquals(expectedResult, checkReaderWriterCompatibility(reader, WRITER_SCHEMA)); @@ -226,8 +231,7 @@ public void testValidateSchemaNewFieldWithDefault() throws Exception { new SchemaCompatibility.SchemaPairCompatibility( SchemaCompatibility.SchemaCompatibilityType.COMPATIBLE, reader, - WRITER_SCHEMA, - SchemaCompatibility.READER_WRITER_COMPATIBLE_MESSAGE); + WRITER_SCHEMA); // Test new field with default value. assertEquals(expectedResult, checkReaderWriterCompatibility(reader, WRITER_SCHEMA)); @@ -241,14 +245,9 @@ public void testValidateSchemaNewField() throws Exception { final Schema reader = Schema.createRecord(readerFields); final SchemaCompatibility.SchemaPairCompatibility expectedResult = new SchemaCompatibility.SchemaPairCompatibility( - SchemaCompatibility.SchemaCompatibilityType.INCOMPATIBLE, + SchemaCompatibilityType.INCOMPATIBLE_MISSING_DEFAULT, reader, - WRITER_SCHEMA, - String.format( - "Data encoded using writer schema:\n%s\n" - + "will or may fail to decode using reader schema:\n%s\n", - WRITER_SCHEMA.toString(true), - reader.toString(true))); + WRITER_SCHEMA); // Test new field without default value. assertEquals(expectedResult, checkReaderWriterCompatibility(reader, WRITER_SCHEMA)); @@ -262,18 +261,12 @@ public void testValidateArrayWriterSchema() throws Exception { new SchemaCompatibility.SchemaPairCompatibility( SchemaCompatibility.SchemaCompatibilityType.COMPATIBLE, validReader, - STRING_ARRAY_SCHEMA, - SchemaCompatibility.READER_WRITER_COMPATIBLE_MESSAGE); + STRING_ARRAY_SCHEMA); final SchemaCompatibility.SchemaPairCompatibility invalidResult = new SchemaCompatibility.SchemaPairCompatibility( - SchemaCompatibility.SchemaCompatibilityType.INCOMPATIBLE, + SchemaCompatibility.SchemaCompatibilityType.INCOMPATIBLE_TYPE, invalidReader, - STRING_ARRAY_SCHEMA, - String.format( - "Data encoded using writer schema:\n%s\n" - + "will or may fail to decode using reader schema:\n%s\n", - STRING_ARRAY_SCHEMA.toString(true), - invalidReader.toString(true))); + STRING_ARRAY_SCHEMA); assertEquals( validResult, @@ -290,18 +283,12 @@ public void testValidatePrimitiveWriterSchema() throws Exception { new SchemaCompatibility.SchemaPairCompatibility( SchemaCompatibility.SchemaCompatibilityType.COMPATIBLE, validReader, - STRING_SCHEMA, - SchemaCompatibility.READER_WRITER_COMPATIBLE_MESSAGE); + STRING_SCHEMA); final SchemaCompatibility.SchemaPairCompatibility invalidResult = new SchemaCompatibility.SchemaPairCompatibility( - SchemaCompatibility.SchemaCompatibilityType.INCOMPATIBLE, + SchemaCompatibility.SchemaCompatibilityType.INCOMPATIBLE_TYPE, INT_SCHEMA, - STRING_SCHEMA, - String.format( - "Data encoded using writer schema:\n%s\n" - + "will or may fail to decode using reader schema:\n%s\n", - STRING_SCHEMA.toString(true), - INT_SCHEMA.toString(true))); + STRING_SCHEMA); assertEquals( validResult, @@ -318,7 +305,7 @@ public void testUnionReaderWriterSubsetIncompatibility() { final Schema unionReader = Schema.createUnion(list(STRING_SCHEMA)); final SchemaPairCompatibility result = checkReaderWriterCompatibility(unionReader, unionWriter); - assertEquals(SchemaCompatibilityType.INCOMPATIBLE, result.getType()); + assertEquals(SchemaCompatibilityType.INCOMPATIBLE_TYPE, result.getType()); } // ----------------------------------------------------------------------------------------------- @@ -394,54 +381,53 @@ public void testUnionReaderWriterSubsetIncompatibility() { /** Collection of reader/writer schema pair that are incompatible. */ public static final List INCOMPATIBLE_READER_WRITER_TEST_CASES = list( - new ReaderWriter(NULL_SCHEMA, INT_SCHEMA), - new ReaderWriter(NULL_SCHEMA, LONG_SCHEMA), + new ReaderWriter(NULL_SCHEMA, INT_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(NULL_SCHEMA, LONG_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), - new ReaderWriter(BOOLEAN_SCHEMA, INT_SCHEMA), + new ReaderWriter(BOOLEAN_SCHEMA, INT_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), - new ReaderWriter(INT_SCHEMA, NULL_SCHEMA), - new ReaderWriter(INT_SCHEMA, BOOLEAN_SCHEMA), - new ReaderWriter(INT_SCHEMA, LONG_SCHEMA), - new ReaderWriter(INT_SCHEMA, FLOAT_SCHEMA), - new ReaderWriter(INT_SCHEMA, DOUBLE_SCHEMA), + new ReaderWriter(INT_SCHEMA, NULL_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(INT_SCHEMA, BOOLEAN_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(INT_SCHEMA, LONG_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(INT_SCHEMA, FLOAT_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(INT_SCHEMA, DOUBLE_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), - new ReaderWriter(LONG_SCHEMA, FLOAT_SCHEMA), - new ReaderWriter(LONG_SCHEMA, DOUBLE_SCHEMA), + new ReaderWriter(LONG_SCHEMA, FLOAT_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(LONG_SCHEMA, DOUBLE_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), - new ReaderWriter(FLOAT_SCHEMA, DOUBLE_SCHEMA), + new ReaderWriter(FLOAT_SCHEMA, DOUBLE_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), - new ReaderWriter(STRING_SCHEMA, BOOLEAN_SCHEMA), - new ReaderWriter(STRING_SCHEMA, INT_SCHEMA), - new ReaderWriter(STRING_SCHEMA, BYTES_SCHEMA), + new ReaderWriter(STRING_SCHEMA, BOOLEAN_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(STRING_SCHEMA, INT_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(STRING_SCHEMA, BYTES_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), - new ReaderWriter(BYTES_SCHEMA, NULL_SCHEMA), - new ReaderWriter(BYTES_SCHEMA, INT_SCHEMA), - new ReaderWriter(BYTES_SCHEMA, STRING_SCHEMA), + new ReaderWriter(BYTES_SCHEMA, NULL_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(BYTES_SCHEMA, INT_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(BYTES_SCHEMA, STRING_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), - new ReaderWriter(INT_ARRAY_SCHEMA, LONG_ARRAY_SCHEMA), - new ReaderWriter(INT_MAP_SCHEMA, INT_ARRAY_SCHEMA), - new ReaderWriter(INT_ARRAY_SCHEMA, INT_MAP_SCHEMA), - new ReaderWriter(INT_MAP_SCHEMA, LONG_MAP_SCHEMA), + new ReaderWriter(INT_ARRAY_SCHEMA, LONG_ARRAY_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(INT_MAP_SCHEMA, INT_ARRAY_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(INT_ARRAY_SCHEMA, INT_MAP_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(INT_MAP_SCHEMA, LONG_MAP_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), - new ReaderWriter(ENUM1_AB_SCHEMA, ENUM1_ABC_SCHEMA), - new ReaderWriter(ENUM1_BC_SCHEMA, ENUM1_ABC_SCHEMA), + new ReaderWriter(ENUM1_BC_SCHEMA, ENUM1_ABC_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_ENUM_MISSING_FIELDS), - new ReaderWriter(ENUM1_AB_SCHEMA, ENUM2_AB_SCHEMA), - new ReaderWriter(INT_SCHEMA, ENUM2_AB_SCHEMA), - new ReaderWriter(ENUM2_AB_SCHEMA, INT_SCHEMA), + new ReaderWriter(ENUM1_AB_SCHEMA, ENUM2_AB_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_NAME), + new ReaderWriter(INT_SCHEMA, ENUM2_AB_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(ENUM2_AB_SCHEMA, INT_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), // Tests involving unions: - new ReaderWriter(INT_UNION_SCHEMA, INT_STRING_UNION_SCHEMA), - new ReaderWriter(STRING_UNION_SCHEMA, INT_STRING_UNION_SCHEMA), + new ReaderWriter(INT_UNION_SCHEMA, INT_STRING_UNION_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), + new ReaderWriter(STRING_UNION_SCHEMA, INT_STRING_UNION_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE), - new ReaderWriter(EMPTY_RECORD2, EMPTY_RECORD1), - new ReaderWriter(A_INT_RECORD1, EMPTY_RECORD1), - new ReaderWriter(A_INT_B_DINT_RECORD1, EMPTY_RECORD1), + new ReaderWriter(EMPTY_RECORD2, EMPTY_RECORD1, SchemaCompatibilityType.INCOMPATIBLE_NAME), + new ReaderWriter(A_INT_RECORD1, EMPTY_RECORD1, SchemaCompatibilityType.INCOMPATIBLE_MISSING_DEFAULT), + new ReaderWriter(A_INT_B_DINT_RECORD1, EMPTY_RECORD1, SchemaCompatibilityType.INCOMPATIBLE_MISSING_DEFAULT), - new ReaderWriter(INT_LIST_RECORD, LONG_LIST_RECORD), + new ReaderWriter(INT_LIST_RECORD, LONG_LIST_RECORD, SchemaCompatibilityType.INCOMPATIBLE_TYPE), // Last check: - new ReaderWriter(NULL_SCHEMA, INT_SCHEMA) + new ReaderWriter(NULL_SCHEMA, INT_SCHEMA, SchemaCompatibilityType.INCOMPATIBLE_TYPE) ); // ----------------------------------------------------------------------------------------------- @@ -458,7 +444,7 @@ public void testReaderWriterCompatibility() { assertEquals(String.format( "Expecting reader %s to be compatible with writer %s, but tested incompatible.", reader, writer), - SchemaCompatibilityType.COMPATIBLE, result.getType()); + readerWriter.getSchemaCompatibilityType(), result.getType()); } } @@ -474,7 +460,7 @@ public void testReaderWriterIncompatibility() { assertEquals(String.format( "Expecting reader %s to be incompatible with writer %s, but tested compatible.", reader, writer), - SchemaCompatibilityType.INCOMPATIBLE, result.getType()); + readerWriter.getSchemaCompatibilityType(), result.getType()); } }