/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: 2009-06-17 02:02:44 UTC
  • mfrom: (4449 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4452.
  • Revision ID: andrew.bennetts@canonical.com-20090617020244-50aantdf95aakvjx
Merge bzr.dev, resolving NEWS conflict.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
53
53
UTF8DirReaderFeature = _UTF8DirReaderFeature()
54
54
 
55
55
 
56
 
class TestOSUtils(tests.TestCaseInTempDir):
 
56
def _already_unicode(s):
 
57
    return s
 
58
 
 
59
 
 
60
def _fs_enc_to_unicode(s):
 
61
    return s.decode(osutils._fs_enc)
 
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.Win32ReadDirFeature.available():
 
87
        try:
 
88
            from bzrlib import _walkdirs_win32
 
89
            # TODO: check on windows, it may be that we need to use/add
 
90
            # safe_unicode instead of _fs_enc_to_unicode
 
91
            scenarios.append(
 
92
                ('win32',
 
93
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
 
94
                      _native_to_unicode=_fs_enc_to_unicode)))
 
95
        except ImportError:
 
96
            pass
 
97
    return scenarios
 
98
 
 
99
 
 
100
def load_tests(basic_tests, module, loader):
 
101
    suite = loader.suiteClass()
 
102
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
 
103
        basic_tests, tests.condition_isinstance(TestDirReader))
 
104
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios(), suite)
 
105
    suite.addTest(remaining_tests)
 
106
    return suite
 
107
 
 
108
 
 
109
class TestContainsWhitespace(tests.TestCase):
57
110
 
58
111
    def test_contains_whitespace(self):
59
112
        self.failUnless(osutils.contains_whitespace(u' '))
69
122
        self.failIf(osutils.contains_whitespace(u'hellothere'))
70
123
        self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
71
124
 
 
125
 
 
126
class TestRename(tests.TestCaseInTempDir):
 
127
 
72
128
    def test_fancy_rename(self):
73
129
        # This should work everywhere
74
130
        def rename(a, b):
112
168
        shape = sorted(os.listdir('.'))
113
169
        self.assertEquals(['A', 'B'], shape)
114
170
 
 
171
 
 
172
class TestRandChars(tests.TestCase):
 
173
 
115
174
    def test_01_rand_chars_empty(self):
116
175
        result = osutils.rand_chars(0)
117
176
        self.assertEqual(result, '')
122
181
        self.assertEqual(type(result), str)
123
182
        self.assertContainsRe(result, r'^[a-z0-9]{100}$')
124
183
 
 
184
 
 
185
class TestIsInside(tests.TestCase):
 
186
 
125
187
    def test_is_inside(self):
126
188
        is_inside = osutils.is_inside
127
189
        self.assertTrue(is_inside('src', 'src/foo.c'))
156
218
                         (['src'], 'srccontrol/foo')]:
157
219
            self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
158
220
 
 
221
 
 
222
class TestRmTree(tests.TestCaseInTempDir):
 
223
 
159
224
    def test_rmtree(self):
160
225
        # Check to remove tree with read-only files/dirs
161
226
        os.mkdir('dir')
174
239
        self.failIfExists('dir/file')
175
240
        self.failIfExists('dir')
176
241
 
 
242
 
 
243
class TestKind(tests.TestCaseInTempDir):
 
244
 
177
245
    def test_file_kind(self):
178
246
        self.build_tree(['file', 'dir/'])
179
247
        self.assertEquals('file', osutils.file_kind('file'))
209
277
                os.remove('socket')
210
278
 
211
279
    def test_kind_marker(self):
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'), '+')
 
280
        self.assertEqual("", osutils.kind_marker("file"))
 
281
        self.assertEqual("/", osutils.kind_marker('directory'))
 
282
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
 
283
        self.assertEqual("@", osutils.kind_marker("symlink"))
 
284
        self.assertEqual("+", osutils.kind_marker("tree-reference"))
 
285
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
 
286
 
 
287
 
 
288
class TestUmask(tests.TestCaseInTempDir):
216
289
 
217
290
    def test_get_umask(self):
218
291
        if sys.platform == 'win32':
