← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testinv.py

  • Committer: Jelmer Vernooij
  • Date: 2005-11-21 20:10:56 UTC
  • mto: (1185.33.40 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 1512.
  • Revision ID: jelmer@samba.org-20051121201056-b5b364b20cb58115
Don't clear Revision.parent_ids after it has been set from the arguments

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testinv.py
16
16
 
17
17
from cStringIO import StringIO
18
18
import os
19
 
import time
20
19
 
21
20
from bzrlib.branch import Branch
 
21
from bzrlib.clone import copy_branch
22
22
import bzrlib.errors as errors
23
23
from bzrlib.diff import internal_diff
24
 
from bzrlib.inventory import (Inventory, ROOT_ID, InventoryFile,
25
 
    InventoryDirectory, InventoryEntry)
 
24
from bzrlib.inventory import Inventory, ROOT_ID
26
25
import bzrlib.inventory as inventory
27
 
from bzrlib.osutils import (has_symlinks, rename, pathjoin, is_inside_any, 
28
 
    is_inside_or_parent_of_any)
29
 
from bzrlib.tests import TestCase, TestCaseWithTransport
30
 
from bzrlib.transform import TreeTransform
31
 
from bzrlib.uncommit import uncommit
 
26
from bzrlib.osutils import has_symlinks, rename
 
27
from bzrlib.selftest import TestCase, TestCaseInTempDir
32
28
 
33
29
 
34
30
class TestInventory(TestCase):
35
31
 
36
32
    def test_is_within(self):
 
33
        from bzrlib.osutils import is_inside_any
37
34
 
38
 
        SRC_FOO_C = pathjoin('src', 'foo.c')
 
35
        SRC_FOO_C = os.path.join('src', 'foo.c')
39
36
        for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
40
37
                         (['src'], SRC_FOO_C),
41
38
                         (['src'], 'src'),
45
42
        for dirs, fn in [(['src'], 'srccontrol'),
46
43
                         (['src'], 'srccontrol/foo')]:
47
44
            self.assertFalse(is_inside_any(dirs, fn))
48
 
 
49
 
    def test_is_within_or_parent(self):
50
 
        for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
51
 
                         (['src'], 'src/foo.c'),
52
 
                         (['src/bar.c'], 'src'),
53
 
                         (['src/bar.c', 'bla/foo.c'], 'src'),
54
 
                         (['src'], 'src'),
55
 
                         ]:
56
 
            self.assert_(is_inside_or_parent_of_any(dirs, fn))
57
45
            
58
 
        for dirs, fn in [(['src'], 'srccontrol'),
59
 
                         (['srccontrol/foo.c'], 'src'),
60
 
                         (['src'], 'srccontrol/foo')]:
61
 
            self.assertFalse(is_inside_or_parent_of_any(dirs, fn))
62
 
 
63
46
    def test_ids(self):
64
47
        """Test detection of files within selected directories."""
65
48
        inv = Inventory()
76
59
        
77
60
        self.assert_('src-id' in inv)
78
61
 
79
 
    def test_iter_entries(self):
80
 
        inv = Inventory()
81
 
        
82
 
        for args in [('src', 'directory', 'src-id'), 
83
 
                     ('doc', 'directory', 'doc-id'), 
84
 
                     ('src/hello.c', 'file', 'hello-id'),
85
 
                     ('src/bye.c', 'file', 'bye-id'),
86
 
                     ('Makefile', 'file', 'makefile-id')]:
87
 
            inv.add_path(*args)
88
 
 
89
 
        self.assertEqual([
90
 
            ('Makefile', 'makefile-id'),
91
 
            ('doc', 'doc-id'),
92
 
            ('src', 'src-id'),
93
 
            ('src/bye.c', 'bye-id'),
94
 
            ('src/hello.c', 'hello-id'),
95
 
            ], [(path, ie.file_id) for path, ie in inv.iter_entries()])
96
 
            
97
 
    def test_iter_entries_by_dir(self):
98
 
        inv = Inventory()
99
 
        
100
 
        for args in [('src', 'directory', 'src-id'), 
101
 
                     ('doc', 'directory', 'doc-id'), 
102
 
                     ('src/hello.c', 'file', 'hello-id'),
103
 
                     ('src/bye.c', 'file', 'bye-id'),
104
 
                     ('zz', 'file', 'zz-id'),
105
 
                     ('src/sub/', 'directory', 'sub-id'),
106
 
                     ('src/zz.c', 'file', 'zzc-id'),
107
 
                     ('src/sub/a', 'file', 'a-id'),
108
 
                     ('Makefile', 'file', 'makefile-id')]:
