/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils.py

  • Committer: Andrew Bennetts
  • Date: 2008-10-27 06:14:45 UTC
  • mfrom: (3793 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3795.
  • Revision ID: andrew.bennetts@canonical.com-20081027061445-eqt9lz6uw1mbvq4g
Merge from bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
24
24
import sys
25
25
import time
26
26
 
27
 
import bzrlib
28
27
from bzrlib import (
29
28
    errors,
30
29
    osutils,
54
53
from bzrlib.tests.file_utils import (
55
54
    FakeReadFile,
56
55
    )
57
 
from bzrlib.tests.test__walkdirs_win32 import WalkdirsWin32Feature
58
 
 
59
 
 
60
 
def load_tests(standard_tests, module, loader):
61
 
    """Parameterize readdir tests."""
62
 
    to_adapt, result = split_suite_by_re(standard_tests, "readdir")
63
 
    adapter = TestScenarioApplier()
64
 
    from bzrlib import _readdir_py
65
 
    adapter.scenarios = [('python', {'read_dir': _readdir_py.read_dir})]
66
 
    if ReadDirFeature.available():
67
 
        adapter.scenarios.append(('pyrex',
68
 
            {'read_dir': ReadDirFeature.read_dir}))
69
 
    adapt_tests(to_adapt, adapter, result)
70
 
    return result
71
 
 
72
 
 
73
 
class _ReadDirFeature(Feature):
 
56
from bzrlib.tests.test__walkdirs_win32 import Win32ReadDirFeature
 
57
 
 
58
 
 
59
class _UTF8DirReaderFeature(Feature):
74
60
 
75
61
    def _probe(self):
76
62
        try:
77
63
            from bzrlib import _readdir_pyx
78
 
            self.read_dir = _readdir_pyx.read_dir
 
64
            self.reader = _readdir_pyx.UTF8DirReader
79
65
            return True
80
66
        except ImportError:
81
67
            return False
83
69
    def feature_name(self):
84
70
        return 'bzrlib._readdir_pyx'
85
71
 
86
 
ReadDirFeature = _ReadDirFeature()
 
72
UTF8DirReaderFeature = _UTF8DirReaderFeature()
87
73
 
88
74
 
89
75
class TestOSUtils(TestCaseInTempDir):
305
291
    def test_format_date(self):
306
292
        self.assertRaises(errors.UnsupportedTimezoneFormat,
307
293
            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.
308
300
 
309
301
    def test_dereference_path(self):
310
302
        self.requireFeature(SymlinkFeature)
779
771
 
780
772
class TestWalkDirs(TestCaseInTempDir):
781
773
 
782
 
    def test_readdir(self):
783
 
        tree = [
784
 
            '.bzr/',
785
 
            '0file',
786
 
            '1dir/',
787
 
            '1dir/0file',
788
 
            '1dir/1dir/',
789
 
            '2file'
790
 
            ]
791
 
        self.build_tree(tree)
792
 
        expected_names = ['.bzr', '0file', '1dir', '2file']
793
 
        # read_dir returns pairs, which form a table with either None in all
794
 
        # the first columns, or a sort key to get best on-disk-read order, 
795
 
        # and the disk path name in utf-8 encoding in the second column.
796
 
        read_result = self.read_dir('.')
797
 
        # The second column is always the names, and every name except "." and
798
 
        # ".." should be present.
799
 
        names = sorted([row[1] for row in read_result])
800
 
        self.assertEqual(expected_names, names)
801
 
        expected_sort_key = None
802
 
        if read_result[0][0] is None:
803
 
            # No sort key returned - all keys must None
804
 
            operator = self.assertEqual
805
 
        else:
806
 
            # A sort key in the first row implies sort keys in the other rows.
807
 
            operator = self.assertNotEqual
808
 
        for row in read_result:
809
 
            operator(None, row[0])
810
 
 
811
 
    def test_compiled_extension_exists(self):
812
 
        self.requireFeature(ReadDirFeature)
813
 
        
814
774
    def test_walkdirs(self):
815
775
        tree = [
816
776
            '.bzr',
912
872
                new_dirblock.append((info[0], info[1], info[2], info[4]))
913
873
            dirblock[:] = new_dirblock
914
874
 
915
 
    def test__walkdirs_utf8_selection(self):
916
 
        # Just trigger the function once, to make sure it has selected a real
917
 
        # implementation.
918
 
        list(osutils._walkdirs_utf8('.'))
919
 
        if WalkdirsWin32Feature.available():
920
 
            # If the compiled form is available, make sure it is used
921
 
            from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
922
 
            self.assertIs(_walkdirs_utf8_win32_find_file,
923
 
                          osutils._real_walkdirs_utf8)
924
 
        elif sys.platform == 'win32':
925
 
            self.assertIs(osutils._walkdirs_unicode_to_utf8,
926
 
                          osutils._real_walkdirs_utf8)
927
 
        elif osutils._fs_enc.upper() in ('UTF-8', 'ASCII', 'ANSI_X3.4-1968'): # ascii
928
 
            self.assertIs(osutils._walkdirs_fs_utf8,
929
 
                          osutils._real_walkdirs_utf8)
930
 
        else:
931
 
            self.assertIs(osutils._walkdirs_unicode_to_utf8,
932
 
                          osutils._real_walkdirs_utf8)
933
 
 
934
875
    def _save_platform_info(self):
935
876
        cur_winver = win32utils.winver
936
877
        cur_fs_enc = osutils._fs_enc
937
 
        cur_real_walkdirs_utf8 = osutils._real_walkdirs_utf8
 
878
        cur_dir_reader = osutils._selected_dir_reader
938
879
        def restore():
939
880
            win32utils.winver = cur_winver
940
881
            osutils._fs_enc = cur_fs_enc
941
 
            osutils._real_walkdirs_utf8 = cur_real_walkdirs_utf8
 
882
            osutils._selected_dir_reader = cur_dir_reader
942
883
        self.addCleanup(restore)
943
884
 
944
 
    def assertWalkdirsUtf8Is(self, expected):
 
885
    def assertReadFSDirIs(self, expected):
945
886
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
946
887
        # Force it to redetect
947
 
        osutils._real_walkdirs_utf8 = None
 
888
        osutils._selected_dir_reader = None
948
889
        # Nothing to list, but should still trigger the selection logic
949
890
        self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
950
 
        self.assertIs(expected, osutils._real_walkdirs_utf8)
 
891
        self.assertIsInstance(osutils._selected_dir_reader, expected)
951
892
 
952
893
    def test_force_walkdirs_utf8_fs_utf8(self):
 
894
        self.requireFeature(UTF8DirReaderFeature)
953
895
        self._save_platform_info()
954
896
        win32utils.winver = None # Avoid the win32 detection code
955
897
        osutils._fs_enc = 'UTF-8'
956
 
        self.assertWalkdirsUtf8Is(osutils._walkdirs_fs_utf8)
 
898
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
957
899
 
958
900
    def test_force_walkdirs_utf8_fs_ascii(self):
 
901
        self.requireFeature(UTF8DirReaderFeature)
959
902
        self._save_platform_info()
960
903
        win32utils.winver = None # Avoid the win32 detection code
961
904
        osutils._fs_enc = 'US-ASCII'
962
 
        self.assertWalkdirsUtf8Is(osutils._walkdirs_fs_utf8)
 
905
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
963
906
 
964
907
    def test_force_walkdirs_utf8_fs_ANSI(self):
 
908
        self.requireFeature(UTF8DirReaderFeature)
965
909
        self._save_platform_info()
966
910
        win32utils.winver = None # Avoid the win32 detection code
967
911
        osutils._fs_enc = 'ANSI_X3.4-1968'
968
 
        self.assertWalkdirsUtf8Is(osutils._walkdirs_fs_utf8)
 
912
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
969
913
 
970
914
    def test_force_walkdirs_utf8_fs_latin1(self):
971
915
        self._save_platform_info()
972
916
        win32utils.winver = None # Avoid the win32 detection code
973
917
        osutils._fs_enc = 'latin1'
974
 
        self.assertWalkdirsUtf8Is(osutils._walkdirs_unicode_to_utf8)
 
918
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
975
919
 
976
920
    def test_force_walkdirs_utf8_nt(self):
977
 
        self.requireFeature(WalkdirsWin32Feature)
 
921
        # Disabled because the thunk of the whole walkdirs api is disabled.
 
922
        self.requireFeature(Win32ReadDirFeature)
978
923
        self._save_platform_info()
979
924
        win32utils.winver = 'Windows NT'
980
 
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
981
 
        self.assertWalkdirsUtf8Is(_walkdirs_utf8_win32_find_file)
 
925
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
926
        self.assertReadFSDirIs(Win32ReadDir)
982
927
 
983
 
    def test_force_walkdirs_utf8_nt(self):
984
 
        self.requireFeature(WalkdirsWin32Feature)
 
928
    def test_force_walkdirs_utf8_98(self):
 
929
        self.requireFeature(Win32ReadDirFeature)
985
930
        self._save_platform_info()
986
931
        win32utils.winver = 'Windows 98'
987
 
        self.assertWalkdirsUtf8Is(osutils._walkdirs_unicode_to_utf8)
 
932
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
988
933
 
989
934
    def test_unicode_walkdirs(self):
990
935
        """Walkdirs should always return unicode paths."""
1093
1038
            result.append((dirdetail, new_dirblock))
1094
1039
        self.assertEqual(expected_dirblocks, result)
1095
1040
 
1096
 
    def test_unicode__walkdirs_unicode_to_utf8(self):
1097
 
        """walkdirs_unicode_to_utf8 should be a safe fallback everywhere
 
1041
    def test__walkdirs_utf8_with_unicode_fs(self):
 
1042
        """UnicodeDirReader should be a safe fallback everywhere
1098
1043
 
1099
1044
        The abspath portion should be in unicode
1100
1045
        """
 
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()
1101
1050
        name0u = u'0file-\xb6'
1102
1051
        name1u = u'1dir-\u062c\u0648'
1103
1052
        name2u = u'2file-\u0633'
1138
1087
                 ]
1139
1088
                ),
1140
1089
            ]
1141
 
        result = list(osutils._walkdirs_unicode_to_utf8('.'))
 
1090
        result = list(osutils._walkdirs_utf8('.'))
1142
1091
        self._filter_out_stat(result)
1143
1092
        self.assertEqual(expected_dirblocks, result)
1144
1093
 
1145
 
    def test__walkdirs_utf_win32_find_file(self):
1146
 
        self.requireFeature(WalkdirsWin32Feature)
 
1094
    def test__walkdirs_utf8_win32readdir(self):
 
1095
        self.requireFeature(Win32ReadDirFeature)
1147
1096
        self.requireFeature(tests.UnicodeFilenameFeature)
1148
 
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
 
1097
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1098
        self._save_platform_info()
 
1099
        osutils._selected_dir_reader = Win32ReadDir()
1149
1100
        name0u = u'0file-\xb6'
1150
1101
        name1u = u'1dir-\u062c\u0648'
1151
1102
        name2u = u'2file-\u0633'
1182
1133
                 ]
1183
1134
                ),
1184
1135
            ]
1185
 
        result = list(_walkdirs_utf8_win32_find_file(u'.'))
 
1136
        result = list(osutils._walkdirs_utf8(u'.'))
1186
1137
        self._filter_out_stat(result)
1187
1138
        self.assertEqual(expected_dirblocks, result)
1188
1139
 
1198
1149
 
1199
1150
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1200
1151
        """make sure our Stat values are valid"""
1201
 
        self.requireFeature(WalkdirsWin32Feature)
 
1152
        self.requireFeature(Win32ReadDirFeature)
1202
1153
        self.requireFeature(tests.UnicodeFilenameFeature)
1203
 
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
 
1154
        from bzrlib._walkdirs_win32 import Win32ReadDir
1204
1155
        name0u = u'0file-\xb6'
1205
1156
        name0 = name0u.encode('utf8')
1206
1157
        self.build_tree([name0u])
1213
1164
        finally:
1214
1165
            f.close()
1215
1166
 
1216
 
        result = list(_walkdirs_utf8_win32_find_file(u'.'))
1217
 
        entry = result[0][1][0]
 
1167
        result = Win32ReadDir().read_dir('', u'.')
 
1168
        entry = result[0]
1218
1169
        self.assertEqual((name0, name0, 'file'), entry[:3])
1219
1170
        self.assertEqual(u'./' + name0u, entry[4])
1220
1171
        self.assertStatIsCorrect(entry[4], entry[3])
1222
1173
 
1223
1174
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1224
1175
        """make sure our Stat values are valid"""
1225
 
        self.requireFeature(WalkdirsWin32Feature)
 
1176
        self.requireFeature(Win32ReadDirFeature)
1226
1177
        self.requireFeature(tests.UnicodeFilenameFeature)
1227
 
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
 
1178
        from bzrlib._walkdirs_win32 import Win32ReadDir
1228
1179
        name0u = u'0dir-\u062c\u0648'
1229
1180
        name0 = name0u.encode('utf8')
1230
1181
        self.build_tree([name0u + '/'])
1231
1182
 
1232
 
        result = list(_walkdirs_utf8_win32_find_file(u'.'))
1233
 
        entry = result[0][1][0]
 
1183
        result = Win32ReadDir().read_dir('', u'.')
 
1184
        entry = result[0]
1234
1185
        self.assertEqual((name0, name0, 'directory'), entry[:3])
1235
1186
        self.assertEqual(u'./' + name0u, entry[4])
1236
1187
        self.assertStatIsCorrect(entry[4], entry[3])
1405
1356
        uni_val, env_val = probe_unicode_in_user_encoding()
1406
1357
        if uni_val is None:
1407
1358
            raise TestSkipped('Cannot find a unicode character that works in'
1408
 
                              ' encoding %s' % (bzrlib.user_encoding,))
 
1359
                              ' encoding %s' % (osutils.get_user_encoding(),))
1409
1360
 
1410
1361
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1411
1362
        self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))