public PackagingDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new PackageDescription {
Id = A.Dummy <string>(), Version = A.Dummy <string>()
};
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var packageDescription = A.Dummy <PackageDescription>();
var result = new Package {
PackageDescription = packageDescription, PackageFileBytes = Encoding.UTF32.GetBytes(A.Dummy <string>()), PackageFileBytesRetrievalDateTimeUtc = A.Dummy <DateTime>()
};
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new PackageRepositoryConfiguration {
Source = A.Dummy <string>(), SourceName = A.Dummy <string>(), UserName = A.Dummy <string>(), ClearTextPassword = A.Dummy <string>(), ProtocolVersion = A.Dummy <int?>()
};
return(result);
});
}
/// <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 DefaultTypeDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new UtcDateTimeRangeInclusive(
A.Dummy <DateTime>(),
A.Dummy <DateTime>()));
}
public DefaultServiceDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NamedServiceLocator(
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullServiceLocator());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(NamedServiceLocator),
typeof(NullServiceLocator)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (ServiceLocatorBase)AD.ummy(randomType);
return(result);
});
}
public ProtocolDummyFactory()
{
/* Add any overriding or custom registrations here. */
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CacheResult <Version, Version>(
A.Dummy <Version>(),
A.Dummy <Version>(),
A.Dummy <DateTime>().ToUniversalTime()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullEvent(
A.Dummy <DateTime>().ToUniversalTime()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullIdentifiedEvent <Version>(
A.Dummy <Version>(),
A.Dummy <DateTime>().ToUniversalTime()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ExecuteOpRequestedEvent <GetProtocolByTypeOp>(
A.Dummy <GetProtocolByTypeOp>(),
A.Dummy <DateTime>().ToUniversalTime(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ExecuteOpRequestedEvent <Version, GetProtocolByTypeOp>(
A.Dummy <Version>(),
A.Dummy <GetProtocolByTypeOp>(),
A.Dummy <DateTime>().ToUniversalTime(),
A.Dummy <string>()));
}
public DefaultHubSpotDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new Contact(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <IReadOnlyDictionary <string, string> >()));
}
public DefaultMongoDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new MongoConnectionDefinition
{
Server = A.Dummy <string>(),
DatabaseName = A.Dummy <string>(),
UserName = A.Dummy <string>(),
Password = A.Dummy <string>(),
AuthenticationDatabaseName = A.Dummy <string>(),
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ExampleDummyFactory"/> class.
/// </summary>
public ExampleDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
// this need a specific constructor because it takes a read only dictionary as a parameter.
var result = new ExampleObject(A.Dummy <string>(), new Dictionary <string, string>());
return(result);
});
// this has valuse I don't want to use.
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ExampleEnumeration.Invalid);
}
public HubSpotDummyFactory()
{
/* Add any overriding or custom registrations here. */
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var readOnlyDictionary = A.Dummy <Dictionary <string, string> >();
readOnlyDictionary.Add(Contact.FirstNamePropertyKey, A.Dummy <string>());
readOnlyDictionary.Add(Contact.LastNamePropertyKey, A.Dummy <string>());
return(new Contact(
A.Dummy <string>(),
A.Dummy <string>(),
readOnlyDictionary));
});
}
/// <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 DefaultSerializationDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new BinaryDescribedSerialization(
A.Dummy <TypeRepresentation>(),
A.Dummy <SerializerRepresentation>(),
A.Dummy <byte[]>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(BinaryDescribedSerialization),
typeof(NullDescribedSerialization),
typeof(StringDescribedSerialization)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (DescribedSerializationBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DynamicTypePlaceholder());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullDescribedSerialization(
A.Dummy <TypeRepresentation>(),
A.Dummy <SerializerRepresentation>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SerializerRepresentation(
A.Dummy <SerializationKind>(),
A.Dummy <TypeRepresentation>(),
A.Dummy <CompressionKind>(),
A.Dummy <IReadOnlyDictionary <string, string> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StringDescribedSerialization(
A.Dummy <TypeRepresentation>(),
A.Dummy <SerializerRepresentation>(),
A.Dummy <string>()));
}
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);
});
}
private static void AddDummyCreatorForAbstractReportingPeriod <T>()
where T : UnitOfTime
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <T>();
var end = A.Dummy <T>();
if ((start is IAmUnboundedTime) || (end is IAmUnboundedTime))
{
if ((start is IAmUnboundedTime) && (end is IAmUnboundedTime))
{
return(new ReportingPeriod <T>(start, start));
}
if (start is IAmUnboundedTime)
{
end = A.Dummy <T>().Whose(_ => _.UnitOfTimeKind == start.UnitOfTimeKind);
}
else
{
start = A.Dummy <T>().Whose(_ => _.UnitOfTimeKind == end.UnitOfTimeKind);
}
return(new ReportingPeriod <T>(end, start));
}
else
{
end = A.Dummy <T>().ThatIs(u => u.GetType() == start.GetType());
if ((dynamic)start <= (dynamic)end)
{
return(new ReportingPeriod <T>(start, end));
}
return(new ReportingPeriod <T>(end, start));
}
});
AutoFixtureBackedDummyFactory.AddDummyCreator <IReportingPeriod <T> >(
() =>
{
var result = A.Dummy <ReportingPeriod <T> >();
return(result);
});
}
public TypeDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var startDateTime = A.Dummy <DateTime>();
var endDateTime = A.Dummy <DateTime>().ThatIs(_ => _ >= startDateTime);
var result = new UtcDateTimeRangeInclusive(startDateTime.ToUniversalTime(), endDateTime.ToUniversalTime());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
Type result;
if (ThreadSafeRandom.Next(0, 2) == 0)
{
result = GetRandomClosedTypeInAppDomain();
}
else
{
while (true)
{
var genericTypeDefinition = GetRandomGenericTypeDefinitionInAppDomain();
var typeArguments = Enumerable.Range(0, genericTypeDefinition.GetGenericArguments().Length).Select(_ => GetRandomClosedTypeInAppDomain()).ToArray();
try
{
result = genericTypeDefinition.MakeGenericType(typeArguments);
break;
}
catch (Exception)
{
}
}
}
return(result);
});
}
public DefaultSerializationDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DescribedSerialization(
A.Dummy <TypeRepresentation>(),
A.Dummy <string>(),
A.Dummy <SerializerRepresentation>(),
A.Dummy <SerializationFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DynamicTypePlaceholder());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SerializerRepresentation(
A.Dummy <SerializationKind>(),
A.Dummy <TypeRepresentation>(),
A.Dummy <CompressionKind>(),
A.Dummy <IReadOnlyDictionary <string, string> >()));
}
public AsposeCellsDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
// can't use General.CreateStandardWorkbook because it will throw without a license.
var workbook = new Workbook();
General.EnsureSizingOperationsHonorPixelsSpecified();
var result = workbook.Worksheets[0];
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(() =>
{
var result = new CellCursor(A.Dummy <Worksheet>(), A.Dummy <PositiveInteger>(), A.Dummy <PositiveInteger>());
return(result);
});
}
private static void RegisterReturningOperation <T>()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(ThrowOpExecutionAbortedExceptionOp <T>),
typeof(NullReturningOp <T>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (ReturningOperationBase <T>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator <IReturningOperation <T> >(A.Dummy <ReturningOperationBase <T> >);
}
private static void AddDummyCreatorForConcreteReportingPeriod <T>()
where T : UnitOfTime
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var start = A.Dummy <T>();
var end = A.Dummy <T>().ThatIs(u => u.GetType() == start.GetType());
if ((start is IAmBoundedTime) && ((dynamic)start <= (dynamic)end))
{
return(new ReportingPeriod <T>(start, end));
}
return(new ReportingPeriod <T>(end, start));
});
AutoFixtureBackedDummyFactory.AddDummyCreator <IReportingPeriod <T> >(
() =>
{
var result = A.Dummy <ReportingPeriod <T> >();
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 DefaultReactorDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AllDependenciesReactorDependency(
A.Dummy <IReadOnlyCollection <IReactorDependency> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AnyDependenciesReactorDependency(
A.Dummy <IReadOnlyCollection <IReactorDependency> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CheckRecordExistsOp(
A.Dummy <IStreamRepresentation>(),
A.Dummy <RecordFilter>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CheckRecordExistsResult(
A.Dummy <IStreamRepresentation>(),
A.Dummy <bool>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CheckRecordHandlingOp(
A.Dummy <IStreamRepresentation>(),
A.Dummy <string>(),
A.Dummy <RecordFilter>(),
A.Dummy <HandlingFilter>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CheckRecordHandlingResult(
A.Dummy <IStreamRepresentation>(),
A.Dummy <IReadOnlyDictionary <long, HandlingStatus> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CompleteHandlingOnReactionRegistrationDependenciesOp(
A.Dummy <ReactionRegistration>(),
A.Dummy <string>(),
A.Dummy <IReadOnlyCollection <HandlingStatus> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DetailsReactionContext(
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EvaluateReactionRegistrationOp(
A.Dummy <ReactionRegistration>(),
A.Dummy <bool>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EvaluateScheduleOp(
A.Dummy <ISchedule>(),
A.Dummy <DateTime>(),
A.Dummy <DateTime?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EventToPutWithId <Version>(
A.Dummy <Version>(),
A.Dummy <IEvent>(),
A.Dummy <IStreamRepresentation>(),
A.Dummy <bool>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EventToPutWithIdOnHandlingStatusMatch <Version>(
A.Dummy <CompositeHandlingStatus>(),
A.Dummy <CompositeHandlingStatusMatchStrategy>(),
A.Dummy <EventToPutWithId <Version> >(),
A.Dummy <ChainOfResponsibilityLinkMatchStrategy>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EventToPutWithIdOnRecordFilterMatch <Version>(
A.Dummy <RecordExistsMatchStrategy>(),
A.Dummy <EventToPutWithId <Version> >(),
A.Dummy <ChainOfResponsibilityLinkMatchStrategy>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ExecuteOpOnScheduleOp(
A.Dummy <string>(),
A.Dummy <IVoidOperation>(),
A.Dummy <ISchedule>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetReactionRegistrationDependenciesStatusOp(
A.Dummy <ReactionRegistration>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ReactionEvent(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <IReactionContext>(),
A.Dummy <IReadOnlyDictionary <IStreamRepresentation, IReadOnlyList <long> > >(),
A.Dummy <DateTime>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ReactionRegistration(
A.Dummy <string>(),
A.Dummy <IReactionContext>(),
A.Dummy <IReadOnlyList <IReactorDependency> >(),
A.Dummy <TimeSpan>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordFilterEntry(
A.Dummy <string>(),
A.Dummy <IStreamRepresentation>(),
A.Dummy <RecordFilter>(),
A.Dummy <bool>(),
A.Dummy <bool>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordFilterReactorDependency(
A.Dummy <IReadOnlyList <RecordFilterEntry> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RunReactorOp(
A.Dummy <int>(),
A.Dummy <TypeRepresentation>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RunScheduleOp(
A.Dummy <TypeRepresentation>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ScheduledExecutionEvent(
A.Dummy <string>(),
A.Dummy <IVoidOperation>(),
A.Dummy <ISchedule>(),
A.Dummy <DateTime?>(),
A.Dummy <DateTime>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new TriggerReactionRegistrationOp(
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new WriteEventOnMatchingHandlingStatusOp <Version>(
A.Dummy <IReadOnlyCollection <CheckRecordHandlingOp> >(),
A.Dummy <IReadOnlyList <EventToPutWithIdOnHandlingStatusMatch <Version> > >(),
A.Dummy <TimeSpan>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new WriteEventOnMatchingRecordFilterOp <Version>(
A.Dummy <IReadOnlyCollection <CheckRecordExistsOp> >(),
A.Dummy <IReadOnlyList <EventToPutWithIdOnRecordFilterMatch <Version> > >(),
A.Dummy <TimeSpan>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new WriteEventsWithUtcTimestampIdOp(
A.Dummy <string>(),
A.Dummy <IReadOnlyCollection <EventToPutWithId <string> > >()));
}
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 TypeDummyFactory()
{
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CultureKind.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(DateTimeFormatKind.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(MissingProtocolStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(StandardTimeZone.Unknown);
// UtcDateTimeRangeInclusive
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var startDateTime = A.Dummy <DateTime>();
var endDateTime = A.Dummy <DateTime>().ThatIs(_ => _ >= startDateTime);
var result = new UtcDateTimeRangeInclusive(startDateTime.ToUniversalTime(), endDateTime.ToUniversalTime());
return(result);
});
// Type
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
Type result;
if (ThreadSafeRandom.Next(0, 2) == 0)
{
result = GetRandomClosedTypeInAppDomain();
}
else
{
while (true)
{
var genericTypeDefinition = GetRandomGenericTypeDefinitionInAppDomain();
var typeArguments = Enumerable.Range(0, genericTypeDefinition.GetGenericArguments().Length).Select(_ => GetRandomClosedTypeInAppDomain()).ToArray();
try
{
result = genericTypeDefinition.MakeGenericType(typeArguments);
break;
}
catch (Exception)
{
}
}
}
return(result);
});
// IOperation
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = (IOperation)A.Dummy <OperationBase>();
return(result);
});
// IReturningOperation<Version>
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = (IReturningOperation <Version>)A.Dummy <ReturningOperationBase <Version> >();
return(result);
});
// IVoidOperation
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = (IVoidOperation)A.Dummy <VoidOperationBase>();
return(result);
});
// NullEvent
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullEvent(
A.Dummy <DateTime>().ToUniversalTime()));
// NullEvent<Version>
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullEvent <Version>(
A.Dummy <Version>(),
A.Dummy <DateTime>().ToUniversalTime()));
// ExecuteOpRequestedEvent<GetProtocolOp>
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ExecuteOpRequestedEvent <GetProtocolOp>(
A.Dummy <GetProtocolOp>(),
A.Dummy <DateTime>().ToUniversalTime(),
A.Dummy <string>()));
// ExecuteOpRequestedEvent<Version, GetProtocolOp>
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ExecuteOpRequestedEvent <Version, GetProtocolOp>(
A.Dummy <Version>(),
A.Dummy <GetProtocolOp>(),
A.Dummy <DateTime>().ToUniversalTime(),
A.Dummy <string>()));
}
public DatabaseDummyFactory()
{
// ------------------------------- EVENTS -------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HandlingForStreamDisabledEvent(
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HandlingForStreamEnabledEvent(
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HandlingForRecordDisabledEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var record = A.Dummy <StreamRecord>();
return(new RecordHandlingAvailableEvent(
record.InternalRecordId,
A.Dummy <string>(),
record,
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingCanceledEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingCompletedEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingFailedEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingFailureResetEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingRunningEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordHandlingSelfCanceledEvent(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PruneOperationExecutedEvent(
A.Dummy <IPruneOp>(),
A.Dummy <PruneSummary>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PruneOperationRequestedEvent(
A.Dummy <IPruneOp>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PruneRequestCanceledEvent(
A.Dummy <string>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new UniqueLongIssuedEvent(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new IdDeprecatedEvent(
A.Dummy <UtcDateTime>(),
A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new IdDeprecatedEvent <Version, Version>(
A.Dummy <Version>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new IdDeprecatedEvent <Version>(
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
// ------------------------------- MODELS -------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StreamRecordHandlingEntry(
A.Dummy <long>(),
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <HandlingStatus>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
A.Dummy <string>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var scenario = ThreadSafeRandom.Next(1, 4);
switch (scenario)
{
case 1:
return(new CreateStreamResult(false, true));
case 2:
return(new CreateStreamResult(true, false));
case 3:
return(new CreateStreamResult(true, true));
default:
throw new NotSupportedException(
FormattableString.Invariant($"Invalid scenario {scenario} for creating a dummy {nameof(CreateStreamResult)}."));
}
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StreamRecordMetadata(
A.Dummy <string>(),
A.Dummy <SerializerRepresentation>(),
A.Dummy <TypeRepresentationWithAndWithoutVersion>(),
A.Dummy <TypeRepresentationWithAndWithoutVersion>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
A.Dummy <UtcDateTime>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StreamRecordMetadata <Version>(
A.Dummy <Version>(),
A.Dummy <SerializerRepresentation>(),
A.Dummy <TypeRepresentationWithAndWithoutVersion>(),
A.Dummy <TypeRepresentationWithAndWithoutVersion>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
A.Dummy <UtcDateTime>(),
A.Dummy <UtcDateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetStreamFromRepresentationOp <FileStreamRepresentation, MemoryStandardStream>(
A.Dummy <FileStreamRepresentation>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var scenario = ThreadSafeRandom.Next(1, 5);
switch (scenario)
{
case 1:
return(new PutRecordResult(A.Dummy <long>(), null));
case 2:
return(new PutRecordResult(null, Some.ReadOnlyDummies <long>().ToList()));
case 3:
return(new PutRecordResult(null, Some.ReadOnlyDummies <long>().ToList(), Some.ReadOnlyDummies <long>().ToList()));
case 4:
return(new PutRecordResult(A.Dummy <long>(), Some.ReadOnlyDummies <long>().ToList(), Some.ReadOnlyDummies <long>().ToList()));
default:
throw new NotSupportedException(FormattableString.Invariant($"Invalid scenario {scenario} for creating a dummy {nameof(PutRecordResult)}."));
}
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var scenario = ThreadSafeRandom.Next(1, 4);
switch (scenario)
{
case 1:
return(new TryHandleRecordResult(null, false));
case 2:
return(new TryHandleRecordResult(A.Dummy <StreamRecord>(), false));
case 3:
return(new TryHandleRecordResult(null, true));
default:
throw new NotSupportedException(FormattableString.Invariant($"Invalid scenario {scenario} for creating a dummy {nameof(TryHandleRecordResult)}."));
}
});
// ------------------------------- ENUMS --------------------------------------
AutoFixtureBackedDummyFactory.ConstrainDummyToBeOneOf(VersionMatchStrategy.Any, VersionMatchStrategy.SpecifiedVersion);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(CompositeHandlingStatus.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ExistingDatabaseStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ExistingRecordStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(ExistingStreamStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(HandlingStatus.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(OrderRecordsBy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(RecordNotFoundStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(StreamNotFoundStrategy.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(StreamRecordItemsToInclude.Unknown);
AutoFixtureBackedDummyFactory.ConstrainDummyToExclude(TagMatchStrategy.Unknown);
// ------------------------------- MODEL INTERFACES --------------------------------------
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IResourceLocator>();
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IStreamRepresentation>();
// ------------------------------- OPERATIONS -------------------------------------
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PruneBeforeInternalRecordDateOp(
A.Dummy <UtcDateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StandardPruneStreamOp(
A.Dummy <long>(),
A.Dummy <UtcDateTime>(),
A.Dummy <string>(),
A.Dummy <IResourceLocator>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StandardUpdateHandlingStatusForRecordOp(
A.Dummy <long>(),
A.Dummy <string>(),
A.Dummy <HandlingStatus>().ThatIsNot(HandlingStatus.DisabledForStream),
Some.ReadOnlyDummies <HandlingStatus>().ToList(),
A.Dummy <string>(),
Some.ReadOnlyDummies <NamedValue <string> >().ToList(),
A.Dummy <bool>(),
A.Dummy <IResourceLocator>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StandardUpdateHandlingStatusForStreamOp(
A.Dummy <HandlingStatus>().ThatIsIn(new[] { HandlingStatus.DisabledForStream, HandlingStatus.AvailableByDefault }),
A.Dummy <string>(),
Some.ReadOnlyDummies <NamedValue <string> >().ToList(),
A.Dummy <IResourceLocator>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>();
var result = new PutAndReturnInternalRecordIdOp <Version>(
A.Dummy <Version>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
existingRecordStrategy,
existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType
? (int?)A.Dummy <ZeroOrPositiveInteger>()
: null,
A.Dummy <VersionMatchStrategy>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>();
var result = new PutOp <Version>(
A.Dummy <Version>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
existingRecordStrategy,
existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType
? (int?)A.Dummy <ZeroOrPositiveInteger>()
: null,
A.Dummy <VersionMatchStrategy>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>();
var result = new PutWithIdAndReturnInternalRecordIdOp <Version, Version>(
A.Dummy <Version>(),
A.Dummy <Version>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
existingRecordStrategy,
existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType
? (int?)A.Dummy <ZeroOrPositiveInteger>()
: null,
A.Dummy <VersionMatchStrategy>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>();
var result = new PutWithIdOp <Version, Version>(
A.Dummy <Version>(),
A.Dummy <Version>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >(),
existingRecordStrategy,
existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType
? (int?)A.Dummy <ZeroOrPositiveInteger>()
: null,
A.Dummy <VersionMatchStrategy>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var existingRecordStrategy = A.Dummy <ExistingRecordStrategy>();
var result = new StandardPutRecordOp(
A.Dummy <StreamRecordMetadata>(),
A.Dummy <DescribedSerializationBase>(),
existingRecordStrategy,
existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundById || existingRecordStrategy == ExistingRecordStrategy.PruneIfFoundByIdAndType
? (int?)A.Dummy <ZeroOrPositiveInteger>()
: null,
A.Dummy <VersionMatchStrategy>(),
A.Dummy <long?>(),
A.Dummy <IResourceLocator>());
return(result);
});
// ------------------------------- OPERATION INTERFACES -------------------------------------
AutoFixtureBackedDummyFactory.UseRandomInterfaceImplementationForDummy <IPruneOp>();
}
public DefaultEmailDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EmailAttachment(
A.Dummy <byte[]>(),
A.Dummy <string>(),
A.Dummy <MediaType>(),
A.Dummy <EncodingKind?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EmailContent(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <IReadOnlyCollection <EmailAttachment> >(),
A.Dummy <IReadOnlyDictionary <string, EmailAttachment> >(),
A.Dummy <EncodingKind?>(),
A.Dummy <EncodingKind?>(),
A.Dummy <EncodingKind?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(FailedToSendEmailEvent <Version>),
typeof(SendEmailRequestedEvent <Version>),
typeof(SucceededInSendingEmailEvent <Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (EmailEventBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EmailMailbox(
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EmailOptions(
A.Dummy <MailPriority?>(),
A.Dummy <DeliveryNotificationOptions?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EmailParticipants(
A.Dummy <EmailMailbox>(),
A.Dummy <IReadOnlyCollection <EmailMailbox> >(),
A.Dummy <IReadOnlyCollection <EmailMailbox> >(),
A.Dummy <IReadOnlyCollection <EmailMailbox> >(),
A.Dummy <IReadOnlyCollection <EmailMailbox> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new FailedToSendEmailEvent <Version>(
A.Dummy <Version>(),
A.Dummy <DateTime>(),
A.Dummy <SendEmailResponse>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SendEmailOp(
A.Dummy <SendEmailRequest>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SendEmailRequest(
A.Dummy <EmailParticipants>(),
A.Dummy <EmailContent>(),
A.Dummy <EmailOptions>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SendEmailRequestedEvent <Version>(
A.Dummy <Version>(),
A.Dummy <DateTime>(),
A.Dummy <SendEmailRequest>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SendEmailResponse(
A.Dummy <SendEmailResult>(),
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(FailedToSendEmailEvent <Version>),
typeof(SucceededInSendingEmailEvent <Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (SendEmailResponseEventBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SmtpServerConnectionDefinition(
A.Dummy <string>(),
A.Dummy <int>(),
A.Dummy <SecureConnectionMethod>(),
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SucceededInSendingEmailEvent <Version>(
A.Dummy <Version>(),
A.Dummy <DateTime>(),
A.Dummy <SendEmailResponse>()));
}
public DiagnosticsDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new AssemblyDetails(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new OperatingSystemDetails(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new MachineDetails(
A.Dummy <Dictionary <string, string> >(),
A.Dummy <int>(),
A.Dummy <Dictionary <string, decimal> >(),
A.Dummy <bool>(),
A.Dummy <OperatingSystemDetails>(),
A.Dummy <string>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new ProcessDetails(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <bool>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new PerformanceCounterDescription(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <float>());
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var result = new PerformanceCounterSample(
A.Dummy <PerformanceCounterDescription>(),
A.Dummy <float>());
return(result);
});
}
public DefaultRepresentationSystemDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AssemblyRepresentation(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ElementInitRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <MethodInfoRepresentation>(),
A.Dummy <IReadOnlyList <ExpressionRepresentationBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new MemberAssignmentRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <MemberInfoRepresentation>(),
A.Dummy <ExpressionRepresentationBase>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(MemberAssignmentRepresentation),
typeof(MemberListBindingRepresentation),
typeof(MemberMemberBindingRepresentation)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (MemberBindingRepresentationBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new MemberListBindingRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <MemberInfoRepresentation>(),
A.Dummy <IReadOnlyList <ElementInitRepresentation> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new MemberMemberBindingRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <MemberInfoRepresentation>(),
A.Dummy <IReadOnlyCollection <MemberBindingRepresentationBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new BinaryExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <ExpressionType>(),
A.Dummy <ExpressionRepresentationBase>(),
A.Dummy <ExpressionRepresentationBase>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ConditionalExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <ExpressionType>(),
A.Dummy <ExpressionRepresentationBase>(),
A.Dummy <ExpressionRepresentationBase>(),
A.Dummy <ExpressionRepresentationBase>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ConstantExpressionRepresentation <Version>(
A.Dummy <TypeRepresentation>(),
A.Dummy <ExpressionType>(),
A.Dummy <Version>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ConstructorInfoRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new MemberInfoRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new MethodInfoRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <string>(),
A.Dummy <IReadOnlyList <TypeRepresentation> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new UnknownTypePlaceholder());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(BinaryExpressionRepresentation),
typeof(ConditionalExpressionRepresentation),
typeof(ConstantExpressionRepresentation <Version>),
typeof(InvocationExpressionRepresentation),
typeof(LambdaExpressionRepresentation),
typeof(ListInitExpressionRepresentation),
typeof(MemberExpressionRepresentation),
typeof(MemberInitExpressionRepresentation),
typeof(MethodCallExpressionRepresentation),
typeof(NewArrayExpressionRepresentation),
typeof(NewExpressionRepresentation),
typeof(ParameterExpressionRepresentation),
typeof(TypeBinaryExpressionRepresentation),
typeof(UnaryExpressionRepresentation)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (ExpressionRepresentationBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new InvocationExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <ExpressionRepresentationBase>(),
A.Dummy <IReadOnlyList <ExpressionRepresentationBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new LambdaExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <ExpressionRepresentationBase>(),
A.Dummy <IReadOnlyList <ParameterExpressionRepresentation> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ListInitExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <NewExpressionRepresentation>(),
A.Dummy <IReadOnlyList <ElementInitRepresentation> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new MemberExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <ExpressionRepresentationBase>(),
A.Dummy <MemberInfoRepresentation>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new MemberInitExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <NewExpressionRepresentation>(),
A.Dummy <IReadOnlyCollection <MemberBindingRepresentationBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new MethodCallExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <ExpressionType>(),
A.Dummy <ExpressionRepresentationBase>(),
A.Dummy <MethodInfoRepresentation>(),
A.Dummy <IReadOnlyList <ExpressionRepresentationBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NewArrayExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <ExpressionType>(),
A.Dummy <IReadOnlyList <ExpressionRepresentationBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NewExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <ConstructorInfoRepresentation>(),
A.Dummy <IReadOnlyList <ExpressionRepresentationBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ParameterExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new TypeBinaryExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <ExpressionRepresentationBase>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new UnaryExpressionRepresentation(
A.Dummy <TypeRepresentation>(),
A.Dummy <ExpressionType>(),
A.Dummy <ExpressionRepresentationBase>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new TypeRepresentation(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <IReadOnlyList <TypeRepresentation> >()));
}
public DefaultProtocolDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ExecutedOpEvent <Version, HandleEventOp <ExecutedOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >(
A.Dummy <Version>(),
A.Dummy <DateTime>(),
A.Dummy <HandleEventOp <ExecutedOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >(),
A.Dummy <IReadOnlyDictionary <string, string> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ExecutingOpEvent <Version, HandleEventOp <ExecutedOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >(
A.Dummy <Version>(),
A.Dummy <DateTime>(),
A.Dummy <HandleEventOp <ExecutedOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >(),
A.Dummy <IReadOnlyDictionary <string, string> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HandledEventEvent <Version, ExecutedOpEvent <Version, HandleEventOp <ExecutingOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >, Version>(
A.Dummy <Version>(),
A.Dummy <DateTime>(),
A.Dummy <ExecutedOpEvent <Version, HandleEventOp <ExecutingOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> > >(),
A.Dummy <IReadOnlyDictionary <string, string> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HandleEventOp <ExecutedOpEvent <Version, HandleEventOp <ExecutingOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >, Version>(
A.Dummy <ExecutedOpEvent <Version, HandleEventOp <ExecutingOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HandlingEventEvent <Version, ExecutedOpEvent <Version, HandleEventOp <ExecutingOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >, Version>(
A.Dummy <Version>(),
A.Dummy <DateTime>(),
A.Dummy <ExecutedOpEvent <Version, HandleEventOp <ExecutingOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> > >(),
A.Dummy <IReadOnlyDictionary <string, string> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RecordedObjectEvent <Version, Version>(
A.Dummy <Version>(),
A.Dummy <DateTime>(),
A.Dummy <Version>(),
A.Dummy <IReadOnlyDictionary <string, string> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetIdFromObjectOp <Version, Version>(
A.Dummy <Version>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetTagsFromObjectOp <Version>(
A.Dummy <Version>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetProtocolByTypeOp(
A.Dummy <TypeRepresentation>(),
A.Dummy <MissingProtocolStrategy>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetReturningProtocolOp <GetIdFromObjectOp <Version, Version>, Version>());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetVoidProtocolOp <HandleEventOp <ExecutedOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CacheResult <Version, Version>(
A.Dummy <Version>(),
A.Dummy <Version>(),
A.Dummy <DateTime>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CacheStatusResult(
A.Dummy <long>(),
A.Dummy <UtcDateTimeRangeInclusive>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ClearCacheOp());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetCacheStatusOp());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetOrAddCachedItemOp <GetIdFromObjectOp <Version, Version>, Version>(
A.Dummy <GetIdFromObjectOp <Version, Version> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetAllResourceLocatorsOp());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetResourceLocatorByIdOp <Version>(
A.Dummy <Version>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullResourceLocator());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ThrowIfResourceUnavailableOp(
A.Dummy <ResourceLocatorBase>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(ExecutedOpEvent <Version, HandleEventOp <ExecutedOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >),
typeof(ExecutingOpEvent <Version, HandleEventOp <ExecutedOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >),
typeof(HandledEventEvent <Version, ExecutedOpEvent <Version, HandleEventOp <ExecutingOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >, Version>),
typeof(HandlingEventEvent <Version, ExecutedOpEvent <Version, HandleEventOp <ExecutingOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >, Version>),
typeof(RecordedObjectEvent <Version, Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (EventBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(HandleEventOp <ExecutedOpEvent <Version, HandleEventOp <ExecutingOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >, Version>),
typeof(GetIdFromObjectOp <Version, Version>),
typeof(GetTagsFromObjectOp <Version>),
typeof(GetProtocolByTypeOp),
typeof(GetReturningProtocolOp <GetIdFromObjectOp <Version, Version>, Version>),
typeof(GetVoidProtocolOp <HandleEventOp <ExecutedOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >),
typeof(ClearCacheOp),
typeof(GetCacheStatusOp),
typeof(GetOrAddCachedItemOp <GetIdFromObjectOp <Version, Version>, Version>),
typeof(GetAllResourceLocatorsOp),
typeof(GetResourceLocatorByIdOp <Version>),
typeof(ThrowIfResourceUnavailableOp)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (OperationBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(GetIdFromObjectOp <Version, Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (ReturningOperationBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(HandleEventOp <ExecutedOpEvent <Version, HandleEventOp <ExecutingOpEvent <Version, GetIdFromObjectOp <Version, Version> >, Version> >, Version>),
typeof(ClearCacheOp),
typeof(ThrowIfResourceUnavailableOp)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (VoidOperationBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NamedResourceLocator(
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(NullResourceLocator),
typeof(NamedResourceLocator)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (ResourceLocatorBase)AD.ummy(randomType);
return(result);
});
}
public DefaultCronDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DailyScheduleInUtc
{
Hour = A.Dummy <int>(),
Minute = A.Dummy <int>(),
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ExpressionSchedule
{
CronExpression = A.Dummy <string>(),
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HourlySchedule
{
Minute = A.Dummy <int>(),
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new IntervalSchedule
{
Interval = A.Dummy <TimeSpan>(),
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new MonthlyScheduleInUtc
{
DaysOfMonth = A.Dummy <int[]>(),
Hour = A.Dummy <int>(),
Minute = A.Dummy <int>(),
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullSchedule());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(DailyScheduleInUtc),
typeof(ExpressionSchedule),
typeof(HourlySchedule),
typeof(IntervalSchedule),
typeof(MonthlyScheduleInUtc),
typeof(NullSchedule),
typeof(WeeklyScheduleInUtc),
typeof(YearlyScheduleInUtc)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (ScheduleBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new WeeklyScheduleInUtc
{
DaysOfWeek = A.Dummy <DayOfWeek[]>(),
Hour = A.Dummy <int>(),
Minute = A.Dummy <int>(),
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new YearlyScheduleInUtc
{
MonthsOfYear = A.Dummy <MonthOfYear[]>(),
DaysOfMonth = A.Dummy <int[]>(),
Hour = A.Dummy <int>(),
Minute = A.Dummy <int>(),
});
}
public DefaultDataStructureDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AdditionalReportInfo(
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AndAlsoOp(
A.Dummy <IReadOnlyCollection <IReturningOperation <bool> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AvailabilityCheck(
A.Dummy <IReturningOperation <AvailabilityCheckResult> >(),
A.Dummy <MessageFormatKind?>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AvailabilityCheckChain(
A.Dummy <IReadOnlyList <AvailabilityCheckStep> >(),
A.Dummy <IReturningOperation <string> >(),
A.Dummy <Availability>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AvailabilityCheckResult(
A.Dummy <IReturningOperation <Availability> >(),
A.Dummy <IReturningOperation <string> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AvailabilityCheckStep(
A.Dummy <IReturningOperation <bool> >(),
A.Dummy <IReturningOperation <string> >(),
A.Dummy <AvailabilityCheckStepAction>(),
A.Dummy <AvailabilityCheckStepAction>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new BooleanCellValueFormat(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(InnerBorder),
typeof(OuterBorder)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (BorderBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new BytesPayloadLinkedResource(
A.Dummy <byte[]>(),
A.Dummy <BytesPayloadLinkedResourceKind>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CategoricalCellValueFormat <Version>(
A.Dummy <IReadOnlyDictionary <Version, string> >(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellAvailabilityCheckClearedEvent(
A.Dummy <DateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellAvailabilityCheckDeterminedCellDisabledEvent(
A.Dummy <DateTime>(),
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellAvailabilityCheckDeterminedCellEnabledEvent(
A.Dummy <DateTime>(),
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(CellAvailabilityCheckClearedEvent),
typeof(CellAvailabilityCheckDeterminedCellDisabledEvent),
typeof(CellAvailabilityCheckDeterminedCellEnabledEvent),
typeof(CellAvailabilityCheckFailedEvent)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (CellAvailabilityCheckEventBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellAvailabilityCheckFailedEvent(
A.Dummy <DateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(ConstCell <Version>),
typeof(InputCell <Version>),
typeof(NullCell),
typeof(OperationCell <Version>),
typeof(SlottedCell)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (CellBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellFormat(
A.Dummy <IReadOnlyList <OuterBorder> >(),
A.Dummy <FontFormat>(),
A.Dummy <Color?>(),
A.Dummy <VerticalAlignment?>(),
A.Dummy <HorizontalAlignment?>(),
A.Dummy <int?>(),
A.Dummy <FillPattern>(),
A.Dummy <CellFormatOptions?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellInputAppliedEvent <Version>(
A.Dummy <DateTime>(),
A.Dummy <Version>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellInputClearedEvent(
A.Dummy <DateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(CellInputAppliedEvent <Version>),
typeof(CellInputClearedEvent)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (CellInputEventBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(ReportCellLocator),
typeof(SectionCellLocator),
typeof(ThisCellLocator)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (CellLocatorBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellOpExecutionAbortedEvent(
A.Dummy <DateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellOpExecutionClearedEvent(
A.Dummy <DateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellOpExecutionCompletedEvent <Version>(
A.Dummy <DateTime>(),
A.Dummy <string>(),
A.Dummy <Version>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellOpExecutionDeemedNotApplicableEvent(
A.Dummy <DateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(CellOpExecutionAbortedEvent),
typeof(CellOpExecutionClearedEvent),
typeof(CellOpExecutionCompletedEvent <Version>),
typeof(CellOpExecutionDeemedNotApplicableEvent),
typeof(CellOpExecutionFailedEvent)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (CellOpExecutionEventBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellOpExecutionFailedEvent(
A.Dummy <DateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellValidationAbortedEvent(
A.Dummy <DateTime>(),
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellValidationClearedEvent(
A.Dummy <DateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellValidationDeemedNotApplicableEvent(
A.Dummy <DateTime>(),
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellValidationDeterminedCellInvalidEvent(
A.Dummy <DateTime>(),
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellValidationDeterminedCellValidEvent(
A.Dummy <DateTime>(),
A.Dummy <string>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(CellValidationAbortedEvent),
typeof(CellValidationClearedEvent),
typeof(CellValidationDeemedNotApplicableEvent),
typeof(CellValidationDeterminedCellInvalidEvent),
typeof(CellValidationDeterminedCellValidEvent),
typeof(CellValidationFailedEvent)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (CellValidationEventBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CellValidationFailedEvent(
A.Dummy <DateTime>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(CategoricalCellValueFormat <Version>),
typeof(NullNumberCellFormat <Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (CellValueFormatBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CheckAvailabilityOfCellIfNecessaryOp(
A.Dummy <IAvailabilityCheckCell>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CheckAvailabilityOp(
A.Dummy <AvailabilityCheckChain>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new Column(
A.Dummy <string>(),
A.Dummy <ColumnFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ColumnFormat(
A.Dummy <IReadOnlyList <OuterBorder> >(),
A.Dummy <IReadOnlyList <InnerBorder> >(),
A.Dummy <CellFormat>(),
A.Dummy <int?>(),
A.Dummy <bool?>(),
A.Dummy <ColumnFormatOptions?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CompareOp(
A.Dummy <IReturningOperation <decimal> >(),
A.Dummy <IReturningOperation <CompareOperator> >(),
A.Dummy <IReturningOperation <decimal> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ConstCell <Version>(
A.Dummy <Version>(),
A.Dummy <string>(),
A.Dummy <int?>(),
A.Dummy <string>(),
A.Dummy <Validation>(),
A.Dummy <IReadOnlyList <CellValidationEventBase> >(),
A.Dummy <Availability>(),
A.Dummy <AvailabilityCheck>(),
A.Dummy <IReadOnlyList <CellAvailabilityCheckEventBase> >(),
A.Dummy <ICellValueFormat <Version> >(),
A.Dummy <CellFormat>(),
A.Dummy <IHoverOver>(),
A.Dummy <ILink>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(ConstCell <Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (ConstOutputCellBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DataRows(
A.Dummy <IReadOnlyList <Row> >(),
A.Dummy <DataRowsFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DataRowsFormat(
A.Dummy <IReadOnlyList <OuterBorder> >(),
A.Dummy <IReadOnlyList <InnerBorder> >(),
A.Dummy <RowFormat>(),
A.Dummy <IReadOnlyList <RowFormat> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DateTimeCellValueFormat(
A.Dummy <DateTimeFormat>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DateTimeFormat(
A.Dummy <DateTimeFormatKind?>(),
A.Dummy <CultureKind?>(),
A.Dummy <bool?>(),
A.Dummy <StandardTimeZone?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DecimalCellValueFormat(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <int?>(),
A.Dummy <char?>(),
A.Dummy <NumberFormatDigitGroupKind?>(),
A.Dummy <char?>(),
A.Dummy <NumberFormatNegativeDisplayKind?>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DivideOp(
A.Dummy <IReturningOperation <decimal> >(),
A.Dummy <IReturningOperation <decimal> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ExecuteOperationCellIfNecessaryOp <Version>(
A.Dummy <IOperationOutputCell <Version> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new FillPattern(
A.Dummy <FillPatternStyle>(),
A.Dummy <Color>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new FlatRow(
A.Dummy <IReadOnlyList <ICell> >(),
A.Dummy <string>(),
A.Dummy <RowFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new FontFormat(
A.Dummy <Color?>(),
A.Dummy <IReadOnlyList <string> >(),
A.Dummy <decimal?>(),
A.Dummy <FontFormatOptions?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new FooterRows(
A.Dummy <IReadOnlyList <FlatRow> >(),
A.Dummy <FooterRowsFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new FooterRowsFormat(
A.Dummy <IReadOnlyList <OuterBorder> >(),
A.Dummy <IReadOnlyList <InnerBorder> >(),
A.Dummy <RowFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetAvailabilityOp(
A.Dummy <IReturningOperation <CellLocatorBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetCellOpExecutionOutcomeOp(
A.Dummy <IReturningOperation <CellLocatorBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetCellValueOp <Version>(
A.Dummy <IReturningOperation <CellLocatorBase> >(),
A.Dummy <IReturningOperation <Version> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetConstOp <Version>(
A.Dummy <Version>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetNumberOfSignificantDigitsOp(
A.Dummy <IReturningOperation <decimal> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetValidityOp(
A.Dummy <IReturningOperation <CellLocatorBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HasCellValueOp(
A.Dummy <IReturningOperation <CellLocatorBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HeaderRows(
A.Dummy <IReadOnlyList <FlatRow> >(),
A.Dummy <HeaderRowsFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HeaderRowsFormat(
A.Dummy <IReadOnlyList <OuterBorder> >(),
A.Dummy <IReadOnlyList <InnerBorder> >(),
A.Dummy <RowFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(HtmlHoverOver),
typeof(StringHoverOver)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (HoverOverBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HtmlCellValueFormat(
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new HtmlHoverOver(
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new IfThenElseOp <Version>(
A.Dummy <IReturningOperation <bool> >(),
A.Dummy <IReturningOperation <Version> >(),
A.Dummy <IReturningOperation <Version> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new InnerBorder(
A.Dummy <BorderWeight>(),
A.Dummy <BorderStyle>(),
A.Dummy <Color>(),
A.Dummy <InnerBorderEdges>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new InputCell <Version>(
A.Dummy <string>(),
A.Dummy <int?>(),
A.Dummy <string>(),
A.Dummy <Validation>(),
A.Dummy <IReadOnlyList <CellValidationEventBase> >(),
A.Dummy <Availability>(),
A.Dummy <AvailabilityCheck>(),
A.Dummy <IReadOnlyList <CellAvailabilityCheckEventBase> >(),
A.Dummy <IReadOnlyList <CellInputEventBase> >(),
A.Dummy <ICellValueFormat <Version> >(),
A.Dummy <CellFormat>(),
A.Dummy <IHoverOver>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(InputCell <Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (InputCellBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new IsEqualToOp <Version>(
A.Dummy <IReturningOperation <Version> >(),
A.Dummy <IReturningOperation <Version> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(SimpleLink)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (LinkBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(BytesPayloadLinkedResource),
typeof(StringPayloadLinkedResource),
typeof(UrlLinkedResource)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (LinkedResourceBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(GetCellValueOp <Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (LocatedCellOpBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new MediaReference(
A.Dummy <string>(),
A.Dummy <MediaReferenceKind>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(ColumnFormat),
typeof(DataRowsFormat),
typeof(FooterRowsFormat),
typeof(HeaderRowsFormat),
typeof(RowFormat),
typeof(TableFormat)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (MultiCellRegionFormatBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(NullMultiStatementOp <Version, Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (MultiStatementOpBase <Version, Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NotOp(
A.Dummy <IReturningOperation <bool> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(ConstCell <Version>),
typeof(InputCell <Version>),
typeof(NullCell),
typeof(OperationCell <Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (NotSlottedCellBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullCell(
A.Dummy <string>(),
A.Dummy <int?>(),
A.Dummy <string>(),
A.Dummy <Validation>(),
A.Dummy <IReadOnlyList <CellValidationEventBase> >(),
A.Dummy <Availability>(),
A.Dummy <AvailabilityCheck>(),
A.Dummy <IReadOnlyList <CellAvailabilityCheckEventBase> >(),
A.Dummy <CellFormat>(),
A.Dummy <IHoverOver>(),
A.Dummy <ILink>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(NullCell)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (NullCellBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullMultiStatementOp <Version, Version>(
A.Dummy <IReadOnlyCollection <IReturningOperation <Version> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullNumberCellFormat <Version>(
A.Dummy <int?>(),
A.Dummy <char?>(),
A.Dummy <NumberFormatDigitGroupKind?>(),
A.Dummy <char?>(),
A.Dummy <NumberFormatNegativeDisplayKind?>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullSingleStatementOp <Version, Version>(
A.Dummy <IReturningOperation <Version> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NullTwoStatementOp <Version, Version>(
A.Dummy <IReturningOperation <Version> >(),
A.Dummy <IReturningOperation <Version> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(NullNumberCellFormat <Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (NumberCellFormatBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new OperationCell <Version>(
A.Dummy <IReturningOperation <Version> >(),
A.Dummy <string>(),
A.Dummy <int?>(),
A.Dummy <string>(),
A.Dummy <Validation>(),
A.Dummy <IReadOnlyList <CellValidationEventBase> >(),
A.Dummy <Availability>(),
A.Dummy <AvailabilityCheck>(),
A.Dummy <IReadOnlyList <CellAvailabilityCheckEventBase> >(),
A.Dummy <IReadOnlyList <CellOpExecutionEventBase> >(),
A.Dummy <ICellValueFormat <Version> >(),
A.Dummy <CellFormat>(),
A.Dummy <IHoverOver>(),
A.Dummy <ILink>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(OperationCell <Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (OperationOutputCellBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new OrElseOp(
A.Dummy <IReadOnlyCollection <IReturningOperation <bool> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new OuterBorder(
A.Dummy <BorderWeight>(),
A.Dummy <BorderStyle>(),
A.Dummy <Color>(),
A.Dummy <OuterBorderSides>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(ConstCell <Version>),
typeof(OperationCell <Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (OutputCellBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PercentCellValueFormat(
A.Dummy <NumberFormatPercentDisplayKind?>(),
A.Dummy <int?>(),
A.Dummy <char?>(),
A.Dummy <NumberFormatDigitGroupKind?>(),
A.Dummy <char?>(),
A.Dummy <NumberFormatNegativeDisplayKind?>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(CellFormat),
typeof(ColumnFormat),
typeof(DataRowsFormat),
typeof(FooterRowsFormat),
typeof(HeaderRowsFormat),
typeof(RowFormat),
typeof(TableFormat)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (RegionFormatBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new Report(
A.Dummy <string>(),
A.Dummy <IReadOnlyCollection <Section> >(),
A.Dummy <string>(),
A.Dummy <DateTime?>(),
A.Dummy <IReadOnlyList <ILink> >(),
A.Dummy <AdditionalReportInfo>(),
A.Dummy <ReportFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ReportCellLocator(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <SlotSelectionStrategy>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ReportFormat(
A.Dummy <bool?>(),
A.Dummy <DateTimeFormat>(),
A.Dummy <ReportFormatOptions?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new Row(
A.Dummy <IReadOnlyList <ICell> >(),
A.Dummy <string>(),
A.Dummy <RowFormat>(),
A.Dummy <IReadOnlyList <Row> >(),
A.Dummy <IReadOnlyList <FlatRow> >(),
A.Dummy <IReadOnlyList <FlatRow> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(FlatRow),
typeof(Row)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (RowBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new RowFormat(
A.Dummy <IReadOnlyList <OuterBorder> >(),
A.Dummy <IReadOnlyList <InnerBorder> >(),
A.Dummy <CellFormat>(),
A.Dummy <int?>(),
A.Dummy <RowFormatOptions?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new Section(
A.Dummy <string>(),
A.Dummy <TreeTable>(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <SectionFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SectionCellLocator(
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <SlotSelectionStrategy>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SectionFormat(
A.Dummy <SectionFormatOptions?>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SimpleLink(
A.Dummy <LinkTarget>(),
A.Dummy <ILinkedResource>(),
A.Dummy <IReadOnlyList <RegionFormatBase> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(NullSingleStatementOp <Version, Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (SingleStatementOpBase <Version, Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SlottedCell(
A.Dummy <IReadOnlyDictionary <string, INotSlottedCell> >(),
A.Dummy <string>(),
A.Dummy <string>(),
A.Dummy <int?>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(CategoricalCellValueFormat <Version>),
typeof(NullNumberCellFormat <Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (StandardCellValueFormatBase <Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StringHoverOver(
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new StringPayloadLinkedResource(
A.Dummy <string>(),
A.Dummy <StringPayloadLinkedResourceKind>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SumOp(
A.Dummy <IReadOnlyCollection <IReturningOperation <decimal> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new TableColumns(
A.Dummy <IReadOnlyList <Column> >(),
A.Dummy <ColumnFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new TableFormat(
A.Dummy <IReadOnlyList <OuterBorder> >(),
A.Dummy <IReadOnlyList <InnerBorder> >(),
A.Dummy <CellFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new TableRows(
A.Dummy <HeaderRows>(),
A.Dummy <DataRows>(),
A.Dummy <FooterRows>(),
A.Dummy <RowFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ThisCellLocator());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new TreeTable(
A.Dummy <TableColumns>(),
A.Dummy <TableRows>(),
A.Dummy <TableFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(NullTwoStatementOp <Version, Version>)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (TwoStatementOpBase <Version, Version>)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new UrlLinkedResource(
A.Dummy <string>(),
A.Dummy <UrlLinkedResourceKind>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ValidateCellIfNecessaryOp(
A.Dummy <IValidationCell>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ValidateOp(
A.Dummy <ValidationChain>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new Validation(
A.Dummy <IReturningOperation <ValidationResult> >(),
A.Dummy <MessageFormatKind?>(),
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ValidationChain(
A.Dummy <IReadOnlyList <ValidationStep> >(),
A.Dummy <IReturningOperation <string> >(),
A.Dummy <Validity>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ValidationResult(
A.Dummy <IReturningOperation <Validity> >(),
A.Dummy <IReturningOperation <string> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ValidationStep(
A.Dummy <IReturningOperation <bool> >(),
A.Dummy <IReturningOperation <string> >(),
A.Dummy <ValidationStepAction>(),
A.Dummy <ValidationStepAction>(),
A.Dummy <string>()));
}
public DefaultNotificationDummyFactory()
{
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(CouldNotSendOnAnyPreparedChannelEvent),
typeof(SentOnAllPreparedChannelsEvent),
typeof(SentOnSomePreparedChannelsEvent)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (AttemptToSendNotificationEventBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AttemptToSendNotificationResult(
A.Dummy <IReadOnlyDictionary <IDeliveryChannel, IReadOnlyCollection <ChannelOperationOutcomeInfo> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(EveryoneAudience),
typeof(VoidAudience)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (AudienceBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AudienceOptedOutOfAllChannelsEvent(
A.Dummy <long>(),
A.Dummy <DateTime>(),
A.Dummy <GetAudienceResult>(),
A.Dummy <GetDeliveryChannelConfigsResult>(),
A.Dummy <PrepareToSendNotificationResult>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(AudienceVoidNotification)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (AudienceSpecifiedNotificationBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new AudienceVoidNotification(
A.Dummy <IAudience>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new BuildTagsOp <AudienceOptedOutOfAllChannelsEvent>(
A.Dummy <long>(),
A.Dummy <AudienceOptedOutOfAllChannelsEvent>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ChannelOperationInstruction(
A.Dummy <IOperation>(),
A.Dummy <ChannelOperationMonitoringInfo>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ChannelOperationMonitoringInfo(
A.Dummy <long>(),
A.Dummy <TypeRepresentation>(),
A.Dummy <TypeRepresentation>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ChannelOperationOutcomeInfo(
A.Dummy <long>(),
A.Dummy <TypeRepresentation>(),
A.Dummy <ChannelOperationOutcome>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CouldNotGetOrUseAudienceEvent(
A.Dummy <long>(),
A.Dummy <DateTime>(),
A.Dummy <GetAudienceResult>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CouldNotGetOrUseDeliveryChannelConfigsEvent(
A.Dummy <long>(),
A.Dummy <DateTime>(),
A.Dummy <GetAudienceResult>(),
A.Dummy <GetDeliveryChannelConfigsResult>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CouldNotPrepareToSendOnAnyChannelEvent(
A.Dummy <long>(),
A.Dummy <DateTime>(),
A.Dummy <GetAudienceResult>(),
A.Dummy <GetDeliveryChannelConfigsResult>(),
A.Dummy <PrepareToSendNotificationResult>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new CouldNotSendOnAnyPreparedChannelEvent(
A.Dummy <long>(),
A.Dummy <DateTime>(),
A.Dummy <AttemptToSendNotificationResult>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(EmailDeliveryChannel),
typeof(SlackDeliveryChannel)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (DeliveryChannelBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new DeliveryChannelConfig(
A.Dummy <IDeliveryChannel>(),
A.Dummy <DeliveryChannelAction>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EmailDeliveryChannel());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new EveryoneAudience());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ExceptionThrownFailure(
A.Dummy <string>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(ExceptionThrownFailure)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (FailureBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new File(
A.Dummy <byte[]>(),
A.Dummy <string>(),
A.Dummy <FileFormat>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetAudienceOp(
A.Dummy <INotification>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetAudienceResult(
A.Dummy <IAudience>(),
A.Dummy <IReadOnlyCollection <IFailure> >(),
A.Dummy <FailureAction>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetDeliveryChannelConfigsOp(
A.Dummy <INotification>(),
A.Dummy <IAudience>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new GetDeliveryChannelConfigsResult(
A.Dummy <IReadOnlyCollection <DeliveryChannelConfig> >(),
A.Dummy <IReadOnlyCollection <IFailure> >(),
A.Dummy <FailureAction>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(AudienceVoidNotification),
typeof(VoidNotification)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (NotificationBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(AudienceOptedOutOfAllChannelsEvent),
typeof(CouldNotGetOrUseAudienceEvent),
typeof(CouldNotGetOrUseDeliveryChannelConfigsEvent),
typeof(CouldNotPrepareToSendOnAnyChannelEvent),
typeof(CouldNotSendOnAnyPreparedChannelEvent),
typeof(PreparedToSendOnAllChannelsEvent),
typeof(PreparedToSendOnSomeChannelsEvent),
typeof(SendNotificationRequestedEvent),
typeof(SentOnAllPreparedChannelsEvent),
typeof(SentOnSomePreparedChannelsEvent)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (NotificationEventBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new NotificationTrackingCode(
A.Dummy <long>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PreparedToSendOnAllChannelsEvent(
A.Dummy <long>(),
A.Dummy <DateTime>(),
A.Dummy <GetAudienceResult>(),
A.Dummy <GetDeliveryChannelConfigsResult>(),
A.Dummy <PrepareToSendNotificationResult>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PreparedToSendOnSomeChannelsEvent(
A.Dummy <long>(),
A.Dummy <DateTime>(),
A.Dummy <GetAudienceResult>(),
A.Dummy <GetDeliveryChannelConfigsResult>(),
A.Dummy <PrepareToSendNotificationResult>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() =>
{
var availableTypes = new[]
{
typeof(AudienceOptedOutOfAllChannelsEvent),
typeof(CouldNotPrepareToSendOnAnyChannelEvent),
typeof(PreparedToSendOnAllChannelsEvent),
typeof(PreparedToSendOnSomeChannelsEvent)
};
var randomIndex = ThreadSafeRandom.Next(0, availableTypes.Length);
var randomType = availableTypes[randomIndex];
var result = (PrepareToSendNotificationEventBase)AD.ummy(randomType);
return(result);
});
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PrepareToSendNotificationResult(
A.Dummy <IReadOnlyDictionary <IDeliveryChannel, PrepareToSendOnChannelResult> >(),
A.Dummy <CannotPrepareToSendOnChannelAction>(),
A.Dummy <IReadOnlyCollection <IDeliveryChannel> >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PrepareToSendOnChannelOp(
A.Dummy <INotification>(),
A.Dummy <IAudience>(),
A.Dummy <IDeliveryChannel>(),
A.Dummy <IReadOnlyCollection <NamedValue <string> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new PrepareToSendOnChannelResult(
A.Dummy <IReadOnlyList <ChannelOperationInstruction> >(),
A.Dummy <IReadOnlyCollection <IFailure> >(),
A.Dummy <PrepareToSendOnChannelFailureAction>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new ProcessSendNotificationSagaOp(
A.Dummy <long>(),
A.Dummy <IReadOnlyDictionary <IDeliveryChannel, IReadOnlyList <ChannelOperationMonitoringInfo> > >()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SendNotificationOp(
A.Dummy <INotification>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SendNotificationRequestedEvent(
A.Dummy <long>(),
A.Dummy <DateTime>(),
A.Dummy <SendNotificationOp>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SentOnAllPreparedChannelsEvent(
A.Dummy <long>(),
A.Dummy <DateTime>(),
A.Dummy <AttemptToSendNotificationResult>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SentOnSomePreparedChannelsEvent(
A.Dummy <long>(),
A.Dummy <DateTime>(),
A.Dummy <AttemptToSendNotificationResult>()));
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new SlackDeliveryChannel());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new VoidAudience());
AutoFixtureBackedDummyFactory.AddDummyCreator(
() => new VoidNotification());
}
