public static void TestRangeMakeInclusiveExclusive() { var range = Range.Create(1, 2); AreEqual(range, range.MakeInclusive(i => i - 1, i => i + 1)); range = Range.CreateExclusive(1, 2); AreEqual(Range.Create(0, 3), range.MakeInclusive(i => i - 1, i => i + 1)); range = Range.CreateExclusiveTo(1, 2); AreEqual(Range.Create(1, 3), range.MakeInclusive(i => i - 1, i => i + 1)); range = Range.CreateExclusive(1, 2); AreEqual(range, range.MakeExclusive(i => i - 1, i => i + 1)); range = Range.Create(1, 2); AreEqual(Range.CreateExclusive(0, 3), range.MakeExclusive(i => i - 1, i => i + 1)); range = Range.CreateExclusiveFrom(1, 2); AreEqual(Range.CreateExclusive(1, 3), range.MakeExclusive(i => i - 1, i => i + 1)); range = Range.CreateExclusive(2, 3); IsTrue(range.MakeInclusive(i => i + 1, i => i - 1).IsEmpty); range = Range.Create(2, 3); IsTrue(range.MakeExclusive(i => i + 1, i => i - 1).IsEmpty); range = Range.CreateExclusive(2, 3); IsTrue(range.MakeInclusive(i => i + 1, i => i - 1).IsEmpty); range = Range.Create(2, 3); IsTrue(range.MakeExclusive(i => i + 1, i => i - 1).IsEmpty); var range2 = Range.CreateExclusive(1, double.PositiveInfinity); IsTrue(range2.MakeInclusive(i => double.NegativeInfinity, i => i + 1).IsInfinite); range2 = Range.Create(double.NegativeInfinity, 2); IsTrue(range2.MakeExclusive(i => i + 1, i => double.PositiveInfinity).IsInfinite); range2 = Range.Create(double.NegativeInfinity, double.PositiveInfinity); AreEqual(range2, range2.MakeInclusive(i => i - 1, i => i + 1)); }
public static void TestRangeToString() { int?value1 = 1; int?empty = null; var key = "Hello!"; AreEqual(Range <int> .Empty.ToString(), "∅"); AreEqual(Range <int> .Infinite.ToString(), "(-∞..+∞)"); AreEqual(Range.Create(1, 1).ToString(), "[1..1]"); AreEqual(Range.Create(1, 2).ToString(), "[1..2]"); AreEqual(Range.CreateExclusive(1, 2).ToString(), "(1..2)"); AreEqual(Range.CreateExclusiveFrom(1, 2).ToString(), "(1..2]"); AreEqual(Range.CreateExclusiveTo(1, 2).ToString(), "[1..2)"); AreEqual(Range.CreateExclusive(value1, empty).ToString("000"), "(001..+∞)"); AreEqual(Range.Create(RangeBoundaryFrom <int?> .Empty, RangeBoundaryTo <int?> .Empty, key).ToString(), "'Hello!':∅"); AreEqual(Range.Create(empty, empty, key).ToString(), "'Hello!':(-∞..+∞)"); AreEqual(Range.Create(empty, empty, (string)null).ToString(), "'':(-∞..+∞)"); AreEqual(Range.Create(1, 1, key).ToString(), "'Hello!':[1..1]"); AreEqual(Range.Create(1, 2, key).ToString(), "'Hello!':[1..2]"); AreEqual(Range.CreateExclusive(1, 2, key).ToString(), "'Hello!':(1..2)"); AreEqual(Range.CreateExclusiveFrom(1, 2, key).ToString(), "'Hello!':(1..2]"); AreEqual(Range.CreateExclusiveTo(1, 2, key).ToString(), "'Hello!':[1..2)"); AreEqual(Range.CreateExclusive(value1, empty, 3).ToString("000"), "'3':(001..+∞)"); AreEqual(Range.Create((int?)1, null, key).ToString(), "'Hello!':[1..+∞)"); var cultureRu = CultureInfo.GetCultureInfo("ru-RU"); var cultureEn = CultureInfo.GetCultureInfo("en-US"); AreEqual(Range.Create(1.5, 2.5, 1.1).ToString("000.000", cultureRu), "'1,1':[001,500..002,500]"); AreEqual(Range.Create(1.5, 2.5, 1.1).ToString("000.000", cultureEn), "'1.1':[001.500..002.500]"); AreEqual(Range.Create(1.5, 2.5, (string)null).ToString(null, cultureRu), "'':[1,5..2,5]"); AreEqual(Range.Create(1.5, 2.5, (string)null).ToString(null, cultureEn), "'':[1.5..2.5]"); }
public static void TestRangeProperties() { int?value1 = 1; int?value2 = 2; int?empty = null; var key = "Hello!"; var a = new Range <int?>(); Throws <InvalidOperationException>(() => a.FromValue.ToString()); Throws <InvalidOperationException>(() => a.ToValue.ToString()); AreEqual(a.From.Kind, RangeBoundaryFromKind.Empty); AreEqual(a.To.Kind, RangeBoundaryToKind.Empty); IsTrue(a.IsEmpty); IsFalse(a.IsNotEmpty); IsFalse(a.IsInfinite); IsFalse(a.IsSinglePoint); a = Range <int?> .Infinite; Throws <InvalidOperationException>(() => a.FromValue.ToString()); Throws <InvalidOperationException>(() => a.ToValue.ToString()); AreEqual(a.From.Kind, RangeBoundaryFromKind.Infinite); AreEqual(a.To.Kind, RangeBoundaryToKind.Infinite); IsFalse(a.IsEmpty); IsTrue(a.IsNotEmpty); IsTrue(a.IsInfinite); IsFalse(a.IsSinglePoint); a = Range.CreateExclusiveTo(empty, value2); Throws <InvalidOperationException>(() => a.FromValue.ToString()); AreEqual(a.ToValue, value2); AreEqual(a.From.Kind, RangeBoundaryFromKind.Infinite); AreEqual(a.To.Kind, RangeBoundaryToKind.Exclusive); IsFalse(a.IsEmpty); IsTrue(a.IsNotEmpty); IsFalse(a.IsInfinite); IsFalse(a.IsSinglePoint); a = Range.Create(value1, value2); AreEqual(a.FromValue, value1); AreEqual(a.ToValue, value2); AreEqual(a.From.Kind, RangeBoundaryFromKind.Inclusive); AreEqual(a.To.Kind, RangeBoundaryToKind.Inclusive); IsFalse(a.IsEmpty); IsTrue(a.IsNotEmpty); IsFalse(a.IsInfinite); IsFalse(a.IsSinglePoint); var b = Range.Create(value1, value1, key); AreEqual(b.FromValue, value1); AreEqual(b.ToValue, value1); AreEqual(b.Key, key); AreEqual(b.From.Kind, RangeBoundaryFromKind.Inclusive); AreEqual(b.To.Kind, RangeBoundaryToKind.Inclusive); IsFalse(b.IsEmpty); IsTrue(b.IsNotEmpty); IsFalse(b.IsInfinite); IsTrue(b.IsSinglePoint); }
public static void TestRangeCreate() { int?value1 = 1; int?value2 = 2; int?empty = null; var key = "Hello!"; DoesNotThrow(() => Range.Create(value1, value2)); DoesNotThrow(() => Range.Create(value1, value1)); DoesNotThrow(() => Range.Create(empty, value2)); DoesNotThrow(() => Range.Create(empty, empty)); DoesNotThrow(() => Range.CreateExclusiveFrom(value1, value2)); Throws <ArgumentException>(() => Range.CreateExclusiveFrom(value1, value1)); DoesNotThrow(() => Range.CreateExclusiveFrom(empty, value2)); DoesNotThrow(() => Range.CreateExclusiveFrom(empty, empty)); DoesNotThrow(() => Range.CreateExclusiveTo(value1, value2, key)); Throws <ArgumentException>(() => Range.CreateExclusiveTo(value2, value2, key)); DoesNotThrow(() => Range.CreateExclusiveTo(empty, value2, key)); DoesNotThrow(() => Range.CreateExclusiveTo(empty, empty, key)); DoesNotThrow(() => Range.CreateExclusive(value1, value2, key)); Throws <ArgumentException>(() => Range.CreateExclusive(value2, value2, key)); DoesNotThrow(() => Range.CreateExclusive(empty, value2, key)); DoesNotThrow(() => Range.CreateExclusive(empty, empty, key)); Throws <ArgumentException>(() => Range.Create(value2, value1, key)); Throws <ArgumentException>(() => Range.CreateExclusiveFrom(value2, value1)); Throws <ArgumentException>(() => Range.CreateExclusiveTo(value2, value1, key)); Throws <ArgumentException>(() => Range.CreateExclusive(value2, value1, key)); Throws <ArgumentException>(() => Range.Create(RangeBoundaryFrom <int?> .Empty, Range.BoundaryTo(value2), key)); Throws <ArgumentException>(() => Range.Create(Range.BoundaryFrom(empty), RangeBoundaryTo <int?> .Empty, key)); Throws <ArgumentException>(() => Range.Create(double.NegativeInfinity, double.NegativeInfinity, key)); Throws <ArgumentException>(() => Range.Create(double.PositiveInfinity, double.PositiveInfinity, key)); Throws <ArgumentException>(() => Range.Create(double.PositiveInfinity, double.NegativeInfinity, key)); Throws <ArgumentException>(() => Range.Create(double.PositiveInfinity, 2, key)); Throws <ArgumentException>(() => Range.Create(1, double.NegativeInfinity, key)); AreEqual( Range <int?> .Empty, new Range <int?>(RangeBoundaryFrom <int?> .Empty, RangeBoundaryTo <int?> .Empty)); AreEqual( Range <int?> .Infinite, Range.Create(empty, empty)); AreEqual( Range <double> .Infinite, Range.Create(double.NegativeInfinity, double.PositiveInfinity)); AreNotEqual( Range <int?> .Infinite, Range.Create(empty, empty, key)); AreEqual( Range.TryCreate(value2, value1), Range <int?> .Empty); IsTrue(Range.TryCreate(value2, value1, key).IsEmpty); IsFalse(Range.TryCreate(value1, value2, key).IsEmpty); IsTrue(Range.TryCreate(double.NegativeInfinity, double.NegativeInfinity, key).IsEmpty); }
public static CompositeRange <T, TKey> ToCompositeRangeExclusiveTo <T, TKey>( this IEnumerable <TKey> source, [InstantHandle] Func <TKey, T> fromValueSelector, [InstantHandle] Func <TKey, T> toValueSelector) where TKey : notnull => source .Select(s => Range.CreateExclusiveTo(fromValueSelector(s), toValueSelector(s), s)) .ToCompositeRange();
public static void TestRangeEquality() { int?value1 = 1; int?value2 = 2; int?value3 = 3; int?empty = null; var key = "Hello!"; var key2 = "Hello2!"; var eFrom = new RangeBoundaryFrom <int?>(); var eTo = new RangeBoundaryTo <int?>(); AreEqual(Range <int?> .Empty, Range.Create(eFrom, eTo)); AreEqual(Range <int?> .Infinite, Range.Create(empty, empty)); AreNotEqual(Range <double?> .Infinite, Range.Create(empty, empty)); AreEqual( Range.CreateExclusiveFrom(value1, value2).From, Range.BoundaryFromExclusive(value1)); AreEqual( Range.CreateExclusiveFrom(value1, value2).To, Range.BoundaryTo(value2)); AreNotEqual( Range.CreateExclusiveFrom(value1, value2), Range.Create(value1, value2)); IsTrue(Range.Create(value1, value2) == Range.Create <int?>(1, 2)); IsTrue(Range.Create(value1, value2) != Range.Create(value1, 1)); IsTrue(Range.Create(value1, value2, key) == Range.Create <int?, string>(1, 2, key)); IsTrue(Range.Create(value1, value2, key) != Range.Create <int?, string>(1, 2, key2)); IsTrue(Range.Create(value1, value2, key) != Range.Create <int?, string>(1, 1, key)); IsTrue(Range.TryCreate(value1, value2) == Range.Create <int?>(1, 2)); IsTrue(Range.TryCreate(value1, value2) != Range.Create(value1, 1)); IsTrue(Range.TryCreate(value1, value2, key) == Range.Create <int?, string>(1, 2, key)); IsTrue(Range.TryCreate(value1, value2, key) != Range.Create <int?, string>(1, 2, key2)); IsTrue(Range.TryCreate(value1, value2, key) != Range.Create <int?, string>(1, 1, key)); IsTrue(Range.TryCreateExclusiveFrom(value1, value2) == Range.CreateExclusiveFrom <int?>(1, 2)); IsTrue(Range.TryCreateExclusiveFrom(value1, value3) == Range.CreateExclusiveFrom(value1, 3)); IsTrue(Range.TryCreateExclusiveFrom(value1, value3) != Range.CreateExclusiveFrom(value1, 4)); IsTrue(Range.TryCreateExclusiveFrom(value1, value2, key) == Range.CreateExclusiveFrom <int?, string>(1, 2, key)); IsTrue(Range.TryCreateExclusiveFrom(value1, value2, key) != Range.CreateExclusiveFrom <int?, string>(1, 2, key2)); IsTrue(Range.TryCreateExclusiveTo(value1, value2) == Range.CreateExclusiveTo <int?>(1, 2)); IsTrue(Range.TryCreateExclusiveTo(value1, value3) == Range.CreateExclusiveTo(value1, 3)); IsTrue(Range.TryCreateExclusiveTo(value1, value3) != Range.CreateExclusiveTo(value1, 4)); IsTrue(Range.TryCreateExclusiveTo(value1, value2, key) == Range.CreateExclusiveTo <int?, string>(1, 2, key)); IsTrue(Range.TryCreateExclusiveTo(value1, value2, key) != Range.CreateExclusiveTo <int?, string>(1, 2, key2)); }
public static void TestKeyedRangeUnion() { double value1 = 1; double value2 = 2; var emptyFrom = RangeBoundaryFrom <double> .Empty; var emptyTo = RangeBoundaryTo <double> .Empty; var emptyRange = Range.Create(emptyFrom, emptyTo, RangeKey); var infiniteRange = Range.Create(double.NegativeInfinity, double.PositiveInfinity, RangeKey); var range = Range.Create(value1, value2, RangeKey); AreEqual(range.Union(range), range); AreEqual(range.Union(1, 2), range); AreEqual(range.Union(1.5, 1.5), range); AreEqual(range.Union(0, 3), Range.Create(0.0, 3.0, RangeKey)); AreEqual(range.Union(1.5, 3), Range.Create(1.0, 3.0, RangeKey)); AreEqual(range.Union(0, 1.5), Range.Create(0.0, 2.0, RangeKey)); AreEqual(range.Union(3, 4), Range.Create(1.0, 4.0, RangeKey)); AreEqual(range.Union(-2, -1), Range.Create(-2.0, 2.0, RangeKey)); AreEqual(range.Union(emptyRange), range); AreEqual(emptyRange.Union(range), range); AreEqual(range.Union(infiniteRange), infiniteRange); AreEqual(infiniteRange.Union(range), infiniteRange); AreEqual(emptyRange.Union(infiniteRange), infiniteRange); AreEqual(infiniteRange.Union(emptyRange), infiniteRange); range = Range.CreateExclusive(value1, value2, RangeKey); AreEqual(range.Union(range), range); AreEqual(range.Union(1, 2), Range.Create(1.0, 2.0, RangeKey)); AreEqual(range.Union(1.5, 1.5), range); AreEqual(range.Union(0, 3), Range.Create(0.0, 3.0, RangeKey)); AreEqual(range.Union(1.5, 3), Range.CreateExclusiveFrom(1.0, 3.0, RangeKey)); AreEqual(range.Union(0, 1.5), Range.CreateExclusiveTo(0.0, 2.0, RangeKey)); AreEqual(range.Union(3, 4), Range.CreateExclusiveFrom(1.0, 4.0, RangeKey)); AreEqual(range.Union(-2, -1), Range.CreateExclusiveTo(-2.0, 2.0, RangeKey)); AreEqual(range.Union(emptyRange), range); AreEqual(emptyRange.Union(range), range); AreEqual(range.Union(infiniteRange), infiniteRange); AreEqual(infiniteRange.Union(range), infiniteRange); AreEqual(emptyRange.Union(infiniteRange), infiniteRange); AreEqual(infiniteRange.Union(emptyRange), infiniteRange); Throws <ArgumentException>( () => range.Union(2, 1)); Throws <ArgumentException>( () => range.Union(double.PositiveInfinity, double.NegativeInfinity)); Throws <ArgumentException>( () => range.Union(2, double.NegativeInfinity)); Throws <ArgumentException>( () => range.Union(double.PositiveInfinity, 1)); }
public static void TestRangeIntersection() { double value1 = 1; double value2 = 2; var emptyFrom = RangeBoundaryFrom <double> .Empty; var emptyTo = RangeBoundaryTo <double> .Empty; var emptyRange = Range.Create(emptyFrom, emptyTo); var infiniteRange = Range.Create(double.NegativeInfinity, double.PositiveInfinity); var range = Range.Create(value1, value2); AreEqual(range.Intersect(range), range); AreEqual(range.Intersect(1, 2), range); AreEqual(range.Intersect(1.5, 1.5), Range.Create(1.5, 1.5)); AreEqual(range.Intersect(0, 3), range); AreEqual(range.Intersect(1.5, 3), Range.Create(1.5, 2.0)); AreEqual(range.Intersect(0, 1.5), Range.Create(1.0, 1.5)); AreEqual(range.Intersect(3, 4), emptyRange); AreEqual(range.Intersect(-2, -1), emptyRange); AreEqual(range.Intersect(emptyRange), emptyRange); AreEqual(emptyRange.Intersect(range), emptyRange); AreEqual(range.Intersect(infiniteRange), range); AreEqual(infiniteRange.Intersect(range), range); AreEqual(emptyRange.Intersect(infiniteRange), emptyRange); AreEqual(infiniteRange.Intersect(emptyRange), emptyRange); range = Range.CreateExclusive(value1, value2); AreEqual(range.Intersect(range), range); AreEqual(range.Intersect(1, 2), range); AreEqual(range.Intersect(1.5, 1.5), Range.Create(1.5, 1.5)); AreEqual(range.Intersect(0, 3), range); AreEqual(range.Intersect(1.5, 3), Range.CreateExclusiveTo(1.5, 2.0)); AreEqual(range.Intersect(0, 1.5), Range.CreateExclusiveFrom(1.0, 1.5)); AreEqual(range.Intersect(3, 4), emptyRange); AreEqual(range.Intersect(-2, -1), emptyRange); AreEqual(range.Intersect(emptyRange), emptyRange); AreEqual(emptyRange.Intersect(range), emptyRange); AreEqual(range.Intersect(infiniteRange), range); AreEqual(infiniteRange.Intersect(range), range); AreEqual(emptyRange.Intersect(infiniteRange), emptyRange); AreEqual(infiniteRange.Intersect(emptyRange), emptyRange); Throws <ArgumentException>( () => range.Intersect(2, 1)); Throws <ArgumentException>( () => range.Intersect(double.PositiveInfinity, double.NegativeInfinity)); Throws <ArgumentException>( () => range.Intersect(2, double.NegativeInfinity)); Throws <ArgumentException>( () => range.Intersect(double.PositiveInfinity, 1)); }
public static void TestRangeTrimFrom() { double?empty = null; double?value1 = 1; double?value2 = 2; var emptyFrom = RangeBoundaryFrom <double?> .Empty; var emptyTo = RangeBoundaryTo <double?> .Empty; var emptyRange = Range.Create(emptyFrom, emptyTo); var range = Range.Create(value1, value2); AreEqual(range.TrimFrom(null), range); AreEqual(range.TrimFrom(double.NegativeInfinity), range); Throws <ArgumentException>(() => range.TrimFrom(double.PositiveInfinity)); AreEqual(range.TrimFrom(RangeBoundaryFrom <double?> .Empty), emptyRange); AreEqual(range.TrimFrom(0), range); AreEqual(range.TrimFrom(1), range); AreEqual(range.TrimFrom(1.5), Range.Create(1.5, value2)); AreEqual(range.TrimFrom(2), Range.Create(2, value2)); AreEqual(range.TrimFrom(3), emptyRange); range = Range.Create(emptyFrom, emptyTo); AreEqual(range.TrimFrom(null), range); AreEqual(range.TrimFrom(double.NegativeInfinity), range); Throws <ArgumentException>(() => range.TrimFrom(double.PositiveInfinity)); AreEqual(range.TrimFrom(RangeBoundaryFrom <double?> .Empty), range); AreEqual(range.TrimFrom(0), range); range = Range.CreateExclusive(empty, empty); AreEqual(range.TrimFrom(null), range); AreEqual(range.TrimFrom(double.NegativeInfinity), range); Throws <ArgumentException>(() => range.TrimFrom(double.PositiveInfinity)); AreEqual(range.TrimFrom(RangeBoundaryFrom <double?> .Empty), emptyRange); AreEqual(range.TrimFrom(0), Range.Create(0, empty)); range = Range.CreateExclusive(value1, value2); AreEqual(range.TrimFrom(1), range); AreEqual(range.TrimFrom(1.5), Range.CreateExclusiveTo(1.5, value2)); AreEqual(range.TrimFrom(2), emptyRange); range = Range.CreateExclusive(value1, value2); AreEqual(range.TrimFrom(Range.BoundaryFrom <double?>(1)), range); AreEqual(range.TrimFrom(Range.BoundaryFrom <double?>(1.5)), Range.CreateExclusiveTo(1.5, value2)); AreEqual(range.TrimFrom(Range.BoundaryFrom <double?>(2)), emptyRange); }
public static void TestKeyedRangeExtendFrom() { double?empty = null; double?value1 = 1; double?value2 = 2; var emptyFrom = RangeBoundaryFrom <double?> .Empty; var emptyTo = RangeBoundaryTo <double?> .Empty; var range = Range.Create(value1, value2, RangeKey); AreEqual(range.ExtendFrom(null), Range.Create(empty, value2, RangeKey)); AreEqual(range.ExtendFrom(double.NegativeInfinity), Range.Create(empty, value2, RangeKey)); Throws <ArgumentException>(() => range.ExtendFrom(double.PositiveInfinity)); AreEqual(range.ExtendFrom(RangeBoundaryFrom <double?> .Empty), range); AreEqual(range.ExtendFrom(0), Range.Create(0, value2, RangeKey)); AreEqual(range.ExtendFrom(1), range); AreEqual(range.ExtendFrom(1.5), range); AreEqual(range.ExtendFrom(2), range); AreEqual(range.ExtendFrom(3), range); range = Range.Create(emptyFrom, emptyTo, RangeKey); AreEqual(range.ExtendFrom(null), range); AreEqual(range.ExtendFrom(double.NegativeInfinity), range); Throws <ArgumentException>(() => range.ExtendFrom(double.PositiveInfinity)); AreEqual(range.ExtendFrom(RangeBoundaryFrom <double?> .Empty), range); AreEqual(range.ExtendFrom(0), range); range = Range.CreateExclusive(empty, empty, RangeKey); AreEqual(range.ExtendFrom(null), range); AreEqual(range.ExtendFrom(double.NegativeInfinity), range); Throws <ArgumentException>(() => range.ExtendFrom(double.PositiveInfinity)); AreEqual(range.ExtendFrom(RangeBoundaryFrom <double?> .Empty), range); AreEqual(range.ExtendFrom(0), range); range = Range.CreateExclusive(value1, value2, RangeKey); AreEqual(range.ExtendFrom(1), Range.CreateExclusiveTo(1, value2, RangeKey)); AreEqual(range.ExtendFrom(1.5), range); AreEqual(range.ExtendFrom(2), range); range = Range.CreateExclusive(value1, value2, RangeKey); AreEqual(range.ExtendFrom(Range.BoundaryFrom <double?>(1)), Range.CreateExclusiveTo(1, value2, RangeKey)); AreEqual(range.ExtendFrom(Range.BoundaryFromExclusive <double?>(1)), range); AreEqual(range.ExtendFrom(Range.BoundaryFromExclusive <double?>(0)), Range.CreateExclusive(0, value2, RangeKey)); }
/// <summary>Splits the range by years.</summary> /// <param name="range">The date range.</param> /// <returns>Ranges split by first day of years in range.</returns> public static IEnumerable <Range <DateTime> > SplitByYears(this Range <DateTime> range) { if (range.IsEmpty) { yield break; } var startDate = range.From.Value; var lastYearDate = range.To.Value.FirstDayOfYear(); while (startDate < lastYearDate) { var next = startDate.FirstDayOfYear().NextYear(); yield return(Range.CreateExclusiveTo(startDate, next)); startDate = next; } yield return(Range.Create(startDate, range.To.Value)); }
public static void TestRangeStartsAfter() { double?empty = null; double?value1 = 1; double?value2 = 2; var emptyFrom = RangeBoundaryFrom <double?> .Empty; var emptyTo = RangeBoundaryTo <double?> .Empty; var range = Range.Create(value1, value2); IsTrue(range.StartsAfter(null)); IsTrue(range.StartsAfter(double.NegativeInfinity)); IsFalse(range.StartsAfter(double.PositiveInfinity)); IsFalse(range.StartsAfter(RangeBoundaryFrom <double?> .Empty)); IsFalse(range.StartsAfter(RangeBoundaryTo <double?> .Empty)); IsTrue(range.StartsAfter(0)); IsFalse(range.StartsAfter(1)); IsFalse(range.StartsAfter(1.5)); IsFalse(range.StartsAfter(2)); IsFalse(range.StartsAfter(3)); IsTrue(range.StartsAfter(Range.Create(empty, 0, _rangeKey2))); IsTrue(range.StartsAfter(Range.CreateExclusiveTo(empty, 1, _rangeKey2))); IsFalse(range.StartsAfter(Range.Create(empty, 1, _rangeKey2))); range = Range.Create(emptyFrom, emptyTo); IsFalse(range.StartsAfter(null)); IsFalse(range.StartsAfter(double.NegativeInfinity)); IsFalse(range.StartsAfter(double.PositiveInfinity)); IsFalse(range.StartsAfter(RangeBoundaryFrom <double?> .Empty)); IsFalse(range.StartsAfter(RangeBoundaryTo <double?> .Empty)); IsFalse(range.StartsAfter(0)); range = Range.CreateExclusive(empty, empty); IsFalse(range.StartsAfter(null)); IsFalse(range.StartsAfter(double.NegativeInfinity)); IsFalse(range.StartsAfter(double.PositiveInfinity)); IsFalse(range.StartsAfter(RangeBoundaryFrom <double?> .Empty)); IsFalse(range.StartsAfter(RangeBoundaryTo <double?> .Empty)); IsFalse(range.StartsAfter(0)); range = Range.CreateExclusive(value1, value2); IsTrue(range.StartsAfter(1)); IsFalse(range.StartsAfter(1.5)); IsFalse(range.StartsAfter(2)); range = Range.CreateExclusive(value1, value2); IsTrue(range.StartsAfter(Range.BoundaryFrom <double?>(1))); IsFalse(range.StartsAfter(Range.BoundaryTo <double?>(2))); IsFalse(range.StartsAfter(Range.BoundaryFromExclusive <double?>(1))); IsFalse(range.StartsAfter(Range.BoundaryFromExclusive <double?>(1.5))); IsFalse(range.StartsAfter(Range.BoundaryFromExclusive <double?>(2))); IsTrue(range.StartsAfter(Range.BoundaryToExclusive <double?>(1))); IsFalse(range.StartsAfter(Range.BoundaryToExclusive <double?>(1.5))); IsFalse(range.StartsAfter(Range.BoundaryToExclusive <double?>(2))); Throws <ArgumentException>( () => range.StartsAfter(Range.BoundaryFrom <double?>(double.PositiveInfinity))); Throws <ArgumentException>( () => range.StartsAfter(Range.BoundaryTo <double?>(double.NegativeInfinity))); }
public static void TestCompositeRangeArgsOrder() { var seek = new Random().Next(); Console.WriteLine( $"{MethodBase.GetCurrentMethod().Name}: Rnd seek: {seek} (use the seek to reproduce test results)."); var rnd = new Random(seek); var ranges = new[] { Range <int> .Empty, Range.Create(1, 2), Range.Create(1, 2), Range.Create(3, 4), Range.Create(3, 5), Range <int> .Empty, Range <int> .Empty, Range <int> .Empty, Range.CreateExclusive(4, 6), Range.CreateExclusiveTo(7, 8), Range.CreateExclusiveTo(3, 5), Range.CreateExclusive(3, 5), Range.CreateExclusiveFrom(3, 5), Range.Create(0, 6), Range <int> .Empty, Range <int> .Empty, Range <int> .Infinite }; var compositeRange = new CompositeRange <int>(ranges); AreEqual( compositeRange.ToString(), "(-∞..+∞): { (-∞..+∞); [0..6]; [1..2]; [1..2]; [3..4]; [3..5); [3..5]; (3..5); (3..5]; (4..6); [7..8) }"); compositeRange = ranges.OrderBy(r => rnd.Next()).ToCompositeRange(); AreEqual( compositeRange.ToString(), "(-∞..+∞): { (-∞..+∞); [0..6]; [1..2]; [1..2]; [3..4]; [3..5); [3..5]; (3..5); (3..5]; (4..6); [7..8) }"); compositeRange = ranges.Take(ranges.Length - 1).ToCompositeRange(); AreEqual( compositeRange.ToString(), "[0..8): { [0..6]; [1..2]; [1..2]; [3..4]; [3..5); [3..5]; (3..5); (3..5]; (4..6); [7..8) }"); compositeRange = ranges.Take(ranges.Length - 1).OrderBy(r => rnd.Next()).ToCompositeRange(); AreEqual( compositeRange.ToString(), "[0..8): { [0..6]; [1..2]; [1..2]; [3..4]; [3..5); [3..5]; (3..5); (3..5]; (4..6); [7..8) }"); compositeRange = new CompositeRange <int>(ranges.Last()); AreEqual(compositeRange.ToString(), "(-∞..+∞): { (-∞..+∞) }"); compositeRange = new CompositeRange <int>(ranges.First()); AreEqual(compositeRange.ToString(), "∅"); compositeRange = new CompositeRange <int>(ranges.Take(0)); AreEqual(compositeRange.ToString(), "∅"); compositeRange = new CompositeRange <int>(); AreEqual(compositeRange.ToString(), "∅"); }
/// <summary>Gets date range from start of the year to the current date.</summary> /// <param name="date">The date.</param> /// <returns>Date range.</returns> public static Range <DateTime> GetToEndOfYearRange(this DateTime date) => Range.CreateExclusiveTo(date, date.FirstDayOfYear().NextYear());
/// <summary>Returns date range for month.</summary> /// <param name="date">The date.</param> /// <returns>Date range for month</returns> public static Range <DateTime> GetMonthRange(this DateTime date) => Range.CreateExclusiveTo(date.FirstDayOfMonth(), date.FirstDayOfMonth().NextMonth());
public static void TestCompositeRangeArgsOrderWithKeys() { var seek = new Random().Next(); Console.WriteLine( $"{MethodBase.GetCurrentMethod().Name}: Rnd seek: {seek} (use the seek to reproduce test results)."); var rnd = new Random(seek); var emtpy = Range.Create(RangeBoundaryFrom <int> .Empty, RangeBoundaryTo <int> .Empty, "E"); var infinite = Range.Create( RangeBoundaryFrom <int> .NegativeInfinity, RangeBoundaryTo <int> .PositiveInfinity, "I"); // Equal ranges should use same keys to provide repeatable results after // ranges array will be shuffled. var ranges = new[] { emtpy, Range.Create(1, 2, "A"), Range.Create(1, 2, "A"), Range.Create(3, 4, "B"), Range.Create(3, 5, "C"), emtpy, emtpy, emtpy, Range.CreateExclusive(4, 6, "D"), Range.CreateExclusiveTo(7, 8, "F"), Range.CreateExclusiveTo(3, 5, "G"), Range.CreateExclusive(3, 5, "H"), Range.CreateExclusiveFrom(3, 5, "K"), Range.Create(0, 6, (string)null), emtpy, emtpy, infinite }; var compositeRange = new CompositeRange <int, string>(ranges); AreEqual( compositeRange.ToString(), "(-∞..+∞): { 'I':(-∞..+∞); '':[0..6]; 'A':[1..2]; 'A':[1..2]; 'B':[3..4]; " + "'G':[3..5); 'C':[3..5]; 'H':(3..5); 'K':(3..5]; 'D':(4..6); 'F':[7..8) }"); compositeRange = new CompositeRange <int, string>(ranges.OrderBy(r => rnd.Next())); AreEqual( compositeRange.ToString(), "(-∞..+∞): { 'I':(-∞..+∞); '':[0..6]; 'A':[1..2]; 'A':[1..2]; 'B':[3..4]; " + "'G':[3..5); 'C':[3..5]; 'H':(3..5); 'K':(3..5]; 'D':(4..6); 'F':[7..8) }"); compositeRange = new CompositeRange <int, string>(ranges.Take(ranges.Length - 1)); AreEqual( compositeRange.ToString(), "[0..8): { '':[0..6]; 'A':[1..2]; 'A':[1..2]; 'B':[3..4]; " + "'G':[3..5); 'C':[3..5]; 'H':(3..5); 'K':(3..5]; 'D':(4..6); 'F':[7..8) }"); compositeRange = new CompositeRange <int, string>(ranges.Take(ranges.Length - 1).OrderBy(r => rnd.Next())); AreEqual( compositeRange.ToString(), "[0..8): { '':[0..6]; 'A':[1..2]; 'A':[1..2]; 'B':[3..4]; " + "'G':[3..5); 'C':[3..5]; 'H':(3..5); 'K':(3..5]; 'D':(4..6); 'F':[7..8) }"); compositeRange = new CompositeRange <int, string>(ranges.Last()); AreEqual(compositeRange.ToString(), "(-∞..+∞): { 'I':(-∞..+∞) }"); compositeRange = new CompositeRange <int, string>(ranges.First()); AreEqual(compositeRange.ToString(), "∅"); compositeRange = new CompositeRange <int, string>(ranges.Take(0)); AreEqual(compositeRange.ToString(), "∅"); compositeRange = new CompositeRange <int, string>(); AreEqual(compositeRange.ToString(), "∅"); }
/// <summary>Returns date range for year.</summary> /// <param name="date">The date.</param> /// <returns>Date range for year</returns> public static Range <DateTimeOffset> GetYearRange(this DateTimeOffset date) => Range.CreateExclusiveTo(date.FirstDayOfYear(), date.FirstDayOfYear().NextYear());