/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_workingtree.py

Update the dirstate tests to lock and unlock properly.
Change the lock.WriteLock functions so that they open in 'rb+' mode instead
of automatically truncating the file.
test_dirstate.py now passes, but we need to figure out or locking mechanism for
WorkingTree4. (does it just lock at the same time as Tree.lock_write()?)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_workingtree.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
# Authors:  Robert Collins <robert.collins@canonical.com>
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
13
13
#
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
18
from cStringIO import StringIO
19
19
import os
20
20
 
21
 
from bzrlib import (
22
 
    bzrdir,
23
 
    conflicts,
24
 
    errors,
25
 
    workingtree,
26
 
    )
 
21
from bzrlib import dirstate, ignores
 
22
import bzrlib
27
23
from bzrlib.branch import Branch
 
24
from bzrlib import bzrdir, conflicts, errors, workingtree
28
25
from bzrlib.bzrdir import BzrDir
 
26
from bzrlib.errors import NotBranchError, NotVersionedError
29
27
from bzrlib.lockdir import LockDir
30
28
from bzrlib.mutabletree import needs_tree_write_lock
 
29
from bzrlib.osutils import pathjoin, getcwd, has_symlinks
 
30
from bzrlib.symbol_versioning import zero_thirteen
31
31
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
32
from bzrlib.trace import mutter
32
33
from bzrlib.transport import get_transport
33
34
from bzrlib.workingtree import (
34
35
    TreeEntry,
35
36
    TreeDirectory,
36
37
    TreeFile,
37
38
    TreeLink,
 
39
    WorkingTree,
38
40
    )
39
41
 
40
 
 
41
42
class TestTreeDirectory(TestCaseWithTransport):
42
43
 
43
44
    def test_kind_character(self):
81
82
            workingtree.WorkingTreeFormat.set_default_format(old_format)
82
83
        self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format())
83
84
 
84
 
    def test_open(self):
85
 
        tree = self.make_branch_and_tree('.')
86
 
        open_direct = workingtree.WorkingTree.open('.')
87
 
        self.assertEqual(tree.basedir, open_direct.basedir)
88
 
        open_no_args = workingtree.WorkingTree.open()
89
 
        self.assertEqual(tree.basedir, open_no_args.basedir)
90
 
 
91
 
    def test_open_containing(self):
92
 
        tree = self.make_branch_and_tree('.')
93
 
        open_direct, relpath = workingtree.WorkingTree.open_containing('.')
94
 
        self.assertEqual(tree.basedir, open_direct.basedir)
95
 
        self.assertEqual('', relpath)
96
 
        open_no_args, relpath = workingtree.WorkingTree.open_containing()
97
 
        self.assertEqual(tree.basedir, open_no_args.basedir)
98
 
        self.assertEqual('', relpath)
99
 
        open_subdir, relpath = workingtree.WorkingTree.open_containing('subdir')
100
 
        self.assertEqual(tree.basedir, open_subdir.basedir)
101
 
        self.assertEqual('subdir', relpath)
102
 
 
103
85
 
104
86
class SampleTreeFormat(workingtree.WorkingTreeFormat):
105
87
    """A sample format
106
88
 
107
 
    this format is initializable, unsupported to aid in testing the
 
89
    this format is initializable, unsupported to aid in testing the 
108
90
    open and open_downlevel routines.
109
91
    """
110
92
 
112
94
        """See WorkingTreeFormat.get_format_string()."""
113
95
        return "Sample tree format."
114
96
 
115
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
116
 
                   accelerator_tree=None, hardlink=False):
 
97
    def initialize(self, a_bzrdir, revision_id=None):
117
98
        """Sample branches cannot be created."""
118
99
        t = a_bzrdir.get_workingtree_transport(self)
119
100
        t.put_bytes('format', self.get_format_string())
142
123
            found_format = workingtree.WorkingTreeFormat.find_format(dir)
143
124
            self.failUnless(isinstance(found_format, format.__class__))
144
125
        check_format(workingtree.WorkingTreeFormat3(), "bar")
145
 
 
 
126
        
146
127
    def test_find_format_no_tree(self):
147
128
        dir = bzrdir.BzrDirMetaFormat1().initialize('.')