109
 
            inv.add_path(*args)
110
 
 
111
 
        self.assertEqual([
112
 
            ('Makefile', 'makefile-id'),
113
 
            ('doc', 'doc-id'),
114
 
            ('src', 'src-id'),
115
 
            ('zz', 'zz-id'),
116
 
            ('src/bye.c', 'bye-id'),
117
 
            ('src/hello.c', 'hello-id'),
118
 
            ('src/sub', 'sub-id'),
119
 
            ('src/zz.c', 'zzc-id'),
120
 
            ('src/sub/a', 'a-id'),
121
 
            ], [(path, ie.file_id) for path, ie in inv.iter_entries_by_dir()])
122
 
            
 
62
 
123
63
    def test_version(self):
124
64
        """Inventory remembers the text's version."""
125
65
        inv = Inventory()
192
132
        link = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
193
133
        self.failIf(link.has_text())
194
134
 
195
 
    def test_make_entry(self):
196
 
        self.assertIsInstance(inventory.make_entry("file", "name", ROOT_ID),
197
 
            inventory.InventoryFile)
198
 
        self.assertIsInstance(inventory.make_entry("symlink", "name", ROOT_ID),
199
 
            inventory.InventoryLink)
200
 
        self.assertIsInstance(inventory.make_entry("directory", "name", ROOT_ID),
201
 
            inventory.InventoryDirectory)
202
135
 
203
 
class TestEntryDiffing(TestCaseWithTransport):
 
136
class TestEntryDiffing(TestCaseInTempDir):
204
137
 
205
138
    def setUp(self):
206
139
        super(TestEntryDiffing, self).setUp()
207
 
        self.wt = self.make_branch_and_tree('.')
208
 
        self.branch = self.wt.branch
 
140
        self.branch = Branch.initialize('.')
 
141
        self.wt = self.branch.working_tree()
209
142
        print >> open('file', 'wb'), 'foo'
210
 
        print >> open('binfile', 'wb'), 'foo'
211
 
        self.wt.add(['file'], ['fileid'])
212
 
        self.wt.add(['binfile'], ['binfileid'])
 
143
        self.branch.add(['file'], ['fileid'])
213
144
        if has_symlinks():
214
145
            os.symlink('target1', 'symlink')
215
 
            self.wt.add(['symlink'], ['linkid'])
 
146
            self.branch.add(['symlink'], ['linkid'])
216
147
        self.wt.commit('message_1', rev_id = '1')
217
148
        print >> open('file', 'wb'), 'bar'
218
 
        print >> open('binfile', 'wb'), 'x' * 1023 + '\x00'
219
149
        if has_symlinks():
220
150
            os.unlink('symlink')
221
151
            os.symlink('target2', 'symlink')
222
 
        self.tree_1 = self.branch.repository.revision_tree('1')
223
 
        self.inv_1 = self.branch.repository.get_inventory('1')
 
152
        self.tree_1 = self.branch.revision_tree('1')
 
153
        self.inv_1 = self.branch.get_inventory('1')
224
154
        self.file_1 = self.inv_1['fileid']
225
 
        self.file_1b = self.inv_1['binfileid']
226
 
        self.tree_2 = self.wt
 
155
        self.tree_2 = self.branch.working_tree()
227
156
        self.inv_2 = self.tree_2.read_working_inventory()
228
157
        self.file_2 = self.inv_2['fileid']
229
 
        self.file_2b = self.inv_2['binfileid']
230
158
        if has_symlinks():
231
159
            self.link_1 = self.inv_1['linkid']
232
160
            self.link_2 = self.inv_2['linkid']
237
165
                          "old_label", self.tree_1,
238
166
                          "/dev/null", None, None,
239
167
                          output)
240
 
        self.assertEqual(output.getvalue(), "--- old_label\n"
241
 
                                            "+++ /dev/null\n"
 
168
        self.assertEqual(output.getvalue(), "--- old_label\t\n"
 
169
                                            "+++ /dev/null\t\n"
242
170
                                            "@@ -1,1 +0,0 @@\n"
243
171
                                            "-foo\n"
244
172
                                            "\n")
249
177
                          "new_label", self.tree_1,
250
178
                          "/dev/null", None, None,
251
179
                          output, reverse=True)
252
 
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
253
 
                                            "+++ new_label\n"
 
