← 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: John Arbash Meinel
  • Date: 2009-04-22 17:18:45 UTC
  • mto: This revision was merged to the branch mainline in revision 4301.
  • Revision ID: john@arbash-meinel.com-20090422171845-5dmqokv8ygf3cvs5
Add the ability to convert a gc block into 'human readable' form.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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
29
29
    errors,
30
30
    osutils,
31
31
    tests,
32
 
    trace,
33
32
    win32utils,
34
33
    )
35
34
from bzrlib.tests import (
36
 
    features,
37
35
    file_utils,
38
36
    test__walkdirs_win32,
39
37
    )
54
52
 
55
53
UTF8DirReaderFeature = _UTF8DirReaderFeature()
56
54
 
57
 
term_ios_feature = tests.ModuleAvailableFeature('termios')
58
 
 
59
 
 
60
 
def _already_unicode(s):
61
 
    return s
62
 
 
63
 
 
64
 
def _utf8_to_unicode(s):
65
 
    return s.decode('UTF-8')
66
 
 
67
 
 
68
 
def dir_reader_scenarios():
69
 
    # For each dir reader we define:
70
 
 
71
 
    # - native_to_unicode: a function converting the native_abspath as returned
72
 
    #   by DirReader.read_dir to its unicode representation
73
 
 
74
 
    # UnicodeDirReader is the fallback, it should be tested on all platforms.
75
 
    scenarios = [('unicode',
76
 
                  dict(_dir_reader_class=osutils.UnicodeDirReader,
77
 
                       _native_to_unicode=_already_unicode))]
78
 
    # Some DirReaders are platform specific and even there they may not be
79
 
    # available.
80
 
    if UTF8DirReaderFeature.available():
81
 
        from bzrlib import _readdir_pyx
82
 
        scenarios.append(('utf8',
83
 
                          dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
84
 
                               _native_to_unicode=_utf8_to_unicode)))
85
 
 
86
 
    if test__walkdirs_win32.win32_readdir_feature.available():
87
 
        try:
88
 
            from bzrlib import _walkdirs_win32
89
 
            scenarios.append(
90
 
                ('win32',
91
 
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
92
 
                      _native_to_unicode=_already_unicode)))
93
 
        except ImportError:
94
 
            pass
95
 
    return scenarios
96
 
 
97
 
 
98
 
def load_tests(basic_tests, module, loader):
99
 
    suite = loader.suiteClass()
100
 
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
101
 
        basic_tests, tests.condition_isinstance(TestDirReader))
102
 
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios(), suite)
103
 
    suite.addTest(remaining_tests)
104
 
    return suite
105
 
 
106
 
 
107
 
class TestContainsWhitespace(tests.TestCase):
 
55
 
 
56
class TestOSUtils(tests.TestCaseInTempDir):
108
57
 
109
58
    def test_contains_whitespace(self):
110
59
        self.failUnless(osutils.contains_whitespace(u' '))
120
69
        self.failIf(osutils.contains_whitespace(u'hellothere'))
121
70
        self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
122
71
 
123
 
 
124
 
class TestRename(tests.TestCaseInTempDir):
125
 
 
126
 
    def create_file(self, filename, content):
127
 
        f = open(filename, 'wb')
128
 
        try:
129
 
            f.write(content)
130
 
        finally:
131
 
            f.close()
132
 
 
133
 
    def _fancy_rename(self, a, b):
134
 
        osutils.fancy_rename(a, b, rename_func=os.rename,
135
 
                             unlink_func=os.unlink)
136
 
 
137
72
    def test_fancy_rename(self):
138
73
        # This should work everywhere
139
 
        self.create_file('a', 'something in a\n')
140
 
        self._fancy_rename('a', 'b')
 
74
        def rename(a, b):
 
75
            osutils.fancy_rename(a, b,
 
76
                    rename_func=os.rename,
 
77
                    unlink_func=os.unlink)
 
78
 
 
79
        open('a', 'wb').write('something in a\n')
 
80
        rename('a', 'b')
141
81
        self.failIfExists('a')
142
82
        self.failUnlessExists('b')
143
83
        self.check_file_contents('b', 'something in a\n')
144
84
 
145
 
        self.create_file('a', 'new something in a\n')
146
 
        self._fancy_rename('b', 'a')
 
85
        open('a', 'wb').write('new something in a\n')
 
86
        rename('b', 'a')
147
87
 
148
88
        self.check_file_contents('a', 'something in a\n')
149
89
 
150
 
    def test_fancy_rename_fails_source_missing(self):
151
 
        # An exception should be raised, and the target should be left in place
152
 
        self.create_file('target', 'data in target\n')
153
 
        self.assertRaises((IOError, OSError), self._fancy_rename,
154
 
                          'missingsource', 'target')
155
 
        self.failUnlessExists('target')
156
 
        self.check_file_contents('target', 'data in target\n')
157
 
 
158
 
    def test_fancy_rename_fails_if_source_and_target_missing(self):
159
 
        self.assertRaises((IOError, OSError), self._fancy_rename,
160
 
                          'missingsource', 'missingtarget')
161
 
 
162
90
    def test_rename(self):
163
91
        # Rename should be semi-atomic on all platforms
