/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

merge from dirstate

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
 
from bzrlib import (
23
 
    dirstate,
24
 
    errors,
25
 
    inventory,
26
 
    memorytree,
27
 
    osutils,
28
 
    revision as _mod_revision,
29
 
    tests,
30
 
    )
31
 
from bzrlib.tests import test_osutils
 
21
from bzrlib import dirstate, errors
 
22
from bzrlib.dirstate import DirState
 
23
from bzrlib.memorytree import MemoryTree
 
24
from bzrlib.tests import TestCaseWithTransport
32
25
 
33
26
 
34
27
# TODO:
 
28
# test DirStateRevisionTree : test filtering out of deleted files does not
 
29
#         filter out files called RECYCLED.BIN ;)
 
30
# test 0 parents, 1 parent, 4 parents.
 
31
# test unicode parents, non unicode parents
 
32
# test all change permutations in one and two parents.
 
33
# i.e. file in parent 1, dir in parent 2, symlink in tree.
 
34
# test that renames in the tree result in correct parent paths 
 
35
# Test get state from a file, then asking for lines.
 
36
# write a smaller state, and check the file has been truncated.
 
37
# add a entry when its in state deleted
 
38
# revision attribute for root entries.
 
39
# test that utf8 strings are preserved in _row_to_line
 
40
# test parent manipulation 
 
41
# test parents that are null in save : i.e. no record in the parent tree for this.
 
42
# todo: _set_data records ghost parents.
35
43
# TESTS to write:
36
44
# general checks for NOT_IN_MEMORY error conditions.
37
45
# set_path_id on a NOT_IN_MEMORY dirstate
43
51
# set_path_id  setting id when state is in memory unmodified
44
52
# set_path_id  setting id when state is in memory modified
45
53
 
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):
 
54
class TestCaseWithDirState(TestCaseWithTransport):
58
55
    """Helper functions for creating DirState objects with various content."""
59
56
 
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
57
    def create_empty_dirstate(self):
71
58
        """Return a locked but empty dirstate"""
72
59
        state = dirstate.DirState.initialize('dirstate')
84
71
        state = self.create_empty_dirstate()
85
72
        try:
86
73
            state._set_data([], dirblocks)
87
 
            state._validate()
88
74
        except:
89
75
            state.unlock()
90
76
            raise
119
105
         b/g      g-file
120
106
         b/h\xc3\xa5  h-\xc3\xa5-file  #This is u'\xe5' encoded into utf-8
121
107
 
122
 
        Notice that a/e is an empty directory.
123
 
 
124
 
        :return: The dirstate, still write-locked.
 
108
        # Notice that a/e is an empty directory.
125
109
        """
126
110
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
127
111
        null_sha = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
158
142
        dirblocks.append(('a', [e_entry, f_entry]))
159
143
        dirblocks.append(('b', [g_entry, h_entry]))
160
144
        state = dirstate.DirState.initialize('dirstate')
161
 
        state._validate()
162
145
        try:
163
146
            state._set_data([], dirblocks)
164
147
        except:
180
163
        """
181
164
        # The state should already be write locked, since we just had to do
182
165
        # some operation to get here.
183
 
        self.assertTrue(state._lock_token is not None)
 
166
        assert state._lock_token is not None
184
167
        try:
185
168
            self.assertEqual(expected_result[0],  state.get_parent_ids())
186
169
            # there should be no ghosts in this tree.
190
173
            state.save()
191
174
        finally:
192
175
            state.unlock()
193
 
        del state
 
176
        del state # Callers should unlock
194
177
        state = dirstate.DirState.on_file('dirstate')
195
178
        state.lock_read()
196
179
        try:
198
181
        finally:
199
182
            state.unlock()
200
183
 
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
184
 
373
185
class TestTreeToDirState(TestCaseWithDirState):
374
186
 
377
189
        # There are no files on disk and no parents
378
190
        tree = self.make_branch_and_tree('tree')
379
191
        expected_result = ([], [
380
 
            (('', '', tree.get_root_id()), # common details
381
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
192
            (('', '', tree.path2id('')), # common details
 
193
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree details
382
194
             ])])
383
195
        state = dirstate.DirState.from_tree(tree, 'dirstate')
384
 
        state._validate()
385
196
        self.check_state_with_reopen(expected_result, state)
386
197
 
387
198
    def test_1_parents_empty_to_dirstate(self):
390
201
        rev_id = tree.commit('first post').encode('utf8')
391
202
        root_stat_pack = dirstate.pack_stat(os.stat(tree.basedir))
392
203
        expected_result = ([rev_id], [
393
 
            (('', '', tree.get_root_id()), # common details
394
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
204
            (('', '', tree.path2id('')), # common details
 
205
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree details
395
206
              ('d', '', 0, False, rev_id), # first parent details
396
207
             ])])
397
208
        state = dirstate.DirState.from_tree(tree, 'dirstate')
398
209
        self.check_state_with_reopen(expected_result, state)
399
 
        state.lock_read()
400
 
        try:
401
 
            state._validate()
402
 
        finally:
403
 
            state.unlock()
404
210
 
405
211
    def test_2_parents_empty_to_dirstate(self):
406
212
        # create a parent by doing a commit
410
216
        rev_id2 = tree2.commit('second post', allow_pointless=True)
411
217
        tree.merge_from_branch(tree2.branch)
412
218
        expected_result = ([rev_id, rev_id2], [
413
 
            (('', '', tree.get_root_id()), # common details
414
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
219
            (('', '', tree.path2id('')), # common details
 
220
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree details
415
221
              ('d', '', 0, False, rev_id), # first parent details
416
 
              ('d', '', 0, False, rev_id), # second parent details
 
222
              ('d', '', 0, False, rev_id2), # second parent details
417
223
             ])])
