← 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: Andrew Bennetts
  • Date: 2010-02-12 04:33:05 UTC
  • mfrom: (5031 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5032.
  • Revision ID: andrew.bennetts@canonical.com-20100212043305-ujdbsdoviql2t7i3
Merge lp:bzr

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_btree_index.py
43
43
        condition_isinstance(TestBTreeNodes))
44
44
    import bzrlib._btree_serializer_py as py_module
45
45
    scenarios = [('python', {'parse_btree': py_module})]
46
 
    if CompiledBtreeParserFeature.available():
47
 
        # Is there a way to do this that gets missing feature failures rather
48
 
        # than no indication to the user?
49
 
        import bzrlib._btree_serializer_pyx as c_module
50
 
        scenarios.append(('C', {'parse_btree': c_module}))
 
46
    if compiled_btreeparser_feature.available():
 
47
        scenarios.append(('C', {'parse_btree':
 
48
                                compiled_btreeparser_feature.module}))
51
49
    return multiply_tests(node_tests, scenarios, others)
52
50
 
53
51
 
54
 
class _CompiledBtreeParserFeature(tests.Feature):
55
 
    def _probe(self):
56
 
        try:
57
 
            import bzrlib._btree_serializer_pyx
58
 
        except ImportError:
59
 
            return False
60
 
        return True
61
 
 
62
 
    def feature_name(self):
63
 
        return 'bzrlib._btree_serializer_pyx'
64
 
 
65
 
CompiledBtreeParserFeature = _CompiledBtreeParserFeature()
 
52
compiled_btreeparser_feature = tests.ModuleAvailableFeature(
 
53
                                'bzrlib._btree_serializer_pyx')
66
54
 
67
55
 
68
56
class BTreeTestCase(TestCaseWithTransport):
71
59
 
72
60
    def setUp(self):
73
61
        TestCaseWithTransport.setUp(self)
74
 
        self._original_header = btree_index._RESERVED_HEADER_BYTES
75
 
        def restore():
76
 
            btree_index._RESERVED_HEADER_BYTES = self._original_header
77
 
        self.addCleanup(restore)
78
 
        btree_index._RESERVED_HEADER_BYTES = 100
 
62
        self.overrideAttr(btree_index, '_RESERVED_HEADER_BYTES', 100)
79
63
 
80
64
    def make_nodes(self, count, key_elements, reference_lists):
81
65
        """Generate count*key_elements sample nodes."""
115
99
 
116
100
    def shrink_page_size(self):
117
101
        """Shrink the default page size so that less fits in a page."""
118
 
        old_page_size = btree_index._PAGE_SIZE
119
 
        def cleanup():
120
 
            btree_index._PAGE_SIZE = old_page_size
121
 
        self.addCleanup(cleanup)
 
102
        self.overrideAttr(btree_index, '_PAGE_SIZE')
122
103
        btree_index._PAGE_SIZE = 2048
123
104
 
124
105
 
359
340
        # Test the parts of the index that take up memory are doing so
360
341
        # predictably.
361
342
        self.assertEqual(1, len(builder._nodes))
362
 
        self.assertEqual(1, len(builder._keys))
363
343
        self.assertIs(None, builder._nodes_by_key)
364
344
        builder.add_node(*nodes[1])
365
345
        self.assertEqual(0, len(builder._nodes))
366
 
        self.assertEqual(0, len(builder._keys))
367
346
        self.assertIs(None, builder._nodes_by_key)
368
347
        self.assertEqual(1, len(builder._backing_indices))
369
348
        self.assertEqual(2, builder._backing_indices[0].key_count())
370
349
        # now back to memory
371
350
        builder.add_node(*nodes[2])
372
351
        self.assertEqual(1, len(builder._nodes))
373
 
        self.assertEqual(1, len(builder._keys))
374
352
        self.assertIs(None, builder._nodes_by_key)
375
353
        # And spills to a second backing index combing all
376
354
        builder.add_node(*nodes[3])
377
355
        self.assertEqual(0, len(builder._nodes))
378
 
        self.assertEqual(0, len(builder._keys))
379
356
        self.assertIs(None, builder._nodes_by_key)
380
357
        self.assertEqual(2, len(builder._backing_indices))
381
358
        self.assertEqual(None, builder._backing_indices[0])
384
361
        builder.add_node(*nodes[4])
385
362
        builder.add_node(*nodes[5])
386
363
        self.assertEqual(0, len(builder._nodes))
387
 
        self.assertEqual(0, len(builder._keys))
388
364
        self.assertIs(None, builder._nodes_by_key)
389
365
        self.assertEqual(2, len(builder._backing_indices))
390
366
        self.assertEqual(2, builder._backing_indices[0].key_count())
448
424
        # Test the parts of the index that take up memory are doing so
