private static GenericYear TweakYear(this GenericYear genericYear) { var tweakedYear = A.Dummy <PositiveInteger>().ThatIs(y => y != genericYear.Year && y <= 9999); var result = new GenericYear(tweakedYear); return(result); }
private static GenericYear TweakBy( this GenericYear genericYear, int amount) { var result = new GenericYear(genericYear.Year + amount); return(result); }
public static void ToString___Should_return_friendly_string_representation_of_object___When_called() { // Arrange var systemUnderTest = new GenericYear(2017); // Act var toString = systemUnderTest.ToString(); // Assert toString.Should().Be("2017"); }
public static void LessThanOperator___Should_return_false___When_left_side_of_operator_is_equal_to_right_side() { // Arrange var systemUnderTest1 = A.Dummy <GenericYear>(); var systemUnderTest2 = new GenericYear(systemUnderTest1.Year); // Act var result = systemUnderTest1 < systemUnderTest2; // Assert result.Should().BeFalse(); }
public static void LessThanOperator___Should_return_false___When_both_sides_of_operator_are_null() { // Arrange GenericYear systemUnderTest1 = null; GenericYear 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 <GenericYear>(); var systemUnderTest2 = new GenericYear(systemUnderTest1.Year); // 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 <GenericYear>(); var systemUnderTest2 = new GenericYear(systemUnderTest1.Year); // Act var result = systemUnderTest1 != systemUnderTest2; // Assert result.Should().BeFalse(); }
public static void GetHashCode___Should_not_be_equal_for_two_UnitOfKind_objects___When_they_are_of_different_kinds_but_have_the_same_granularity_and_same_property_values() { // Arrange var calendarUnbounded = A.Dummy <CalendarUnbounded>(); var fiscalUnbounded = new FiscalUnbounded(); var genericUnbounded = new GenericUnbounded(); var calendarYear = A.Dummy <CalendarYear>(); var fiscalYear = new FiscalYear(calendarYear.Year); var genericYear = new GenericYear(calendarYear.Year); var calendarQuarter = A.Dummy <CalendarQuarter>(); var fiscalQuarter = new FiscalQuarter(calendarQuarter.Year, calendarQuarter.QuarterNumber); var genericQuarter = new GenericQuarter(calendarQuarter.Year, calendarQuarter.QuarterNumber); var calendarMonth = A.Dummy <CalendarMonth>(); var fiscalMonth = new FiscalMonth(calendarMonth.Year, calendarMonth.MonthNumber); var genericMonth = new GenericMonth(calendarMonth.Year, calendarMonth.MonthNumber); // Act var calendarUnboundedHashCode = calendarUnbounded.GetHashCode(); var fiscalUnboundedHashCode = fiscalUnbounded.GetHashCode(); var genericUnboundedHashCode = genericUnbounded.GetHashCode(); var calendarYearHashCode = calendarYear.GetHashCode(); var fiscalYearHashCode = fiscalYear.GetHashCode(); var genericYearHashCode = genericYear.GetHashCode(); var calendarQuarterHashCode = calendarQuarter.GetHashCode(); var fiscalQuarterHashCode = fiscalQuarter.GetHashCode(); var genericQuarterHashCode = genericQuarter.GetHashCode(); var calendarMonthHashCode = calendarMonth.GetHashCode(); var fiscalMonthHashCode = fiscalMonth.GetHashCode(); var genericMonthHashCode = genericMonth.GetHashCode(); // Assert calendarUnboundedHashCode.Should().NotBe(fiscalUnboundedHashCode); calendarUnboundedHashCode.Should().NotBe(genericUnboundedHashCode); fiscalUnboundedHashCode.Should().NotBe(genericUnboundedHashCode); calendarYearHashCode.Should().NotBe(fiscalYearHashCode); calendarYearHashCode.Should().NotBe(genericYearHashCode); fiscalYearHashCode.Should().NotBe(genericYearHashCode); calendarQuarterHashCode.Should().NotBe(fiscalQuarterHashCode); calendarQuarterHashCode.Should().NotBe(genericQuarterHashCode); fiscalQuarterHashCode.Should().NotBe(genericQuarterHashCode); calendarMonthHashCode.Should().NotBe(fiscalMonthHashCode); calendarMonthHashCode.Should().NotBe(genericMonthHashCode); fiscalMonthHashCode.Should().NotBe(genericMonthHashCode); }
public static void GreaterThanOperator___Should_return_true___When_left_side_of_operator_is_not_null_and_right_side_is_null() { // Arrange var systemUnderTest1 = A.Dummy <GenericYear>(); GenericYear systemUnderTest2 = null; // Act var result = systemUnderTest1 > systemUnderTest2; // Assert result.Should().BeTrue(); }
public static void GreaterThanOrEqualToOperator___Should_return_true___When_both_sides_of_operator_are_null() { // Arrange GenericYear systemUnderTest1 = null; GenericYear systemUnderTest2 = null; // Act var result = systemUnderTest1 >= systemUnderTest2; // Assert result.Should().BeTrue(); }
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 <GenericYear>(); var systemUnderTest2 = new GenericYear(systemUnderTest1.Year); // Act var result = systemUnderTest1.CompareTo((object)systemUnderTest2); // Assert result.Should().Be(0); }
public static void CompareTo___Should_throw_ArgumentException___When_calling_non_typed_overload_and_other_object_is_null() { // Arrange var systemUnderTest1 = A.Dummy <GenericYear>(); GenericYear systemUnderTest2 = null; // Act var ex = Record.Exception(() => systemUnderTest1.CompareTo((object)systemUnderTest2)); // Assert ex.Should().BeOfType <ArgumentException>(); }
public static void GreaterThanOrEqualToOperator___Should_return_true___When_left_side_of_operator_is_equal_to_right_side() { // Arrange var systemUnderTest1 = A.Dummy <GenericYear>(); var systemUnderTest2 = new GenericYear(systemUnderTest1.Year); // Act var result = systemUnderTest1 >= systemUnderTest2; // Assert result.Should().BeTrue(); }
public static void GreaterThanOrEqualToOperator___Should_return_false___When_left_side_of_operator_is_null_and_right_side_is_not_null() { // Arrange GenericYear systemUnderTest1 = null; var systemUnderTest2 = A.Dummy <GenericYear>(); // Act var result = systemUnderTest1 >= systemUnderTest2; // Assert result.Should().BeFalse(); }
public static void Year___Should_return_same_year_passed_to_constructor___When_getting() { // Arrange var validYear = A.Dummy <GenericYear>(); var year = validYear.Year; var systemUnderTest = new GenericYear(year); // Act var actualYear = systemUnderTest.Year; // Assert actualYear.Should().Be(year); }
public static void GetHashCode___Should_be_equal_for_two_GenericYears___When_both_objects_have_the_same_property_values() { // Arrange var systemUnderTest1 = A.Dummy <GenericYear>(); var systemUnderTest2 = new GenericYear(systemUnderTest1.Year); // Act var hash1 = systemUnderTest1.GetHashCode(); var hash2 = systemUnderTest2.GetHashCode(); // Assert hash1.Should().Be(hash2); }
public static void EqualsOperator___Should_return_false___When_one_side_of_operator_is_null_and_the_other_side_is_not_null() { // Arrange GenericYear systemUnderTest1 = null; var systemUnderTest2 = A.Dummy <GenericYear>(); // Act var result1 = systemUnderTest1 == systemUnderTest2; var result2 = systemUnderTest2 == systemUnderTest1; // Assert result1.Should().BeFalse(); result2.Should().BeFalse(); }
public static void GetUnitsToDate___Should_return_list_with_only_lastUnitOfTimeInYear___When_lastUnitOfTimeInYear_is_of_type_GenericYear() { // Arrange var lastUnitOfTimeInYear = new GenericYear(2016); var expectedUnitsToDate = new List <GenericYear> { lastUnitOfTimeInYear }; // Act var actualUnitsToDate = lastUnitOfTimeInYear.GetUnitsToDate(); // Assert actualUnitsToDate.Should().Equal(expectedUnitsToDate); }
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>(); }
/// <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); }); }
/// <summary> /// Initializes a new instance of the <see cref="GenericYearReportingPeriod"/> class. /// </summary> /// <param name="start">The start of the reporting period.</param> /// <param name="end">The end of the reporting period.</param> public GenericYearReportingPeriod( GenericYear start, GenericYear end) : base(start, end) { }