← 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: Martin von Gagern
  • Date: 2010-04-22 06:25:26 UTC
  • mfrom: (0.27.39 trunk)
  • mto: This revision was merged to the branch mainline in revision 5240.
  • Revision ID: martin.vgagern@gmx.net-20100422062526-4lyy2yoor932u80w
Join bzr-bash-completion plugin into core bzr tree.

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
21
21
import os
22
22
import re
23
23
import socket
 
24
import stat
24
25
import sys
25
26
import time
26
27
 
27
28
from bzrlib import (
28
29
    errors,
29
 
    lazy_regex,
30
30
    osutils,
31
 
    symbol_versioning,
32
31
    tests,
33
32
    trace,
34
33
    win32utils,
38
37
    file_utils,
39
38
    test__walkdirs_win32,
40
39
    )
41
 
from bzrlib.tests.scenarios import load_tests_apply_scenarios
42
40
 
43
41
 
44
42
class _UTF8DirReaderFeature(tests.Feature):
97
95
    return scenarios
98
96
 
99
97
 
100
 
load_tests = load_tests_apply_scenarios
 
98
def load_tests(basic_tests, module, loader):
 
99
    suite = loader.suiteClass()
 
100
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
 
101
        basic_tests, tests.condition_isinstance(TestDirReader))
 
102
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios(), suite)
 
103
    suite.addTest(remaining_tests)
 
104
    return suite
101
105
 
102
106
 
103
107
class TestContainsWhitespace(tests.TestCase):
104
108
 
105
109
    def test_contains_whitespace(self):
106
 
        self.assertTrue(osutils.contains_whitespace(u' '))
107
 
        self.assertTrue(osutils.contains_whitespace(u'hello there'))
108
 
        self.assertTrue(osutils.contains_whitespace(u'hellothere\n'))
109
 
        self.assertTrue(osutils.contains_whitespace(u'hello\nthere'))
110
 
        self.assertTrue(osutils.contains_whitespace(u'hello\rthere'))
111
 
        self.assertTrue(osutils.contains_whitespace(u'hello\tthere'))
 
110
        self.failUnless(osutils.contains_whitespace(u' '))
 
111
        self.failUnless(osutils.contains_whitespace(u'hello there'))
 
112
        self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
 
113
        self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
 
114
        self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
 
115
        self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
112
116
 
113
117
        # \xa0 is "Non-breaking-space" which on some python locales thinks it
114
118
        # is whitespace, but we do not.
115
 
        self.assertFalse(osutils.contains_whitespace(u''))
116
 
        self.assertFalse(osutils.contains_whitespace(u'hellothere'))
117
 
        self.assertFalse(osutils.contains_whitespace(u'hello\xa0there'))
 
119
        self.failIf(osutils.contains_whitespace(u''))
 
120
        self.failIf(osutils.contains_whitespace(u'hellothere'))
 
121
        self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
118
122
 
119
123
 
120
124
class TestRename(tests.TestCaseInTempDir):
134
138
        # This should work everywhere
135
139
        self.create_file('a', 'something in a\n')
136
140
        self._fancy_rename('a', 'b')
137
 
        self.assertPathDoesNotExist('a')
138
 
        self.assertPathExists('b')
 
141
        self.failIfExists('a')
 
142
        self.failUnlessExists('b')
139
143
        self.check_file_contents('b', 'something in a\n')
140
144
 
141
145
        self.create_file('a', 'new something in a\n')
148
152
        self.create_file('target', 'data in target\n')
149
153
        self.assertRaises((IOError, OSError), self._fancy_rename,
150
154
                          'missingsource', 'target')
151
 
        self.assertPathExists('target')
 
155
        self.failUnlessExists('target')
152
156
        self.check_file_contents('target', 'data in target\n')
153
157
 
154
158
    def test_fancy_rename_fails_if_source_and_target_missing(self):
159
163
        # Rename should be semi-atomic on all platforms
160
164
        self.create_file('a', 'something in a\n')
161
165
        osutils.rename('a', 'b')
162
 
        self.assertPathDoesNotExist('a')
163
 
        self.assertPathExists('b')
 
166
        self.failIfExists('a')
 
