public static void GetUnitsToDate___Should_return_all_quarters_from_1Q_to_lastUnitOfTimeInYear___When_lastUnitOfTimeInYear_is_of_type_CalendarQuarter()
{
// Arrange
var lastUnitOfTimeInYear1 = new CalendarQuarter(2016, QuarterNumber.Q1);
var lastUnitOfTimeInYear2 = new CalendarQuarter(2016, QuarterNumber.Q2);
var lastUnitOfTimeInYear3 = new CalendarQuarter(2016, QuarterNumber.Q3);
var lastUnitOfTimeInYear4 = new CalendarQuarter(2016, QuarterNumber.Q4);
var expectedUnitsToDate1 = new List <CalendarQuarter> {
lastUnitOfTimeInYear1
};
var expectedUnitsToDate2 = new List <CalendarQuarter> {
lastUnitOfTimeInYear1, lastUnitOfTimeInYear2
};
var expectedUnitsToDate3 = new List <CalendarQuarter> {
lastUnitOfTimeInYear1, lastUnitOfTimeInYear2, lastUnitOfTimeInYear3
};
var expectedUnitsToDate4 = new List <CalendarQuarter> {
lastUnitOfTimeInYear1, lastUnitOfTimeInYear2, lastUnitOfTimeInYear3, lastUnitOfTimeInYear4
};
// Act
var actualUnitsToDate1 = lastUnitOfTimeInYear1.GetUnitsToDate();
var actualUnitsToDate2 = lastUnitOfTimeInYear2.GetUnitsToDate();
var actualUnitsToDate3 = lastUnitOfTimeInYear3.GetUnitsToDate();
var actualUnitsToDate4 = lastUnitOfTimeInYear4.GetUnitsToDate();
// Assert
actualUnitsToDate1.Should().Equal(expectedUnitsToDate1);
actualUnitsToDate2.Should().Equal(expectedUnitsToDate2);
actualUnitsToDate3.Should().Equal(expectedUnitsToDate3);
actualUnitsToDate4.Should().Equal(expectedUnitsToDate4);
}
/// <summary>
/// Get list of Quarters between two dates
/// </summary>
/// <remarks>WARNING: NEEDS TESTING</remarks>
/// <param name="StartDate"></param>
/// <param name="EndDate"></param>
/// <returns></returns>
public static IEnumerable <CalendarQuarter> GetAllQuarters(DateTime StartDate, DateTime EndDate)
{
var qtrs = new List <CalendarQuarter>();
var firstQuarter = new CalendarQuarter(StartDate);
var lastQuarter = new CalendarQuarter(EndDate);
var startDate = firstQuarter.StartDate;
qtrs.Add(lastQuarter);
CalendarQuarter quarter;
quarter = lastQuarter.GetPriorQuarter();
qtrs.Add(quarter);
do
{
quarter = quarter.GetPriorQuarter();
qtrs.Add(quarter);
} while (quarter.StartDate > startDate);
qtrs.Add(firstQuarter);
return(qtrs);
}
public static IEnumerable <CalendarQuarter> GetPreviousQuarters(int NumberToReturn, DateTime Date,
bool IncludeCurrent = false)
{
var qtrs = new List <CalendarQuarter>();
CalendarQuarter quarter;
//var lastQuarterYear = 0;
var currentQuarter = new CalendarQuarter(Date);
if (IncludeCurrent)
{
quarter = currentQuarter;
//qtrs.Add(currentQuarter);
//numToGet = numToGet - 1;
}
else
{
quarter = currentQuarter.GetPriorQuarter();
}
qtrs.Add(quarter);
var numToGet = NumberToReturn - 1;
for (int i = 0; i < numToGet; i++)
{
quarter = quarter.GetPriorQuarter();
qtrs.Add(quarter);
}
return(qtrs);
}
private static CalendarQuarter TweakBy(
this CalendarQuarter calendarQuarter,
int amount,
CalendarQuarterComponent componentToTweak)
{
if (componentToTweak == CalendarQuarterComponent.Quarter)
{
var referenceMonth = new DateTime(calendarQuarter.Year, (int)calendarQuarter.QuarterNumber * 3, 1);
var updatedMonth = referenceMonth.AddMonths(amount * 3);
var result = new CalendarQuarter(updatedMonth.Year, (QuarterNumber)(updatedMonth.Month / 3));
return(result);
}
if (componentToTweak == CalendarQuarterComponent.Year)
{
var result = new CalendarQuarter(calendarQuarter.Year + amount, calendarQuarter.QuarterNumber);
return(result);
}
throw new NotSupportedException("this calendar quarter component is not supported: " + componentToTweak);
}
public static void GetLastCalendarDay___Should_return_last_day_of_quarter___When_parameter_unitOfTime_is_of_type_CalendarQuarter()
{
// Arrange
var quarter1 = new CalendarQuarter(2016, QuarterNumber.Q1);
var quarter2 = new CalendarQuarter(2016, QuarterNumber.Q2);
var quarter3 = new CalendarQuarter(2016, QuarterNumber.Q3);
var quarter4 = new CalendarQuarter(2016, QuarterNumber.Q4);
var expectedDay1 = new CalendarDay(2016, MonthOfYear.March, DayOfMonth.ThirtyOne);
var expectedDay2 = new CalendarDay(2016, MonthOfYear.June, DayOfMonth.Thirty);
var expectedDay3 = new CalendarDay(2016, MonthOfYear.September, DayOfMonth.Thirty);
var expectedDay4 = new CalendarDay(2016, MonthOfYear.December, DayOfMonth.ThirtyOne);
// Act
var actualDay1 = quarter1.GetLastCalendarDay();
var actualDay2 = quarter2.GetLastCalendarDay();
var actualDay3 = quarter3.GetLastCalendarDay();
var actualDay4 = quarter4.GetLastCalendarDay();
// Assert
actualDay1.Should().Be(expectedDay1);
actualDay2.Should().Be(expectedDay2);
actualDay3.Should().Be(expectedDay3);
actualDay4.Should().Be(expectedDay4);
}
public static void GetFirstCalendarDay___Should_return_first_day_of_quarter___When_parameter_unitOfTime_is_of_type_CalendarQuarter()
{
// Arrange
var quarter1 = new CalendarQuarter(2016, QuarterNumber.Q1);
var quarter2 = new CalendarQuarter(2016, QuarterNumber.Q2);
var quarter3 = new CalendarQuarter(2016, QuarterNumber.Q3);
var quarter4 = new CalendarQuarter(2016, QuarterNumber.Q4);
var expectedDay1 = new CalendarDay(2016, MonthOfYear.January, DayOfMonth.One);
var expectedDay2 = new CalendarDay(2016, MonthOfYear.April, DayOfMonth.One);
var expectedDay3 = new CalendarDay(2016, MonthOfYear.July, DayOfMonth.One);
var expectedDay4 = new CalendarDay(2016, MonthOfYear.October, DayOfMonth.One);
// Act
var actualDay1 = quarter1.GetFirstCalendarDay();
var actualDay2 = quarter2.GetFirstCalendarDay();
var actualDay3 = quarter3.GetFirstCalendarDay();
var actualDay4 = quarter4.GetFirstCalendarDay();
// Assert
actualDay1.Should().Be(expectedDay1);
actualDay2.Should().Be(expectedDay2);
actualDay3.Should().Be(expectedDay3);
actualDay4.Should().Be(expectedDay4);
}
public static void GreaterThanOperator___Should_return_false___When_left_side_of_operator_is_null_and_right_side_is_not_null()
{
// Arrange
CalendarQuarter systemUnderTest1 = null;
var systemUnderTest2 = A.Dummy <CalendarQuarter>();
// Act
var result = systemUnderTest1 > systemUnderTest2;
// Assert
result.Should().BeFalse();
}
public static void CompareTo___Should_throw_ArgumentException___When_calling_non_typed_overload_and_other_object_is_null()
{
// Arrange
var systemUnderTest1 = A.Dummy <CalendarQuarter>();
CalendarQuarter systemUnderTest2 = null;
// Act
var ex = Record.Exception(() => systemUnderTest1.CompareTo((object)systemUnderTest2));
// Assert
ex.Should().BeOfType <ArgumentException>();
}
public static void CompareTo___Should_return_0___When_calling_non_typed_overload_and_test_object_is_equal_to_other_object()
{
// Arrange
var systemUnderTest1 = A.Dummy <CalendarQuarter>();
var systemUnderTest2 = new CalendarQuarter(systemUnderTest1.Year, systemUnderTest1.QuarterNumber);
// Act
var result = systemUnderTest1.CompareTo((object)systemUnderTest2);
// Assert
result.Should().Be(0);
}
public static void GreaterThanOrEqualToOperator___Should_return_true___When_left_side_of_operator_is_equal_to_right_side()
{
// Arrange
var systemUnderTest1 = A.Dummy <CalendarQuarter>();
var systemUnderTest2 = new CalendarQuarter(systemUnderTest1.Year, systemUnderTest1.QuarterNumber);
// Act
var result = systemUnderTest1 >= systemUnderTest2;
// Assert
result.Should().BeTrue();
}
public static void GreaterThanOrEqualToOperator___Should_return_true___When_both_sides_of_operator_are_null()
{
// Arrange
CalendarQuarter systemUnderTest1 = null;
CalendarQuarter systemUnderTest2 = null;
// Act
var result = systemUnderTest1 >= systemUnderTest2;
// Assert
result.Should().BeTrue();
}
public static void GreaterThanOrEqualToOperator___Should_return_true___When_left_side_of_operator_is_not_null_and_right_side_is_null()
{
// Arrange
var systemUnderTest1 = A.Dummy <CalendarQuarter>();
CalendarQuarter systemUnderTest2 = null;
// Act
var result = systemUnderTest1 >= systemUnderTest2;
// Assert
result.Should().BeTrue();
}
public static void LessThanOperator___Should_return_false___When_both_sides_of_operator_are_null()
{
// Arrange
CalendarQuarter systemUnderTest1 = null;
CalendarQuarter systemUnderTest2 = null;
// Act
var result = systemUnderTest1 < systemUnderTest2;
// Assert
result.Should().BeFalse();
}
public static void Equals___Should_return_true___When_calling_non_typed_overload_and_objects_being_compared_have_same_property_values()
{
// Arrange
var systemUnderTest1 = A.Dummy <CalendarQuarter>();
var systemUnderTest2 = new CalendarQuarter(systemUnderTest1.Year, systemUnderTest1.QuarterNumber);
// Act
var result = systemUnderTest1.Equals((object)systemUnderTest2);
// Assert
result.Should().BeTrue();
}
public static void NotEqualsOperator___Should_return_false___When_objects_being_compared_have_same_property_values()
{
// Arrange
var systemUnderTest1 = A.Dummy <CalendarQuarter>();
var systemUnderTest2 = new CalendarQuarter(systemUnderTest1.Year, systemUnderTest1.QuarterNumber);
// Act
var result = systemUnderTest1 != systemUnderTest2;
// Assert
result.Should().BeFalse();
}
public static void GetHashCode___Should_be_equal_for_two_CalendarQuarters___When_both_objects_have_the_same_property_values()
{
// Arrange
var systemUnderTest1 = A.Dummy <CalendarQuarter>();
var systemUnderTest2 = new CalendarQuarter(systemUnderTest1.Year, systemUnderTest1.QuarterNumber);
// Act
var hash1 = systemUnderTest1.GetHashCode();
var hash2 = systemUnderTest2.GetHashCode();
// Assert
hash1.Should().Be(hash2);
}
public static void ToString___Should_return_friendly_string_representation_of_object___When_called()
{
// Arrange
var systemUnderTest1 = new CalendarQuarter(2017, QuarterNumber.Q1);
var systemUnderTest2 = new CalendarQuarter(2017, QuarterNumber.Q4);
// Act
var toString1 = systemUnderTest1.ToString();
var toString2 = systemUnderTest2.ToString();
// Assert
toString1.Should().Be("1Q2017");
toString2.Should().Be("4Q2017");
}
public static void NotEqualsOperator___Should_return_true___When_one_side_of_operator_is_null_and_the_other_side_is_not_null()
{
// Arrange
CalendarQuarter systemUnderTest1 = null;
var systemUnderTest2 = A.Dummy <CalendarQuarter>();
// Act
var result1 = systemUnderTest1 != systemUnderTest2;
var result2 = systemUnderTest2 != systemUnderTest1;
// Assert
result1.Should().BeTrue();
result2.Should().BeTrue();
}
public static void ToCalendarQuarter___Should_adjust_fiscal_quarter_to_calendar_quarter___When_called()
{
// Arrange
// note: See red and green highlighted area in embedded spreadsheet FiscalQuarterToCalendarQuarter.xlsx
var expected1 = new CalendarQuarter(2013, (QuarterNumber)3);
var expected2 = new CalendarQuarter(2013, (QuarterNumber)2);
var expected3 = new CalendarQuarter(2013, (QuarterNumber)1);
var expected4 = new CalendarQuarter(2012, (QuarterNumber)4);
// Act
var actual1a = new FiscalQuarter(2013, (QuarterNumber)4).ToCalendarQuarter((QuarterNumber)4);
var actual1b = new FiscalQuarter(2014, (QuarterNumber)1).ToCalendarQuarter((QuarterNumber)3);
var actual1c = new FiscalQuarter(2014, (QuarterNumber)2).ToCalendarQuarter((QuarterNumber)2);
var actual1d = new FiscalQuarter(2013, (QuarterNumber)3).ToCalendarQuarter((QuarterNumber)1);
var actual2a = new FiscalQuarter(2013, (QuarterNumber)3).ToCalendarQuarter((QuarterNumber)4);
var actual2b = new FiscalQuarter(2013, (QuarterNumber)4).ToCalendarQuarter((QuarterNumber)3);
var actual2c = new FiscalQuarter(2014, (QuarterNumber)1).ToCalendarQuarter((QuarterNumber)2);
var actual2d = new FiscalQuarter(2013, (QuarterNumber)2).ToCalendarQuarter((QuarterNumber)1);
var actual3a = new FiscalQuarter(2013, (QuarterNumber)2).ToCalendarQuarter((QuarterNumber)4);
var actual3b = new FiscalQuarter(2013, (QuarterNumber)3).ToCalendarQuarter((QuarterNumber)3);
var actual3c = new FiscalQuarter(2013, (QuarterNumber)4).ToCalendarQuarter((QuarterNumber)2);
var actual3d = new FiscalQuarter(2013, (QuarterNumber)1).ToCalendarQuarter((QuarterNumber)1);
var actual4a = new FiscalQuarter(2013, (QuarterNumber)1).ToCalendarQuarter((QuarterNumber)4);
var actual4b = new FiscalQuarter(2013, (QuarterNumber)2).ToCalendarQuarter((QuarterNumber)3);
var actual4c = new FiscalQuarter(2013, (QuarterNumber)3).ToCalendarQuarter((QuarterNumber)2);
var actual4d = new FiscalQuarter(2012, (QuarterNumber)4).ToCalendarQuarter((QuarterNumber)1);
// Assert
actual1a.Should().Be(expected1);
actual1b.Should().Be(expected1);
actual1c.Should().Be(expected1);
actual1d.Should().Be(expected1);
actual2a.Should().Be(expected2);
actual2b.Should().Be(expected2);
actual2c.Should().Be(expected2);
actual2d.Should().Be(expected2);
actual3a.Should().Be(expected3);
actual3b.Should().Be(expected3);
actual3c.Should().Be(expected3);
actual3d.Should().Be(expected3);
actual4a.Should().Be(expected4);
actual4b.Should().Be(expected4);
actual4c.Should().Be(expected4);
actual4d.Should().Be(expected4);
}
public static void ToFiscalQuarter___Should_adjust_calendar_quarter_to_fiscal_quarter___When_called()
{
// Arrange
// note: See green and yellow highlighted area in embedded spreadsheet FiscalQuarterToCalendarQuarter.xlsx
var calQuarter2 = new CalendarQuarter(2013, QuarterNumber.Q2);
var calQuarter1 = new CalendarQuarter(2013, QuarterNumber.Q1);
var calQuarter3 = new CalendarQuarter(2013, QuarterNumber.Q3);
var calQuarter4 = new CalendarQuarter(2013, QuarterNumber.Q4);
// Act
var fiscalQuarter1a = calQuarter1.ToFiscalQuarter((QuarterNumber)4);
var fiscalQuarter1b = calQuarter1.ToFiscalQuarter((QuarterNumber)3);
var fiscalQuarter1c = calQuarter1.ToFiscalQuarter((QuarterNumber)2);
var fiscalQuarter1d = calQuarter1.ToFiscalQuarter((QuarterNumber)1);
var fiscalQuarter2a = calQuarter2.ToFiscalQuarter((QuarterNumber)4);
var fiscalQuarter2b = calQuarter2.ToFiscalQuarter((QuarterNumber)3);
var fiscalQuarter2c = calQuarter2.ToFiscalQuarter((QuarterNumber)2);
var fiscalQuarter2d = calQuarter2.ToFiscalQuarter((QuarterNumber)1);
var fiscalQuarter3a = calQuarter3.ToFiscalQuarter((QuarterNumber)4);
var fiscalQuarter3b = calQuarter3.ToFiscalQuarter((QuarterNumber)3);
var fiscalQuarter3c = calQuarter3.ToFiscalQuarter((QuarterNumber)2);
var fiscalQuarter3d = calQuarter3.ToFiscalQuarter((QuarterNumber)1);
var fiscalQuarter4a = calQuarter4.ToFiscalQuarter((QuarterNumber)4);
var fiscalQuarter4b = calQuarter4.ToFiscalQuarter((QuarterNumber)3);
var fiscalQuarter4c = calQuarter4.ToFiscalQuarter((QuarterNumber)2);
var fiscalQuarter4d = calQuarter4.ToFiscalQuarter((QuarterNumber)1);
// Assert
fiscalQuarter1a.Should().Be(new FiscalQuarter(2013, (QuarterNumber)2));
fiscalQuarter1b.Should().Be(new FiscalQuarter(2013, (QuarterNumber)3));
fiscalQuarter1c.Should().Be(new FiscalQuarter(2013, (QuarterNumber)4));
fiscalQuarter1d.Should().Be(new FiscalQuarter(2013, (QuarterNumber)1));
fiscalQuarter2a.Should().Be(new FiscalQuarter(2013, (QuarterNumber)3));
fiscalQuarter2b.Should().Be(new FiscalQuarter(2013, (QuarterNumber)4));
fiscalQuarter2c.Should().Be(new FiscalQuarter(2014, (QuarterNumber)1));
fiscalQuarter2d.Should().Be(new FiscalQuarter(2013, (QuarterNumber)2));
fiscalQuarter3a.Should().Be(new FiscalQuarter(2013, (QuarterNumber)4));
fiscalQuarter3b.Should().Be(new FiscalQuarter(2014, (QuarterNumber)1));
fiscalQuarter3c.Should().Be(new FiscalQuarter(2014, (QuarterNumber)2));
fiscalQuarter3d.Should().Be(new FiscalQuarter(2013, (QuarterNumber)3));
fiscalQuarter4a.Should().Be(new FiscalQuarter(2014, (QuarterNumber)1));
fiscalQuarter4b.Should().Be(new FiscalQuarter(2014, (QuarterNumber)2));
fiscalQuarter4c.Should().Be(new FiscalQuarter(2014, (QuarterNumber)3));
fiscalQuarter4d.Should().Be(new FiscalQuarter(2013, (QuarterNumber)4));
}
public static void QuarterNumber___Should_return_same_quarterNumber_passed_to_constructor___When_getting()
{
// Arrange
var validQuarter = A.Dummy <CalendarQuarter>();
var year = validQuarter.Year;
var quarter = validQuarter.QuarterNumber;
var systemUnderTest = new CalendarQuarter(year, quarter);
// Act
var actualQuarter = systemUnderTest.QuarterNumber;
// Assert
actualQuarter.Should().Be(quarter);
}
private static CalendarQuarter TweakComponentOfCalendarQuarter(this CalendarQuarter calendarQuarter, CalendarQuarterComponent componentToTweak)
{
if (componentToTweak == CalendarQuarterComponent.Quarter)
{
var tweakedQuarter = A.Dummy <QuarterNumber>().ThatIsNot(calendarQuarter.QuarterNumber);
var result = new CalendarQuarter(calendarQuarter.Year, tweakedQuarter);
return(result);
}
if (componentToTweak == CalendarQuarterComponent.Year)
{
var tweakedYear = A.Dummy <PositiveInteger>().ThatIs(y => y != calendarQuarter.Year && y <= 9999);
var result = new CalendarQuarter(tweakedYear, calendarQuarter.QuarterNumber);
return(result);
}
throw new NotSupportedException("this calendar quarter component is not supported: " + componentToTweak);
}
private async Task <string> GetQuarterIdentifierAsync(CalendarQuarter date, bool createIfNotExists)
{
if (createIfNotExists)
{
var query = _graphClient
.Cypher
.Merge("(a:Quarter { quarter: {quarter}, year: {year} })")
.OnCreate()
.Set("a.uniqueId = {id}, a.quarter = {quarter}, a.year = {year}")
.WithParams(
new
{
id = Guid.NewGuid().ToString(),
quarter = date.Quarter,
year = date.Year
})
.Return <string>("a.uniqueId");
var results = await query.ResultsAsync.ConfigureAwait(false);
return(results.FirstOrDefault());
}
else
{
var query = _graphClient
.Cypher
.Match("(a:Quarter { quarter: {quarter}, year: {year} })")
.WithParams(
new
{
quarter = date.Quarter,
year = date.Year
})
.Return <string>("a.uniqueId");
var results = await query.ResultsAsync.ConfigureAwait(false);
return(results.FirstOrDefault());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AccountingTimeDummyFactory"/> class.
/// </summary>
public AccountingTimeDummyFactory()
{
// ------------------------------------------------------------------------------------
// --------------------------- accounting period system ------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(FiftyTwoFiftyThreeWeekMethodology.Unknown);
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <AccountingPeriodSystem>();
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new FiscalYearAccountingPeriodSystem(A.Dummy <MonthOfYear>().ThatIsNot(MonthOfYear.December));
return(result);
});
// ------------------------------------------------------------------------------------
// ------------------------------------- time ----------------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(DayOfMonth.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MonthNumber.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MonthOfYear.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(QuarterNumber.Invalid);
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <UnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <CalendarUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <FiscalUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <GenericUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAMonth>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAQuarter>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAYear>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IAmBoundedTime>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IAmUnboundedTime>();
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericMonth(year, A.Dummy <MonthNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericYear(year);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalMonth(year, A.Dummy <MonthNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalYear(year);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
while (true)
{
try
{
var date = A.Dummy <DateTime>();
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarDay(year, (MonthOfYear)date.Month, (DayOfMonth)date.Day);
return(result);
}
catch (ArgumentException)
{
}
}
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarMonth(year, A.Dummy <MonthOfYear>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarYear(year);
return(result);
});
// ------------------------------------------------------------------------------------
// ------------------------------ reporting period -----------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ReportingPeriodComponent.Invalid);
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(GenericReportingPeriod), typeof(FiscalReportingPeriod), typeof(CalendarReportingPeriod) };
var result = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
return(result);
});
// ------------------------------------------------------------------------------------
// ------------------------------------- unit ----------------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(UnitOfTimeKind.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(UnitOfTimeGranularity.Invalid);
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var unitOfTime = A.Dummy <UnitOfTime>().ThatIs(_ => !(_ is IAmUnboundedTime));
var result = new Unit(unitOfTime.UnitOfTimeKind, unitOfTime.UnitOfTimeGranularity);
return(result);
});
// ------------------------------------------------------------------------------------
// -------------------------- reporting period wrappers ------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <GenericMonth>();
var end = A.Dummy <GenericMonth>();
var result = end >= start
? new GenericMonthReportingPeriod(start, end)
: new GenericMonthReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <GenericQuarter>();
var end = A.Dummy <GenericQuarter>();
var result = end >= start
? new GenericQuarterReportingPeriod(start, end)
: new GenericQuarterReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <GenericYear>();
var end = A.Dummy <GenericYear>();
var result = end >= start
? new GenericYearReportingPeriod(start, end)
: new GenericYearReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <FiscalMonth>();
var end = A.Dummy <FiscalMonth>();
var result = end >= start
? new FiscalMonthReportingPeriod(start, end)
: new FiscalMonthReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <FiscalQuarter>();
var end = A.Dummy <FiscalQuarter>();
var result = end >= start
? new FiscalQuarterReportingPeriod(start, end)
: new FiscalQuarterReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <FiscalYear>();
var end = A.Dummy <FiscalYear>();
var result = end >= start
? new FiscalYearReportingPeriod(start, end)
: new FiscalYearReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <CalendarDay>();
var end = A.Dummy <CalendarDay>();
var result = end >= start
? new CalendarDayReportingPeriod(start, end)
: new CalendarDayReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <CalendarMonth>();
var end = A.Dummy <CalendarMonth>();
var result = end >= start
? new CalendarMonthReportingPeriod(start, end)
: new CalendarMonthReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <CalendarQuarter>();
var end = A.Dummy <CalendarQuarter>();
var result = end >= start
? new CalendarQuarterReportingPeriod(start, end)
: new CalendarQuarterReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <CalendarYear>();
var end = A.Dummy <CalendarYear>();
var result = end >= start
? new CalendarYearReportingPeriod(start, end)
: new CalendarYearReportingPeriod(end, start);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(BoundedGenericReportingPeriod), typeof(BoundedFiscalReportingPeriod), typeof(BoundedCalendarReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new BoundedReportingPeriod(reportingPeriod.Start, reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(GenericMonthReportingPeriod), typeof(GenericQuarterReportingPeriod), typeof(GenericYearReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new BoundedGenericReportingPeriod((GenericUnitOfTime)reportingPeriod.Start, (GenericUnitOfTime)reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(FiscalMonthReportingPeriod), typeof(FiscalQuarterReportingPeriod), typeof(FiscalYearReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new BoundedFiscalReportingPeriod((FiscalUnitOfTime)reportingPeriod.Start, (FiscalUnitOfTime)reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(CalendarDayReportingPeriod), typeof(CalendarMonthReportingPeriod), typeof(CalendarQuarterReportingPeriod), typeof(CalendarYearReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new BoundedCalendarReportingPeriod((CalendarUnitOfTime)reportingPeriod.Start, (CalendarUnitOfTime)reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var boundedReportingPeriod = A.Dummy <BoundedGenericReportingPeriod>().ReportingPeriod;
var result = ThreadSafeRandom.Next(0, 2) == 0
? new SemiBoundedGenericReportingPeriod((GenericUnitOfTime)boundedReportingPeriod.Start, new GenericUnbounded())
: new SemiBoundedGenericReportingPeriod(new GenericUnbounded(), (GenericUnitOfTime)boundedReportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var boundedReportingPeriod = A.Dummy <BoundedFiscalReportingPeriod>().ReportingPeriod;
var result = ThreadSafeRandom.Next(0, 2) == 0
? new SemiBoundedFiscalReportingPeriod((FiscalUnitOfTime)boundedReportingPeriod.Start, new FiscalUnbounded())
: new SemiBoundedFiscalReportingPeriod(new FiscalUnbounded(), (FiscalUnitOfTime)boundedReportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var boundedReportingPeriod = A.Dummy <BoundedCalendarReportingPeriod>().ReportingPeriod;
var result = ThreadSafeRandom.Next(0, 2) == 0
? new SemiBoundedCalendarReportingPeriod((CalendarUnitOfTime)boundedReportingPeriod.Start, new CalendarUnbounded())
: new SemiBoundedCalendarReportingPeriod(new CalendarUnbounded(), (CalendarUnitOfTime)boundedReportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(GenericUnboundedReportingPeriod), typeof(SemiBoundedGenericReportingPeriod), typeof(BoundedGenericReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new GenericReportingPeriod((GenericUnitOfTime)reportingPeriod.Start, (GenericUnitOfTime)reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(FiscalUnboundedReportingPeriod), typeof(SemiBoundedFiscalReportingPeriod), typeof(BoundedFiscalReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new FiscalReportingPeriod((FiscalUnitOfTime)reportingPeriod.Start, (FiscalUnitOfTime)reportingPeriod.End);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var potentialTypes = new[] { typeof(CalendarUnboundedReportingPeriod), typeof(SemiBoundedCalendarReportingPeriod), typeof(BoundedCalendarReportingPeriod) };
var reportingPeriod = GetRandomReportingPeriodWrapper(potentialTypes).ReportingPeriod;
var result = new CalendarReportingPeriod((CalendarUnitOfTime)reportingPeriod.Start, (CalendarUnitOfTime)reportingPeriod.End);
return(result);
});
// ------------------------------------------------------------------------------------
// ------------------------------------ cutoff ---------------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new RelativeCutoff(A.Dummy <Duration>(), A.Dummy <ReportingPeriodComponent>().ThatIsIn(new[] { ReportingPeriodComponent.Start, ReportingPeriodComponent.End }));
return(result);
});
// ------------------------------------------------------------------------------------
// ---------------------------------- timeseries -------------------------------------
// ------------------------------------------------------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = (IDatapoint)A.Dummy <Datapoint <Version> >();
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = (ITimeseries)A.Dummy <Timeseries <Version> >();
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = GetDummyTimeseries <Version>();
return(result);
});
}
public async Task <TimeTreeReference> Get(DateTimeOffset date)
{
// Create year (link if possible)
var yearId = await GetYearIdentifierAsync(date, true).ConfigureAwait(false);
var prevYearId = await GetYearIdentifierAsync(date.AddYears(-1), false).ConfigureAwait(false);
var nextYearId = await GetYearIdentifierAsync(date.AddYears(1), false).ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Year", prevYearId,
"PREV", "Year", yearId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Year", yearId,
"PREV", "Year", nextYearId)
.ConfigureAwait(false);
if (_configuration.Specificity == TimeTreeSpecificity.Years)
{
return(new TimeTreeReference("Year", yearId));
}
// Create quarter
var quarter = new CalendarQuarter(date);
var quarterId = await GetQuarterIdentifierAsync(quarter, true).ConfigureAwait(false);
var prevQuarterId = await GetQuarterIdentifierAsync(quarter.Previous, false).ConfigureAwait(false);
var nextQuarterId = await GetQuarterIdentifierAsync(quarter.Next, false).ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Quarter", prevQuarterId,
"PREV", "Quarter", quarterId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Quarter", quarterId,
"PREV", "Quarter", nextQuarterId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"CHILD_QUARTER", "Year", yearId,
"PARENT_YEAR", "Quarter", quarterId)
.ConfigureAwait(false);
if (_configuration.Specificity == TimeTreeSpecificity.Quarters)
{
return(new TimeTreeReference("Quarter", quarterId));
}
// Create month
var monthId = await GetMonthIdentifierAsync(date, true).ConfigureAwait(false);
var prevMonthId = await GetMonthIdentifierAsync(date.AddMonths(-1), false).ConfigureAwait(false);
var nextMonthId = await GetMonthIdentifierAsync(date.AddMonths(1), false).ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Month", prevMonthId,
"PREV", "Month", monthId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Month", monthId,
"PREV", "Month", nextMonthId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"CHILD_MONTH", "Year", yearId,
"PARENT_YEAR", "Month", monthId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"CHILD_MONTH", "Quarter", quarterId,
"PARENT_QUARTER", "Month", monthId)
.ConfigureAwait(false);
if (_configuration.Specificity == TimeTreeSpecificity.Months)
{
return(new TimeTreeReference("Month", monthId));
}
// Create week
var week = new CalendarWeek(date, _configuration.FirstDayOfWeek);
var weekId = await GetWeekIdentifierAsync(week, true).ConfigureAwait(false);
var prevWeekId = await GetWeekIdentifierAsync(week.Previous, false).ConfigureAwait(false);
var nextWeekId = await GetWeekIdentifierAsync(week.Next, false).ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Week", prevWeekId,
"PREV", "Week", weekId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Week", weekId,
"PREV", "Week", nextWeekId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"CHILD_WEEK", "Year", yearId,
"PARENT_YEAR", "Week", weekId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"CHILD_WEEK", "Quarter", quarterId,
"PARENT_QUARTER", "Week", weekId)
.ConfigureAwait(false);
if (_configuration.Specificity == TimeTreeSpecificity.Weeks)
{
return(new TimeTreeReference("Week", weekId));
}
// Create day
var dayId = await GetDayIdentifierAsync(date, true).ConfigureAwait(false);
var prevDayId = await GetDayIdentifierAsync(date.AddDays(-1), false).ConfigureAwait(false);
var nextDayId = await GetDayIdentifierAsync(date.AddDays(1), false).ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Day", prevDayId,
"PREV", "Day", weekId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Day", weekId,
"PREV", "Day", nextDayId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"CHILD_DAY", "Month", quarterId,
"PARENT_MONTH", "Day", dayId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"CHILD_DAY", "Week", weekId,
"PARENT_WEEK", "Day", dayId)
.ConfigureAwait(false);
if (_configuration.Specificity == TimeTreeSpecificity.Days)
{
return(new TimeTreeReference("Day", dayId));
}
// Create hour
var hourId = await GetHourIdentifierAsync(date, true).ConfigureAwait(false);
var prevHourId = await GetHourIdentifierAsync(date.AddHours(-1), false).ConfigureAwait(false);
var nextHourId = await GetHourIdentifierAsync(date.AddHours(1), false).ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Hour", prevHourId,
"PREV", "Hour", hourId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Hour", hourId,
"PREV", "Hour", nextHourId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"CHILD_HOUR", "Day", dayId,
"PARENT_DAY", "Hour", hourId)
.ConfigureAwait(false);
if (_configuration.Specificity == TimeTreeSpecificity.Hours)
{
return(new TimeTreeReference("Hour", hourId));
}
// Create minute
var minuteId = await GetMinuteIdentifierAsync(date, true).ConfigureAwait(false);
var prevMinuteId = await GetMinuteIdentifierAsync(date.AddMinutes(-1), false).ConfigureAwait(false);
var nextMinuteId = await GetMinuteIdentifierAsync(date.AddMinutes(1), false).ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Minute", prevMinuteId,
"PREV", "Minute", minuteId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Minute", minuteId,
"PREV", "Minute", nextMinuteId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"CHILD_MINUTE", "Minute", hourId,
"PARENT_HOUR", "Hour", minuteId)
.ConfigureAwait(false);
if (_configuration.Specificity == TimeTreeSpecificity.Minutes)
{
return(new TimeTreeReference("Minute", minuteId));
}
// Create second
var secondId = await GetSecondIdentifierAsync(date, true).ConfigureAwait(false);
var prevSecondId = await GetSecondIdentifierAsync(date.AddSeconds(-1), false).ConfigureAwait(false);
var nextSecondId = await GetSecondIdentifierAsync(date.AddSeconds(1), false).ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Second", prevSecondId,
"PREV", "Second", secondId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"NEXT", "Second", secondId,
"PREV", "Second", nextSecondId)
.ConfigureAwait(false);
await CreateLinkIfNotExistsAsync(
"CHILD_SECOND", "Second", minuteId,
"PARENT_MINUTE", "Minute", secondId)
.ConfigureAwait(false);
return(new TimeTreeReference("Second", secondId));
}
/// <summary>
/// Initializes a new instance of the <see cref="CalendarQuarterReportingPeriod"/> class.
/// </summary>
/// <param name="start">The start of the reporting period.</param>
/// <param name="end">The end of the reporting period.</param>
public CalendarQuarterReportingPeriod(
CalendarQuarter start,
CalendarQuarter end)
: base(start, end)
{
}
public AccountingTimeDummyFactory()
{
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(DayOfMonth.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MonthNumber.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MonthOfYear.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(QuarterNumber.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(UnitOfTimeKind.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(UnitOfTimeGranularity.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ReportingPeriodComponent.Invalid);
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <UnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <CalendarUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <FiscalUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <GenericUnitOfTime>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAMonth>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAQuarter>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IHaveAYear>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IAmBoundedTime>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IAmUnboundedTime>();
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericMonth(year, A.Dummy <MonthNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new GenericYear(year);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalMonth(year, A.Dummy <MonthNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new FiscalYear(year);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
while (true)
{
try
{
var date = A.Dummy <DateTime>();
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarDay(year, (MonthOfYear)date.Month, (DayOfMonth)date.Day);
return(result);
}
catch (ArgumentException)
{
}
}
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarMonth(year, A.Dummy <MonthOfYear>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarQuarter(year, A.Dummy <QuarterNumber>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var year = ThreadSafeRandom.Next(MinYear, MaxYear + 1);
var result = new CalendarYear(year);
return(result);
});
AddDummyCreatorForAbstractReportingPeriod <UnitOfTime>();
AddDummyCreatorForAbstractReportingPeriod <CalendarUnitOfTime>();
AddDummyCreatorForAbstractReportingPeriod <FiscalUnitOfTime>();
AddDummyCreatorForAbstractReportingPeriod <GenericUnitOfTime>();
AddDummyCreatorForConcreteReportingPeriod <CalendarDay>();
AddDummyCreatorForConcreteReportingPeriod <CalendarQuarter>();
AddDummyCreatorForConcreteReportingPeriod <CalendarMonth>();
AddDummyCreatorForConcreteReportingPeriod <CalendarYear>();
AddDummyCreatorForConcreteReportingPeriod <CalendarUnbounded>();
AddDummyCreatorForConcreteReportingPeriod <FiscalMonth>();
AddDummyCreatorForConcreteReportingPeriod <FiscalQuarter>();
AddDummyCreatorForConcreteReportingPeriod <FiscalYear>();
AddDummyCreatorForConcreteReportingPeriod <FiscalUnbounded>();
AddDummyCreatorForConcreteReportingPeriod <GenericMonth>();
AddDummyCreatorForConcreteReportingPeriod <GenericQuarter>();
AddDummyCreatorForConcreteReportingPeriod <GenericYear>();
AddDummyCreatorForConcreteReportingPeriod <GenericUnbounded>();
}
