public void Test_building_with_boundaries()
{
BoundedPeriodSet set1 = one + two + three + four;
BoundedPeriodSet set2 = two + four + five;
(set1 - set2).Should().Be(one + three);
(set1 * set2).Should().Be(two + four);
}
public void Test_all()
{
OpenPeriodSet openAll = OpenPeriodSet.All;
BoundedPeriodSet boundedAll = BoundedPeriodSet.All;
OpenPeriodSet remainder = openAll.Minus(boundedAll);
openAll.Should().Be(boundedAll);
remainder.IsEmpty.Should().BeTrue();
}
public void TestEquals()
{
BoundedPeriodSet bounded = new OpenPeriodSet(startOne, startTwo);
bounded.Should()
.Be((BoundedPeriodSet)one);
OpenPeriodSet open = new BoundedPeriodSet(startOne, startTwo);
open.Should().Be(one);
bounded = new OpenPeriodSet(startOne);
NonEmptyBoundedPeriodSet nonEmptyBounded = (NonEmptyBoundedPeriodSet)bounded;
nonEmptyBounded.End.Should().Be(DateTime.MaxValue);
nonEmptyBounded.Should().Be(new BoundedPeriodSet(startOne));
new BoundedPeriodSet(startOne).Should().Be(nonEmptyBounded);
}
public void Test_initialize_degenerate()
{
BoundedPeriodSet degenerate;
NonEmptyBoundedPeriodSet nonEmptyDegenerate;
OpenPeriodSet openDegenerate;
NonEmptyOpenPeriodSet nonEmptyOpenDegenerate;
DateTime from = startOne;
DateTime?to = startOne;
degenerate = new BoundedPeriodSet(from, to);
degenerate.Boundaries.Count().Should().Be(1);
nonEmptyDegenerate = new NonEmptyBoundedPeriodSet(startOne, startOne);
nonEmptyDegenerate.Boundaries.Count().Should().Be(1);
openDegenerate = new OpenPeriodSet(from, to);
openDegenerate.Boundaries.Count().Should().Be(1);
nonEmptyOpenDegenerate = new NonEmptyOpenPeriodSet(startOne, startOne);
nonEmptyOpenDegenerate.Boundaries.Count().Should().Be(1);
}
public void Test_degenerate()
{
BoundedPeriodSet degenerate = new BoundedPeriodSet(startOne, startOne);
degenerate.Should().NotBe(BoundedPeriodSet.Empty);
degenerate.Should().NotBe(OpenPeriodSet.Empty);
degenerate.IsEmpty.Should().BeFalse();
IDefaultInterval <DateTime> nonEmptyDegenerate;
degenerate.IsNonEmpty(out nonEmptyDegenerate).Should().BeTrue();
nonEmptyDegenerate.Start.Should().Be(startOne);
nonEmptyDegenerate.End.Should().Be(startOne);
(degenerate * one).Should().Be(degenerate);
(one - degenerate).Cross(degenerate).Should().Be(empty);
(degenerate + two).Cross(degenerate).Should().NotBe(empty);
degenerate = new BoundedPeriodSet(startTwo, startTwo);
BoundedPeriodSet set = one + two;
BoundedPeriodSet difference = set - degenerate;
difference.Contains(startTwo).Should().BeFalse();
difference.Cross(degenerate).Should().Be(empty);
}