418
224
        state = dirstate.DirState.from_tree(tree, 'dirstate')
419
225
        self.check_state_with_reopen(expected_result, state)
420
 
        state.lock_read()
421
 
        try:
422
 
            state._validate()
423
 
        finally:
424
 
            state.unlock()
425
226
 
426
227
    def test_empty_unknowns_are_ignored_to_dirstate(self):
427
228
        """We should be able to create a dirstate for an empty tree."""
429
230
        tree = self.make_branch_and_tree('tree')
430
231
        self.build_tree(['tree/unknown'])
431
232
        expected_result = ([], [
432
 
            (('', '', tree.get_root_id()), # common details
433
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
233
            (('', '', tree.path2id('')), # common details
 
234
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree details
434
235
             ])])
435
236
        state = dirstate.DirState.from_tree(tree, 'dirstate')
436
237
        self.check_state_with_reopen(expected_result, state)
438
239
    def get_tree_with_a_file(self):
439
240
        tree = self.make_branch_and_tree('tree')
440
241
        self.build_tree(['tree/a file'])
441
 
        tree.add('a file', 'a-file-id')
 
242
        tree.add('a file', 'a file id')
442
243
        return tree
443
244
 
444
245
    def test_non_empty_no_parents_to_dirstate(self):
446
247
        # There are files on disk and no parents
447
248
        tree = self.get_tree_with_a_file()
448
249
        expected_result = ([], [
449
 
            (('', '', tree.get_root_id()), # common details
450
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
250
            (('', '', tree.path2id('')), # common details
 
251
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree details
451
252
             ]),
452
 
            (('', 'a file', 'a-file-id'), # common
 
253
            (('', 'a file', 'a file id'), # common
453
254
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
454
255
             ]),
455
256
            ])
464
265
        # and length:
465
266
        self.build_tree_contents([('tree/a file', 'new content\n')])
466
267
        expected_result = ([rev_id], [
467
 
            (('', '', tree.get_root_id()), # common details
468
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
268
            (('', '', tree.path2id('')), # common details
 
269
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree details
469
270
              ('d', '', 0, False, rev_id), # first parent details
470
271
             ]),
471
 
            (('', 'a file', 'a-file-id'), # common
 
272
            (('', 'a file', 'a file id'), # common
472
273
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
473
 
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
474
 
               rev_id), # first parent
 
274
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False, rev_id), # first parent
475
275
             ]),
476
276
            ])
477
277
        state = dirstate.DirState.from_tree(tree, 'dirstate')
491
291
        # and length again, giving us three distinct values:
492
292
        self.build_tree_contents([('tree/a file', 'new content\n')])
493
293
        expected_result = ([rev_id, rev_id2], [
494
 
            (('', '', tree.get_root_id()), # common details
495
 
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
294
            (('', '', tree.path2id('')), # common details
 
295
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree details
496
296
              ('d', '', 0, False, rev_id), # first parent details
497
 
              ('d', '', 0, False, rev_id), # second parent details
 
297
              ('d', '', 0, False, rev_id2), # second parent details
498
298
             ]),
499
 
            (('', 'a file', 'a-file-id'), # common
 
299
            (('', 'a file', 'a file id'), # common
500
300
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
501
 
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
502
 
               rev_id), # first parent
503
 
              ('f', '314d796174c9412647c3ce07dfb5d36a94e72958', 14, False,
504
 
               rev_id2), # second parent
 
301
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False, rev_id), # first parent
 
302
              ('f', '314d796174c9412647c3ce07dfb5d36a94e72958', 14, False, rev_id2), # second parent
505
303
             ]),
506
304
            ])
507
305
        state = dirstate.DirState.from_tree(tree, 'dirstate')
508
306
        self.check_state_with_reopen(expected_result, state)
509
307
 
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
308
 
533
309
class TestDirStateOnFile(TestCaseWithDirState):
534
310
 
543
319
        # get a state object
544
320
        # no parents, default tree content
545
321
        expected_result = ([], [
546
 
            (('', '', tree.get_root_id()), # common details
 
322
            (('', '', tree.path2id('')), # common details
547
323
             # current tree details, but new from_tree skips statting, it
548
324
             # uses set_state_from_inventory, and thus depends on the
549
325
             # inventory state.
560
336
        try:
561
337
            # doing a save should work here as there have been no changes.
562
338
            state.save()
563
 
            # TODO: stat it and check it hasn't changed; may require waiting
564
 
            # for the state accuracy window.
565
 
        finally:
566
 
            state.unlock()
567
 
 
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)
 
339
            # TODO: stat it and check it hasn't changed; may require waiting for
 
340
            # the state accuracy window.
705
341
        finally:
706
342
            state.unlock()
707
343
 
718
354
        try:
719
355
            self.assertIsInstance(state, dirstate.DirState)
720
356
            lines = state.get_lines()
721
 
        finally:
 
357
            self.assertFileEqual(''.join(state.get_lines()),
 
358
                'dirstate')
 
359
            self.check_state_with_reopen(expected_result, state)
 
360
        except:
722
361
            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)
 
362
            raise
729
363
 
730
364
 
731
365
class TestDirStateManipulations(TestCaseWithDirState):
737
371
        try:
738
372
            tree1.add('')
739
373
            revid1 = tree1.commit('foo').encode('utf8')
740
 
            root_id = tree1.get_root_id()
 
374
            root_id = tree1.inventory.root.file_id
741
375
            inv = tree1.inventory
742
376
        finally:
743
377
            tree1.unlock()
744
378
        expected_result = [], [
745
379
            (('', '', root_id), [
746
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT)])]
 
380
             ('d', '', 0, False, DirState.NULLSTAT)])]
