public void ChildReferenceGenDataSaveTests()
{
const string fileNameDef = "ChildDef.dcb";
const string expectedDef = ReferenceChildDefText;
const string fileName = "Child.dcb";
const string expected = ReferenceChildText;
var dataGrandchildhild = SetUpParentChildData("Grandchild", "Greatgrandchild", "Greatgrandchild");
var dataChild = SetUpParentChildReferenceData("Child", "Grandchild", "GrandchildDef", "Grandchild", dataGrandchildhild);
var genData = dataChild;
Assert.AreEqual("GrandchildDef", genData.GenDataDef.GetClassSubClasses(1)[0].Reference);
var d = genData.GenDataDef.AsGenDataBase();
Assert.AreEqual("GrandchildDef", GetFirstObjectOfSubClass(GetFirstObject(d), "SubClass").Attributes[1]);
GenParameters.SaveToFile(d, fileNameDef);
var file = File.ReadAllText(fileNameDef);
Assert.AreEqual(expectedDef, file);
GenParameters.SaveToFile(genData, fileName);
file = File.ReadAllText(fileName);
Assert.AreEqual(expected, file);
}
public void GenParameterNestedReferenceTest()
{
EnsureFileExists("ChildDef.dcb", ".");
EnsureFileExists("GrandchildDef.dcb", ".");
EnsureFileExists("Grandchild.dcb", ".");
CreateGenDataSaveText("Child.dcb", ReferenceChildDefText);
CreateGenDataSaveText("Child.txt", ReferenceChildText);
GenParameters f;
using (var s = new FileStream("Child.dcb", FileMode.Open, FileAccess.ReadWrite))
f = new GenParameters(s)
{
DataName = "Child"
};
GenDataBase d;
using (var s = new FileStream("Child.txt", FileMode.Open, FileAccess.ReadWrite))
d = new GenParameters(f.AsDef(), s)
{
DataName = "Child"
};
Assert.AreEqual(4, d.GenDataDef.Classes.Count);
var child = GetFirstObject(d);
Assert.AreEqual("Child", child.Attributes[0]);
var grandchild = GetFirstObjectOfSubClass(child, "grandchild");
Assert.IsNotNull(grandchild);
Assert.That(d.Cache.ContainsKey("grandchild"));
}
public void DirectoryFileStreamProfileTest()
{
const string dir = "TestDir";
const string fileName = dir + @"\GenProfileTest.dcb";
var f = GenDataDef.CreateMinimal();
var d = f.AsGenDataBase();
if (File.Exists(fileName))
{
File.Delete(fileName);
}
if (Directory.Exists(dir))
{
Directory.Delete(dir);
}
GenParameters.SaveToFile(d, fileName);
Assert.IsTrue(Directory.Exists(dir), "Output directory is not created.");
Assert.IsTrue(File.Exists(fileName));
GenParameters d1;
using (var stream = new FileStream(fileName, FileMode.Open))
d1 = new GenParameters(stream)
{
DataName = "GenProfileTest"
};
VerifyDataCreation(d1);
}
public void GenParameterReferenceReferredTest()
{
CreateGenDataSaveText("Grandchild.dcb", ReferenceGrandchildDefText);
CreateGenDataSaveText("Grandchild.txt", ReferenceGrandchildText);
GenParameters f;
using (var s = new FileStream("Grandchild.dcb", FileMode.Open, FileAccess.ReadWrite))
f = new GenParameters(s)
{
DataName = "Grandchild"
};
GenDataBase d;
using (var s = new FileStream("Grandchild.txt", FileMode.Open, FileAccess.ReadWrite))
d = new GenParameters(f.AsDef(), s)
{
DataName = "Grandchild"
};
Assert.AreEqual(3, d.GenDataDef.Classes.Count);
var grandchild = GetFirstObject(d);
Assert.AreEqual("Grandchild", grandchild.Attributes[0]);
var greatgrandchild = GetFirstObjectOfSubClass(grandchild, "greatgrandchild");
Assert.IsNotNull(greatgrandchild);
}
public void Generate()
{
if (Settings.FileGroup.Profile == "")
{
return;
}
GenParameters d;
var data = BuildFilePath(Settings.FileGroup.FilePath, Settings.FileGroup.FileName);
using (var dataStream = new FileStream(data, FileMode.Open))
d = new GenParameters(GenDataDef, dataStream)
{
DataName = Path.GetFileNameWithoutExtension(data)
};
var baseFile = Settings.GetBaseFiles().Find(Settings.FileGroup.BaseFileName);
var profile = baseFile.ProfileList.Find(Settings.FileGroup.Profile);
var profileFileName = BuildFilePath(profile.FilePath, profile.FileName);
var p = new GenCompactProfileParser(GenDataDef, profileFileName, "")
{
GenObject = d.Root
};
using (var writer = new GenWriter(null)
{
FileName = Settings.GeneratedFile.Replace('/', '\\')
})
p.Generate(d, writer);
}
public void GenTextParametersTest()
{
var d = new GenParameters(GenDataSaveText);
var f = d.AsDef();
VerifyAsDef(f);
}
/// <summary>
/// Create a new file and save the file group.
/// </summary>
/// <param name="fileGroup">The file group defining the new file.</param>
public void CreateFile(FileGroup fileGroup)
{
fileGroup.SaveFields();
if (!File.Exists(BuildFilePath(fileGroup.FilePath, fileGroup.FileName).Replace('/', '\\')))
{
var dataDef = Settings.FindBaseFile(fileGroup.BaseFileName);
var f = GenDataBase.DataLoader.LoadData(BuildFilePath(dataDef.FilePath, dataDef.FileName)).AsDef();
var d = new GenDataBase(f);
var fileName = BuildFilePath(fileGroup.FilePath, fileGroup.FileName);
GenParameters.SaveToFile(d, fileName);
}
if (Settings.FindFileGroup(fileGroup.Name) == null)
{
Settings.Model.GenSettingsList[0].AddFileGroup(fileGroup.Name, fileGroup.FileName, fileGroup.FilePath,
fileGroup.BaseFileName, fileGroup.Profile, fileGroup.GeneratedFile);
}
if (fileGroup.BaseFileName == "Definition")
{
AddBaseFile(fileGroup);
}
SetFileGroup(fileGroup.Name);
SaveSettings();
}
static IEnumerable <IGenIteration <TResult> > BindExampleSpace(
IExampleSpace <T> exampleSpace,
Func <T, IGen <TResult> > selector,
GenParameters parameters)
{
return(selector(exampleSpace.Current.Value).Advanced
.Run(parameters)
.TakeWhileInclusive(iteration => !iteration.IsInstance())
.Select(iteration =>
{
return iteration.Match(
onInstance: instance =>
{
var jointExampleSpace = JoinExampleSpaces(
exampleSpace,
instance.ExampleSpace,
selector,
parameters);
return GenIterationFactory.Instance(
iteration.ReplayParameters,
iteration.NextParameters,
jointExampleSpace);
},
onError: error => error,
onDiscard: discard => discard);
}));
};
protected override IEnumerable <IGenIteration <T> > Run(GenParameters parameters)
{
while (true)
{
yield return(GenIterationFactory.Error <T>(parameters, parameters, _genName, _message));
}
}
public void GenDefTextParametersTest()
{
var f0 = GenDataDef.CreateMinimal();
var d = new GenParameters(f0, GenDataSaveText);
var f = d.AsDef();
VerifyAsDef(f);
}
private void LoadParametersWithDef()
{
using (var dataStream = new FileStream(Args.Data, FileMode.Open))
GenParameters = new GenParameters(GenDataDef, dataStream)
{
DataName = Path.GetFileNameWithoutExtension(Args.Data)
};
}
private void SaveSettings()
{
if ((SaveToDisk &&
(Settings.FileGroup == null || Settings.FileGroup.FileName == null ||
!Settings.FileGroup.FileName.Equals("Settings.dcb", StringComparison.InvariantCultureIgnoreCase))))
{
GenParameters.SaveToFile(Settings.Model.GenDataBase, "Data/Settings.dcb");
}
}
public GenIteration(
GenParameters replayParameters,
GenParameters nextParameters,
IGenData <T> data)
{
ReplayParameters = replayParameters;
NextParameters = nextParameters;
Data = data;
}
public void InheritanceDataProfileTest()
{
var df = SetUpVirtualDefinition();
var d = df.GenDataBase;
var p = GenParameters.CreateProfile(d.AsDef());
var profileText = p.ProfileText(ProfileFragmentSyntaxDictionary.ActiveProfileFragmentSyntaxDictionary).Replace(">:", ":");
Assert.AreEqual(VirtualDefinitionProfile, profileText);
}
public void InheritanceDataExpansionTest()
{
var dataFile = GetTestDataFileName("InheritanceDataExpansionTest");
var d = PopulateInheritanceData(dataFile);
GenParameters.SaveToFile(d, dataFile);
var text = File.ReadAllText(dataFile);
Assert.AreEqual(VirtualDefinitionData, text);
}
IEnumerable <IGenIteration <T> > GenFunc(GenParameters parameters)
{
while (true)
{
var replayParameters = parameters;
var(value, nextParameters) = func(replayParameters);
parameters = nextParameters;
yield return(GenIterationFactory.Instance(replayParameters, nextParameters, ExampleSpaceFactory.Singleton(value)));
}
}
public void ReferenceOutputProfileTest()
{
var dataGrandchildhild = SetUpParentChildData("Grandchild", "Greatgrandchild", "Greatgrandchild");
var dataChild = SetUpParentChildReferenceData("Child", "Grandchild", "GrandchildDef", "Grandchild", dataGrandchildhild);
var dataParent = SetUpParentChildReferenceData("Parent", "Child", "ChildDef", "Child", dataChild);
var p = GenParameters.CreateProfile(dataParent.GenDataDef);
Assert.AreEqual(GenDataDefProfile.CreateProfile(dataParent.GenDataDef),
p.ProfileText(ProfileFragmentSyntaxDictionary.ActiveProfileFragmentSyntaxDictionary)
.Replace(">:", ":"));
}
private void LoadDef(Args args)
{
GenParameters f;
using (var definitionStream = new FileStream(args.Definition, FileMode.Open))
f = new GenParameters(definitionStream)
{
DataName = Path.GetFileNameWithoutExtension(args.Definition)
};
GenDataDef = f.AsDef();
}
public void InheritanceDataSaveTest()
{
var dataFile = GetTestDataFileName("InheritanceDataSaveTest");
var d = PopulateInheritanceData(dataFile);
var p = GenParameters.CreateProfile(d.GenDataDef);
p.GenObject = d.Root;
var text = GenFragmentExpander.Expand(d.GenDataDef, d.Root, p.Fragment);
Assert.AreEqual(VirtualDefinitionData, text);
}
public void OutputProfileTest()
{
var f0 = GenDataDef.CreateMinimal();
var p = GenParameters.CreateProfile(f0);
var p0 = GenDataDefProfile.CreateProfile(f0);
Assert.AreEqual(p0,
p.ProfileText(ProfileFragmentSyntaxDictionary.ActiveProfileFragmentSyntaxDictionary)
.Replace(">:", ":"));
ValidateProfileData(p, f0);
}
public void GenFileParameterDefinitionExtractTest()
{
CreateGenDataSaveText("GenFileParameterDefinitionExtractTest.txt");
GenDataDef f;
using (var s = new FileStream("GenFileParameterDefinitionExtractTest.txt", FileMode.Open, FileAccess.ReadWrite))
{
f = GenParameters.ExtractDef(s);
Assert.AreEqual(0, s.Position);
}
VerifyAsDef(f);
}
public void EmptySettingsTest()
{
var f = GenDataBase.DataLoader.LoadData("GeneratorEditor").AsDef();
var d = new GenDataBase(f);
GenParameters.SaveToFile(d, "Settings.dcb");
var data = new GeData();
data.Settings = data.GetDefaultSettings();
Assert.AreEqual(0, data.Settings.GetFileGroups().Count);
Assert.AreEqual(1, data.Settings.GetBaseFiles().Count);
}
public static string CreateProfile(GenDataDef genDataDef)
{
var def = new StringBuilder();
def.Append("Definition=");
def.AppendLine(genDataDef.DefinitionName);
GenParameters.ClassDefinition(genDataDef, 0, def);
var profile = new StringBuilder();
ClassProfile(genDataDef, 0, profile);
return(def + ".\r\n" + profile);
}
public static Replay Decode(string str)
{
var decompressed = DecompressString(str);
var components = decompressed.Split('.');
var seed = DecodeInt(components[0]);
var size = DecodeInt(components[1]);
var exampleSpacePath = DecodeExampleSpacePath(components[2]);
return(new Replay(
GenParameters.Create(seed, size),
exampleSpacePath));
}
public void SaveFile(FileGroup fileGroup)
{
fileGroup.SaveFields();
var fileName = BuildFilePath(fileGroup.FilePath, fileGroup.FileName);
GenParameters.SaveToFile(GenDataBase, fileName);
if (Settings.FindFileGroup(fileGroup.Name) == null)
{
Settings.GetFileGroups().Add(fileGroup);
}
SetFileGroup(fileGroup.Name);
SaveSettings();
}
public void GenParameterTest()
{
CreateGenDataSaveText("GenParameterTest.txt");
GenParameters d;
using (var s = new FileStream("GenParameterTest.txt", FileMode.Open, FileAccess.ReadWrite))
d = new GenParameters(s)
{
DataName = "GenParameterTest"
};
var f = d.AsDef();
VerifyAsDef(f);
}
static IEnumerable <IExampleSpace <TResult> > BindSubspace(
IExampleSpace <T> leftExampleSpace,
Func <T, IGen <TResult> > selector,
GenParameters parameters)
{
var stream = BindExampleSpace(leftExampleSpace, selector, parameters);
foreach (var iteration in stream)
{
if (iteration.ToEither <TResult, TResult>().IsLeft(out IGenInstance <TResult> instance))
{
yield return(instance.ExampleSpace);
}
}
}
public static CheckResult <T> Check <T>(
this IGen <Test <T> > property,
int?iterations = null,
int?seed = null,
int?size = null,
int?shrinkLimit = null,
string?replay = null,
bool deepCheck = true)
{
var resolvedIterations = iterations ?? 100;
var(initialSize, resizeStrategy) = SizingAspects <T> .Resolve(size == null?null : new Size(size.Value), resolvedIterations);
var initialParameters = seed == null
? GenParameters.Create(initialSize)
: GenParameters.Create(Rng.Create(seed.Value), initialSize);
var initialContext = new CheckStateContext <T>(
property,
resolvedIterations,
shrinkLimit ?? 500,
initialParameters,
deepCheck);
CheckState <T> initialState = replay == null
? new GenerationStates.Generation_Begin <T>()
: new ReplayState <T>(replay);
var transitions = CheckStateEnumerator.Enumerate(
initialState,
initialContext,
new[] { new ResizeCheckStateTransitionDecorator <T>(resizeStrategy) });
var transitionAggregation = AggregateTransitions(transitions);
return(new CheckResult <T>(
transitionAggregation.FinalContext.CompletedIterationsUntilCounterexample,
transitionAggregation.FinalContext.Discards,
transitionAggregation.FinalContext.Shrinks + transitionAggregation.FinalContext.CompletedIterationsAfterCounterexample,
transitionAggregation.FinalContext.Counterexample == null
? null
: FromCounterexampleContext(transitionAggregation.FinalContext.Counterexample),
transitionAggregation.Checks,
initialParameters,
transitionAggregation.FinalContext.NextParameters,
transitionAggregation.TerminationReason));
}
private static SpyEnumerable <IExampleSpace <T> > CreateInfiniteEnumerable(
IGen <T> elementGen,
GenParameters parameters,
int?iterationLimit)
{
var source = elementGen.Advanced
.Run(parameters)
.WithDiscardCircuitBreaker(_ => true, iteration => iteration.IsDiscard())
.Select(iteration => iteration.Match <IGenInstance <T>?>(
onInstance: instance => instance,
onError: _ => null,
onDiscard: _ => null))
.Where(instance => instance != null)
.Select(instance => instance !.ExampleSpace);
return(new SpyEnumerable <IExampleSpace <T> >(ThrowOnLimit(source, iterationLimit)));
}
public void GrandchildReferenceGenDataSaveTests()
{
const string fileNameDef = "GrandchildDef.dcb";
const string expectedDef = ReferenceGrandchildDefText;
const string fileName = "Grandchild.dcb";
const string expected = ReferenceGrandchildText;
var dataGrandchildhild = SetUpParentChildData("Grandchild", "Greatgrandchild", "Greatgrandchild");
GenParameters.SaveToFile(dataGrandchildhild.GenDataDef.AsGenDataBase(), fileNameDef);
var file = File.ReadAllText(fileNameDef);
Assert.AreEqual(expectedDef, file);
GenParameters.SaveToFile(dataGrandchildhild, fileName);
file = File.ReadAllText(fileName);
Assert.AreEqual(expected, file);
}
