← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

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

  • Committer: John Arbash Meinel
  • Date: 2010-08-02 17:16:12 UTC
  • mto: This revision was merged to the branch mainline in revision 5369.
  • Revision ID: john@arbash-meinel.com-20100802171612-rdh5ods70w2bl3j7
We also have to re-implement it for _simple_set_pyx.pyx

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests of status command.
18
18
 
19
19
Most of these depend on the particular formatting used.
20
 
As such they really are blackbox tests even though some of the 
 
20
As such they really are blackbox tests even though some of the
21
21
tests are not using self.capture. If we add tests for the programmatic
22
22
interface later, they will be non blackbox tests.
23
23
"""
32
32
    bzrdir,
33
33
    conflicts,
34
34
    errors,
 
35
    osutils,
35
36
    )
36
37
import bzrlib.branch
37
38
from bzrlib.osutils import pathjoin
42
43
 
43
44
 
44
45
class BranchStatus(TestCaseWithTransport):
45
 
    
 
46
 
46
47
    def assertStatus(self, expected_lines, working_tree,
47
 
        revision=None, short=False):
 
48
        revision=None, short=False, pending=True, verbose=False):
48
49
        """Run status in working_tree and look for output.
49
 
        
 
50
 
50
51
        :param expected_lines: The lines to look for.
51
52
        :param working_tree: The tree to run status in.
