/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

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

  • Committer: Jelmer Vernooij
  • Date: 2018-11-16 16:20:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7174.
  • Revision ID: jelmer@jelmer.uk-20181116162027-6v6i0kpyfi54blso
Use addCleanup.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_status.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2016 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
22
22
interface later, they will be non blackbox tests.
23
23
"""
24
24
 
25
 
from cStringIO import StringIO
26
25
import codecs
27
26
from os import mkdir, chdir, rmdir, unlink
28
27
import sys
29
 
from tempfile import TemporaryFile
30
28
 
31
 
from bzrlib import (
32
 
    bzrdir,
 
29
from ... import (
33
30
    conflicts,
34
31
    errors,
35
32
    osutils,
36
 
    )
37
 
import bzrlib.branch
38
 
from bzrlib.osutils import pathjoin
39
 
from bzrlib.revisionspec import RevisionSpec
40
 
from bzrlib.status import show_tree_status
41
 
from bzrlib.tests import TestCaseWithTransport, TestSkipped
42
 
from bzrlib.workingtree import WorkingTree
 
33
    status,
 
34
    )
 
35
from breezy.bzr import (
 
36
    bzrdir,
 
37
    )
 
38
import breezy.branch
 
39
from ...osutils import pathjoin
 
40
from ...revisionspec import RevisionSpec
 
41
from ...sixish import (
 
42
    BytesIO,
 
43
    StringIO,
 
44
    PY3,
 
45
    )
 
46
from ...status import show_tree_status
 
47
from .. import TestCaseWithTransport, TestSkipped
 
48
from ...workingtree import WorkingTree
43
49
 
44
50
 
45
51
class BranchStatus(TestCaseWithTransport):
46
52
 
47
 
    def assertStatus(self, expected_lines, working_tree,
 
53
    def setUp(self):
 
54
        super(BranchStatus, self).setUp()
 
55
        # As TestCase.setUp clears all hooks, we install this default
 
56
        # post_status hook handler for the test.
 
57
        status.hooks.install_named_hook('post_status',
 
58
            status._show_shelve_summary,
 
59
            'brz status')
 
60
 
 
61
    def assertStatus(self, expected_lines, working_tree, specific_files=None,
48
62
        revision=None, short=False, pending=True, verbose=False):
49
63
        """Run status in working_tree and look for output.
50
64
 
51
65
        :param expected_lines: The lines to look for.
52
66
        :param working_tree: The tree to run status in.
