← 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: Andrew Bennetts
  • Date: 2010-10-13 06:14:37 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101013061437-2e2m9gro1eusnbb8
Tweaks to the sphinx build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
1
 
# Copyright (C) 2005-2011 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
20
20
import errno
21
21
import os
22
22
import re
23
 
import select
24
23
import socket
25
24
import sys
26
25
import time
39
38
    file_utils,
40
39
    test__walkdirs_win32,
41
40
    )
42
 
from bzrlib.tests.scenarios import load_tests_apply_scenarios
43
 
 
44
 
 
45
 
class _UTF8DirReaderFeature(features.Feature):
 
41
 
 
42
 
 
43
class _UTF8DirReaderFeature(tests.Feature):
46
44
 
47
45
    def _probe(self):
48
46
        try:
55
53
    def feature_name(self):
56
54
        return 'bzrlib._readdir_pyx'
57
55
 
58
 
UTF8DirReaderFeature = features.ModuleAvailableFeature('bzrlib._readdir_pyx')
 
56
UTF8DirReaderFeature = _UTF8DirReaderFeature()
59
57
 
60
 
term_ios_feature = features.ModuleAvailableFeature('termios')
 
58
term_ios_feature = tests.ModuleAvailableFeature('termios')
61
59
 
62
60
 
63
61
def _already_unicode(s):
98
96
    return scenarios
99
97
 
100
98
 
101
 
load_tests = load_tests_apply_scenarios
 
99
def load_tests(basic_tests, module, loader):
 
100
    suite = loader.suiteClass()
 
101
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
 
102
        basic_tests, tests.condition_isinstance(TestDirReader))
 
103
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios(), suite)
 
104
    suite.addTest(remaining_tests)
 
105
    return suite
102
106
 
103
107
 
104
108
class TestContainsWhitespace(tests.TestCase):
105
109
 
106
110
    def test_contains_whitespace(self):
107
 
        self.assertTrue(osutils.contains_whitespace(u' '))
108
 
        self.assertTrue(osutils.contains_whitespace(u'hello there'))
109
 
        self.assertTrue(osutils.contains_whitespace(u'hellothere\n'))
110
 
        self.assertTrue(osutils.contains_whitespace(u'hello\nthere'))
111
 
        self.assertTrue(osutils.contains_whitespace(u'hello\rthere'))
112
 
        self.assertTrue(osutils.contains_whitespace(u'hello\tthere'))
 
111
        self.failUnless(osutils.contains_whitespace(u' '))
 
112
        self.failUnless(osutils.contains_whitespace(u'hello there'))
 
113
        self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
 
114
        self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
 
115
        self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
 
116
        self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
113
117
 
114
118
        # \xa0 is "Non-breaking-space" which on some python locales thinks it
115
119
        # is whitespace, but we do not.
116
 
        self.assertFalse(osutils.contains_whitespace(u''))
117
 
        self.assertFalse(osutils.contains_whitespace(u'hellothere'))
118
 
        self.assertFalse(osutils.contains_whitespace(u'hello\xa0there'))
 
120
        self.failIf(osutils.contains_whitespace(u''))
 
121
        self.failIf(osutils.contains_whitespace(u'hellothere'))
 
122
        self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
119
123
 
120
124
 
121
125
class TestRename(tests.TestCaseInTempDir):
135
139
        # This should work everywhere
136
140
        self.create_file('a', 'something in a\n')
137
141
        self._fancy_rename('a', 'b')
138
 
        self.assertPathDoesNotExist('a')
139
 
        self.assertPathExists('b')
 
142
        self.failIfExists('a')
 
143
        self.failUnlessExists('b')
140
144
        self.check_file_contents('b', 'something in a\n')
141
145
 
142
146
        self.create_file('a', 'new something in a\n')
149
153
        self.create_file('target', 'data in target\n')
150
154
        self.assertRaises((IOError, OSError), self._fancy_rename,
151
155
                          'missingsource', 'target')
152
 
        self.assertPathExists('target')
 
156
        self.failUnlessExists('target')
153
157
        self.check_file_contents('target', 'data in target\n')
154
158
 
155
159
    def test_fancy_rename_fails_if_source_and_target_missing(self):
160
164
        # Rename should be semi-atomic on all platforms
161
165
        self.create_file('a', 'something in a\n')
162
166
        osutils.rename('a', 'b')
163
 
        self.assertPathDoesNotExist('a')
164
 
        self.assertPathExists('b')
 
