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
- browse files at revision 4326.2.4
- compare with another revision
- compare with revision 1663
- download diff
- download tarball
- view history from revision 4326.2.4
- Committer: Jonathan Lange
- Date: 2009-05-11 04:33:27 UTC
- mfrom: (4347 +trunk)
- mto: This revision was merged to the branch mainline in revision 4349.
- Revision ID: jml@canonical.com-20090511043327-43p8twenbmh804f8
Merge trunk, resolving conflicts.
- files added:
- bzrlib/tests/per_interbranch/test_pull.py
- files modified:
- NEWS
added
removed
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='.')
813
909
814
910
class TestWalkDirs(tests.TestCaseInTempDir):
815
911
912
def assertExpectedBlocks(self, expected, result):
913
self.assertEqual(expected,
914
[(dirinfo, [line[0:3] for line in block])
915
for dirinfo, block in result])
916
816
917
def test_walkdirs(self):
817
918
tree = [
818
919
'.bzr',
850
951
result.append((dirdetail, dirblock))
851
952
852
953
self.assertTrue(found_bzrdir)
853
self.assertEqual(expected_dirblocks,
854
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
954
self.assertExpectedBlocks(expected_dirblocks, result)
855
955
# you can search a subdir only, with a supplied prefix.
856
956
result = []
857
957
for dirblock in osutils.walkdirs('./1dir', '1dir'):
858
958
result.append(dirblock)
859
self.assertEqual(expected_dirblocks[1:],
860
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
959
self.assertExpectedBlocks(expected_dirblocks[1:], result)
861
960
862
961
def test_walkdirs_os_error(self):
863
962
# <https://bugs.edge.launchpad.net/bzr/+bug/338653>
869
968
os.mkdir("test-unreadable")
870
969
os.chmod("test-unreadable", 0000)
871
970
# must chmod it back so that it can be removed
872
self.addCleanup(lambda: os.chmod("test-unreadable", 0700))
971
self.addCleanup(os.chmod, "test-unreadable", 0700)
873
972
# The error is not raised until the generator is actually evaluated.
874
973
# (It would be ok if it happened earlier but at the moment it
875
974
# doesn't.)
916
1015
result.append((dirdetail, dirblock))
917
1016
918
1017
self.assertTrue(found_bzrdir)
919
self.assertEqual(expected_dirblocks,
920
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1018
self.assertExpectedBlocks(expected_dirblocks, result)
1019
921
1020
# you can search a subdir only, with a supplied prefix.
922
1021
result = []
923
1022
for dirblock in osutils.walkdirs('./1dir', '1dir'):
924
1023
result.append(dirblock)
925
self.assertEqual(expected_dirblocks[1:],
926
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1024
self.assertExpectedBlocks(expected_dirblocks[1:], result)
927
1025
928
1026
def _filter_out_stat(self, result):
929
1027
"""Filter out the stat value from the walkdirs result"""
944
1042
osutils._selected_dir_reader = cur_dir_reader
945
1043
self.addCleanup(restore)
946
1044
947
def assertReadFSDirIs(self, expected):
1045
def assertDirReaderIs(self, expected):
948
1046
"""Assert the right implementation for _walkdirs_utf8 is chosen."""
949
1047
# Force it to redetect
950
1048
osutils._selected_dir_reader = None
957
1055
self._save_platform_info()
958
1056
win32utils.winver = None # Avoid the win32 detection code
959
1057
osutils._fs_enc = 'UTF-8'
960
self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
1058
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
961
1059
962
1060
def test_force_walkdirs_utf8_fs_ascii(self):
963
1061
self.requireFeature(UTF8DirReaderFeature)
964
1062
self._save_platform_info()
965
1063
win32utils.winver = None # Avoid the win32 detection code
966
1064
osutils._fs_enc = 'US-ASCII'
967
self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
1065
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
968
1066
969
1067
def test_force_walkdirs_utf8_fs_ANSI(self):
970
1068
self.requireFeature(UTF8DirReaderFeature)
971
1069
self._save_platform_info()
972
1070
win32utils.winver = None # Avoid the win32 detection code
973
1071
osutils._fs_enc = 'ANSI_X3.4-1968'
974
self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
1072
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
975
1073
976
1074
def test_force_walkdirs_utf8_fs_latin1(self):
977
1075
self._save_platform_info()
978
1076
win32utils.winver = None # Avoid the win32 detection code
979
1077
osutils._fs_enc = 'latin1'
980
self.assertReadFSDirIs(osutils.UnicodeDirReader)
1078
self.assertDirReaderIs(osutils.UnicodeDirReader)
981
1079
982
1080
def test_force_walkdirs_utf8_nt(self):
983
1081
# Disabled because the thunk of the whole walkdirs api is disabled.
985
1083
self._save_platform_info()
986
1084
win32utils.winver = 'Windows NT'
987
1085
from bzrlib._walkdirs_win32 import Win32ReadDir
988
self.assertReadFSDirIs(Win32ReadDir)
1086
self.assertDirReaderIs(Win32ReadDir)
989
1087
990
1088
def test_force_walkdirs_utf8_98(self):
991
1089
self.requireFeature(test__walkdirs_win32.Win32ReadDirFeature)
992
1090
self._save_platform_info()
993
1091
win32utils.winver = 'Windows 98'
994
self.assertReadFSDirIs(osutils.UnicodeDirReader)
1092
self.assertDirReaderIs(osutils.UnicodeDirReader)
995
1093
996
1094
def test_unicode_walkdirs(self):
997
1095
"""Walkdirs should always return unicode paths."""
1420
1518
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1421
1519
1422
1520
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
1521
class TestSizeShaFile(tests.TestCaseInTempDir):
1446
1522
1447
1523
def test_sha_empty(self):
1510
1586
"Invalid regular expression in test case: '*': "
1511
1587
"nothing to repeat",
1512
1588
str(err))
1589
1590
1591
class TestDirReader(tests.TestCaseInTempDir):
1592
1593
# Set by load_tests
1594
_dir_reader_class = None
1595
_native_to_unicode = None
1596
1597
def setUp(self):
1598
tests.TestCaseInTempDir.setUp(self)
1599
1600
# Save platform specific info and reset it
1601
cur_dir_reader = osutils._selected_dir_reader
1602
1603
def restore():
1604
osutils._selected_dir_reader = cur_dir_reader
1605
self.addCleanup(restore)
1606
1607
osutils._selected_dir_reader = self._dir_reader_class()
1608
1609
def _get_ascii_tree(self):
1610
tree = [
1611
'0file',
1612
'1dir/',
1613
'1dir/0file',
1614
'1dir/1dir/',
1615
'2file'
1616
]
1617
expected_dirblocks = [
1618
(('', '.'),
1619
[('0file', '0file', 'file'),
1620
('1dir', '1dir', 'directory'),
1621
('2file', '2file', 'file'),
1622
]
1623
),
1624
(('1dir', './1dir'),
1625
[('1dir/0file', '0file', 'file'),
1626
('1dir/1dir', '1dir', 'directory'),
1627
]
1628
),
1629
(('1dir/1dir', './1dir/1dir'),
1630
[
1631
]
1632
),
1633
]
1634
return tree, expected_dirblocks
1635
1636
def test_walk_cur_dir(self):
1637
tree, expected_dirblocks = self._get_ascii_tree()
1638
self.build_tree(tree)
1639
result = list(osutils._walkdirs_utf8('.'))
1640
# Filter out stat and abspath
1641
self.assertEqual(expected_dirblocks,
1642
[(dirinfo, [line[0:3] for line in block])
1643
for dirinfo, block in result])
1644
1645
def test_walk_sub_dir(self):
1646
tree, expected_dirblocks = self._get_ascii_tree()
1647
self.build_tree(tree)
1648
# you can search a subdir only, with a supplied prefix.
1649
result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1650
# Filter out stat and abspath
1651
self.assertEqual(expected_dirblocks[1:],
1652
[(dirinfo, [line[0:3] for line in block])
1653
for dirinfo, block in result])
1654
1655
def _get_unicode_tree(self):
1656
name0u = u'0file-\xb6'
1657
name1u = u'1dir-\u062c\u0648'
1658
name2u = u'2file-\u0633'
1659
tree = [
1660
name0u,
1661
name1u + '/',
1662
name1u + '/' + name0u,
1663
name1u + '/' + name1u + '/',
1664
name2u,
1665
]
1666
name0 = name0u.encode('UTF-8')
1667
name1 = name1u.encode('UTF-8')
1668
name2 = name2u.encode('UTF-8')
1669
expected_dirblocks = [
1670
(('', '.'),
1671
[(name0, name0, 'file', './' + name0u),
1672
(name1, name1, 'directory', './' + name1u),
1673
(name2, name2, 'file', './' + name2u),
1674
]
1675
),
1676
((name1, './' + name1u),
1677
[(name1 + '/' + name0, name0, 'file', './' + name1u
1678
+ '/' + name0u),
1679
(name1 + '/' + name1, name1, 'directory', './' + name1u
1680
+ '/' + name1u),
1681
]
1682
),
1683
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1684
[
1685
]
1686
),
1687
]
1688
return tree, expected_dirblocks
1689
1690
def _filter_out(self, raw_dirblocks):
1691
"""Filter out a walkdirs_utf8 result.
1692
1693
stat field is removed, all native paths are converted to unicode
1694
"""
1695
filtered_dirblocks = []
1696
for dirinfo, block in raw_dirblocks:
1697
dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1698
details = []
1699
for line in block:
1700
details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1701
filtered_dirblocks.append((dirinfo, details))
1702
return filtered_dirblocks
1703
1704
def test_walk_unicode_tree(self):
1705
self.requireFeature(tests.UnicodeFilenameFeature)
1706
tree, expected_dirblocks = self._get_unicode_tree()
1707
self.build_tree(tree)
1708
result = list(osutils._walkdirs_utf8('.'))
1709
self.assertEqual(expected_dirblocks, self._filter_out(result))
1710
1711
def test_symlink(self):
1712
self.requireFeature(tests.SymlinkFeature)
1713
self.requireFeature(tests.UnicodeFilenameFeature)
1714
target = u'target\N{Euro Sign}'
1715
link_name = u'l\N{Euro Sign}nk'
1716
os.symlink(target, link_name)
1717
target_utf8 = target.encode('UTF-8')
1718
link_name_utf8 = link_name.encode('UTF-8')
1719
expected_dirblocks = [
1720
(('', '.'),
1721
[(link_name_utf8, link_name_utf8,
1722
'symlink', './' + link_name),],
1723
)]
1724
result = list(osutils._walkdirs_utf8('.'))
1725
self.assertEqual(expected_dirblocks, self._filter_out(result))
1726
1727
1728
class TestReadLink(tests.TestCaseInTempDir):
1729
"""Exposes os.readlink() problems and the osutils solution.
1730
1731
The only guarantee offered by os.readlink(), starting with 2.6, is that a
1732
unicode string will be returned if a unicode string is passed.
1733
1734
But prior python versions failed to properly encode the passed unicode
1735
string.
1736
"""
1737
_test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
1738
1739
def setUp(self):
1740
super(tests.TestCaseInTempDir, self).setUp()
1741
self.link = u'l\N{Euro Sign}ink'
1742
self.target = u'targe\N{Euro Sign}t'
1743
os.symlink(self.target, self.link)
1744
1745
def test_os_readlink_link_encoding(self):
1746
if sys.version_info < (2, 6):
1747
self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
1748
else:
1749
self.assertEquals(self.target, os.readlink(self.link))
1750
1751
def test_os_readlink_link_decoding(self):
1752
self.assertEquals(self.target.encode(osutils._fs_enc),
1753
os.readlink(self.link.encode(osutils._fs_enc)))
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0