/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_dirstate.py

  • Committer: John Arbash Meinel
  • Date: 2007-02-28 21:50:11 UTC
  • mto: (2255.11.3 dirstate)
  • mto: This revision was merged to the branch mainline in revision 2322.
  • Revision ID: john@arbash-meinel.com-20070228215011-hfmfc13mswbubn18
Add tests that the walkdirs variants work on unicode paths.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_dirstate.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests of the dirstate functionality being built for WorkingTreeFormat4."""
18
18
 
22
22
from bzrlib import (
23
23
    dirstate,
24
24
    errors,
25
 
    inventory,
26
 
    memorytree,
27
25
    osutils,
28
 
    revision as _mod_revision,
29
 
    tests,
30
26
    )
31
 
from bzrlib.tests import test_osutils
 
27
from bzrlib.memorytree import MemoryTree
 
28
from bzrlib.tests import TestCase, TestCaseWithTransport
32
29
 
33
30
 
34
31
# TODO:
 
32
# test DirStateRevisionTree : test filtering out of deleted files does not
 
33
#         filter out files called RECYCLED.BIN ;)
 
34
# test 0 parents, 1 parent, 4 parents.
 
35
# test unicode parents, non unicode parents
 
36
# test all change permutations in one and two parents.
 
37
# i.e. file in parent 1, dir in parent 2, symlink in tree.
 
38
# test that renames in the tree result in correct parent paths
 
39
# Test get state from a file, then asking for lines.
 
40
# write a smaller state, and check the file has been truncated.
 
41
# add a entry when its in state deleted
 
42
# revision attribute for root entries.
 
43
# test that utf8 strings are preserved in _row_to_line
 
44
# test parent manipulation
 
45
# test parents that are null in save : i.e. no record in the parent tree for this.
 
46
# todo: _set_data records ghost parents.
35
47
# TESTS to write:
36
48
# general checks for NOT_IN_MEMORY error conditions.
37
49
# set_path_id on a NOT_IN_MEMORY dirstate
43
55
# set_path_id  setting id when state is in memory unmodified
44
56
# set_path_id  setting id when state is in memory modified
45
57
 
46
 
 
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
55
 
 
56
 
 
57
 
class TestCaseWithDirState(tests.TestCaseWithTransport):
 
58
class TestCaseWithDirState(TestCaseWithTransport):
58
59
    """Helper functions for creating DirState objects with various content."""
59
60
 
60
 
    # Set by load_tests
61
 
    _dir_reader_class = None
62
 
    _native_to_unicode = None # Not used yet
63
 
 
64
 
    def setUp(self):
65
 
        tests.TestCaseWithTransport.setUp(self)
66
 
 
67
 
        self.overrideAttr(osutils,
68
 
                          '_selected_dir_reader', self._dir_reader_class())
69
 
 
70
61
    def create_empty_dirstate(self):
71
62
        """Return a locked but empty dirstate"""
72
63
        state = dirstate.DirState.initialize('dirstate')
84
75
        state = self.create_empty_dirstate()
85
76
        try:
86
77
            state._set_data([], dirblocks)
87
 
            state._validate()
88
78
        except:
89
79
            state.unlock()
90
80
            raise
119
109
         b/g      g-file
120
110
         b/h\xc3\xa5  h-\xc3\xa5-file  #This is u'\xe5' encoded into utf-8
121
111
 
122
 
        Notice that a/e is an empty directory.
123
 
 
124
 
        :return: The dirstate, still write-locked.
 
112
        # Notice that a/e is an empty directory.
125
113
        """
126
114
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
127
115
        null_sha = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
158
146
        dirblocks.append(('a', [e_entry, f_entry]))
159
147
        dirblocks.append(('b', [g_entry, h_entry]))
160
148
        state = dirstate.DirState.initialize('dirstate')
161
 
        state._validate()
162
149
        try:
163
150
            state._set_data([], dirblocks)
164
151
        except:
180
167
        """
181
168
        # The state should already be write locked, since we just had to do
182
169
        # some operation to get here.
183
 
        self.assertTrue(state._lock_token is not None)
 
170
        assert state._lock_token is not None
184
171
        try:
185
172
            self.assertEqual(expected_result[0],  state.get_parent_ids())
186
173
            # there should be no ghosts in this tree.
190
177
            state.save()
191
178
        finally:
192
179
            state.unlock()
193
 
        del state
 
180
        del state # Callers should unlock
194
181
        state = dirstate.DirState.on_file('dirstate')
195
182
        state.lock_read()
196
183
        try:
198
185
        finally:
199
186
            state.unlock()
200
187
 
201
 
    def create_basic_dirstate(self):
202
 
        """Create a dirstate with a few files and directories.
203
 
 
204
 
            a
205
 
            b/
206
 
              c
207
 
              d/
208
 
                e
209
 
            b-c
210
 
            f
211
 
        """
212
 
        tree = self.make_branch_and_tree('tree')
213
 
        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']
215
 
        self.build_tree(['tree/' + p for p in paths])
216
 
        tree.set_root_id('TREE_ROOT')
217
 
        tree.add([p.rstrip('/') for p in paths], file_ids)
218
 
        tree.commit('initial', rev_id='rev-1')
219
 
        revision_id = 'rev-1'
220
 
        # a_packed_stat = dirstate.pack_stat(os.stat('tree/a'))
221
 
        t = self.get_transport('tree')
222
 
        a_text = t.get_bytes('a')
223
 
        a_sha = osutils.sha_string(a_text)
224
 
        a_len = len(a_text)
225
 
        # b_packed_stat = dirstate.pack_stat(os.stat('tree/b'))
226
 
        # c_packed_stat = dirstate.pack_stat(os.stat('tree/b/c'))
227
 
        c_text = t.get_bytes('b/c')
228
 
        c_sha = osutils.sha_string(c_text)
229
 
        c_len = len(c_text)
230
 
        # d_packed_stat = dirstate.pack_stat(os.stat('tree/b/d'))
231
 
        # e_packed_stat = dirstate.pack_stat(os.stat('tree/b/d/e'))
232
 
        e_text = t.get_bytes('b/d/e')
233
 
        e_sha = osutils.sha_string(e_text)
234
 
        e_len = len(e_text)
235
 
        b_c_text = t.get_bytes('b-c')
236
 
        b_c_sha = osutils.sha_string(b_c_text)
237
 
        b_c_len = len(b_c_text)
238
 
        # f_packed_stat = dirstate.pack_stat(os.stat('tree/f'))
239
 
        f_text = t.get_bytes('f')
240
 
        f_sha = osutils.sha_string(f_text)
241
 
        f_len = len(f_text)
242
 
        null_stat = dirstate.DirState.NULLSTAT
243
 
        expected = {
244
 
            '':(('', '', 'TREE_ROOT'), [
245
 
                  ('d', '', 0, False, null_stat),
246
 
                  ('d', '', 0, False, revision_id),
247
 
                ]),
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),
275
 
                 ]),
276
 
        }
277
 
        state = dirstate.DirState.from_tree(tree, 'dirstate')
278
 
        try:
279
 
            state.save()
280
 
        finally:
281
 
            state.unlock()
282
 
        # Use a different object, to make sure nothing is pre-cached in memory.
283
 
        state = dirstate.DirState.on_file('dirstate')
284
 
        state.lock_read()
285
 
        self.addCleanup(state.unlock)
286
 
        self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
287
 
                         state._dirblock_state)
288
 
        # This is code is only really tested if we actually have to make more
289
 
        # than one read, so set the page size to something smaller.
290
 
        # We want it to contain about 2.2 records, so that we have a couple
291
 
        # records that we can read per attempt
292
 
        state._bisect_page_size = 200
293
 
        return tree, state, expected
294
 
 
295
 
    def create_duplicated_dirstate(self):
296
 
        """Create a dirstate with a deleted and added entries.
297
 
 
298
 
        This grabs a basic_dirstate, and then removes and re adds every entry
299
 
        with a new file id.
300
 
        """
301
 
        tree, state, expected = self.create_basic_dirstate()
302
 
        # Now we will just remove and add every file so we get an extra entry
303
 
        # 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'])
305
 
        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'])
307
 
 
308
 
        # Update the expected dictionary.
309
 
        for path in ['a', 'b', 'b/c', 'b/d', 'b/d/e', 'b-c', 'f']:
310
 
            orig = expected[path]
311
 
            path2 = path + '2'
312
 
            # This record was deleted in the current tree
313
 
            expected[path] = (orig[0], [dirstate.DirState.NULL_PARENT_DETAILS,
314
 
                                        orig[1][1]])
315
 
            new_key = (orig[0][0], orig[0][1], orig[0][2]+'2')
316
 
            # And didn't exist in the basis tree
317
 
            expected[path2] = (new_key, [orig[1][0],
318
 
                                         dirstate.DirState.NULL_PARENT_DETAILS])
319
 
 
320
 
        # We will replace the 'dirstate' file underneath 'state', but that is
321
 
        # okay as lock as we unlock 'state' first.
322
 
        state.unlock()
323
 
        try:
324
 
            new_state = dirstate.DirState.from_tree(tree, 'dirstate')
325
 
            try:
326
 
                new_state.save()
327
 
            finally:
328
 
                new_state.unlock()
329
 
        finally:
330
 
            # But we need to leave state in a read-lock because we already have
331
 
            # a cleanup scheduled
332
 
            state.lock_read()
333
 
        return tree, state, expected
334
 
 
335
 
    def create_renamed_dirstate(self):
336
 
        """Create a dirstate with a few internal renames.
337
 
 
338
 
        This takes the basic dirstate, and moves the paths around.
