private static void CompareContext(ISubClassBase expectedList, ISubClassBase actualList) { var expectedId = expectedList.ClassId; var actualId = actualList.ClassId; Assert.AreEqual(expectedId, actualId); Assert.AreEqual(expectedList.Count, actualList.Count, "Class " + expectedId + " objects"); Assert.AreEqual(expectedList.ClassId, actualList.ClassId); Assert.AreEqual(expectedList.Definition.SubClass.RefClassId, actualList.Definition.SubClass.RefClassId); Assert.AreEqual(expectedList.Reference, expectedList.Reference); Assert.AreEqual(expectedList.Definition.SubClass.ToString(), actualList.Definition.SubClass.ToString()); for (var i = 0; i < expectedList.Count; i++) { var expectedObject = expectedList[i]; var actualObject = actualList[i]; Assert.AreEqual(expectedObject.ClassId, actualObject.ClassId); var expectedAttributes = new GenAttributes(expectedObject.GenDataBase.GenDataDef, expectedObject.ClassId); var actualAttributes = new GenAttributes(actualObject.GenDataBase.GenDataDef, actualObject.ClassId); expectedAttributes.GenObject = expectedObject; actualAttributes.GenObject = actualObject; Assert.GreaterOrEqual(expectedObject.Attributes.Count, actualObject.Attributes.Count); foreach (var property in actualObject.Definition.Properties) { Assert.AreEqual(expectedAttributes.AsString(property), actualAttributes.AsString(property), property + " " + expectedAttributes.AsString("Name") + " vs " + actualAttributes.AsString("Name")); } Assert.AreEqual(expectedObject.SubClass.Count, actualObject.SubClass.Count); for (var j = 0; j < actualObject.SubClass.Count; j++) { var expectedSubClassName = expectedObject.SubClass[j].Definition.SubClass.Name; var actualSubClassName = actualObject.SubClass[j].Definition.SubClass.Name; Assert.AreEqual(expectedSubClassName, actualSubClassName); var expectedSubClassDef = expectedObject.GetSubClass(expectedSubClassName).Definition.SubClass; var actualSubClassDef = actualObject.GetSubClass(actualSubClassName).Definition.SubClass; Assert.AreEqual(expectedSubClassDef.ToString(), actualSubClassDef.ToString()); Assert.AreEqual(expectedSubClassDef.ClassId, actualSubClassDef.ClassId); Assert.AreEqual(expectedSubClassDef.IsInherited, actualSubClassDef.IsInherited); Assert.AreEqual(expectedSubClassDef.IsAbstract, actualSubClassDef.IsAbstract); Assert.AreEqual(expectedObject.SubClass[j].ClassId, actualObject.SubClass[j].ClassId); Assert.AreEqual(expectedObject.SubClass[j].Reference, actualObject.SubClass[j].Reference); CompareContext(expectedObject.SubClass[j], actualObject.SubClass[j]); } Assert.AreEqual(expectedObject.Definition.Inheritors.Count, actualObject.Definition.Inheritors.Count); for (var j = 0; j < expectedObject.Definition.Inheritors.Count; j++) { var expectedDefInheritor = expectedObject.Definition.Inheritors[j]; var actualDefInheritor = actualObject.Definition.Inheritors[j]; Assert.AreEqual(expectedDefInheritor.ClassId, actualDefInheritor.ClassId); Assert.Less(expectedId, expectedDefInheritor.ClassId); } } }
public void ClassWithPropertyGenDefExtractTest() { var f = new GenDataDef(); f.AddClass("", "Class"); f.AddClass("Class", "Property"); var d = f.AsGenDataBase(); var a = new GenAttributes(d.GenDataDef, SubClassClassId); Assert.AreEqual(1, d.Root.SubClass.Count); Assert.AreEqual(2, d.Root.SubClass[0].Count); var c = GetFirstObject(d); Assert.AreEqual(2, c.SubClass.Count); Assert.AreEqual(2, c.Attributes.Count); Assert.AreEqual(ClassClassId, c.ClassId); var s = GetFirstObjectOfSubClass(c, "SubClass"); Assert.AreEqual(1, c.GetSubClass("SubClass").Count); a.GenObject = s; Assert.AreEqual("Property", a.AsString("Name")); Assert.IsNull(GetFirstObjectOfSubClass(c, "Property")); }
public void EmptyClassGenDefExtractTest() { var f = new GenDataDef(); f.AddClass("", "Class"); var d = f.AsGenDataBase(); var a = new GenAttributes(d.GenDataDef, ClassClassId); var r = d.Root; Assert.AreEqual(1, r.SubClass.Count); Assert.AreEqual(1, r.SubClass[0].Count); var c = GetFirstObject(d); Assert.AreEqual(2, c.SubClass.Count); Assert.AreEqual(2, c.Attributes.Count); var s = GetFirstObjectOfSubClass(c, "SubClass"); Assert.IsNull(s); var p = GetFirstObjectOfSubClass(c, "Property"); Assert.IsNull(p); a.GenObject = c; Assert.AreEqual("Class", a.AsString("Name")); }
public void ReferenceGenDefExtractTest() { var fChild = SetUpParentChildDef("Child", "Grandchild"); var fParent = SetUpParentChildReferenceDef("Parent", "Child", "ChildDef", fChild); var d = fParent.AsGenDataBase(); var a = new GenAttributes(fParent, ClassClassId); var c = GetFirstObject(d); Assert.AreEqual(1, d.Root.SubClass[0].Count); a.GenObject = c; Assert.AreEqual("Parent", a.AsString("Name")); a = new GenAttributes(d.GenDataDef, SubClassClassId) { GenObject = GetFirstObjectOfSubClass(c, "SubClass") }; Assert.AreEqual("Child", a.AsString("Name")); Assert.AreEqual("ChildDef", a.AsString("Reference")); }
protected static void ValidateMinimalData(GenDataBase d) { Assert.AreEqual("Minimal", d.GenDataDef.DefinitionName); Assert.AreEqual(4, d.GenDataDef.Classes.Count); //Assert.IsFalse(d.Eol(RootClassId)); //Assert.IsFalse(d.Eol(ClassClassId)); //Assert.IsFalse(d.Eol(SubClassClassId)); //Assert.IsFalse(d.Eol(PropertyClassId)); //Assert.AreEqual(RootClassId, d.Context[RootClassId].ClassId); //Assert.AreEqual(ClassClassId, d.Context[ClassClassId].ClassId); //Assert.AreEqual(SubClassClassId, d.Context[SubClassClassId].ClassId); //Assert.AreEqual(PropertyClassId, d.Context[PropertyClassId].ClassId); //Assert.IsTrue(d.Context[RootClassId].IsFirst()); //Assert.IsTrue(d.Context[RootClassId].IsLast()); //Assert.AreEqual(1, d.Context[RootClassId].GenObject.SubClass.Count); // Class class tests //d.First(ClassClassId); var c = GetFirstObject(d); Assert.IsNotNull(c); Assert.AreNotEqual(0, c.GetSubClass("SubClass").Count); Assert.AreNotEqual(0, c.GetSubClass("Property").Count); //Assert.IsTrue(d.Context[ClassClassId].IsFirst()); //Assert.IsTrue(d.Context[SubClassClassId].IsFirst()); //Assert.IsTrue(d.Context[PropertyClassId].IsFirst()); var ca = new GenAttributes(d.GenDataDef, ClassClassId); var sa = new GenAttributes(d.GenDataDef, SubClassClassId); var pa = new GenAttributes(d.GenDataDef, PropertyClassId); ca.GenObject = c; Assert.AreEqual("Class", ca.AsString("Name")); Assert.AreEqual(2, c.SubClass.Count); Assert.AreEqual(2, c.GetSubClass("SubClass").Count); Assert.AreEqual(2, c.GetSubClass("Property").Count); pa.GenObject = c.GetSubClass("Property")[0]; Assert.AreEqual("Name", pa.AsString("Name")); // SubClass class tests - SubClass var s = GetFirstObjectOfSubClass(c, "SubClass"); Assert.IsNotNull(s); sa.GenObject = s; Assert.AreEqual("SubClass", sa.AsString("Name")); Assert.AreEqual(0, s.SubClass.Count); // SubClass class tests - Property var p = GetNextObjectInSubClass(s); Assert.AreEqual(p.GetSubClass("SubClass").Count - 1, p.GetSubClass("SubClass").IndexOf(p)); sa.GenObject = p; Assert.AreEqual("Property", sa.AsString("Name")); Assert.AreEqual(0, p.SubClass.Count); // SubClass class tests s = GetNextObjectInSubClass(c); Assert.IsNotNull(s); ca.GenObject = s; Assert.AreEqual("SubClass", ca.AsString("Name")); Assert.AreEqual(0, s.GetSubClass("SubClass").Count); Assert.AreEqual(3, s.GetSubClass("Property").Count); pa.GenObject = s.GetSubClass("Property")[0]; Assert.AreEqual("Name", pa.AsString("Name")); pa.GenObject = GetNextObjectInSubClass((GenObject)pa.GenObject); Assert.AreEqual("Reference", pa.AsString("Name")); pa.GenObject = GetNextObjectInSubClass((GenObject)pa.GenObject); Assert.AreEqual("Relationship", pa.AsString("Name")); // Property class tests p = GetNextObjectInSubClass(s); Assert.IsNotNull(p); ca.GenObject = p; Assert.AreEqual("Property", ca.AsString("Name")); Assert.AreEqual(0, p.GetSubClass("SubClass").Count); Assert.AreEqual(1, p.GetSubClass("Property").Count); pa.GenObject = p.GetSubClass("Property")[0]; Assert.AreEqual("Name", pa.AsString("Name")); }
/// <summary> /// Create a new <see cref="ClassTreeNode"/> for the selected class /// </summary> /// <param name="parentNode">The tree node of the parent subclass of this class.</param> /// <param name="genDataBase"></param> /// <param name="definition">The definition data for the data being navigated.</param> /// <param name="classId">The ID of this class.</param> /// <param name="genObject"></param> public ClassTreeNode(SubClassTreeNode parentNode, GenDataBase genDataBase, Definition definition, int classId, GenObject genObject) { ClassId = classId; GenDataBase = genDataBase; ParentNode = parentNode; GenObject = genObject; ClassDef = GenDataBase.GenDataDef.GetClassDef(ClassId); Def = ClassId > definition.ClassList.Count ? null : definition.ClassList[ClassId - 1]; GenAttributes = new GenAttributes(GenDataBase.GenDataDef, classId) { GenObject = GenObject }; Text = ClassDef.Properties.IndexOf("Name") == -1 ? ClassDef.Name : GenAttributes.AsString("Name"); ImageIndex = 1; ToolTipText = Def == null ? "" : Def.Title; Tag = new GenObjectViewModel(GenObject, Def, ClassDef.IsReference); foreach (var subClass in ClassDef.SubClasses) { Nodes.Add(new SubClassTreeNode(this, GenDataBase, definition, subClass.SubClass.ClassId)); } }