~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_info.py

  • Committer: Martin Pool
  • Date: 2005-05-06 02:34:54 UTC
  • Revision ID: mbp@sourcefrog.net-20050506023454-7118a1b22e8515bc
- ignore any diff files lying around in tree

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
"""Tests for the info command of bzr."""
19
 
 
20
 
import sys
21
 
 
22
 
from bzrlib import (
23
 
    branch,
24
 
    bzrdir,
25
 
    errors,
26
 
    info,
27
 
    osutils,
28
 
    upgrade,
29
 
    urlutils,
30
 
    )
31
 
from bzrlib.osutils import format_date
32
 
from bzrlib.tests import TestSkipped
33
 
from bzrlib.tests.blackbox import ExternalBase
34
 
 
35
 
 
36
 
class TestInfo(ExternalBase):
37
 
 
38
 
    def test_info_non_existing(self):
39
 
        if sys.platform == "win32":
40
 
            location = "C:/i/do/not/exist/"
41
 
        else:
42
 
            location = "/i/do/not/exist/"
43
 
        out, err = self.run_bzr('info '+location, retcode=3)
44
 
        self.assertEqual(out, '')
45
 
        self.assertEqual(err, 'bzr: ERROR: Not a branch: "%s".\n' % location)
46
 
 
47
 
    def test_info_standalone(self):
48
 
        transport = self.get_transport()
49
 
 
50
 
        # Create initial standalone branch
51
 
        tree1 = self.make_branch_and_tree('standalone', 'weave')
52
 
        self.build_tree(['standalone/a'])
53
 
        tree1.add('a')
54
 
        branch1 = tree1.branch
55
 
 
56
 
        out, err = self.run_bzr('info standalone')
57
 
        self.assertEqualDiff(
58
 
"""Standalone tree (format: weave)
59
 
Location:
60
 
  branch root: standalone
61
 
""", out)
62
 
        self.assertEqual('', err)
63
 
 
64
 
        out, err = self.run_bzr('info standalone -v')
65
 
        self.assertEqualDiff(
66
 
"""Standalone tree (format: weave)
67
 
Location:
68
 
  branch root: standalone
69
 
 
70
 
Format:
71
 
       control: All-in-one format 6
72
 
  working tree: Working tree format 2
73
 
        branch: Branch format 4
74
 
    repository: Weave repository format 6
75
 
 
76
 
In the working tree:
77
 
         0 unchanged
78
 
         0 modified
79
 
         1 added
80
 
         0 removed
81
 
         0 renamed
82
 
         0 unknown
83
 
         0 ignored
84
 
         0 versioned subdirectories
85
 
 
86
 
Branch history:
87
 
         0 revisions
88
 
         0 committers
89
 
 
90
 
Repository:
91
 
         0 revisions
92
 
""", out)
93
 
        self.assertEqual('', err)
94
 
        tree1.commit('commit one')
95
 
        rev = branch1.repository.get_revision(branch1.revision_history()[0])
96
 
        datestring_first = format_date(rev.timestamp, rev.timezone)
97
 
 
98
 
        # Branch standalone with push location
99
 
        branch2 = branch1.bzrdir.sprout('branch').open_branch()
100
 
        branch2.set_push_location(branch1.bzrdir.root_transport.base)
101
 
 
102
 
        out, err = self.run_bzr('info branch')
103
 
        self.assertEqualDiff(
104
 
"""Standalone tree (format: weave)
105
 
Location:
106
 
  branch root: branch
107
 
 
108
 
Related branches:
109
 
    push branch: standalone
110
 
  parent branch: standalone
111
 
""", out)
112
 
        self.assertEqual('', err)
113
 
 
114
 
        out, err = self.run_bzr('info branch --verbose')
115
 
        self.assertEqualDiff(
116
 
"""Standalone tree (format: weave)
117
 
Location:
118
 
  branch root: branch
119
 
 
120
 
Related branches:
121
 
    push branch: standalone
122
 
  parent branch: standalone
123
 
 
124
 
Format:
125
 
       control: All-in-one format 6
126
 
  working tree: Working tree format 2
127
 
        branch: Branch format 4
128
 
    repository: Weave repository format 6
129
 
 
130
 
In the working tree:
131
 
         1 unchanged
132
 
         0 modified
133
 
         0 added
134
 
         0 removed
135
 
         0 renamed
136
 
         0 unknown
137
 
         0 ignored
138
 
         0 versioned subdirectories
139
 
 
140
 
Branch history:
141
 
         1 revision
142
 
         1 committer
143
 
         0 days old
144
 
   first revision: %s
145
 
  latest revision: %s
146
 
 
147
 
Repository:
148
 
         1 revision
149
 
""" % (datestring_first, datestring_first,
150
 
       ), out)
151
 
        self.assertEqual('', err)
152
 
 
153
 
        # Branch and bind to standalone, needs upgrade to metadir
154
 
        # (creates backup as unknown)
155
 
        branch1.bzrdir.sprout('bound')
156
 
        knit1_format = bzrdir.format_registry.make_bzrdir('knit')
157
 
        upgrade.upgrade('bound', knit1_format)
158
 
        branch3 = bzrdir.BzrDir.open('bound').open_branch()
159
 
        branch3.bind(branch1)
160
 
        bound_tree = branch3.bzrdir.open_workingtree()
161
 
        out, err = self.run_bzr('info -v bound')
162
 
        self.assertEqualDiff(
163
 
"""Checkout (format: knit)
164
 
Location:
165
 
       checkout root: bound
166
 
  checkout of branch: standalone
167
 
 
168
 
Related branches:
169
 
  parent branch: standalone
170
 
 
171
 
Format:
172
 
       control: Meta directory format 1
173
 
  working tree: %s
174
 
        branch: %s
175
 
    repository: %s
176
 
 
177
 
In the working tree:
178
 
         1 unchanged
179
 
         0 modified
180
 
         0 added
181
 
         0 removed
182
 
         0 renamed
183
 
         1 unknown
184
 
         0 ignored
185
 
         0 versioned subdirectories
186
 
 
187
 
Branch history:
188
 
         1 revision
189
 
         1 committer
190
 
         0 days old
191
 
   first revision: %s
192
 
  latest revision: %s
193
 
 
194
 
Repository:
195
 
         1 revision
196
 
""" % (bound_tree._format.get_format_description(),
197
 
       branch3._format.get_format_description(),
198
 
       branch3.repository._format.get_format_description(),
199
 
       datestring_first, datestring_first,
200
 
       ), out)