180
        self.assertEqual(output.getvalue(), "--- /dev/null\t\n"
 
181
                                            "+++ new_label\t\n"
254
182
                                            "@@ -0,0 +1,1 @@\n"
255
183
                                            "+foo\n"
256
184
                                            "\n")
261
189
                          "/dev/null", self.tree_1, 
262
190
                          "new_label", self.file_2, self.tree_2,
263
191
                          output)
264
 
        self.assertEqual(output.getvalue(), "--- /dev/null\n"
265
 
                                            "+++ new_label\n"
 
192
        self.assertEqual(output.getvalue(), "--- /dev/null\t\n"
 
193
                                            "+++ new_label\t\n"
266
194
                                            "@@ -1,1 +1,1 @@\n"
267
195
                                            "-foo\n"
268
196
                                            "+bar\n"
269
197
                                            "\n")
270
198
        
271
 
    def test_file_diff_binary(self):
272
 
        output = StringIO()
273
 
        self.file_1.diff(internal_diff, 
274
 
                          "/dev/null", self.tree_1, 
275
 
                          "new_label", self.file_2b, self.tree_2,
276
 
                          output)
277
 
        self.assertEqual(output.getvalue(), 
278
 
                         "Binary files /dev/null and new_label differ\n")
279
199
    def test_link_diff_deleted(self):
280
200
        if not has_symlinks():
281
201
            return
310
230
                         "=== target changed 'target1' => 'target2'\n")
311
231
 
312
232
 
313
 
class TestSnapshot(TestCaseWithTransport):
 
233
class TestSnapshot(TestCaseInTempDir):
314
234
 
315
235
    def setUp(self):
316
236
        # for full testing we'll need a branch
320
240
        # to change, and then test merge patterns
321
241
        # with fake parent entries.
322
242
        super(TestSnapshot, self).setUp()
323
 
        self.wt = self.make_branch_and_tree('.')
324
 
        self.branch = self.wt.branch
325
 
        self.build_tree(['subdir/', 'subdir/file'], line_endings='binary')
326
 
        self.wt.add(['subdir', 'subdir/file'],
327
 
                                       ['dirid', 'fileid'])
 
243
        self.branch = Branch.initialize('.')
 
244
        self.build_tree(['subdir/', 'subdir/file'])
 
245
        self.branch.add(['subdir', 'subdir/file'], ['dirid', 'fileid'])
328
246
        if has_symlinks():
329
247
            pass
 
248
        self.wt = self.branch.working_tree()
330
249
        self.wt.commit('message_1', rev_id = '1')
331
 
        self.tree_1 = self.branch.repository.revision_tree('1')
332
 
        self.inv_1 = self.branch.repository.get_inventory('1')
 
250
        self.tree_1 = self.branch.revision_tree('1')
 
251
        self.inv_1 = self.branch.get_inventory('1')
333
252
        self.file_1 = self.inv_1['fileid']
334
 
        self.file_active = self.wt.inventory['fileid']
335
 
        self.builder = self.branch.get_commit_builder([], timestamp=time.time(), revision_id='2')
 
253
        self.work_tree = self.branch.working_tree()
 
254
        self.file_active = self.work_tree.inventory['fileid']
336
255
 
337
256
    def test_snapshot_new_revision(self):
338
257
        # This tests that a simple commit with no parents makes a new
339
258
        # revision value in the inventory entry
340
 
        self.file_active.snapshot('2', 'subdir/file', {}, self.wt, self.builder)
 
259
        self.file_active.snapshot('2', 'subdir/file', {}, self.work_tree, 
 
260
                                  self.branch.weave_store,
 
261
                                  self.branch.get_transaction())
341
262
        # expected outcome - file_1 has a revision id of '2', and we can get
342
263
        # its text of 'file contents' out of the weave.
343
264
        self.assertEqual(self.file_1.revision, '1')
344
265
        self.assertEqual(self.file_active.revision, '2')
345
266
        # this should be a separate test probably, but lets check it once..
346
 
        lines = self.branch.repository.weave_store.get_weave(
347
 
            'fileid', 
348
 
            self.branch.get_transaction()).get_lines('2')
 
267
        lines = self.branch.weave_store.get_lines('fileid','2',
 
268
            self.branch.get_transaction())
349
269
        self.assertEqual(lines, ['contents of subdir/file\n'])
350
270
 
351
271
    def test_snapshot_unchanged(self):
352
272
        #This tests that a simple commit does not make a new entry for
