/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/tests/test_osutils.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
16
16
 
17
17
"""Tests for the osutils wrapper."""
18
18
 
19
 
from cStringIO import StringIO
20
19
import errno
21
20
import os
22
21
import re
26
25
import tempfile
27
26
import time
28
27
 
29
 
from bzrlib import (
 
28
from .. import (
30
29
    errors,
31
30
    lazy_regex,
32
31
    osutils,
35
34
    trace,
36
35
    win32utils,
37
36
    )
38
 
from bzrlib.tests import (
 
37
from ..sixish import (
 
38
    BytesIO,
 
39
    )
 
40
from . import (
39
41
    features,
40
42
    file_utils,
41
43
    test__walkdirs_win32,
42
44
    )
43
 
from bzrlib.tests.scenarios import load_tests_apply_scenarios
 
45
from .scenarios import load_tests_apply_scenarios
44
46
 
45
47
 
46
48
class _UTF8DirReaderFeature(features.Feature):
47
49
 
48
50
    def _probe(self):
49
51
        try:
50
 
            from bzrlib import _readdir_pyx
 
52
            from .. import _readdir_pyx
51
53
            self.reader = _readdir_pyx.UTF8DirReader
52
54
            return True
53
55
        except ImportError:
54
56
            return False
55
57
 
56
58
    def feature_name(self):
57
 
        return 'bzrlib._readdir_pyx'
 
59
        return 'breezy._readdir_pyx'
58
60
 
59
 
UTF8DirReaderFeature = features.ModuleAvailableFeature('bzrlib._readdir_pyx')
 
61
UTF8DirReaderFeature = features.ModuleAvailableFeature('breezy._readdir_pyx')
60
62
 
61
63
term_ios_feature = features.ModuleAvailableFeature('termios')
62
64
 
82
84
    # Some DirReaders are platform specific and even there they may not be
83
85
    # available.
84
86
    if UTF8DirReaderFeature.available():
85
 
        from bzrlib import _readdir_pyx
 
87
        from .. import _readdir_pyx
86
88
        scenarios.append(('utf8',
87
89
                          dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
88
90
                               _native_to_unicode=_utf8_to_unicode)))
89
91
 
90
92
    if test__walkdirs_win32.win32_readdir_feature.available():
91
93
        try:
92
 
            from bzrlib import _walkdirs_win32
 
94
            from .. import _walkdirs_win32
93
95
            scenarios.append(
94
96
                ('win32',
95
97
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
185
187
    def test_rename_exception(self):
186
188
        try:
187
189
            osutils.rename('nonexistent_path', 'different_nonexistent_path')
188
 
        except OSError, e:
 
190
        except OSError as e:
189
191
            self.assertEqual(e.old_filename, 'nonexistent_path')
190
192
            self.assertEqual(e.new_filename, 'different_nonexistent_path')
191
193
            self.assertTrue('nonexistent_path' in e.strerror)
307
309
        # TODO: jam 20060529 Test a block device
308
310
        try:
309
311
            os.lstat('/dev/null')
310
 
        except OSError, e:
 
312
        except OSError as e:
311
313
            if e.errno not in (errno.ENOENT,):
312
314
                raise
313
315
        else:
351
353
 
352
354
        orig_umask = osutils.get_umask()
353
355
        self.addCleanup(os.umask, orig_umask)
354
 
        os.umask(0222)
355
 
        self.assertEqual(0222, osutils.get_umask())
356
 
        os.umask(0022)
357
 
        self.assertEqual(0022, osutils.get_umask())
358
 
        os.umask(0002)
359
 
        self.assertEqual(0002, osutils.get_umask())
360
 
        os.umask(0027)
361
 
        self.assertEqual(0027, osutils.get_umask())
 
356
        os.umask(0o222)
 
357
        self.assertEqual(0o222, osutils.get_umask())
 
358
        os.umask(0o022)
 
359
        self.assertEqual(0o022, osutils.get_umask())
 
360
        os.umask(0o002)
 
361
        self.assertEqual(0o002, osutils.get_umask())
 
362
        os.umask(0o027)
 
363
        self.assertEqual(0o027, osutils.get_umask())
362
364
 
363
365
 
364
366
class TestDateTime(tests.TestCase):
517
519
        # Make a file readonly
518
520
        osutils.make_readonly('file')
519
521
        mode = os.lstat('file').st_mode
520
 
        self.assertEqual(mode, mode & 0777555)
 
522
        self.assertEqual(mode, mode & 0o777555)
521
523
 
522
524
        # Make a file writable
523
525
        osutils.make_writable('file')
524
526
        mode = os.lstat('file').st_mode
525
 
        self.assertEqual(mode, mode | 0200)
 
527
        self.assertEqual(mode, mode | 0o200)
526
528
 
527
529
        if osutils.has_symlinks():
528
530
            # should not error when handed a symlink
612
614
        self.assertTrue(self.test_data_len > self.block_size)
613
615
 
614
616
        from_file = file_utils.FakeReadFile(self.test_data)
615
 
        to_file = StringIO()
 
617
        to_file = BytesIO()
616
618
 
617
619
        # read (max / 2) bytes and verify read size wasn't affected
618
620
        num_bytes_to_read = self.block_size / 2
653
655
 
654
656
        # retrieve data in blocks
655
657
        from_file = file_utils.FakeReadFile(self.test_data)
656
 
        to_file = StringIO()
 
658
        to_file = BytesIO()
657
659
        osutils.pumpfile(from_file, to_file, self.test_data_len,
658
660
                         self.block_size)
659
661
 
677
679
 
678
680
        # retrieve data to EOF
679
681
        from_file = file_utils.FakeReadFile(self.test_data)
680
 
        to_file = StringIO()
 
682
        to_file = BytesIO()
681
683
        osutils.pumpfile(from_file, to_file, -1, self.block_size)
682
684
 
683
685
        # verify read size was equal to the maximum read size
697
699
        with this new version."""
698
700
        # retrieve data using default (old) pumpfile method
699
701
        from_file = file_utils.FakeReadFile(self.test_data)
700
 
        to_file = StringIO()
 
702
        to_file = BytesIO()
701
703
        osutils.pumpfile(from_file, to_file)
702
704
 
703
705
        # report error if the data wasn't equal (we only report the size due
711
713
        activity = []
712
714
        def log_activity(length, direction):
713
715
            activity.append((length, direction))
714
 
        from_file = StringIO(self.test_data)
715
 
        to_file = StringIO()
 
716
        from_file = BytesIO(self.test_data)
 
717
        to_file = BytesIO()
716
718
        osutils.pumpfile(from_file, to_file, buff_size=500,
717
719
                         report_activity=log_activity, direction='read')
718
720
        self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
719
721
                          (36, 'read')], activity)
720
722
 
721
 
        from_file = StringIO(self.test_data)
722
 
        to_file = StringIO()
 
723
        from_file = BytesIO(self.test_data)
 
724
        to_file = BytesIO()
723
725
        del activity[:]
724
726
        osutils.pumpfile(from_file, to_file, buff_size=500,
725
727
                         report_activity=log_activity, direction='write')
727
729
                          (36, 'write')], activity)
728
730
 
729
731
        # And with a limited amount of data
730
 
        from_file = StringIO(self.test_data)
731
 
        to_file = StringIO()
 
732
        from_file = BytesIO(self.test_data)
 
733
        to_file = BytesIO()
732
734
        del activity[:]
733
735
        osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
734
736
                         report_activity=log_activity, direction='read')
739
741
class TestPumpStringFile(tests.TestCase):
740
742
 
741
743
    def test_empty(self):
742
 
        output = StringIO()
 
744
        output = BytesIO()
743
745
        osutils.pump_string_file("", output)
744
746
        self.assertEqual("", output.getvalue())
745
747
 
746
748
    def test_more_than_segment_size(self):
747
 
        output = StringIO()
 
749
        output = BytesIO()
748
750
        osutils.pump_string_file("123456789", output, 2)
749
751
        self.assertEqual("123456789", output.getvalue())
750
752
 
751
753
    def test_segment_size(self):
752
 
        output = StringIO()
 
754
        output = BytesIO()
753
755
        osutils.pump_string_file("12", output, 2)
754
756
        self.assertEqual("12", output.getvalue())
755
757
 
756
758
    def test_segment_size_multiple(self):
757
 
        output = StringIO()
 
759
        output = BytesIO()
758
760
        osutils.pump_string_file("1234", output, 2)
759
761
        self.assertEqual("1234", output.getvalue())
760
762
 
963
965
 
964
966
    def test_getcwd(self):
965
967
        cwd = osutils._win32_getcwd()
966
 
        os_cwd = os.getcwdu()
 
968
        os_cwd = osutils._getcwd()
967
969
        self.assertEqual(os_cwd[1:].replace('\\', '/'), cwd[1:])
968
970
        # win32 is inconsistent whether it returns lower or upper case
969
971
        # and even if it was consistent the user might type the other
1011
1013
    def test_minimum_path_selection(self):
1012
1014
        self.assertEqual(set(),
1013
1015
            osutils.minimum_path_selection([]))
1014
 
        self.assertEqual(set(['a']),
 
1016
        self.assertEqual({'a'},
1015
1017
            osutils.minimum_path_selection(['a']))
1016
 
        self.assertEqual(set(['a', 'b']),
 
1018
        self.assertEqual({'a', 'b'},
1017
1019
            osutils.minimum_path_selection(['a', 'b']))
1018
 
        self.assertEqual(set(['a/', 'b']),
 
1020
        self.assertEqual({'a/', 'b'},
1019
1021
            osutils.minimum_path_selection(['a/', 'b']))
1020
 
        self.assertEqual(set(['a/', 'b']),
 
1022
        self.assertEqual({'a/', 'b'},
1021
1023
            osutils.minimum_path_selection(['a/c', 'a/', 'b']))
1022
 
        self.assertEqual(set(['a-b', 'a', 'a0b']),
 
1024
        self.assertEqual({'a-b', 'a', 'a0b'},
1023
1025
            osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
1024
1026
 
1025
1027
    def test_mkdtemp(self):
1046
1048
 
1047
1049
        try:
1048
1050
            osutils._win32_rename('b', 'a')
1049
 
        except (IOError, OSError), e:
 
1051
        except (IOError, OSError) as e:
1050
1052
            self.assertEqual(errno.ENOENT, e.errno)
1051
1053
        self.assertFileEqual('foo\n', 'a')
1052
1054
 
1054
1056
        os.mkdir('a')
1055
1057
        try:
1056
1058
            osutils._win32_rename('b', 'a')
1057
 
        except (IOError, OSError), e:
 
1059
        except (IOError, OSError) as e:
1058
1060
            self.assertEqual(errno.ENOENT, e.errno)
1059
1061
 
1060
1062
    def test_rename_current_dir(self):
1066
1068
        # doesn't exist.
1067
1069
        try:
1068
1070
            osutils._win32_rename('b', '.')
1069
 
        except (IOError, OSError), e:
 
1071
        except (IOError, OSError) as e:
1070
1072
            self.assertEqual(errno.ENOENT, e.errno)
1071
1073
 
1072
1074
    def test_splitpath(self):
1117
1119
                         osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
1118
1120
 
1119
1121
    def test_osutils_binding(self):
1120
 
        from bzrlib.tests import test__chunks_to_lines
 
1122
        from . import test__chunks_to_lines
1121
1123
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
1122
 
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
 
1124
            from .._chunks_to_lines_pyx import chunks_to_lines
1123
1125
        else:
1124
 
            from bzrlib._chunks_to_lines_py import chunks_to_lines
 
1126
            from .._chunks_to_lines_py import chunks_to_lines
1125
1127
        self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
1126
1128
 
1127
1129
 
1200
1202
        os.mkdir("test-unreadable")
1201
1203
        os.chmod("test-unreadable", 0000)
1202
1204
        # must chmod it back so that it can be removed
1203
 
        self.addCleanup(os.chmod, "test-unreadable", 0700)
 
1205
        self.addCleanup(os.chmod, "test-unreadable", 0o700)
1204
1206
        # The error is not raised until the generator is actually evaluated.
1205
1207
        # (It would be ok if it happened earlier but at the moment it
1206
1208
        # doesn't.)
1233
1235
        # rename the 1file to a latin-1 filename
1234
1236
        os.rename("./1file", "\xe8file")
1235
1237
        if "\xe8file" not in os.listdir("."):
1236
 
            self.skip("Lack filesystem that preserves arbitrary bytes")
 
1238
            self.skipTest("Lack filesystem that preserves arbitrary bytes")
1237
1239
 
1238
1240
        self._save_platform_info()
1239
1241
        win32utils.winver = None # Avoid the win32 detection code
1340
1342
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1341
1343
        self._save_platform_info()
1342
1344
        win32utils.winver = 'Windows NT'
1343
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1345
        from .._walkdirs_win32 import Win32ReadDir
1344
1346
        self.assertDirReaderIs(Win32ReadDir)
1345
1347
 
1346
1348
    def test_force_walkdirs_utf8_98(self):
1503
1505
    def test__walkdirs_utf8_win32readdir(self):
1504
1506
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1505
1507
        self.requireFeature(features.UnicodeFilenameFeature)
1506
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1508
        from .._walkdirs_win32 import Win32ReadDir
1507
1509
        self._save_platform_info()
1508
1510
        osutils._selected_dir_reader = Win32ReadDir()
1509
1511
        name0u = u'0file-\xb6'
1560
1562
        """make sure our Stat values are valid"""
1561
1563
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1562
1564
        self.requireFeature(features.UnicodeFilenameFeature)
1563
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1565
        from .._walkdirs_win32 import Win32ReadDir
1564
1566
        name0u = u'0file-\xb6'
1565
1567
        name0 = name0u.encode('utf8')
1566
1568
        self.build_tree([name0u])
1584
1586
        """make sure our Stat values are valid"""
1585
1587
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1586
1588
        self.requireFeature(features.UnicodeFilenameFeature)
1587
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1589
        from .._walkdirs_win32 import Win32ReadDir
1588
1590
        name0u = u'0dir-\u062c\u0648'
1589
1591
        name0 = name0u.encode('utf8')
1590
1592
        self.build_tree([name0u + '/'])
1731
1733
    def setUp(self):
1732
1734
        super(TestSetUnsetEnv, self).setUp()
1733
1735
 
1734
 
        self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
 
1736
        self.assertEqual(None, os.environ.get('BRZ_TEST_ENV_VAR'),
1735
1737
                         'Environment was not cleaned up properly.'
1736
 
                         ' Variable BZR_TEST_ENV_VAR should not exist.')
 
1738
                         ' Variable BRZ_TEST_ENV_VAR should not exist.')
1737
1739
        def cleanup():
1738
 
            if 'BZR_TEST_ENV_VAR' in os.environ:
1739
 
                del os.environ['BZR_TEST_ENV_VAR']
 
1740
            if 'BRZ_TEST_ENV_VAR' in os.environ:
 
1741
                del os.environ['BRZ_TEST_ENV_VAR']
1740
1742
        self.addCleanup(cleanup)
1741
1743
 
1742
1744
    def test_set(self):
1743
1745
        """Test that we can set an env variable"""
1744
 
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
 
1746
        old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'foo')
1745
1747
        self.assertEqual(None, old)
1746
 
        self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
 
1748
        self.assertEqual('foo', os.environ.get('BRZ_TEST_ENV_VAR'))
1747
1749
 
1748
1750
    def test_double_set(self):
1749
1751
        """Test that we get the old value out"""
1750
 
        osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1751
 
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
 
1752
        osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'foo')
 
1753
        old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'bar')
1752
1754
        self.assertEqual('foo', old)
1753
 
        self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
 
1755
        self.assertEqual('bar', os.environ.get('BRZ_TEST_ENV_VAR'))
1754
1756
 
1755
1757
    def test_unicode(self):
1756
1758
        """Environment can only contain plain strings
1763
1765
                'Cannot find a unicode character that works in encoding %s'
1764
1766
                % (osutils.get_user_encoding(),))
1765
1767
 
1766
 
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1767
 
        self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
 
1768
        old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', uni_val)
 
1769
        self.assertEqual(env_val, os.environ.get('BRZ_TEST_ENV_VAR'))
1768
1770
 
1769
1771
    def test_unset(self):
1770
1772
        """Test that passing None will remove the env var"""
1771
 
        osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1772
 
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
 
1773
        osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', 'foo')
 
1774
        old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', None)
1773
1775
        self.assertEqual('foo', old)
1774
 
        self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1775
 
        self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
 
1776
        self.assertEqual(None, os.environ.get('BRZ_TEST_ENV_VAR'))
 
1777
        self.assertFalse('BRZ_TEST_ENV_VAR' in os.environ)
1776
1778
 
1777
1779
 
1778
1780
class TestSizeShaFile(tests.TestCaseInTempDir):
1814
1816
class TestResourceLoading(tests.TestCaseInTempDir):
1815
1817
 
1816
1818
    def test_resource_string(self):
1817
 
        # test resource in bzrlib
1818
 
        text = osutils.resource_string('bzrlib', 'debug.py')
 
1819
        # test resource in breezy
 
1820
        text = osutils.resource_string('breezy', 'debug.py')
1819
1821
        self.assertContainsRe(text, "debug_flags = set()")
1820
 
        # test resource under bzrlib
1821
 
        text = osutils.resource_string('bzrlib.ui', 'text.py')
 
1822
        # test resource under breezy
 
1823
        text = osutils.resource_string('breezy.ui', 'text.py')
1822
1824
        self.assertContainsRe(text, "class TextUIFactory")
1823
1825
        # test unsupported package
1824
1826
        self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1825
1827
            'yyy.xx')
1826
1828
        # test unknown resource
1827
 
        self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
 
1829
        self.assertRaises(IOError, osutils.resource_string, 'breezy', 'yyy.xx')
1828
1830
 
1829
1831
 
1830
1832
class TestReCompile(tests.TestCase):
2021
2023
        self.assertIsInstance(concurrency, int)
2022
2024
 
2023
2025
    def test_local_concurrency_environment_variable(self):
2024
 
        self.overrideEnv('BZR_CONCURRENCY', '2')
 
2026
        self.overrideEnv('BRZ_CONCURRENCY', '2')
2025
2027
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
2026
 
        self.overrideEnv('BZR_CONCURRENCY', '3')
 
2028
        self.overrideEnv('BRZ_CONCURRENCY', '3')
2027
2029
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
2028
 
        self.overrideEnv('BZR_CONCURRENCY', 'foo')
 
2030
        self.overrideEnv('BRZ_CONCURRENCY', 'foo')
2029
2031
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
2030
2032
 
2031
2033
    def test_option_concurrency(self):
2032
 
        self.overrideEnv('BZR_CONCURRENCY', '1')
 
2034
        self.overrideEnv('BRZ_CONCURRENCY', '1')
2033
2035
        self.run_bzr('rocks --concurrency 42')
2034
2036
        # Command line overrides environment variable
2035
 
        self.assertEqual('42', os.environ['BZR_CONCURRENCY'])
 
2037
        self.assertEqual('42', os.environ['BRZ_CONCURRENCY'])
2036
2038
        self.assertEqual(42, osutils.local_concurrency(use_cache=False))
2037
2039
 
2038
2040
 
2040
2042
 
2041
2043
    def _try_loading(self):
2042
2044
        try:
2043
 
            import bzrlib._fictional_extension_py
2044
 
        except ImportError, e:
 
2045
            import breezy._fictional_extension_py
 
2046
        except ImportError as e:
2045
2047
            osutils.failed_to_load_extension(e)
2046
2048
            return True
2047
2049
 
2062
2064
        self.assertLength(0, warnings)
2063
2065
 
2064
2066
    def test_report_extension_load_failures_message(self):
2065
 
        log = StringIO()
 
2067
        log = BytesIO()
2066
2068
        trace.push_log_file(log)
2067
2069
        self.assertTrue(self._try_loading())
2068
2070
        osutils.report_extension_load_failures()
2069
2071
        self.assertContainsRe(
2070
2072
            log.getvalue(),
2071
 
            r"bzr: warning: some compiled extensions could not be loaded; "
 
2073
            r"brz: warning: some compiled extensions could not be loaded; "
2072
2074
            "see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
2073
2075
            )
2074
2076
 
2104
2106
    def test_default_values(self):
2105
2107
        self.assertEqual(80, osutils.default_terminal_width)
2106
2108
 
2107
 
    def test_defaults_to_BZR_COLUMNS(self):
2108
 
        # BZR_COLUMNS is set by the test framework
2109
 
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
2110
 
        self.overrideEnv('BZR_COLUMNS', '12')
 
2109
    def test_defaults_to_BRZ_COLUMNS(self):
 
2110
        # BRZ_COLUMNS is set by the test framework
 
2111
        self.assertNotEqual('12', os.environ['BRZ_COLUMNS'])
 
2112
        self.overrideEnv('BRZ_COLUMNS', '12')
2111
2113
        self.assertEqual(12, osutils.terminal_width())
2112
2114
 
2113
 
    def test_BZR_COLUMNS_0_no_limit(self):
2114
 
        self.overrideEnv('BZR_COLUMNS', '0')
 
2115
    def test_BRZ_COLUMNS_0_no_limit(self):
 
2116
        self.overrideEnv('BRZ_COLUMNS', '0')
2115
2117
        self.assertEqual(None, osutils.terminal_width())
2116
2118
 
2117
2119
    def test_falls_back_to_COLUMNS(self):
2118
 
        self.overrideEnv('BZR_COLUMNS', None)
 
2120
        self.overrideEnv('BRZ_COLUMNS', None)
2119
2121
        self.assertNotEqual('42', os.environ['COLUMNS'])
2120
2122
        self.set_fake_tty()
2121
2123
        self.overrideEnv('COLUMNS', '42')
2122
2124
        self.assertEqual(42, osutils.terminal_width())
2123
2125
 
2124
2126
    def test_tty_default_without_columns(self):
2125
 
        self.overrideEnv('BZR_COLUMNS', None)
 
2127
        self.overrideEnv('BRZ_COLUMNS', None)
2126
2128
        self.overrideEnv('COLUMNS', None)
2127
2129
 
2128
2130
        def terminal_size(w, h):
2136
2138
        self.assertEqual(42, osutils.terminal_width())
2137
2139
 
2138
2140
    def test_non_tty_default_without_columns(self):
2139
 
        self.overrideEnv('BZR_COLUMNS', None)
 
2141
        self.overrideEnv('BRZ_COLUMNS', None)
2140
2142
        self.overrideEnv('COLUMNS', None)
2141
2143
        self.replace_stdout(None)
2142
2144
        self.assertEqual(None, osutils.terminal_width())
2153
2155
        else:
2154
2156
            self.overrideAttr(termios, 'TIOCGWINSZ')
2155
2157
            del termios.TIOCGWINSZ
2156
 
        self.overrideEnv('BZR_COLUMNS', None)
 
2158
        self.overrideEnv('BRZ_COLUMNS', None)
2157
2159
        self.overrideEnv('COLUMNS', None)
2158
2160
        # Whatever the result is, if we don't raise an exception, it's ok.
2159
2161
        osutils.terminal_width()
2198
2200
class TestPathFromEnviron(tests.TestCase):
2199
2201
 
2200
2202
    def test_is_unicode(self):
2201
 
        self.overrideEnv('BZR_TEST_PATH', './anywhere at all/')
2202
 
        path = osutils.path_from_environ('BZR_TEST_PATH')
 
2203
        self.overrideEnv('BRZ_TEST_PATH', './anywhere at all/')
 
2204
        path = osutils.path_from_environ('BRZ_TEST_PATH')
2203
2205
        self.assertIsInstance(path, unicode)
2204
2206
        self.assertEqual(u'./anywhere at all/', path)
2205
2207
 
2206
2208
    def test_posix_path_env_ascii(self):
2207
 
        self.overrideEnv('BZR_TEST_PATH', '/tmp')
2208
 
        home = osutils._posix_path_from_environ('BZR_TEST_PATH')
 
2209
        self.overrideEnv('BRZ_TEST_PATH', '/tmp')
 
2210
        home = osutils._posix_path_from_environ('BRZ_TEST_PATH')
2209
2211
        self.assertIsInstance(home, unicode)
2210
2212
        self.assertEqual(u'/tmp', home)
2211
2213
 
2212
2214
    def test_posix_path_env_unicode(self):
2213
2215
        self.requireFeature(features.ByteStringNamedFilesystem)
2214
 
        self.overrideEnv('BZR_TEST_PATH', '/home/\xa7test')
 
2216
        self.overrideEnv('BRZ_TEST_PATH', '/home/\xa7test')
2215
2217
        self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
2216
2218
        self.assertEqual(u'/home/\xa7test',
2217
 
            osutils._posix_path_from_environ('BZR_TEST_PATH'))
 
2219
            osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2218
2220
        osutils._fs_enc = "iso8859-5"
2219
2221
        self.assertEqual(u'/home/\u0407test',
2220
 
            osutils._posix_path_from_environ('BZR_TEST_PATH'))
 
2222
            osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2221
2223
        osutils._fs_enc = "utf-8"
2222
2224
        self.assertRaises(errors.BadFilenameEncoding,
2223
 
            osutils._posix_path_from_environ, 'BZR_TEST_PATH')
 
2225
            osutils._posix_path_from_environ, 'BRZ_TEST_PATH')
2224
2226
 
2225
2227
 
2226
2228
class TestGetHomeDir(tests.TestCase):