~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils.py

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

• reverse the comparison (6449.5.1 to 6015.59.1)
• stop comparing with revision 6015.59.1

Show diffs side-by-side

added

removed

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

429

430

class TestLinks(tests.TestCaseInTempDir):

430

431

 

431

432

    def test_dereference_path(self):

432

 

        self.requireFeature(tests.SymlinkFeature)

 

433

        self.requireFeature(features.SymlinkFeature)

433

434

        cwd = osutils.realpath('.')

434

435

        os.mkdir('bar')

435

436

        bar_path = osutils.pathjoin(cwd, 'bar')

482

483

 

483

484

class TestCanonicalRelPath(tests.TestCaseInTempDir):

484

485

 

485

 

    _test_needs_features = [tests.CaseInsCasePresFilenameFeature]

 

486

    _test_needs_features = [features.CaseInsCasePresFilenameFeature]

486

487

 

487

488

    def test_canonical_relpath_simple(self):

488

489

        f = file('MixedCaseName', 'w')

898

899

    """Test win32 functions that create files."""

899

900

 

900

901

    def test_getcwd(self):

901

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

902

        self.requireFeature(features.UnicodeFilenameFeature)

902

903

        os.mkdir(u'mu-\xb5')

903

904

        os.chdir(u'mu-\xb5')

904

905

        # TODO: jam 20060427 This will probably fail on Mac OSX because

994

995

    """Test mac special functions that require directories."""

995

996

 

996

997

    def test_getcwd(self):

997

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

998

        self.requireFeature(features.UnicodeFilenameFeature)

998

999

        os.mkdir(u'B\xe5gfors')

999

1000

        os.chdir(u'B\xe5gfors')

1000

1001

        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')

1001

1002

 

1002

1003

    def test_getcwd_nonnorm(self):

1003

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

1004

        self.requireFeature(features.UnicodeFilenameFeature)

1004

1005

        # Test that _mac_getcwd() will normalize this path

1005

1006

        os.mkdir(u'Ba\u030agfors')

1006

1007

        os.chdir(u'Ba\u030agfors')

1116

1117

        # are not using the filesystem's encoding

1117

1118

 

1118

1119

        # require a bytestring based filesystem

1119

 

        self.requireFeature(tests.ByteStringNamedFilesystem)

 

1120

        self.requireFeature(features.ByteStringNamedFilesystem)

1120

1121

 

1121

