← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_btree_index.py

  • Committer: John Arbash Meinel
  • Date: 2009-12-10 17:16:19 UTC
  • mfrom: (4884 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4889.
  • Revision ID: john@arbash-meinel.com-20091210171619-ehdcxjbl8afhq9g1
Bring in bzr.dev 4884

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_btree_index.py
124
124
 
125
125
class TestBTreeBuilder(BTreeTestCase):
126
126
 
 
127
    def test_clear_cache(self):
 
128
        builder = btree_index.BTreeBuilder(reference_lists=0, key_elements=1)
 
129
        # This is a no-op, but we need the api to be consistent with other
 
130
        # BTreeGraphIndex apis.
 
131
        builder.clear_cache()
 
132
 
127
133
    def test_empty_1_0(self):
128
134
        builder = btree_index.BTreeBuilder(key_elements=1, reference_lists=0)
129
135
        # NamedTemporaryFile dies on builder.finish().read(). weird.
155
161
        temp_file = builder.finish()
156
162
        content = temp_file.read()
157
163
        del temp_file
158
 
        self.assertEqual(158, len(content))
 
164
        self.assertEqual(131, len(content))
159
165
        self.assertEqual(
160
166
            "B+Tree Graph Index 2\nnode_ref_lists=0\nkey_elements=1\nlen=5\n"
161
167
            "row_lengths=1\n",
179
185
        temp_file = builder.finish()
180
186
        content = temp_file.read()
181
187
        del temp_file
182
 
        self.assertEqual(264, len(content))
 
188
        self.assertEqual(238, len(content))
183
189
        self.assertEqual(
184
190
            "B+Tree Graph Index 2\nnode_ref_lists=2\nkey_elements=2\nlen=10\n"
185
191
            "row_lengths=1\n",
245
251
        temp_file = builder.finish()
246
252
        content = temp_file.read()
247
253
        del temp_file
248
 
        self.assertEqual(181, len(content))
 
254
        self.assertEqual(155, len(content))
249
255
        self.assertEqual(
250
256
            "B+Tree Graph Index 2\nnode_ref_lists=0\nkey_elements=1\nlen=10\n"
251
257
            "row_lengths=1\n",
353
359
        # Test the parts of the index that take up memory are doing so
354
360
        # predictably.
355
361
        self.assertEqual(1, len(builder._nodes))
356
 
        self.assertEqual(1, len(builder._keys))
357
362
        self.assertIs(None, builder._nodes_by_key)
358
363
        builder.add_node(*nodes[1])
359
364
        self.assertEqual(0, len(builder._nodes))
360
 
        self.assertEqual(0, len(builder._keys))
361
365
        self.assertIs(None, builder._nodes_by_key)
362
366
        self.assertEqual(1, len(builder._backing_indices))
363
367
        self.assertEqual(2, builder._backing_indices[0].key_count())
364
368
        # now back to memory
365
369
        builder.add_node(*nodes[2])
366
370
        self.assertEqual(1, len(builder._nodes))
367
 
        self.assertEqual(1, len(builder._keys))
368
371
        self.assertIs(None, builder._nodes_by_key)
369
372
        # And spills to a second backing index combing all
370
373
        builder.add_node(*nodes[3])
371
374
        self.assertEqual(0, len(builder._nodes))
372
 
        self.assertEqual(0, len(builder._keys))
373
375
        self.assertIs(None, builder._nodes_by_key)
374
376
        self.assertEqual(2, len(builder._backing_indices))
375
377
        self.assertEqual(None, builder._backing_indices[0])
378
380
        builder.add_node(*nodes[4])
379
381
        builder.add_node(*nodes[5])
380
382
        self.assertEqual(0, len(builder._nodes))
381
 
        self.assertEqual(0, len(builder._keys))
382
383
        self.assertIs(None, builder._nodes_by_key)
383
384
        self.assertEqual(2, len(builder._backing_indices))
384
385
        self.assertEqual(2, builder._backing_indices[0].key_count())
442
443
        # Test the parts of the index that take up memory are doing so
443
444
        # predictably.
444
445
        self.assertEqual(1, len(builder._nodes))
445
 
        self.assertEqual(1, len(builder._keys))
446
446
        self.assertIs(None, builder._nodes_by_key)
447
447
        builder.add_node(*nodes[1])
448
448
        self.assertEqual(0, len(builder._nodes))
449
 
        self.assertEqual(0, len(builder._keys))
450
449
        self.assertIs(None, builder._nodes_by_key)
451
450
        self.assertEqual(1, len(builder._backing_indices))
452
451
        self.assertEqual(2, builder._backing_indices[0].key_count())
453
452
        # now back to memory
454
453
        builder.add_node(*nodes[2])
455
454
        self.assertEqual(1, len(builder._nodes))
456
 
        self.assertEqual(1, len(builder._keys))
457
455
        self.assertIs(None, builder._nodes_by_key)
458
456
        # And spills to a second backing index but doesn't combine
459
457
        builder.add_node(*nodes[3])
460
458
        self.assertEqual(0, len(builder._nodes))
461
 
        self.assertEqual(0, len(builder._keys))
462
459
        self.assertIs(None, builder._nodes_by_key)
463
460
        self.assertEqual(2, len(builder._backing_indices))
464
461
        for backing_index in builder._backing_indices:
467
464
        builder.add_node(*nodes[4])
468
465
        builder.add_node(*nodes[5])
469
466
        self.assertEqual(0, len(builder._nodes))
470
 
        self.assertEqual(0, len(builder._keys))
471
467
        self.assertIs(None, builder._nodes_by_key)
472
468
        self.assertEqual(3, len(builder._backing_indices))
473
469
        for backing_index in builder._backing_indices:
532
528
        builder.add_node(*nodes[0])
533
529
        # Test the parts of the index that take up memory are doing so
534
530
        # predictably.
535
 
        self.assertEqual(1, len(builder._keys))
536
531
        self.assertEqual(1, len(builder._nodes))
537
532
        self.assertIs(None, builder._nodes_by_key)
538
533
        builder.add_node(*nodes[1])
539
 
        self.assertEqual(0, len(builder._keys))
540
534
        self.assertEqual(0, len(builder._nodes))
541
535
        self.assertIs(None, builder._nodes_by_key)
542
536
        self.assertEqual(1, len(builder._backing_indices))
545
539
        old = dict(builder._get_nodes_by_key()) #Build up the nodes by key dict
546
540
        builder.add_node(*nodes[2])
547
541
        self.assertEqual(1, len(builder._nodes))
548
 
        self.assertEqual(1, len(builder._keys))
549
542
        self.assertIsNot(None, builder._nodes_by_key)
550
543
        self.assertNotEqual({}, builder._nodes_by_key)
551
544
        # We should have a new entry
553
546
        # And spills to a second backing index combing all
554
547
        builder.add_node(*nodes[3])
555
548
        self.assertEqual(0, len(builder._nodes))
556
 
        self.assertEqual(0, len(builder._keys))
557
549
        self.assertIs(None, builder._nodes_by_key)
558
550
        self.assertEqual(2, len(builder._backing_indices))
559
551
        self.assertEqual(None, builder._backing_indices[0])
562
554
        builder.add_node(*nodes[4])
563
555
        builder.add_node(*nodes[5])
564
556
        self.assertEqual(0, len(builder._nodes))
565
 
        self.assertEqual(0, len(builder._keys))
566
557
        self.assertIs(None, builder._nodes_by_key)
567
558
        self.assertEqual(2, len(builder._backing_indices))
568
559
        self.assertEqual(2, builder._backing_indices[0].key_count())
639
630
        size = trans.put_file('index', stream)
640
631
        return btree_index.BTreeGraphIndex(trans, 'index', size)
641
632
 
 
633
    def test_clear_cache(self):
 
634
        nodes = self.make_nodes(160, 2, 2)
 
635
        index = self.make_index(ref_lists=2, key_elements=2, nodes=nodes)
 
636
        self.assertEqual(1, len(list(index.iter_entries([nodes[30][0]]))))
 
637
        self.assertEqual([1, 4], index._row_lengths)
 
638
        self.assertIsNot(None, index._root_node)
 
639
        internal_node_pre_clear = index._internal_node_cache.keys()
 
640
        self.assertTrue(len(index._leaf_node_cache) > 0)
 
641
        index.clear_cache()
 
642
        # We don't touch _root_node or _internal_node_cache, both should be
 
643
        # small, and can save a round trip or two
 
644
        self.assertIsNot(None, index._root_node)
 
645
        # NOTE: We don't want to affect the _internal_node_cache, as we expect
 
646
        #       it will be small, and if we ever do touch this index again, it
 
647
        #       will save round-trips.  This assertion isn't very strong,
 
648
        #       becuase without a 3-level index, we don't have any internal
 
649
        #       nodes cached.
 
650
        self.assertEqual(internal_node_pre_clear,
 
651
                         index._internal_node_cache.keys())
 
652
        self.assertEqual(0, len(index._leaf_node_cache))
 
653
 
642
654
    def test_trivial_constructor(self):
643
655
        transport = get_transport('trace+' + self.get_url(''))
644
656
        index = btree_index.BTreeGraphIndex(transport, 'index', None)
691
703
        # The entire index should have been read, as it is one page long.
692
704
        self.assertEqual([('readv', 'index', [(0, size)], False, None)],
693
705
            transport._activity)
694
 
        self.assertEqual(1199, size)
 
706
        self.assertEqual(1173, size)
695
707
 
696
708
    def test__read_nodes_no_size_one_page_reads_once(self):
697
709
        self.make_index(nodes=[(('key',), 'value', ())])
745
757
        # The entire index should have been read linearly.
746
758
        self.assertEqual([('readv', 'index', [(0, size)], False, None)],
747
759
            transport._activity)
748
 
        self.assertEqual(1514, size)
 
760
        self.assertEqual(1488, size)
749
761
 
750
762
    def test_validate_two_pages(self):
751
763
        builder = btree_index.BTreeBuilder(key_elements=2, reference_lists=2)