148
129
        self.assertRaises(errors.NoWorkingTree,
193
174
        t = control.get_workingtree_transport(None)
194
175
        self.assertEqualDiff('Bazaar-NG Working Tree format 3',
195
176
                             t.get('format').read())
196
 
        self.assertEqualDiff(t.get('inventory').read(),
 
177
        # self.assertContainsRe(t.get('inventory').read(), 
 
178
        #                       '<inventory file_id="[^"]*" format="5">\n'
 
179
        #                       '</inventory>\n',
 
180
        #                      )
 
181
        # WorkingTreeFormat3 doesn't default to creating a unique root id,
 
182
        # because it is incompatible with older bzr versions
 
183
        self.assertContainsRe(t.get('inventory').read(),
197
184
                              '<inventory format="5">\n'
198
185
                              '</inventory>\n',
199
186
                             )
202
189
        self.assertFalse(t.has('inventory.basis'))
203
190
        # no last-revision file means 'None' or 'NULLREVISION'
204
191
        self.assertFalse(t.has('last-revision'))
205
 
        # TODO RBC 20060210 do a commit, check the inventory.basis is created
 
192
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
206
193
        # correctly and last-revision file becomes present.
207
194
 
208
195
    def test_uses_lockdir(self):
209
196
        """WorkingTreeFormat3 uses its own LockDir:
210
 
 
 
197
            
211
198
            - lock is a directory
212
199
            - when the WorkingTree is locked, LockDir can see that
213
200
        """
235
222
        control.create_repository()
236
223
        control.create_branch()
237
224
        tree = workingtree.WorkingTreeFormat3().initialize(control)
238
 
        tree._transport.delete("pending-merges")
 
225
        tree._control_files._transport.delete("pending-merges")
239
226
        self.assertEqual([], tree.get_parent_ids())
240
227
 
241
228
 
 
229
class TestWorkingTreeFormat4(TestCaseWithTransport):
 
230
    """Tests specific to WorkingTreeFormat4."""
 
231
 
 
232
    def test_disk_layout(self):
 
233
        control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())
 
234
        control.create_repository()
 
235
        control.create_branch()
 
236
        tree = workingtree.WorkingTreeFormat4().initialize(control)
 
237
        # we want:
 
238
        # format 'Bazaar Working Tree format 4'
 
239
        # stat-cache = ??
 
240
        t = control.get_workingtree_transport(None)
 
241
        self.assertEqualDiff('Bazaar Working Tree format 4\n',
 
242
                             t.get('format').read())
 
243
        self.assertEqualDiff('### bzr hashcache v5\n',
 
244
                             t.get('stat-cache').read())
 
245
        self.assertFalse(t.has('inventory.basis'))
 
246
        # no last-revision file means 'None' or 'NULLREVISION'
 
247
        self.assertFalse(t.has('last-revision'))
 
248
        # TODO RBC 20060210 do a commit, check the inventory.basis is created 
 
249
        # correctly and last-revision file becomes present.
 
250
        # manually make a dirstate toc check the format is as desired.
 
251
        state = dirstate.DirState.on_file(t.local_abspath('dirstate'))
 
252
        self.assertEqual([], state.get_parent_ids())
 
253
 
 
254
    def test_uses_lockdir(self):
 
255
        """WorkingTreeFormat4 uses its own LockDir:
 
256
            
 
257
            - lock is a directory
 
258
            - when the WorkingTree is locked, LockDir can see that
 
259
        """
 
260
        # this test could be factored into a subclass of tests common to both
 
261
        # format 3 and 4, but for now its not much of an issue as there is only one in common.
 
262
        t = self.get_transport()
 
263
        tree = self.make_workingtree()
 
264
        self.assertIsDirectory('.bzr', t)
 
265
        self.assertIsDirectory('.bzr/checkout', t)
 
266
        self.assertIsDirectory('.bzr/checkout/lock', t)
 
267
        our_lock = LockDir(t, '.bzr/checkout/lock')
 
268
        self.assertEquals(our_lock.peek(), None)
 
269
        tree.lock_write()
 
270
        self.assertTrue(our_lock.peek())
 
271
        tree.unlock()
 
272
        self.assertEquals(our_lock.peek(), None)
 
273
 
 
274
    def make_workingtree(self):
 
275
        url = self.get_url()
 
276
        dir = bzrdir.BzrDirMetaFormat1().initialize(url)
 
277
        repo = dir.create_repository()
 
278
        branch = dir.create_branch()
 
279
        try:
 
280
            return workingtree.WorkingTreeFormat4().initialize(dir)
 
281
        except errors.NotLocalUrl:
 
282
            raise TestSkipped('Not a local URL')
 
283
 
 
284
    # TODO: test that dirstate also stores & retrieves the parent list of 
 
285
    # workingtree-parent revisions, including when they have multiple parents.
 
286
    # (in other words, the case when we're constructing a merge of 
 
287
    # revisions which are themselves merges.)
 
288
 
 
289
    # The simplest case is that the the workingtree's primary 
 
290
    # parent tree can be retrieved.  This is required for all WorkingTrees, 
 
291
    # and covered by the generic tests.
 
292
 
 
293
    def test_dirstate_stores_all_parent_inventories(self):
 
294
        tree = self.make_workingtree()
 
295
 
 
296
        # We're going to build in tree a working tree 
 
297
        # with three parent trees, with some files in common.  
 
298
    
 
299
        # We really don't want to do commit or merge in the new dirstate-based
 
300
        # tree, because that might not work yet.  So instead we build
 
301
        # revisions elsewhere and pull them across, doing by hand part of the
 
302
        # work that merge would do.
 
303
 
 
304
        subtree = self.make_branch_and_tree('subdir')
 
305
        # writelock the tree so its repository doesn't get readlocked by
 
306
        # the revision tree locks. This works around the bug where we dont
 
307
        # permit lock upgrading.
 
308
        subtree.lock_write()
 
309
        self.addCleanup(subtree.unlock)
 
310
        self.build_tree(['subdir/file-a',])
 
311
        subtree.add(['file-a'], ['id-a'])
 
312
        rev1 = subtree.commit('commit in subdir')
 
313
        rev1_tree = subtree.basis_tree()
 
314
        rev1_tree.lock_read()
 
315
        self.addCleanup(rev1_tree.unlock)
 
316
 
 
317
        subtree2 = subtree.bzrdir.sprout('subdir2').open_workingtree()
 
318
        self.build_tree(['subdir2/file-b'])
 
319
        subtree2.add(['file-b'], ['id-b'])
 
320
        rev2 = subtree2.commit('commit in subdir2')
 
321
        rev2_tree = subtree2.basis_tree()
 
322
        rev2_tree.lock_read()
 
323
        self.addCleanup(rev2_tree.unlock)
 
324
 
 
325
        subtree.merge_from_branch(subtree2.branch)
 
326
        rev3 = subtree.commit('merge from subdir2')
 
327
        rev3_tree = subtree.basis_tree()
 
328
        rev3_tree.lock_read()
 
329
        self.addCleanup(rev3_tree.unlock)
 
330
 
 
331
        repo = tree.branch.repository
 
332
        repo.fetch(subtree.branch.repository, rev3)
 
333
        # will also pull the others...
 
334
 
 
335
        # tree doesn't contain a text merge yet but we'll just
 
336
        # set the parents as if a merge had taken place. 
 
337
        # this should cause the tree data to be folded into the 
 
338
        # dirstate.
 
339
        tree.set_parent_trees([
 
340
            (rev1, rev1_tree),
 
341
            (rev2, rev2_tree),
 
342
            (rev3, rev3_tree), ])
 
343
 
 
344
        # now we should be able to get them back out
 
345
        self.assertTreesEqual(tree.revision_tree(rev1), rev1_tree)
 
346
        self.assertTreesEqual(tree.revision_tree(rev2), rev2_tree)
 
347
        self.assertTreesEqual(tree.revision_tree(rev3), rev3_tree)
 
348
 
 
349
    def test_dirstate_doesnt_read_parents_from_repo_when_setting(self):
 
350
        """Setting parent trees on a dirstate working tree takes
 
351
        the trees it's given and doesn't need to read them from the 
 
352
        repository.
 
353
        """
 
354
        tree = self.make_workingtree()
 
355
 
 
356
        subtree = self.make_branch_and_tree('subdir')
 
357
        rev1 = subtree.commit('commit in subdir')
 
358
        rev1_tree = subtree.basis_tree()
 
359
        rev1_tree.lock_read()
 
360
        self.addCleanup(rev1_tree.unlock)
 
361
 
 
362
        tree.branch.pull(subtree.branch)
 
363
 
 
364
        # break the repository's legs to make sure it only uses the trees
 
365
        # it's given; any calls to forbidden methods will raise an 
 
366
        # AssertionError
 
367
        repo = tree.branch.repository
 
368
        repo.get_revision = self.fail
 
369
        repo.get_inventory = self.fail
 
370
        repo.get_inventory_xml = self.fail
 
371
        # try to set the parent trees.
 
372
        tree.set_parent_trees([(rev1, rev1_tree)])
 
373
 
 
374
    def test_dirstate_doesnt_read_from_repo_when_returning_cache_tree(self):
 
375
        """Getting parent trees from a dirstate tree does not read from the 
 
376
        repos inventory store. This is an important part of the dirstate
 
377
        performance optimisation work.
 
378
        """
 
379
        tree = self.make_workingtree()
 
380
 
 
381
        subtree = self.make_branch_and_tree('subdir')
 
382
        # writelock the tree so its repository doesn't get readlocked by
 
383
        # the revision tree locks. This works around the bug where we dont
 
384
        # permit lock upgrading.
 
385
        subtree.lock_write()
 
386
        self.addCleanup(subtree.unlock)
 
387
        rev1 = subtree.commit('commit in subdir')
 
388
        rev1_tree = subtree.basis_tree()
 
389
        rev1_tree.lock_read()
 
390
        self.addCleanup(rev1_tree.unlock)
 
391
        rev2 = subtree.commit('second commit in subdir', allow_pointless=True)
 
392
        rev2_tree = subtree.basis_tree()
 
393
        rev2_tree.lock_read()
 
394
        self.addCleanup(rev2_tree.unlock)
 
395
 
 
396
        tree.branch.pull(subtree.branch)
 
397
 
 
398
        # break the repository's legs to make sure it only uses the trees
 
399
        # it's given; any calls to forbidden methods will raise an 
 
400
        # AssertionError
 
401
        repo = tree.branch.repository
 
402
        # dont uncomment this: the revision object must be accessed to 
 
403
        # answer 'get_parent_ids' for the revision tree- dirstate does not 
 
404
        # cache the parents of a parent tree at this point.
 
405
        #repo.get_revision = self.fail
 
406
        repo.get_inventory = self.fail
 
407
        repo.get_inventory_xml = self.fail
 
408
        # set the parent trees.
 
409
        tree.set_parent_trees([(rev1, rev1_tree), (rev2, rev2_tree)])
 
410
        # read the first tree
 
411
        result_rev1_tree = tree.revision_tree(rev1)
 
412
        # read the second
 
413
        result_rev2_tree = tree.revision_tree(rev2)
 
414
        # compare - there should be no differences between the handed and 
 
415
        # returned trees
 
416
        self.assertTreesEqual(rev1_tree, result_rev1_tree)
 
417
        self.assertTreesEqual(rev2_tree, result_rev2_tree)
 
418
 
 
419
    def test_dirstate_doesnt_cache_non_parent_trees(self):
 
420
        """Getting parent trees from a dirstate tree does not read from the 
 
421
        repos inventory store. This is an important part of the dirstate
 
422
        performance optimisation work.
 
423
        """
 
424
        tree = self.make_workingtree()
 
425
 
 
426
        # make a tree that we can try for, which is able to be returned but
 
427
        # must not be
 
428
        subtree = self.make_branch_and_tree('subdir')
 
429
        rev1 = subtree.commit('commit in subdir')
 
430
        tree.branch.pull(subtree.branch)
 
431
        # check it fails
 
432
        self.assertRaises(errors.NoSuchRevision, tree.revision_tree, rev1)
 
433
 
 
434
    def test_no_dirstate_outside_lock(self):
 
435
        # temporary test until the code is mature enough to test from outside.
 
436
        """Getting a dirstate object fails if there is no lock."""
 
437
        def lock_and_call_current_dirstate(tree, lock_method):
 
438
            getattr(tree, lock_method)()
 
439
            tree.current_dirstate()
 
440
            tree.unlock()
 
441
        tree = self.make_workingtree()
 
442
        self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
 
443
        lock_and_call_current_dirstate(tree, 'lock_read')
 
444
        self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
 
445
        lock_and_call_current_dirstate(tree, 'lock_write')
 
446
        self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
 
447
        lock_and_call_current_dirstate(tree, 'lock_tree_write')
 
448
        self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate)
 