201
 
        self.assertEqual('', err)
202
 
 
203
 
        # Checkout standalone (same as above, but does not have parent set)
204
 
        branch4 = bzrdir.BzrDir.create_branch_convenience('checkout',
205
 
            format=knit1_format)
206
 
        branch4.bind(branch1)
207
 
        branch4.bzrdir.open_workingtree().update()
208
 
        out, err = self.run_bzr('info checkout --verbose')
209
 
        self.assertEqualDiff(
210
 
"""Checkout (format: knit)
211
 
Location:
212
 
       checkout root: checkout
213
 
  checkout of branch: standalone
214
 
 
215
 
Format:
216
 
       control: Meta directory format 1
217
 
  working tree: Working tree format 3
218
 
        branch: Branch format 5
219
 
    repository: %s
220
 
 
221
 
In the working tree:
222
 
         1 unchanged
223
 
         0 modified
224
 
         0 added
225
 
         0 removed
226
 
         0 renamed
227
 
         0 unknown
228
 
         0 ignored
229
 
         0 versioned subdirectories
230
 
 
231
 
Branch history:
232
 
         1 revision
233
 
         1 committer
234
 
         0 days old
235
 
   first revision: %s
236
 
  latest revision: %s
237
 
 
238
 
Repository:
239
 
         1 revision
240
 
""" % (branch4.repository._format.get_format_description(),
241
 
       datestring_first, datestring_first,
242
 
       ), out)
243
 
        self.assertEqual('', err)
244
 
 
245
 
        # Lightweight checkout (same as above, different branch and repository)
246
 
        tree5 = branch1.create_checkout('lightcheckout', lightweight=True)
247
 
        branch5 = tree5.branch
248
 
        out, err = self.run_bzr('info -v lightcheckout')
249
 
        self.assertEqualDiff(
250
 
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root \
251
 
or dirstate or dirstate-tags or \
252
 
pack-0.92 or rich-root or rich-root-pack)
253
 
Location:
254
 
  light checkout root: lightcheckout
255
 
   checkout of branch: standalone
256
 
 
257
 
Format:
258
 
       control: Meta directory format 1
259
 
  working tree: Working tree format 4
260
 
        branch: Branch format 4
261
 
    repository: Weave repository format 6
262
 
 
263
 
In the working tree:
264
 
         1 unchanged
265
 
         0 modified
266
 
         0 added
267
 
         0 removed
268
 
         0 renamed
269
 
         0 unknown
270
 
         0 ignored
271
 
         0 versioned subdirectories
272
 
 
273
 
Branch history:
274
 
         1 revision
275
 
         1 committer
276
 
         0 days old
277
 
   first revision: %s
278
 
  latest revision: %s
279
 
 
280
 
Repository:
281
 
         1 revision
282
 
""" % (datestring_first, datestring_first,), out)
283
 
        self.assertEqual('', err)
284
 
 
285
 
        # Update initial standalone branch
286
 
        self.build_tree(['standalone/b'])
287
 
        tree1.add('b')
288
 
        tree1.commit('commit two')
289
 
        rev = branch1.repository.get_revision(branch1.revision_history()[-1])
290
 
        datestring_last = format_date(rev.timestamp, rev.timezone)
291
 
 
292
 
        # Out of date branched standalone branch will not be detected
293
 
        out, err = self.run_bzr('info -v branch')
294
 
        self.assertEqualDiff(
295
 
"""Standalone tree (format: weave)
296
 
Location:
297
 
  branch root: branch
298
 
 
299
 
Related branches:
300
 
    push branch: standalone
301
 
  parent branch: standalone
302
 
 
303
 
Format:
304
 
       control: All-in-one format 6
305
 
  working tree: Working tree format 2
306
 
        branch: Branch format 4
307
 
    repository: Weave repository format 6
308
 
 
309
 
In the working tree:
310
 
         1 unchanged
311
 
         0 modified
312
 
         0 added
313
 
         0 removed
314
 
         0 renamed
315
 
         0 unknown
316
 
         0 ignored
317
 
         0 versioned subdirectories
318
 
 
319
 
Branch history:
320
 
         1 revision
321
 
         1 committer
322
 
         0 days old
323
 
   first revision: %s
324
 
  latest revision: %s
325
 
 
326
 
Repository:
327
 
         1 revision
328
 
""" % (datestring_first, datestring_first,
329
 
       ), out)
330
 
        self.assertEqual('', err)
331
 
 
332
 
        # Out of date bound branch
333
 
        out, err = self.run_bzr('info -v bound')
334
 
        self.assertEqualDiff(
335
 
"""Checkout (format: knit)
336
 
Location:
337
 
       checkout root: bound
338
 
  checkout of branch: standalone
339
 
 
340
 
Related branches:
341
 
  parent branch: standalone
342
 
 
343
 
Format:
344
 
       control: Meta directory format 1
345
 
  working tree: Working tree format 3
346
 
        branch: Branch format 5
347
 
    repository: %s
348
 
 
349
 
Branch is out of date: missing 1 revision.
350
 
 
351
 
In the working tree:
352
 
         1 unchanged
353
 
         0 modified
354
 
         0 added
355
 
         0 removed
356
 
         0 renamed
357
 
         1 unknown
358
 
         0 ignored
359
 
         0 versioned subdirectories
360
 
 
361
 
Branch history:
362
 
         1 revision
363
 
         1 committer
364
 
         0 days old
365
 
   first revision: %s
366
 
  latest revision: %s
367
 
 
368
 
Repository:
369
 
         1 revision
370
 
""" % (branch3.repository._format.get_format_description(),
371
 
       datestring_first, datestring_first,
372
 
       ), out)
373
 
        self.assertEqual('', err)
374
 
 
375
 
        # Out of date checkout
376
 
        out, err = self.run_bzr('info -v checkout')
377
 
        self.assertEqualDiff(
378
 
"""Checkout (format: knit)
379
 
Location:
380
 
       checkout root: checkout
381
 
  checkout of branch: standalone
