← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Vincent Ladeuil
  • Date: 2008-01-29 15:16:31 UTC
  • mto: (3206.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 3207.
  • Revision ID: v.ladeuil+lp@free.fr-20080129151631-vqjd13tb405mobx6
Fix two more leaking tmp dirs, by reworking TransformPreview lock handling.

* bzrlib/tests/test_transform.py:
(TestTransformMerge): Revert previous patch and cleanly call
preview.finalize now that we can.

* bzrlib/tests/test_merge.py:
(TestMerge.test_make_preview_transform): Catch TransformPreview
leak.

* bzrlib/builtins.py:
(cmd_merge._do_preview): Finalize the TransformPreview or the
limbodir will stay in /tmp.

* bzrlib/transform.py:
(TreeTransformBase.__init__): Create the _deletiondir since it's
reffered to by finalize.
(TreeTransformBase.finalize): Delete the dir only if _deletiondir
is set.
(TreeTransform.__init__): Use a temp var for deletiondir and set
the attribute after the base class __init__ has been called.
(TransformPreview.__init__): Read locks the tree since finalize
wants to unlock it (as suggested by Aaron).

Show diffs side-by-side

added added

removed removed

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