← 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-02-12 04:33:05 UTC
  • mfrom: (5031 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5032.
  • Revision ID: andrew.bennetts@canonical.com-20100212043305-ujdbsdoviql2t7i3
Merge lp:bzr

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
53
53
 
54
54
UTF8DirReaderFeature = _UTF8DirReaderFeature()
55
55
 
 
56
term_ios_feature = tests.ModuleAvailableFeature('termios')
 
57
 
56
58
 
57
59
def _already_unicode(s):
58
60
    return s
59
61
 
60
62
 
61
 
def _fs_enc_to_unicode(s):
62
 
    return s.decode(osutils._fs_enc)
63
 
 
64
 
 
65
63
def _utf8_to_unicode(s):
66
64
    return s.decode('UTF-8')
67
65
 
84
82
                          dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
85
83
                               _native_to_unicode=_utf8_to_unicode)))
86
84
 
87
 
    if test__walkdirs_win32.Win32ReadDirFeature.available():
 
85
    if test__walkdirs_win32.win32_readdir_feature.available():
88
86
        try:
89
87
            from bzrlib import _walkdirs_win32
90
 
            # TODO: check on windows, it may be that we need to use/add
91
 
            # safe_unicode instead of _fs_enc_to_unicode
92
88
            scenarios.append(
93
89
                ('win32',
94
90
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
95
 
                      _native_to_unicode=_fs_enc_to_unicode)))
 
91
                      _native_to_unicode=_already_unicode)))
96
92
        except ImportError:
97
93
            pass
98
94
    return scenarios
126
122
 
127
123
class TestRename(tests.TestCaseInTempDir):
128
124
 
 
125
    def create_file(self, filename, content):
 
126
        f = open(filename, 'wb')
 
127
        try:
 
128
            f.write(content)
 
129
        finally:
 
130
            f.close()
 
131
 
 
132
    def _fancy_rename(self, a, b):
 
133
        osutils.fancy_rename(a, b, rename_func=os.rename,
 
134
                             unlink_func=os.unlink)
 
135
 
129
136
    def test_fancy_rename(self):
130
137
        # This should work everywhere
131
 
        def rename(a, b):
132
 
            osutils.fancy_rename(a, b,
133
 
                    rename_func=os.rename,
134
 
                    unlink_func=os.unlink)
135
 
 
136
 
        open('a', 'wb').write('something in a\n')
137
 
        rename('a', 'b')
 
138
        self.create_file('a', 'something in a\n')
 
139
        self._fancy_rename('a', 'b')
138
140
        self.failIfExists('a')
139
141
        self.failUnlessExists('b')
140
142
        self.check_file_contents('b', 'something in a\n')
141
143
 
142
 
        open('a', 'wb').write('new something in a\n')
143
 
        rename('b', 'a')
 
144
        self.create_file('a', 'new something in a\n')
 
145
        self._fancy_rename('b', 'a')
144
146
 
145
147
        self.check_file_contents('a', 'something in a\n')
146
148
 
 
149
    def test_fancy_rename_fails_source_missing(self):
 
150
        # An exception should be raised, and the target should be left in place
 
151
        self.create_file('target', 'data in target\n')
 
152
        self.assertRaises((IOError, OSError), self._fancy_rename,
 
153
                          'missingsource', 'target')
 
154
        self.failUnlessExists('target')
 
155
        self.check_file_contents('target', 'data in target\n')
 
156
 
 
157
    def test_fancy_rename_fails_if_source_and_target_missing(self):
 
158
        self.assertRaises((IOError, OSError), self._fancy_rename,
 
159
                          'missingsource', 'missingtarget')
 
160
 
147
161
    def test_rename(self):
148
162
        # Rename should be semi-atomic on all platforms
149
 
        open('a', 'wb').write('something in a\n')
 
163
        self.create_file('a', 'something in a\n')
150
164
        osutils.rename('a', 'b')
151
165
        self.failIfExists('a')
152
166
        self.failUnlessExists('b')
153
167
        self.check_file_contents('b', 'something in a\n')
154
168
 
155
 
        open('a', 'wb').write('new something in a\n')
 
169
        self.create_file('a', 'new something in a\n')
156
170
        osutils.rename('b', 'a')
157
171
 
158
172
        self.check_file_contents('a', 'something in a\n')
366
380
        # Instead blackbox.test_locale should check for localized
367
381
        # dates once they do occur in output strings.
368
382
 
 
383
    def test_format_date_with_offset_in_original_timezone(self):
 
384
        self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
 
385
            osutils.format_date_with_offset_in_original_timezone(0))
 
386
        self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
 
387
            osutils.format_date_with_offset_in_original_timezone(100000))
 
388
        self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
 
389
            osutils.format_date_with_offset_in_original_timezone(100000, 7200))
 
390
 
369
391
    def test_local_time_offset(self):
370
392
        """Test that local_time_offset() returns a sane value."""