382
 
 
383
 
Format:
384
 
       control: Meta directory format 1
385
 
  working tree: Working tree format 3
386
 
        branch: Branch format 5
387
 
    repository: %s
388
 
 
389
 
Branch is out of date: missing 1 revision.
390
 
 
391
 
In the working tree:
392
 
         1 unchanged
393
 
         0 modified
394
 
         0 added
395
 
         0 removed
396
 
         0 renamed
397
 
         0 unknown
398
 
         0 ignored
399
 
         0 versioned subdirectories
400
 
 
401
 
Branch history:
402
 
         1 revision
403
 
         1 committer
404
 
         0 days old
405
 
   first revision: %s
406
 
  latest revision: %s
407
 
 
408
 
Repository:
409
 
         1 revision
410
 
""" % (branch4.repository._format.get_format_description(),
411
 
       datestring_first, datestring_first,
412
 
       ), out)
413
 
        self.assertEqual('', err)
414
 
 
415
 
        # Out of date lightweight checkout
416
 
        out, err = self.run_bzr('info lightcheckout --verbose')
417
 
        self.assertEqualDiff(
418
 
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root or \
419
 
dirstate or dirstate-tags or \
420
 
pack-0.92 or rich-root or rich-root-pack)
421
 
Location:
422
 
  light checkout root: lightcheckout
423
 
   checkout of branch: standalone
424
 
 
425
 
Format:
426
 
       control: Meta directory format 1
427
 
  working tree: Working tree format 4
428
 
        branch: Branch format 4
429
 
    repository: Weave repository format 6
430
 
 
431
 
Working tree is out of date: missing 1 revision.
432
 
 
433
 
In the working tree:
434
 
         1 unchanged
435
 
         0 modified
436
 
         0 added
437
 
         0 removed
438
 
         0 renamed
439
 
         0 unknown
440
 
         0 ignored
441
 
         0 versioned subdirectories
442
 
 
443
 
Branch history:
444
 
         2 revisions
445
 
         1 committer
446
 
         0 days old
447
 
   first revision: %s
448
 
  latest revision: %s
449
 
 
450
 
Repository:
451
 
         2 revisions
452
 
""" % (datestring_first, datestring_last,), out)
453
 
        self.assertEqual('', err)
454
 
 
455
 
    def test_info_standalone_no_tree(self):
456
 
        # create standalone branch without a working tree
457
 
        format = bzrdir.format_registry.make_bzrdir('default')
458
 
        branch = self.make_branch('branch')
459
 
        repo = branch.repository
460
 
        out, err = self.run_bzr('info branch -v')
461
 
        self.assertEqualDiff(
462
 
"""Standalone branch (format: %s)
463
 
Location:
464
 
  branch root: branch
465
 
 
466
 
Format:
467
 
       control: Meta directory format 1
468
 
        branch: %s
469
 
    repository: %s
470
 
 
471
 
Branch history:
472
 
         0 revisions
473
 
         0 committers
474
 
 
475
 
Repository:
476
 
         0 revisions
477
 
""" % (info.describe_format(repo.bzrdir, repo, branch, None),
478
 
       format.get_branch_format().get_format_description(),
479
 
       format.repository_format.get_format_description(),
480
 
       ), out)
481
 
        self.assertEqual('', err)
482
 
 
483
 
    def test_info_shared_repository(self):
484
 
        format = bzrdir.format_registry.make_bzrdir('knit')
485
 
        transport = self.get_transport()
486
 
 
487
 
        # Create shared repository
488
 
        repo = self.make_repository('repo', shared=True, format=format)
489
 
        repo.set_make_working_trees(False)
490
 
        out, err = self.run_bzr('info -v repo')
491
 
        self.assertEqualDiff(
492
 
"""Shared repository (format: dirstate or dirstate-tags or knit)
493
 
Location:
494
 
  shared repository: %s
495
 
 
496
 
Format:
497
 
       control: Meta directory format 1
498
 
    repository: %s
499
 
 
500
 
Repository:
501
 
         0 revisions
502
 
""" % ('repo', format.repository_format.get_format_description(),
503
 
       ), out)
504
 
        self.assertEqual('', err)
505
 
 
506
 
        # Create branch inside shared repository
507
 
        repo.bzrdir.root_transport.mkdir('branch')
508
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch',
509
 
            format=format)
510
 
        out, err = self.run_bzr('info -v repo/branch')
511
 
        self.assertEqualDiff(
512
 
"""Repository branch (format: dirstate or knit)
513
 
Location:
514
 
  shared repository: repo
515
 
  repository branch: repo/branch
516
 
 
517
 
Format:
518
 
       control: Meta directory format 1
519
 
        branch: %s
520
 
    repository: %s
521
 
 
522
 
Branch history:
523
 
         0 revisions
524
 
         0 committers
525
 
 
526
 
Repository:
527
 
         0 revisions
528
 
""" % (format.get_branch_format().get_format_description(),
529
 
       format.repository_format.get_format_description(),
530
 
       ), out)
531
 
        self.assertEqual('', err)
532
 
 
533
 
        # Create lightweight checkout
534
 
        transport.mkdir('tree')
535
 
        transport.mkdir('tree/lightcheckout')
536
 
        tree2 = branch1.create_checkout('tree/lightcheckout', 
537
 
            lightweight=True)
538
 
        branch2 = tree2.branch
539
 
        self.assertCheckoutStatusOutput('-v tree/lightcheckout', tree2,
540
 
                   shared_repo=repo, repo_branch=branch1, verbose=True)
541
 
 
542
 
        # Create normal checkout
543
 
        tree3 = branch1.create_checkout('tree/checkout')
544
 
        self.assertCheckoutStatusOutput('tree/checkout --verbose', tree3,
545
 
            verbose=True,
546
 
            light_checkout=False, repo_branch=branch1)
547
 
        # Update lightweight checkout
548
 
        self.build_tree(['tree/lightcheckout/a'])
549
 
        tree2.add('a')
550
 
        tree2.commit('commit one')
551
 
        rev = repo.get_revision(branch2.revision_history()[0])
552
 
        datestring_first = format_date(rev.timestamp, rev.timezone)
