/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: Ian Clatworthy
  • Date: 2008-12-15 06:18:29 UTC
  • mfrom: (3905 +trunk)
  • mto: (3586.1.23 views-ui)
  • mto: This revision was merged to the branch mainline in revision 4030.
  • Revision ID: ian.clatworthy@canonical.com-20081215061829-c8qwa93g71u9fsh5
merge bzr.dev 3905

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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
24
24
import sys
25
25
import time
26
26
 
27
 
import bzrlib
28
27
from bzrlib import (
29
28
    errors,
30
29
    osutils,
37
36
        is_inside_or_parent_of_any,
38
37
        pathjoin,
39
38
        pumpfile,
 
39
        pump_string_file,
40
40
        )
41
41
from bzrlib.tests import (
 
42
        adapt_tests,
 
43
        Feature,
42
44
        probe_unicode_in_user_encoding,
 
45
        split_suite_by_re,
43
46
        StringIOWrapper,
44
47
        SymlinkFeature,
45
48
        TestCase,
46
49
        TestCaseInTempDir,
 
50
        TestScenarioApplier,
47
51
        TestSkipped,
48
52
        )
49
53
from bzrlib.tests.file_utils import (
50
54
    FakeReadFile,
51
55
    )
52
 
from bzrlib.tests.test__walkdirs_win32 import WalkdirsWin32Feature
 
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()
53
73
 
54
74
 
55
75
class TestOSUtils(TestCaseInTempDir):
271
291
    def test_format_date(self):
272
292
        self.assertRaises(errors.UnsupportedTimezoneFormat,
273
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.
274
300
 
275
301
    def test_dereference_path(self):
276
302
        self.requireFeature(SymlinkFeature)
440
466
            message = "Data not equal.  Expected %d bytes, received %d."
441
467
            self.fail(message % (len(response_data), self.test_data_len))
442
468
 
 
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
 
443
493
class TestSafeUnicode(TestCase):
444
494
 
445
495
    def test_from_ascii_string(self):
706
756
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
707
757
 
708
758
 
 
759
class TestChunksToLines(TestCase):
 
760
 
 
761
    def test_smoketest(self):
 
762
        self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
 
763
                         osutils.chunks_to_lines(['foo\nbar', '\nbaz\n']))
 
764
        self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
 
765
                         osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
 
766
 
 
767
    def test_is_compiled(self):
 
768
        from bzrlib.tests.test__chunks_to_lines import CompiledChunksToLinesFeature
 
769
        if CompiledChunksToLinesFeature:
 
770
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
 
771
        else:
 
772
            from bzrlib._chunks_to_lines_py import chunks_to_lines
 
773
        self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
 
774
 
 
775
 
709
776
class TestSplitLines(TestCase):
710
777
 
711
778
    def test_split_unicode(self):
822
889
                new_dirblock.append((info[0], info[1], info[2], info[4]))
823
890
            dirblock[:] = new_dirblock
824
891
 
825
 
    def test__walkdirs_utf8_selection(self):
826
 
        # Just trigger the function once, to make sure it has selected a real
827
 
        # implementation.
828
 
        list(osutils._walkdirs_utf8('.'))
829
 
        if WalkdirsWin32Feature.available():
830
 
            # If the compiled form is available, make sure it is used
831
 
            from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
832
 
            self.assertIs(_walkdirs_utf8_win32_find_file,
833
 
                          osutils._real_walkdirs_utf8)
834
 
        elif sys.platform == 'win32':
835
 
            self.assertIs(osutils._walkdirs_unicode_to_utf8,
836
 
                          osutils._real_walkdirs_utf8)
837
 
        elif osutils._fs_enc.upper() in ('UTF-8', 'ASCII', 'ANSI_X3.4-1968'): # ascii
838
 
            self.assertIs(osutils._walkdirs_fs_utf8,
839
 
                          osutils._real_walkdirs_utf8)
840
 
        else:
841
 
            self.assertIs(osutils._walkdirs_unicode_to_utf8,
842
 
                          osutils._real_walkdirs_utf8)
843
 
 
844
892
    def _save_platform_info(self):
845
893
        cur_winver = win32utils.winver
846
894
        cur_fs_enc = osutils._fs_enc
847
 
        cur_real_walkdirs_utf8 = osutils._real_walkdirs_utf8
 
895
        cur_dir_reader = osutils._selected_dir_reader
848
896
        def restore():