52
53
        """
53
 
        output_string = self.status_string(working_tree, revision, short)
 
54
        output_string = self.status_string(working_tree, revision, short,
 
55
                pending, verbose)
54
56
        self.assertEqual(expected_lines, output_string.splitlines(True))
55
 
    
56
 
    def status_string(self, wt, revision=None, short=False):
 
57
 
 
58
    def status_string(self, wt, revision=None, short=False, pending=True,
 
59
        verbose=False):
57
60
        # use a real file rather than StringIO because it doesn't handle
58
61
        # Unicode very well.
59
62
        tof = codecs.getwriter('utf-8')(TemporaryFile())
60
 
        show_tree_status(wt, to_file=tof, revision=revision, short=short)
 
63
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
 
64
                show_pending=pending, verbose=verbose)
61
65
        tof.seek(0)
62
66
        return tof.read().decode('utf-8')
63
67
 
92
96
                'unknown:\n',
93
97
                '  bye.c\n',
94
98
                '  hello.c\n',
 
99
                'pending merge tips: (use -v to see all merge revisions)\n',
 
100
                '  (ghost) pending@pending-0-0\n',
 
101
            ],
 
102
            wt)
 
103
        self.assertStatus([
 
104
                'unknown:\n',
 
105
                '  bye.c\n',
 
106
                '  hello.c\n',
95
107
                'pending merges:\n',
96
 
                '  pending@pending-0-0\n',
 
108
                '  (ghost) pending@pending-0-0\n',
97
109
            ],
98
 
            wt)
 
110
            wt, verbose=True)
99
111
        self.assertStatus([
100
112
                '?   bye.c\n',
101
113
                '?   hello.c\n',
102
 
                'P   pending@pending-0-0\n',
 
114
                'P   (ghost) pending@pending-0-0\n',
103
115
            ],
104
116
            wt, short=True)
 
117
        self.assertStatus([
 
118
                'unknown:\n',
 
119
                '  bye.c\n',
 
120
                '  hello.c\n',
 
121
            ],
 
122
            wt, pending=False)
 
123
        self.assertStatus([
 
124
                '?   bye.c\n',
 
125
                '?   hello.c\n',
 
126
            ],
 
127
            wt, short=True, pending=False)
105
128
 
106
129
    def test_branch_status_revisions(self):
107
130
        """Tests branch status with revisions"""
124
147
        self.build_tree(['more.c'])
125
148
        wt.add('more.c')
126
149
        wt.commit('Another test message')
127
 
        
 
150
 
128
151
        revs.append(RevisionSpec.from_string('1'))
129
152
        self.assertStatus([
130
153
                'added:\n',
145
168
        wt2 = b_2_dir.open_workingtree()
146
169
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
147
170
        wt2.merge_from_branch(wt.branch)
148
 
        message = self.status_string(wt2)
 
171
        message = self.status_string(wt2, verbose=True)
149
172
        self.assertStartsWith(message, "pending merges:\n")
150
173
        self.assertEndsWith(message, "Empty commit 2\n")
151
174
        wt2.commit("merged")
153
176
        wt.commit("Empty commit 3 " +
154
177
                   "blah blah blah blah " * 100)
155
178
        wt2.merge_from_branch(wt.branch)
156
 
        message = self.status_string(wt2)
 
179
        message = self.status_string(wt2, verbose=True)
157
180
        self.assertStartsWith(message, "pending merges:\n")
158
181
        self.assert_("Empty commit 3" in message)
159
182
        self.assertEndsWith(message, "...\n")
183
206
        wt.add('directory')
184
207
        wt.add('test.c')
185
208
        wt.commit('testing')
186
 
        
 
209
 
187
210
        self.assertStatus([
188
211
                'unknown:\n',
189
212
                '  bye.c\n',
202
225
        tof = StringIO()
203
226
        self.assertRaises(errors.PathsDoNotExist,
204
227
                          show_tree_status,
205
 
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
228
                          wt, specific_files=['bye.c','test.c','absent.c'],
206
229
                          to_file=tof)
207
 
        
 
230
 
208
231
        tof = StringIO()
209
232
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
210
233
        tof.seek(0)
261
284
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
262
285
                             tof.getvalue())
263
286
 
 
287
    def _prepare_nonexistent(self):
 
288
        wt = self.make_branch_and_tree('.')
 
289
        self.assertStatus([], wt)
 
290
        self.build_tree(['FILE_A', 'FILE_B', 'FILE_C', 'FILE_D', 'FILE_E', ])
 
291
        wt.add('FILE_A')
 
292
        wt.add('FILE_B')
 
293
        wt.add('FILE_C')
 
294
        wt.add('FILE_D')
 
295
        wt.add('FILE_E')
 
296
        wt.commit('Create five empty files.')
 
297
        open('FILE_B', 'w').write('Modification to file FILE_B.')
 
298
        open('FILE_C', 'w').write('Modification to file FILE_C.')
 
299
        unlink('FILE_E')  # FILE_E will be versioned but missing
 
300
        open('FILE_Q', 'w').write('FILE_Q is added but not committed.')
 
301
        wt.add('FILE_Q')  # FILE_Q will be added but not committed
 
302
        open('UNVERSIONED_BUT_EXISTING', 'w')
 
303
        return wt
 
304
 
264
305
    def test_status_nonexistent_file(self):
265
306
        # files that don't exist in either the basis tree or working tree
266
307
        # should give an error
267
 
        wt = self.make_branch_and_tree('.')
268
 
        out, err = self.run_bzr('status does-not-exist', retcode=3)
269
 
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
 
308
        wt = self._prepare_nonexistent()
 
309
        self.assertStatus([
 
310
            'removed:\n',
 
311
            '  FILE_E\n',
 
312
            'added:\n',
 
313
            '  FILE_Q\n',
 
314
            'modified:\n',
 
315
            '  FILE_B\n',
 
316
            '  FILE_C\n',
 
317
            'unknown:\n',
 
318
            '  UNVERSIONED_BUT_EXISTING\n',
 
319
            ],
 
320
            wt)
 
321
        self.assertStatus([
 
322
            ' M  FILE_B\n',
 
323
            ' M  FILE_C\n',
 
324
            ' D  FILE_E\n',
 
325
            '+N  FILE_Q\n',
 
326
            '?   UNVERSIONED_BUT_EXISTING\n',
 
327
            ],
 
328
            wt, short=True)
 
329
 
 
330
        # Okay, everything's looking good with the existent files.
 
331
        # Let's see what happens when we throw in non-existent files.
 
332
 
 
333
        # bzr st [--short] NONEXISTENT '
 
334
        expected = [
 
335
          'nonexistent:\n',
 
336
          '  NONEXISTENT\n',
 
337
          ]
 
338
        out, err = self.run_bzr('status NONEXISTENT', retcode=3)
 
339
        self.assertEqual(expected, out.splitlines(True))
 
340
        self.assertContainsRe(err,
 
341
                              r'.*ERROR: Path\(s\) do not exist: '
 
342
                              'NONEXISTENT.*')
 
343
        expected = [
 
344
          'X:   NONEXISTENT\n',
 
345
          ]
 
346
        out, err = self.run_bzr('status --short NONEXISTENT', retcode=3)
 
347
        self.assertContainsRe(err,
 
348
                              r'.*ERROR: Path\(s\) do not exist: '
 
349
                              'NONEXISTENT.*')
 
350
 
 
351
    def test_status_nonexistent_file_with_others(self):
 
352
        # bzr st [--short] NONEXISTENT ...others..
 
353
        wt = self._prepare_nonexistent()
 
354
        expected = [
 
355
          'removed:\n',
 
356
          '  FILE_E\n',
 
357
          'modified:\n',
 
358
          '  FILE_B\n',
 
359
          '  FILE_C\n',
 
360
          'nonexistent:\n',
 
361
          '  NONEXISTENT\n',
 
362
          ]
 
363
        out, err = self.run_bzr('status NONEXISTENT '
 
364
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
 
365
                                retcode=3)
 
366
        self.assertEqual(expected, out.splitlines(True))
 
367
        self.assertContainsRe(err,
 
368
                              r'.*ERROR: Path\(s\) do not exist: '
 
369
                              'NONEXISTENT.*')
 
370
        expected = [
 
371
          ' D  FILE_E\n',
 
372
          ' M  FILE_C\n',
 
373
          ' M  FILE_B\n',
 
374
          'X   NONEXISTENT\n',
 
375
          ]
 
376
        out, err = self.run_bzr('status --short NONEXISTENT '
 
377
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
 
378
                                retcode=3)
 
379
        self.assertEqual(expected, out.splitlines(True))
 
380
        self.assertContainsRe(err,
 
381
                              r'.*ERROR: Path\(s\) do not exist: '
 
382
                              'NONEXISTENT.*')
 
383
 
 
384
    def test_status_multiple_nonexistent_files(self):
 
385
        # bzr st [--short] NONEXISTENT ... ANOTHER_NONEXISTENT ...
 
386
        wt = self._prepare_nonexistent()
 
387
        expected = [
 
388
          'removed:\n',
 
389
          '  FILE_E\n',
 
390
          'modified:\n',
 
391
          '  FILE_B\n',
 
392
          '  FILE_C\n',
 
393
          'nonexistent:\n',
 
394
          '  ANOTHER_NONEXISTENT\n',
 
395
          '  NONEXISTENT\n',
 
396
          ]
 
397
        out, err = self.run_bzr('status NONEXISTENT '
 
398
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
 
399
                                'FILE_C FILE_D FILE_E', retcode=3)
 
400
        self.assertEqual(expected, out.splitlines(True))
 
401
        self.assertContainsRe(err,
 
402
                              r'.*ERROR: Path\(s\) do not exist: '
 
403
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
 
404
        expected = [
 
405
          ' D  FILE_E\n',
 
406
          ' M  FILE_C\n',
 
407
          ' M  FILE_B\n',
 
408
          'X   ANOTHER_NONEXISTENT\n',
 
409
          'X   NONEXISTENT\n',
 
410
          ]
 
411
        out, err = self.run_bzr('status --short NONEXISTENT '
 
412
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
 
413
                                'FILE_C FILE_D FILE_E', retcode=3)
 
414
        self.assertEqual(expected, out.splitlines(True))
 
415
        self.assertContainsRe(err,
 
416
                              r'.*ERROR: Path\(s\) do not exist: '
 
417
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
 
418
 
 
419
    def test_status_nonexistent_file_with_unversioned(self):
 
420
        # bzr st [--short] NONEXISTENT A B UNVERSIONED_BUT_EXISTING C D E Q
 
421
        wt = self._prepare_nonexistent()
 
422
        expected = [
 
423
          'removed:\n',
 
424
          '  FILE_E\n',
 
425
          'added:\n',
 
426
          '  FILE_Q\n',
 
427
          'modified:\n',
 
428
          '  FILE_B\n',
 
429
          '  FILE_C\n',
 
430
          'unknown:\n',
 
431
          '  UNVERSIONED_BUT_EXISTING\n',
 
432
          'nonexistent:\n',
 
433
          '  NONEXISTENT\n',
 
434
          ]
 
435
        out, err = self.run_bzr('status NONEXISTENT '
 
436
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
 
437
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
 
438
        self.assertEqual(expected, out.splitlines(True))
 
439
        self.assertContainsRe(err,
 
440
                              r'.*ERROR: Path\(s\) do not exist: '
 
441
                              'NONEXISTENT.*')
 
442
        expected = [
 
443
          '+N  FILE_Q\n',
 
444
          '?   UNVERSIONED_BUT_EXISTING\n',
 
445
          ' D  FILE_E\n',
 
446
          ' M  FILE_C\n',
 
447
          ' M  FILE_B\n',
 
448
          'X   NONEXISTENT\n',
 
449
          ]
 
450
        out, err = self.run_bzr('status --short NONEXISTENT '
 
451
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
 
452
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
 
453
        self.assertEqual(expected, out.splitlines(True))
 
454
        self.assertContainsRe(err,
 
455
                              r'.*ERROR: Path\(s\) do not exist: '
 
456
                              'NONEXISTENT.*')
270
457
 
271
458
    def test_status_out_of_date(self):
272
459
        """Simulate status of out-of-date tree after remote push"""
285
472
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
286
473
                         err)
287
474
 
 
475
    def test_status_on_ignored(self):
 
476
        """Tests branch status on an unversioned file which is considered ignored.
 