353
273
        # an unchanged inventory entry
354
274
        self.file_active.snapshot('2', 'subdir/file', {'1':self.file_1},
355
 
                                  self.wt, self.builder)
 
275
                                  self.work_tree, self.branch.weave_store,
 
276
                                  self.branch.get_transaction())
356
277
        self.assertEqual(self.file_1.revision, '1')
357
278
        self.assertEqual(self.file_active.revision, '1')
358
 
        vf = self.branch.repository.weave_store.get_weave(
359
 
            'fileid', 
360
 
            self.branch.repository.get_transaction())
361
 
        self.assertRaises(errors.RevisionNotPresent,
362
 
                          vf.get_lines,
363
 
                          '2')
 
279
        self.assertRaises(errors.WeaveError,
 
280
                          self.branch.weave_store.get_lines, 'fileid', '2',
 
281
                          self.branch.get_transaction())
364
282
 
365
283
    def test_snapshot_merge_identical_different_revid(self):
366
284
        # This tests that a commit with two identical parents, one of which has
374
292
        self.assertEqual(self.file_1, other_ie)
375
293
        other_ie.revision = 'other'
376
294
        self.assertNotEqual(self.file_1, other_ie)
377
 
        versionfile = self.branch.repository.weave_store.get_weave(
378
 
            'fileid', self.branch.repository.get_transaction())
379
 
        versionfile.clone_text('other', '1', ['1'])
 
295
        self.branch.weave_store.add_identical_text('fileid', '1', 'other', ['1'],
 
296
            self.branch.get_transaction())
380
297
        self.file_active.snapshot('2', 'subdir/file', 
381
298
                                  {'1':self.file_1, 'other':other_ie},
382
 
                                  self.wt, self.builder)
 
299
                                  self.work_tree, self.branch.weave_store,
 
300
                                  self.branch.get_transaction())
383
301
        self.assertEqual(self.file_active.revision, '2')
384
302
 
385
303
    def test_snapshot_changed(self):
388
306
        self.file_active.name='newname'
389
307
        rename('subdir/file', 'subdir/newname')
390
308
        self.file_active.snapshot('2', 'subdir/newname', {'1':self.file_1}, 
391
 
                                  self.wt, self.builder)
 
309
                                  self.work_tree, 
 
310
                                  self.branch.weave_store,
 
311
                                  self.branch.get_transaction())
392
312
        # expected outcome - file_1 has a revision id of '2'
393
313
        self.assertEqual(self.file_active.revision, '2')
394
314
 
395
315
 
396
 
class TestPreviousHeads(TestCaseWithTransport):
 
316
class TestPreviousHeads(TestCaseInTempDir):
397
317
 
398
318
    def setUp(self):
399
319
        # we want several inventories, that respectively
405
325
        # D) fileid present in two inventories and one is
406
326
        #   a descendent of the other. (B, D)
407
327
        super(TestPreviousHeads, self).setUp()
408
 
        self.wt = self.make_branch_and_tree('.')
409
 
        self.branch = self.wt.branch
410
328
        self.build_tree(['file'])
 
329
        self.branch = Branch.initialize('.')
 
330
        self.wt = self.branch.working_tree()
411
331
        self.wt.commit('new branch', allow_pointless=True, rev_id='A')
412
 
        self.inv_A = self.branch.repository.get_inventory('A')
413
 
        self.wt.add(['file'], ['fileid'])
 
332
        self.inv_A = self.branch.get_inventory('A')
 
333
        self.branch.add(['file'], ['fileid'])
414
334
        self.wt.commit('add file', rev_id='B')
415
 
        self.inv_B = self.branch.repository.get_inventory('B')
416
 
        uncommit(self.branch, tree=self.wt)
 
335
        self.inv_B = self.branch.get_inventory('B')
 
336
        self.branch.put_controlfile('revision-history', 'A\n')
417
337
        self.assertEqual(self.branch.revision_history(), ['A'])
418
338
        self.wt.commit('another add of file', rev_id='C')
419
 
        self.inv_C = self.branch.repository.get_inventory('C')
 
339
        self.inv_C = self.branch.get_inventory('C')
420
340
        self.wt.add_pending_merge('B')
421
341
        self.wt.commit('merge in B', rev_id='D')
422
 
        self.inv_D = self.branch.repository.get_inventory('D')
 
342
        self.inv_D = self.branch.get_inventory('D')
423
343
        self.file_active = self.wt.inventory['fileid']
