public void CapabilityExportRelatedConcept()
        {
            var          collection      = new CapabilitiesCollection();
            const string conceptName     = "concept";
            const string relatedConcept  = "related";
            const string relatedConcept2 = "related2";
            const string relatedConcept3 = "related3";
            var          concept         = collection.AddConcept(conceptName);
            var          related         = collection.AddConcept(relatedConcept);

            concept.AddRelatedConcept(related);
            collection.AddRelation(conceptName, relatedConcept2);
            collection.AddRelation(conceptName, relatedConcept3);

            concept.SetCapability("Color", "Red");
            related.SetCapability("Icon", "image.png");

            concept.AddBlacklistedCapability("Icon");

            const string documentName = "related.xmlcaps";
            const string capsFileName = "related.caps";

            collection.SaveAsDocument(documentName);
            CapabilitiesDocumentImporter.LoadFileCapabilities(documentName, capsFileName);
            var exists = File.Exists(capsFileName);

            Assert.IsTrue(exists);
            collection = CapabilitiesLoader.LoadFileCapabilities(capsFileName);

            Assert.IsTrue(collection.HasConcept("concept"));
        }
        public void TestRelateCapability()
        {
            var          collection   = new CapabilitiesCollection();
            const string shapeId      = "shape";
            const string tranId       = "transform";
            var          shapeConcept = collection.AddConcept(shapeId);

            shapeConcept.SetCapability("Color", "Red");
            var tranConcept = collection.AddConcept(tranId);

            collection.AddRelation(tranId, shapeId);
            var colorValue = tranConcept.GetCapability("Color");

            Assert.IsTrue(tranConcept.HasCapability("Color"));
            Assert.AreEqual(colorValue, "Red");
            Assert.IsTrue(tranConcept.IsRelatedWith(shapeId));
        }
        public void TestAddCapability()
        {
            var          collection     = new CapabilitiesCollection();
            const string shapeId        = "shape";
            var          conceptBuilder = collection.AddConcept(shapeId);

            Assert.IsTrue(collection.HasConcept(shapeId));
            var sameConceptBuilder = collection.GetConcept(shapeId);

            Assert.IsTrue(conceptBuilder.Node == sameConceptBuilder.Node);
        }
        public void TestConceptBuilder()
        {
            var          collection   = new CapabilitiesCollection();
            const string shapeId      = "shape";
            const string circleId     = "circle";
            var          shapeConcept = collection.AddConcept(shapeId);

            shapeConcept.SetCapability("Color", "Red");
            var circleConcept = collection.AddConcept(circleId);

            collection.AddRelation(circleId, shapeId);

            Assert.IsTrue(circleConcept.HasCapability("Color"));
            Assert.IsTrue(circleConcept.IsRelatedWith(shapeId));
            Assert.IsTrue(circleConcept.GetRelatedConcept(shapeId).Node == shapeConcept.Node);

            circleConcept.AddBlacklistedCapability("Color");
            Assert.IsFalse(circleConcept.HasCapability("Color"));
            Assert.IsTrue(circleConcept.GetCapability("Color") == String.Empty);

            circleConcept.RemoveBlackistedCapability("Color");
            Assert.IsTrue(circleConcept.HasCapability("Color"));
            Assert.IsTrue(circleConcept.GetCapability("Color") != String.Empty);
        }
        public void CapabilityExportEmptyConcept()
        {
            var collection = new CapabilitiesCollection();

            collection.AddConcept("Empty concept");

            const string documentName = "emtpy.xmlcaps";
            const string capsFileName = "out.caps";

            collection.SaveAsDocument(documentName);
            CapabilitiesDocumentImporter.LoadFileCapabilities(documentName, capsFileName);
            var exists = File.Exists(capsFileName);

            Assert.IsTrue(exists);
        }
        private ReferencedShapeConstraints()
        {
            Capabilities = new CapabilitiesCollection();
            var face = Capabilities.AddConcept("Face");

            var rectangle     = Capabilities.AddConcept(FunctionNames.ThreePointsRectangle);
            var parallelogram = Capabilities.AddConcept(FunctionNames.Paralleogram);
            var circle        = Capabilities.AddConcept(FunctionNames.Circle);
            var ellipse       = Capabilities.AddConcept(FunctionNames.Ellipse);
            var makeFace      = Capabilities.AddConcept(FunctionNames.Face);

            Capabilities.AddConcept(FunctionNames.Arc);
            var line = Capabilities.AddConcept(FunctionNames.LineTwoPoints);

            Capabilities.AddConcept(FunctionNames.WireTwoPoints);
            Capabilities.AddConcept(FunctionNames.VerticalLine);
            Capabilities.AddConcept(FunctionNames.HorizontalLine);

            var box      = Capabilities.AddConcept(FunctionNames.Box);
            var cone     = Capabilities.AddConcept(FunctionNames.Cone);
            var cylinder = Capabilities.AddConcept(FunctionNames.Cylinder);

            Capabilities.AddConcept(FunctionNames.Sphere);
            Capabilities.AddConcept(FunctionNames.Torus);

            var cut = Capabilities.AddConcept(FunctionNames.Cut);

            rectangle.AddRelatedConcept(face);
            circle.AddRelatedConcept(face);
            ellipse.AddRelatedConcept(face);
            makeFace.AddRelatedConcept(face);

            box.AddRelatedConcept(face);
            cone.AddRelatedConcept(face);
            cylinder.AddRelatedConcept(face);

            var extrude = Capabilities.AddConcept(FunctionNames.Extrude);

            AcceptOperation(face, ShapeOperations.Extrudable);
            AcceptOperation(extrude, ShapeOperations.Extrudable);
            AcceptOperation(cut, ShapeOperations.Extrudable);

            AcceptOperation(line, ShapeOperations.Dimensionable);
            AcceptOperation(cut, ShapeOperations.Dimensionable);
            AcceptOperation(extrude, ShapeOperations.Dimensionable);
            AcceptOperation(face, ShapeOperations.Dimensionable);
            AcceptOperation(parallelogram, ShapeOperations.Dimensionable);

            AcceptOperation(circle, ShapeOperations.CircleRadiusConstraint);
            AcceptOperation(line, ShapeOperations.LineLengthConstraint);
            AcceptOperation(rectangle, ShapeOperations.RectangleMeasurementConstraint);


            //Capabilities.SaveAsDocument("ReferencedShapeConstraints.xmlcaps");
            //CapabilitiesDocumentImporter.LoadFileCapabilities("ReferencedShapeConstraints.xmlcaps",
            //                                                  "ReferencedShapeConstraints.caps");

            //Capabilities = CapabilitiesLoader.LoadFileCapabilities("ReferencedShapeConstraints.caps");
        }