~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_knit.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-02-25 22:00:24 UTC
  • mfrom: (4039.3.8 sort_knit_fetch)
  • Revision ID: pqm@pqm.ubuntu.com-20090225220024-b81h6glz8zi2ekfh
(jam) Batch up requests for fulltexts into 5MB (compressed) requests,
        rather than 1 per file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1093
1093
            call[1][1].getvalue())
1094
1094
        self.assertEqual({'create_parent_dir': True}, call[2])
1095
1095
 
 
1096
    def assertTotalBuildSize(self, size, keys, positions):
 
1097
        self.assertEqual(size,
 
1098
                         knit._get_total_build_size(None, keys, positions))
 
1099
 
 
1100
    def test__get_total_build_size(self):
 
1101
        positions = {
 
1102
            ('a',): (('fulltext', False), (('a',), 0, 100), None),
 
1103
            ('b',): (('line-delta', False), (('b',), 100, 21), ('a',)),
 
1104
            ('c',): (('line-delta', False), (('c',), 121, 35), ('b',)),
 
1105
            ('d',): (('line-delta', False), (('d',), 156, 12), ('b',)),
 
1106
            }
 
1107
        self.assertTotalBuildSize(100, [('a',)], positions)
 
1108
        self.assertTotalBuildSize(121, [('b',)], positions)
 
1109
        # c needs both a & b
 
1110
        self.assertTotalBuildSize(156, [('c',)], positions)
 
1111
        # we shouldn't count 'b' twice
 
1112
        self.assertTotalBuildSize(156, [('b',), ('c',)], positions)
 
1113
        self.assertTotalBuildSize(133, [('d',)], positions)
 
1114
        self.assertTotalBuildSize(168, [('c',), ('d',)], positions)
 
1115
 
1096
1116
    def test_get_position(self):
1097
1117
        transport = MockTransport([
1098
1118
            _KndxIndex.HEADER,
1867
1887
        self.assertEqual([], self.caught_entries)
1868
1888
 
1869
1889
 
 
1890
class TestKnitVersionedFiles(KnitTests):
 
1891
 
 
1892
    def assertGroupKeysForIo(self, exp_groups, keys, non_local_keys,
 
1893
                             positions, _min_buffer_size=None):
 
1894
        kvf = self.make_test_knit()
 
1895
        if _min_buffer_size is None:
 
1896
            _min_buffer_size = knit._STREAM_MIN_BUFFER_SIZE
 
1897
        self.assertEqual(exp_groups, kvf._group_keys_for_io(keys,
 
1898
                                        non_local_keys, positions,
 
1899
                                        _min_buffer_size=_min_buffer_size))
 
1900
 
 
1901
    def assertSplitByPrefix(self, expected_map, expected_prefix_order,
 
1902
                            keys):
 
1903
        split, prefix_order = KnitVersionedFiles._split_by_prefix(keys)
 
1904
        self.assertEqual(expected_map, split)
 
1905
        self.assertEqual(expected_prefix_order, prefix_order)
 
1906
 
 
1907
    def test__group_keys_for_io(self):
 
1908
        ft_detail = ('fulltext', False)
 
1909
        ld_detail = ('line-delta', False)
 
1910
        f_a = ('f', 'a')
 
1911
        f_b = ('f', 'b')
 
1912
        f_c = ('f', 'c')
 
1913
        g_a = ('g', 'a')
 
1914
        g_b = ('g', 'b')
 
1915
        g_c = ('g', 'c')
 
1916
        positions = {
 
1917
            f_a: (ft_detail, (f_a, 0, 100), None),
 
1918
            f_b: (ld_detail, (f_b, 100, 21), f_a),
 
1919
            f_c: (ld_detail, (f_c, 180, 15), f_b),
 
1920
            g_a: (ft_detail, (g_a, 121, 35), None),
 
1921
            g_b: (ld_detail, (g_b, 156, 12), g_a),
 
1922
            g_c: (ld_detail, (g_c, 195, 13), g_a),
 
1923
            }
 
1924
        self.assertGroupKeysForIo([([f_a], set())],
 
1925
                                  [f_a], [], positions)
 
1926
        self.assertGroupKeysForIo([([f_a], set([f_a]))],
 
1927
                                  [f_a], [f_a], positions)
 
1928
        self.assertGroupKeysForIo([([f_a, f_b], set([]))],
 
1929
                                  [f_a, f_b], [], positions)
 
1930
        self.assertGroupKeysForIo([([f_a, f_b], set([f_b]))],
 
1931
                                  [f_a, f_b], [f_b], positions)
 
1932
        self.assertGroupKeysForIo([([f_a, f_b, g_a, g_b], set())],
 
1933
                                  [f_a, g_a, f_b, g_b], [], positions)
 
1934
        self.assertGroupKeysForIo([([f_a, f_b, g_a, g_b], set())],
 
1935
                                  [f_a, g_a, f_b, g_b], [], positions,
 
1936
                                  _min_buffer_size=150)
 
1937
        self.assertGroupKeysForIo([([f_a, f_b], set()), ([g_a, g_b], set())],
 
1938
                                  [f_a, g_a, f_b, g_b], [], positions,
 
1939
                                  _min_buffer_size=100)
 
1940
        self.assertGroupKeysForIo([([f_c], set()), ([g_b], set())],
 
1941
                                  [f_c, g_b], [], positions,
 
1942
                                  _min_buffer_size=125)
 
1943
        self.assertGroupKeysForIo([([g_b, f_c], set())],
 
1944
                                  [g_b, f_c], [], positions,
 
1945
                                  _min_buffer_size=125)
 
1946
 
 
1947
    def test__split_by_prefix(self):
 
1948
        self.assertSplitByPrefix({'f': [('f', 'a'), ('f', 'b')],
 
1949
                                  'g': [('g', 'b'), ('g', 'a')],
 
1950
                                 }, ['f', 'g'],
 
1951
                                 [('f', 'a'), ('g', 'b'),
 
1952
                                  ('g', 'a'), ('f', 'b')])
 
1953
 
 
1954
        self.assertSplitByPrefix({'f': [('f', 'a'), ('f', 'b')],
 
1955
                                  'g': [('g', 'b'), ('g', 'a')],
 
1956
                                 }, ['f', 'g'],
 
1957
                                 [('f', 'a'), ('f', 'b'),
 
1958
                                  ('g', 'b'), ('g', 'a')])
 
1959
 
 
1960
        self.assertSplitByPrefix({'f': [('f', 'a'), ('f', 'b')],
 
1961
                                  'g': [('g', 'b'), ('g', 'a')],
 
1962
                                 }, ['f', 'g'],
 
1963
                                 [('f', 'a'), ('f', 'b'),
 
1964
                                  ('g', 'b'), ('g', 'a')])
 
1965
 
 
1966
        self.assertSplitByPrefix({'f': [('f', 'a'), ('f', 'b')],
 
1967
                                  'g': [('g', 'b'), ('g', 'a')],
 
1968
                                  '': [('a',), ('b',)]
 
1969
                                 }, ['f', 'g', ''],
 
1970
                                 [('f', 'a'), ('g', 'b'),
 
1971
                                  ('a',), ('b',),
 
1972
                                  ('g', 'a'), ('f', 'b')])
 
1973
 
 
1974
 
1870
1975
class TestStacking(KnitTests):
1871
1976
 
1872
1977
    def get_basis_and_test_knit(self):