449
 
 
450
    def test_new_dirstate_on_new_lock(self):
 
451
        # until we have detection for when a dirstate can be reused, we
 
452
        # want to reparse dirstate on every new lock.
 
453
        known_dirstates = set()
 
454
        def lock_and_compare_all_current_dirstate(tree, lock_method):
 
455
            getattr(tree, lock_method)()
 
456
            state = tree.current_dirstate()
 
457
            self.assertFalse(state in known_dirstates)
 
458
            known_dirstates.add(state)
 
459
            tree.unlock()
 
460
        tree = self.make_workingtree()
 
461
        # lock twice with each type to prevent silly per-lock-type bugs.
 
462
        # each lock and compare looks for a unique state object.
 
463
        lock_and_compare_all_current_dirstate(tree, 'lock_read')
 
464
        lock_and_compare_all_current_dirstate(tree, 'lock_read')
 
465
        lock_and_compare_all_current_dirstate(tree, 'lock_tree_write')
 
466
        lock_and_compare_all_current_dirstate(tree, 'lock_tree_write')
 
467
        lock_and_compare_all_current_dirstate(tree, 'lock_write')
 
468
        lock_and_compare_all_current_dirstate(tree, 'lock_write')
 
469
 
 
470
 
242
471
class TestFormat2WorkingTree(TestCaseWithTransport):
243
472
    """Tests that are specific to format 2 trees."""
