private static IReadOnlyList <Datapoint <T> > AddDatapointsWithGapLikely <T>( IReadOnlyList <Datapoint <T> > datapoints, ReportingPeriod reportingPeriod, TimeComparison timeComparison) { var result = new List <Datapoint <T> >(); var adjacentReportingPeriod = GetAdjacentBoundedReportingPeriod(reportingPeriod, timeComparison); // Most likely will result in a gap in the timeseries and also possibly datapoints in different granularity. var adjacentDatapoints = adjacentReportingPeriod .GetUnitsWithin() .Select(_ => _.ToReportingPeriod()) .Select(_ => new Datapoint <T>(_, A.Dummy <T>())) .ToList(); if (timeComparison == TimeComparison.After) { result.AddRange(datapoints); result.AddRange(adjacentDatapoints); } else { result.AddRange(adjacentDatapoints); result.AddRange(datapoints); } return(result); }
private static ReportingPeriod GetAdjacentBoundedReportingPeriod( ReportingPeriod reportingPeriod, TimeComparison timeComparison) { ReportingPeriod result; if (timeComparison == TimeComparison.After) { result = A.Dummy <ReportingPeriod>() .Whose(_ => (!_.HasComponentWithUnboundedGranularity()) && (_.GetUnitOfTimeKind() == reportingPeriod.GetUnitOfTimeKind()) && (_.Start.ToMostGranular().Start > reportingPeriod.End.ToMostGranular().End)); } else if (timeComparison == TimeComparison.Before) { result = A.Dummy <ReportingPeriod>() .Whose(_ => (!_.HasComponentWithUnboundedGranularity()) && (_.GetUnitOfTimeKind() == reportingPeriod.GetUnitOfTimeKind()) && (_.End.ToMostGranular().End < reportingPeriod.Start.ToMostGranular().Start)); } else { throw new NotSupportedException(Invariant($"This {nameof(TimeComparison)} is not supported: {timeComparison}.")); } return(result); }
void AssertIntervalEqualTo( DateTime basePoint, DateTime target, int years = 0, int months = 0, int days = 0, int hours = 0, int minutes = 0, int seconds = 0, int milliseconds = 0, bool negative = false ) { CalendarTimeSpan diff = TimeComparison.CalendarDifference(basePoint, target); Assert.Equal( new CalendarTimeSpan(years, months, days, hours, minutes, seconds, milliseconds, negative), diff ); }
public static int Compare(DateTime a, DateTime b, TimeComparison mode) { switch (mode) { case TimeComparison.JustDate: return(DateTime.Compare(a.Date, b.Date)); case TimeComparison.JustTime: return(TimeSpan.Compare(a.TimeOfDay, b.TimeOfDay)); default: return(DateTime.Compare(a, b)); } }
public void After_Should_CollectError_When_TimeComparisonSet(DateTime memberValue, DateTime min, TimeComparison timeComparison, bool expectedIsValid) { Tester.TestSingleMemberRule <DateTime?>( m => m.After(min, timeComparison), memberValue, expectedIsValid, Phrases.Keys.Times.After, new[] { Arg.Time("min", min), Arg.Enum("timeComparison", timeComparison) }); }
public void Between_Should_CollectError_When_TimeComparisonSet(DateTime min, DateTime model, DateTime max, TimeComparison timeComparison, bool shouldBeValid) { Tester.TestSingleRule( model, m => m.Between(min, max, timeComparison), shouldBeValid, MessageKey.Times.Between, Arg.Time("min", min), Arg.Time("max", max), Arg.Enum("timeComparison", timeComparison)); }
public void NotEqualTo_Should_CollectError_When_TimeComparisonSet(DateTime memberValue, DateTime value, TimeComparison timeComparison, bool expectedIsValid) { Tester.TestSingleMemberRule <DateTime?>( m => m.NotEqualTo(value, timeComparison), memberValue, expectedIsValid, Phrases.Keys.Times.NotEqualTo, new[] { Arg.Time("value", value), Arg.Enum("timeComparison", timeComparison) }); }
public static IMemberSpecificationBuilder <TModel, DateTime?> Before <TModel>(this IMemberSpecificationBuilder <TModel, DateTime?> @this, DateTime max, TimeComparison timeComparison = TimeComparison.All) where TModel : class { return(@this.AsNullable(m => m.Before(max, timeComparison))); }
public void Before_Should_CollectError_When_TimeComparisonSet_FromNullable(DateTime model, DateTime max, TimeComparison timeComparison, bool shouldBeValid) { Tester.TestSingleRule <DateTime?>( model, m => m.Before(max, timeComparison), shouldBeValid, MessageKey.Times.Before, Arg.Time("max", max), Arg.Enum("timeComparison", timeComparison)); }
public void Before_Should_CollectError_When_TimeComparisonSet(DateTime memberValue, DateTime max, TimeComparison timeComparison, bool expectedIsValid) { Tester.TestSingleMemberRule( m => m.Before(max, timeComparison), memberValue, expectedIsValid, Phrases.Keys.Times.Before, new[] { Arg.Time("max", max), Arg.Enum("timeComparison", timeComparison) }); }
public static IMemberSpecificationBuilder <TModel, DateTimeOffset> BetweenOrEqualTo <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset> @this, DateTimeOffset min, DateTimeOffset max, TimeComparison timeComparison = TimeComparison.All) where TModel : class { return(@this.Valid(m => (TimeComparer.Compare(m, min, timeComparison) >= 0) && (TimeComparer.Compare(m, max, timeComparison) <= 0), Phrases.Keys.Times.BetweenOrEqualTo, new[] { Arg.Time(nameof(min), min), Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison) })); }
public void NotEqualTo_Should_CollectError_When_TimeComparisonSet_FromNullable(DateTimeOffset model, DateTimeOffset value, TimeComparison timeComparison, bool shouldBeValid) { Tester.TestSingleRule <DateTimeOffset?>( model, m => m.NotEqualTo(value, timeComparison), shouldBeValid, MessageKey.Times.NotEqualTo, Arg.Time("value", value), Arg.Enum("timeComparison", timeComparison)); }
public void BeforeOrEqualTo_Should_CollectError_When_TimeComparisonSet(DateTimeOffset model, DateTimeOffset max, TimeComparison timeComparison, bool shouldBeValid) { Tester.TestSingleRule( model, m => m.BeforeOrEqualTo(max, timeComparison), shouldBeValid, MessageKey.Times.BeforeOrEqualTo, Arg.Time("max", max), Arg.Enum("timeComparison", timeComparison)); }
public static IRuleOut <DateTime?> BetweenOrEqualTo(this IRuleIn <DateTime?> @this, DateTime min, DateTime max, TimeComparison timeComparison = TimeComparison.All) { return(@this.RuleTemplate(m => TimeComparer.Compare(m.Value, min, timeComparison) >= 0 && TimeComparer.Compare(m.Value, max, timeComparison) <= 0, MessageKey.Times.BetweenOrEqualTo, Arg.Time(nameof(min), min), Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison))); }
public static IRuleOut <DateTime> EqualTo(this IRuleIn <DateTime> @this, DateTime value, TimeComparison timeComparison = TimeComparison.All) { return(@this.RuleTemplate(m => TimeComparer.Compare(m, value, timeComparison) == 0, MessageKey.Times.EqualTo, Arg.Time(nameof(value), value), Arg.Enum(nameof(timeComparison), timeComparison))); }
public static IRuleOut <DateTime> Between(this IRuleIn <DateTime> @this, DateTime min, DateTime max, TimeComparison timeComparison = TimeComparison.All) { return(@this.RuleTemplate(m => TimeComparer.Compare(m, min, timeComparison) > 0 && TimeComparer.Compare(m, max, timeComparison) < 0, MessageKey.Times.Between, Arg.Time(nameof(min), min), Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison))); }
public static IRuleOut <DateTime> BeforeOrEqualTo(this IRuleIn <DateTime> @this, DateTime max, TimeComparison timeComparison = TimeComparison.All) { return(@this.RuleTemplate(m => TimeComparer.Compare(m, max, timeComparison) <= 0, MessageKey.Times.BeforeOrEqualTo, Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison))); }
public static IRuleOut <DateTime> AfterOrEqualTo(this IRuleIn <DateTime> @this, DateTime min, TimeComparison timeComparison = TimeComparison.All) { return(@this.RuleTemplate(m => TimeComparer.Compare(m, min, timeComparison) >= 0, MessageKey.Times.AfterOrEqualTo, Arg.Time(nameof(min), min), Arg.Enum(nameof(timeComparison), timeComparison))); }
public void BetweenOrEqualTo_Should_CollectError_When_TimeComparisonSet(DateTime min, DateTime memberValue, DateTime max, TimeComparison timeComparison, bool expectedIsValid) { Tester.TestSingleMemberRule <DateTime?>( m => m.BetweenOrEqualTo(min, max, timeComparison), memberValue, expectedIsValid, Phrases.Keys.Times.BetweenOrEqualTo, new[] { Arg.Time("min", min), Arg.Time("max", max), Arg.Enum("timeComparison", timeComparison) }); }
public static IRuleOut <DateTimeOffset?> After(this IRuleIn <DateTimeOffset?> @this, DateTimeOffset min, TimeComparison timeComparison = TimeComparison.All) { return(@this.RuleTemplate(m => TimeComparer.Compare(m.Value, min, timeComparison) > 0, MessageKey.Times.After, Arg.Time(nameof(min), min), Arg.Enum(nameof(timeComparison), timeComparison))); }
public static IMemberSpecificationBuilder <TModel, DateTimeOffset?> After <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset?> @this, DateTimeOffset min, TimeComparison timeComparison = TimeComparison.All) where TModel : class { return(@this.AsNullable(m => m.After(min, timeComparison))); }
public static IRuleOut <DateTimeOffset?> Before(this IRuleIn <DateTimeOffset?> @this, DateTimeOffset max, TimeComparison timeComparison = TimeComparison.All) { return(@this.RuleTemplate(m => TimeComparer.Compare(m.Value, max, timeComparison) < 0, MessageKey.Times.Before, Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison))); }
public void After_Should_CollectError_When_TimeComparisonSet_FromNullable(DateTimeOffset model, DateTimeOffset min, TimeComparison timeComparison, bool shouldBeValid) { Tester.TestSingleRule <DateTimeOffset?>( model, m => m.After(min, timeComparison), shouldBeValid, MessageKey.Times.After, Arg.Time("min", min), Arg.Enum("timeComparison", timeComparison)); }
public static IMemberSpecificationBuilder <TModel, DateTimeOffset?> BetweenOrEqualTo <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset?> @this, DateTimeOffset min, DateTimeOffset max, TimeComparison timeComparison = TimeComparison.All) where TModel : class { return(@this.AsNullable(m => m.BetweenOrEqualTo(min, max, timeComparison))); }
public void BetweenOrEqualTo_Should_CollectError_When_TimeComparisonSet_FromNullable(DateTimeOffset min, DateTimeOffset model, DateTimeOffset max, TimeComparison timeComparison, bool shouldBeValid) { Tester.TestSingleRule <DateTimeOffset?>( model, m => m.BetweenOrEqualTo(min, max, timeComparison), shouldBeValid, MessageKey.Times.BetweenOrEqualTo, Arg.Time("min", min), Arg.Time("max", max), Arg.Enum("timeComparison", timeComparison)); }
public static IMemberSpecificationBuilder <TModel, DateTimeOffset?> EqualTo <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset?> @this, DateTimeOffset value, TimeComparison timeComparison = TimeComparison.All) where TModel : class { return(@this.AsNullable(m => m.EqualTo(value, timeComparison))); }
public static IMemberSpecificationBuilder <TModel, DateTimeOffset> Before <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset> @this, DateTimeOffset max, TimeComparison timeComparison = TimeComparison.All) where TModel : class { return(@this.Valid(m => TimeComparer.Compare(m, max, timeComparison) < 0, Phrases.Keys.Times.Before, new[] { Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison) })); }
public void EqualTo_Should_CollectError_When_TimeComparisonSet(DateTime model, DateTime value, TimeComparison timeComparison, bool shouldBeValid) { Tester.TestSingleRule( model, m => m.EqualTo(value, timeComparison), shouldBeValid, MessageKey.Times.EqualTo, Arg.Time("value", value), Arg.Enum("timeComparison", timeComparison)); }
public static IMemberSpecificationBuilder <TModel, DateTimeOffset> EqualTo <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset> @this, DateTimeOffset value, TimeComparison timeComparison = TimeComparison.All) where TModel : class { return(@this.Valid(m => TimeComparer.Compare(m, value, timeComparison) == 0, Phrases.Keys.Times.EqualTo, new[] { Arg.Time(nameof(value), value), Arg.Enum(nameof(timeComparison), timeComparison) })); }
public void AfterOrEqualTo_Should_CollectError_When_TimeComparisonSet(DateTime model, DateTime min, TimeComparison timeComparison, bool shouldBeValid) { Tester.TestSingleRule( model, m => m.AfterOrEqualTo(min, timeComparison), shouldBeValid, MessageKey.Times.AfterOrEqualTo, Arg.Time("min", min), Arg.Enum("timeComparison", timeComparison)); }