← 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-09-17 04:35:23 UTC
  • mfrom: (5050.17.20 2.2)
  • mto: This revision was merged to the branch mainline in revision 5431.
  • Revision ID: andrew.bennetts@canonical.com-20100917043523-c5t63gmvxqxmqh5j
Merge lp:bzr/2.2, including fixes for #625574, #636930, #254278.

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
 
38
39
    file_utils,
39
40
    test__walkdirs_win32,
40
41
    )
41
 
from bzrlib.tests.scenarios import load_tests_apply_scenarios
42
42
 
43
43
 
44
44
class _UTF8DirReaderFeature(tests.Feature):
97
97
    return scenarios
98
98
 
99
99
 
100
 
load_tests = load_tests_apply_scenarios
 
100
def load_tests(basic_tests, module, loader):
 
101
    suite = loader.suiteClass()
 
102
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
 
103
        basic_tests, tests.condition_isinstance(TestDirReader))
 
104
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios(), suite)
 
105
    suite.addTest(remaining_tests)
 
106
    return suite
101
107
 
102
108
 
103
109
class TestContainsWhitespace(tests.TestCase):
104
110
 
105
111
    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'))
 
112
        self.failUnless(osutils.contains_whitespace(u' '))
 
113
        self.failUnless(osutils.contains_whitespace(u'hello there'))
 
114
        self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
 
115
        self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
 
116
        self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
 
117
        self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
112
118
 
113
119
        # \xa0 is "Non-breaking-space" which on some python locales thinks it
114
120
        # 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'))
 
121
        self.failIf(osutils.contains_whitespace(u''))
 
122
        self.failIf(osutils.contains_whitespace(u'hellothere'))
 
123
        self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
118
124
 
119
125
 
120
126
class TestRename(tests.TestCaseInTempDir):
134
140
        # This should work everywhere
135
141
        self.create_file('a', 'something in a\n')
136
142
        self._fancy_rename('a', 'b')
137
 
        self.assertPathDoesNotExist('a')
138
 
        self.assertPathExists('b')
 
143
        self.failIfExists('a')
 
144
        self.failUnlessExists('b')
139
145
        self.check_file_contents('b', 'something in a\n')
140
146
 
141
147
        self.create_file('a', 'new something in a\n')
148
154
        self.create_file('target', 'data in target\n')
149
155
        self.assertRaises((IOError, OSError), self._fancy_rename,
150
156
                          'missingsource', 'target')
151
 
        self.assertPathExists('target')
 
157
        self.failUnlessExists('target')
152
158
        self.check_file_contents('target', 'data in target\n')
153
159
 
154
160
    def test_fancy_rename_fails_if_source_and_target_missing(self):
159
165
        # Rename should be semi-atomic on all platforms
160
166
        self.create_file('a', 'something in a\n')
161
167
        osutils.rename('a', 'b')
162
 
        self.assertPathDoesNotExist('a')
163
 
        self.assertPathExists('b')
 
168
        self.failIfExists('a')
 
169
        self.failUnlessExists('b')
164
170
        self.check_file_contents('b', 'something in a\n')
165
171
 
166
172
        self.create_file('a', 'new something in a\n')
231
237
            self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
232
238
 
233
239
 
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
240
class TestRmTree(tests.TestCaseInTempDir):
254
241
 
255
242
    def test_rmtree(self):
267
254
 
268
255
        osutils.rmtree('dir')
269
256
 
270
 
        self.assertPathDoesNotExist('dir/file')
271
 
        self.assertPathDoesNotExist('dir')
 
257
        self.failIfExists('dir/file')
 
258
        self.failIfExists('dir')
272
259
 
273
260
 
274
261
class TestDeleteAny(tests.TestCaseInTempDir):
488
475
        f = file('MixedCaseName', 'w')
489
476
        f.close()
490
477
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
491
 
        self.assertEqual('work/MixedCaseName', actual)
 
478
        self.failUnlessEqual('work/MixedCaseName', actual)
492
479
 
493
480
    def test_canonical_relpath_missing_tail(self):
494
481
        os.mkdir('MixedCaseParent')
495
482
        actual = osutils.canonical_relpath(self.test_base_dir,
496
483
                                           'mixedcaseparent/nochild')
497
 
        self.assertEqual('work/MixedCaseParent/nochild', actual)
 
484
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
498
485
 
499
486
 
500
487
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
924
911
        b.close()
925
912
 
926
913
        osutils._win32_rename('b', 'a')
927
 
        self.assertPathExists('a')
928
 
        self.assertPathDoesNotExist('b')
 
914
        self.failUnlessExists('a')
 
