/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 breezy/tests/test_dirstate.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-09-15 00:32:05 UTC
  • mfrom: (7096.3.9 per-tree-git-revtree)
  • Revision ID: breezy.the.bot@gmail.com-20180915003205-dmcqqujf6z368wgf
Run per_tree tests against GitRevisionTree.

Merged from https://code.launchpad.net/~jelmer/brz/per-tree-git-revtree/+merge/354530

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_dirstate.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Tests of the dirstate functionality being built for WorkingTreeFormat4."""
18
18
 
19
 
import bisect
20
19
import os
 
20
import tempfile
21
21
 
22
 
from bzrlib import (
23
 
    dirstate,
 
22
from .. import (
 
23
    controldir,
24
24
    errors,
25
 
    inventory,
26
25
    memorytree,
27
26
    osutils,
28
27
    revision as _mod_revision,
 
28
    revisiontree,
29
29
    tests,
30
30
    )
31
 
from bzrlib.tests import test_osutils
 
31
from ..bzr import (
 
32
    dirstate,
 
33
    inventory,
 
34
    inventorytree,
 
35
    workingtree_4,
 
36
    )
 
37
from . import (
 
38
    features,
 
39
    test_osutils,
 
40
    )
 
41
from .scenarios import load_tests_apply_scenarios
32
42
 
33
43
 
34
44
# TODO:
44
54
# set_path_id  setting id when state is in memory modified
45
55
 
46
56
 
47
 
def load_tests(basic_tests, module, loader):
48
 
    suite = loader.suiteClass()
49
 
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
50
 
        basic_tests, tests.condition_isinstance(TestCaseWithDirState))
51
 
    tests.multiply_tests(dir_reader_tests,
52
 
                         test_osutils.dir_reader_scenarios(), suite)
53
 
    suite.addTest(remaining_tests)
54
 
    return suite
 
57
class TestErrors(tests.TestCase):
 
58
 
 
59
    def test_dirstate_corrupt(self):
 
60
        error = dirstate.DirstateCorrupt('.bzr/checkout/dirstate',
 
61
                                       'trailing garbage: "x"')
 
62
        self.assertEqualDiff("The dirstate file (.bzr/checkout/dirstate)"
 
63
            " appears to be corrupt: trailing garbage: \"x\"",
 
64
            str(error))
 
65
 
 
66
 
 
67
load_tests = load_tests_apply_scenarios
55
68
 
56
69
 
57
70
class TestCaseWithDirState(tests.TestCaseWithTransport):
58
71
    """Helper functions for creating DirState objects with various content."""
59
72
 
 
73
    scenarios = test_osutils.dir_reader_scenarios()
 
74
 
60
75
    # Set by load_tests
61
76
    _dir_reader_class = None
62
77
    _native_to_unicode = None # Not used yet
63
78
 
64
79
    def setUp(self):
65
 
        tests.TestCaseWithTransport.setUp(self)
66
 
 
 
80
        super(TestCaseWithDirState, self).setUp()
67
81
        self.overrideAttr(osutils,
68
82
                          '_selected_dir_reader', self._dir_reader_class())
69
83
 
74
88
 
75
89
    def create_dirstate_with_root(self):
76
90
        """Return a write-locked state with a single root entry."""
77
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
78
 
        root_entry_direntry = ('', '', 'a-root-value'), [
79
 
            ('d', '', 0, False, packed_stat),
 
91
        packed_stat = b'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
 
92
        root_entry_direntry = (b'', b'', b'a-root-value'), [
 
93
            (b'd', b'', 0, False, packed_stat),
80
94
            ]
81
95
        dirblocks = []
82
 
        dirblocks.append(('', [root_entry_direntry]))
83
 
        dirblocks.append(('', []))
 
96
        dirblocks.append((b'', [root_entry_direntry]))
 
97
        dirblocks.append((b'', []))
84
98
        state = self.create_empty_dirstate()
85
99
        try:
86
100
            state._set_data([], dirblocks)
92
106
 
93
107
    def create_dirstate_with_root_and_subdir(self):
94
108
        """Return a locked DirState with a root and a subdir"""
95
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
96
 
        subdir_entry = ('', 'subdir', 'subdir-id'), [
97
 
            ('d', '', 0, False, packed_stat),
 
109
        packed_stat = b'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
 
110
        subdir_entry = (b'', b'subdir', b'subdir-id'), [
 
111
            (b'd', b'', 0, False, packed_stat),
98
112
            ]
99
113
        state = self.create_dirstate_with_root()
100
114
        try:
123
137
 
124
138
        :return: The dirstate, still write-locked.
125
139
        """
126
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
127
 
        null_sha = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
128
 
        root_entry = ('', '', 'a-root-value'), [
129
 
            ('d', '', 0, False, packed_stat),
130
 
            ]
131
 
        a_entry = ('', 'a', 'a-dir'), [
132
 
            ('d', '', 0, False, packed_stat),
133
 
            ]
134
 
        b_entry = ('', 'b', 'b-dir'), [
135
 
            ('d', '', 0, False, packed_stat),
136
 
            ]
137
 
        c_entry = ('', 'c', 'c-file'), [
138
 
            ('f', null_sha, 10, False, packed_stat),
139
 
            ]
140
 
        d_entry = ('', 'd', 'd-file'), [
141
 
            ('f', null_sha, 20, False, packed_stat),
142
 
            ]
143
 
        e_entry = ('a', 'e', 'e-dir'), [
144
 
            ('d', '', 0, False, packed_stat),
145
 
            ]
146
 
        f_entry = ('a', 'f', 'f-file'), [
147
 
            ('f', null_sha, 30, False, packed_stat),
148
 
            ]
149
 
        g_entry = ('b', 'g', 'g-file'), [
150
 
            ('f', null_sha, 30, False, packed_stat),
151
 
            ]
152
 
        h_entry = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file'), [
153
 
            ('f', null_sha, 40, False, packed_stat),
 
140
        packed_stat = b'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
 
141
        null_sha = b'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
 
142
        root_entry = (b'', b'', b'a-root-value'), [
 
143
            (b'd', b'', 0, False, packed_stat),
 
144
            ]
 
145
        a_entry = (b'', b'a', b'a-dir'), [
 
146
            (b'd', b'', 0, False, packed_stat),
 
147
            ]
 
148
        b_entry = (b'', b'b', b'b-dir'), [
 
149
            (b'd', b'', 0, False, packed_stat),
 
150
            ]
 
151
        c_entry = (b'', b'c', b'c-file'), [
 
152
            (b'f', null_sha, 10, False, packed_stat),
 
153
            ]
 
154
        d_entry = (b'', b'd', b'd-file'), [
 
155
            (b'f', null_sha, 20, False, packed_stat),
 
156
            ]
 
157
        e_entry = (b'a', b'e', b'e-dir'), [
 
158
            (b'd', b'', 0, False, packed_stat),
 
159
            ]
 
160
        f_entry = (b'a', b'f', b'f-file'), [
 
161
            (b'f', null_sha, 30, False, packed_stat),
 
162
            ]
 
163
        g_entry = (b'b', b'g', b'g-file'), [
 
164
            (b'f', null_sha, 30, False, packed_stat),
 
165
            ]
 
166
        h_entry = (b'b', b'h\xc3\xa5', b'h-\xc3\xa5-file'), [
 
167
            (b'f', null_sha, 40, False, packed_stat),
154
168
            ]
155
169
        dirblocks = []
156
 
        dirblocks.append(('', [root_entry]))
157
 
        dirblocks.append(('', [a_entry, b_entry, c_entry, d_entry]))
158
 
        dirblocks.append(('a', [e_entry, f_entry]))
159
 
        dirblocks.append(('b', [g_entry, h_entry]))
 
170
        dirblocks.append((b'', [root_entry]))
 
171
        dirblocks.append((b'', [a_entry, b_entry, c_entry, d_entry]))
 
172
        dirblocks.append((b'a', [e_entry, f_entry]))
 
173
        dirblocks.append((b'b', [g_entry, h_entry]))
160
174
        state = dirstate.DirState.initialize('dirstate')
161
175
        state._validate()
162
176
        try:
