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