231
304
        os.umask(0027)
232
305
        self.assertEqual(0027, osutils.get_umask())
233
306
 
 
307
 
 
308
class TestDateTime(tests.TestCase):
 
309
 
234
310
    def assertFormatedDelta(self, expected, seconds):
235
311
        """Assert osutils.format_delta formats as expected"""
236
312
        actual = osutils.format_delta(seconds)
277
353
        # Instead blackbox.test_locale should check for localized
278
354
        # dates once they do occur in output strings.
279
355
 
 
356
    def test_local_time_offset(self):
 
357
        """Test that local_time_offset() returns a sane value."""
 
358
        offset = osutils.local_time_offset()
 
359
        self.assertTrue(isinstance(offset, int))
 
360
        # Test that the offset is no more than a eighteen hours in
 
361
        # either direction.
 
362
        # Time zone handling is system specific, so it is difficult to
 
363
        # do more specific tests, but a value outside of this range is
 
364
        # probably wrong.
 
365
        eighteen_hours = 18 * 3600
 
366
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
367
 
 
368
    def test_local_time_offset_with_timestamp(self):
 
369
        """Test that local_time_offset() works with a timestamp."""
 
370
        offset = osutils.local_time_offset(1000000000.1234567)
 
371
        self.assertTrue(isinstance(offset, int))
 
372
        eighteen_hours = 18 * 3600
 
373
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
374
 
 
375
 
 
376
class TestLinks(tests.TestCaseInTempDir):
 
377
 
280
378
    def test_dereference_path(self):
281
379
        self.requireFeature(tests.SymlinkFeature)
282
380
        cwd = osutils.realpath('.')
325
423
            osutils.make_readonly('dangling')
326
424
            osutils.make_writable('dangling')
327
425
 
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
 
 
334
426
    def test_host_os_dereferences_symlinks(self):
335
427
        osutils.host_os_dereferences_symlinks()
336
428
 
697
789
    def test_minimum_path_selection(self):
698
790
        self.assertEqual(set(),
699
791
            osutils.minimum_path_selection([]))
 
792
        self.assertEqual(set(['a']),
 
793
            osutils.minimum_path_selection(['a']))
700
794
        self.assertEqual(set(['a', 'b']),
701
795
            osutils.minimum_path_selection(['a', 'b']))
702
796
        self.assertEqual(set(['a/', 'b']),
703
797
            osutils.minimum_path_selection(['a/', 'b']))
704
798
        self.assertEqual(set(['a/', 'b']),
705
799
            osutils.minimum_path_selection(['a/c', 'a/', 'b']))
 