211
225
        """
212
226
        tree = self.make_branch_and_tree('tree')
213
227
        paths = ['a', 'b/', 'b/c', 'b/d/', 'b/d/e', 'b-c', 'f']
214
 
        file_ids = ['a-id', 'b-id', 'c-id', 'd-id', 'e-id', 'b-c-id', 'f-id']
 
228
        file_ids = [b'a-id', b'b-id', b'c-id', b'd-id', b'e-id', b'b-c-id', b'f-id']
215
229
        self.build_tree(['tree/' + p for p in paths])
216
 
        tree.set_root_id('TREE_ROOT')
 
230
        tree.set_root_id(b'TREE_ROOT')
217
231
        tree.add([p.rstrip('/') for p in paths], file_ids)
218
 
        tree.commit('initial', rev_id='rev-1')
219
 
        revision_id = 'rev-1'
 
232
        tree.commit('initial', rev_id=b'rev-1')
 
233
        revision_id = b'rev-1'
220
234
        # a_packed_stat = dirstate.pack_stat(os.stat('tree/a'))
221
235
        t = self.get_transport('tree')
222
236
        a_text = t.get_bytes('a')
241
255
        f_len = len(f_text)
242
256
        null_stat = dirstate.DirState.NULLSTAT
243
257
        expected = {
244
 
            '':(('', '', 'TREE_ROOT'), [
245
 
                  ('d', '', 0, False, null_stat),
246
 
                  ('d', '', 0, False, revision_id),
 
258
            b'': ((b'', b'', b'TREE_ROOT'), [
 
259
                  (b'd', b'', 0, False, null_stat),
 
260
                  (b'd', b'', 0, False, revision_id),
247
261
                ]),
248
 
            'a':(('', 'a', 'a-id'), [
249
 
                   ('f', '', 0, False, null_stat),
250
 
                   ('f', a_sha, a_len, False, revision_id),
251
 
                 ]),
252
 
            'b':(('', 'b', 'b-id'), [
253
 
                  ('d', '', 0, False, null_stat),
254
 
                  ('d', '', 0, False, revision_id),
255
 
                 ]),
256
 
            'b/c':(('b', 'c', 'c-id'), [
257
 
                    ('f', '', 0, False, null_stat),
258
 
                    ('f', c_sha, c_len, False, revision_id),
259
 
                   ]),
260
 
            'b/d':(('b', 'd', 'd-id'), [
261
 
                    ('d', '', 0, False, null_stat),
262
 
                    ('d', '', 0, False, revision_id),
263
 
                   ]),
264
 
            'b/d/e':(('b/d', 'e', 'e-id'), [
265
 
                      ('f', '', 0, False, null_stat),
266
 
                      ('f', e_sha, e_len, False, revision_id),
267
 
                     ]),
268
 
            'b-c':(('', 'b-c', 'b-c-id'), [
269
 
                      ('f', '', 0, False, null_stat),
270
 
                      ('f', b_c_sha, b_c_len, False, revision_id),
271
 
                     ]),
272
 
            'f':(('', 'f', 'f-id'), [
273
 
                  ('f', '', 0, False, null_stat),
274
 
                  ('f', f_sha, f_len, False, revision_id),
 
262
            b'a': ((b'', b'a', b'a-id'), [
 
263
                   (b'f', b'', 0, False, null_stat),
 
264
                   (b'f', a_sha, a_len, False, revision_id),
 
265
                 ]),
 
266
            b'b': ((b'', b'b', b'b-id'), [
 
267
                  (b'd', b'', 0, False, null_stat),
 
268
                  (b'd', b'', 0, False, revision_id),
 
269
                 ]),
 
270
            b'b/c': ((b'b', b'c', b'c-id'), [
 
271
                    (b'f', b'', 0, False, null_stat),
 
272
                    (b'f', c_sha, c_len, False, revision_id),
 
273
                   ]),
 
274
            b'b/d': ((b'b', b'd', b'd-id'), [
 
275
                    (b'd', b'', 0, False, null_stat),
 
276
                    (b'd', b'', 0, False, revision_id),
 
277
                   ]),
 
278
            b'b/d/e': ((b'b/d', b'e', b'e-id'), [
 
279
                      (b'f', b'', 0, False, null_stat),
 
280
                      (b'f', e_sha, e_len, False, revision_id),
 
281
                     ]),
 
282
            b'b-c': ((b'', b'b-c', b'b-c-id'), [
 
283
                      (b'f', b'', 0, False, null_stat),
 
284
                      (b'f', b_c_sha, b_c_len, False, revision_id),
 
285
                     ]),
 
286
            b'f': ((b'', b'f', b'f-id'), [
 
287
                  (b'f', b'', 0, False, null_stat),
 
288
                  (b'f', f_sha, f_len, False, revision_id),
275
289
                 ]),
276
290
        }
277
291
        state = dirstate.DirState.from_tree(tree, 'dirstate')
301
315
        tree, state, expected = self.create_basic_dirstate()
302
316
        # Now we will just remove and add every file so we get an extra entry
303
317
        # per entry. Unversion in reverse order so we handle subdirs
304
 
        tree.unversion(['f-id', 'b-c-id', 'e-id', 'd-id', 'c-id', 'b-id', 'a-id'])
 
318
        tree.unversion(['f', 'b-c', 'b/d/e', 'b/d', 'b/c', 'b', 'a'])
305
319
        tree.add(['a', 'b', 'b/c', 'b/d', 'b/d/e', 'b-c', 'f'],
306
 
                 ['a-id2', 'b-id2', 'c-id2', 'd-id2', 'e-id2', 'b-c-id2', 'f-id2'])
 
320
                 [b'a-id2', b'b-id2', b'c-id2', b'd-id2', b'e-id2', b'b-c-id2', b'f-id2'])
307
321
 
308
322
        # Update the expected dictionary.
309
 
        for path in ['a', 'b', 'b/c', 'b/d', 'b/d/e', 'b-c', 'f']:
 
323
        for path in [b'a', b'b', b'b/c', b'b/d', b'b/d/e', b'b-c', b'f']:
310
324
            orig = expected[path]
311
 
            path2 = path + '2'
 
325
            path2 = path + b'2'
312
326
            # This record was deleted in the current tree
313
327
            expected[path] = (orig[0], [dirstate.DirState.NULL_PARENT_DETAILS,
314
328
                                        orig[1][1]])
315
 
            new_key = (orig[0][0], orig[0][1], orig[0][2]+'2')
 
329
            new_key = (orig[0][0], orig[0][1], orig[0][2]+b'2')
316
330
            # And didn't exist in the basis tree
317
331
            expected[path2] = (new_key, [orig[1][0],
318
332
                                         dirstate.DirState.NULL_PARENT_DETAILS])
343
357
        # And a directory
344
358
        tree.rename_one('b/d', 'h')
345
359
 
346
 
        old_a = expected['a']
347
 
        expected['a'] = (old_a[0], [('r', 'b/g', 0, False, ''), old_a[1][1]])
348
 
        expected['b/g'] = (('b', 'g', 'a-id'), [old_a[1][0],
349
 
                                                ('r', 'a', 0, False, '')])
350
 
        old_d = expected['b/d']
351
 
        expected['b/d'] = (old_d[0], [('r', 'h', 0, False, ''), old_d[1][1]])
352
 
        expected['h'] = (('', 'h', 'd-id'), [old_d[1][0],
353
 
                                             ('r', 'b/d', 0, False, '')])
 
360
        old_a = expected[b'a']
 
361
        expected[b'a'] = (old_a[0], [(b'r', b'b/g', 0, False, b''), old_a[1][1]])
 
362
        expected[b'b/g'] = ((b'b', b'g', b'a-id'), [old_a[1][0],
 
363
                                                (b'r', b'a', 0, False, b'')])
 
364
        old_d = expected[b'b/d']
 
365
        expected[b'b/d'] = (old_d[0], [(b'r', b'h', 0, False, b''), old_d[1][1]])
 
366
        expected[b'h'] = ((b'', b'h', b'd-id'), [old_d[1][0],
 
367
                                             (b'r', b'b/d', 0, False, b'')])
354
368
 
355
 
        old_e = expected['b/d/e']
356
 
        expected['b/d/e'] = (old_e[0], [('r', 'h/e', 0, False, ''),
 
369
        old_e = expected[b'b/d/e']
 
370
        expected[b'b/d/e'] = (old_e[0], [(b'r', b'h/e', 0, False, b''),
357
371
                             old_e[1][1]])
358
 
        expected['h/e'] = (('h', 'e', 'e-id'), [old_e[1][0],
359
 
                                                ('r', 'b/d/e', 0, False, '')])
 
372
        expected[b'h/e'] = ((b'h', b'e', b'e-id'), [old_e[1][0],
 
373
                                                (b'r', b'b/d/e', 0, False, b'')])
360
374
 
361
375
        state.unlock()
362
376
        try:
377
391
        # There are no files on disk and no parents
378
392
        tree = self.make_branch_and_tree('tree')
379
393
        expected_result = ([], [
380
 
            (('', '', tree.get_root_id()), # common details
381
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
394
            ((b'', b'', tree.get_root_id()), # common details
 
395
             [(b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
382
396
             ])])
383
397
        state = dirstate.DirState.from_tree(tree, 'dirstate')
384
398
        state._validate()
387
401
    def test_1_parents_empty_to_dirstate(self):
388
402
        # create a parent by doing a commit
389
403
        tree = self.make_branch_and_tree('tree')
390
 
        rev_id = tree.commit('first post').encode('utf8')
 
404
        rev_id = tree.commit('first post')
391
405
        root_stat_pack = dirstate.pack_stat(os.stat(tree.basedir))
392
406
        expected_result = ([rev_id], [
393
 
            (('', '', tree.get_root_id()), # common details
394
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
395
 
              ('d', '', 0, False, rev_id), # first parent details
 
407
            ((b'', b'', tree.get_root_id()), # common details
 
408
             [(b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
409
              (b'd', b'', 0, False, rev_id), # first parent details
396
410
             ])])
397
411
        state = dirstate.DirState.from_tree(tree, 'dirstate')
398
412
        self.check_state_with_reopen(expected_result, state)
406
420
        # create a parent by doing a commit
407
421
        tree = self.make_branch_and_tree('tree')
408
422
        rev_id = tree.commit('first post')
409
 
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
423
        tree2 = tree.controldir.sprout('tree2').open_workingtree()
410
424
        rev_id2 = tree2.commit('second post', allow_pointless=True)
411
425
        tree.merge_from_branch(tree2.branch)
412
426
        expected_result = ([rev_id, rev_id2], [
413
 
            (('', '', tree.get_root_id()), # common details
414
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
415
 
              ('d', '', 0, False, rev_id), # first parent details
416
 
              ('d', '', 0, False, rev_id), # second parent details
 
427
            ((b'', b'', tree.get_root_id()), # common details
 
428
             [(b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
429
              (b'd', b'', 0, False, rev_id), # first parent details
 
430
              (b'd', b'', 0, False, rev_id), # second parent details
417
431
             ])])
418
432
        state = dirstate.DirState.from_tree(tree, 'dirstate')
419
433
        self.check_state_with_reopen(expected_result, state)
429
443
        tree = self.make_branch_and_tree('tree')
430
444
        self.build_tree(['tree/unknown'])
431
445
        expected_result = ([], [
432
 
            (('', '', tree.get_root_id()), # common details
433
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
446
            ((b'', b'', tree.get_root_id()), # common details
 
447
             [(b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
434
448
             ])])
435
449
        state = dirstate.DirState.from_tree(tree, 'dirstate')
436
450
        self.check_state_with_reopen(expected_result, state)
438
452
    def get_tree_with_a_file(self):
439
453
        tree = self.make_branch_and_tree('tree')
440
454
        self.build_tree(['tree/a file'])
441
 
        tree.add('a file', 'a-file-id')
 
455
        tree.add('a file', b'a-file-id')
442
456
        return tree
443
457
 
444
458
    def test_non_empty_no_parents_to_dirstate(self):
446
460
        # There are files on disk and no parents
447
461
        tree = self.get_tree_with_a_file()
448
462
        expected_result = ([], [
449
 
            (('', '', tree.get_root_id()), # common details
450
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
463
            ((b'', b'', tree.get_root_id()), # common details
 
464
             [(b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
451
465
             ]),
452
 
            (('', 'a file', 'a-file-id'), # common
453
 
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
 
466
            ((b'', b'a file', b'a-file-id'), # common
 
467
             [(b'f', b'', 0, False, dirstate.DirState.NULLSTAT), # current
454
468
             ]),
455
469
            ])
456
470
        state = dirstate.DirState.from_tree(tree, 'dirstate')
459
473
    def test_1_parents_not_empty_to_dirstate(self):
460
474
        # create a parent by doing a commit
461
475
        tree = self.get_tree_with_a_file()
462
 
        rev_id = tree.commit('first post').encode('utf8')
 
476
        rev_id = tree.commit('first post')
463
477
        # change the current content to be different this will alter stat, sha
464
478
        # and length:
465
 
        self.build_tree_contents([('tree/a file', 'new content\n')])
 
479
        self.build_tree_contents([('tree/a file', b'new content\n')])
466
480
        expected_result = ([rev_id], [
467
 
            (('', '', tree.get_root_id()), # common details
468
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
469
 
              ('d', '', 0, False, rev_id), # first parent details
 
481
            ((b'', b'', tree.get_root_id()), # common details
 
482
             [(b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
483
              (b'd', b'', 0, False, rev_id), # first parent details
470
484
             ]),
471
 
            (('', 'a file', 'a-file-id'), # common
472
 
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
473
 
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
 
485
            ((b'', b'a file', b'a-file-id'), # common
 
486
             [(b'f', b'', 0, False, dirstate.DirState.NULLSTAT), # current
 
487
              (b'f', b'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
474
488
               rev_id), # first parent
475
489
             ]),
476
490
            ])
480
494
    def test_2_parents_not_empty_to_dirstate(self):
481
495
        # create a parent by doing a commit
482
496
        tree = self.get_tree_with_a_file()
483
 
        rev_id = tree.commit('first post').encode('utf8')
484
 
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
 
497
        rev_id = tree.commit('first post')
 
498
        tree2 = tree.controldir.sprout('tree2').open_workingtree()
485
499
        # change the current content to be different this will alter stat, sha
486
500
        # and length:
487
 
        self.build_tree_contents([('tree2/a file', 'merge content\n')])
488
 
        rev_id2 = tree2.commit('second post').encode('utf8')
 
501
        self.build_tree_contents([('tree2/a file', b'merge content\n')])
 
502
        rev_id2 = tree2.commit('second post')
489
503
        tree.merge_from_branch(tree2.branch)
490
504
        # change the current content to be different this will alter stat, sha
491
505
        # and length again, giving us three distinct values:
492
 
        self.build_tree_contents([('tree/a file', 'new content\n')])
 
506
        self.build_tree_contents([('tree/a file', b'new content\n')])
493
507
        expected_result = ([rev_id, rev_id2], [
494
 
            (('', '', tree.get_root_id()), # common details
495
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
496
 
              ('d', '', 0, False, rev_id), # first parent details
497
 
              ('d', '', 0, False, rev_id), # second parent details
 
508
            ((b'', b'', tree.get_root_id()), # common details
 
509
             [(b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
510
              (b'd', b'', 0, False, rev_id), # first parent details
 
511
              (b'd', b'', 0, False, rev_id), # second parent details
498
512
             ]),
499
 
            (('', 'a file', 'a-file-id'), # common
500
 
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
501
 
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
 
513
            ((b'', b'a file', b'a-file-id'), # common
 
514
             [(b'f', b'', 0, False, dirstate.DirState.NULLSTAT), # current
 
515
              (b'f', b'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
502
516
               rev_id), # first parent
503
 
              ('f', '314d796174c9412647c3ce07dfb5d36a94e72958', 14, False,
 
517
              (b'f', b'314d796174c9412647c3ce07dfb5d36a94e72958', 14, False,
504
518
               rev_id2), # second parent
505
519
             ]),
506
520
            ])
516
530
        for i in range(7):
517
531
            tree = self.make_branch_and_tree('tree%d' % i)
518
532
            self.build_tree(['tree%d/name' % i,])
519
 
            tree.add(['name'], ['file-id%d' % i])
520
 
            revision_id = 'revid-%d' % i
 
533
            tree.add(['name'], [b'file-id%d' % i])
 
534
            revision_id = b'revid-%d' % i
521
535
            tree.commit('message', rev_id=revision_id)
522
536
            parents.append((revision_id,
523
537
                tree.branch.repository.revision_tree(revision_id)))
532
546
 
533
547
class TestDirStateOnFile(TestCaseWithDirState):
534
548
 
 
549
    def create_updated_dirstate(self):
 
550
        self.build_tree(['a-file'])
 
551
        tree = self.make_branch_and_tree('.')
 
552
        tree.add(['a-file'], [b'a-id'])
 
553
        tree.commit('add a-file')
 
554
        # Save and unlock the state, re-open it in readonly mode
 
555
        state = dirstate.DirState.from_tree(tree, 'dirstate')
 
556
        state.save()
 
557
        state.unlock()
 
558
        state = dirstate.DirState.on_file('dirstate')
 
559
        state.lock_read()
 
560
        return state
 
561
 
535
562
    def test_construct_with_path(self):
536
563
        tree = self.make_branch_and_tree('tree')
537
564
        state = dirstate.DirState.from_tree(tree, 'dirstate.from_tree')
539
566
        # write to disk.
540
567
        lines = state.get_lines()
541
568
        state.unlock()
542
 
        self.build_tree_contents([('dirstate', ''.join(lines))])
 
569
        self.build_tree_contents([('dirstate', b''.join(lines))])
543
570
        # get a state object
544
571
        # no parents, default tree content
545
572
        expected_result = ([], [
546
 
            (('', '', tree.get_root_id()), # common details
 
573
            ((b'', b'', tree.get_root_id()), # common details
547
574
             # current tree details, but new from_tree skips statting, it
548
575
             # uses set_state_from_inventory, and thus depends on the
549
576
             # inventory state.
550
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT),
 
577
             [(b'd', b'', 0, False, dirstate.DirState.NULLSTAT),
551
578
             ])
552
579
            ])
553
580
        state = dirstate.DirState.on_file('dirstate')
566
593
            state.unlock()
567
594
 
568
595
    def test_can_save_in_read_lock(self):
569
 
        self.build_tree(['a-file'])
570
 
        state = dirstate.DirState.initialize('dirstate')
571
 
        try:
572
 
            # No stat and no sha1 sum.
573
 
            state.add('a-file', 'a-file-id', 'file', None, '')
574
 
            state.save()
575
 
        finally:
576
 
            state.unlock()
577
 
 
578
 
        # Now open in readonly mode
579
 
        state = dirstate.DirState.on_file('dirstate')
580
 
        state.lock_read()
581
 
        try:
582
 
            entry = state._get_entry(0, path_utf8='a-file')
 
596
        state = self.create_updated_dirstate()
 
597
        try:
 
598
            entry = state._get_entry(0, path_utf8=b'a-file')
583
599
            # The current size should be 0 (default)
584
600
            self.assertEqual(0, entry[1][0][2])
585
601
            # We should have a real entry.
586
602
            self.assertNotEqual((None, None), entry)
587
 
            # Make sure everything is old enough
 
603
            # Set the cutoff-time into the future, so things look cacheable
588
604
            state._sha_cutoff_time()
589
 
            state._cutoff_time += 10
590
 
            # Change the file length
591
 
            self.build_tree_contents([('a-file', 'shorter')])
592
 
            sha1sum = dirstate.update_entry(state, entry, 'a-file',
593
 
                os.lstat('a-file'))
594
 
            # new file, no cached sha:
595
 
            self.assertEqual(None, sha1sum)
 
605
            state._cutoff_time += 10.0
 
606
            st = os.lstat('a-file')
 
607
            sha1sum = dirstate.update_entry(state, entry, 'a-file', st)
 
608
            # We updated the current sha1sum because the file is cacheable
 
609
            self.assertEqual(b'ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
 
610
                             sha1sum)
596
611
 
597
612
            # The dirblock has been updated
598
 
            self.assertEqual(7, entry[1][0][2])
599
 
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
613
            self.assertEqual(st.st_size, entry[1][0][2])
 
614
            self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
600
615
                             state._dirblock_state)
601
616
 
602
617
            del entry
610
625
        state = dirstate.DirState.on_file('dirstate')
611
626
        state.lock_read()
612
627
        try:
613
 
            entry = state._get_entry(0, path_utf8='a-file')
614
 
            self.assertEqual(7, entry[1][0][2])
 
628
            entry = state._get_entry(0, path_utf8=b'a-file')
 
629
            self.assertEqual(st.st_size, entry[1][0][2])
615
630
        finally:
616
631
            state.unlock()
617
632
 
618
633
    def test_save_fails_quietly_if_locked(self):
619
634
        """If dirstate is locked, save will fail without complaining."""
620
 
        self.build_tree(['a-file'])
621
 
        state = dirstate.DirState.initialize('dirstate')
622
 
        try:
623
 
            # No stat and no sha1 sum.
624
 
            state.add('a-file', 'a-file-id', 'file', None, '')
625
 
            state.save()
626
 
        finally:
627
 
            state.unlock()
628
 
 
629
 
        state = dirstate.DirState.on_file('dirstate')
630
 
        state.lock_read()
631
 
        try:
632
 
            entry = state._get_entry(0, path_utf8='a-file')
633
 
            sha1sum = dirstate.update_entry(state, entry, 'a-file',
634
 
                os.lstat('a-file'))
635
 
            # No sha - too new
636
 
            self.assertEqual(None, sha1sum)
637
 
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
635
        state = self.create_updated_dirstate()
 
636
        try:
 
637
            entry = state._get_entry(0, path_utf8=b'a-file')
 
638
            # No cached sha1 yet.
 
639
            self.assertEqual(b'', entry[1][0][1])
 
640
            # Set the cutoff-time into the future, so things look cacheable
 
641
            state._sha_cutoff_time()
 
642
            state._cutoff_time += 10.0
 
643
            st = os.lstat('a-file')
 
644
            sha1sum = dirstate.update_entry(state, entry, 'a-file', st)
 
645
            self.assertEqual(b'ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
 
646
                             sha1sum)
 
647
            self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
638
648
                             state._dirblock_state)
639
649
 
640
650
            # Now, before we try to save, grab another dirstate, and take out a
661
671
        state = dirstate.DirState.on_file('dirstate')
662
672
        state.lock_read()
663
673
        try:
664
 
            entry = state._get_entry(0, path_utf8='a-file')
665
 
            self.assertEqual('', entry[1][0][1])
 
674
            entry = state._get_entry(0, path_utf8=b'a-file')
 
675
            self.assertEqual(b'', entry[1][0][1])
666
676
        finally:
667
677
            state.unlock()
668
678
 
671
681
        state = dirstate.DirState.initialize('dirstate')
672
682
        try:
673
683
            # No stat and no sha1 sum.
674
 
            state.add('a-file', 'a-file-id', 'file', None, '')
 
684
            state.add('a-file', b'a-file-id', 'file', None, b'')
675
685
            state.save()
676
686
        finally:
677
687
            state.unlock()
678
688
 
679
689
        # The dirstate should include TREE_ROOT and 'a-file' and nothing else
680
690
        expected_blocks = [
681
 
            ('', [(('', '', 'TREE_ROOT'),
682
 
                   [('d', '', 0, False, dirstate.DirState.NULLSTAT)])]),
683
 
            ('', [(('', 'a-file', 'a-file-id'),
684
 
                   [('f', '', 0, False, dirstate.DirState.NULLSTAT)])]),
 
691
            (b'', [((b'', b'', b'TREE_ROOT'),
 
692
                   [(b'd', b'', 0, False, dirstate.DirState.NULLSTAT)])]),
 
693
            (b'', [((b'', b'a-file', b'a-file-id'),
 
694
                   [(b'f', b'', 0, False, dirstate.DirState.NULLSTAT)])]),
685
695
        ]
686
696
 
687
697
        state = dirstate.DirState.on_file('dirstate')
691
701
            self.assertEqual(expected_blocks, state._dirblocks)
692
702
 
693
703
            # Now modify the state, but mark it as inconsistent
694
 
            state.add('a-dir', 'a-dir-id', 'directory', None, '')
 
704
            state.add('a-dir', b'a-dir-id', 'directory', None, b'')
695
705
            state._changes_aborted = True
696
706
            state.save()
697
707
        finally:
710
720
 
711
721
    def test_initialize(self):
712
722
        expected_result = ([], [
713
 
            (('', '', 'TREE_ROOT'), # common details
714
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
723
            ((b'', b'', b'TREE_ROOT'), # common details
 
724
             [(b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
715
725
             ])
716
726
            ])
717
727
        state = dirstate.DirState.initialize('dirstate')
723
733
        # On win32 you can't read from a locked file, even within the same
724
734
        # process. So we have to unlock and release before we check the file
725
735
        # contents.
726
 
        self.assertFileEqual(''.join(lines), 'dirstate')
 
736
        self.assertFileEqual(b''.join(lines), 'dirstate')
727
737
        state.lock_read() # check_state_with_reopen will unlock
728
738
        self.check_state_with_reopen(expected_result, state)
729
739
 
730
740
 
731
741
class TestDirStateManipulations(TestCaseWithDirState):
732
742
 
 
743
    def make_minimal_tree(self):
 
744
        tree1 = self.make_branch_and_memory_tree('tree1')
 
745
        tree1.lock_write()
 
746
        self.addCleanup(tree1.unlock)
 
747
        tree1.add('')
 
748
        revid1 = tree1.commit('foo')
 
749
        return tree1, revid1
 
750
 
 
751
    def test_update_minimal_updates_id_index(self):
 
752
        state = self.create_dirstate_with_root_and_subdir()
 
753
        self.addCleanup(state.unlock)
 
754
        id_index = state._get_id_index()
 
755
        self.assertEqual([b'a-root-value', b'subdir-id'], sorted(id_index))
 
756
        state.add('file-name', b'file-id', 'file', None, '')
 
757
        self.assertEqual([b'a-root-value', b'file-id', b'subdir-id'],
 
758
                         sorted(id_index))
 
759
        state.update_minimal((b'', b'new-name', b'file-id'), b'f',
 
760
                             path_utf8=b'new-name')
 
761
        self.assertEqual([b'a-root-value', b'file-id', b'subdir-id'],
 
762
                         sorted(id_index))
 
763
        self.assertEqual([(b'', b'new-name', b'file-id')],
 
764
                         sorted(id_index[b'file-id']))
 
765
        state._validate()
 
766
 
733
767
    def test_set_state_from_inventory_no_content_no_parents(self):
734
768
        # setting the current inventory is a slow but important api to support.
735
 
        tree1 = self.make_branch_and_memory_tree('tree1')
736
 
        tree1.lock_write()
737
 
        try:
738
 
            tree1.add('')
739
 
            revid1 = tree1.commit('foo').encode('utf8')
740
 
            root_id = tree1.get_root_id()
741
 
            inv = tree1.inventory
742
 
        finally:
743
 
            tree1.unlock()
 
769
        tree1, revid1 = self.make_minimal_tree()
 
770
        inv = tree1.root_inventory
 
771
        root_id = inv.path2id('')
744
772
        expected_result = [], [
745
 
            (('', '', root_id), [
746
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT)])]
 
773
            ((b'', b'', root_id), [
 
774
             (b'd', b'', 0, False, dirstate.DirState.NULLSTAT)])]
747
775
        state = dirstate.DirState.initialize('dirstate')
748
776
        try:
749
777
            state.set_state_from_inventory(inv)
758
786
            # This will unlock it
759
787
            self.check_state_with_reopen(expected_result, state)
760
788
 
 
789
    def test_set_state_from_scratch_no_parents(self):
 
790
        tree1, revid1 = self.make_minimal_tree()
 
791
        inv = tree1.root_inventory
 
792
        root_id = inv.path2id('')
 
793
        expected_result = [], [
 
794
            ((b'', b'', root_id), [
 
795
             (b'd', b'', 0, False, dirstate.DirState.NULLSTAT)])]
 
796
        state = dirstate.DirState.initialize('dirstate')
 
797
        try:
 
798
            state.set_state_from_scratch(inv, [], [])
 
799
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
800
                             state._header_state)
 
801
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
802
                             state._dirblock_state)
 
803
        except:
 
804
            state.unlock()
 
805
            raise
 
806
        else:
 
807
            # This will unlock it
 
808
            self.check_state_with_reopen(expected_result, state)
 
809
 
 
810
    def test_set_state_from_scratch_identical_parent(self):
 
811
        tree1, revid1 = self.make_minimal_tree()
 
812
        inv = tree1.root_inventory
 
813
        root_id = inv.path2id('')
 
814
        rev_tree1 = tree1.branch.repository.revision_tree(revid1)
 
815
        d_entry = (b'd', b'', 0, False, dirstate.DirState.NULLSTAT)
 
816
        parent_entry = (b'd', b'', 0, False, revid1)
 
817
        expected_result = [revid1], [
 
818
            ((b'', b'', root_id), [d_entry, parent_entry])]
 
819
        state = dirstate.DirState.initialize('dirstate')
 
820
        try:
 
821
            state.set_state_from_scratch(inv, [(revid1, rev_tree1)], [])
 
822
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
823
                             state._header_state)
 
824
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
825
                             state._dirblock_state)
 
826
        except:
 
827
            state.unlock()
 
828
            raise
 
829
        else:
 
830
            # This will unlock it
 
831
            self.check_state_with_reopen(expected_result, state)
 
832
 
761
833
    def test_set_state_from_inventory_preserves_hashcache(self):
762
834
        # https://bugs.launchpad.net/bzr/+bug/146176
763
835
        # set_state_from_inventory should preserve the stat and hash value for
765
837
 
766
838
        tree = self.make_branch_and_tree('.')
767
839
        # depends on the default format using dirstate...
768
 
        tree.lock_write()
769
 
        try:
 
840
        with tree.lock_write():
770
841
            # make a dirstate with some valid hashcache data
771
842
            # file on disk, but that's not needed for this test
772
 
            foo_contents = 'contents of foo'
 
843
            foo_contents = b'contents of foo'
773
844
            self.build_tree_contents([('foo', foo_contents)])
774
 
            tree.add('foo', 'foo-id')
 
845
            tree.add('foo', b'foo-id')
775
846
 
776
847
            foo_stat = os.stat('foo')
777
848
            foo_packed = dirstate.pack_stat(foo_stat)
780
851
 
781
852
            # should not be cached yet, because the file's too fresh
782
853
            self.assertEqual(
783
 
                (('', 'foo', 'foo-id',),
784
 
                 [('f', '', 0, False, dirstate.DirState.NULLSTAT)]),
785
 
                tree._dirstate._get_entry(0, 'foo-id'))
 
854
                ((b'', b'foo', b'foo-id',),
 
855
                 [(b'f', b'', 0, False, dirstate.DirState.NULLSTAT)]),
 
856
                tree._dirstate._get_entry(0, b'foo-id'))
786
857
            # poke in some hashcache information - it wouldn't normally be
787
858
            # stored because it's too fresh
788
859
            tree._dirstate.update_minimal(
789
 
                ('', 'foo', 'foo-id'),
790
 
                'f', False, foo_sha, foo_packed, foo_size, 'foo')
 
860
                (b'', b'foo', b'foo-id'),
 
861
                b'f', False, foo_sha, foo_packed, foo_size, b'foo')
791
862
            # now should be cached
792
863
            self.assertEqual(
793
 
                (('', 'foo', 'foo-id',),
794
 
                 [('f', foo_sha, foo_size, False, foo_packed)]),
795
 
                tree._dirstate._get_entry(0, 'foo-id'))
 
864
                ((b'', b'foo', b'foo-id',),
 
865
                 [(b'f', foo_sha, foo_size, False, foo_packed)]),
 
866
                tree._dirstate._get_entry(0, b'foo-id'))
796
867
 
797
868
            # extract the inventory, and add something to it
798
 
            inv = tree._get_inventory()
 
869
            inv = tree._get_root_inventory()
799
870
            # should see the file we poked in...
800
 
            self.assertTrue(inv.has_id('foo-id'))
 
871
            self.assertTrue(inv.has_id(b'foo-id'))
801
872
            self.assertTrue(inv.has_filename('foo'))
802
 
            inv.add_path('bar', 'file', 'bar-id')
 
873
            inv.add_path('bar', 'file', b'bar-id')
803
874
            tree._dirstate._validate()
804
875
            # this used to cause it to lose its hashcache
805
876
            tree._dirstate.set_state_from_inventory(inv)
806
877
            tree._dirstate._validate()
807
 
        finally:
808
 
            tree.unlock()
809
878
 
810
 
        tree.lock_read()
811
 
        try:
 
879
        with tree.lock_read():
812
880
            # now check that the state still has the original hashcache value
813
881
            state = tree._dirstate
814
882
            state._validate()
815
 
            foo_tuple = state._get_entry(0, path_utf8='foo')
 
883
            foo_tuple = state._get_entry(0, path_utf8=b'foo')
816
884
            self.assertEqual(
817
 
                (('', 'foo', 'foo-id',),
818
 
                 [('f', foo_sha, len(foo_contents), False,
 
885
                ((b'', b'foo', b'foo-id',),
 
886
                 [(b'f', foo_sha, len(foo_contents), False,
819
887
                   dirstate.pack_stat(foo_stat))]),
820
888
                foo_tuple)
821
 
        finally:
822
 
            tree.unlock()
823
889
 
824
890
    def test_set_state_from_inventory_mixed_paths(self):
825
891
        tree1 = self.make_branch_and_tree('tree1')
828
894
        tree1.lock_write()
829
895
        try:
830
896
            tree1.add(['a', 'a/b', 'a-b', 'a/b/foo', 'a-b/bar'],
831
 
                      ['a-id', 'b-id', 'a-b-id', 'foo-id', 'bar-id'])
832
 
            tree1.commit('rev1', rev_id='rev1')
 
897
                      [b'a-id', b'b-id', b'a-b-id', b'foo-id', b'bar-id'])
 
898
            tree1.commit('rev1', rev_id=b'rev1')
833
899
            root_id = tree1.get_root_id()
834
 
            inv = tree1.inventory
 
900
            inv = tree1.root_inventory
835
901
        finally:
836
902
            tree1.unlock()
837
 
        expected_result1 = [('', '', root_id, 'd'),
838
 
                            ('', 'a', 'a-id', 'd'),
839
 
                            ('', 'a-b', 'a-b-id', 'd'),
840
 
                            ('a', 'b', 'b-id', 'd'),
841
 
                            ('a/b', 'foo', 'foo-id', 'f'),
842
 
                            ('a-b', 'bar', 'bar-id', 'f'),
 
903
        expected_result1 = [(b'', b'', root_id, b'd'),
 
904
                            (b'', b'a', b'a-id', b'd'),
 
905
                            (b'', b'a-b', b'a-b-id', b'd'),
 
906
                            (b'a', b'b', b'b-id', b'd'),
 
907
                            (b'a/b', b'foo', b'foo-id', b'f'),
 
908
                            (b'a-b', b'bar', b'bar-id', b'f'),
843
909
                           ]
844
 
        expected_result2 = [('', '', root_id, 'd'),
845
 
                            ('', 'a', 'a-id', 'd'),
846
 
                            ('', 'a-b', 'a-b-id', 'd'),
847
 
                            ('a-b', 'bar', 'bar-id', 'f'),
 
910
        expected_result2 = [(b'', b'', root_id, b'd'),
 
911
                            (b'', b'a', b'a-id', b'd'),
 
912
                            (b'', b'a-b', b'a-b-id', b'd'),
 
913
                            (b'a-b', b'bar', b'bar-id', b'f'),
848
914
                           ]
849
915
        state = dirstate.DirState.initialize('dirstate')
850
916
        try:
853
919
            for entry in state._iter_entries():
854
920
                values.append(entry[0] + entry[1][0][:1])
855
921
            self.assertEqual(expected_result1, values)
856
 
            del inv['b-id']
 
922
            inv.delete(b'b-id')
857
923
            state.set_state_from_inventory(inv)
858
924
            values = []
859
925
            for entry in state._iter_entries():
867
933
        state = dirstate.DirState.initialize('dirstate')
868
934
        try:
869
935
            # check precondition to be sure the state does change appropriately.
870
 
            root_entry = (('', '', 'TREE_ROOT'), [('d', '', 0, False, 'x'*32)])
 
936
            root_entry = ((b'', b'', b'TREE_ROOT'), [(b'd', b'', 0, False, b'x'*32)])
871
937
            self.assertEqual([root_entry], list(state._iter_entries()))
872
 
            self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
 
938
            self.assertEqual(root_entry, state._get_entry(0, path_utf8=b''))
873
939
            self.assertEqual(root_entry,
874
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
 
940
                             state._get_entry(0, fileid_utf8=b'TREE_ROOT'))
875
941
            self.assertEqual((None, None),
876
 
                             state._get_entry(0, fileid_utf8='second-root-id'))
877
 
            state.set_path_id('', 'second-root-id')
878
 
            new_root_entry = (('', '', 'second-root-id'),
879
 
                              [('d', '', 0, False, 'x'*32)])
 
942
                             state._get_entry(0, fileid_utf8=b'second-root-id'))
 
943
            state.set_path_id(b'', b'second-root-id')
 
944
            new_root_entry = ((b'', b'', b'second-root-id'),
 
945
                              [(b'd', b'', 0, False, b'x'*32)])
880
946
            expected_rows = [new_root_entry]
881
947
            self.assertEqual(expected_rows, list(state._iter_entries()))
882
 
            self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
883
 
            self.assertEqual(new_root_entry, 
884
 
                             state._get_entry(0, fileid_utf8='second-root-id'))
 
948
            self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=b''))
 
949
            self.assertEqual(new_root_entry,
 
950
                             state._get_entry(0, fileid_utf8=b'second-root-id'))
885
951
            self.assertEqual((None, None),
886
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
 
952
                             state._get_entry(0, fileid_utf8=b'TREE_ROOT'))
887
953
            # should work across save too
888
954
            state.save()
889
955
        finally:
900
966
        """Set the root file id in a dirstate with parents"""
901
967
        mt = self.make_branch_and_tree('mt')
902
968
        # in case the default tree format uses a different root id
903
 
        mt.set_root_id('TREE_ROOT')
904
 
        mt.commit('foo', rev_id='parent-revid')
905
 
        rt = mt.branch.repository.revision_tree('parent-revid')
 
969
        mt.set_root_id(b'TREE_ROOT')
 
970
        mt.commit('foo', rev_id=b'parent-revid')
 
971
        rt = mt.branch.repository.revision_tree(b'parent-revid')
906
972
        state = dirstate.DirState.initialize('dirstate')
907
973
        state._validate()
908
974
        try:
909
 
            state.set_parent_trees([('parent-revid', rt)], ghosts=[])
910
 
            root_entry = (('', '', 'TREE_ROOT'),
911
 
                          [('d', '', 0, False, 'x'*32),
912
 
                           ('d', '', 0, False, 'parent-revid')])
913
 
            self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
 
975
            state.set_parent_trees([(b'parent-revid', rt)], ghosts=[])
 
976
            root_entry = ((b'', b'', b'TREE_ROOT'),
 
977
                          [(b'd', b'', 0, False, b'x'*32),
 
978
                           (b'd', b'', 0, False, b'parent-revid')])
 
979
            self.assertEqual(root_entry, state._get_entry(0, path_utf8=b''))
914
980
            self.assertEqual(root_entry,
915
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
 
981
                             state._get_entry(0, fileid_utf8=b'TREE_ROOT'))
916
982
            self.assertEqual((None, None),
917
 
                             state._get_entry(0, fileid_utf8='Asecond-root-id'))
918
 
            state.set_path_id('', 'Asecond-root-id')
 
983
                             state._get_entry(0, fileid_utf8=b'Asecond-root-id'))
 
984
            state.set_path_id(b'', b'Asecond-root-id')
919
985
            state._validate()
920
986
            # now see that it is what we expected
921
 
            old_root_entry = (('', '', 'TREE_ROOT'),
922
 
                              [('a', '', 0, False, ''),
923
 
                               ('d', '', 0, False, 'parent-revid')])
924
 
            new_root_entry = (('', '', 'Asecond-root-id'),
925
 
                              [('d', '', 0, False, ''),
926
 
                               ('a', '', 0, False, '')])
 
987
            old_root_entry = ((b'', b'', b'TREE_ROOT'),
 
988
                              [(b'a', b'', 0, False, b''),
 
989
                               (b'd', b'', 0, False, b'parent-revid')])
 
990
            new_root_entry = ((b'', b'', b'Asecond-root-id'),
 
991
                              [(b'd', b'', 0, False, b''),
 
992
                               (b'a', b'', 0, False, b'')])
927
993
            expected_rows = [new_root_entry, old_root_entry]
928
994
            state._validate()
929
995
            self.assertEqual(expected_rows, list(state._iter_entries()))
930
 
            self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
931
 
            self.assertEqual(old_root_entry, state._get_entry(1, path_utf8=''))
 
996
            self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=b''))
 
997
            self.assertEqual(old_root_entry, state._get_entry(1, path_utf8=b''))
932
998
            self.assertEqual((None, None),
933
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
 
999
                             state._get_entry(0, fileid_utf8=b'TREE_ROOT'))
934
1000
            self.assertEqual(old_root_entry,
935
 
                             state._get_entry(1, fileid_utf8='TREE_ROOT'))
 
1001
                             state._get_entry(1, fileid_utf8=b'TREE_ROOT'))
936
1002
            self.assertEqual(new_root_entry,
937
 
                             state._get_entry(0, fileid_utf8='Asecond-root-id'))
 
1003
                             state._get_entry(0, fileid_utf8=b'Asecond-root-id'))
938
1004
            self.assertEqual((None, None),
939
 
                             state._get_entry(1, fileid_utf8='Asecond-root-id'))
 
1005
                             state._get_entry(1, fileid_utf8=b'Asecond-root-id'))
940
1006
            # should work across save too
941
1007
            state.save()
942
1008
        finally:
953
1019
        state.lock_write()
954
1020
        try:
955
1021
            state._validate()
956
 
            state.set_path_id('', 'tree-root-2')
 
1022
            state.set_path_id(b'', b'tree-root-2')
957
1023
            state._validate()
958
1024
        finally:
959
1025
            state.unlock()
967
1033
            revid1 = tree1.commit('foo')
968
1034
        finally:
969
1035
            tree1.unlock()
970
 
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
 
1036
        branch2 = tree1.branch.controldir.clone('tree2').open_branch()
971
1037
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
972
1038
        tree2.lock_write()
973
1039
        try:
977
1043
            tree2.unlock()
978
1044
        state = dirstate.DirState.initialize('dirstate')
979
1045
        try:
980
 
            state.set_path_id('', root_id)
 
1046
            state.set_path_id(b'', root_id)
981
1047
            state.set_parent_trees(
982
1048
                ((revid1, tree1.branch.repository.revision_tree(revid1)),
983
1049
                 (revid2, tree2.branch.repository.revision_tree(revid2)),
984
 
                 ('ghost-rev', None)),
985
 
                ['ghost-rev'])
 
1050
                 (b'ghost-rev', None)),
 
1051
                [b'ghost-rev'])
986
1052
            # check we can reopen and use the dirstate after setting parent
987
1053
            # trees.
988
1054
            state._validate()
993
1059
        state = dirstate.DirState.on_file('dirstate')
994
1060
        state.lock_write()
995
1061
        try:
996
 
            self.assertEqual([revid1, revid2, 'ghost-rev'],
 
1062
            self.assertEqual([revid1, revid2, b'ghost-rev'],
997
1063
                             state.get_parent_ids())
998
1064
            # iterating the entire state ensures that the state is parsable.
999
1065
            list(state._iter_entries())
1000
1066
            # be sure that it sets not appends - change it
1001
1067
            state.set_parent_trees(
1002
1068
                ((revid1, tree1.branch.repository.revision_tree(revid1)),
1003
 
                 ('ghost-rev', None)),
1004
 
                ['ghost-rev'])
 
1069
                 (b'ghost-rev', None)),
 
1070
                [b'ghost-rev'])
1005
1071
            # and now put it back.
1006
1072
            state.set_parent_trees(
1007
1073
                ((revid1, tree1.branch.repository.revision_tree(revid1)),
1008
1074
                 (revid2, tree2.branch.repository.revision_tree(revid2)),
1009
 
                 ('ghost-rev', tree2.branch.repository.revision_tree(
 
1075
                 (b'ghost-rev', tree2.branch.repository.revision_tree(
1010
1076
                                   _mod_revision.NULL_REVISION))),
1011
 
                ['ghost-rev'])
1012
 
            self.assertEqual([revid1, revid2, 'ghost-rev'],
 
1077
                [b'ghost-rev'])
 
1078
            self.assertEqual([revid1, revid2, b'ghost-rev'],
1013
1079
                             state.get_parent_ids())
1014
1080
            # the ghost should be recorded as such by set_parent_trees.
1015
 
            self.assertEqual(['ghost-rev'], state.get_ghosts())
 
1081
            self.assertEqual([b'ghost-rev'], state.get_ghosts())
1016
1082
            self.assertEqual(
1017
 
                [(('', '', root_id), [
1018
 
                  ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1019
 
                  ('d', '', 0, False, revid1),
1020
 
                  ('d', '', 0, False, revid1)
 
1083
                [((b'', b'', root_id), [
 
1084
                  (b'd', b'', 0, False, dirstate.DirState.NULLSTAT),
 
1085
                  (b'd', b'', 0, False, revid1),
 
1086
                  (b'd', b'', 0, False, revid1)
1021
1087
                  ])],
1022
1088
                list(state._iter_entries()))
1023
1089
        finally:
1032
1098
        tree1.lock_write()
1033
1099
        try:
1034
1100
            tree1.add('')
1035
 
            tree1.add(['a file'], ['file-id'], ['file'])
1036
 
            tree1.put_file_bytes_non_atomic('file-id', 'file-content')
 
1101
            tree1.add(['a file'], [b'file-id'], ['file'])
 
1102
            tree1.put_file_bytes_non_atomic('a file', b'file-content')
1037
1103
            revid1 = tree1.commit('foo')
1038
1104
        finally:
1039
1105
            tree1.unlock()
1040
 
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
 
1106
        branch2 = tree1.branch.controldir.clone('tree2').open_branch()
1041
1107
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
1042
1108
        tree2.lock_write()
1043
1109
        try:
1044
 
            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
 
1110
            tree2.put_file_bytes_non_atomic('a file', b'new file-content')
1045
1111
            revid2 = tree2.commit('foo')
1046
1112
            root_id = tree2.get_root_id()
1047
1113
        finally:
1048
1114
            tree2.unlock()
1049
1115
        # check the layout in memory
1050
 
        expected_result = [revid1.encode('utf8'), revid2.encode('utf8')], [
1051
 
            (('', '', root_id), [
1052
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1053
 
             ('d', '', 0, False, revid1.encode('utf8')),
1054
 
             ('d', '', 0, False, revid1.encode('utf8'))
 
1116
        expected_result = [revid1, revid2], [
 
1117
            ((b'', b'', root_id), [
 
1118
             (b'd', b'', 0, False, dirstate.DirState.NULLSTAT),
 
1119
             (b'd', b'', 0, False, revid1),
 
1120
             (b'd', b'', 0, False, revid1)
1055
1121
             ]),
1056
 
            (('', 'a file', 'file-id'), [
1057
 
             ('a', '', 0, False, ''),
1058
 
             ('f', '2439573625385400f2a669657a7db6ae7515d371', 12, False,
1059
 
              revid1.encode('utf8')),
1060
 
             ('f', '542e57dc1cda4af37cb8e55ec07ce60364bb3c7d', 16, False,
1061
 
              revid2.encode('utf8'))
 
1122
            ((b'', b'a file', b'file-id'), [
 
1123
             (b'a', b'', 0, False, b''),
 
1124
             (b'f', b'2439573625385400f2a669657a7db6ae7515d371', 12, False,
 
1125
              revid1),
 
1126
             (b'f', b'542e57dc1cda4af37cb8e55ec07ce60364bb3c7d', 16, False,
 
1127
              revid2)
1062
1128
             ])
1063
1129
            ]
1064
1130
        state = dirstate.DirState.initialize('dirstate')
1065
1131
        try:
1066
 
            state.set_path_id('', root_id)
 
1132
            state.set_path_id(b'', root_id)
1067
1133
            state.set_parent_trees(
1068
1134
                ((revid1, tree1.branch.repository.revision_tree(revid1)),
1069
1135
                 (revid2, tree2.branch.repository.revision_tree(revid2)),
1086
1152
        # the 1*20 is the sha1 pretend value.
1087
1153
        state = dirstate.DirState.initialize('dirstate')
1088
1154
        expected_entries = [
1089
 
            (('', '', 'TREE_ROOT'), [
1090
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
1155
            ((b'', b'', b'TREE_ROOT'), [
 
1156
             (b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
1091
1157
             ]),
1092
 
            (('', 'a file', 'a-file-id'), [
1093
 
             ('f', '1'*20, 19, False, dirstate.pack_stat(stat)), # current tree
 
1158
            ((b'', b'a file', b'a-file-id'), [
 
1159
             (b'f', b'1'*20, 19, False, dirstate.pack_stat(stat)), # current tree
1094
1160
             ]),
1095
1161
            ]
1096
1162
        try:
1097
 
            state.add('a file', 'a-file-id', 'file', stat, '1'*20)
 
1163
            state.add('a file', b'a-file-id', 'file', stat, b'1'*20)
1098
1164
            # having added it, it should be in the output of iter_entries.
1099
1165
            self.assertEqual(expected_entries, list(state._iter_entries()))
1100
1166
            # saving and reloading should not affect this.
1117
1183
        state = dirstate.DirState.initialize('dirstate')
1118
1184
        self.addCleanup(state.unlock)
1119
1185
        self.assertRaises(errors.NotVersionedError, state.add,
1120
 
                          'unversioned/a file', 'a-file-id', 'file', None, None)
 
1186
                          'unversioned/a file', b'a-file-id', 'file', None, None)
1121
1187
 
1122
1188
    def test_add_directory_to_root_no_parents_all_data(self):
1123
1189
        # The most trivial addition of a dir is when there are no parents and
1125
1191
        self.build_tree(['a dir/'])
1126
1192
        stat = os.lstat('a dir')
1127
1193
        expected_entries = [
1128
 
            (('', '', 'TREE_ROOT'), [
1129
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
1194
            ((b'', b'', b'TREE_ROOT'), [
 
1195
             (b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
1130
1196
             ]),
1131
 
            (('', 'a dir', 'a dir id'), [
1132
 
             ('d', '', 0, False, dirstate.pack_stat(stat)), # current tree
 
1197
            ((b'', b'a dir', b'a dir id'), [
 
1198
             (b'd', b'', 0, False, dirstate.pack_stat(stat)), # current tree
1133
1199
             ]),
1134
1200
            ]
1135
1201
        state = dirstate.DirState.initialize('dirstate')
1136
1202
        try:
1137
 
            state.add('a dir', 'a dir id', 'directory', stat, None)
 
1203
            state.add('a dir', b'a dir id', 'directory', stat, None)
1138
1204
            # having added it, it should be in the output of iter_entries.
1139
1205
            self.assertEqual(expected_entries, list(state._iter_entries()))
1140
1206
            # saving and reloading should not affect this.
1151
1217
        # The most trivial addition of a symlink when there are no parents and
1152
1218
        # its in the root and all data about the file is supplied
1153
1219
        # bzr doesn't support fake symlinks on windows, yet.
1154
 
        self.requireFeature(tests.SymlinkFeature)
 
1220
        self.requireFeature(features.SymlinkFeature)
1155
1221
        os.symlink(target, link_name)
1156
1222
        stat = os.lstat(link_name)
1157
1223
        expected_entries = [
1158
 
            (('', '', 'TREE_ROOT'), [
1159
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
1224
            ((b'', b'', b'TREE_ROOT'), [
 
1225
             (b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
1160
1226
             ]),
1161
 
            (('', link_name.encode('UTF-8'), 'a link id'), [
1162
 
             ('l', target.encode('UTF-8'), stat[6],
 
1227
            ((b'', link_name.encode('UTF-8'), b'a link id'), [
 
1228
             (b'l', target.encode('UTF-8'), stat[6],
1163
1229
              False, dirstate.pack_stat(stat)), # current tree
1164
1230
             ]),
1165
1231
            ]
1166
1232
        state = dirstate.DirState.initialize('dirstate')
1167
1233
        try:
1168
 
            state.add(link_name, 'a link id', 'symlink', stat,
 
1234
            state.add(link_name, b'a link id', 'symlink', stat,
1169
1235
                      target.encode('UTF-8'))
1170
1236
            # having added it, it should be in the output of iter_entries.
1171
1237
            self.assertEqual(expected_entries, list(state._iter_entries()))
1179
1245
        self.assertEqual(expected_entries, list(state._iter_entries()))
1180
1246
 
1181
1247
    def test_add_symlink_to_root_no_parents_all_data(self):
1182
 
        self._test_add_symlink_to_root_no_parents_all_data('a link', 'target')
 
1248
        self._test_add_symlink_to_root_no_parents_all_data(u'a link', u'target')
1183
1249
 
1184
1250
    def test_add_symlink_unicode_to_root_no_parents_all_data(self):
1185
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1251
        self.requireFeature(features.UnicodeFilenameFeature)
1186
1252
        self._test_add_symlink_to_root_no_parents_all_data(
1187
1253
            u'\N{Euro Sign}link', u'targ\N{Euro Sign}et')
1188
1254
 
1192
1258
        dirstat = os.lstat('a dir')
1193
1259
        filestat = os.lstat('a dir/a file')
1194
1260
        expected_entries = [
1195
 
            (('', '', 'TREE_ROOT'), [
1196
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1197
 
             ]),
1198
 
            (('', 'a dir', 'a dir id'), [
1199
 
             ('d', '', 0, False, dirstate.pack_stat(dirstat)), # current tree
1200
 
             ]),
1201
 
            (('a dir', 'a file', 'a-file-id'), [
1202
 
             ('f', '1'*20, 25, False,
 
1261
            ((b'', b'', b'TREE_ROOT'), [
 
1262
             (b'd', b'', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
1263
             ]),
 
1264
            ((b'', b'a dir', b'a dir id'), [
 
1265
             (b'd', b'', 0, False, dirstate.pack_stat(dirstat)), # current tree
 
1266
             ]),
 
1267
            ((b'a dir', b'a file', b'a-file-id'), [
 
1268
             (b'f', b'1'*20, 25, False,
1203
1269
              dirstate.pack_stat(filestat)), # current tree details
1204
1270
             ]),
1205
1271
            ]
1206
1272
        state = dirstate.DirState.initialize('dirstate')
1207
1273
        try:
1208
 
            state.add('a dir', 'a dir id', 'directory', dirstat, None)
1209
 
            state.add('a dir/a file', 'a-file-id', 'file', filestat, '1'*20)
 
1274
            state.add('a dir', b'a dir id', 'directory', dirstat, None)
 
1275
            state.add('a dir/a file', b'a-file-id', 'file', filestat, b'1'*20)
1210
1276
            # added it, it should be in the output of iter_entries.
1211
1277
            self.assertEqual(expected_entries, list(state._iter_entries()))
1212
1278
            # saving and reloading should not affect this.
1222
1288
        # make a dirstate and add a tree reference
1223
1289
        state = dirstate.DirState.initialize('dirstate')
1224
1290
        expected_entry = (
1225
 
            ('', 'subdir', 'subdir-id'),
1226
 
            [('t', 'subtree-123123', 0, False,
1227
 
              'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')],
 
1291
            (b'', b'subdir', b'subdir-id'),
 
1292
            [(b't', b'subtree-123123', 0, False,
 
1293
              b'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')],
1228
1294
            )
1229
1295
        try:
1230
 
            state.add('subdir', 'subdir-id', 'tree-reference', None, 'subtree-123123')
1231
 
            entry = state._get_entry(0, 'subdir-id', 'subdir')
 
1296
            state.add('subdir', b'subdir-id', 'tree-reference', None, b'subtree-123123')
 
1297
            entry = state._get_entry(0, b'subdir-id', b'subdir')
1232
1298
            self.assertEqual(entry, expected_entry)
1233
1299
            state._validate()
1234
1300
            state.save()
1238
1304
        state.lock_read()
1239
1305
        self.addCleanup(state.unlock)
1240
1306
        state._validate()
1241
 
        entry2 = state._get_entry(0, 'subdir-id', 'subdir')
 
1307
        entry2 = state._get_entry(0, b'subdir-id', b'subdir')
1242
1308
        self.assertEqual(entry, entry2)
1243
1309
        self.assertEqual(entry, expected_entry)
1244
1310
        # and lookup by id should work too
1245
 
        entry2 = state._get_entry(0, fileid_utf8='subdir-id')
 
1311
        entry2 = state._get_entry(0, fileid_utf8=b'subdir-id')
1246
1312
        self.assertEqual(entry, expected_entry)
1247
1313
 
1248
1314
    def test_add_forbidden_names(self):
1249
1315
        state = dirstate.DirState.initialize('dirstate')
1250
1316
        self.addCleanup(state.unlock)
1251
1317
        self.assertRaises(errors.BzrError,
1252
 
            state.add, '.', 'ass-id', 'directory', None, None)
 
1318
            state.add, '.', b'ass-id', 'directory', None, None)
1253
1319
        self.assertRaises(errors.BzrError,
1254
 
            state.add, '..', 'ass-id', 'directory', None, None)
 
1320
            state.add, '..', b'ass-id', 'directory', None, None)
1255
1321
 
1256
1322
    def test_set_state_with_rename_b_a_bug_395556(self):
1257
1323
        # bug 395556 uncovered a bug where the dirstate ends up with a false
1263
1329
        self.build_tree(['tree1/b'])
1264
1330
        tree1.lock_write()
1265
1331
        try:
1266
 
            tree1.add(['b'], ['b-id'])
 
1332
            tree1.add(['b'], [b'b-id'])
1267
1333
            root_id = tree1.get_root_id()
1268
 
            inv = tree1.inventory
 
1334
            inv = tree1.root_inventory
1269
1335
            state = dirstate.DirState.initialize('dirstate')
1270
1336
            try:
1271
1337
                # Set the initial state with 'b'
1272
1338
                state.set_state_from_inventory(inv)
1273
 
                inv.rename('b-id', root_id, 'a')
 
1339
                inv.rename(b'b-id', root_id, 'a')
1274
1340
                # Set the new state with 'a', which currently corrupts.
1275
1341
                state.set_state_from_inventory(inv)
1276
 
                expected_result1 = [('', '', root_id, 'd'),
1277
 
                                    ('', 'a', 'b-id', 'f'),
 
1342
                expected_result1 = [(b'', b'', root_id, b'd'),
 
1343
                                    (b'', b'a', b'b-id', b'f'),
1278
1344
                                   ]
1279
1345
                values = []
1280
1346
                for entry in state._iter_entries():
1286
1352
            tree1.unlock()
1287
1353
 
1288
1354
 
 
1355
class TestDirStateHashUpdates(TestCaseWithDirState):
 
1356
 
 
1357
    def do_update_entry(self, state, path):
 
1358
        entry = state._get_entry(0, path_utf8=path)
 
1359
        stat = os.lstat(path)
 
1360
        return dirstate.update_entry(state, entry, os.path.abspath(path), stat)
 
1361
 
 
1362
    def _read_state_content(self, state):
 
1363
        """Read the content of the dirstate file.
 
