public static bool Equals(Schema s1, Schema s2)
{
if (ReferenceEquals(s1, s2))
{
return(true);
}
if (s2 == null || s1 == null || s1.HasMetadata != s2.HasMetadata || s1.Fields.Count != s2.Fields.Count)
{
return(false);
}
if (!s1.Fields.Keys.All(k => s2.Fields.ContainsKey(k) && FieldComparer.Equals(s1.Fields[k], s2.Fields[k])) ||
!s2.Fields.Keys.All(k => s1.Fields.ContainsKey(k) && FieldComparer.Equals(s2.Fields[k], s1.Fields[k])))
{
return(false);
}
if (s1.HasMetadata && s2.HasMetadata)
{
return(s1.Metadata.Keys.Count() == s2.Metadata.Keys.Count() &&
s1.Metadata.Keys.All(k => s2.Metadata.ContainsKey(k) && s1.Metadata[k] == s2.Metadata[k]) &&
s2.Metadata.Keys.All(k => s1.Metadata.ContainsKey(k) && s2.Metadata[k] == s1.Metadata[k]));
}
return(true);
}
public void TestListTypeConstructor()
{
var stringField = new Field.Builder().Name("item").DataType(StringType.Default).Build();
var stringType1 = new ListType(stringField);
var stringType2 = new ListType(StringType.Default);
Assert.True(FieldComparer.Equals(stringType1.ValueField, stringType2.ValueField));
Assert.Equal(stringType1.ValueDataType.TypeId, stringType2.ValueDataType.TypeId);
}
private static void CompareNested(NestedType expectedType, NestedType actualType)
{
Assert.Equal(expectedType.Fields.Count, actualType.Fields.Count);
for (int i = 0; i < expectedType.Fields.Count; i++)
{
FieldComparer.Compare(expectedType.Fields[i], actualType.Fields[i]);
}
}
public void Equality()
{
Field f0_nullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Field f0_nonnullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Nullable(false).Build();
Field f0_other = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Field f0_with_meta = new Field.Builder().Name("f0").DataType(Int32Type.Default).Nullable(true).Metadata("a", "1").Metadata("b", "2").Build();
Assert.True(FieldComparer.Equals(f0_nullable, f0_other));
Assert.False(FieldComparer.Equals(f0_nullable, f0_nonnullable));
Assert.False(FieldComparer.Equals(f0_nullable, f0_with_meta));
}
public void TestMetadataConstruction()
{
var metadata = new Dictionary <string, string> {
{ "foo", "bar" }, { "bizz", "buzz" }
};
var metadata1 = new Dictionary <string, string>(metadata);
Field f0_nullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Metadata(metadata).Build();
Field f1_nullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Metadata(metadata1).Build();
Assert.True(metadata.Keys.SequenceEqual(f0_nullable.Metadata.Keys) && metadata.Values.SequenceEqual(f0_nullable.Metadata.Values));
Assert.True(FieldComparer.Equals(f0_nullable, f1_nullable));
}
public void TestStructGetFieldByName()
{
Field f0_nullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Field f1_nullable = new Field.Builder().Name("f1").DataType(StringType.Default).Build();
Field f2_nullable = new Field.Builder().Name("f2").DataType(UInt8Type.Default).Build();
List <Field> fields = new List <Field>()
{
f0_nullable, f1_nullable, f2_nullable
};
StructType struct_type = new StructType(fields);
FieldComparer.Compare(struct_type.GetFieldByName("f0"), f0_nullable);
FieldComparer.Compare(struct_type.GetFieldByName("f1"), f1_nullable);
FieldComparer.Compare(struct_type.GetFieldByName("f2"), f2_nullable);
Assert.True(struct_type.GetFieldByName("not_found") == null);
}
public void TestStructBasics()
{
Field f0_nullable = new Field.Builder().Name("f0").DataType(Int32Type.Default).Build();
Field f1_nullable = new Field.Builder().Name("f1").DataType(StringType.Default).Build();
Field f2_nullable = new Field.Builder().Name("f2").DataType(UInt8Type.Default).Build();
List <Field> fields = new List <Field>()
{
f0_nullable, f1_nullable, f2_nullable
};
StructType struct_type = new StructType(fields);
var structFields = struct_type.Fields;
Assert.True(FieldComparer.Equals(structFields.ElementAt(0), f0_nullable));
Assert.True(FieldComparer.Equals(structFields.ElementAt(1), f1_nullable));
Assert.True(FieldComparer.Equals(structFields.ElementAt(2), f2_nullable));
}
public static void Compare(Schema expected, Schema actual)
{
if (ReferenceEquals(expected, actual))
{
return;
}
Assert.Equal(expected.HasMetadata, actual.HasMetadata);
if (expected.HasMetadata)
{
Assert.Equal(expected.Metadata.Keys.Count(), actual.Metadata.Keys.Count());
Assert.True(expected.Metadata.Keys.All(k => actual.Metadata.ContainsKey(k) && expected.Metadata[k] == actual.Metadata[k]));
Assert.True(actual.Metadata.Keys.All(k => expected.Metadata.ContainsKey(k) && actual.Metadata[k] == expected.Metadata[k]));
}
Assert.Equal(expected.Fields.Count, actual.Fields.Count);
Assert.True(expected.Fields.Keys.All(k => actual.Fields.ContainsKey(k)));
foreach (string name in expected.Fields.Keys)
{
FieldComparer.Compare(expected.Fields[name], actual.Fields[name]);
}
}
