public void ImplicitConversionOperatorShouldReturnNodeWhenTuple()
{
Event e1 = new Event.Node(0, new Event.Node(1, 1, 0), 0);
Event e2 = (0, (1, 1, 0), 0); // combo of C#7 tuples and implicit conversion operator is wow!
e1.Equals(e2).Should().BeTrue();
}
Event DecodeEventNode()
{
Event e = null;
byte prefix2 = Scan(2);
switch (prefix2)
{
case 0: // (0,0,er)
e = new Event.Node(0, 0, DecodeEvent());
break;
case 1: // (0,el,0)
e = new Event.Node(0, DecodeEvent(), 0);
break;
case 2: // (0,el,er)
e = new Event.Node(0, DecodeEvent(), DecodeEvent());
break;
case 3: // n != 0
byte prefix3 = Scan(1);
switch (prefix3)
{
case 0:
byte prefix4 = Scan(1);
switch (prefix4)
{
case 0: // (n,0,er)
e = new Event.Node(DecodeN(), 0, DecodeEvent());
break;
case 1: // (n,el,0)
e = new Event.Node(DecodeN(), DecodeEvent(), 0);
break;
default:
ThrowUnexpected(prefix4);
break;
}
break;
case 1: // (n,el,er)
e = new Event.Node(DecodeN(), DecodeEvent(), DecodeEvent());
break;
default:
ThrowUnexpected(prefix3);
break;
}
break;
default:
ThrowUnexpected(prefix2);
break;
}
return(e);
}
public void MaxShouldReturnNPlusMaxOfLeftAndRightEvents()
{
// Arrange
Event e = new Event.Node(1, 2, 3);
// Act & Assert
e.Max().Should().Be(1 + 3);
}
public void LeqShouldReturnTrueWhenLeafN1IsLessThanNodeN2()
{
// Arrange
Event e1 = 1;
Event e2 = new Event.Node(2, 0, 0);
// Act & Assert
e1.Leq(e2).Should().BeTrue();
}
public void LeqShouldReturnTrueWhenNodeN1PlusR1IsLessThanOrEqualToLeafN2()
{
// Arrange
Event e1 = new Event.Node(2, 0, 1);
Event e2 = new Event.Leaf(3);
// Act & Assert
e1.Leq(e2).Should().BeTrue();
}
public void LeqShouldReturnFalseWhenNodeN1PlusR1IsGreaterThanLeafLeafN2()
{
// Arrange
Event e1 = new Event.Node(2, 0, 2);
Event e2 = new Event.Leaf(3);
// Act & Assert
e1.Leq(e2).Should().BeFalse();
}
public void LeqShouldReturnTrueWhenNodeN1EqualsNodeN2AndL1EqualsL2()
{
// Arrange
Event e1 = new Event.Node(2, 2, 0);
Event e2 = new Event.Node(2, 2, 0);
// Act & Assert
e1.Leq(e2).Should().BeTrue();
}
public void LeqShouldReturnFalseWhenNodeN1EqualsNodeN2AndL1GreaterThanL2()
{
// Arrange
Event e1 = new Event.Node(2, 3, 0);
Event e2 = new Event.Node(2, 2, 0);
// Act & Assert
e1.Leq(e2).Should().BeFalse();
}
public void EqualsShouldReturnTrueWhenComparingComplexNodesWithDifferentValues()
{
// Arrange
Event e1 = new Event.Node(0, new Event.Node(3, 4, 5), new Event.Node(6, 7, 8));
Event e2 = new Event.Node(0, new Event.Node(3, 5, 4), new Event.Node(6, 7, 8));
// Act & Assert
e1.Equals(e2).Should().BeFalse();
}
public void EqualsShouldReturnFalseWhenComparingNodesWithDifferentR()
{
// Arrange
Event e1 = new Event.Node(0, 1, 2);
Event e2 = new Event.Node(0, 1, 9);
// Act & Assert
e1.Equals(e2).Should().BeFalse();
}
public void EqualsShouldReturnTrueWhenComparingNodesWithSameValues()
{
// Arrange
Event e1 = new Event.Node(0, 1, 2);
Event e2 = new Event.Node(0, 1, 2);
// Act & Assert
e1.Equals(e2).Should().BeTrue();
}
public void NormalizeShouldReturnNormalizedTreeForNodeWithLeftAndRightLeafs()
{
// Arrange
Event e = new Event.Node(1, 2, 3);
// Act
Event result = e.Normalize();
// Assert
result.Should().Be(new Event.Node(3, 0, 1));
}
public void SinkShouldCascadeToSubTreeWhenSinkingGreaterThanN()
{
// Arrange
Event e = new Event.Node(2, 3, 4);
// Act
Event result = e.Sink(3);
// Assert
result.Should().Be(new Event.Node(0, 2, 3));
}
public void NormalizeShouldReturnLeafWithNPlusMWhenNodeHasSameLeftAndRightEvents()
{
// Arrange
Event e = new Event.Node(2, 3, 3);
// Act
Event result = e.Normalize();
// Assert
result.Should().Be(new Event.Leaf(5));
}
public void JoinShouldReturnDefinedValueWhenNodeN1AndLeafN2()
{
// Arrange
Event e1 = new Event.Node(2, 0, 1);
Event e2 = new Event.Leaf(1);
// Act
Event result = e1.Join(e2);
// Assert
result.Should().Be(new Event.Node(2, 0, 1));
}
public void JoinShouldReturnDefinedValueWhenNodeN1AndNodeN2WithN1GreaterThanN2()
{
// Arrange
Event e1 = new Event.Node(2, 0, 1);
Event e2 = new Event.Node(1, 1, 0);
// Act
Event result = e1.Join(e2);
// Assert
result.Should().Be(new Event.Node(2, 0, 1));
}
public void GetHashCodeShouldNotMatchWhenNodesHaveDifferentValues()
{
// Arrange
Event e1 = new Event.Node(0, 1, 2);
Event e2 = new Event.Node(0, 2, 2);
// Act
int hash1 = e1.GetHashCode();
int hash2 = e2.GetHashCode();
e1.Equals(e2).Should().BeFalse();
}
public void GetHashCodeShouldMatchWhenNodesHaveSameValues()
{
// Arrange
Event e1 = new Event.Node(0, 1, 2);
Event e2 = new Event.Node(0, 1, 2);
// Act
int hash1 = e1.GetHashCode();
int hash2 = e2.GetHashCode();
e1.Equals(e2).Should().BeTrue();
}
public void GetHashCodeShouldMatchWhenComplexNodesHaveDifferentValues()
{
// Arrange
Event e1 = new Event.Node(0, new Event.Node(3, 4, 5), new Event.Node(6, 7, 8));
Event e2 = new Event.Node(0, new Event.Node(3, 4, 6), new Event.Node(6, 7, 8));
// Act
int hash1 = e1.GetHashCode();
int hash2 = e2.GetHashCode();
e1.Equals(e2).Should().BeFalse();
}
public void JoinShouldReturnDefinedValueWhenNodeN1AndNodeN2WithN1LessThanN2()
{
// Arrange
Event e1 = new Event.Node(1, 2, 0);
Event e2 = new Event.Node(3, 1, 3);
// Act
Event result = e1.Join(e2);
// Assert
result.Should().Be(new Event.Node(4, 0, 2));
}
public void SinkShouldReturnDefinedValueForNode()
{
// Arrange
int n = 2;
int m = 1;
Event e = new Event.Node(n, 8, 9);
// Act
Event result = e.Sink(m);
// Assert
result.Should().Be(new Event.Node(n - m, 8, 9));
}
public void NormalizeShouldReturnRecursivelyNormalizedEventTree()
{
// This event tree, and sub-trees, are not normalized which recursively normalized.
// Arrange
Event e = new Event.Node(1, new Event.Node(2, 3, 4), new Event.Node(1, 2, 4));
// Act
Event result = e.Normalize();
// Assert
result.Should().Be(new Event.Node(4, new Event.Node(2, 0, 1), new Event.Node(0, 0, 2)));
}
public void MatchShouldInvokeNodeActionWhenEventRepresentsNode()
{
// Arrange
Event e = new Event.Node(0, 1, 2);
Action <int> leafAction = Substitute.For <Action <int> >();
Action <int, Event, Event> nodeAction = Substitute.For <Action <int, Event, Event> >();
// Act
e.Match(leafAction, nodeAction);
// Assert
leafAction.DidNotReceiveWithAnyArgs();
nodeAction.Received().Invoke(0, 1, 2);
}
public void MatchShouldInvokeNodeFuncWhenEventRepresentsNode()
{
// Arrange
Event e = new Event.Node(0, 1, 2);
Func <int, object> leafFn = Substitute.For <Func <int, object> >();
Func <int, Event, Event, object> nodeFn = Substitute.For <Func <int, Event, Event, object> >();
// Act
e.Match(leafFn, nodeFn);
// Assert
leafFn.DidNotReceiveWithAnyArgs();
nodeFn.Received().Invoke(0, 1, 2);
}
public void NormalizeShouldReturnNormalizedTreeForNodeWithLeftNodeAndRightLeaf()
{
// This is an example from the ITC paper which assumes events are always
// normalized (or start as normalized). In this, the tree is not normalized, but
// the sub-trees are.
// Arrange
Event e = new Event.Node(2, new Event.Node(2, 1, 0), 3);
// Act
Event result = e.Normalize();
// Assert
result.Should().Be(new Event.Node(4, new Event.Node(0, 1, 0), 1));
}
public void ToStringShouldCorrectlyRepresentNode()
{
string s = new Event.Node(0, 3, new Event.Node(1, 2, 3)).ToString();
s.Should().Be("(0,3,(1,2,3))");
}