553
 
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
554
 
        self.assertEqualDiff(
555
 
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root or \
556
 
dirstate or dirstate-tags or \
557
 
pack-0.92 or rich-root or rich-root-pack)
558
 
Location:
559
 
  light checkout root: tree/lightcheckout
560
 
   checkout of branch: repo/branch
561
 
    shared repository: repo
562
 
 
563
 
Format:
564
 
       control: Meta directory format 1
565
 
  working tree: Working tree format 4
566
 
        branch: %s
567
 
    repository: %s
568
 
 
569
 
In the working tree:
570
 
         1 unchanged
571
 
         0 modified
572
 
         0 added
573
 
         0 removed
574
 
         0 renamed
575
 
         0 unknown
576
 
         0 ignored
577
 
         0 versioned subdirectories
578
 
 
579
 
Branch history:
580
 
         1 revision
581
 
         1 committer
582
 
         0 days old
583
 
   first revision: %s
584
 
  latest revision: %s
585
 
 
586
 
Repository:
587
 
         1 revision
588
 
""" % (format.get_branch_format().get_format_description(),
589
 
       format.repository_format.get_format_description(),
590
 
       datestring_first, datestring_first,
591
 
       ), out)
592
 
        self.assertEqual('', err)
593
 
 
594
 
        # Out of date checkout
595
 
        out, err = self.run_bzr('info -v tree/checkout')
596
 
        self.assertEqualDiff(
597
 
"""Checkout (format: dirstate)
598
 
Location:
599
 
       checkout root: tree/checkout
600
 
  checkout of branch: repo/branch
601
 
 
602
 
Format:
603
 
       control: Meta directory format 1
604
 
  working tree: Working tree format 4
605
 
        branch: %s
606
 
    repository: %s
607
 
 
608
 
Branch is out of date: missing 1 revision.
609
 
 
610
 
In the working tree:
611
 
         0 unchanged
612
 
         0 modified
613
 
         0 added
614
 
         0 removed
615
 
         0 renamed
616
 
         0 unknown
617
 
         0 ignored
618
 
         0 versioned subdirectories
619
 
 
620
 
Branch history:
621
 
         0 revisions
622
 
         0 committers
623
 
 
624
 
Repository:
625
 
         0 revisions
626
 
""" % (format.get_branch_format().get_format_description(),
627
 
       format.repository_format.get_format_description(),
628
 
       ), out)
629
 
        self.assertEqual('', err)
630
 
 
631
 
        # Update checkout
632
 
        tree3.update()
633
 
        self.build_tree(['tree/checkout/b'])
634
 
        tree3.add('b')
635
 
        out, err = self.run_bzr('info tree/checkout --verbose')
636
 
        self.assertEqualDiff(
637
 
"""Checkout (format: dirstate)
638
 
Location:
639
 
       checkout root: tree/checkout
640
 
  checkout of branch: repo/branch
641
 
 
642
 
Format:
643
 
       control: Meta directory format 1
644
 
  working tree: Working tree format 4
645
 
        branch: %s
646
 
    repository: %s
647
 
 
648
 
In the working tree:
649
 
         1 unchanged
650
 
         0 modified
651
 
         1 added
652
 
         0 removed
653
 
         0 renamed
654
 
         0 unknown
655
 
         0 ignored
656
 
         0 versioned subdirectories
657
 
 
658
 
Branch history:
659
 
         1 revision
660
 
         1 committer
661
 
         0 days old
662
 
   first revision: %s
663
 
  latest revision: %s
664
 
 
665
 
Repository:
666
 
         1 revision
667
 
""" % (format.get_branch_format().get_format_description(),
668
 
       format.repository_format.get_format_description(),
669
 
       datestring_first, datestring_first,
670
 
       ), out)
671
 
        self.assertEqual('', err)
672
 
        tree3.commit('commit two')
673
 
 
674
 
        # Out of date lightweight checkout
675
 
        rev = repo.get_revision(branch1.revision_history()[-1])
676
 
        datestring_last = format_date(rev.timestamp, rev.timezone)
677
 
        out, err = self.run_bzr('info tree/lightcheckout --verbose')
678
 
        self.assertEqualDiff(
679
 
"""Lightweight checkout (format: 1.6 or 1.6.1-rich-root or \
680
 
dirstate or dirstate-tags or \
681
 
pack-0.92 or rich-root or rich-root-pack)
682
 
Location:
683
 
  light checkout root: tree/lightcheckout
684
 
   checkout of branch: repo/branch
685
 
    shared repository: repo
686
 
 
687
 
Format:
688
 
       control: Meta directory format 1
689
 
  working tree: Working tree format 4
690
 
        branch: %s
691
 
    repository: %s
692
 
 
693
 
Working tree is out of date: missing 1 revision.
694
 
 
695
 
In the working tree:
696
 
         1 unchanged
697
 
         0 modified
698
 
         0 added
699
 
         0 removed
700
 
         0 renamed
701
 
         0 unknown
702
 
         0 ignored
703
 
         0 versioned subdirectories
704
 
 
705
 
Branch history:
706
 
         2 revisions
707
 
         1 committer
708
 
         0 days old
709
 
   first revision: %s
710
 
  latest revision: %s
711
 
 
712
 
Repository:
713
 
         2 revisions
714
 
""" % (format.get_branch_format().get_format_description(),
715
 
       format.repository_format.get_format_description(),
716
 
       datestring_first, datestring_last,
717
 
       ), out)
718
 
        self.assertEqual('', err)
719
 
 
720
 
        # Show info about shared branch
721
 
        out, err = self.run_bzr('info repo/branch --verbose')
722
 
        self.assertEqualDiff(
723
 
"""Repository branch (format: dirstate or knit)
724
 
Location:
725
 
  shared repository: repo
726
 
  repository branch: repo/branch
727
 
 
728
 
Format:
729
 
       control: Meta directory format 1
730
 
        branch: %s
731
 
    repository: %s
732
 
 
733
 
Branch history:
734
 
         2 revisions
735
 
         1 committer
736
 
         0 days old
737
 
   first revision: %s
738
 
  latest revision: %s
739
 
 
740
 
Repository:
741
 
         2 revisions
742
 