244
473
 
245
474
    def create_format2_tree(self, url):
246
475
        return self.make_branch_and_tree(
247
 
            url, format=bzrdir.BzrDirFormat6())
 
476
            url, format=bzrlib.bzrdir.BzrDirFormat6())
248
477
 
249
478
    def test_conflicts(self):
250
479
        # test backwards compatability
269
498
        self.assertEqual(list(tree.conflicts()), [expected])
270
499
 
271
500
 
 
501
class TestNonFormatSpecificCode(TestCaseWithTransport):
 
502
    """This class contains tests of workingtree that are not format specific."""
 
503
 
 
504
    def test_gen_file_id(self):
 
505
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_file_id,
 
506
                                      'filename')
 
507
        self.assertStartsWith(file_id, 'filename-')
 
508
 
 
509
    def test_gen_root_id(self):
 
510
        file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_root_id)
 
511
        self.assertStartsWith(file_id, 'tree_root-')
 
512
        
 
513
 
272
514
class InstrumentedTree(object):
273
515
    """A instrumented tree to check the needs_tree_write_lock decorator."""
274
516
 
286
528
    @needs_tree_write_lock
287
529
    def method_that_raises(self):
288
530
        """This method causes an exception when called with parameters.
289
 
 
 
531
        
290
532
        This allows the decorator code to be checked - it should still call
291
533
        unlock.
292
534
        """
