/// <summary>
/// WA DNR fiscal year boundary is June 30th.
/// </summary>
/// <param name="qtr"></param>
/// <param name="calendarYear"></param>
/// <returns></returns>
public static DateTime GetFirstDateInFiscalQuarter(FiscalQuarter qtr, int calendarYear)
{
if (qtr == FiscalQuarter.First)
{
// 1st FiscalQuarter = July 1 to Sept 30
return(new DateTime(calendarYear, 7, 1));
}
if (qtr == FiscalQuarter.Second)
{
// 2nd FiscalQuarter = October 1 to December 31
return(new DateTime(calendarYear, 10, 1));
}
if (qtr == FiscalQuarter.Third)
{
// 3rd FiscalQuarter = January 1 to March 31
return(new DateTime(calendarYear, 1, 1));
}
if (qtr == FiscalQuarter.Fourth)
{
// 4th FiscalQuarter = April 1 to June 30
return(new DateTime(calendarYear, 4, 1));
}
throw new InvalidDataException($"Unknown FiscalQuarter: {qtr.ToString()}");
}
private static FiscalQuarter TweakBy(
this FiscalQuarter fiscalQuarter,
int amount,
FiscalQuarterComponent componentToTweak)
{
if (componentToTweak == FiscalQuarterComponent.Quarter)
{
var referenceMonth = new DateTime(fiscalQuarter.Year, (int)fiscalQuarter.QuarterNumber * 3, 1);
var updatedMonth = referenceMonth.AddMonths(amount * 3);
var result = new FiscalQuarter(updatedMonth.Year, (QuarterNumber)(updatedMonth.Month / 3));
return(result);
}
if (componentToTweak == FiscalQuarterComponent.Year)
{
var result = new FiscalQuarter(fiscalQuarter.Year + amount, fiscalQuarter.QuarterNumber);
return(result);
}
throw new NotSupportedException("this fiscal quarter component is not supported: " + componentToTweak);
}
public static void GetUnitsToDate___Should_return_all_quarters_from_1Q_to_lastUnitOfTimeInYear___When_lastUnitOfTimeInYear_is_of_type_FiscalQuarter()
{
// Arrange
var lastUnitOfTimeInYear1 = new FiscalQuarter(2016, QuarterNumber.Q1);
var lastUnitOfTimeInYear2 = new FiscalQuarter(2016, QuarterNumber.Q2);
var lastUnitOfTimeInYear3 = new FiscalQuarter(2016, QuarterNumber.Q3);
var lastUnitOfTimeInYear4 = new FiscalQuarter(2016, QuarterNumber.Q4);
var expectedUnitsToDate1 = new List <FiscalQuarter> {
lastUnitOfTimeInYear1
};
var expectedUnitsToDate2 = new List <FiscalQuarter> {
lastUnitOfTimeInYear1, lastUnitOfTimeInYear2
};
var expectedUnitsToDate3 = new List <FiscalQuarter> {
lastUnitOfTimeInYear1, lastUnitOfTimeInYear2, lastUnitOfTimeInYear3
};
var expectedUnitsToDate4 = new List <FiscalQuarter> {
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);
}
public static FiscalQuarter GetFiscalQuarterPreviousToFiscalQuarter(this FiscalQuarter givenFiscalQuarter)
{
int fiscalQuarterNumber = (int)givenFiscalQuarter - 1;
if (fiscalQuarterNumber == 0)
{
// Wrap back to prior year
fiscalQuarterNumber = 4;
}
return((FiscalQuarter)fiscalQuarterNumber);
}
public static void GreaterThanOrEqualToOperator___Should_return_true___When_left_side_of_operator_is_equal_to_right_side()
{
// Arrange
var systemUnderTest1 = A.Dummy <FiscalQuarter>();
var systemUnderTest2 = new FiscalQuarter(systemUnderTest1.Year, systemUnderTest1.QuarterNumber);
// 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 <FiscalQuarter>();
FiscalQuarter 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
FiscalQuarter systemUnderTest1 = null;
FiscalQuarter systemUnderTest2 = null;
// Act
var result = systemUnderTest1 >= systemUnderTest2;
// Assert
result.Should().BeTrue();
}
public static void GreaterThanOperator___Should_return_false___When_left_side_of_operator_is_null_and_right_side_is_not_null()
{
// Arrange
FiscalQuarter systemUnderTest1 = null;
var systemUnderTest2 = A.Dummy <FiscalQuarter>();
// Act
var result = systemUnderTest1 > systemUnderTest2;
// Assert
result.Should().BeFalse();
}
public static void LessThanOperator___Should_return_false___When_both_sides_of_operator_are_null()
{
// Arrange
FiscalQuarter systemUnderTest1 = null;
FiscalQuarter 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 <FiscalQuarter>();
var systemUnderTest2 = new FiscalQuarter(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 <FiscalQuarter>();
var systemUnderTest2 = new FiscalQuarter(systemUnderTest1.Year, systemUnderTest1.QuarterNumber);
// 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 <FiscalQuarter>();
FiscalQuarter 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 <FiscalQuarter>();
var systemUnderTest2 = new FiscalQuarter(systemUnderTest1.Year, systemUnderTest1.QuarterNumber);
// Act
var result = systemUnderTest1.CompareTo((object)systemUnderTest2);
// Assert
result.Should().Be(0);
}
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 GetHashCode___Should_be_equal_for_two_FiscalQuarters___When_both_objects_have_the_same_property_values()
{
// Arrange
var systemUnderTest1 = A.Dummy <FiscalQuarter>();
var systemUnderTest2 = new FiscalQuarter(systemUnderTest1.Year, systemUnderTest1.QuarterNumber);
// Act
var hash1 = systemUnderTest1.GetHashCode();
var hash2 = systemUnderTest2.GetHashCode();
// Assert
hash1.Should().Be(hash2);
}
public static void NotEqualsOperator___Should_return_true___When_one_side_of_operator_is_null_and_the_other_side_is_not_null()
{
// Arrange
FiscalQuarter systemUnderTest1 = null;
var systemUnderTest2 = A.Dummy <FiscalQuarter>();
// Act
var result1 = systemUnderTest1 != systemUnderTest2;
var result2 = systemUnderTest2 != systemUnderTest1;
// Assert
result1.Should().BeTrue();
result2.Should().BeTrue();
}
public static void ToString___Should_return_friendly_string_representation_of_object___When_called()
{
// Arrange
var systemUnderTest1 = new FiscalQuarter(2017, QuarterNumber.Q1);
var systemUnderTest2 = new FiscalQuarter(2017, QuarterNumber.Q4);
// Act
var toString1 = systemUnderTest1.ToString();
var toString2 = systemUnderTest2.ToString();
// Assert
toString1.Should().Be("1Q2017");
toString2.Should().Be("4Q2017");
}
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 QuarterNumber___Should_return_same_quarterNumber_passed_to_constructor___When_getting()
{
// Arrange
var validQuarter = A.Dummy <FiscalQuarter>();
var year = validQuarter.Year;
var quarter = validQuarter.QuarterNumber;
var systemUnderTest = new FiscalQuarter(year, quarter);
// Act
var actualQuarter = systemUnderTest.QuarterNumber;
// Assert
actualQuarter.Should().Be(quarter);
}
public static DateTime GetLastDateInFiscalQuarter(FiscalQuarter qtr, int calendarYear)
{
if (qtr == FiscalQuarter.First) // 1st FiscalQuarter = October 1 to December 31
{
return(new DateTime(calendarYear, 12, DateTime.DaysInMonth(calendarYear, 12)));
}
if (qtr == FiscalQuarter.Second) // 2nd FiscalQuarter = January 1 to March 31
{
return(new DateTime(calendarYear, 3, DateTime.DaysInMonth(calendarYear, 3)));
}
if (qtr == FiscalQuarter.Third) // 3rd FiscalQuarter = April 1 to June 30
{
return(new DateTime(calendarYear, 6, DateTime.DaysInMonth(calendarYear, 6)));
}
// 4th FiscalQuarter = July 1 to Sept 30
return(new DateTime(calendarYear, 9, DateTime.DaysInMonth(calendarYear, 9)));
}
public static DateTime GetFirstDateInFiscalQuarter(FiscalQuarter qtr, int calendarYear)
{
if (qtr == FiscalQuarter.First) // 1st FiscalQuarter = October 1 to December 31
{
return(new DateTime(calendarYear, 10, 1));
}
if (qtr == FiscalQuarter.Second) // 2nd FiscalQuarter = January 1 to March 31
{
return(new DateTime(calendarYear, 1, 1));
}
if (qtr == FiscalQuarter.Third) // 3rd FiscalQuarter = April 1 to June 30
{
return(new DateTime(calendarYear, 4, 1));
}
// 4th FiscalQuarter = July 1 to Sept 30
return(new DateTime(calendarYear, 7, 1));
}
public static DateTime GetLastDateOfPreviousFiscalQuarter(DateTime fromDate)
{
// What quarter are we in?
FiscalQuarter currentQuarter = GetFiscalQuarter((Month)fromDate.Month);
// What's the previous quarter?
FiscalQuarter previousQuarter = GetFiscalQuarterPreviousToFiscalQuarter(currentQuarter);
// If we wrapped our FY (i.e. went from quarter 2 => quarter 1), decrease the calendar year to the previous year.
int calendarYear = fromDate.Year;
if (previousQuarter == FiscalQuarter.First && currentQuarter == FiscalQuarter.Second)
{
calendarYear -= 1;
}
// Use the previous Quarter / Calendar Year to get the last date in the fiscal quarter
return(GetLastDateInFiscalQuarter(previousQuarter, calendarYear));
}
private static FiscalQuarter TweakComponentOfFiscalQuarter(this FiscalQuarter fiscalQuarter, FiscalQuarterComponent componentToTweak)
{
if (componentToTweak == FiscalQuarterComponent.Quarter)
{
var tweakedQuarter = A.Dummy <QuarterNumber>().ThatIsNot(fiscalQuarter.QuarterNumber);
var result = new FiscalQuarter(fiscalQuarter.Year, tweakedQuarter);
return(result);
}
if (componentToTweak == FiscalQuarterComponent.Year)
{
var tweakedYear = A.Dummy <PositiveInteger>().ThatIs(y => y != fiscalQuarter.Year && y <= 9999);
var result = new FiscalQuarter(tweakedYear, fiscalQuarter.QuarterNumber);
return(result);
}
throw new NotSupportedException("this fiscal quarter component is not supported: " + componentToTweak);
}
/// <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 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>();
}
public static DateTime GetLastDateInFiscalQuarter(this DateTime dateInQuarter)
{
FiscalQuarter qtr = ((Month)dateInQuarter.Month).GetFiscalQuarter();
return(GetLastDateInFiscalQuarter(qtr, dateInQuarter.Year));
}
/// <summary>
/// Initializes a new instance of the <see cref="FiscalQuarterReportingPeriod"/> class.
/// </summary>
/// <param name="start">The start of the reporting period.</param>
/// <param name="end">The end of the reporting period.</param>
public FiscalQuarterReportingPeriod(
FiscalQuarter start,
FiscalQuarter end)
: base(start, end)
{
}
