← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-08-03 07:15:11 UTC
  • mfrom: (4580.1.2 408199-check-2a)
  • Revision ID: pqm@pqm.ubuntu.com-20090803071511-dwb041qzak0vjzdk
(mbp) check blackbox tests now handle the root being included in the
        file-id count

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
27
27
 
28
28
from bzrlib import (
29
29
    errors,
30
 
    lazy_regex,
31
30
    osutils,
32
 
    symbol_versioning,
33
31
    tests,
34
 
    trace,
35
32
    win32utils,
36
33
    )
37
34
from bzrlib.tests import (
38
 
    features,
39
35
    file_utils,
40
36
    test__walkdirs_win32,
41
37
    )
56
52
 
57
53
UTF8DirReaderFeature = _UTF8DirReaderFeature()
58
54
 
59
 
term_ios_feature = tests.ModuleAvailableFeature('termios')
60
 
 
61
55
 
62
56
def _already_unicode(s):
63
57
    return s
64
58
 
65
59
 
 
60
def _fs_enc_to_unicode(s):
 
61
    return s.decode(osutils._fs_enc)
 
62
 
 
63
 
66
64
def _utf8_to_unicode(s):
67
65
    return s.decode('UTF-8')
68
66
 
85
83
                          dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
86
84
                               _native_to_unicode=_utf8_to_unicode)))
87
85
 
88
 
    if test__walkdirs_win32.win32_readdir_feature.available():
 
86
    if test__walkdirs_win32.Win32ReadDirFeature.available():
89
87
        try:
90
88
            from bzrlib import _walkdirs_win32
 
89
            # TODO: check on windows, it may be that we need to use/add
 
90
            # safe_unicode instead of _fs_enc_to_unicode
91
91
            scenarios.append(
92
92
                ('win32',
93
93
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
94
 
                      _native_to_unicode=_already_unicode)))
 
94
                      _native_to_unicode=_fs_enc_to_unicode)))
95
95
        except ImportError:
96
96
            pass
97
97
    return scenarios
125
125
 
126
126
class TestRename(tests.TestCaseInTempDir):
127
127
 
128
 
    def create_file(self, filename, content):
129
 
        f = open(filename, 'wb')
130
 
        try:
131
 
            f.write(content)
132
 
        finally:
133
 
            f.close()
134
 
 
135
 
    def _fancy_rename(self, a, b):
136
 
        osutils.fancy_rename(a, b, rename_func=os.rename,
137
 
                             unlink_func=os.unlink)
138
 
 
139
128
    def test_fancy_rename(self):
140
129
        # This should work everywhere
141
 
        self.create_file('a', 'something in a\n')
142
 
        self._fancy_rename('a', 'b')
 
130
        def rename(a, b):
 
131
            osutils.fancy_rename(a, b,
 
132
                    rename_func=os.rename,
 
133
                    unlink_func=os.unlink)
 
134
 
 
135
        open('a', 'wb').write('something in a\n')
 
136
        rename('a', 'b')
143
137
        self.failIfExists('a')
144
138
        self.failUnlessExists('b')
145
139
        self.check_file_contents('b', 'something in a\n')
146
140
 
147
 
        self.create_file('a', 'new something in a\n')
148
 
        self._fancy_rename('b', 'a')
 
141
        open('a', 'wb').write('new something in a\n')
 
142
        rename('b', 'a')
149
143
 
150
144
        self.check_file_contents('a', 'something in a\n')
151
145
 
152
 
    def test_fancy_rename_fails_source_missing(self):
153
 
        # An exception should be raised, and the target should be left in place
154
 
        self.create_file('target', 'data in target\n')
155
 
        self.assertRaises((IOError, OSError), self._fancy_rename,
156
 
                          'missingsource', 'target')
157
 
        self.failUnlessExists('target')
158
 
        self.check_file_contents('target', 'data in target\n')
159
 
 
160
 
    def test_fancy_rename_fails_if_source_and_target_missing(self):
161
 
        self.assertRaises((IOError, OSError), self._fancy_rename,
162
 
                          'missingsource', 'missingtarget')
163
 
 
164
146
    def test_rename(self):
165
147
        # Rename should be semi-atomic on all platforms
166
 
        self.create_file('a', 'something in a\n')
 
148
        open('a', 'wb').write('something in a\n')
167
149
        osutils.rename('a', 'b')
168
150
        self.failIfExists('a')
169
151
        self.failUnlessExists('b')