164
 
        self.create_file('a', 'something in a\n')
 
92
        open('a', 'wb').write('something in a\n')
165
93
        osutils.rename('a', 'b')
166
94
        self.failIfExists('a')
167
95
        self.failUnlessExists('b')
168
96
        self.check_file_contents('b', 'something in a\n')
169
97
 
170
 
        self.create_file('a', 'new something in a\n')
 
98
        open('a', 'wb').write('new something in a\n')
171
99
        osutils.rename('b', 'a')
172
100
 
173
101
        self.check_file_contents('a', 'something in a\n')
184
112
        shape = sorted(os.listdir('.'))
185
113
        self.assertEquals(['A', 'B'], shape)
186
114
 
187
 
    def test_rename_error(self):
188
 
        # We wrap os.rename to make it give an error including the filenames
189
 
        # https://bugs.launchpad.net/bzr/+bug/491763
190
 
        err = self.assertRaises(OSError, osutils.rename,
191
 
            'nonexistent', 'target')
192
 
        self.assertContainsString(str(err), 'nonexistent')
193
 
 
194
 
 
195
 
class TestRandChars(tests.TestCase):
196
 
 
197
115
    def test_01_rand_chars_empty(self):
198
116
        result = osutils.rand_chars(0)
199
117
        self.assertEqual(result, '')
204
122
        self.assertEqual(type(result), str)
205
123
        self.assertContainsRe(result, r'^[a-z0-9]{100}$')
206
124
 
207
 
 
208
 
class TestIsInside(tests.TestCase):
209
 
 
210
125
    def test_is_inside(self):
211
126
        is_inside = osutils.is_inside
212
127
        self.assertTrue(is_inside('src', 'src/foo.c'))
241
156
                         (['src'], 'srccontrol/foo')]:
242
157
            self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
243
158
 
244
 
 
245
 
class TestRmTree(tests.TestCaseInTempDir):
246
 
 
247
159
    def test_rmtree(self):
248
160
        # Check to remove tree with read-only files/dirs
249
161
        os.mkdir('dir')
262
174
        self.failIfExists('dir/file')
263
175
        self.failIfExists('dir')
264
176
 
265
 
 
266
 
class TestDeleteAny(tests.TestCaseInTempDir):
267
 
 
268
 
    def test_delete_any_readonly(self):
269
 
        # from <https://bugs.launchpad.net/bzr/+bug/218206>
270
 
        self.build_tree(['d/', 'f'])
271
 
        osutils.make_readonly('d')
272
 
        osutils.make_readonly('f')
273
 
 
274
 
        osutils.delete_any('f')
275
 
        osutils.delete_any('d')
276
 
 
277
 
 
278
 
class TestKind(tests.TestCaseInTempDir):
279
 
 
280
177
    def test_file_kind(self):
281
178
        self.build_tree(['file', 'dir/'])
282
179
        self.assertEquals('file', osutils.file_kind('file'))
312
209
                os.remove('socket')
313
210
 
314
211
    def test_kind_marker(self):
315
 
        self.assertEqual("", osutils.kind_marker("file"))
316
 
        self.assertEqual("/", osutils.kind_marker('directory'))
317
 
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
318
 
        self.assertEqual("@", osutils.kind_marker("symlink"))
319
 
        self.assertEqual("+", osutils.kind_marker("tree-reference"))
320
 
        self.assertEqual("", osutils.kind_marker("fifo"))
321
 
        self.assertEqual("", osutils.kind_marker("socket"))
322
 
        self.assertEqual("", osutils.kind_marker("unknown"))
323
 
 
324
 
 
325
 
class TestUmask(tests.TestCaseInTempDir):
 
212
        self.assertEqual(osutils.kind_marker('file'), '')
 
213
        self.assertEqual(osutils.kind_marker('directory'), '/')
 
214
        self.assertEqual(osutils.kind_marker('symlink'), '@')
 
215
        self.assertEqual(osutils.kind_marker('tree-reference'), '+')
326
216
 
327
217
    def test_get_umask(self):
328
218
        if sys.platform == 'win32':
341
231
        os.umask(0027)
342
232
        self.assertEqual(0027, osutils.get_umask())
343
233
 
344
 
 
345
 
class TestDateTime(tests.TestCase):
346
 
 
347
234
    def assertFormatedDelta(self, expected, seconds):
348
235
        """Assert osutils.format_delta formats as expected"""
349
236
        actual = osutils.format_delta(seconds)
390
277
        # Instead blackbox.test_locale should check for localized
391
278
        # dates once they do occur in output strings.
392
279
 
393
 
    def test_format_date_with_offset_in_original_timezone(self):
394
 
        self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
395
 
            osutils.format_date_with_offset_in_original_timezone(0))
396
 
        self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
397
 
            osutils.format_date_with_offset_in_original_timezone(100000))
398
 
        self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
399
 
            osutils.format_date_with_offset_in_original_timezone(100000, 7200))
400
 
 
401
 
    def test_local_time_offset(self):
402
 
        """Test that local_time_offset() returns a sane value."""
403
 
        offset = osutils.local_time_offset()
404
 
        self.assertTrue(isinstance(offset, int))
