/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-26 21:17:03 UTC
  • mto: (2255.11.3 dirstate)
  • mto: This revision was merged to the branch mainline in revision 2322.
  • Revision ID: john@arbash-meinel.com-20070226211703-hqcam97hrxohk5jc
Make set_root_id() a no-op if the id doesn't change,
and change the test_merge_core tests to flush the state to disk, since
they are hanging onto a write lock.

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
 
19
 
import bisect
20
19
import os
21
20
 
22
21
from bzrlib import (
23
22
    dirstate,
24
23
    errors,
25
 
    inventory,
26
 
    memorytree,
27
24
    osutils,
28
 
    revision as _mod_revision,
29
 
    tests,
30
25
    )
31
 
from bzrlib.tests import test_osutils
 
26
from bzrlib.memorytree import MemoryTree
 
27
from bzrlib.tests import TestCaseWithTransport
32
28
 
33
29
 
34
30
# TODO:
 
31
# test DirStateRevisionTree : test filtering out of deleted files does not
 
32
#         filter out files called RECYCLED.BIN ;)
 
33
# test 0 parents, 1 parent, 4 parents.
 
34
# test unicode parents, non unicode parents
 
35
# test all change permutations in one and two parents.
 
36
# i.e. file in parent 1, dir in parent 2, symlink in tree.
 
37
# test that renames in the tree result in correct parent paths
 
38
# Test get state from a file, then asking for lines.
 
39
# write a smaller state, and check the file has been truncated.
 
40
# add a entry when its in state deleted
 
41
# revision attribute for root entries.
 
42
# test that utf8 strings are preserved in _row_to_line
 
43
# test parent manipulation
 
44
# test parents that are null in save : i.e. no record in the parent tree for this.
 
45
# todo: _set_data records ghost parents.
35
46
# TESTS to write:
36
47
# general checks for NOT_IN_MEMORY error conditions.
37
48
# set_path_id on a NOT_IN_MEMORY dirstate
43
54
# set_path_id  setting id when state is in memory unmodified
44
55
# set_path_id  setting id when state is in memory modified
45
56
 
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):
 
57
class TestCaseWithDirState(TestCaseWithTransport):
58
58
    """Helper functions for creating DirState objects with various content."""
59
59
 
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
60
    def create_empty_dirstate(self):
71
61
        """Return a locked but empty dirstate"""
72
62
        state = dirstate.DirState.initialize('dirstate')
84
74
        state = self.create_empty_dirstate()
85
75
        try:
86
76
            state._set_data([], dirblocks)
87
 
            state._validate()
88
77
        except:
89
78
            state.unlock()
90
79
            raise
119
108
         b/g      g-file
120
109
         b/h\xc3\xa5  h-\xc3\xa5-file  #This is u'\xe5' encoded into utf-8
121
110
 
122
 
        Notice that a/e is an empty directory.
123
 
 
124
 
        :return: The dirstate, still write-locked.
 
111
        # Notice that a/e is an empty directory.
125
112
        """
126
113
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
127
114
        null_sha = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
158
145
        dirblocks.append(('a', [e_entry, f_entry]))
159
146
        dirblocks.append(('b', [g_entry, h_entry]))
160
147
        state = dirstate.DirState.initialize('dirstate')
161
 
        state._validate()
162
148
        try:
163
149
            state._set_data([], dirblocks)
164
150
        except:
180
166
        """
181
167
        # The state should already be write locked, since we just had to do
182
168
        # some operation to get here.
183
 
        self.assertTrue(state._lock_token is not None)
 
169
        assert state._lock_token is not None
184
170
        try:
185
171
            self.assertEqual(expected_result[0],  state.get_parent_ids())
186
172
            # there should be no ghosts in this tree.
190
176
            state.save()
191
177
        finally:
192
178
            state.unlock()
193
 
        del state
 
179
        del state # Callers should unlock
194
180
        state = dirstate.DirState.on_file('dirstate')
195
181
        state.lock_read()
196
182
        try:
198
184
        finally:
199
185
            state.unlock()
200
186
 
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
187
 
373
188
class TestTreeToDirState(TestCaseWithDirState):
374
189
 
377
192
        # There are no files on disk and no parents
378
193
        tree = self.make_branch_and_tree('tree')
379
194
        expected_result = ([], [
380
 
            (('', '', tree.get_root_id()), # common details
 
195
            (('', '', tree.path2id('')), # common details
381
196
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
382
197
             ])])
383
198
        state = dirstate.DirState.from_tree(tree, 'dirstate')
384
 
        state._validate()
385
199
        self.check_state_with_reopen(expected_result, state)
386
200
 
387
201
    def test_1_parents_empty_to_dirstate(self):
390
204
        rev_id = tree.commit('first post').encode('utf8')
391
205
        root_stat_pack = dirstate.pack_stat(os.stat(tree.basedir))
392
206
        expected_result = ([rev_id], [
393
 
            (('', '', tree.get_root_id()), # common details
 
207
            (('', '', tree.path2id('')), # common details
394
208
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
395
209
              ('d', '', 0, False, rev_id), # first parent details
396
210
             ])])
