← 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: 2008-06-05 04:05:05 UTC
  • mfrom: (3473.1.1 ianc-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20080605040505-i9kqxg2fps2qjdi0
Add the 'alias' command (Tim Penhey)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
16
16
 
17
17
"""Tests for the osutils wrapper."""
18
18
 
19
 
from cStringIO import StringIO
20
19
import errno
21
20
import os
22
21
import socket
23
22
import stat
24
23
import sys
25
 
import time
26
24
 
 
25
import bzrlib
27
26
from bzrlib import (
28
27
    errors,
29
28
    osutils,
30
 
    tests,
31
29
    win32utils,
32
30
    )
33
31
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
36
34
        is_inside_or_parent_of_any,
37
35
        pathjoin,
38
36
        pumpfile,
39
 
        pump_string_file,
40
37
        )
41
38
from bzrlib.tests import (
42
 
        adapt_tests,
43
 
        Feature,
44
39
        probe_unicode_in_user_encoding,
45
 
        split_suite_by_re,
46
40
        StringIOWrapper,
47
41
        SymlinkFeature,
48
42
        TestCase,
49
43
        TestCaseInTempDir,
50
 
        TestScenarioApplier,
51
44
        TestSkipped,
52
45
        )
53
46
from bzrlib.tests.file_utils import (
54
47
    FakeReadFile,
55
48
    )
56
 
from bzrlib.tests.test__walkdirs_win32 import Win32ReadDirFeature
57
 
 
58
 
 
59
 
class _UTF8DirReaderFeature(Feature):
60
 
 
61
 
    def _probe(self):
62
 
        try:
63
 
            from bzrlib import _readdir_pyx
64
 
            self.reader = _readdir_pyx.UTF8DirReader
65
 
            return True
66
 
        except ImportError:
67
 
            return False
68
 
 
69
 
    def feature_name(self):
70
 
        return 'bzrlib._readdir_pyx'
71
 
 
72
 
UTF8DirReaderFeature = _UTF8DirReaderFeature()
73
 
 
 
49
from cStringIO import StringIO
74
50
 
75
51
class TestOSUtils(TestCaseInTempDir):
76
52
 
291
267
    def test_format_date(self):
292
268
        self.assertRaises(errors.UnsupportedTimezoneFormat,
293
269
            osutils.format_date, 0, timezone='foo')
294
 
        self.assertIsInstance(osutils.format_date(0), str)
295
 
        self.assertIsInstance(osutils.format_local_date(0), unicode)
296
 
        # Testing for the actual value of the local weekday without
297
 
        # duplicating the code from format_date is difficult.
298
 
        # Instead blackbox.test_locale should check for localized
299
 
        # dates once they do occur in output strings.
300
270
 
301
271
    def test_dereference_path(self):
302
272
        self.requireFeature(SymlinkFeature)
352
322
        self.assertEqual("@", osutils.kind_marker("symlink"))
353
323
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
354
324
 
355
 
    def test_host_os_dereferences_symlinks(self):
356
 
        osutils.host_os_dereferences_symlinks()
357
 
 
358
325
 
359
326
class TestPumpFile(TestCase):
360
327
    """Test pumpfile method."""
466
433
            message = "Data not equal.  Expected %d bytes, received %d."
467
434
            self.fail(message % (len(response_data), self.test_data_len))
468
435
 
469
 
 
470
 
class TestPumpStringFile(TestCase):
471
 
 
472
 
    def test_empty(self):
473
 
        output = StringIO()
474
 
        pump_string_file("", output)
475
 
        self.assertEqual("", output.getvalue())
476
 
 
477
 
    def test_more_than_segment_size(self):
478
 
        output = StringIO()
479
 
        pump_string_file("123456789", output, 2)
480
 
        self.assertEqual("123456789", output.getvalue())
481
 
 
482
 
    def test_segment_size(self):
483
 
        output = StringIO()
484
 
        pump_string_file("12", output, 2)
485
 
        self.assertEqual("12", output.getvalue())
486
 
 
487
 
    def test_segment_size_multiple(self):
488
 
        output = StringIO()
489
 
        pump_string_file("1234", output, 2)
490
 
        self.assertEqual("1234", output.getvalue())
491
 
 
492
 
 
493
436
class TestSafeUnicode(TestCase):
494
437
 
495
438
    def test_from_ascii_string(self):
872
815
                new_dirblock.append((info[0], info[1], info[2], info[4]))
873
816
            dirblock[:] = new_dirblock
874
817
 
875
 
    def _save_platform_info(self):
876
 
        cur_winver = win32utils.winver