747
381
        state = dirstate.DirState.initialize('dirstate')
748
382
        try:
749
383
            state.set_state_from_inventory(inv)
750
 
            self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
751
 
                             state._header_state)
752
 
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
753
 
                             state._dirblock_state)
 
384
            self.assertEqual(DirState.IN_MEMORY_UNMODIFIED, state._header_state)
 
385
            self.assertEqual(DirState.IN_MEMORY_MODIFIED, state._dirblock_state)
754
386
        except:
755
387
            state.unlock()
756
388
            raise
758
390
            # This will unlock it
759
391
            self.check_state_with_reopen(expected_result, state)
760
392
 
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
393
    def test_set_path_id_no_parents(self):
866
394
        """The id of a path can be changed trivally with no parents."""
867
395
        state = dirstate.DirState.initialize('dirstate')
868
396
        try:
869
397
            # 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()
 
398
            self.assertEqual(
 
399
                [(('', '', 'TREE_ROOT'), [('d', '', 0, False, 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])],
 
400
                list(state._iter_entries()))
 
401
            state.set_path_id('', 'foobarbaz')
 
402
            expected_rows = [
 
403
                (('', '', 'foobarbaz'), [('d', '', 0, False, 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])]
 
404
            self.assertEqual(expected_rows, list(state._iter_entries()))
 
405
            # should work across save too
 
406
            state.save()
 
407
        finally:
 
408
            state.unlock()
 
409
        state = dirstate.DirState.on_file('dirstate')
 
410
        state.lock_read()
 
411
        try:
 
412
            self.assertEqual(expected_rows, list(state._iter_entries()))
958
413
        finally:
959
414
            state.unlock()
960
415
 
968
423
        finally:
969
424
            tree1.unlock()
970
425
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
971
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
426
        tree2 = MemoryTree.create_on_branch(branch2)
972
427
        tree2.lock_write()
973
428
        try:
974
429
            revid2 = tree2.commit('foo')
975
 
            root_id = tree2.get_root_id()
 
430
            root_id = tree2.inventory.root.file_id
976
431
        finally:
977
432
            tree2.unlock()
978
433
        state = dirstate.DirState.initialize('dirstate')
983
438
                 (revid2, tree2.branch.repository.revision_tree(revid2)),
984
439
                 ('ghost-rev', None)),
985
440
                ['ghost-rev'])
986
 
            # check we can reopen and use the dirstate after setting parent
987
 
            # trees.
988
 
            state._validate()
 
441
            # check we can reopen and use the dirstate after setting parent trees.
989
442
            state.save()
990
 
            state._validate()
991
443
        finally:
992
444
            state.unlock()
993
445
        state = dirstate.DirState.on_file('dirstate')
1006
458
            state.set_parent_trees(
1007
459
                ((revid1, tree1.branch.repository.revision_tree(revid1)),
1008
460
                 (revid2, tree2.branch.repository.revision_tree(revid2)),
1009
 
                 ('ghost-rev', tree2.branch.repository.revision_tree(
1010
 
                                   _mod_revision.NULL_REVISION))),
 
461
                 ('ghost-rev', tree2.branch.repository.revision_tree(None))),
1011
462
                ['ghost-rev'])
1012
463
            self.assertEqual([revid1, revid2, 'ghost-rev'],
1013
464
                             state.get_parent_ids())
1015
466
            self.assertEqual(['ghost-rev'], state.get_ghosts())
1016
467
            self.assertEqual(
1017
468
                [(('', '', root_id), [
1018
 
                  ('d', '', 0, False, dirstate.DirState.NULLSTAT),
 
469
                  ('d', '', 0, False, DirState.NULLSTAT),
1019
470
                  ('d', '', 0, False, revid1),
1020
 
                  ('d', '', 0, False, revid1)
 
471
                  ('d', '', 0, False, revid2)
1021
472
                  ])],
1022
473
                list(state._iter_entries()))
1023
474
        finally:
1025
476
 
1026
477
    def test_set_parent_trees_file_missing_from_tree(self):
1027
478
        # Adding a parent tree may reference files not in the current state.
1028
 
        # they should get listed just once by id, even if they are in two
 
479
        # they should get listed just once by id, even if they are in two  
1029
480
        # separate trees.
1030
481
        # set_parent_trees is a slow but important api to support.
1031
482
        tree1 = self.make_branch_and_memory_tree('tree1')
1038
489
        finally:
1039
490
            tree1.unlock()
1040
491
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1041
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
492
        tree2 = MemoryTree.create_on_branch(branch2)
1042
493
        tree2.lock_write()
1043
494
        try:
1044
495
            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
1045
496
            revid2 = tree2.commit('foo')
1046
 
            root_id = tree2.get_root_id()
 
497
            root_id = tree2.inventory.root.file_id
1047
498
        finally:
1048
499
            tree2.unlock()
1049
500
        # check the layout in memory
1050
501
        expected_result = [revid1.encode('utf8'), revid2.encode('utf8')], [
1051
502
            (('', '', root_id), [
1052
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT),
 
503
             ('d', '', 0, False, DirState.NULLSTAT),
1053
504
             ('d', '', 0, False, revid1.encode('utf8')),
1054
 
             ('d', '', 0, False, revid1.encode('utf8'))
1055
 
             ]),
 