167
        self.failIfExists('a')
 
168
        self.failUnlessExists('b')
165
169
        self.check_file_contents('b', 'something in a\n')
166
170
 
167
171
        self.create_file('a', 'new something in a\n')
232
236
            self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
233
237
 
234
238
 
235
 
class TestLstat(tests.TestCaseInTempDir):
236
 
 
237
 
    def test_lstat_matches_fstat(self):
238
 
        # On Windows, lstat and fstat don't always agree, primarily in the
239
 
        # 'st_ino' and 'st_dev' fields. So we force them to be '0' in our
240
 
        # custom implementation.
241
 
        if sys.platform == 'win32':
242
 
            # We only have special lstat/fstat if we have the extension.
243
 
            # Without it, we may end up re-reading content when we don't have
244
 
            # to, but otherwise it doesn't effect correctness.
245
 
            self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
246
 
        f = open('test-file.txt', 'wb')
247
 
        self.addCleanup(f.close)
248
 
        f.write('some content\n')
249
 
        f.flush()
250
 
        self.assertEqualStat(osutils.fstat(f.fileno()),
251
 
                             osutils.lstat('test-file.txt'))
252
 
 
253
 
 
254
239
class TestRmTree(tests.TestCaseInTempDir):
255
240
 
256
241
    def test_rmtree(self):
268
253
 
269
254
        osutils.rmtree('dir')
270
255
 
271
 
        self.assertPathDoesNotExist('dir/file')
272
 
        self.assertPathDoesNotExist('dir')
 
256
        self.failIfExists('dir/file')
 
257
        self.failIfExists('dir')
273
258
 
274
259
 
275
260
class TestDeleteAny(tests.TestCaseInTempDir):
430
415
class TestLinks(tests.TestCaseInTempDir):
431
416
 
432
417
    def test_dereference_path(self):
433
 
        self.requireFeature(features.SymlinkFeature)
 
418
        self.requireFeature(tests.SymlinkFeature)
434
419
        cwd = osutils.realpath('.')
435
420
        os.mkdir('bar')
436
421
        bar_path = osutils.pathjoin(cwd, 'bar')
483
468
 
484
469
class TestCanonicalRelPath(tests.TestCaseInTempDir):
485
470
 
486
 
    _test_needs_features = [features.CaseInsCasePresFilenameFeature]
 
471
    _test_needs_features = [tests.CaseInsCasePresFilenameFeature]
487
472
 
488
473
    def test_canonical_relpath_simple(self):
489
474
        f = file('MixedCaseName', 'w')
490
475
        f.close()
491
476
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
492
 
        self.assertEqual('work/MixedCaseName', actual)
 
477
        self.failUnlessEqual('work/MixedCaseName', actual)
493
478
 
494
479
    def test_canonical_relpath_missing_tail(self):
495
480
        os.mkdir('MixedCaseParent')
496
481
        actual = osutils.canonical_relpath(self.test_base_dir,
497
482
                                           'mixedcaseparent/nochild')
498
 
        self.assertEqual('work/MixedCaseParent/nochild', actual)
 
483
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
499
484
 
500
485
 
501
486
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
819
804
        self.assertEqual(None, osutils.safe_file_id(None))
820
805
 
821
806
 
822
 
class TestPosixFuncs(tests.TestCase):
823
 
    """Test that the posix version of normpath returns an appropriate path
824
 
       when used with 2 leading slashes."""
825
 
 
826
 
    def test_normpath(self):
827
 
        self.assertEqual('/etc/shadow', osutils._posix_normpath('/etc/shadow'))
828
 
        self.assertEqual('/etc/shadow', osutils._posix_normpath('//etc/shadow'))
829
 
        self.assertEqual('/etc/shadow', osutils._posix_normpath('///etc/shadow'))
830
 
 
831
 
 
832
807
class TestWin32Funcs(tests.TestCase):
833
808
    """Test that _win32 versions of os utilities return appropriate paths."""
834
809
 
899
874
    """Test win32 functions that create files."""
900
875
 
901
876
    def test_getcwd(self):
902
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
877
        self.requireFeature(tests.UnicodeFilenameFeature)
903
878
        os.mkdir(u'mu-\xb5')
904
879
        os.chdir(u'mu-\xb5')
905
880
        # TODO: jam 20060427 This will probably fail on Mac OSX because
935
910
        b.close()
936
911
 
937
912
        osutils._win32_rename('b', 'a')
938
 
        self.assertPathExists('a')
