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 GenSegmentTest(string cardinalityText, GenCardinality genCardinality, string expected)
{
var cardinality = GenCardinality.All;
var dictionary = ProfileFragmentSyntaxDictionary.ActiveProfileFragmentSyntaxDictionary;
if (cardinalityText != "")
{
for (var i = 0; i < dictionary.GenCardinalityText.Length; i++)
{
if (cardinalityText != dictionary.GenCardinalityText[i])
{
continue;
}
cardinality = (GenCardinality)i;
break;
}
}
var profile = "`[Property" + dictionary.GenCardinalityText[(int)cardinality] + ":`Property.Name`" +
((cardinality == GenCardinality.AllDlm || cardinality == GenCardinality.BackDlm)
? "`;"
: "") + ",`]";
var p = new GenCompactProfileParser(GenData.GenDataDef, "", "`[Class':" + profile + "`]");
var g = (GenSegment)((GenSegment)p.Body.Fragment[0]).Body.Fragment[0];
g.GenObject = GetFirstObject(GenData);
Assert.AreEqual(genCardinality.ToString(), ((Segment)g.Fragment).Cardinality);
Assert.AreEqual("Property", g.Definition.Name);
VerifyFragment(GenData, g, "GenSegment", FragmentType.Segment, "Property", profile, expected, false, null,
p.Profile.GenDataBase.GenDataDef);
}
public void NestedInheritanceClassExpansionTest()
{
var d = LoadVirtualParentData();
var p = new GenCompactProfileParser(d.GenDataDef, "", NestedInheritanceProfile);
var text = GenFragmentExpander.Expand(d.GenDataDef, d.Root, p.Fragment);
Assert.AreEqual(InheritanceProfileResult, text);
}
private static GenSegment SetUpSegmentSeparatorFragment(GenDataBase d, GenCardinality cardinality)
{
var profile = "`[TestData" + (cardinality == GenCardinality.AllDlm ? "/" : "\\") + ":`?TestData.Display:`TestData.Name``]`;, `]";
var p = new GenCompactProfileParser(d.GenDataDef, "", profile);
var g = (GenSegment)p.Body.Fragment[0];
return(g);
}
public void InheritanceClassExpansionTest()
{
var dataFile = GetTestDataFileName("InheritanceClassExpansionTest");
var d = PopulateInheritanceData(dataFile);
var p = new GenCompactProfileParser(d.GenDataDef, "", InheritanceProfile);
var text = GenFragmentExpander.Expand(d.GenDataDef, d.Root, p.Fragment);
Assert.AreEqual(InheritanceProfileResult, text);
}
public void InheritanceClassGenerationTest()
{
var dataFile = GetTestDataFileName("InheritanceClassGenerationTest");
var d = PopulateInheritanceData(dataFile);
var p = new GenCompactProfileParser(d.GenDataDef, "", InheritanceProfile);
var text = GenerateFragment(d, p);
Assert.AreEqual(InheritanceProfileResult, text);
}
protected static GeData LoadProfile(string newProfileText, string fileGroup = "Definition",
string newProfile = "NewProfile", string newProfileTitle = "New Profile Title")
{
var geData = SetUpGeData(fileGroup);
var parser = new GenCompactProfileParser(geData.GenDataDef, "", newProfileText);
geData.Profile.Profile = parser.Profile;
geData.Settings.BaseFile.AddProfile(newProfile, newProfile + ".prf", "Data", newProfileTitle);
return(geData);
}
private static GenProfileFragment ValidateExpansion(GenDataBase d, string txt, FragmentType[] expectedFragmentTypes,
string expectedExpansion, string message, string expectedProfileText = null)
{
var expected = expectedProfileText ?? txt;
var profile = new GenCompactProfileParser(d.GenDataDef, "", txt);
Assert.AreEqual(expectedFragmentTypes.Count(), profile.Body.Count, "Number of fragments expected");
for (var i = 0; i < profile.Body.Count; i++)
{
Assert.AreEqual(expectedFragmentTypes[i], profile.Body.Fragment[i].FragmentType);
}
Assert.AreEqual(expected,
profile.ProfileText(
ProfileFragmentSyntaxDictionary.ActiveProfileFragmentSyntaxDictionary));
Assert.AreEqual(expectedExpansion,
GenFragmentExpander.Expand(d.GenDataDef, d.Root, profile.Fragment),
message);
return(profile);
}
public void GenLookupNoMatchTest()
{
const string txt = "SubClass does not exist";
const string profile = "`[Class:`[SubClass:`%Class.Name=SubClass.Name:`;" + txt + "`]`]`]";
var d = SetUpLookupData();
var f = d.GenDataDef;
var p = new GenCompactProfileParser(f, "", profile);
var g = ((GenSegment)((GenSegment)p.Body.Fragment[0]).Body.Fragment[0]).Body.Fragment[0];
Assert.AreEqual(FragmentType.Lookup, g.FragmentType);
Assert.IsFalse(g.IsTextFragment);
var genFragmentLabel = new GenFragmentLabel(g.Fragment);
Assert.AreEqual("~Class.Name=SubClass.Name", genFragmentLabel.ProfileLabel());
Assert.AreEqual("`%Class.Name=SubClass.Name:`;" + txt + "`]",
g.ProfileText(ProfileFragmentSyntaxDictionary.ActiveProfileFragmentSyntaxDictionary));
var c = GetLastObjectInSubClass(GetFirstObject(d)); // Has no subclasses
Assert.AreEqual("Property", c.Attributes[0]);
var s = GetFirstObjectOfSubClass(c, "SubClass");
g.ParentContainer.GenObject = c;
g.GenObject = s;
Assert.AreEqual(txt, GenFragmentExpander.Expand(d.GenDataDef, g.GenObject, g.Fragment));
var str = GenerateFragment(d, g);
Assert.AreEqual(txt, str);
c = GetFirstObject(d);
Assert.AreEqual("Class", c.Attributes[0]);
s = GetFirstObjectOfSubClass(c, "SubClass");
Assert.AreEqual("SubClass", s.Attributes[0]);
g.GenObject = s;
str = GenerateFragment(d, g);
Assert.AreEqual("", str);
}
public void FileStreamProfileTest()
{
const string txt = "`[Class>:`Class.Name`,`]";
const string fileName = "GenProfileTest.prf";
var d = SetUpData();
if (File.Exists(fileName))
{
File.Delete(fileName);
}
File.WriteAllText(fileName, txt);
var profile = new GenCompactProfileParser(d.GenDataDef, fileName, "");
Assert.AreEqual(1, profile.Body.Count, "Only one fragment expected");
Assert.AreEqual(FragmentType.Segment, profile.Body.Fragment[0].FragmentType);
Assert.AreEqual(txt,
profile.ProfileText(
ProfileFragmentSyntaxDictionary.ActiveProfileFragmentSyntaxDictionary));
Assert.AreEqual("Class,SubClass,Property,",
GenFragmentExpander.Expand(d.GenDataDef, d.Root, profile.Fragment),
"Class list expected");
}
private void LoadProfile()
{
GenProfileFragment = new GenCompactProfileParser(GenDataDef, Args.Profile, "", Args.Delimiter[0]);
}