53
67
        """
54
 
        output_string = self.status_string(working_tree, revision, short,
 
68
        output_string = self.status_string(working_tree, specific_files, revision, short,
55
69
                pending, verbose)
56
70
        self.assertEqual(expected_lines, output_string.splitlines(True))
57
71
 
58
 
    def status_string(self, wt, revision=None, short=False, pending=True,
59
 
        verbose=False):
60
 
        # use a real file rather than StringIO because it doesn't handle
61
 
        # Unicode very well.
62
 
        tof = codecs.getwriter('utf-8')(TemporaryFile())
63
 
        show_tree_status(wt, to_file=tof, revision=revision, short=short,
64
 
                show_pending=pending, verbose=verbose)
65
 
        tof.seek(0)
66
 
        return tof.read().decode('utf-8')
 
72
    def status_string(self, wt, specific_files=None, revision=None,
 
73
        short=False, pending=True, verbose=False):
 
74
        uio = self.make_utf8_encoded_stringio()
 
75
        show_tree_status(wt, specific_files=specific_files, to_file=uio,
 
76
                revision=revision, short=short, show_pending=pending,
 
77
                verbose=verbose)
 
78
        return uio.getvalue().decode('utf-8')
67
79
 
68
80
    def test_branch_status(self):
69
81
        """Test basic branch status"""
91
103
        # add a commit to allow showing pending merges.
92
104
        wt.commit('create a parent to allow testing merge output')
93
105
 
94
 
        wt.add_parent_tree_id('pending@pending-0-0')
 
106
        wt.add_parent_tree_id(b'pending@pending-0-0')
95
107
        self.assertStatus([
96
108
                'unknown:\n',
97
109
                '  bye.c\n',
163
175
        wt = self.make_branch_and_tree('branch')
164
176
        b = wt.branch
165
177
        wt.commit("Empty commit 1")
166
 
        b_2_dir = b.bzrdir.sprout('./copy')
 
178
        b_2_dir = b.controldir.sprout('./copy')
167
179
        b_2 = b_2_dir.open_branch()
168
180
        wt2 = b_2_dir.open_workingtree()
169
181
        wt.commit(u"\N{TIBETAN DIGIT TWO} Empty commit 2")
178
190
        wt2.merge_from_branch(wt.branch)
179
191
        message = self.status_string(wt2, verbose=True)
180
192
        self.assertStartsWith(message, "pending merges:\n")
181
 
        self.assert_("Empty commit 3" in message)
 
193
        self.assertTrue("Empty commit 3" in message)
182
194
        self.assertEndsWith(message, "...\n")
183
195
 
184
196
    def test_tree_status_ignores(self):
202
214
        wt = self.make_branch_and_tree('.')
203
215
        b = wt.branch
204
216
 
205
 
        self.build_tree(['directory/','directory/hello.c', 'bye.c','test.c','dir2/'])
 
217
        self.build_tree(['directory/', 'directory/hello.c',
 
218
                         'bye.c', 'test.c', 'dir2/',
 
219
                         'missing.c'])
206
220
        wt.add('directory')
207
221
        wt.add('test.c')
208
222
        wt.commit('testing')
 
223
        wt.add('missing.c')
 
224
        unlink('missing.c')
209
225
 
210
226
        self.assertStatus([
 
227
                'missing:\n',
 
228
                '  missing.c\n',
211
229
                'unknown:\n',
212
230
                '  bye.c\n',
213
231
                '  dir2/\n',
218
236
        self.assertStatus([
219
237
                '?   bye.c\n',
220
238
                '?   dir2/\n',
221
 
                '?   directory/hello.c\n'
 
239
                '?   directory/hello.c\n',
 
240
                '+!  missing.c\n',
222
241
                ],
223
242
                wt, short=True)
224
243
 
225
244
        tof = StringIO()
226
245
        self.assertRaises(errors.PathsDoNotExist,
227
246
                          show_tree_status,
228
 
                          wt, specific_files=['bye.c','test.c','absent.c'],
 
247
                          wt, specific_files=['bye.c', 'test.c', 'absent.c'],
229
248
                          to_file=tof)
230
249
 
231
250
        tof = StringIO()
232
251
        show_tree_status(wt, specific_files=['directory'], to_file=tof)
233
252
        tof.seek(0)
234
 
        self.assertEquals(tof.readlines(),
 
253
        self.assertEqual(tof.readlines(),
235
254
                          ['unknown:\n',
236
255
                           '  directory/hello.c\n'
237
256
                           ])
239
258
        show_tree_status(wt, specific_files=['directory'], to_file=tof,
240
259
                         short=True)
241
260
        tof.seek(0)
242
 
        self.assertEquals(tof.readlines(), ['?   directory/hello.c\n'])
 
261
        self.assertEqual(tof.readlines(), ['?   directory/hello.c\n'])
243
262
 
244
263
        tof = StringIO()
245
264
        show_tree_status(wt, specific_files=['dir2'], to_file=tof)
246
265
        tof.seek(0)
247
 
        self.assertEquals(tof.readlines(),
 
266
        self.assertEqual(tof.readlines(),
248
267
                          ['unknown:\n',
249
268
                           '  dir2/\n'
250
269
                           ])
251
270
        tof = StringIO()
252
271
        show_tree_status(wt, specific_files=['dir2'], to_file=tof, short=True)
253
272
        tof.seek(0)
254
 
        self.assertEquals(tof.readlines(), ['?   dir2/\n'])
 
273
        self.assertEqual(tof.readlines(), ['?   dir2/\n'])
255
274
 
256
275
        tof = StringIO()
257
276
        revs = [RevisionSpec.from_string('0'), RevisionSpec.from_string('1')]
258
277
        show_tree_status(wt, specific_files=['test.c'], to_file=tof,
259
278
                         short=True, revision=revs)
260
279
        tof.seek(0)
261
 
        self.assertEquals(tof.readlines(), ['+N  test.c\n'])
 
280
        self.assertEqual(tof.readlines(), ['+N  test.c\n'])
 
281
 
 
282
        tof = StringIO()
 
283
        show_tree_status(wt, specific_files=['missing.c'], to_file=tof)
 
284
        tof.seek(0)
 
285
        self.assertEqual(tof.readlines(),
 
286
                          ['missing:\n',
 
287
                           '  missing.c\n'])
 
288
 
 
289
        tof = StringIO()
 
290
        show_tree_status(wt, specific_files=['missing.c'], to_file=tof,
 
291
                         short=True)
 
292
        tof.seek(0)
 
293
        self.assertEqual(tof.readlines(),
 
294
                          ['+!  missing.c\n'])
262
295
 
263
296
    def test_specific_files_conflicts(self):
264
297
        tree = self.make_branch_and_tree('.')
267
300
        tree.commit('added dir2')
268
301
        tree.set_conflicts(conflicts.ConflictList(
269
302
            [conflicts.ContentsConflict('foo')]))
270
 
        tof = StringIO()
 
303
        tof = BytesIO()
271
304
        show_tree_status(tree, specific_files=['dir2'], to_file=tof)
272
 
        self.assertEqualDiff('', tof.getvalue())
 
305
        self.assertEqualDiff(b'', tof.getvalue())
273
306
        tree.set_conflicts(conflicts.ConflictList(
274
307
            [conflicts.ContentsConflict('dir2')]))
275
308
        tof = StringIO()
294
327
        wt.add('FILE_D')
295
328
        wt.add('FILE_E')
296
329
        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.')
 
330
        with open('FILE_B', 'w') as f: f.write('Modification to file FILE_B.')
 
331
        with open('FILE_C', 'w') as f: f.write('Modification to file FILE_C.')
299
332
        unlink('FILE_E')  # FILE_E will be versioned but missing
300
 
        open('FILE_Q', 'w').write('FILE_Q is added but not committed.')
 
333
        with open('FILE_Q', 'w') as f: f.write('FILE_Q is added but not committed.')
301
334
        wt.add('FILE_Q')  # FILE_Q will be added but not committed
302
335
        open('UNVERSIONED_BUT_EXISTING', 'w')
303
336
        return wt
330
363
        # Okay, everything's looking good with the existent files.
331
364
        # Let's see what happens when we throw in non-existent files.
332
365
 
333
 
        # bzr st [--short] NONEXISTENT '
 
366
        # brz st [--short] NONEXISTENT '
334
367
        expected = [
335
368
          'nonexistent:\n',
336
369
          '  NONEXISTENT\n',
349
382
                              'NONEXISTENT.*')
350
383
 
351
384
    def test_status_nonexistent_file_with_others(self):
352
 
        # bzr st [--short] NONEXISTENT ...others..
 
385
        # brz st [--short] NONEXISTENT ...others..
353
386
        wt = self._prepare_nonexistent()
354
387
        expected = [
355
388
          'removed:\n',
368
401
                              r'.*ERROR: Path\(s\) do not exist: '
369
402
                              'NONEXISTENT.*')
370
403
        expected = [
 
404
          ' M  FILE_B\n',
 
405
          ' M  FILE_C\n',
371
406
          ' D  FILE_E\n',
372
 
          ' M  FILE_C\n',
373
 
          ' M  FILE_B\n',
374
407
          'X   NONEXISTENT\n',
375
408
          ]
376
409
        out, err = self.run_bzr('status --short NONEXISTENT '
382
415
                              'NONEXISTENT.*')
383
416
 
384
417
    def test_status_multiple_nonexistent_files(self):
385
 
        # bzr st [--short] NONEXISTENT ... ANOTHER_NONEXISTENT ...
 
418
        # brz st [--short] NONEXISTENT ... ANOTHER_NONEXISTENT ...
386
419
        wt = self._prepare_nonexistent()
387
420
        expected = [
388
421
          'removed:\n',
402
435
                              r'.*ERROR: Path\(s\) do not exist: '
403
436
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
404
437
        expected = [
 
438
          ' M  FILE_B\n',
 
439
          ' M  FILE_C\n',
405
440
          ' D  FILE_E\n',
406
 
          ' M  FILE_C\n',
407
 
          ' M  FILE_B\n',
408
441
          'X   ANOTHER_NONEXISTENT\n',
409
442
          'X   NONEXISTENT\n',
410
443
          ]
417
450
                              'ANOTHER_NONEXISTENT NONEXISTENT.*')
418
451
 
419
452
    def test_status_nonexistent_file_with_unversioned(self):
420
 
        # bzr st [--short] NONEXISTENT A B UNVERSIONED_BUT_EXISTING C D E Q
 
453
        # brz st [--short] NONEXISTENT A B UNVERSIONED_BUT_EXISTING C D E Q
421
454
        wt = self._prepare_nonexistent()
422
455
        expected = [
423
456
          'removed:\n',
439
472
        self.assertContainsRe(err,
440
473
                              r'.*ERROR: Path\(s\) do not exist: '
441
474
                              'NONEXISTENT.*')
442
 
        expected = [
 
475
        expected = sorted([
443
476
          '+N  FILE_Q\n',
444
477
          '?   UNVERSIONED_BUT_EXISTING\n',
445
478
          ' D  FILE_E\n',
446
479
          ' M  FILE_C\n',
447
480
          ' M  FILE_B\n',
448
481
          'X   NONEXISTENT\n',
449
 
          ]
 
482
          ])
450
483
        out, err = self.run_bzr('status --short NONEXISTENT '
451
484
                                'FILE_A FILE_B UNVERSIONED_BUT_EXISTING '
452
485
                                'FILE_C FILE_D FILE_E FILE_Q', retcode=3)
453
 
        self.assertEqual(expected, out.splitlines(True))
 
486
        actual = out.splitlines(True)
 
487
        actual.sort()
 
488
        self.assertEqual(expected, actual)
454
489
        self.assertContainsRe(err,
455
490
                              r'.*ERROR: Path\(s\) do not exist: '
456
491
                              'NONEXISTENT.*')
458
493
    def test_status_out_of_date(self):
459
494
        """Simulate status of out-of-date tree after remote push"""
460
495
        tree = self.make_branch_and_tree('.')
461
 
        self.build_tree_contents([('a', 'foo\n')])
 
496
        self.build_tree_contents([('a', b'foo\n')])
462
497
        tree.lock_write()
463
498
        try:
464
499
            tree.add(['a'])
465
500
            tree.commit('add test file')
466
501
            # simulate what happens after a remote push
467
 
            tree.set_last_revision("0")
 
502
            tree.set_last_revision(b"0")
468
503
        finally:
469
504
            # before run another commands we should unlock tree
470
505
            tree.unlock()
471
506
        out, err = self.run_bzr('status')
472
 
        self.assertEqual("working tree is out of date, run 'bzr update'\n",
 
507
        self.assertEqual("working tree is out of date, run 'brz update'\n",
473
508
                         err)
474
509
 
475
510
    def test_status_on_ignored(self):
483
518
        result = self.run_bzr('status')[0]
484
519
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
485
520
        short_result = self.run_bzr('status --short')[0]
486
 
        self.assertContainsRe(short_result, "\?   test1.c\n")
 
521
        self.assertContainsRe(short_result, "\\?   test1.c\n")
487
522
 
488
523
        result = self.run_bzr('status test1.c')[0]
489
524
        self.assertContainsRe(result, "unknown:\n  test1.c\n")
490
525
        short_result = self.run_bzr('status --short test1.c')[0]
491
 
        self.assertContainsRe(short_result, "\?   test1.c\n")
 
526
        self.assertContainsRe(short_result, "\\?   test1.c\n")
492
527
 
493
528
        result = self.run_bzr('status test1.c~')[0]
494
529
        self.assertContainsRe(result, "ignored:\n  test1.c~\n")
503
538
        result = self.run_bzr('status test1.c test1.c~ test2.c~')[0]
504
539
        self.assertContainsRe(result, "unknown:\n  test1.c\nignored:\n  test1.c~\n  test2.c~\n")
505
540
        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")
 
541
        self.assertContainsRe(short_result, "\\?   test1.c\nI   test1.c~\nI   test2.c~\n")
507
542
 
508
543
    def test_status_write_lock(self):
509
544
        """Test that status works without fetching history and