915
        self.failIfExists('b')
929
916
        self.assertFileEqual('baz\n', 'a')
930
917
 
931
918
    def test_rename_missing_file(self):
1085
1072
        if sys.platform == 'win32':
1086
1073
            raise tests.TestNotApplicable(
1087
1074
                "readdir IOError not tested on win32")
1088
 
        self.requireFeature(features.not_running_as_root)
1089
1075
        os.mkdir("test-unreadable")
1090
1076
        os.chmod("test-unreadable", 0000)
1091
1077
        # must chmod it back so that it can be removed
1121
1107
 
1122
1108
        # rename the 1file to a latin-1 filename
1123
1109
        os.rename("./1file", "\xe8file")
1124
 
        if "\xe8file" not in os.listdir("."):
1125
 
            self.skip("Lack filesystem that preserves arbitrary bytes")
1126
1110
 
1127
1111
        self._save_platform_info()
1128
1112
        win32utils.winver = None # Avoid the win32 detection code
1614
1598
                          ('d', 'source/b', 'target/b'),
1615
1599
                          ('f', 'source/b/c', 'target/b/c'),
1616
1600
                         ], processed_files)
1617
 
        self.assertPathDoesNotExist('target')
 
1601
        self.failIfExists('target')
1618
1602
        if osutils.has_symlinks():
1619
1603
            self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1620
1604
 
1666
1650
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1667
1651
        self.assertEqual('foo', old)
1668
1652
        self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1669
 
        self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
 
1653
        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1670
1654
 
1671
1655
 
1672
1656
class TestSizeShaFile(tests.TestCaseInTempDir):
1749
1733
 
1750
1734
class TestDirReader(tests.TestCaseInTempDir):
1751
1735
 
1752
 
    scenarios = dir_reader_scenarios()
1753
 
 
1754
1736
    # Set by load_tests
1755
1737
    _dir_reader_class = None
1756
1738
    _native_to_unicode = None
1918
1900
        self.assertIsInstance(concurrency, int)
1919
1901
 
1920
1902
    def test_local_concurrency_environment_variable(self):
1921
 
        self.overrideEnv('BZR_CONCURRENCY', '2')
 
1903
        os.environ['BZR_CONCURRENCY'] = '2'
1922
1904
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1923
 
        self.overrideEnv('BZR_CONCURRENCY', '3')
 
1905
        os.environ['BZR_CONCURRENCY'] = '3'
1924
1906
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1925
 
        self.overrideEnv('BZR_CONCURRENCY', 'foo')
 
1907
        os.environ['BZR_CONCURRENCY'] = 'foo'
1926
1908
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1927
1909
 
1928
1910
    def test_option_concurrency(self):
1929
 
        self.overrideEnv('BZR_CONCURRENCY', '1')
 
1911
        os.environ['BZR_CONCURRENCY'] = '1'
1930
1912
        self.run_bzr('rocks --concurrency 42')
1931
 
        # Command line overrides environment variable
 
1913
        # Command line overrides envrionment variable
1932
1914
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1933
1915
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1934
1916
 
2004
1986
    def test_defaults_to_BZR_COLUMNS(self):
2005
1987
        # BZR_COLUMNS is set by the test framework
2006
1988
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
2007
 
        self.overrideEnv('BZR_COLUMNS', '12')
 
1989
        os.environ['BZR_COLUMNS'] = '12'
2008
1990
        self.assertEqual(12, osutils.terminal_width())
2009
1991
 
2010
 
    def test_BZR_COLUMNS_0_no_limit(self):
2011
 
        self.overrideEnv('BZR_COLUMNS', '0')
2012
 
        self.assertEqual(None, osutils.terminal_width())
2013
 
 
2014
1992
    def test_falls_back_to_COLUMNS(self):
2015
 
        self.overrideEnv('BZR_COLUMNS', None)
 
1993
        del os.environ['BZR_COLUMNS']
2016
1994
        self.assertNotEqual('42', os.environ['COLUMNS'])
2017
1995
        self.set_fake_tty()
2018
 
        self.overrideEnv('COLUMNS', '42')
 
1996
        os.environ['COLUMNS'] = '42'
2019
1997
        self.assertEqual(42, osutils.terminal_width())
2020
1998
 
2021
1999
    def test_tty_default_without_columns(self):
2022
 
        self.overrideEnv('BZR_COLUMNS', None)
2023
 
        self.overrideEnv('COLUMNS', None)
 
2000
        del os.environ['BZR_COLUMNS']
 
2001
        del os.environ['COLUMNS']
2024
2002
 
2025
2003
        def terminal_size(w, h):