1364
 
 
1365
        On Windows when one process locks a file, you can't even open() the
 
1366
        file in another process (to read it). So we go directly to
 
1367
        state._state_file. This should always be the exact disk representation,
 
1368
        so it is reasonable to do so.
 
1369
        DirState also always seeks before reading, so it doesn't matter if we
 
1370
        bump the file pointer.
 
1371
        """
 
1372
        state._state_file.seek(0)
 
1373
        return state._state_file.read()
 
1374
 
 
1375
    def test_worth_saving_limit_avoids_writing(self):
 
1376
        tree = self.make_branch_and_tree('.')
 
1377
        self.build_tree(['c', 'd'])
 
1378
        tree.lock_write()
 
1379
        tree.add(['c', 'd'], [b'c-id', b'd-id'])
 
1380
        tree.commit('add c and d')
 
1381
        state = InstrumentedDirState.on_file(tree.current_dirstate()._filename,
 
1382
                                             worth_saving_limit=2)
 
1383
        tree.unlock()
 
1384
        state.lock_write()
 
1385
        self.addCleanup(state.unlock)
 
1386
        state._read_dirblocks_if_needed()
 
1387
        state.adjust_time(+20) # Allow things to be cached
 
1388
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1389
                         state._dirblock_state)
 
1390
        content = self._read_state_content(state)
 
1391
        self.do_update_entry(state, b'c')
 
1392
        self.assertEqual(1, len(state._known_hash_changes))
 
1393
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
 
1394
                         state._dirblock_state)
 
1395
        state.save()
 
1396
        # It should not have set the state to IN_MEMORY_UNMODIFIED because the
 
1397
        # hash values haven't been written out.
 
1398
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
 
1399
                         state._dirblock_state)
 
1400
        self.assertEqual(content, self._read_state_content(state))
 
1401
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
 
1402
                         state._dirblock_state)
 
1403
        self.do_update_entry(state, b'd')
 
1404
        self.assertEqual(2, len(state._known_hash_changes))
 
1405
        state.save()
 
1406
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1407
                         state._dirblock_state)
 
1408
        self.assertEqual(0, len(state._known_hash_changes))
 
1409
 
 
1410
 
1289
1411
class TestGetLines(TestCaseWithDirState):
1290
1412
 
1291
1413
    def test_get_line_with_2_rows(self):
1292
1414
        state = self.create_dirstate_with_root_and_subdir()
1293
1415
        try:
1294
 
            self.assertEqual(['#bazaar dirstate flat format 3\n',
1295
 
                'crc32: 41262208\n',
1296
 
                'num_entries: 2\n',
1297
 
                '0\x00\n\x00'
1298
 
                '0\x00\n\x00'
1299
 
                '\x00\x00a-root-value\x00'
1300
 
                'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00\n\x00'
1301
 
                '\x00subdir\x00subdir-id\x00'
1302
 
                'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00\n\x00'
 
1416
            self.assertEqual([b'#bazaar dirstate flat format 3\n',
 
1417
                b'crc32: 41262208\n',
 
1418
                b'num_entries: 2\n',
 
1419
                b'0\x00\n\x00'
 
1420
                b'0\x00\n\x00'
 
1421
                b'\x00\x00a-root-value\x00'
 
1422
                b'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00\n\x00'
 
1423
                b'\x00subdir\x00subdir-id\x00'
 
1424
                b'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00\n\x00'
1303
1425
                ], state.get_lines())
1304
1426
        finally:
1305
1427
            state.unlock()
1308
1430
        state = self.create_dirstate_with_root()
1309
1431
        try:
1310
1432
            self.assertEqual(
1311
 
                '\x00\x00a-root-value\x00d\x00\x000\x00n'
1312
 
                '\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk',
 
1433
                b'\x00\x00a-root-value\x00d\x00\x000\x00n'
 
1434
                b'\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk',
1313
1435
                state._entry_to_line(state._dirblocks[0][1][0]))
1314
1436
        finally:
1315
1437
            state.unlock()
1316
1438
 
1317
1439
    def test_entry_to_line_with_parent(self):
1318
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1319
 
        root_entry = ('', '', 'a-root-value'), [
1320
 
            ('d', '', 0, False, packed_stat), # current tree details
 
1440
        packed_stat = b'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
 
1441
        root_entry = (b'', b'', b'a-root-value'), [
 
1442
            (b'd', b'', 0, False, packed_stat), # current tree details
1321
1443
             # first: a pointer to the current location
1322
 
            ('a', 'dirname/basename', 0, False, ''),
 
1444
            (b'a', b'dirname/basename', 0, False, b''),
1323
1445
            ]
1324
1446
        state = dirstate.DirState.initialize('dirstate')
1325
1447
        try:
1326
1448
            self.assertEqual(
1327
 
                '\x00\x00a-root-value\x00'
1328
 
                'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00'
1329
 
                'a\x00dirname/basename\x000\x00n\x00',
 
1449
                b'\x00\x00a-root-value\x00'
 
1450
                b'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00'
 
1451
                b'a\x00dirname/basename\x000\x00n\x00',
1330
1452
                state._entry_to_line(root_entry))
1331
1453
        finally:
1332
1454
            state.unlock()
1333
1455
 
1334
1456
    def test_entry_to_line_with_two_parents_at_different_paths(self):
1335
1457
        # / in the tree, at / in one parent and /dirname/basename in the other.
1336
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1337
 
        root_entry = ('', '', 'a-root-value'), [
1338
 
            ('d', '', 0, False, packed_stat), # current tree details
1339
 
            ('d', '', 0, False, 'rev_id'), # first parent details
 
1458
        packed_stat = b'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
 
1459
        root_entry = (b'', b'', b'a-root-value'), [
 
1460
            (b'd', b'', 0, False, packed_stat), # current tree details
 
1461
            (b'd', b'', 0, False, b'rev_id'), # first parent details
1340
1462
             # second: a pointer to the current location
1341
 
            ('a', 'dirname/basename', 0, False, ''),
 
1463
            (b'a', b'dirname/basename', 0, False, b''),
1342
1464
            ]
1343
1465
        state = dirstate.DirState.initialize('dirstate')
1344
1466
        try:
1345
1467
            self.assertEqual(
1346
 
                '\x00\x00a-root-value\x00'
1347
 
                'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00'
1348
 
                'd\x00\x000\x00n\x00rev_id\x00'
1349
 
                'a\x00dirname/basename\x000\x00n\x00',
 
1468
                b'\x00\x00a-root-value\x00'
 
1469
                b'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00'
 
1470
                b'd\x00\x000\x00n\x00rev_id\x00'
 
1471
                b'a\x00dirname/basename\x000\x00n\x00',
1350
1472
                state._entry_to_line(root_entry))
1351
1473
        finally:
1352
1474
            state.unlock()
1354
1476
    def test_iter_entries(self):
1355
1477
        # we should be able to iterate the dirstate entries from end to end
1356
1478
        # this is for get_lines to be easy to read.
1357
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
 
1479
        packed_stat = b'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1358
1480
        dirblocks = []
1359
 
        root_entries = [(('', '', 'a-root-value'), [
1360
 
            ('d', '', 0, False, packed_stat), # current tree details
 
1481
        root_entries = [((b'', b'', b'a-root-value'), [
 
1482
            (b'd', b'', 0, False, packed_stat), # current tree details
1361
1483
            ])]
1362
1484
        dirblocks.append(('', root_entries))
1363
1485
        # add two files in the root
1364
 
        subdir_entry = ('', 'subdir', 'subdir-id'), [
1365
 
            ('d', '', 0, False, packed_stat), # current tree details
 
1486
        subdir_entry = (b'', b'subdir', b'subdir-id'), [
 
1487
            (b'd', b'', 0, False, packed_stat), # current tree details
1366
1488
            ]
1367
 
        afile_entry = ('', 'afile', 'afile-id'), [
1368
 
            ('f', 'sha1value', 34, False, packed_stat), # current tree details
 
1489
        afile_entry = (b'', b'afile', b'afile-id'), [
 
1490
            (b'f', b'sha1value', 34, False, packed_stat), # current tree details
1369
1491
            ]
1370
1492
        dirblocks.append(('', [subdir_entry, afile_entry]))
1371
1493
        # and one in subdir
1372
 
        file_entry2 = ('subdir', '2file', '2file-id'), [
1373
 
            ('f', 'sha1value', 23, False, packed_stat), # current tree details
 
1494
        file_entry2 = (b'subdir', b'2file', b'2file-id'), [
 
1495
            (b'f', b'sha1value', 23, False, packed_stat), # current tree details
1374
1496
            ]
1375
1497
        dirblocks.append(('subdir', [file_entry2]))
1376
1498
        state = dirstate.DirState.initialize('dirstate')
1400
1522
    def test_simple_structure(self):
1401
1523
        state = self.create_dirstate_with_root_and_subdir()
1402
1524
        self.addCleanup(state.unlock)
1403
 
        self.assertBlockRowIndexEqual(1, 0, True, True, state, '', 'subdir', 0)
1404
 
        self.assertBlockRowIndexEqual(1, 0, True, False, state, '', 'bdir', 0)
1405
 
        self.assertBlockRowIndexEqual(1, 1, True, False, state, '', 'zdir', 0)
1406
 
        self.assertBlockRowIndexEqual(2, 0, False, False, state, 'a', 'foo', 0)
 
1525
        self.assertBlockRowIndexEqual(1, 0, True, True, state, b'', b'subdir', 0)
 
1526
        self.assertBlockRowIndexEqual(1, 0, True, False, state, b'', b'bdir', 0)
 
1527
        self.assertBlockRowIndexEqual(1, 1, True, False, state, b'', b'zdir', 0)
 
1528
        self.assertBlockRowIndexEqual(2, 0, False, False, state, b'a', b'foo', 0)
1407
1529
        self.assertBlockRowIndexEqual(2, 0, False, False, state,
1408
 
                                      'subdir', 'foo', 0)
 
1530
                                      b'subdir', b'foo', 0)
1409
1531
 
1410
1532
    def test_complex_structure_exists(self):
1411
1533
        state = self.create_complex_dirstate()
1412
1534
        self.addCleanup(state.unlock)
1413
1535
        # Make sure we can find everything that exists
1414
 
        self.assertBlockRowIndexEqual(0, 0, True, True, state, '', '', 0)
1415
 
        self.assertBlockRowIndexEqual(1, 0, True, True, state, '', 'a', 0)
1416
 
        self.assertBlockRowIndexEqual(1, 1, True, True, state, '', 'b', 0)
1417
 
        self.assertBlockRowIndexEqual(1, 2, True, True, state, '', 'c', 0)
1418
 
        self.assertBlockRowIndexEqual(1, 3, True, True, state, '', 'd', 0)
1419
 
        self.assertBlockRowIndexEqual(2, 0, True, True, state, 'a', 'e', 0)
1420
 
        self.assertBlockRowIndexEqual(2, 1, True, True, state, 'a', 'f', 0)
1421
 
        self.assertBlockRowIndexEqual(3, 0, True, True, state, 'b', 'g', 0)
 
1536
        self.assertBlockRowIndexEqual(0, 0, True, True, state, b'', b'', 0)
 
1537
        self.assertBlockRowIndexEqual(1, 0, True, True, state, b'', b'a', 0)
 
1538
        self.assertBlockRowIndexEqual(1, 1, True, True, state, b'', b'b', 0)
 
1539
        self.assertBlockRowIndexEqual(1, 2, True, True, state, b'', b'c', 0)
 
1540
        self.assertBlockRowIndexEqual(1, 3, True, True, state, b'', b'd', 0)
 
1541
        self.assertBlockRowIndexEqual(2, 0, True, True, state, b'a', b'e', 0)
 
1542
        self.assertBlockRowIndexEqual(2, 1, True, True, state, b'a', b'f', 0)
 
1543
        self.assertBlockRowIndexEqual(3, 0, True, True, state, b'b', b'g', 0)
1422
1544
        self.assertBlockRowIndexEqual(3, 1, True, True, state,
1423
 
                                      'b', 'h\xc3\xa5', 0)
 
1545
                                      b'b', b'h\xc3\xa5', 0)
1424
1546
 
1425
1547
    def test_complex_structure_missing(self):
1426
1548
        state = self.create_complex_dirstate()
1427
1549
        self.addCleanup(state.unlock)
1428
1550
        # Make sure things would be inserted in the right locations
1429
1551
        # '_' comes before 'a'
1430
 
        self.assertBlockRowIndexEqual(0, 0, True, True, state, '', '', 0)
1431
 
        self.assertBlockRowIndexEqual(1, 0, True, False, state, '', '_', 0)
1432
 
        self.assertBlockRowIndexEqual(1, 1, True, False, state, '', 'aa', 0)
 
1552
        self.assertBlockRowIndexEqual(0, 0, True, True, state, b'', b'', 0)
 
1553
        self.assertBlockRowIndexEqual(1, 0, True, False, state, b'', b'_', 0)
 
1554
        self.assertBlockRowIndexEqual(1, 1, True, False, state, b'', b'aa', 0)
1433
1555
        self.assertBlockRowIndexEqual(1, 4, True, False, state,
1434
 
                                      '', 'h\xc3\xa5', 0)
1435
 
        self.assertBlockRowIndexEqual(2, 0, False, False, state, '_', 'a', 0)
1436
 
        self.assertBlockRowIndexEqual(3, 0, False, False, state, 'aa', 'a', 0)
1437
 
        self.assertBlockRowIndexEqual(4, 0, False, False, state, 'bb', 'a', 0)
 
1556
                                      b'', b'h\xc3\xa5', 0)
 
1557
        self.assertBlockRowIndexEqual(2, 0, False, False, state, b'_', b'a', 0)
 
1558
        self.assertBlockRowIndexEqual(3, 0, False, False, state, b'aa', b'a', 0)
 
1559
        self.assertBlockRowIndexEqual(4, 0, False, False, state, b'bb', b'a', 0)
1438
1560
        # This would be inserted between a/ and b/
1439
 
        self.assertBlockRowIndexEqual(3, 0, False, False, state, 'a/e', 'a', 0)
 
1561
        self.assertBlockRowIndexEqual(3, 0, False, False, state, b'a/e', b'a', 0)
1440
1562
        # Put at the end
1441
 
        self.assertBlockRowIndexEqual(4, 0, False, False, state, 'e', 'a', 0)
 
1563
        self.assertBlockRowIndexEqual(4, 0, False, False, state, b'e', b'a', 0)
1442
1564
 
1443
1565
 
1444
1566
class TestGetEntry(TestCaseWithDirState):
1455
1577
    def test_simple_structure(self):
1456
1578
        state = self.create_dirstate_with_root_and_subdir()
1457
1579
        self.addCleanup(state.unlock)
1458
 
        self.assertEntryEqual('', '', 'a-root-value', state, '', 0)
1459
 
        self.assertEntryEqual('', 'subdir', 'subdir-id', state, 'subdir', 0)
1460
 
        self.assertEntryEqual(None, None, None, state, 'missing', 0)
1461
 
        self.assertEntryEqual(None, None, None, state, 'missing/foo', 0)
1462
 
        self.assertEntryEqual(None, None, None, state, 'subdir/foo', 0)
 
1580
        self.assertEntryEqual(b'', b'', b'a-root-value', state, b'', 0)
 
1581
        self.assertEntryEqual(b'', b'subdir', b'subdir-id', state, b'subdir', 0)
 
1582
        self.assertEntryEqual(None, None, None, state, b'missing', 0)
 
1583
        self.assertEntryEqual(None, None, None, state, b'missing/foo', 0)
 
1584
        self.assertEntryEqual(None, None, None, state, b'subdir/foo', 0)
1463
1585
 
1464
1586
    def test_complex_structure_exists(self):
1465
1587
        state = self.create_complex_dirstate()
1466
1588
        self.addCleanup(state.unlock)
1467
 
        self.assertEntryEqual('', '', 'a-root-value', state, '', 0)
1468
 
        self.assertEntryEqual('', 'a', 'a-dir', state, 'a', 0)
1469
 
        self.assertEntryEqual('', 'b', 'b-dir', state, 'b', 0)
1470
 
        self.assertEntryEqual('', 'c', 'c-file', state, 'c', 0)
1471
 
        self.assertEntryEqual('', 'd', 'd-file', state, 'd', 0)
1472
 
        self.assertEntryEqual('a', 'e', 'e-dir', state, 'a/e', 0)
1473
 
        self.assertEntryEqual('a', 'f', 'f-file', state, 'a/f', 0)
1474
 
        self.assertEntryEqual('b', 'g', 'g-file', state, 'b/g', 0)
1475
 
        self.assertEntryEqual('b', 'h\xc3\xa5', 'h-\xc3\xa5-file', state,
1476
 
                              'b/h\xc3\xa5', 0)
 
1589
        self.assertEntryEqual(b'', b'', b'a-root-value', state, b'', 0)
 
1590
        self.assertEntryEqual(b'', b'a', b'a-dir', state, b'a', 0)
 
1591
        self.assertEntryEqual(b'', b'b', b'b-dir', state, b'b', 0)
 
1592
        self.assertEntryEqual(b'', b'c', b'c-file', state, b'c', 0)
 
1593
        self.assertEntryEqual(b'', b'd', b'd-file', state, b'd', 0)
 
1594
        self.assertEntryEqual(b'a', b'e', b'e-dir', state, b'a/e', 0)
 
1595
        self.assertEntryEqual(b'a', b'f', b'f-file', state, b'a/f', 0)
 
1596
        self.assertEntryEqual(b'b', b'g', b'g-file', state, b'b/g', 0)
 
1597
        self.assertEntryEqual(b'b', b'h\xc3\xa5', b'h-\xc3\xa5-file', state,
 
1598
                              b'b/h\xc3\xa5', 0)
1477
1599
 
1478
1600
    def test_complex_structure_missing(self):
1479
1601
        state = self.create_complex_dirstate()
1480
1602
        self.addCleanup(state.unlock)
1481
 
        self.assertEntryEqual(None, None, None, state, '_', 0)
1482
 
        self.assertEntryEqual(None, None, None, state, '_\xc3\xa5', 0)
1483
 
        self.assertEntryEqual(None, None, None, state, 'a/b', 0)
1484
 
        self.assertEntryEqual(None, None, None, state, 'c/d', 0)
 
1603
        self.assertEntryEqual(None, None, None, state, b'_', 0)
 
1604
        self.assertEntryEqual(None, None, None, state, b'_\xc3\xa5', 0)
 
1605
        self.assertEntryEqual(None, None, None, state, b'a/b', 0)
 
1606
        self.assertEntryEqual(None, None, None, state, b'c/d', 0)
1485
1607
 
1486
1608
    def test_get_entry_uninitialized(self):
1487
1609
        """Calling get_entry will load data if it needs to"""
1498
1620
                             state._header_state)
1499
1621
            self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
1500
1622
                             state._dirblock_state)
1501
 
            self.assertEntryEqual('', '', 'a-root-value', state, '', 0)
 
1623
            self.assertEntryEqual(b'', b'', b'a-root-value', state, b'', 0)
1502
1624
        finally:
1503
1625
            state.unlock()
1504
1626
 
1528
1650
 
1529
1651
        :return: The dirstate, still write-locked.
1530
1652
        """