167
        self.failUnlessExists('b')
164
168
        self.check_file_contents('b', 'something in a\n')
165
169
 
166
170
        self.create_file('a', 'new something in a\n')
231
235
            self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
232
236
 
233
237
 
234
 
class TestLstat(tests.TestCaseInTempDir):
235
 
 
236
 
    def test_lstat_matches_fstat(self):
237
 
        # On Windows, lstat and fstat don't always agree, primarily in the
238
 
        # 'st_ino' and 'st_dev' fields. So we force them to be '0' in our
239
 
        # custom implementation.
240
 
        if sys.platform == 'win32':
241
 
            # We only have special lstat/fstat if we have the extension.
242
 
            # Without it, we may end up re-reading content when we don't have
243
 
            # to, but otherwise it doesn't effect correctness.
244
 
            self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
245
 
        f = open('test-file.txt', 'wb')
246
 
        self.addCleanup(f.close)
247
 
        f.write('some content\n')
248
 
        f.flush()
249
 
        self.assertEqualStat(osutils.fstat(f.fileno()),
250
 
                             osutils.lstat('test-file.txt'))
251
 
 
252
 
 
253
238
class TestRmTree(tests.TestCaseInTempDir):
254
239
 
255
240
    def test_rmtree(self):
267
252
 
268
253
        osutils.rmtree('dir')
269
254
 
270
 
        self.assertPathDoesNotExist('dir/file')
271
 
        self.assertPathDoesNotExist('dir')
 
255
        self.failIfExists('dir/file')
 
256
        self.failIfExists('dir')
272
257
 
273
258
 
274
259
class TestDeleteAny(tests.TestCaseInTempDir):
488
473
        f = file('MixedCaseName', 'w')
489
474
        f.close()
490
475
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
491
 
        self.assertEqual('work/MixedCaseName', actual)
 
476
        self.failUnlessEqual('work/MixedCaseName', actual)
492
477
 
493
478
    def test_canonical_relpath_missing_tail(self):
494
479
        os.mkdir('MixedCaseParent')
495
480
        actual = osutils.canonical_relpath(self.test_base_dir,
496
481
                                           'mixedcaseparent/nochild')
497
 
        self.assertEqual('work/MixedCaseParent/nochild', actual)
 
482
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
498
483
 
499
484
 
500
485
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
818
803
        self.assertEqual(None, osutils.safe_file_id(None))
819
804
 
820
805
 
821
 
class TestPosixFuncs(tests.TestCase):
822
 
    """Test that the posix version of normpath returns an appropriate path
823
 
       when used with 2 leading slashes."""
824
 
 
825
 
    def test_normpath(self):
826
 
        self.assertEqual('/etc/shadow', osutils._posix_normpath('/etc/shadow'))
827
 
        self.assertEqual('/etc/shadow', osutils._posix_normpath('//etc/shadow'))
828
 
        self.assertEqual('/etc/shadow', osutils._posix_normpath('///etc/shadow'))
829
 
 
830
 
 
831
806
class TestWin32Funcs(tests.TestCase):
832
807
    """Test that _win32 versions of os utilities return appropriate paths."""
833
808
 
886
861
        self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
887
862
        # relative path
888
863
        cwd = osutils.getcwd().rstrip('/')
889
 
        drive = osutils.ntpath.splitdrive(cwd)[0]
 
864
        drive = osutils._nt_splitdrive(cwd)[0]
890
865
        self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
891
866
        self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
892
867
        # unicode path
934
909
        b.close()
935
910
 
936
911
        osutils._win32_rename('b', 'a')
937
 
        self.assertPathExists('a')
938
 
        self.assertPathDoesNotExist('b')
 
912
        self.failUnlessExists('a')
 
913
        self.failIfExists('b')
939
914
        self.assertFileEqual('baz\n', 'a')
940
915
 
941
916
    def test_rename_missing_file(self):
1089
1064
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
1090
1065
 
1091
1066
    def test_walkdirs_os_error(self):
1092
 
        # <https://bugs.launchpad.net/bzr/+bug/338653>
 
1067
        # <https://bugs.edge.launchpad.net/bzr/+bug/338653>