371
393
        offset = osutils.local_time_offset()
967
989
 
968
990
    def test_osutils_binding(self):
969
991
        from bzrlib.tests import test__chunks_to_lines
970
 
        if test__chunks_to_lines.CompiledChunksToLinesFeature.available():
 
992
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
971
993
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
972
994
        else:
973
995
            from bzrlib._chunks_to_lines_py import chunks_to_lines
1113
1135
            dirblock[:] = new_dirblock
1114
1136
 
1115
1137
    def _save_platform_info(self):
1116
 
        cur_winver = win32utils.winver
1117
 
        cur_fs_enc = osutils._fs_enc
1118
 
        cur_dir_reader = osutils._selected_dir_reader
1119
 
        def restore():
1120
 
            win32utils.winver = cur_winver
1121
 
            osutils._fs_enc = cur_fs_enc
1122
 
            osutils._selected_dir_reader = cur_dir_reader
1123
 
        self.addCleanup(restore)
 
1138
        self.overrideAttr(win32utils, 'winver')
 
1139
        self.overrideAttr(osutils, '_fs_enc')
 
1140
        self.overrideAttr(osutils, '_selected_dir_reader')
1124
1141
 
1125
1142
    def assertDirReaderIs(self, expected):
1126
1143
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
1159
1176
 
1160
1177
    def test_force_walkdirs_utf8_nt(self):
1161
1178
        # Disabled because the thunk of the whole walkdirs api is disabled.
1162
 
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
 
1179
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1163
1180
        self._save_platform_info()
1164
1181
        win32utils.winver = 'Windows NT'
1165
1182
        from bzrlib._walkdirs_win32 import Win32ReadDir
1166
1183
        self.assertDirReaderIs(Win32ReadDir)
1167
1184
 
1168
1185
    def test_force_walkdirs_utf8_98(self):
1169
 
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
 
1186
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1170
1187
        self._save_platform_info()
1171
1188
        win32utils.winver = 'Windows 98'
1172
1189
        self.assertDirReaderIs(osutils.UnicodeDirReader)
1323
1340
        self.assertEqual(expected_dirblocks, result)
1324
1341
 
1325
1342
    def test__walkdirs_utf8_win32readdir(self):
1326
 
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
 
1343
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1327
1344
        self.requireFeature(tests.UnicodeFilenameFeature)
1328
1345
        from bzrlib._walkdirs_win32 import Win32ReadDir
1329
1346
        self._save_platform_info()
1380
1397
 
1381
1398
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1382
1399
        """make sure our Stat values are valid"""
1383
 
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
 
1400
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1384
1401
        self.requireFeature(tests.UnicodeFilenameFeature)
1385
1402
        from bzrlib._walkdirs_win32 import Win32ReadDir
1386
1403
        name0u = u'0file-\xb6'
1404
1421
 
1405
1422
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1406
1423
        """make sure our Stat values are valid"""
1407
 
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
 
1424
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1408
1425
        self.requireFeature(tests.UnicodeFilenameFeature)
1409
1426
        from bzrlib._walkdirs_win32 import Win32ReadDir
1410
1427
        name0u = u'0dir-\u062c\u0648'
1559
1576
        def cleanup():
1560
1577
            if 'BZR_TEST_ENV_VAR' in os.environ:
1561
1578
                del os.environ['BZR_TEST_ENV_VAR']
1562
 
 
1563
1579
        self.addCleanup(cleanup)
1564
1580
 
1565
1581
    def test_set(self):
1613
1629
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
1614
1630
        self.build_tree_contents([('foo', text)])
1615
1631
        expected_sha = osutils.sha_string(text)
1616
 
        f = open('foo')
 
1632
        f = open('foo', 'rb')
1617
1633
        self.addCleanup(f.close)
1618
1634
        size, sha = osutils.size_sha_file(f)
1619
1635
        self.assertEqual(38, size)
1676
1692
 
1677
1693
    def setUp(self):
1678
1694
        tests.TestCaseInTempDir.setUp(self)
1679
 
 
1680
 
        # Save platform specific info and reset it
1681
 
        cur_dir_reader = osutils._selected_dir_reader
1682
 
 
1683
 
        def restore():
1684
 
            osutils._selected_dir_reader = cur_dir_reader
1685
 
        self.addCleanup(restore)
1686
 
 
1687
 
        osutils._selected_dir_reader = self._dir_reader_class()
 
1695
        self.overrideAttr(osutils,
 
1696
                          '_selected_dir_reader', self._dir_reader_class())
1688
1697
 
1689
1698
    def _get_ascii_tree(self):