877
 
        cur_fs_enc = osutils._fs_enc
878
 
        cur_dir_reader = osutils._selected_dir_reader
879
 
        def restore():
880
 
            win32utils.winver = cur_winver
881
 
            osutils._fs_enc = cur_fs_enc
882
 
            osutils._selected_dir_reader = cur_dir_reader
883
 
        self.addCleanup(restore)
884
 
 
885
 
    def assertReadFSDirIs(self, expected):
886
 
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
887
 
        # Force it to redetect
888
 
        osutils._selected_dir_reader = None
889
 
        # Nothing to list, but should still trigger the selection logic
890
 
        self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
891
 
        self.assertIsInstance(osutils._selected_dir_reader, expected)
892
 
 
893
 
    def test_force_walkdirs_utf8_fs_utf8(self):
894
 
        self.requireFeature(UTF8DirReaderFeature)
895
 
        self._save_platform_info()
896
 
        win32utils.winver = None # Avoid the win32 detection code
897
 
        osutils._fs_enc = 'UTF-8'
898
 
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
899
 
 
900
 
    def test_force_walkdirs_utf8_fs_ascii(self):
901
 
        self.requireFeature(UTF8DirReaderFeature)
902
 
        self._save_platform_info()
903
 
        win32utils.winver = None # Avoid the win32 detection code
904
 
        osutils._fs_enc = 'US-ASCII'
905
 
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
906
 
 
907
 
    def test_force_walkdirs_utf8_fs_ANSI(self):
908
 
        self.requireFeature(UTF8DirReaderFeature)
909
 
        self._save_platform_info()
910
 
        win32utils.winver = None # Avoid the win32 detection code
911
 
        osutils._fs_enc = 'ANSI_X3.4-1968'
912
 
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
913
 
 
914
 
    def test_force_walkdirs_utf8_fs_latin1(self):
915
 
        self._save_platform_info()
916
 
        win32utils.winver = None # Avoid the win32 detection code
917
 
        osutils._fs_enc = 'latin1'
918
 
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
919
 
 
920
 
    def test_force_walkdirs_utf8_nt(self):
921
 
        # Disabled because the thunk of the whole walkdirs api is disabled.
922
 
        self.requireFeature(Win32ReadDirFeature)
923
 
        self._save_platform_info()
924
 
        win32utils.winver = 'Windows NT'
925
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
926
 
        self.assertReadFSDirIs(Win32ReadDir)
927
 
 
928
 
    def test_force_walkdirs_utf8_98(self):
929
 
        self.requireFeature(Win32ReadDirFeature)
930
 
        self._save_platform_info()
931
 
        win32utils.winver = 'Windows 98'
932
 
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
933
 
 
934
818
    def test_unicode_walkdirs(self):
935
819
        """Walkdirs should always return unicode paths."""
936
820
        name0 = u'0file-\xb6'
1038
922
            result.append((dirdetail, new_dirblock))
1039
923
        self.assertEqual(expected_dirblocks, result)
1040
924
 
1041
 
    def test__walkdirs_utf8_with_unicode_fs(self):
1042
 
        """UnicodeDirReader should be a safe fallback everywhere
 
925
    def test_unicode__walkdirs_unicode_to_utf8(self):
 
926
        """walkdirs_unicode_to_utf8 should be a safe fallback everywhere
1043
927
 
1044
928
        The abspath portion should be in unicode