1093
1068
        # Pyrex readdir didn't raise useful messages if it had an error
1094
1069
        # reading the directory
1095
1070
        if sys.platform == 'win32':
1096
1071
            raise tests.TestNotApplicable(
1097
1072
                "readdir IOError not tested on win32")
1098
 
        self.requireFeature(features.not_running_as_root)
1099
1073
        os.mkdir("test-unreadable")
1100
1074
        os.chmod("test-unreadable", 0000)
1101
1075
        # must chmod it back so that it can be removed
1109
1083
        # Ensure the message contains the file name
1110
1084
        self.assertContainsRe(str(e), "\./test-unreadable")
1111
1085
 
1112
 
 
1113
 
    def test_walkdirs_encoding_error(self):
1114
 
        # <https://bugs.launchpad.net/bzr/+bug/488519>
1115
 
        # walkdirs didn't raise a useful message when the filenames
1116
 
        # are not using the filesystem's encoding
1117
 
 
1118
 
        # require a bytestring based filesystem
1119
 
        self.requireFeature(tests.ByteStringNamedFilesystem)
1120
 
 
1121
 
        tree = [
1122
 
            '.bzr',
1123
 
            '0file',
1124
 
            '1dir/',
1125
 
            '1dir/0file',
1126
 
            '1dir/1dir/',
1127
 
            '1file'
1128
 
            ]
1129
 
 
1130
 
        self.build_tree(tree)
1131
 
 
1132
 
        # rename the 1file to a latin-1 filename
1133
 
        os.rename("./1file", "\xe8file")
1134
 
        if "\xe8file" not in os.listdir("."):
1135
 
            self.skip("Lack filesystem that preserves arbitrary bytes")
1136
 
 
1137
 
        self._save_platform_info()
1138
 
        win32utils.winver = None # Avoid the win32 detection code
1139
 
        osutils._fs_enc = 'UTF-8'
1140
 
 
1141
 
        # this should raise on error
1142
 
        def attempt():
1143
 
            for dirdetail, dirblock in osutils.walkdirs('.'):
1144
 
                pass
1145
 
 
1146
 
        self.assertRaises(errors.BadFilenameEncoding, attempt)
1147
 
 
1148
1086
    def test__walkdirs_utf8(self):
1149
1087
        tree = [
1150
1088
            '.bzr',
1624
1562
                          ('d', 'source/b', 'target/b'),
1625
1563
                          ('f', 'source/b/c', 'target/b/c'),
1626
1564
                         ], processed_files)
1627
 
        self.assertPathDoesNotExist('target')
 
1565
        self.failIfExists('target')
1628
1566
        if osutils.has_symlinks():
1629
1567
            self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1630
1568
 
1676
1614
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1677
1615
        self.assertEqual('foo', old)
1678
1616
        self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1679
 
        self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
 
1617
        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1680
1618
 
1681
1619
 
1682
1620
class TestSizeShaFile(tests.TestCaseInTempDir):
1733
1671
 
1734
1672
class TestReCompile(tests.TestCase):
1735
1673
 
1736
 
    def _deprecated_re_compile_checked(self, *args, **kwargs):
1737
 
        return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
1738
 
            osutils.re_compile_checked, *args, **kwargs)
1739
 
 
1740
1674
    def test_re_compile_checked(self):
1741
 
        r = self._deprecated_re_compile_checked(r'A*', re.IGNORECASE)
 
1675
        r = osutils.re_compile_checked(r'A*', re.IGNORECASE)
1742
1676
        self.assertTrue(r.match('aaaa'))
1743
1677
        self.assertTrue(r.match('aAaA'))
1744
1678
 
1745
1679
    def test_re_compile_checked_error(self):
1746
1680
        # like https://bugs.launchpad.net/bzr/+bug/251352
1747
 
 
1748
 
        # Due to possible test isolation error, re.compile is not lazy at
1749
 
        # this point. We re-install lazy compile.
1750
 
        lazy_regex.install_lazy_compile()
1751
1681
        err = self.assertRaises(
1752
1682
            errors.BzrCommandError,
1753
 
            self._deprecated_re_compile_checked, '*', re.IGNORECASE, 'test case')
 
