Subject: Fix some test case failures on i386.
Origin: upstream
Bug-Debian: https://bugs.debian.org/806383
Applied-Upstream: https://github.com/igraph/python-igraph/commit/17df5c301a952e4894db4e4a8963d85527fdc860

--- a/igraph/test/decomposition.py	2016-08-24 11:32:21.187287419 +0200
+++ b/igraph/test/decomposition.py	2016-08-24 11:50:58.345023251 +0200
@@ -141,15 +141,25 @@
 
 class CommunityTests(unittest.TestCase):
     def reindexMembership(self, cl):
+        if hasattr(cl, "membership"):
+            cl = cl.membership
         idgen = UniqueIdGenerator()
-        return [idgen[i] for i in cl.membership]
+        return [idgen[i] for i in cl]
+
+    def assertMembershipsEqual(self, observed, expected):
+        if hasattr(observed, "membership"):
+            observed = observed.membership
+        if hasattr(expected, "membership"):
+            expected = expected.membership
+        self.assertEqual(self.reindexMembership(expected), \
+                         self.reindexMembership(observed))
 
     def testClauset(self):
         # Two cliques of size 5 with one connecting edge
         g = Graph.Full(5) + Graph.Full(5)
         g.add_edges([(0, 5)])
         cl = g.community_fastgreedy().as_clustering()
-        self.assertEqual(cl.membership, [0,0,0,0,0,1,1,1,1,1])
+        self.assertMembershipsEqual(cl, [0,0,0,0,0,1,1,1,1,1])
         self.assertAlmostEqual(cl.q, 0.4523, places=3)
 
         # Lollipop, weighted
@@ -157,46 +167,46 @@
         g.add_edges([(3,4)])
         weights = [1, 1, 1, 1, 1, 1, 10, 10]
         cl = g.community_fastgreedy(weights).as_clustering()
-        self.assertEqual(cl.membership, [0, 0, 0, 1, 1, 1])
+        self.assertMembershipsEqual(cl, [0,0,0,1,1,1])
         self.assertAlmostEqual(cl.q, 0.1708, places=3)
 
         # Same graph, different weights
         g.es["weight"] = [3] * g.ecount()
         cl = g.community_fastgreedy("weight").as_clustering()
-        self.assertEqual(cl.membership, [0, 0, 0, 0, 1, 1])
+        self.assertMembershipsEqual(cl, [0,0,0,0,1,1])
         self.assertAlmostEqual(cl.q, 0.1796, places=3)
 
         # Disconnected graph
         g = Graph.Full(4) + Graph.Full(4) + Graph.Full(3) + Graph.Full(2)
         cl = g.community_fastgreedy().as_clustering()
-        self.assertEqual(cl.membership, [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3])
+        self.assertMembershipsEqual(cl, [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3])
 
         # Empty graph
         g = Graph(20)
         cl = g.community_fastgreedy().as_clustering()
-        self.assertEqual(cl.membership, range(g.vcount()))
+        self.assertMembershipsEqual(cl, range(g.vcount()))
 
     def testEdgeBetweenness(self):
         # Full graph, no weights
         g = Graph.Full(5)
         cl = g.community_edge_betweenness().as_clustering()
-        self.assertEqual(cl.membership, [0]*5)
+        self.assertMembershipsEqual(cl, [0]*5)
 
         # Full graph with weights
         g.es["weight"] = 1
         g[0,1] = g[1,2] = g[2,0] = g[3,4] = 10
         cl = g.community_edge_betweenness(weights="weight").as_clustering()
-        self.assertEqual(cl.membership, [0,0,0,1,1])
+        self.assertMembershipsEqual(cl, [0,0,0,1,1])
         self.assertAlmostEqual(cl.q, 0.2750, places=3)
 
     def testEigenvector(self):
         g = Graph.Full(5) + Graph.Full(5)
         g.add_edges([(0, 5)])
         cl = g.community_leading_eigenvector()
-        self.assertTrue(cl.membership == [0,0,0,0,0,1,1,1,1,1])
+        self.assertMembershipsEqual(cl, [0,0,0,0,0,1,1,1,1,1])
         self.assertAlmostEqual(cl.q, 0.4523, places=3)
         cl = g.community_leading_eigenvector(2)