505
             ('d', '', 0, False, revid2.encode('utf8'))]),
1056
506
            (('', 'a file', 'file-id'), [
1057
507
             ('a', '', 0, False, ''),
1058
 
             ('f', '2439573625385400f2a669657a7db6ae7515d371', 12, False,
1059
 
              revid1.encode('utf8')),
1060
 
             ('f', '542e57dc1cda4af37cb8e55ec07ce60364bb3c7d', 16, False,
1061
 
              revid2.encode('utf8'))
1062
 
             ])
 
508
             ('f', '2439573625385400f2a669657a7db6ae7515d371', 12, False, revid1.encode('utf8')),
 
509
             ('f', '542e57dc1cda4af37cb8e55ec07ce60364bb3c7d', 16, False, revid2.encode('utf8'))])
1063
510
            ]
1064
511
        state = dirstate.DirState.initialize('dirstate')
1065
512
        try:
1087
534
        state = dirstate.DirState.initialize('dirstate')
1088
535
        expected_entries = [
1089
536
            (('', '', 'TREE_ROOT'), [
1090
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
537
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree details
1091
538
             ]),
1092
 
            (('', 'a file', 'a-file-id'), [
1093
 
             ('f', '1'*20, 19, False, dirstate.pack_stat(stat)), # current tree
 
539
            (('', 'a file', 'a file id'), [
 
540
             ('f', '1'*20, 19, False, dirstate.pack_stat(stat)), # current tree details
1094
541
             ]),
1095
542
            ]
1096
543
        try:
1097
 
            state.add('a file', 'a-file-id', 'file', stat, '1'*20)
 
544
            state.add('a file', 'a file id', 'file', stat, '1'*20)
1098
545
            # having added it, it should be in the output of iter_entries.
1099
546
            self.assertEqual(expected_entries, list(state._iter_entries()))
1100
547
            # saving and reloading should not affect this.
1103
550
            state.unlock()
1104
551
        state = dirstate.DirState.on_file('dirstate')
1105
552
        state.lock_read()
1106
 
        self.addCleanup(state.unlock)
1107
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
553
        try:
 
554
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
555
        finally:
 
556
            state.unlock()
1108
557
 
1109
558
    def test_add_path_to_unversioned_directory(self):
1110
559
        """Adding a path to an unversioned directory should error.
1115
564
        """
1116
565
        self.build_tree(['unversioned/', 'unversioned/a file'])
1117
566
        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)
 
567
        try:
 
568
            self.assertRaises(errors.NotVersionedError, state.add,
 
569
                'unversioned/a file', 'a file id', 'file', None, None)
 
570
        finally:
 
571
            state.unlock()
1121
572
 
1122
573
    def test_add_directory_to_root_no_parents_all_data(self):
1123
574
        # The most trivial addition of a dir is when there are no parents and
1126
577
        stat = os.lstat('a dir')
1127
578
        expected_entries = [
1128
579
            (('', '', 'TREE_ROOT'), [
1129
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
580
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree details
1130
581
             ]),
1131
582
            (('', 'a dir', 'a dir id'), [
1132
 
             ('d', '', 0, False, dirstate.pack_stat(stat)), # current tree
 
583
             ('d', '', 0, False, dirstate.pack_stat(stat)), # current tree details
1133
584
             ]),
1134
585
            ]
1135
586
        state = dirstate.DirState.initialize('dirstate')
1143
594
            state.unlock()
1144
595
        state = dirstate.DirState.on_file('dirstate')
1145
596
        state.lock_read()
1146
 
        self.addCleanup(state.unlock)
1147
 
        state._validate()
1148
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
597
        try:
 
598
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
599
        finally:
 
600
            state.unlock()
1149
601
 
1150
 
    def _test_add_symlink_to_root_no_parents_all_data(self, link_name, target):
 
602
    def test_add_symlink_to_root_no_parents_all_data(self):
1151
603
        # The most trivial addition of a symlink when there are no parents and
1152
604
        # 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)
 
605
        ## TODO: windows: dont fail this test. Also, how are symlinks meant to
 
606
        # be represented on windows.
 
607
        os.symlink('target', 'a link')
 
608
        stat = os.lstat('a link')
1157
609
        expected_entries = [
1158
610
            (('', '', 'TREE_ROOT'), [
1159
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
611
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree details
1160
612
             ]),
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
 
613
            (('', 'a link', 'a link id'), [
 
614
             ('l', 'target', 6, False, dirstate.pack_stat(stat)), # current tree details
1164
615
             ]),
1165
616
            ]
1166
617
        state = dirstate.DirState.initialize('dirstate')
1167
618
        try:
1168
 
            state.add(link_name, 'a link id', 'symlink', stat,
1169
 
                      target.encode('UTF-8'))
 
619
            state.add('a link', 'a link id', 'symlink', stat, 'target')
1170
620
            # having added it, it should be in the output of iter_entries.
1171
621
            self.assertEqual(expected_entries, list(state._iter_entries()))
1172
622
            # saving and reloading should not affect this.
1175
625
            state.unlock()
1176
626
        state = dirstate.DirState.on_file('dirstate')
1177
627
        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')
 
628
        try:
 
629
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
630
        finally:
 
631
            state.unlock()
1188
632
 
1189
633
    def test_add_directory_and_child_no_parents_all_data(self):
1190
634
        # after adding a directory, we should be able to add children to it.
1193
637
        filestat = os.lstat('a dir/a file')
1194
638
        expected_entries = [
1195
639
            (('', '', 'TREE_ROOT'), [
1196
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
 
640
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree details
1197
641
             ]),
1198
642
            (('', 'a dir', 'a dir id'), [
1199
 
             ('d', '', 0, False, dirstate.pack_stat(dirstat)), # current tree
 
643
             ('d', '', 0, False, dirstate.pack_stat(dirstat)), # current tree details
1200
644
             ]),
1201
 
            (('a dir', 'a file', 'a-file-id'), [
1202
 
             ('f', '1'*20, 25, False,
1203
 
              dirstate.pack_stat(filestat)), # current tree details
 
645
            (('a dir', 'a file', 'a file id'), [
 
646
             ('f', '1'*20, 25, False, dirstate.pack_stat(filestat)), # current tree details
1204
647
             ]),
1205
648
            ]
1206
649
        state = dirstate.DirState.initialize('dirstate')
1207
650
        try:
1208
651
            state.add('a dir', 'a dir id', 'directory', dirstat, None)
1209
 
            state.add('a dir/a file', 'a-file-id', 'file', filestat, '1'*20)
 
652
            state.add('a dir/a file', 'a file id', 'file', filestat, '1'*20)
1210
653
            # added it, it should be in the output of iter_entries.
1211
654
            self.assertEqual(expected_entries, list(state._iter_entries()))
1212
655
            # saving and reloading should not affect this.
1215
658
            state.unlock()
1216
659
        state = dirstate.DirState.on_file('dirstate')
1217
660
        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
661
        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()
 
662
            self.assertEqual(expected_entries, list(state._iter_entries()))
1235
663
        finally:
1236
664
            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
665
 
1288
666
 
1289
667
class TestGetLines(TestCaseWithDirState):
1291
669
    def test_get_line_with_2_rows(self):
1292
670
        state = self.create_dirstate_with_root_and_subdir()
1293
671
        try:
1294
 
            self.assertEqual(['#bazaar dirstate flat format 3\n',
1295
 
                'crc32: 41262208\n',
 
672
            self.assertEqual(['#bazaar dirstate flat format 2\n',
 
673
                'adler32: -1327947603\n',
1296
674
                'num_entries: 2\n',
1297
675
                '0\x00\n\x00'
1298
676
                '0\x00\n\x00'
1299
677
                '\x00\x00a-root-value\x00'
1300
678
                'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00\n\x00'
1301
679
                '\x00subdir\x00subdir-id\x00'
1302
 
                'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00\n\x00'
1303
 
                ], state.get_lines())
 
680
                'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00\n\x00'],
 
681
                state.get_lines())
1304
682
        finally:
1305
683
            state.unlock()
1306
684
 
1308
686
        state = self.create_dirstate_with_root()
1309
687
        try:
1310
688
            self.assertEqual(
1311
 
                '\x00\x00a-root-value\x00d\x00\x000\x00n'
1312
 
                '\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk',
 
689
                '\x00\x00a-root-value\x00d\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk',
1313
690
                state._entry_to_line(state._dirblocks[0][1][0]))
1314
691
        finally:
1315
692
            state.unlock()
1318
695
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1319
696
        root_entry = ('', '', 'a-root-value'), [
1320
697
            ('d', '', 0, False, packed_stat), # current tree details
1321
 
             # first: a pointer to the current location
1322
 
            ('a', 'dirname/basename', 0, False, ''),
 
698
            ('a', 'dirname/basename', 0, False, ''), # first: a pointer to the current location
1323
699
            ]
1324
700
        state = dirstate.DirState.initialize('dirstate')
1325
701
        try:
1337
713
        root_entry = ('', '', 'a-root-value'), [
1338
714
            ('d', '', 0, False, packed_stat), # current tree details
1339
715
            ('d', '', 0, False, 'rev_id'), # first parent details
1340
 
             # second: a pointer to the current location
1341
 
            ('a', 'dirname/basename', 0, False, ''),
 
716
            ('a', 'dirname/basename', 0, False, ''), # second: a pointer to the current location
1342
717
            ]
1343
718
        state = dirstate.DirState.initialize('dirstate')
1344
719
        try:
1376
751
        state = dirstate.DirState.initialize('dirstate')
1377
752
        try:
1378
753
            state._set_data([], dirblocks)
1379
 
            expected_entries = [root_entries[0], subdir_entry, afile_entry,
1380
 
                                file_entry2]
 
754
            expected_entries = [root_entries[0], subdir_entry, afile_entry, file_entry2]
1381
755
            self.assertEqual(expected_entries, list(state._iter_entries()))
1382
756
        finally:
1383
757
            state.unlock()
1404
778
        self.assertBlockRowIndexEqual(1, 0, True, False, state, '', 'bdir', 0)
1405
779
        self.assertBlockRowIndexEqual(1, 1, True, False, state, '', 'zdir', 0)
1406
780
        self.assertBlockRowIndexEqual(2, 0, False, False, state, 'a', 'foo', 0)
1407
 
        self.assertBlockRowIndexEqual(2, 0, False, False, state,
1408
 
                                      'subdir', 'foo', 0)
 
781
        self.assertBlockRowIndexEqual(2, 0, False, False, state, 'subdir', 'foo', 0)
1409
782
 
1410
783
    def test_complex_structure_exists(self):
1411
784
        state = self.create_complex_dirstate()
1419
792
        self.assertBlockRowIndexEqual(2, 0, True, True, state, 'a', 'e', 0)
1420
793
        self.assertBlockRowIndexEqual(2, 1, True, True, state, 'a', 'f', 0)
1421
794
        self.assertBlockRowIndexEqual(3, 0, True, True, state, 'b', 'g', 0)
1422
 
        self.assertBlockRowIndexEqual(3, 1, True, True, state,
1423
 
                                      'b', 'h\xc3\xa5', 0)
 
795
        self.assertBlockRowIndexEqual(3, 1, True, True, state, 'b', 'h\xc3\xa5', 0)
1424
796
 
1425
797
    def test_complex_structure_missing(self):
1426
798
        state = self.create_complex_dirstate()
1430
802
        self.assertBlockRowIndexEqual(0, 0, True, True, state, '', '', 0)
1431
803
        self.assertBlockRowIndexEqual(1, 0, True, False, state, '', '_', 0)
1432
804
        self.assertBlockRowIndexEqual(1, 1, True, False, state, '', 'aa', 0)
1433
 
        self.assertBlockRowIndexEqual(1, 4, True, False, state,
1434
 
                                      '', 'h\xc3\xa5', 0)
 
805
        self.assertBlockRowIndexEqual(1, 4, True, False, state, '', 'h\xc3\xa5', 0)
1435
806
        self.assertBlockRowIndexEqual(2, 0, False, False, state, '_', 'a', 0)
1436
807
        self.assertBlockRowIndexEqual(3, 0, False, False, state, 'aa', 'a', 0)
1437
808
        self.assertBlockRowIndexEqual(4, 0, False, False, state, 'bb', 'a', 0)
1472
843
        self.assertEntryEqual('a', 'e', 'e-dir', state, 'a/e', 0)
1473
844
        self.assertEntryEqual('a', 'f', 'f-file', state, 'a/f', 0)
1474
845
        self.assertEntryEqual('b', 'g', 'g-file', state, 'b/g', 0)
1475
 
        self.assertEntryEqual('b', 'h\xc3\xa5', 'h-\xc3\xa5-file', state,
1476
 
                              'b/h\xc3\xa5', 0)
 
846
        self.assertEntryEqual('b', 'h\xc3\xa5', 'h-\xc3\xa5-file', state, 'b/h\xc3\xa5', 0)
1477
847
 
1478
848
    def test_complex_structure_missing(self):
1479
849
        state = self.create_complex_dirstate()
1494
864
        state = dirstate.DirState.on_file('dirstate')
1495
865
        state.lock_read()
1496
866
        try:
1497
 
            self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
1498
 
                             state._header_state)
1499
 
            self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
1500
 
                             state._dirblock_state)
 
867
            self.assertEqual(dirstate.DirState.NOT_IN_MEMORY, state._header_state)
 
868
            self.assertEqual(dirstate.DirState.NOT_IN_MEMORY, state._dirblock_state)
1501
869
            self.assertEntryEqual('', '', 'a-root-value', state, '', 0)
1502
870
        finally:
1503
871
            state.unlock()
1504
 
 
1505
 
 
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):
1797
 
    """Test the ability to bisect into the disk format."""
