← 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: Canonical.com Patch Queue Manager
  • Date: 2011-05-11 15:04:23 UTC
  • mfrom: (5848.1.1 2.4-cython-first)
  • Revision ID: pqm@pqm.ubuntu.com-20110511150423-tpm1ablukqalkvim
(jameinel) Default to using Cython for compiling code,
 rather than Pyrex. (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
1
 
# Copyright (C) 2005-2016 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
20
20
import errno
21
21
import os
22
22
import re
23
 
import select
24
23
import socket
25
24
import sys
26
 
import tempfile
27
25
import time
28
26
 
29
27
from bzrlib import (
43
41
from bzrlib.tests.scenarios import load_tests_apply_scenarios
44
42
 
45
43
 
46
 
class _UTF8DirReaderFeature(features.Feature):
 
44
class _UTF8DirReaderFeature(tests.Feature):
47
45
 
48
46
    def _probe(self):
49
47
        try:
56
54
    def feature_name(self):
57
55
        return 'bzrlib._readdir_pyx'
58
56
 
59
 
UTF8DirReaderFeature = features.ModuleAvailableFeature('bzrlib._readdir_pyx')
 
57
UTF8DirReaderFeature = _UTF8DirReaderFeature()
60
58
 
61
 
term_ios_feature = features.ModuleAvailableFeature('termios')
 
59
term_ios_feature = tests.ModuleAvailableFeature('termios')
62
60
 
63
61
 
64
62
def _already_unicode(s):
180
178
        # we can't use failUnlessExists on case-insensitive filesystem
181
179
        # so try to check shape of the tree
182
180
        shape = sorted(os.listdir('.'))
183
 
        self.assertEqual(['A', 'B'], shape)
184
 
 
185
 
    def test_rename_exception(self):
186
 
        try:
187
 
            osutils.rename('nonexistent_path', 'different_nonexistent_path')
188
 
        except OSError, e:
189
 
            self.assertEqual(e.old_filename, 'nonexistent_path')
190
 
            self.assertEqual(e.new_filename, 'different_nonexistent_path')
191
 
            self.assertTrue('nonexistent_path' in e.strerror)
192
 
            self.assertTrue('different_nonexistent_path' in e.strerror)
 
181
        self.assertEquals(['A', 'B'], shape)
193
182
 
194
183
 
195
184
class TestRandChars(tests.TestCase):
222
211
                         (['src'], SRC_FOO_C),
223
212
                         (['src'], 'src'),
224
213
                         ]:
225
 
            self.assertTrue(osutils.is_inside_any(dirs, fn))
 
214
            self.assert_(osutils.is_inside_any(dirs, fn))
226
215
        for dirs, fn in [(['src'], 'srccontrol'),
227
216
                         (['src'], 'srccontrol/foo')]:
228
217
            self.assertFalse(osutils.is_inside_any(dirs, fn))
234
223
                         (['src/bar.c', 'bla/foo.c'], 'src'),
235
224
                         (['src'], 'src'),
236
225
                         ]:
237
 
            self.assertTrue(osutils.is_inside_or_parent_of_any(dirs, fn))
 
226
            self.assert_(osutils.is_inside_or_parent_of_any(dirs, fn))
238
227
 