515
550
        wt = self.make_branch_and_tree('branch1')
516
551
        b = wt.branch
517
552
        wt.commit('Empty commit 1')
518
 
        wt2 = b.bzrdir.sprout('branch2').open_workingtree()
 
553
        wt2 = b.controldir.sprout('branch2').open_workingtree()
519
554
        wt2.commit('Empty commit 2')
520
555
        out, err = self.run_bzr('status branch1 -rbranch:branch2')
521
556
        self.assertEqual('', out)
522
557
 
 
558
    def test_status_with_shelves(self):
 
559
        """Ensure that _show_shelve_summary handler works.
 
560
        """
 
561
        wt = self.make_branch_and_tree('.')
 
562
        self.build_tree(['hello.c'])
 
563
        wt.add('hello.c')
 
564
        self.run_bzr(['shelve', '--all', '-m', 'foo'])
 
565
        self.build_tree(['bye.c'])
 
566
        wt.add('bye.c')
 
567
        self.assertStatus([
 
568
                'added:\n',
 
569
                '  bye.c\n',
 
570
                '1 shelf exists. See "brz shelve --list" for details.\n',
 
571
            ],
 
572
            wt)
 
573
        self.run_bzr(['shelve', '--all', '-m', 'bar'])
 
574
        self.build_tree(['eggs.c', 'spam.c'])
 