1798
 
 
1799
 
    def assertBisect(self, expected_map, map_keys, state, paths):
1800
 
        """Assert that bisecting for paths returns the right result.
1801
 
 
1802
 
        :param expected_map: A map from key => entry value
1803
 
        :param map_keys: The keys to expect for each path
1804
 
        :param state: The DirState object.
1805
 
        :param paths: A list of paths, these will automatically be split into
1806
 
                      (dir, name) tuples, and sorted according to how _bisect
1807
 
                      requires.
1808
 
        """
1809
 
        result = state._bisect(paths)
1810
 
        # For now, results are just returned in whatever order we read them.
1811
 
        # We could sort by (dir, name, file_id) or something like that, but in
1812
 
        # the end it would still be fairly arbitrary, and we don't want the
1813
 
        # extra overhead if we can avoid it. So sort everything to make sure
1814
 
        # equality is true
1815
 
        self.assertEqual(len(map_keys), len(paths))
1816
 
        expected = {}
1817
 
        for path, keys in zip(paths, map_keys):
1818
 
            if keys is None:
1819
 
                # This should not be present in the output
1820
 
                continue
1821
 
            expected[path] = sorted(expected_map[k] for k in keys)
1822
 
 
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()
1827
 
 
1828
 
        self.assertEqual(expected, result)