1531
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1532
 
        null_sha = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
 
1653
        packed_stat = b'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
 
1654
        null_sha = b'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
1533
1655
        NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
1534
 
        root_entry = ('', '', 'a-root-value'), [
1535
 
            ('d', '', 0, False, packed_stat),
1536
 
            ('d', '', 0, False, 'parent-revid'),
1537
 
            ]
1538
 
        a_entry = ('', 'a', 'a-dir'), [
1539
 
            ('d', '', 0, False, packed_stat),
1540
 
            ('d', '', 0, False, 'parent-revid'),
1541
 
            ]
1542
 
        b_entry = ('', 'b', 'b-dir'), [
1543
 
            ('d', '', 0, False, packed_stat),
1544
 
            ('d', '', 0, False, 'parent-revid'),
1545
 
            ]
1546
 
        c_entry = ('', 'c', 'c-file'), [
1547
 
            ('f', null_sha, 10, False, packed_stat),
1548
 
            ('r', 'b/j', 0, False, ''),
1549
 
            ]
1550
 
        d_entry = ('', 'd', 'd-file'), [
1551
 
            ('f', null_sha, 20, False, packed_stat),
1552
 
            ('f', 'd', 20, False, 'parent-revid'),
1553
 
            ]
1554
 
        e_entry = ('a', 'e', 'e-dir'), [
1555
 
            ('d', '', 0, False, packed_stat),
1556
 
            ('d', '', 0, False, 'parent-revid'),
1557
 
            ]
