public void NotEquals_ToOtherType()
{
ShortValueOr <EquatableObject> value1 = new EquatableObject(100);
ShortValueOr <TestObject> value2 = new TestObject();
Assert.False(value1.Equals(value2));
}
// Only primitive values are supported:
// - strings, such as "hello", etc.
// - numbers, such as 123.66124, etc.
// - booleans: true and false.
private static bool TryParseEquatableObject(DTypeSpecLexer lexer, out EquatableObject value)
{
Contracts.AssertValue(lexer);
string token;
if (!lexer.TryNextToken(out token) || token.Length == 0)
{
value = default(EquatableObject);
return(false);
}
// String support
if (token[0] == '"')
{
int tokenLen = token.Length;
if (tokenLen < 2 || token[tokenLen - 1] != '"')
{
value = default(EquatableObject);
return(false);
}
value = new EquatableObject(token.Substring(1, tokenLen - 2));
return(true);
}
// Number (hex) support
if (token[0] == '#' && token.Length > 1)
{
if (uint.TryParse(token.Substring(1), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out uint intValue))
{
value = new EquatableObject((double)intValue);
return(true);
}
value = default(EquatableObject);
return(false);
}
// Number (double) support
double numValue;
if (double.TryParse(token, out numValue))
{
value = new EquatableObject(numValue);
return(true);
}
// Boolean support
bool boolValue;
if (bool.TryParse(token, out boolValue))
{
value = new EquatableObject(boolValue);
return(true);
}
value = default(EquatableObject);
return(false);
}
public bool TryGetValue(string key, out EquatableObject value)
{
Contracts.AssertValue(key);
bool fRet = RedBlackNode <EquatableObject> .TryGetValue(_root, key, out value);
Contracts.Assert(fRet == (value.Object != null));
return(fRet);
}
public void DoesNotEqualToSucceeds(EquatableObject?value, EquatableObject valueToCompare)
{
var act = () => Requires.Argument(value, nameof(value))
.DoesNotEqualTo(valueToCompare)
.Check();
act.Should().NotThrow();
}
public void When_comparing_base_Generic_IComparable_object_Should_equate()
{
EquatableObject baseObj = new EquatableObject();
DerivedEquatableObject derivedObj = new DerivedEquatableObject();
Assert.Equal(derivedObj, baseObj);
Assert.True(baseObj.Equals__Called);
}
public void When_copmaring_derived_IEquitable_object_Should_equate()
{
EquatableObject baseObj = new EquatableObject();
DerivedEquatableObject derivedObj = new DerivedEquatableObject();
Assert.Equal(baseObj, derivedObj);
Assert.True(baseObj.Equals__Called);
}
public void Should_EquatableOverload_AreDifferent()
{
var obj1 = new EquatableObject(1, "Test name");
var obj2 = new EquatableObject(2, "Different test name");
var diff = _provider.ComputeDiff(obj1, obj2, _comparisonOptions);
Assert.Greater(diff.Count, 0);
}
public void CallsIEquatable()
{
EquatableObject obj1 = new EquatableObject();
EquatableObject obj2 = new EquatableObject();
Assert.Equal(obj1, obj2);
Assert.True(obj1.Equals__Called);
Assert.Same(obj2, obj1.Equals_Other);
}
public void IEquatables_AreComparedByEquals()
{
var object1 = new EquatableObject(100);
var object2 = new EquatableObject(100);
var object3 = new EquatableObject(200);
SimpleValueOr <EquatableObject> value1 = object1;
SimpleValueOr <EquatableObject> value2 = object2;
SimpleValueOr <EquatableObject> value3 = object3;
Assert.True(value1.Equals(value2));
Assert.False(value1.Equals(value3));
Assert.True(value1 == value2);
Assert.False(value1 != value2);
Assert.True(value1.Equals((object)value2));
Assert.AreEqual(value1.GetHashCode(), value2.GetHashCode());
Assert.AreNotEqual(value2.GetHashCode(), value3.GetHashCode());
}
public void When_comparing_enumerables_of_equitable_objects_Should_use_IEquitable_Equals_for_each_item()
{
var obj1 = new EquatableObject();
var obj2 = new EquatableObject();
var list1 = new List <EquatableObject> {
obj1, obj2
};
var obj3 = new EquatableObject();
var obj4 = new EquatableObject();
var list2 = new List <EquatableObject> {
obj3, obj4
};
Record.Exception(() => Assert.Equal(list1, list2));
Assert.True(obj1.Equals__Called);
Assert.True(obj2.Equals__Called);
Assert.Equal(obj2.Equals_Other, obj3);
Assert.Equal(obj2.Equals_Other, obj4);
}
public ValueTree SetItem(string name, EquatableObject value)
{
Contracts.AssertValue(name);
Contracts.AssertValue(value.Object);
return(new ValueTree(RedBlackNode <EquatableObject> .SetItem(_root, name, value)));
}
public EquatableObjectContainer(EquatableObject eo) => _eo = eo;
