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);
}