397
211
        state = dirstate.DirState.from_tree(tree, 'dirstate')
398
212
        self.check_state_with_reopen(expected_result, state)
399
 
        state.lock_read()
400
 
        try:
401
 
            state._validate()
402
 
        finally:
403
 
            state.unlock()
404
213
 
405
214
    def test_2_parents_empty_to_dirstate(self):
406
215
        # create a parent by doing a commit
410
219
        rev_id2 = tree2.commit('second post', allow_pointless=True)
411
220
        tree.merge_from_branch(tree2.branch)
412
221
        expected_result = ([rev_id, rev_id2], [
413
 
            (('', '', tree.get_root_id()), # common details
 
222
            (('', '', tree.path2id('')), # common details
414
223
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
415
224
              ('d', '', 0, False, rev_id), # first parent details
416
 
              ('d', '', 0, False, rev_id), # second parent details
 
225
              ('d', '', 0, False, rev_id2), # second parent details
417
226
             ])])
418
227
        state = dirstate.DirState.from_tree(tree, 'dirstate')
419
228
        self.check_state_with_reopen(expected_result, state)
420
 
        state.lock_read()
421
 
        try:
422
 
            state._validate()
423
 
        finally:
424
 
            state.unlock()
425
229
 
426
230
    def test_empty_unknowns_are_ignored_to_dirstate(self):
427
231
        """We should be able to create a dirstate for an empty tree."""
429
233
        tree = self.make_branch_and_tree('tree')
430
234
        self.build_tree(['tree/unknown'])
431
235
        expected_result = ([], [
432
 
            (('', '', tree.get_root_id()), # common details
 
236
            (('', '', tree.path2id('')), # common details
433
237
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
434
238
             ])])
435
239
        state = dirstate.DirState.from_tree(tree, 'dirstate')
438
242
    def get_tree_with_a_file(self):
439
243
        tree = self.make_branch_and_tree('tree')
440
244
        self.build_tree(['tree/a file'])
441
 
        tree.add('a file', 'a-file-id')
 
245
        tree.add('a file', 'a file id')
442
246
        return tree
443
247
 
444
248
    def test_non_empty_no_parents_to_dirstate(self):
446
250
        # There are files on disk and no parents
447
251
        tree = self.get_tree_with_a_file()
448
252
        expected_result = ([], [
449
 
            (('', '', tree.get_root_id()), # common details
 
253
            (('', '', tree.path2id('')), # common details
450
254
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
451
255
             ]),
452
 
            (('', 'a file', 'a-file-id'), # common
 
256
            (('', 'a file', 'a file id'), # common
453
257
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
454
258
             ]),
455
259
            ])
464
268
        # and length:
465
269
        self.build_tree_contents([('tree/a file', 'new content\n')])