339
 
        """
340
 
        tree, state, expected = self.create_basic_dirstate()
341
 
        # Rename a file
342
 
        tree.rename_one('a', 'b/g')
343
 
        # And a directory
344
 
        tree.rename_one('b/d', 'h')
345
 
 
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, '')])
354
 
 
355
 
        old_e = expected['b/d/e']
356
 
        expected['b/d/e'] = (old_e[0], [('r', 'h/e', 0, False, ''),
357
 
                             old_e[1][1]])
358
 
        expected['h/e'] = (('h', 'e', 'e-id'), [old_e[1][0],
359
 
                                                ('r', 'b/d/e', 0, False, '')])
360
 
 
361
 
        state.unlock()
362
 
        try:
363
 
            new_state = dirstate.DirState.from_tree(tree, 'dirstate')
364
 
            try:
365
 
                new_state.save()
366
 
            finally:
367
 
                new_state.unlock()
368
 
        finally:
369
 
            state.lock_read()
370
 
        return tree, state, expected
371
 
 
372
188
 
373
189
class TestTreeToDirState(TestCaseWithDirState):
374
190
 
377
193
        # There are no files on disk and no parents
378
194
        tree = self.make_branch_and_tree('tree')
379
195
        expected_result = ([], [
380
 
            (('', '', tree.get_root_id()), # common details
 
196
            (('', '', tree.path2id('')), # common details
381
197
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
382
198
             ])])
383
199
        state = dirstate.DirState.from_tree(tree, 'dirstate')
384
 
        state._validate()
385
200
        self.check_state_with_reopen(expected_result, state)
386
201
 
387
202
    def test_1_parents_empty_to_dirstate(self):
390
205
        rev_id = tree.commit('first post').encode('utf8')
391
206
        root_stat_pack = dirstate.pack_stat(os.stat(tree.basedir))
392
207
        expected_result = ([rev_id], [
393
 
            (('', '', tree.get_root_id()), # common details
 
208
            (('', '', tree.path2id('')), # common details
394
209
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
395
210
              ('d', '', 0, False, rev_id), # first parent details
396
211
             ])])
397
212
        state = dirstate.DirState.from_tree(tree, 'dirstate')
398
213
        self.check_state_with_reopen(expected_result, state)
399
 
        state.lock_read()
400
 
        try:
401
 
            state._validate()
402
 
        finally:
403
 
            state.unlock()
404
214
 
405
215
    def test_2_parents_empty_to_dirstate(self):
406
216
        # create a parent by doing a commit
410
220
        rev_id2 = tree2.commit('second post', allow_pointless=True)
411
221
        tree.merge_from_branch(tree2.branch)
412
222
        expected_result = ([rev_id, rev_id2], [
413
 
            (('', '', tree.get_root_id()), # common details
 
223
            (('', '', tree.path2id('')), # common details
414
224
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
415
225
              ('d', '', 0, False, rev_id), # first parent details
416
 
              ('d', '', 0, False, rev_id), # second parent details
 
226
              ('d', '', 0, False, rev_id2), # second parent details
417
227
             ])])
418
228
        state = dirstate.DirState.from_tree(tree, 'dirstate')
419
229
        self.check_state_with_reopen(expected_result, state)
420
 
        state.lock_read()
421
 
        try:
422
 
            state._validate()
423
 
        finally:
424
 
            state.unlock()
425
230
 
426
231
    def test_empty_unknowns_are_ignored_to_dirstate(self):
427
232
        """We should be able to create a dirstate for an empty tree."""
429
234
        tree = self.make_branch_and_tree('tree')
430
235
        self.build_tree(['tree/unknown'])
431
236
        expected_result = ([], [
432
 
            (('', '', tree.get_root_id()), # common details
 
237
            (('', '', tree.path2id('')), # common details
433
238
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
434
239
             ])])
435
240
        state = dirstate.DirState.from_tree(tree, 'dirstate')
438
243
    def get_tree_with_a_file(self):
439
244
        tree = self.make_branch_and_tree('tree')
440
245
        self.build_tree(['tree/a file'])
441
 
        tree.add('a file', 'a-file-id')
 
246
        tree.add('a file', 'a file id')
442
247
        return tree
443
248
 
444
249
    def test_non_empty_no_parents_to_dirstate(self):
446
251
        # There are files on disk and no parents
447
252
        tree = self.get_tree_with_a_file()
448
253
        expected_result = ([], [
449
 
            (('', '', tree.get_root_id()), # common details
 
254
            (('', '', tree.path2id('')), # common details
450
255
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
451
256
             ]),
452
 
            (('', 'a file', 'a-file-id'), # common
 
257
            (('', 'a file', 'a file id'), # common
453
258
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
454
259
             ]),
455
260
            ])
464
269
        # and length:
465
270
        self.build_tree_contents([('tree/a file', 'new content\n')])
466
271
        expected_result = ([rev_id], [
467
 
            (('', '', tree.get_root_id()), # common details
 
272
            (('', '', tree.path2id('')), # common details
468
273
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
469
274
              ('d', '', 0, False, rev_id), # first parent details
470
275
             ]),
471
 
            (('', 'a file', 'a-file-id'), # common
 
276
            (('', 'a file', 'a file id'), # common
472
277
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
473
278
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
474
279
               rev_id), # first parent
491
296
        # and length again, giving us three distinct values:
492
297
        self.build_tree_contents([('tree/a file', 'new content\n')])
493
298
        expected_result = ([rev_id, rev_id2], [
494
 
            (('', '', tree.get_root_id()), # common details
 
299
            (('', '', tree.path2id('')), # common details
495
300
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
496
301
              ('d', '', 0, False, rev_id), # first parent details
497
 
              ('d', '', 0, False, rev_id), # second parent details
 
302
              ('d', '', 0, False, rev_id2), # second parent details
498
303
             ]),
499
 
            (('', 'a file', 'a-file-id'), # common
 
304
            (('', 'a file', 'a file id'), # common
500
305
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
501
306
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
502
307
               rev_id), # first parent
507
312
        state = dirstate.DirState.from_tree(tree, 'dirstate')
508
313
        self.check_state_with_reopen(expected_result, state)
509
314
 
510
 
    def test_colliding_fileids(self):
511
 
        # test insertion of parents creating several entries at the same path.
512
 
        # we used to have a bug where they could cause the dirstate to break
513
 
        # its ordering invariants.
514
 
        # create some trees to test from
515
 
        parents = []
516
 
        for i in range(7):
517
 
            tree = self.make_branch_and_tree('tree%d' % i)
518
 
            self.build_tree(['tree%d/name' % i,])
519
 
            tree.add(['name'], ['file-id%d' % i])
520
 
            revision_id = 'revid-%d' % i
521
 
            tree.commit('message', rev_id=revision_id)
522
 
            parents.append((revision_id,
523
 
                tree.branch.repository.revision_tree(revision_id)))
524
 
        # now fold these trees into a dirstate
525
 
        state = dirstate.DirState.initialize('dirstate')
526
 
        try:
527
 
            state.set_parent_trees(parents, [])
528
 
            state._validate()
529
 
        finally:
530
 
            state.unlock()
531
 
 
532
315
 
533
316
class TestDirStateOnFile(TestCaseWithDirState):
534
317
 
543
326
        # get a state object
544
327
        # no parents, default tree content
545
328
        expected_result = ([], [
546
 
            (('', '', tree.get_root_id()), # common details
 
329
            (('', '', tree.path2id('')), # common details
547
330
             # current tree details, but new from_tree skips statting, it
548
331
             # uses set_state_from_inventory, and thus depends on the
549
332
             # inventory state.
565
348
        finally:
566
349
            state.unlock()
567
350
 
568
 
    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')
583
 
            # The current size should be 0 (default)
584
 
            self.assertEqual(0, entry[1][0][2])
585
 
            # We should have a real entry.
586
 
            self.assertNotEqual((None, None), entry)
587
 
            # Make sure everything is old enough
588
 
            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)
596
 
 
597
 
            # The dirblock has been updated
598
 
            self.assertEqual(7, entry[1][0][2])
599
 
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
600
 
                             state._dirblock_state)
601
 
 
602
 
            del entry
603
 
            # Now, since we are the only one holding a lock, we should be able
604
 
            # to save and have it written to disk
605
 
            state.save()
606
 
        finally:
607
 
            state.unlock()
608
 
 
609
 
        # Re-open the file, and ensure that the state has been updated.
610
 
        state = dirstate.DirState.on_file('dirstate')
611
 
        state.lock_read()
612
 
        try:
613
 
            entry = state._get_entry(0, path_utf8='a-file')
614
 
            self.assertEqual(7, entry[1][0][2])
615
 
        finally:
616
 
            state.unlock()
617
 
 
618
 
    def test_save_fails_quietly_if_locked(self):
619
 
        """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,
638
 
                             state._dirblock_state)
639
 
 
640
 
            # Now, before we try to save, grab another dirstate, and take out a
641
 
            # read lock.
642
 
            # TODO: jam 20070315 Ideally this would be locked by another
643
 
            #       process. To make sure the file is really OS locked.
644
 
            state2 = dirstate.DirState.on_file('dirstate')
645
 
            state2.lock_read()
646
 
            try:
647
 
                # This won't actually write anything, because it couldn't grab
648
 
                # a write lock. But it shouldn't raise an error, either.
649
 
                # TODO: jam 20070315 We should probably distinguish between
650
 
                #       being dirty because of 'update_entry'. And dirty
651
 
                #       because of real modification. So that save() *does*
652
 
                #       raise a real error if it fails when we have real
653
 
                #       modifications.
654
 
                state.save()
655
 
            finally:
656
 
                state2.unlock()
657
 
        finally:
658
 
            state.unlock()
659
 
 
660
 
        # The file on disk should not be modified.
661
 
        state = dirstate.DirState.on_file('dirstate')
662
 
        state.lock_read()
663
 
        try:
664
 
            entry = state._get_entry(0, path_utf8='a-file')
665
 
            self.assertEqual('', entry[1][0][1])
666
 
        finally:
667
 
            state.unlock()
668
 
 
669
 
    def test_save_refuses_if_changes_aborted(self):
670
 
        self.build_tree(['a-file', 'a-dir/'])
671
 
        state = dirstate.DirState.initialize('dirstate')
672
 
        try:
673
 
            # No stat and no sha1 sum.
674
 
            state.add('a-file', 'a-file-id', 'file', None, '')
675
 
            state.save()
676
 
        finally:
677
 
            state.unlock()
678
 
 
679
 
        # The dirstate should include TREE_ROOT and 'a-file' and nothing else
680
 
        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)])]),
685
 
        ]
686
 
 
687
 
        state = dirstate.DirState.on_file('dirstate')
688
 
        state.lock_write()
689
 
        try:
690
 
            state._read_dirblocks_if_needed()
691
 
            self.assertEqual(expected_blocks, state._dirblocks)
692
 
 
693
 
            # Now modify the state, but mark it as inconsistent
694
 
            state.add('a-dir', 'a-dir-id', 'directory', None, '')
695
 
            state._changes_aborted = True
696
 
            state.save()
697
 
        finally:
698
 
            state.unlock()
699
 
 
700
 
        state = dirstate.DirState.on_file('dirstate')
701
 
        state.lock_read()
702
 
        try:
703
 
            state._read_dirblocks_if_needed()
704
 
            self.assertEqual(expected_blocks, state._dirblocks)
705
 
        finally:
706
 
            state.unlock()
707
 
 
708
351
 
709
352
class TestDirStateInitialize(TestCaseWithDirState):
710
353
 
718
361
        try:
719
362
            self.assertIsInstance(state, dirstate.DirState)
720
363
            lines = state.get_lines()
721
 
        finally:
 
364
            self.assertFileEqual(''.join(state.get_lines()),
 
365
                'dirstate')
 
366
            self.check_state_with_reopen(expected_result, state)
 
367
        except:
722
368
            state.unlock()
723
 
        # On win32 you can't read from a locked file, even within the same