303
545
        self.assertEqual(
304
546
            'method_with_tree_write_lock',
305
547
            tree.method_with_tree_write_lock.__name__)
306
 
        self.assertDocstring(
 
548
        self.assertEqual(
307
549
            "A lock_tree_write decorated method that returns its arguments.",
308
 
            tree.method_with_tree_write_lock)
 
550
            tree.method_with_tree_write_lock.__doc__)
309
551
        args = (1, 2, 3)
310
552
        kwargs = {'a':'b'}
311
553
        result = tree.method_with_tree_write_lock(1,2,3, a='b')
313
555
        self.assertEqual(['t', 'u'], tree._locks)
314
556
        self.assertRaises(TypeError, tree.method_that_raises, 'foo')
315
557
        self.assertEqual(['t', 'u', 't', 'u'], tree._locks)
316
 
 
317
 
 
318
 
class TestRevert(TestCaseWithTransport):
319
 
 
320
 
    def test_revert_conflicts_recursive(self):
321
 
        this_tree = self.make_branch_and_tree('this-tree')
322
 
        self.build_tree_contents([('this-tree/foo/',),
323
 
                                  ('this-tree/foo/bar', 'bar')])
324
 
        this_tree.add(['foo', 'foo/bar'])
325
 
        this_tree.commit('created foo/bar')
