private static void VerifyIdTriple(ReadOnlyGraph readOnlyGraph)
        {
            var idTriples = readOnlyGraph.GetTriplesWithSubjectPredicate(
                readOnlyGraph.CreateUriNode(PackageUri),
                readOnlyGraph.CreateUriNode(Schema.Predicates.Id));

            Assert.Equal(1, idTriples.Count());
            Assert.Equal(PackageId, ((LiteralNode)idTriples.First().Object).Value);
        }
        public void RejectsMergeWhenKeepOriginalGraphUriIsSpecified(bool keepOriginalGraphUri)
        {
            // Arrange
            var readOnlyGraph = new ReadOnlyGraph(GetIdMutableGraph());
            var otherGraph    = GetVersionMutableGraph();

            // Act & Assert
            var exception = Assert.Throws <NotSupportedException>(() => readOnlyGraph.Merge(otherGraph, keepOriginalGraphUri));

            Assert.Equal(ReadOnlyMessage, exception.Message);

            VerifyIdTriple(readOnlyGraph);
            Assert.Equal(1, readOnlyGraph.Triples.Count);
        }
        public void RejectsAssertOfSingleTriple()
        {
            // Arrange
            var readOnlyGraph = new ReadOnlyGraph(GetIdMutableGraph());

            // Act & Assert
            var exception = Assert.Throws <NotSupportedException>(() => readOnlyGraph.Assert(new Triple(
                                                                                                 readOnlyGraph.CreateUriNode(PackageUri),
                                                                                                 readOnlyGraph.CreateUriNode(Schema.Predicates.Version),
                                                                                                 readOnlyGraph.CreateLiteralNode(PackageId))));

            Assert.Equal(ReadOnlyMessage, exception.Message);

            VerifyIdTriple(readOnlyGraph);
            Assert.Equal(1, readOnlyGraph.Triples.Count);
        }
        public void MutationsOfTheOriginalGraphDoNotEffectTheReadOnlyGraph()
        {
            // Arrange
            var mutableGraph  = GetIdMutableGraph();
            var readOnlyGraph = new ReadOnlyGraph(mutableGraph);

            // Act
            mutableGraph.Assert(
                mutableGraph.CreateUriNode(PackageUri),
                mutableGraph.CreateUriNode(Schema.Predicates.Version),
                mutableGraph.CreateLiteralNode(PackageVersion));

            // Assert
            var versionTriples = readOnlyGraph.GetTriplesWithSubjectPredicate(
                readOnlyGraph.CreateUriNode(PackageUri),
                readOnlyGraph.CreateUriNode(Schema.Predicates.Version));

            Assert.Empty(versionTriples);

            VerifyIdTriple(readOnlyGraph);
            Assert.Equal(1, readOnlyGraph.Triples.Count);
        }
示例#5
0
        public void ReadOnlyGraph_Coontructor_PopulatesEdgesAndVertices()
        {
            int    vertex1 = 10;
            int    vertex2 = 20;
            int    vertex3 = 30;
            string edge1   = "edge1";
            string edge2   = "edge2";

            EdgeDescriptor <int, string> edgeDescriptor1 = new EdgeDescriptor <int, string>(vertex1, vertex2, edge1);
            EdgeDescriptor <int, string> edgeDescriptor2 = new EdgeDescriptor <int, string>(vertex1, vertex3, edge2);

            IEnumerable <EdgeDescriptor <int, string> > edges = new List <EdgeDescriptor <int, string> >()
            {
                edgeDescriptor1, edgeDescriptor2
            };
            ReadOnlyGraph <int, string> readOnlyGraph = new ReadOnlyGraph <int, string>(edges);

            Assert.AreEqual(3, readOnlyGraph.NumVertices);
            Assert.IsTrue(readOnlyGraph.HasVertex(vertex1));
            Assert.IsTrue(readOnlyGraph.HasVertex(vertex2));
            Assert.IsTrue(readOnlyGraph.HasVertex(vertex3));
            Assert.AreEqual(edge1, readOnlyGraph.FindEdge(vertex1, vertex2));
            Assert.AreEqual(edge2, readOnlyGraph.FindEdge(vertex1, vertex3));
        }