449
425
        # predictably.
450
426
        self.assertEqual(1, len(builder._nodes))
451
 
        self.assertEqual(1, len(builder._keys))
452
427
        self.assertIs(None, builder._nodes_by_key)
453
428
        builder.add_node(*nodes[1])
454
429
        self.assertEqual(0, len(builder._nodes))
455
 
        self.assertEqual(0, len(builder._keys))
456
430
        self.assertIs(None, builder._nodes_by_key)
457
431
        self.assertEqual(1, len(builder._backing_indices))
458
432
        self.assertEqual(2, builder._backing_indices[0].key_count())
459
433
        # now back to memory
460
434
        builder.add_node(*nodes[2])
461
435
        self.assertEqual(1, len(builder._nodes))
462
 
        self.assertEqual(1, len(builder._keys))
463
436
        self.assertIs(None, builder._nodes_by_key)
464
437
        # And spills to a second backing index but doesn't combine
465
438
        builder.add_node(*nodes[3])
466
439
        self.assertEqual(0, len(builder._nodes))
467
 
        self.assertEqual(0, len(builder._keys))
468
440
        self.assertIs(None, builder._nodes_by_key)
469
441
        self.assertEqual(2, len(builder._backing_indices))
470
442
        for backing_index in builder._backing_indices:
473
445
        builder.add_node(*nodes[4])
474
446
        builder.add_node(*nodes[5])
475
447
        self.assertEqual(0, len(builder._nodes))
476
 
        self.assertEqual(0, len(builder._keys))
477
448
        self.assertIs(None, builder._nodes_by_key)
478
449
        self.assertEqual(3, len(builder._backing_indices))
479
450
        for backing_index in builder._backing_indices:
538
509
        builder.add_node(*nodes[0])
539
510
        # Test the parts of the index that take up memory are doing so
540
511
        # predictably.
541
 
        self.assertEqual(1, len(builder._keys))
542
512
        self.assertEqual(1, len(builder._nodes))
543
513
        self.assertIs(None, builder._nodes_by_key)
544
514
        builder.add_node(*nodes[1])
545
 
        self.assertEqual(0, len(builder._keys))
546
515
        self.assertEqual(0, len(builder._nodes))
547
516
        self.assertIs(None, builder._nodes_by_key)
548
517
        self.assertEqual(1, len(builder._backing_indices))
551
520
        old = dict(builder._get_nodes_by_key()) #Build up the nodes by key dict
552
521
        builder.add_node(*nodes[2])
553
522
        self.assertEqual(1, len(builder._nodes))
554
 
        self.assertEqual(1, len(builder._keys))
555
523
        self.assertIsNot(None, builder._nodes_by_key)
556
524
        self.assertNotEqual({}, builder._nodes_by_key)
557
525
        # We should have a new entry
559
527
        # And spills to a second backing index combing all
560
528
        builder.add_node(*nodes[3])
561
529
        self.assertEqual(0, len(builder._nodes))
562
 
        self.assertEqual(0, len(builder._keys))
563
530
        self.assertIs(None, builder._nodes_by_key)
564
531
        self.assertEqual(2, len(builder._backing_indices))
565
532
        self.assertEqual(None, builder._backing_indices[0])
568
535
        builder.add_node(*nodes[4])
569
536
        builder.add_node(*nodes[5])
570
537
        self.assertEqual(0, len(builder._nodes))
571
 
        self.assertEqual(0, len(builder._keys))
572
538
        self.assertIs(None, builder._nodes_by_key)
573
539
        self.assertEqual(2, len(builder._backing_indices))
574
540
        self.assertEqual(2, builder._backing_indices[0].key_count())
1184
1150
 
1185
1151
class TestBTreeNodes(BTreeTestCase):
1186
1152
 
1187
 
    def restore_parser(self):
1188
 
        btree_index._btree_serializer = self.saved_parser
1189
 
 
1190
1153
    def setUp(self):
1191
1154
        BTreeTestCase.setUp(self)
1192
 
        self.saved_parser = btree_index._btree_serializer
1193
 
        self.addCleanup(self.restore_parser)
1194
 
        btree_index._btree_serializer = self.parse_btree
 
1155
        self.overrideAttr(btree_index, '_btree_serializer', self.parse_btree)
1195
1156
 
1196
1157
    def test_LeafNode_1_0(self):
1197
1158
        node_bytes = ("type=leaf\n"
1308
1269
    def test_exists(self):
1309
1270
        # This is just to let the user know if they don't have the feature
1310
1271
        # available
1311
 
        self.requireFeature(CompiledBtreeParserFeature)
 
1272
        self.requireFeature(compiled_btreeparser_feature)
1312
1273
 
1313
1274
 
1314
1275
class TestMultiBisectRight(tests.TestCase):