← 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: Canonical.com Patch Queue Manager
  • Date: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

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,
 
36
    status,
35
37
    )
36
38
import bzrlib.branch
37
39
from bzrlib.osutils import pathjoin
42
44
 
43
45
 
44
46
class BranchStatus(TestCaseWithTransport):
45
 
    
 
47
 
 
48
    def setUp(self):
 
49
        super(BranchStatus, self).setUp()
 
50
        # As TestCase.setUp clears all hooks, we install this default
 
51
        # post_status hook handler for the test.
 
52
        status.hooks.install_named_hook('post_status',
 
53
            status._show_shelve_summary,
 
54
            'bzr status')
 
55
 
46
56
    def assertStatus(self, expected_lines, working_tree,
47
 
        revision=None, short=False, pending=True):
 
57
        revision=None, short=False, pending=True, verbose=False):
48
58
        """Run status in working_tree and look for output.
49
 
        
 
59
 
50
60
        :param expected_lines: The lines to look for.
51
61
        :param working_tree: The tree to run status in.
52
62
        """
53
63
        output_string = self.status_string(working_tree, revision, short,
54
 
                pending)
 
64
                pending, verbose)
55
65
        self.assertEqual(expected_lines, output_string.splitlines(True))
56
 
    
57
 
    def status_string(self, wt, revision=None, short=False, pending=True):
 
66
 
 
67
    def status_string(self, wt, revision=None, short=False, pending=True,
 
68
        verbose=False):
58
69
        # use a real file rather than StringIO because it doesn't handle
59
70
        # Unicode very well.
60
71
        tof = codecs.getwriter('utf-8')(TemporaryFile())
61
72
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
62
 
                show_pending=pending)
 
73
                show_pending=pending, verbose=verbose)
63
74
        tof.seek(0)
64
75
        return tof.read().decode('utf-8')
65
76
 
94
105
                'unknown:\n',
95
106
                '  bye.c\n',
96
107
                '  hello.c\n',
 
108
                'pending merge tips: (use -v to see all merge revisions)\n',
 
109
                '  (ghost) pending@pending-0-0\n',
 
110
            ],
 
111
            wt)
 
112
        self.assertStatus([
 
113
                'unknown:\n',
 
114
                '  bye.c\n',
 
115
                '  hello.c\n',
97
116
                'pending merges:\n',
98
117
                '  (ghost) pending@pending-0-0\n',
99
118
            ],
100
 
            wt)
 
119
            wt, verbose=True)