1829
 
 
1830
 
    def assertBisectDirBlocks(self, expected_map, map_keys, state, paths):
1831
 
        """Assert that bisecting for dirbblocks returns the right result.
1832
 
 
1833
 
        :param expected_map: A map from key => expected values
1834
 
        :param map_keys: A nested list of paths we expect to be returned.
1835
 
            Something like [['a', 'b', 'f'], ['b/c', 'b/d']]
1836
 
        :param state: The DirState object.
1837
 
        :param paths: A list of directories
1838
 
        """
1839
 
        result = state._bisect_dirblocks(paths)
1840
 
        self.assertEqual(len(map_keys), len(paths))
1841
 
        expected = {}
1842
 
        for path, keys in zip(paths, map_keys):
1843
 
            if keys is None:
1844
 
                # This should not be present in the output
1845
 
                continue
1846
 
            expected[path] = sorted(expected_map[k] for k in keys)
1847
 
        for path in result:
1848
 
            result[path].sort()
1849
 
 
1850
 
        self.assertEqual(expected, result)
1851
 
 
1852
 
    def assertBisectRecursive(self, expected_map, map_keys, state, paths):
1853
 
        """Assert the return value of a recursive bisection.
1854
 
 
1855
 
        :param expected_map: A map from key => entry value
1856
 
        :param map_keys: A list of paths we expect to be returned.
1857
 
            Something like ['a', 'b', 'f', 'b/d', 'b/d2']
1858
 
        :param state: The DirState object.
1859
 
        :param paths: A list of files and directories. It will be broken up
1860
 
            into (dir, name) pairs and sorted before calling _bisect_recursive.
1861
 
        """