-        self.assertTrue(cl.membership == [0,0,0,0,0,1,1,1,1,1])
+        self.assertMembershipsEqual(cl, [0,0,0,0,0,1,1,1,1,1])
         self.assertAlmostEqual(cl.q, 0.4523, places=3)
 
     def testInfomap(self):
@@ -204,7 +214,7 @@
         cl = g.community_infomap()
         self.assertAlmostEqual(cl.codelength, 4.60605, places=3)
         self.assertAlmostEqual(cl.q, 0.40203, places=3)
-        self.assertTrue(cl.membership == [1,1,1,1,2,2,2,1,0,1,2,1,1,1,0,0,2,1,0,1,0,1] + [0]*12)
+        self.assertMembershipsEqual(cl, [1,1,1,1,2,2,2,1,0,1,2,1,1,1,0,0,2,1,0,1,0,1] + [0]*12)
 
         # Smoke testing with vertex and edge weights
         v_weights = [random.randint(1, 5) for _ in xrange(g.vcount())]
@@ -223,7 +233,7 @@
         g.es["weight"] = [2, 1, 2]
         g.vs["initial"] = [0, -1, -1, 1]
         cl = g.community_label_propagation("weight", "initial", [1,0,0,1])
-        self.assertTrue(cl.membership == [0, 0, 1, 1])
+        self.assertMembershipsEqual(cl, [0,0,1,1])
         cl = g.community_label_propagation(initial="initial", fixed=[1,0,0,1])
         self.assertTrue(cl.membership == [0, 0, 1, 1] or \
                         cl.membership == [0, 1, 1, 1] or \
@@ -240,8 +250,8 @@
               (10,14), (11,13)]
         cls = g.community_multilevel(return_levels=True)
         self.assertTrue(len(cls) == 2)
-        self.assertTrue(cls[0].membership == [0,0,0,1,0,0,1,1,2,2,2,3,2,3,2,2])
-        self.assertTrue(cls[1].membership == [0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1])
+        self.assertMembershipsEqual(cls[0], [1,1,1,0,1,1,0,0,2,2,2,3,2,3,2,2])
+        self.assertMembershipsEqual(cls[1], [0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1])
         self.assertAlmostEqual(cls[0].q, 0.346301, places=5)
         self.assertAlmostEqual(cls[1].q, 0.392219, places=5)
 
@@ -251,7 +261,7 @@
 
             cl = g.community_optimal_modularity()
             self.assertTrue(len(cl) == 2)
-            self.assertTrue(cl.membership == [0, 0, 1, 0, 1])
+            self.assertMembershipsEqual(cl, [0, 0, 1, 0, 1])
             self.assertAlmostEqual(cl.q, 0.08, places=7)
 
             ws = [i % 5 for i in xrange(g.ecount())]
@@ -262,7 +272,7 @@
             g = Graph.Famous("zachary")
             cl = g.community_optimal_modularity()
             self.assertTrue(len(cl) == 4)
-            self.assertTrue(cl.membership == [0, 0, 0, 0, 1, 1, 1, 0, 2, 2, 1, \
+            self.assertMembershipsEqual(cl, [0, 0, 0, 0, 1, 1, 1, 0, 2, 2, 1, \
                     0, 0, 0, 2, 2, 1, 0, 2, 0, 2, 0, 2, 3, 3, 3, 2, 3, 3, \
                     2, 2, 3, 2, 2])
             self.assertAlmostEqual(cl.q, 0.4197896, places=7)
@@ -293,9 +303,9 @@
         g = Graph.Full(5) + Graph.Full(5) + Graph.Full(5)
         g += [(0,5), (5,10), (10, 0)]
         cl = g.community_walktrap().as_clustering()
-        self.assertTrue(cl.membership == [0,0,0,0,0,1,1,1,1,1,2,2,2,2,2])
+        self.assertMembershipsEqual(cl, [0,0,0,0,0,1,1,1,1,1,2,2,2,2,2])
         cl = g.community_walktrap(steps=3).as_clustering()
-        self.assertTrue(cl.membership == [0,0,0,0,0,1,1,1,1,1,2,2,2,2,2])
+        self.assertMembershipsEqual(cl, [0,0,0,0,0,1,1,1,1,1,2,2,2,2,2])
        
 
 class CohesiveBlocksTests(unittest.TestCase):