575
        wt.add('eggs.c')
 
576
        wt.add('spam.c')
 
577
        self.assertStatus([
 
578
                'added:\n',
 
579
                '  eggs.c\n',
 
580
                '  spam.c\n',
 
581
                '2 shelves exist. See "brz shelve --list" for details.\n',
 
582
            ],
 
583
            wt)
 
584
        self.assertStatus([
 
585
                'added:\n',
 
586
                '  spam.c\n',
 
587
            ],
 
588
            wt,
 
589
            specific_files=['spam.c'])
 
590
 
523
591
 
524
592
class CheckoutStatus(BranchStatus):
525
593
 
531
599
    def make_branch_and_tree(self, relpath):
532
600
        source = self.make_branch(pathjoin('..', relpath))
533
601
        checkout = bzrdir.BzrDirMetaFormat1().initialize(relpath)
534
 
        bzrlib.branch.BranchReferenceFormat().initialize(checkout,
535
 
            target_branch=source)
 
602
        checkout.set_branch_reference(source)
536
603
        return checkout.create_workingtree()
537
604
 
538
605
 
561
628
        self.assertContainsRe(result, "added:\n  hello.txt\n" \
562
629
                                      "unknown:\n  world.txt\n")
563
630
        result2 = self.run_bzr("status -r 0..")[0]
