1 files changed, 186 insertions, 0 deletions
diff --git a/lib/python2.7/site-packages/setoolsgui/networkx/algorithms/assortativity/tests/test_mixing.py b/lib/python2.7/site-packages/setoolsgui/networkx/algorithms/assortativity/tests/test_mixing.py
new file mode 100644
index 0000000..ce60a94
--- /dev/null
+++ b/lib/python2.7/site-packages/setoolsgui/networkx/algorithms/assortativity/tests/test_mixing.py
@@ -0,0 +1,186 @@
+#!/usr/bin/env python
+from nose.tools import *
+from nose import SkipTest
+import networkx as nx
+from base_test import BaseTestAttributeMixing,BaseTestDegreeMixing
+
+
+class TestDegreeMixingDict(BaseTestDegreeMixing):
+
+
+    def test_degree_mixing_dict_undirected(self):
+        d=nx.degree_mixing_dict(self.P4)
+        d_result={1:{2:2},
+                  2:{1:2,2:2},
+                  }
+        assert_equal(d,d_result)
+
+    def test_degree_mixing_dict_undirected_normalized(self):
+        d=nx.degree_mixing_dict(self.P4, normalized=True)
+        d_result={1:{2:1.0/3},
+                  2:{1:1.0/3,2:1.0/3},
+                  }
+        assert_equal(d,d_result)
+
+    def test_degree_mixing_dict_directed(self):
+        d=nx.degree_mixing_dict(self.D)
+        print(d)
+        d_result={1:{3:2},
+                  2:{1:1,3:1},
+                  3:{}
+                  }
+        assert_equal(d,d_result)
+
+    def test_degree_mixing_dict_multigraph(self):
+        d=nx.degree_mixing_dict(self.M)
+        d_result={1:{2:1},
+                  2:{1:1,3:3},
+                  3:{2:3}
+                  }
+        assert_equal(d,d_result)
+
+
+class TestDegreeMixingMatrix(BaseTestDegreeMixing):
+
+    @classmethod
+    def setupClass(cls):
+        global np
+        global npt
+        try:
+            import numpy as np
+            import numpy.testing as npt
+
+        except ImportError:
+             raise SkipTest('NumPy not available.')
+
+    def test_degree_mixing_matrix_undirected(self):
+        a_result=np.array([[0,0,0],
+                           [0,0,2],
+                           [0,2,2]]
+                          )
+        a=nx.degree_mixing_matrix(self.P4,normalized=False)
+        npt.assert_equal(a,a_result)
+        a=nx.degree_mixing_matrix(self.P4)
+        npt.assert_equal(a,a_result/float(a_result.sum()))
+
+    def test_degree_mixing_matrix_directed(self):
+        a_result=np.array([[0,0,0,0],
+                           [0,0,0,2],
+                           [0,1,0,1],
+                           [0,0,0,0]]
+                          )
+        a=nx.degree_mixing_matrix(self.D,normalized=False)
+        npt.assert_equal(a,a_result)
+        a=nx.degree_mixing_matrix(self.D)
+        npt.assert_equal(a,a_result/float(a_result.sum()))
+
+    def test_degree_mixing_matrix_multigraph(self):
+        a_result=np.array([[0,0,0,0],
+                           [0,0,1,0],
+                           [0,1,0,3],
+                           [0,0,3,0]]
+                          )
+        a=nx.degree_mixing_matrix(self.M,normalized=False)
+        npt.assert_equal(a,a_result)
+        a=nx.degree_mixing_matrix(self.M)
+        npt.assert_equal(a,a_result/float(a_result.sum()))
+
+
+    def test_degree_mixing_matrix_selfloop(self):
+        a_result=np.array([[0,0,0],
+                           [0,0,0],
+                           [0,0,2]]
+                          )
+        a=nx.degree_mixing_matrix(self.S,normalized=False)
+        npt.assert_equal(a,a_result)
+        a=nx.degree_mixing_matrix(self.S)
+        npt.assert_equal(a,a_result/float(a_result.sum()))
+
+
+class TestAttributeMixingDict(BaseTestAttributeMixing):
+
+    def test_attribute_mixing_dict_undirected(self):
+        d=nx.attribute_mixing_dict(self.G,'fish')
+        d_result={'one':{'one':2,'red':1},
+                  'two':{'two':2,'blue':1},
+                  'red':{'one':1},
+                  'blue':{'two':1}
+                  }
+        assert_equal(d,d_result)
+
+    def test_attribute_mixing_dict_directed(self):
+        d=nx.attribute_mixing_dict(self.D,'fish')
+        d_result={'one':{'one':1,'red':1},
+                  'two':{'two':1,'blue':1},
+                  'red':{},
+                  'blue':{}
+                  }
+        assert_equal(d,d_result)
+
+
+    def test_attribute_mixing_dict_multigraph(self):
+        d=nx.attribute_mixing_dict(self.M,'fish')
+        d_result={'one':{'one':4},
+                  'two':{'two':2},
+                  }
+        assert_equal(d,d_result)
+
+
+
+class TestAttributeMixingMatrix(BaseTestAttributeMixing):
+    @classmethod
+    def setupClass(cls):
+        global np
+        global npt
+        try:
+            import numpy as np
+            import numpy.testing as npt
+
+        except ImportError:
+             raise SkipTest('NumPy not available.')
+
+    def test_attribute_mixing_matrix_undirected(self):
+        mapping={'one':0,'two':1,'red':2,'blue':3}
+        a_result=np.array([[2,0,1,0],
+                           [0,2,0,1],
+                           [1,0,0,0],
+                           [0,1,0,0]]
+                          )
+        a=nx.attribute_mixing_matrix(self.G,'fish',
+                                         mapping=mapping,
+                                         normalized=False)
+        npt.assert_equal(a,a_result)
+        a=nx.attribute_mixing_matrix(self.G,'fish',
+                                         mapping=mapping)
+        npt.assert_equal(a,a_result/float(a_result.sum()))
+
+    def test_attribute_mixing_matrix_directed(self):
+        mapping={'one':0,'two':1,'red':2,'blue':3}
+        a_result=np.array([[1,0,1,0],
+                           [0,1,0,1],
+                           [0,0,0,0],
+                           [0,0,0,0]]
+                          )
+        a=nx.attribute_mixing_matrix(self.D,'fish',
+                                         mapping=mapping,
+                                         normalized=False)
+        npt.assert_equal(a,a_result)
+        a=nx.attribute_mixing_matrix(self.D,'fish',
+                                         mapping=mapping)
+        npt.assert_equal(a,a_result/float(a_result.sum()))
+
+    def test_attribute_mixing_matrix_multigraph(self):
+        mapping={'one':0,'two':1,'red':2,'blue':3}
+        a_result=np.array([[4,0,0,0],
+                           [0,2,0,0],
+                           [0,0,0,0],
+                           [0,0,0,0]]
+                          )
+        a=nx.attribute_mixing_matrix(self.M,'fish',
+                                         mapping=mapping,
+                                         normalized=False)
+        npt.assert_equal(a,a_result)
+        a=nx.attribute_mixing_matrix(self.M,'fish',
+                                         mapping=mapping)
+        npt.assert_equal(a,a_result/float(a_result.sum()))
+