424
 
        self.weave = self.branch.repository.weave_store.get_weave('fileid',
425
 
            self.branch.repository.get_transaction())
 
344
        self.weave = self.branch.weave_store.get_weave('fileid',
 
345
            self.branch.get_transaction())
426
346
        
427
347
    def get_previous_heads(self, inventories):
428
 
        return self.file_active.find_previous_heads(
429
 
            inventories, 
430
 
            self.branch.repository.weave_store,
431
 
            self.branch.repository.get_transaction())
 
348
        return self.file_active.find_previous_heads(inventories, self.weave)
432
349
        
433
350
    def test_fileid_in_no_inventory(self):
434
351
        self.assertEqual({}, self.get_previous_heads([self.inv_A]))
456
373
                         self.get_previous_heads([self.inv_D, self.inv_B]))
457
374
 
458
375
    # TODO: test two inventories with the same file revision 
459
 
 
460
 
 
461
 
class TestDescribeChanges(TestCase):
462
 
 
463
 
    def test_describe_change(self):
464
 
        # we need to test the following change combinations:
465
 
        # rename
466
 
        # reparent
467
 
        # modify
468
 
        # gone
469
 
        # added
470
 
        # renamed/reparented and modified
471
 
        # change kind (perhaps can't be done yet?)
472
 
        # also, merged in combination with all of these?
473
 
        old_a = InventoryFile('a-id', 'a_file', ROOT_ID)
474
 
        old_a.text_sha1 = '123132'
475
 
        old_a.text_size = 0
476
 
        new_a = InventoryFile('a-id', 'a_file', ROOT_ID)
477
 
        new_a.text_sha1 = '123132'
478
 
        new_a.text_size = 0
479
 
 
480
 
        self.assertChangeDescription('unchanged', old_a, new_a)
481
 
 
482
 
        new_a.text_size = 10
483
 
        new_a.text_sha1 = 'abcabc'
484
 
        self.assertChangeDescription('modified', old_a, new_a)
485
 
 
486
 
        self.assertChangeDescription('added', None, new_a)
487
 
        self.assertChangeDescription('removed', old_a, None)
488
 
        # perhaps a bit questionable but seems like the most reasonable thing...
489
 
        self.assertChangeDescription('unchanged', None, None)
490
 
 
491
 
        # in this case it's both renamed and modified; show a rename and 
492
 
        # modification:
493
 
        new_a.name = 'newfilename'
494
 
        self.assertChangeDescription('modified and renamed', old_a, new_a)
495
 
 
496
 
        # reparenting is 'renaming'
497
 
        new_a.name = old_a.name
498
 
        new_a.parent_id = 'somedir-id'
499
 
        self.assertChangeDescription('modified and renamed', old_a, new_a)
500
 
 
501
 
        # reset the content values so its not modified
502
 
        new_a.text_size = old_a.text_size
503
 
        new_a.text_sha1 = old_a.text_sha1
504
 
        new_a.name = old_a.name
505
 
 
506
 
        new_a.name = 'newfilename'
507
 
        self.assertChangeDescription('renamed', old_a, new_a)
508
 
 
509
 
        # reparenting is 'renaming'
510
 
        new_a.name = old_a.name
511
 
        new_a.parent_id = 'somedir-id'
512
 
        self.assertChangeDescription('renamed', old_a, new_a)
513
 
 
514
 
    def assertChangeDescription(self, expected_change, old_ie, new_ie):
515
 
        change = InventoryEntry.describe_change(old_ie, new_ie)
516
 
        self.assertEqual(expected_change, change)
517
 
 
518
 
 
519
 
class TestExecutable(TestCaseWithTransport):
520
 
 
521
 
    def test_stays_executable(self):
522
 
        a_id = "a-20051208024829-849e76f7968d7a86"
523
 
        b_id = "b-20051208024829-849e76f7968d7a86"
524
 
        wt = self.make_branch_and_tree('b1')
525
 
        b = wt.branch
526
 
        tt = TreeTransform(wt)
527
 
        tt.new_file('a', tt.root, 'a test\n', a_id, True)
528
 
        tt.new_file('b', tt.root, 'b test\n', b_id, False)
529
 
        tt.apply()
530
 
 
531
 
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
532
 
 
533
 
        # reopen the tree and ensure it stuck.
534
 
        wt = wt.bzrdir.open_workingtree()
535
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in wt.inventory.iter_entries()])
536
 
 
537
 
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
538
 
        self.failIf(wt.is_executable(b_id), "'b' gained an execute bit")