1862
 
        expected = {}
1863
 
        for key in map_keys:
1864
 
            entry = expected_map[key]
1865
 
            dir_name_id, trees_info = entry
1866
 
            expected[dir_name_id] = trees_info
1867
 
 
1868
 
        result = state._bisect_recursive(paths)
1869
 
 
1870
 
        self.assertEqual(expected, result)
1871
 
 
1872
 
    def test_bisect_each(self):
1873
 
        """Find a single record using bisect."""
1874
 
        tree, state, expected = self.create_basic_dirstate()
1875
 
 
1876
 
        # Bisect should return the rows for the specified files.
1877
 
        self.assertBisect(expected, [['']], state, [''])
1878
 
        self.assertBisect(expected, [['a']], state, ['a'])
1879
 
        self.assertBisect(expected, [['b']], state, ['b'])
1880
 
        self.assertBisect(expected, [['b/c']], state, ['b/c'])
1881
 
        self.assertBisect(expected, [['b/d']], state, ['b/d'])
1882
 
        self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
1883
 
        self.assertBisect(expected, [['b-c']], state, ['b-c'])
1884
 
        self.assertBisect(expected, [['f']], state, ['f'])
1885
 
 
1886
 
    def test_bisect_multi(self):
1887
 
        """Bisect can be used to find multiple records at the same time."""
1888
 
        tree, state, expected = self.create_basic_dirstate()
1889
 
        # Bisect should be capable of finding multiple entries at the same time
1890
 
        self.assertBisect(expected, [['a'], ['b'], ['f']],
1891
 
                          state, ['a', 'b', 'f'])
1892
 
        self.assertBisect(expected, [['f'], ['b/d'], ['b/d/e']],
1893
 
                          state, ['f', 'b/d', 'b/d/e'])
1894
 
        self.assertBisect(expected, [['b'], ['b-c'], ['b/c']],
1895
 
                          state, ['b', 'b-c', 'b/c'])
1896
 
 
1897
 
    def test_bisect_one_page(self):
1898
 
        """Test bisect when there is only 1 page to read"""
1899
 
        tree, state, expected = self.create_basic_dirstate()
1900
 
        state._bisect_page_size = 5000
1901
 
        self.assertBisect(expected,[['']], state, [''])
1902
 
        self.assertBisect(expected,[['a']], state, ['a'])
1903
 
        self.assertBisect(expected,[['b']], state, ['b'])
1904
 
        self.assertBisect(expected,[['b/c']], state, ['b/c'])
1905
 
        self.assertBisect(expected,[['b/d']], state, ['b/d'])
1906
 
        self.assertBisect(expected,[['b/d/e']], state, ['b/d/e'])
1907
 
        self.assertBisect(expected,[['b-c']], state, ['b-c'])
1908
 
        self.assertBisect(expected,[['f']], state, ['f'])
1909
 
        self.assertBisect(expected,[['a'], ['b'], ['f']],
1910
 
                          state, ['a', 'b', 'f'])
1911
 
        self.assertBisect(expected, [['b/d'], ['b/d/e'], ['f']],
1912
 
                          state, ['b/d', 'b/d/e', 'f'])
1913
 
        self.assertBisect(expected, [['b'], ['b/c'], ['b-c']],
1914
 
                          state, ['b', 'b/c', 'b-c'])
1915
 
 
1916
 
    def test_bisect_duplicate_paths(self):
1917
 
        """When bisecting for a path, handle multiple entries."""
1918
 
        tree, state, expected = self.create_duplicated_dirstate()
1919
 
 
1920
 
        # Now make sure that both records are properly returned.
1921
 
        self.assertBisect(expected, [['']], state, [''])
1922
 
        self.assertBisect(expected, [['a', 'a2']], state, ['a'])
1923
 
        self.assertBisect(expected, [['b', 'b2']], state, ['b'])
1924
 
        self.assertBisect(expected, [['b/c', 'b/c2']], state, ['b/c'])
1925
 
        self.assertBisect(expected, [['b/d', 'b/d2']], state, ['b/d'])
1926
 
        self.assertBisect(expected, [['b/d/e', 'b/d/e2']],
1927
 
                          state, ['b/d/e'])
1928
 
        self.assertBisect(expected, [['b-c', 'b-c2']], state, ['b-c'])
1929
 
        self.assertBisect(expected, [['f', 'f2']], state, ['f'])
1930
 
 
1931
 
    def test_bisect_page_size_too_small(self):
1932
 
        """If the page size is too small, we will auto increase it."""
1933
 
        tree, state, expected = self.create_basic_dirstate()
1934
 
        state._bisect_page_size = 50
1935
 
        self.assertBisect(expected, [None], state, ['b/e'])
1936
 
        self.assertBisect(expected, [['a']], state, ['a'])
1937
 
        self.assertBisect(expected, [['b']], state, ['b'])
1938
 
        self.assertBisect(expected, [['b/c']], state, ['b/c'])
1939
 
        self.assertBisect(expected, [['b/d']], state, ['b/d'])
1940
 
        self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
1941
 
        self.assertBisect(expected, [['b-c']], state, ['b-c'])
1942
 
        self.assertBisect(expected, [['f']], state, ['f'])
1943
 
 
1944
 
    def test_bisect_missing(self):
1945
 
        """Test that bisect return None if it cannot find a path."""
1946
 
        tree, state, expected = self.create_basic_dirstate()
1947
 
        self.assertBisect(expected, [None], state, ['foo'])