405
 
        # Test that the offset is no more than a eighteen hours in
406
 
        # either direction.
407
 
        # Time zone handling is system specific, so it is difficult to
408
 
        # do more specific tests, but a value outside of this range is
409
 
        # probably wrong.
410
 
        eighteen_hours = 18 * 3600
411
 
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
412
 
 
413
 
    def test_local_time_offset_with_timestamp(self):
414
 
        """Test that local_time_offset() works with a timestamp."""
415
 
        offset = osutils.local_time_offset(1000000000.1234567)
416
 
        self.assertTrue(isinstance(offset, int))
417
 
        eighteen_hours = 18 * 3600
418
 
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
419
 
 
420
 
 
421
 
class TestLinks(tests.TestCaseInTempDir):
422
 
 
423
280
    def test_dereference_path(self):
424
281
        self.requireFeature(tests.SymlinkFeature)
425
282
        cwd = osutils.realpath('.')
468
325
            osutils.make_readonly('dangling')
469
326
            osutils.make_writable('dangling')
470
327
 
 
328
    def test_kind_marker(self):
 
329
        self.assertEqual("", osutils.kind_marker("file"))
 
330
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
 
331
        self.assertEqual("@", osutils.kind_marker("symlink"))
 
332
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
 
333
 
471
334
    def test_host_os_dereferences_symlinks(self):
472
335
        osutils.host_os_dereferences_symlinks()
473
336
 
479
342
    def test_canonical_relpath_simple(self):
480
343
        f = file('MixedCaseName', 'w')
481
344
        f.close()
482
 
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
 
345
        # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
346
        real_base_dir = osutils.realpath(self.test_base_dir)
 
347
        actual = osutils.canonical_relpath(real_base_dir, 'mixedcasename')
483
348
        self.failUnlessEqual('work/MixedCaseName', actual)
484
349
 
485
350
    def test_canonical_relpath_missing_tail(self):
486
351
        os.mkdir('MixedCaseParent')