""" % (format.get_branch_format().get_format_description(),
743
 
       format.repository_format.get_format_description(),
744
 
       datestring_first, datestring_last,
745
 
       ), out)
746
 
        self.assertEqual('', err)
747
 
 
748
 
        # Show info about repository with revisions
749
 
        out, err = self.run_bzr('info -v repo')
750
 
        self.assertEqualDiff(
751
 
"""Shared repository (format: dirstate or dirstate-tags or knit)
752
 
Location:
753
 
  shared repository: repo
754
 
 
755
 
Format:
756
 
       control: Meta directory format 1
757
 
    repository: %s
758
 
 
759
 
Repository:
760
 
         2 revisions
761
 
""" % (format.repository_format.get_format_description(),
762
 
       ), out)
763
 
        self.assertEqual('', err)
764
 
 
765
 
    def test_info_shared_repository_with_trees(self):
766
 
        format = bzrdir.format_registry.make_bzrdir('knit')
767
 
        transport = self.get_transport()
768
 
 
769
 
        # Create shared repository with working trees
770
 
        repo = self.make_repository('repo', shared=True, format=format)
771
 
        repo.set_make_working_trees(True)
772
 
        out, err = self.run_bzr('info -v repo')
773
 
        self.assertEqualDiff(
774
 
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
775
 
Location:
776
 
  shared repository: repo
777
 
 
778
 
Format:
779
 
       control: Meta directory format 1
780
 
    repository: %s
781
 
 
782
 
Create working tree for new branches inside the repository.
783
 
 
784
 
Repository:
785
 
         0 revisions
786
 
""" % (format.repository_format.get_format_description(),
787
 
       ), out)
788
 
        self.assertEqual('', err)
789
 
 
790
 
        # Create two branches
791
 
        repo.bzrdir.root_transport.mkdir('branch1')
792
 
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch1',
793
 
            format=format)
794
 
        branch2 = branch1.bzrdir.sprout('repo/branch2').open_branch()
795
 
 
796
 
        # Empty first branch
797
 
        out, err = self.run_bzr('info repo/branch1 --verbose')
798
 
        self.assertEqualDiff(
799
 
"""Repository tree (format: knit)
800
 
Location:
801
 
  shared repository: repo
802
 
  repository branch: repo/branch1
803
 
 
804
 
Format:
805
 
       control: Meta directory format 1
806
 
  working tree: Working tree format 3
807
 
        branch: %s
808
 
    repository: %s
809
 
 
810
 
In the working tree:
811
 
         0 unchanged
812
 
         0 modified
813
 
         0 added
814
 
         0 removed
815
 
         0 renamed
816
 
         0 unknown
817
 
         0 ignored
818
 
         0 versioned subdirectories
819
 
 
820
 
Branch history:
821
 
         0 revisions
822
 
         0 committers
823
 
 
824
 
Repository:
825
 
         0 revisions
826
 
""" % (format.get_branch_format().get_format_description(),
827
 
       format.repository_format.get_format_description(),
828
 
       ), out)
829
 
        self.assertEqual('', err)
830
 
 
831
 
        # Update first branch
832
 
        self.build_tree(['repo/branch1/a'])
833
 
        tree1 = branch1.bzrdir.open_workingtree()
834
 
        tree1.add('a')
835
 
        tree1.commit('commit one')
836
 
        rev = repo.get_revision(branch1.revision_history()[0])
837
 
        datestring_first = format_date(rev.timestamp, rev.timezone)
838
 
        out, err = self.run_bzr('info -v repo/branch1')
839
 
        self.assertEqualDiff(
840
 
"""Repository tree (format: knit)
841
 
Location:
842
 
  shared repository: repo
843
 
  repository branch: repo/branch1
844
 
 
845
 
Format:
846
 
       control: Meta directory format 1
847
 
  working tree: Working tree format 3
848
 
        branch: %s
849
 
    repository: %s
850
 
 
851
 
In the working tree:
852
 
         1 unchanged
853
 
         0 modified
854
 
         0 added
855
 
         0 removed
856
 
         0 renamed
857
 
         0 unknown
858
 
         0 ignored
859
 
         0 versioned subdirectories
860
 
 
861
 
Branch history:
862
 
         1 revision
863
 
         1 committer
864
 
         0 days old
865
 
   first revision: %s
866
 
  latest revision: %s
867
 
 
868
 
Repository:
869
 
         1 revision
870
 
""" % (format.get_branch_format().get_format_description(),
871
 
       format.repository_format.get_format_description(),
872
 
       datestring_first, datestring_first,
873
 
       ), out)
874
 
        self.assertEqual('', err)
875
 
 
876
 
        # Out of date second branch
877
 
        out, err = self.run_bzr('info repo/branch2 --verbose')
878
 
        self.assertEqualDiff(
879
 
"""Repository tree (format: knit)
880
 
Location:
881
 
  shared repository: repo
882
 
  repository branch: repo/branch2
883
 
 
884
 
Related branches:
885
 
  parent branch: repo/branch1
886
 
 
887
 
Format:
888
 
       control: Meta directory format 1
889
 
  working tree: Working tree format 3
890
 
        branch: %s
891
 
    repository: %s
892
 
 
893
 
In the working tree:
894
 
         0 unchanged
895
 
         0 modified
896
 
         0 added
897
 
         0 removed
898
 
         0 renamed
899
 
         0 unknown
900
 
         0 ignored
901
 
         0 versioned subdirectories
902
 
 
903
 
Branch history:
904
 
         0 revisions
905
 
         0 committers
906
 
 
907
 
Repository:
908
 
         1 revision
909
 
""" % (format.get_branch_format().get_format_description(),
910
 
       format.repository_format.get_format_description(),
911
 
       ), out)
912
 
        self.assertEqual('', err)
913
 
 
914
 
        # Update second branch
915
 
        tree2 = branch2.bzrdir.open_workingtree()
916
 
        tree2.pull(branch1)
917
 
        out, err = self.run_bzr('info -v repo/branch2')