1558
 
        f_entry = ('a', 'f', 'f-file'), [
1559
 
            ('f', null_sha, 30, False, packed_stat),
1560
 
            ('f', 'f', 20, False, 'parent-revid'),
1561
 
            ]
1562
 
        g_entry = ('b', 'g', 'g-file'), [
1563
 
            ('f', null_sha, 30, False, packed_stat),
1564
 
            NULL_PARENT_DETAILS,
1565
 
            ]
1566
 
        h_entry1 = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file1'), [
1567
 
            ('f', null_sha, 40, False, packed_stat),
1568
 
            NULL_PARENT_DETAILS,
1569
 
            ]
1570
 
        h_entry2 = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file2'), [
1571
 
            NULL_PARENT_DETAILS,
1572
 
            ('f', 'h', 20, False, 'parent-revid'),
1573
 
            ]
1574
 
        i_entry = ('b', 'i', 'i-file'), [
1575
 
            NULL_PARENT_DETAILS,
1576
 
            ('f', 'h', 20, False, 'parent-revid'),
1577
 
            ]
1578
 
        j_entry = ('b', 'j', 'c-file'), [
1579
 
            ('r', 'c', 0, False, ''),
1580
 
            ('f', 'j', 20, False, 'parent-revid'),
 
1656
        root_entry = (b'', b'', b'a-root-value'), [
 
1657
            (b'd', b'', 0, False, packed_stat),
 
1658
            (b'd', b'', 0, False, b'parent-revid'),
 
1659
            ]
 
1660
        a_entry = (b'', b'a', b'a-dir'), [
 
1661
            (b'd', b'', 0, False, packed_stat),
 
1662
            (b'd', b'', 0, False, b'parent-revid'),
 
1663
            ]
 
1664
        b_entry = (b'', b'b', b'b-dir'), [
 
1665
            (b'd', b'', 0, False, packed_stat),
 
1666
            (b'd', b'', 0, False, b'parent-revid'),
 
1667
            ]
 
1668
        c_entry = (b'', b'c', b'c-file'), [
 
1669
            (b'f', null_sha, 10, False, packed_stat),
 
1670
            (b'r', b'b/j', 0, False, b''),
 
1671
            ]
 
1672
        d_entry = (b'', b'd', b'd-file'), [
 
1673
            (b'f', null_sha, 20, False, packed_stat),
 
1674
            (b'f', b'd', 20, False, b'parent-revid'),
 
1675
            ]
 
1676
        e_entry = (b'a', b'e', b'e-dir'), [
 
1677
            (b'd', b'', 0, False, packed_stat),
 
1678
            (b'd', b'', 0, False, b'parent-revid'),
 
1679
            ]
 
1680
        f_entry = (b'a', b'f', b'f-file'), [
 
1681
            (b'f', null_sha, 30, False, packed_stat),
 
1682
            (b'f', b'f', 20, False, b'parent-revid'),
 
1683
            ]
 
1684
        g_entry = (b'b', b'g', b'g-file'), [
 
1685
            (b'f', null_sha, 30, False, packed_stat),
 
1686
            NULL_PARENT_DETAILS,
 
1687
            ]
 
1688
        h_entry1 = (b'b', b'h\xc3\xa5', b'h-\xc3\xa5-file1'), [
 
1689
            (b'f', null_sha, 40, False, packed_stat),
 
1690
            NULL_PARENT_DETAILS,
 
1691
            ]
 
1692
        h_entry2 = (b'b', b'h\xc3\xa5', b'h-\xc3\xa5-file2'), [
 
1693
            NULL_PARENT_DETAILS,
 
1694
            (b'f', b'h', 20, False, b'parent-revid'),
 
1695
            ]
 
1696
        i_entry = (b'b', b'i', b'i-file'), [
 
1697
            NULL_PARENT_DETAILS,
 
1698
            (b'f', b'h', 20, False, b'parent-revid'),
 
1699
            ]
 
1700
        j_entry = (b'b', b'j', b'c-file'), [
 
1701
            (b'r', b'c', 0, False, b''),
 
1702
            (b'f', b'j', 20, False, b'parent-revid'),
1581
1703
            ]
1582
1704
        dirblocks = []
1583
 
        dirblocks.append(('', [root_entry]))
1584
 
        dirblocks.append(('', [a_entry, b_entry, c_entry, d_entry]))
1585
 
        dirblocks.append(('a', [e_entry, f_entry]))
1586
 
        dirblocks.append(('b', [g_entry, h_entry1, h_entry2, i_entry, j_entry]))
 
1705
        dirblocks.append((b'', [root_entry]))
 
1706
        dirblocks.append((b'', [a_entry, b_entry, c_entry, d_entry]))
 
1707
        dirblocks.append((b'a', [e_entry, f_entry]))
 
1708
        dirblocks.append((b'b', [g_entry, h_entry1, h_entry2, i_entry, j_entry]))
1587
1709
        state = dirstate.DirState.initialize('dirstate')
1588
1710
        state._validate()
1589
1711
        try:
1590
 
            state._set_data(['parent'], dirblocks)
 
1712
            state._set_data([b'parent'], dirblocks)
1591
1713
        except:
1592
1714
            state.unlock()
1593
1715
            raise
1601
1723
        expected_result.append(dirblocks[3][1][3]) # i
1602
1724
        expected_result.append(dirblocks[3][1][4]) # j
1603
1725
        self.assertEqual(expected_result,
1604
 
            list(state._iter_child_entries(1, 'b')))
 
1726
            list(state._iter_child_entries(1, b'b')))
1605
1727
 
1606
1728
    def test_iter_child_root(self):
1607
1729
        state, dirblocks = self.create_dirstate_with_two_trees()
1616
1738
        expected_result.append(dirblocks[3][1][3]) # i
1617
1739
        expected_result.append(dirblocks[3][1][4]) # j
1618
1740
        self.assertEqual(expected_result,
1619
 
            list(state._iter_child_entries(1, '')))
 
1741
            list(state._iter_child_entries(1, b'')))
1620
1742
 
1621
1743
 
1622
1744
class TestDirstateSortOrder(tests.TestCaseWithTransport):
1632
1754
        dirs = ['a', 'a/a', 'a/a/a', 'a/a/a/a',
1633
1755
                'a-a', 'a/a-a', 'a/a/a-a', 'a/a/a/a-a',
1634
1756
               ]
1635
 
        null_sha = ''
 
1757
        null_sha = b''
1636
1758
        state = dirstate.DirState.initialize('dirstate')
1637
1759
        self.addCleanup(state.unlock)
1638
1760
 
1639
1761
        fake_stat = os.stat('dirstate')
1640
1762
        for d in dirs:
1641
 
            d_id = d.replace('/', '_')+'-id'
 
1763
            d_id = d.encode('utf-8').replace(b'/', b'_')+b'-id'
1642
1764
            file_path = d + '/f'
1643
 
            file_id = file_path.replace('/', '_')+'-id'
 
1765
            file_id = file_path.encode('utf-8').replace(b'/', b'_')+b'-id'
1644
1766
            state.add(d, d_id, 'directory', fake_stat, null_sha)
1645
1767
            state.add(file_path, file_id, 'file', fake_stat, null_sha)
1646
1768
 
