← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: Martin Pool
  • Date: 2007-07-11 04:15:48 UTC
  • mto: This revision was merged to the branch mainline in revision 2605.
  • Revision ID: mbp@sourcefrog.net-20070711041548-n1om2ptyj2j01r6l
Clean up old/unused global options

Show diffs side-by-side

added added

removed removed

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