477
 
 
478
        See https://bugs.launchpad.net/bzr/+bug/40103
 
479
        """
 
480
        tree = self.make_branch_and_tree('.')
 
481
 
 
482
        self.build_tree(['test1.c', 'test1.c~', 'test2.c~'])
 
483
        result = self.run_bzr('status')[0]
 
484
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
 
485
        short_result = self.run_bzr('status --short')[0]
 
486
        self.assertContainsRe(short_result, "\?   test1.c\n")
 
487
 
 
488
        result = self.run_bzr('status test1.c')[0]
 
489
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
 
490
        short_result = self.run_bzr('status --short test1.c')[0]
 
491
        self.assertContainsRe(short_result, "\?   test1.c\n")
 
492
 
 
493
        result = self.run_bzr('status test1.c~')[0]
 
494
        self.assertContainsRe(result, "ignored:\n  test1.c~\n")
 
495
        short_result = self.run_bzr('status --short test1.c~')[0]
 
496
        self.assertContainsRe(short_result, "I   test1.c~\n")
 
497
 
 
498
        result = self.run_bzr('status test1.c~ test2.c~')[0]
 
499
        self.assertContainsRe(result, "ignored:\n  test1.c~\n  test2.c~\n")
 
500
        short_result = self.run_bzr('status --short test1.c~ test2.c~')[0]
 
501
        self.assertContainsRe(short_result, "I   test1.c~\nI   test2.c~\n")
 
502
 
 
503
        result = self.run_bzr('status test1.c test1.c~ test2.c~')[0]
 
504
        self.assertContainsRe(result, "unknown:\n  test1.c\nignored:\n  test1.c~\n  test2.c~\n")
 
505
        short_result = self.run_bzr('status --short test1.c test1.c~ test2.c~')[0]
 
506
        self.assertContainsRe(short_result, "\?   test1.c\nI   test1.c~\nI   test2.c~\n")
 
507
 
 
508
    def test_status_write_lock(self):
 
509
        """Test that status works without fetching history and
 