918
 
        self.assertEqualDiff(
919
 
"""Repository tree (format: knit)
920
 
Location:
921
 
  shared repository: repo
922
 
  repository branch: repo/branch2
923
 
 
924
 
Related branches:
925
 
  parent branch: repo/branch1
926
 
 
927
 
Format:
928
 
       control: Meta directory format 1
929
 
  working tree: Working tree format 3
930
 
        branch: %s
931
 
    repository: %s
932
 
 
933
 
In the working tree:
934
 
         1 unchanged
935
 
         0 modified
936
 
         0 added
937
 
         0 removed
938
 
         0 renamed
939
 
         0 unknown
940
 
         0 ignored
941
 
         0 versioned subdirectories
942
 
 
943
 
Branch history:
944
 
         1 revision
945
 
         1 committer
946
 
         0 days old
947
 
   first revision: %s
948
 
  latest revision: %s
949
 
 
950
 
Repository:
951
 
         1 revision
952
 
""" % (format.get_branch_format().get_format_description(),
953
 
       format.repository_format.get_format_description(),
954
 
       datestring_first, datestring_first,
955
 
       ), out)
956
 
        self.assertEqual('', err)
957
 
 
958
 
        # Show info about repository with revisions
959
 
        out, err = self.run_bzr('info -v repo')
