~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-07-06 03:15:29 UTC
  • mfrom: (1711.2.78 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060706031529-e189d8c3f42076be
(jam) allow plugins to include benchmarks

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006, 2007 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2006 by Canonical Ltd
 
2
# -*- coding: utf-8 -*-
 
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
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
7
 
#
 
8
 
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
12
# GNU General Public License for more details.
12
 
#
 
13
 
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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
 
    )
30
24
from bzrlib.osutils import format_date
31
25
from bzrlib.tests import TestSkipped
32
26
from bzrlib.tests.blackbox import ExternalBase
39
33
            location = "C:/i/do/not/exist/"
40
34
        else:
41
35
            location = "/i/do/not/exist/"
42
 
        out, err = self.run_bzr('info '+location, retcode=3)
 
36
        out, err = self.runbzr('info '+location, retcode=3)
43
37
        self.assertEqual(out, '')
44
38
        self.assertEqual(err, 'bzr: ERROR: Not a branch: %s\n' % location)
45
39
 
47
41
        transport = self.get_transport()
48
42
 
49
43
        # Create initial standalone branch
50
 
        tree1 = self.make_branch_and_tree('standalone', 'weave')
 
44
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
 
45
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirFormat6())
 
46
        tree1 = self.make_branch_and_tree('standalone')
 
47
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
51
48
        self.build_tree(['standalone/a'])
52
49
        tree1.add('a')
53
50
        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
 
51
        out, err = self.runbzr('info standalone')
 
52
        self.assertEqualDiff(
 
53
"""Location:
 
54
  branch root: %s
68
55
 
69
56
Format:
70
57
       control: All-in-one format 6
84
71
 
85
72
Branch history:
86
73
         0 revisions
87
 
         0 committers
88
74
 
89
 
Repository:
 
75
Revision store:
90
76
         0 revisions
91
77
         0 KiB
92
 
""", out)
 
78
""" % branch1.bzrdir.root_transport.base, out)
93
79
        self.assertEqual('', err)
94
80
        tree1.commit('commit one')
95
81
        rev = branch1.repository.get_revision(branch1.revision_history()[0])
98
84
        # Branch standalone with push location
99
85
        branch2 = branch1.bzrdir.sprout('branch').open_branch()
100
86
        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
 
87
        out, err = self.runbzr('info branch --verbose')
 
88
        self.assertEqualDiff(
 
89
"""Location:
 
90
  branch root: %s
 
91
 
 
92
Related branches:
 
93
      parent branch: %s
 
94
  publish to branch: %s
123
95
 
124
96
Format:
125
97
       control: All-in-one format 6
144
116
   first revision: %s
145
117
  latest revision: %s
146
118
 
147
 
Repository:
 
119
Revision store:
148
120
         1 revision
149
121
         %d KiB
150
 