1948
 
        self.assertBisect(expected, [None], state, ['b/foo'])
1949
 
        self.assertBisect(expected, [None], state, ['bar/foo'])
1950
 
        self.assertBisect(expected, [None], state, ['b-c/foo'])
1951
 
 
1952
 
        self.assertBisect(expected, [['a'], None, ['b/d']],
1953
 
                          state, ['a', 'foo', 'b/d'])
1954
 
 
1955
 
    def test_bisect_rename(self):
1956
 
        """Check that we find a renamed row."""
1957
 
        tree, state, expected = self.create_renamed_dirstate()
1958
 
 
1959
 
        # Search for the pre and post renamed entries
1960
 
        self.assertBisect(expected, [['a']], state, ['a'])
1961
 
        self.assertBisect(expected, [['b/g']], state, ['b/g'])
1962
 
        self.assertBisect(expected, [['b/d']], state, ['b/d'])
1963
 
        self.assertBisect(expected, [['h']], state, ['h'])
1964
 
 
1965
 
        # What about b/d/e? shouldn't that also get 2 directory entries?
1966
 
        self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
1967
 
        self.assertBisect(expected, [['h/e']], state, ['h/e'])
1968
 
 
1969
 
    def test_bisect_dirblocks(self):
1970
 
        tree, state, expected = self.create_duplicated_dirstate()
1971
 
        self.assertBisectDirBlocks(expected,
1972
 
            [['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2']],
1973
 
            state, [''])
1974
 
        self.assertBisectDirBlocks(expected,
1975
 
            [['b/c', 'b/c2', 'b/d', 'b/d2']], state, ['b'])
1976
 
        self.assertBisectDirBlocks(expected,
1977
 
            [['b/d/e', 'b/d/e2']], state, ['b/d'])
1978
 
        self.assertBisectDirBlocks(expected,
1979
 
            [['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2'],
1980
 
             ['b/c', 'b/c2', 'b/d', 'b/d2'],
1981
 
             ['b/d/e', 'b/d/e2'],
1982
 
            ], state, ['', 'b', 'b/d'])
1983
 
 
1984
 
    def test_bisect_dirblocks_missing(self):
1985
 
        tree, state, expected = self.create_basic_dirstate()
1986
 
        self.assertBisectDirBlocks(expected, [['b/d/e'], None],
1987
 
            state, ['b/d', 'b/e'])
1988
 
        # Files don't show up in this search
1989
 
        self.assertBisectDirBlocks(expected, [None], state, ['a'])
1990
 
        self.assertBisectDirBlocks(expected, [None], state, ['b/c'])
1991
 
        self.assertBisectDirBlocks(expected, [None], state, ['c'])
1992
 
        self.assertBisectDirBlocks(expected, [None], state, ['b/d/e'])
1993
 
        self.assertBisectDirBlocks(expected, [None], state, ['f'])
1994
 
 
1995
 
    def test_bisect_recursive_each(self):
1996
 
        tree, state, expected = self.create_basic_dirstate()
1997
 
        self.assertBisectRecursive(expected, ['a'], state, ['a'])
1998
 
        self.assertBisectRecursive(expected, ['b/c'], state, ['b/c'])
1999
 
        self.assertBisectRecursive(expected, ['b/d/e'], state, ['b/d/e'])
2000
 
        self.assertBisectRecursive(expected, ['b-c'], state, ['b-c'])
2001
 
        self.assertBisectRecursive(expected, ['b/d', 'b/d/e'],
2002
 
                                   state, ['b/d'])
2003
 
        self.assertBisectRecursive(expected, ['b', 'b/c', 'b/d', 'b/d/e'],
2004
 
                                   state, ['b'])
2005
 
        self.assertBisectRecursive(expected, ['', 'a', 'b', 'b-c', 'f', 'b/c',
2006
 
                                              'b/d', 'b/d/e'],
2007
 
                                   state, [''])
2008
 
 
2009
 
    def test_bisect_recursive_multiple(self):
2010
 
        tree, state, expected = self.create_basic_dirstate()
2011
 
        self.assertBisectRecursive(expected, ['a', 'b/c'], state, ['a', 'b/c'])
2012
 
        self.assertBisectRecursive(expected, ['b/d', 'b/d/e'],
2013
 
                                   state, ['b/d', 'b/d/e'])
2014
 
 
2015
 
    def test_bisect_recursive_missing(self):
2016
 
        tree, state, expected = self.create_basic_dirstate()
2017
 
        self.assertBisectRecursive(expected, [], state, ['d'])
2018
 
        self.assertBisectRecursive(expected, [], state, ['b/e'])
2019
 
        self.assertBisectRecursive(expected, [], state, ['g'])
2020
 
        self.assertBisectRecursive(expected, ['a'], state, ['a', 'g'])
2021
 
 
2022
 
    def test_bisect_recursive_renamed(self):
2023
 
        tree, state, expected = self.create_renamed_dirstate()
2024
 
 
2025
 
        # Looking for either renamed item should find the other
2026
 
        self.assertBisectRecursive(expected, ['a', 'b/g'], state, ['a'])
2027
 
        self.assertBisectRecursive(expected, ['a', 'b/g'], state, ['b/g'])
2028
 
        # Looking in the containing directory should find the rename target,
2029
 
        # and anything in a subdir of the renamed target.
2030
 
        self.assertBisectRecursive(expected, ['a', 'b', 'b/c', 'b/d',
2031
 
                                              'b/d/e', 'b/g', 'h', 'h/e'],
2032
 
                                   state, ['b'])
2033
 
 
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)