← 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: Vincent Ladeuil
  • Date: 2012-02-14 17:22:37 UTC
  • mfrom: (6466 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6468.
  • Revision ID: v.ladeuil+lp@free.fr-20120214172237-7dv7er3n4uy8d5m4
Merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
20
20
import errno
21
21
import os
22
22
import re
 
23
import select
23
24
import socket
24
25
import sys
25
26
import time
41
42
from bzrlib.tests.scenarios import load_tests_apply_scenarios
42
43
 
43
44
 
44
 
class _UTF8DirReaderFeature(tests.Feature):
 
45
class _UTF8DirReaderFeature(features.Feature):
45
46
 
46
47
    def _probe(self):
47
48
        try:
54
55
    def feature_name(self):
55
56
        return 'bzrlib._readdir_pyx'
56
57
 
57
 
UTF8DirReaderFeature = _UTF8DirReaderFeature()
 
58
UTF8DirReaderFeature = features.ModuleAvailableFeature('bzrlib._readdir_pyx')
58
59
 
59
 
term_ios_feature = tests.ModuleAvailableFeature('termios')
 
60
term_ios_feature = features.ModuleAvailableFeature('termios')
60
61
 
61
62
 
62
63
def _already_unicode(s):
103
104
class TestContainsWhitespace(tests.TestCase):
104
105
 
105
106
    def test_contains_whitespace(self):
106
 
        self.failUnless(osutils.contains_whitespace(u' '))
107
 
        self.failUnless(osutils.contains_whitespace(u'hello there'))
108
 
        self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
109
 
        self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
110
 
        self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
111
 
        self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
 
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'))
112
113
 
113
114
        # \xa0 is "Non-breaking-space" which on some python locales thinks it
114
115
        # is whitespace, but we do not.
115
 
        self.failIf(osutils.contains_whitespace(u''))
116
 
        self.failIf(osutils.contains_whitespace(u'hellothere'))
117
 
        self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
 
116
        self.assertFalse(osutils.contains_whitespace(u''))
 
117
        self.assertFalse(osutils.contains_whitespace(u'hellothere'))
 
118
        self.assertFalse(osutils.contains_whitespace(u'hello\xa0there'))
118
119
 
119
120
 
120
121
class TestRename(tests.TestCaseInTempDir):
134
135
        # This should work everywhere
135
136
        self.create_file('a', 'something in a\n')
136
137
        self._fancy_rename('a', 'b')
137
 
        self.failIfExists('a')
138
 
        self.failUnlessExists('b')
 
138
        self.assertPathDoesNotExist('a')
 
139
        self.assertPathExists('b')
139
140
        self.check_file_contents('b', 'something in a\n')
140
141
 
141
142
        self.create_file('a', 'new something in a\n')
148
149
        self.create_file('target', 'data in target\n')
149
150
        self.assertRaises((IOError, OSError), self._fancy_rename,
150
151
                          'missingsource', 'target')
151
 
        self.failUnlessExists('target')
 
152
        self.assertPathExists('target')
152
153
        self.check_file_contents('target', 'data in target\n')
153
154
 
154
155
    def test_fancy_rename_fails_if_source_and_target_missing(self):
159
160
        # Rename should be semi-atomic on all platforms
160
161
        self.create_file('a', 'something in a\n')
161
162
        osutils.rename('a', 'b')
162
 
        self.failIfExists('a')
163
 
        self.failUnlessExists('b')
 
163
        self.assertPathDoesNotExist('a')
 
164
        self.assertPathExists('b')
164
165
        self.check_file_contents('b', 'something in a\n')
165
166
 
166
167
        self.create_file('a', 'new something in a\n')
231
232
            self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
232
233
 
233
234
 
 
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
 
234
254
class TestRmTree(tests.TestCaseInTempDir):
235
255
 
236
256
    def test_rmtree(self):
248
268
 
249
269
        osutils.rmtree('dir')
250
270
 
251
 
        self.failIfExists('dir/file')
252
 
        self.failIfExists('dir')
 
271
        self.assertPathDoesNotExist('dir/file')
 
272
        self.assertPathDoesNotExist('dir')
253
273
 
254
274
 
255
275
class TestDeleteAny(tests.TestCaseInTempDir):
410
430
class TestLinks(tests.TestCaseInTempDir):
411
431
 
412
432
    def test_dereference_path(self):
413
 
        self.requireFeature(tests.SymlinkFeature)
 
433
        self.requireFeature(features.SymlinkFeature)
414
434
        cwd = osutils.realpath('.')
415
435
        os.mkdir('bar')
416
436
        bar_path = osutils.pathjoin(cwd, 'bar')
463
483
 
464
484
class TestCanonicalRelPath(tests.TestCaseInTempDir):
465
485
 
466
 
    _test_needs_features = [tests.CaseInsCasePresFilenameFeature]
 
486
    _test_needs_features = [features.CaseInsCasePresFilenameFeature]
467
487
 
468
488
    def test_canonical_relpath_simple(self):
469
489
        f = file('MixedCaseName', 'w')
470
490
        f.close()
471
491
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
472
 
        self.failUnlessEqual('work/MixedCaseName', actual)
 
492
        self.assertEqual('work/MixedCaseName', actual)
473
493
 
474
494
    def test_canonical_relpath_missing_tail(self):
475
495
        os.mkdir('MixedCaseParent')
476
496
        actual = osutils.canonical_relpath(self.test_base_dir,
477
497
                                           'mixedcaseparent/nochild')
478
 
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
 
498
        self.assertEqual('work/MixedCaseParent/nochild', actual)
479
499
 
480
500
 
481
501
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
799
819
        self.assertEqual(None, osutils.safe_file_id(None))
800
820
 
801
821
 
 
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
 
802
832
class TestWin32Funcs(tests.TestCase):
803
833
    """Test that _win32 versions of os utilities return appropriate paths."""
804
834
 
869
899
    """Test win32 functions that create files."""
870
900
 
871
901
    def test_getcwd(self):
872
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
902
        self.requireFeature(features.UnicodeFilenameFeature)
873
903
        os.mkdir(u'mu-\xb5')
874
904
        os.chdir(u'mu-\xb5')
875
905
        # TODO: jam 20060427 This will probably fail on Mac OSX because
905
935
        b.close()
906
936
 
907
937
        osutils._win32_rename('b', 'a')
908
 
        self.failUnlessExists('a')
909
 
        self.failIfExists('b')
 
938
        self.assertPathExists('a')
 
939
        self.assertPathDoesNotExist('b')
910
940
        self.assertFileEqual('baz\n', 'a')
911
941
 
912
942
    def test_rename_missing_file(self):
965
995
    """Test mac special functions that require directories."""
966
996
 
967
997
    def test_getcwd(self):
968
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
998
        self.requireFeature(features.UnicodeFilenameFeature)
969
999
        os.mkdir(u'B\xe5gfors')
970
1000
        os.chdir(u'B\xe5gfors')
971
1001
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
972
1002
 
973
1003
    def test_getcwd_nonnorm(self):
974
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1004
        self.requireFeature(features.UnicodeFilenameFeature)
975
1005
        # Test that _mac_getcwd() will normalize this path
976
1006
        os.mkdir(u'Ba\u030agfors')
977
1007
        os.chdir(u'Ba\u030agfors')
1087
1117
        # are not using the filesystem's encoding
1088
1118
 
1089
1119
        # require a bytestring based filesystem
1090
 
        self.requireFeature(tests.ByteStringNamedFilesystem)
 
1120
        self.requireFeature(features.ByteStringNamedFilesystem)
1091
1121
 
1092
1122
        tree = [
1093
1123
            '.bzr',
1187
1217
        self.requireFeature(UTF8DirReaderFeature)
1188
1218
        self._save_platform_info()
1189
1219
        win32utils.winver = None # Avoid the win32 detection code
1190
 
        osutils._fs_enc = 'UTF-8'
1191
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
1220
        osutils._fs_enc = 'utf-8'
 
1221
        self.assertDirReaderIs(
 
1222
            UTF8DirReaderFeature.module.UTF8DirReader)
1192
1223
 
1193
1224
    def test_force_walkdirs_utf8_fs_ascii(self):
1194
1225
        self.requireFeature(UTF8DirReaderFeature)
1195
1226
        self._save_platform_info()
1196
1227
        win32utils.winver = None # Avoid the win32 detection code
1197
 
        osutils._fs_enc = 'US-ASCII'
1198
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1199
 
 
1200
 
    def test_force_walkdirs_utf8_fs_ANSI(self):
1201
 
        self.requireFeature(UTF8DirReaderFeature)
1202
 
        self._save_platform_info()
1203
 
        win32utils.winver = None # Avoid the win32 detection code
1204
 
        osutils._fs_enc = 'ANSI_X3.4-1968'
1205
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
1228
        osutils._fs_enc = 'ascii'
 
1229
        self.assertDirReaderIs(
 
1230
            UTF8DirReaderFeature.module.UTF8DirReader)
1206
1231
 
1207
1232
    def test_force_walkdirs_utf8_fs_latin1(self):
1208
1233
        self._save_platform_info()
1209
1234
        win32utils.winver = None # Avoid the win32 detection code
1210
 
        osutils._fs_enc = 'latin1'
 
1235
        osutils._fs_enc = 'iso-8859-1'
1211
1236
        self.assertDirReaderIs(osutils.UnicodeDirReader)
1212
1237
 
1213
1238
    def test_force_walkdirs_utf8_nt(self):
1226
1251
 
1227
1252
    def test_unicode_walkdirs(self):
1228
1253
        """Walkdirs should always return unicode paths."""
1229
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1254
        self.requireFeature(features.UnicodeFilenameFeature)
1230
1255
        name0 = u'0file-\xb6'
1231
1256
        name1 = u'1dir-\u062c\u0648'
1232
1257
        name2 = u'2file-\u0633'
1269
1294
 
1270
1295
        The abspath portion might be in unicode or utf-8
1271
1296
        """
1272
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1297
        self.requireFeature(features.UnicodeFilenameFeature)
1273
1298
        name0 = u'0file-\xb6'
1274
1299
        name1 = u'1dir-\u062c\u0648'
1275
1300
        name2 = u'2file-\u0633'
1330
1355
 
1331
1356
        The abspath portion should be in unicode
1332
1357
        """
1333
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1358
        self.requireFeature(features.UnicodeFilenameFeature)
1334
1359
        # Use the unicode reader. TODO: split into driver-and-driven unit
1335
1360
        # tests.
1336
1361
        self._save_platform_info()
1377
1402
 
1378
1403
    def test__walkdirs_utf8_win32readdir(self):
1379
1404
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1380
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1405
        self.requireFeature(features.UnicodeFilenameFeature)
1381
1406
        from bzrlib._walkdirs_win32 import Win32ReadDir
1382
1407
        self._save_platform_info()
1383
1408
        osutils._selected_dir_reader = Win32ReadDir()
1434
1459
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1435
1460
        """make sure our Stat values are valid"""
1436
1461
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1437
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1462
        self.requireFeature(features.UnicodeFilenameFeature)
1438
1463
        from bzrlib._walkdirs_win32 import Win32ReadDir
1439
1464
        name0u = u'0file-\xb6'
1440
1465
        name0 = name0u.encode('utf8')
1458
1483
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1459
1484
        """make sure our Stat values are valid"""
1460
1485
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1461
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1486
        self.requireFeature(features.UnicodeFilenameFeature)
1462
1487
        from bzrlib._walkdirs_win32 import Win32ReadDir
1463
1488
        name0u = u'0dir-\u062c\u0648'
1464
1489
        name0 = name0u.encode('utf8')
1564
1589
        self.assertEqual(['c'], os.listdir('target/b'))
1565
1590
 
1566
1591
    def test_copy_tree_symlinks(self):
1567
 
        self.requireFeature(tests.SymlinkFeature)
 
1592
        self.requireFeature(features.SymlinkFeature)
1568
1593
        self.build_tree(['source/'])
1569
1594
        os.symlink('a/generic/path', 'source/lnk')
1570
1595
        osutils.copy_tree('source', 'target')
1595
1620
                          ('d', 'source/b', 'target/b'),
1596
1621
                          ('f', 'source/b/c', 'target/b/c'),
1597
1622
                         ], processed_files)