1690
1699
        tree = [
1835
1844
 
1836
1845
class TestConcurrency(tests.TestCase):
1837
1846
 
 
1847
    def setUp(self):
 
1848
        super(TestConcurrency, self).setUp()
 
1849
        self.overrideAttr(osutils, '_cached_local_concurrency')
 
1850
 
1838
1851
    def test_local_concurrency(self):
1839
1852
        concurrency = osutils.local_concurrency()
1840
1853
        self.assertIsInstance(concurrency, int)
1841
1854
 
 
1855
    def test_local_concurrency_environment_variable(self):
 
1856
        os.environ['BZR_CONCURRENCY'] = '2'
 
1857
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
 
1858
        os.environ['BZR_CONCURRENCY'] = '3'
 
1859
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
 
1860
        os.environ['BZR_CONCURRENCY'] = 'foo'
 
1861
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
 
1862
 
 
1863
    def test_option_concurrency(self):
 
1864
        os.environ['BZR_CONCURRENCY'] = '1'
 
1865
        self.run_bzr('rocks --concurrency 42')
 
1866
        # Command line overrides envrionment variable
 
1867
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
 
1868
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
 
1869
 
1842
1870
 
1843
1871
class TestFailedToLoadExtension(tests.TestCase):
1844
1872
 
1851
1879
 
1852
1880
    def setUp(self):
1853
1881
        super(TestFailedToLoadExtension, self).setUp()
1854
 
        self.saved_failures = osutils._extension_load_failures[:]
1855
 
        del osutils._extension_load_failures[:]
1856
 
        self.addCleanup(self.restore_failures)
1857
 
 
1858
 
    def restore_failures(self):
1859
 
        osutils._extension_load_failures = self.saved_failures
 
1882
        self.overrideAttr(osutils, '_extension_load_failures', [])
1860
1883
 
1861
1884
    def test_failure_to_load(self):
1862
1885
        self._try_loading()
1880
1903
            r"bzr: warning: some compiled extensions could not be loaded; "
1881
1904
            "see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1882
1905
            )
 
1906
 
 
1907
 
 
1908
class TestTerminalWidth(tests.TestCase):
 
1909
 
 
1910
    def replace_stdout(self, new):
 
1911
        self.overrideAttr(sys, 'stdout', new)
 
1912
 
 
1913
    def replace__terminal_size(self, new):
 
1914
        self.overrideAttr(osutils, '_terminal_size', new)
 
1915
 
 
1916
    def set_fake_tty(self):
 
1917
 
 
1918
        class I_am_a_tty(object):
 
1919
            def isatty(self):
 
1920
                return True
 
1921
 
 
1922
        self.replace_stdout(I_am_a_tty())
 
1923
 
 
1924
    def test_default_values(self):
 
1925
        self.assertEqual(80, osutils.default_terminal_width)
 
1926
 
 
1927
    def test_defaults_to_BZR_COLUMNS(self):
 
1928
        # BZR_COLUMNS is set by the test framework
 
1929
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
 
1930
        os.environ['BZR_COLUMNS'] = '12'
 
1931
        self.assertEqual(12, osutils.terminal_width())
 
1932
 
 
1933
    def test_falls_back_to_COLUMNS(self):
 
1934
        del os.environ['BZR_COLUMNS']
 
1935
        self.assertNotEqual('42', os.environ['COLUMNS'])
 
1936
        self.set_fake_tty()
 
1937
        os.environ['COLUMNS'] = '42'
 
1938
        self.assertEqual(42, osutils.terminal_width())
 
1939
 
 
1940
    def test_tty_default_without_columns(self):
 
1941
        del os.environ['BZR_COLUMNS']
 
1942
        del os.environ['COLUMNS']
 
1943
 
 
1944
        def terminal_size(w, h):
 
1945
            return 42, 42
 
1946
 
 
1947
        self.set_fake_tty()
 
1948
        # We need to override the osutils definition as it depends on the
 
1949
        # running environment that we can't control (PQM running without a
 
1950
        # controlling terminal is one example).
 
1951
        self.replace__terminal_size(terminal_size)
 
1952
        self.assertEqual(42, osutils.terminal_width())
 
1953
 
 
1954
    def test_non_tty_default_without_columns(self):
 
1955
        del os.environ['BZR_COLUMNS']
 
1956
        del os.environ['COLUMNS']
 
1957
        self.replace_stdout(None)
 
1958
        self.assertEqual(None, osutils.terminal_width())
 
1959
 
 
1960
    def test_no_TIOCGWINSZ(self):
 
1961
        self.requireFeature(term_ios_feature)
 
1962
        termios = term_ios_feature.module
 
1963
        # bug 63539 is about a termios without TIOCGWINSZ attribute
 
1964
        try:
 
1965
            orig = termios.TIOCGWINSZ
 
1966
        except AttributeError:
 
1967
            # We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
 
1968
            pass
 
1969
        else:
 
1970
            self.overrideAttr(termios, 'TIOCGWINSZ')
 
1971
            del termios.TIOCGWINSZ
 
1972
        del os.environ['BZR_COLUMNS']
 
1973
        del os.environ['COLUMNS']
 
1974
        # Whatever the result is, if we don't raise an exception, it's ok.
 
1975
        osutils.terminal_width()