564
 
        self.assertEquals(result2, result)
 
631
        self.assertEqual(result2, result)
565
632
 
566
633
    def test_status_short(self):
567
634
        tree = self.make_branch_and_tree('.')
579
646
        self.assertContainsRe(result, "[+]N  hello.txt\n")
580
647
 
581
648
        self.build_tree(['world.txt'])
582
 
        result = self.run_bzr("status --short -r 0")[0]
 
649
        result = self.run_bzr("status -S -r 0")[0]
583
650
        self.assertContainsRe(result, "[+]N  hello.txt\n" \
584
651
                                      "[?]   world.txt\n")
585
 
        result2 = self.run_bzr("status --short -r 0..")[0]
586
 
        self.assertEquals(result2, result)
 
652
        result2 = self.run_bzr("status -S -r 0..")[0]
 
653
        self.assertEqual(result2, result)
587
654
 
588
655
    def test_status_versioned(self):
589
656
        tree = self.make_branch_and_tree('.')
605
672
        self.assertContainsRe(result, "added:\n  hello.txt\n")
606
673
        self.assertNotContainsRe(result, "unknown:\n  world.txt\n")
607
674
        result2 = self.run_bzr("status --versioned -r 0..")[0]
608
 
        self.assertEquals(result2, result)
 
675
        self.assertEqual(result2, result)
609
676
 
610
677
    def test_status_SV(self):
611
678
        tree = self.make_branch_and_tree('.')
627
694
        self.assertContainsRe(result, "[+]N  hello.txt\n")
628
695
 
629
696
        result2 = self.run_bzr("status -SV -r 0..")[0]
630
 
        self.assertEquals(result2, result)
 
697
        self.assertEqual(result2, result)
631
698
 
632
699
    def assertStatusContains(self, pattern, short=False):
633
700
        """Run status, and assert it contains the given pattern"""
644
711
        tree.commit('added file')
645
712
        unlink('file')
646
713
        self.build_tree(['file/'])
647
 
        self.assertStatusContains('kind changed:\n  file \(file => directory\)')
 
714
        self.assertStatusContains('kind changed:\n  file \\(file => directory\\)')
648
715
        tree.rename_one('file', 'directory')