487
 
        actual = osutils.canonical_relpath(self.test_base_dir,
 
352
        # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
353
        real_base_dir = osutils.realpath(self.test_base_dir)
 
354
        actual = osutils.canonical_relpath(real_base_dir,
488
355
                                           'mixedcaseparent/nochild')
489
356
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
490
357
 
491
358
 
492
 
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
493
 
 
494
 
    def assertRelpath(self, expected, base, path):
495
 
        actual = osutils._cicp_canonical_relpath(base, path)
496
 
        self.assertEqual(expected, actual)
497
 
 
498
 
    def test_simple(self):
499
 
        self.build_tree(['MixedCaseName'])
500
 
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
501
 
        self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
502
 
 
503
 
    def test_subdir_missing_tail(self):
504
 
        self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
505
 
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
506
 
        self.assertRelpath('MixedCaseParent/a_child', base,
507
 
                           'MixedCaseParent/a_child')
508
 
        self.assertRelpath('MixedCaseParent/a_child', base,
509
 
                           'MixedCaseParent/A_Child')
510
 
        self.assertRelpath('MixedCaseParent/not_child', base,
511
 
                           'MixedCaseParent/not_child')
512
 
 
513
 
    def test_at_root_slash(self):
514
 
        # We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
515
 
        # check...
516
 
        if osutils.MIN_ABS_PATHLENGTH > 1:
517
 
            raise tests.TestSkipped('relpath requires %d chars'
518
 
                                    % osutils.MIN_ABS_PATHLENGTH)
519
 
        self.assertRelpath('foo', '/', '/foo')
520
 
 
521
 
    def test_at_root_drive(self):
522
 
        if sys.platform != 'win32':
523
 
            raise tests.TestNotApplicable('we can only test drive-letter relative'
524
 
                                          ' paths on Windows where we have drive'
525
 
                                          ' letters.')
526
 
        # see bug #322807
527
 
        # The specific issue is that when at the root of a drive, 'abspath'
528
 
        # returns "C:/" or just "/". However, the code assumes that abspath
529
 
        # always returns something like "C:/foo" or "/foo" (no trailing slash).
530
 
        self.assertRelpath('foo', 'C:/', 'C:/foo')
531
 
        self.assertRelpath('foo', 'X:/', 'X:/foo')
532
 
        self.assertRelpath('foo', 'X:/', 'X://foo')
533
 
 
534
 
 
535
359
class TestPumpFile(tests.TestCase):
536
360
    """Test pumpfile method."""
537
361
 
697
521
        self.assertEqual("1234", output.getvalue())
698
522
 
699
523
 
700
 
class TestRelpath(tests.TestCase):
701
 
 
702
 
    def test_simple_relpath(self):
703
 
        cwd = osutils.getcwd()
704
 
        subdir = cwd + '/subdir'
705
 
        self.assertEqual('subdir', osutils.relpath(cwd, subdir))
706
 
 
707
 
    def test_deep_relpath(self):
708
 
        cwd = osutils.getcwd()
709
 
        subdir = cwd + '/sub/subsubdir'
710
 
        self.assertEqual('sub/subsubdir', osutils.relpath(cwd, subdir))
711
 
 
712
 
    def test_not_relative(self):
713
 
        self.assertRaises(errors.PathNotChild,
714
 
                          osutils.relpath, 'C:/path', 'H:/path')
715
 
        self.assertRaises(errors.PathNotChild,
716
 
                          osutils.relpath, 'C:/', 'H:/path')
717
 
 
718
 
 
719
524
class TestSafeUnicode(tests.TestCase):
720
525
 
721
526
    def test_from_ascii_string(self):
892
697
    def test_minimum_path_selection(self):
893
698
        self.assertEqual(set(),
894
699
            osutils.minimum_path_selection([]))
895
 
        self.assertEqual(set(['a']),
896
 
            osutils.minimum_path_selection(['a']))
897
700
        self.assertEqual(set(['a', 'b']),
898
701
            osutils.minimum_path_selection(['a', 'b']))
899
702
        self.assertEqual(set(['a/', 'b']),
900
703
            osutils.minimum_path_selection(['a/', 'b']))
901
704
        self.assertEqual(set(['a/', 'b']),
902
705
            osutils.minimum_path_selection(['a/c', 'a/', 'b']))
903
 
        self.assertEqual(set(['a-b', 'a', 'a0b']),
904
 
            osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
905
706
 
906
707
    def test_mkdtemp(self):
907
708
        tmpdir = osutils._win32_mkdtemp(dir='.')
963
764
        self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
964
765
 
965
766
 
966
 
class TestParentDirectories(tests.TestCaseInTempDir):
967
 
    """Test osutils.parent_directories()"""
968
 
 
969
 
    def test_parent_directories(self):
970
 
        self.assertEqual([], osutils.parent_directories('a'))
971
 
        self.assertEqual(['a'], osutils.parent_directories('a/b'))
972
 
        self.assertEqual(['a/b', 'a'], osutils.parent_directories('a/b/c'))
973
 
 
974
 
 
975
767
class TestMacFuncsDirs(tests.TestCaseInTempDir):
976
768
    """Test mac special functions that require directories."""
977
769
 
999
791
 
1000
792
    def test_osutils_binding(self):
1001
793
        from bzrlib.tests import test__chunks_to_lines
1002
 
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
 
794
        if test__chunks_to_lines.CompiledChunksToLinesFeature.available():
1003
795
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1004
796
        else:
1005
797
            from bzrlib._chunks_to_lines_py import chunks_to_lines
1021
813
 
1022
814
class TestWalkDirs(tests.TestCaseInTempDir):
1023
815
 
1024
 
    def assertExpectedBlocks(self, expected, result):
1025
 
        self.assertEqual(expected,
1026
 
                         [(dirinfo, [line[0:3] for line in block])
1027
 
                          for dirinfo, block in result])
1028
 
 
1029
816
    def test_walkdirs(self):
1030
817
        tree = [
1031
818
            '.bzr',
1063
850
            result.append((dirdetail, dirblock))
1064
851
 
1065
852
        self.assertTrue(found_bzrdir)
1066
 
        self.assertExpectedBlocks(expected_dirblocks, result)
 
853
        self.assertEqual(expected_dirblocks,
 
854
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1067
855
        # you can search a subdir only, with a supplied prefix.
1068
856
        result = []
1069
857
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
1070
858
            result.append(dirblock)
1071
 
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
 
859
        self.assertEqual(expected_dirblocks[1:],
 
860
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1072
861
 
1073
862
    def test_walkdirs_os_error(self):
1074
863
        # <https://bugs.edge.launchpad.net/bzr/+bug/338653>
1080
869
        os.mkdir("test-unreadable")
1081
870
        os.chmod("test-unreadable", 0000)
1082
871
        # must chmod it back so that it can be removed
1083
 
        self.addCleanup(os.chmod, "test-unreadable", 0700)
 
872
        self.addCleanup(lambda: os.chmod("test-unreadable", 0700))
1084
873
        # The error is not raised until the generator is actually evaluated.
1085
874
        # (It would be ok if it happened earlier but at the moment it
1086
875
        # doesn't.)
1127
916
            result.append((dirdetail, dirblock))
1128
917
 
1129
918
        self.assertTrue(found_bzrdir)
1130
 
        self.assertExpectedBlocks(expected_dirblocks, result)
1131
 
 
 
919
        self.assertEqual(expected_dirblocks,
 
920
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1132
921
        # you can search a subdir only, with a supplied prefix.
1133
922
        result = []
1134
923
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
1135
924
            result.append(dirblock)
1136
 
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
 
925
        self.assertEqual(expected_dirblocks[1:],
 
926
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1137
927
 
1138
928
    def _filter_out_stat(self, result):
1139
929
        """Filter out the stat value from the walkdirs result"""
1145
935
            dirblock[:] = new_dirblock
1146
936
 
1147
937
    def _save_platform_info(self):
1148
 
        self.overrideAttr(win32utils, 'winver')
1149
 
        self.overrideAttr(osutils, '_fs_enc')
1150
 
        self.overrideAttr(osutils, '_selected_dir_reader')
 
938
        cur_winver = win32utils.winver
 
939
        cur_fs_enc = osutils._fs_enc
 
940
        cur_dir_reader = osutils._selected_dir_reader
 
941
        def restore():
 
942
            win32utils.winver = cur_winver
 
943
            osutils._fs_enc = cur_fs_enc
 
944
            osutils._selected_dir_reader = cur_dir_reader
 
945
        self.addCleanup(restore)
1151
946
 
1152
 
    def assertDirReaderIs(self, expected):
 
947
    def assertReadFSDirIs(self, expected):
1153
948
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
1154
949
        # Force it to redetect
1155
950
        osutils._selected_dir_reader = None
1162
957
        self._save_platform_info()
1163
958
        win32utils.winver = None # Avoid the win32 detection code
1164
959
        osutils._fs_enc = 'UTF-8'
1165
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
960
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
1166
961
 
1167
962
    def test_force_walkdirs_utf8_fs_ascii(self):
1168
963
        self.requireFeature(UTF8DirReaderFeature)
1169
964
        self._save_platform_info()
1170
965
        win32utils.winver = None # Avoid the win32 detection code
1171
966
        osutils._fs_enc = 'US-ASCII'
1172
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
967
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
1173
968
 
1174
969
    def test_force_walkdirs_utf8_fs_ANSI(self):
1175
970
        self.requireFeature(UTF8DirReaderFeature)
1176
971
        self._save_platform_info()
1177
972
        win32utils.winver = None # Avoid the win32 detection code
1178
973
        osutils._fs_enc = 'ANSI_X3.4-1968'
1179
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
974
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
1180
975
 
1181
976
    def test_force_walkdirs_utf8_fs_latin1(self):
1182
977
        self._save_platform_info()
1183
978
        win32utils.winver = None # Avoid the win32 detection code
1184
979
        osutils._fs_enc = 'latin1'
1185
 
        self.assertDirReaderIs(osutils.UnicodeDirReader)
 
980
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
1186
981
 
1187
982
    def test_force_walkdirs_utf8_nt(self):
1188
983
        # Disabled because the thunk of the whole walkdirs api is disabled.
1189
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
984
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1190
985
        self._save_platform_info()
1191
986
        win32utils.winver = 'Windows NT'
1192
987
        from bzrlib._walkdirs_win32 import Win32ReadDir
1193
 
        self.assertDirReaderIs(Win32ReadDir)
 
988
        self.assertReadFSDirIs(Win32ReadDir)
1194
989
 
1195
990
    def test_force_walkdirs_utf8_98(self):
1196
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
991
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1197
992
        self._save_platform_info()
1198
993
        win32utils.winver = 'Windows 98'
1199
 
        self.assertDirReaderIs(osutils.UnicodeDirReader)
 
994
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
1200
995
 
1201
996
    def test_unicode_walkdirs(self):
1202
997
        """Walkdirs should always return unicode paths."""
1350
1145
        self.assertEqual(expected_dirblocks, result)
1351
1146
 
1352
1147
    def test__walkdirs_utf8_win32readdir(self):
1353
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1148
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1354
1149
        self.requireFeature(tests.UnicodeFilenameFeature)
1355
1150
        from bzrlib._walkdirs_win32 import Win32ReadDir
1356
1151
        self._save_platform_info()
1407
1202
 
1408
1203
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1409
1204
        """make sure our Stat values are valid"""
1410
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1205
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1411
1206
        self.requireFeature(tests.UnicodeFilenameFeature)
1412
1207
        from bzrlib._walkdirs_win32 import Win32ReadDir
1413
1208
        name0u = u'0file-\xb6'
1431
1226
 
1432
1227
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1433
1228
        """make sure our Stat values are valid"""
1434
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1229
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
1435
1230
        self.requireFeature(tests.UnicodeFilenameFeature)
1436
1231
        from bzrlib._walkdirs_win32 import Win32ReadDir
1437
1232
        name0u = u'0dir-\u062c\u0648'
1586
1381
        def cleanup():
1587
1382
            if 'BZR_TEST_ENV_VAR' in os.environ:
1588
1383
                del os.environ['BZR_TEST_ENV_VAR']
 
1384
 
1589
1385
        self.addCleanup(cleanup)
1590
1386
 
1591
1387
    def test_set(self):
1624
1420
        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1625
1421
 
1626
1422
 
 
1423
class TestLocalTimeOffset(tests.TestCase):
 
1424
 
 
1425
    def test_local_time_offset(self):
 
1426
        """Test that local_time_offset() returns a sane value."""
 
1427
        offset = osutils.local_time_offset()
 
1428
        self.assertTrue(isinstance(offset, int))
 
1429
        # Test that the offset is no more than a eighteen hours in
 
1430
        # either direction.
 
1431
        # Time zone handling is system specific, so it is difficult to
 
1432
        # do more specific tests, but a value outside of this range is
 
1433
        # probably wrong.
 
1434
        eighteen_hours = 18 * 3600
 
1435
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
1436
 
 
1437
    def test_local_time_offset_with_timestamp(self):
 
1438
        """Test that local_time_offset() works with a timestamp."""
 
1439
        offset = osutils.local_time_offset(1000000000.1234567)
 
1440
        self.assertTrue(isinstance(offset, int))
 
1441
        eighteen_hours = 18 * 3600
 
1442
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
1443
 
 
1444
 
1627
1445
class TestSizeShaFile(tests.TestCaseInTempDir):
1628
1446
 
1629
1447
    def test_sha_empty(self):
1639
1457
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
1640
1458
        self.build_tree_contents([('foo', text)])
1641
1459
        expected_sha = osutils.sha_string(text)
1642
 
        f = open('foo', 'rb')
 
1460
        f = open('foo')
1643
1461
        self.addCleanup(f.close)
1644
1462
        size, sha = osutils.size_sha_file(f)
1645
1463
        self.assertEqual(38, size)
1692
1510
            "Invalid regular expression in test case: '*': "
1693
1511
            "nothing to repeat",
1694
1512
            str(err))
1695
 
 
1696
 
 
1697
 
class TestDirReader(tests.TestCaseInTempDir):
1698
 
 
1699
 
    # Set by load_tests
1700
 
    _dir_reader_class = None
1701
 
    _native_to_unicode = None
1702
 
 
1703
 
    def setUp(self):
1704
 
        tests.TestCaseInTempDir.setUp(self)
1705
 
        self.overrideAttr(osutils,
1706
 
                          '_selected_dir_reader', self._dir_reader_class())
1707
 
 
1708
 
    def _get_ascii_tree(self):
1709
 
        tree = [
1710
 
            '0file',
1711
 
            '1dir/',
1712
 
            '1dir/0file',
1713
 
            '1dir/1dir/',
1714
 
            '2file'
1715
 
            ]
1716
 
        expected_dirblocks = [
1717
 
                (('', '.'),
1718
 
                 [('0file', '0file', 'file'),
1719
 
                  ('1dir', '1dir', 'directory'),
1720
 
                  ('2file', '2file', 'file'),
1721
 
                 ]
1722
 
                ),
1723
 
                (('1dir', './1dir'),
1724
 
                 [('1dir/0file', '0file', 'file'),
1725
 
                  ('1dir/1dir', '1dir', 'directory'),
1726
 
                 ]
1727
 
                ),
1728
 
                (('1dir/1dir', './1dir/1dir'),
1729
 
                 [
1730
 
                 ]
1731
 
                ),
1732
 
            ]
1733
 
        return tree, expected_dirblocks
1734
 
 
1735
 
    def test_walk_cur_dir(self):
1736
 
        tree, expected_dirblocks = self._get_ascii_tree()
1737
 
        self.build_tree(tree)
1738
 
        result = list(osutils._walkdirs_utf8('.'))
1739
 
        # Filter out stat and abspath
1740
 
        self.assertEqual(expected_dirblocks,
1741
 
                         [(dirinfo, [line[0:3] for line in block])
1742
 
                          for dirinfo, block in result])
1743
 
 
1744
 
    def test_walk_sub_dir(self):
1745
 
        tree, expected_dirblocks = self._get_ascii_tree()
1746
 
        self.build_tree(tree)
1747
 
        # you can search a subdir only, with a supplied prefix.
1748
 
        result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1749
 
        # Filter out stat and abspath
1750
 
        self.assertEqual(expected_dirblocks[1:],
1751
 
                         [(dirinfo, [line[0:3] for line in block])
1752
 
                          for dirinfo, block in result])
1753
 
 
1754
 
    def _get_unicode_tree(self):
1755
 
        name0u = u'0file-\xb6'
1756
 
        name1u = u'1dir-\u062c\u0648'
1757
 
        name2u = u'2file-\u0633'
1758
 
        tree = [
1759
 
            name0u,
1760
 
            name1u + '/',
1761
 
            name1u + '/' + name0u,
1762
 
            name1u + '/' + name1u + '/',
1763
 
            name2u,
1764
 
            ]
1765
 
        name0 = name0u.encode('UTF-8')
1766
 
        name1 = name1u.encode('UTF-8')
1767
 
        name2 = name2u.encode('UTF-8')
1768
 
        expected_dirblocks = [
1769
 
                (('', '.'),
1770
 
                 [(name0, name0, 'file', './' + name0u),
1771
 
                  (name1, name1, 'directory', './' + name1u),
1772
 
                  (name2, name2, 'file', './' + name2u),
1773
 
                 ]
1774
 
                ),
1775
 
                ((name1, './' + name1u),
1776
 
                 [(name1 + '/' + name0, name0, 'file', './' + name1u
1777
 
                                                        + '/' + name0u),
1778
 
                  (name1 + '/' + name1, name1, 'directory', './' + name1u
1779
 
                                                            + '/' + name1u),
1780
 
                 ]
1781
 
                ),
1782
 
                ((name1 + '/' + name1, './' + name1u + '/' + name1u),
1783
 
                 [
1784
 
                 ]
1785
 
                ),
1786
 
            ]
1787
 
        return tree, expected_dirblocks
1788
 
 
1789
 
    def _filter_out(self, raw_dirblocks):
1790
 
        """Filter out a walkdirs_utf8 result.
1791
 
 
1792
 
        stat field is removed, all native paths are converted to unicode
1793
 
        """
1794
 
        filtered_dirblocks = []
1795
 
        for dirinfo, block in raw_dirblocks:
1796
 
            dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1797
 
            details = []
1798
 
            for line in block:
1799
 
                details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1800
 
            filtered_dirblocks.append((dirinfo, details))
1801
 
        return filtered_dirblocks
1802
 
 
1803
 
    def test_walk_unicode_tree(self):
1804
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1805
 
        tree, expected_dirblocks = self._get_unicode_tree()
1806
 
        self.build_tree(tree)
1807
 
        result = list(osutils._walkdirs_utf8('.'))
1808
 
        self.assertEqual(expected_dirblocks, self._filter_out(result))
1809
 
 
1810
 
    def test_symlink(self):
1811
 
        self.requireFeature(tests.SymlinkFeature)
1812
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1813
 
        target = u'target\N{Euro Sign}'
1814
 
        link_name = u'l\N{Euro Sign}nk'
1815
 
        os.symlink(target, link_name)
1816
 
        target_utf8 = target.encode('UTF-8')
1817
 
        link_name_utf8 = link_name.encode('UTF-8')
1818
 
        expected_dirblocks = [
1819
 
                (('', '.'),
1820
 
                 [(link_name_utf8, link_name_utf8,
1821
 
                   'symlink', './' + link_name),],
1822
 
                 )]
1823
 
        result = list(osutils._walkdirs_utf8('.'))
1824
 
        self.assertEqual(expected_dirblocks, self._filter_out(result))
1825
 
 
1826
 
 
1827
 
class TestReadLink(tests.TestCaseInTempDir):
1828
 
    """Exposes os.readlink() problems and the osutils solution.
1829
 
 
1830
 
    The only guarantee offered by os.readlink(), starting with 2.6, is that a
1831
 
    unicode string will be returned if a unicode string is passed.
1832
 
 
1833
 
    But prior python versions failed to properly encode the passed unicode
1834
 
    string.
1835
 
    """
1836
 
    _test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
1837
 
 
1838
 
    def setUp(self):
1839
 
        super(tests.TestCaseInTempDir, self).setUp()
1840
 
        self.link = u'l\N{Euro Sign}ink'
1841
 
        self.target = u'targe\N{Euro Sign}t'
1842
 
        os.symlink(self.target, self.link)
1843
 
 
1844
 
    def test_os_readlink_link_encoding(self):
1845
 
        if sys.version_info < (2, 6):
1846
 
            self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
1847
 
        else:
1848
 
            self.assertEquals(self.target,  os.readlink(self.link))
1849
 
 
1850
 
    def test_os_readlink_link_decoding(self):
1851
 
        self.assertEquals(self.target.encode(osutils._fs_enc),
1852
 
                          os.readlink(self.link.encode(osutils._fs_enc)))
1853
 
 
1854
 
 
1855
 
class TestConcurrency(tests.TestCase):
1856
 
 
1857
 
    def setUp(self):
1858
 
        super(TestConcurrency, self).setUp()
1859
 
        self.overrideAttr(osutils, '_cached_local_concurrency')
1860
 
 
1861
 
    def test_local_concurrency(self):
1862
 
        concurrency = osutils.local_concurrency()
1863
 
        self.assertIsInstance(concurrency, int)
1864
 
 
1865
 
    def test_local_concurrency_environment_variable(self):
1866
 
        os.environ['BZR_CONCURRENCY'] = '2'
1867
 
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1868
 
        os.environ['BZR_CONCURRENCY'] = '3'
1869
 
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1870
 
        os.environ['BZR_CONCURRENCY'] = 'foo'
1871
 
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1872
 
 
1873
 
    def test_option_concurrency(self):
1874
 
        os.environ['BZR_CONCURRENCY'] = '1'
1875
 
        self.run_bzr('rocks --concurrency 42')
1876
 
        # Command line overrides envrionment variable
1877
 
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1878
 
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1879
 
 
1880
 
 
1881
 
class TestFailedToLoadExtension(tests.TestCase):
1882
 
 
1883
 
    def _try_loading(self):
1884
 
        try:
1885
 
            import bzrlib._fictional_extension_py
1886
 
        except ImportError, e:
1887
 
            osutils.failed_to_load_extension(e)
1888
 
            return True
1889
 
 
1890
 
    def setUp(self):
1891
 
        super(TestFailedToLoadExtension, self).setUp()
1892
 
        self.overrideAttr(osutils, '_extension_load_failures', [])
1893
 
 
1894
 
    def test_failure_to_load(self):
1895
 
        self._try_loading()
1896
 
        self.assertLength(1, osutils._extension_load_failures)
1897
 
        self.assertEquals(osutils._extension_load_failures[0],
1898
 
            "No module named _fictional_extension_py")
1899
 
 
1900
 
    def test_report_extension_load_failures_no_warning(self):
1901
 
        self.assertTrue(self._try_loading())
1902
 
        warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
1903
 
        # it used to give a Python warning; it no longer does
1904
 
        self.assertLength(0, warnings)
1905
 
 
1906
 
    def test_report_extension_load_failures_message(self):
1907
 
        log = StringIO()
1908
 
        trace.push_log_file(log)
1909
 
        self.assertTrue(self._try_loading())
1910
 
        osutils.report_extension_load_failures()
1911
 
        self.assertContainsRe(
1912
 
            log.getvalue(),
1913
 
            r"bzr: warning: some compiled extensions could not be loaded; "
1914
 
            "see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1915
 
            )
1916
 
 
1917
 
 
1918
 
class TestTerminalWidth(tests.TestCase):
1919
 
 
1920
 
    def replace_stdout(self, new):
1921
 
        self.overrideAttr(sys, 'stdout', new)
1922
 
 
1923
 
    def replace__terminal_size(self, new):
1924
 
        self.overrideAttr(osutils, '_terminal_size', new)
1925
 
 
1926
 
    def set_fake_tty(self):
1927
 
 
1928
 
        class I_am_a_tty(object):
1929
 
            def isatty(self):
1930
 
                return True
1931
 
 
1932
 
        self.replace_stdout(I_am_a_tty())
1933
 
 
1934
 
    def test_default_values(self):
1935
 
        self.assertEqual(80, osutils.default_terminal_width)
1936
 
 
1937
 
    def test_defaults_to_BZR_COLUMNS(self):
1938
 
        # BZR_COLUMNS is set by the test framework
1939
 
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
1940
 
        os.environ['BZR_COLUMNS'] = '12'
1941
 
        self.assertEqual(12, osutils.terminal_width())
1942
 
 
1943
 
    def test_falls_back_to_COLUMNS(self):
1944
 
        del os.environ['BZR_COLUMNS']
1945
 
        self.assertNotEqual('42', os.environ['COLUMNS'])
1946
 
        self.set_fake_tty()
1947
 
        os.environ['COLUMNS'] = '42'
1948
 
        self.assertEqual(42, osutils.terminal_width())
1949
 
 
1950
 
    def test_tty_default_without_columns(self):
1951
 
        del os.environ['BZR_COLUMNS']
1952
 
        del os.environ['COLUMNS']
1953
 
 
1954
 
        def terminal_size(w, h):
1955
 
            return 42, 42
1956
 
 
1957
 
        self.set_fake_tty()
1958
 
        # We need to override the osutils definition as it depends on the
1959
 
        # running environment that we can't control (PQM running without a
1960
 
        # controlling terminal is one example).
1961
 
        self.replace__terminal_size(terminal_size)
1962
 
        self.assertEqual(42, osutils.terminal_width())
1963
 
 
1964
 
    def test_non_tty_default_without_columns(self):
1965
 
        del os.environ['BZR_COLUMNS']
1966
 
        del os.environ['COLUMNS']
1967
 
        self.replace_stdout(None)
1968
 
        self.assertEqual(None, osutils.terminal_width())
1969
 
 
1970
 
    def test_no_TIOCGWINSZ(self):
1971
 
        self.requireFeature(term_ios_feature)
1972
 
        termios = term_ios_feature.module
1973
 
        # bug 63539 is about a termios without TIOCGWINSZ attribute
1974
 
        try:
1975
 
            orig = termios.TIOCGWINSZ
1976
 
        except AttributeError:
1977
 
            # We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
1978
 
            pass
1979
 
        else:
1980
 
            self.overrideAttr(termios, 'TIOCGWINSZ')
1981
 
            del termios.TIOCGWINSZ
1982
 
        del os.environ['BZR_COLUMNS']
1983
 
        del os.environ['COLUMNS']
1984
 
        # Whatever the result is, if we don't raise an exception, it's ok.
1985
 
        osutils.terminal_width()
1986
 
 
1987
 
class TestCreationOps(tests.TestCaseInTempDir):
1988
 
    _test_needs_features = [features.chown_feature]
1989
 
 
1990
 
    def setUp(self):
1991
 
        tests.TestCaseInTempDir.setUp(self)
1992
 
        self.overrideAttr(os, 'chown', self._dummy_chown)
1993
 
 
1994
 
        # params set by call to _dummy_chown
1995
 
        self.path = self.uid = self.gid = None
1996
 
 
1997
 
    def _dummy_chown(self, path, uid, gid):
1998
 
        self.path, self.uid, self.gid = path, uid, gid
1999
 
 
2000
 
    def test_copy_ownership_from_path(self):
2001
 
        """copy_ownership_from_path test with specified src."""
2002
 
        ownsrc = '/'
2003
 
        f = open('test_file', 'wt')
2004
 
        osutils.copy_ownership_from_path('test_file', ownsrc)
2005
 
 
2006
 
        s = os.stat(ownsrc)
2007
 
        self.assertEquals(self.path, 'test_file')
2008
 
        self.assertEquals(self.uid, s.st_uid)
2009
 
        self.assertEquals(self.gid, s.st_gid)
2010
 
 
2011
 
    def test_copy_ownership_nonesrc(self):
2012
 
        """copy_ownership_from_path test with src=None."""
2013
 
        f = open('test_file', 'wt')
2014
 
        # should use parent dir for permissions
2015
 
        osutils.copy_ownership_from_path('test_file')
2016
 
 
2017
 
        s = os.stat('..')
2018
 
        self.assertEquals(self.path, 'test_file')
2019
 
        self.assertEquals(self.uid, s.st_uid)
2020
 
        self.assertEquals(self.gid, s.st_gid)