public string GenerateInstance(InstanceGenerator instanceGenerator)
{
return(RandomGenerator.Next(256) + "."
+ RandomGenerator.Next(256) + "."
+ RandomGenerator.Next(256) + "."
+ RandomGenerator.Next(256));
}
public T GenerateInstance(InstanceGenerator instanceGenerator)
{
var generateInstance = (T)_fallbackTypeGenerator.GenerateInstance(instanceGenerator);
_fallbackTypeGenerator.FillFieldsAndPropertiesOf(generateInstance, instanceGenerator);
return(generateInstance);
}
public static void GenerateMaTiInstances()
{
// Generate MaTi instances
RandomizerSimple random = new RandomizerSimple(0);
// Generate original MaTi set
Instance tiny = InstanceGenerator.GenerateMaTiLayoutTiny(random, new SettingConfiguration(), new ControlConfiguration());
Instance small = InstanceGenerator.GenerateMaTiLayoutSmall(random, new SettingConfiguration(), new ControlConfiguration());
Instance medium = InstanceGenerator.GenerateMaTiLayoutMedium(random, new SettingConfiguration(), new ControlConfiguration());
Instance large = InstanceGenerator.GenerateMaTiLayoutLarge(random, new SettingConfiguration(), new ControlConfiguration());
Instance huge = InstanceGenerator.GenerateMaTiLayoutHuge(random, new SettingConfiguration(), new ControlConfiguration());
InstanceIO.WriteInstance("MaTiTiny.xinst", tiny);
InstanceIO.WriteInstance("MaTiSmall.xinst", small);
InstanceIO.WriteInstance("MaTiMedium.xinst", medium);
InstanceIO.WriteInstance("MaTiLarge.xinst", large);
InstanceIO.WriteInstance("MaTiHuge.xinst", huge);
// Generate alternative MaTi set
InstanceIO.WriteInstance("MaTiPico.xinst", InstanceGenerator.GenerateMaTiLayoutPico(random, new SettingConfiguration(), new ControlConfiguration()));
InstanceIO.WriteInstance("MaTiNano.xinst", InstanceGenerator.GenerateMaTiLayoutNano(random, new SettingConfiguration(), new ControlConfiguration()));
InstanceIO.WriteInstance("MaTiMicro.xinst", InstanceGenerator.GenerateMaTiLayoutMicro(random, new SettingConfiguration(), new ControlConfiguration()));
InstanceIO.WriteInstance("MaTiMilli.xinst", InstanceGenerator.GenerateMaTiLayoutMilli(random, new SettingConfiguration(), new ControlConfiguration()));
InstanceIO.WriteInstance("MaTiCenti.xinst", InstanceGenerator.GenerateMaTiLayoutCenti(random, new SettingConfiguration(), new ControlConfiguration()));
InstanceIO.WriteInstance("MaTiDeca.xinst", InstanceGenerator.GenerateMaTiLayoutDeca(random, new SettingConfiguration(), new ControlConfiguration()));
InstanceIO.WriteInstance("MaTiHecto.xinst", InstanceGenerator.GenerateMaTiLayoutHecto(random, new SettingConfiguration(), new ControlConfiguration()));
InstanceIO.WriteInstance("MaTiKilo.xinst", InstanceGenerator.GenerateMaTiLayoutKilo(random, new SettingConfiguration(), new ControlConfiguration()));
InstanceIO.WriteInstance("MaTiMega.xinst", InstanceGenerator.GenerateMaTiLayoutMega(random, new SettingConfiguration(), new ControlConfiguration()));
InstanceIO.WriteInstance("MaTiGiga.xinst", InstanceGenerator.GenerateMaTiLayoutGiga(random, new SettingConfiguration(), new ControlConfiguration()));
}
public string GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
return(RandomGenerator.Next(256) + "."
+ RandomGenerator.Next(256) + "."
+ RandomGenerator.Next(256) + "."
+ RandomGenerator.Next(256));
}
public T Resolve(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
try
{
_nestingLimit.AddNestingFor <T>(trace);
if (!_nestingLimit.IsReachedFor <T>())
{
return(_fakeChain.Resolve(instanceGenerator, trace));
}
else
{
try
{
trace.NestingLimitReachedTryingDummy();
return(instanceGenerator.Dummy <T>(trace)); //TODO
}
catch (TargetInvocationException e)
{
return(default(T));
}
catch (MemberAccessException e)
{
return(default(T));
}
catch (ArgumentException e)
{
return(default(T));
}
}
}
finally
{
_nestingLimit.RemoveNestingFor <T>(trace);
}
}
public void TwoStarts()
{
InstanceGenerator.Cleaner(CharacteId1);
bot.StateMachine(CharacterState.NewCharacter, "/start", CharacteId1);
bot.StateMachine(CharacterState.NewCharacter, "/start", CharacteId1);
Assert.AreEqual(_characterRepository.Read(CharacteId1).State, CharacterState.ChangeName);
}
public object GenerateCustomizedInstance(InstanceGenerator instanceGenerator, GenerationRequest request, Type type)
{
var generateInstance = GenerateInstance(instanceGenerator, request, type);
CustomizeCreatedValue(generateInstance, instanceGenerator, request, type);
return(generateInstance);
}
public T Resolve(InstanceGenerator instanceGenerator)
{
try
{
_perTypeNestingLimit.AddNestingFor <T>();
if (!_perTypeNestingLimit.IsReachedFor <T>())
{
return(_fakeChain.Resolve(instanceGenerator));
}
else
{
try
{
return(instanceGenerator.Dummy <T>());
}
catch (TargetInvocationException e)
{
return(default(T));
}
catch (MemberAccessException e)
{
return(default(T));
}
catch (ArgumentException e)
{
return(default(T));
}
}
}
finally
{
_perTypeNestingLimit.RemoveNestingFor <T>();
}
}
public async Task Add_ShallAddItemToCrd()
{
_kubernetesClient
.Setup(p => p.CreateNamespacedCustomObjectWithHttpMessagesAsync(It.IsAny <CustomResourceDefinition>(), It.IsAny <object>()))
.Returns(Task.FromResult(new HttpOperationResponse <object>
{
Response = new HttpResponseMessage()
}));
var job = new Job();
job.JobId = Guid.NewGuid().ToString();
job.PayloadId = Guid.NewGuid().ToString();
var jobStore = new JobStore(
_loggerFactory.Object,
_configuration,
_kubernetesClient.Object,
_fileSystem);
var instance = InstanceGenerator.GenerateInstance("./aet", "aet", fileSystem: _fileSystem);
await jobStore.Add(job, "job-name", new List <InstanceStorageInfo> {
instance
});
_logger.VerifyLoggingMessageBeginsWith($"Failed to add save new job {job.JobId} in CRD", LogLevel.Warning, Times.Never());
_kubernetesClient.Verify(p => p.CreateNamespacedCustomObjectWithHttpMessagesAsync(It.IsAny <CustomResourceDefinition>(), It.IsAny <object>()), Times.Once());
}
public void ShallSaveAndNotify()
{
_dicomToolkit.Setup(p => p.Save(It.IsAny <DicomFile>(), It.IsAny <string>()));
_notificationService.Setup(p => p.NewInstanceStored(It.IsAny <InstanceStorageInfo>()));
var config = new ClaraApplicationEntity();
config.AeTitle = "my-aet";
config.Processor = "Nvidia.Clara.DicomAdapter.Test.Unit.MockJobProcessor, Nvidia.Clara.Dicom.Test.Unit";
var handler = new ApplicationEntityHandler(_serviceProvider, config, _rootStoragePath, _cancellationTokenSource.Token, _fileSystem);
var request = InstanceGenerator.GenerateDicomCStoreRequest();
var instance = InstanceStorageInfo.CreateInstanceStorageInfo(request, _rootStoragePath, config.AeTitle, 1, _fileSystem);
handler.Save(request, instance);
_fileSystem.File.Create(instance.InstanceStorageFullPath);
handler.Save(request, instance);
_logger.VerifyLogging(LogLevel.Error, Times.Never());
_logger.VerifyLogging("Instance already exists, skipping.", LogLevel.Information, Times.Once());
_logger.VerifyLogging("Instance saved successfully.", LogLevel.Debug, Times.Once());
_logger.VerifyLogging("Instance stored and notified successfully.", LogLevel.Information, Times.Once());
_dicomToolkit.Verify(p => p.Save(It.IsAny <DicomFile>(), It.IsAny <string>()), Times.Exactly(1));
_notificationService.Verify(p => p.NewInstanceStored(instance), Times.Once());
}
public async Task Add_ShallRetryOnFailure()
{
_kubernetesClient
.Setup(p => p.CreateNamespacedCustomObjectWithHttpMessagesAsync(It.IsAny <CustomResourceDefinition>(), It.IsAny <object>()))
.Throws(new HttpOperationException("error message")
{
Response = new HttpResponseMessageWrapper(new HttpResponseMessage(HttpStatusCode.Conflict), "error content")
});
var job = new Job();
job.JobId = Guid.NewGuid().ToString();
job.PayloadId = Guid.NewGuid().ToString();
var jobStore = new JobStore(
_loggerFactory.Object,
_configuration,
_kubernetesClient.Object,
_fileSystem);
var instance = InstanceGenerator.GenerateInstance("./aet", "aet", fileSystem: _fileSystem);
await Assert.ThrowsAsync <HttpOperationException>(async() => await jobStore.Add(job, "job-name", new List <InstanceStorageInfo> {
instance
}));
_logger.VerifyLoggingMessageBeginsWith($"Failed to add new job {job.JobId} in CRD", LogLevel.Warning, Times.Exactly(3));
_kubernetesClient.Verify(p => p.CreateNamespacedCustomObjectWithHttpMessagesAsync(It.IsAny <CustomResourceDefinition>(), It.IsAny <object>()), Times.Exactly(4));
}
public T GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var generateInstance = (T)_fallbackTypeGenerator.GenerateInstance(instanceGenerator, trace);
_fallbackTypeGenerator.CustomizeCreatedValue(generateInstance, instanceGenerator, trace);
return(generateInstance);
}
public string GenerateInstance(InstanceGenerator instanceGenerator)
{
var preprocessedStrings = from str in _excludedSubstrings
where !String.IsNullOrEmpty(str)
select str;
var result = _stringGenerator.GenerateInstance(instanceGenerator);
var found = false;
for (int i = 0; i < 100; ++i)
{
result = _stringGenerator.GenerateInstance(instanceGenerator);
if (preprocessedStrings.Any(result.Contains))
{
found = true;
break;
}
}
if (!found)
{
foreach (var excludedSubstring in _excludedSubstrings.Where(s => s != String.Empty))
{
result = result.Replace(excludedSubstring, "");
}
}
return(result);
}
private static object CreateGenericDelegatesForFunction(InstanceGenerator instanceGenerator, MethodInfo methodInfo,
GenerationTrace trace)
{
var fullSignatureTypes = ReturnTypeOf(methodInfo).Concat(ParameterTypes(methodInfo));
return(CreateGenericDelegatesObjectForConcreteTypes(fullSignatureTypes, WithArgumentGeneratedBy(instanceGenerator, methodInfo, trace)));
}
public BaseEvaluator(MilkrunBufferAllocationProblem problem)
{
Flc = InstanceGenerator.Generate(1);
for (var i = 0; i < Flc.NumMachines; i++)
{
Flc.Machines[i].ProcessingRate = problem.ProcessingRates[i];
}
}
public T Apply(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
//todo think it through - should it need access to InlineGenerators?
var elementType = typeof (T).GetElementType();
var array = InlineGenerators.GetByNameAndType(nameof(InlineGenerators.Array), elementType)
.GenerateInstance(instanceGenerator, trace);
return (T)array;
}
public void FindGame()
{
InstanceGenerator.Cleaner(CharacteId1);
bot.StateMachine(CharacterState.NewCharacter, "/start", CharacteId1);
bot.StateMachine(_characterRepository.Read(CharacteId1).State, "Step1", CharacteId1);
bot.StateMachine(_characterRepository.Read(CharacteId1).State, "/game", CharacteId1);
Assert.AreEqual(_characterRepository.Read(CharacteId1).State, CharacterState.FindGame);
}
public int GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var sequence = new IntegerSequence(_startingValue, _step, _simpleValueGenerator.GenerateInstance(instanceGenerator, trace));
var finalSequence = Maybe.OfNullable(Sequences.FirstOrDefault(s => s.Equals(sequence))).ValueOr(sequence);
Sequences.Add(finalSequence);
return(finalSequence.Next());
}
public void SetUserName()
{
InstanceGenerator.Cleaner(CharacteId1);
bot.StateMachine(CharacterState.NewCharacter, "/start", CharacteId1);
bot.StateMachine(_characterRepository.Read(CharacteId1).State, "Step1", CharacteId1);
Assert.AreEqual(_characterRepository.Read(CharacteId1).CharacterName, "Step1");
Assert.AreEqual(_characterRepository.Read(CharacteId1).State, CharacterState.ChangeGameMode);
}
public string GenerateInstance(InstanceGenerator gen)
{
var request = new RegularExpressionRequest(_pattern);
var result = RegexGenerator.Create(request, new DummyContext());
return(result.ToString());
}
public object NewInstanceOf(Type type, InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var typeInfo = type.GetTypeInfo();
var type1 = typeInfo.GetGenericArguments()[0];
var type2 = typeInfo.GetGenericArguments()[1];
return(_factoryMethod.Invoke(type1, type2, instanceGenerator, trace));
}
private static TList MapFieldToProperty <TList, TItem>(DataTable dt, FieldMapperList map)
{
try
{
var result = (TList)InstanceGenerator.Create(typeof(TList));
foreach (DataRow dr in dt.Rows)
{
var innerItem = (TItem)InstanceGenerator.Create(typeof(TItem));
#region Invoke property setter calls
foreach (var item in map)
{
try
{
object value = dr[item.ColumnName];
if (Convert.IsDBNull(value))
{
value = null;
}
DynamicCode.SetProperty(innerItem, item.PropertyName, value);
}
catch (Exception ex)
{
if (item.IsRequired)
{
// set breakpoint here to find out why something fails
Debug.WriteLine(ex.Message);
Debug.WriteLine(DebuggerTool.Dump(ex));
throw;
}
}
}
#endregion
#region Invoke the Add() method to add the inner item to list
try
{
DynamicCode.InvokeMethod(result, "Add", innerItem);
}
catch (Exception ex)
{
// set breakpoint here to find out why something fails
Debug.WriteLine(ex.Message);
throw;
}
#endregion
}
return(result);
}
catch (Exception ex)
{
DebuggerTool.AddData(ex, "dt(XML)", DataUtil.DataTableToXml(dt));
Debug.WriteLine(ex.ToString());
throw;
}
}
private static void Main(string[] args)
{
var algorithm = new BestFitAlgo();
var instance = InstanceGenerator.Generate(1000);
var result = algorithm.Solve(instance, ItemsOrder.VolumeDesc, false);
PrintResult(result);
Console.ReadLine();
}
public object Apply(InstanceGenerator instanceGenerator, GenerationRequest request, Type type)
{
//todo think it through - should it need access to InlineGenerators?
var elementType = type.GetElementType();
var array = InlineGenerators.GetByNameAndType(nameof(InlineGenerators.Array), elementType)
.GenerateInstance(instanceGenerator, request);
return(array);
}
private T WithCustomizations <T>(
InstanceGenerator gen,
GenerationRequest request,
Func <FixtureWrapper, T> creation)
{
using (_generator.Customize(request, gen))
{
return(creation.Invoke(_generator));
}
}
public static ICollection <T> AddTo <T>(ICollection <T> collection, int many,
InstanceGenerator instanceGenerator, GenerationTrace trace)
{
for (int i = 0; i < many; ++i)
{
collection.Add(instanceGenerator.Instance <T>(trace));
}
return(collection);
}
public IEnumerable <T> GenerateInstance(InstanceGenerator instanceGenerator, GenerationRequest request)
{
var list = new List <T>();
list.Add(instanceGenerator.Instance <T>(request));
list.AddRange(_included);
list.Add(instanceGenerator.Instance <T>(request));
return(list);
}
public object Apply(InstanceGenerator instanceGenerator, GenerationRequest request, Type type)
{
var resultType = type.GenericTypeArguments.First();
var parameters = instanceGenerator.Instance(resultType, request);
var result = new GenericMethodProxyCalls().ResultOfGenericVersionOfStaticMethod <Task>(
type.GenericTypeArguments.First(),
"FromResult", parameters);
return(result);
}
public string GenerateInstance(InstanceGenerator instanceGenerator)
{
var result = String.Empty;
for (var i = 0; i < _maxLength; ++i)
{
result += _charGenerator.GenerateInstance(instanceGenerator);
}
return(result);
}
public Dictionary <TKey, TValue> GenerateInstance(InstanceGenerator instanceGenerator, GenerationTrace trace)
{
var dict = new Dictionary <TKey, TValue>();
foreach (var key in _keys)
{
dict.Add(key, instanceGenerator.Instance <TValue>(trace));
}
return(dict);
}
public XFormGenerator(XmlDocument skeleton, XmlNamespaceManager namespaceManager, XmlNode dataRoot, XmlNode templatesRoot, XmlNode labelsRoot, XmlNode stateRoot, XmlNode bindsRoot, XmlNode uiRoot)
{
xform = skeleton;
xformsNamespacePrefix = namespaceManager.LookupPrefix(xformsNamespace);
if(xformsNamespacePrefix == "")
{
xformsNamespacePrefix = "xforms";
namespaceManager.AddNamespace(xformsNamespacePrefix, xformsNamespace);
}
instanceGenerator = new InstanceGenerator(xform, dataRoot);
instanceHandler = (Handler)instanceGenerator;
templateGenerator = new InstanceGenerator(xform, templatesRoot);
templateHandler = (Handler)templateGenerator;
currentLabelsNode = labelsRoot;
currentStateNode = stateRoot;
currentBindsNode = bindsRoot;
currentUINode = uiRoot;
InitialiseCurrentLabelXPath();
}
public void TestContextAttributeThrows()
{
XmlDocument instance = new XmlDocument();
instance.LoadXml("<foo><bar baz=\"blah\" /></foo>");
Assert.Throws<ArgumentException>(delegate { generator = new InstanceGenerator(instance, instance.SelectSingleNode("/foo/bar/@baz")); });
}
public void TestContextElement()
{
XmlDocument instance = new XmlDocument();
instance.LoadXml("<foo><bar /></foo>");
generator = new InstanceGenerator(instance, instance.SelectSingleNode("/foo/bar"));
handler = (Handler)generator;
XmlSchemaElement element = new XmlSchemaElement();
element.Name = "baz";
handler.BeginElement(element);
Assert.AreSame(instance, generator.Result, "Instance generator returned incorrect instance document");
Assert.AreEqual(1, generator.Result.SelectNodes("/foo/bar/*").Count, "Instance generator returned incorrect number of elements");
AssertElement((XmlElement)generator.Result.SelectNodes("/foo/bar/*").Item(0), "baz", "");
}
public void SetUp()
{
generator = new InstanceGenerator();
handler = (Handler)generator;
schemata = new XmlSchemaSet();
}