510
        having a write lock.
 
511
 
 
512
        See https://bugs.launchpad.net/bzr/+bug/149270
 
513
        """
 
514
        mkdir('branch1')
 
515
        wt = self.make_branch_and_tree('branch1')
 
516
        b = wt.branch
 
517
        wt.commit('Empty commit 1')
 
518
        wt2 = b.bzrdir.sprout('branch2').open_workingtree()
 
519
        wt2.commit('Empty commit 2')
 
520
        out, err = self.run_bzr('status branch1 -rbranch:branch2')
 
521
        self.assertEqual('', out)
 
522
 
288
523
 
289
524
class CheckoutStatus(BranchStatus):
290
525
 
292
527
        super(CheckoutStatus, self).setUp()
293
528
        mkdir('codir')
294
529
        chdir('codir')
295
 
        
 
530
 
296
531
    def make_branch_and_tree(self, relpath):
297
532
        source = self.make_branch(pathjoin('..', relpath))
298
533
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
299
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
534
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
 
535
            target_branch=source)
300
536
        return checkout.create_workingtree()
301
537
 
302
538
 
371
607
        result2 = self.run_bzr("status --versioned -r 0..")[0]
372
608
        self.assertEquals(result2, result)
373
609
 
374
 
    def assertStatusContains(self, pattern):
 
610
    def test_status_SV(self):
 
611
        tree = self.make_branch_and_tree('.')
 
612
 
 
613
        self.build_tree(['hello.txt'])
 
614
        result = self.run_bzr("status -SV")[0]
 
615
        self.assertNotContainsRe(result, "hello.txt")
 
616
 
 
617
        tree.add("hello.txt")
 
618
        result = self.run_bzr("status -SV")[0]
 
619
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
620
 
 
621
        tree.commit(message="added")
 
622
        result = self.run_bzr("status -SV -r 0..1")[0]
 
623
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
624
 
 
625
        self.build_tree(['world.txt'])
 
626
        result = self.run_bzr("status -SV -r 0")[0]
 
627
        self.assertContainsRe(result, "[+]N  hello.txt\n")
 
628
 
 
629
        result2 = self.run_bzr("status -SV -r 0..")[0]
 
630
        self.assertEquals(result2, result)
 
631
 
 
632
    def assertStatusContains(self, pattern, short=False):
375
633
        """Run status, and assert it contains the given pattern"""
376
 
        result = self.run_bzr("status --short")[0]
 
634
        if short:
 
635
            result = self.run_bzr("status --short")[0]
 
636
        else:
 
637
            result = self.run_bzr("status")[0]
377
638
        self.assertContainsRe(result, pattern)
378
639
 
 
640
    def test_kind_change_plain(self):
 
641
        tree = self.make_branch_and_tree('.')
 
642
        self.build_tree(['file'])
 
643
        tree.add('file')
 
644
        tree.commit('added file')
 
645
        unlink('file')
 
646
        self.build_tree(['file/'])
 
647
        self.assertStatusContains('kind changed:\n  file \(file => directory\)')
 
648
        tree.rename_one('file', 'directory')
 
649
        self.assertStatusContains('renamed:\n  file/ => directory/\n' \
 
650
                                  'modified:\n  directory/\n')
 
651
        rmdir('directory')
 
652
        self.assertStatusContains('removed:\n  file\n')
 
653
 
379
654
    def test_kind_change_short(self):
380
655
        tree = self.make_branch_and_tree('.')
381
656
        self.build_tree(['file'])
383
658
        tree.commit('added file')
384
659
        unlink('file')
385
660
        self.build_tree(['file/'])
386
 
        self.assertStatusContains('K  file => file/')
 
661
        self.assertStatusContains('K  file => file/',
 
662
                                   short=True)
387
663
        tree.rename_one('file', 'directory')
388
 
        self.assertStatusContains('RK  file => directory/')
 
664
        self.assertStatusContains('RK  file => directory/',
 
665
                                   short=True)
389
666
        rmdir('directory')
390
 
        self.assertStatusContains('RD  file => directory')
 
667
        self.assertStatusContains('RD  file => directory',
 
668
                                   short=True)
391
669
 
392
670
    def test_status_illegal_revision_specifiers(self):
393
671
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
394
672
        self.assertContainsRe(err, 'one or two revision specifiers')
395
673
 
 
674
    def test_status_no_pending(self):
 
675
        a_tree = self.make_branch_and_tree('a')
 
676
        self.build_tree(['a/a'])
 
677
        a_tree.add('a')
 
678
        a_tree.commit('a')
 
679
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
680
        self.build_tree(['b/b'])
 
681
        b_tree.add('b')
 
682
        b_tree.commit('b')
 
683
 
 
684
        self.run_bzr('merge ../b', working_dir='a')
 
685
        out, err = self.run_bzr('status --no-pending', working_dir='a')
 
686
        self.assertEquals(out, "added:\n  b\n")
 
687
 
 
688
    def test_pending_specific_files(self):
 
689
        """With a specific file list, pending merges are not shown."""
 
690
        tree = self.make_branch_and_tree('tree')
 
691
        self.build_tree_contents([('tree/a', 'content of a\n')])
 
692
        tree.add('a')
 
693
        r1_id = tree.commit('one')
 
694
        alt = tree.bzrdir.sprout('alt').open_workingtree()
 
695
        self.build_tree_contents([('alt/a', 'content of a\nfrom alt\n')])
 
696
        alt_id = alt.commit('alt')
 
697
        tree.merge_from_branch(alt.branch)
 
698
        output = self.make_utf8_encoded_stringio()
 
699
        show_tree_status(tree, to_file=output)
 
700
        self.assertContainsRe(output.getvalue(), 'pending merge')
 
701
        out, err = self.run_bzr('status tree/a')
 
702
        self.assertNotContainsRe(out, 'pending merge')
 
703
 
396
704
 
397
705
class TestStatusEncodings(TestCaseWithTransport):
398
 
    
399
 
    def setUp(self):
400
 
        TestCaseWithTransport.setUp(self)
401
 
        self.user_encoding = bzrlib.user_encoding
402
 
        self.stdout = sys.stdout
403
 
 
404
 
    def tearDown(self):
405
 
        bzrlib.user_encoding = self.user_encoding
406
 
        sys.stdout = self.stdout
407
 
        TestCaseWithTransport.tearDown(self)
408
706
 
409
707
    def make_uncommitted_tree(self):
410
708
        """Build a branch with uncommitted unicode named changes in the cwd."""
419
717
        return working_tree
420
718
 
421
719
    def test_stdout_ascii(self):
422
 
        sys.stdout = StringIO()
423
 
        bzrlib.user_encoding = 'ascii'
 
720
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
424
721
        working_tree = self.make_uncommitted_tree()
425
722
        stdout, stderr = self.run_bzr("status")
426
723
 
430
727
""")
431
728
 
432
729
    def test_stdout_latin1(self):
433
 
        sys.stdout = StringIO()
434
 
        bzrlib.user_encoding = 'latin-1'
 
730
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
435
731
        working_tree = self.make_uncommitted_tree()
436
732
        stdout, stderr = self.run_bzr('status')
437
733