960
 
        self.assertEqualDiff(
961
 
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
962
 
Location:
963
 
  shared repository: repo
964
 
 
965
 
Format:
966
 
       control: Meta directory format 1
967
 
    repository: %s
968
 
 
969
 
Create working tree for new branches inside the repository.
970
 
 
971
 
Repository:
972
 
         1 revision
973
 
""" % (format.repository_format.get_format_description(),
974
 
       ),
975
 
       out)
976
 
        self.assertEqual('', err)
977
 
    
978
 
    def test_info_shared_repository_with_tree_in_root(self):
979
 
        format = bzrdir.format_registry.make_bzrdir('knit')
980
 
        transport = self.get_transport()
981
 
 
982
 
        # Create shared repository with working trees
983
 
        repo = self.make_repository('repo', shared=True, format=format)
984
 
        repo.set_make_working_trees(True)
985
 
        out, err = self.run_bzr('info -v repo')
986
 
        self.assertEqualDiff(
987
 
"""Shared repository with trees (format: dirstate or dirstate-tags or knit)
988
 
Location:
989
 
  shared repository: repo
990
 
 
991
 
Format:
992
 
       control: Meta directory format 1
993
 
    repository: %s
994
 
 
995
 
Create working tree for new branches inside the repository.
996
 
 
997
 
Repository:
998
 
         0 revisions
999
 
""" % (format.repository_format.get_format_description(),
1000
 
       ), out)
1001
 
        self.assertEqual('', err)
1002
 
 
1003
 
        # Create branch in root of repository
1004
 
        control = repo.bzrdir
1005
 
        branch = control.create_branch()
1006
 
        control.create_workingtree()
1007
 
        out, err = self.run_bzr('info -v repo')
1008
 
        self.assertEqualDiff(
1009
 
"""Repository tree (format: knit)
1010
 
Location:
1011
 
  shared repository: repo
1012
 
  repository branch: repo
1013
 
 
1014
 
Format:
1015
 
       control: Meta directory format 1
1016
 
  working tree: Working tree format 3
1017
 
        branch: %s
1018
 
    repository: %s
1019
 
 
1020
 
In the working tree:
1021
 
         0 unchanged
1022
 
         0 modified
1023
 
         0 added
1024
 
         0 removed
1025
 
         0 renamed
1026
 
         0 unknown
1027
 
         0 ignored
1028
 
         0 versioned subdirectories
1029
 
 
1030
 
Branch history:
1031
 
         0 revisions
1032
 
         0 committers
1033
 
 
1034
 
Repository:
1035
 
         0 revisions
1036
 
""" % (format.get_branch_format().get_format_description(),
1037
 
       format.repository_format.get_format_description(),
1038
 
       ), out)
1039
 
        self.assertEqual('', err)
1040
 
 
1041
 
    def assertCheckoutStatusOutput(self,
1042
 
        command_string, lco_tree, shared_repo=None,
1043
 
        repo_branch=None,
1044
 
        tree_locked=False,
1045
 
        branch_locked=False, repo_locked=False,
1046
 
        verbose=False,
1047
 
        light_checkout=True,
1048
 
        checkout_root=None):
1049
 
        """Check the output of info in a checkout.
1050
 
 
1051
 
        This is not quite a mirror of the info code: rather than using the
1052
 
        tree being examined to predict output, it uses a bunch of flags which
1053
 
        allow us, the test writers, to document what *should* be present in
1054
 
        the output. Removing this separation would remove the value of the
1055
 
        tests.
1056
 
        
1057
 
        :param path: the path to the light checkout.
1058
 
        :param lco_tree: the tree object for the light checkout.
1059
 
        :param shared_repo: A shared repository is in use, expect that in
1060
 
            the output.
1061
 
        :param repo_branch: A branch in a shared repository for non light
1062
 
            checkouts.
1063
 
        :param tree_locked: If true, expect the tree to be locked.
1064
 
        :param branch_locked: If true, expect the branch to be locked.
1065
 
        :param repo_locked: If true, expect the repository to be locked.
1066
 
            Note that the lco_tree.branch.repository is inspected, and if is not
1067
 
            actually locked then this parameter is overridden. This is because
1068
 
            pack repositories do not have any public API for obtaining an
1069
 
            exclusive repository wide lock.
1070
 
        :param verbose: If true, expect verbose output
1071
 
        """
1072
 
        def friendly_location(url):
1073
 
            path = urlutils.unescape_for_display(url, 'ascii')
1074
 
            try:
1075
 
                return osutils.relpath(osutils.getcwd(), path)
1076
 
            except errors.PathNotChild:
1077
 
                return path
1078
 
 
1079
 
        if tree_locked:
1080
 
            # We expect this to fail because of locking errors.
1081
 
            # (A write-locked file cannot be read-locked
1082
 
            # in the different process -- either on win32 or on linux).
1083
 
            # This should be removed when the locking errors are fixed.
1084
 
            self.expectFailure('OS locks are exclusive '
1085
 
                'for different processes (Bug #174055)',
1086
 
                self.run_bzr_subprocess,
1087
 
                'info ' + command_string)
1088
 
        out, err = self.run_bzr('info %s' % command_string)
1089
 
        description = {
1090
 
            (True, True): 'Lightweight checkout',
1091
 
            (True, False): 'Repository checkout',
1092
 
            (False, True): 'Lightweight checkout',
1093
 
            (False, False): 'Checkout',
1094
 
            }[(shared_repo is not None, light_checkout)]
1095
 
        format = {True: '1.6 or 1.6.1-rich-root'
1096
 
                        ' or dirstate or dirstate-tags or pack-0.92'
1097
 
                        ' or rich-root or rich-root-pack',
1098
 
                  False: 'dirstate'}[light_checkout]
1099
 
        if repo_locked:
1100
 
            repo_locked = lco_tree.branch.repository.get_physical_lock_status()
1101
 
        if repo_locked or branch_locked or tree_locked:
1102
 
            def locked_message(a_bool):
1103
 
                if a_bool:
1104
 
                    return 'locked'
1105
 
                else:
1106
 
                    return 'unlocked'
1107
 
            expected_lock_output = (
1108
 
                "\n"
1109
 
                "Lock status:\n"
1110
 
                "  working tree: %s\n"
1111
 
                "        branch: %s\n"
1112
 
                "    repository: %s\n" % (
1113
 
                    locked_message(tree_locked),
1114
 
                    locked_message(branch_locked),
1115
 
                    locked_message(repo_locked)))
1116
 
        else:
1117
 
            expected_lock_output = ''
1118
 
        tree_data = ''
1119
 
        extra_space = ''
1120
 
        if light_checkout:
1121
 
            tree_data = ("  light checkout root: %s\n" %
1122
 
                friendly_location(lco_tree.bzrdir.root_transport.base))
1123
 
            extra_space = ' '
1124
 
        if lco_tree.branch.get_bound_location() is not None:
1125
 
            tree_data += ("%s       checkout root: %s\n" % (extra_space,
1126
 
                friendly_location(lco_tree.branch.bzrdir.root_transport.base)))
1127
 
        if shared_repo is not None:
1128
 
            branch_data = (
1129
 
                "   checkout of branch: %s\n"
1130
 
                "    shared repository: %s\n" %
1131
 
                (friendly_location(repo_branch.bzrdir.root_transport.base),
1132
 
                 friendly_location(shared_repo.bzrdir.root_transport.base)))
1133
 
        elif repo_branch is not None:
1134
 
            branch_data = (
1135
 
                "%s  checkout of branch: %s\n" %
1136
 
                (extra_space,
1137
 
                 friendly_location(repo_branch.bzrdir.root_transport.base)))
1138
 
        else:
1139
 
            branch_data = ("   checkout of branch: %s\n" %
1140
 
                lco_tree.branch.bzrdir.root_transport.base)
1141
 
        
1142
 
        if verbose:
1143
 
            verbose_info = '         0 committers\n'
1144
 
        else:
1145
 
            verbose_info = ''
1146
 
            
1147
 
        self.assertEqualDiff(
1148
 
"""%s (format: %s)
1149
 
Location:
1150
 
%s%s
1151
 
Format:
1152
 
       control: Meta directory format 1
1153
 
  working tree: %s
1154
 
        branch: %s
1155
 
    repository: %s
1156
 
%s
1157
 
In the working tree:
1158
 
         0 unchanged
1159
 
         0 modified
1160
 
         0 added
1161
 
         0 removed
1162
 
         0 renamed
1163
 
         0 unknown
1164
 
         0 ignored
1165
 
         0 versioned subdirectories
1166
 
 
1167
 
Branch history:
1168
 
         0 revisions
1169
 
%s
1170
 
Repository:
1171
 
         0 revisions
1172
 
""" %  (description,
1173
 
        format,
1174
 
        tree_data,
1175
 
        branch_data,
1176
 
        lco_tree._format.get_format_description(),
1177
 
        lco_tree.branch._format.get_format_description(),
1178
 
        lco_tree.branch.repository._format.get_format_description(),
1179
 
        expected_lock_output,
1180
 
        verbose_info,
1181
 
        ), out)
1182
 
        self.assertEqual('', err)
1183
 
 
1184
 
    def test_info_locking(self):
1185
 
        transport = self.get_transport()
1186
 
        # Create shared repository with a branch
1187
 
        repo = self.make_repository('repo', shared=True,
1188
 
                                    format=bzrdir.BzrDirMetaFormat1())
1189
 
        repo.set_make_working_trees(False)
1190
 
        repo.bzrdir.root_transport.mkdir('branch')
1191
 
        repo_branch = repo.bzrdir.create_branch_convenience('repo/branch',
1192
 
                                    format=bzrdir.BzrDirMetaFormat1())
1193
 
        # Do a heavy checkout
1194
 
        transport.mkdir('tree')
1195
 
        transport.mkdir('tree/checkout')
1196
 
        co_branch = bzrdir.BzrDir.create_branch_convenience('tree/checkout',
1197
 
            format=bzrdir.BzrDirMetaFormat1())
1198
 
        co_branch.bind(repo_branch)
1199
 
        # Do a light checkout of the heavy one
1200
 
        transport.mkdir('tree/lightcheckout')
1201
 
        lco_dir = bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
1202
 
        branch.BranchReferenceFormat().initialize(lco_dir, co_branch)
1203
 
        lco_dir.create_workingtree()
1204
 
        lco_tree = lco_dir.open_workingtree()
1205
 
 
1206
 
        # Test all permutations of locking the working tree, branch and repository
1207
 
        # W B R
1208
 
 
1209
 
        # U U U
1210
 
        self.assertCheckoutStatusOutput('-v tree/lightcheckout', lco_tree,
1211
 
                                        repo_branch=repo_branch,
1212
 
                                        verbose=True, light_checkout=True)
1213
 
        # U U L
1214
 
        lco_tree.branch.repository.lock_write()
1215
 
        try:
1216
 
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
1217
 
            lco_tree, repo_branch=repo_branch,
1218
 
            repo_locked=True, verbose=True, light_checkout=True)
1219
 
        finally:
1220
 
            lco_tree.branch.repository.unlock()
1221
 
        # U L L
1222
 
        lco_tree.branch.lock_write()
1223
 
        try:
1224
 
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
1225
 
            lco_tree,
1226
 
            branch_locked=True,
1227
 
            repo_locked=True,
1228
 
            repo_branch=repo_branch,
1229
 
            verbose=True)
1230
 
        finally:
1231
 
            lco_tree.branch.unlock()
1232
 
        # L L L
1233
 
        lco_tree.lock_write()
1234
 
        try:
1235
 
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
1236
 
            lco_tree, repo_branch=repo_branch,
1237
 
            tree_locked=True,
1238
 
            branch_locked=True,
1239
 
            repo_locked=True,
1240
 
            verbose=True)
1241
 
        finally:
1242
 
            lco_tree.unlock()
1243
 
        # L L U
1244
 
        lco_tree.lock_write()
1245
 
        lco_tree.branch.repository.unlock()
1246
 
        try:
1247
 
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
1248
 
            lco_tree, repo_branch=repo_branch,
1249
 
            tree_locked=True,
1250
 
            branch_locked=True,
1251
 
            verbose=True)
1252
 
        finally:
1253
 
            lco_tree.branch.repository.lock_write()
1254
 
            lco_tree.unlock()
1255
 
        # L U U
1256
 
        lco_tree.lock_write()
1257
 
        lco_tree.branch.unlock()
1258
 
        try:
1259
 
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
1260
 
            lco_tree, repo_branch=repo_branch,
1261
 
            tree_locked=True,
1262
 
            verbose=True)
1263
 
        finally:
1264
 
            lco_tree.branch.lock_write()
1265
 
            lco_tree.unlock()
1266
 
        # L U L
1267
 
        lco_tree.lock_write()
1268
 
        lco_tree.branch.unlock()
1269
 
        lco_tree.branch.repository.lock_write()
1270
 
        try:
1271
 
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
1272
 
            lco_tree, repo_branch=repo_branch,
1273
 
            tree_locked=True,
1274
 
            repo_locked=True,
1275
 
            verbose=True)
1276
 
        finally:
1277
 
            lco_tree.branch.repository.unlock()
1278
 
            lco_tree.branch.lock_write()
1279
 
            lco_tree.unlock()
1280
 
        # U L U
1281
 
        lco_tree.branch.lock_write()
1282
 
        lco_tree.branch.repository.unlock()
1283
 
        try:
1284
 
            self.assertCheckoutStatusOutput('-v tree/lightcheckout',
1285
 
            lco_tree, repo_branch=repo_branch,
1286
 
            branch_locked=True,
1287
 
            verbose=True)
1288
 
        finally:
1289
 
            lco_tree.branch.repository.lock_write()
1290
 
            lco_tree.branch.unlock()
1291
 
 
1292
 
        if sys.platform == 'win32':
1293
 
            self.knownFailure('Win32 cannot run "bzr info"'
1294
 
                              ' when the tree is locked.')
1295
 
 
1296
 
    def test_info_locking_oslocks(self):
1297
 
        if sys.platform == "win32":
1298
 
            raise TestSkipped("don't use oslocks on win32 in unix manner")
1299
 
 
1300
 
        tree = self.make_branch_and_tree('branch',
1301
 
                                         format=bzrdir.BzrDirFormat6())
1302
 
 
1303
 
        # Test all permutations of locking the working tree, branch and repository
1304
 
        # XXX: Well not yet, as we can't query oslocks yet. Currently, it's
1305
 
        # implemented by raising NotImplementedError and get_physical_lock_status()
1306
 
        # always returns false. This makes bzr info hide the lock status.  (Olaf)
1307
 
        # W B R
1308
 
 
1309
 
        # U U U
1310
 
        out, err = self.run_bzr('info -v branch')
1311
 
        self.assertEqualDiff(
1312
 
"""Standalone tree (format: weave)
1313
 
Location:
1314
 
  branch root: %s
1315
 
 
1316
 
Format:
1317
 
       control: All-in-one format 6
1318
 
  working tree: Working tree format 2
1319
 
        branch: Branch format 4
1320
 
    repository: %s
1321
 
 
1322
 
In the working tree:
1323
 
         0 unchanged
1324
 
         0 modified
1325
 
         0 added
1326
 
         0 removed
1327
 
         0 renamed
1328
 
         0 unknown
1329
 
         0 ignored
1330
 
         0 versioned subdirectories
1331
 
 
1332
 
Branch history:
1333
 
         0 revisions
1334
 
         0 committers
1335
 
 
1336
 
Repository:
1337
 
         0 revisions
1338
 
""" % ('branch', tree.branch.repository._format.get_format_description(),
1339
 
       ), out)
1340
 
        self.assertEqual('', err)
1341
 
        # L L L
1342
 
        tree.lock_write()
1343
 
        out, err = self.run_bzr('info -v branch')
1344
 
        self.assertEqualDiff(
1345
 
"""Standalone tree (format: weave)
1346
 
Location:
1347
 
  branch root: %s
1348
 
 
1349
 
Format:
1350
 
       control: All-in-one format 6
1351
 
  working tree: Working tree format 2
1352
 
        branch: Branch format 4
1353
 
    repository: %s
1354
 
 
1355
 
In the working tree:
1356
 
         0 unchanged
1357
 
         0 modified
1358
 
         0 added
1359
 
         0 removed
1360
 
         0 renamed
1361
 
         0 unknown
1362
 
         0 ignored
1363
 
         0 versioned subdirectories
1364
 
 
1365
 
Branch history:
1366
 
         0 revisions
1367
 
         0 committers
1368
 
 
1369
 
Repository:
1370
 
         0 revisions
1371
 
""" % ('branch', tree.branch.repository._format.get_format_description(),
1372
 
       ), out)
1373
 
        self.assertEqual('', err)
1374
 
        tree.unlock()
1375
 
 
1376
 
    def test_info_stacked(self):
1377
 
        # We have a mainline
1378
 
        trunk_tree = self.make_branch_and_tree('mainline',
1379
 
            format='1.6')
1380
 
        trunk_tree.commit('mainline')
1381
 
        # and a branch from it which is stacked
1382
 
        new_dir = trunk_tree.bzrdir.sprout('newbranch', stacked=True)
1383
 
        out, err = self.run_bzr('info newbranch')
1384
 
        self.assertEqual(
1385
 
"""Standalone tree (format: 1.6)
1386
 
Location:
1387
 
  branch root: newbranch
1388
 
 
1389
 
Related branches:
1390
 
  parent branch: mainline
1391
 
     stacked on: mainline
1392
 
""", out)
1393
 
        self.assertEqual("", err)