~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils.py

• browse files at revision 4775.1.1
• compare with another revision
• download diff
• download tarball
• view history from revision 4775.1.1

• reverse the comparison (4775.1.1 to 4597.3.73)
• stop comparing with revision 4597.3.73

Show diffs side-by-side

added

removed

bzrlib/tests/test_osutils.py

53

53

 

54

54

UTF8DirReaderFeature = _UTF8DirReaderFeature()

55

55

 

56

 

term_ios_feature = tests.ModuleAvailableFeature('termios')

57

 

 

58

56

 

59

57

def _already_unicode(s):

60

58

    return s

61

59

 

62

60

 

 

61

def _fs_enc_to_unicode(s):

 

62

    return s.decode(osutils._fs_enc)

 

63

 

 

64

 

63

65

def _utf8_to_unicode(s):

64

66

    return s.decode('UTF-8')

65

67

 

82

84

                          dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,

83

85

                               _native_to_unicode=_utf8_to_unicode)))

84

86

 

85

 

    if test__walkdirs_win32.win32_readdir_feature.available():

 

87

    if test__walkdirs_win32.Win32ReadDirFeature.available():

86

88

        try:

87

89

            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

88

92

            scenarios.append(

89

93

                ('win32',

90

94

                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,

91

 

                      _native_to_unicode=_already_unicode)))

 

95

                      _native_to_unicode=_fs_enc_to_unicode)))

92

96

        except ImportError:

93

97

            pass

94

98

    return scenarios

122

126

 

123

127

class TestRename(tests.TestCaseInTempDir):

124

128

 

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

 

 

136

129

    def test_fancy_rename(self):

137

130

        # This should work everywhere

138

 

        self.create_file('a', 'something in a\n')

139

 

        self._fancy_rename('a', 'b')

 

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')

140

138

        self.failIfExists('a')

141

139

        self.failUnlessExists('b')

142

140

        self.check_file_contents('b', 'something in a\n')

143

141

 

144

 

        self.create_file('a', 'new something in a\n')

145

 

        self._fancy_rename('b', 'a')

 

142

        open('a', 'wb').write('new something in a\n')

 

143

        rename('b', 'a')

146

144

 

147

145

        self.check_file_contents('a', 'something in a\n')

148

146

 

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

 

 

161

147

    def test_rename(self):

162

148

        # Rename should be semi-atomic on all platforms

163

 

        self.create_file('a', 'something in a\n')

 

149

        open('a', 'wb').write('something in a\n')

164

150

        osutils.rename('a', 'b')

165

151

        self.failIfExists('a')

166

152

        self.failUnlessExists('b')

167

153

        self.check_file_contents('b', 'something in a\n')

168

154

 

169

 

        self.create_file('a', 'new something in a\n')

 

155

        open('a', 'wb').write('new something in a\n')

170

156

        osutils.rename('b', 'a')

171

157

 

172

158

        self.check_file_contents('a', 'something in a\n')

380

366

        # Instead blackbox.test_locale should check for localized

381

367

        # dates once they do occur in output strings.

382

368

 

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

 

 

391

369

    def test_local_time_offset(self):

392

370

        """Test that local_time_offset() returns a sane value."""

393

371

        offset = osutils.local_time_offset()

989

967

 

990

968

    def test_osutils_binding(self):

991

969

        from bzrlib.tests import test__chunks_to_lines

992

 

        if test__chunks_to_lines.compiled_chunkstolines_feature.available():

 

970

        if test__chunks_to_lines.CompiledChunksToLinesFeature.available():

993

971

            from bzrlib._chunks_to_lines_pyx import chunks_to_lines

994

972

        else:

995

973

            from bzrlib._chunks_to_lines_py import chunks_to_lines

1135

1113

            dirblock[:] = new_dirblock

1136

1114

 

1137

1115

    def _save_platform_info(self):

1138

 

        self.overrideAttr(win32utils, 'winver')

1139

 

        self.overrideAttr(osutils, '_fs_enc')

1140

 

        self.overrideAttr(osutils, '_selected_dir_reader')

 

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)

1141

1124

 

1142

1125

    def assertDirReaderIs(self, expected):

1143

1126

        """Assert the right implementation for _walkdirs_utf8 is chosen."""

1176

1159

 

1177