1122

        tree = [

1122

1123

            '.bzr',

1216

1217

        self.requireFeature(UTF8DirReaderFeature)

1217

1218

        self._save_platform_info()

1218

1219

        win32utils.winver = None # Avoid the win32 detection code

1219

 

        osutils._fs_enc = 'UTF-8'

1220

 

        self.assertDirReaderIs(UTF8DirReaderFeature.reader)

 

1220

        osutils._fs_enc = 'utf-8'

 

1221

        self.assertDirReaderIs(

 

1222

            UTF8DirReaderFeature.module.UTF8DirReader)

1221

1223

 

1222

1224

    def test_force_walkdirs_utf8_fs_ascii(self):

1223

1225

        self.requireFeature(UTF8DirReaderFeature)

1224

1226

        self._save_platform_info()

1225

1227

        win32utils.winver = None # Avoid the win32 detection code

1226

 

        osutils._fs_enc = 'US-ASCII'

1227

 

        self.assertDirReaderIs(UTF8DirReaderFeature.reader)

1228

 

 

1229

 

    def test_force_walkdirs_utf8_fs_ANSI(self):

1230

 

        self.requireFeature(UTF8DirReaderFeature)

1231

 

        self._save_platform_info()

1232

 

        win32utils.winver = None # Avoid the win32 detection code

1233

 

        osutils._fs_enc = 'ANSI_X3.4-1968'

1234

 

        self.assertDirReaderIs(UTF8DirReaderFeature.reader)

 

1228

        osutils._fs_enc = 'ascii'

 

1229

        self.assertDirReaderIs(

 

1230

            UTF8DirReaderFeature.module.UTF8DirReader)

1235

1231

 

1236

1232

    def test_force_walkdirs_utf8_fs_latin1(self):

1237

1233

        self._save_platform_info()

1238

1234

        win32utils.winver = None # Avoid the win32 detection code

1239

 

        osutils._fs_enc = 'latin1'

 

1235

        osutils._fs_enc = 'iso-8859-1'

1240

1236

        self.assertDirReaderIs(osutils.UnicodeDirReader)

1241

1237

 

1242

1238

    def test_force_walkdirs_utf8_nt(self):

1255

1251

 

1256

1252

    def test_unicode_walkdirs(self):

1257

1253

        """Walkdirs should always return unicode paths."""

1258

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

1254

        self.requireFeature(features.UnicodeFilenameFeature)

1259

1255

        name0 = u'0file-\xb6'

1260

1256

        name1 = u'1dir-\u062c\u0648'

1261

1257

        name2 = u'2file-\u0633'

1298

1294

 

1299

1295

        The abspath portion might be in unicode or utf-8

1300

1296

        """

1301

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

1297

        self.requireFeature(features.UnicodeFilenameFeature)

1302

1298

        name0 = u'0file-\xb6'

1303

1299

        name1 = u'1dir-\u062c\u0648'

1304

1300

        name2 = u'2file-\u0633'

1359

1355

 

1360

1356

        The abspath portion should be in unicode

1361

1357

        """

1362

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

1358

        self.requireFeature(features.UnicodeFilenameFeature)

1363

1359

        # Use the unicode reader. TODO: split into driver-and-driven unit

1364

1360

        # tests.

1365

1361

        self._save_platform_info()

1406

1402

 

1407

1403

    def test__walkdirs_utf8_win32readdir(self):

1408

1404

        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)

1409

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

1405

        self.requireFeature(features.UnicodeFilenameFeature)

1410

1406

        from bzrlib._walkdirs_win32 import Win32ReadDir

1411

1407

        self._save_platform_info()

1412

1408

        osutils._selected_dir_reader = Win32ReadDir()

1463

1459

    def test__walkdirs_utf_win32_find_file_stat_file(self):

1464

1460

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

1465

1461

        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)

1466

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

1462

        self.requireFeature(features.UnicodeFilenameFeature)

1467

1463

        from bzrlib._walkdirs_win32 import Win32ReadDir

1468

1464

        name0u = u'0file-\xb6'

1469

1465

        name0 = name0u.encode('utf8')

1487

1483

    def test__walkdirs_utf_win32_find_file_stat_directory(self):

1488

1484

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

1489

1485

        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)

1490

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

1486

        self.requireFeature(features.UnicodeFilenameFeature)

1491

1487

        from bzrlib._walkdirs_win32 import Win32ReadDir

1492

1488

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

1493

1489

        name0 = name0u.encode('utf8')

1593

1589

        self.assertEqual(['c'], os.listdir('target/b'))

1594

1590

 

1595

1591

    def test_copy_tree_symlinks(self):

1596

 

        self.requireFeature(tests.SymlinkFeature)

 

1592

        self.requireFeature(features.SymlinkFeature)

1597

1593

        self.build_tree(['source/'])

1598

1594

        os.symlink('a/generic/path', 'source/lnk')

1599

1595

        osutils.copy_tree('source', 'target')

1866

1862

        return filtered_dirblocks

1867

1863

 

1868

1864

    def test_walk_unicode_tree(self):

1869

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

1865

        self.requireFeature(features.UnicodeFilenameFeature)

1870

1866

        tree, expected_dirblocks = self._get_unicode_tree()

1871

1867

        self.build_tree(tree)

1872

1868

        result = list(osutils._walkdirs_utf8('.'))

1873