170
152
        self.check_file_contents('b', 'something in a\n')
171
153
 
172
 
        self.create_file('a', 'new something in a\n')
 
154
        open('a', 'wb').write('new something in a\n')
173
155
        osutils.rename('b', 'a')
174
156
 
175
157
        self.check_file_contents('a', 'something in a\n')
312
294
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
313
295
        self.assertEqual("@", osutils.kind_marker("symlink"))
314
296
        self.assertEqual("+", osutils.kind_marker("tree-reference"))
315
 
        self.assertEqual("", osutils.kind_marker("fifo"))
316
 
        self.assertEqual("", osutils.kind_marker("socket"))
317
 
        self.assertEqual("", osutils.kind_marker("unknown"))
 
297
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
318
298
 
319
299
 
320
300
class TestUmask(tests.TestCaseInTempDir):
385
365
        # Instead blackbox.test_locale should check for localized
386
366
        # dates once they do occur in output strings.
387
367
 
388
 
    def test_format_date_with_offset_in_original_timezone(self):
389
 
        self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
390
 
            osutils.format_date_with_offset_in_original_timezone(0))
391
 
        self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
392
 
            osutils.format_date_with_offset_in_original_timezone(100000))
393
 
        self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
394
 
            osutils.format_date_with_offset_in_original_timezone(100000, 7200))
395
 
 
396
368
    def test_local_time_offset(self):
397
369
        """Test that local_time_offset() returns a sane value."""
398
370
        offset = osutils.local_time_offset()
474
446
    def test_canonical_relpath_simple(self):
475
447
        f = file('MixedCaseName', 'w')
476
448
        f.close()
477
 
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
 
449
        # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
450
        real_base_dir = osutils.realpath(self.test_base_dir)
 
451
        actual = osutils.canonical_relpath(real_base_dir, 'mixedcasename')
478
452
        self.failUnlessEqual('work/MixedCaseName', actual)
479
453
 
480
454
    def test_canonical_relpath_missing_tail(self):
481
455
        os.mkdir('MixedCaseParent')