1045
929
        """
1046
 
        # Use the unicode reader. TODO: split into driver-and-driven unit
1047
 
        # tests.
1048
 
        self._save_platform_info()
1049
 
        osutils._selected_dir_reader = osutils.UnicodeDirReader()
1050
930
        name0u = u'0file-\xb6'
1051
931
        name1u = u'1dir-\u062c\u0648'
1052
932
        name2u = u'2file-\u0633'
1087
967
                 ]
1088
968
                ),
1089
969
            ]
1090
 
        result = list(osutils._walkdirs_utf8('.'))
1091
 
        self._filter_out_stat(result)
1092
 
        self.assertEqual(expected_dirblocks, result)
1093
 
 
1094
 
    def test__walkdirs_utf8_win32readdir(self):
1095
 
        self.requireFeature(Win32ReadDirFeature)
1096
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1097
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
1098
 
        self._save_platform_info()
1099
 
        osutils._selected_dir_reader = Win32ReadDir()
1100
 
        name0u = u'0file-\xb6'
1101
 
        name1u = u'1dir-\u062c\u0648'
1102
 
        name2u = u'2file-\u0633'
1103
 
        tree = [
1104
 
            name0u,
1105
 
            name1u + '/',
1106
 
            name1u + '/' + name0u,
1107
 
            name1u + '/' + name1u + '/',
1108
 
            name2u,
1109
 
            ]
1110
 
        self.build_tree(tree)
1111
 
        name0 = name0u.encode('utf8')
1112
 
        name1 = name1u.encode('utf8')
1113
 
        name2 = name2u.encode('utf8')
1114
 
 
1115
 
        # All of the abspaths should be in unicode, all of the relative paths
1116
 
        # should be in utf8
1117
 
        expected_dirblocks = [
1118
 
                (('', '.'),
1119
 
                 [(name0, name0, 'file', './' + name0u),
1120
 
                  (name1, name1, 'directory', './' + name1u),
1121
 
                  (name2, name2, 'file', './' + name2u),
1122
 
                 ]
1123
 
                ),
1124
 
                ((name1, './' + name1u),
1125
 
                 [(name1 + '/' + name0, name0, 'file', './' + name1u
1126
 
                                                        + '/' + name0u),
1127
 
                  (name1 + '/' + name1, name1, 'directory', './' + name1u
1128
 
                                                            + '/' + name1u),
1129
 
                 ]
1130
 
                ),
1131
 
                ((name1 + '/' + name1, './' + name1u + '/' + name1u),
1132
 
                 [
1133
 
                 ]
1134
 
                ),
1135
 
            ]
1136
 
        result = list(osutils._walkdirs_utf8(u'.'))
1137
 
        self._filter_out_stat(result)
1138
 
        self.assertEqual(expected_dirblocks, result)
1139
 
 
1140
 
    def assertStatIsCorrect(self, path, win32stat):
1141
 
        os_stat = os.stat(path)
1142
 
        self.assertEqual(os_stat.st_size, win32stat.st_size)
1143
 
        self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
1144
 
        self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
1145
 
        self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
1146
 
        self.assertEqual(os_stat.st_dev, win32stat.st_dev)
1147
 
        self.assertEqual(os_stat.st_ino, win32stat.st_ino)
1148
 
        self.assertEqual(os_stat.st_mode, win32stat.st_mode)
1149
 
 
1150
 
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1151
 
        """make sure our Stat values are valid"""
1152
 
        self.requireFeature(Win32ReadDirFeature)
1153
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1154
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
1155
 
        name0u = u'0file-\xb6'
1156
 
        name0 = name0u.encode('utf8')
1157
 
        self.build_tree([name0u])
1158
 
        # I hate to sleep() here, but I'm trying to make the ctime different
1159
 
        # from the mtime
1160
 
        time.sleep(2)
1161
 
        f = open(name0u, 'ab')
1162
 
        try:
1163
 
            f.write('just a small update')
1164
 
        finally:
1165
 
            f.close()
1166
 
 
1167
 
        result = Win32ReadDir().read_dir('', u'.')
1168
 
        entry = result[0]
1169
 
        self.assertEqual((name0, name0, 'file'), entry[:3])
1170
 
        self.assertEqual(u'./' + name0u, entry[4])
1171
 
        self.assertStatIsCorrect(entry[4], entry[3])
1172
 
        self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
1173
 
 
1174
 
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1175
 
        """make sure our Stat values are valid"""
1176
 
        self.requireFeature(Win32ReadDirFeature)
1177
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1178
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
1179
 
        name0u = u'0dir-\u062c\u0648'
1180
 
        name0 = name0u.encode('utf8')
1181
 
        self.build_tree([name0u + '/'])
1182
 
 
1183
 
        result = Win32ReadDir().read_dir('', u'.')
1184
 
        entry = result[0]
1185
 
        self.assertEqual((name0, name0, 'directory'), entry[:3])
1186
 
        self.assertEqual(u'./' + name0u, entry[4])
1187
 
        self.assertStatIsCorrect(entry[4], entry[3])
 
970
        result = list(osutils._walkdirs_unicode_to_utf8('.'))
 
971
        self._filter_out_stat(result)
 
972
        self.assertEqual(expected_dirblocks, result)
1188
973
 
1189
974
    def assertPathCompare(self, path_less, path_greater):
1190
975
        """check that path_less and path_greater compare correctly."""
1356
1141
        uni_val, env_val = probe_unicode_in_user_encoding()
1357
1142
        if uni_val is None:
1358
1143
            raise TestSkipped('Cannot find a unicode character that works in'
1359
 
                              ' encoding %s' % (osutils.get_user_encoding(),))
 
1144
                              ' encoding %s' % (bzrlib.user_encoding,))
1360
1145
 
1361
1146
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1362
1147
        self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))