1598
 
        self.failIfExists('target')
 
1623
        self.assertPathDoesNotExist('target')
1599
1624
        if osutils.has_symlinks():
1600
1625
            self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1601
1626
 
1647
1672
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1648
1673
        self.assertEqual('foo', old)
1649
1674
        self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1650
 
        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
 
1675
        self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
1651
1676
 
1652
1677
 
1653
1678
class TestSizeShaFile(tests.TestCaseInTempDir):
1837
1862
        return filtered_dirblocks
1838
1863
 
1839
1864
    def test_walk_unicode_tree(self):
1840
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1865
        self.requireFeature(features.UnicodeFilenameFeature)
1841
1866
        tree, expected_dirblocks = self._get_unicode_tree()
1842
1867
        self.build_tree(tree)
1843
1868
        result = list(osutils._walkdirs_utf8('.'))
1844
1869
        self.assertEqual(expected_dirblocks, self._filter_out(result))
1845
1870
 
1846
1871
    def test_symlink(self):
1847
 
        self.requireFeature(tests.SymlinkFeature)
1848
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1872
        self.requireFeature(features.SymlinkFeature)
 
1873
        self.requireFeature(features.UnicodeFilenameFeature)
1849
1874
        target = u'target\N{Euro Sign}'
1850
1875
        link_name = u'l\N{Euro Sign}nk'