1647
 
        expected = ['', '', 'a',
1648
 
                'a/a', 'a/a/a', 'a/a/a/a',
1649
 
                'a/a/a/a-a', 'a/a/a-a', 'a/a-a', 'a-a',
 
1769
        expected = [b'', b'', b'a',
 
1770
                b'a/a', b'a/a/a', b'a/a/a/a',
 
1771
                b'a/a/a/a-a', b'a/a/a-a', b'a/a-a', b'a-a',
1650
1772
               ]
1651
 
        split = lambda p:p.split('/')
 
1773
        split = lambda p:p.split(b'/')
1652
1774
        self.assertEqual(sorted(expected, key=split), expected)
1653
1775
        dirblock_names = [d[0] for d in state._dirblocks]
1654
1776
        self.assertEqual(expected, dirblock_names)
1656
1778
    def test_set_parent_trees_correct_order(self):
1657
1779
        """After calling set_parent_trees() we should maintain the order."""
1658
1780
        dirs = ['a', 'a-a', 'a/a']
1659
 
        null_sha = ''
 
1781
        null_sha = b''
1660
1782
        state = dirstate.DirState.initialize('dirstate')
1661
1783
        self.addCleanup(state.unlock)
1662
1784
 
1663
1785
        fake_stat = os.stat('dirstate')
1664
1786
        for d in dirs:
1665
 
            d_id = d.replace('/', '_')+'-id'
 
1787
            d_id = d.encode('utf-8').replace(b'/', b'_')+b'-id'
1666
1788
            file_path = d + '/f'
1667
 
            file_id = file_path.replace('/', '_')+'-id'
 
1789
            file_id = file_path.encode('utf-8').replace(b'/', b'_')+b'-id'
1668
1790
            state.add(d, d_id, 'directory', fake_stat, null_sha)
1669
1791
            state.add(file_path, file_id, 'file', fake_stat, null_sha)
1670
1792
 
1671
 
        expected = ['', '', 'a', 'a/a', 'a-a']
 
1793
        expected = [b'', b'', b'a', b'a/a', b'a-a']
1672
1794
        dirblock_names = [d[0] for d in state._dirblocks]
1673
1795
        self.assertEqual(expected, dirblock_names)
1674
1796
 
1684
1806
class InstrumentedDirState(dirstate.DirState):
1685
1807
    """An DirState with instrumented sha1 functionality."""
1686
1808
 
1687
 
    def __init__(self, path, sha1_provider):
1688
 
        super(InstrumentedDirState, self).__init__(path, sha1_provider)
 
1809
    def __init__(self, path, sha1_provider, worth_saving_limit=0):
 
1810
        super(InstrumentedDirState, self).__init__(path, sha1_provider,
 
1811
            worth_saving_limit=worth_saving_limit)
1689
1812
        self._time_offset = 0
1690
1813
        self._log = []
1691
1814
        # member is dynamically set in DirState.__init__ to turn on trace
1748
1871
        self.assertEqual(expected, dirstate.pack_stat(stat_value))
1749
1872
 
1750
1873
    def test_pack_stat_int(self):
1751
 
        st = _FakeStat(6859L, 1172758614, 1172758617, 777L, 6499538L, 0100644)
 
1874
        st = _FakeStat(6859, 1172758614, 1172758617, 777, 6499538, 0o100644)
1752
1875
        # Make sure that all parameters have an impact on the packed stat.
1753
 
        self.assertPackStat('AAAay0Xm4FZF5uBZAAADCQBjLNIAAIGk', st)
1754
 
        st.st_size = 7000L
 
1876
        self.assertPackStat(b'AAAay0Xm4FZF5uBZAAADCQBjLNIAAIGk', st)
 
1877
        st.st_size = 7000
1755
1878
        #                ay0 => bWE
1756
 
        self.assertPackStat('AAAbWEXm4FZF5uBZAAADCQBjLNIAAIGk', st)
 
1879
        self.assertPackStat(b'AAAbWEXm4FZF5uBZAAADCQBjLNIAAIGk', st)
1757
1880
        st.st_mtime = 1172758620
1758
1881
        #                     4FZ => 4Fx
1759
 
        self.assertPackStat('AAAbWEXm4FxF5uBZAAADCQBjLNIAAIGk', st)
 
1882
        self.assertPackStat(b'AAAbWEXm4FxF5uBZAAADCQBjLNIAAIGk', st)
1760
1883
        st.st_ctime = 1172758630
1761
1884
        #                          uBZ => uBm
1762
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1763
 
        st.st_dev = 888L
 
1885
        self.assertPackStat(b'AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
 
1886
        st.st_dev = 888
1764
1887
        #                                DCQ => DeA
1765
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADeABjLNIAAIGk', st)
1766
 
        st.st_ino = 6499540L
 
1888
        self.assertPackStat(b'AAAbWEXm4FxF5uBmAAADeABjLNIAAIGk', st)
 
1889
        st.st_ino = 6499540
1767
1890
        #                                     LNI => LNQ
1768
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADeABjLNQAAIGk', st)
1769
 
        st.st_mode = 0100744
 
1891
        self.assertPackStat(b'AAAbWEXm4FxF5uBmAAADeABjLNQAAIGk', st)
 
1892
        st.st_mode = 0o100744
1770
1893
        #                                          IGk => IHk
1771
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADeABjLNQAAIHk', st)
 
1894
        self.assertPackStat(b'AAAbWEXm4FxF5uBmAAADeABjLNQAAIHk', st)
1772
1895
 
1773
1896
    def test_pack_stat_float(self):
1774
1897
        """On some platforms mtime and ctime are floats.
1776
1899
        Make sure we don't get warnings or errors, and that we ignore changes <
1777
1900
        1s
1778
1901
        """
1779
 
        st = _FakeStat(7000L, 1172758614.0, 1172758617.0,
1780
 
                       777L, 6499538L, 0100644)
 
1902
        st = _FakeStat(7000, 1172758614.0, 1172758617.0,
 
1903
                       777, 6499538, 0o100644)
1781
1904
        # These should all be the same as the integer counterparts
1782
 
        self.assertPackStat('AAAbWEXm4FZF5uBZAAADCQBjLNIAAIGk', st)
 
1905
        self.assertPackStat(b'AAAbWEXm4FZF5uBZAAADCQBjLNIAAIGk', st)
1783
1906
        st.st_mtime = 1172758620.0
1784
1907
        #                     FZF5 => FxF5
1785
 
        self.assertPackStat('AAAbWEXm4FxF5uBZAAADCQBjLNIAAIGk', st)
 
1908
        self.assertPackStat(b'AAAbWEXm4FxF5uBZAAADCQBjLNIAAIGk', st)
1786
1909
        st.st_ctime = 1172758630.0
1787
1910
        #                          uBZ => uBm
1788
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
 
1911
        self.assertPackStat(b'AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1789
1912
        # fractional seconds are discarded, so no change from above
1790
1913
        st.st_mtime = 1172758620.453
1791
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
 
1914
        self.assertPackStat(b'AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1792
1915
        st.st_ctime = 1172758630.228
1793
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
 
1916
        self.assertPackStat(b'AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1794
1917
 
1795
1918
 
1796
1919
class TestBisect(TestCaseWithDirState):
1874
1997
        tree, state, expected = self.create_basic_dirstate()
1875
1998
 
1876
1999
        # Bisect should return the rows for the specified files.
1877
 
        self.assertBisect(expected, [['']], state, [''])
1878
 
        self.assertBisect(expected, [['a']], state, ['a'])
1879
 
        self.assertBisect(expected, [['b']], state, ['b'])
1880
 
        self.assertBisect(expected, [['b/c']], state, ['b/c'])
1881
 
        self.assertBisect(expected, [['b/d']], state, ['b/d'])
1882
 
        self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
1883
 
        self.assertBisect(expected, [['b-c']], state, ['b-c'])
1884
 
        self.assertBisect(expected, [['f']], state, ['f'])
 
2000
        self.assertBisect(expected, [[b'']], state, [b''])
 
2001
        self.assertBisect(expected, [[b'a']], state, [b'a'])
 
2002
        self.assertBisect(expected, [[b'b']], state, [b'b'])
 
2003
        self.assertBisect(expected, [[b'b/c']], state, [b'b/c'])
 
2004
        self.assertBisect(expected, [[b'b/d']], state, [b'b/d'])
 
2005
        self.assertBisect(expected, [[b'b/d/e']], state, [b'b/d/e'])
 
2006
        self.assertBisect(expected, [[b'b-c']], state, [b'b-c'])
 
2007
        self.assertBisect(expected, [[b'f']], state, [b'f'])
1885
2008
 
1886
2009
    def test_bisect_multi(self):
1887
2010
        """Bisect can be used to find multiple records at the same time."""
1888
2011
        tree, state, expected = self.create_basic_dirstate()
1889
2012
        # Bisect should be capable of finding multiple entries at the same time
1890
 
        self.assertBisect(expected, [['a'], ['b'], ['f']],
1891
 
                          state, ['a', 'b', 'f'])
1892
 
        self.assertBisect(expected, [['f'], ['b/d'], ['b/d/e']],
1893
 
                          state, ['f', 'b/d', 'b/d/e'])
1894
 
        self.assertBisect(expected, [['b'], ['b-c'], ['b/c']],
1895
 
                          state, ['b', 'b-c', 'b/c'])
 
2013
        self.assertBisect(expected, [[b'a'], [b'b'], [b'f']],
 
2014
                          state, [b'a', b'b', b'f'])
 
2015
        self.assertBisect(expected, [[b'f'], [b'b/d'], [b'b/d/e']],
 
2016
                          state, [b'f', b'b/d', b'b/d/e'])
 
2017
        self.assertBisect(expected, [[b'b'], [b'b-c'], [b'b/c']],
 
2018
                          state, [b'b', b'b-c', b'b/c'])
1896
2019
 
1897
2020
    def test_bisect_one_page(self):
1898
2021
        """Test bisect when there is only 1 page to read"""
1899
2022
        tree, state, expected = self.create_basic_dirstate()
1900
2023
        state._bisect_page_size = 5000
1901
 
        self.assertBisect(expected,[['']], state, [''])
1902
 
        self.assertBisect(expected,[['a']], state, ['a'])
1903
 
        self.assertBisect(expected,[['b']], state, ['b'])
1904
 
        self.assertBisect(expected,[['b/c']], state, ['b/c'])
1905
 
        self.assertBisect(expected,[['b/d']], state, ['b/d'])
1906
 
        self.assertBisect(expected,[['b/d/e']], state, ['b/d/e'])
1907
 
        self.assertBisect(expected,[['b-c']], state, ['b-c'])
1908
 
        self.assertBisect(expected,[['f']], state, ['f'])
1909
 
        self.assertBisect(expected,[['a'], ['b'], ['f']],
1910
 
                          state, ['a', 'b', 'f'])
1911
 
        self.assertBisect(expected, [['b/d'], ['b/d/e'], ['f']],
1912
 
                          state, ['b/d', 'b/d/e', 'f'])
1913
 
        self.assertBisect(expected, [['b'], ['b/c'], ['b-c']],
1914
 
                          state, ['b', 'b/c', 'b-c'])
 
2024
        self.assertBisect(expected, [[b'']], state, [b''])
 
2025
        self.assertBisect(expected, [[b'a']], state, [b'a'])
 
2026
        self.assertBisect(expected, [[b'b']], state, [b'b'])
 
2027
        self.assertBisect(expected, [[b'b/c']], state, [b'b/c'])
 
2028
        self.assertBisect(expected, [[b'b/d']], state, [b'b/d'])
 
2029
        self.assertBisect(expected, [[b'b/d/e']], state, [b'b/d/e'])
 
2030
        self.assertBisect(expected, [[b'b-c']], state, [b'b-c'])
 
2031
        self.assertBisect(expected, [[b'f']], state, [b'f'])
 
2032
        self.assertBisect(expected, [[b'a'], [b'b'], [b'f']],
 
2033
                          state, [b'a', b'b', b'f'])
 
2034
        self.assertBisect(expected, [[b'b/d'], [b'b/d/e'], [b'f']],
 
2035
                          state, [b'b/d', b'b/d/e', b'f'])
 
2036
        self.assertBisect(expected, [[b'b'], [b'b/c'], [b'b-c']],
 
2037
                          state, [b'b', b'b/c', b'b-c'])
1915
2038
 
1916
2039
    def test_bisect_duplicate_paths(self):
1917
2040
        """When bisecting for a path, handle multiple entries."""
1918
2041
        tree, state, expected = self.create_duplicated_dirstate()
1919
2042
 
1920
2043
        # Now make sure that both records are properly returned.
1921
 
        self.assertBisect(expected, [['']], state, [''])
1922
 
        self.assertBisect(expected, [['a', 'a2']], state, ['a'])
1923
 
        self.assertBisect(expected, [['b', 'b2']], state, ['b'])
1924
 
        self.assertBisect(expected, [['b/c', 'b/c2']], state, ['b/c'])
1925
 
        self.assertBisect(expected, [['b/d', 'b/d2']], state, ['b/d'])
1926
 
        self.assertBisect(expected, [['b/d/e', 'b/d/e2']],
1927
 
                          state, ['b/d/e'])
1928
 
        self.assertBisect(expected, [['b-c', 'b-c2']], state, ['b-c'])
1929
 
        self.assertBisect(expected, [['f', 'f2']], state, ['f'])
 
2044
        self.assertBisect(expected, [[b'']], state, [b''])
 
2045
        self.assertBisect(expected, [[b'a', b'a2']], state, [b'a'])
 
2046
        self.assertBisect(expected, [[b'b', b'b2']], state, [b'b'])
 
2047
        self.assertBisect(expected, [[b'b/c', b'b/c2']], state, [b'b/c'])
 
2048
        self.assertBisect(expected, [[b'b/d', b'b/d2']], state, [b'b/d'])
 
2049
        self.assertBisect(expected, [[b'b/d/e', b'b/d/e2']],
 
2050
                          state, [b'b/d/e'])
 
2051
        self.assertBisect(expected, [[b'b-c', b'b-c2']], state, [b'b-c'])
 
2052
        self.assertBisect(expected, [[b'f', b'f2']], state, [b'f'])
1930
2053
 
1931
2054
    def test_bisect_page_size_too_small(self):
1932
2055
        """If the page size is too small, we will auto increase it."""
1933
2056
        tree, state, expected = self.create_basic_dirstate()
1934
2057
        state._bisect_page_size = 50
1935
 
        self.assertBisect(expected, [None], state, ['b/e'])
1936
 
        self.assertBisect(expected, [['a']], state, ['a'])
1937
 
        self.assertBisect(expected, [['b']], state, ['b'])
1938
 
        self.assertBisect(expected, [['b/c']], state, ['b/c'])
1939
 
        self.assertBisect(expected, [['b/d']], state, ['b/d'])
1940
 
        self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
1941
 
        self.assertBisect(expected, [['b-c']], state, ['b-c'])
1942
 
        self.assertBisect(expected, [['f']], state, ['f'])
 
2058
        self.assertBisect(expected, [None], state, [b'b/e'])
 
2059
        self.assertBisect(expected, [[b'a']], state, [b'a'])
 
2060
        self.assertBisect(expected, [[b'b']], state, [b'b'])
 
2061
        self.assertBisect(expected, [[b'b/c']], state, [b'b/c'])
 
2062
        self.assertBisect(expected, [[b'b/d']], state, [b'b/d'])
 
2063
        self.assertBisect(expected, [[b'b/d/e']], state, [b'b/d/e'])
 
2064
        self.assertBisect(expected, [[b'b-c']], state, [b'b-c'])
 
2065
        self.assertBisect(expected, [[b'f']], state, [b'f'])
1943
2066
 
1944
2067
    def test_bisect_missing(self):
1945
2068
        """Test that bisect return None if it cannot find a path."""
1946
2069
        tree, state, expected = self.create_basic_dirstate()
1947
 
        self.assertBisect(expected, [None], state, ['foo'])
1948
 
        self.assertBisect(expected, [None], state, ['b/foo'])
1949
 
        self.assertBisect(expected, [None], state, ['bar/foo'])
1950
 
        self.assertBisect(expected, [None], state, ['b-c/foo'])
 
2070
        self.assertBisect(expected, [None], state, [b'foo'])
 
2071
        self.assertBisect(expected, [None], state, [b'b/foo'])
 
2072
        self.assertBisect(expected, [None], state, [b'bar/foo'])
 
2073
        self.assertBisect(expected, [None], state, [b'b-c/foo'])
1951
2074
 
1952
 
        self.assertBisect(expected, [['a'], None, ['b/d']],
1953
 
                          state, ['a', 'foo', 'b/d'])
 
2075
        self.assertBisect(expected, [[b'a'], None, [b'b/d']],
 
2076
                          state, [b'a', b'foo', b'b/d'])
1954
2077
 
1955
2078
    def test_bisect_rename(self):
1956
2079
        """Check that we find a renamed row."""
1957
2080
        tree, state, expected = self.create_renamed_dirstate()
1958
2081
 
1959
2082
        # Search for the pre and post renamed entries
1960
 
        self.assertBisect(expected, [['a']], state, ['a'])
1961
 
        self.assertBisect(expected, [['b/g']], state, ['b/g'])
1962
 
        self.assertBisect(expected, [['b/d']], state, ['b/d'])
1963
 
        self.assertBisect(expected, [['h']], state, ['h'])
 
2083
        self.assertBisect(expected, [[b'a']], state, [b'a'])
 
2084
        self.assertBisect(expected, [[b'b/g']], state, [b'b/g'])
 
2085
        self.assertBisect(expected, [[b'b/d']], state, [b'b/d'])
 
2086
        self.assertBisect(expected, [[b'h']], state, [b'h'])
1964
2087
 
1965
2088
        # What about b/d/e? shouldn't that also get 2 directory entries?
1966
 
        self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
1967
 
        self.assertBisect(expected, [['h/e']], state, ['h/e'])
 
2089
        self.assertBisect(expected, [[b'b/d/e']], state, [b'b/d/e'])
 
2090
        self.assertBisect(expected, [[b'h/e']], state, [b'h/e'])
1968
2091
 
1969
2092
    def test_bisect_dirblocks(self):
1970
2093
        tree, state, expected = self.create_duplicated_dirstate()
1971
2094
        self.assertBisectDirBlocks(expected,
1972
 
            [['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2']],
1973
 
            state, [''])
1974
 
        self.assertBisectDirBlocks(expected,
1975
 
            [['b/c', 'b/c2', 'b/d', 'b/d2']], state, ['b'])
1976
 
        self.assertBisectDirBlocks(expected,
1977
 
            [['b/d/e', 'b/d/e2']], state, ['b/d'])
1978
 
        self.assertBisectDirBlocks(expected,
1979
 
            [['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2'],
1980
 
             ['b/c', 'b/c2', 'b/d', 'b/d2'],
1981
 
             ['b/d/e', 'b/d/e2'],
1982
 
            ], state, ['', 'b', 'b/d'])
 
2095
            [[b'', b'a', b'a2', b'b', b'b2', b'b-c', b'b-c2', b'f', b'f2']],
 
2096
            state, [b''])
 
2097
        self.assertBisectDirBlocks(expected,
 
2098
            [[b'b/c', b'b/c2', b'b/d', b'b/d2']], state, [b'b'])
 
2099
        self.assertBisectDirBlocks(expected,
 
2100
            [[b'b/d/e', b'b/d/e2']], state, [b'b/d'])
 
2101
        self.assertBisectDirBlocks(expected,
 
2102
            [[b'', b'a', b'a2', b'b', b'b2', b'b-c', b'b-c2', b'f', b'f2'],
 
2103
             [b'b/c', b'b/c2', b'b/d', b'b/d2'],
 
2104
             [b'b/d/e', b'b/d/e2'],
 
2105
            ], state, [b'', b'b', b'b/d'])
1983
2106
 
1984
2107
    def test_bisect_dirblocks_missing(self):
1985
2108
        tree, state, expected = self.create_basic_dirstate()
1986
 
        self.assertBisectDirBlocks(expected, [['b/d/e'], None],
1987
 
            state, ['b/d', 'b/e'])
 
2109
        self.assertBisectDirBlocks(expected, [[b'b/d/e'], None],
 
2110
            state, [b'b/d', b'b/e'])
1988
2111
        # Files don't show up in this search
1989
 
        self.assertBisectDirBlocks(expected, [None], state, ['a'])
1990
 
        self.assertBisectDirBlocks(expected, [None], state, ['b/c'])
1991
 
        self.assertBisectDirBlocks(expected, [None], state, ['c'])
1992
 
        self.assertBisectDirBlocks(expected, [None], state, ['b/d/e'])
1993
 
        self.assertBisectDirBlocks(expected, [None], state, ['f'])
 
2112
        self.assertBisectDirBlocks(expected, [None], state, [b'a'])
 
2113
        self.assertBisectDirBlocks(expected, [None], state, [b'b/c'])
 
2114
        self.assertBisectDirBlocks(expected, [None], state, [b'c'])
 
2115
        self.assertBisectDirBlocks(expected, [None], state, [b'b/d/e'])
 
2116
        self.assertBisectDirBlocks(expected, [None], state, [b'f'])
1994
2117
 
1995
2118
    def test_bisect_recursive_each(self):
1996
2119
        tree, state, expected = self.create_basic_dirstate()
1997
 
        self.assertBisectRecursive(expected, ['a'], state, ['a'])
1998
 
        self.assertBisectRecursive(expected, ['b/c'], state, ['b/c'])
1999
 
        self.assertBisectRecursive(expected, ['b/d/e'], state, ['b/d/e'])
2000
 
        self.assertBisectRecursive(expected, ['b-c'], state, ['b-c'])
2001
 
        self.assertBisectRecursive(expected, ['b/d', 'b/d/e'],
2002
 
                                   state, ['b/d'])
2003
 
        self.assertBisectRecursive(expected, ['b', 'b/c', 'b/d', 'b/d/e'],
2004
 
                                   state, ['b'])
2005
 
        self.assertBisectRecursive(expected, ['', 'a', 'b', 'b-c', 'f', 'b/c',
2006
 
                                              'b/d', 'b/d/e'],
2007
 
                                   state, [''])
 
2120
        self.assertBisectRecursive(expected, [b'a'], state, [b'a'])
 
2121
        self.assertBisectRecursive(expected, [b'b/c'], state, [b'b/c'])
 
2122
        self.assertBisectRecursive(expected, [b'b/d/e'], state, [b'b/d/e'])
 
2123
        self.assertBisectRecursive(expected, [b'b-c'], state, [b'b-c'])
 
2124
        self.assertBisectRecursive(expected, [b'b/d', b'b/d/e'],
 
2125
                                   state, [b'b/d'])
 
2126
        self.assertBisectRecursive(expected, [b'b', b'b/c', b'b/d', b'b/d/e'],
 
2127
                                   state, [b'b'])
 
2128
        self.assertBisectRecursive(expected, [b'', b'a', b'b', b'b-c', b'f', b'b/c',
 
2129
                                              b'b/d', b'b/d/e'],
 
2130
                                   state, [b''])
2008
2131
 
2009
2132
    def test_bisect_recursive_multiple(self):
2010
2133
        tree, state, expected = self.create_basic_dirstate()
2011
 
        self.assertBisectRecursive(expected, ['a', 'b/c'], state, ['a', 'b/c'])
2012
 
        self.assertBisectRecursive(expected, ['b/d', 'b/d/e'],
2013
 
                                   state, ['b/d', 'b/d/e'])
 
2134
        self.assertBisectRecursive(expected, [b'a', b'b/c'], state, [b'a', b'b/c'])
 
2135
        self.assertBisectRecursive(expected, [b'b/d', b'b/d/e'],
 
2136
                                   state, [b'b/d', b'b/d/e'])
2014
2137
 
2015
2138
    def test_bisect_recursive_missing(self):
2016
2139
        tree, state, expected = self.create_basic_dirstate()
2017
 
        self.assertBisectRecursive(expected, [], state, ['d'])
2018
 
        self.assertBisectRecursive(expected, [], state, ['b/e'])
2019
 
        self.assertBisectRecursive(expected, [], state, ['g'])
2020
 
        self.assertBisectRecursive(expected, ['a'], state, ['a', 'g'])
 
2140
        self.assertBisectRecursive(expected, [], state, [b'd'])
 
2141
        self.assertBisectRecursive(expected, [], state, [b'b/e'])
 
2142
        self.assertBisectRecursive(expected, [], state, [b'g'])
 
2143
        self.assertBisectRecursive(expected, [b'a'], state, [b'a', b'g'])
2021
2144
 
2022
2145
    def test_bisect_recursive_renamed(self):
2023
2146
        tree, state, expected = self.create_renamed_dirstate()
2024
2147
 
2025
2148
        # Looking for either renamed item should find the other
2026
 
        self.assertBisectRecursive(expected, ['a', 'b/g'], state, ['a'])
2027
 
        self.assertBisectRecursive(expected, ['a', 'b/g'], state, ['b/g'])
 
2149
        self.assertBisectRecursive(expected, [b'a', b'b/g'], state, [b'a'])
 
2150
        self.assertBisectRecursive(expected, [b'a', b'b/g'], state, [b'b/g'])
2028
2151
        # Looking in the containing directory should find the rename target,
2029
2152
        # and anything in a subdir of the renamed target.
2030
 
        self.assertBisectRecursive(expected, ['a', 'b', 'b/c', 'b/d',
2031
 
                                              'b/d/e', 'b/g', 'h', 'h/e'],
2032
 
                                   state, ['b'])
 
2153
        self.assertBisectRecursive(expected, [b'a', b'b', b'b/c', b'b/d',
 
2154
                                              b'b/d/e', b'b/g', b'h', b'h/e'],
 
2155
                                   state, [b'b'])
2033
2156
 
2034
2157
 
2035
2158
class TestDirstateValidation(TestCaseWithDirState):
2052
2175
        # we're appending to the dirblock, but this name comes before some of
2053
2176
        # the existing names; that's wrong
2054
2177
        last_dirblock[1].append(
2055
 
            (('h', 'aaaa', 'a-id'),
2056
 
             [('a', '', 0, False, ''),
2057
 
              ('a', '', 0, False, '')]))
 
2178
            ((b'h', b'aaaa', b'a-id'),
 
2179
             [(b'a', b'', 0, False, b''),
 
2180
              (b'a', b'', 0, False, b'')]))
2058
2181
        e = self.assertRaises(AssertionError,
2059
2182
            state._validate)
2060
2183
        self.assertContainsRe(str(e), 'not sorted')
2065
2188
        last_dirblock = state._dirblocks[-1]
2066
2189
        # add an entry with the wrong directory name
2067
2190
        last_dirblock[1].append(
2068
 
            (('', 'z', 'a-id'),
2069
 
             [('a', '', 0, False, ''),
2070
 
              ('a', '', 0, False, '')]))
 
2191
            ((b'', b'z', b'a-id'),
 
2192
             [(b'a', b'', 0, False, b''),
 
2193
              (b'a', b'', 0, False, b'')]))
2071
2194
        e = self.assertRaises(AssertionError,
2072
2195
            state._validate)
2073
2196
        self.assertContainsRe(str(e),
2080
2203
        # make another entry for a-id, without a correct 'r' pointer to
2081
2204
        # the real occurrence in the working tree
2082
2205
        last_dirblock[1].append(
2083
 
            (('h', 'z', 'a-id'),
2084
 
             [('a', '', 0, False, ''),
2085
 
              ('a', '', 0, False, '')]))
 
2206
            ((b'h', b'z', b'a-id'),
 
2207
             [(b'a', b'', 0, False, b''),
 
2208
              (b'a', b'', 0, False, b'')]))
2086
2209
        e = self.assertRaises(AssertionError,
2087
2210
            state._validate)
2088
2211
        self.assertContainsRe(str(e),
2092
2215
class TestDirstateTreeReference(TestCaseWithDirState):
2093
2216
 
2094
2217
    def test_reference_revision_is_none(self):
2095
 
        tree = self.make_branch_and_tree('tree', format='dirstate-with-subtree')
 
2218
        tree = self.make_branch_and_tree('tree', format='development-subtree')
2096
2219
        subtree = self.make_branch_and_tree('tree/subtree',
2097
 
                            format='dirstate-with-subtree')
2098
 
        subtree.set_root_id('subtree')
 
2220
                            format='development-subtree')
 
2221
        subtree.set_root_id(b'subtree')
2099
2222
        tree.add_reference(subtree)
2100
2223
        tree.add('subtree')
2101
2224
        state = dirstate.DirState.from_tree(tree, 'dirstate')
2102
 
        key = ('', 'subtree', 'subtree')
2103
 
        expected = ('', [(key,
2104
 
            [('t', '', 0, False, 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])])
 
2225
        key = (b'', b'subtree', b'subtree')
 
2226
        expected = (b'', [(key,
 
2227
            [(b't', b'', 0, False, b'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])])
2105
2228
 
2106
2229
        try:
2107
2230
            self.assertEqual(expected, state._find_block(key))
2120
2243
 
2121
2244
    def test_discard_one_parent(self):
2122
2245
        # No-op
2123
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2124
 
        root_entry_direntry = ('', '', 'a-root-value'), [
2125
 
            ('d', '', 0, False, packed_stat),
2126
 
            ('d', '', 0, False, packed_stat),
 
2246
        packed_stat = b'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
 
2247
        root_entry_direntry = (b'', b'', b'a-root-value'), [
 
2248
            (b'd', b'', 0, False, packed_stat),
 
2249
            (b'd', b'', 0, False, packed_stat),
2127
2250
            ]
2128
2251
        dirblocks = []
2129
 
        dirblocks.append(('', [root_entry_direntry]))
2130
 
        dirblocks.append(('', []))
 
2252
        dirblocks.append((b'', [root_entry_direntry]))
 
2253
        dirblocks.append((b'', []))
2131
2254
 
2132
2255
        state = self.create_empty_dirstate()
2133
2256
        self.addCleanup(state.unlock)
2134
 
        state._set_data(['parent-id'], dirblocks[:])
 
2257
        state._set_data([b'parent-id'], dirblocks[:])
2135
2258
        state._validate()
2136
2259
 
2137
2260
        state._discard_merge_parents()
2140
2263
 
2141
2264
    def test_discard_simple(self):
2142
2265
        # No-op
2143
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2144
 
        root_entry_direntry = ('', '', 'a-root-value'), [
2145
 
            ('d', '', 0, False, packed_stat),
2146
 
            ('d', '', 0, False, packed_stat),
2147
 
            ('d', '', 0, False, packed_stat),
 
2266
        packed_stat = b'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
 
2267
        root_entry_direntry = (b'', b'', b'a-root-value'), [
 
2268
            (b'd', b'', 0, False, packed_stat),
 
2269
            (b'd', b'', 0, False, packed_stat),
 
2270
            (b'd', b'', 0, False, packed_stat),
2148
2271
            ]
2149
 
        expected_root_entry_direntry = ('', '', 'a-root-value'), [
2150
 
            ('d', '', 0, False, packed_stat),
2151
 
            ('d', '', 0, False, packed_stat),
 
2272
        expected_root_entry_direntry = (b'', b'', b'a-root-value'), [
 
2273
            (b'd', b'', 0, False, packed_stat),
 
2274
            (b'd', b'', 0, False, packed_stat),
2152
2275
            ]
2153
2276
        dirblocks = []
2154
 
        dirblocks.append(('', [root_entry_direntry]))
2155
 
        dirblocks.append(('', []))
 
2277
        dirblocks.append((b'', [root_entry_direntry]))
 
2278
        dirblocks.append((b'', []))
2156
2279
 
2157
2280
        state = self.create_empty_dirstate()
2158
2281
        self.addCleanup(state.unlock)
2159
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
 
2282
        state._set_data([b'parent-id', b'merged-id'], dirblocks[:])
2160
2283
        state._validate()
2161
2284
 
2162
2285
        # This should strip of the extra column
2163
2286
        state._discard_merge_parents()
2164
2287
        state._validate()
2165
 
        expected_dirblocks = [('', [expected_root_entry_direntry]), ('', [])]
 
2288
        expected_dirblocks = [(b'', [expected_root_entry_direntry]), (b'', [])]
2166
2289
        self.assertEqual(expected_dirblocks, state._dirblocks)
2167
2290
 
2168
2291
    def test_discard_absent(self):
2169
2292
        """If entries are only in a merge, discard should remove the entries"""
2170
2293
        null_stat = dirstate.DirState.NULLSTAT
2171
 
        present_dir = ('d', '', 0, False, null_stat)
2172
 
        present_file = ('f', '', 0, False, null_stat)
 
2294
        present_dir = (b'd', b'', 0, False, null_stat)
 
2295
        present_file = (b'f', b'', 0, False, null_stat)
2173
2296
        absent = dirstate.DirState.NULL_PARENT_DETAILS
2174
 
        root_key = ('', '', 'a-root-value')
2175
 
        file_in_root_key = ('', 'file-in-root', 'a-file-id')
2176
 
        file_in_merged_key = ('', 'file-in-merged', 'b-file-id')
2177
 
        dirblocks = [('', [(root_key, [present_dir, present_dir, present_dir])]),
2178
 
                     ('', [(file_in_merged_key,
 
2297
        root_key = (b'', b'', b'a-root-value')
 
2298
        file_in_root_key = (b'', b'file-in-root', b'a-file-id')
 
2299
        file_in_merged_key = (b'', b'file-in-merged', b'b-file-id')
 
2300
        dirblocks = [(b'', [(root_key, [present_dir, present_dir, present_dir])]),
 
2301
                     (b'', [(file_in_merged_key,
2179
2302
                            [absent, absent, present_file]),
2180
2303
                           (file_in_root_key,
2181
2304
                            [present_file, present_file, present_file]),
2184
2307
 
2185
2308
        state = self.create_empty_dirstate()
2186
2309
        self.addCleanup(state.unlock)
2187
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
 
2310
        state._set_data([b'parent-id', b'merged-id'], dirblocks[:])
2188
2311
        state._validate()
2189
2312
 
2190
 
        exp_dirblocks = [('', [(root_key, [present_dir, present_dir])]),
2191
 
                         ('', [(file_in_root_key,
 
2313
        exp_dirblocks = [(b'', [(root_key, [present_dir, present_dir])]),
 
2314
                         (b'', [(file_in_root_key,
2192
2315
                                [present_file, present_file]),
2193
2316
                              ]),
2194
2317
                        ]
2198
2321
 
2199
2322
    def test_discard_renamed(self):
2200
2323
        null_stat = dirstate.DirState.NULLSTAT
2201
 
        present_dir = ('d', '', 0, False, null_stat)
2202
 
        present_file = ('f', '', 0, False, null_stat)
 
2324
        present_dir = (b'd', b'', 0, False, null_stat)
 
2325
        present_file = (b'f', b'', 0, False, null_stat)
2203
2326
        absent = dirstate.DirState.NULL_PARENT_DETAILS
2204
 
        root_key = ('', '', 'a-root-value')
2205
 
        file_in_root_key = ('', 'file-in-root', 'a-file-id')
 
2327
        root_key = (b'', b'', b'a-root-value')
 
2328
        file_in_root_key = (b'', b'file-in-root', b'a-file-id')
2206
2329
        # Renamed relative to parent
2207
 
        file_rename_s_key = ('', 'file-s', 'b-file-id')
2208
 
        file_rename_t_key = ('', 'file-t', 'b-file-id')
 
2330
        file_rename_s_key = (b'', b'file-s', b'b-file-id')
 
2331
        file_rename_t_key = (b'', b'file-t', b'b-file-id')
2209
2332
        # And one that is renamed between the parents, but absent in this
2210
 
        key_in_1 = ('', 'file-in-1', 'c-file-id')
2211
 
        key_in_2 = ('', 'file-in-2', 'c-file-id')
 
2333
        key_in_1 = (b'', b'file-in-1', b'c-file-id')
 
2334
        key_in_2 = (b'', b'file-in-2', b'c-file-id')
2212
2335
 
2213
2336
        dirblocks = [
2214
 
            ('', [(root_key, [present_dir, present_dir, present_dir])]),
2215
 
            ('', [(key_in_1,
2216
 
                   [absent, present_file, ('r', 'file-in-2', 'c-file-id')]),
 
2337
            (b'', [(root_key, [present_dir, present_dir, present_dir])]),
 
2338
            (b'', [(key_in_1,
 
2339
                   [absent, present_file, (b'r', b'file-in-2', b'c-file-id')]),
2217
2340
                  (key_in_2,
2218
 
                   [absent, ('r', 'file-in-1', 'c-file-id'), present_file]),
 
2341
                   [absent, (b'r', b'file-in-1', b'c-file-id'), present_file]),
2219
2342
                  (file_in_root_key,
2220
2343
                   [present_file, present_file, present_file]),
2221
2344
                  (file_rename_s_key,
2222
 
                   [('r', 'file-t', 'b-file-id'), absent, present_file]),
 
2345
                   [(b'r', b'file-t', b'b-file-id'), absent, present_file]),
2223
2346
                  (file_rename_t_key,
2224
 
                   [present_file, absent, ('r', 'file-s', 'b-file-id')]),
 
2347
                   [present_file, absent, (b'r', b'file-s', b'b-file-id')]),
2225
2348
                 ]),
2226
2349
        ]
2227
2350
        exp_dirblocks = [
2228
 
            ('', [(root_key, [present_dir, present_dir])]),
2229
 
            ('', [(key_in_1, [absent, present_file]),
 
2351
            (b'', [(root_key, [present_dir, present_dir])]),
 
2352
            (b'', [(key_in_1, [absent, present_file]),
2230
2353
                  (file_in_root_key, [present_file, present_file]),
2231
2354
                  (file_rename_t_key, [present_file, absent]),
2232
2355
                 ]),
2233
2356
        ]
2234
2357
        state = self.create_empty_dirstate()
2235
2358
        self.addCleanup(state.unlock)
2236
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
 
2359
        state._set_data([b'parent-id', b'merged-id'], dirblocks[:])
2237
2360
        state._validate()
2238
2361
 
2239
2362
        state._discard_merge_parents()
2242
2365
 
2243
2366
    def test_discard_all_subdir(self):
2244
2367
        null_stat = dirstate.DirState.NULLSTAT
2245
 
        present_dir = ('d', '', 0, False, null_stat)
2246
 
        present_file = ('f', '', 0, False, null_stat)
 
2368
        present_dir = (b'd', b'', 0, False, null_stat)
 
2369
        present_file = (b'f', b'', 0, False, null_stat)
2247
2370
        absent = dirstate.DirState.NULL_PARENT_DETAILS
2248
 
        root_key = ('', '', 'a-root-value')
2249
 
        subdir_key = ('', 'sub', 'dir-id')
2250
 
        child1_key = ('sub', 'child1', 'child1-id')
2251
 
        child2_key = ('sub', 'child2', 'child2-id')
2252
 
        child3_key = ('sub', 'child3', 'child3-id')
 
2371
        root_key = (b'', b'', b'a-root-value')
 
2372
        subdir_key = (b'', b'sub', b'dir-id')
 
2373
        child1_key = (b'sub', b'child1', b'child1-id')
 
2374
        child2_key = (b'sub', b'child2', b'child2-id')
 
2375
        child3_key = (b'sub', b'child3', b'child3-id')
2253
2376
 
2254
2377
        dirblocks = [
2255
 
            ('', [(root_key, [present_dir, present_dir, present_dir])]),
2256
 
            ('', [(subdir_key, [present_dir, present_dir, present_dir])]),
2257
 
            ('sub', [(child1_key, [absent, absent, present_file]),
 
2378
            (b'', [(root_key, [present_dir, present_dir, present_dir])]),
 
2379
            (b'', [(subdir_key, [present_dir, present_dir, present_dir])]),
 
2380
            (b'sub', [(child1_key, [absent, absent, present_file]),
2258
2381
                     (child2_key, [absent, absent, present_file]),
2259
2382
                     (child3_key, [absent, absent, present_file]),
2260
2383
                    ]),
2261
2384
        ]
2262
2385
        exp_dirblocks = [
2263
 
            ('', [(root_key, [present_dir, present_dir])]),
2264
 
            ('', [(subdir_key, [present_dir, present_dir])]),
2265
 
            ('sub', []),
 
2386
            (b'', [(root_key, [present_dir, present_dir])]),
 
2387
            (b'', [(subdir_key, [present_dir, present_dir])]),
 
2388
            (b'sub', []),
2266
2389
        ]
2267
2390
        state = self.create_empty_dirstate()
2268
2391
        self.addCleanup(state.unlock)
2269
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
 
2392
        state._set_data([b'parent-id', b'merged-id'], dirblocks[:])
2270
2393
        state._validate()
2271
2394
 
2272
2395
        state._discard_merge_parents()
2282
2405
        # details should always allow join() and always be a plain str when
2283
2406
        # finished
2284
2407
        (minikind, fingerprint, size, executable, tree_data) = details
2285
 
        self.assertIsInstance(minikind, str)
2286
 
        self.assertIsInstance(fingerprint, str)
2287
 
        self.assertIsInstance(tree_data, str)
 
2408
        self.assertIsInstance(minikind, bytes)
 
2409
        self.assertIsInstance(fingerprint, bytes)
 
2410
        self.assertIsInstance(tree_data, bytes)
2288
2411
 
2289
2412
    def test_unicode_symlink(self):
2290
 
        inv_entry = inventory.InventoryLink('link-file-id',
 
2413
        inv_entry = inventory.InventoryLink(b'link-file-id',
2291
2414
                                            u'nam\N{Euro Sign}e',
2292
 
                                            'link-parent-id')
2293
 
        inv_entry.revision = 'link-revision-id'
 
2415
                                            b'link-parent-id')
 
2416
        inv_entry.revision = b'link-revision-id'
2294
2417
        target = u'link-targ\N{Euro Sign}t'
2295
2418
        inv_entry.symlink_target = target
2296
 
        self.assertDetails(('l', target.encode('UTF-8'), 0, False,
2297
 
                            'link-revision-id'), inv_entry)
 
2419
        self.assertDetails((b'l', target.encode('UTF-8'), 0, False,
 
2420
                            b'link-revision-id'), inv_entry)
2298
2421
 
2299
2422
 
2300
2423
class TestSHA1Provider(tests.TestCaseInTempDir):
2305
2428
        self.assertRaises(NotImplementedError, p.stat_and_sha1, "foo")
2306
2429
 
2307
2430
    def test_defaultsha1provider_sha1(self):
2308
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
 
2431
        text = b'test\r\nwith\nall\rpossible line endings\r\n'
2309
2432
        self.build_tree_contents([('foo', text)])
2310
2433
        expected_sha = osutils.sha_string(text)
2311
2434
        p = dirstate.DefaultSHA1Provider()
2312
2435
        self.assertEqual(expected_sha, p.sha1('foo'))
2313
2436
 
2314
2437
    def test_defaultsha1provider_stat_and_sha1(self):
2315
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
 
2438
        text = b'test\r\nwith\nall\rpossible line endings\r\n'
2316
2439
        self.build_tree_contents([('foo', text)])
2317
2440
        expected_sha = osutils.sha_string(text)
2318
2441
        p = dirstate.DefaultSHA1Provider()
2320
2443
        self.assertTrue(len(statvalue) >= 10)
2321
2444
        self.assertEqual(len(text), statvalue.st_size)
2322
2445
        self.assertEqual(expected_sha, sha1)
 
2446
 
 
2447
 
 
2448
class _Repo(object):
 
2449
    """A minimal api to get InventoryRevisionTree to work."""
 
2450
 
 
2451
    def __init__(self):
 
2452
        default_format = controldir.format_registry.make_controldir('default')
 
2453
        self._format = default_format.repository_format
 
2454
 
 
2455
    def lock_read(self):
 
2456
        pass
 
2457
 
 
2458
    def unlock(self):
 
2459
        pass
 
2460
 
 
2461
 
 
2462
class TestUpdateBasisByDelta(tests.TestCase):
 
2463
 
 
2464
    def path_to_ie(self, path, file_id, rev_id, dir_ids):
 
2465
        if path.endswith('/'):
 
2466
            is_dir = True
 
2467
            path = path[:-1]
 
2468
        else:
 
2469
            is_dir = False
 
2470
        dirname, basename = osutils.split(path)
 
2471
        try:
 
2472
            dir_id = dir_ids[dirname]
 
2473
        except KeyError:
 
2474
            dir_id = osutils.basename(dirname).encode('utf-8') + b'-id'
 
2475
        if is_dir:
 
2476
            ie = inventory.InventoryDirectory(file_id, basename, dir_id)
 
2477
            dir_ids[path] = file_id
 
2478
        else:
 
2479
            ie = inventory.InventoryFile(file_id, basename, dir_id)
 
2480
            ie.text_size = 0
 
2481
            ie.text_sha1 = b''
 
2482
        ie.revision = rev_id
 
2483
        return ie
 
2484
 
 
2485
    def create_tree_from_shape(self, rev_id, shape):
 
2486
        dir_ids = {'': b'root-id'}
 
2487
        inv = inventory.Inventory(b'root-id', rev_id)
 
2488
        for info in shape:
 
2489
            if len(info) == 2:
 
2490
                path, file_id = info
 
2491
                ie_rev_id = rev_id
 
2492
            else:
 
2493
                path, file_id, ie_rev_id = info
 
2494
            if path == '':
 
2495
                # Replace the root entry
 
2496
                del inv._byid[inv.root.file_id]
 
2497
                inv.root.file_id = file_id
 
2498
                inv._byid[file_id] = inv.root
 
2499
                dir_ids[''] = file_id
 
2500
                continue
 
2501
            inv.add(self.path_to_ie(path, file_id, ie_rev_id, dir_ids))
 
2502
        return inventorytree.InventoryRevisionTree(_Repo(), inv, rev_id)
 
2503
 
 
2504
    def create_empty_dirstate(self):
 
2505
        fd, path = tempfile.mkstemp(prefix='bzr-dirstate')
 
2506
        self.addCleanup(os.remove, path)
 
2507
        os.close(fd)
 
2508
        state = dirstate.DirState.initialize(path)
 
2509
        self.addCleanup(state.unlock)
 
2510
        return state
 
2511
 
 
2512
    def create_inv_delta(self, delta, rev_id):
 
2513
        """Translate a 'delta shape' into an actual InventoryDelta"""
 
2514
        dir_ids = {'': b'root-id'}
 
2515
        inv_delta = []
 
2516
        for old_path, new_path, file_id in delta:
 
2517
            if old_path is not None and old_path.endswith('/'):
 
2518
                # Don't have to actually do anything for this, because only
 
2519
                # new_path creates InventoryEntries
 
2520
                old_path = old_path[:-1]
 
2521
            if new_path is None: # Delete
 
2522
                inv_delta.append((old_path, None, file_id, None))
 
2523
                continue
 
2524
            ie = self.path_to_ie(new_path, file_id, rev_id, dir_ids)
 
2525
            inv_delta.append((old_path, new_path, file_id, ie))
 
2526
        return inv_delta
 
2527
 
 
2528
    def assertUpdate(self, active, basis, target):
 
2529
        """Assert that update_basis_by_delta works how we want.
 
2530
 
 
2531
        Set up a DirState object with active_shape for tree 0, basis_shape for
 
2532
        tree 1. Then apply the delta from basis_shape to target_shape,
 
2533
        and assert that the DirState is still valid, and that its stored
 
2534
        content matches the target_shape.
 
2535
        """
 
2536
        active_tree = self.create_tree_from_shape(b'active', active)
 
2537
        basis_tree = self.create_tree_from_shape(b'basis', basis)
 
2538
        target_tree = self.create_tree_from_shape(b'target', target)
 
2539
        state = self.create_empty_dirstate()
 
2540
        state.set_state_from_scratch(active_tree.root_inventory,
 
2541
            [(b'basis', basis_tree)], [])
 
2542
        delta = target_tree.root_inventory._make_delta(
 
2543
            basis_tree.root_inventory)
 
2544
        state.update_basis_by_delta(delta, b'target')
 
2545
        state._validate()
 
2546
        dirstate_tree = workingtree_4.DirStateRevisionTree(state,
 
2547
            b'target', _Repo())
 
2548
        # The target now that delta has been applied should match the
 
2549
        # RevisionTree
 
2550
        self.assertEqual([], list(dirstate_tree.iter_changes(target_tree)))
 
2551
        # And the dirblock state should be identical to the state if we created
 
2552
        # it from scratch.
 
2553
        state2 = self.create_empty_dirstate()
 
2554
        state2.set_state_from_scratch(active_tree.root_inventory,
 
2555
            [(b'target', target_tree)], [])
 
2556
        self.assertEqual(state2._dirblocks, state._dirblocks)
 
2557
        return state
 
2558
 
 
2559
    def assertBadDelta(self, active, basis, delta):
 
2560
        """Test that we raise InconsistentDelta when appropriate.
 
2561
 
 
2562
        :param active: The active tree shape
 
2563
        :param basis: The basis tree shape
 
2564
        :param delta: A description of the delta to apply. Similar to the form
 
2565
            for regular inventory deltas, but omitting the InventoryEntry.
 
2566
            So adding a file is: (None, 'path', b'file-id')
 
2567
            Adding a directory is: (None, 'path/', b'dir-id')
 
2568
            Renaming a dir is: ('old/', 'new/', b'dir-id')
 
2569
            etc.
 
2570
        """
 
2571
        active_tree = self.create_tree_from_shape(b'active', active)
 
2572
        basis_tree = self.create_tree_from_shape(b'basis', basis)
 
2573
        inv_delta = self.create_inv_delta(delta, b'target')
 
2574
        state = self.create_empty_dirstate()
 
2575
        state.set_state_from_scratch(active_tree.root_inventory,
 
2576
            [(b'basis', basis_tree)], [])
 
2577
        self.assertRaises(errors.InconsistentDelta,
 
2578
            state.update_basis_by_delta, inv_delta, b'target')
 
2579
        ## try:
 
2580
        ##     state.update_basis_by_delta(inv_delta, b'target')
 
2581
        ## except errors.InconsistentDelta, e:
 
2582
        ##     import pdb; pdb.set_trace()
 
2583
        ## else:
 
2584
        ##     import pdb; pdb.set_trace()
 
2585
        self.assertTrue(state._changes_aborted)
 
2586
 
 
2587
    def test_remove_file_matching_active_state(self):
 
2588
        state = self.assertUpdate(
 
2589
            active=[],
 
2590
            basis =[('file', b'file-id')],
 
2591
            target=[],
 
2592
            )
 
2593
 
 
2594
    def test_remove_file_present_in_active_state(self):
 
2595
        state = self.assertUpdate(
 
2596
            active=[('file', b'file-id')],
 
2597
            basis =[('file', b'file-id')],
 
2598
            target=[],
 
2599
            )
 
2600
 
 
2601
    def test_remove_file_present_elsewhere_in_active_state(self):
 
2602
        state = self.assertUpdate(
 
2603
            active=[('other-file', b'file-id')],
 
2604
            basis =[('file', b'file-id')],
 
2605
            target=[],
 
2606
            )
 
2607
 
 
2608
    def test_remove_file_active_state_has_diff_file(self):
 
2609
        state = self.assertUpdate(
 
2610
            active=[('file', b'file-id-2')],
 
2611
            basis =[('file', b'file-id')],
 
2612
            target=[],
 
2613
            )
 
2614
 
 
2615
    def test_remove_file_active_state_has_diff_file_and_file_elsewhere(self):
 
2616
        state = self.assertUpdate(
 
2617
            active=[('file', b'file-id-2'),
 
2618
                    ('other-file', b'file-id')],
 
2619
            basis =[('file', b'file-id')],
 
2620
            target=[],
 
2621
            )
 
2622
 
 
2623
    def test_add_file_matching_active_state(self):
 
2624
        state = self.assertUpdate(
 
2625
            active=[('file', b'file-id')],
 
2626
            basis =[],
 
2627
            target=[('file', b'file-id')],
 
2628
            )
 
2629
 
 
2630
    def test_add_file_in_empty_dir_not_matching_active_state(self):
 
2631
        state = self.assertUpdate(
 
2632
                active=[],
 
2633
                basis=[('dir/', b'dir-id')],
 
2634
                target=[('dir/', b'dir-id', b'basis'), ('dir/file', b'file-id')],
 
2635
                )
 
2636
 
 
2637
    def test_add_file_missing_in_active_state(self):
 
2638
        state = self.assertUpdate(
 
2639
            active=[],
 
2640
            basis =[],
 
2641
            target=[('file', b'file-id')],
 
2642
            )
 
2643
 
 
2644
    def test_add_file_elsewhere_in_active_state(self):
 
2645
        state = self.assertUpdate(
 
2646
            active=[('other-file', b'file-id')],
 
2647
            basis =[],
 
2648
            target=[('file', b'file-id')],
 
2649
            )
 
2650
 
 
2651
    def test_add_file_active_state_has_diff_file_and_file_elsewhere(self):
 
2652
        state = self.assertUpdate(
 
2653
            active=[('other-file', b'file-id'),
 
2654
                    ('file', b'file-id-2')],
 
2655
            basis =[],
 
2656
            target=[('file', b'file-id')],
 
2657
            )
 
2658
 
 
2659
    def test_rename_file_matching_active_state(self):
 
2660
        state = self.assertUpdate(
 
2661
            active=[('other-file', b'file-id')],
 
2662
            basis =[('file', b'file-id')],
 
2663
            target=[('other-file', b'file-id')],
 
2664
            )
 
2665
 
 
2666
    def test_rename_file_missing_in_active_state(self):
 
2667
        state = self.assertUpdate(
 
2668
            active=[],
 
2669
            basis =[('file', b'file-id')],
 
2670
            target=[('other-file', b'file-id')],
 
2671
            )
 
2672
 
 
2673
    def test_rename_file_present_elsewhere_in_active_state(self):
 
2674
        state = self.assertUpdate(
 
2675
            active=[('third', b'file-id')],
 
2676
            basis =[('file', b'file-id')],
 
2677
            target=[('other-file', b'file-id')],
 
2678
            )
 
2679
 
 
2680
    def test_rename_file_active_state_has_diff_source_file(self):
 
2681
        state = self.assertUpdate(
 
2682
            active=[('file', b'file-id-2')],
 
2683
            basis =[('file', b'file-id')],
 
2684
            target=[('other-file', b'file-id')],
 
2685
            )
 
2686
 
 
2687
    def test_rename_file_active_state_has_diff_target_file(self):
 
2688
        state = self.assertUpdate(
 
2689
            active=[('other-file', b'file-id-2')],
 
2690
            basis =[('file', b'file-id')],
 
2691
            target=[('other-file', b'file-id')],
 
2692
            )
 
2693
 
 
2694
    def test_rename_file_active_has_swapped_files(self):
 
2695
        state = self.assertUpdate(
 
2696
            active=[('file', b'file-id'),
 
2697
                    ('other-file', b'file-id-2')],
 
2698
            basis= [('file', b'file-id'),
 
2699
                    ('other-file', b'file-id-2')],
 
2700
            target=[('file', b'file-id-2'),
 
2701
                    ('other-file', b'file-id')])
 
2702
 
 
2703
    def test_rename_file_basis_has_swapped_files(self):
 
2704
        state = self.assertUpdate(
 
2705
            active=[('file', b'file-id'),
 
2706
                    ('other-file', b'file-id-2')],
 
2707
            basis= [('file', b'file-id-2'),
 
2708
                    ('other-file', b'file-id')],
 
2709
            target=[('file', b'file-id'),
 
2710
                    ('other-file', b'file-id-2')])
 
2711
 
 
2712
    def test_rename_directory_with_contents(self):
 
2713
        state = self.assertUpdate( # active matches basis
 
2714
            active=[('dir1/', b'dir-id'),
 
2715
                    ('dir1/file', b'file-id')],
 
2716
            basis= [('dir1/', b'dir-id'),
 
2717
                    ('dir1/file', b'file-id')],
 
2718
            target=[('dir2/', b'dir-id'),
 
2719
                    ('dir2/file', b'file-id')])
 
2720
        state = self.assertUpdate( # active matches target
 
2721
            active=[('dir2/', b'dir-id'),
 
2722
                    ('dir2/file', b'file-id')],
 
2723
            basis= [('dir1/', b'dir-id'),
 
2724
                    ('dir1/file', b'file-id')],
 
2725
            target=[('dir2/', b'dir-id'),
 
2726
                    ('dir2/file', b'file-id')])
 
2727
        state = self.assertUpdate( # active empty
 
2728
            active=[],
 
2729
            basis= [('dir1/', b'dir-id'),
 
2730
                    ('dir1/file', b'file-id')],
 
2731
            target=[('dir2/', b'dir-id'),
 
2732
                    ('dir2/file', b'file-id')])
 
2733
        state = self.assertUpdate( # active present at other location
 
2734
            active=[('dir3/', b'dir-id'),
 
2735
                    ('dir3/file', b'file-id')],
 
2736
            basis= [('dir1/', b'dir-id'),
 
2737
                    ('dir1/file', b'file-id')],
 
2738
            target=[('dir2/', b'dir-id'),
 
2739
                    ('dir2/file', b'file-id')])
 
2740
        state = self.assertUpdate( # active has different ids
 
2741
            active=[('dir1/', b'dir1-id'),
 
2742
                    ('dir1/file', b'file1-id'),
 
2743
                    ('dir2/', b'dir2-id'),
 
2744
                    ('dir2/file', b'file2-id')],
 
2745
            basis= [('dir1/', b'dir-id'),
 
2746
                    ('dir1/file', b'file-id')],
 
2747
            target=[('dir2/', b'dir-id'),
 
2748
                    ('dir2/file', b'file-id')])
 
2749
 
 
2750
    def test_invalid_file_not_present(self):
 
2751
        state = self.assertBadDelta(
 
2752
            active=[('file', b'file-id')],
 
2753
            basis= [('file', b'file-id')],
 
2754
            delta=[('other-file', 'file', b'file-id')])
 
2755
 
 
2756
    def test_invalid_new_id_same_path(self):
 
2757
        # The bad entry comes after
 
2758
        state = self.assertBadDelta(
 
2759
            active=[('file', b'file-id')],
 
2760
            basis= [('file', b'file-id')],
 
2761
            delta=[(None, 'file', b'file-id-2')])
 
2762
        # The bad entry comes first
 
2763
        state = self.assertBadDelta(
 
2764
            active=[('file', b'file-id-2')],
 
2765
            basis=[('file', b'file-id-2')],
 
2766
            delta=[(None, 'file', b'file-id')])
 
2767
 
 
2768
    def test_invalid_existing_id(self):
 
2769
        state = self.assertBadDelta(
 
2770
            active=[('file', b'file-id')],
 
2771
            basis= [('file', b'file-id')],
 
2772
            delta=[(None, 'file', b'file-id')])
 
2773
 
 
2774
    def test_invalid_parent_missing(self):
 
2775
        state = self.assertBadDelta(
 
2776
            active=[],
 
2777
            basis= [],
 
2778
            delta=[(None, 'path/path2', b'file-id')])
 
2779
        # Note: we force the active tree to have the directory, by knowing how
 
2780
        #       path_to_ie handles entries with missing parents
 
2781
        state = self.assertBadDelta(
 
2782
            active=[('path/', b'path-id')],
 
2783
            basis= [],
 
2784
            delta=[(None, 'path/path2', b'file-id')])
 
2785
        state = self.assertBadDelta(
 
2786
            active=[('path/', b'path-id'),
 
2787
                    ('path/path2', b'file-id')],
 
2788
            basis= [],
 
2789
            delta=[(None, 'path/path2', b'file-id')])
 
2790
 
 
2791
    def test_renamed_dir_same_path(self):
 
2792
        # We replace the parent directory, with another parent dir. But the C
 
2793
        # file doesn't look like it has been moved.
 
2794
        state = self.assertUpdate(# Same as basis
 
2795
            active=[('dir/', b'A-id'),
 
2796
                    ('dir/B', b'B-id')],
 
2797
            basis= [('dir/', b'A-id'),
 
2798
                    ('dir/B', b'B-id')],
 
2799
            target=[('dir/', b'C-id'),
 
2800
                    ('dir/B', b'B-id')])
 
2801
        state = self.assertUpdate(# Same as target
 
2802
            active=[('dir/', b'C-id'),
 
2803
                    ('dir/B', b'B-id')],
 
2804
            basis= [('dir/', b'A-id'),
 
2805
                    ('dir/B', b'B-id')],
 
2806
            target=[('dir/', b'C-id'),
 
2807
                    ('dir/B', b'B-id')])
 
2808
        state = self.assertUpdate(# empty active
 
2809
            active=[],
 
2810
            basis= [('dir/', b'A-id'),
 
2811
                    ('dir/B', b'B-id')],
 
2812
            target=[('dir/', b'C-id'),
 
2813
                    ('dir/B', b'B-id')])
 
2814
        state = self.assertUpdate(# different active
 
2815
            active=[('dir/', b'D-id'),
 
2816
                    ('dir/B', b'B-id')],
 
2817
            basis= [('dir/', b'A-id'),
 
2818
                    ('dir/B', b'B-id')],
 
2819
            target=[('dir/', b'C-id'),
 
2820
                    ('dir/B', b'B-id')])
 
2821
 
 
2822
    def test_parent_child_swap(self):
 
2823
        state = self.assertUpdate(# Same as basis
 
2824
            active=[('A/', b'A-id'),
 
2825
                    ('A/B/', b'B-id'),
 
2826
                    ('A/B/C', b'C-id')],
 
2827
            basis= [('A/', b'A-id'),
 
2828
                    ('A/B/', b'B-id'),
 
2829
                    ('A/B/C', b'C-id')],
 
2830
            target=[('A/', b'B-id'),
 
2831
                    ('A/B/', b'A-id'),
 
2832
                    ('A/B/C', b'C-id')])
 
2833
        state = self.assertUpdate(# Same as target
 
2834
            active=[('A/', b'B-id'),
 
2835
                    ('A/B/', b'A-id'),
 
2836
                    ('A/B/C', b'C-id')],
 
2837
            basis= [('A/', b'A-id'),
 
2838
                    ('A/B/', b'B-id'),
 
2839
                    ('A/B/C', b'C-id')],
 
2840
            target=[('A/', b'B-id'),
 
2841
                    ('A/B/', b'A-id'),
 
2842
                    ('A/B/C', b'C-id')])
 
2843
        state = self.assertUpdate(# empty active
 
2844
            active=[],
 
2845
            basis= [('A/', b'A-id'),
 
2846
                    ('A/B/', b'B-id'),
 
2847
                    ('A/B/C', b'C-id')],
 
2848
            target=[('A/', b'B-id'),
 
2849
                    ('A/B/', b'A-id'),
 
2850
                    ('A/B/C', b'C-id')])
 
2851
        state = self.assertUpdate(# different active
 
2852
            active=[('D/', b'A-id'),
 
2853
                    ('D/E/', b'B-id'),
 
2854
                    ('F', b'C-id')],
 
2855
            basis= [('A/', b'A-id'),
 
2856
                    ('A/B/', b'B-id'),
 
2857
                    ('A/B/C', b'C-id')],
 
2858
            target=[('A/', b'B-id'),
 
2859
                    ('A/B/', b'A-id'),
 
2860
                    ('A/B/C', b'C-id')])
 
2861
 
 
2862
    def test_change_root_id(self):
 
2863
        state = self.assertUpdate( # same as basis
 
2864
            active=[('', b'root-id'),
 
2865
                    ('file', b'file-id')],
 
2866
            basis= [('', b'root-id'),
 
2867
                    ('file', b'file-id')],
 
2868
            target=[('', b'target-root-id'),
 
2869
                    ('file', b'file-id')])
 
2870
        state = self.assertUpdate( # same as target
 
2871
            active=[('', b'target-root-id'),
 
2872
                    ('file', b'file-id')],
 
2873
            basis= [('', b'root-id'),
 
2874
                    ('file', b'file-id')],
 
2875
            target=[('', b'target-root-id'),
 
2876
                    ('file', b'root-id')])
 
2877
        state = self.assertUpdate( # all different
 
2878
            active=[('', b'active-root-id'),
 
2879
                    ('file', b'file-id')],
 
2880
            basis= [('', b'root-id'),
 
2881
                    ('file', b'file-id')],
 
2882
            target=[('', b'target-root-id'),
 
2883
                    ('file', b'root-id')])
 
2884
 
 
2885
    def test_change_file_absent_in_active(self):
 
2886
        state = self.assertUpdate(
 
2887
            active=[],
 
2888
            basis= [('file', b'file-id')],
 
2889
            target=[('file', b'file-id')])
 
2890
 
 
2891
    def test_invalid_changed_file(self):
 
2892
        state = self.assertBadDelta( # Not present in basis
 
2893
            active=[('file', b'file-id')],
 
2894
            basis= [],
 
2895
            delta=[('file', 'file', b'file-id')])
 
2896
        state = self.assertBadDelta( # present at another location in basis
 
2897
            active=[('file', b'file-id')],
 
2898
            basis= [('other-file', b'file-id')],
 
2899
            delta=[('file', 'file', b'file-id')])