939
 
        self.assertPathDoesNotExist('b')
 
913
        self.failUnlessExists('a')
 
914
        self.failIfExists('b')
940
915
        self.assertFileEqual('baz\n', 'a')
941
916
 
942
917
    def test_rename_missing_file(self):
995
970
    """Test mac special functions that require directories."""
996
971
 
997
972
    def test_getcwd(self):
998
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
973
        self.requireFeature(tests.UnicodeFilenameFeature)
999
974
        os.mkdir(u'B\xe5gfors')
1000
975
        os.chdir(u'B\xe5gfors')
1001
976
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
1002
977
 
1003
978
    def test_getcwd_nonnorm(self):
1004
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
979
        self.requireFeature(tests.UnicodeFilenameFeature)
1005
980
        # Test that _mac_getcwd() will normalize this path
1006
981
        os.mkdir(u'Ba\u030agfors')
1007
982
        os.chdir(u'Ba\u030agfors')
1117
1092
        # are not using the filesystem's encoding
1118
1093
 
1119
1094
        # require a bytestring based filesystem
1120
 
        self.requireFeature(features.ByteStringNamedFilesystem)
 
1095
        self.requireFeature(tests.ByteStringNamedFilesystem)
1121
1096
 
1122
1097
        tree = [
1123
1098
            '.bzr',
1132
1107
 
1133
1108
        # rename the 1file to a latin-1 filename
1134
1109
        os.rename("./1file", "\xe8file")
1135
 
        if "\xe8file" not in os.listdir("."):
1136
 
            self.skip("Lack filesystem that preserves arbitrary bytes")
1137
1110
 
1138
1111
        self._save_platform_info()
1139
1112
        win32utils.winver = None # Avoid the win32 detection code
1217
1190
        self.requireFeature(UTF8DirReaderFeature)
1218
1191
        self._save_platform_info()
1219
1192
        win32utils.winver = None # Avoid the win32 detection code
1220
 
        osutils._fs_enc = 'utf-8'
1221
 
        self.assertDirReaderIs(
1222
 
            UTF8DirReaderFeature.module.UTF8DirReader)
 
1193
        osutils._fs_enc = 'UTF-8'
 
1194
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1223
1195
 
1224
1196
    def test_force_walkdirs_utf8_fs_ascii(self):
1225
1197
        self.requireFeature(UTF8DirReaderFeature)
1226
1198
        self._save_platform_info()
1227
1199
        win32utils.winver = None # Avoid the win32 detection code
1228
 
        osutils._fs_enc = 'ascii'
1229
 
        self.assertDirReaderIs(
1230
 
            UTF8DirReaderFeature.module.UTF8DirReader)
 
1200
        osutils._fs_enc = 'US-ASCII'
 
1201
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
1202
 
 
1203
    def test_force_walkdirs_utf8_fs_ANSI(self):
 
1204
        self.requireFeature(UTF8DirReaderFeature)
 
1205
        self._save_platform_info()
 
1206
        win32utils.winver = None # Avoid the win32 detection code
 
1207
        osutils._fs_enc = 'ANSI_X3.4-1968'
 
1208
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1231
1209
 
1232
1210
    def test_force_walkdirs_utf8_fs_latin1(self):
1233
1211
        self._save_platform_info()
1234
1212
        win32utils.winver = None # Avoid the win32 detection code
1235
 
        osutils._fs_enc = 'iso-8859-1'
 
1213
        osutils._fs_enc = 'latin1'
1236
1214
        self.assertDirReaderIs(osutils.UnicodeDirReader)
1237
1215
 
1238
1216
    def test_force_walkdirs_utf8_nt(self):
1251
1229
 
1252
1230
    def test_unicode_walkdirs(self):
1253
1231
        """Walkdirs should always return unicode paths."""
1254
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1232
        self.requireFeature(tests.UnicodeFilenameFeature)
1255
1233
        name0 = u'0file-\xb6'
1256
1234
        name1 = u'1dir-\u062c\u0648'
1257
1235
        name2 = u'2file-\u0633'
1294
1272
 
1295
1273
        The abspath portion might be in unicode or utf-8
1296
1274
        """
1297
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1275
        self.requireFeature(tests.UnicodeFilenameFeature)
1298
1276
        name0 = u'0file-\xb6'
1299
1277
        name1 = u'1dir-\u062c\u0648'
1300
1278
        name2 = u'2file-\u0633'
1355
1333
 
1356
1334
        The abspath portion should be in unicode
1357
1335
        """
1358
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1336
        self.requireFeature(tests.UnicodeFilenameFeature)
1359
1337
        # Use the unicode reader. TODO: split into driver-and-driven unit
1360
1338
        # tests.
1361
1339
        self._save_platform_info()
1402
1380
 
1403
1381
    def test__walkdirs_utf8_win32readdir(self):
1404
1382
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1405
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1383
        self.requireFeature(tests.UnicodeFilenameFeature)
1406
1384
        from bzrlib._walkdirs_win32 import Win32ReadDir
1407
1385
        self._save_platform_info()
1408
1386
        osutils._selected_dir_reader = Win32ReadDir()
1459
1437
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1460
1438
        """make sure our Stat values are valid"""
1461
1439
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1462
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1440
        self.requireFeature(tests.UnicodeFilenameFeature)
1463
1441
        from bzrlib._walkdirs_win32 import Win32ReadDir
1464
1442
        name0u = u'0file-\xb6'
1465
1443
        name0 = name0u.encode('utf8')
1483
1461
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1484
1462
        """make sure our Stat values are valid"""
1485
1463
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1486
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1464
        self.requireFeature(tests.UnicodeFilenameFeature)
1487
1465
        from bzrlib._walkdirs_win32 import Win32ReadDir
1488
1466
        name0u = u'0dir-\u062c\u0648'
1489
1467
        name0 = name0u.encode('utf8')
1589
1567
        self.assertEqual(['c'], os.listdir('target/b'))
1590
1568
 
1591
1569
    def test_copy_tree_symlinks(self):
1592
 
        self.requireFeature(features.SymlinkFeature)
 
1570
        self.requireFeature(tests.SymlinkFeature)
1593
1571
        self.build_tree(['source/'])
1594
1572
        os.symlink('a/generic/path', 'source/lnk')
1595
1573
        osutils.copy_tree('source', 'target')
1620
1598
                          ('d', 'source/b', 'target/b'),
1621
1599
                          ('f', 'source/b/c', 'target/b/c'),
1622
1600
                         ], processed_files)
