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 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 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 ModifyIsDirectedProperty(BasicAdjList network, bool isDirected)
 {
     if (network.IsDirected != isDirected)
     {
         network.IsDirected = isDirected;
     }
 }

        public void AddEdge_Throws_Ex_If_Edge_Is_Null()
        {
            var net =new BasicAdjList(Guid.NewGuid());
            BasicNode node0 = new BasicNode(net);

            BasicEdge edge0 = null;
            var ex = Assert.Throws<ArgumentNullException>(() => node0.AddEdge(edge0));
        }

        public void AddEdge_Throws_Ex_If_Edge_Is_Invalid_Type()
        {
            var net =new BasicAdjList(Guid.NewGuid());
            BasicNode node0 = new BasicNode(net);

            DummyBasicEdge edge0 = new DummyBasicEdge();
            var ex = Assert.Throws<ArgumentException>(() => node0.AddEdge(edge0));
        }

 public void Contains_ReturnsTrueWhenANodeExists()
 {
     //Arrange
     var net = new BasicAdjList(Guid.NewGuid());
     INode node = net.CreateNode();
     bool result = net.Contains(node);
     Assert.True(result);
 }

 public void Ctor_With_Different_Network_Parent_Than_Source_Node()
 {
     //Arrange
     var net = new BasicAdjList(Guid.NewGuid());
     BasicAdjList net2 = new BasicAdjList(Guid.NewGuid());
     var nodeA = new BasicNode(net2);
     var nodeB = new BasicNode(net);
     var ex = Assert.Throws<ArgumentException>(() => new BasicEdge(net, nodeA, nodeB));
 }

        public void Ctor_Throws_Ex_With_Null_Passed_InAsSourceNode()
        {
            //Arrange
            var net = new BasicAdjList(Guid.NewGuid());
            IBasicNode nodeA = null;
            var nodeB = new BasicNode(net);

            //Act, Assert
            var ex = Assert.Throws<ArgumentException>(() => new BasicEdge(net, nodeA, nodeB));
        }

 public void CreateEdge_Increments_Edge_Count_By_1()
 {
     //Arrange
     var net = new BasicAdjList(Guid.NewGuid());
     Assert.Equal(0, net.EdgeCount);
     INode nodeA = net.CreateNode();
     INode nodeB = net.CreateNode();
     IEdge edge = net.CreateEdge(nodeA, nodeB);
     Assert.Equal(1, net.EdgeCount);
 }

        public void Ctor_Throws_Ex_With_Null_Passed_In_As_Network()
        {
            //Assign
            IBasicAdjList net = new BasicAdjList(Guid.NewGuid());
            var nodeA = new BasicNode(net);
            var nodeB = new BasicNode(net);

            //Act, Assert
            var ex = Assert.Throws<ArgumentNullException>(() => new BasicEdge(null, nodeA, nodeB));
        }

 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);
 }

        public void EdgeDataAttributeCount_Returns0_IfEdgeDataIsNull()
        {
            var net = new BasicAdjList(Guid.NewGuid());
            int count = 0;

            net.EdgeData = null;

            int result = net.EdgeDataAttributeCount;

            Assert.Equal(count, 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 ChangeEventsEnabled_When_False_Prevents_NetworkChanged_Fired_When_CreateNode_Is_Called(int nodeCount)
        {
            //Arrange
            var net = new BasicAdjList(Guid.NewGuid());
            var helper = new NetworkChangedEventsTestHelper();
            net.NetworkChanged += new NetworkChangedEventHandler<INetwork, NetworkChangedEventArgs>(helper.NetworkChanged_DummyHandler);

            net.ChangeEventsEnabled = false;
            for (int i = 0; i < nodeCount; i++)
                net.CreateNode();

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

        public void EdgeDataAttributeCount()
        {
            var net = new BasicAdjList(Guid.NewGuid());
            int count = 3;

            var mockMgr = new Mock<IDataAttributes<IEdge>>();
            net.EdgeData = mockMgr.Object;
            mockMgr.Setup(foo => foo.ColumnCount).Returns(count);

            int result = net.EdgeDataAttributeCount;

            Assert.Equal(count, result);
        }

        public void AddEdge_IncrementsDegree_ForSelfLoop()
        {
            var net =new BasicAdjList(Guid.NewGuid());
            BasicNode node0 = new BasicNode(net);
            BasicNode node1 = new BasicNode(net);

            BasicEdge edge0 = new BasicEdge(net, node0, node0);

            int degree = node0.Degree;
            Assert.Equal(0, degree);
            node0.AddEdge(edge0);
            degree = node0.Degree;
            Assert.Equal(2, degree);
        }

        public void AddRow_ThrowsIfValuesTypesDoesNotMatchListsTypes(Type[] dataTypes, object[] values)
        {
            BasicAdjList net = new BasicAdjList(Guid.NewGuid());
            DataAttributeMgr mgr = new DataAttributeMgr(NODE_ATTRIB_LIST, net);

            CreateLists(dataTypes, mgr);

            object[] badVals = new object[values.Length];
            for (int i = 0; i < values.Length; i++)
            {
                badVals[i] = Guid.NewGuid();
            }
            mgr.AddRow(badVals);
        }

        public void AddingNodes_Adds_Row_With_Matching_Key_In_NodeData(int nodeCount)
        {
            var net = new BasicAdjList(Guid.NewGuid());
            var table = new DataAttributeTable<INode>();
            table.Network = net;
            net.NodeData = table;

            for(int i=0; i<nodeCount; i++)
            {
                var node = net.CreateNode();
                Assert.Equal((i+1), net.NodeCount);
                Assert.Equal((i+1), table.RowCount);
                Assert.True(table.RowOwnerMap.ContainsKey(node));
            }
        }

        /// <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;
        }