239
228
        for dirs, fn in [(['src'], 'srccontrol'),
240
229
                         (['srccontrol/foo.c'], 'src'),
298
287
 
299
288
    def test_file_kind(self):
300
289
        self.build_tree(['file', 'dir/'])
301
 
        self.assertEqual('file', osutils.file_kind('file'))
302
 
        self.assertEqual('directory', osutils.file_kind('dir/'))
 
290
        self.assertEquals('file', osutils.file_kind('file'))
 
291
        self.assertEquals('directory', osutils.file_kind('dir/'))
303
292
        if osutils.has_symlinks():
304
293
            os.symlink('symlink', 'symlink')
305
 
            self.assertEqual('symlink', osutils.file_kind('symlink'))
 
294
            self.assertEquals('symlink', osutils.file_kind('symlink'))
306
295
 
307
296
        # TODO: jam 20060529 Test a block device
308
297
        try:
311
300
            if e.errno not in (errno.ENOENT,):
312
301
                raise
313
302
        else:
314
 
            self.assertEqual('chardev', osutils.file_kind('/dev/null'))
 
303
            self.assertEquals('chardev', osutils.file_kind('/dev/null'))
315
304
 
316
305
        mkfifo = getattr(os, 'mkfifo', None)
317
306
        if mkfifo:
318
307
            mkfifo('fifo')
319
308
            try:
320
 
                self.assertEqual('fifo', osutils.file_kind('fifo'))
 
309
                self.assertEquals('fifo', osutils.file_kind('fifo'))
321
310
            finally:
322
311
                os.remove('fifo')
323
312
 
326
315
            s = socket.socket(AF_UNIX)
327
316
            s.bind('socket')
328
317
            try:
329
 
                self.assertEqual('socket', osutils.file_kind('socket'))
 
318
                self.assertEquals('socket', osutils.file_kind('socket'))
330
319
            finally:
331
320
                os.remove('socket')
332
321
 
437
426
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
438
427
 
439
428
 
440
 
class TestFdatasync(tests.TestCaseInTempDir):
441
 
 
442
 
    def do_fdatasync(self):
443
 
        f = tempfile.NamedTemporaryFile()
444
 
        osutils.fdatasync(f.fileno())
445
 
        f.close()
446
 
 
447
 
    @staticmethod
448
 
    def raise_eopnotsupp(*args, **kwargs):
449
 
        raise IOError(errno.EOPNOTSUPP, os.strerror(errno.EOPNOTSUPP))
450
 
 
451
 
    @staticmethod
452
 
    def raise_enotsup(*args, **kwargs):
453
 
        raise IOError(errno.ENOTSUP, os.strerror(errno.ENOTSUP))
454
 
 
455
 
    def test_fdatasync_handles_system_function(self):
456
 
        self.overrideAttr(os, "fdatasync")
457
 
        self.do_fdatasync()
458
 
 
459
 
    def test_fdatasync_handles_no_fdatasync_no_fsync(self):
460
 
        self.overrideAttr(os, "fdatasync")
461
 
        self.overrideAttr(os, "fsync")
462
 
        self.do_fdatasync()
463
 
 
464
 
    def test_fdatasync_handles_no_EOPNOTSUPP(self):
465
 
        self.overrideAttr(errno, "EOPNOTSUPP")
466
 
        self.do_fdatasync()
467
 
 
468
 
    def test_fdatasync_catches_ENOTSUP(self):
469
 
        enotsup = getattr(errno, "ENOTSUP", None)
470
 
        if enotsup is None:
471
 
            raise tests.TestNotApplicable("No ENOTSUP on this platform")
472
 
        self.overrideAttr(os, "fdatasync", self.raise_enotsup)
473
 
        self.do_fdatasync()
474
 
 
475
 
    def test_fdatasync_catches_EOPNOTSUPP(self):
476
 
        enotsup = getattr(errno, "EOPNOTSUPP", None)
477
 
        if enotsup is None:
478
 
            raise tests.TestNotApplicable("No EOPNOTSUPP on this platform")
479
 
        self.overrideAttr(os, "fdatasync", self.raise_eopnotsupp)
480
 
        self.do_fdatasync()
481
 
 
482
 
 
483
429
class TestLinks(tests.TestCaseInTempDir):
484
430
 
485
431
    def test_dereference_path(self):
486
 
        self.requireFeature(features.SymlinkFeature)
 
432
        self.requireFeature(tests.SymlinkFeature)
487
433
        cwd = osutils.realpath('.')
488
434
        os.mkdir('bar')
489
435
        bar_path = osutils.pathjoin(cwd, 'bar')
536
482
 
537
483
class TestCanonicalRelPath(tests.TestCaseInTempDir):
538
484
 
539
 
    _test_needs_features = [features.CaseInsCasePresFilenameFeature]
 
485
    _test_needs_features = [tests.CaseInsCasePresFilenameFeature]
540
486
 
541
487
    def test_canonical_relpath_simple(self):
542
488
        f = file('MixedCaseName', 'w')
598
544
    """Test pumpfile method."""
599
545
 
600
546
    def setUp(self):
601
 
        super(TestPumpFile, self).setUp()
 
547
        tests.TestCase.setUp(self)
602
548
        # create a test datablock
603
549
        self.block_size = 512
604
550
        pattern = '0123456789ABCDEF'
872
818
        self.assertEqual(None, osutils.safe_file_id(None))
873
819
 
874
820
 
875
 
class TestSendAll(tests.TestCase):
876
 
 
877
 
    def test_send_with_disconnected_socket(self):
878
 
        class DisconnectedSocket(object):
879
 
            def __init__(self, err):
880
 
                self.err = err
881
 
            def send(self, content):
882
 
                raise self.err
883
 
            def close(self):
884
 
                pass
885
 
        # All of these should be treated as ConnectionReset
886
 
        errs = []
887
 
        for err_cls in (IOError, socket.error):
888
 
            for errnum in osutils._end_of_stream_errors:
889
 
                errs.append(err_cls(errnum))
890
 
        for err in errs:
891
 
            sock = DisconnectedSocket(err)
892
 
            self.assertRaises(errors.ConnectionReset,
893
 
                osutils.send_all, sock, 'some more content')
894
 
 
895
 
    def test_send_with_no_progress(self):
896
 
        # See https://bugs.launchpad.net/bzr/+bug/1047309
897
 
        # It seems that paramiko can get into a state where it doesn't error,
898
 
        # but it returns 0 bytes sent for requests over and over again.
899
 
        class NoSendingSocket(object):
900
 
            def __init__(self):
901
 
                self.call_count = 0
902
 
            def send(self, bytes):
903
 
                self.call_count += 1
904
 
                if self.call_count > 100:
905
 
                    # Prevent the test suite from hanging
906
 
                    raise RuntimeError('too many calls')
907
 
                return 0
908
 
        sock = NoSendingSocket()
909
 
        self.assertRaises(errors.ConnectionReset,
910
 
                          osutils.send_all, sock, 'content')
911
 
        self.assertEqual(1, sock.call_count)
912
 
 
913
 
 
914
 
class TestPosixFuncs(tests.TestCase):
915
 
    """Test that the posix version of normpath returns an appropriate path
916
 
       when used with 2 leading slashes."""
917
 
 
918
 
    def test_normpath(self):
919
 
        self.assertEqual('/etc/shadow', osutils._posix_normpath('/etc/shadow'))
920
 
        self.assertEqual('/etc/shadow', osutils._posix_normpath('//etc/shadow'))
921
 
        self.assertEqual('/etc/shadow', osutils._posix_normpath('///etc/shadow'))
922
 
 
923
 
 
924
821
class TestWin32Funcs(tests.TestCase):
925
822
    """Test that _win32 versions of os utilities return appropriate paths."""
926
823
 
927
824
    def test_abspath(self):
928
 
        self.requireFeature(features.win32_feature)
929
825
        self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
930
826
        self.assertEqual('C:/foo', osutils._win32_abspath('C:/foo'))
931
827
        self.assertEqual('//HOST/path', osutils._win32_abspath(r'\\HOST\path'))
944
840
                         osutils._win32_pathjoin('path/to', 'C:/foo'))