1160

    def test_force_walkdirs_utf8_nt(self):

1178

1161

        # Disabled because the thunk of the whole walkdirs api is disabled.

1179

 

        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)

 

1162

        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)

1180

1163

        self._save_platform_info()

1181

1164

        win32utils.winver = 'Windows NT'

1182

1165

        from bzrlib._walkdirs_win32 import Win32ReadDir

1183

1166

        self.assertDirReaderIs(Win32ReadDir)

1184

1167

 

1185

1168

    def test_force_walkdirs_utf8_98(self):

1186

 

        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)

 

1169

        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)

1187

1170

        self._save_platform_info()

1188

1171

        win32utils.winver = 'Windows 98'

1189

1172

        self.assertDirReaderIs(osutils.UnicodeDirReader)

1340

1323

        self.assertEqual(expected_dirblocks, result)

1341

1324

 

1342

1325

    def test__walkdirs_utf8_win32readdir(self):

1343

 

        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)

 

1326

        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)

1344

1327

        self.requireFeature(tests.UnicodeFilenameFeature)

1345

1328

        from bzrlib._walkdirs_win32 import Win32ReadDir

1346

1329

        self._save_platform_info()

1397

1380

 

1398

1381

    def test__walkdirs_utf_win32_find_file_stat_file(self):

1399

1382

        """make sure our Stat values are valid"""

1400

 

        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)

 

1383

        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)

1401

1384

        self.requireFeature(tests.UnicodeFilenameFeature)

1402

1385

        from bzrlib._walkdirs_win32 import Win32ReadDir

1403

1386

        name0u = u'0file-\xb6'

1421

1404

 

1422

1405

    def test__walkdirs_utf_win32_find_file_stat_directory(self):

1423

1406

        """make sure our Stat values are valid"""

1424

 

        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)

 

1407

        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)

1425

1408

        self.requireFeature(tests.UnicodeFilenameFeature)

1426

1409

        from bzrlib._walkdirs_win32 import Win32ReadDir

1427

1410

        name0u = u'0dir-\u062c\u0648'

1576

1559

        def cleanup():

1577

1560

            if 'BZR_TEST_ENV_VAR' in os.environ:

1578

1561

                del os.environ['BZR_TEST_ENV_VAR']

 

1562

 

1579

1563

        self.addCleanup(cleanup)

1580

1564

 

1581

1565

    def test_set(self):

1629

1613

        text = 'test\r\nwith\nall\rpossible line endings\r\n'

1630

1614

        self.build_tree_contents([('foo', text)])

1631

1615

        expected_sha = osutils.sha_string(text)

1632

 

        f = open('foo', 'rb')

 

1616

        f = open('foo')

1633

1617

        self.addCleanup(f.close)

1634

1618

        size, sha = osutils.size_sha_file(f)

1635

1619

        self.assertEqual(38, size)

1692

1676

 

1693

1677

    def setUp(self):

1694

1678

        tests.TestCaseInTempDir.setUp(self)

1695

 

        self.overrideAttr(osutils,

1696

 

                          '_selected_dir_reader', self._dir_reader_class())

 

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()

1697

1688

 

1698

1689

    def _get_ascii_tree(self):

1699

1690

        tree = [

1844

1835

 

1845

1836

class TestConcurrency(tests.TestCase):

1846

1837

 

1847

 

    def setUp(self):

1848

 

        super(TestConcurrency, self).setUp()

1849

 

        self.overrideAttr(osutils, '_cached_local_concurrency')

1850

 

 

1851

1838

    def test_local_concurrency(self):

1852

1839

        concurrency = osutils.local_concurrency()

1853

1840

        self.assertIsInstance(concurrency, int)

1854

1841

 

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

 

 

1870

1842

 

1871

1843

class TestFailedToLoadExtension(tests.TestCase):

1872

1844

 

1879

1851

 

1880

1852

    def setUp(self):

1881

1853

        super(TestFailedToLoadExtension, self).setUp()

1882

 

        self.overrideAttr(osutils, '_extension_load_failures', [])

 

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

1883

1860

 

1884

1861

    def test_failure_to_load(self):

1885

1862

        self._try_loading()

1903

1880

            r"bzr: warning: some compiled extensions could not be loaded; "

1904

1881

            "see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"

1905

1882

            )

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()

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1