""" % (datestring_first, datestring_first,
 
122
""" % (branch2.bzrdir.root_transport.base,
 
123
       branch1.bzrdir.root_transport.base,
 
124
       branch1.bzrdir.root_transport.base,
 
125
       datestring_first, datestring_first,
151
126
       # poking at _revision_store isn't all that clean, but neither is
152
127
       # having the ui test dependent on the exact overhead of a given store.
153
128
       branch2.repository._revision_store.total_size(
158
133
        # Branch and bind to standalone, needs upgrade to metadir
159
134
        # (creates backup as unknown)
160
135
        branch1.bzrdir.sprout('bound')
161
 
        knit1_format = bzrdir.format_registry.make_bzrdir('knit')
162
 
        bzrlib.upgrade.upgrade('bound', knit1_format)
 
136
        bzrlib.upgrade.upgrade('bound', bzrlib.bzrdir.BzrDirMetaFormat1())
163
137
        branch3 = bzrlib.bzrdir.BzrDir.open('bound').open_branch()
164
138
        branch3.bind(branch1)
165
139
        bound_tree = branch3.bzrdir.open_workingtree()
166
 
        out, err = self.run_bzr('info -v bound')
 
140
        out, err = self.runbzr('info bound')
167
141
        self.assertEqualDiff(
168
 
"""Checkout (format: knit)
169
 
Location:
170
 
       checkout root: bound
171
 
  checkout of branch: standalone
 
142
"""Location:
 
143
       checkout root: %s
 
144
  checkout of branch: %s
172
145
 
173
146
Related branches:
174
 
  parent branch: standalone
 
147
  parent branch: %s
175
148
 
176
149
Format:
177
150
       control: Meta directory format 1
178
151
  working tree: %s
179
 
        branch: %s
 
152
        branch: Branch format 5
180
153
    repository: %s
181
154
 
182
155
In the working tree:
191
164
 
192
165
Branch history:
193
166
         1 revision
194
 
         1 committer
195
167
         0 days old
196
168
   first revision: %s
197
169
  latest revision: %s
198
170
 
199
 
Repository:
 
171
Revision store:
200
172
         1 revision
201
173
         %d KiB
202
 
""" % (bound_tree._format.get_format_description(),
203
 
       branch3._format.get_format_description(),
 
174
""" % (branch3.bzrdir.root_transport.base,
 
175
       branch1.bzrdir.root_transport.base,
 
176
       branch1.bzrdir.root_transport.base,
 
177
       bound_tree._format.get_format_description(),      
204
178
       branch3.repository._format.get_format_description(),
205
179
       datestring_first, datestring_first,
206
180
       # poking at _revision_store isn't all that clean, but neither is
211
185
        self.assertEqual('', err)
212
186
 
213
187
        # Checkout standalone (same as above, but does not have parent set)
214
 
        branch4 = bzrlib.bzrdir.BzrDir.create_branch_convenience('checkout',
215
 
            format=knit1_format)
 
188
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
 
189
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
 
190
        branch4 = bzrlib.bzrdir.BzrDir.create_branch_convenience('checkout')
 
191
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
216
192
        branch4.bind(branch1)
217
193
        branch4.bzrdir.open_workingtree().update()
218
 
        out, err = self.run_bzr('info checkout --verbose')
 
194
        out, err = self.runbzr('info checkout --verbose')
219
195
        self.assertEqualDiff(
220
 
"""Checkout (format: knit)
221
 
Location:
222
 
       checkout root: checkout
223
 
  checkout of branch: standalone
 
196
"""Location:
 
197
       checkout root: %s
 
198
  checkout of branch: %s
224
199
 
225
200
Format:
226
201
       control: Meta directory format 1
245
220
   first revision: %s
246
221
  latest revision: %s
247
222
 
248
 
Repository:
 
223
Revision store:
249
224
         1 revision
250
225
         %d KiB
251
 
""" % (branch4.repository._format.get_format_description(),
 
226
""" % (branch4.bzrdir.root_transport.base,
 
227
       branch1.bzrdir.root_transport.base,
 
228
       branch4.repository._format.get_format_description(),
252
229
       datestring_first, datestring_first,
253
230
       # poking at _revision_store isn't all that clean, but neither is
254
231
       # having the ui test dependent on the exact overhead of a given store.
258
235
        self.assertEqual('', err)
259
236
 
260
237
        # Lightweight checkout (same as above, different branch and repository)
261
 
        tree5 = branch1.create_checkout('lightcheckout', lightweight=True)
 
238
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
 
239
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
 
240
        transport.mkdir('lightcheckout')
 
241
        dir5 = bzrlib.bzrdir.BzrDirMetaFormat1().initialize('lightcheckout')
 
242
        bzrlib.branch.BranchReferenceFormat().initialize(dir5, branch1)
 
243
        dir5.create_workingtree()
 
244
        tree5 = dir5.open_workingtree()
 
245
        bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)
262
246
        branch5 = tree5.branch
263
 
        out, err = self.run_bzr('info -v lightcheckout')
 
247
        out, err = self.runbzr('info lightcheckout')
264
248
        self.assertEqualDiff(
265
 
"""Lightweight checkout (format: dirstate or dirstate-tags)
266
 
Location:
267
 
  light checkout root: lightcheckout
268
 
   checkout of branch: standalone
 
249
"""Location:
 
250
 light checkout root: %s
 
251
  checkout of branch: %s
269
252
 
270
253
Format:
271
254
       control: Meta directory format 1
272
 
  working tree: Working tree format 4
 
255
  working tree: Working tree format 3
273
256
        branch: Branch format 4
274
257
    repository: Weave repository format 6
275
258
 
285
268
 
286
269
Branch history:
287
270
         1 revision
288
 
         1 committer
289
271
         0 days old
290
272
   first revision: %s
291
273
  latest revision: %s
292
274
 
293
 
Repository:
 
275
Revision store:
294
276
         1 revision
295
277
         0 KiB
296
 
""" % (datestring_first, datestring_first,), out)
 
278
""" % (tree5.bzrdir.root_transport.base,
 
279
       branch1.bzrdir.root_transport.base,
 
280
       datestring_first, datestring_first,
 
281
       ), out)
297
282
        self.assertEqual('', err)
298
283
 
299
284
        # Update initial standalone branch
304
289
        datestring_last = format_date(rev.timestamp, rev.timezone)
305
290
 
306
291
        # Out of date branched standalone branch will not be detected
307
 
        out, err = self.run_bzr('info -v branch')
 
292
        out, err = self.runbzr('info branch')
308
293
        self.assertEqualDiff(
309
 
"""Standalone tree (format: weave)
310
 
Location:
311
 
  branch root: branch
 
294
"""Location:
 
295
  branch root: %s
312
296
 
313
297
Related branches:
314
 
    push branch: standalone
315
 
  parent branch: standalone
 
298
      parent branch: %s
 
299
  publish to branch: %s
316
300
 
317
301
Format:
318
302
       control: All-in-one format 6
332
316
 
333
317
Branch history:
334
318
         1 revision
335
 
         1 committer
336
319
         0 days old
337
320
   first revision: %s
338
321
  latest revision: %s
339
322
 
340
 
Repository:
 
323
Revision store:
341
324
         1 revision
342
325
         0 KiB
343
 
""" % (datestring_first, datestring_first,
 
326
""" % (branch2.bzrdir.root_transport.base,
 
327
       branch1.bzrdir.root_transport.base,
 
328
       branch1.bzrdir.root_transport.base,
 
329
       datestring_first, datestring_first,
344
330
       ), out)
345
331
        self.assertEqual('', err)
346
332
 
347
333
        # Out of date bound branch
348
 
        out, err = self.run_bzr('info -v bound')
 
334
        out, err = self.runbzr('info bound')
349
335
        self.assertEqualDiff(
350
 
"""Checkout (format: knit)
351
 
Location:
352
 
       checkout root: bound
353
 
  checkout of branch: standalone
 
336
"""Location:
 
337
       checkout root: %s
 
338
  checkout of branch: %s
354
339
 
355
340
Related branches:
356
 
  parent branch: standalone
 
341
  parent branch: %s
357
342
 
358
343
Format:
359
344
       control: Meta directory format 1
375
360
 
376
361
Branch history:
377
362
         1 revision
378
 
         1 committer
379
363
         0 days old
380
364
   first revision: %s
381
365
  latest revision: %s
382
366
 
383
 
Repository:
 
367
Revision store:
384
368
         1 revision
385
369
         %d KiB
386
 
""" % (branch3.repository._format.get_format_description(),
 
370
""" % (branch3.bzrdir.root_transport.base,
 
371
       branch1.bzrdir.root_transport.base,
 
372
       branch1.bzrdir.root_transport.base,
 
373
       branch3.repository._format.get_format_description(),
387
374
       datestring_first, datestring_first,
388
375
       # poking at _revision_store isn't all that clean, but neither is
389
376
       # having the ui test dependent on the exact overhead of a given store.
393
380
        self.assertEqual('', err)
394
381
 
395
382
        # Out of date checkout
396
 
        out, err = self.run_bzr('info -v checkout')
 
383
        out, err = self.runbzr('info checkout')
397
384
        self.assertEqualDiff(
398
 
"""Checkout (format: knit)
399
 
Location:
400
 
       checkout root: checkout
401
 
  checkout of branch: standalone
 
385
"""Location:
 
386
       checkout root: %s
 
387
  checkout of branch: %s
402
388
 
403
389
Format:
404
390
       control: Meta directory format 1
420
406
 
421
407
Branch history:
422
408
         1 revision
423
 
         1 committer
424
409
         0 days old
425
410
   first revision: %s
426
411
  latest revision: %s
427
412
 
428
 
Repository:
 
413
Revision store:
429
414
         1 revision
430
415
         %d KiB
431
 
""" % (branch4.repository._format.get_format_description(),
 
416
""" % (branch4.bzrdir.root_transport.base,
 
417
       branch1.bzrdir.root_transport.base,
 
418
       branch4.repository._format.get_format_description(),
432
419
       datestring_first, datestring_first,
433
420
       # poking at _revision_store isn't all that clean, but neither is
434
421
       # having the ui test dependent on the exact overhead of a given store.
438
425
        self.assertEqual('', err)
439
426
 
440
427
        # Out of date lightweight checkout
441
 
        out, err = self.run_bzr('info lightcheckout --verbose')
 
428
        out, err = self.runbzr('info lightcheckout --verbose')
442
429
        self.assertEqualDiff(
443
 
"""Lightweight checkout (format: dirstate or dirstate-tags)
444
 
Location:
445
 
  light checkout root: lightcheckout
446
 
   checkout of branch: standalone
 
430
"""Location:
 
431
 light checkout root: %s
 
432
  checkout of branch: %s
447
433
 
448
434
Format:
449
435
       control: Meta directory format 1
450
 
  working tree: Working tree format 4
 
436
  working tree: Working tree format 3
451
437
        branch: Branch format 4
452
438
    repository: Weave repository format 6
453
439
 
470
456
   first revision: %s
471
457
  latest revision: %s
472
458
 
473
 
Repository:
 
459
Revision store:
474
460
         2 revisions
475
461
         0 KiB
476
 
""" % (datestring_first, datestring_last,), out)
 
462
""" % (tree5.bzrdir.root_transport.base,
 
463
       branch1.bzrdir.root_transport.base,
 
464
       datestring_first, datestring_last,
 
465
       ), out)
477
466
        self.assertEqual('', err)
478
467
 
479
468
    def test_info_standalone_no_tree(self):
480
469
        # create standalone branch without a working tree
481
 
        format = bzrdir.format_registry.make_bzrdir('default')
482
470
        branch = self.make_branch('branch')
483
471
        repo = branch.repository
484
 
        out, err = self.run_bzr('info branch -v')
 
472
        out, err = self.runbzr('info branch')
485
473
        self.assertEqualDiff(
486
 
"""Standalone branch (format: dirstate or knit)
487
 
Location:
488
 
  branch root: branch
 
474
"""Location:
 
475
  branch root: %s
489
476
 
490
477
Format:
491
478
       control: Meta directory format 1
492
 
        branch: %s
 
479
        branch: Branch format 5
493
480
    repository: %s
494
481
 
495
482
Branch history:
496
483
         0 revisions
497
 
         0 committers
498
484
 
499
 
Repository:
 
485
Revision store:
500
486
         0 revisions
501
487
         0 KiB
502
 
""" % (format.get_branch_format().get_format_description(),
503
 
       format.repository_format.get_format_description(),
 
488
""" % (branch.bzrdir.root_transport.base,
 
489
       repo._format.get_format_description(),
504
490
       ), out)
505
491
        self.assertEqual('', err)
506
492
 
507
493
    def test_info_shared_repository(self):
508
 
        format = bzrdir.format_registry.make_bzrdir('knit')
 
494
        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
 
495
        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrlib.bzrdir.BzrDirMetaFormat1())
509
496
        transport = self.get_transport()
510
497
 
511
498
        # Create shared repository
512
 
        repo = self.make_repository('repo', shared=True, format=format)
 
499
        repo = self.make_repository('repo', shared=True)
513
500
        repo.set_make_working_trees(False)
514
 
        out, err = self.run_bzr('info -v repo')
 
501
        out, err = self.runbzr('info repo')
515
502
        self.assertEqualDiff(
516
 
"""Shared repository (format: dirstate or dirstate-tags or knit)
517
 
Location:
 
503
"""Location:
518
504
  shared repository: %s
519
505
 
520
506
Format:
521
507
       control: Meta directory format 1
522
508
    repository: %s
523
509
 
524
 
Repository:
 
510
Revision store:
525
511
         0 revisions
526
512
         0 KiB
527
 
""" % ('repo', format.repository_format.get_format_description(),
 
513
""" % (repo.bzrdir.root_transport.base,
 
514
       repo._format.get_format_description(),
528
515
       ), out)
529
516
        self.assertEqual('', err)
530
517
 
531
518
        # Create branch inside shared repository
532
519
        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')
 
520
        branch1 = repo.bzrdir.create_branch_convenience('repo/branch')
 
521
        out, err = self.runbzr('info repo/branch')
536
522
        self.assertEqualDiff(
537
 
"""Repository branch (format: dirstate or knit)
538
 
Location:
539
 
  shared repository: repo
540
 
  repository branch: repo/branch
 
523
"""Location:
 
524
  shared repository: %s
 
525
  repository branch: branch
541
526
 
542
527
Format:
543
528
       control: Meta directory format 1
544
 
        branch: %s
 
529
        branch: Branch format 5
545
530
    repository: %s
546
531
 
547
532
Branch history:
548
533
         0 revisions
549
 
         0 committers
550
534
 
551
 
Repository:
 
535
Revision store:
552
536
         0 revisions
553
537
         0 KiB
554
 
""" % (format.get_branch_format().get_format_description(),
555
 
       format.repository_format.get_format_description(),
 
538
""" % (repo.bzrdir.root_transport.base,
 
539
       repo._format.get_format_description(),
556
540
       ), out)
557
541
        self.assertEqual('', err)
558
542
 
559
543
        # Create lightweight checkout
560
544
        transport.mkdir('tree')
561
545
        transport.mkdir('tree/lightcheckout')
562
 
        tree2 = branch1.create_checkout('tree/lightcheckout', 
563
 
            lightweight=True)
 
546
        dir2 = bzrlib.bzrdir.BzrDirMetaFormat1().initialize('tree/lightcheckout')
 
547
        bzrlib.branch.BranchReferenceFormat().initialize(dir2, branch1)
 
548
        dir2.create_workingtree()
 
549
        tree2 = dir2.open_workingtree()
564
550
        branch2 = tree2.branch
565
 
        self.assertCheckoutStatusOutput('-v tree/lightcheckout', tree2,
566
 
                   shared_repo=repo, repo_branch=branch1, verbose=True)
 
551
        self.assertCheckoutStatusOutput('tree/lightcheckout', tree2, shared_repo=repo)
567
552
 
568
553
        # Create normal checkout
569
 
        tree3 = branch1.create_checkout('tree/checkout')
 
554
        branch3 = bzrlib.bzrdir.BzrDir.create_branch_convenience('tree/checkout')
 
555
        branch3.bind(branch1)
 
556
        tree3 = branch3.bzrdir.open_workingtree()
 
557
        tree3.update()
570
558
        self.assertCheckoutStatusOutput('tree/checkout --verbose', tree3,
571
559
            verbose=True,
572
560
            light_checkout=False, repo_branch=branch1)
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,
1248
1203
        transport.mkdir('tree')
1249
1204
        transport.mkdir('tree/checkout')
1250
1205
        co_branch = bzrlib.bzrdir.BzrDir.create_branch_convenience('tree/checkout',
1251
 
            format=bzrlib.bzrdir.BzrDirMetaFormat1())
 
1206
                                    format=bzrlib.bzrdir.BzrDirMetaFormat1())
1252
1207
        co_branch.bind(repo_branch)
1253
1208
        # Do a light checkout of the heavy one
1254
1209
        transport.mkdir('tree/lightcheckout')
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()