2026
2004
            return 42, 42
2033
2011
        self.assertEqual(42, osutils.terminal_width())
2034
2012
 
2035
2013
    def test_non_tty_default_without_columns(self):
2036
 
        self.overrideEnv('BZR_COLUMNS', None)
2037
 
        self.overrideEnv('COLUMNS', None)
 
2014
        del os.environ['BZR_COLUMNS']
 
2015
        del os.environ['COLUMNS']
2038
2016
        self.replace_stdout(None)
2039
2017
        self.assertEqual(None, osutils.terminal_width())
2040
2018
 
2050
2028
        else:
2051
2029
            self.overrideAttr(termios, 'TIOCGWINSZ')
2052
2030
            del termios.TIOCGWINSZ
2053
 
        self.overrideEnv('BZR_COLUMNS', None)
2054
 
        self.overrideEnv('COLUMNS', None)
 
2031
        del os.environ['BZR_COLUMNS']
 
2032
        del os.environ['COLUMNS']
2055
2033
        # Whatever the result is, if we don't raise an exception, it's ok.
2056
2034
        osutils.terminal_width()
2057
2035
 
2093
2071
class TestGetuserUnicode(tests.TestCase):
2094
2072
 
2095
2073
    def test_ascii_user(self):
2096
 
        self.overrideEnv('LOGNAME', 'jrandom')
 
2074
        osutils.set_or_unset_env('LOGNAME', 'jrandom')
2097
2075
        self.assertEqual(u'jrandom', osutils.getuser_unicode())
2098
2076
 
2099
2077
    def test_unicode_user(self):
2100
2078
        ue = osutils.get_user_encoding()
2101
 
        uni_val, env_val = tests.probe_unicode_in_user_encoding()
2102
 
        if uni_val is None:
2103
 
            raise tests.TestSkipped(
2104
 
                'Cannot find a unicode character that works in encoding %s'
2105
 
                % (osutils.get_user_encoding(),))
2106
 
        uni_username = u'jrandom' + uni_val
2107
 
        encoded_username = uni_username.encode(ue)
2108
 
        self.overrideEnv('LOGNAME', encoded_username)
2109
 
        self.assertEqual(uni_username, osutils.getuser_unicode())
2110
 
        self.overrideEnv('LOGNAME', u'jrandom\xb6'.encode(ue))
 
2079
        osutils.set_or_unset_env('LOGNAME', u'jrandom\xb6'.encode(ue))
2111
2080
        self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())
2112
 
 
2113
 
class TestBackupNames(tests.TestCase):
2114
 
 
2115
 
    def setUp(self):
2116
 
        super(TestBackupNames, self).setUp()
2117
 
        self.backups = []
2118
 
 
2119
 
    def backup_exists(self, name):
2120
 
        return name in self.backups
2121
 
 
2122
 
    def available_backup_name(self, name):
2123
 
        backup_name = osutils.available_backup_name(name, self.backup_exists)
2124
 
        self.backups.append(backup_name)
2125
 
        return backup_name
2126
 
 
2127
 
    def assertBackupName(self, expected, name):
2128
 
        self.assertEqual(expected, self.available_backup_name(name))
2129
 
 
2130
 
    def test_empty(self):
2131
 
        self.assertBackupName('file.~1~', 'file')
2132
 
 
2133
 
    def test_existing(self):
2134
 
        self.available_backup_name('file')
2135
 
        self.available_backup_name('file')
2136
 
        self.assertBackupName('file.~3~', 'file')
2137
 
        # Empty slots are found, this is not a strict requirement and may be
2138
 
        # revisited if we test against all implementations.
2139
 
        self.backups.remove('file.~2~')
2140
 
        self.assertBackupName('file.~2~', 'file')
2141
 
 
2142
 
 
2143
 
class TestFindExecutableInPath(tests.TestCase):
2144
 
 
2145
 
    def test_windows(self):
2146
 
        if sys.platform != 'win32':
2147
 
            raise tests.TestSkipped('test requires win32')
2148
 
        self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
2149
 
        self.assertTrue(
2150
 
            osutils.find_executable_on_path('explorer.exe') is not None)
2151
 
        self.assertTrue(
2152
 
            osutils.find_executable_on_path('EXPLORER.EXE') is not None)
2153
 
        self.assertTrue(
2154
 
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2155
 
        self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2156
 
 
2157
 
    def test_other(self):
2158
 
        if sys.platform == 'win32':
2159
 
            raise tests.TestSkipped('test requires non-win32')
2160
 
        self.assertTrue(osutils.find_executable_on_path('sh') is not None)
2161
 
        self.assertTrue(
2162
 
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)