724
 
        # process. So we have to unlock and release before we check the file
725
 
        # contents.
726
 
        self.assertFileEqual(''.join(lines), 'dirstate')
727
 
        state.lock_read() # check_state_with_reopen will unlock
728
 
        self.check_state_with_reopen(expected_result, state)
 
369
            raise
729
370
 
730
371
 
731
372
class TestDirStateManipulations(TestCaseWithDirState):
737
378
        try:
738
379
            tree1.add('')
739
380
            revid1 = tree1.commit('foo').encode('utf8')
740
 
            root_id = tree1.get_root_id()
 
381
            root_id = tree1.inventory.root.file_id
741
382
            inv = tree1.inventory
742
383
        finally:
743
384
            tree1.unlock()
758
399
            # This will unlock it
759
400
            self.check_state_with_reopen(expected_result, state)
760
401
 
761
 
    def test_set_state_from_inventory_preserves_hashcache(self):
762
 
        # https://bugs.launchpad.net/bzr/+bug/146176
763
 
        # set_state_from_inventory should preserve the stat and hash value for
764
 
        # workingtree files that are not changed by the inventory.
765
 
 
766
 
        tree = self.make_branch_and_tree('.')
767
 
        # depends on the default format using dirstate...
768
 
        tree.lock_write()
769
 
        try:
770
 
            # make a dirstate with some valid hashcache data
771
 
            # file on disk, but that's not needed for this test
772
 
            foo_contents = 'contents of foo'
773
 
            self.build_tree_contents([('foo', foo_contents)])
774
 
            tree.add('foo', 'foo-id')
775
 
 
776
 
            foo_stat = os.stat('foo')
777
 
            foo_packed = dirstate.pack_stat(foo_stat)
778
 
            foo_sha = osutils.sha_string(foo_contents)
779
 
            foo_size = len(foo_contents)
780
 
 
781
 
            # should not be cached yet, because the file's too fresh
782
 
            self.assertEqual(
783
 
                (('', 'foo', 'foo-id',),
784
 
                 [('f', '', 0, False, dirstate.DirState.NULLSTAT)]),
785
 
                tree._dirstate._get_entry(0, 'foo-id'))
786
 
            # poke in some hashcache information - it wouldn't normally be
787
 
            # stored because it's too fresh
788
 
            tree._dirstate.update_minimal(
789
 
                ('', 'foo', 'foo-id'),
790
 
                'f', False, foo_sha, foo_packed, foo_size, 'foo')
791
 
            # now should be cached
792
 
            self.assertEqual(
793
 
                (('', 'foo', 'foo-id',),
794
 
                 [('f', foo_sha, foo_size, False, foo_packed)]),
795
 
                tree._dirstate._get_entry(0, 'foo-id'))
796
 
 
797
 
            # extract the inventory, and add something to it
798
 
            inv = tree._get_inventory()
799
 
            # should see the file we poked in...
800
 
            self.assertTrue(inv.has_id('foo-id'))
801
 
            self.assertTrue(inv.has_filename('foo'))
802
 
            inv.add_path('bar', 'file', 'bar-id')
803
 
            tree._dirstate._validate()
804
 
            # this used to cause it to lose its hashcache
805
 
            tree._dirstate.set_state_from_inventory(inv)
806
 
            tree._dirstate._validate()
807
 
        finally:
808
 
            tree.unlock()
809
 
 
810
 
        tree.lock_read()
811
 
        try:
812
 
            # now check that the state still has the original hashcache value
813
 
            state = tree._dirstate
814
 
            state._validate()
815
 
            foo_tuple = state._get_entry(0, path_utf8='foo')
816
 
            self.assertEqual(
817
 
                (('', 'foo', 'foo-id',),
818
 
                 [('f', foo_sha, len(foo_contents), False,
819
 
                   dirstate.pack_stat(foo_stat))]),
820
 
                foo_tuple)
821
 
        finally:
822
 
            tree.unlock()
823
 
 
824
 
    def test_set_state_from_inventory_mixed_paths(self):
825
 
        tree1 = self.make_branch_and_tree('tree1')
826
 
        self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a-b/',
827
 
                         'tree1/a/b/foo', 'tree1/a-b/bar'])
828
 
        tree1.lock_write()
829
 
        try:
830
 
            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')
833
 
            root_id = tree1.get_root_id()
834
 
            inv = tree1.inventory
835
 
        finally:
836
 
            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'),
843
 
                           ]
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'),
848
 
                           ]
849
 
        state = dirstate.DirState.initialize('dirstate')
850
 
        try:
851
 
            state.set_state_from_inventory(inv)
852
 
            values = []
853
 
            for entry in state._iter_entries():
854
 
                values.append(entry[0] + entry[1][0][:1])
855
 
            self.assertEqual(expected_result1, values)
856
 
            del inv['b-id']
857
 
            state.set_state_from_inventory(inv)
858
 
            values = []
859
 
            for entry in state._iter_entries():
860
 
                values.append(entry[0] + entry[1][0][:1])
861
 
            self.assertEqual(expected_result2, values)
862
 
        finally:
863
 
            state.unlock()
864
 
 
865
402
    def test_set_path_id_no_parents(self):
866
403
        """The id of a path can be changed trivally with no parents."""
867
404
        state = dirstate.DirState.initialize('dirstate')
868
405
        try:
869
406
            # check precondition to be sure the state does change appropriately.
870
 
            root_entry = (('', '', 'TREE_ROOT'), [('d', '', 0, False, 'x'*32)])
871
 
            self.assertEqual([root_entry], list(state._iter_entries()))
872
 
            self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
873
 
            self.assertEqual(root_entry,
874
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
875
 
            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)])
880
 
            expected_rows = [new_root_entry]
881
 
            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'))
885
 
            self.assertEqual((None, None),
886
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
887
 
            # should work across save too
888
 
            state.save()
889
 
        finally:
890
 
            state.unlock()
891
 
        state = dirstate.DirState.on_file('dirstate')
892
 
        state.lock_read()
893
 
        try:
894
 
            state._validate()
895
 
            self.assertEqual(expected_rows, list(state._iter_entries()))
896
 
        finally:
897
 
            state.unlock()
898
 
 
899
 
    def test_set_path_id_with_parents(self):
900
 
        """Set the root file id in a dirstate with parents"""
901
 
        mt = self.make_branch_and_tree('mt')
902
 
        # 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')
906
 
        state = dirstate.DirState.initialize('dirstate')
907
 
        state._validate()
908
 
        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=''))
914
 
            self.assertEqual(root_entry,
915
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
916
 
            self.assertEqual((None, None),
917
 
                             state._get_entry(0, fileid_utf8='Asecond-root-id'))
918
 
            state.set_path_id('', 'Asecond-root-id')
919
 
            state._validate()
920
 
            # 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, '')])
927
 
            expected_rows = [new_root_entry, old_root_entry]
928
 
            state._validate()
929
 
            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=''))
932
 
            self.assertEqual((None, None),
933
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
934
 
            self.assertEqual(old_root_entry,
935
 
                             state._get_entry(1, fileid_utf8='TREE_ROOT'))
936
 
            self.assertEqual(new_root_entry,
937
 
                             state._get_entry(0, fileid_utf8='Asecond-root-id'))
938
 
            self.assertEqual((None, None),
939
 
                             state._get_entry(1, fileid_utf8='Asecond-root-id'))
940
 
            # should work across save too
941
 
            state.save()
942
 
        finally:
943
 
            state.unlock()
944
 
        # now flush & check we get the same
945
 
        state = dirstate.DirState.on_file('dirstate')
946
 
        state.lock_read()
947
 
        try:
948
 
            state._validate()
949
 
            self.assertEqual(expected_rows, list(state._iter_entries()))
950
 
        finally:
951
 
            state.unlock()
952
 
        # now change within an existing file-backed state
953
 
        state.lock_write()
954
 
        try:
955
 
            state._validate()
956
 
            state.set_path_id('', 'tree-root-2')
957
 
            state._validate()
 
407
            self.assertEqual(
 
408
                [(('', '', 'TREE_ROOT'), [('d', '', 0, False,
 
409
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])],
 
410
                list(state._iter_entries()))
 
411
            state.set_path_id('', 'foobarbaz')
 
412
            expected_rows = [
 
413
                (('', '', 'foobarbaz'), [('d', '', 0, False,
 
414
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])]
 
415
            self.assertEqual(expected_rows, list(state._iter_entries()))
 
416
            # should work across save too
 
417
            state.save()
 
418
        finally:
 
419
            state.unlock()
 
420
        state = dirstate.DirState.on_file('dirstate')
 
421
        state.lock_read()
 
422
        try:
 
423
            self.assertEqual(expected_rows, list(state._iter_entries()))
958
424
        finally:
959
425
            state.unlock()
960
426
 
968
434
        finally:
969
435
            tree1.unlock()
970
436
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
971
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
437
        tree2 = MemoryTree.create_on_branch(branch2)
972
438
        tree2.lock_write()
973
439
        try:
974
440
            revid2 = tree2.commit('foo')
975
 
            root_id = tree2.get_root_id()
 
441
            root_id = tree2.inventory.root.file_id
976
442
        finally:
977
443
            tree2.unlock()
978
444
        state = dirstate.DirState.initialize('dirstate')
985
451
                ['ghost-rev'])
986
452
            # check we can reopen and use the dirstate after setting parent
987
453
            # trees.
988
 
            state._validate()
989
454
            state.save()
990
 
            state._validate()
991
455
        finally:
992
456
            state.unlock()
993
457
        state = dirstate.DirState.on_file('dirstate')
1006
470
            state.set_parent_trees(
1007
471
                ((revid1, tree1.branch.repository.revision_tree(revid1)),
1008
472
                 (revid2, tree2.branch.repository.revision_tree(revid2)),
1009
 
                 ('ghost-rev', tree2.branch.repository.revision_tree(
1010
 
                                   _mod_revision.NULL_REVISION))),
 
473
                 ('ghost-rev', tree2.branch.repository.revision_tree(None))),
1011
474
                ['ghost-rev'])
1012
475
            self.assertEqual([revid1, revid2, 'ghost-rev'],
1013
476
                             state.get_parent_ids())
1017
480
                [(('', '', root_id), [
1018
481
                  ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1019
482
                  ('d', '', 0, False, revid1),
1020
 
                  ('d', '', 0, False, revid1)
 
483
                  ('d', '', 0, False, revid2)
1021
484
                  ])],
1022
485
                list(state._iter_entries()))
1023
486
        finally:
1038
501
        finally:
1039
502
            tree1.unlock()
1040
503
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1041
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
504
        tree2 = MemoryTree.create_on_branch(branch2)
1042
505
        tree2.lock_write()
1043
506
        try:
1044
507
            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
1045
508
            revid2 = tree2.commit('foo')