849
897
            win32utils.winver = cur_winver
850
898
            osutils._fs_enc = cur_fs_enc
851
 
            osutils._real_walkdirs_utf8 = cur_real_walkdirs_utf8
 
899
            osutils._selected_dir_reader = cur_dir_reader
852
900
        self.addCleanup(restore)
853
901
 
854
 
    def assertWalkdirsUtf8Is(self, expected):
 
902
    def assertReadFSDirIs(self, expected):
855
903
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
856
904
        # Force it to redetect
857
 
        osutils._real_walkdirs_utf8 = None
 
905
        osutils._selected_dir_reader = None
858
906
        # Nothing to list, but should still trigger the selection logic
859
907
        self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
860
 
        self.assertIs(expected, osutils._real_walkdirs_utf8)
 
908
        self.assertIsInstance(osutils._selected_dir_reader, expected)
861
909
 
862
910
    def test_force_walkdirs_utf8_fs_utf8(self):
 
911
        self.requireFeature(UTF8DirReaderFeature)
863
912
        self._save_platform_info()
864
913
        win32utils.winver = None # Avoid the win32 detection code
865
914
        osutils._fs_enc = 'UTF-8'
866
 
        self.assertWalkdirsUtf8Is(osutils._walkdirs_fs_utf8)
 
915
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
867
916
 
868
917
    def test_force_walkdirs_utf8_fs_ascii(self):
 
918
        self.requireFeature(UTF8DirReaderFeature)
869
919
        self._save_platform_info()
870
920
        win32utils.winver = None # Avoid the win32 detection code
871
921
        osutils._fs_enc = 'US-ASCII'
872
 
        self.assertWalkdirsUtf8Is(osutils._walkdirs_fs_utf8)
 
922
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
873
923
 
874
924
    def test_force_walkdirs_utf8_fs_ANSI(self):
 
925
        self.requireFeature(UTF8DirReaderFeature)
875
926
        self._save_platform_info()
876
927
        win32utils.winver = None # Avoid the win32 detection code
877
928
        osutils._fs_enc = 'ANSI_X3.4-1968'
878
 
        self.assertWalkdirsUtf8Is(osutils._walkdirs_fs_utf8)
 
929
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
879
930
 
880
931
    def test_force_walkdirs_utf8_fs_latin1(self):
881
932
        self._save_platform_info()
882
933
        win32utils.winver = None # Avoid the win32 detection code
883
934
        osutils._fs_enc = 'latin1'
884
 
        self.assertWalkdirsUtf8Is(osutils._walkdirs_unicode_to_utf8)
 
935
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
885
936
 
886
937
    def test_force_walkdirs_utf8_nt(self):
887
 
        self.requireFeature(WalkdirsWin32Feature)
 
938
        # Disabled because the thunk of the whole walkdirs api is disabled.
 
939
        self.requireFeature(Win32ReadDirFeature)
888
940
        self._save_platform_info()
889
941
        win32utils.winver = 'Windows NT'
890
 
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
891
 
        self.assertWalkdirsUtf8Is(_walkdirs_utf8_win32_find_file)
 
942
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
943
        self.assertReadFSDirIs(Win32ReadDir)
892
944
 
893
 
    def test_force_walkdirs_utf8_nt(self):
894
 
        self.requireFeature(WalkdirsWin32Feature)
 
945
    def test_force_walkdirs_utf8_98(self):
 
946
        self.requireFeature(Win32ReadDirFeature)
895
947
        self._save_platform_info()
896
948
        win32utils.winver = 'Windows 98'
897
 
        self.assertWalkdirsUtf8Is(osutils._walkdirs_unicode_to_utf8)
 
949
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
898
950
 
899
951
    def test_unicode_walkdirs(self):
900
952
        """Walkdirs should always return unicode paths."""
1003
1055
            result.append((dirdetail, new_dirblock))
1004
1056
        self.assertEqual(expected_dirblocks, result)
1005
1057
 
1006
 
    def test_unicode__walkdirs_unicode_to_utf8(self):
1007
 
        """walkdirs_unicode_to_utf8 should be a safe fallback everywhere
 
1058
    def test__walkdirs_utf8_with_unicode_fs(self):
 
1059
        """UnicodeDirReader should be a safe fallback everywhere
1008
1060
 
1009
1061
        The abspath portion should be in unicode