945
841
        self.assertEqual('path/to/foo',
946
842
                         osutils._win32_pathjoin('path/to/', 'foo'))
947
 
 
948
 
    def test_pathjoin_late_bugfix(self):
949
 
        if sys.version_info < (2, 7, 6):
950
 
            expected = '/foo'
951
 
        else:
952
 
            expected = 'C:/foo'
953
 
        self.assertEqual(expected,
 
843
        self.assertEqual('/foo',
954
844
                         osutils._win32_pathjoin('C:/path/to/', '/foo'))
955
 
        self.assertEqual(expected,
 
845
        self.assertEqual('/foo',
956
846
                         osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
957
847
 
958
848
    def test_normpath(self):
978
868
        self.assertEqual('C:\\foo', osutils._win32_fixdrive('c:\\foo'))
979
869
 
980
870
    def test_win98_abspath(self):
981
 
        self.requireFeature(features.win32_feature)
982
871
        # absolute path
983
872
        self.assertEqual('C:/foo', osutils._win98_abspath('C:\\foo'))
984
873
        self.assertEqual('C:/foo', osutils._win98_abspath('C:/foo'))
999
888
    """Test win32 functions that create files."""
1000
889
 
1001
890
    def test_getcwd(self):
1002
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
891
        self.requireFeature(tests.UnicodeFilenameFeature)
1003
892
        os.mkdir(u'mu-\xb5')
1004
893
        os.chdir(u'mu-\xb5')
1005
894
        # TODO: jam 20060427 This will probably fail on Mac OSX because
1095
984
    """Test mac special functions that require directories."""
1096
985
 
1097
986
    def test_getcwd(self):
1098
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
987
        self.requireFeature(tests.UnicodeFilenameFeature)
1099
988
        os.mkdir(u'B\xe5gfors')
1100
989
        os.chdir(u'B\xe5gfors')
1101
990
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
1102
991
 
1103
992
    def test_getcwd_nonnorm(self):
1104
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
993
        self.requireFeature(tests.UnicodeFilenameFeature)
1105
994
        # Test that _mac_getcwd() will normalize this path
1106
995
        os.mkdir(u'Ba\u030agfors')
1107
996
        os.chdir(u'Ba\u030agfors')
1205
1094
        # (It would be ok if it happened earlier but at the moment it
1206
1095
        # doesn't.)
1207
1096
        e = self.assertRaises(OSError, list, osutils._walkdirs_utf8("."))
1208
 
        self.assertEqual('./test-unreadable', e.filename)
1209
 
        self.assertEqual(errno.EACCES, e.errno)
 
1097
        self.assertEquals('./test-unreadable', e.filename)
 
1098
        self.assertEquals(errno.EACCES, e.errno)
1210
1099
        # Ensure the message contains the file name
1211
1100
        self.assertContainsRe(str(e), "\./test-unreadable")
1212
1101
 
1217
1106
        # are not using the filesystem's encoding
1218
1107
 
1219
1108
        # require a bytestring based filesystem
1220
 
        self.requireFeature(features.ByteStringNamedFilesystem)
 
1109
        self.requireFeature(tests.ByteStringNamedFilesystem)
1221
1110
 
1222
1111
        tree = [
1223
1112
            '.bzr',
1317
1206
        self.requireFeature(UTF8DirReaderFeature)
1318
1207
        self._save_platform_info()
1319
1208
        win32utils.winver = None # Avoid the win32 detection code
1320
 
        osutils._fs_enc = 'utf-8'
1321
 
        self.assertDirReaderIs(
1322
 
            UTF8DirReaderFeature.module.UTF8DirReader)
 
1209
        osutils._fs_enc = 'UTF-8'
 
1210
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1323
1211
 
1324
1212
    def test_force_walkdirs_utf8_fs_ascii(self):
1325
1213
        self.requireFeature(UTF8DirReaderFeature)
1326
1214
        self._save_platform_info()
1327
1215
        win32utils.winver = None # Avoid the win32 detection code
1328
 
        osutils._fs_enc = 'ascii'
1329
 
        self.assertDirReaderIs(
1330
 
            UTF8DirReaderFeature.module.UTF8DirReader)
 
1216
        osutils._fs_enc = 'US-ASCII'
 
1217
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
1218
 
 
1219
    def test_force_walkdirs_utf8_fs_ANSI(self):
 
1220
        self.requireFeature(UTF8DirReaderFeature)
 
1221
        self._save_platform_info()
 
1222
        win32utils.winver = None # Avoid the win32 detection code
 
1223
        osutils._fs_enc = 'ANSI_X3.4-1968'
 
1224
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1331
1225
 
1332
1226
    def test_force_walkdirs_utf8_fs_latin1(self):
1333
1227
        self._save_platform_info()
1334
1228
        win32utils.winver = None # Avoid the win32 detection code
1335
 
        osutils._fs_enc = 'iso-8859-1'
 
1229
        osutils._fs_enc = 'latin1'
1336
1230
        self.assertDirReaderIs(osutils.UnicodeDirReader)
1337
1231
 
1338
1232
    def test_force_walkdirs_utf8_nt(self):
1351
1245
 
1352
1246
    def test_unicode_walkdirs(self):
1353
1247
        """Walkdirs should always return unicode paths."""
1354
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1248
        self.requireFeature(tests.UnicodeFilenameFeature)
1355
1249
        name0 = u'0file-\xb6'
1356
1250
        name1 = u'1dir-\u062c\u0648'
1357
1251
        name2 = u'2file-\u0633'
1394
1288
 
1395
1289
        The abspath portion might be in unicode or utf-8
1396
1290
        """
1397
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1291
        self.requireFeature(tests.UnicodeFilenameFeature)
1398
1292
        name0 = u'0file-\xb6'
1399
1293
        name1 = u'1dir-\u062c\u0648'
1400
1294
        name2 = u'2file-\u0633'
1455
1349
 
1456
1350
        The abspath portion should be in unicode
1457
1351
        """
1458
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1352
        self.requireFeature(tests.UnicodeFilenameFeature)
1459
1353
        # Use the unicode reader. TODO: split into driver-and-driven unit
1460
1354
        # tests.
1461
1355
        self._save_platform_info()
1502
1396
 
1503
1397
    def test__walkdirs_utf8_win32readdir(self):
1504
1398
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1505
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1399
        self.requireFeature(tests.UnicodeFilenameFeature)
1506
1400
        from bzrlib._walkdirs_win32 import Win32ReadDir
1507
1401
        self._save_platform_info()
1508
1402
        osutils._selected_dir_reader = Win32ReadDir()
1559
1453
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1560
1454
        """make sure our Stat values are valid"""
1561
1455
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1562
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1456
        self.requireFeature(tests.UnicodeFilenameFeature)
1563
1457
        from bzrlib._walkdirs_win32 import Win32ReadDir
1564
1458
        name0u = u'0file-\xb6'
1565
1459
        name0 = name0u.encode('utf8')
1583
1477
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1584
1478
        """make sure our Stat values are valid"""
1585
1479
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1586
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1480
        self.requireFeature(tests.UnicodeFilenameFeature)
1587
1481
        from bzrlib._walkdirs_win32 import Win32ReadDir
1588
1482
        name0u = u'0dir-\u062c\u0648'
1589
1483
        name0 = name0u.encode('utf8')
1689
1583
        self.assertEqual(['c'], os.listdir('target/b'))
1690
1584
 
1691
1585
    def test_copy_tree_symlinks(self):
1692
 
        self.requireFeature(features.SymlinkFeature)
 
1586
        self.requireFeature(tests.SymlinkFeature)
1693
1587
        self.build_tree(['source/'])
1694
1588
        os.symlink('a/generic/path', 'source/lnk')
1695
1589
        osutils.copy_tree('source', 'target')
1862
1756
    _native_to_unicode = None
1863
1757
 
1864
1758
    def setUp(self):
1865
 
        super(TestDirReader, self).setUp()
 
1759
        tests.TestCaseInTempDir.setUp(self)
1866
1760
        self.overrideAttr(osutils,
1867
1761
                          '_selected_dir_reader', self._dir_reader_class())
1868
1762
 
1962
1856
        return filtered_dirblocks
1963
1857
 
1964
1858
    def test_walk_unicode_tree(self):
1965
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1859
        self.requireFeature(tests.UnicodeFilenameFeature)
1966
1860
        tree, expected_dirblocks = self._get_unicode_tree()
1967
1861
        self.build_tree(tree)
1968
1862
        result = list(osutils._walkdirs_utf8('.'))
1969
1863
        self.assertEqual(expected_dirblocks, self._filter_out(result))
1970
1864
 
1971
1865
    def test_symlink(self):
1972
 
        self.requireFeature(features.SymlinkFeature)
1973
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
1866
        self.requireFeature(tests.SymlinkFeature)
 
1867
        self.requireFeature(tests.UnicodeFilenameFeature)
1974
1868
        target = u'target\N{Euro Sign}'
1975
1869
        link_name = u'l\N{Euro Sign}nk'
1976
1870
        os.symlink(target, link_name)
1994
1888
    But prior python versions failed to properly encode the passed unicode
1995
1889
    string.
1996
1890
    """
1997
 
    _test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]
 
1891
    _test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
1998
1892
 
1999
1893
    def setUp(self):
2000
1894
        super(tests.TestCaseInTempDir, self).setUp()
2003
1897
        os.symlink(self.target, self.link)
2004
1898
 
2005
1899
    def test_os_readlink_link_encoding(self):
2006
 
        self.assertEqual(self.target,  os.readlink(self.link))
 
1900
        if sys.version_info < (2, 6):
 
1901
            self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
 
1902
        else:
 
1903
            self.assertEquals(self.target,  os.readlink(self.link))
2007
1904
 
2008
1905
    def test_os_readlink_link_decoding(self):
2009
 
        self.assertEqual(self.target.encode(osutils._fs_enc),
 
1906
        self.assertEquals(self.target.encode(osutils._fs_enc),
2010
1907
                          os.readlink(self.link.encode(osutils._fs_enc)))
2011
1908
 
2012
1909
 
2032
1929
        self.overrideEnv('BZR_CONCURRENCY', '1')
2033
1930
        self.run_bzr('rocks --concurrency 42')
2034
1931
        # Command line overrides environment variable
2035
 
        self.assertEqual('42', os.environ['BZR_CONCURRENCY'])
2036
 
        self.assertEqual(42, osutils.local_concurrency(use_cache=False))
 
1932
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
 
1933
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
2037
1934
 
2038
1935
 
2039
1936
class TestFailedToLoadExtension(tests.TestCase):
2052
1949
    def test_failure_to_load(self):
2053
1950
        self._try_loading()
2054
1951
        self.assertLength(1, osutils._extension_load_failures)
2055
 
        self.assertEqual(osutils._extension_load_failures[0],
 
1952
        self.assertEquals(osutils._extension_load_failures[0],
2056
1953
            "No module named _fictional_extension_py")
2057
1954
 
2058
1955
    def test_report_extension_load_failures_no_warning(self):
2076
1973
class TestTerminalWidth(tests.TestCase):
2077
1974
 
2078
1975
    def setUp(self):
2079
 
        super(TestTerminalWidth, self).setUp()
 
1976
        tests.TestCase.setUp(self)
2080
1977
        self._orig_terminal_size_state = osutils._terminal_size_state
2081
1978
        self._orig_first_terminal_size = osutils._first_terminal_size
2082
1979
        self.addCleanup(self.restore_osutils_globals)
2158
2055
        # Whatever the result is, if we don't raise an exception, it's ok.
2159
2056
        osutils.terminal_width()
2160
2057
 
2161
 
 
2162
2058
class TestCreationOps(tests.TestCaseInTempDir):
2163
2059
    _test_needs_features = [features.chown_feature]
2164
2060
 
2165
2061
    def setUp(self):
2166
 
        super(TestCreationOps, self).setUp()
 
2062
        tests.TestCaseInTempDir.setUp(self)
2167
2063
        self.overrideAttr(os, 'chown', self._dummy_chown)
2168
2064
 
2169
2065
        # params set by call to _dummy_chown
2179
2075
        osutils.copy_ownership_from_path('test_file', ownsrc)
2180
2076
 
2181
2077
        s = os.stat(ownsrc)
2182
 
        self.assertEqual(self.path, 'test_file')
2183
 
        self.assertEqual(self.uid, s.st_uid)
2184
 
        self.assertEqual(self.gid, s.st_gid)
 
2078
        self.assertEquals(self.path, 'test_file')
 
2079
        self.assertEquals(self.uid, s.st_uid)
 
2080
        self.assertEquals(self.gid, s.st_gid)
2185
2081
 
2186
2082
    def test_copy_ownership_nonesrc(self):
2187
2083
        """copy_ownership_from_path test with src=None."""
2190
2086
        osutils.copy_ownership_from_path('test_file')
2191
2087
 
2192
2088
        s = os.stat('..')
2193
 
        self.assertEqual(self.path, 'test_file')
2194
 
        self.assertEqual(self.uid, s.st_uid)
2195
 
        self.assertEqual(self.gid, s.st_gid)
2196
 
 
2197
 
 
2198
 
class TestPathFromEnviron(tests.TestCase):
2199
 
 
2200
 
    def test_is_unicode(self):
2201
 
        self.overrideEnv('BZR_TEST_PATH', './anywhere at all/')
2202
 
        path = osutils.path_from_environ('BZR_TEST_PATH')
2203
 
        self.assertIsInstance(path, unicode)
2204
 
        self.assertEqual(u'./anywhere at all/', path)
2205
 
 
2206
 
    def test_posix_path_env_ascii(self):
2207
 
        self.overrideEnv('BZR_TEST_PATH', '/tmp')
2208
 
        home = osutils._posix_path_from_environ('BZR_TEST_PATH')
2209
 
        self.assertIsInstance(home, unicode)
2210
 
        self.assertEqual(u'/tmp', home)
2211
 
 
2212
 
    def test_posix_path_env_unicode(self):
2213
 
        self.requireFeature(features.ByteStringNamedFilesystem)
2214
 
        self.overrideEnv('BZR_TEST_PATH', '/home/\xa7test')
2215
 
        self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
2216
 
        self.assertEqual(u'/home/\xa7test',
2217
 
            osutils._posix_path_from_environ('BZR_TEST_PATH'))
2218
 
        osutils._fs_enc = "iso8859-5"
2219
 
        self.assertEqual(u'/home/\u0407test',
2220
 
            osutils._posix_path_from_environ('BZR_TEST_PATH'))
2221
 
        osutils._fs_enc = "utf-8"
2222
 
        self.assertRaises(errors.BadFilenameEncoding,
2223
 
            osutils._posix_path_from_environ, 'BZR_TEST_PATH')
2224
 
 
2225
 
 
2226
 
class TestGetHomeDir(tests.TestCase):
2227
 
 
2228
 
    def test_is_unicode(self):
2229
 
        home = osutils._get_home_dir()
2230
 
        self.assertIsInstance(home, unicode)
2231
 
 
2232
 
    def test_posix_homeless(self):
2233
 
        self.overrideEnv('HOME', None)
2234
 
        home = osutils._get_home_dir()
2235
 
        self.assertIsInstance(home, unicode)
2236
 
 
2237
 
    def test_posix_home_ascii(self):
2238
 
        self.overrideEnv('HOME', '/home/test')
2239
 
        home = osutils._posix_get_home_dir()
2240
 
        self.assertIsInstance(home, unicode)
2241
 
        self.assertEqual(u'/home/test', home)
2242
 
 
2243
 
    def test_posix_home_unicode(self):
2244
 
        self.requireFeature(features.ByteStringNamedFilesystem)
2245
 
        self.overrideEnv('HOME', '/home/\xa7test')
2246
 
        self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
2247
 
        self.assertEqual(u'/home/\xa7test', osutils._posix_get_home_dir())
2248
 
        osutils._fs_enc = "iso8859-5"
2249
 
        self.assertEqual(u'/home/\u0407test', osutils._posix_get_home_dir())
2250
 
        osutils._fs_enc = "utf-8"
2251
 
        self.assertRaises(errors.BadFilenameEncoding,
2252
 
            osutils._posix_get_home_dir)
2253
 
 
 
2089
        self.assertEquals(self.path, 'test_file')
 
2090
        self.assertEquals(self.uid, s.st_uid)
 
2091
        self.assertEquals(self.gid, s.st_gid)
2254
2092
 
2255
2093
class TestGetuserUnicode(tests.TestCase):
2256
2094
 
2257
 
    def test_is_unicode(self):
2258
 
        user = osutils.getuser_unicode()
2259
 
        self.assertIsInstance(user, unicode)
2260
 
 
2261
 
    def envvar_to_override(self):
2262
 
        if sys.platform == "win32":
2263
 
            # Disable use of platform calls on windows so envvar is used
2264
 
            self.overrideAttr(win32utils, 'has_ctypes', False)
2265
 
            return 'USERNAME' # only variable used on windows
2266
 
        return 'LOGNAME' # first variable checked by getpass.getuser()
2267
 
 
2268
2095
    def test_ascii_user(self):
2269
 
        self.overrideEnv(self.envvar_to_override(), 'jrandom')
 
2096
        self.overrideEnv('LOGNAME', 'jrandom')
2270
2097
        self.assertEqual(u'jrandom', osutils.getuser_unicode())
2271
2098
 
2272
2099
    def test_unicode_user(self):
2278
2105
                % (osutils.get_user_encoding(),))
2279
2106
        uni_username = u'jrandom' + uni_val
2280
2107
        encoded_username = uni_username.encode(ue)
2281
 
        self.overrideEnv(self.envvar_to_override(), encoded_username)
 
2108
        self.overrideEnv('LOGNAME', encoded_username)
2282
2109
        self.assertEqual(uni_username, osutils.getuser_unicode())
2283
 
 
 
2110
        self.overrideEnv('LOGNAME', u'jrandom\xb6'.encode(ue))
 
2111
        self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())
2284
2112
 
2285
2113
class TestBackupNames(tests.TestCase):
2286
2114
 
2325
2153
        self.assertTrue(
2326
2154
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2327
2155
        self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2328
 
        
2329
 
    def test_windows_app_path(self):
2330
 
        if sys.platform != 'win32':
2331
 
            raise tests.TestSkipped('test requires win32')
2332
 
        # Override PATH env var so that exe can only be found on App Path
2333
 
        self.overrideEnv('PATH', '')
2334
 
        # Internt Explorer is always registered in the App Path
2335
 
        self.assertTrue(osutils.find_executable_on_path('iexplore') is not None)
2336
2156
 
2337
2157
    def test_other(self):
2338
2158
        if sys.platform == 'win32':
2340
2160
        self.assertTrue(osutils.find_executable_on_path('sh') is not None)
2341
2161
        self.assertTrue(
2342
2162
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2343
 
 
2344
 
 
2345
 
class TestEnvironmentErrors(tests.TestCase):
2346
 
    """Test handling of environmental errors"""
2347
 
 
2348
 
    def test_is_oserror(self):
2349
 
        self.assertTrue(osutils.is_environment_error(
2350
 
            OSError(errno.EINVAL, "Invalid parameter")))
2351
 
 
2352
 
    def test_is_ioerror(self):
2353
 
        self.assertTrue(osutils.is_environment_error(
2354
 
            IOError(errno.EINVAL, "Invalid parameter")))
2355
 
 
2356
 
    def test_is_socket_error(self):
2357
 
        self.assertTrue(osutils.is_environment_error(
2358
 
            socket.error(errno.EINVAL, "Invalid parameter")))
2359
 
 
2360
 
    def test_is_select_error(self):
2361
 
        self.assertTrue(osutils.is_environment_error(
2362
 
            select.error(errno.EINVAL, "Invalid parameter")))
2363
 
 
2364
 
    def test_is_pywintypes_error(self):
2365
 
        self.requireFeature(features.pywintypes)
2366
 
        import pywintypes
2367
 
        self.assertTrue(osutils.is_environment_error(
2368
 
            pywintypes.error(errno.EINVAL, "Invalid parameter", "Caller")))