482
 
        actual = osutils.canonical_relpath(self.test_base_dir,
 
456
        # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
457
        real_base_dir = osutils.realpath(self.test_base_dir)
 
458
        actual = osutils.canonical_relpath(real_base_dir,
483
459
                                           'mixedcaseparent/nochild')
484
460
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
485
461
 
486
462
 
487
 
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
488
 
 
489
 
    def assertRelpath(self, expected, base, path):
490
 
        actual = osutils._cicp_canonical_relpath(base, path)
491
 
        self.assertEqual(expected, actual)
492
 
 
493
 
    def test_simple(self):
494
 
        self.build_tree(['MixedCaseName'])
495
 
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
496
 
        self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
497
 
 
498
 
    def test_subdir_missing_tail(self):
499
 
        self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
500
 
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
501
 
        self.assertRelpath('MixedCaseParent/a_child', base,
502
 
                           'MixedCaseParent/a_child')
503
 
        self.assertRelpath('MixedCaseParent/a_child', base,
504
 
                           'MixedCaseParent/A_Child')
505
 
        self.assertRelpath('MixedCaseParent/not_child', base,
506
 
                           'MixedCaseParent/not_child')
507
 
 
508
 
    def test_at_root_slash(self):
509
 
        # We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
510
 
        # check...
511
 
        if osutils.MIN_ABS_PATHLENGTH > 1:
512
 
            raise tests.TestSkipped('relpath requires %d chars'
513
 
                                    % osutils.MIN_ABS_PATHLENGTH)
514
 
        self.assertRelpath('foo', '/', '/foo')
515
 
 
516
 
    def test_at_root_drive(self):
517
 
        if sys.platform != 'win32':
518
 
            raise tests.TestNotApplicable('we can only test drive-letter relative'
519
 
                                          ' paths on Windows where we have drive'
520
 
                                          ' letters.')
521
 
        # see bug #322807
522
 
        # The specific issue is that when at the root of a drive, 'abspath'
523
 
        # returns "C:/" or just "/". However, the code assumes that abspath
524
 
        # always returns something like "C:/foo" or "/foo" (no trailing slash).
525
 
        self.assertRelpath('foo', 'C:/', 'C:/foo')
526
 
        self.assertRelpath('foo', 'X:/', 'X:/foo')
527
 
        self.assertRelpath('foo', 'X:/', 'X://foo')
528
 
 
529
 
 
530
463
class TestPumpFile(tests.TestCase):
531
464
    """Test pumpfile method."""
532
465
 
863
796
        self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
864
797
        # relative path
865
798
        cwd = osutils.getcwd().rstrip('/')
866
 
        drive = osutils.ntpath.splitdrive(cwd)[0]
 
799
        drive = osutils._nt_splitdrive(cwd)[0]
867
800
        self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
868
801
        self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
869
802
        # unicode path
994
927
 
995
928
    def test_osutils_binding(self):
996
929
        from bzrlib.tests import test__chunks_to_lines
997
 
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
 
930
        if test__chunks_to_lines.CompiledChunksToLinesFeature.available():
998
931
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
999
932
        else:
1000
933
            from bzrlib._chunks_to_lines_py import chunks_to_lines
1066
999
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
1067
1000
 
1068
1001
    def test_walkdirs_os_error(self):
1069
 
        # <https://bugs.launchpad.net/bzr/+bug/338653>
 
1002
        # <https://bugs.edge.launchpad.net/bzr/+bug/338653>
1070
1003
        # Pyrex readdir didn't raise useful messages if it had an error
1071
1004
        # reading the directory
1072
1005
        if sys.platform == 'win32':
1085
1018
        # Ensure the message contains the file name
1086
1019
        self.assertContainsRe(str(e), "\./test-unreadable")
1087
1020
 
1088
 
 
1089
 
    def test_walkdirs_encoding_error(self):
1090
 
        # <https://bugs.launchpad.net/bzr/+bug/488519>
1091
 
        # walkdirs didn't raise a useful message when the filenames
1092
 
        # are not using the filesystem's encoding
1093
 
 
1094
 
        # require a bytestring based filesystem
1095
 
        self.requireFeature(tests.ByteStringNamedFilesystem)
1096
 
 
1097
 
        tree = [
1098
 
            '.bzr',
1099
 
            '0file',
1100
 
            '1dir/',
1101
 
            '1dir/0file',
1102
 
            '1dir/1dir/',
1103
 
            '1file'
1104
 
            ]
1105
 
 
1106
 
        self.build_tree(tree)
1107
 
 
1108
 
        # rename the 1file to a latin-1 filename
1109
 
        os.rename("./1file", "\xe8file")
1110
 
 
1111
 
        self._save_platform_info()
1112
 
        win32utils.winver = None # Avoid the win32 detection code
1113
 
        osutils._fs_enc = 'UTF-8'
1114
 
 
1115
 
        # this should raise on error
1116
 
        def attempt():
1117
 
            for dirdetail, dirblock in osutils.walkdirs('.'):
1118
 
                pass
1119
 
 
1120
 
        self.assertRaises(errors.BadFilenameEncoding, attempt)
1121
 
 
1122
1021
    def test__walkdirs_utf8(self):
1123
1022
        tree = [
1124
1023
            '.bzr',
1174
1073
            dirblock[:] = new_dirblock
1175
1074
 
1176
1075
    def _save_platform_info(self):
1177
 
        self.overrideAttr(win32utils, 'winver')
1178
 
        self.overrideAttr(osutils, '_fs_enc')
1179
 
        self.overrideAttr(osutils, '_selected_dir_reader')
 
1076
        cur_winver = win32utils.winver
 
1077
        cur_fs_enc = osutils._fs_enc
 
1078
        cur_dir_reader = osutils._selected_dir_reader
 
1079
        def restore():
 
1080
            win32utils.winver = cur_winver
 
1081
            osutils._fs_enc = cur_fs_enc
 
1082
            osutils._selected_dir_reader = cur_dir_reader
 
1083
        self.addCleanup(restore)
1180
1084
 
1181
1085
    def assertDirReaderIs(self, expected):
1182
1086
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
1215
1119
 
1216
1120
    def test_force_walkdirs_utf8_nt(self):
1217
1121
        # Disabled because the thunk of the whole walkdirs api is disabled.
1218
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1122
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1219
1123
        self._save_platform_info()
1220
1124
        win32utils.winver = 'Windows NT'
1221
1125
        from bzrlib._walkdirs_win32 import Win32ReadDir
1222
1126
        self.assertDirReaderIs(Win32ReadDir)
1223
1127
 
1224
1128
    def test_force_walkdirs_utf8_98(self):
1225
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1129
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1226
1130
        self._save_platform_info()
1227
1131
        win32utils.winver = 'Windows 98'
1228
1132
        self.assertDirReaderIs(osutils.UnicodeDirReader)
1379
1283
        self.assertEqual(expected_dirblocks, result)
1380
1284
 
1381
1285
    def test__walkdirs_utf8_win32readdir(self):
1382
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1286
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1383
1287
        self.requireFeature(tests.UnicodeFilenameFeature)
1384
1288
        from bzrlib._walkdirs_win32 import Win32ReadDir
1385
1289
        self._save_platform_info()
1436
1340
 
1437
1341
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1438
1342
        """make sure our Stat values are valid"""
1439
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1343
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1440
1344
        self.requireFeature(tests.UnicodeFilenameFeature)
1441
1345
        from bzrlib._walkdirs_win32 import Win32ReadDir
1442
1346
        name0u = u'0file-\xb6'
1460
1364
 
1461
1365
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1462
1366
        """make sure our Stat values are valid"""
1463
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1367
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1464
1368
        self.requireFeature(tests.UnicodeFilenameFeature)
1465
1369
        from bzrlib._walkdirs_win32 import Win32ReadDir
1466
1370
        name0u = u'0dir-\u062c\u0648'
1615
1519
        def cleanup():
1616
1520
            if 'BZR_TEST_ENV_VAR' in os.environ:
1617
1521
                del os.environ['BZR_TEST_ENV_VAR']
 
1522
 
1618
1523
        self.addCleanup(cleanup)
1619
1524
 
1620
1525
    def test_set(self):
1668
1573
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
1669
1574
        self.build_tree_contents([('foo', text)])
1670
1575
        expected_sha = osutils.sha_string(text)
1671
 
        f = open('foo', 'rb')
 
1576
        f = open('foo')
1672
1577
        self.addCleanup(f.close)
1673
1578
        size, sha = osutils.size_sha_file(f)
1674
1579
        self.assertEqual(38, size)
1707
1612
 
1708
1613
class TestReCompile(tests.TestCase):
1709
1614
 
1710
 
    def _deprecated_re_compile_checked(self, *args, **kwargs):
1711
 
        return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
1712
 
            osutils.re_compile_checked, *args, **kwargs)
1713
 
 
1714
1615
    def test_re_compile_checked(self):
1715
 
        r = self._deprecated_re_compile_checked(r'A*', re.IGNORECASE)
 
1616
        r = osutils.re_compile_checked(r'A*', re.IGNORECASE)
1716
1617
        self.assertTrue(r.match('aaaa'))
1717
1618
        self.assertTrue(r.match('aAaA'))
1718
1619
 
1719
1620
    def test_re_compile_checked_error(self):
1720
1621
        # like https://bugs.launchpad.net/bzr/+bug/251352
1721
 
 
1722
 
        # Due to possible test isolation error, re.compile is not lazy at
1723
 
        # this point. We re-install lazy compile.
1724
 
        lazy_regex.install_lazy_compile()
1725
1622
        err = self.assertRaises(
1726
1623
            errors.BzrCommandError,
1727
 
            self._deprecated_re_compile_checked, '*', re.IGNORECASE, 'test case')
 
1624
            osutils.re_compile_checked, '*', re.IGNORECASE, 'test case')
