public static void LastMonthInFiscalYear___Should_return_same_lastMonthInFiscalYear_passed_to_constructor___When_getting()
{
// Arrange
var expectedMonth = A.Dummy <MonthOfYear>().ThatIsNot(MonthOfYear.December);
var systemUnderTest = new FiscalYearAccountingPeriodSystem(expectedMonth);
// Act
var actualMonth = systemUnderTest.LastMonthInFiscalYear;
// Assert
actualMonth.Should().Be(expectedMonth);
}
public static void Deserialize___Should_return_equivalent_object_of_type_FiscalYearAccountingPeriodSystem___When_an_object_of_that_type_is_serialized_to_json_and_deserialized_as_AccountingPeriodSystem()
{
// Arrange
var serializer = new NaosJsonSerializer();
var expectedAccountingPeriodSystem = new FiscalYearAccountingPeriodSystem(A.Dummy <MonthOfYear>().ThatIsNot(MonthOfYear.December));
var serializedJsonBytes = serializer.SerializeToBytes(expectedAccountingPeriodSystem);
var serializedJsonString = serializer.SerializeToString(expectedAccountingPeriodSystem);
// Act
var systemUnderTest1 = serializer.Deserialize <AccountingPeriodSystem>(serializedJsonBytes) as FiscalYearAccountingPeriodSystem;
var systemUnderTest2 = serializer.Deserialize <AccountingPeriodSystem>(serializedJsonString) as FiscalYearAccountingPeriodSystem;
// Assert
systemUnderTest1.Should().NotBeNull();
systemUnderTest1.LastMonthInFiscalYear.Should().Be(expectedAccountingPeriodSystem.LastMonthInFiscalYear);
systemUnderTest2.Should().NotBeNull();
systemUnderTest2.LastMonthInFiscalYear.Should().Be(expectedAccountingPeriodSystem.LastMonthInFiscalYear);
}
public static void GetReportingPeriodForFiscalYear___Should_return_reporting_period_beginning_first_of_the_month_after_LastMonthInFiscalYear_in_the_prior_year_and_ending_last_day_of_LastMonthInFiscalYear___When_called()
{
// Arrange
var nonLeapYear = A.Dummy <DateTime>().ThatIs(_ => !DateTime.IsLeapYear(_.Year)).Year;
var leapYear = A.Dummy <DateTime>().ThatIs(_ => DateTime.IsLeapYear(_.Year)).Year;
var systemUnderTest1 = new FiscalYearAccountingPeriodSystem(MonthOfYear.January);
var systemUnderTest2 = new FiscalYearAccountingPeriodSystem(MonthOfYear.February);
var systemUnderTest3 = new FiscalYearAccountingPeriodSystem(MonthOfYear.March);
var systemUnderTest4 = new FiscalYearAccountingPeriodSystem(MonthOfYear.April);
var systemUnderTest5 = new FiscalYearAccountingPeriodSystem(MonthOfYear.May);
var systemUnderTest6 = new FiscalYearAccountingPeriodSystem(MonthOfYear.June);
var systemUnderTest7 = new FiscalYearAccountingPeriodSystem(MonthOfYear.July);
var systemUnderTest8 = new FiscalYearAccountingPeriodSystem(MonthOfYear.August);
var systemUnderTest9 = new FiscalYearAccountingPeriodSystem(MonthOfYear.September);
var systemUnderTest10 = new FiscalYearAccountingPeriodSystem(MonthOfYear.October);
var systemUnderTest11 = new FiscalYearAccountingPeriodSystem(MonthOfYear.November);
var expectedReportingPeriod1NonLeapYear = new ReportingPeriod(1.February(nonLeapYear - 1).ToCalendarDay(), 31.January(nonLeapYear).ToCalendarDay());
var expectedReportingPeriod2NonLeapYear = new ReportingPeriod(1.March(nonLeapYear - 1).ToCalendarDay(), 28.February(nonLeapYear).ToCalendarDay());
var expectedReportingPeriod3NonLeapYear = new ReportingPeriod(1.April(nonLeapYear - 1).ToCalendarDay(), 31.March(nonLeapYear).ToCalendarDay());
var expectedReportingPeriod4NonLeapYear = new ReportingPeriod(1.May(nonLeapYear - 1).ToCalendarDay(), 30.April(nonLeapYear).ToCalendarDay());
var expectedReportingPeriod5NonLeapYear = new ReportingPeriod(1.June(nonLeapYear - 1).ToCalendarDay(), 31.May(nonLeapYear).ToCalendarDay());
var expectedReportingPeriod6NonLeapYear = new ReportingPeriod(1.July(nonLeapYear - 1).ToCalendarDay(), 30.June(nonLeapYear).ToCalendarDay());
var expectedReportingPeriod7NonLeapYear = new ReportingPeriod(1.August(nonLeapYear - 1).ToCalendarDay(), 31.July(nonLeapYear).ToCalendarDay());
var expectedReportingPeriod8NonLeapYear = new ReportingPeriod(1.September(nonLeapYear - 1).ToCalendarDay(), 31.August(nonLeapYear).ToCalendarDay());
var expectedReportingPeriod9NonLeapYear = new ReportingPeriod(1.October(nonLeapYear - 1).ToCalendarDay(), 30.September(nonLeapYear).ToCalendarDay());
var expectedReportingPeriod10NonLeapYear = new ReportingPeriod(1.November(nonLeapYear - 1).ToCalendarDay(), 31.October(nonLeapYear).ToCalendarDay());
var expectedReportingPeriod11NonLeapYear = new ReportingPeriod(1.December(nonLeapYear - 1).ToCalendarDay(), 30.November(nonLeapYear).ToCalendarDay());
var expectedReportingPeriod1LeapYear = new ReportingPeriod(1.February(leapYear - 1).ToCalendarDay(), 31.January(leapYear).ToCalendarDay());
var expectedReportingPeriod2LeapYear = new ReportingPeriod(1.March(leapYear - 1).ToCalendarDay(), 29.February(leapYear).ToCalendarDay());
var expectedReportingPeriod3LeapYear = new ReportingPeriod(1.April(leapYear - 1).ToCalendarDay(), 31.March(leapYear).ToCalendarDay());
var expectedReportingPeriod4LeapYear = new ReportingPeriod(1.May(leapYear - 1).ToCalendarDay(), 30.April(leapYear).ToCalendarDay());
var expectedReportingPeriod5LeapYear = new ReportingPeriod(1.June(leapYear - 1).ToCalendarDay(), 31.May(leapYear).ToCalendarDay());
var expectedReportingPeriod6LeapYear = new ReportingPeriod(1.July(leapYear - 1).ToCalendarDay(), 30.June(leapYear).ToCalendarDay());
var expectedReportingPeriod7LeapYear = new ReportingPeriod(1.August(leapYear - 1).ToCalendarDay(), 31.July(leapYear).ToCalendarDay());
var expectedReportingPeriod8LeapYear = new ReportingPeriod(1.September(leapYear - 1).ToCalendarDay(), 31.August(leapYear).ToCalendarDay());
var expectedReportingPeriod9LeapYear = new ReportingPeriod(1.October(leapYear - 1).ToCalendarDay(), 30.September(leapYear).ToCalendarDay());
var expectedReportingPeriod10LeapYear = new ReportingPeriod(1.November(leapYear - 1).ToCalendarDay(), 31.October(leapYear).ToCalendarDay());
var expectedReportingPeriod11LeapYear = new ReportingPeriod(1.December(leapYear - 1).ToCalendarDay(), 30.November(leapYear).ToCalendarDay());
// Act
var actualReportingPeriod1NonLeapYear = systemUnderTest1.GetReportingPeriodForFiscalYear(new FiscalYear(nonLeapYear));
var actualReportingPeriod2NonLeapYear = systemUnderTest2.GetReportingPeriodForFiscalYear(new FiscalYear(nonLeapYear));
var actualReportingPeriod3NonLeapYear = systemUnderTest3.GetReportingPeriodForFiscalYear(new FiscalYear(nonLeapYear));
var actualReportingPeriod4NonLeapYear = systemUnderTest4.GetReportingPeriodForFiscalYear(new FiscalYear(nonLeapYear));
var actualReportingPeriod5NonLeapYear = systemUnderTest5.GetReportingPeriodForFiscalYear(new FiscalYear(nonLeapYear));
var actualReportingPeriod6NonLeapYear = systemUnderTest6.GetReportingPeriodForFiscalYear(new FiscalYear(nonLeapYear));
var actualReportingPeriod7NonLeapYear = systemUnderTest7.GetReportingPeriodForFiscalYear(new FiscalYear(nonLeapYear));
var actualReportingPeriod8NonLeapYear = systemUnderTest8.GetReportingPeriodForFiscalYear(new FiscalYear(nonLeapYear));
var actualReportingPeriod9NonLeapYear = systemUnderTest9.GetReportingPeriodForFiscalYear(new FiscalYear(nonLeapYear));
var actualReportingPeriod10NonLeapYear = systemUnderTest10.GetReportingPeriodForFiscalYear(new FiscalYear(nonLeapYear));
var actualReportingPeriod11NonLeapYear = systemUnderTest11.GetReportingPeriodForFiscalYear(new FiscalYear(nonLeapYear));
var actualReportingPeriod1LeapYear = systemUnderTest1.GetReportingPeriodForFiscalYear(new FiscalYear(leapYear));
var actualReportingPeriod2LeapYear = systemUnderTest2.GetReportingPeriodForFiscalYear(new FiscalYear(leapYear));
var actualReportingPeriod3LeapYear = systemUnderTest3.GetReportingPeriodForFiscalYear(new FiscalYear(leapYear));
var actualReportingPeriod4LeapYear = systemUnderTest4.GetReportingPeriodForFiscalYear(new FiscalYear(leapYear));
var actualReportingPeriod5LeapYear = systemUnderTest5.GetReportingPeriodForFiscalYear(new FiscalYear(leapYear));
var actualReportingPeriod6LeapYear = systemUnderTest6.GetReportingPeriodForFiscalYear(new FiscalYear(leapYear));
var actualReportingPeriod7LeapYear = systemUnderTest7.GetReportingPeriodForFiscalYear(new FiscalYear(leapYear));
var actualReportingPeriod8LeapYear = systemUnderTest8.GetReportingPeriodForFiscalYear(new FiscalYear(leapYear));
var actualReportingPeriod9LeapYear = systemUnderTest9.GetReportingPeriodForFiscalYear(new FiscalYear(leapYear));
var actualReportingPeriod10LeapYear = systemUnderTest10.GetReportingPeriodForFiscalYear(new FiscalYear(leapYear));
var actualReportingPeriod11LeapYear = systemUnderTest11.GetReportingPeriodForFiscalYear(new FiscalYear(leapYear));
// Assert
actualReportingPeriod1NonLeapYear.Should().Be(expectedReportingPeriod1NonLeapYear);
actualReportingPeriod2NonLeapYear.Should().Be(expectedReportingPeriod2NonLeapYear);
actualReportingPeriod3NonLeapYear.Should().Be(expectedReportingPeriod3NonLeapYear);
actualReportingPeriod4NonLeapYear.Should().Be(expectedReportingPeriod4NonLeapYear);
actualReportingPeriod5NonLeapYear.Should().Be(expectedReportingPeriod5NonLeapYear);
actualReportingPeriod6NonLeapYear.Should().Be(expectedReportingPeriod6NonLeapYear);
actualReportingPeriod7NonLeapYear.Should().Be(expectedReportingPeriod7NonLeapYear);
actualReportingPeriod8NonLeapYear.Should().Be(expectedReportingPeriod8NonLeapYear);
actualReportingPeriod9NonLeapYear.Should().Be(expectedReportingPeriod9NonLeapYear);
actualReportingPeriod10NonLeapYear.Should().Be(expectedReportingPeriod10NonLeapYear);
actualReportingPeriod11NonLeapYear.Should().Be(expectedReportingPeriod11NonLeapYear);
actualReportingPeriod1LeapYear.Should().Be(expectedReportingPeriod1LeapYear);
actualReportingPeriod2LeapYear.Should().Be(expectedReportingPeriod2LeapYear);
actualReportingPeriod3LeapYear.Should().Be(expectedReportingPeriod3LeapYear);
actualReportingPeriod4LeapYear.Should().Be(expectedReportingPeriod4LeapYear);
actualReportingPeriod5LeapYear.Should().Be(expectedReportingPeriod5LeapYear);
actualReportingPeriod6LeapYear.Should().Be(expectedReportingPeriod6LeapYear);
actualReportingPeriod7LeapYear.Should().Be(expectedReportingPeriod7LeapYear);
actualReportingPeriod8LeapYear.Should().Be(expectedReportingPeriod8LeapYear);
actualReportingPeriod9LeapYear.Should().Be(expectedReportingPeriod9LeapYear);
actualReportingPeriod10LeapYear.Should().Be(expectedReportingPeriod10LeapYear);
actualReportingPeriod11LeapYear.Should().Be(expectedReportingPeriod11LeapYear);
}
/// <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);
});
}