1851
1876
        os.symlink(target, link_name)
1869
1894
    But prior python versions failed to properly encode the passed unicode
1870
1895
    string.
1871
1896
    """
1872
 
    _test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
 
1897
    _test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]
1873
1898
 
1874
1899
    def setUp(self):
1875
1900
        super(tests.TestCaseInTempDir, self).setUp()
1878
1903
        os.symlink(self.target, self.link)
1879
1904
 
1880
1905
    def test_os_readlink_link_encoding(self):
1881
 
        if sys.version_info < (2, 6):
1882
 
            self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
1883
 
        else:
1884
 
            self.assertEquals(self.target,  os.readlink(self.link))
 
1906
        self.assertEquals(self.target,  os.readlink(self.link))
1885
1907
 
1886
1908
    def test_os_readlink_link_decoding(self):
1887
1909
        self.assertEquals(self.target.encode(osutils._fs_enc),
2036
2058
        # Whatever the result is, if we don't raise an exception, it's ok.
2037
2059
        osutils.terminal_width()
2038
2060
 
 
2061
 
2039
2062
class TestCreationOps(tests.TestCaseInTempDir):
2040
2063
    _test_needs_features = [features.chown_feature]
2041
2064
 
2071
2094
        self.assertEquals(self.uid, s.st_uid)
2072
2095
        self.assertEquals(self.gid, s.st_gid)
2073
2096
 
 
2097
 
 
2098
class TestPathFromEnviron(tests.TestCase):
 
2099
 
 
2100
    def test_is_unicode(self):
 
2101
        self.overrideEnv('BZR_TEST_PATH', './anywhere at all/')
 
2102
        path = osutils.path_from_environ('BZR_TEST_PATH')
 
2103
        self.assertIsInstance(path, unicode)
 
2104
        self.assertEqual(u'./anywhere at all/', path)
 
2105
 
 
2106
    def test_posix_path_env_ascii(self):
 
2107
        self.overrideEnv('BZR_TEST_PATH', '/tmp')
 
2108
        home = osutils._posix_path_from_environ('BZR_TEST_PATH')
 
2109
        self.assertIsInstance(home, unicode)
 
2110
        self.assertEqual(u'/tmp', home)
 
2111
 
 
2112
    def test_posix_path_env_unicode(self):
 
2113
        self.requireFeature(features.ByteStringNamedFilesystem)
 
2114
        self.overrideEnv('BZR_TEST_PATH', '/home/\xa7test')
 
2115
        self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
 
2116
        self.assertEqual(u'/home/\xa7test',
 
2117
            osutils._posix_path_from_environ('BZR_TEST_PATH'))
 
2118
        osutils._fs_enc = "iso8859-5"
 
2119
        self.assertEqual(u'/home/\u0407test',
 
2120
            osutils._posix_path_from_environ('BZR_TEST_PATH'))
 
2121
        osutils._fs_enc = "utf-8"
 
2122
        self.assertRaises(errors.BadFilenameEncoding,
 
2123
            osutils._posix_path_from_environ, 'BZR_TEST_PATH')
 
2124
 
 
2125
 
 
2126
class TestGetHomeDir(tests.TestCase):
 
2127
 
 
2128
    def test_is_unicode(self):
 
2129
        home = osutils._get_home_dir()
 
2130
        self.assertIsInstance(home, unicode)
 
2131
 
 
2132
    def test_posix_homeless(self):
 
2133
        self.overrideEnv('HOME', None)
 
2134
        home = osutils._get_home_dir()
 
2135
        self.assertIsInstance(home, unicode)
 
2136
 
 
2137
    def test_posix_home_ascii(self):
 
2138
        self.overrideEnv('HOME', '/home/test')
 
2139
        home = osutils._posix_get_home_dir()
 
2140
        self.assertIsInstance(home, unicode)
 
2141
        self.assertEqual(u'/home/test', home)
 
2142
 
 
2143
    def test_posix_home_unicode(self):
 
2144
        self.requireFeature(features.ByteStringNamedFilesystem)
 
2145
        self.overrideEnv('HOME', '/home/\xa7test')
 
2146
        self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
 
2147
        self.assertEqual(u'/home/\xa7test', osutils._posix_get_home_dir())
 
2148
        osutils._fs_enc = "iso8859-5"
 
2149
        self.assertEqual(u'/home/\u0407test', osutils._posix_get_home_dir())
 
2150
        osutils._fs_enc = "utf-8"
 
2151
        self.assertRaises(errors.BadFilenameEncoding,
 
2152
            osutils._posix_get_home_dir)
 
2153
 
 
2154
 
2074
2155
class TestGetuserUnicode(tests.TestCase):
2075
2156
 
 
2157
    def test_is_unicode(self):
 
2158
        user = osutils.getuser_unicode()
 
2159
        self.assertIsInstance(user, unicode)
 
2160
 
 
2161
    def envvar_to_override(self):
 
2162
        if sys.platform == "win32":
 
2163
            # Disable use of platform calls on windows so envvar is used
 
2164
            self.overrideAttr(win32utils, 'has_ctypes', False)
 
2165
            return 'USERNAME' # only variable used on windows
 
2166
        return 'LOGNAME' # first variable checked by getpass.getuser()
 
2167
 
2076
2168
    def test_ascii_user(self):
2077
 
        self.overrideEnv('LOGNAME', 'jrandom')
 
2169
        self.overrideEnv(self.envvar_to_override(), 'jrandom')
2078
2170
        self.assertEqual(u'jrandom', osutils.getuser_unicode())
2079
2171
 
2080
2172
    def test_unicode_user(self):
2086
2178
                % (osutils.get_user_encoding(),))
2087
2179
        uni_username = u'jrandom' + uni_val
2088
2180
        encoded_username = uni_username.encode(ue)
2089
 
        self.overrideEnv('LOGNAME', encoded_username)
 
2181
        self.overrideEnv(self.envvar_to_override(), encoded_username)
2090
2182
        self.assertEqual(uni_username, osutils.getuser_unicode())
2091
 
        self.overrideEnv('LOGNAME', u'jrandom\xb6'.encode(ue))
2092
 
        self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())
 
2183
 
2093
2184
 
2094
2185
class TestBackupNames(tests.TestCase):
2095
2186
 
2141
2232
        self.assertTrue(osutils.find_executable_on_path('sh') is not None)
2142
2233
        self.assertTrue(
2143
2234
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
 
2235
 
 
2236
 
 
2237
class TestEnvironmentErrors(tests.TestCase):
 
2238
    """Test handling of environmental errors"""
 
2239
 
 
2240
    def test_is_oserror(self):
 
2241
        self.assertTrue(osutils.is_environment_error(
 
2242
            OSError(errno.EINVAL, "Invalid parameter")))
 
2243
 
 
2244
    def test_is_ioerror(self):
 
2245
        self.assertTrue(osutils.is_environment_error(
 
2246
            IOError(errno.EINVAL, "Invalid parameter")))
 
2247
 
 
2248
    def test_is_socket_error(self):
 
2249
        self.assertTrue(osutils.is_environment_error(
 
2250
            socket.error(errno.EINVAL, "Invalid parameter")))
 
2251
 
 
2252
    def test_is_select_error(self):
 
2253
        self.assertTrue(osutils.is_environment_error(
 
2254
            select.error(errno.EINVAL, "Invalid parameter")))
 
2255
 
 
2256
    def test_is_pywintypes_error(self):
 
2257
        self.requireFeature(features.pywintypes)
 
2258
        import pywintypes
 
2259
        self.assertTrue(osutils.is_environment_error(
 
2260
            pywintypes.error(errno.EINVAL, "Invalid parameter", "Caller")))