1683
            osutils.re_compile_checked, '*', re.IGNORECASE, 'test case')
1754
1684
        self.assertEqual(
1755
 
            'Invalid regular expression in test case: '
1756
 
            '"*" nothing to repeat',
 
1685
            "Invalid regular expression in test case: '*': "
 
1686
            "nothing to repeat",
1757
1687
            str(err))
1758
1688
 
1759
1689
 
1760
1690
class TestDirReader(tests.TestCaseInTempDir):
1761
1691
 
1762
 
    scenarios = dir_reader_scenarios()
1763
 
 
1764
1692
    # Set by load_tests
1765
1693
    _dir_reader_class = None
1766
1694
    _native_to_unicode = None
1907
1835
        os.symlink(self.target, self.link)
1908
1836
 
1909
1837
    def test_os_readlink_link_encoding(self):
1910
 
        self.assertEquals(self.target,  os.readlink(self.link))
 
1838
        if sys.version_info < (2, 6):
 
1839
            self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
 
1840
        else:
 
1841
            self.assertEquals(self.target,  os.readlink(self.link))
1911
1842
 
1912
1843
    def test_os_readlink_link_decoding(self):
1913
1844
        self.assertEquals(self.target.encode(osutils._fs_enc),
1925
1856
        self.assertIsInstance(concurrency, int)
1926
1857
 
1927
1858
    def test_local_concurrency_environment_variable(self):
1928
 
        self.overrideEnv('BZR_CONCURRENCY', '2')
 
1859
        os.environ['BZR_CONCURRENCY'] = '2'
1929
1860
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1930
 
        self.overrideEnv('BZR_CONCURRENCY', '3')
 
1861
        os.environ['BZR_CONCURRENCY'] = '3'
1931
1862
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1932
 
        self.overrideEnv('BZR_CONCURRENCY', 'foo')
 
1863
        os.environ['BZR_CONCURRENCY'] = 'foo'
1933
1864
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1934
1865
 
1935
1866
    def test_option_concurrency(self):
1936
 
        self.overrideEnv('BZR_CONCURRENCY', '1')
 
1867
        os.environ['BZR_CONCURRENCY'] = '1'
1937
1868
        self.run_bzr('rocks --concurrency 42')
1938
 
        # Command line overrides environment variable
 
1869
        # Command line overrides envrionment variable
1939
1870
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1940
1871
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1941
1872
 
1979
1910
 
1980
1911
class TestTerminalWidth(tests.TestCase):
1981
1912
 
1982
 
    def setUp(self):
1983
 
        tests.TestCase.setUp(self)
1984
 
        self._orig_terminal_size_state = osutils._terminal_size_state
1985
 
        self._orig_first_terminal_size = osutils._first_terminal_size
1986
 
        self.addCleanup(self.restore_osutils_globals)
1987
 
        osutils._terminal_size_state = 'no_data'
1988
 
        osutils._first_terminal_size = None
1989
 
 
1990
 
    def restore_osutils_globals(self):
1991
 
        osutils._terminal_size_state = self._orig_terminal_size_state
1992
 
        osutils._first_terminal_size = self._orig_first_terminal_size
1993
 
 
1994
1913
    def replace_stdout(self, new):
1995
1914
        self.overrideAttr(sys, 'stdout', new)
1996
1915
 
2011
1930
    def test_defaults_to_BZR_COLUMNS(self):
2012
1931
        # BZR_COLUMNS is set by the test framework
2013
1932
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
2014
 
        self.overrideEnv('BZR_COLUMNS', '12')
 
1933
        os.environ['BZR_COLUMNS'] = '12'
2015
1934
        self.assertEqual(12, osutils.terminal_width())
2016
1935
 
2017
 
    def test_BZR_COLUMNS_0_no_limit(self):
2018
 
        self.overrideEnv('BZR_COLUMNS', '0')
2019
 
        self.assertEqual(None, osutils.terminal_width())
2020
 
 
2021
1936
    def test_falls_back_to_COLUMNS(self):
2022
 
        self.overrideEnv('BZR_COLUMNS', None)
 
1937
        del os.environ['BZR_COLUMNS']
2023
1938
        self.assertNotEqual('42', os.environ['COLUMNS'])
2024
1939
        self.set_fake_tty()
2025
 
        self.overrideEnv('COLUMNS', '42')
 
1940
        os.environ['COLUMNS'] = '42'
2026
1941
        self.assertEqual(42, osutils.terminal_width())
2027
1942
 
2028
1943
    def test_tty_default_without_columns(self):
2029
 
        self.overrideEnv('BZR_COLUMNS', None)
2030
 
        self.overrideEnv('COLUMNS', None)
 
1944
        del os.environ['BZR_COLUMNS']
 
1945
        del os.environ['COLUMNS']
2031
1946
 
2032
1947
        def terminal_size(w, h):
2033
1948
            return 42, 42
2040
1955
        self.assertEqual(42, osutils.terminal_width())
2041
1956
 
2042
1957
    def test_non_tty_default_without_columns(self):
2043
 
        self.overrideEnv('BZR_COLUMNS', None)
2044
 
        self.overrideEnv('COLUMNS', None)
 
1958
        del os.environ['BZR_COLUMNS']
 
1959
        del os.environ['COLUMNS']
2045
1960
        self.replace_stdout(None)
2046
1961
        self.assertEqual(None, osutils.terminal_width())
2047
1962
 
2057
1972
        else:
2058
1973
            self.overrideAttr(termios, 'TIOCGWINSZ')
2059
1974
            del termios.TIOCGWINSZ
2060
 
        self.overrideEnv('BZR_COLUMNS', None)
2061
 
        self.overrideEnv('COLUMNS', None)
 
1975
        del os.environ['BZR_COLUMNS']
 
1976
        del os.environ['COLUMNS']
2062
1977
        # Whatever the result is, if we don't raise an exception, it's ok.
2063
1978
        osutils.terminal_width()
2064
1979
 
2065
 
 
2066
1980
class TestCreationOps(tests.TestCaseInTempDir):
2067
1981
    _test_needs_features = [features.chown_feature]
2068
1982
 
2076
1990
    def _dummy_chown(self, path, uid, gid):
2077
1991
        self.path, self.uid, self.gid = path, uid, gid
2078
1992
 
2079
 
    def test_copy_ownership_from_path(self):
2080
 
        """copy_ownership_from_path test with specified src."""
2081
 
        ownsrc = '/'
2082
 
        f = open('test_file', 'wt')
2083
 
        osutils.copy_ownership_from_path('test_file', ownsrc)
2084
 
 
2085
 
        s = os.stat(ownsrc)
2086
 
        self.assertEquals(self.path, 'test_file')
2087
 
        self.assertEquals(self.uid, s.st_uid)
2088
 
        self.assertEquals(self.gid, s.st_gid)
2089
 
 
2090
 
    def test_copy_ownership_nonesrc(self):
2091
 
        """copy_ownership_from_path test with src=None."""
2092
 
        f = open('test_file', 'wt')
2093
 
        # should use parent dir for permissions
2094
 
        osutils.copy_ownership_from_path('test_file')
2095
 
 
2096
 
        s = os.stat('..')
2097
 
        self.assertEquals(self.path, 'test_file')
2098
 
        self.assertEquals(self.uid, s.st_uid)
2099
 
        self.assertEquals(self.gid, s.st_gid)
2100
 
 
2101
 
 
2102
 
class TestGetuserUnicode(tests.TestCase):
2103
 
 
2104
 
    def test_ascii_user(self):
2105
 
        self.overrideEnv('LOGNAME', 'jrandom')
2106
 
        self.assertEqual(u'jrandom', osutils.getuser_unicode())
2107
 
 
2108
 
    def test_unicode_user(self):
2109
 
        ue = osutils.get_user_encoding()
2110
 
        uni_val, env_val = tests.probe_unicode_in_user_encoding()
2111
 
        if uni_val is None:
2112
 
            raise tests.TestSkipped(
2113
 
                'Cannot find a unicode character that works in encoding %s'
2114
 
                % (osutils.get_user_encoding(),))
2115
 
        uni_username = u'jrandom' + uni_val
2116
 
        encoded_username = uni_username.encode(ue)
2117
 
        self.overrideEnv('LOGNAME', encoded_username)
2118
 
        self.assertEqual(uni_username, osutils.getuser_unicode())
2119
 
        self.overrideEnv('LOGNAME', u'jrandom\xb6'.encode(ue))
2120
 
        self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())
