13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
17
"""Tests for the osutils wrapper."""
19
from cStringIO import StringIO
26
28
from bzrlib import (
31
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
32
37
from bzrlib.tests import (
40
class TestOSUtils(TestCaseInTempDir):
42
from bzrlib.tests.scenarios import load_tests_apply_scenarios
45
class _UTF8DirReaderFeature(features.Feature):
49
from bzrlib import _readdir_pyx
50
self.reader = _readdir_pyx.UTF8DirReader
55
def feature_name(self):
56
return 'bzrlib._readdir_pyx'
58
UTF8DirReaderFeature = features.ModuleAvailableFeature('bzrlib._readdir_pyx')
60
term_ios_feature = features.ModuleAvailableFeature('termios')
63
def _already_unicode(s):
67
def _utf8_to_unicode(s):
68
return s.decode('UTF-8')
71
def dir_reader_scenarios():
72
# For each dir reader we define:
74
# - native_to_unicode: a function converting the native_abspath as returned
75
# by DirReader.read_dir to its unicode representation
77
# UnicodeDirReader is the fallback, it should be tested on all platforms.
78
scenarios = [('unicode',
79
dict(_dir_reader_class=osutils.UnicodeDirReader,
80
_native_to_unicode=_already_unicode))]
81
# Some DirReaders are platform specific and even there they may not be
83
if UTF8DirReaderFeature.available():
84
from bzrlib import _readdir_pyx
85
scenarios.append(('utf8',
86
dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
87
_native_to_unicode=_utf8_to_unicode)))
89
if test__walkdirs_win32.win32_readdir_feature.available():
91
from bzrlib import _walkdirs_win32
94
dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
95
_native_to_unicode=_already_unicode)))
101
load_tests = load_tests_apply_scenarios
104
class TestContainsWhitespace(tests.TestCase):
42
106
def test_contains_whitespace(self):
43
self.failUnless(osutils.contains_whitespace(u' '))
44
self.failUnless(osutils.contains_whitespace(u'hello there'))
45
self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
46
self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
47
self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
48
self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
107
self.assertTrue(osutils.contains_whitespace(u' '))
108
self.assertTrue(osutils.contains_whitespace(u'hello there'))
109
self.assertTrue(osutils.contains_whitespace(u'hellothere\n'))
110
self.assertTrue(osutils.contains_whitespace(u'hello\nthere'))
111
self.assertTrue(osutils.contains_whitespace(u'hello\rthere'))
112
self.assertTrue(osutils.contains_whitespace(u'hello\tthere'))
50
114
# \xa0 is "Non-breaking-space" which on some python locales thinks it
51
115
# is whitespace, but we do not.
52
self.failIf(osutils.contains_whitespace(u''))
53
self.failIf(osutils.contains_whitespace(u'hellothere'))
54
self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
116
self.assertFalse(osutils.contains_whitespace(u''))
117
self.assertFalse(osutils.contains_whitespace(u'hellothere'))
118
self.assertFalse(osutils.contains_whitespace(u'hello\xa0there'))
121
class TestRename(tests.TestCaseInTempDir):
123
def create_file(self, filename, content):
124
f = open(filename, 'wb')
130
def _fancy_rename(self, a, b):
131
osutils.fancy_rename(a, b, rename_func=os.rename,
132
unlink_func=os.unlink)
56
134
def test_fancy_rename(self):
57
135
# This should work everywhere
59
osutils.fancy_rename(a, b,
60
rename_func=os.rename,
61
unlink_func=os.unlink)
63
open('a', 'wb').write('something in a\n')
65
self.failIfExists('a')
66
self.failUnlessExists('b')
136
self.create_file('a', 'something in a\n')
137
self._fancy_rename('a', 'b')
138
self.assertPathDoesNotExist('a')
139
self.assertPathExists('b')
67
140
self.check_file_contents('b', 'something in a\n')
69
open('a', 'wb').write('new something in a\n')
142
self.create_file('a', 'new something in a\n')
143
self._fancy_rename('b', 'a')
72
145
self.check_file_contents('a', 'something in a\n')
147
def test_fancy_rename_fails_source_missing(self):
148
# An exception should be raised, and the target should be left in place
149
self.create_file('target', 'data in target\n')
150
self.assertRaises((IOError, OSError), self._fancy_rename,
151
'missingsource', 'target')
152
self.assertPathExists('target')
153
self.check_file_contents('target', 'data in target\n')
155
def test_fancy_rename_fails_if_source_and_target_missing(self):
156
self.assertRaises((IOError, OSError), self._fancy_rename,
157
'missingsource', 'missingtarget')
74
159
def test_rename(self):
75
160
# Rename should be semi-atomic on all platforms
76
open('a', 'wb').write('something in a\n')
161
self.create_file('a', 'something in a\n')
77
162
osutils.rename('a', 'b')
78
self.failIfExists('a')
79
self.failUnlessExists('b')
163
self.assertPathDoesNotExist('a')
164
self.assertPathExists('b')
80
165
self.check_file_contents('b', 'something in a\n')
82
open('a', 'wb').write('new something in a\n')
167
self.create_file('a', 'new something in a\n')
83
168
osutils.rename('b', 'a')
85
170
self.check_file_contents('a', 'something in a\n')
87
172
# TODO: test fancy_rename using a MemoryTransport
174
def test_rename_change_case(self):
175
# on Windows we should be able to change filename case by rename
176
self.build_tree(['a', 'b/'])
177
osutils.rename('a', 'A')
178
osutils.rename('b', 'B')
179
# we can't use failUnlessExists on case-insensitive filesystem
180
# so try to check shape of the tree
181
shape = sorted(os.listdir('.'))
182
self.assertEquals(['A', 'B'], shape)
185
class TestRandChars(tests.TestCase):
89
187
def test_01_rand_chars_empty(self):
90
188
result = osutils.rand_chars(0)
91
189
self.assertEqual(result, '')
240
456
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
241
457
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
244
class TestSafeUnicode(TestCase):
459
def test_changing_access(self):
460
f = file('file', 'w')
464
# Make a file readonly
465
osutils.make_readonly('file')
466
mode = os.lstat('file').st_mode
467
self.assertEqual(mode, mode & 0777555)
469
# Make a file writable
470
osutils.make_writable('file')
471
mode = os.lstat('file').st_mode
472
self.assertEqual(mode, mode | 0200)
474
if osutils.has_symlinks():
475
# should not error when handed a symlink
476
os.symlink('nonexistent', 'dangling')
477
osutils.make_readonly('dangling')
478
osutils.make_writable('dangling')
480
def test_host_os_dereferences_symlinks(self):
481
osutils.host_os_dereferences_symlinks()
484
class TestCanonicalRelPath(tests.TestCaseInTempDir):
486
_test_needs_features = [features.CaseInsCasePresFilenameFeature]
488
def test_canonical_relpath_simple(self):
489
f = file('MixedCaseName', 'w')
491
actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
492
self.assertEqual('work/MixedCaseName', actual)
494
def test_canonical_relpath_missing_tail(self):
495
os.mkdir('MixedCaseParent')
496
actual = osutils.canonical_relpath(self.test_base_dir,
497
'mixedcaseparent/nochild')
498
self.assertEqual('work/MixedCaseParent/nochild', actual)
501
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
503
def assertRelpath(self, expected, base, path):
504
actual = osutils._cicp_canonical_relpath(base, path)
505
self.assertEqual(expected, actual)
507
def test_simple(self):
508
self.build_tree(['MixedCaseName'])
509
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
510
self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
512
def test_subdir_missing_tail(self):
513
self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
514
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
515
self.assertRelpath('MixedCaseParent/a_child', base,
516
'MixedCaseParent/a_child')
517
self.assertRelpath('MixedCaseParent/a_child', base,
518
'MixedCaseParent/A_Child')
519
self.assertRelpath('MixedCaseParent/not_child', base,
520
'MixedCaseParent/not_child')
522
def test_at_root_slash(self):
523
# We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
525
if osutils.MIN_ABS_PATHLENGTH > 1:
526
raise tests.TestSkipped('relpath requires %d chars'
527
% osutils.MIN_ABS_PATHLENGTH)
528
self.assertRelpath('foo', '/', '/foo')
530
def test_at_root_drive(self):
531
if sys.platform != 'win32':
532
raise tests.TestNotApplicable('we can only test drive-letter relative'
533
' paths on Windows where we have drive'
536
# The specific issue is that when at the root of a drive, 'abspath'
537
# returns "C:/" or just "/". However, the code assumes that abspath
538
# always returns something like "C:/foo" or "/foo" (no trailing slash).
539
self.assertRelpath('foo', 'C:/', 'C:/foo')
540
self.assertRelpath('foo', 'X:/', 'X:/foo')
541
self.assertRelpath('foo', 'X:/', 'X://foo')
544
class TestPumpFile(tests.TestCase):
545
"""Test pumpfile method."""
548
tests.TestCase.setUp(self)
549
# create a test datablock
550
self.block_size = 512
551
pattern = '0123456789ABCDEF'
552
self.test_data = pattern * (3 * self.block_size / len(pattern))
553
self.test_data_len = len(self.test_data)
555
def test_bracket_block_size(self):
556
"""Read data in blocks with the requested read size bracketing the
558
# make sure test data is larger than max read size
559
self.assertTrue(self.test_data_len > self.block_size)
561
from_file = file_utils.FakeReadFile(self.test_data)
564
# read (max / 2) bytes and verify read size wasn't affected
565
num_bytes_to_read = self.block_size / 2
566
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
567
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
568
self.assertEqual(from_file.get_read_count(), 1)
570
# read (max) bytes and verify read size wasn't affected
571
num_bytes_to_read = self.block_size
572
from_file.reset_read_count()
573
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
574
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
575
self.assertEqual(from_file.get_read_count(), 1)
577
# read (max + 1) bytes and verify read size was limited
578
num_bytes_to_read = self.block_size + 1
579
from_file.reset_read_count()
580
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
581
self.assertEqual(from_file.get_max_read_size(), self.block_size)
582
self.assertEqual(from_file.get_read_count(), 2)
584
# finish reading the rest of the data
585
num_bytes_to_read = self.test_data_len - to_file.tell()
586
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
588
# report error if the data wasn't equal (we only report the size due
589
# to the length of the data)
590
response_data = to_file.getvalue()
591
if response_data != self.test_data:
592
message = "Data not equal. Expected %d bytes, received %d."
593
self.fail(message % (len(response_data), self.test_data_len))
595
def test_specified_size(self):
596
"""Request a transfer larger than the maximum block size and verify
597
that the maximum read doesn't exceed the block_size."""
598
# make sure test data is larger than max read size
599
self.assertTrue(self.test_data_len > self.block_size)
601
# retrieve data in blocks
602
from_file = file_utils.FakeReadFile(self.test_data)
604
osutils.pumpfile(from_file, to_file, self.test_data_len,
607
# verify read size was equal to the maximum read size
608
self.assertTrue(from_file.get_max_read_size() > 0)
609
self.assertEqual(from_file.get_max_read_size(), self.block_size)
610
self.assertEqual(from_file.get_read_count(), 3)
612
# report error if the data wasn't equal (we only report the size due
613
# to the length of the data)
614
response_data = to_file.getvalue()
615
if response_data != self.test_data:
616
message = "Data not equal. Expected %d bytes, received %d."
617
self.fail(message % (len(response_data), self.test_data_len))
619
def test_to_eof(self):
620
"""Read to end-of-file and verify that the reads are not larger than
621
the maximum read size."""
622
# make sure test data is larger than max read size
623
self.assertTrue(self.test_data_len > self.block_size)
625
# retrieve data to EOF
626
from_file = file_utils.FakeReadFile(self.test_data)
628
osutils.pumpfile(from_file, to_file, -1, self.block_size)
630
# verify read size was equal to the maximum read size
631
self.assertEqual(from_file.get_max_read_size(), self.block_size)
632
self.assertEqual(from_file.get_read_count(), 4)
634
# report error if the data wasn't equal (we only report the size due
635
# to the length of the data)
636
response_data = to_file.getvalue()
637
if response_data != self.test_data:
638
message = "Data not equal. Expected %d bytes, received %d."
639
self.fail(message % (len(response_data), self.test_data_len))
641
def test_defaults(self):
642
"""Verifies that the default arguments will read to EOF -- this
643
test verifies that any existing usages of pumpfile will not be broken
644
with this new version."""
645
# retrieve data using default (old) pumpfile method
646
from_file = file_utils.FakeReadFile(self.test_data)
648
osutils.pumpfile(from_file, to_file)
650
# report error if the data wasn't equal (we only report the size due
651
# to the length of the data)
652
response_data = to_file.getvalue()
653
if response_data != self.test_data:
654
message = "Data not equal. Expected %d bytes, received %d."
655
self.fail(message % (len(response_data), self.test_data_len))
657
def test_report_activity(self):
659
def log_activity(length, direction):
660
activity.append((length, direction))
661
from_file = StringIO(self.test_data)
663
osutils.pumpfile(from_file, to_file, buff_size=500,
664
report_activity=log_activity, direction='read')
665
self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
666
(36, 'read')], activity)
668
from_file = StringIO(self.test_data)
671
osutils.pumpfile(from_file, to_file, buff_size=500,
672
report_activity=log_activity, direction='write')
673
self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
674
(36, 'write')], activity)
676
# And with a limited amount of data
677
from_file = StringIO(self.test_data)
680
osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
681
report_activity=log_activity, direction='read')
682
self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
686
class TestPumpStringFile(tests.TestCase):
688
def test_empty(self):
690
osutils.pump_string_file("", output)
691
self.assertEqual("", output.getvalue())
693
def test_more_than_segment_size(self):
695
osutils.pump_string_file("123456789", output, 2)
696
self.assertEqual("123456789", output.getvalue())
698
def test_segment_size(self):
700
osutils.pump_string_file("12", output, 2)
701
self.assertEqual("12", output.getvalue())
703
def test_segment_size_multiple(self):
705
osutils.pump_string_file("1234", output, 2)
706
self.assertEqual("1234", output.getvalue())
709
class TestRelpath(tests.TestCase):
711
def test_simple_relpath(self):
712
cwd = osutils.getcwd()
713
subdir = cwd + '/subdir'
714
self.assertEqual('subdir', osutils.relpath(cwd, subdir))
716
def test_deep_relpath(self):
717
cwd = osutils.getcwd()
718
subdir = cwd + '/sub/subsubdir'
719
self.assertEqual('sub/subsubdir', osutils.relpath(cwd, subdir))
721
def test_not_relative(self):
722
self.assertRaises(errors.PathNotChild,
723
osutils.relpath, 'C:/path', 'H:/path')
724
self.assertRaises(errors.PathNotChild,
725
osutils.relpath, 'C:/', 'H:/path')
728
class TestSafeUnicode(tests.TestCase):
246
730
def test_from_ascii_string(self):
247
731
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
523
1082
result.append((dirdetail, dirblock))
525
1084
self.assertTrue(found_bzrdir)
526
self.assertEqual(expected_dirblocks,
527
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
528
# you can search a subdir only, with a supplied prefix.
530
for dirblock in osutils.walkdirs('./1dir', '1dir'):
531
result.append(dirblock)
532
self.assertEqual(expected_dirblocks[1:],
533
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1085
self.assertExpectedBlocks(expected_dirblocks, result)
1086
# you can search a subdir only, with a supplied prefix.
1088
for dirblock in osutils.walkdirs('./1dir', '1dir'):
1089
result.append(dirblock)
1090
self.assertExpectedBlocks(expected_dirblocks[1:], result)
1092
def test_walkdirs_os_error(self):
1093
# <https://bugs.launchpad.net/bzr/+bug/338653>
1094
# Pyrex readdir didn't raise useful messages if it had an error
1095
# reading the directory
1096
if sys.platform == 'win32':
1097
raise tests.TestNotApplicable(
1098
"readdir IOError not tested on win32")
1099
self.requireFeature(features.not_running_as_root)
1100
os.mkdir("test-unreadable")
1101
os.chmod("test-unreadable", 0000)
1102
# must chmod it back so that it can be removed
1103
self.addCleanup(os.chmod, "test-unreadable", 0700)
1104
# The error is not raised until the generator is actually evaluated.
1105
# (It would be ok if it happened earlier but at the moment it
1107
e = self.assertRaises(OSError, list, osutils._walkdirs_utf8("."))
1108
self.assertEquals('./test-unreadable', e.filename)
1109
self.assertEquals(errno.EACCES, e.errno)
1110
# Ensure the message contains the file name
1111
self.assertContainsRe(str(e), "\./test-unreadable")
1114
def test_walkdirs_encoding_error(self):
1115
# <https://bugs.launchpad.net/bzr/+bug/488519>
1116
# walkdirs didn't raise a useful message when the filenames
1117
# are not using the filesystem's encoding
1119
# require a bytestring based filesystem
1120
self.requireFeature(features.ByteStringNamedFilesystem)
1131
self.build_tree(tree)
1133
# rename the 1file to a latin-1 filename
1134
os.rename("./1file", "\xe8file")
1135
if "\xe8file" not in os.listdir("."):
1136
self.skip("Lack filesystem that preserves arbitrary bytes")
1138
self._save_platform_info()
1139
win32utils.winver = None # Avoid the win32 detection code
1140
osutils._fs_enc = 'UTF-8'
1142
# this should raise on error
1144
for dirdetail, dirblock in osutils.walkdirs('.'):
1147
self.assertRaises(errors.BadFilenameEncoding, attempt)
1149
def test__walkdirs_utf8(self):
1158
self.build_tree(tree)
1159
expected_dirblocks = [
1161
[('0file', '0file', 'file'),
1162
('1dir', '1dir', 'directory'),
1163
('2file', '2file', 'file'),
1166
(('1dir', './1dir'),
1167
[('1dir/0file', '0file', 'file'),
1168
('1dir/1dir', '1dir', 'directory'),
1171
(('1dir/1dir', './1dir/1dir'),
1177
found_bzrdir = False
1178
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1179
if len(dirblock) and dirblock[0][1] == '.bzr':
1180
# this tests the filtering of selected paths
1183
result.append((dirdetail, dirblock))
1185
self.assertTrue(found_bzrdir)
1186
self.assertExpectedBlocks(expected_dirblocks, result)
1188
# you can search a subdir only, with a supplied prefix.
1190
for dirblock in osutils.walkdirs('./1dir', '1dir'):
1191
result.append(dirblock)
1192
self.assertExpectedBlocks(expected_dirblocks[1:], result)
1194
def _filter_out_stat(self, result):
1195
"""Filter out the stat value from the walkdirs result"""
1196
for dirdetail, dirblock in result:
1198
for info in dirblock:
1199
# Ignore info[3] which is the stat
1200
new_dirblock.append((info[0], info[1], info[2], info[4]))
1201
dirblock[:] = new_dirblock
1203
def _save_platform_info(self):
1204
self.overrideAttr(win32utils, 'winver')
1205
self.overrideAttr(osutils, '_fs_enc')
1206
self.overrideAttr(osutils, '_selected_dir_reader')
1208
def assertDirReaderIs(self, expected):
1209
"""Assert the right implementation for _walkdirs_utf8 is chosen."""
1210
# Force it to redetect
1211
osutils._selected_dir_reader = None
1212
# Nothing to list, but should still trigger the selection logic
1213
self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
1214
self.assertIsInstance(osutils._selected_dir_reader, expected)
1216
def test_force_walkdirs_utf8_fs_utf8(self):
1217
self.requireFeature(UTF8DirReaderFeature)
1218
self._save_platform_info()
1219
win32utils.winver = None # Avoid the win32 detection code
1220
osutils._fs_enc = 'UTF-8'
1221
self.assertDirReaderIs(
1222
UTF8DirReaderFeature.module.UTF8DirReader)
1224
def test_force_walkdirs_utf8_fs_ascii(self):
1225
self.requireFeature(UTF8DirReaderFeature)
1226
self._save_platform_info()
1227
win32utils.winver = None # Avoid the win32 detection code
1228
osutils._fs_enc = 'US-ASCII'
1229
self.assertDirReaderIs(
1230
UTF8DirReaderFeature.module.UTF8DirReader)
1232
def test_force_walkdirs_utf8_fs_ANSI(self):
1233
self.requireFeature(UTF8DirReaderFeature)
1234
self._save_platform_info()
1235
win32utils.winver = None # Avoid the win32 detection code
1236
osutils._fs_enc = 'ANSI_X3.4-1968'
1237
self.assertDirReaderIs(
1238
UTF8DirReaderFeature.module.UTF8DirReader)
1240
def test_force_walkdirs_utf8_fs_latin1(self):
1241
self._save_platform_info()
1242
win32utils.winver = None # Avoid the win32 detection code
1243
osutils._fs_enc = 'latin1'
1244
self.assertDirReaderIs(osutils.UnicodeDirReader)
1246
def test_force_walkdirs_utf8_nt(self):
1247
# Disabled because the thunk of the whole walkdirs api is disabled.
1248
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1249
self._save_platform_info()
1250
win32utils.winver = 'Windows NT'
1251
from bzrlib._walkdirs_win32 import Win32ReadDir
1252
self.assertDirReaderIs(Win32ReadDir)
1254
def test_force_walkdirs_utf8_98(self):
1255
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1256
self._save_platform_info()
1257
win32utils.winver = 'Windows 98'
1258
self.assertDirReaderIs(osutils.UnicodeDirReader)
1260
def test_unicode_walkdirs(self):
1261
"""Walkdirs should always return unicode paths."""
1262
self.requireFeature(features.UnicodeFilenameFeature)
1263
name0 = u'0file-\xb6'
1264
name1 = u'1dir-\u062c\u0648'
1265
name2 = u'2file-\u0633'
1269
name1 + '/' + name0,
1270
name1 + '/' + name1 + '/',
1273
self.build_tree(tree)
1274
expected_dirblocks = [
1276
[(name0, name0, 'file', './' + name0),
1277
(name1, name1, 'directory', './' + name1),
1278
(name2, name2, 'file', './' + name2),
1281
((name1, './' + name1),
1282
[(name1 + '/' + name0, name0, 'file', './' + name1
1284
(name1 + '/' + name1, name1, 'directory', './' + name1
1288
((name1 + '/' + name1, './' + name1 + '/' + name1),
1293
result = list(osutils.walkdirs('.'))
1294
self._filter_out_stat(result)
1295
self.assertEqual(expected_dirblocks, result)
1296
result = list(osutils.walkdirs(u'./'+name1, name1))
1297
self._filter_out_stat(result)
1298
self.assertEqual(expected_dirblocks[1:], result)
1300
def test_unicode__walkdirs_utf8(self):
1301
"""Walkdirs_utf8 should always return utf8 paths.
1303
The abspath portion might be in unicode or utf-8
1305
self.requireFeature(features.UnicodeFilenameFeature)
1306
name0 = u'0file-\xb6'
1307
name1 = u'1dir-\u062c\u0648'
1308
name2 = u'2file-\u0633'
1312
name1 + '/' + name0,
1313
name1 + '/' + name1 + '/',
1316
self.build_tree(tree)
1317
name0 = name0.encode('utf8')
1318
name1 = name1.encode('utf8')
1319
name2 = name2.encode('utf8')
1321
expected_dirblocks = [
1323
[(name0, name0, 'file', './' + name0),
1324
(name1, name1, 'directory', './' + name1),
1325
(name2, name2, 'file', './' + name2),
1328
((name1, './' + name1),
1329
[(name1 + '/' + name0, name0, 'file', './' + name1
1331
(name1 + '/' + name1, name1, 'directory', './' + name1
1335
((name1 + '/' + name1, './' + name1 + '/' + name1),
1341
# For ease in testing, if walkdirs_utf8 returns Unicode, assert that
1342
# all abspaths are Unicode, and encode them back into utf8.
1343
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1344
self.assertIsInstance(dirdetail[0], str)
1345
if isinstance(dirdetail[1], unicode):
1346
dirdetail = (dirdetail[0], dirdetail[1].encode('utf8'))
1347
dirblock = [list(info) for info in dirblock]
1348
for info in dirblock:
1349
self.assertIsInstance(info[4], unicode)
1350
info[4] = info[4].encode('utf8')
1352
for info in dirblock:
1353
self.assertIsInstance(info[0], str)
1354
self.assertIsInstance(info[1], str)
1355
self.assertIsInstance(info[4], str)
1356
# Remove the stat information
1357
new_dirblock.append((info[0], info[1], info[2], info[4]))
1358
result.append((dirdetail, new_dirblock))
1359
self.assertEqual(expected_dirblocks, result)
1361
def test__walkdirs_utf8_with_unicode_fs(self):
1362
"""UnicodeDirReader should be a safe fallback everywhere
1364
The abspath portion should be in unicode
1366
self.requireFeature(features.UnicodeFilenameFeature)
1367
# Use the unicode reader. TODO: split into driver-and-driven unit
1369
self._save_platform_info()
1370
osutils._selected_dir_reader = osutils.UnicodeDirReader()
1371
name0u = u'0file-\xb6'
1372
name1u = u'1dir-\u062c\u0648'
1373
name2u = u'2file-\u0633'
1377
name1u + '/' + name0u,
1378
name1u + '/' + name1u + '/',
1381
self.build_tree(tree)
1382
name0 = name0u.encode('utf8')
1383
name1 = name1u.encode('utf8')
1384
name2 = name2u.encode('utf8')
1386
# All of the abspaths should be in unicode, all of the relative paths
1388
expected_dirblocks = [
1390
[(name0, name0, 'file', './' + name0u),
1391
(name1, name1, 'directory', './' + name1u),
1392
(name2, name2, 'file', './' + name2u),
1395
((name1, './' + name1u),
1396
[(name1 + '/' + name0, name0, 'file', './' + name1u
1398
(name1 + '/' + name1, name1, 'directory', './' + name1u
1402
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1407
result = list(osutils._walkdirs_utf8('.'))
1408
self._filter_out_stat(result)
1409
self.assertEqual(expected_dirblocks, result)
1411
def test__walkdirs_utf8_win32readdir(self):
1412
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1413
self.requireFeature(features.UnicodeFilenameFeature)
1414
from bzrlib._walkdirs_win32 import Win32ReadDir
1415
self._save_platform_info()
1416
osutils._selected_dir_reader = Win32ReadDir()
1417
name0u = u'0file-\xb6'
1418
name1u = u'1dir-\u062c\u0648'
1419
name2u = u'2file-\u0633'
1423
name1u + '/' + name0u,
1424
name1u + '/' + name1u + '/',
1427
self.build_tree(tree)
1428
name0 = name0u.encode('utf8')
1429
name1 = name1u.encode('utf8')
1430
name2 = name2u.encode('utf8')
1432
# All of the abspaths should be in unicode, all of the relative paths
1434
expected_dirblocks = [
1436
[(name0, name0, 'file', './' + name0u),
1437
(name1, name1, 'directory', './' + name1u),
1438
(name2, name2, 'file', './' + name2u),
1441
((name1, './' + name1u),
1442
[(name1 + '/' + name0, name0, 'file', './' + name1u
1444
(name1 + '/' + name1, name1, 'directory', './' + name1u
1448
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1453
result = list(osutils._walkdirs_utf8(u'.'))
1454
self._filter_out_stat(result)
1455
self.assertEqual(expected_dirblocks, result)
1457
def assertStatIsCorrect(self, path, win32stat):
1458
os_stat = os.stat(path)
1459
self.assertEqual(os_stat.st_size, win32stat.st_size)
1460
self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
1461
self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
1462
self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
1463
self.assertEqual(os_stat.st_dev, win32stat.st_dev)
1464
self.assertEqual(os_stat.st_ino, win32stat.st_ino)
1465
self.assertEqual(os_stat.st_mode, win32stat.st_mode)
1467
def test__walkdirs_utf_win32_find_file_stat_file(self):
1468
"""make sure our Stat values are valid"""
1469
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1470
self.requireFeature(features.UnicodeFilenameFeature)
1471
from bzrlib._walkdirs_win32 import Win32ReadDir
1472
name0u = u'0file-\xb6'
1473
name0 = name0u.encode('utf8')
1474
self.build_tree([name0u])
1475
# I hate to sleep() here, but I'm trying to make the ctime different
1478
f = open(name0u, 'ab')
1480
f.write('just a small update')
1484
result = Win32ReadDir().read_dir('', u'.')
1486
self.assertEqual((name0, name0, 'file'), entry[:3])
1487
self.assertEqual(u'./' + name0u, entry[4])
1488
self.assertStatIsCorrect(entry[4], entry[3])
1489
self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
1491
def test__walkdirs_utf_win32_find_file_stat_directory(self):
1492
"""make sure our Stat values are valid"""
1493
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1494
self.requireFeature(features.UnicodeFilenameFeature)
1495
from bzrlib._walkdirs_win32 import Win32ReadDir
1496
name0u = u'0dir-\u062c\u0648'
1497
name0 = name0u.encode('utf8')
1498
self.build_tree([name0u + '/'])
1500
result = Win32ReadDir().read_dir('', u'.')
1502
self.assertEqual((name0, name0, 'directory'), entry[:3])
1503
self.assertEqual(u'./' + name0u, entry[4])
1504
self.assertStatIsCorrect(entry[4], entry[3])
535
1506
def assertPathCompare(self, path_less, path_greater):
536
1507
"""check that path_less and path_greater compare correctly."""
724
1680
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
725
1681
self.assertEqual('foo', old)
726
1682
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
727
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
730
class TestLocalTimeOffset(TestCase):
732
def test_local_time_offset(self):
733
"""Test that local_time_offset() returns a sane value."""
734
offset = osutils.local_time_offset()
735
self.assertTrue(isinstance(offset, int))
736
# Test that the offset is no more than a eighteen hours in
738
# Time zone handling is system specific, so it is difficult to
739
# do more specific tests, but a value outside of this range is
741
eighteen_hours = 18 * 3600
742
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
744
def test_local_time_offset_with_timestamp(self):
745
"""Test that local_time_offset() works with a timestamp."""
746
offset = osutils.local_time_offset(1000000000.1234567)
747
self.assertTrue(isinstance(offset, int))
748
eighteen_hours = 18 * 3600
749
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1683
self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
1686
class TestSizeShaFile(tests.TestCaseInTempDir):
1688
def test_sha_empty(self):
1689
self.build_tree_contents([('foo', '')])
1690
expected_sha = osutils.sha_string('')
1692
self.addCleanup(f.close)
1693
size, sha = osutils.size_sha_file(f)
1694
self.assertEqual(0, size)
1695
self.assertEqual(expected_sha, sha)
1697
def test_sha_mixed_endings(self):
1698
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1699
self.build_tree_contents([('foo', text)])
1700
expected_sha = osutils.sha_string(text)
1701
f = open('foo', 'rb')
1702
self.addCleanup(f.close)
1703
size, sha = osutils.size_sha_file(f)
1704
self.assertEqual(38, size)
1705
self.assertEqual(expected_sha, sha)
1708
class TestShaFileByName(tests.TestCaseInTempDir):
1710
def test_sha_empty(self):
1711
self.build_tree_contents([('foo', '')])
1712
expected_sha = osutils.sha_string('')
1713
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1715
def test_sha_mixed_endings(self):
1716
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1717
self.build_tree_contents([('foo', text)])
1718
expected_sha = osutils.sha_string(text)
1719
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1722
class TestResourceLoading(tests.TestCaseInTempDir):
1724
def test_resource_string(self):
1725
# test resource in bzrlib
1726
text = osutils.resource_string('bzrlib', 'debug.py')
1727
self.assertContainsRe(text, "debug_flags = set()")
1728
# test resource under bzrlib
1729
text = osutils.resource_string('bzrlib.ui', 'text.py')
1730
self.assertContainsRe(text, "class TextUIFactory")
1731
# test unsupported package
1732
self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1734
# test unknown resource
1735
self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1738
class TestReCompile(tests.TestCase):
1740
def _deprecated_re_compile_checked(self, *args, **kwargs):
1741
return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
1742
osutils.re_compile_checked, *args, **kwargs)
1744
def test_re_compile_checked(self):
1745
r = self._deprecated_re_compile_checked(r'A*', re.IGNORECASE)
1746
self.assertTrue(r.match('aaaa'))
1747
self.assertTrue(r.match('aAaA'))
1749
def test_re_compile_checked_error(self):
1750
# like https://bugs.launchpad.net/bzr/+bug/251352
1752
# Due to possible test isolation error, re.compile is not lazy at
1753
# this point. We re-install lazy compile.
1754
lazy_regex.install_lazy_compile()
1755
err = self.assertRaises(
1756
errors.BzrCommandError,
1757
self._deprecated_re_compile_checked, '*', re.IGNORECASE, 'test case')
1759
'Invalid regular expression in test case: '
1760
'"*" nothing to repeat',
1764
class TestDirReader(tests.TestCaseInTempDir):
1766
scenarios = dir_reader_scenarios()
1769
_dir_reader_class = None
1770
_native_to_unicode = None
1773
tests.TestCaseInTempDir.setUp(self)
1774
self.overrideAttr(osutils,
1775
'_selected_dir_reader', self._dir_reader_class())
1777
def _get_ascii_tree(self):
1785
expected_dirblocks = [
1787
[('0file', '0file', 'file'),
1788
('1dir', '1dir', 'directory'),
1789
('2file', '2file', 'file'),
1792
(('1dir', './1dir'),
1793
[('1dir/0file', '0file', 'file'),
1794
('1dir/1dir', '1dir', 'directory'),
1797
(('1dir/1dir', './1dir/1dir'),
1802
return tree, expected_dirblocks
1804
def test_walk_cur_dir(self):
1805
tree, expected_dirblocks = self._get_ascii_tree()
1806
self.build_tree(tree)
1807
result = list(osutils._walkdirs_utf8('.'))
1808
# Filter out stat and abspath
1809
self.assertEqual(expected_dirblocks,
1810
[(dirinfo, [line[0:3] for line in block])
1811
for dirinfo, block in result])
1813
def test_walk_sub_dir(self):
1814
tree, expected_dirblocks = self._get_ascii_tree()
1815
self.build_tree(tree)
1816
# you can search a subdir only, with a supplied prefix.
1817
result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1818
# Filter out stat and abspath
1819
self.assertEqual(expected_dirblocks[1:],
1820
[(dirinfo, [line[0:3] for line in block])
1821
for dirinfo, block in result])
1823
def _get_unicode_tree(self):
1824
name0u = u'0file-\xb6'
1825
name1u = u'1dir-\u062c\u0648'
1826
name2u = u'2file-\u0633'
1830
name1u + '/' + name0u,
1831
name1u + '/' + name1u + '/',
1834
name0 = name0u.encode('UTF-8')
1835
name1 = name1u.encode('UTF-8')
1836
name2 = name2u.encode('UTF-8')
1837
expected_dirblocks = [
1839
[(name0, name0, 'file', './' + name0u),
1840
(name1, name1, 'directory', './' + name1u),
1841
(name2, name2, 'file', './' + name2u),
1844
((name1, './' + name1u),
1845
[(name1 + '/' + name0, name0, 'file', './' + name1u
1847
(name1 + '/' + name1, name1, 'directory', './' + name1u
1851
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1856
return tree, expected_dirblocks
1858
def _filter_out(self, raw_dirblocks):
1859
"""Filter out a walkdirs_utf8 result.
1861
stat field is removed, all native paths are converted to unicode
1863
filtered_dirblocks = []
1864
for dirinfo, block in raw_dirblocks:
1865
dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1868
details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1869
filtered_dirblocks.append((dirinfo, details))
1870
return filtered_dirblocks
1872
def test_walk_unicode_tree(self):
1873
self.requireFeature(features.UnicodeFilenameFeature)
1874
tree, expected_dirblocks = self._get_unicode_tree()
1875
self.build_tree(tree)
1876
result = list(osutils._walkdirs_utf8('.'))
1877
self.assertEqual(expected_dirblocks, self._filter_out(result))
1879
def test_symlink(self):
1880
self.requireFeature(features.SymlinkFeature)
1881
self.requireFeature(features.UnicodeFilenameFeature)
1882
target = u'target\N{Euro Sign}'
1883
link_name = u'l\N{Euro Sign}nk'
1884
os.symlink(target, link_name)
1885
target_utf8 = target.encode('UTF-8')
1886
link_name_utf8 = link_name.encode('UTF-8')
1887
expected_dirblocks = [
1889
[(link_name_utf8, link_name_utf8,
1890
'symlink', './' + link_name),],
1892
result = list(osutils._walkdirs_utf8('.'))
1893
self.assertEqual(expected_dirblocks, self._filter_out(result))
1896
class TestReadLink(tests.TestCaseInTempDir):
1897
"""Exposes os.readlink() problems and the osutils solution.
1899
The only guarantee offered by os.readlink(), starting with 2.6, is that a
1900
unicode string will be returned if a unicode string is passed.
1902
But prior python versions failed to properly encode the passed unicode
1905
_test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]
1908
super(tests.TestCaseInTempDir, self).setUp()
1909
self.link = u'l\N{Euro Sign}ink'
1910
self.target = u'targe\N{Euro Sign}t'
1911
os.symlink(self.target, self.link)
1913
def test_os_readlink_link_encoding(self):
1914
self.assertEquals(self.target, os.readlink(self.link))
1916
def test_os_readlink_link_decoding(self):
1917
self.assertEquals(self.target.encode(osutils._fs_enc),
1918
os.readlink(self.link.encode(osutils._fs_enc)))
1921
class TestConcurrency(tests.TestCase):
1924
super(TestConcurrency, self).setUp()
1925
self.overrideAttr(osutils, '_cached_local_concurrency')
1927
def test_local_concurrency(self):
1928
concurrency = osutils.local_concurrency()
1929
self.assertIsInstance(concurrency, int)
1931
def test_local_concurrency_environment_variable(self):
1932
self.overrideEnv('BZR_CONCURRENCY', '2')
1933
self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1934
self.overrideEnv('BZR_CONCURRENCY', '3')
1935
self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1936
self.overrideEnv('BZR_CONCURRENCY', 'foo')
1937
self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1939
def test_option_concurrency(self):
1940
self.overrideEnv('BZR_CONCURRENCY', '1')
1941
self.run_bzr('rocks --concurrency 42')
1942
# Command line overrides environment variable
1943
self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1944
self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1947
class TestFailedToLoadExtension(tests.TestCase):
1949
def _try_loading(self):
1951
import bzrlib._fictional_extension_py
1952
except ImportError, e:
1953
osutils.failed_to_load_extension(e)
1957
super(TestFailedToLoadExtension, self).setUp()
1958
self.overrideAttr(osutils, '_extension_load_failures', [])
1960
def test_failure_to_load(self):
1962
self.assertLength(1, osutils._extension_load_failures)
1963
self.assertEquals(osutils._extension_load_failures[0],
1964
"No module named _fictional_extension_py")
1966
def test_report_extension_load_failures_no_warning(self):
1967
self.assertTrue(self._try_loading())
1968
warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
1969
# it used to give a Python warning; it no longer does
1970
self.assertLength(0, warnings)
1972
def test_report_extension_load_failures_message(self):
1974
trace.push_log_file(log)
1975
self.assertTrue(self._try_loading())
1976
osutils.report_extension_load_failures()
1977
self.assertContainsRe(
1979
r"bzr: warning: some compiled extensions could not be loaded; "
1980
"see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1984
class TestTerminalWidth(tests.TestCase):
1987
tests.TestCase.setUp(self)
1988
self._orig_terminal_size_state = osutils._terminal_size_state
1989
self._orig_first_terminal_size = osutils._first_terminal_size
1990
self.addCleanup(self.restore_osutils_globals)
1991
osutils._terminal_size_state = 'no_data'
1992
osutils._first_terminal_size = None
1994
def restore_osutils_globals(self):
1995
osutils._terminal_size_state = self._orig_terminal_size_state
1996
osutils._first_terminal_size = self._orig_first_terminal_size
1998
def replace_stdout(self, new):
1999
self.overrideAttr(sys, 'stdout', new)
2001
def replace__terminal_size(self, new):
2002
self.overrideAttr(osutils, '_terminal_size', new)
2004
def set_fake_tty(self):
2006
class I_am_a_tty(object):
2010
self.replace_stdout(I_am_a_tty())
2012
def test_default_values(self):
2013
self.assertEqual(80, osutils.default_terminal_width)
2015
def test_defaults_to_BZR_COLUMNS(self):
2016
# BZR_COLUMNS is set by the test framework
2017
self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
2018
self.overrideEnv('BZR_COLUMNS', '12')
2019
self.assertEqual(12, osutils.terminal_width())
2021
def test_BZR_COLUMNS_0_no_limit(self):
2022
self.overrideEnv('BZR_COLUMNS', '0')
2023
self.assertEqual(None, osutils.terminal_width())
2025
def test_falls_back_to_COLUMNS(self):
2026
self.overrideEnv('BZR_COLUMNS', None)
2027
self.assertNotEqual('42', os.environ['COLUMNS'])
2029
self.overrideEnv('COLUMNS', '42')
2030
self.assertEqual(42, osutils.terminal_width())
2032
def test_tty_default_without_columns(self):
2033
self.overrideEnv('BZR_COLUMNS', None)
2034
self.overrideEnv('COLUMNS', None)
2036
def terminal_size(w, h):
2040
# We need to override the osutils definition as it depends on the
2041
# running environment that we can't control (PQM running without a
2042
# controlling terminal is one example).
2043
self.replace__terminal_size(terminal_size)
2044
self.assertEqual(42, osutils.terminal_width())
2046
def test_non_tty_default_without_columns(self):
2047
self.overrideEnv('BZR_COLUMNS', None)
2048
self.overrideEnv('COLUMNS', None)
2049
self.replace_stdout(None)
2050
self.assertEqual(None, osutils.terminal_width())
2052
def test_no_TIOCGWINSZ(self):
2053
self.requireFeature(term_ios_feature)
2054
termios = term_ios_feature.module
2055
# bug 63539 is about a termios without TIOCGWINSZ attribute
2057
orig = termios.TIOCGWINSZ
2058
except AttributeError:
2059
# We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
2062
self.overrideAttr(termios, 'TIOCGWINSZ')
2063
del termios.TIOCGWINSZ
2064
self.overrideEnv('BZR_COLUMNS', None)
2065
self.overrideEnv('COLUMNS', None)
2066
# Whatever the result is, if we don't raise an exception, it's ok.
2067
osutils.terminal_width()
2070
class TestCreationOps(tests.TestCaseInTempDir):
2071
_test_needs_features = [features.chown_feature]
2074
tests.TestCaseInTempDir.setUp(self)
2075
self.overrideAttr(os, 'chown', self._dummy_chown)
2077
# params set by call to _dummy_chown
2078
self.path = self.uid = self.gid = None
2080
def _dummy_chown(self, path, uid, gid):
2081
self.path, self.uid, self.gid = path, uid, gid
2083
def test_copy_ownership_from_path(self):
2084
"""copy_ownership_from_path test with specified src."""
2086
f = open('test_file', 'wt')
2087
osutils.copy_ownership_from_path('test_file', ownsrc)
2090
self.assertEquals(self.path, 'test_file')
2091
self.assertEquals(self.uid, s.st_uid)
2092
self.assertEquals(self.gid, s.st_gid)
2094
def test_copy_ownership_nonesrc(self):
2095
"""copy_ownership_from_path test with src=None."""
2096
f = open('test_file', 'wt')
2097
# should use parent dir for permissions
2098
osutils.copy_ownership_from_path('test_file')
2101
self.assertEquals(self.path, 'test_file')
2102
self.assertEquals(self.uid, s.st_uid)
2103
self.assertEquals(self.gid, s.st_gid)
2106
class TestGetuserUnicode(tests.TestCase):
2108
def test_ascii_user(self):
2109
self.overrideEnv('LOGNAME', 'jrandom')
2110
self.assertEqual(u'jrandom', osutils.getuser_unicode())
2112
def test_unicode_user(self):
2113
ue = osutils.get_user_encoding()
2114
uni_val, env_val = tests.probe_unicode_in_user_encoding()
2116
raise tests.TestSkipped(
2117
'Cannot find a unicode character that works in encoding %s'
2118
% (osutils.get_user_encoding(),))
2119
uni_username = u'jrandom' + uni_val
2120
encoded_username = uni_username.encode(ue)
2121
self.overrideEnv('LOGNAME', encoded_username)
2122
self.assertEqual(uni_username, osutils.getuser_unicode())
2123
self.overrideEnv('LOGNAME', u'jrandom\xb6'.encode(ue))
2124
self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())
2126
def test_no_username_bug_660174(self):
2127
self.requireFeature(features.win32_feature)
2128
for name in ('LOGNAME', 'USER', 'LNAME', 'USERNAME'):
2129
self.overrideEnv(name, None)
2130
self.assertEqual(u'UNKNOWN', osutils.getuser_unicode())
2133
class TestBackupNames(tests.TestCase):
2136
super(TestBackupNames, self).setUp()
2139
def backup_exists(self, name):
2140
return name in self.backups
2142
def available_backup_name(self, name):
2143
backup_name = osutils.available_backup_name(name, self.backup_exists)
2144
self.backups.append(backup_name)
2147
def assertBackupName(self, expected, name):
2148
self.assertEqual(expected, self.available_backup_name(name))
2150
def test_empty(self):
2151
self.assertBackupName('file.~1~', 'file')
2153
def test_existing(self):
2154
self.available_backup_name('file')
2155
self.available_backup_name('file')
2156
self.assertBackupName('file.~3~', 'file')
2157
# Empty slots are found, this is not a strict requirement and may be
2158
# revisited if we test against all implementations.
2159
self.backups.remove('file.~2~')
2160
self.assertBackupName('file.~2~', 'file')
2163
class TestFindExecutableInPath(tests.TestCase):
2165
def test_windows(self):
2166
if sys.platform != 'win32':
2167
raise tests.TestSkipped('test requires win32')
2168
self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
2170
osutils.find_executable_on_path('explorer.exe') is not None)
2172
osutils.find_executable_on_path('EXPLORER.EXE') is not None)
2174
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2175
self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2177
def test_other(self):
2178
if sys.platform == 'win32':
2179
raise tests.TestSkipped('test requires non-win32')
2180
self.assertTrue(osutils.find_executable_on_path('sh') is not None)
2182
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2185
class TestEnvironmentErrors(tests.TestCase):
2186
"""Test handling of environmental errors"""
2188
def test_is_oserror(self):
2189
self.assertTrue(osutils.is_environment_error(
2190
OSError(errno.EINVAL, "Invalid parameter")))
2192
def test_is_ioerror(self):
2193
self.assertTrue(osutils.is_environment_error(
2194
IOError(errno.EINVAL, "Invalid parameter")))
2196
def test_is_socket_error(self):
2197
self.assertTrue(osutils.is_environment_error(
2198
socket.error(errno.EINVAL, "Invalid parameter")))
2200
def test_is_select_error(self):
2201
self.assertTrue(osutils.is_environment_error(
2202
select.error(errno.EINVAL, "Invalid parameter")))
2204
def test_is_pywintypes_error(self):
2205
self.requireFeature(features.pywintypes)
2207
self.assertTrue(osutils.is_environment_error(
2208
pywintypes.error(errno.EINVAL, "Invalid parameter", "Caller")))
added
removed
bzrlib/tests/test_osutils.py