1010
1062
        """
 
1063
        # Use the unicode reader. TODO: split into driver-and-driven unit
 
1064
        # tests.
 
1065
        self._save_platform_info()
 
1066
        osutils._selected_dir_reader = osutils.UnicodeDirReader()
1011
1067
        name0u = u'0file-\xb6'
1012
1068
        name1u = u'1dir-\u062c\u0648'
1013
1069
        name2u = u'2file-\u0633'
1048
1104
                 ]
1049
1105
                ),
1050
1106
            ]
1051
 
        result = list(osutils._walkdirs_unicode_to_utf8('.'))
 
1107
        result = list(osutils._walkdirs_utf8('.'))
1052
1108
        self._filter_out_stat(result)
1053
1109
        self.assertEqual(expected_dirblocks, result)
1054
1110
 
1055
 
    def test__walkdirs_utf_win32_find_file(self):
1056
 
        self.requireFeature(WalkdirsWin32Feature)
 
1111
    def test__walkdirs_utf8_win32readdir(self):
 
1112
        self.requireFeature(Win32ReadDirFeature)
1057
1113
        self.requireFeature(tests.UnicodeFilenameFeature)
1058
 
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
 
1114
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1115
        self._save_platform_info()
 
1116
        osutils._selected_dir_reader = Win32ReadDir()
1059
1117
        name0u = u'0file-\xb6'
1060
1118
        name1u = u'1dir-\u062c\u0648'
1061
1119
        name2u = u'2file-\u0633'
1092
1150
                 ]
1093
1151
                ),
1094
1152
            ]
1095
 
        result = list(_walkdirs_utf8_win32_find_file(u'.'))
 
1153
        result = list(osutils._walkdirs_utf8(u'.'))
1096
1154
        self._filter_out_stat(result)
1097
1155
        self.assertEqual(expected_dirblocks, result)
1098
1156
 
1108
1166
 
1109
1167
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1110
1168
        """make sure our Stat values are valid"""
1111
 
        self.requireFeature(WalkdirsWin32Feature)
 
1169
        self.requireFeature(Win32ReadDirFeature)
1112
1170
        self.requireFeature(tests.UnicodeFilenameFeature)
1113
 
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
 
1171
        from bzrlib._walkdirs_win32 import Win32ReadDir
1114
1172
        name0u = u'0file-\xb6'
1115
1173
        name0 = name0u.encode('utf8')
1116
1174
        self.build_tree([name0u])
1123
1181
        finally:
1124
1182
            f.close()
1125
1183
 
1126
 
        result = list(_walkdirs_utf8_win32_find_file(u'.'))
1127
 
        entry = result[0][1][0]
 
1184
        result = Win32ReadDir().read_dir('', u'.')
 
1185
        entry = result[0]
1128
1186
        self.assertEqual((name0, name0, 'file'), entry[:3])
1129
1187
        self.assertEqual(u'./' + name0u, entry[4])
1130
1188
        self.assertStatIsCorrect(entry[4], entry[3])
1132
1190
 
1133
1191
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1134
1192
        """make sure our Stat values are valid"""
1135
 
        self.requireFeature(WalkdirsWin32Feature)
 
1193
        self.requireFeature(Win32ReadDirFeature)
1136
1194
        self.requireFeature(tests.UnicodeFilenameFeature)
1137
 
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
 
1195
        from bzrlib._walkdirs_win32 import Win32ReadDir
1138
1196
        name0u = u'0dir-\u062c\u0648'
1139
1197
        name0 = name0u.encode('utf8')
1140
1198
        self.build_tree([name0u + '/'])
1141
1199
 
1142
 
        result = list(_walkdirs_utf8_win32_find_file(u'.'))
1143
 
        entry = result[0][1][0]
 
1200
        result = Win32ReadDir().read_dir('', u'.')
 
1201
        entry = result[0]
1144
1202
        self.assertEqual((name0, name0, 'directory'), entry[:3])
1145
1203
        self.assertEqual(u'./' + name0u, entry[4])
1146
1204
        self.assertStatIsCorrect(entry[4], entry[3])
1315
1373
        uni_val, env_val = probe_unicode_in_user_encoding()
1316
1374
        if uni_val is None:
1317
1375
            raise TestSkipped('Cannot find a unicode character that works in'
1318
 
                              ' encoding %s' % (bzrlib.user_encoding,))
 
1376
                              ' encoding %s' % (osutils.get_user_encoding(),))
1319
1377
 
1320
1378
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1321
1379
        self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))