649
716
        self.assertStatusContains('renamed:\n  file/ => directory/\n' \
650
717
                                  'modified:\n  directory/\n')
676
743
        self.build_tree(['a/a'])
677
744
        a_tree.add('a')
678
745
        a_tree.commit('a')
679
 
        b_tree = a_tree.bzrdir.sprout('b').open_workingtree()
 
746
        b_tree = a_tree.controldir.sprout('b').open_workingtree()
680
747
        self.build_tree(['b/b'])
681
748
        b_tree.add('b')
682
749
        b_tree.commit('b')
683
750
 
684
751
        self.run_bzr('merge ../b', working_dir='a')
685
752
        out, err = self.run_bzr('status --no-pending', working_dir='a')
686
 
        self.assertEquals(out, "added:\n  b\n")
 
753
        self.assertEqual(out, "added:\n  b\n")
687
754
 
688
755
    def test_pending_specific_files(self):
689
756
        """With a specific file list, pending merges are not shown."""
690
757
        tree = self.make_branch_and_tree('tree')
691
 
        self.build_tree_contents([('tree/a', 'content of a\n')])
 
758
        self.build_tree_contents([('tree/a', b'content of a\n')])
692
759
        tree.add('a')
693
760
        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')])
 
761
        alt = tree.controldir.sprout('alt').open_workingtree()
 
762
        self.build_tree_contents([('alt/a', b'content of a\nfrom alt\n')])
696
763
        alt_id = alt.commit('alt')
697
764
        tree.merge_from_branch(alt.branch)
698
765
        output = self.make_utf8_encoded_stringio()
699
766
        show_tree_status(tree, to_file=output)
700
 
        self.assertContainsRe(output.getvalue(), 'pending merge')
 
767
        self.assertContainsRe(output.getvalue(), b'pending merge')
701
768
        out, err = self.run_bzr('status tree/a')
702
769
        self.assertNotContainsRe(out, 'pending merge')
703
770
 
704
771
 
705
772
class TestStatusEncodings(TestCaseWithTransport):
706
773
 
707
 
    def setUp(self):
708
 
        TestCaseWithTransport.setUp(self)
709
 
        self.user_encoding = osutils._cached_user_encoding
710
 
        self.stdout = sys.stdout
711
 
 
712
 
    def tearDown(self):
713
 
        osutils._cached_user_encoding = self.user_encoding
714
 
        sys.stdout = self.stdout
715
 
        TestCaseWithTransport.tearDown(self)
716
 
 
717
774
    def make_uncommitted_tree(self):
718
775
        """Build a branch with uncommitted unicode named changes in the cwd."""
719
776
        working_tree = self.make_branch_and_tree(u'.')
720
777
        filename = u'hell\u00d8'
721
778
        try:
722
 
            self.build_tree_contents([(filename, 'contents of hello')])
 
779
            self.build_tree_contents([(filename, b'contents of hello')])
723
780
        except UnicodeEncodeError:
724
781
            raise TestSkipped("can't build unicode working tree in "
725
782
                "filesystem encoding %s" % sys.getfilesystemencoding())
727
784
        return working_tree
728
785
 
729
786
    def test_stdout_ascii(self):
730
 
        sys.stdout = StringIO()
731
 
        osutils._cached_user_encoding = 'ascii'
 
787
        self.overrideAttr(osutils, '_cached_user_encoding', 'ascii')
732
788
        working_tree = self.make_uncommitted_tree()
733
789
        stdout, stderr = self.run_bzr("status")
734
790
 
735
 
        self.assertEquals(stdout, """\
 
791
        self.assertEqual(stdout, """\
736
792
added:
737
793
  hell?
738
794
""")
739
795
 
740
796
    def test_stdout_latin1(self):
741
 
        sys.stdout = StringIO()
742
 
        osutils._cached_user_encoding = 'latin-1'
 
797
        self.overrideAttr(osutils, '_cached_user_encoding', 'latin-1')
743
798
        working_tree = self.make_uncommitted_tree()
744
799
        stdout, stderr = self.run_bzr('status')
745
800
 
746
 
        self.assertEquals(stdout, u"""\
 
801
        expected = u"""\
747
802
added:
748
803
  hell\u00d8
749
 
""".encode('latin-1'))
 
804
"""
 
805
        if not PY3:
 
806
            expected = expected.encode('latin-1')
 
807
        self.assertEqual(stdout, expected)
750
808