/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_knit.py

  • Committer: Jelmer Vernooij
  • Date: 2017-02-05 16:49:28 UTC
  • mto: (6621.2.1 py3)
  • mto: This revision was merged to the branch mainline in revision 6624.
  • Revision ID: jelmer@jelmer.uk-20170205164928-nmcybzip5kdhiwon
Use 2to3 set_literal fixer.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_knit.py
943
943
            ])
944
944
        index = self.get_knit_index(transport, "filename", "r")
945
945
        self.assertEqual(1, len(index.keys()))
946
 
        self.assertEqual(set([("version",)]), index.keys())
 
946
        self.assertEqual({("version",)}, index.keys())
947
947
 
948
948
    def test_read_corrupted_header(self):
949
949
        transport = MockTransport(['not a bzr knit index header\n'])
1026
1026
        self.assertEqual(set(), index.keys())
1027
1027
 
1028
1028
        index.add_records([(("a",), ["option"], (("a",), 0, 1), [])])
1029
 
        self.assertEqual(set([("a",)]), index.keys())
 
1029
        self.assertEqual({("a",)}, index.keys())
1030
1030
 
1031
1031
        index.add_records([(("a",), ["option"], (("a",), 0, 1), [])])
1032
 
        self.assertEqual(set([("a",)]), index.keys())
 
1032
        self.assertEqual({("a",)}, index.keys())
1033
1033
 
1034
1034
        index.add_records([(("b",), ["option"], (("b",), 0, 1), [])])
1035
 
        self.assertEqual(set([("a",), ("b",)]), index.keys())
 
1035
        self.assertEqual({("a",), ("b",)}, index.keys())
1036
1036
 
1037
1037
    def add_a_b(self, index, random_id=None):
1038
1038
        kwargs = {}
1291
1291
            "b option 10 10 0", # This line isn't terminated, ignored
1292
1292
            ])
1293
1293
        index = self.get_knit_index(transport, "filename", "r")
1294
 
        self.assertEqual(set([('a',)]), index.keys())
 
1294
        self.assertEqual({('a',)}, index.keys())
1295
1295
 
1296
1296
    def test_skip_incomplete_record(self):
1297
1297
        # A line with bogus data should just be skipped
1302
1302
            "c option 20 10 0 :", # Properly terminated, and starts with '\n'
1303
1303
            ])
1304
1304
        index = self.get_knit_index(transport, "filename", "r")
1305
 
        self.assertEqual(set([('a',), ('c',)]), index.keys())
 
1305
        self.assertEqual({('a',), ('c',)}, index.keys())
1306
1306
 
1307
1307
    def test_trailing_characters(self):
1308
1308
        # A line with bogus data should just be skipped
1313
1313
            "c option 20 10 0 :", # Properly terminated, and starts with '\n'
1314
1314
            ])
1315
1315
        index = self.get_knit_index(transport, "filename", "r")
1316
 
        self.assertEqual(set([('a',), ('c',)]), index.keys())
 
1316
        self.assertEqual({('a',), ('c',)}, index.keys())
1317
1317
 
1318
1318
 
1319
1319
class LowLevelKnitIndexTests_c(LowLevelKnitIndexTests):
1549
1549
            'a-2 fulltext 0 0 0 :\n'
1550
1550
            'a-3 fulltext 0 0 1 :'
1551
1551
            )
1552
 
        self.assertEqual(set([('a-3',), ('a-1',), ('a-2',)]), idx.keys())
 
1552
        self.assertEqual({('a-3',), ('a-1',), ('a-2',)}, idx.keys())