1623
 
        self.assertPathDoesNotExist('target')
 
1601
        self.failIfExists('target')
1624
1602
        if osutils.has_symlinks():
1625
1603
            self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1626
1604
 
1672
1650
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1673
1651
        self.assertEqual('foo', old)
1674
1652
        self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1675
 
        self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
 
1653
        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1676
1654
 
1677
1655
 
1678
1656
class TestSizeShaFile(tests.TestCaseInTempDir):
1755
1733
 
1756
1734
class TestDirReader(tests.TestCaseInTempDir):
1757
1735
 
1758
 
    scenarios = dir_reader_scenarios()
1759
 
 
1760
1736
    # Set by load_tests
1761
1737
    _dir_reader_class = None
1762
1738
    _native_to_unicode = None
1862
1838
        return filtered_dirblocks
1863
1839
 
1864
1840
    def test_walk_unicode_tree(self):
1865
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1841
        self.requireFeature(tests.UnicodeFilenameFeature)
1866
1842
        tree, expected_dirblocks = self._get_unicode_tree()
1867
1843
        self.build_tree(tree)
1868
1844
        result = list(osutils._walkdirs_utf8('.'))
1869
1845
        self.assertEqual(expected_dirblocks, self._filter_out(result))
1870
1846
 
1871
1847
    def test_symlink(self):
1872
 
        self.requireFeature(features.SymlinkFeature)
1873
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1848
        self.requireFeature(tests.SymlinkFeature)
 
1849
        self.requireFeature(tests.UnicodeFilenameFeature)
1874
1850
        target = u'target\N{Euro Sign}'
1875
1851
        link_name = u'l\N{Euro Sign}nk'
1876
1852
        os.symlink(target, link_name)
1894
1870
    But prior python versions failed to properly encode the passed unicode
1895
1871
    string.
