public void ReferenceCacheSelfLocalPathTest()
{
var d = GenDataDef.CreateMinimal().AsGenData();
var d0 = GenDataDef.CreateMinimal().AsGenData();
d.Cache.Internal("Minimal", "self", d0);
}
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 GenDataReorderTests()
{
var f = GenDataDef.CreateMinimal();
var d = new GenDataBase(f);
var c = CreateGenObject(d.Root, "Class", "Class");
CreateGenObject(c, "SubClass", "SubClass1");
CreateGenObject(c, "SubClass", "SubClass2");
CreateGenObject(c, "SubClass", "SubClass3");
// Verify initial subclass order - Index is last added item
CheckOrder(d, "123", "Verify initial subclass order");
// Make and verify moves
MoveItem(d, ListMove.Up, 2, "132", "Move last subclass up one place");
MoveItem(d, ListMove.ToTop, 2, "213", "Move last subclass to top");
MoveItem(d, ListMove.ToTop, 1, "123", "Move second subclass to top");
MoveItem(d, ListMove.ToBottom, 0, "231", "Move first subclass to bottom");
MoveItem(d, ListMove.ToTop, 0, "231", "Move first subclass to top (should have no effect)");
MoveItem(d, ListMove.ToBottom, 2, "231", "Move last subclass to bottom (should have no effect)");
MoveItem(d, ListMove.Up, 0, "231", "Move first subclass up (should have no effect)");
MoveItem(d, ListMove.Down, 2, "231", "Move last subclass down (should have no effect)");
MoveItem(d, ListMove.Down, 0, "321", "Move first subclass down");
MoveItem(d, ListMove.Down, 1, "312", "Move second subclass down");
MoveItem(d, ListMove.Up, 1, "132", "Move second subclass up");
MoveItem(d, ListMove.ToBottom, 1, "123", "Move second subclass to bottom");
}
private static GenDataBase SetUpSegmentSeparatorData(string display)
{
var fm = GenDataDef.CreateMinimal();
var dm = new GenDataBase(fm);
var td = CreateClass(dm, "TestData");
CreateProperty("Name", td);
CreateProperty("Display", td);
var f = dm.AsDef();
var a = new GenAttributes(f, 1);
var d = new GenDataBase(f);
a.GenObject = CreateGenObject(d.Root, "TestData", "One");
a.SetString("Name", "One");
a.SetString("Display", display[0] == '1' ? "True" : "");
a.SaveFields();
a.GenObject = CreateGenObject(d.Root, "TestData", "Two");
a.SetString("Name", "Two");
a.SetString("Display", display[1] == '1' ? "True" : "");
a.SaveFields();
a.GenObject = CreateGenObject(d.Root, "TestData", "Three");
a.SetString("Name", "Three");
a.SetString("Display", display[2] == '1' ? "True" : "");
a.SaveFields();
return(d);
}
public void MinimalGenDefExtractTest()
{
var f = GenDataDef.CreateMinimal();
var d = f.AsGenDataBase();
ValidateMinimalData(d);
}
public void MinimalGenDataAsDefTest()
{
var f = GenDataDef.CreateMinimal();
var d = f.AsGenDataBase();
var f0 = d.AsDef();
VerifyAsDef(f0);
}
protected static GenDataBase SetUpLookupData()
{
var f = GenDataDef.CreateMinimal();
var d = SetUpLookupData(f);
return(d);
}
public void GenDefTextParametersTest()
{
var f0 = GenDataDef.CreateMinimal();
var d = new GenParameters(f0, GenDataSaveText);
var f = d.AsDef();
VerifyAsDef(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"));
}
public void ReferenceCacheSelfTest()
{
var d = GenDataDef.CreateMinimal().AsGenData();
d.Cache.Check("Minimal", "self");
var self = d.Cache["self"];
Assert.AreSame(d, self);
}
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 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 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 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));
}
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);
}
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 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 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));
}
public void ContextReferencePropertyExistsWithValueTest()
{
var f = GenDataDef.CreateMinimal();
var idx = f.AddClassInstanceProperty(1, "Reference");
var d = new GenDataBase(f);
SetUpData(d);
var id = f.GetId("Class.Reference");
var genObject = GenObject.GetContext(d.Root, "Class");
genObject.Attributes[idx] = "Reference value";
Assert.AreEqual("Reference value", genObject.GetValue(id));
}
public void GenDefParameterTest()
{
CreateGenDataSaveText("GenDefParameterTest.txt");
var f0 = GenDataDef.CreateMinimal();
GenParameters d;
using (var s = new FileStream("GenDefParameterTest.txt", FileMode.Open, FileAccess.ReadWrite))
d = new GenParameters(f0, s)
{
DataName = "GenDefParameterTest"
};
var f = d.AsDef();
VerifyAsDef(f);
}
protected static GenDataBase SetUpNumericComparisonData()
{
var f = GenDataDef.CreateMinimal();
f.AddClassInstanceProperty(PropertyClassId, "Number");
var d = new GenDataBase(f);
var a = new GenAttributes(f, PropertyClassId);
SetUpData(d);
a.GenObject = GetFirstObjectOfSubClass(GetLastObjectInSubClass(GetFirstObject(d)), "Property");
a.SetNumber("Number", 15);
a.SaveFields();
return(d);
}
public void GetGenDataBaseReferencesTest()
{
var d = GenDataDef.CreateMinimal().AsGenData();
d.GenDataBase.References.Add("Data", "Def");
d.GenDataBase.References.Add("Data", "Def");
var references = d.GenDataBase.References.ReferenceList;
Assert.AreEqual(3, references.Count);
Assert.AreEqual("data", references[0].Data);
Assert.AreEqual("def", references[0].Definition);
Assert.AreEqual("def", references[1].Data);
Assert.AreEqual("minimal", references[1].Definition);
Assert.AreEqual("minimal", references[2].Data);
Assert.AreEqual("minimal", references[2].Definition);
}
public void ReferenceCacheLocalPathTest()
{
var d = GenDataDef.CreateMinimal().AsGenData();
var d0 = GenDataDef.CreateMinimal().AsGenData();
var d1 = d0.DuplicateContext();
var lookup0 = d.Cache.Internal("Minimal", "d0", d0);
var lookup1 = d.Cache.Internal("Minimal", "d1", d1);
Assert.AreSame(d0, lookup0);
Assert.AreSame(d1, lookup1);
lookup0 = d.Cache["d0"];
lookup1 = d.Cache["d1"];
Assert.AreSame(d0, lookup0);
Assert.AreSame(d1, lookup1);
Assert.AreNotSame(lookup1, lookup0);
}
public void CreateMinimalTest()
{
var f = GenDataDef.CreateMinimal();
Assert.AreEqual(0, f.GetClassId(""));
Assert.AreEqual(1, f.GetClassId("Class"));
Assert.AreEqual(2, f.GetClassId("SubClass"));
Assert.AreEqual(3, f.GetClassId("Property"));
Assert.AreEqual(1, f.GetClassSubClasses(0).Count);
Assert.AreEqual(2, f.GetClassSubClasses(1).Count);
Assert.AreEqual(0, f.GetClassSubClasses(2).Count);
Assert.AreEqual(0, f.GetClassSubClasses(3).Count);
Assert.AreEqual(1, f.GetClassSubClasses(0)[0].SubClass.ClassId);
Assert.AreEqual(2, f.GetClassSubClasses(1)[0].SubClass.ClassId);
Assert.AreEqual(3, f.GetClassSubClasses(1)[1].SubClass.ClassId);
}
public void GenParameterScannerTest()
{
const string txt = "Property=Title[Title='Property Title',DataType=String,Read,Write,PrivateVar,Visibility=3]\r\n";
GenDataDef.CreateMinimal();
using (var scan = new ParameterScanner(txt))
{
scan.ScanObject();
Assert.IsFalse(scan.AtEnd);
Assert.AreEqual("Property", scan.RecordType, "Property record type expected");
Assert.AreEqual("Title", scan.Attribute("Name"), "Name attribute by default");
Assert.AreEqual("Property Title", scan.Attribute("Title"), "Quoted attribute value");
Assert.AreEqual("True", scan.Attribute("Read"), "Boolean attribute");
Assert.AreEqual("", scan.Attribute("Missing"), "Missing attribute blank by default");
scan.ScanObject();
Assert.IsTrue(scan.Eof);
}
}
public void IdentifierConditionProfileTest()
{
const string txt = "`[Class':" +
"`?Class.Name<Class.NameEQ:Class name is less than Class `]" +
"`?Class.Name=Class.NameEQ:Class name equals Class `]" +
"`?Class.Name>Class.NameEQ:Class name is greater than Class `]" +
"`?Class.Name<Class.NameLT:Class name is less than Clasa `]" +
"`?Class.Name=Class.NameLT:Class name equals Clasa `]" +
"`?Class.Name>Class.NameLT:Class name is greater than Clasa `]" +
"`?Class.Name<Class.NameGT:Class name is less than Clasz `]" +
"`?Class.Name=Class.NameGT:Class name equals Clasz `]" +
"`?Class.Name>Class.NameGT:Class name is greater than Clasz `]" +
"`]";
var f = GenDataDef.CreateMinimal();
f.AddClassInstanceProperty(ClassClassId, "NameLT");
f.AddClassInstanceProperty(ClassClassId, "NameEQ");
f.AddClassInstanceProperty(ClassClassId, "NameGT");
f.AddClassInstanceProperty(ClassClassId, "NameBlank");
var d = SetUpData(f);
var c = GetFirstObject(d);
Assert.AreEqual("Class", c.Attributes[0]);
var a = new GenAttributes(f, ClassClassId)
{
GenObject = c
};
a.SetString("NameLT", "Clasa");
a.SetString("NameEQ", "Class");
a.SetString("NameGT", "Clasz");
a.SetString("NameBlank", "");
a.SaveFields();
const string expectedExpansion = "Class name equals Class " +
"Class name is greater than Clasa " +
"Class name is less than Clasz ";
var expectedFragmentType = new[] { FragmentType.Segment };
const string message = "Comparison conditions expected";
ValidateExpansion(d, txt, expectedFragmentType, expectedExpansion, message);
}
public void EmptyClassGenDataAsDefTest()
{
var f = GenDataDef.CreateMinimal();
var d = new GenDataBase(f);
CreateClass(d, "Class");
var f0 = d.AsDef();
Assert.AreEqual(2, f0.Classes.Count);
// Root class
Assert.AreEqual("", f0.GetClassName(0));
Assert.AreEqual(0, f0.GetClassProperties(0).Count);
Assert.AreEqual(1, f0.GetClassSubClasses(0).Count);
// Defined Class
Assert.AreEqual(0, f.GetClassId(""));
Assert.AreEqual("Class", f.GetClassName(1));
Assert.AreEqual(1, f0.GetClassSubClasses(0)[0].SubClass.ClassId);
}
public void GenDataSaveTests()
{
const string fileName = "GenDataSaveTest.txt";
const string expected = GenDataSaveText;
var f = GenDataDef.CreateMinimal();
f.AddClassInstanceProperty(ClassClassId, "Title");
var a = new GenAttributes(f, ClassClassId);
var d = new GenDataBase(f);
SetUpData(d);
a.GenObject = GetFirstObject(d);
a.SetString("Title", "Class object");
a.SaveFields();
GenParameters.SaveToFile(d, fileName);
var file = File.ReadAllText(fileName);
Assert.AreEqual(expected, file);
}
protected static GenDataBase SetUpComparisonData()
{
var f = GenDataDef.CreateMinimal();
f.AddClassInstanceProperty(PropertyClassId, "NameLT");
f.AddClassInstanceProperty(PropertyClassId, "NameEQ");
f.AddClassInstanceProperty(PropertyClassId, "NameGT");
f.AddClassInstanceProperty(PropertyClassId, "NameBlank");
var d = new GenDataBase(f);
SetUpData(d);
var c = GetFirstObject(d);
Assert.AreEqual("Class", c.Attributes[0]);
var a = new GenAttributes(f, ClassClassId)
{
GenObject = c
};
a.SetString("NameLT", "Clasa");
a.SetString("NameEQ", "Class");
a.SetString("NameGT", "Clasz");
a.SetString("NameBlank", "");
a.SaveFields();
c = GetLastObjectInSubClass(c);
Assert.AreEqual("Property", c.Attributes[0]);
a.GenObject = GetFirstObjectOfSubClass(c, "Property");
a.SetString("NameLT", "Nama");
a.SetString("NameEQ", "Name");
a.SetString("NameGT", "Namz");
a.SetString("NameBlank", "");
a.SaveFields();
return(d);
}
public void GenDataFileSaveTest()
{
const string fileName = "GenProfileTest.dcb";
var f = GenDataDef.CreateMinimal();
var d = f.AsGenDataBase();
if (File.Exists(fileName))
{
File.Delete(fileName);
}
GenParameters.SaveToFile(d, fileName);
Assert.IsTrue(File.Exists(fileName));
GenDataBase d1;
using (var stream = new FileStream(fileName, FileMode.Open))
d1 = new GenParameters(stream)
{
DataName = "GenProfileTest"
};
VerifyDataCreation(d1);
}