2121
 
 
2122
 
    def test_no_username_bug_660174(self):
2123
 
        self.requireFeature(features.win32_feature)
2124
 
        for name in ('LOGNAME', 'USER', 'LNAME', 'USERNAME'):
2125
 
            self.overrideEnv(name, None)
2126
 
        self.assertEqual(u'UNKNOWN', osutils.getuser_unicode())
2127
 
 
2128
 
 
2129
 
class TestBackupNames(tests.TestCase):
2130
 
 
2131
 
    def setUp(self):
2132
 
        super(TestBackupNames, self).setUp()
2133
 
        self.backups = []
2134
 
 
2135
 
    def backup_exists(self, name):
2136
 
        return name in self.backups
2137
 
 
2138
 
    def available_backup_name(self, name):
2139
 
        backup_name = osutils.available_backup_name(name, self.backup_exists)
2140
 
        self.backups.append(backup_name)
2141
 
        return backup_name
2142
 
 
2143
 
    def assertBackupName(self, expected, name):
2144
 
        self.assertEqual(expected, self.available_backup_name(name))
2145
 
 
2146
 
    def test_empty(self):
2147
 
        self.assertBackupName('file.~1~', 'file')
2148
 
 
2149
 
    def test_existing(self):
2150
 
        self.available_backup_name('file')
