C# BasicAdjList.CreateEdge方法代码示例

        public void ContainsSelfLoops()
        {
            var net =new BasicAdjList(Guid.NewGuid());
            BasicNode nodeA = net.CreateNode() as BasicNode;
            BasicNode nodeB = net.CreateNode() as BasicNode;
            BasicNode nodeC = net.CreateNode() as BasicNode;
            BasicNode nodeD = net.CreateNode() as BasicNode;

            net.CreateEdge(nodeA, nodeB);
            net.CreateEdge(nodeA, nodeA);
            net.CreateEdge(nodeA, nodeD);
            net.CreateEdge(nodeD, nodeD);
            net.CreateEdge(nodeD, nodeD);

            bool result = nodeA.ContainsSelfLoops();
            Assert.True(result);

            result = nodeB.ContainsSelfLoops();
            Assert.False(result);

            result = nodeC.ContainsSelfLoops();
            Assert.False(result);

            result = nodeD.ContainsSelfLoops();
            Assert.True(result);
        }

 public void CreateEdge_Assigns_Edge_Index()
 {
     //Arrange
     var net = new BasicAdjList(Guid.NewGuid());
     INode nodeA = net.CreateNode();
     INode nodeB = net.CreateNode();
     INode nodeC = net.CreateNode();
     BasicEdge edgeA = net.CreateEdge(nodeA, nodeB) as BasicEdge;
     BasicEdge edgeB = net.CreateEdge(nodeC, nodeB) as BasicEdge;
     Assert.Equal(0, edgeA.Index);
     Assert.Equal(1, edgeB.Index);
 }

        public void AddingEdges_Adds_Row_With_Matching_Key_In_EdgeData(int nodeCount, int edgeCount)
        {
            Random rand = new Random();
            var net = new BasicAdjList(Guid.NewGuid());
            var table = new DataAttributeTable<IEdge>();
            table.Network = net;
            net.EdgeData = table;

            for (int i = 0; i < nodeCount; i++)
            {
                var node = net.CreateNode();
            }

            INode nodeA = null;
            INode nodeB = null;
            IEdge edge = null;
            for (int i = 0; i < edgeCount; i++)
            {
                nodeA = net.Nodes[rand.Next(nodeCount)];
                nodeB = net.Nodes[rand.Next(nodeCount)];
                edge = net.CreateEdge(nodeA, nodeB);
                Assert.Equal((i + 1), net.EdgeCount);
                Assert.Equal((i + 1), table.RowCount);
                Assert.True(table.RowOwnerMap.ContainsKey(edge));
            }
        }

        public void ChangeEventsEnabled_When_False_Prevents_NetworkChanged_Fired_When_RemoveEdge_Is_Called(int nodeCount, int edgeCount, int edgesToRemove)
        {
            //Arrange
            var net = new BasicAdjList(Guid.NewGuid());
            Random rand = new Random();
            for (int i = 0; i < nodeCount; i++)
                net.CreateNode();

            INode nodeA = null;
            INode nodeB = null;

            IEdge[] edges = new IEdge[edgeCount];
            for (int i = 0; i < edgeCount; i++)
            {
                nodeA = net.Nodes[rand.Next(nodeCount)];
                nodeB = net.Nodes[rand.Next(nodeCount)];
                edges[i] = net.CreateEdge(nodeA, nodeB);
            }
            //---------------------

            var helper = new NetworkChangedEventsTestHelper();
            net.NetworkChanged += new NetworkChangedEventHandler<INetwork, NetworkChangedEventArgs>(helper.NetworkChanged_DummyHandler);

            net.ChangeEventsEnabled = false;
            for (int i = 0; i < edges.Length; i++)
            {
                net.RemoveEdge(edges[i]);
            }

            Assert.Equal(0, helper.NetworkChanged_TimesCalled);
        }

 public void Contains_ReturnsTrueWhenAnEdgeExists()
 {
     //Arrange
     var net = new BasicAdjList(Guid.NewGuid());
     INode nodeA = net.CreateNode();
     INode nodeB = net.CreateNode();
     IEdge edge = net.CreateEdge(nodeA, nodeB);
     bool result = net.Contains(edge);
     Assert.True(result);
 }

        /// <summary>
        /// Parses a particular string format to a network.  Format is
        /// "n,e,d|pair;pair;pair" where n = node count, e = edge count, d = true/false for directedness and
        /// pair is a number pair of node indices indicating an edges.  Ex:  "5,3,false|0,1;1,2;3,5"  *note that the
        /// number of pairs should match the number of edges
        /// </summary>
        public static IBasicAdjList ParseToNetwork(string input, bool enableNodeData, bool enableEdgeData)
        {
            // n,e,directed|pair;
            // 7,23,false|0,3;0,2;0,4;1,4;1,2;1,3;2,5;2,4;2,4;3,5;3,1;3,6;3,0;4,4;4,5;4,3;5,1;5,1;5,4;5,6;5,0;6,3;6,1;
            IBasicAdjList network = null;
            var split1 = input.Split(new[] {'|'});
            var split2 = split1[0].Split(new[] { ',' });

            int n = int.Parse(split2[0]);
            int m = int.Parse(split2[1]);
            bool directed = bool.Parse(split2[2]);

            var split3 = split1[1].Split(new[] { ';' }); // pairs

            if(split3.Length != m)
                throw new ArgumentException(string.Format("The number of pairs {0} did not match the number of edges {1} in {2}", split3.Length, m, input));
            INode a = null;
            INode b = null;

            using (var fac = new BasicAdjListFactory())
            {
                network = new BasicAdjList(Guid.NewGuid(), directed);
                for(int i=0; i<n; i++)
                    network.CreateNode();
            }

            string[] pair = null;
            int indexA = -1;
            int indexB = -1;
            for (int i = 0; i < split3.Length; i++ )
            {
                pair = split3[i].Split(new[] { ',' });
                indexA = int.Parse(pair[0]);
                indexB = int.Parse(pair[1]);
                a = network.Nodes[indexA];
                b = network.Nodes[indexB];
                network.CreateEdge(a, b);
            }

            using (var fac = new DataAttributeTableFactory(network))
            {
                if (enableNodeData)
                    fac.CreateNodeDataTable();
                if (enableEdgeData)
                    fac.CreateEdgeDataTable();
            }
            return network;
        }

        public void CreateEdge_Calls_Add_Edge_For_Source_And_Targ_Nodes()
        {
            //Arrange
            var mockNodeA = new Mock<IBasicNode>();
            var mockNodeB = new Mock<IBasicNode>();

            var net = new BasicAdjList(Guid.NewGuid());

            mockNodeA.Setup(foo => foo.Network).Returns(net);
            mockNodeB.Setup(foo => foo.Network).Returns(net);

            mockNodeA.Setup(foo => foo.Index).Returns(0);
            mockNodeB.Setup(foo => foo.Index).Returns(1);

            net.AddNewNode(mockNodeA.Object);
            net.AddNewNode(mockNodeB.Object);

            var edge = net.CreateEdge(mockNodeA.Object, mockNodeB.Object);
            mockNodeA.Verify(foo => foo.AddEdge(edge), Times.AtLeastOnce());
            mockNodeB.Verify(foo => foo.AddEdge(edge), Times.AtLeastOnce());
        }

 public void IsEdge_ReturnsTrueIfEdgeExistsBetweenTwoNodes()
 {
     //Arrange
     var net = new BasicAdjList(Guid.NewGuid());
     INode nodeA = net.CreateNode();
     INode nodeB = net.CreateNode();
     IEdge edge = net.CreateEdge(nodeA, nodeB);
     bool result = net.IsEdge(nodeA, nodeB);
     Assert.True(result);
 }

 public void IsEdge_ReturnsTrueFor_Self_Looped_Edges()
 {
     //Arrange
     var net = new BasicAdjList(Guid.NewGuid());
     INode nodeA = net.CreateNode();
     INode nodeB = net.CreateNode();
     IEdge edge = net.CreateEdge(nodeB, nodeB);
     bool result = net.IsEdge(nodeB, nodeB);
     Assert.True(result);
 }

 public void IsEdge_ReturnsFalseIf_Nodes_AreReversedButEdgeExists()
 {
     //Arrange
     var net = new BasicAdjList(Guid.NewGuid());
     INode nodeA = net.CreateNode();
     INode nodeB = net.CreateNode();
     IEdge edge = net.CreateEdge(nodeA, nodeB);
     bool result = net.IsEdge(nodeB, nodeA);
     Assert.False(result);
 }

 public void IsEdge_ReturnsFalseIfEdgeDNE()
 {
     //Arrange
     var net = new BasicAdjList(Guid.NewGuid());
     INode nodeA = net.CreateNode();
     INode nodeB = net.CreateNode();
     INode nodeC = net.CreateNode();
     IEdge edge = net.CreateEdge(nodeA, nodeB);
     bool result = net.IsEdge(nodeC, nodeA);
     Assert.False(result);
 }

        public void EdgeCount(int nodeCount, int edgeCount)
        {
            var net = new BasicAdjList(Guid.NewGuid());
            INode a = null, b = null;
            a = net.CreateNode();
            b = net.CreateNode();

            for (int i = 0; i < edgeCount; i++)
                net.CreateEdge(a, b);

            Assert.Equal(net.EdgeCount, edgeCount);
        }

 public void GetEdge_With_Ignore_Direction_Param_Returns_Null_If_EdgeDNE(bool ignoreDirection)
 {
     //Arrange
     var net = new BasicAdjList(Guid.NewGuid());
     INode nodeA = net.CreateNode();
     INode nodeB = net.CreateNode();
     INode nodeC = net.CreateNode();
     IEdge edge = net.CreateEdge(nodeA, nodeB);
     IEdge result = net.GetEdge(nodeC, nodeA, ignoreDirection);
     Assert.Null(result);
 }

        public void ItemGetter_Returns_Cell_Val_By_RowIndex_And_ColIndex()
        {
            //Arrange
            var net = new BasicAdjList(Guid.NewGuid());

            var table = new DataAttributeTable<IEdge>();
            table.Network = net;

            table.Columns.Add(new DataColumn("X", typeof(string)));

            var nodeA = net.CreateNode();
            var nodeB = net.CreateNode();
            var nodeC = net.CreateNode();

            var edgeA = net.CreateEdge(nodeB, nodeC);
            var edgeB = net.CreateEdge(nodeA, nodeC);

            table.AddRow(edgeA);
            table.AddRow(edgeB);

            table.SetValue<string>(edgeA, 0, "valA");
            table.SetValue<string>(edgeB, 0, "valB");

            //Act
            string val0 = (string)table[0, 0];
            string val1 = (string)table[1, 0];
            // verify primary keys

            //Assert
            Assert.Equal(val0, "valA");
            Assert.Equal(val1, "valB");
        }

        public void SetValue_Of_T_Assigns_Object_To_Cell_Val_By_Owner_And_ColIndex()
        {
            //Arrange
            var net = new BasicAdjList(Guid.NewGuid());

            var table = new DataAttributeTable<IEdge>();
            table.Network = net;

            table.Columns.Add(new DataColumn("X", typeof (string)));

            var nodeA = net.CreateNode();
            var nodeB = net.CreateNode();
            var nodeC = net.CreateNode();

            var edgeA = net.CreateEdge(nodeB, nodeC);
            var edgeB = net.CreateEdge(nodeA, nodeC);

            table.AddRow(edgeA);
            table.AddRow(edgeB);

            //Act
            table.SetValue<string>(edgeA, 0, "valA");
            table.SetValue<string>(edgeB, 0, "valB");

            string val0 = (string)table.Rows[0][0];
            string val1 = (string)table.Rows[1][0];
            // verify primary keys

            //Assert
            Assert.Equal(val0, "valA");
            Assert.Equal(val1, "valB");
        }