public void Test_serialization()
{
string serialized = JsonConvert.SerializeObject(one);
OpenPeriodSet deserialized = JsonConvert.DeserializeObject <OpenPeriodSet>(serialized);
deserialized.Should().Be(one);
}
public void Test_nonempty()
{
OpenPeriodSet set = new OpenPeriodSet(startOne, startTwo) + new OpenPeriodSet(startThree, startFour);
IOpenPeriod nonEmpty;
set.IsNonEmpty(out nonEmpty);
nonEmpty.Earliest.Should().Be(startOne);
nonEmpty.To.Should().Be(startFour);
NonEmptyBoundedPeriodSet nonEmptyBounded = new NonEmptyBoundedPeriodSet(startOne);
DateTime earliest = nonEmptyBounded.Start;
DateTime last = nonEmptyBounded.End;
earliest.Should().Be(startOne);
last.Should().Be(DateTime.MaxValue);
nonEmptyBounded.IntervalCount.Should().Be(1);
NonEmptyOpenPeriodSet nonEmptyOpen = new NonEmptyOpenPeriodSet(startOne);
earliest = nonEmptyOpen.Earliest;
DateTime?lastIfAny = nonEmptyOpen.To;
earliest.Should().Be(startOne);
lastIfAny.Should().Be(null);
nonEmptyOpen = new NonEmptyOpenPeriodSet(startOne);
nonEmptyOpen.Earliest.Should().Be(startOne);
}
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 Test_cross()
{
OpenPeriodSet set = one + three + four;
set.Cross(startOne).Should().Be(new StartKind(Inclusivity.Inclusive));
set.Cross(startTwo).Should().Be(new EndKind(Inclusivity.Exclusive));
set.Cross(startThree).Should().Be(new StartKind(Inclusivity.Inclusive));
set.Cross(startFour).Should().Be(new ContinuationKind());
set.Cross(startFive).Should().Be(new EndKind(Inclusivity.Exclusive));
set.Cross(startSix).Should().Be(null);
new BoundedPeriodSet(startOne, startOne).Cross(startOne).Should().Be(new DegenerateKind());
}
public void Test_entire_cross()
{
OpenPeriodSet left = new OpenPeriodSet(startOne);
OpenPeriodSet right = OpenPeriodSet.All - new OpenPeriodSet(startTwo);
(left * right).Should().Be(one);
(right * left).Should().Be(one);
OpenPeriodSet left1 = OpenPeriodSet.All - new OpenPeriodSet(startTwo);
OpenPeriodSet left2 = OpenPeriodSet.All - new OpenPeriodSet(startOne);
(left1 * left2).Should().Be(left2);
(left2 * left1).Should().Be(left2);
}
public void Test_entire_add()
{
OpenPeriodSet left = OpenPeriodSet.All - new OpenPeriodSet(startTwo);
OpenPeriodSet right = new OpenPeriodSet(startOne);
(left + right).Should().Be(OpenPeriodSet.All);
(right + left).Should().Be(OpenPeriodSet.All);
(OpenPeriodSet.All - (two + three) + (one + two + three + four)).Should().Be(OpenPeriodSet.All);
OpenPeriodSet left1 = OpenPeriodSet.All - new OpenPeriodSet(startOne);
OpenPeriodSet left2 = OpenPeriodSet.All - new OpenPeriodSet(startTwo);
(left1 + one).Should().Be(left2);
}
public virtual void FixtureSetup()
{
startOne = new DateTime(2016, 1, 1);
startTwo = new DateTime(2016, 2, 1);
startThree = new DateTime(2016, 3, 1);
startFour = new DateTime(2016, 4, 1);
startFive = new DateTime(2016, 5, 1);
startSix = new DateTime(2016, 6, 1);
startSeven = new DateTime(2016, 7, 1);
startEight = new DateTime(2016, 8, 1);
one = new OpenPeriodSet(startOne, startTwo);
two = new OpenPeriodSet(startTwo, startThree);
three = new OpenPeriodSet(startThree, startFour);
four = new OpenPeriodSet(startFour, startFive);
five = new OpenPeriodSet(startFive, startSix);
empty = OpenPeriodSet.Empty;
}
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_entire_subtract()
{
OpenPeriodSet entire = OpenPeriodSet.All;
IOpenPeriod nonEmptyEntire;
entire.IsNonEmpty(out nonEmptyEntire).Should().BeTrue();
nonEmptyEntire.Earliest.Should().Be(DateTime.MinValue);
nonEmptyEntire.To.Should().Be(null);
OpenPeriodSet set1 = new OpenPeriodSet(startFour);
OpenPeriodSet difference = entire - set1;
difference.Contains(startOne).Should().BeTrue();
IOpenPeriod nonEmptyDifference;
difference.IsNonEmpty(out nonEmptyDifference).Should().BeTrue();
nonEmptyDifference.Earliest.Should().Be(DateTime.MinValue);
nonEmptyDifference.To.Should().Be(startFour);
difference = difference - (one + two);
difference.Contains(startTwo).Should().BeFalse();
difference.IsNonEmpty(out nonEmptyDifference).Should().BeTrue();
nonEmptyDifference.Earliest.Should().Be(DateTime.MinValue);
nonEmptyDifference.To.Should().Be(startFour);
difference = entire - (one + two);
difference.Contains(startTwo).Should().BeFalse();
difference.IsNonEmpty(out nonEmptyDifference).Should().BeTrue();
nonEmptyDifference.Earliest.Should().Be(DateTime.MinValue);
nonEmptyDifference.To.Should().Be(null);
difference = entire - new OpenPeriodSet(startOne, startOne);
difference.Contains(startOne).Should().BeFalse();
difference.IsNonEmpty(out nonEmptyDifference).Should().BeTrue();
nonEmptyDifference.Earliest.Should().Be(DateTime.MinValue);
nonEmptyDifference.To.Should().Be(null);
}