2151
 
        self.available_backup_name('file')
2152
 
        self.assertBackupName('file.~3~', 'file')
2153
 
        # Empty slots are found, this is not a strict requirement and may be
2154
 
        # revisited if we test against all implementations.
2155
 
        self.backups.remove('file.~2~')
2156
 
        self.assertBackupName('file.~2~', 'file')
2157
 
 
2158
 
 
2159
 
class TestFindExecutableInPath(tests.TestCase):
2160
 
 
2161
 
    def test_windows(self):
2162
 
        if sys.platform != 'win32':
2163
 
            raise tests.TestSkipped('test requires win32')
2164
 
        self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
2165
 
        self.assertTrue(
2166
 
            osutils.find_executable_on_path('explorer.exe') is not None)
2167
 
        self.assertTrue(
2168
 
            osutils.find_executable_on_path('EXPLORER.EXE') is not None)
2169
 
        self.assertTrue(
2170
 
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2171
 
        self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2172
 
 
2173
 
    def test_other(self):
2174
 
        if sys.platform == 'win32':
2175
 
            raise tests.TestSkipped('test requires non-win32')
2176
 
        self.assertTrue(osutils.find_executable_on_path('sh') is not None)
2177
 
        self.assertTrue(
2178
 
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
 
1993
    def test_mkdir_with_ownership_chown(self):
 
1994
        """Ensure that osutils.mkdir_with_ownership chowns correctly with ownership_src.
 
1995
        """
 
1996
        ownsrc = '/'
 
1997
        osutils.mkdir_with_ownership('foo', ownsrc)
 
1998
 
 
1999
        s = os.stat(ownsrc)
 
2000
        self.assertEquals(self.path, 'foo')
 
2001
        self.assertEquals(self.uid, s.st_uid)
 
2002
        self.assertEquals(self.gid, s.st_gid)
 
2003
 
 
2004
    def test_open_with_ownership_chown(self):
 
2005
        """Ensure that osutils.open_with_ownership chowns correctly with ownership_src.
 
2006
        """
 
2007
        ownsrc = '/'
 
2008
        f = osutils.open_with_ownership('foo', 'w', ownership_src=ownsrc)
 
2009
 
 
2010
        # do a test write and close
 
2011
        f.write('hello')
 
2012
        f.close()
 
2013
 
 
2014
        s = os.stat(ownsrc)
 
2015
        self.assertEquals(self.path, 'foo')
 
2016
        self.assertEquals(self.uid, s.st_uid)
 
2017
        self.assertEquals(self.gid, s.st_gid)
 
2018