public void TestEqualObjects_does_not_throw_exception_when_objects_equal()
{
var obj1 = new MethodSignature(typeof(int), typeof(string));
var obj2 = new MethodSignature(typeof(int), typeof(string));
EqualityTester.TestEqualObjects(obj1, obj2);
}
public void StructurallyEqualsWorks()
{
var n1 = null as object;
var n2 = null as object;
var o1 = new object();
var o2 = new object();
var t1 = new EqualityTester { Id = 1 };
var t2 = new EqualityTester { Id = 1 };
var t3 = new EqualityTester { Id = 3 };
var s = "foo";
Assert.True(n1.StructurallyEquals(null));
Assert.True(n1.StructurallyEquals(n1));
Assert.True(n1.StructurallyEquals(n2));
Assert.True(o1.StructurallyEquals(o1));
Assert.True(t1.StructurallyEquals(t1));
Assert.True(s.StructurallyEquals(s));
Assert.False(o1.StructurallyEquals(null));
Assert.False(o1.StructurallyEquals(n1));
Assert.False(n1.StructurallyEquals(o1));
Assert.False(s.StructurallyEquals(o1));
Assert.False(t1.StructurallyEquals(s));
Assert.False(o1.StructurallyEquals(o2));
Assert.False(o1.StructurallyEquals(s));
Assert.True(t1.StructurallyEquals(t2));
Assert.False(t1.StructurallyEquals(t3));
}
public void Equality()
{
DateTime timestamp1 = new DateTime(2000, 6, 1, 23, 1, 5, DateTimeKind.Utc);
TimeSpan staleness1 = TimeSpan.FromSeconds(10);
DateTime timestamp2 = new DateTime(2005, 1, 1, 1, 1, 1, DateTimeKind.Utc);
TimeSpan staleness2 = TimeSpan.FromSeconds(30);
var strong = TimestampBound.Strong;
var minRead = TimestampBound.OfMinReadTimestamp(timestamp1);
var read = TimestampBound.OfReadTimestamp(timestamp1);
var exactStaleness = TimestampBound.OfExactStaleness(staleness1);
var maxStaleness = TimestampBound.OfMaxStaleness(staleness1);
EqualityTester.AssertEqual(strong,
new[] { strong },
new[] { minRead, read, exactStaleness, maxStaleness });
EqualityTester.AssertEqual(minRead,
new[] { TimestampBound.OfMinReadTimestamp(timestamp1) },
new[] { strong, read, exactStaleness, maxStaleness, TimestampBound.OfMinReadTimestamp(timestamp2) });
EqualityTester.AssertEqual(read,
new[] { TimestampBound.OfReadTimestamp(timestamp1) },
new[] { strong, minRead, exactStaleness, maxStaleness, TimestampBound.OfReadTimestamp(timestamp2) });
EqualityTester.AssertEqual(exactStaleness,
new[] { TimestampBound.OfExactStaleness(staleness1) },
new[] { strong, minRead, read, maxStaleness, TimestampBound.OfExactStaleness(staleness2) });
EqualityTester.AssertEqual(maxStaleness,
new[] { TimestampBound.OfMaxStaleness(staleness1) },
new[] { strong, minRead, read, exactStaleness, TimestampBound.OfMaxStaleness(staleness2) });
}
public void FastEqualsWorks()
{
var n1 = null as object;
var n2 = null as object;
var o1 = new object();
var o2 = new object();
var t1 = new EqualityTester { Id = 1 };
var t2 = new EqualityTester { Id = 1 };
var t3 = new EqualityTester { Id = 3 };
var s = "foo";
Assert.Equal(true, n1.FastEquals(null));
Assert.Equal(true, n1.FastEquals(n1));
Assert.Equal(true, n1.FastEquals(n2));
Assert.Equal(true, o1.FastEquals(o1));
Assert.Equal(true, t1.FastEquals(t1));
Assert.Equal(true, s.FastEquals(s));
Assert.Equal(false, o1.FastEquals(null));
Assert.Equal(false, o1.FastEquals(n1));
Assert.Equal(false, n1.FastEquals(o1));
Assert.Equal(false, s.FastEquals(o1));
Assert.Equal(false, t1.FastEquals(s));
Assert.Equal(null, o1.FastEquals(o2));
Assert.Equal(null, o1.FastEquals(s));
Assert.Equal(null, t1.FastEquals(t2));
Assert.Equal(null, t1.FastEquals(t3));
}
public void EqualityHandlesNullValues()
{
var map1 = new MapField <string, ForeignMessage>();
map1.Add("a", new ForeignMessage {
C = 10
});
map1.Add("b", null);
var map2 = new MapField <string, ForeignMessage>();
map2.Add("a", new ForeignMessage {
C = 10
});
map2.Add("b", null);
EqualityTester.AssertEquality(map1, map2);
// Check the null value isn't ignored entirely...
Assert.IsTrue(map1.Remove("b"));
EqualityTester.AssertInequality(map1, map2);
map1.Add("b", new ForeignMessage());
EqualityTester.AssertInequality(map1, map2);
map1["b"] = null;
EqualityTester.AssertEquality(map1, map2);
}
public void NaNValuesComparedBitwise()
{
var map1 = new MapField <string, double>
{
{ "x", SampleNaNs.Regular },
{ "y", SampleNaNs.SignallingFlipped }
};
var map2 = new MapField <string, double>
{
{ "x", SampleNaNs.Regular },
{ "y", SampleNaNs.PayloadFlipped }
};
var map3 = new MapField <string, double>
{
{ "x", SampleNaNs.Regular },
{ "y", SampleNaNs.SignallingFlipped }
};
EqualityTester.AssertInequality(map1, map2);
EqualityTester.AssertEquality(map1, map3);
Assert.True(map1.Values.Contains(SampleNaNs.SignallingFlipped));
Assert.False(map2.Values.Contains(SampleNaNs.SignallingFlipped));
}
public void TestUnequalObjects_throws_exception_when_objects_not_equal()
{
var obj1 = new MethodSignature(typeof(int), typeof(string));
var obj2 = new MethodSignature(typeof(DateTime), typeof(decimal));
EqualityTester.TestUnequalObjects(obj1, obj2);
}
public void TestUnequalObjects_does_not_throw_exception_when_objects_equal()
{
var obj1 = new MethodSignature(typeof(int), typeof(string));
var obj2 = new MethodSignature(typeof(int), typeof(string));
Assert.Throws <InvalidOperationException>(() => EqualityTester.TestUnequalObjects(obj1, obj2));
}
public void Equality_CustomHostAndPort()
{
string dataSource = "projects/p1/instances/i1/databases/d1";
var builder = new SpannerConnectionStringBuilder {
DataSource = dataSource, Host = "h1", Port = 500
};
// The data source doesn't matter
var equalBuilder = new SpannerConnectionStringBuilder($"Data Source=projects/p2/instances/i2/databases/d2;Host = h1; Port = 500");
var unequalBuilders = new[]
{
new SpannerConnectionStringBuilder {
DataSource = dataSource, Host = "h1", Port = 600
},
new SpannerConnectionStringBuilder {
DataSource = dataSource, Host = "h2", Port = 500
},
new SpannerConnectionStringBuilder {
DataSource = dataSource, Host = "h1", Port = 500, MaximumGrpcChannels = 5
},
new SpannerConnectionStringBuilder {
DataSource = dataSource, Host = "h1", Port = 500, MaxConcurrentStreamsLowWatermark = 25
},
new SpannerConnectionStringBuilder {
DataSource = dataSource, Host = "h1", Port = 500, CredentialFile = "creds.json"
},
new SpannerConnectionStringBuilder($"Data Source={dataSource}; Host = h1; Port = 500", new ComputeCredential().ToChannelCredentials())
};
var options = new SpannerClientCreationOptions(builder);
var equalOptions = new SpannerClientCreationOptions(equalBuilder);
var unequalOptions = unequalBuilders.Select(b => new SpannerClientCreationOptions(b)).ToArray();
EqualityTester.AssertEqual(options, new[] { equalOptions }, unequalOptions);
}
public void Equality_Simple()
{
var map = new MapField <string, string>();
EqualityTester.AssertEquality(map, map);
EqualityTester.AssertInequality(map, null);
Assert.IsFalse(map.Equals(new object()));
}
public void Equality(string controlText, string[] equalText, string[] unequalText)
{
BigQueryNumeric control = BigQueryNumeric.Parse(controlText);
BigQueryNumeric[] equal = equalText.Select(BigQueryNumeric.Parse).ToArray();
BigQueryNumeric[] unequal = unequalText.Select(BigQueryNumeric.Parse).ToArray();
EqualityTester.AssertEqual(control, equal, unequal);
EqualityTester.AssertEqualityOperators(control, equal, unequal);
}
public void Equality_override_works()
{
var item1 = new MethodSignature(typeof(int), typeof(string));
var item2 = new MethodSignature(typeof(int), typeof(string));
var item3 = new MethodSignature(typeof(DateTime), typeof(decimal));
EqualityTester.TestEqualObjects(item1, item2);
EqualityTester.TestUnequalObjects(item2, item3);
EqualityTester.TestAgainstNull(item3);
}
public static int test_expr_generic_equatable(int a)
{
if (EqualityTester <int> .Check(a, 12))
{
return(1);
}
else
{
return(0);
}
}
public void Equality()
{
EqualityTester.AssertEqual(BigQueryGeography.Parse("POINT(30 10)"),
new[] { BigQueryGeography.Parse("POINT(30 10)") },
new[]
{
BigQueryGeography.Parse("POINT (30 10)"), // Whitespace is relevant
BigQueryGeography.Parse("POINT"),
BigQueryGeography.Parse("LINESTRING (30 10, 10 30, 40 40)")
});
}
public void EqualityIsKeySensitive()
{
var map1 = new MapField <string, string>();
map1.Add("first key", "v1");
map1.Add("second key", "v2");
var map2 = new MapField <string, string>();
map2.Add("third key", "v1");
map2.Add("fourth key", "v2");
EqualityTester.AssertInequality(map1, map2);
}
public void EqualityIsOrderInsensitive()
{
var map1 = new MapField <string, string>();
map1.Add("a", "v1");
map1.Add("b", "v2");
var map2 = new MapField <string, string>();
map2.Add("b", "v2");
map2.Add("a", "v1");
EqualityTester.AssertEquality(map1, map2);
}
HashSet(EqualityTester <T> tester, int capacity)
{
if (tester == null)
{
tester = Query.getDefaultEqualityTester();
}
indexes = new int[capacity];
hashCodes = new int[capacity];
nexts = new int[capacity];
#pragma warning disable 313
elements = new T[capacity];
#pragma warning restore
firstFree = -1;
this.tester = tester;
}
public void NaNComparisons()
{
var message1 = new TestWellKnownTypes {
DoubleField = SampleNaNs.Regular
};
var message2 = new TestWellKnownTypes {
DoubleField = SampleNaNs.PayloadFlipped
};
var message3 = new TestWellKnownTypes {
DoubleField = SampleNaNs.Regular
};
EqualityTester.AssertInequality(message1, message2);
EqualityTester.AssertEquality(message1, message3);
}
public void EqualityIsOrderInsensitive()
{
var map1 = new MapField <string, string>
{
{ "a", "v1" },
{ "b", "v2" }
};
var map2 = new MapField <string, string>
{
{ "b", "v2" },
{ "a", "v1" }
};
EqualityTester.AssertEquality(map1, map2);
}
public void EqualityIsKeySensitive()
{
var map1 = new MapField <string, string>
{
{ "first key", "v1" },
{ "second key", "v2" }
};
var map2 = new MapField <string, string>
{
{ "third key", "v1" },
{ "fourth key", "v2" }
};
EqualityTester.AssertInequality(map1, map2);
}
public void EqualityIsValueSensitive()
{
// Note: Without some care, it's a little easier than one might
// hope to see hash collisions, but only in some environments...
var map1 = new MapField <string, string>();
map1.Add("a", "first value");
map1.Add("b", "second value");
var map2 = new MapField <string, string>();
map2.Add("a", "third value");
map2.Add("b", "fourth value");
EqualityTester.AssertInequality(map1, map2);
}
public void NaNValuesComparedBitwise()
{
var list1 = new RepeatedField <double> {
SampleNaNs.Regular, SampleNaNs.SignallingFlipped
};
var list2 = new RepeatedField <double> {
SampleNaNs.Regular, SampleNaNs.PayloadFlipped
};
var list3 = new RepeatedField <double> {
SampleNaNs.Regular, SampleNaNs.SignallingFlipped
};
EqualityTester.AssertInequality(list1, list2);
EqualityTester.AssertEquality(list1, list3);
Assert.True(list1.Contains(SampleNaNs.SignallingFlipped));
Assert.False(list2.Contains(SampleNaNs.SignallingFlipped));
}
public void NaNValuesComparedBitwise()
{
var list1 = new RepeatedField <double> {
SampleNaNs.Regular, SampleNaNs.SignallingFlipped
};
var list2 = new RepeatedField <double> {
SampleNaNs.Regular, SampleNaNs.PayloadFlipped
};
var list3 = new RepeatedField <double> {
SampleNaNs.Regular, SampleNaNs.SignallingFlipped
};
// All SampleNaNs have the same hashcode under certain targets (e.g. netcoreapp2.1)
EqualityTester.AssertInequality(list1, list2, checkHashcode: false);
EqualityTester.AssertEquality(list1, list3);
Assert.True(list1.Contains(SampleNaNs.SignallingFlipped));
Assert.False(list2.Contains(SampleNaNs.SignallingFlipped));
}
public void Equality_DefaultHostAndPort()
{
string dataSource = "projects/p1/instances/i1/databases/d1";
var builder = new SpannerConnectionStringBuilder {
DataSource = dataSource
};
// Timeout doesn't matter
var equalBuilder = new SpannerConnectionStringBuilder($"Data Source={dataSource}; Timeout=100");
var unequalBuilders = new[]
{
new SpannerConnectionStringBuilder {
DataSource = dataSource, CredentialFile = "creds.json"
},
new SpannerConnectionStringBuilder($"Data Source={dataSource}", new ComputeCredential().ToChannelCredentials())
};
var options = new SpannerClientCreationOptions(builder);
var equalOptions = new SpannerClientCreationOptions(equalBuilder);
var unequalOptions = unequalBuilders.Select(b => new SpannerClientCreationOptions(b)).ToArray();
EqualityTester.AssertEqual(options, new[] { equalOptions }, unequalOptions);
}
public void GetHashCode_SameValues_HashCodesAreTheSame() => EqualityTester.AssertSameHashCodes <JsonArray>(GetData(), GetReadonlyData());
public void EqualsObject_DifferentValues_False()
=> EqualityTester.AssertNotEquals <JsonArray>(GetData(), new JsonArray {
"hello", 5
});
public void EqualsObject_Null_False() => EqualityTester.AssertNotEquals <JsonArray>(GetData(), null);
public void EqualsObject_SameValuesDifferentOrder_False()
=> EqualityTester.AssertNotEquals <JsonArray>(new JsonArray {
"a", "b", "c"
}, new JsonArray {
"c", "a", "b"
});
public void EqualsObject_SameValues_True() => EqualityTester.AssertEquals <JsonArray>(GetData(), new JsonArray(GetReadonlyData()));
public void EqualsObject_DifferentTypes_False() => EqualityTester.AssertNotEquals <JsonArray>(GetData(), new object());
public void EqualsObject_SameInstance_True()
{
var obj = new JsonArray(GetData());
EqualityTester.AssertEquals <JsonArray>(obj, obj);
}
public void TemperatureEquality_DifferentType_NotEqual()
{
EqualityTester.Act(32, "a", false);
}