1896
1872
    """
1897
 
    _test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]
 
1873
    _test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
1898
1874
 
1899
1875
    def setUp(self):
1900
1876
        super(tests.TestCaseInTempDir, self).setUp()
1903
1879
        os.symlink(self.target, self.link)
1904
1880
 
1905
1881
    def test_os_readlink_link_encoding(self):
1906
 
        self.assertEquals(self.target,  os.readlink(self.link))
 
1882
        if sys.version_info < (2, 6):
 
1883
            self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
 
1884
        else:
 
1885
            self.assertEquals(self.target,  os.readlink(self.link))
1907
1886
 
1908
1887
    def test_os_readlink_link_decoding(self):
1909
1888
        self.assertEquals(self.target.encode(osutils._fs_enc),
1921
1900
        self.assertIsInstance(concurrency, int)
1922
1901
 
1923
1902
    def test_local_concurrency_environment_variable(self):
1924
 
        self.overrideEnv('BZR_CONCURRENCY', '2')
 
1903
        os.environ['BZR_CONCURRENCY'] = '2'
1925
1904
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1926
 
        self.overrideEnv('BZR_CONCURRENCY', '3')
 
1905
        os.environ['BZR_CONCURRENCY'] = '3'
1927
1906
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1928
 
        self.overrideEnv('BZR_CONCURRENCY', 'foo')
 
1907
        os.environ['BZR_CONCURRENCY'] = 'foo'
1929
1908
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1930
1909
 
1931
1910
    def test_option_concurrency(self):
1932
 
        self.overrideEnv('BZR_CONCURRENCY', '1')
 
1911
        os.environ['BZR_CONCURRENCY'] = '1'
1933
1912
        self.run_bzr('rocks --concurrency 42')
1934
 
        # Command line overrides environment variable
 
1913
        # Command line overrides envrionment variable
1935
1914
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1936
1915
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1937
1916
 
2007
1986
    def test_defaults_to_BZR_COLUMNS(self):
2008
1987
        # BZR_COLUMNS is set by the test framework
2009
1988
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
2010
 
        self.overrideEnv('BZR_COLUMNS', '12')
 
1989
        os.environ['BZR_COLUMNS'] = '12'
2011
1990
        self.assertEqual(12, osutils.terminal_width())
2012
1991
 
2013
 
    def test_BZR_COLUMNS_0_no_limit(self):
2014
 
        self.overrideEnv('BZR_COLUMNS', '0')
2015
 
        self.assertEqual(None, osutils.terminal_width())
2016
 
 
2017
1992
    def test_falls_back_to_COLUMNS(self):
2018
 
        self.overrideEnv('BZR_COLUMNS', None)
 
1993
        del os.environ['BZR_COLUMNS']
2019
1994
        self.assertNotEqual('42', os.environ['COLUMNS'])
2020
1995
        self.set_fake_tty()
2021
 
        self.overrideEnv('COLUMNS', '42')
 
1996
        os.environ['COLUMNS'] = '42'
2022
1997
        self.assertEqual(42, osutils.terminal_width())
2023
1998
 
2024
1999
    def test_tty_default_without_columns(self):
2025
 
        self.overrideEnv('BZR_COLUMNS', None)
2026
 
        self.overrideEnv('COLUMNS', None)
 
2000
        del os.environ['BZR_COLUMNS']
 
2001
        del os.environ['COLUMNS']
2027
2002
 
2028
2003
        def terminal_size(w, h):
2029
2004
            return 42, 42
2036
2011
        self.assertEqual(42, osutils.terminal_width())
2037
2012
 
2038
2013
    def test_non_tty_default_without_columns(self):
2039
 
        self.overrideEnv('BZR_COLUMNS', None)
2040
 
        self.overrideEnv('COLUMNS', None)
 
2014
        del os.environ['BZR_COLUMNS']
 
2015
        del os.environ['COLUMNS']
2041
2016
        self.replace_stdout(None)
2042
2017
        self.assertEqual(None, osutils.terminal_width())
2043
2018
 
2053
2028
        else:
2054
2029
            self.overrideAttr(termios, 'TIOCGWINSZ')
2055
2030
            del termios.TIOCGWINSZ
2056
 
        self.overrideEnv('BZR_COLUMNS', None)
2057
 
        self.overrideEnv('COLUMNS', None)
 
2031
        del os.environ['BZR_COLUMNS']
 
2032
        del os.environ['COLUMNS']
2058
2033
        # Whatever the result is, if we don't raise an exception, it's ok.
2059
2034
        osutils.terminal_width()
2060
2035
 
2061
 
 
2062
2036
class TestCreationOps(tests.TestCaseInTempDir):
2063
2037
    _test_needs_features = [features.chown_feature]
2064
2038
 
2094
2068
        self.assertEquals(self.uid, s.st_uid)
2095
2069
        self.assertEquals(self.gid, s.st_gid)
2096
2070
 
2097
 
 
2098
2071
class TestGetuserUnicode(tests.TestCase):
2099
2072
 
2100
2073
    def test_ascii_user(self):
2101
 
        self.overrideEnv('LOGNAME', 'jrandom')
 
2074
        osutils.set_or_unset_env('LOGNAME', 'jrandom')
2102
2075
        self.assertEqual(u'jrandom', osutils.getuser_unicode())
2103
2076
 
2104
2077
    def test_unicode_user(self):
2110
2083
                % (osutils.get_user_encoding(),))
2111
2084
        uni_username = u'jrandom' + uni_val
2112
2085
        encoded_username = uni_username.encode(ue)
2113
 
        self.overrideEnv('LOGNAME', encoded_username)
 
2086
        osutils.set_or_unset_env('LOGNAME', encoded_username)
2114
2087
        self.assertEqual(uni_username, osutils.getuser_unicode())
2115
 
        self.overrideEnv('LOGNAME', u'jrandom\xb6'.encode(ue))
2116
 
        self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())
2117
 
 
2118
 
 
2119
 
class TestBackupNames(tests.TestCase):
2120
 
 
2121
 
    def setUp(self):
2122
 
        super(TestBackupNames, self).setUp()
2123
 
        self.backups = []
2124
 
 
2125
 
    def backup_exists(self, name):
2126
 
        return name in self.backups
2127
 
 
2128
 
    def available_backup_name(self, name):
2129
 
        backup_name = osutils.available_backup_name(name, self.backup_exists)
2130
 
        self.backups.append(backup_name)
2131
 
        return backup_name
2132
 
 
2133
 
    def assertBackupName(self, expected, name):
2134
 
        self.assertEqual(expected, self.available_backup_name(name))
2135
 
 
2136
 
    def test_empty(self):
2137
 
        self.assertBackupName('file.~1~', 'file')
2138
 
 
2139
 
    def test_existing(self):
2140
 
        self.available_backup_name('file')
2141
 
        self.available_backup_name('file')
2142
 
        self.assertBackupName('file.~3~', 'file')
2143
 
        # Empty slots are found, this is not a strict requirement and may be
2144
 
        # revisited if we test against all implementations.
2145
 
        self.backups.remove('file.~2~')
2146
 
        self.assertBackupName('file.~2~', 'file')
2147
 
 
2148
 
 
2149
 
class TestFindExecutableInPath(tests.TestCase):
2150
 
 
2151
 
    def test_windows(self):
2152
 
        if sys.platform != 'win32':
2153
 
            raise tests.TestSkipped('test requires win32')
2154
 
        self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
2155
 
        self.assertTrue(
2156
 
            osutils.find_executable_on_path('explorer.exe') is not None)
2157
 
        self.assertTrue(
2158
 
            osutils.find_executable_on_path('EXPLORER.EXE') is not None)
2159
 
        self.assertTrue(
2160
 
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2161
 
        self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2162
 
 
2163
 
    def test_other(self):
2164
 
        if sys.platform == 'win32':
2165
 
            raise tests.TestSkipped('test requires non-win32')
2166
 
        self.assertTrue(osutils.find_executable_on_path('sh') is not None)
2167
 
        self.assertTrue(
2168
 
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2169
 
 
2170
 
 
2171
 
class TestEnvironmentErrors(tests.TestCase):
2172
 
    """Test handling of environmental errors"""
2173
 
 
2174
 
    def test_is_oserror(self):
2175
 
        self.assertTrue(osutils.is_environment_error(
2176
 
            OSError(errno.EINVAL, "Invalid parameter")))
2177
 
 
2178
 
    def test_is_ioerror(self):
2179
 
        self.assertTrue(osutils.is_environment_error(
2180
 
            IOError(errno.EINVAL, "Invalid parameter")))
2181
 
 
2182
 
    def test_is_socket_error(self):
2183
 
        self.assertTrue(osutils.is_environment_error(
2184
 
            socket.error(errno.EINVAL, "Invalid parameter")))
2185
 
 
2186
 
    def test_is_select_error(self):
2187
 
        self.assertTrue(osutils.is_environment_error(
2188
 
            select.error(errno.EINVAL, "Invalid parameter")))
2189
 
 
2190
 
    def test_is_pywintypes_error(self):
2191
 
        self.requireFeature(features.pywintypes)
2192
 
        import pywintypes
2193
 
        self.assertTrue(osutils.is_environment_error(
2194
 
            pywintypes.error(errno.EINVAL, "Invalid parameter", "Caller")))