public static string ExpandSecondary(GenDataDef genDataDef, GenObject genObject, Fragment fragment)
{
if (fragment is ContainerFragment)
{
return(Create(genDataDef, genObject, fragment).ExpandSecondary());
}
return("");
}
public void MinimalGenDataAsDefTest()
{
var f = GenDataDef.CreateMinimal();
var d = f.AsGenDataBase();
var f0 = d.AsDef();
VerifyAsDef(f0);
}
public void GenDefTextParametersTest()
{
var f0 = GenDataDef.CreateMinimal();
var d = new GenParameters(f0, GenDataSaveText);
var f = d.AsDef();
VerifyAsDef(f);
}
/// <summary>
/// Load the GenData from the specified path using the given definition.
/// </summary>
/// <param name="dataDef">The definition of the data being loaded.</param>
/// <param name="path">The path of the data to be loaded.</param>
/// <returns>The loaded data.</returns>
public GenDataBase LoadData(GenDataDef dataDef, string path)
{
using (var stream = GenParameters.CreateStream(GetFullPath(path)))
return new GenParameters(dataDef, stream)
{
DataName = GetDataName(path)
};
}
public GenLookupParams(GenDataDef genDataDef, GenContainerFragmentBase parentContainer, string condition, bool isPrimary = true)
: base(genDataDef, parentContainer, FragmentType.Lookup, isPrimary: isPrimary)
{
var sa = condition.Split('=');
Var1 = GenDataDef.GetId(sa[0]);
Var2 = GenDataDef.GetId(sa[1]);
}
protected static GenDataBase SetUpLookupData()
{
var f = GenDataDef.CreateMinimal();
var d = SetUpLookupData(f);
return(d);
}
public GenSegment(GenSegmentParams genSegmentParams)
: base(genSegmentParams.SetFragmentType(FragmentType.Segment))
{
Segment = (Segment)Fragment;
Body.ParentSegment = this;
ClassId = GenDataDef.GetClassId(genSegmentParams.ClassName);
Segment.Cardinality = genSegmentParams.Cardinality.ToString();
}
public GenConditionParams(GenDataDef genDataDef, GenContainerFragmentBase parentContainer, ConditionParameters conditionParameters, bool isPrimary = true)
: base(genDataDef, parentContainer, FragmentType.Condition, isPrimary: isPrimary)
{
Var1 = conditionParameters.Var1;
Var2 = conditionParameters.Var2;
GenComparison = conditionParameters.GenComparison;
UseLit = conditionParameters.UseLit;
Lit = conditionParameters.Lit;
}
private void ScanPlaceholder(GenContainerFragmentBase parentContainer,
ref GenTextBlock textBlock, bool isPrimary)
{
AddText(parentContainer, ref textBlock, GenDataDef.GetId(Scan.ScanName()), GenDataDef, isPrimary);
if (Scan.CheckChar(Scan.Delimiter))
{
Scan.SkipChar();
}
}
public void ReferenceCacheSelfTest()
{
var d = GenDataDef.CreateMinimal().AsGenData();
d.Cache.Check("Minimal", "self");
var self = d.Cache["self"];
Assert.AreSame(d, self);
}
private static void ValidateProfileFragmentBodyList(GenDataDef profileDataDef, GenNamedApplicationList <FragmentBody> fragmentBodies)
{
foreach (var body in fragmentBodies)
{
VerifyObjectClass(profileDataDef, "FragmentBody", body.GenObject);
Assert.AreEqual(1, fragmentBodies.Count(body0 => body0.Name == body.Name),
"Fragment body names must be unique: " + body.Name);
}
}
public static GenDataDef GetDefinition()
{
var f = new GenDataDef();
f.DefinitionName = "ProfileDefinition";
f.AddSubClass("", "ProfileRoot");
f.AddSubClass("ProfileRoot", "FragmentBody");
f.AddSubClass("FragmentBody", "Fragment");
f.AddInheritor("Fragment", "Null");
f.AddInheritor("Fragment", "Text");
f.AddInheritor("Fragment", "Placeholder");
f.AddInheritor("Fragment", "ContainerFragment");
f.AddInheritor("ContainerFragment", "Profile");
f.AddInheritor("ContainerFragment", "Segment");
f.AddInheritor("ContainerFragment", "Block");
f.AddInheritor("ContainerFragment", "Lookup");
f.AddInheritor("ContainerFragment", "Condition");
f.AddInheritor("ContainerFragment", "Function");
f.AddInheritor("ContainerFragment", "TextBlock");
f.AddInheritor("ContainerFragment", "Annotation");
f.Classes[1].AddInstanceProperty("Name");
f.Classes[1].AddInstanceProperty("Title");
f.Classes[2].AddInstanceProperty("Name");
f.Classes[3].AddInstanceProperty("Name");
f.Classes[4].AddInstanceProperty("Name");
f.Classes[4].AddInstanceProperty("TextValue");
f.Classes[5].AddInstanceProperty("Name");
f.Classes[5].AddInstanceProperty("Class");
f.Classes[5].AddInstanceProperty("Property");
f.Classes[6].AddInstanceProperty("Name");
f.Classes[6].AddInstanceProperty("Primary");
f.Classes[6].AddInstanceProperty("Secondary");
f.Classes[7].AddInstanceProperty("Name");
f.Classes[8].AddInstanceProperty("Name");
f.Classes[8].AddInstanceProperty("Class");
f.Classes[8].AddInstanceProperty("Cardinality");
f.Classes[9].AddInstanceProperty("Name");
f.Classes[10].AddInstanceProperty("Name");
f.Classes[10].AddInstanceProperty("NoMatch");
f.Classes[10].AddInstanceProperty("Class1");
f.Classes[10].AddInstanceProperty("Property1");
f.Classes[10].AddInstanceProperty("Class2");
f.Classes[10].AddInstanceProperty("Property2");
f.Classes[11].AddInstanceProperty("Name");
f.Classes[11].AddInstanceProperty("Class1");
f.Classes[11].AddInstanceProperty("Property1");
f.Classes[11].AddInstanceProperty("Comparison");
f.Classes[11].AddInstanceProperty("Class2");
f.Classes[11].AddInstanceProperty("Property2");
f.Classes[11].AddInstanceProperty("Lit");
f.Classes[11].AddInstanceProperty("UseLit");
f.Classes[12].AddInstanceProperty("Name");
f.Classes[12].AddInstanceProperty("FunctionName");
f.Classes[13].AddInstanceProperty("Name");
f.Classes[14].AddInstanceProperty("Name");
return(f);
}
public void GetGenDataBaseReferencesLoadTest()
{
var d = GenDataDef.CreateMinimal().AsGenData();
d.GenDataBase.References.Add("Data/Definition", "Minimal");
d.LoadCache();
Assert.That(d.Cache.Contains("minimal"));
Assert.That(d.Cache.Contains("data\\definition"));
}
/// <summary>
/// Parameters for creating a GenFragment
/// </summary>
/// <param name="genDataDef">The definition of the data being generated.</param>
/// <param name="parentContainer">The container fragment conataining this fragment.</param>
/// <param name="fragmentType">The type of fragment.</param>
/// <param name="isPrimary">Is this fragmnent in the primary body?</param>
public GenFragmentParams(GenDataDef genDataDef, GenContainerFragmentBase parentContainer, FragmentType fragmentType, bool isPrimary = true)
{
Contract.Requires(parentContainer != null);
Contract.Ensures(fragmentType == FragmentType.Profile || Fragment != null);
GenDataDef = genDataDef;
ParentContainer = parentContainer;
Container = ParentContainer == null ? null : (ContainerFragment)ParentContainer.Fragment;
IsPrimary = isPrimary;
SetFragmentType(fragmentType);
}
public GenCompactProfileParser(GenDataDef genDataDef, string filePath, string textToScan, char delimiter = '`')
: this(
genDataDef,
string.IsNullOrEmpty(filePath)
? new CompactProfileScanner(textToScan) { Delimiter = delimiter }
: new CompactProfileScanner(new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{ Delimiter = delimiter }
)
{
}
public void GenAttributeTests()
{
var f = GenDataDef.CreateMinimal();
var d = new GenDataBase(f);
var o = CreateGenObject(d.Root, "Class", "Class");
CreateGenObject(o, "SubClass", "SubClass");
VerifyDataCreation(d);
}
public void ContextNoReferencePropertyExistsNoReferenceTest()
{
var f = GenDataDef.CreateMinimal();
var d = new GenDataBase(f);
SetUpData(d);
var genObject = GenObject.GetContext(d.Root, "Class");
var id = f.GetId("Class.Reference");
Assert.AreEqual("", genObject.GetValue(id));
}
private void AddText(GenContainerFragmentBase parentContainer,
ref GenTextBlock textBlock, GenDataId id, GenDataDef genDataDef, bool isPrimary)
{
if (id.ClassId == -1 || id.PropertyId == -1)
{
throw new GeneratorException(Scan.Buffer.ToString() + id, GenErrorType.ProfileError);
}
CheckTextBlock(parentContainer, ref textBlock, genDataDef, isPrimary);
textBlock.Body.Add(
new GenPlaceholderFragment(new GenPlaceholderFragmentParams(GenDataDef, textBlock, id)));
}
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 NewGenDataDefTest()
{
var def = new GenDataDef();
Assert.AreEqual(1, def.Classes.Count, "Classes in a new def");
Assert.AreEqual("", def.GetClassName(0), "Dummy root class name");
Assert.AreEqual(0, def.GetClassId(""), "Index of dummy root");
Assert.AreEqual(0, def.GetClassSubClasses(0).Count, "Subclasses of dummy root");
Assert.IsNull(def.GetClassParent(0), "Parent of dummy root");
Assert.IsEmpty(def.GetClassProperties(0), "Dummy root has no properties");
}
public void EmptyGenDataAsDefTest()
{
var f = GenDataDef.CreateMinimal();
var d = new GenDataBase(f);
var f0 = d.AsDef();
Assert.AreEqual(1, f0.Classes.Count); // Root class only
Assert.AreEqual("", f0.GetClassName(0));
Assert.AreEqual(0, f0.GetClassProperties(0).Count);
Assert.AreEqual(0, f0.GetClassSubClasses(0).Count);
}
public void GenPlaceholderTest()
{
var r = new GenProfileFragment(new GenProfileParams(GenData.GenDataDef));
var g =
new GenPlaceholderFragment(new GenPlaceholderFragmentParams(GenDataDef, r,
GenDataDef.GetId("Property.Name")));
g.GenObject = GetNextObjectInSubClass(GetFirstObjectOfSubClass(GetFirstObject(GenData), "Property"));
VerifyFragment(GenData, g, "GenPlaceholderFragment", FragmentType.Placeholder, "Property.Name", "`Property.Name`",
"Property2", true, null, r.Profile.GenDataBase.GenDataDef);
}
protected static GenDataDef SetUpParentChildDef(string parentClassName, string childClassName)
{
var def = new GenDataDef {
DefinitionName = parentClassName
};
def.AddSubClass("", parentClassName);
def.AddClassInstanceProperty(1, "Name");
SetUpChildDef(parentClassName, childClassName, def);
return(def);
}
protected static GenDataBase SetUpData()
{
var f = GenDataDef.CreateMinimal();
var d = new GenDataBase(f);
var c = CreateGenObject(d.Root, "Class", "Class");
CreateGenObject(c, "SubClass", "SubClass");
CreateGenObject(c, "Property", "Property");
CreateGenObject(c, "Property", "Property2");
return(d);
}
private static void CheckTextBlock(GenDataDef genDataDef, ref GenTextBlock textBlock,
GenContainerFragmentBase classProfile)
{
if (textBlock == null)
{
textBlock =
new GenTextBlock(new GenFragmentParams(genDataDef, classProfile,
FragmentType.TextBlock));
classProfile.Body.Add(textBlock);
}
}
public void ContextNoFirstPropertyExistsSecondTest()
{
var f = GenDataDef.CreateMinimal();
var d = new GenDataBase(f);
SetUpData(d);
CreateGenObject(d.Root, "Class", "Class0");
var genObject = GetNextObjectInSubClass(GenObject.GetContext(d.Root, "Class"));
var id = f.GetId("Class.First");
Assert.AreEqual("", genObject.GetValue(id));
}
public void ReferenceCacheFilePathTest()
{
var d = GenDataDef.CreateMinimal().AsGenData();
d.GenDataBase.References.Add("Data/Minimal", "Data/Minimal");
d.GenDataBase.References.Add("Data/Definition", "Data/Minimal");
d.LoadCache();
var minimal = d.Cache["Data/Minimal"];
var definition = d.Cache["Data/Definition"];
Assert.AreNotSame(minimal, definition);
}
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 void ContextEmptyFirstPropertyExistsTest()
{
var f = GenDataDef.CreateMinimal();
f.AddClassInstanceProperty(1, "First");
var d = new GenDataBase(f);
SetUpData(d);
var genObject = GenObject.GetContext(d.Root, "Class");
var id = f.GetId("Class.First");
Assert.AreEqual("", genObject.GetValue(id));
}
protected static GenDataDef SetUpParentChildReferenceDef(string parentClassName, string childClassName,
string childDefName, GenDataDef defChild)
{
var def = new GenDataDef {
DefinitionName = parentClassName
};
def.Cache.Internal(childDefName, defChild);
def.AddSubClass("", parentClassName);
def.AddClassInstanceProperty(1, "Name");
def.AddSubClass(parentClassName, childClassName, childDefName);
return(def);
}