466
270
        expected_result = ([rev_id], [
467
 
            (('', '', tree.get_root_id()), # common details
 
271
            (('', '', tree.path2id('')), # common details
468
272
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
469
273
              ('d', '', 0, False, rev_id), # first parent details
470
274
             ]),
471
 
            (('', 'a file', 'a-file-id'), # common
 
275
            (('', 'a file', 'a file id'), # common
472
276
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
473
277
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
474
278
               rev_id), # first parent
491
295
        # and length again, giving us three distinct values:
492
296
        self.build_tree_contents([('tree/a file', 'new content\n')])
493
297
        expected_result = ([rev_id, rev_id2], [
494
 
            (('', '', tree.get_root_id()), # common details
 
298
            (('', '', tree.path2id('')), # common details
495
299
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
496
300
              ('d', '', 0, False, rev_id), # first parent details
497
 
              ('d', '', 0, False, rev_id), # second parent details
 
301
              ('d', '', 0, False, rev_id2), # second parent details
498
302
             ]),
499
 
            (('', 'a file', 'a-file-id'), # common
 
303
            (('', 'a file', 'a file id'), # common
500
304
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
501
305
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
502
306
               rev_id), # first parent
507
311
        state = dirstate.DirState.from_tree(tree, 'dirstate')
508
312
        self.check_state_with_reopen(expected_result, state)
509
313
 
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
314
 
533
315
class TestDirStateOnFile(TestCaseWithDirState):
534
316
 
543
325
        # get a state object
544
326
        # no parents, default tree content
545
327
        expected_result = ([], [
546
 
            (('', '', tree.get_root_id()), # common details
 
328
            (('', '', tree.path2id('')), # common details
547
329
             # current tree details, but new from_tree skips statting, it
548
330
             # uses set_state_from_inventory, and thus depends on the
549
331
             # inventory state.
565
347
        finally:
566
348
            state.unlock()
567
349
 
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
350
 
709
351
class TestDirStateInitialize(TestCaseWithDirState):
710
352
 
718
360
        try:
719
361
            self.assertIsInstance(state, dirstate.DirState)
720
362
            lines = state.get_lines()
721
 
        finally:
 
363
            self.assertFileEqual(''.join(state.get_lines()),
 
364
                'dirstate')
 
365
            self.check_state_with_reopen(expected_result, state)
 
366
        except:
722
367
            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)
 
368
            raise
729
369
 
730
370
 
731
371
class TestDirStateManipulations(TestCaseWithDirState):
737
377
        try:
738
378
            tree1.add('')
739
379
            revid1 = tree1.commit('foo').encode('utf8')
740
 
            root_id = tree1.get_root_id()
 
380
            root_id = tree1.inventory.root.file_id
741
381
            inv = tree1.inventory
742
382
        finally:
743
383
            tree1.unlock()
758
398
            # This will unlock it
759
399
            self.check_state_with_reopen(expected_result, state)
760
400
 
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
401
    def test_set_path_id_no_parents(self):
866
402
        """The id of a path can be changed trivally with no parents."""
867
403
        state = dirstate.DirState.initialize('dirstate')
868
404
        try:
869
405
            # 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()
 
406
            self.assertEqual(
 
407
                [(('', '', 'TREE_ROOT'), [('d', '', 0, False,
 
408
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])],
 
409
                list(state._iter_entries()))
 
410
            state.set_path_id('', 'foobarbaz')
 
411
            expected_rows = [
 
412
                (('', '', 'foobarbaz'), [('d', '', 0, False,
 
413
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])]
 
414
            self.assertEqual(expected_rows, list(state._iter_entries()))
 
415
            # should work across save too
 
416
            state.save()
 
417
        finally:
 
418
            state.unlock()
 
419
        state = dirstate.DirState.on_file('dirstate')
 
420
        state.lock_read()
 
421
        try:
 
422
            self.assertEqual(expected_rows, list(state._iter_entries()))
958
423
        finally:
959
424
            state.unlock()
960
425
 
968
433
        finally:
969
434
            tree1.unlock()
970
435
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
971
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
436
        tree2 = MemoryTree.create_on_branch(branch2)
972
437
        tree2.lock_write()
973
438
        try:
974
439
            revid2 = tree2.commit('foo')
975
 
            root_id = tree2.get_root_id()
 
440
            root_id = tree2.inventory.root.file_id
976
441
        finally:
977
442
            tree2.unlock()
978
443
        state = dirstate.DirState.initialize('dirstate')
985
450
                ['ghost-rev'])
986
451
            # check we can reopen and use the dirstate after setting parent
987
452
            # trees.
988
 
            state._validate()
989
453
            state.save()
990
 
            state._validate()
991
454
        finally:
992
455
            state.unlock()
993
456
        state = dirstate.DirState.on_file('dirstate')
1006
469
            state.set_parent_trees(
1007
470
                ((revid1, tree1.branch.repository.revision_tree(revid1)),
1008
471
                 (revid2, tree2.branch.repository.revision_tree(revid2)),
1009
 
                 ('ghost-rev', tree2.branch.repository.revision_tree(
1010
 
                                   _mod_revision.NULL_REVISION))),
 
472
                 ('ghost-rev', tree2.branch.repository.revision_tree(None))),
1011
473
                ['ghost-rev'])
1012
474
            self.assertEqual([revid1, revid2, 'ghost-rev'],
1013
475
                             state.get_parent_ids())
1017
479
                [(('', '', root_id), [
1018
480
                  ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1019
481
                  ('d', '', 0, False, revid1),
1020
 
                  ('d', '', 0, False, revid1)
 
482
                  ('d', '', 0, False, revid2)
1021
483
                  ])],
1022
484
                list(state._iter_entries()))
1023
485
        finally:
1038
500
        finally:
1039
501
            tree1.unlock()
1040
502
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1041
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
503
        tree2 = MemoryTree.create_on_branch(branch2)
1042
504
        tree2.lock_write()
1043
505
        try:
1044
506
            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
1045
507
            revid2 = tree2.commit('foo')
1046
 
            root_id = tree2.get_root_id()
 
508
            root_id = tree2.inventory.root.file_id
1047
509
        finally:
1048
510
            tree2.unlock()
1049
511
        # check the layout in memory
1051
513
            (('', '', root_id), [
1052
514
             ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1053
515
             ('d', '', 0, False, revid1.encode('utf8')),
1054
 
             ('d', '', 0, False, revid1.encode('utf8'))
 
516
             ('d', '', 0, False, revid2.encode('utf8'))
1055
517
             ]),
1056
518
            (('', 'a file', 'file-id'), [
1057
519
             ('a', '', 0, False, ''),
1089
551
            (('', '', 'TREE_ROOT'), [
1090
552
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1091
553
             ]),
1092
 
            (('', 'a file', 'a-file-id'), [
 
554
            (('', 'a file', 'a file id'), [
1093
555
             ('f', '1'*20, 19, False, dirstate.pack_stat(stat)), # current tree
1094
556
             ]),
1095
557
            ]
1096
558
        try:
1097
 
            state.add('a file', 'a-file-id', 'file', stat, '1'*20)
 
559
            state.add('a file', 'a file id', 'file', stat, '1'*20)
1098
560
            # having added it, it should be in the output of iter_entries.
1099
561
            self.assertEqual(expected_entries, list(state._iter_entries()))
1100
562
            # saving and reloading should not affect this.
1103
565
            state.unlock()
1104
566
        state = dirstate.DirState.on_file('dirstate')
1105
567
        state.lock_read()
1106
 
        self.addCleanup(state.unlock)
1107
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
568
        try:
 
569
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
570
        finally:
 
571
            state.unlock()
1108
572
 
1109
573
    def test_add_path_to_unversioned_directory(self):
1110
574
        """Adding a path to an unversioned directory should error.
1115
579
        """
1116
580
        self.build_tree(['unversioned/', 'unversioned/a file'])
1117
581
        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)
 
582
        try:
 
583
            self.assertRaises(errors.NotVersionedError, state.add,
 
584
                'unversioned/a file', 'a file id', 'file', None, None)
 
585
        finally:
 
586
            state.unlock()
1121
587
 
1122
588
    def test_add_directory_to_root_no_parents_all_data(self):
1123
589
        # The most trivial addition of a dir is when there are no parents and
1143
609
            state.unlock()
1144
610
        state = dirstate.DirState.on_file('dirstate')
1145
611
        state.lock_read()
1146
 
        self.addCleanup(state.unlock)
1147
 
        state._validate()
1148
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
612
        try:
 
613
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
614
        finally:
 
615
            state.unlock()
1149
616
 
1150
 
    def _test_add_symlink_to_root_no_parents_all_data(self, link_name, target):
 
617
    def test_add_symlink_to_root_no_parents_all_data(self):
1151
618
        # The most trivial addition of a symlink when there are no parents and
1152
619
        # 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)
 
620
        ## TODO: windows: dont fail this test. Also, how are symlinks meant to
 
621
        # be represented on windows.
 
622
        os.symlink('target', 'a link')
 
623
        stat = os.lstat('a link')
1157
624
        expected_entries = [
1158
625
            (('', '', 'TREE_ROOT'), [
1159
626
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1160
627
             ]),
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
 
628
            (('', 'a link', 'a link id'), [
 
629
             ('l', 'target', 6, False, dirstate.pack_stat(stat)), # current tree
1164
630
             ]),
1165
631
            ]
1166
632
        state = dirstate.DirState.initialize('dirstate')
1167
633
        try:
1168
 
            state.add(link_name, 'a link id', 'symlink', stat,
1169
 
                      target.encode('UTF-8'))
 
634
            state.add('a link', 'a link id', 'symlink', stat, 'target')
1170
635
            # having added it, it should be in the output of iter_entries.
1171
636
            self.assertEqual(expected_entries, list(state._iter_entries()))
1172
637
            # saving and reloading should not affect this.
1175
640
            state.unlock()
1176
641
        state = dirstate.DirState.on_file('dirstate')
1177
642
        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')
 
643
        try:
 
644
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
645
        finally:
 
646
            state.unlock()
1188
647
 
1189
648
    def test_add_directory_and_child_no_parents_all_data(self):
1190
649
        # after adding a directory, we should be able to add children to it.
1198
657
            (('', 'a dir', 'a dir id'), [
1199
658
             ('d', '', 0, False, dirstate.pack_stat(dirstat)), # current tree
1200
659
             ]),
1201
 
            (('a dir', 'a file', 'a-file-id'), [
 
660
            (('a dir', 'a file', 'a file id'), [
1202
661
             ('f', '1'*20, 25, False,
1203
662
              dirstate.pack_stat(filestat)), # current tree details
1204
663
             ]),
1206
665
        state = dirstate.DirState.initialize('dirstate')
1207
666
        try:
1208
667
            state.add('a dir', 'a dir id', 'directory', dirstat, None)
1209
 
            state.add('a dir/a file', 'a-file-id', 'file', filestat, '1'*20)
 
668
            state.add('a dir/a file', 'a file id', 'file', filestat, '1'*20)
1210
669
            # added it, it should be in the output of iter_entries.
1211
670
            self.assertEqual(expected_entries, list(state._iter_entries()))
1212
671
            # saving and reloading should not affect this.
1215
674
            state.unlock()
1216
675
        state = dirstate.DirState.on_file('dirstate')
1217
676
        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
677
        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()
 
678
            self.assertEqual(expected_entries, list(state._iter_entries()))
1235
679
        finally:
1236
680
            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
681
 
1288
682
 
1289
683
class TestGetLines(TestCaseWithDirState):
1291
685
    def test_get_line_with_2_rows(self):
1292
686
        state = self.create_dirstate_with_root_and_subdir()
1293
687
        try:
1294
 
            self.assertEqual(['#bazaar dirstate flat format 3\n',
1295
 
                'crc32: 41262208\n',
 
688
            self.assertEqual(['#bazaar dirstate flat format 2\n',
 
689
                'adler32: -1327947603\n',
1296
690
                'num_entries: 2\n',
1297
691
                '0\x00\n\x00'
1298
692
                '0\x00\n\x00'
1503
897
            state.unlock()
1504
898
 
1505
899
 
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):
1623
 
    """Test that DirState adds entries in the right order."""
1624
 
 
1625
 
    def test_add_sorting(self):
1626
 
        """Add entries in lexicographical order, we get path sorted order.
1627
 
 
1628
 
        This tests it to a depth of 4, to make sure we don't just get it right
1629
 
        at a single depth. 'a/a' should come before 'a-a', even though it
1630
 
        doesn't lexicographically.
1631
 
        """
1632
 
        dirs = ['a', 'a/a', 'a/a/a', 'a/a/a/a',
1633
 
                'a-a', 'a/a-a', 'a/a/a-a', 'a/a/a/a-a',
1634
 
               ]
1635
 
        null_sha = ''
1636
 
        state = dirstate.DirState.initialize('dirstate')
1637
 
        self.addCleanup(state.unlock)
1638
 
 
1639
 
        fake_stat = os.stat('dirstate')
1640
 
        for d in dirs:
1641
 
            d_id = d.replace('/', '_')+'-id'
1642
 
            file_path = d + '/f'
1643
 
            file_id = file_path.replace('/', '_')+'-id'
1644
 
            state.add(d, d_id, 'directory', fake_stat, null_sha)
1645
 
            state.add(file_path, file_id, 'file', fake_stat, null_sha)
1646
 
 
1647
 
        expected = ['', '', 'a',
1648
 
                'a/a', 'a/a/a', 'a/a/a/a',
1649
 
                'a/a/a/a-a', 'a/a/a-a', 'a/a-a', 'a-a',
1650
 
               ]
1651
 
        split = lambda p:p.split('/')
1652
 
        self.assertEqual(sorted(expected, key=split), expected)
1653
 
        dirblock_names = [d[0] for d in state._dirblocks]
1654
 
        self.assertEqual(expected, dirblock_names)
1655
 
 
1656
 
    def test_set_parent_trees_correct_order(self):
1657
 
        """After calling set_parent_trees() we should maintain the order."""
1658
 
        dirs = ['a', 'a-a', 'a/a']
1659
 
        null_sha = ''
1660
 
        state = dirstate.DirState.initialize('dirstate')
1661
 
        self.addCleanup(state.unlock)
1662
 
 
1663
 
        fake_stat = os.stat('dirstate')
1664
 
        for d in dirs:
1665
 
            d_id = d.replace('/', '_')+'-id'
1666
 
            file_path = d + '/f'
1667
 
            file_id = file_path.replace('/', '_')+'-id'
1668
 
            state.add(d, d_id, 'directory', fake_stat, null_sha)
1669
 
            state.add(file_path, file_id, 'file', fake_stat, null_sha)
1670
 
 
1671
 
        expected = ['', '', 'a', 'a/a', 'a-a']
1672
 
        dirblock_names = [d[0] for d in state._dirblocks]
1673
 
        self.assertEqual(expected, dirblock_names)
1674
 
 
1675
 
        # *really* cheesy way to just get an empty tree
1676
 
        repo = self.make_repository('repo')
1677
 
        empty_tree = repo.revision_tree(_mod_revision.NULL_REVISION)
1678
 
        state.set_parent_trees([('null:', empty_tree)], [])
1679
 
 
1680
 
        dirblock_names = [d[0] for d in state._dirblocks]
1681
 
        self.assertEqual(expected, dirblock_names)
1682
 
 
1683
 
 
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):
 
900
class TestBisect(TestCaseWithTransport):
1797
901
    """Test the ability to bisect into the disk format."""
1798
902
 
 
903
    def create_basic_dirstate(self):
 
904
        """Create a dirstate with a few files and directories.
 
905
 
 
906
            a
 
907
            b/
 
908
              c
 
909
              d/
 
910
                e
 
911
            f
 
912
        """
 
913
        tree = self.make_branch_and_tree('tree')
 
914
        paths = ['a', 'b/', 'b/c', 'b/d/', 'b/d/e', 'f']
 
915
        file_ids = ['a-id', 'b-id', 'c-id', 'd-id', 'e-id', 'f-id']
 
916
        self.build_tree(['tree/' + p for p in paths])
 
917
        tree.set_root_id('TREE_ROOT')
 
918
        tree.add([p.rstrip('/') for p in paths], file_ids)
 
919
        tree.commit('initial', rev_id='rev-1')
 
920
        revision_id = 'rev-1'
 
921
        # a_packed_stat = dirstate.pack_stat(os.stat('tree/a'))
 
922
        t = self.get_transport().clone('tree')
 
923
        a_text = t.get_bytes('a')
 
924
        a_sha = osutils.sha_string(a_text)
 
925
        a_len = len(a_text)
 
926
        # b_packed_stat = dirstate.pack_stat(os.stat('tree/b'))
 
927
        # c_packed_stat = dirstate.pack_stat(os.stat('tree/b/c'))
 
928
        c_text = t.get_bytes('b/c')
 
929
        c_sha = osutils.sha_string(c_text)
 
930
        c_len = len(c_text)
 
931
        # d_packed_stat = dirstate.pack_stat(os.stat('tree/b/d'))
 
932
        # e_packed_stat = dirstate.pack_stat(os.stat('tree/b/d/e'))
 
933
        e_text = t.get_bytes('b/d/e')
 
934
        e_sha = osutils.sha_string(e_text)
 
935
        e_len = len(e_text)
 
936
        # f_packed_stat = dirstate.pack_stat(os.stat('tree/f'))
 
937
        f_text = t.get_bytes('f')
 
938
        f_sha = osutils.sha_string(f_text)
 
939
        f_len = len(f_text)
 
940
        null_stat = dirstate.DirState.NULLSTAT
 
941
        expected = {
 
942
            '':(('', '', 'TREE_ROOT'), [
 
943
                  ('d', '', 0, False, null_stat),
 
944
                  ('d', '', 0, False, revision_id),
 
945
                ]),
 
946
            'a':(('', 'a', 'a-id'), [
 
947
                   ('f', '', 0, False, null_stat),
 
948
                   ('f', a_sha, a_len, False, revision_id),
 
949
                 ]),
 
950
            'b':(('', 'b', 'b-id'), [
 
951
                  ('d', '', 0, False, null_stat),
 
952
                  ('d', '', 0, False, revision_id),
 
953
                 ]),
 
954
            'b/c':(('b', 'c', 'c-id'), [
 
955
                    ('f', '', 0, False, null_stat),
 
956
                    ('f', c_sha, c_len, False, revision_id),
 
957
                   ]),
 
958
            'b/d':(('b', 'd', 'd-id'), [
 
959
                    ('d', '', 0, False, null_stat),
 
960
                    ('d', '', 0, False, revision_id),
 
961
                   ]),
 
962
            'b/d/e':(('b/d', 'e', 'e-id'), [
 
963
                      ('f', '', 0, False, null_stat),
 
964
                      ('f', e_sha, e_len, False, revision_id),
 
965
                     ]),
 
966
            'f':(('', 'f', 'f-id'), [
 
967
                  ('f', '', 0, False, null_stat),
 
968
                  ('f', f_sha, f_len, False, revision_id),
 
969
                 ]),
 
970
        }
 
971
        state = dirstate.DirState.from_tree(tree, 'dirstate')
 
972
        try:
 
973
            state.save()
 
974
        finally:
 
975
            state.unlock()
 
976
        # Use a different object, to make sure nothing is pre-cached in memory.
 
977
        state = dirstate.DirState.on_file('dirstate')
 
978
        state.lock_read()
 
979
        self.addCleanup(state.unlock)
 
980
        self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
 
981
                         state._dirblock_state)
 
982
        # This is code is only really tested if we actually have to make more
 
983
        # than one read, so set the page size to something smaller.
 
984
        # We want it to contain about 2.2 records, so that we have a couple
 
985
        # records that we can read per attempt
 
986
        state._bisect_page_size = 200
 
987
        return tree, state, expected
 
988
 
 
989
    def create_duplicated_dirstate(self):
 
990
        """Create a dirstate with a deleted and added entries.
 
991
 
 
992
        This grabs a basic_dirstate, and then removes and re adds every entry
 
993
        with a new file id.
 
994
        """
 
995
        tree, state, expected = self.create_basic_dirstate()
 
996
        # Now we will just remove and add every file so we get an extra entry
 
997
        # per entry. Unversion in reverse order so we handle subdirs
 
998
        tree.unversion(['f-id', 'e-id', 'd-id', 'c-id', 'b-id', 'a-id'])
 
999
        tree.add(['a', 'b', 'b/c', 'b/d', 'b/d/e', 'f'],
 
1000
                 ['a-id2', 'b-id2', 'c-id2', 'd-id2', 'e-id2', 'f-id2'])
 
1001
 
 
1002
        # Update the expected dictionary.
 
1003
        for path in ['a', 'b', 'b/c', 'b/d', 'b/d/e', 'f']:
 
1004
            orig = expected[path]
 
1005
            path2 = path + '2'
 
1006
            # This record was deleted in the current tree
 
1007
            expected[path] = (orig[0], [dirstate.DirState.NULL_PARENT_DETAILS,
 
1008
                                        orig[1][1]])
 
1009
            new_key = (orig[0][0], orig[0][1], orig[0][2]+'2')
 
1010
            # And didn't exist in the basis tree
 
1011
            expected[path2] = (new_key, [orig[1][0],
 
1012
                                         dirstate.DirState.NULL_PARENT_DETAILS])
 
1013
 
 
1014
        # We will replace the 'dirstate' file underneath 'state', but that is
 
1015
        # okay as lock as we unlock 'state' first.
 
1016
        state.unlock()
 
1017
        try:
 
1018
            new_state = dirstate.DirState.from_tree(tree, 'dirstate')
 
1019
            try:
 
1020
                new_state.save()
 
1021
            finally:
 
1022
                new_state.unlock()
 
1023
        finally:
 
1024
            # But we need to leave state in a read-lock because we already have
 
1025
            # a cleanup scheduled
 
1026
            state.lock_read()
 
1027
        return tree, state, expected
 
1028
 
 
1029
    def create_renamed_dirstate(self):
 
1030
        """Create a dirstate with a few internal renames.
 
1031
 
 
1032
        This takes the basic dirstate, and moves the paths around.
 
1033
        """
 
1034
        tree, state, expected = self.create_basic_dirstate()
 
1035
        # Rename a file
 
1036
        tree.rename_one('a', 'b/g')
 
1037
        # And a directory
 
1038
        tree.rename_one('b/d', 'h')
 
1039
 
 
1040
        old_a = expected['a']
 
1041
        expected['a'] = (old_a[0], [('r', 'b/g', 0, False, ''), old_a[1][1]])
 
1042
        expected['b/g'] = (('b', 'g', 'a-id'), [old_a[1][0],
 
1043
                                                ('r', 'a', 0, False, '')])
 
1044
        old_d = expected['b/d']
 
1045
        expected['b/d'] = (old_d[0], [('r', 'h', 0, False, ''), old_d[1][1]])
 
1046
        expected['h'] = (('', 'h', 'd-id'), [old_d[1][0],
 
1047
                                             ('r', 'b/d', 0, False, '')])
 
1048
 
 
1049
        old_e = expected['b/d/e']
 
1050
        expected['b/d/e'] = (old_e[0], [('r', 'h/e', 0, False, ''),
 
1051
                             old_e[1][1]])
 
1052
        expected['h/e'] = (('h', 'e', 'e-id'), [old_e[1][0],
 
1053
                                                ('r', 'b/d/e', 0, False, '')])
 
1054
 
 
1055
        state.unlock()
 
1056
        try:
 
1057
            new_state = dirstate.DirState.from_tree(tree, 'dirstate')
 
1058
            try:
 
1059
                new_state.save()
 
1060
            finally:
 
1061
                new_state.unlock()
 
1062
        finally:
 
1063
            state.lock_read()
 
1064
        return tree, state, expected
 
1065
 
1799
1066
    def assertBisect(self, expected_map, map_keys, state, paths):
1800
1067
        """Assert that bisecting for paths returns the right result.
1801
1068
 
1806
1073
                      (dir, name) tuples, and sorted according to how _bisect
1807
1074
                      requires.
1808
1075
        """
1809
 
        result = state._bisect(paths)
 
1076
        dir_names = sorted(osutils.split(p) for p in paths)
 
1077
        result = state._bisect(dir_names)
1810
1078
        # For now, results are just returned in whatever order we read them.
1811
1079
        # We could sort by (dir, name, file_id) or something like that, but in
1812
1080
        # the end it would still be fairly arbitrary, and we don't want the
1813
1081
        # extra overhead if we can avoid it. So sort everything to make sure
1814
1082
        # equality is true
1815
 
        self.assertEqual(len(map_keys), len(paths))
 
1083
        assert len(map_keys) == len(dir_names)
1816
1084
        expected = {}
1817
 
        for path, keys in zip(paths, map_keys):
 
1085
        for dir_name, keys in zip(dir_names, map_keys):
1818
1086
            if keys is None:
1819
1087
                # This should not be present in the output
1820
1088
                continue
1821
 
            expected[path] = sorted(expected_map[k] for k in keys)
 
1089
            expected[dir_name] = sorted(expected_map[k] for k in keys)
1822
1090
 
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()
 
1091
        for dir_name in result:
 
1092
            result[dir_name].sort()
1827
1093
 
1828
1094
        self.assertEqual(expected, result)
1829
1095
 
1837
1103
        :param paths: A list of directories
1838
1104
        """
1839
1105
        result = state._bisect_dirblocks(paths)
1840
 
        self.assertEqual(len(map_keys), len(paths))
 
1106
        assert len(map_keys) == len(paths)
 
1107
 
1841
1108
        expected = {}
1842
1109
        for path, keys in zip(paths, map_keys):
1843
1110
            if keys is None:
1865
1132
            dir_name_id, trees_info = entry
1866
1133
            expected[dir_name_id] = trees_info
1867
1134
 
1868
 
        result = state._bisect_recursive(paths)
 
1135
        dir_names = sorted(osutils.split(p) for p in paths)
 
1136
        result = state._bisect_recursive(dir_names)
1869
1137
 
1870
1138
        self.assertEqual(expected, result)
1871
1139
 
1880
1148
        self.assertBisect(expected, [['b/c']], state, ['b/c'])
1881
1149
        self.assertBisect(expected, [['b/d']], state, ['b/d'])
1882
1150
        self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
1883
 
        self.assertBisect(expected, [['b-c']], state, ['b-c'])
1884
1151
        self.assertBisect(expected, [['f']], state, ['f'])
1885
1152
 
1886
1153
    def test_bisect_multi(self):
1889
1156
        # Bisect should be capable of finding multiple entries at the same time
1890
1157
        self.assertBisect(expected, [['a'], ['b'], ['f']],
1891
1158
                          state, ['a', 'b', 'f'])
 
1159
        # ('', 'f') sorts before the others
1892
1160
        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'])
 
1161
                          state, ['b/d', 'b/d/e', 'f'])
1896
1162
 
1897
1163
    def test_bisect_one_page(self):
1898
1164
        """Test bisect when there is only 1 page to read"""
1904
1170
        self.assertBisect(expected,[['b/c']], state, ['b/c'])
1905
1171
        self.assertBisect(expected,[['b/d']], state, ['b/d'])
1906
1172
        self.assertBisect(expected,[['b/d/e']], state, ['b/d/e'])
1907
 
        self.assertBisect(expected,[['b-c']], state, ['b-c'])
1908
1173
        self.assertBisect(expected,[['f']], state, ['f'])
1909
1174
        self.assertBisect(expected,[['a'], ['b'], ['f']],
1910
1175
                          state, ['a', 'b', 'f'])
1911
 
        self.assertBisect(expected, [['b/d'], ['b/d/e'], ['f']],
 
1176
        # ('', 'f') sorts before the others
 
1177
        self.assertBisect(expected, [['f'], ['b/d'], ['b/d/e']],
1912
1178
                          state, ['b/d', 'b/d/e', 'f'])
1913
 
        self.assertBisect(expected, [['b'], ['b/c'], ['b-c']],
1914
 
                          state, ['b', 'b/c', 'b-c'])
1915
1179
 
1916
1180
    def test_bisect_duplicate_paths(self):
1917
1181
        """When bisecting for a path, handle multiple entries."""
1925
1189
        self.assertBisect(expected, [['b/d', 'b/d2']], state, ['b/d'])
1926
1190
        self.assertBisect(expected, [['b/d/e', 'b/d/e2']],
1927
1191
                          state, ['b/d/e'])
1928
 
        self.assertBisect(expected, [['b-c', 'b-c2']], state, ['b-c'])
1929
1192
        self.assertBisect(expected, [['f', 'f2']], state, ['f'])
1930
1193
 
1931
1194
    def test_bisect_page_size_too_small(self):
1938
1201
        self.assertBisect(expected, [['b/c']], state, ['b/c'])
1939
1202
        self.assertBisect(expected, [['b/d']], state, ['b/d'])
1940
1203
        self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
1941
 
        self.assertBisect(expected, [['b-c']], state, ['b-c'])
1942
1204
        self.assertBisect(expected, [['f']], state, ['f'])
1943
1205
 
1944
1206
    def test_bisect_missing(self):
1947
1209
        self.assertBisect(expected, [None], state, ['foo'])
1948
1210
        self.assertBisect(expected, [None], state, ['b/foo'])
1949
1211
        self.assertBisect(expected, [None], state, ['bar/foo'])
1950
 
        self.assertBisect(expected, [None], state, ['b-c/foo'])
1951
1212
 
1952
1213
        self.assertBisect(expected, [['a'], None, ['b/d']],
1953
1214
                          state, ['a', 'foo', 'b/d'])
1969
1230
    def test_bisect_dirblocks(self):
1970
1231
        tree, state, expected = self.create_duplicated_dirstate()
1971
1232
        self.assertBisectDirBlocks(expected,
1972
 
            [['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2']],
1973
 
            state, [''])
 
1233
            [['', 'a', 'a2', 'b', 'b2', 'f', 'f2']], state, [''])
1974
1234
        self.assertBisectDirBlocks(expected,
1975
1235
            [['b/c', 'b/c2', 'b/d', 'b/d2']], state, ['b'])
1976
1236
        self.assertBisectDirBlocks(expected,
1977
1237
            [['b/d/e', 'b/d/e2']], state, ['b/d'])
1978
1238
        self.assertBisectDirBlocks(expected,
1979
 
            [['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2'],
 
1239
            [['', 'a', 'a2', 'b', 'b2', 'f', 'f2'],
1980
1240
             ['b/c', 'b/c2', 'b/d', 'b/d2'],
1981
1241
             ['b/d/e', 'b/d/e2'],
1982
1242
            ], state, ['', 'b', 'b/d'])
1997
1257
        self.assertBisectRecursive(expected, ['a'], state, ['a'])
1998
1258
        self.assertBisectRecursive(expected, ['b/c'], state, ['b/c'])
1999
1259
        self.assertBisectRecursive(expected, ['b/d/e'], state, ['b/d/e'])
2000
 
        self.assertBisectRecursive(expected, ['b-c'], state, ['b-c'])
2001
1260
        self.assertBisectRecursive(expected, ['b/d', 'b/d/e'],
2002
1261
                                   state, ['b/d'])
2003
1262
        self.assertBisectRecursive(expected, ['b', 'b/c', 'b/d', 'b/d/e'],
2004
1263
                                   state, ['b'])
2005
 
        self.assertBisectRecursive(expected, ['', 'a', 'b', 'b-c', 'f', 'b/c',
 
1264
        self.assertBisectRecursive(expected, ['', 'a', 'b', 'f', 'b/c',
2006
1265
                                              'b/d', 'b/d/e'],
2007
1266
                                   state, [''])
2008
1267
 
2031
1290
                                              'b/d/e', 'b/g', 'h', 'h/e'],
2032
1291
                                   state, ['b'])
2033
1292
 
2034
 
 
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)