← Back to branch summary

~jelmer/brz/launchpad-test-fix

« back to all changes in this revision

Viewing changes to breezy/tests/test_index.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-08-20 23:50:02 UTC
  • mfrom: (7067.4.2 python3-fix-index)
  • Revision ID: breezy.the.bot@gmail.com-20180820235002-ganbpwhc5obsfb9n
Fix the last few failing index tests on Python 3.

Merged from https://code.launchpad.net/~jelmer/brz/python3-fix-index/+merge/353379

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_index.py
310
310
            self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
311
311
                (b'a%skey' % int2byte(bad_char), ), b'data')
312
312
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
313
 
                (b'', ), b'data')
 
313
                (), b'data')
314
314
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
315
315
                b'not-a-tuple', b'data')
316
316
        # not enough length
544
544
        # And the regions of the file that have been parsed should be in the
545
545
        # parsed_byte_map and the parsed_key_map
546
546
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
547
 
        self.assertEqual([(None, self.make_key(26)),
 
547
        self.assertEqual([((), self.make_key(26)),
548
548
                          (self.make_key(31), self.make_key(48))],
549
549
                         index._parsed_key_map)
550
550
 
560
560
        # and we should have a parse map that includes the header and the
561
561
        # region that was parsed after trimming.
562
562
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
563
 
        self.assertEqual([(None, self.make_key(26)),
 
563
        self.assertEqual([((), self.make_key(26)),
564
564
                          (self.make_key(31), self.make_key(48))],
565
565
            index._parsed_key_map)
566
566
 
584
584
        # and we should have a parse map that includes the header and the
585
585
        # region that was parsed after trimming.
586
586
        self.assertEqual([(0, 4045), (11759, 15707)], index._parsed_byte_map)
587
 
        self.assertEqual([(None, self.make_key(116)),
 
587
        self.assertEqual([((), self.make_key(116)),
588
588
                          (self.make_key(35), self.make_key(51))],
589
589
            index._parsed_key_map)
590
590
        # now ask for two keys, right before and after the parsed region
608
608
            [(index._size // 2, (b'40', ))])
609
609
        # check the parse map, this determines the test validity
610
610
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
611
 
        self.assertEqual([(None, self.make_key(26)),
 
611
        self.assertEqual([((), self.make_key(26)),
612
612
                          (self.make_key(31), self.make_key(48))],
613
613
            index._parsed_key_map)
614
614
        # reset the transport log
632
632
            [(index._size // 2, (b'40', ))])
633
633
        # check the parse map, this determines the test validity
634
634
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
635
 
        self.assertEqual([(None, self.make_key(26)),
 
635
        self.assertEqual([((), self.make_key(26)),
636
636
                          (self.make_key(31), self.make_key(48))],
637
637
            index._parsed_key_map)
638
638
        # reset the transport log
659
659
            [(index._size // 2, (b'30', ))])
660
660
        # check the parse map, this determines the test validity
661
661
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
662
 
        self.assertEqual([(None, self.make_key(26)),
 
662
        self.assertEqual([((), self.make_key(26)),
663
663
                          (self.make_key(31), self.make_key(48))],
664
664
            index._parsed_key_map)
665
 
        self.assertEqual([((index._size // 2, ('30', )), -1)],
 
665
        self.assertEqual([((index._size // 2, (b'30', )), -1)],
666
666
            result)
667
667
 
668
668
    def test_lookup_key_above_probed_area(self):
675
675
            [(index._size // 2, (b'50', ))])
676
676
        # check the parse map, this determines the test validity
677
677
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
678
 
        self.assertEqual([(None, self.make_key(26)),
 
678
        self.assertEqual([((), self.make_key(26)),
679
679
                          (self.make_key(31), self.make_key(48))],
680
680
            index._parsed_key_map)
681
681
        self.assertEqual([((index._size // 2, (b'50', )), +1)],
698
698
        # check the parse map - only the start and middle should have been
699
699
        # parsed.
700
700
        self.assertEqual([(0, 4027), (10198, 14028)], index._parsed_byte_map)
701
 
        self.assertEqual([(None, self.make_key(17)),
 
701
        self.assertEqual([((), self.make_key(17)),
702
702
                          (self.make_key(44), self.make_key(5))],
703
703
            index._parsed_key_map)
704
704
        # and check the transport activity likewise.
733
733
        # check the parse map - only the start and middle should have been
734
734
        # parsed.
735
735
        self.assertEqual([(0, 3890), (6444, 10274)], index._parsed_byte_map)
736
 
        self.assertEqual([(None, self.make_key(25)),
 
736
        self.assertEqual([((), self.make_key(25)),
737
737
                          (self.make_key(37), self.make_key(52))],
738
738
            index._parsed_key_map)
739
739
        # and check the transport activity likewise.
1463
1463
        index2_1, index2_2 = cgi2._indices
1464
1464
        cgi1.set_sibling_indices([cgi2])
1465
1465
        # Trigger a reordering in cgi1.  cgi2 will be reordered as well.
1466
 
        list(cgi1.iter_entries([('index-1-2-key-1',)]))
 
1466
        list(cgi1.iter_entries([(b'index-1-2-key-1',)]))
1467
1467
        self.assertEqual([index2_2, index2_1], cgi2._indices)
1468
1468
        self.assertEqual(['two', 'one'], cgi2._index_names)
1469
1469