/// <summary>
/// Initializes a new instance of the <see cref="ExcelDummyFactory"/> class.
/// </summary>
public ExcelDummyFactory()
{
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <DataValidation>();
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(BorderEdges.Unknown);
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = Color.FromArgb(ThreadSafeRandom.Next(256), ThreadSafeRandom.Next(256), ThreadSafeRandom.Next(256));
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var worksheetName = "worksheet-" + A.Dummy <Guid>().ToString().Substring(1, 10);
var rowNumber = A.Dummy <PositiveInteger>().ThatIs(_ => _ <= Constants.MaximumRowNumber);
var columnNumber = A.Dummy <PositiveInteger>().ThatIs(_ => _ <= Constants.MaximumColumnNumber);
var result = new CellReference(worksheetName, rowNumber, columnNumber);
return(result);
});
}
public SerializationDummyFactory()
{
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(SerializationKind.Invalid, SerializationKind.Proprietary);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(SerializationFormat.Invalid);
#if OBeautifulCodeSerializationSolution
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <KeyOrValueObjectHierarchyBase>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <TestBase>();
#endif
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializationDummyFactory"/> class.
/// </summary>
public SerializationDummyFactory()
{
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(SerializationKind.Invalid, SerializationKind.Proprietary);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(SerializationFormat.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CompressionKind.Invalid);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(RegisteredJsonConverterOutputKind.Unknown);
#if NaosSerializationDomainTest
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new TypeRepresentation(A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>(), new TypeRepresentation[0]));
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <Naos.Serialization.Test.KeyOrValueObjectHierarchyBase>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <Naos.Serialization.Test.TestBase>();
#endif
}
public LoggingDummyFactory()
{
var logWriterConfigTypes = typeof(LogWriterConfigBase).Assembly.DefinedTypes.Where(_ => _.BaseType == typeof(LogWriterConfigBase)).ToList();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <LogWriterConfigBase>(
null,
logWriterConfigTypes);
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new LogItemContext(A.Dummy <DateTime>().ToUniversalTime(), A.Dummy <string>(), A.Dummy <string>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var context = A.Dummy <LogItemContext>();
var dummySubject = new DummySubject {
Info = A.Dummy <string>()
};
var result = new LogItem(new RawSubject(dummySubject, dummySubject.Info).ToSubject(), LogItemKind.Object, context, A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new RawSubject(A.Dummy <string>(), A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var rawSubject = A.Dummy <RawSubject>();
var result = rawSubject.ToSubject();
return(result);
});
}
public CronDummyFactory()
{
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <ScheduleBase>();
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new DailyScheduleInUtc
{
Hour = A.Dummy <int>().ThatIsInRange(0, 23),
Minute = A.Dummy <int>().ThatIsInRange(0, 59),
};
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new ExpressionSchedule
{
CronExpression = "*/" + A.Dummy <int>().ThatIsInRange(1, 4) + " * * * *",
};
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new HourlySchedule
{
Minute = A.Dummy <int>().ThatIsInRange(0, 59),
};
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new IntervalSchedule()
{
Interval = new TimeSpan(A.Dummy <long>().ThatIsInRange(0, 10000))
};
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new MonthlyScheduleInUtc()
{
DaysOfMonth = new[]
{
A.Dummy <int>().ThatIsInRange(0, 28),
A.Dummy <int>().ThatIsInRange(0, 28),
A.Dummy <int>().ThatIsInRange(0, 28),
A.Dummy <int>().ThatIsInRange(0, 28),
A.Dummy <int>().ThatIsInRange(0, 28),
}.Distinct().ToArray(),
Hour = A.Dummy <int>().ThatIsInRange(0, 23),
Minute = A.Dummy <int>().ThatIsInRange(0, 59),
};
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new WeeklyScheduleInUtc()
{
DaysOfWeek = Some.Dummies <DayOfWeek>(3).ToArray(),
Hour = A.Dummy <int>().ThatIsInRange(0, 23),
Minute = A.Dummy <int>().ThatIsInRange(0, 59),
};
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new YearlyScheduleInUtc()
{
MonthsOfYear = Some.Dummies <MonthOfYear>(4).ToArray(),
DaysOfMonth = new[]
{
A.Dummy <int>().ThatIsInRange(0, 28),
A.Dummy <int>().ThatIsInRange(0, 28),
A.Dummy <int>().ThatIsInRange(0, 28),
A.Dummy <int>().ThatIsInRange(0, 28),
A.Dummy <int>().ThatIsInRange(0, 28),
}.Distinct().ToArray(),
Hour = A.Dummy <int>().ThatIsInRange(0, 23),
Minute = A.Dummy <int>().ThatIsInRange(0, 59),
};
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 CodeGenDummyFactory()
{
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <CustomBaseClass>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <CustomMultilevelBaseClass>();
AutoFixtureBackedDummyFactory.UseRandomConcreteSubclassForDummy <CustomMultilevelChildBaseClass>();
}
/// <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);
});
}