1046
 
            root_id = tree2.get_root_id()
 
509
            root_id = tree2.inventory.root.file_id
1047
510
        finally:
1048
511
            tree2.unlock()
1049
512
        # check the layout in memory
1051
514
            (('', '', root_id), [
1052
515
             ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1053
516
             ('d', '', 0, False, revid1.encode('utf8')),
1054
 
             ('d', '', 0, False, revid1.encode('utf8'))
 
517
             ('d', '', 0, False, revid2.encode('utf8'))
1055
518
             ]),
1056
519
            (('', 'a file', 'file-id'), [
1057
520
             ('a', '', 0, False, ''),
1089
552
            (('', '', 'TREE_ROOT'), [
1090
553
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1091
554
             ]),
1092
 
            (('', 'a file', 'a-file-id'), [
 
555
            (('', 'a file', 'a file id'), [
1093
556
             ('f', '1'*20, 19, False, dirstate.pack_stat(stat)), # current tree
1094
557
             ]),
1095
558
            ]
1096
559
        try:
1097
 
            state.add('a file', 'a-file-id', 'file', stat, '1'*20)
 
560
            state.add('a file', 'a file id', 'file', stat, '1'*20)
1098
561
            # having added it, it should be in the output of iter_entries.
1099
562
            self.assertEqual(expected_entries, list(state._iter_entries()))
1100
563
            # saving and reloading should not affect this.
1103
566
            state.unlock()
1104
567
        state = dirstate.DirState.on_file('dirstate')
1105
568
        state.lock_read()
1106
 
        self.addCleanup(state.unlock)
1107
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
569
        try:
 
570
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
571
        finally:
 
572
            state.unlock()
1108
573
 
1109
574
    def test_add_path_to_unversioned_directory(self):
1110
575
        """Adding a path to an unversioned directory should error.
1115
580
        """
1116
581
        self.build_tree(['unversioned/', 'unversioned/a file'])
1117
582
        state = dirstate.DirState.initialize('dirstate')
1118
 
        self.addCleanup(state.unlock)
1119
 
        self.assertRaises(errors.NotVersionedError, state.add,
1120
 
                          'unversioned/a file', 'a-file-id', 'file', None, None)
 
583
        try:
 
584
            self.assertRaises(errors.NotVersionedError, state.add,
 
585
                'unversioned/a file', 'a file id', 'file', None, None)
 
586
        finally:
 
587
            state.unlock()
1121
588
 
1122
589
    def test_add_directory_to_root_no_parents_all_data(self):
1123
590
        # The most trivial addition of a dir is when there are no parents and
1143
610
            state.unlock()
1144
611
        state = dirstate.DirState.on_file('dirstate')
1145
612
        state.lock_read()
1146
 
        self.addCleanup(state.unlock)
1147
 
        state._validate()
1148
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
613
        try:
 
614
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
615
        finally:
 
616
            state.unlock()
1149
617
 
1150
 
    def _test_add_symlink_to_root_no_parents_all_data(self, link_name, target):
 
618
    def test_add_symlink_to_root_no_parents_all_data(self):
1151
619
        # The most trivial addition of a symlink when there are no parents and
1152
620
        # its in the root and all data about the file is supplied
1153
 
        # bzr doesn't support fake symlinks on windows, yet.
1154
 
        self.requireFeature(tests.SymlinkFeature)
1155
 
        os.symlink(target, link_name)
1156
 
        stat = os.lstat(link_name)
 
621
        ## TODO: windows: dont fail this test. Also, how are symlinks meant to
 
622
        # be represented on windows.
 
623
        os.symlink('target', 'a link')
 
624
        stat = os.lstat('a link')
1157
625
        expected_entries = [
1158
626
            (('', '', 'TREE_ROOT'), [
1159
627
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1160
628
             ]),
1161
 
            (('', link_name.encode('UTF-8'), 'a link id'), [
1162
 
             ('l', target.encode('UTF-8'), stat[6],
1163
 
              False, dirstate.pack_stat(stat)), # current tree
 
629
            (('', 'a link', 'a link id'), [
 
630
             ('l', 'target', 6, False, dirstate.pack_stat(stat)), # current tree
1164
631
             ]),
1165
632
            ]
1166
633
        state = dirstate.DirState.initialize('dirstate')
1167
634
        try:
1168
 
            state.add(link_name, 'a link id', 'symlink', stat,
1169
 
                      target.encode('UTF-8'))
 
635
            state.add('a link', 'a link id', 'symlink', stat, 'target')
1170
636
            # having added it, it should be in the output of iter_entries.
1171
637
            self.assertEqual(expected_entries, list(state._iter_entries()))
1172
638
            # saving and reloading should not affect this.
1175
641
            state.unlock()
1176
642
        state = dirstate.DirState.on_file('dirstate')
1177
643
        state.lock_read()
1178
 
        self.addCleanup(state.unlock)
1179
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
1180
 
 
1181
 
    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')
1183
 
 
1184
 
    def test_add_symlink_unicode_to_root_no_parents_all_data(self):
1185
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1186
 
        self._test_add_symlink_to_root_no_parents_all_data(
1187
 
            u'\N{Euro Sign}link', u'targ\N{Euro Sign}et')
 
644
        try:
 
645
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
646
        finally:
 
647
            state.unlock()
1188
648
 
1189
649
    def test_add_directory_and_child_no_parents_all_data(self):
1190
650
        # after adding a directory, we should be able to add children to it.
1198
658
            (('', 'a dir', 'a dir id'), [
1199
659
             ('d', '', 0, False, dirstate.pack_stat(dirstat)), # current tree
1200
660
             ]),
1201
 
            (('a dir', 'a file', 'a-file-id'), [
 
661
            (('a dir', 'a file', 'a file id'), [
1202
662
             ('f', '1'*20, 25, False,
1203
663
              dirstate.pack_stat(filestat)), # current tree details
1204
664
             ]),
1206
666
        state = dirstate.DirState.initialize('dirstate')
1207
667
        try:
1208
668
            state.add('a dir', 'a dir id', 'directory', dirstat, None)
1209
 
            state.add('a dir/a file', 'a-file-id', 'file', filestat, '1'*20)
 
669
            state.add('a dir/a file', 'a file id', 'file', filestat, '1'*20)
1210
670
            # added it, it should be in the output of iter_entries.
1211
671
            self.assertEqual(expected_entries, list(state._iter_entries()))
1212
672
            # saving and reloading should not affect this.
1215
675
            state.unlock()
1216
676
        state = dirstate.DirState.on_file('dirstate')
1217
677
        state.lock_read()
1218
 
        self.addCleanup(state.unlock)
1219
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
1220
 
 
1221
 
    def test_add_tree_reference(self):
1222
 
        # make a dirstate and add a tree reference
1223
 
        state = dirstate.DirState.initialize('dirstate')
1224
 
        expected_entry = (
1225
 
            ('', 'subdir', 'subdir-id'),
1226
 
            [('t', 'subtree-123123', 0, False,
1227
 
              'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')],
1228
 
            )
1229
678
        try:
1230
 
            state.add('subdir', 'subdir-id', 'tree-reference', None, 'subtree-123123')
1231
 
            entry = state._get_entry(0, 'subdir-id', 'subdir')
1232
 
            self.assertEqual(entry, expected_entry)
1233
 
            state._validate()
1234
 
            state.save()
 
679
            self.assertEqual(expected_entries, list(state._iter_entries()))
1235
680
        finally:
1236
681
            state.unlock()
1237
 
        # now check we can read it back
1238
 
        state.lock_read()
1239
 
        self.addCleanup(state.unlock)
1240
 
        state._validate()
1241
 
        entry2 = state._get_entry(0, 'subdir-id', 'subdir')
1242
 
        self.assertEqual(entry, entry2)
1243
 
        self.assertEqual(entry, expected_entry)
1244
 
        # and lookup by id should work too
1245
 
        entry2 = state._get_entry(0, fileid_utf8='subdir-id')
1246
 
        self.assertEqual(entry, expected_entry)
1247
 
 
1248
 
    def test_add_forbidden_names(self):
1249
 
        state = dirstate.DirState.initialize('dirstate')
1250
 
        self.addCleanup(state.unlock)
1251
 
        self.assertRaises(errors.BzrError,
1252
 
            state.add, '.', 'ass-id', 'directory', None, None)
1253
 
        self.assertRaises(errors.BzrError,
1254
 
            state.add, '..', 'ass-id', 'directory', None, None)
1255
 
 
1256
 
    def test_set_state_with_rename_b_a_bug_395556(self):
1257
 
        # bug 395556 uncovered a bug where the dirstate ends up with a false
1258
 
        # relocation record - in a tree with no parents there should be no
1259
 
        # absent or relocated records. This then leads to further corruption
1260
 
        # when a commit occurs, as the incorrect relocation gathers an
1261
 
        # incorrect absent in tree 1, and future changes go to pot.
1262
 
        tree1 = self.make_branch_and_tree('tree1')
1263
 
        self.build_tree(['tree1/b'])
1264
 
        tree1.lock_write()
1265
 
        try:
1266
 
            tree1.add(['b'], ['b-id'])
1267
 
            root_id = tree1.get_root_id()
1268
 
            inv = tree1.inventory
1269
 
            state = dirstate.DirState.initialize('dirstate')
1270
 
            try:
1271
 
                # Set the initial state with 'b'
1272
 
                state.set_state_from_inventory(inv)
1273
 
                inv.rename('b-id', root_id, 'a')
1274
 
                # Set the new state with 'a', which currently corrupts.
1275
 
                state.set_state_from_inventory(inv)
1276
 
                expected_result1 = [('', '', root_id, 'd'),
1277
 
                                    ('', 'a', 'b-id', 'f'),
1278
 
                                   ]
1279
 
                values = []
1280
 
                for entry in state._iter_entries():
1281
 
                    values.append(entry[0] + entry[1][0][:1])
1282
 
                self.assertEqual(expected_result1, values)
1283
 
            finally:
1284
 
                state.unlock()
1285
 
        finally:
1286
 
            tree1.unlock()
1287
682
 
1288
683
 
1289
684
class TestGetLines(TestCaseWithDirState):
1292
687
        state = self.create_dirstate_with_root_and_subdir()
1293
688
        try:
1294
689
            self.assertEqual(['#bazaar dirstate flat format 3\n',
1295
 
                'crc32: 41262208\n',
 
690
                'adler32: -1327947603\n',
1296
691
                'num_entries: 2\n',
1297
692
                '0\x00\n\x00'
1298
693
                '0\x00\n\x00'
1503
898
            state.unlock()
1504
899
 
1505
900
 
1506
 
class TestIterChildEntries(TestCaseWithDirState):
1507
 
 
1508
 
    def create_dirstate_with_two_trees(self):
1509
 
        """This dirstate contains multiple files and directories.
1510
 
 
1511
 
         /        a-root-value
1512
 
         a/       a-dir
1513
 
         b/       b-dir
1514
 
         c        c-file
1515
 
         d        d-file
1516
 
         a/e/     e-dir
1517
 
         a/f      f-file
1518
 
         b/g      g-file
1519
 
         b/h\xc3\xa5  h-\xc3\xa5-file  #This is u'\xe5' encoded into utf-8
1520
 
 
1521
 
        Notice that a/e is an empty directory.
1522
 
 
1523
 
        There is one parent tree, which has the same shape with the following variations:
1524
 
        b/g in the parent is gone.
1525
 
        b/h in the parent has a different id
1526
 
        b/i is new in the parent
1527
 
        c is renamed to b/j in the parent
1528
 
 
1529
 
        :return: The dirstate, still write-locked.
1530
 
        """
1531
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1532
 
        null_sha = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
1533
 
        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'),
1581
 
            ]
1582
 
        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]))
1587
 
        state = dirstate.DirState.initialize('dirstate')
1588
 
        state._validate()
1589
 
        try:
1590
 
            state._set_data(['parent'], dirblocks)
1591
 
        except:
1592
 
            state.unlock()
1593
 
            raise
1594
 
        return state, dirblocks
1595
 
 
1596
 
    def test_iter_children_b(self):
1597
 
        state, dirblocks = self.create_dirstate_with_two_trees()
1598
 
        self.addCleanup(state.unlock)
1599
 
        expected_result = []
1600
 
        expected_result.append(dirblocks[3][1][2]) # h2
1601
 
        expected_result.append(dirblocks[3][1][3]) # i
1602
 
        expected_result.append(dirblocks[3][1][4]) # j
1603
 
        self.assertEqual(expected_result,
1604
 
            list(state._iter_child_entries(1, 'b')))
1605
 
 
1606
 
    def test_iter_child_root(self):
1607
 
        state, dirblocks = self.create_dirstate_with_two_trees()
1608
 
        self.addCleanup(state.unlock)
1609
 
        expected_result = []
1610
 
        expected_result.append(dirblocks[1][1][0]) # a
1611
 
        expected_result.append(dirblocks[1][1][1]) # b
1612
 
        expected_result.append(dirblocks[1][1][3]) # d
1613
 
        expected_result.append(dirblocks[2][1][0]) # e
1614
 
        expected_result.append(dirblocks[2][1][1]) # f
1615
 
        expected_result.append(dirblocks[3][1][2]) # h2
1616
 
        expected_result.append(dirblocks[3][1][3]) # i
1617
 
        expected_result.append(dirblocks[3][1][4]) # j
1618
 
        self.assertEqual(expected_result,
1619
 
            list(state._iter_child_entries(1, '')))
1620
 
 
1621
 
 
1622
 
class TestDirstateSortOrder(tests.TestCaseWithTransport):
 
901
class TestDirstateSortOrder(TestCaseWithTransport):
1623
902
    """Test that DirState adds entries in the right order."""
1624
903
 
1625
904
    def test_add_sorting(self):
1674
953
 
1675
954
        # *really* cheesy way to just get an empty tree
1676
955
        repo = self.make_repository('repo')
1677
 
        empty_tree = repo.revision_tree(_mod_revision.NULL_REVISION)
 
956
        empty_tree = repo.revision_tree(None)
1678
957
        state.set_parent_trees([('null:', empty_tree)], [])
1679
958
 
1680
959
        dirblock_names = [d[0] for d in state._dirblocks]
1681
960
        self.assertEqual(expected, dirblock_names)
1682
961
 
1683
962
 
1684
 
class InstrumentedDirState(dirstate.DirState):
1685
 
    """An DirState with instrumented sha1 functionality."""
1686
 
 
1687
 
    def __init__(self, path, sha1_provider):
1688
 
        super(InstrumentedDirState, self).__init__(path, sha1_provider)
1689
 
        self._time_offset = 0
1690
 
        self._log = []
1691
 
        # member is dynamically set in DirState.__init__ to turn on trace
1692
 
        self._sha1_provider = sha1_provider
1693
 
        self._sha1_file = self._sha1_file_and_log
1694
 
 
1695
 
    def _sha_cutoff_time(self):
1696
 
        timestamp = super(InstrumentedDirState, self)._sha_cutoff_time()
1697
 
        self._cutoff_time = timestamp + self._time_offset
1698
 
 
1699
 
    def _sha1_file_and_log(self, abspath):
1700
 
        self._log.append(('sha1', abspath))
1701
 
        return self._sha1_provider.sha1(abspath)
1702
 
 
1703
 
    def _read_link(self, abspath, old_link):
1704
 
        self._log.append(('read_link', abspath, old_link))
1705
 
        return super(InstrumentedDirState, self)._read_link(abspath, old_link)
1706
 
 
1707
 
    def _lstat(self, abspath, entry):
1708
 
        self._log.append(('lstat', abspath))
1709
 
        return super(InstrumentedDirState, self)._lstat(abspath, entry)
1710
 
 
1711
 
    def _is_executable(self, mode, old_executable):
1712
 
        self._log.append(('is_exec', mode, old_executable))
1713
 
        return super(InstrumentedDirState, self)._is_executable(mode,
1714
 
                                                                old_executable)
1715
 
 
1716
 
    def adjust_time(self, secs):
1717
 
        """Move the clock forward or back.
1718
 
 
1719
 
        :param secs: The amount to adjust the clock by. Positive values make it
1720
 
        seem as if we are in the future, negative values make it seem like we
1721
 
        are in the past.
1722
 
        """
1723
 
        self._time_offset += secs
1724
 
        self._cutoff_time = None
1725
 
 
1726
 
 
1727
 
class _FakeStat(object):
1728
 
    """A class with the same attributes as a real stat result."""
1729
 
 
1730
 
    def __init__(self, size, mtime, ctime, dev, ino, mode):
1731
 
        self.st_size = size
1732
 
        self.st_mtime = mtime
1733
 
        self.st_ctime = ctime
1734
 
        self.st_dev = dev
1735
 
        self.st_ino = ino
1736
 
        self.st_mode = mode
1737
 
 
1738
 
    @staticmethod
1739
 
    def from_stat(st):
1740
 
        return _FakeStat(st.st_size, st.st_mtime, st.st_ctime, st.st_dev,
1741
 
            st.st_ino, st.st_mode)
1742
 
 
1743
 
 
1744
 
class TestPackStat(tests.TestCaseWithTransport):
1745
 
 
1746
 
    def assertPackStat(self, expected, stat_value):
1747
 
        """Check the packed and serialized form of a stat value."""
1748
 
        self.assertEqual(expected, dirstate.pack_stat(stat_value))
1749
 
 
1750
 
    def test_pack_stat_int(self):
1751
 
        st = _FakeStat(6859L, 1172758614, 1172758617, 777L, 6499538L, 0100644)
1752
 
        # Make sure that all parameters have an impact on the packed stat.
1753
 
        self.assertPackStat('AAAay0Xm4FZF5uBZAAADCQBjLNIAAIGk', st)
1754
 
        st.st_size = 7000L
1755
 
        #                ay0 => bWE
1756
 
        self.assertPackStat('AAAbWEXm4FZF5uBZAAADCQBjLNIAAIGk', st)
1757
 
        st.st_mtime = 1172758620
1758
 
        #                     4FZ => 4Fx
1759
 
        self.assertPackStat('AAAbWEXm4FxF5uBZAAADCQBjLNIAAIGk', st)
1760
 
        st.st_ctime = 1172758630
1761
 
        #                          uBZ => uBm
1762
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1763
 
        st.st_dev = 888L
1764
 
        #                                DCQ => DeA
1765
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADeABjLNIAAIGk', st)
1766
 
        st.st_ino = 6499540L
1767
 
        #                                     LNI => LNQ
1768
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADeABjLNQAAIGk', st)
1769
 
        st.st_mode = 0100744
1770
 
        #                                          IGk => IHk
1771
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADeABjLNQAAIHk', st)
1772
 
 
1773
 
    def test_pack_stat_float(self):
1774
 
        """On some platforms mtime and ctime are floats.
1775
 
 
1776
 
        Make sure we don't get warnings or errors, and that we ignore changes <
1777
 
        1s
1778
 
        """
1779
 
        st = _FakeStat(7000L, 1172758614.0, 1172758617.0,
1780
 
                       777L, 6499538L, 0100644)
1781
 
        # These should all be the same as the integer counterparts
1782
 
        self.assertPackStat('AAAbWEXm4FZF5uBZAAADCQBjLNIAAIGk', st)
1783
 
        st.st_mtime = 1172758620.0
1784
 
        #                     FZF5 => FxF5
1785
 
        self.assertPackStat('AAAbWEXm4FxF5uBZAAADCQBjLNIAAIGk', st)
1786
 
        st.st_ctime = 1172758630.0
1787
 
        #                          uBZ => uBm
1788
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1789
 
        # fractional seconds are discarded, so no change from above
1790
 
        st.st_mtime = 1172758620.453
1791
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1792
 
        st.st_ctime = 1172758630.228
1793
 
        self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1794
 
 
1795
 
 
1796
 
class TestBisect(TestCaseWithDirState):
 
963
class TestBisect(TestCaseWithTransport):
1797
964
    """Test the ability to bisect into the disk format."""
1798
965
 
 
966
    def create_basic_dirstate(self):
 
967
        """Create a dirstate with a few files and directories.
 
968
 
 
969
            a
 
970
            b/
 
971
              c
 
972
              d/
 
973
                e
 
974
            f
 
975
        """
 
976
        tree = self.make_branch_and_tree('tree')
 
977
        paths = ['a', 'b/', 'b/c', 'b/d/', 'b/d/e', 'f']
 
978
        file_ids = ['a-id', 'b-id', 'c-id', 'd-id', 'e-id', 'f-id']
 
979
        self.build_tree(['tree/' + p for p in paths])
 
980
        tree.set_root_id('TREE_ROOT')
 
981
        tree.add([p.rstrip('/') for p in paths], file_ids)
 
982
        tree.commit('initial', rev_id='rev-1')
 
983
        revision_id = 'rev-1'
 
984
        # a_packed_stat = dirstate.pack_stat(os.stat('tree/a'))
 
985
        t = self.get_transport().clone('tree')
 
986
        a_text = t.get_bytes('a')
 
987
        a_sha = osutils.sha_string(a_text)
 
988
        a_len = len(a_text)
 
989
        # b_packed_stat = dirstate.pack_stat(os.stat('tree/b'))
 
990
        # c_packed_stat = dirstate.pack_stat(os.stat('tree/b/c'))
 
991
        c_text = t.get_bytes('b/c')
 
992
        c_sha = osutils.sha_string(c_text)
 
993
        c_len = len(c_text)
 
994
        # d_packed_stat = dirstate.pack_stat(os.stat('tree/b/d'))
 
995
        # e_packed_stat = dirstate.pack_stat(os.stat('tree/b/d/e'))
 
996
        e_text = t.get_bytes('b/d/e')
 
997
        e_sha = osutils.sha_string(e_text)
 
998
        e_len = len(e_text)
 
999
        # f_packed_stat = dirstate.pack_stat(os.stat('tree/f'))
 
1000
        f_text = t.get_bytes('f')
 
1001
        f_sha = osutils.sha_string(f_text)
 
1002
        f_len = len(f_text)
 
1003
        null_stat = dirstate.DirState.NULLSTAT
 
1004
        expected = {
 
1005
            '':(('', '', 'TREE_ROOT'), [
 
1006
                  ('d', '', 0, False, null_stat),
 
1007
                  ('d', '', 0, False, revision_id),
 
1008
                ]),
 
1009
            'a':(('', 'a', 'a-id'), [
 
1010
                   ('f', '', 0, False, null_stat),
 
1011
                   ('f', a_sha, a_len, False, revision_id),
 
1012
                 ]),
 
1013
            'b':(('', 'b', 'b-id'), [
 
1014
                  ('d', '', 0, False, null_stat),
 
1015
                  ('d', '', 0, False, revision_id),
 
1016
                 ]),
 
1017
            'b/c':(('b', 'c', 'c-id'), [
 
1018
                    ('f', '', 0, False, null_stat),
 
1019
                    ('f', c_sha, c_len, False, revision_id),
 
1020
                   ]),
 
1021
            'b/d':(('b', 'd', 'd-id'), [
 
1022
                    ('d', '', 0, False, null_stat),
 
1023
                    ('d', '', 0, False, revision_id),
 
1024
                   ]),
 
1025
            'b/d/e':(('b/d', 'e', 'e-id'), [
 
1026
                      ('f', '', 0, False, null_stat),
 
1027
                      ('f', e_sha, e_len, False, revision_id),
 
1028
                     ]),
 
1029
            'f':(('', 'f', 'f-id'), [
 
1030
                  ('f', '', 0, False, null_stat),
 
1031
                  ('f', f_sha, f_len, False, revision_id),
 
1032
                 ]),
 
1033
        }
 
1034
        state = dirstate.DirState.from_tree(tree, 'dirstate')
 
1035
        try:
 
1036
            state.save()
 
1037
        finally:
 
1038
            state.unlock()
 
1039
        # Use a different object, to make sure nothing is pre-cached in memory.
 
1040
        state = dirstate.DirState.on_file('dirstate')
 
1041
        state.lock_read()
 
1042
        self.addCleanup(state.unlock)
 
1043
        self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
 
1044
                         state._dirblock_state)
 
1045
        # This is code is only really tested if we actually have to make more
 
1046
        # than one read, so set the page size to something smaller.
 
1047
        # We want it to contain about 2.2 records, so that we have a couple
 
1048
        # records that we can read per attempt
 
1049
        state._bisect_page_size = 200
 
1050
        return tree, state, expected
 
1051
 
 
1052
    def create_duplicated_dirstate(self):
 
1053
        """Create a dirstate with a deleted and added entries.
 
1054
 
 
1055
        This grabs a basic_dirstate, and then removes and re adds every entry
 
1056
        with a new file id.
 
1057
        """
 
1058
        tree, state, expected = self.create_basic_dirstate()
 
1059
        # Now we will just remove and add every file so we get an extra entry
 
1060
        # per entry. Unversion in reverse order so we handle subdirs
 
1061
        tree.unversion(['f-id', 'e-id', 'd-id', 'c-id', 'b-id', 'a-id'])
 
1062
        tree.add(['a', 'b', 'b/c', 'b/d', 'b/d/e', 'f'],
 
1063
                 ['a-id2', 'b-id2', 'c-id2', 'd-id2', 'e-id2', 'f-id2'])
 
1064
 
 
1065
        # Update the expected dictionary.
 
1066
        for path in ['a', 'b', 'b/c', 'b/d', 'b/d/e', 'f']:
 
1067
            orig = expected[path]
 
1068
            path2 = path + '2'
 
1069
            # This record was deleted in the current tree
 
1070
            expected[path] = (orig[0], [dirstate.DirState.NULL_PARENT_DETAILS,
 
1071
                                        orig[1][1]])
 
1072
            new_key = (orig[0][0], orig[0][1], orig[0][2]+'2')
 
1073
            # And didn't exist in the basis tree
 
1074
            expected[path2] = (new_key, [orig[1][0],
 
1075
                                         dirstate.DirState.NULL_PARENT_DETAILS])
 
1076
 
 
1077
        # We will replace the 'dirstate' file underneath 'state', but that is
 
1078
        # okay as lock as we unlock 'state' first.
 
1079
        state.unlock()
 
1080
        try:
 
1081
            new_state = dirstate.DirState.from_tree(tree, 'dirstate')
 
1082
            try:
 
1083
                new_state.save()
 
1084
            finally:
 
1085
                new_state.unlock()
 
1086
        finally:
 
1087
            # But we need to leave state in a read-lock because we already have
 
1088
            # a cleanup scheduled
 
1089
            state.lock_read()
 
1090
        return tree, state, expected
 
1091
 
 
1092
    def create_renamed_dirstate(self):
 
1093
        """Create a dirstate with a few internal renames.
 
1094
 
 
1095
        This takes the basic dirstate, and moves the paths around.
 
1096
        """
 
1097
        tree, state, expected = self.create_basic_dirstate()
 
1098
        # Rename a file
 
1099
        tree.rename_one('a', 'b/g')
 
1100
        # And a directory
 
1101
        tree.rename_one('b/d', 'h')
 
1102
 
 
1103
        old_a = expected['a']
 
1104
        expected['a'] = (old_a[0], [('r', 'b/g', 0, False, ''), old_a[1][1]])
 
1105
        expected['b/g'] = (('b', 'g', 'a-id'), [old_a[1][0],
 
1106
                                                ('r', 'a', 0, False, '')])
 
1107
        old_d = expected['b/d']
 
1108
        expected['b/d'] = (old_d[0], [('r', 'h', 0, False, ''), old_d[1][1]])
 
1109
        expected['h'] = (('', 'h', 'd-id'), [old_d[1][0],
 
1110
                                             ('r', 'b/d', 0, False, '')])
 
1111
 
 
1112
        old_e = expected['b/d/e']
 
1113
        expected['b/d/e'] = (old_e[0], [('r', 'h/e', 0, False, ''),
 
1114
                             old_e[1][1]])
 
1115
        expected['h/e'] = (('h', 'e', 'e-id'), [old_e[1][0],
 
1116
                                                ('r', 'b/d/e', 0, False, '')])
 
1117
 
 
1118
        state.unlock()
 
1119
        try:
 
1120
            new_state = dirstate.DirState.from_tree(tree, 'dirstate')
 
1121
            try:
 
1122
                new_state.save()
 
1123
            finally:
 
1124
                new_state.unlock()
 
1125
        finally:
 
1126
            state.lock_read()
 
1127
        return tree, state, expected
 
1128
 
1799
1129
    def assertBisect(self, expected_map, map_keys, state, paths):
1800
1130
        """Assert that bisecting for paths returns the right result.
1801
1131
 
1806
1136
                      (dir, name) tuples, and sorted according to how _bisect
1807
1137
                      requires.
1808
1138
        """
1809
 
        result = state._bisect(paths)
 
1139
        dir_names = sorted(osutils.split(p) for p in paths)
 
1140
        result = state._bisect(dir_names)
1810
1141
        # For now, results are just returned in whatever order we read them.
1811
1142
        # We could sort by (dir, name, file_id) or something like that, but in
1812
1143
        # the end it would still be fairly arbitrary, and we don't want the
1813
1144
        # extra overhead if we can avoid it. So sort everything to make sure
1814
1145
        # equality is true
1815
 
        self.assertEqual(len(map_keys), len(paths))
 
1146
        assert len(map_keys) == len(dir_names)
1816
1147
        expected = {}
1817
 
        for path, keys in zip(paths, map_keys):
 
1148
        for dir_name, keys in zip(dir_names, map_keys):
1818
1149
            if keys is None:
1819
1150
                # This should not be present in the output
1820
1151
                continue
1821
 
            expected[path] = sorted(expected_map[k] for k in keys)
 
1152
            expected[dir_name] = sorted(expected_map[k] for k in keys)
1822
1153
 
1823
 
        # The returned values are just arranged randomly based on when they
1824
 
        # were read, for testing, make sure it is properly sorted.
1825
 
        for path in result:
1826
 
            result[path].sort()
 
1154
        for dir_name in result:
 
1155
            result[dir_name].sort()
1827
1156
 
1828
1157
        self.assertEqual(expected, result)
1829
1158
 
1837
1166
        :param paths: A list of directories
1838
1167
        """
1839
1168
        result = state._bisect_dirblocks(paths)
1840
 
        self.assertEqual(len(map_keys), len(paths))
 
1169
        assert len(map_keys) == len(paths)
 
1170
 
1841
1171
        expected = {}
1842
1172
        for path, keys in zip(paths, map_keys):
1843
1173
            if keys is None:
1865
1195
            dir_name_id, trees_info = entry
1866
1196
            expected[dir_name_id] = trees_info
1867
1197
 
1868
 
        result = state._bisect_recursive(paths)
 
1198
        dir_names = sorted(osutils.split(p) for p in paths)
 
1199
        result = state._bisect_recursive(dir_names)
1869
1200
 
1870
1201
        self.assertEqual(expected, result)
1871
1202
 
1880
1211
        self.assertBisect(expected, [['b/c']], state, ['b/c'])
1881
1212
        self.assertBisect(expected, [['b/d']], state, ['b/d'])
1882
1213
        self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
1883
 
        self.assertBisect(expected, [['b-c']], state, ['b-c'])
1884
1214
        self.assertBisect(expected, [['f']], state, ['f'])
1885
1215
 
1886
1216
    def test_bisect_multi(self):
1889
1219
        # Bisect should be capable of finding multiple entries at the same time
1890
1220
        self.assertBisect(expected, [['a'], ['b'], ['f']],
1891
1221
                          state, ['a', 'b', 'f'])
 
1222
        # ('', 'f') sorts before the others
1892
1223
        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'])
 
1224
                          state, ['b/d', 'b/d/e', 'f'])
1896
1225
 
1897
1226
    def test_bisect_one_page(self):
1898
1227
        """Test bisect when there is only 1 page to read"""
1904
1233
        self.assertBisect(expected,[['b/c']], state, ['b/c'])
1905
1234
        self.assertBisect(expected,[['b/d']], state, ['b/d'])
1906
1235
        self.assertBisect(expected,[['b/d/e']], state, ['b/d/e'])
1907
 
        self.assertBisect(expected,[['b-c']], state, ['b-c'])
1908
1236
        self.assertBisect(expected,[['f']], state, ['f'])
1909
1237
        self.assertBisect(expected,[['a'], ['b'], ['f']],
1910
1238
                          state, ['a', 'b', 'f'])
1911
 
        self.assertBisect(expected, [['b/d'], ['b/d/e'], ['f']],
 
1239
        # ('', 'f') sorts before the others
 
1240
        self.assertBisect(expected, [['f'], ['b/d'], ['b/d/e']],
1912
1241
                          state, ['b/d', 'b/d/e', 'f'])
1913
 
        self.assertBisect(expected, [['b'], ['b/c'], ['b-c']],
1914
 
                          state, ['b', 'b/c', 'b-c'])
1915
1242
 
1916
1243
    def test_bisect_duplicate_paths(self):
1917
1244
        """When bisecting for a path, handle multiple entries."""
1925
1252
        self.assertBisect(expected, [['b/d', 'b/d2']], state, ['b/d'])
1926
1253
        self.assertBisect(expected, [['b/d/e', 'b/d/e2']],
1927
1254
                          state, ['b/d/e'])
1928
 
        self.assertBisect(expected, [['b-c', 'b-c2']], state, ['b-c'])
1929
1255
        self.assertBisect(expected, [['f', 'f2']], state, ['f'])
1930
1256
 
1931
1257
    def test_bisect_page_size_too_small(self):
1938
1264
        self.assertBisect(expected, [['b/c']], state, ['b/c'])
1939
1265
        self.assertBisect(expected, [['b/d']], state, ['b/d'])
1940
1266
        self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
1941
 
        self.assertBisect(expected, [['b-c']], state, ['b-c'])
1942
1267
        self.assertBisect(expected, [['f']], state, ['f'])
1943
1268
 
1944
1269
    def test_bisect_missing(self):
1947
1272
        self.assertBisect(expected, [None], state, ['foo'])
1948
1273
        self.assertBisect(expected, [None], state, ['b/foo'])
1949
1274
        self.assertBisect(expected, [None], state, ['bar/foo'])
1950
 
        self.assertBisect(expected, [None], state, ['b-c/foo'])
1951
1275
 
1952
1276
        self.assertBisect(expected, [['a'], None, ['b/d']],
1953
1277
                          state, ['a', 'foo', 'b/d'])
1969
1293
    def test_bisect_dirblocks(self):
1970
1294
        tree, state, expected = self.create_duplicated_dirstate()
1971
1295
        self.assertBisectDirBlocks(expected,
1972
 
            [['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2']],
1973
 
            state, [''])
 
1296
            [['', 'a', 'a2', 'b', 'b2', 'f', 'f2']], state, [''])
1974
1297
        self.assertBisectDirBlocks(expected,
1975
1298
            [['b/c', 'b/c2', 'b/d', 'b/d2']], state, ['b'])
1976
1299
        self.assertBisectDirBlocks(expected,
1977
1300
            [['b/d/e', 'b/d/e2']], state, ['b/d'])
1978
1301
        self.assertBisectDirBlocks(expected,
1979
 
            [['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2'],
 
1302
            [['', 'a', 'a2', 'b', 'b2', 'f', 'f2'],
1980
1303
             ['b/c', 'b/c2', 'b/d', 'b/d2'],
1981
1304
             ['b/d/e', 'b/d/e2'],
1982
1305
            ], state, ['', 'b', 'b/d'])
1997
1320
        self.assertBisectRecursive(expected, ['a'], state, ['a'])
1998
1321
        self.assertBisectRecursive(expected, ['b/c'], state, ['b/c'])
1999
1322
        self.assertBisectRecursive(expected, ['b/d/e'], state, ['b/d/e'])
2000
 
        self.assertBisectRecursive(expected, ['b-c'], state, ['b-c'])
2001
1323
        self.assertBisectRecursive(expected, ['b/d', 'b/d/e'],
2002
1324
                                   state, ['b/d'])
2003
1325
        self.assertBisectRecursive(expected, ['b', 'b/c', 'b/d', 'b/d/e'],
2004
1326
                                   state, ['b'])
2005
 
        self.assertBisectRecursive(expected, ['', 'a', 'b', 'b-c', 'f', 'b/c',
 
1327
        self.assertBisectRecursive(expected, ['', 'a', 'b', 'f', 'b/c',
2006
1328
                                              'b/d', 'b/d/e'],
2007
1329
                                   state, [''])
2008
1330
 
2032
1354
                                   state, ['b'])
2033
1355
 
2034
1356
 
2035
 
class TestDirstateValidation(TestCaseWithDirState):
2036
 
 
2037
 
    def test_validate_correct_dirstate(self):
2038
 
        state = self.create_complex_dirstate()
2039
 
        state._validate()
2040
 
        state.unlock()
2041
 
        # and make sure we can also validate with a read lock
2042
 
        state.lock_read()
2043
 
        try:
2044
 
            state._validate()
2045
 
        finally:
2046
 
            state.unlock()
2047
 
 
2048
 
    def test_dirblock_not_sorted(self):
2049
 
        tree, state, expected = self.create_renamed_dirstate()
2050
 
        state._read_dirblocks_if_needed()
2051
 
        last_dirblock = state._dirblocks[-1]
2052
 
        # we're appending to the dirblock, but this name comes before some of
2053
 
        # the existing names; that's wrong
2054
 
        last_dirblock[1].append(
2055
 
            (('h', 'aaaa', 'a-id'),
2056
 
             [('a', '', 0, False, ''),
2057
 
              ('a', '', 0, False, '')]))
2058
 
        e = self.assertRaises(AssertionError,
2059
 
            state._validate)
2060
 
        self.assertContainsRe(str(e), 'not sorted')
2061
 
 
2062
 
    def test_dirblock_name_mismatch(self):
2063
 
        tree, state, expected = self.create_renamed_dirstate()
2064
 
        state._read_dirblocks_if_needed()
2065
 
        last_dirblock = state._dirblocks[-1]
2066
 
        # add an entry with the wrong directory name
2067
 
        last_dirblock[1].append(
2068
 
            (('', 'z', 'a-id'),
2069
 
             [('a', '', 0, False, ''),
2070
 
              ('a', '', 0, False, '')]))
2071
 
        e = self.assertRaises(AssertionError,
2072
 
            state._validate)
2073
 
        self.assertContainsRe(str(e),
2074
 
            "doesn't match directory name")
2075
 
 
2076
 
    def test_dirblock_missing_rename(self):
2077
 
        tree, state, expected = self.create_renamed_dirstate()
2078
 
        state._read_dirblocks_if_needed()
2079
 
        last_dirblock = state._dirblocks[-1]
2080
 
        # make another entry for a-id, without a correct 'r' pointer to
2081
 
        # the real occurrence in the working tree
2082
 
        last_dirblock[1].append(
2083
 
            (('h', 'z', 'a-id'),
2084
 
             [('a', '', 0, False, ''),
2085
 
              ('a', '', 0, False, '')]))
2086
 
        e = self.assertRaises(AssertionError,
2087
 
            state._validate)
2088
 
        self.assertContainsRe(str(e),
2089
 
            'file a-id is absent in row')
2090
 
 
2091
 
 
2092
 
class TestDirstateTreeReference(TestCaseWithDirState):
2093
 
 
2094
 
    def test_reference_revision_is_none(self):
2095
 
        tree = self.make_branch_and_tree('tree', format='dirstate-with-subtree')
2096
 
        subtree = self.make_branch_and_tree('tree/subtree',
2097
 
                            format='dirstate-with-subtree')
2098
 
        subtree.set_root_id('subtree')
2099
 
        tree.add_reference(subtree)
2100
 
        tree.add('subtree')
2101
 
        state = dirstate.DirState.from_tree(tree, 'dirstate')
2102
 
        key = ('', 'subtree', 'subtree')
2103
 
        expected = ('', [(key,
2104
 
            [('t', '', 0, False, 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])])
2105
 
 
2106
 
        try:
2107
 
            self.assertEqual(expected, state._find_block(key))
2108
 
        finally:
2109
 
            state.unlock()
2110
 
 
2111
 
 
2112
 
class TestDiscardMergeParents(TestCaseWithDirState):
2113
 
 
2114
 
    def test_discard_no_parents(self):
2115
 
        # This should be a no-op
2116
 
        state = self.create_empty_dirstate()
2117
 
        self.addCleanup(state.unlock)
2118
 
        state._discard_merge_parents()
2119
 
        state._validate()
2120
 
 
2121
 
    def test_discard_one_parent(self):
2122
 
        # 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),
2127
 
            ]
2128
 
        dirblocks = []
2129
 
        dirblocks.append(('', [root_entry_direntry]))
2130
 
        dirblocks.append(('', []))
2131
 
 
2132
 
        state = self.create_empty_dirstate()
2133
 
        self.addCleanup(state.unlock)
2134
 
        state._set_data(['parent-id'], dirblocks[:])
2135
 
        state._validate()
2136
 
 
2137
 
        state._discard_merge_parents()
2138
 
        state._validate()
2139
 
        self.assertEqual(dirblocks, state._dirblocks)
2140
 
 
2141
 
    def test_discard_simple(self):
2142
 
        # 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),
2148
 
            ]
2149
 
        expected_root_entry_direntry = ('', '', 'a-root-value'), [
2150
 
            ('d', '', 0, False, packed_stat),
2151
 
            ('d', '', 0, False, packed_stat),
2152
 
            ]
2153
 
        dirblocks = []
2154
 
        dirblocks.append(('', [root_entry_direntry]))
2155
 
        dirblocks.append(('', []))
2156
 
 
2157
 
        state = self.create_empty_dirstate()
2158
 
        self.addCleanup(state.unlock)
2159
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2160
 
        state._validate()
2161
 
 
2162
 
        # This should strip of the extra column
2163
 
        state._discard_merge_parents()
2164
 
        state._validate()
2165
 
        expected_dirblocks = [('', [expected_root_entry_direntry]), ('', [])]
2166
 
        self.assertEqual(expected_dirblocks, state._dirblocks)
2167
 
 
2168
 
    def test_discard_absent(self):
2169
 
        """If entries are only in a merge, discard should remove the entries"""
2170
 
        null_stat = dirstate.DirState.NULLSTAT
2171
 
        present_dir = ('d', '', 0, False, null_stat)
2172
 
        present_file = ('f', '', 0, False, null_stat)
2173
 
        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,
2179
 
                            [absent, absent, present_file]),
2180
 
                           (file_in_root_key,
2181
 
                            [present_file, present_file, present_file]),
2182
 
                          ]),
2183
 
                    ]
2184
 
 
2185
 
        state = self.create_empty_dirstate()
2186
 
        self.addCleanup(state.unlock)
2187
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2188
 
        state._validate()
2189
 
 
2190
 
        exp_dirblocks = [('', [(root_key, [present_dir, present_dir])]),
2191
 
                         ('', [(file_in_root_key,
2192
 
                                [present_file, present_file]),
2193
 
                              ]),
2194
 
                        ]
2195
 
        state._discard_merge_parents()
2196
 
        state._validate()
2197
 
        self.assertEqual(exp_dirblocks, state._dirblocks)
2198
 
 
2199
 
    def test_discard_renamed(self):
2200
 
        null_stat = dirstate.DirState.NULLSTAT
2201
 
        present_dir = ('d', '', 0, False, null_stat)
2202
 
        present_file = ('f', '', 0, False, null_stat)
2203
 
        absent = dirstate.DirState.NULL_PARENT_DETAILS
2204
 
        root_key = ('', '', 'a-root-value')
2205
 
        file_in_root_key = ('', 'file-in-root', 'a-file-id')
2206
 
        # Renamed relative to parent
2207
 
        file_rename_s_key = ('', 'file-s', 'b-file-id')
2208
 
        file_rename_t_key = ('', 'file-t', 'b-file-id')
2209
 
        # 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')
2212
 
 
2213
 
        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')]),
2217
 
                  (key_in_2,
2218
 
                   [absent, ('r', 'file-in-1', 'c-file-id'), present_file]),
2219
 
                  (file_in_root_key,
2220
 
                   [present_file, present_file, present_file]),
2221
 
                  (file_rename_s_key,
2222
 
                   [('r', 'file-t', 'b-file-id'), absent, present_file]),
2223
 
                  (file_rename_t_key,
2224
 
                   [present_file, absent, ('r', 'file-s', 'b-file-id')]),
2225
 
                 ]),
2226
 
        ]
2227
 
        exp_dirblocks = [
2228
 
            ('', [(root_key, [present_dir, present_dir])]),
2229
 
            ('', [(key_in_1, [absent, present_file]),
2230
 
                  (file_in_root_key, [present_file, present_file]),
2231
 
                  (file_rename_t_key, [present_file, absent]),
2232
 
                 ]),
2233
 
        ]
2234
 
        state = self.create_empty_dirstate()
2235
 
        self.addCleanup(state.unlock)
2236
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2237
 
        state._validate()
2238
 
 
2239
 
        state._discard_merge_parents()
2240
 
        state._validate()
2241
 
        self.assertEqual(exp_dirblocks, state._dirblocks)
2242
 
 
2243
 
    def test_discard_all_subdir(self):
2244
 
        null_stat = dirstate.DirState.NULLSTAT
2245
 
        present_dir = ('d', '', 0, False, null_stat)
2246
 
        present_file = ('f', '', 0, False, null_stat)
2247
 
        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')
2253
 
 
2254
 
        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]),
2258
 
                     (child2_key, [absent, absent, present_file]),
2259
 
                     (child3_key, [absent, absent, present_file]),
2260
 
                    ]),
2261
 
        ]
2262
 
        exp_dirblocks = [
2263
 
            ('', [(root_key, [present_dir, present_dir])]),
2264
 
            ('', [(subdir_key, [present_dir, present_dir])]),
2265
 
            ('sub', []),
2266
 
        ]
2267
 
        state = self.create_empty_dirstate()
2268
 
        self.addCleanup(state.unlock)
2269
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2270
 
        state._validate()
2271
 
 
2272
 
        state._discard_merge_parents()
2273
 
        state._validate()
2274
 
        self.assertEqual(exp_dirblocks, state._dirblocks)
2275
 
 
2276
 
 
2277
 
class Test_InvEntryToDetails(tests.TestCase):
2278
 
 
2279
 
    def assertDetails(self, expected, inv_entry):
2280
 
        details = dirstate.DirState._inv_entry_to_details(inv_entry)
2281
 
        self.assertEqual(expected, details)
2282
 
        # details should always allow join() and always be a plain str when
2283
 
        # finished
2284
 
        (minikind, fingerprint, size, executable, tree_data) = details
2285
 
        self.assertIsInstance(minikind, str)
2286
 
        self.assertIsInstance(fingerprint, str)
2287
 
        self.assertIsInstance(tree_data, str)
2288
 
 
2289
 
    def test_unicode_symlink(self):
2290
 
        inv_entry = inventory.InventoryLink('link-file-id',
2291
 
                                            u'nam\N{Euro Sign}e',
2292
 
                                            'link-parent-id')
2293
 
        inv_entry.revision = 'link-revision-id'
2294
 
        target = u'link-targ\N{Euro Sign}t'
2295
 
        inv_entry.symlink_target = target
2296
 
        self.assertDetails(('l', target.encode('UTF-8'), 0, False,
2297
 
                            'link-revision-id'), inv_entry)
2298
 
 
2299
 
 
2300
 
class TestSHA1Provider(tests.TestCaseInTempDir):
2301
 
 
2302
 
    def test_sha1provider_is_an_interface(self):
2303
 
        p = dirstate.SHA1Provider()
2304
 
        self.assertRaises(NotImplementedError, p.sha1, "foo")
2305
 
        self.assertRaises(NotImplementedError, p.stat_and_sha1, "foo")
2306
 
 
2307
 
    def test_defaultsha1provider_sha1(self):
2308
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
2309
 
        self.build_tree_contents([('foo', text)])
2310
 
        expected_sha = osutils.sha_string(text)
2311
 
        p = dirstate.DefaultSHA1Provider()
2312
 
        self.assertEqual(expected_sha, p.sha1('foo'))
2313
 
 
2314
 
    def test_defaultsha1provider_stat_and_sha1(self):
2315
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
2316
 
        self.build_tree_contents([('foo', text)])
2317
 
        expected_sha = osutils.sha_string(text)
2318
 
        p = dirstate.DefaultSHA1Provider()
2319
 
        statvalue, sha1 = p.stat_and_sha1('foo')
2320
 
        self.assertTrue(len(statvalue) >= 10)
2321
 
        self.assertEqual(len(text), statvalue.st_size)
2322
 
        self.assertEqual(expected_sha, sha1)
 
1357
class TestBisectDirblock(TestCase):
 
1358
    """Test that bisect_dirblock() returns the expected values.
 
1359
 
 
1360
    bisect_dirblock is intended to work like bisect.bisect_left() except it
 
1361
    knows it is working on dirblocks and that dirblocks are sorted by ('path',
 
1362
    'to', 'foo') chunks rather than by raw 'path/to/foo'.
 
1363
    """
 
1364
 
 
1365
    def assertBisect(self, dirblocks, split_dirblocks, path, *args, **kwargs):
 
1366
        """Assert that bisect_split works like bisect_left on the split paths.
 
1367
 
 
1368
        :param dirblocks: A list of (path, [info]) pairs.
 
1369
        :param split_dirblocks: A list of ((split, path), [info]) pairs.
 
1370
        :param path: The path we are indexing.
 
1371
 
 
1372
        All other arguments will be passed along.
 
1373
        """
 
1374
        bisect_split_idx = dirstate.bisect_dirblock(dirblocks, path,
 
1375
                                                 *args, **kwargs)
 
1376
        split_dirblock = (path.split('/'), [])
 
1377
        bisect_left_idx = bisect.bisect_left(split_dirblocks, split_dirblock,
 
1378
                                             *args)
 
1379
        self.assertEqual(bisect_left_idx, bisect_split_idx,
 
1380
                         'bisect_split disagreed. %s != %s'
 
1381
                         ' for key %s'
 
1382
                         % (bisect_left_idx, bisect_split_idx, path)
 
1383
                         )
 
1384
 
 
1385
    def paths_to_dirblocks(self, paths):
 
1386
        """Convert a list of paths into dirblock form.
 
1387
 
 
1388
        Also, ensure that the paths are in proper sorted order.
 
1389
        """
 
1390
        dirblocks = [(path, []) for path in paths]
 
1391
        split_dirblocks = [(path.split('/'), []) for path in paths]
 
1392
        self.assertEqual(sorted(split_dirblocks), split_dirblocks)
 
1393
        return dirblocks, split_dirblocks
 
1394
 
 
1395
    def test_simple(self):
 
1396
        """In the simple case it works just like bisect_left"""
 
1397
        paths = ['', 'a', 'b', 'c', 'd']
 
1398
        dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
 
1399
        for path in paths:
 
1400
            self.assertBisect(dirblocks, split_dirblocks, path)
 
1401
        self.assertBisect(dirblocks, split_dirblocks, '_')
 
1402
        self.assertBisect(dirblocks, split_dirblocks, 'aa')
 
1403
        self.assertBisect(dirblocks, split_dirblocks, 'bb')
 
1404
        self.assertBisect(dirblocks, split_dirblocks, 'cc')
 
1405
        self.assertBisect(dirblocks, split_dirblocks, 'dd')
 
1406
        self.assertBisect(dirblocks, split_dirblocks, 'a/a')
 
1407
        self.assertBisect(dirblocks, split_dirblocks, 'b/b')
 
1408
        self.assertBisect(dirblocks, split_dirblocks, 'c/c')
 
1409
        self.assertBisect(dirblocks, split_dirblocks, 'd/d')
 
1410
 
 
1411
    def test_involved(self):
 
1412
        """This is where bisect_left diverges slightly."""
 
1413
        paths = ['', 'a',
 
1414
                 'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
 
1415
                 'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
 
1416
                 'a-a', 'a-z',
 
1417
                 'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
 
1418
                 'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
 
1419
                 'z-a', 'z-z',
 
1420
                ]
 
1421
        dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
 
1422
        for path in paths:
 
1423
            self.assertBisect(dirblocks, split_dirblocks, path)
 
1424
 
 
1425
    def test_involved_cached(self):
 
1426
        """This is where bisect_left diverges slightly."""
 
1427
        paths = ['', 'a',
 
1428
                 'a/a', 'a/a/a', 'a/a/z', 'a/a-a', 'a/a-z',
 
1429
                 'a/z', 'a/z/a', 'a/z/z', 'a/z-a', 'a/z-z',
 
1430
                 'a-a', 'a-z',
 
1431
                 'z', 'z/a/a', 'z/a/z', 'z/a-a', 'z/a-z',
 
1432
                 'z/z', 'z/z/a', 'z/z/z', 'z/z-a', 'z/z-z',
 
1433
                 'z-a', 'z-z',
 
1434
                ]
 
1435
        cache = {}
 
1436
        dirblocks, split_dirblocks = self.paths_to_dirblocks(paths)
 
1437
        for path in paths:
 
1438
            self.assertBisect(dirblocks, split_dirblocks, path, cache=cache)
 
1439