Rev 4171: Fix the test suite now that we don't combine-on-spill in lp:///~jameinel/bzr/1.14-btree_spill

[John Arbash Meinel]

At lp:///~jameinel/bzr/1.14-btree_spill

------------------------------------------------------------
revno: 4171
revision-id: john at arbash-meinel.com-20090319202123-2fravh4wzgt3lp57
parent: john at arbash-meinel.com-20090319201050-yii7fgrjvlqn3nuf
committer: John Arbash Meinel <john at arbash-meinel.com>
branch nick: 1.14-btree_spill
timestamp: Thu 2009-03-19 15:21:23 -0500
message:
  Fix the test suite now that we don't combine-on-spill
-------------- next part --------------
=== modified file 'bzrlib/tests/test_btree_index.py'
--- a/bzrlib/tests/test_btree_index.py	2009-03-07 06:58:17 +0000
+++ b/bzrlib/tests/test_btree_index.py	2009-03-19 20:21:23 +0000
@@ -363,43 +363,40 @@
         self.assertEqual(1, len(builder._nodes))
         self.assertEqual(1, len(builder._keys))
         self.assertIs(None, builder._nodes_by_key)
-        # And spills to a second backing index combing all
+        # And spills to a second backing index
         builder.add_node(*nodes[3])
         self.assertEqual(0, len(builder._nodes))
         self.assertEqual(0, len(builder._keys))
         self.assertIs(None, builder._nodes_by_key)
         self.assertEqual(2, len(builder._backing_indices))
-        self.assertEqual(None, builder._backing_indices[0])
-        self.assertEqual(4, builder._backing_indices[1].key_count())
-        # The next spills to the 2-len slot
+        for i in xrange(2):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
+        # The next spills to the next slot
         builder.add_node(*nodes[4])
         builder.add_node(*nodes[5])
         self.assertEqual(0, len(builder._nodes))
         self.assertEqual(0, len(builder._keys))
         self.assertIs(None, builder._nodes_by_key)
-        self.assertEqual(2, len(builder._backing_indices))
-        self.assertEqual(2, builder._backing_indices[0].key_count())
-        self.assertEqual(4, builder._backing_indices[1].key_count())
+        self.assertEqual(3, len(builder._backing_indices))
+        for i in xrange(3):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
         # Next spill combines
         builder.add_node(*nodes[6])
         builder.add_node(*nodes[7])
-        self.assertEqual(3, len(builder._backing_indices))
-        self.assertEqual(None, builder._backing_indices[0])
-        self.assertEqual(None, builder._backing_indices[1])
-        self.assertEqual(8, builder._backing_indices[2].key_count())
+        self.assertEqual(4, len(builder._backing_indices))
+        for i in xrange(4):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
         # And so forth - counting up in binary.
         builder.add_node(*nodes[8])
         builder.add_node(*nodes[9])
-        self.assertEqual(3, len(builder._backing_indices))
-        self.assertEqual(2, builder._backing_indices[0].key_count())
-        self.assertEqual(None, builder._backing_indices[1])
-        self.assertEqual(8, builder._backing_indices[2].key_count())
+        self.assertEqual(5, len(builder._backing_indices))
+        for i in xrange(5):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
         builder.add_node(*nodes[10])
         builder.add_node(*nodes[11])
-        self.assertEqual(3, len(builder._backing_indices))
-        self.assertEqual(None, builder._backing_indices[0])
-        self.assertEqual(4, builder._backing_indices[1].key_count())
-        self.assertEqual(8, builder._backing_indices[2].key_count())
+        self.assertEqual(6, len(builder._backing_indices))
+        for i in xrange(6):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
         builder.add_node(*nodes[12])
         # Test that memory and disk are both used for query methods; and that
         # None is skipped over happily.
@@ -412,17 +409,14 @@
         self.assertEqual(set([(builder,) + node for node in nodes[11:13]]),
             set(builder.iter_entries_prefix([nodes[12][0], nodes[11][0]])))
         builder.add_node(*nodes[13])
-        self.assertEqual(3, len(builder._backing_indices))
-        self.assertEqual(2, builder._backing_indices[0].key_count())
-        self.assertEqual(4, builder._backing_indices[1].key_count())
-        self.assertEqual(8, builder._backing_indices[2].key_count())
+        self.assertEqual(7, len(builder._backing_indices))
+        for i in xrange(7):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
         builder.add_node(*nodes[14])
         builder.add_node(*nodes[15])