800
        self.assertEqual(set(['a-b', 'a', 'a0b']),
 
801
            osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
706
802
 
707
803
    def test_mkdtemp(self):
708
804
        tmpdir = osutils._win32_mkdtemp(dir='.')
764
860
        self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
765
861
 
766
862
 
 
863
class TestParentDirectories(tests.TestCaseInTempDir):
 
864
    """Test osutils.parent_directories()"""
 
865
 
 
866
    def test_parent_directories(self):
 
867
        self.assertEqual([], osutils.parent_directories('a'))
 
868
        self.assertEqual(['a'], osutils.parent_directories('a/b'))
 
869
        self.assertEqual(['a/b', 'a'], osutils.parent_directories('a/b/c'))
 
870
 
 
871
 
767
872
class TestMacFuncsDirs(tests.TestCaseInTempDir):
768
873
    """Test mac special functions that require directories."""
769
874
 
813
918
 
814
919
class TestWalkDirs(tests.TestCaseInTempDir):
815
920
 
 
921
    def assertExpectedBlocks(self, expected, result):
 
922
        self.assertEqual(expected,
 
923
                         [(dirinfo, [line[0:3] for line in block])
 
924
                          for dirinfo, block in result])
 
925
 
816
926
    def test_walkdirs(self):
817
927
        tree = [
818
928
            '.bzr',
850
960
            result.append((dirdetail, dirblock))
851
961
 
852
962
        self.assertTrue(found_bzrdir)
853
 
        self.assertEqual(expected_dirblocks,
854
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
963
        self.assertExpectedBlocks(expected_dirblocks, result)
855
964
        # you can search a subdir only, with a supplied prefix.
856
965
        result = []
857
966
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
858
967
            result.append(dirblock)
859
 
        self.assertEqual(expected_dirblocks[1:],
860
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
968
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
861
969
 
862
970
    def test_walkdirs_os_error(self):
863
971
        # <https://bugs.edge.launchpad.net/bzr/+bug/338653>
869
977
        os.mkdir("test-unreadable")
870
978
        os.chmod("test-unreadable", 0000)
871
979
        # must chmod it back so that it can be removed
872
 
        self.addCleanup(lambda: os.chmod("test-unreadable", 0700))
 
980
        self.addCleanup(os.chmod, "test-unreadable", 0700)
873
981
        # The error is not raised until the generator is actually evaluated.
874
982
        # (It would be ok if it happened earlier but at the moment it
875
983
        # doesn't.)
916
1024
            result.append((dirdetail, dirblock))
917
1025
 
918
1026
        self.assertTrue(found_bzrdir)
919
 
        self.assertEqual(expected_dirblocks,
920
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
1027
        self.assertExpectedBlocks(expected_dirblocks, result)
 
1028
 
921
1029
        # you can search a subdir only, with a supplied prefix.
922
1030
        result = []
923
1031
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
924
1032
            result.append(dirblock)
925
 
        self.assertEqual(expected_dirblocks[1:],
926
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
1033
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
927
1034
 
928
1035
    def _filter_out_stat(self, result):
929
1036
        """Filter out the stat value from the walkdirs result"""
944
1051
            osutils._selected_dir_reader = cur_dir_reader
945
1052
        self.addCleanup(restore)
946
1053
 
947
 
    def assertReadFSDirIs(self, expected):
 
1054
    def assertDirReaderIs(self, expected):
948
1055
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
949
1056
        # Force it to redetect
950
1057
        osutils._selected_dir_reader = None
957
1064
        self._save_platform_info()
958
1065
        win32utils.winver = None # Avoid the win32 detection code
959
1066
        osutils._fs_enc = 'UTF-8'
960
 
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
 
1067
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
961
1068
 
962
1069
    def test_force_walkdirs_utf8_fs_ascii(self):
963
1070
        self.requireFeature(UTF8DirReaderFeature)
964
1071
        self._save_platform_info()
965
1072
        win32utils.winver = None # Avoid the win32 detection code
966
1073
        osutils._fs_enc = 'US-ASCII'
967
 
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
 
1074
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
968
1075
 
969
1076
    def test_force_walkdirs_utf8_fs_ANSI(self):
970
1077
        self.requireFeature(UTF8DirReaderFeature)
971
1078
        self._save_platform_info()
972
1079
        win32utils.winver = None # Avoid the win32 detection code
973
1080
        osutils._fs_enc = 'ANSI_X3.4-1968'
974
 
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
 
1081
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
975
1082
 
976
1083
    def test_force_walkdirs_utf8_fs_latin1(self):
977
1084
        self._save_platform_info()
978
1085
        win32utils.winver = None # Avoid the win32 detection code
979
1086
        osutils._fs_enc = 'latin1'
980
 
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
 
1087
        self.assertDirReaderIs(osutils.UnicodeDirReader)
981
1088
 
982
1089
    def test_force_walkdirs_utf8_nt(self):
983
1090
        # Disabled because the thunk of the whole walkdirs api is disabled.
985
1092
        self._save_platform_info()
986
1093
        win32utils.winver = 'Windows NT'
987
1094
        from bzrlib._walkdirs_win32 import Win32ReadDir
988
 
        self.assertReadFSDirIs(Win32ReadDir)
 
1095
        self.assertDirReaderIs(Win32ReadDir)
989
1096
 
990
1097
    def test_force_walkdirs_utf8_98(self):
991
1098
        self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
992
1099
        self._save_platform_info()
993
1100
        win32utils.winver = 'Windows 98'
994
 
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
 
1101
        self.assertDirReaderIs(osutils.UnicodeDirReader)
995
1102
 
996
1103
    def test_unicode_walkdirs(self):
997
1104
        """Walkdirs should always return unicode paths."""
1420
1527
        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1421
1528
 
1422
1529
 
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
 
 
1445
1530
class TestSizeShaFile(tests.TestCaseInTempDir):
1446
1531
 
1447
1532
    def test_sha_empty(self):
1510
1595
            "Invalid regular expression in test case: '*': "
1511
1596
            "nothing to repeat",
1512
1597
            str(err))
 
1598
 
 
1599
 
 
1600
class TestDirReader(tests.TestCaseInTempDir):
 
1601
 
 
1602
    # Set by load_tests
 
1603
    _dir_reader_class = None
 
1604
    _native_to_unicode = None
 
1605
 
 
1606
    def setUp(self):
 
1607
        tests.TestCaseInTempDir.setUp(self)
 
1608
 
 
1609
        # Save platform specific info and reset it
 
1610
        cur_dir_reader = osutils._selected_dir_reader
 
1611
 
 
1612
        def restore():
 
1613
            osutils._selected_dir_reader = cur_dir_reader
 
1614
        self.addCleanup(restore)
 
1615
 
 
1616
        osutils._selected_dir_reader = self._dir_reader_class()
 
1617
 
 
1618
    def _get_ascii_tree(self):
 
1619
        tree = [
 
1620
            '0file',
 
1621
            '1dir/',
 
1622
            '1dir/0file',
 
1623
            '1dir/1dir/',
 
1624
            '2file'
 
1625
            ]
 
1626
        expected_dirblocks = [
 
1627
                (('', '.'),
 
1628
                 [('0file', '0file', 'file'),
 
1629
                  ('1dir', '1dir', 'directory'),
 
1630
                  ('2file', '2file', 'file'),
 
1631
                 ]
 
1632
                ),
 
1633
                (('1dir', './1dir'),
 
1634
                 [('1dir/0file', '0file', 'file'),
 
1635
                  ('1dir/1dir', '1dir', 'directory'),
 
1636
                 ]
 
1637
                ),
 
1638
                (('1dir/1dir', './1dir/1dir'),
 
1639
                 [
 
1640
                 ]
 
1641
                ),
 
1642
            ]
 
1643
        return tree, expected_dirblocks
 
1644
 
 
1645
    def test_walk_cur_dir(self):
 
1646
        tree, expected_dirblocks = self._get_ascii_tree()
 
1647
        self.build_tree(tree)
 
1648
        result = list(osutils._walkdirs_utf8('.'))
 
1649
        # Filter out stat and abspath
 
1650
        self.assertEqual(expected_dirblocks,
 
1651
                         [(dirinfo, [line[0:3] for line in block])
 
1652
                          for dirinfo, block in result])
 
1653
 
 
1654
    def test_walk_sub_dir(self):
 
1655
        tree, expected_dirblocks = self._get_ascii_tree()
 
1656
        self.build_tree(tree)
 
1657
        # you can search a subdir only, with a supplied prefix.
 
1658
        result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
 
1659
        # Filter out stat and abspath
 
1660
        self.assertEqual(expected_dirblocks[1:],
 
1661
                         [(dirinfo, [line[0:3] for line in block])
 
1662
                          for dirinfo, block in result])
 
1663
 
 
1664
    def _get_unicode_tree(self):
 
1665
        name0u = u'0file-\xb6'
 
1666
        name1u = u'1dir-\u062c\u0648'
 
1667
        name2u = u'2file-\u0633'
 
1668
        tree = [
 
1669
            name0u,
 
1670
            name1u + '/',
 
1671
            name1u + '/' + name0u,
 
1672
            name1u + '/' + name1u + '/',
 
1673
            name2u,
 
1674
            ]
 
1675
        name0 = name0u.encode('UTF-8')
 
1676
        name1 = name1u.encode('UTF-8')
 
1677
        name2 = name2u.encode('UTF-8')
 
1678
        expected_dirblocks = [
 
1679
                (('', '.'),
 
1680
                 [(name0, name0, 'file', './' + name0u),
 
1681
                  (name1, name1, 'directory', './' + name1u),
 
1682
                  (name2, name2, 'file', './' + name2u),
 
1683
                 ]
 
1684
                ),
 
1685
                ((name1, './' + name1u),
 
1686
                 [(name1 + '/' + name0, name0, 'file', './' + name1u
 
1687
                                                        + '/' + name0u),
 
1688
                  (name1 + '/' + name1, name1, 'directory', './' + name1u
 
1689
                                                            + '/' + name1u),
 
1690
                 ]
 
1691
                ),
 
1692
                ((name1 + '/' + name1, './' + name1u + '/' + name1u),
 
1693
                 [
 
1694
                 ]
 
1695
                ),
 
1696
            ]
 
1697
        return tree, expected_dirblocks
 
1698
 
 
1699
    def _filter_out(self, raw_dirblocks):
 
1700
        """Filter out a walkdirs_utf8 result.
 
1701
 
 
1702
        stat field is removed, all native paths are converted to unicode
 
1703
        """
 
1704
        filtered_dirblocks = []
 
1705
        for dirinfo, block in raw_dirblocks:
 
1706
            dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
 
1707
            details = []
 
1708
            for line in block:
 
1709
                details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
 
1710
            filtered_dirblocks.append((dirinfo, details))
 
1711
        return filtered_dirblocks
 
1712
 
 
1713
    def test_walk_unicode_tree(self):
 
1714
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1715
        tree, expected_dirblocks = self._get_unicode_tree()
 
1716
        self.build_tree(tree)
 
1717
        result = list(osutils._walkdirs_utf8('.'))
 
1718
        self.assertEqual(expected_dirblocks, self._filter_out(result))
 
1719
 
 
1720
    def test_symlink(self):
 
1721
        self.requireFeature(tests.SymlinkFeature)
 
1722
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1723
        target = u'target\N{Euro Sign}'
 
1724
        link_name = u'l\N{Euro Sign}nk'
 
1725
        os.symlink(target, link_name)
 
1726
        target_utf8 = target.encode('UTF-8')
 
1727
        link_name_utf8 = link_name.encode('UTF-8')
 
1728
        expected_dirblocks = [
 
1729
                (('', '.'),
 
1730
                 [(link_name_utf8, link_name_utf8,
 
1731
                   'symlink', './' + link_name),],
 
1732
                 )]
 
1733
        result = list(osutils._walkdirs_utf8('.'))
 
1734
        self.assertEqual(expected_dirblocks, self._filter_out(result))
 
1735
 
 
1736
 
 
1737
class TestReadLink(tests.TestCaseInTempDir):
 
1738
    """Exposes os.readlink() problems and the osutils solution.
 
1739
 
 
1740
    The only guarantee offered by os.readlink(), starting with 2.6, is that a
 
1741
    unicode string will be returned if a unicode string is passed.
 
1742
 
 
1743
    But prior python versions failed to properly encode the passed unicode
 
1744
    string.
 
1745
    """
 
1746
    _test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
 
1747
 
 
1748
    def setUp(self):
 
1749
        super(tests.TestCaseInTempDir, self).setUp()
 
1750
        self.link = u'l\N{Euro Sign}ink'
 
1751
        self.target = u'targe\N{Euro Sign}t'
 
1752
        os.symlink(self.target, self.link)
 
1753
 
 
1754
    def test_os_readlink_link_encoding(self):
 
1755
        if sys.version_info < (2, 6):
 
1756
            self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
 
1757
        else:
 
1758
            self.assertEquals(self.target,  os.readlink(self.link))
 
1759
 
 
1760
    def test_os_readlink_link_decoding(self):
 
1761
        self.assertEquals(self.target.encode(osutils._fs_enc),
 
1762
                          os.readlink(self.link.encode(osutils._fs_enc)))
 
1763
 
 
1764
 
 
1765
class TestConcurrency(tests.TestCase):
 
1766
 
 
1767
    def test_local_concurrency(self):
 
1768
        concurrency = osutils.local_concurrency()
 
1769
        self.assertIsInstance(concurrency, int)