1869

        self.assertEqual(expected_dirblocks, self._filter_out(result))

1874

1870

 

1875

1871

    def test_symlink(self):

1876

 

        self.requireFeature(tests.SymlinkFeature)

1877

 

        self.requireFeature(tests.UnicodeFilenameFeature)

 

1872

        self.requireFeature(features.SymlinkFeature)

 

1873

        self.requireFeature(features.UnicodeFilenameFeature)

1878

1874

        target = u'target\N{Euro Sign}'

1879

1875

        link_name = u'l\N{Euro Sign}nk'

1880

1876

        os.symlink(target, link_name)

1898

1894

    But prior python versions failed to properly encode the passed unicode

1899

1895

    string.

1900

1896

    """

1901

 

    _test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]

 

1897

    _test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]

1902

1898

 

1903

1899

    def setUp(self):

1904

1900

        super(tests.TestCaseInTempDir, self).setUp()

2101

2097

 

2102

2098

class TestGetuserUnicode(tests.TestCase):

2103

2099

 

 

2100

    def test_is_unicode(self):

 

2101

        user = osutils.getuser_unicode()

 

2102

        self.assertIsInstance(user, unicode)

 

2103

 

 

2104

    def envvar_to_override(self):

 

2105

        if sys.platform == "win32":

 

2106

            # Disable use of platform calls on windows so envvar is used

 

2107

            self.overrideAttr(win32utils, 'has_ctypes', False)

 

2108

            return 'USERNAME' # only variable used on windows

 

2109

        return 'LOGNAME' # first variable checked by getpass.getuser()

 

2110

 

2104

2111

    def test_ascii_user(self):

2105

 

        self.overrideEnv('LOGNAME', 'jrandom')

 

2112

        self.overrideEnv(self.envvar_to_override(), 'jrandom')

2106

2113

        self.assertEqual(u'jrandom', osutils.getuser_unicode())

2107

2114

 

2108

2115

    def test_unicode_user(self):

2114

2121

                % (osutils.get_user_encoding(),))

2115

2122

        uni_username = u'jrandom' + uni_val

2116

2123

        encoded_username = uni_username.encode(ue)

2117

 

        self.overrideEnv('LOGNAME', encoded_username)

 

2124

        self.overrideEnv(self.envvar_to_override(), encoded_username)

2118

2125

        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

2126

 

2128

2127

 

2129

2128

class TestBackupNames(tests.TestCase):

2176

2175

        self.assertTrue(osutils.find_executable_on_path('sh') is not None)

2177

2176

        self.assertTrue(

2178

2177

            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)

 

2178

 

 

2179

 

 

2180

class TestEnvironmentErrors(tests.TestCase):

 

2181

    """Test handling of environmental errors"""

 

2182

 

 

2183

    def test_is_oserror(self):

 

2184

        self.assertTrue(osutils.is_environment_error(

 

2185

            OSError(errno.EINVAL, "Invalid parameter")))

 

2186

 

 

2187

    def test_is_ioerror(self):

 

2188

        self.assertTrue(osutils.is_environment_error(

 

2189

            IOError(errno.EINVAL, "Invalid parameter")))

 

2190

 

 

2191

    def test_is_socket_error(self):

 

2192

        self.assertTrue(osutils.is_environment_error(

 

2193

            socket.error(errno.EINVAL, "Invalid parameter")))

 

2194

 

 

2195

    def test_is_select_error(self):

 

2196

        self.assertTrue(osutils.is_environment_error(

 

2197

            select.error(errno.EINVAL, "Invalid parameter")))

 

2198

 

 

2199

    def test_is_pywintypes_error(self):

 

2200

        self.requireFeature(features.pywintypes)

 

2201

        import pywintypes

 

2202

        self.assertTrue(osutils.is_environment_error(

 

2203

            pywintypes.error(errno.EINVAL, "Invalid parameter", "Caller")))

• Older »

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