1553
1553
        self.assertEqual({
1554
1554
            ('a-1',): ((('a-1',), 0, 0), None, (), ('fulltext', False)),
1555
1555
            ('a-2',): ((('a-2',), 0, 0), None, (('a-1',),), ('fulltext', False)),
1587
1587
 
1588
1588
        # Assert the pre-condition
1589
1589
        def assertA1Only():
1590
 
            self.assertEqual(set([('a-1',)]), set(idx.keys()))
 
1590
            self.assertEqual({('a-1',)}, set(idx.keys()))
1591
1591
            self.assertEqual(
1592
1592
                {('a-1',): ((('a-1',), 0, 0), None, (), ('fulltext', False))},
1593
1593
                idx.get_build_details([('a-1',)]))
1662
1662
 
1663
1663
    def test_keys(self):
1664
1664
        index = self.two_graph_index()
1665
 
        self.assertEqual(set([('tail',), ('tip',), ('parent',), ('separate',)]),
 
1665
        self.assertEqual({('tail',), ('tip',), ('parent',), ('separate',)},
1666
1666
            set(index.keys()))
1667
1667
 
1668
1668
    def test_get_position(self):
1964
1964
 
1965
1965
    def test_keys(self):
1966
1966
        index = self.two_graph_index()
1967
 
        self.assertEqual(set([('tail',), ('tip',), ('parent',), ('separate',)]),
 
1967
        self.assertEqual({('tail',), ('tip',), ('parent',), ('separate',)},
1968
1968
            set(index.keys()))
1969
1969
 
1970
1970
    def test_get_position(self):
2128
2128
            }
2129
2129
        self.assertGroupKeysForIo([([f_a], set())],
2130
2130
                                  [f_a], [], positions)
2131
 
        self.assertGroupKeysForIo([([f_a], set([f_a]))],
 
2131
        self.assertGroupKeysForIo([([f_a], {f_a})],
2132
2132
                                  [f_a], [f_a], positions)
2133
2133
        self.assertGroupKeysForIo([([f_a, f_b], set([]))],
2134
2134
                                  [f_a, f_b], [], positions)
2135
 
        self.assertGroupKeysForIo([([f_a, f_b], set([f_b]))],
 
2135
        self.assertGroupKeysForIo([([f_a, f_b], {f_b})],
2136
2136
                                  [f_a, f_b], [f_b], positions)
2137
2137
        self.assertGroupKeysForIo([([f_a, f_b, g_a, g_b], set())],
2138
2138
                                  [f_a, g_a, f_b, g_b], [], positions)
2235
2235
        self.assertEqual([(key_basis, 'foo\n'), (key_basis, 'bar\n')], details)
2236
2236
        # Not optimised to date:
2237
2237
        # self.assertEqual([("annotate", key_basis)], basis.calls)
2238
 
        self.assertEqual([('get_parent_map', set([key_basis])),
2239
 
            ('get_parent_map', set([key_basis])),
 
2238
        self.assertEqual([('get_parent_map', {key_basis}),
 
2239
            ('get_parent_map', {key_basis}),
2240
2240
            ('get_record_stream', [key_basis], 'topological', True)],
2241
2241
            basis.calls)
2242
2242
 
2262
2262
        parent_map = test.get_parent_map([key, key_basis, key_missing])
2263
2263
        self.assertEqual({key: (),
2264
2264
            key_basis: ()}, parent_map)
2265
 
        self.assertEqual([("get_parent_map", set([key_basis, key_missing]))],
 
2265
        self.assertEqual([("get_parent_map", {key_basis, key_missing})],
2266
2266
            basis.calls)
2267
2267
 
2268
2268
    def test_get_record_stream_unordered_fulltexts(self):
2299
2299
        # It's not strictly minimal, but it seems reasonable for now for it to
2300
2300
        # ask which fallbacks have which parents.
2301
2301
        self.assertEqual([
2302
 
            ("get_parent_map", set([key_basis, key_missing])),
 
2302
            ("get_parent_map", {key_basis, key_missing}),
2303
2303
            ("get_record_stream", [key_basis], 'unordered', True)],
2304
2304
            calls)
2305
2305
 
2348
2348
        # It's not strictly minimal, but it seems reasonable for now for it to
2349
2349
        # ask which fallbacks have which parents.
2350
2350
        self.assertEqual([
2351
 
            ("get_parent_map", set([key_basis, key_basis_2, key_missing])),
 
2351
            ("get_parent_map", {key_basis, key_basis_2, key_missing}),
2352
2352
            # topological is requested from the fallback, because that is what
2353
2353
            # was requested at the top level.
2354
2354
            ("get_record_stream", [key_basis_2, key_basis], 'topological', True)],
2386
2386
        # It's not strictly minimal, but it seems reasonable for now for it to
2387
2387
        # ask which fallbacks have which parents.
2388
2388
        self.assertEqual([
2389
 
            ("get_parent_map", set([key_basis, key_missing])),
 
2389
            ("get_parent_map", {key_basis, key_missing}),
2390
2390
            ("get_record_stream", [key_basis], 'unordered', False)],
2391
2391
            calls)
2392
2392
 
2432
2432
        # It's not strictly minimal, but it seems reasonable for now for it to
2433
2433
        # ask which fallbacks have which parents.
2434
2434
        self.assertEqual([
2435
 
            ("get_parent_map", set([key_basis, key_basis_2, key_missing])),
 
2435
            ("get_parent_map", {key_basis, key_basis_2, key_missing}),
2436
2436
            ("get_record_stream", [key_basis_2, key_basis], 'topological', False)],
2437
2437
            calls)
2438
2438
 
2456
2456
        sha1s = test.get_sha1s([key, key_missing, key_basis])
2457
2457
        self.assertEqual({key: key_sha1sum,
2458
2458
            key_basis: basis_sha1sum}, sha1s)
2459
 
        self.assertEqual([("get_sha1s", set([key_basis, key_missing]))],
 
2459
        self.assertEqual([("get_sha1s", {key_basis, key_missing})],
2460
2460
            basis.calls)
2461
2461
 
2462
2462
    def test_insert_record_stream(self):
2475
2475
        test.insert_record_stream(stream)
2476
2476
        # XXX: this does somewhat too many calls in making sure of whether it
2477
2477
        # has to recreate the full text.
2478
 
        self.assertEqual([("get_parent_map", set([key_basis])),
2479
 
             ('get_parent_map', set([key_basis])),
 
2478
        self.assertEqual([("get_parent_map", {key_basis}),
 
2479
             ('get_parent_map', {key_basis}),
2480
2480
             ('get_record_stream', [key_basis], 'unordered', True)],
2481
2481
            basis.calls)
2482
2482
        self.assertEqual({key_delta:(key_basis,)},
2495
2495
        basis.calls = []
2496
2496
        lines = list(test.iter_lines_added_or_present_in_keys([key1]))
2497
2497
        self.assertEqual([("foo\n", key1)], lines)
2498
 
        self.assertEqual([("iter_lines_added_or_present_in_keys", set([key1]))],
 
2498
        self.assertEqual([("iter_lines_added_or_present_in_keys", {key1})],
2499
2499
            basis.calls)
2500
2500
        # keys in both are not duplicated:
2501
2501
        test.add_lines(key2, (), ["bar\n"])
2517
2517
        basis.add_lines(key1, (), [])
2518
2518
        basis.calls = []
2519
2519
        keys = test.keys()
2520
 
        self.assertEqual(set([key1]), set(keys))
 
2520
        self.assertEqual({key1}, set(keys))
2521
2521
        self.assertEqual([("keys",)], basis.calls)
2522
2522
        # keys in both are not duplicated:
2523
2523
        test.add_lines(key2, (), [])
2525
2525
        basis.calls = []
2526
2526
        keys = test.keys()
2527
2527
        self.assertEqual(2, len(keys))
2528
 
        self.assertEqual(set([key1, key2]), set(keys))
 
2528
        self.assertEqual({key1, key2}, set(keys))
2529
2529
        self.assertEqual([("keys",)], basis.calls)
2530
2530
 
2531
2531
    def test_add_mpdiffs(self):
2543
2543
        diffs = source.make_mpdiffs([key_delta])
2544
2544
        test.add_mpdiffs([(key_delta, (key_basis,),
2545
2545
            source.get_sha1s([key_delta])[key_delta], diffs[0])])
2546
 
        self.assertEqual([("get_parent_map", set([key_basis])),
 
2546
        self.assertEqual([("get_parent_map", {key_basis}),
2547
2547
            ('get_record_stream', [key_basis], 'unordered', True),],
2548
2548
            basis.calls)
2549
2549
        self.assertEqual({key_delta:(key_basis,)},
2571
2571
            diffs)
2572
2572
        self.assertEqual(3, len(basis.calls))
2573
2573
        self.assertEqual([
2574
 
            ("get_parent_map", set([key_left, key_right])),
2575
 
            ("get_parent_map", set([key_left, key_right])),
 
2574
            ("get_parent_map", {key_left, key_right}),
 
2575
            ("get_parent_map", {key_left, key_right}),
2576
2576
            ],
2577
2577
            basis.calls[:-1])
2578
2578
        last_call = basis.calls[-1]
2579
2579
        self.assertEqual('get_record_stream', last_call[0])
2580
 
        self.assertEqual(set([key_left, key_right]), set(last_call[1]))
 
2580
        self.assertEqual({key_left, key_right}, set(last_call[1]))
2581
2581
        self.assertEqual('topological', last_call[2])
2582
2582
        self.assertEqual(True, last_call[3])
2583
2583