-        self.assertEqual(4, len(builder._backing_indices))
-        self.assertEqual(None, builder._backing_indices[0])
-        self.assertEqual(None, builder._backing_indices[1])
-        self.assertEqual(None, builder._backing_indices[2])
-        self.assertEqual(16, builder._backing_indices[3].key_count())
+        self.assertEqual(8, len(builder._backing_indices))
+        for i in xrange(8):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
         # Now finish, and check we got a correctly ordered tree
         transport = self.get_transport('')
         size = transport.put_file('index', builder.finish())
@@ -464,43 +458,39 @@
         self.assertNotEqual({}, builder._nodes_by_key)
         # We should have a new entry
         self.assertNotEqual(old, builder._nodes_by_key)
-        # And spills to a second backing index combing all
+        # And spills to a second backing index
         builder.add_node(*nodes[3])
         self.assertEqual(0, len(builder._nodes))
         self.assertEqual(0, len(builder._keys))
         self.assertIs(None, builder._nodes_by_key)
         self.assertEqual(2, len(builder._backing_indices))
-        self.assertEqual(None, builder._backing_indices[0])
-        self.assertEqual(4, builder._backing_indices[1].key_count())
-        # The next spills to the 2-len slot
+        for i in xrange(2):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
+        # The next spills to yet another slot
         builder.add_node(*nodes[4])
         builder.add_node(*nodes[5])
         self.assertEqual(0, len(builder._nodes))
         self.assertEqual(0, len(builder._keys))
         self.assertIs(None, builder._nodes_by_key)
-        self.assertEqual(2, len(builder._backing_indices))
-        self.assertEqual(2, builder._backing_indices[0].key_count())
-        self.assertEqual(4, builder._backing_indices[1].key_count())
-        # Next spill combines
+        self.assertEqual(3, len(builder._backing_indices))
+        for i in xrange(3):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
         builder.add_node(*nodes[6])
         builder.add_node(*nodes[7])
-        self.assertEqual(3, len(builder._backing_indices))
-        self.assertEqual(None, builder._backing_indices[0])
-        self.assertEqual(None, builder._backing_indices[1])
-        self.assertEqual(8, builder._backing_indices[2].key_count())
-        # And so forth - counting up in binary.
+        self.assertEqual(4, len(builder._backing_indices))
+        for i in xrange(4):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
+        # And so forth
         builder.add_node(*nodes[8])
         builder.add_node(*nodes[9])
-        self.assertEqual(3, len(builder._backing_indices))
-        self.assertEqual(2, builder._backing_indices[0].key_count())
-        self.assertEqual(None, builder._backing_indices[1])
-        self.assertEqual(8, builder._backing_indices[2].key_count())
+        self.assertEqual(5, len(builder._backing_indices))
+        for i in xrange(5):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
         builder.add_node(*nodes[10])
         builder.add_node(*nodes[11])
-        self.assertEqual(3, len(builder._backing_indices))
-        self.assertEqual(None, builder._backing_indices[0])
-        self.assertEqual(4, builder._backing_indices[1].key_count())
-        self.assertEqual(8, builder._backing_indices[2].key_count())
+        self.assertEqual(6, len(builder._backing_indices))
+        for i in xrange(6):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
         builder.add_node(*nodes[12])
         # Test that memory and disk are both used for query methods; and that
         # None is skipped over happily.
@@ -513,17 +503,14 @@
         self.assertEqual(set([(builder,) + node for node in nodes[11:13]]),
             set(builder.iter_entries_prefix([nodes[12][0], nodes[11][0]])))
         builder.add_node(*nodes[13])
-        self.assertEqual(3, len(builder._backing_indices))
-        self.assertEqual(2, builder._backing_indices[0].key_count())
-        self.assertEqual(4, builder._backing_indices[1].key_count())
-        self.assertEqual(8, builder._backing_indices[2].key_count())
+        self.assertEqual(7, len(builder._backing_indices))
+        for i in xrange(7):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
         builder.add_node(*nodes[14])
         builder.add_node(*nodes[15])
-        self.assertEqual(4, len(builder._backing_indices))
-        self.assertEqual(None, builder._backing_indices[0])
-        self.assertEqual(None, builder._backing_indices[1])
-        self.assertEqual(None, builder._backing_indices[2])
-        self.assertEqual(16, builder._backing_indices[3].key_count())
+        self.assertEqual(8, len(builder._backing_indices))
+        for i in xrange(7):
+            self.assertEqual(2, builder._backing_indices[i].key_count())
         # Now finish, and check we got a correctly ordered tree
         transport = self.get_transport('')
         size = transport.put_file('index', builder.finish())