326
 
        other_tree = this_tree.bzrdir.sprout('other-tree').open_workingtree()
327
 
        self.build_tree_contents([('other-tree/foo/bar', 'baz')])
328
 
        other_tree.commit('changed bar')
329
 
        self.build_tree_contents([('this-tree/foo/bar', 'qux')])
330
 
        this_tree.commit('changed qux')
331
 
        this_tree.merge_from_branch(other_tree.branch)
332
 
        self.assertEqual(1, len(this_tree.conflicts()))
333
 
        this_tree.revert(['foo'])
334
 
        self.assertEqual(0, len(this_tree.conflicts()))
335
 
 
336
 
 
337
 
class TestAutoResolve(TestCaseWithTransport):
338
 
 
339
 
    def test_auto_resolve(self):
340
 
        base = self.make_branch_and_tree('base')
341
 
        self.build_tree_contents([('base/hello', 'Hello')])
342
 
        base.add('hello', 'hello_id')
343
 
        base.commit('Hello')
344
 
        other = base.bzrdir.sprout('other').open_workingtree()
345
 
        self.build_tree_contents([('other/hello', 'hELLO')])
346
 
        other.commit('Case switch')
347
 
        this = base.bzrdir.sprout('this').open_workingtree()
348
 
        self.failUnlessExists('this/hello')
349
 
        self.build_tree_contents([('this/hello', 'Hello World')])
350
 
        this.commit('Add World')
351
 
        this.merge_from_branch(other.branch)
352
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
353
 
                         this.conflicts())
354
 
        this.auto_resolve()
355
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
356
 
                         this.conflicts())
357
 
        self.build_tree_contents([('this/hello', '<<<<<<<')])
358
 
        this.auto_resolve()
359
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
360
 
                         this.conflicts())
361
 
        self.build_tree_contents([('this/hello', '=======')])
362
 
        this.auto_resolve()
363
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
364
 
                         this.conflicts())
365
 
        self.build_tree_contents([('this/hello', '\n>>>>>>>')])
366
 
        remaining, resolved = this.auto_resolve()
367
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
368
 
                         this.conflicts())
369
 
        self.assertEqual([], resolved)
370
 
        self.build_tree_contents([('this/hello', 'hELLO wORLD')])
371
 
        remaining, resolved = this.auto_resolve()
372
 
        self.assertEqual([], this.conflicts())
373
 
        self.assertEqual([conflicts.TextConflict('hello', None, 'hello_id')],
374
 
                         resolved)
375
 
        self.failIfExists('this/hello.BASE')
376
 
 
377
 
    def test_auto_resolve_dir(self):
378
 
        tree = self.make_branch_and_tree('tree')
379
 
        self.build_tree(['tree/hello/'])
380
 
        tree.add('hello', 'hello-id')
381
 
        file_conflict = conflicts.TextConflict('file', None, 'hello-id')
382
 
        tree.set_conflicts(conflicts.ConflictList([file_conflict]))
383
 
        tree.auto_resolve()
384
 
 
385
 
 
386
 
class TestFindTrees(TestCaseWithTransport):
387
 
 
388
 
    def test_find_trees(self):
389
 
        self.make_branch_and_tree('foo')
390
 
        self.make_branch_and_tree('foo/bar')
391
 
        # Sticking a tree inside a control dir is heinous, so let's skip it
392
 
        self.make_branch_and_tree('foo/.bzr/baz')
393
 
        self.make_branch('qux')
394
 
        trees = workingtree.WorkingTree.find_trees('.')
395
 
        self.assertEqual(2, len(list(trees)))