101
120
        self.assertStatus([
102
121
                '?   bye.c\n',
103
122
                '?   hello.c\n',
137
156
        self.build_tree(['more.c'])
138
157
        wt.add('more.c')
139
158
        wt.commit('Another test message')
140
 
        
 
159
 
141
160
        revs.append(RevisionSpec.from_string('1'))
142
161
        self.assertStatus([
143
162
                'added:\n',
158
177
        wt2 = b_2_dir.open_workingtree()
159
178
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
160
179
        wt2.merge_from_branch(wt.branch)
161
 
        message = self.status_string(wt2)
 
180
        message = self.status_string(wt2, verbose=True)
162
181
        self.assertStartsWith(message, "pending merges:\n")
163
182
        self.assertEndsWith(message, "Empty commit 2\n")
164
183
        wt2.commit("merged")
166
185
        wt.commit("Empty commit 3 " +
167
186
                   "blah blah blah blah " * 100)
168
187
        wt2.merge_from_branch(wt.branch)
169
 
        message = self.status_string(wt2)
 
188
        message = self.status_string(wt2, verbose=True)
170
189
        self.assertStartsWith(message, "pending merges:\n")
171
190
        self.assert_("Empty commit 3" in message)
172
191
        self.assertEndsWith(message, "...\n")
192
211
        wt = self.make_branch_and_tree('.')
193
212
        b = wt.branch
194
213
 
195
 
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
 
214
        self.build_tree(['directory/','directory/hello.c',
 
215
                         'bye.c','test.c','dir2/',
 
216
                         'missing.c'])
196
217
        wt.add('directory')
197
218
        wt.add('test.c')
198
219
        wt.commit('testing')
199
 
        
 
220
        wt.add('missing.c')
 
221
        unlink('missing.c')
 
222
 
200
223
        self.assertStatus([
 
224
                'missing:\n',
 
225
                '  missing.c\n',
201
226
                'unknown:\n',
202
227
                '  bye.c\n',
203
228
                '  dir2/\n',
208
233
        self.assertStatus([
209
234
                '?   bye.c\n',
210
235
                '?   dir2/\n',
 
236
                '+!  missing.c\n',
211
237
                '?   directory/hello.c\n'
212
238
                ],
213
239
                wt, short=True)
215
241
        tof = StringIO()
216
242
        self.assertRaises(errors.PathsDoNotExist,
217
243
                          show_tree_status,
218
 
                          wt, specific_files=['bye.c','test.c','absent.c'], 
 
244
                          wt, specific_files=['bye.c','test.c','absent.c'],
219
245
                          to_file=tof)
220
 
        
 
246
 
221
247
        tof = StringIO()
222
248
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
223
249
        tof.seek(0)
250
276
        tof.seek(0)
251
277
        self.assertEquals(tof.readlines(), ['+N  test.c\n'])
252
278
 
 
279
        tof = StringIO()
 
280
        show_tree_status(wt, specific_files=['missing.c'], to_file=tof)
 
281
        tof.seek(0)
 
282
        self.assertEquals(tof.readlines(),
 
283
                          ['missing:\n',
 
284
                           '  missing.c\n'])
 
285
 
 
286
        tof = StringIO()
 
287
        show_tree_status(wt, specific_files=['missing.c'], to_file=tof,
 
288
                         short=True)
 
289
        tof.seek(0)
 
290
        self.assertEquals(tof.readlines(),
 
291
                          ['+!  missing.c\n'])
 
292
 
253
293
    def test_specific_files_conflicts(self):
254
294
        tree = self.make_branch_and_tree('.')
255
295
        self.build_tree(['dir2/'])
274
314
        self.assertEqualDiff('conflicts:\n  Contents conflict in dir2/file1\n',
275
315
                             tof.getvalue())
276
316
 
 
317
    def _prepare_nonexistent(self):
 
318
        wt = self.make_branch_and_tree('.')
 
319
        self.assertStatus([], wt)
 
320
        self.build_tree(['FILE_A', 'FILE_B', 'FILE_C', 'FILE_D', 'FILE_E', ])
 
321
        wt.add('FILE_A')
 
322
        wt.add('FILE_B')
 
323
        wt.add('FILE_C')
 
324
        wt.add('FILE_D')
 
325
        wt.add('FILE_E')
 
326
        wt.commit('Create five empty files.')
 
327
        with open('FILE_B', 'w') as f: f.write('Modification to file FILE_B.')
 
328
        with open('FILE_C', 'w') as f: f.write('Modification to file FILE_C.')
 
329
        unlink('FILE_E')  # FILE_E will be versioned but missing
 
330
        with open('FILE_Q', 'w') as f: f.write('FILE_Q is added but not committed.')
 
331
        wt.add('FILE_Q')  # FILE_Q will be added but not committed
 
332
        open('UNVERSIONED_BUT_EXISTING', 'w')
 
333
        return wt
 
334
 
277
335
    def test_status_nonexistent_file(self):
278
336
        # files that don't exist in either the basis tree or working tree
279
337
        # should give an error
280
 
        wt = self.make_branch_and_tree('.')
281
 
        out, err = self.run_bzr('status does-not-exist', retcode=3)
282
 
        self.assertContainsRe(err, r'do not exist.*does-not-exist')
 
338
        wt = self._prepare_nonexistent()
 
339
        self.assertStatus([
 
340
            'removed:\n',
 
341
            '  FILE_E\n',
 
342
            'added:\n',
 
343
            '  FILE_Q\n',
 
344
            'modified:\n',
 
345
            '  FILE_B\n',
 
346
            '  FILE_C\n',
 
347
            'unknown:\n',
 
348
            '  UNVERSIONED_BUT_EXISTING\n',
 
349
            ],
 
350
            wt)
 
351
        self.assertStatus([
 
352
            ' M  FILE_B\n',
 
353
            ' M  FILE_C\n',
 
354
            ' D  FILE_E\n',
 
355
            '+N  FILE_Q\n',
 
356
            '?   UNVERSIONED_BUT_EXISTING\n',
 
357
            ],
 
358
            wt, short=True)
 
359
 
 
360
        # Okay, everything's looking good with the existent files.
 
361
        # Let's see what happens when we throw in non-existent files.
 
362
 
 
363
        # bzr st [--short] NONEXISTENT '
 
364
        expected = [
 
365
          'nonexistent:\n',
 
366
          '  NONEXISTENT\n',
 
367
          ]
 
368
        out, err = self.run_bzr('status NONEXISTENT', retcode=3)
 
369
        self.assertEqual(expected, out.splitlines(True))
 
370
        self.assertContainsRe(err,
 
371
                              r'.*ERROR: Path\(s\) do not exist: '
 
372
                              'NONEXISTENT.*')
 
373
        expected = [
 
374
          'X:   NONEXISTENT\n',
 
375
          ]
 
376
        out, err = self.run_bzr('status --short NONEXISTENT', retcode=3)
 
377
        self.assertContainsRe(err,
 
378
                              r'.*ERROR: Path\(s\) do not exist: '
 
379
                              'NONEXISTENT.*')
 
380
 
 
381
    def test_status_nonexistent_file_with_others(self):
 
382
        # bzr st [--short] NONEXISTENT ...others..
 
383
        wt = self._prepare_nonexistent()
 
384
        expected = [
 
385
          'removed:\n',
 
386
          '  FILE_E\n',
 
387
          'modified:\n',
 
388
          '  FILE_B\n',
 
389
          '  FILE_C\n',
 
390
          'nonexistent:\n',
 
391
          '  NONEXISTENT\n',
 
392
          ]
 
393
        out, err = self.run_bzr('status NONEXISTENT '
 
394
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
 
395
                                retcode=3)
 
396
        self.assertEqual(expected, out.splitlines(True))
 
397
        self.assertContainsRe(err,
 
398
                              r'.*ERROR: Path\(s\) do not exist: '
 
399
                              'NONEXISTENT.*')
 
400
        expected = [
 
401
          ' D  FILE_E\n',
 
402
          ' M  FILE_C\n',
 
403
          ' M  FILE_B\n',
 
404
          'X   NONEXISTENT\n',
 
405
          ]
 
406
        out, err = self.run_bzr('status --short NONEXISTENT '
 
407
                                'FILE_A FILE_B FILE_C FILE_D FILE_E',
 
408
                                retcode=3)
 
409
        self.assertEqual(expected, out.splitlines(True))
 
410
        self.assertContainsRe(err,
 
411
                              r'.*ERROR: Path\(s\) do not exist: '
 
412
                              'NONEXISTENT.*')
 
413
 
 
414
    def test_status_multiple_nonexistent_files(self):
 
415
        # bzr st [--short] NONEXISTENT ... ANOTHER_NONEXISTENT ...
 
416
        wt = self._prepare_nonexistent()
 
417
        expected = [
 
418
          'removed:\n',
 
419
          '  FILE_E\n',
 
420
          'modified:\n',
 
421
          '  FILE_B\n',
 
422
          '  FILE_C\n',
 
423
          'nonexistent:\n',
 
424
          '  ANOTHER_NONEXISTENT\n',
 
425
          '  NONEXISTENT\n',
 
426
          ]
 
427
        out, err = self.run_bzr('status NONEXISTENT '
 
428
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
 
429
                                'FILE_C FILE_D FILE_E', retcode=3)
 
430
        self.assertEqual(expected, out.splitlines(True))
 
431
        self.assertContainsRe(err,
 
432
                              r'.*ERROR: Path\(s\) do not exist: '
 
433
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
 
434
        expected = [
 
435
          ' D  FILE_E\n',
 
436
          ' M  FILE_C\n',
 
437
          ' M  FILE_B\n',
 
438
          'X   ANOTHER_NONEXISTENT\n',
 
439
          'X   NONEXISTENT\n',
 
440
          ]
 
441
        out, err = self.run_bzr('status --short NONEXISTENT '
 
442
                                'FILE_A FILE_B ANOTHER_NONEXISTENT '
 
443
                                'FILE_C FILE_D FILE_E', retcode=3)
 
444
        self.assertEqual(expected, out.splitlines(True))
 
445
        self.assertContainsRe(err,
 
446
                              r'.*ERROR: Path\(s\) do not exist: '
 
447
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
 
448
 
 
449
    def test_status_nonexistent_file_with_unversioned(self):
 
450
        # bzr st [--short] NONEXISTENT A B UNVERSIONED_BUT_EXISTING C D E Q
 
451
        wt = self._prepare_nonexistent()
 
452
        expected = [
 
453
          'removed:\n',
 
454
          '  FILE_E\n',
 
455
          'added:\n',
 
456
          '  FILE_Q\n',
 
457
          'modified:\n',
 
458
          '  FILE_B\n',
 
459
          '  FILE_C\n',
 
460
          'unknown:\n',
 
461
          '  UNVERSIONED_BUT_EXISTING\n',
 
462
          'nonexistent:\n',
 
463
          '  NONEXISTENT\n',
 
464
          ]
 
465
        out, err = self.run_bzr('status NONEXISTENT '
 
466
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
 
467
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
 
468
        self.assertEqual(expected, out.splitlines(True))
 
469
        self.assertContainsRe(err,
 
470
                              r'.*ERROR: Path\(s\) do not exist: '
 
471
                              'NONEXISTENT.*')
 
472
        expected = [
 
473
          '+N  FILE_Q\n',
 
474
          '?   UNVERSIONED_BUT_EXISTING\n',
 
475
          ' D  FILE_E\n',
 
476
          ' M  FILE_C\n',
 
477
          ' M  FILE_B\n',
 
478
          'X   NONEXISTENT\n',
 
479
          ]
 
480
        expected.sort()
 
481
        out, err = self.run_bzr('status --short NONEXISTENT '
 
482
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
 
483
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
 
484
        actual = out.splitlines(True)
 
485
        actual.sort()
 
486
        self.assertEqual(expected, actual)
 
487
        self.assertContainsRe(err,
 
488
                              r'.*ERROR: Path\(s\) do not exist: '
 
489
                              'NONEXISTENT.*')
283
490
 
284
491
    def test_status_out_of_date(self):
285
492
        """Simulate status of out-of-date tree after remote push"""
298
505
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
299
506
                         err)
300
507
 
 
508
    def test_status_on_ignored(self):
 
509
        """Tests branch status on an unversioned file which is considered ignored.
 
510
 
 
511
        See https://bugs.launchpad.net/bzr/+bug/40103
 
512
        """
 
513
        tree = self.make_branch_and_tree('.')
 
514
 
 
515
        self.build_tree(['test1.c', 'test1.c~', 'test2.c~'])
 
516
        result = self.run_bzr('status')[0]
 
517
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
 
518
        short_result = self.run_bzr('status --short')[0]
 
519
        self.assertContainsRe(short_result, "\?   test1.c\n")
 
520
 
 
521
        result = self.run_bzr('status test1.c')[0]
 
522
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
 
523
        short_result = self.run_bzr('status --short test1.c')[0]
 
524
        self.assertContainsRe(short_result, "\?   test1.c\n")
 
525
 
 
526
        result = self.run_bzr('status test1.c~')[0]
 
527
        self.assertContainsRe(result, "ignored:\n  test1.c~\n")
 
528
        short_result = self.run_bzr('status --short test1.c~')[0]
 
529
        self.assertContainsRe(short_result, "I   test1.c~\n")
 
530
 
 
531
        result = self.run_bzr('status test1.c~ test2.c~')[0]
 
532
        self.assertContainsRe(result, "ignored:\n  test1.c~\n  test2.c~\n")
 
533
        short_result = self.run_bzr('status --short test1.c~ test2.c~')[0]
 
534
        self.assertContainsRe(short_result, "I   test1.c~\nI   test2.c~\n")
 
535
 
 
536
        result = self.run_bzr('status test1.c test1.c~ test2.c~')[0]
 
537
        self.assertContainsRe(result, "unknown:\n  test1.c\nignored:\n  test1.c~\n  test2.c~\n")
 
538
        short_result = self.run_bzr('status --short test1.c test1.c~ test2.c~')[0]
 
539
        self.assertContainsRe(short_result, "\?   test1.c\nI   test1.c~\nI   test2.c~\n")
 
540
 
 
541
    def test_status_write_lock(self):
 
542
        """Test that status works without fetching history and
 
543
        having a write lock.
 
544
 
 
545
        See https://bugs.launchpad.net/bzr/+bug/149270
 
546
        """
 
547
        mkdir('branch1')
 
548
        wt = self.make_branch_and_tree('branch1')
 
549
        b = wt.branch
 
550
        wt.commit('Empty commit 1')
 
551
        wt2 = b.bzrdir.sprout('branch2').open_workingtree()
 
552
        wt2.commit('Empty commit 2')
 
553
        out, err = self.run_bzr('status branch1 -rbranch:branch2')
 
554
        self.assertEqual('', out)
 
555
 
 
556
    def test_status_with_shelves(self):
 
557
        """Ensure that _show_shelve_summary handler works.
 
558
        """
 
559
        wt = self.make_branch_and_tree('.')
 
560
        self.build_tree(['hello.c'])
 
561
        wt.add('hello.c')
 
562
        self.run_bzr(['shelve', '--all', '-m', 'foo'])
 
563
        self.build_tree(['bye.c'])
 
564
        wt.add('bye.c')
 
565
        self.assertStatus([
 
566
                'added:\n',
 
567
                '  bye.c\n',
 
568
                '1 shelf exists. See "bzr shelve --list" for details.\n',
 
569
            ],
 
570
            wt)
 
571
        self.run_bzr(['shelve', '--all', '-m', 'bar'])
 
572
        self.build_tree(['spam.c'])
 
573
        wt.add('spam.c')
 
574
        self.assertStatus([
 
575
                'added:\n',
 
576
                '  spam.c\n',
 
577
                '2 shelves exist. See "bzr shelve --list" for details.\n',
 
578
            ],
 
579
            wt)
 
580
 
301
581
 
302
582
class CheckoutStatus(BranchStatus):
303
583
 
305
585
        super(CheckoutStatus, self).setUp()
306
586
        mkdir('codir')
307
587
        chdir('codir')
308
 
        
 
588
 
309
589
    def make_branch_and_tree(self, relpath):
310
590
        source = self.make_branch(pathjoin('..', relpath))
311
591
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
312
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)
 
592
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
 
593
            target_branch=source)
313
594
        return checkout.create_workingtree()
314
595
 
315
596
 
356
637
        self.assertContainsRe(result, "[+]N  hello.txt\n")
357
638
 
358
639
        self.build_tree(['world.txt'])
359
 
        result = self.run_bzr("status --short -r 0")[0]
 
640
        result = self.run_bzr("status -S -r 0")[0]
360
641
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
361
642
                                      "[?]   world.txt\n")
362
 
        result2 = self.run_bzr("status --short -r 0..")[0]
 
643
        result2 = self.run_bzr("status -S -r 0..")[0]
363
644
        self.assertEquals(result2, result)
364
645
 
365
646
    def test_status_versioned(self):
406
687
        result2 = self.run_bzr("status -SV -r 0..")[0]
407
688
        self.assertEquals(result2, result)
408
689
 
409
 
    def assertStatusContains(self, pattern):
 
690
    def assertStatusContains(self, pattern, short=False):
410
691
        """Run status, and assert it contains the given pattern"""
411
 
        result = self.run_bzr("status --short")[0]
 
692
        if short:
 
693
            result = self.run_bzr("status --short")[0]
 
694
        else:
 
695
            result = self.run_bzr("status")[0]
412
696
        self.assertContainsRe(result, pattern)
413
697
 
 
698
    def test_kind_change_plain(self):
 
699
        tree = self.make_branch_and_tree('.')
 
700
        self.build_tree(['file'])
 
701
        tree.add('file')
 
702
        tree.commit('added file')
 
703
        unlink('file')
 
704
        self.build_tree(['file/'])
 
705
        self.assertStatusContains('kind changed:\n  file \(file => directory\)')
 
706
        tree.rename_one('file', 'directory')
 
707
        self.assertStatusContains('renamed:\n  file/ => directory/\n' \
 
708
                                  'modified:\n  directory/\n')
 
709
        rmdir('directory')
 
710
        self.assertStatusContains('removed:\n  file\n')
 
711
 
414
712
    def test_kind_change_short(self):
415
713
        tree = self.make_branch_and_tree('.')
416
714
        self.build_tree(['file'])
418
716
        tree.commit('added file')
419
717
        unlink('file')
420
718
        self.build_tree(['file/'])
421
 
        self.assertStatusContains('K  file => file/')
 
719
        self.assertStatusContains('K  file => file/',
 
720
                                   short=True)
422
721
        tree.rename_one('file', 'directory')
423
 
        self.assertStatusContains('RK  file => directory/')
 
722
        self.assertStatusContains('RK  file => directory/',
 
723
                                   short=True)
424
724
        rmdir('directory')
425
 
        self.assertStatusContains('RD  file => directory')
 
725
        self.assertStatusContains('RD  file => directory',
 
726
                                   short=True)
426
727
 
427
728
    def test_status_illegal_revision_specifiers(self):
428
729
        out, err = self.run_bzr('status -r 1..23..123', retcode=3)
454
755
        tree.merge_from_branch(alt.branch)
455
756
        output = self.make_utf8_encoded_stringio()
456
757
        show_tree_status(tree, to_file=output)
457
 
        self.assertContainsRe(output.getvalue(), 'pending merges:')
 
758
        self.assertContainsRe(output.getvalue(), 'pending merge')
458
759
        out, err = self.run_bzr('status tree/a')
459
 
        self.assertNotContainsRe(out, 'pending merges:')
 
760
        self.assertNotContainsRe(out, 'pending merge')
460
761
 
461
762
 
462
763
class TestStatusEncodings(TestCaseWithTransport):
463
 
    
464
 
    def setUp(self):
465
 
        TestCaseWithTransport.setUp(self)
466
 
        self.user_encoding = bzrlib.user_encoding
467
 
        self.stdout = sys.stdout
468
 
 
469
 
    def tearDown(self):
470
 
        bzrlib.user_encoding = self.user_encoding
471
 
        sys.stdout = self.stdout
472
 
        TestCaseWithTransport.tearDown(self)
473
764
 
474
765
    def make_uncommitted_tree(self):
475
766
        """Build a branch with uncommitted unicode named changes in the cwd."""
484
775
        return working_tree
485
776
 
486
777
    def test_stdout_ascii(self):
487
 
        sys.stdout = StringIO()
488
 
        bzrlib.user_encoding = 'ascii'
 
778
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
489
779
        working_tree = self.make_uncommitted_tree()
490
780
        stdout, stderr = self.run_bzr("status")
491
781
 
495
785
""")
496
786
 
497
787
    def test_stdout_latin1(self):
498
 
        sys.stdout = StringIO()
499
 
        bzrlib.user_encoding = 'latin-1'
 
788
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
500
789
        working_tree = self.make_uncommitted_tree()
501
790
        stdout, stderr = self.run_bzr('status')
502
791