public void Type()
        {
            this.Explorer.AddRepository(this.Repository);

            var person = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            person.SingularName = "Person";
            person.PluralName   = "Persons";

            person.SendChangedEvent();
            this.domain.SendChangedEvent();

            this.TreeViewTester.SelectNode(this.TypeNode);

            var testPropertyGrid = new PropertyGridTester("testPropertyGrid");

            var singularNameTester = testPropertyGrid.FindGridItem("SingularName");
            var pluralNameTester   = testPropertyGrid.FindGridItem("PluralName");

            singularNameTester.Value = "Persoon";
            pluralNameTester.Value   = "Personen";

            Assert.AreEqual("Persoon", person.SingularName);
            Assert.AreEqual("Personen", person.PluralName);
        }
        public void SuperTypes()
        {
            this.Explorer.AddRepository(this.Repository);

            var classA = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            classA.SingularName = "A";
            classA.PluralName   = "As";

            var abstractClassA = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            abstractClassA.IsAbstract   = true;
            abstractClassA.SingularName = "AA";
            abstractClassA.PluralName   = "AAs";

            var interfaceA = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            interfaceA.IsInterface  = true;
            interfaceA.SingularName = "IA";
            interfaceA.PluralName   = "IAs";

            ObjectType[] interfaces = { interfaceA };

            classA.SendChangedEvent();
            abstractClassA.SendChangedEvent();
            interfaceA.SendChangedEvent();
            this.domain.SendChangedEvent();

            this.TreeViewTester.SelectNode(this.TypeNode);

            var testPropertyGrid = new PropertyGridTester("testPropertyGrid");

            var typeDecorator = (ObjectTypeDecorator)testPropertyGrid.Target.SelectedObject;

            typeDecorator.Superclass = abstractClassA;

            Assert.AreEqual(abstractClassA, typeDecorator.Superclass);
            Assert.AreEqual(0, typeDecorator.Superinterfaces.Length);

            typeDecorator.Superinterfaces = interfaces;

            Assert.AreEqual(abstractClassA, typeDecorator.Superclass);
            Assert.AreEqual(1, typeDecorator.Superinterfaces.Length);
            Assert.AreEqual(interfaceA, typeDecorator.Superinterfaces[0]);

            typeDecorator.Superinterfaces = new ObjectType[0];

            Assert.AreEqual(abstractClassA, typeDecorator.Superclass);
            Assert.AreEqual(0, typeDecorator.Superinterfaces.Length);

            typeDecorator.Superclass = null;

            Assert.IsNull(typeDecorator.Superclass);
            Assert.AreEqual(0, typeDecorator.Superinterfaces.Length);
        }
        public void SuperClass()
        {
            this.Explorer.AddRepository(this.Repository);

            var person = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            person.SingularName = "Person";
            person.PluralName   = "Persons";

            var employee = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            employee.SingularName = "Employee";
            employee.PluralName   = "Employees";
            employee.IsAbstract   = true;

            var adressable = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            adressable.SingularName = "Adressable";
            adressable.PluralName   = "Adressable";
            adressable.IsAbstract   = true;

            person.SendChangedEvent();
            employee.SendChangedEvent();
            adressable.SendChangedEvent();
            this.domain.SendChangedEvent();

            this.TreeViewTester.SelectNode(this.TreeViewTester.FindNode(0, 0, 0, 2));

            var testPropertyGrid   = new PropertyGridTester("testPropertyGrid");
            var superClassGridItem = testPropertyGrid.FindGridItem("Superclass");

            Assert.AreEqual(null, superClassGridItem.Value);

            var typeDecorator = (ObjectTypeDecorator)testPropertyGrid.Target.SelectedObject;
            var editorMock    = new EditorMock(typeDecorator);

            editorMock.EditorMockDropDown += SuperClassEditorMockDropDown;
            var superclassTypeEditorTypeEditor = new SuperclassTypeEditor();
            var superClass =
                (ObjectType)superclassTypeEditorTypeEditor.EditValue(editorMock, editorMock, typeDecorator.Superclass);

            Assert.AreEqual(superClass, employee);

            superClassGridItem.Value = superClass;

            Assert.AreEqual(superClass, person.DirectSuperclass);
        }
        public void RelationType()
        {
            this.Explorer.AddRepository(this.Repository);

            var company = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            company.SingularName = "Company";
            company.PluralName   = "Companies";

            var person = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            person.SingularName = "Person";
            person.PluralName   = "Persons";

            company.SendChangedEvent();
            person.SendChangedEvent();

            var employeeRelationType = this.domain.AddDeclaredRelationType(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid());

            employeeRelationType.AssociationType.ObjectType           = company;
            employeeRelationType.AssociationType.IsOne                = true;
            employeeRelationType.AssociationType.AssignedSingularName = "Employer";
            employeeRelationType.AssociationType.AssignedPluralName   = "Employers";
            employeeRelationType.RoleType.ObjectType           = person;
            employeeRelationType.RoleType.IsMany               = true;
            employeeRelationType.RoleType.AssignedSingularName = "Employee";
            employeeRelationType.RoleType.AssignedPluralName   = "Employees";

            employeeRelationType.SendChangedEvent();
            this.domain.SendChangedEvent();

            this.TypeNode.Target.ExpandAll();
            var relationNodeTesters = this.TypeNode.FindByTagType(typeof(RelationTypeTag));
            var employeeNodeTester  = relationNodeTesters[0];

            this.TreeViewTester.SelectNode(employeeNodeTester);
            var testPropertyGrid = new PropertyGridTester("testPropertyGrid");

            var relationDecorator = (RelationTypeDecorator)testPropertyGrid.Target.SelectedObject;
            var roleDecorator     = relationDecorator.RoleType;
            var editorMock        = new EditorMock(roleDecorator);

            editorMock.EditorMockDropDown += EditorMockEditorMockDropDown;
            var typeTypeEditor = new ObjectTypeTypeEditor();

            typeTypeEditor.EditValue(editorMock, editorMock, roleDecorator.ObjectType);
        }
        public void Interfaces()
        {
            this.testCaseSwitch = TestCaseSwitch.Interfaces;

            this.Explorer.AddRepository(this.Repository);

            var person = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            person.SingularName = "Person";
            person.PluralName   = "Persons";

            var role = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            role.IsInterface  = true;
            role.SingularName = "Role";
            role.PluralName   = "RoleTypes";

            role.SendChangedEvent();
            person.SendChangedEvent();
            this.domain.SendChangedEvent();

            // Muldec
            this.TreeViewTester.SelectNode(0, 0, 0, 0);

            var testPropertyGrid = new PropertyGridTester("testPropertyGrid");

            var typeDecorator             = (ObjectTypeDecorator)testPropertyGrid.Target.SelectedObject;
            var editorMock                = new EditorMock(typeDecorator);
            var superinterfacesTypeEditor = new SuperinterfacesTypeEditor();
            var interfaces                =
                (ObjectType[])
                superinterfacesTypeEditor.EditValue(editorMock, editorMock, typeDecorator.PossibleSuperinterfaces);

            typeDecorator.Superinterfaces = interfaces;

            Assert.AreEqual(1, interfaces.Length);
            Assert.AreEqual(role, interfaces[0]);
            Assert.AreEqual(1, person.DirectSuperinterfaces.Length);
        }
        public void Relation()
        {
            this.Explorer.AddRepository(this.Repository);

            var company = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            company.SingularName = "Company";
            company.PluralName   = "Companies";

            var person = this.domain.AddDeclaredObjectType(Guid.NewGuid());

            person.SingularName = "Person";
            person.PluralName   = "Persons";

            company.SendChangedEvent();
            person.SendChangedEvent();

            var employeeRelationType = this.domain.AddDeclaredRelationType(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid());

            employeeRelationType.AssociationType.ObjectType           = company;
            employeeRelationType.AssociationType.IsOne                = true;
            employeeRelationType.AssociationType.AssignedSingularName = "Employer";
            employeeRelationType.AssociationType.AssignedPluralName   = "Employers";
            employeeRelationType.RoleType.ObjectType           = person;
            employeeRelationType.RoleType.IsMany               = true;
            employeeRelationType.RoleType.AssignedSingularName = "Employee";
            employeeRelationType.RoleType.AssignedPluralName   = "Employees";

            var companyName = this.domain.AddDeclaredRelationType(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid());

            companyName.IsIndexed = true;
            companyName.IsDerived = true;
            companyName.AssociationType.ObjectType    = company;
            companyName.RoleType.ObjectType           = (ObjectType)this.domain.Domain.Find(UnitTypeIds.StringId);
            companyName.RoleType.AssignedSingularName = "Name";
            companyName.RoleType.AssignedPluralName   = "Names";

            employeeRelationType.SendChangedEvent();
            companyName.SendChangedEvent();
            this.domain.SendChangedEvent();

            this.TypeNode.Target.ExpandAll();
            var relationNodeTesters = this.TypeNode.FindByTagType(typeof(RelationTypeTag));
            var employeeNodeTester  = relationNodeTesters[0];
            var nameNodeTester      = relationNodeTesters[1];

            // Indexed
            this.TreeViewTester.SelectNode(employeeNodeTester);
            var testPropertyGrid = new PropertyGridTester("testPropertyGrid");
            var employeeRelationIsIndexedTester = testPropertyGrid.FindGridItem("IsIndexed");

            this.TreeViewTester.SelectNode(nameNodeTester);
            testPropertyGrid = new PropertyGridTester("testPropertyGrid");
            var nameRelationIsIndexedTester = testPropertyGrid.FindGridItem("IsIndexed");

            Assert.AreEqual(false, employeeRelationIsIndexedTester.Value);
            Assert.AreEqual(true, nameRelationIsIndexedTester.Value);

            employeeRelationIsIndexedTester.Value = true;
            nameRelationIsIndexedTester.Value     = false;

            Assert.AreEqual(true, employeeRelationType.IsIndexed);
            Assert.AreEqual(false, companyName.IsIndexed);

            // Derived
            this.TreeViewTester.SelectNode(employeeNodeTester);
            testPropertyGrid = new PropertyGridTester("testPropertyGrid");
            var employeeRelationIsDerivedTester = testPropertyGrid.FindGridItem("IsDerived");

            this.TreeViewTester.SelectNode(nameNodeTester);
            testPropertyGrid = new PropertyGridTester("testPropertyGrid");
            var nameRelationIsDerivedTester = testPropertyGrid.FindGridItem("IsDerived");

            Assert.AreEqual(false, employeeRelationIsDerivedTester.Value);
            Assert.AreEqual(true, nameRelationIsDerivedTester.Value);

            employeeRelationIsDerivedTester.Value = true;
            nameRelationIsDerivedTester.Value     = false;

            Assert.AreEqual(true, employeeRelationType.IsDerived);
            Assert.AreEqual(false, companyName.IsDerived);

            // Names
            this.TreeViewTester.SelectNode(employeeNodeTester);
            testPropertyGrid = new PropertyGridTester("testPropertyGrid");

            var employeeAssociationSingularName = testPropertyGrid.FindGridItem("AssociationType", "SingularName");

            employeeAssociationSingularName.Value = string.Empty;
            Assert.IsFalse(employeeRelationType.AssociationType.ExistAssignedSingularName);

            var employeeAssociationPluralName = testPropertyGrid.FindGridItem("AssociationType", "PluralName");

            employeeAssociationPluralName.Value = string.Empty;
            Assert.IsFalse(employeeRelationType.AssociationType.ExistAssignedPluralName);

            Assert.IsNotNull(testPropertyGrid.FindGridItem("AssociationType", "ObjectType"));

            var employeeRoleSingularName = testPropertyGrid.FindGridItem("RoleType", "SingularName");

            employeeRoleSingularName.Value = string.Empty;
            Assert.IsFalse(employeeRelationType.RoleType.ExistAssignedSingularName);

            var employeeRolePluralName = testPropertyGrid.FindGridItem("RoleType", "PluralName");

            employeeRolePluralName.Value = string.Empty;
            Assert.IsFalse(employeeRelationType.RoleType.ExistAssignedPluralName);

            Assert.IsNotNull(testPropertyGrid.FindGridItem("RoleType", "ObjectType"));
        }