public void Ctor_WhenCalled_MinMaxSet() { var interval = new ClosedInterval <int>(1, 4); Assert.That(interval.Min, Is.EqualTo(1)); Assert.That(interval.Max, Is.EqualTo(4)); }
public void Equals_SameIntervals_ReturnTrue() { var interval1 = new ClosedInterval <int>(1, 3); var interval2 = new ClosedInterval <int>(1, 3); Assert.That(interval1, Is.EqualTo(interval2)); }
public GetAggregateReport(Guid reportId, ClosedInterval dateFilter, Guid userId, int daysPerAggregate) { this.DaysPerAggregate = daysPerAggregate; this.ReportId = reportId; this.DateFilter = dateFilter; this.UserId = userId; }
public void Equals_DifferentIntervals_ReturnFalse() { var interval1 = new ClosedInterval <int>(0, 3); var interval2 = new ClosedInterval <int>(1, 3); Assert.That(interval1, Is.Not.EqualTo(interval2)); }
public void Ctor_WhenCalled_MinMaxSet() { var interval = new ClosedInterval<int>( 1, 4 ); Assert.That( interval.Min, Is.EqualTo( 1 ) ); Assert.That( interval.Max, Is.EqualTo( 4 ) ); }
public void Equals_SameIntervals_ReturnTrue() { var interval1 = new ClosedInterval<int>( 1, 3 ); var interval2 = new ClosedInterval<int>( 1, 3 ); Assert.That( interval1, Is.EqualTo( interval2 ) ); }
public void Equals_DifferentIntervals_ReturnFalse() { var interval1 = new ClosedInterval<int>( 0, 3 ); var interval2 = new ClosedInterval<int>( 1, 3 ); Assert.That( interval1, Is.Not.EqualTo( interval2 ) ); }
private IEnumerable <TransactionCategoryRow> GetRows(ClosedInterval filter) { for (DateTime date = filter.From; date <= filter.To; date = date.AddDays(1)) { yield return(CreateRow(date)); } }
public void FromMinMax() { var interval = ClosedInterval.FromMinMax(1, 4); Assert.That(interval.Min, Is.EqualTo(1)); Assert.That(interval.Max, Is.EqualTo(4)); }
public void FromOffsetLength() { var interval = ClosedInterval.FromOffsetLength(3, 3); Assert.That(interval.Min, Is.EqualTo(3)); Assert.That(interval.Max, Is.EqualTo(5)); }
public void Count_ValidSeriesAndInterval_ReturnsValidCount() { var series = CreateSeries(new TV(1, 1), new TV(2, 2), new TV(3, 3), new TV(4, 4), new TV(5, 5)); var range = new SeriesRange <int, int>(series, ClosedInterval.FromOffsetLength(1, 2)); Assert.That(range.Count, Is.EqualTo(2)); }
private TransactionSearchFilter FacilitateFilter(TransactionSearchFilter filter, int numberOfDaysToAggregate) { var startDate = filter.DateFilter.From.AddDays(-numberOfDaysToAggregate).Date; var endDate = filter.DateFilter.To; var closedInterval = new ClosedInterval(startDate, endDate); return(new TransactionSearchFilter(closedInterval, filter.Accounts, filter.IncludeExpressions, filter.ExcludeExpressions)); }
public void Ctor_EmptySeries_ViewportIsEmpty() { var series = CreateSeries(); var viewport = new SimpleSeriesViewport(series, ClosedInterval.FromOffsetLength(0, 0)); Assert.That(viewport.Series, Is.Empty); }
public void GetValue_WithIndex_ReturnsValidValue() { var series = CreateSeries(new TV(1, 1), new TV(2, 2), new TV(3, 3), new TV(4, 4), new TV(5, 5)); var range = new SeriesRange <int, int>(series, ClosedInterval.FromOffsetLength(1, 2)); Assert.That(range[1].Value, Is.EqualTo(3)); }
public void FromDynamic() { var set = new[] { 1, 2, 3, 4, 5, 6 }; var interval = ClosedInterval.FromDynamic(set, v => v < 3, v => v < 6); Assert.That(interval.Min, Is.EqualTo(2)); Assert.That(interval.Max, Is.EqualTo(4)); }
public void Should_Be_Equal() { var a = new ClosedInterval(new DateTime(2017, 1, 2), new DateTime(2017, 1, 3)); var b = new ClosedInterval(new DateTime(2017, 1, 2), new DateTime(2017, 1, 3)); Assert.Equal(a, b); Assert.True(a == b); }
public void WhenToMethodIsCalledOnAnInstance_ThenReturnedInstanceShouldBeDifferent() { var firstInstance = new ClosedInterval <int>(lowerLimitPoint: 0, upperLimitPoint: 0); var instanceFromToMethod = firstInstance.To(10); Assert.IsFalse(ReferenceEquals(firstInstance, instanceFromToMethod)); }
public void WhenToMethodIsCalledOnAnInstance_ThenReturnedInstanceShouldBeDifferent() { var firstInstance = new ClosedInterval<int>(lowerLimitPoint: 0, upperLimitPoint: 0); var instanceFromToMethod = firstInstance.To(10); Assert.IsFalse(ReferenceEquals(firstInstance, instanceFromToMethod)); }
public void WhenConstructorIsCalledWithComparer_ThenGivenComparerShouldBeCalled() { var mockComparer = BuildMockIntComparer(); var classUnderTest = new ClosedInterval <int>(lowerLimitPoint: 1, upperLimitPoint: 5, comparesLimitPoints: mockComparer); mockComparer.ReceivedWithAnyArgs().Compare(1, 1); }
public void WhenConstructorIsCalledWithComparer_ThenGivenComparerShouldBeCalled() { var mockComparer = BuildMockIntComparer(); var classUnderTest = new ClosedInterval<int>(lowerLimitPoint: 1, upperLimitPoint: 5, comparesLimitPoints: mockComparer); mockComparer.ReceivedWithAnyArgs().Compare(1, 1); }
public void WhenWithComparerIsCalledOnAnInstance_ThenReturnedInstanceshouldBeDifferent() { var firstInstance = new ClosedInterval <int>(lowerLimitPoint: 0, upperLimitPoint: 0); var instanceFromWithComparerMethod = firstInstance.WithComparer(BuildMockIntComparer()); Assert.IsFalse(ReferenceEquals(firstInstance, instanceFromWithComparerMethod)); }
public void ClosedIntervalIntersection() { var first = new ClosedInterval<int>(0, 10); var second = new ClosedInterval<int>(5, 15); var intersection = first.Intersection(second); Assert.IsTrue(intersection.Minimum == 5); Assert.IsTrue(intersection.Maximum == 10); }
public void WhenContainsIsCalledWithAValueEqualToUpperLimt_ThenTrueShouldBeReturned() { int lowerLimit = 5; int upperLimit = 10; var classUnderTest = new ClosedInterval<int>(lowerLimitPoint: lowerLimit, upperLimitPoint: upperLimit); Assert.IsTrue(classUnderTest.Contains(upperLimit)); }
public void WhenContainsIsCalledWithAValueEqualToUpperLimt_ThenTrueShouldBeReturned() { int lowerLimit = 5; int upperLimit = 10; var classUnderTest = new ClosedInterval <int>(lowerLimitPoint: lowerLimit, upperLimitPoint: upperLimit); Assert.IsTrue(classUnderTest.Contains(upperLimit)); }
private Dictionary <ClosedInterval, decimal> InitializeDictionary(ClosedInterval dateFilter) { var dict = new Dictionary <ClosedInterval, decimal>(); for (DateTime date = dateFilter.From; date <= dateFilter.To; date = date.AddMonths(1)) { dict.Add(GetInterval(date), 0m); } return(dict); }
public void GetEnumerator_ValidSeriesAndInterval_ReturnsValidRange() { var series = CreateSeries(new TV(1, 1), new TV(2, 2), new TV(3, 3), new TV(4, 4), new TV(5, 5)); var range = new SeriesRange <int, int>(series, ClosedInterval.FromOffsetLength(1, 2)); var expectedRange = new[] { new TV(2, 2), new TV(3, 3) }; Assert.That(range, Is.EquivalentTo(expectedRange)); }
public void WhenWithComparerIsCalled_ThenGivenComparerShouldBeCalled() { var mockComparer = BuildMockIntComparer(); var classUnderTest = new ClosedInterval <int>(lowerLimitPoint: 0, upperLimitPoint: 10); classUnderTest.WithComparer(mockComparer); mockComparer.ReceivedWithAnyArgs().Compare(1, 1); }
public void Ctor_WhenCalled_ViewportRangeIsApplied() { var series = CreateSeries(new TV(1, 1), new TV(2, 2), new TV(3, 3), new TV(4, 4)); var viewport = new SimpleSeriesViewport(series, ClosedInterval.FromOffsetLength(2, 2)); var expectedSeries = new[] { new TV(2, 2), new TV(3, 3) }; Assert.That(viewport.Series, Is.EquivalentTo(expectedSeries)); }
public List <Aggregate> Compute(ClosedInterval interval, List <TransactionCategoryRow> orderedRows, int numberOfDaysToAggregate) { var aggregates = new List <Aggregate>(); for (DateTime date = interval.From; date <= interval.To; date = date.AddDays(1)) { var sumForDay = GetSumForDay(date, numberOfDaysToAggregate, orderedRows); aggregates.Add(new Aggregate(new ClosedInterval(date.AddDays(-numberOfDaysToAggregate), date), sumForDay)); } return(aggregates); }
public void WhenConstructorIsCalledWithLimitsWrongWayAround_ThenConstructedInstanceShouldHaveCorrectecLimits() { int wrongLowerLimit = 90; int wrongUpperLimit = 10; var classUnderTest = new ClosedInterval<int>(lowerLimitPoint: wrongLowerLimit, upperLimitPoint: wrongUpperLimit); var limitComparisonResult = classUnderTest.LowerLimitPoint.CompareTo(classUnderTest.UpperLimitPoint); Assert.That(limitComparisonResult, Is.LessThan(0), "Limit points should have been corrected."); }
public void Ctor_WhenCalled_MinMaxCalculatedProperly() { var series = CreateSeries(new TV(1, 1), new TV(2, 2), new TV(3, 3), new TV(4, 4)); var viewport = new SimpleSeriesViewport(series, ClosedInterval.FromOffsetLength(2, 2)); Assert.That(viewport.MinTime, Is.EqualTo(2)); Assert.That(viewport.MinValue.Value, Is.EqualTo(2)); Assert.That(viewport.MaxTime, Is.EqualTo(3)); Assert.That(viewport.MaxValue.Value, Is.EqualTo(3)); }
public void WhenConstructorIsCalledWithLimitsWrongWayAround_ThenConstructedInstanceShouldHaveCorrectecLimits() { int wrongLowerLimit = 90; int wrongUpperLimit = 10; var classUnderTest = new ClosedInterval <int>(lowerLimitPoint: wrongLowerLimit, upperLimitPoint: wrongUpperLimit); var limitComparisonResult = classUnderTest.LowerLimitPoint.CompareTo(classUnderTest.UpperLimitPoint); Assert.That(limitComparisonResult, Is.LessThan(0), "Limit points should have been corrected."); }
public void Should_Return_Full_DataSeries() { var service = new CumulativeReportService(null); var from = new DateTime(2017, 1, 1); var to = new DateTime(2017, 2, 28); var orderedRows = GetRows(from, to); var filter = new ClosedInterval(from, to.AddDays(2)); var result = service.Compute(orderedRows, filter); Assert.Equal(Fibonacci(31) + Fibonacci(28), result.Sum(r => r.Expences)); }
public void Should_Return_Full_Service() { var service = new AggregateReportService(null); var start = new DateTime(2017, 1, 3); var end = start.AddDays(6); var interval = new ClosedInterval(start, end); var aggregates = service.Compute(interval, GetRows(), 3); Assert.Equal(27, aggregates.Sum(a => a.Expences)); }
public void WhenContainsIsCalledWithAllPointsBetweenLimits_ThenTrueShouldBeReturned() { var lowerLimit = 0; var upperLimit = 10; var classUnderTest = new ClosedInterval <int>(lowerLimitPoint: lowerLimit, upperLimitPoint: upperLimit); foreach (int candidatePoint in System.Linq.Enumerable.Range(lowerLimit, (upperLimit - lowerLimit) + 1)) { if (!classUnderTest.Contains(candidatePoint)) { Assert.Fail(System.String.Format("Point: {0} should be contained in interval.", candidatePoint)); } } }
public void WhenContainsIsCalledWithAllPointsBetweenLimits_ThenTrueShouldBeReturned() { var lowerLimit = 0; var upperLimit = 10; var classUnderTest = new ClosedInterval<int>(lowerLimitPoint: lowerLimit, upperLimitPoint: upperLimit); foreach (int candidatePoint in System.Linq.Enumerable.Range(lowerLimit, (upperLimit - lowerLimit) + 1)) { if (!classUnderTest.Contains(candidatePoint)) { Assert.Fail(System.String.Format("Point: {0} should be contained in interval.", candidatePoint)); } } }
public void WhenWithComparerIsCalled_AndGivenComparerReversesLimits_ThenFinalInstanceShouldHaveReversedLimits() { var mockComparer = Substitute.For <IComparer <int> >(); mockComparer.Compare(Arg.Any <int>(), Arg.Any <int>()).Returns(args => - 1 * ((int)args[0]).CompareTo((int)args[1])); int originaLowerLimit = 1; int originalUpperLimit = 10; var classUnderTest = new ClosedInterval <int>(lowerLimitPoint: originaLowerLimit, upperLimitPoint: originalUpperLimit).WithComparer(mockComparer); bool limitsHaveBeenReversed = classUnderTest.UpperLimitPoint.Equals(originaLowerLimit) && classUnderTest.LowerLimitPoint.Equals(originalUpperLimit); Assert.IsTrue(limitsHaveBeenReversed); }
public List <Aggregate> Compute(IEnumerable <TransactionCategoryRow> rows, ClosedInterval dateFilter) { var list = new List <Aggregate>(); var dict = InitializeDictionary(dateFilter); foreach (var row in rows) { var interval = GetInterval(row.Row.Date); dict[interval] += row.Row.Amount; } return(dict .Select(kv => new Aggregate(kv.Key, kv.Value)) .OrderBy(a => a.Interval.From) .ToList()); }
public async Task <IRequest <AggregateEnvelope> > Create(Guid reportId, ClosedInterval dateFilter, Guid userId) { var report = await repository.Find(reportId); switch (report.Type) { case "aggregate": return(new GetAggregateReport(reportId, dateFilter, userId, 30)); case "cumulative": return(new GetCumulativeReport(reportId, dateFilter, userId)); case "total-monthly": return(new GetTotalMonthlyReport(reportId, dateFilter, userId)); default: throw new ArgumentException(); } }
public void WriteCsvAsync(string fileName, AttendanceFormat attendanceFormat, string dateFormat, string timeOfExitFormat, string columnSeparator, ClosedInterval<float> attendanceRateToConsider, IEnumerable<IPerson> people) { if (fileName == null) throw new ArgumentNullException(nameof(fileName)); if (attendanceFormat != AttendanceFormat.StatusDescription) throw new NotImplementedException(nameof(attendanceFormat)); if (!DateTimeFormatStringIsValid(dateFormat)) throw new FormatException(nameof(dateFormat)); if (!DateTimeFormatStringIsValid(timeOfExitFormat)) throw new FormatException(nameof(timeOfExitFormat)); if (columnSeparator == null) throw new ArgumentNullException(nameof(columnSeparator)); if (people == null) throw new ArgumentNullException(nameof(people)); if (attendanceRateToConsider.Minimum < 0 || attendanceRateToConsider.Maximum > 1) throw new ArgumentOutOfRangeException(nameof(attendanceRateToConsider) + " must be between [0,1]."); var peopleWithinTargetAttendanceRate = people.Where(p => PersonIsWithinTargetAttendanceRate(p, attendanceRateToConsider)).ToArray(); WriteCsvImpl(fileName, attendanceFormat, dateFormat, timeOfExitFormat, columnSeparator, peopleWithinTargetAttendanceRate); }
public ConstantBoundsFn( int dim, ClosedInterval.Double value ) { this.dim = dim; this.value = value; }
private bool PersonIsWithinTargetAttendanceRate(IPerson person, ClosedInterval<float> targetAttendanceRate) { var personAttendanceRate = CalculatePersonAttendanceRate(person); return targetAttendanceRate.Contains(personAttendanceRate); }
public void ClosedIntervalIntersectsWithMaximum() { var other = new ClosedInterval<int>(Maximum, Maximum + 1); Assert.IsTrue(Reference.IntersectsWith(other)); }
public void WhenWithComparerIsCalled_ThenGivenComparerShouldBeCalled() { var mockComparer = BuildMockIntComparer(); var classUnderTest = new ClosedInterval<int>(lowerLimitPoint: 0, upperLimitPoint: 10); classUnderTest.WithComparer(mockComparer); mockComparer.ReceivedWithAnyArgs().Compare(1, 1); }
public void ClosedIntervalIntersectsWithMinimum() { var other = new ClosedInterval<int>(Minimum - 1, Minimum); Assert.IsTrue(Reference.IntersectsWith(other)); }
public void TestInitialize() { Reference = new ClosedInterval<int>(Minimum, Maximum); }
public void WriteCsvAsync(string fileName, ClosedInterval<float> attendanceRateToConsider, IEnumerable<IPerson> people) { WriteCsvAsync(fileName, AttendanceFormat.StatusDescription, Default.DateFormat, Default.TimeFormat, DefaultColumnSeparator, attendanceRateToConsider, people); }
public void Includes_MinMaxAndValueEquals_ReturnsTrue() { var interval = new ClosedInterval<int>( 0, 0 ); Assert.IsTrue( interval.Includes( 0 ) ); }
public void WhenWithComparerIsCalledOnAnInstance_ThenReturnedInstanceshouldBeDifferent() { var firstInstance = new ClosedInterval<int>(lowerLimitPoint: 0, upperLimitPoint: 0); var instanceFromWithComparerMethod = firstInstance.WithComparer(BuildMockIntComparer()); Assert.IsFalse(ReferenceEquals(firstInstance, instanceFromWithComparerMethod)); }
public void WhenWithComparerIsCalled_AndGivenComparerReversesLimits_ThenFinalInstanceShouldHaveReversedLimits() { var mockComparer = Substitute.For<IComparer<int>>(); mockComparer.Compare(Arg.Any<int>(), Arg.Any<int>()).Returns(args => -1 * ((int)args[0]).CompareTo((int)args[1])); int originaLowerLimit = 1; int originalUpperLimit = 10; var classUnderTest = new ClosedInterval<int>(lowerLimitPoint: originaLowerLimit, upperLimitPoint: originalUpperLimit).WithComparer(mockComparer); bool limitsHaveBeenReversed = classUnderTest.UpperLimitPoint.Equals(originaLowerLimit) && classUnderTest.LowerLimitPoint.Equals(originalUpperLimit); Assert.IsTrue(limitsHaveBeenReversed); }