1728
1625
        self.assertEqual(
1729
 
            'Invalid regular expression in test case: '
1730
 
            '"*" nothing to repeat',
 
1626
            "Invalid regular expression in test case: '*': "
 
1627
            "nothing to repeat",
1731
1628
            str(err))
1732
1629
 
1733
1630
 
1739
1636
 
1740
1637
    def setUp(self):
1741
1638
        tests.TestCaseInTempDir.setUp(self)
1742
 
        self.overrideAttr(osutils,
1743
 
                          '_selected_dir_reader', self._dir_reader_class())
 
1639
 
 
1640
        # Save platform specific info and reset it
 
1641
        cur_dir_reader = osutils._selected_dir_reader
 
1642
 
 
1643
        def restore():
 
1644
            osutils._selected_dir_reader = cur_dir_reader
 
1645
        self.addCleanup(restore)
 
1646
 
 
1647
        osutils._selected_dir_reader = self._dir_reader_class()
1744
1648
 
1745
1649
    def _get_ascii_tree(self):
1746
1650
        tree = [
1891
1795
 
1892
1796
class TestConcurrency(tests.TestCase):
1893
1797
 
1894
 
    def setUp(self):
1895
 
        super(TestConcurrency, self).setUp()
1896
 
        self.overrideAttr(osutils, '_cached_local_concurrency')
1897
 
 
1898
1798
    def test_local_concurrency(self):
1899
1799
        concurrency = osutils.local_concurrency()
1900
1800
        self.assertIsInstance(concurrency, int)
1901
 
 
1902
 
    def test_local_concurrency_environment_variable(self):
1903
 
        os.environ['BZR_CONCURRENCY'] = '2'
1904
 
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1905
 
        os.environ['BZR_CONCURRENCY'] = '3'
1906
 
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1907
 
        os.environ['BZR_CONCURRENCY'] = 'foo'
1908
 
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1909
 
 
1910
 
    def test_option_concurrency(self):
1911
 
        os.environ['BZR_CONCURRENCY'] = '1'
1912
 
        self.run_bzr('rocks --concurrency 42')
1913
 
        # Command line overrides envrionment variable
1914
 
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1915
 
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1916
 
 
1917
 
 
1918
 
class TestFailedToLoadExtension(tests.TestCase):
1919
 
 
1920
 
    def _try_loading(self):
1921
 
        try:
1922
 
            import bzrlib._fictional_extension_py
1923
 
        except ImportError, e:
1924
 
            osutils.failed_to_load_extension(e)
1925
 
            return True
1926
 
 
1927
 
    def setUp(self):
1928
 
        super(TestFailedToLoadExtension, self).setUp()
1929
 
        self.overrideAttr(osutils, '_extension_load_failures', [])
1930
 
 
1931
 
    def test_failure_to_load(self):
1932
 
        self._try_loading()
1933
 
        self.assertLength(1, osutils._extension_load_failures)
1934
 
        self.assertEquals(osutils._extension_load_failures[0],
1935
 
            "No module named _fictional_extension_py")
1936
 
 
1937
 
    def test_report_extension_load_failures_no_warning(self):
1938
 
        self.assertTrue(self._try_loading())
1939
 
        warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
1940
 
        # it used to give a Python warning; it no longer does
1941
 
        self.assertLength(0, warnings)
1942
 
 
1943
 
    def test_report_extension_load_failures_message(self):
1944
 
        log = StringIO()
1945
 
        trace.push_log_file(log)
1946
 
        self.assertTrue(self._try_loading())
1947
 
        osutils.report_extension_load_failures()
1948
 
        self.assertContainsRe(
1949
 
            log.getvalue(),
1950
 
            r"bzr: warning: some compiled extensions could not be loaded; "
1951
 
            "see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1952
 
            )
1953
 
 
1954
 
 
1955
 
class TestTerminalWidth(tests.TestCase):
1956
 
 
1957
 
    def setUp(self):
1958
 
        tests.TestCase.setUp(self)
1959
 
        self._orig_terminal_size_state = osutils._terminal_size_state
1960
 
        self._orig_first_terminal_size = osutils._first_terminal_size
1961
 
        self.addCleanup(self.restore_osutils_globals)
1962
 
        osutils._terminal_size_state = 'no_data'
1963
 
        osutils._first_terminal_size = None
1964
 
 
1965
 
    def restore_osutils_globals(self):
1966
 
        osutils._terminal_size_state = self._orig_terminal_size_state
1967
 
        osutils._first_terminal_size = self._orig_first_terminal_size
1968
 
 
1969
 
    def replace_stdout(self, new):
1970
 
        self.overrideAttr(sys, 'stdout', new)
1971
 
 
1972
 
    def replace__terminal_size(self, new):
1973
 
        self.overrideAttr(osutils, '_terminal_size', new)
1974
 
 
1975
 
    def set_fake_tty(self):
1976
 
 
1977
 
        class I_am_a_tty(object):
1978
 
            def isatty(self):
1979
 
                return True
1980
 
 
1981
 
        self.replace_stdout(I_am_a_tty())
1982
 
 
1983
 
    def test_default_values(self):
1984
 
        self.assertEqual(80, osutils.default_terminal_width)
1985
 
 
1986
 
    def test_defaults_to_BZR_COLUMNS(self):
1987
 
        # BZR_COLUMNS is set by the test framework
1988
 
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
1989
 
        os.environ['BZR_COLUMNS'] = '12'
1990
 
        self.assertEqual(12, osutils.terminal_width())
1991
 
 
1992
 
    def test_falls_back_to_COLUMNS(self):
1993
 
        del os.environ['BZR_COLUMNS']
1994
 
        self.assertNotEqual('42', os.environ['COLUMNS'])
1995
 
        self.set_fake_tty()
1996
 
        os.environ['COLUMNS'] = '42'
1997
 
        self.assertEqual(42, osutils.terminal_width())
1998
 
 
1999
 
    def test_tty_default_without_columns(self):
2000
 
        del os.environ['BZR_COLUMNS']
2001
 
        del os.environ['COLUMNS']
2002
 
 
2003
 
        def terminal_size(w, h):
2004
 
            return 42, 42
2005
 
 
2006
 
        self.set_fake_tty()
2007
 
        # We need to override the osutils definition as it depends on the
2008
 
        # running environment that we can't control (PQM running without a
2009
 
        # controlling terminal is one example).
2010
 
        self.replace__terminal_size(terminal_size)
2011
 
        self.assertEqual(42, osutils.terminal_width())
2012
 
 
2013
 
    def test_non_tty_default_without_columns(self):
2014
 
        del os.environ['BZR_COLUMNS']
2015
 
        del os.environ['COLUMNS']
2016
 
        self.replace_stdout(None)
2017
 
        self.assertEqual(None, osutils.terminal_width())
2018
 
 
2019
 
    def test_no_TIOCGWINSZ(self):
2020
 
        self.requireFeature(term_ios_feature)
2021
 
        termios = term_ios_feature.module
2022
 
        # bug 63539 is about a termios without TIOCGWINSZ attribute
2023
 
        try:
2024
 
            orig = termios.TIOCGWINSZ
2025
 
        except AttributeError:
2026
 
            # We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
2027
 
            pass
2028
 
        else:
2029
 
            self.overrideAttr(termios, 'TIOCGWINSZ')
2030
 
            del termios.TIOCGWINSZ
2031
 
        del os.environ['BZR_COLUMNS']
2032
 
        del os.environ['COLUMNS']
2033
 
        # Whatever the result is, if we don't raise an exception, it's ok.
2034
 
        osutils.terminal_width()
2035
 
 
2036
 
class TestCreationOps(tests.TestCaseInTempDir):
2037
 
    _test_needs_features = [features.chown_feature]
2038
 
 
2039
 
    def setUp(self):
2040
 
        tests.TestCaseInTempDir.setUp(self)
2041
 
        self.overrideAttr(os, 'chown', self._dummy_chown)
2042
 
 
2043
 
        # params set by call to _dummy_chown
2044
 
        self.path = self.uid = self.gid = None
2045
 
 
2046
 
    def _dummy_chown(self, path, uid, gid):
2047
 
        self.path, self.uid, self.gid = path, uid, gid
2048
 
 
2049
 
    def test_copy_ownership_from_path(self):
2050
 
        """copy_ownership_from_path test with specified src."""
2051
 
        ownsrc = '/'
2052
 
        f = open('test_file', 'wt')
2053
 
        osutils.copy_ownership_from_path('test_file', ownsrc)
2054
 
 
2055
 
        s = os.stat(ownsrc)
2056
 
        self.assertEquals(self.path, 'test_file')
2057
 
        self.assertEquals(self.uid, s.st_uid)
2058
 
        self.assertEquals(self.gid, s.st_gid)
2059
 
 
2060
 
    def test_copy_ownership_nonesrc(self):
2061
 
        """copy_ownership_from_path test with src=None."""
2062
 
        f = open('test_file', 'wt')
2063
 
        # should use parent dir for permissions
2064
 
        osutils.copy_ownership_from_path('test_file')
2065
 
 
2066
 
        s = os.stat('..')
2067
 
        self.assertEquals(self.path, 'test_file')
2068
 
        self.assertEquals(self.uid, s.st_uid)
2069
 
        self.assertEquals(self.gid, s.st_gid)
2070
 
 
2071
 
class TestGetuserUnicode(tests.TestCase):
2072
 
 
2073
 
    def test_ascii_user(self):
2074
 
        osutils.set_or_unset_env('LOGNAME', 'jrandom')
2075
 
        self.assertEqual(u'jrandom', osutils.getuser_unicode())
2076
 
 
2077
 
    def test_unicode_user(self):
2078
 
        ue = osutils.get_user_encoding()
2079
 
        osutils.set_or_unset_env('LOGNAME', u'jrandom\xb6'.encode(ue))
2080
 
        self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())