~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Alexander Belchenko
  • Date: 2007-01-04 23:36:44 UTC
  • mfrom: (2224 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2225.
  • Revision ID: bialix@ukr.net-20070104233644-7znkxoj9b0y7ev28
merge bzr.dev

Show diffs side-by-side

added added

removed removed

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