539
 
 
540
 
        wt.commit('adding a,b', rev_id='r1')
541
 
 
542
 
        rev_tree = b.repository.revision_tree('r1')
543
 
        self.failUnless(rev_tree.is_executable(a_id), "'a' lost the execute bit")
544
 
        self.failIf(rev_tree.is_executable(b_id), "'b' gained an execute bit")
545
 
 
546
 
        self.failUnless(rev_tree.inventory[a_id].executable)
547
 
        self.failIf(rev_tree.inventory[b_id].executable)
548
 
 
549
 
        # Make sure the entries are gone
550
 
        os.remove('b1/a')
551
 
        os.remove('b1/b')
552
 
        self.failIf(wt.has_id(a_id))
553
 
        self.failIf(wt.has_filename('a'))
554
 
        self.failIf(wt.has_id(b_id))
555
 
        self.failIf(wt.has_filename('b'))
556
 
 
557
 
        # Make sure that revert is able to bring them back,
558
 
        # and sets 'a' back to being executable
559
 
 
560
 
        wt.revert(['a', 'b'], rev_tree, backups=False)
561
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in wt.inventory.iter_entries()])
562
 
 
563
 
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
564
 
        self.failIf(wt.is_executable(b_id), "'b' gained an execute bit")
565
 
 
566
 
        # Now remove them again, and make sure that after a
567
 
        # commit, they are still marked correctly
568
 
        os.remove('b1/a')
569
 
        os.remove('b1/b')
570
 
        wt.commit('removed', rev_id='r2')
571
 
 
572
 
        self.assertEqual([], [cn for cn,ie in wt.inventory.iter_entries()])
573
 
        self.failIf(wt.has_id(a_id))
574
 
        self.failIf(wt.has_filename('a'))
575
 
        self.failIf(wt.has_id(b_id))
576
 
        self.failIf(wt.has_filename('b'))
577
 
 
578
 
        # Now revert back to the previous commit
579
 
        wt.revert([], rev_tree, backups=False)
580
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in wt.inventory.iter_entries()])
581
 
 
582
 
        self.failUnless(wt.is_executable(a_id), "'a' lost the execute bit")
583
 
        self.failIf(wt.is_executable(b_id), "'b' gained an execute bit")
584
 
 
585
 
        # Now make sure that 'bzr branch' also preserves the
586
 
        # executable bit
587
 
        # TODO: Maybe this should be a blackbox test
588
 
        d2 = b.bzrdir.clone('b2', revision_id='r1')
589
 
        t2 = d2.open_workingtree()
590
 
        b2 = t2.branch
591
 
        self.assertEquals('r1', b2.last_revision())
592
 
 
593
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in t2.inventory.iter_entries()])
594
 
        self.failUnless(t2.is_executable(a_id), "'a' lost the execute bit")
595
 
        self.failIf(t2.is_executable(b_id), "'b' gained an execute bit")
596
 
 
597
 
        # Make sure pull will delete the files
598
 
        t2.pull(b)
599
 
        self.assertEquals('r2', b2.last_revision())
600
 
        self.assertEqual([], [cn for cn,ie in t2.inventory.iter_entries()])
601
 
 
602
 
        # Now commit the changes on the first branch
603
 
        # so that the second branch can pull the changes
604
 
        # and make sure that the executable bit has been copied
605
 
        wt.commit('resurrected', rev_id='r3')
606
 
 
607
 
        t2.pull(b)
608
 
        self.assertEquals('r3', b2.last_revision())
609
 
        self.assertEqual(['a', 'b'], [cn for cn,ie in t2.inventory.iter_entries()])
610
 
 
611
 
        self.failUnless(t2.is_executable(a_id), "'a' lost the execute bit")
612
 
        self.failIf(t2.is_executable(b_id), "'b' gained an execute bit")
613
 
 
614
 
 
615
 
class TestRevert(TestCaseWithTransport):
616
 
 
617
 
    def test_dangling_id(self):
618
 
        wt = self.make_branch_and_tree('b1')
619
 
        self.assertEqual(len(wt.inventory), 1)
620
 
        open('b1/a', 'wb').write('a test\n')
621
 
        wt.add('a')
622
 
        self.assertEqual(len(wt.inventory), 2)
623
 
        os.unlink('b1/a')
624
 
        wt.revert([])
625
 
        self.assertEqual(len(wt.inventory), 1)