1
# Copyright (C) 2005-2010 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Tests for the osutils wrapper."""
19
from cStringIO import StringIO
36
from bzrlib.tests import (
43
class _UTF8DirReaderFeature(tests.Feature):
47
from bzrlib import _readdir_pyx
48
self.reader = _readdir_pyx.UTF8DirReader
53
def feature_name(self):
54
return 'bzrlib._readdir_pyx'
56
UTF8DirReaderFeature = _UTF8DirReaderFeature()
58
term_ios_feature = tests.ModuleAvailableFeature('termios')
61
def _already_unicode(s):
65
def _utf8_to_unicode(s):
66
return s.decode('UTF-8')
69
def dir_reader_scenarios():
70
# For each dir reader we define:
72
# - native_to_unicode: a function converting the native_abspath as returned
73
# by DirReader.read_dir to its unicode representation
75
# UnicodeDirReader is the fallback, it should be tested on all platforms.
76
scenarios = [('unicode',
77
dict(_dir_reader_class=osutils.UnicodeDirReader,
78
_native_to_unicode=_already_unicode))]
79
# Some DirReaders are platform specific and even there they may not be
81
if UTF8DirReaderFeature.available():
82
from bzrlib import _readdir_pyx
83
scenarios.append(('utf8',
84
dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
85
_native_to_unicode=_utf8_to_unicode)))
87
if test__walkdirs_win32.win32_readdir_feature.available():
89
from bzrlib import _walkdirs_win32
92
dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
93
_native_to_unicode=_already_unicode)))
99
def load_tests(basic_tests, module, loader):
100
suite = loader.suiteClass()
101
dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
102
basic_tests, tests.condition_isinstance(TestDirReader))
103
tests.multiply_tests(dir_reader_tests, dir_reader_scenarios(), suite)
104
suite.addTest(remaining_tests)
108
class TestContainsWhitespace(tests.TestCase):
110
def test_contains_whitespace(self):
111
self.failUnless(osutils.contains_whitespace(u' '))
112
self.failUnless(osutils.contains_whitespace(u'hello there'))
113
self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
114
self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
115
self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
116
self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
118
# \xa0 is "Non-breaking-space" which on some python locales thinks it
119
# is whitespace, but we do not.
120
self.failIf(osutils.contains_whitespace(u''))
121
self.failIf(osutils.contains_whitespace(u'hellothere'))
122
self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
125
class TestRename(tests.TestCaseInTempDir):
127
def create_file(self, filename, content):
128
f = open(filename, 'wb')
134
def _fancy_rename(self, a, b):
135
osutils.fancy_rename(a, b, rename_func=os.rename,
136
unlink_func=os.unlink)
138
def test_fancy_rename(self):
139
# This should work everywhere
140
self.create_file('a', 'something in a\n')
141
self._fancy_rename('a', 'b')
142
self.failIfExists('a')
143
self.failUnlessExists('b')
144
self.check_file_contents('b', 'something in a\n')
146
self.create_file('a', 'new something in a\n')
147
self._fancy_rename('b', 'a')
149
self.check_file_contents('a', 'something in a\n')
151
def test_fancy_rename_fails_source_missing(self):
152
# An exception should be raised, and the target should be left in place
153
self.create_file('target', 'data in target\n')
154
self.assertRaises((IOError, OSError), self._fancy_rename,
155
'missingsource', 'target')
156
self.failUnlessExists('target')
157
self.check_file_contents('target', 'data in target\n')
159
def test_fancy_rename_fails_if_source_and_target_missing(self):
160
self.assertRaises((IOError, OSError), self._fancy_rename,
161
'missingsource', 'missingtarget')
163
def test_rename(self):
164
# Rename should be semi-atomic on all platforms
165
self.create_file('a', 'something in a\n')
166
osutils.rename('a', 'b')
167
self.failIfExists('a')
168
self.failUnlessExists('b')
169
self.check_file_contents('b', 'something in a\n')
171
self.create_file('a', 'new something in a\n')
172
osutils.rename('b', 'a')
174
self.check_file_contents('a', 'something in a\n')
176
# TODO: test fancy_rename using a MemoryTransport
178
def test_rename_change_case(self):
179
# on Windows we should be able to change filename case by rename
180
self.build_tree(['a', 'b/'])
181
osutils.rename('a', 'A')
182
osutils.rename('b', 'B')
183
# we can't use failUnlessExists on case-insensitive filesystem
184
# so try to check shape of the tree
185
shape = sorted(os.listdir('.'))
186
self.assertEquals(['A', 'B'], shape)
189
class TestRandChars(tests.TestCase):
191
def test_01_rand_chars_empty(self):
192
result = osutils.rand_chars(0)
193
self.assertEqual(result, '')
195
def test_02_rand_chars_100(self):
196
result = osutils.rand_chars(100)
197
self.assertEqual(len(result), 100)
198
self.assertEqual(type(result), str)
199
self.assertContainsRe(result, r'^[a-z0-9]{100}$')
202
class TestIsInside(tests.TestCase):
204
def test_is_inside(self):
205
is_inside = osutils.is_inside
206
self.assertTrue(is_inside('src', 'src/foo.c'))
207
self.assertFalse(is_inside('src', 'srccontrol'))
208
self.assertTrue(is_inside('src', 'src/a/a/a/foo.c'))
209
self.assertTrue(is_inside('foo.c', 'foo.c'))
210
self.assertFalse(is_inside('foo.c', ''))
211
self.assertTrue(is_inside('', 'foo.c'))
213
def test_is_inside_any(self):
214
SRC_FOO_C = osutils.pathjoin('src', 'foo.c')
215
for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
216
(['src'], SRC_FOO_C),
219
self.assert_(osutils.is_inside_any(dirs, fn))
220
for dirs, fn in [(['src'], 'srccontrol'),
221
(['src'], 'srccontrol/foo')]:
222
self.assertFalse(osutils.is_inside_any(dirs, fn))
224
def test_is_inside_or_parent_of_any(self):
225
for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
226
(['src'], 'src/foo.c'),
227
(['src/bar.c'], 'src'),
228
(['src/bar.c', 'bla/foo.c'], 'src'),
231
self.assert_(osutils.is_inside_or_parent_of_any(dirs, fn))
233
for dirs, fn in [(['src'], 'srccontrol'),
234
(['srccontrol/foo.c'], 'src'),
235
(['src'], 'srccontrol/foo')]:
236
self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
239
class TestRmTree(tests.TestCaseInTempDir):
241
def test_rmtree(self):
242
# Check to remove tree with read-only files/dirs
244
f = file('dir/file', 'w')
247
# would like to also try making the directory readonly, but at the
248
# moment python shutil.rmtree doesn't handle that properly - it would
249
# need to chmod the directory before removing things inside it - deferred
250
# for now -- mbp 20060505
251
# osutils.make_readonly('dir')
252
osutils.make_readonly('dir/file')
254
osutils.rmtree('dir')
256
self.failIfExists('dir/file')
257
self.failIfExists('dir')
260
class TestDeleteAny(tests.TestCaseInTempDir):
262
def test_delete_any_readonly(self):
263
# from <https://bugs.launchpad.net/bzr/+bug/218206>
264
self.build_tree(['d/', 'f'])
265
osutils.make_readonly('d')
266
osutils.make_readonly('f')
268
osutils.delete_any('f')
269
osutils.delete_any('d')
272
class TestKind(tests.TestCaseInTempDir):
274
def test_file_kind(self):
275
self.build_tree(['file', 'dir/'])
276
self.assertEquals('file', osutils.file_kind('file'))
277
self.assertEquals('directory', osutils.file_kind('dir/'))
278
if osutils.has_symlinks():
279
os.symlink('symlink', 'symlink')
280
self.assertEquals('symlink', osutils.file_kind('symlink'))
282
# TODO: jam 20060529 Test a block device
284
os.lstat('/dev/null')
286
if e.errno not in (errno.ENOENT,):
289
self.assertEquals('chardev', osutils.file_kind('/dev/null'))
291
mkfifo = getattr(os, 'mkfifo', None)
295
self.assertEquals('fifo', osutils.file_kind('fifo'))
299
AF_UNIX = getattr(socket, 'AF_UNIX', None)
301
s = socket.socket(AF_UNIX)
304
self.assertEquals('socket', osutils.file_kind('socket'))
308
def test_kind_marker(self):
309
self.assertEqual("", osutils.kind_marker("file"))
310
self.assertEqual("/", osutils.kind_marker('directory'))
311
self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
312
self.assertEqual("@", osutils.kind_marker("symlink"))
313
self.assertEqual("+", osutils.kind_marker("tree-reference"))
314
self.assertEqual("", osutils.kind_marker("fifo"))
315
self.assertEqual("", osutils.kind_marker("socket"))
316
self.assertEqual("", osutils.kind_marker("unknown"))
319
class TestUmask(tests.TestCaseInTempDir):
321
def test_get_umask(self):
322
if sys.platform == 'win32':
323
# umask always returns '0', no way to set it
324
self.assertEqual(0, osutils.get_umask())
327
orig_umask = osutils.get_umask()
328
self.addCleanup(os.umask, orig_umask)
330
self.assertEqual(0222, osutils.get_umask())
332
self.assertEqual(0022, osutils.get_umask())
334
self.assertEqual(0002, osutils.get_umask())
336
self.assertEqual(0027, osutils.get_umask())
339
class TestDateTime(tests.TestCase):
341
def assertFormatedDelta(self, expected, seconds):
342
"""Assert osutils.format_delta formats as expected"""
343
actual = osutils.format_delta(seconds)
344
self.assertEqual(expected, actual)
346
def test_format_delta(self):
347
self.assertFormatedDelta('0 seconds ago', 0)
348
self.assertFormatedDelta('1 second ago', 1)
349
self.assertFormatedDelta('10 seconds ago', 10)
350
self.assertFormatedDelta('59 seconds ago', 59)
351
self.assertFormatedDelta('89 seconds ago', 89)
352
self.assertFormatedDelta('1 minute, 30 seconds ago', 90)
353
self.assertFormatedDelta('3 minutes, 0 seconds ago', 180)
354
self.assertFormatedDelta('3 minutes, 1 second ago', 181)
355
self.assertFormatedDelta('10 minutes, 15 seconds ago', 615)
356
self.assertFormatedDelta('30 minutes, 59 seconds ago', 1859)
357
self.assertFormatedDelta('31 minutes, 0 seconds ago', 1860)
358
self.assertFormatedDelta('60 minutes, 0 seconds ago', 3600)
359
self.assertFormatedDelta('89 minutes, 59 seconds ago', 5399)
360
self.assertFormatedDelta('1 hour, 30 minutes ago', 5400)
361
self.assertFormatedDelta('2 hours, 30 minutes ago', 9017)
362
self.assertFormatedDelta('10 hours, 0 minutes ago', 36000)
363
self.assertFormatedDelta('24 hours, 0 minutes ago', 86400)
364
self.assertFormatedDelta('35 hours, 59 minutes ago', 129599)
365
self.assertFormatedDelta('36 hours, 0 minutes ago', 129600)
366
self.assertFormatedDelta('36 hours, 0 minutes ago', 129601)
367
self.assertFormatedDelta('36 hours, 1 minute ago', 129660)
368
self.assertFormatedDelta('36 hours, 1 minute ago', 129661)
369
self.assertFormatedDelta('84 hours, 10 minutes ago', 303002)
371
# We handle when time steps the wrong direction because computers
372
# don't have synchronized clocks.
373
self.assertFormatedDelta('84 hours, 10 minutes in the future', -303002)
374
self.assertFormatedDelta('1 second in the future', -1)
375
self.assertFormatedDelta('2 seconds in the future', -2)
377
def test_format_date(self):
378
self.assertRaises(errors.UnsupportedTimezoneFormat,
379
osutils.format_date, 0, timezone='foo')
380
self.assertIsInstance(osutils.format_date(0), str)
381
self.assertIsInstance(osutils.format_local_date(0), unicode)
382
# Testing for the actual value of the local weekday without
383
# duplicating the code from format_date is difficult.
384
# Instead blackbox.test_locale should check for localized
385
# dates once they do occur in output strings.
387
def test_format_date_with_offset_in_original_timezone(self):
388
self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
389
osutils.format_date_with_offset_in_original_timezone(0))
390
self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
391
osutils.format_date_with_offset_in_original_timezone(100000))
392
self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
393
osutils.format_date_with_offset_in_original_timezone(100000, 7200))
395
def test_local_time_offset(self):
396
"""Test that local_time_offset() returns a sane value."""
397
offset = osutils.local_time_offset()
398
self.assertTrue(isinstance(offset, int))
399
# Test that the offset is no more than a eighteen hours in
401
# Time zone handling is system specific, so it is difficult to
402
# do more specific tests, but a value outside of this range is
404
eighteen_hours = 18 * 3600
405
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
407
def test_local_time_offset_with_timestamp(self):
408
"""Test that local_time_offset() works with a timestamp."""
409
offset = osutils.local_time_offset(1000000000.1234567)
410
self.assertTrue(isinstance(offset, int))
411
eighteen_hours = 18 * 3600
412
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
415
class TestLinks(tests.TestCaseInTempDir):
417
def test_dereference_path(self):
418
self.requireFeature(tests.SymlinkFeature)
419
cwd = osutils.realpath('.')
421
bar_path = osutils.pathjoin(cwd, 'bar')
422
# Using './' to avoid bug #1213894 (first path component not
423
# dereferenced) in Python 2.4.1 and earlier
424
self.assertEqual(bar_path, osutils.realpath('./bar'))
425
os.symlink('bar', 'foo')
426
self.assertEqual(bar_path, osutils.realpath('./foo'))
428
# Does not dereference terminal symlinks
429
foo_path = osutils.pathjoin(cwd, 'foo')
430
self.assertEqual(foo_path, osutils.dereference_path('./foo'))
432
# Dereferences parent symlinks
434
baz_path = osutils.pathjoin(bar_path, 'baz')
435
self.assertEqual(baz_path, osutils.dereference_path('./foo/baz'))
437
# Dereferences parent symlinks that are the first path element
438
self.assertEqual(baz_path, osutils.dereference_path('foo/baz'))
440
# Dereferences parent symlinks in absolute paths
441
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
442
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
444
def test_changing_access(self):
445
f = file('file', 'w')
449
# Make a file readonly
450
osutils.make_readonly('file')
451
mode = os.lstat('file').st_mode
452
self.assertEqual(mode, mode & 0777555)
454
# Make a file writable
455
osutils.make_writable('file')
456
mode = os.lstat('file').st_mode
457
self.assertEqual(mode, mode | 0200)
459
if osutils.has_symlinks():
460
# should not error when handed a symlink
461
os.symlink('nonexistent', 'dangling')
462
osutils.make_readonly('dangling')
463
osutils.make_writable('dangling')
465
def test_host_os_dereferences_symlinks(self):
466
osutils.host_os_dereferences_symlinks()
469
class TestCanonicalRelPath(tests.TestCaseInTempDir):
471
_test_needs_features = [tests.CaseInsCasePresFilenameFeature]
473
def test_canonical_relpath_simple(self):
474
f = file('MixedCaseName', 'w')
476
actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
477
self.failUnlessEqual('work/MixedCaseName', actual)
479
def test_canonical_relpath_missing_tail(self):
480
os.mkdir('MixedCaseParent')
481
actual = osutils.canonical_relpath(self.test_base_dir,
482
'mixedcaseparent/nochild')
483
self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
486
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
488
def assertRelpath(self, expected, base, path):
489
actual = osutils._cicp_canonical_relpath(base, path)
490
self.assertEqual(expected, actual)
492
def test_simple(self):
493
self.build_tree(['MixedCaseName'])
494
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
495
self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
497
def test_subdir_missing_tail(self):
498
self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
499
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
500
self.assertRelpath('MixedCaseParent/a_child', base,
501
'MixedCaseParent/a_child')
502
self.assertRelpath('MixedCaseParent/a_child', base,
503
'MixedCaseParent/A_Child')
504
self.assertRelpath('MixedCaseParent/not_child', base,
505
'MixedCaseParent/not_child')
507
def test_at_root_slash(self):
508
# We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
510
if osutils.MIN_ABS_PATHLENGTH > 1:
511
raise tests.TestSkipped('relpath requires %d chars'
512
% osutils.MIN_ABS_PATHLENGTH)
513
self.assertRelpath('foo', '/', '/foo')
515
def test_at_root_drive(self):
516
if sys.platform != 'win32':
517
raise tests.TestNotApplicable('we can only test drive-letter relative'
518
' paths on Windows where we have drive'
521
# The specific issue is that when at the root of a drive, 'abspath'
522
# returns "C:/" or just "/". However, the code assumes that abspath
523
# always returns something like "C:/foo" or "/foo" (no trailing slash).
524
self.assertRelpath('foo', 'C:/', 'C:/foo')
525
self.assertRelpath('foo', 'X:/', 'X:/foo')
526
self.assertRelpath('foo', 'X:/', 'X://foo')
529
class TestPumpFile(tests.TestCase):
530
"""Test pumpfile method."""
533
tests.TestCase.setUp(self)
534
# create a test datablock
535
self.block_size = 512
536
pattern = '0123456789ABCDEF'
537
self.test_data = pattern * (3 * self.block_size / len(pattern))
538
self.test_data_len = len(self.test_data)
540
def test_bracket_block_size(self):
541
"""Read data in blocks with the requested read size bracketing the
543
# make sure test data is larger than max read size
544
self.assertTrue(self.test_data_len > self.block_size)
546
from_file = file_utils.FakeReadFile(self.test_data)
549
# read (max / 2) bytes and verify read size wasn't affected
550
num_bytes_to_read = self.block_size / 2
551
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
552
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
553
self.assertEqual(from_file.get_read_count(), 1)
555
# read (max) bytes and verify read size wasn't affected
556
num_bytes_to_read = self.block_size
557
from_file.reset_read_count()
558
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
559
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
560
self.assertEqual(from_file.get_read_count(), 1)
562
# read (max + 1) bytes and verify read size was limited
563
num_bytes_to_read = self.block_size + 1
564
from_file.reset_read_count()
565
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
566
self.assertEqual(from_file.get_max_read_size(), self.block_size)
567
self.assertEqual(from_file.get_read_count(), 2)
569
# finish reading the rest of the data
570
num_bytes_to_read = self.test_data_len - to_file.tell()
571
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
573
# report error if the data wasn't equal (we only report the size due
574
# to the length of the data)
575
response_data = to_file.getvalue()
576
if response_data != self.test_data:
577
message = "Data not equal. Expected %d bytes, received %d."
578
self.fail(message % (len(response_data), self.test_data_len))
580
def test_specified_size(self):
581
"""Request a transfer larger than the maximum block size and verify
582
that the maximum read doesn't exceed the block_size."""
583
# make sure test data is larger than max read size
584
self.assertTrue(self.test_data_len > self.block_size)
586
# retrieve data in blocks
587
from_file = file_utils.FakeReadFile(self.test_data)
589
osutils.pumpfile(from_file, to_file, self.test_data_len,
592
# verify read size was equal to the maximum read size
593
self.assertTrue(from_file.get_max_read_size() > 0)
594
self.assertEqual(from_file.get_max_read_size(), self.block_size)
595
self.assertEqual(from_file.get_read_count(), 3)
597
# report error if the data wasn't equal (we only report the size due
598
# to the length of the data)
599
response_data = to_file.getvalue()
600
if response_data != self.test_data:
601
message = "Data not equal. Expected %d bytes, received %d."
602
self.fail(message % (len(response_data), self.test_data_len))
604
def test_to_eof(self):
605
"""Read to end-of-file and verify that the reads are not larger than
606
the maximum read size."""
607
# make sure test data is larger than max read size
608
self.assertTrue(self.test_data_len > self.block_size)
610
# retrieve data to EOF
611
from_file = file_utils.FakeReadFile(self.test_data)
613
osutils.pumpfile(from_file, to_file, -1, self.block_size)
615
# verify read size was equal to the maximum read size
616
self.assertEqual(from_file.get_max_read_size(), self.block_size)
617
self.assertEqual(from_file.get_read_count(), 4)
619
# report error if the data wasn't equal (we only report the size due
620
# to the length of the data)
621
response_data = to_file.getvalue()
622
if response_data != self.test_data:
623
message = "Data not equal. Expected %d bytes, received %d."
624
self.fail(message % (len(response_data), self.test_data_len))
626
def test_defaults(self):
627
"""Verifies that the default arguments will read to EOF -- this
628
test verifies that any existing usages of pumpfile will not be broken
629
with this new version."""
630
# retrieve data using default (old) pumpfile method
631
from_file = file_utils.FakeReadFile(self.test_data)
633
osutils.pumpfile(from_file, to_file)
635
# report error if the data wasn't equal (we only report the size due
636
# to the length of the data)
637
response_data = to_file.getvalue()
638
if response_data != self.test_data:
639
message = "Data not equal. Expected %d bytes, received %d."
640
self.fail(message % (len(response_data), self.test_data_len))
642
def test_report_activity(self):
644
def log_activity(length, direction):
645
activity.append((length, direction))
646
from_file = StringIO(self.test_data)
648
osutils.pumpfile(from_file, to_file, buff_size=500,
649
report_activity=log_activity, direction='read')
650
self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
651
(36, 'read')], activity)
653
from_file = StringIO(self.test_data)
656
osutils.pumpfile(from_file, to_file, buff_size=500,
657
report_activity=log_activity, direction='write')
658
self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
659
(36, 'write')], activity)
661
# And with a limited amount of data
662
from_file = StringIO(self.test_data)
665
osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
666
report_activity=log_activity, direction='read')
667
self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
671
class TestPumpStringFile(tests.TestCase):
673
def test_empty(self):
675
osutils.pump_string_file("", output)
676
self.assertEqual("", output.getvalue())
678
def test_more_than_segment_size(self):
680
osutils.pump_string_file("123456789", output, 2)
681
self.assertEqual("123456789", output.getvalue())
683
def test_segment_size(self):
685
osutils.pump_string_file("12", output, 2)
686
self.assertEqual("12", output.getvalue())
688
def test_segment_size_multiple(self):
690
osutils.pump_string_file("1234", output, 2)
691
self.assertEqual("1234", output.getvalue())
694
class TestRelpath(tests.TestCase):
696
def test_simple_relpath(self):
697
cwd = osutils.getcwd()
698
subdir = cwd + '/subdir'
699
self.assertEqual('subdir', osutils.relpath(cwd, subdir))
701
def test_deep_relpath(self):
702
cwd = osutils.getcwd()
703
subdir = cwd + '/sub/subsubdir'
704
self.assertEqual('sub/subsubdir', osutils.relpath(cwd, subdir))
706
def test_not_relative(self):
707
self.assertRaises(errors.PathNotChild,
708
osutils.relpath, 'C:/path', 'H:/path')
709
self.assertRaises(errors.PathNotChild,
710
osutils.relpath, 'C:/', 'H:/path')
713
class TestSafeUnicode(tests.TestCase):
715
def test_from_ascii_string(self):
716
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
718
def test_from_unicode_string_ascii_contents(self):
719
self.assertEqual(u'bargam', osutils.safe_unicode(u'bargam'))
721
def test_from_unicode_string_unicode_contents(self):
722
self.assertEqual(u'bargam\xae', osutils.safe_unicode(u'bargam\xae'))
724
def test_from_utf8_string(self):
725
self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
727
def test_bad_utf8_string(self):
728
self.assertRaises(errors.BzrBadParameterNotUnicode,
729
osutils.safe_unicode,
733
class TestSafeUtf8(tests.TestCase):
735
def test_from_ascii_string(self):
737
self.assertEqual('foobar', osutils.safe_utf8(f))
739
def test_from_unicode_string_ascii_contents(self):
740
self.assertEqual('bargam', osutils.safe_utf8(u'bargam'))
742
def test_from_unicode_string_unicode_contents(self):
743
self.assertEqual('bargam\xc2\xae', osutils.safe_utf8(u'bargam\xae'))
745
def test_from_utf8_string(self):
746
self.assertEqual('foo\xc2\xae', osutils.safe_utf8('foo\xc2\xae'))
748
def test_bad_utf8_string(self):
749
self.assertRaises(errors.BzrBadParameterNotUnicode,
750
osutils.safe_utf8, '\xbb\xbb')
753
class TestSafeRevisionId(tests.TestCase):
755
def test_from_ascii_string(self):
756
# this shouldn't give a warning because it's getting an ascii string
757
self.assertEqual('foobar', osutils.safe_revision_id('foobar'))
759
def test_from_unicode_string_ascii_contents(self):
760
self.assertEqual('bargam',
761
osutils.safe_revision_id(u'bargam', warn=False))
763
def test_from_unicode_deprecated(self):
764
self.assertEqual('bargam',
765
self.callDeprecated([osutils._revision_id_warning],
766
osutils.safe_revision_id, u'bargam'))
768
def test_from_unicode_string_unicode_contents(self):
769
self.assertEqual('bargam\xc2\xae',
770
osutils.safe_revision_id(u'bargam\xae', warn=False))
772
def test_from_utf8_string(self):
773
self.assertEqual('foo\xc2\xae',
774
osutils.safe_revision_id('foo\xc2\xae'))
777
"""Currently, None is a valid revision_id"""
778
self.assertEqual(None, osutils.safe_revision_id(None))
781
class TestSafeFileId(tests.TestCase):
783
def test_from_ascii_string(self):
784
self.assertEqual('foobar', osutils.safe_file_id('foobar'))
786
def test_from_unicode_string_ascii_contents(self):
787
self.assertEqual('bargam', osutils.safe_file_id(u'bargam', warn=False))
789
def test_from_unicode_deprecated(self):
790
self.assertEqual('bargam',
791
self.callDeprecated([osutils._file_id_warning],
792
osutils.safe_file_id, u'bargam'))
794
def test_from_unicode_string_unicode_contents(self):
795
self.assertEqual('bargam\xc2\xae',
796
osutils.safe_file_id(u'bargam\xae', warn=False))
798
def test_from_utf8_string(self):
799
self.assertEqual('foo\xc2\xae',
800
osutils.safe_file_id('foo\xc2\xae'))
803
"""Currently, None is a valid revision_id"""
804
self.assertEqual(None, osutils.safe_file_id(None))
807
class TestWin32Funcs(tests.TestCase):
808
"""Test that _win32 versions of os utilities return appropriate paths."""
810
def test_abspath(self):
811
self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
812
self.assertEqual('C:/foo', osutils._win32_abspath('C:/foo'))
813
self.assertEqual('//HOST/path', osutils._win32_abspath(r'\\HOST\path'))
814
self.assertEqual('//HOST/path', osutils._win32_abspath('//HOST/path'))
816
def test_realpath(self):
817
self.assertEqual('C:/foo', osutils._win32_realpath('C:\\foo'))
818
self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
820
def test_pathjoin(self):
821
self.assertEqual('path/to/foo',
822
osutils._win32_pathjoin('path', 'to', 'foo'))
823
self.assertEqual('C:/foo',
824
osutils._win32_pathjoin('path\\to', 'C:\\foo'))
825
self.assertEqual('C:/foo',
826
osutils._win32_pathjoin('path/to', 'C:/foo'))
827
self.assertEqual('path/to/foo',
828
osutils._win32_pathjoin('path/to/', 'foo'))
829
self.assertEqual('/foo',
830
osutils._win32_pathjoin('C:/path/to/', '/foo'))
831
self.assertEqual('/foo',
832
osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
834
def test_normpath(self):
835
self.assertEqual('path/to/foo',
836
osutils._win32_normpath(r'path\\from\..\to\.\foo'))
837
self.assertEqual('path/to/foo',
838
osutils._win32_normpath('path//from/../to/./foo'))
840
def test_getcwd(self):
841
cwd = osutils._win32_getcwd()
842
os_cwd = os.getcwdu()
843
self.assertEqual(os_cwd[1:].replace('\\', '/'), cwd[1:])
844
# win32 is inconsistent whether it returns lower or upper case
845
# and even if it was consistent the user might type the other
846
# so we force it to uppercase
847
# running python.exe under cmd.exe return capital C:\\
848
# running win32 python inside a cygwin shell returns lowercase
849
self.assertEqual(os_cwd[0].upper(), cwd[0])
851
def test_fixdrive(self):
852
self.assertEqual('H:/foo', osutils._win32_fixdrive('h:/foo'))
853
self.assertEqual('H:/foo', osutils._win32_fixdrive('H:/foo'))
854
self.assertEqual('C:\\foo', osutils._win32_fixdrive('c:\\foo'))
856
def test_win98_abspath(self):
858
self.assertEqual('C:/foo', osutils._win98_abspath('C:\\foo'))
859
self.assertEqual('C:/foo', osutils._win98_abspath('C:/foo'))
861
self.assertEqual('//HOST/path', osutils._win98_abspath(r'\\HOST\path'))
862
self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
864
cwd = osutils.getcwd().rstrip('/')
865
drive = osutils.ntpath.splitdrive(cwd)[0]
866
self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
867
self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
870
self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
873
class TestWin32FuncsDirs(tests.TestCaseInTempDir):
874
"""Test win32 functions that create files."""
876
def test_getcwd(self):
877
self.requireFeature(tests.UnicodeFilenameFeature)
880
# TODO: jam 20060427 This will probably fail on Mac OSX because
881
# it will change the normalization of B\xe5gfors
882
# Consider using a different unicode character, or make
883
# osutils.getcwd() renormalize the path.
884
self.assertEndsWith(osutils._win32_getcwd(), u'mu-\xb5')
886
def test_minimum_path_selection(self):
887
self.assertEqual(set(),
888
osutils.minimum_path_selection([]))
889
self.assertEqual(set(['a']),
890
osutils.minimum_path_selection(['a']))
891
self.assertEqual(set(['a', 'b']),
892
osutils.minimum_path_selection(['a', 'b']))
893
self.assertEqual(set(['a/', 'b']),
894
osutils.minimum_path_selection(['a/', 'b']))
895
self.assertEqual(set(['a/', 'b']),
896
osutils.minimum_path_selection(['a/c', 'a/', 'b']))
897
self.assertEqual(set(['a-b', 'a', 'a0b']),
898
osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
900
def test_mkdtemp(self):
901
tmpdir = osutils._win32_mkdtemp(dir='.')
902
self.assertFalse('\\' in tmpdir)
904
def test_rename(self):
912
osutils._win32_rename('b', 'a')
913
self.failUnlessExists('a')
914
self.failIfExists('b')
915
self.assertFileEqual('baz\n', 'a')
917
def test_rename_missing_file(self):
923
osutils._win32_rename('b', 'a')
924
except (IOError, OSError), e:
925
self.assertEqual(errno.ENOENT, e.errno)
926
self.assertFileEqual('foo\n', 'a')
928
def test_rename_missing_dir(self):
931
osutils._win32_rename('b', 'a')
932
except (IOError, OSError), e:
933
self.assertEqual(errno.ENOENT, e.errno)
935
def test_rename_current_dir(self):
938
# You can't rename the working directory
939
# doing rename non-existant . usually
940
# just raises ENOENT, since non-existant
943
osutils._win32_rename('b', '.')
944
except (IOError, OSError), e:
945
self.assertEqual(errno.ENOENT, e.errno)
947
def test_splitpath(self):
948
def check(expected, path):
949
self.assertEqual(expected, osutils.splitpath(path))
952
check(['a', 'b'], 'a/b')
953
check(['a', 'b'], 'a/./b')
954
check(['a', '.b'], 'a/.b')
955
check(['a', '.b'], 'a\\.b')
957
self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
960
class TestParentDirectories(tests.TestCaseInTempDir):
961
"""Test osutils.parent_directories()"""
963
def test_parent_directories(self):
964
self.assertEqual([], osutils.parent_directories('a'))
965
self.assertEqual(['a'], osutils.parent_directories('a/b'))
966
self.assertEqual(['a/b', 'a'], osutils.parent_directories('a/b/c'))
969
class TestMacFuncsDirs(tests.TestCaseInTempDir):
970
"""Test mac special functions that require directories."""
972
def test_getcwd(self):
973
self.requireFeature(tests.UnicodeFilenameFeature)
974
os.mkdir(u'B\xe5gfors')
975
os.chdir(u'B\xe5gfors')
976
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
978
def test_getcwd_nonnorm(self):
979
self.requireFeature(tests.UnicodeFilenameFeature)
980
# Test that _mac_getcwd() will normalize this path
981
os.mkdir(u'Ba\u030agfors')
982
os.chdir(u'Ba\u030agfors')
983
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
986
class TestChunksToLines(tests.TestCase):
988
def test_smoketest(self):
989
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
990
osutils.chunks_to_lines(['foo\nbar', '\nbaz\n']))
991
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
992
osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
994
def test_osutils_binding(self):
995
from bzrlib.tests import test__chunks_to_lines
996
if test__chunks_to_lines.compiled_chunkstolines_feature.available():
997
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
999
from bzrlib._chunks_to_lines_py import chunks_to_lines
1000
self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
1003
class TestSplitLines(tests.TestCase):
1005
def test_split_unicode(self):
1006
self.assertEqual([u'foo\n', u'bar\xae'],
1007
osutils.split_lines(u'foo\nbar\xae'))
1008
self.assertEqual([u'foo\n', u'bar\xae\n'],
1009
osutils.split_lines(u'foo\nbar\xae\n'))
1011
def test_split_with_carriage_returns(self):
1012
self.assertEqual(['foo\rbar\n'],
1013
osutils.split_lines('foo\rbar\n'))
1016
class TestWalkDirs(tests.TestCaseInTempDir):
1018
def assertExpectedBlocks(self, expected, result):
1019
self.assertEqual(expected,
1020
[(dirinfo, [line[0:3] for line in block])
1021
for dirinfo, block in result])
1023
def test_walkdirs(self):
1032
self.build_tree(tree)
1033
expected_dirblocks = [
1035
[('0file', '0file', 'file'),
1036
('1dir', '1dir', 'directory'),
1037
('2file', '2file', 'file'),
1040
(('1dir', './1dir'),
1041
[('1dir/0file', '0file', 'file'),
1042
('1dir/1dir', '1dir', 'directory'),
1045
(('1dir/1dir', './1dir/1dir'),
1051
found_bzrdir = False
1052
for dirdetail, dirblock in osutils.walkdirs('.'):
1053
if len(dirblock) and dirblock[0][1] == '.bzr':
1054
# this tests the filtering of selected paths
1057
result.append((dirdetail, dirblock))
1059
self.assertTrue(found_bzrdir)
1060
self.assertExpectedBlocks(expected_dirblocks, result)
1061
# you can search a subdir only, with a supplied prefix.
1063
for dirblock in osutils.walkdirs('./1dir', '1dir'):
1064
result.append(dirblock)
1065
self.assertExpectedBlocks(expected_dirblocks[1:], result)
1067
def test_walkdirs_os_error(self):
1068
# <https://bugs.launchpad.net/bzr/+bug/338653>
1069
# Pyrex readdir didn't raise useful messages if it had an error
1070
# reading the directory
1071
if sys.platform == 'win32':
1072
raise tests.TestNotApplicable(
1073
"readdir IOError not tested on win32")
1074
self.requireFeature(features.not_running_as_root)
1075
os.mkdir("test-unreadable")
1076
os.chmod("test-unreadable", 0000)
1077
# must chmod it back so that it can be removed
1078
self.addCleanup(os.chmod, "test-unreadable", 0700)
1079
# The error is not raised until the generator is actually evaluated.
1080
# (It would be ok if it happened earlier but at the moment it
1082
e = self.assertRaises(OSError, list, osutils._walkdirs_utf8("."))
1083
self.assertEquals('./test-unreadable', e.filename)
1084
self.assertEquals(errno.EACCES, e.errno)
1085
# Ensure the message contains the file name
1086
self.assertContainsRe(str(e), "\./test-unreadable")
1089
def test_walkdirs_encoding_error(self):
1090
# <https://bugs.launchpad.net/bzr/+bug/488519>
1091
# walkdirs didn't raise a useful message when the filenames
1092
# are not using the filesystem's encoding
1094
# require a bytestring based filesystem
1095
self.requireFeature(tests.ByteStringNamedFilesystem)
1106
self.build_tree(tree)
1108
# rename the 1file to a latin-1 filename
1109
os.rename("./1file", "\xe8file")
1111
self._save_platform_info()
1112
win32utils.winver = None # Avoid the win32 detection code
1113
osutils._fs_enc = 'UTF-8'
1115
# this should raise on error
1117
for dirdetail, dirblock in osutils.walkdirs('.'):
1120
self.assertRaises(errors.BadFilenameEncoding, attempt)
1122
def test__walkdirs_utf8(self):
1131
self.build_tree(tree)
1132
expected_dirblocks = [
1134
[('0file', '0file', 'file'),
1135
('1dir', '1dir', 'directory'),
1136
('2file', '2file', 'file'),
1139
(('1dir', './1dir'),
1140
[('1dir/0file', '0file', 'file'),
1141
('1dir/1dir', '1dir', 'directory'),
1144
(('1dir/1dir', './1dir/1dir'),
1150
found_bzrdir = False
1151
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1152
if len(dirblock) and dirblock[0][1] == '.bzr':
1153
# this tests the filtering of selected paths
1156
result.append((dirdetail, dirblock))
1158
self.assertTrue(found_bzrdir)
1159
self.assertExpectedBlocks(expected_dirblocks, result)
1161
# you can search a subdir only, with a supplied prefix.
1163
for dirblock in osutils.walkdirs('./1dir', '1dir'):
1164
result.append(dirblock)
1165
self.assertExpectedBlocks(expected_dirblocks[1:], result)
1167
def _filter_out_stat(self, result):
1168
"""Filter out the stat value from the walkdirs result"""
1169
for dirdetail, dirblock in result:
1171
for info in dirblock:
1172
# Ignore info[3] which is the stat
1173
new_dirblock.append((info[0], info[1], info[2], info[4]))
1174
dirblock[:] = new_dirblock
1176
def _save_platform_info(self):
1177
self.overrideAttr(win32utils, 'winver')
1178
self.overrideAttr(osutils, '_fs_enc')
1179
self.overrideAttr(osutils, '_selected_dir_reader')
1181
def assertDirReaderIs(self, expected):
1182
"""Assert the right implementation for _walkdirs_utf8 is chosen."""
1183
# Force it to redetect
1184
osutils._selected_dir_reader = None
1185
# Nothing to list, but should still trigger the selection logic
1186
self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
1187
self.assertIsInstance(osutils._selected_dir_reader, expected)
1189
def test_force_walkdirs_utf8_fs_utf8(self):
1190
self.requireFeature(UTF8DirReaderFeature)
1191
self._save_platform_info()
1192
win32utils.winver = None # Avoid the win32 detection code
1193
osutils._fs_enc = 'UTF-8'
1194
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1196
def test_force_walkdirs_utf8_fs_ascii(self):
1197
self.requireFeature(UTF8DirReaderFeature)
1198
self._save_platform_info()
1199
win32utils.winver = None # Avoid the win32 detection code
1200
osutils._fs_enc = 'US-ASCII'
1201
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1203
def test_force_walkdirs_utf8_fs_ANSI(self):
1204
self.requireFeature(UTF8DirReaderFeature)
1205
self._save_platform_info()
1206
win32utils.winver = None # Avoid the win32 detection code
1207
osutils._fs_enc = 'ANSI_X3.4-1968'
1208
self.assertDirReaderIs(UTF8DirReaderFeature.reader)
1210
def test_force_walkdirs_utf8_fs_latin1(self):
1211
self._save_platform_info()
1212
win32utils.winver = None # Avoid the win32 detection code
1213
osutils._fs_enc = 'latin1'
1214
self.assertDirReaderIs(osutils.UnicodeDirReader)
1216
def test_force_walkdirs_utf8_nt(self):
1217
# Disabled because the thunk of the whole walkdirs api is disabled.
1218
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1219
self._save_platform_info()
1220
win32utils.winver = 'Windows NT'
1221
from bzrlib._walkdirs_win32 import Win32ReadDir
1222
self.assertDirReaderIs(Win32ReadDir)
1224
def test_force_walkdirs_utf8_98(self):
1225
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1226
self._save_platform_info()
1227
win32utils.winver = 'Windows 98'
1228
self.assertDirReaderIs(osutils.UnicodeDirReader)
1230
def test_unicode_walkdirs(self):
1231
"""Walkdirs should always return unicode paths."""
1232
self.requireFeature(tests.UnicodeFilenameFeature)
1233
name0 = u'0file-\xb6'
1234
name1 = u'1dir-\u062c\u0648'
1235
name2 = u'2file-\u0633'
1239
name1 + '/' + name0,
1240
name1 + '/' + name1 + '/',
1243
self.build_tree(tree)
1244
expected_dirblocks = [
1246
[(name0, name0, 'file', './' + name0),
1247
(name1, name1, 'directory', './' + name1),
1248
(name2, name2, 'file', './' + name2),
1251
((name1, './' + name1),
1252
[(name1 + '/' + name0, name0, 'file', './' + name1
1254
(name1 + '/' + name1, name1, 'directory', './' + name1
1258
((name1 + '/' + name1, './' + name1 + '/' + name1),
1263
result = list(osutils.walkdirs('.'))
1264
self._filter_out_stat(result)
1265
self.assertEqual(expected_dirblocks, result)
1266
result = list(osutils.walkdirs(u'./'+name1, name1))
1267
self._filter_out_stat(result)
1268
self.assertEqual(expected_dirblocks[1:], result)
1270
def test_unicode__walkdirs_utf8(self):
1271
"""Walkdirs_utf8 should always return utf8 paths.
1273
The abspath portion might be in unicode or utf-8
1275
self.requireFeature(tests.UnicodeFilenameFeature)
1276
name0 = u'0file-\xb6'
1277
name1 = u'1dir-\u062c\u0648'
1278
name2 = u'2file-\u0633'
1282
name1 + '/' + name0,
1283
name1 + '/' + name1 + '/',
1286
self.build_tree(tree)
1287
name0 = name0.encode('utf8')
1288
name1 = name1.encode('utf8')
1289
name2 = name2.encode('utf8')
1291
expected_dirblocks = [
1293
[(name0, name0, 'file', './' + name0),
1294
(name1, name1, 'directory', './' + name1),
1295
(name2, name2, 'file', './' + name2),
1298
((name1, './' + name1),
1299
[(name1 + '/' + name0, name0, 'file', './' + name1
1301
(name1 + '/' + name1, name1, 'directory', './' + name1
1305
((name1 + '/' + name1, './' + name1 + '/' + name1),
1311
# For ease in testing, if walkdirs_utf8 returns Unicode, assert that
1312
# all abspaths are Unicode, and encode them back into utf8.
1313
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1314
self.assertIsInstance(dirdetail[0], str)
1315
if isinstance(dirdetail[1], unicode):
1316
dirdetail = (dirdetail[0], dirdetail[1].encode('utf8'))
1317
dirblock = [list(info) for info in dirblock]
1318
for info in dirblock:
1319
self.assertIsInstance(info[4], unicode)
1320
info[4] = info[4].encode('utf8')
1322
for info in dirblock:
1323
self.assertIsInstance(info[0], str)
1324
self.assertIsInstance(info[1], str)
1325
self.assertIsInstance(info[4], str)
1326
# Remove the stat information
1327
new_dirblock.append((info[0], info[1], info[2], info[4]))
1328
result.append((dirdetail, new_dirblock))
1329
self.assertEqual(expected_dirblocks, result)
1331
def test__walkdirs_utf8_with_unicode_fs(self):
1332
"""UnicodeDirReader should be a safe fallback everywhere
1334
The abspath portion should be in unicode
1336
self.requireFeature(tests.UnicodeFilenameFeature)
1337
# Use the unicode reader. TODO: split into driver-and-driven unit
1339
self._save_platform_info()
1340
osutils._selected_dir_reader = osutils.UnicodeDirReader()
1341
name0u = u'0file-\xb6'
1342
name1u = u'1dir-\u062c\u0648'
1343
name2u = u'2file-\u0633'
1347
name1u + '/' + name0u,
1348
name1u + '/' + name1u + '/',
1351
self.build_tree(tree)
1352
name0 = name0u.encode('utf8')
1353
name1 = name1u.encode('utf8')
1354
name2 = name2u.encode('utf8')
1356
# All of the abspaths should be in unicode, all of the relative paths
1358
expected_dirblocks = [
1360
[(name0, name0, 'file', './' + name0u),
1361
(name1, name1, 'directory', './' + name1u),
1362
(name2, name2, 'file', './' + name2u),
1365
((name1, './' + name1u),
1366
[(name1 + '/' + name0, name0, 'file', './' + name1u
1368
(name1 + '/' + name1, name1, 'directory', './' + name1u
1372
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1377
result = list(osutils._walkdirs_utf8('.'))
1378
self._filter_out_stat(result)
1379
self.assertEqual(expected_dirblocks, result)
1381
def test__walkdirs_utf8_win32readdir(self):
1382
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1383
self.requireFeature(tests.UnicodeFilenameFeature)
1384
from bzrlib._walkdirs_win32 import Win32ReadDir
1385
self._save_platform_info()
1386
osutils._selected_dir_reader = Win32ReadDir()
1387
name0u = u'0file-\xb6'
1388
name1u = u'1dir-\u062c\u0648'
1389
name2u = u'2file-\u0633'
1393
name1u + '/' + name0u,
1394
name1u + '/' + name1u + '/',
1397
self.build_tree(tree)
1398
name0 = name0u.encode('utf8')
1399
name1 = name1u.encode('utf8')
1400
name2 = name2u.encode('utf8')
1402
# All of the abspaths should be in unicode, all of the relative paths
1404
expected_dirblocks = [
1406
[(name0, name0, 'file', './' + name0u),
1407
(name1, name1, 'directory', './' + name1u),
1408
(name2, name2, 'file', './' + name2u),
1411
((name1, './' + name1u),
1412
[(name1 + '/' + name0, name0, 'file', './' + name1u
1414
(name1 + '/' + name1, name1, 'directory', './' + name1u
1418
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1423
result = list(osutils._walkdirs_utf8(u'.'))
1424
self._filter_out_stat(result)
1425
self.assertEqual(expected_dirblocks, result)
1427
def assertStatIsCorrect(self, path, win32stat):
1428
os_stat = os.stat(path)
1429
self.assertEqual(os_stat.st_size, win32stat.st_size)
1430
self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
1431
self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
1432
self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
1433
self.assertEqual(os_stat.st_dev, win32stat.st_dev)
1434
self.assertEqual(os_stat.st_ino, win32stat.st_ino)
1435
self.assertEqual(os_stat.st_mode, win32stat.st_mode)
1437
def test__walkdirs_utf_win32_find_file_stat_file(self):
1438
"""make sure our Stat values are valid"""
1439
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1440
self.requireFeature(tests.UnicodeFilenameFeature)
1441
from bzrlib._walkdirs_win32 import Win32ReadDir
1442
name0u = u'0file-\xb6'
1443
name0 = name0u.encode('utf8')
1444
self.build_tree([name0u])
1445
# I hate to sleep() here, but I'm trying to make the ctime different
1448
f = open(name0u, 'ab')
1450
f.write('just a small update')
1454
result = Win32ReadDir().read_dir('', u'.')
1456
self.assertEqual((name0, name0, 'file'), entry[:3])
1457
self.assertEqual(u'./' + name0u, entry[4])
1458
self.assertStatIsCorrect(entry[4], entry[3])
1459
self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
1461
def test__walkdirs_utf_win32_find_file_stat_directory(self):
1462
"""make sure our Stat values are valid"""
1463
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1464
self.requireFeature(tests.UnicodeFilenameFeature)
1465
from bzrlib._walkdirs_win32 import Win32ReadDir
1466
name0u = u'0dir-\u062c\u0648'
1467
name0 = name0u.encode('utf8')
1468
self.build_tree([name0u + '/'])
1470
result = Win32ReadDir().read_dir('', u'.')
1472
self.assertEqual((name0, name0, 'directory'), entry[:3])
1473
self.assertEqual(u'./' + name0u, entry[4])
1474
self.assertStatIsCorrect(entry[4], entry[3])
1476
def assertPathCompare(self, path_less, path_greater):
1477
"""check that path_less and path_greater compare correctly."""
1478
self.assertEqual(0, osutils.compare_paths_prefix_order(
1479
path_less, path_less))
1480
self.assertEqual(0, osutils.compare_paths_prefix_order(
1481
path_greater, path_greater))
1482
self.assertEqual(-1, osutils.compare_paths_prefix_order(
1483
path_less, path_greater))
1484
self.assertEqual(1, osutils.compare_paths_prefix_order(
1485
path_greater, path_less))
1487
def test_compare_paths_prefix_order(self):
1488
# root before all else
1489
self.assertPathCompare("/", "/a")
1490
# alpha within a dir
1491
self.assertPathCompare("/a", "/b")
1492
self.assertPathCompare("/b", "/z")
1493
# high dirs before lower.
1494
self.assertPathCompare("/z", "/a/a")
1495
# except if the deeper dir should be output first
1496
self.assertPathCompare("/a/b/c", "/d/g")
1497
# lexical betwen dirs of the same height
1498
self.assertPathCompare("/a/z", "/z/z")
1499
self.assertPathCompare("/a/c/z", "/a/d/e")
1501
# this should also be consistent for no leading / paths
1502
# root before all else
1503
self.assertPathCompare("", "a")
1504
# alpha within a dir
1505
self.assertPathCompare("a", "b")
1506
self.assertPathCompare("b", "z")
1507
# high dirs before lower.
1508
self.assertPathCompare("z", "a/a")
1509
# except if the deeper dir should be output first
1510
self.assertPathCompare("a/b/c", "d/g")
1511
# lexical betwen dirs of the same height
1512
self.assertPathCompare("a/z", "z/z")
1513
self.assertPathCompare("a/c/z", "a/d/e")
1515
def test_path_prefix_sorting(self):
1516
"""Doing a sort on path prefix should match our sample data."""
1531
dir_sorted_paths = [
1547
sorted(original_paths, key=osutils.path_prefix_key))
1548
# using the comparison routine shoudl work too:
1551
sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
1554
class TestCopyTree(tests.TestCaseInTempDir):
1556
def test_copy_basic_tree(self):
1557
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1558
osutils.copy_tree('source', 'target')
1559
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1560
self.assertEqual(['c'], os.listdir('target/b'))
1562
def test_copy_tree_target_exists(self):
1563
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c',
1565
osutils.copy_tree('source', 'target')
1566
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1567
self.assertEqual(['c'], os.listdir('target/b'))
1569
def test_copy_tree_symlinks(self):
1570
self.requireFeature(tests.SymlinkFeature)
1571
self.build_tree(['source/'])
1572
os.symlink('a/generic/path', 'source/lnk')
1573
osutils.copy_tree('source', 'target')
1574
self.assertEqual(['lnk'], os.listdir('target'))
1575
self.assertEqual('a/generic/path', os.readlink('target/lnk'))
1577
def test_copy_tree_handlers(self):
1578
processed_files = []
1579
processed_links = []
1580
def file_handler(from_path, to_path):
1581
processed_files.append(('f', from_path, to_path))
1582
def dir_handler(from_path, to_path):
1583
processed_files.append(('d', from_path, to_path))
1584
def link_handler(from_path, to_path):
1585
processed_links.append((from_path, to_path))
1586
handlers = {'file':file_handler,
1587
'directory':dir_handler,
1588
'symlink':link_handler,
1591
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1592
if osutils.has_symlinks():
1593
os.symlink('a/generic/path', 'source/lnk')
1594
osutils.copy_tree('source', 'target', handlers=handlers)
1596
self.assertEqual([('d', 'source', 'target'),
1597
('f', 'source/a', 'target/a'),
1598
('d', 'source/b', 'target/b'),
1599
('f', 'source/b/c', 'target/b/c'),
1601
self.failIfExists('target')
1602
if osutils.has_symlinks():
1603
self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1606
class TestSetUnsetEnv(tests.TestCase):
1607
"""Test updating the environment"""
1610
super(TestSetUnsetEnv, self).setUp()
1612
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
1613
'Environment was not cleaned up properly.'
1614
' Variable BZR_TEST_ENV_VAR should not exist.')
1616
if 'BZR_TEST_ENV_VAR' in os.environ:
1617
del os.environ['BZR_TEST_ENV_VAR']
1618
self.addCleanup(cleanup)
1621
"""Test that we can set an env variable"""
1622
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1623
self.assertEqual(None, old)
1624
self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
1626
def test_double_set(self):
1627
"""Test that we get the old value out"""
1628
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1629
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
1630
self.assertEqual('foo', old)
1631
self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
1633
def test_unicode(self):
1634
"""Environment can only contain plain strings
1636
So Unicode strings must be encoded.
1638
uni_val, env_val = tests.probe_unicode_in_user_encoding()
1640
raise tests.TestSkipped(
1641
'Cannot find a unicode character that works in encoding %s'
1642
% (osutils.get_user_encoding(),))
1644
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1645
self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
1647
def test_unset(self):
1648
"""Test that passing None will remove the env var"""
1649
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1650
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1651
self.assertEqual('foo', old)
1652
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1653
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1656
class TestSizeShaFile(tests.TestCaseInTempDir):
1658
def test_sha_empty(self):
1659
self.build_tree_contents([('foo', '')])
1660
expected_sha = osutils.sha_string('')
1662
self.addCleanup(f.close)
1663
size, sha = osutils.size_sha_file(f)
1664
self.assertEqual(0, size)
1665
self.assertEqual(expected_sha, sha)
1667
def test_sha_mixed_endings(self):
1668
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1669
self.build_tree_contents([('foo', text)])
1670
expected_sha = osutils.sha_string(text)
1671
f = open('foo', 'rb')
1672
self.addCleanup(f.close)
1673
size, sha = osutils.size_sha_file(f)
1674
self.assertEqual(38, size)
1675
self.assertEqual(expected_sha, sha)
1678
class TestShaFileByName(tests.TestCaseInTempDir):
1680
def test_sha_empty(self):
1681
self.build_tree_contents([('foo', '')])
1682
expected_sha = osutils.sha_string('')
1683
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1685
def test_sha_mixed_endings(self):
1686
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1687
self.build_tree_contents([('foo', text)])
1688
expected_sha = osutils.sha_string(text)
1689
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1692
class TestResourceLoading(tests.TestCaseInTempDir):
1694
def test_resource_string(self):
1695
# test resource in bzrlib
1696
text = osutils.resource_string('bzrlib', 'debug.py')
1697
self.assertContainsRe(text, "debug_flags = set()")
1698
# test resource under bzrlib
1699
text = osutils.resource_string('bzrlib.ui', 'text.py')
1700
self.assertContainsRe(text, "class TextUIFactory")
1701
# test unsupported package
1702
self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1704
# test unknown resource
1705
self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1708
class TestReCompile(tests.TestCase):
1710
def _deprecated_re_compile_checked(self, *args, **kwargs):
1711
return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
1712
osutils.re_compile_checked, *args, **kwargs)
1714
def test_re_compile_checked(self):
1715
r = self._deprecated_re_compile_checked(r'A*', re.IGNORECASE)
1716
self.assertTrue(r.match('aaaa'))
1717
self.assertTrue(r.match('aAaA'))
1719
def test_re_compile_checked_error(self):
1720
# like https://bugs.launchpad.net/bzr/+bug/251352
1722
# Due to possible test isolation error, re.compile is not lazy at
1723
# this point. We re-install lazy compile.
1724
lazy_regex.install_lazy_compile()
1725
err = self.assertRaises(
1726
errors.BzrCommandError,
1727
self._deprecated_re_compile_checked, '*', re.IGNORECASE, 'test case')
1729
'Invalid regular expression in test case: '
1730
'"*" nothing to repeat',
1734
class TestDirReader(tests.TestCaseInTempDir):
1737
_dir_reader_class = None
1738
_native_to_unicode = None
1741
tests.TestCaseInTempDir.setUp(self)
1742
self.overrideAttr(osutils,
1743
'_selected_dir_reader', self._dir_reader_class())
1745
def _get_ascii_tree(self):
1753
expected_dirblocks = [
1755
[('0file', '0file', 'file'),
1756
('1dir', '1dir', 'directory'),
1757
('2file', '2file', 'file'),
1760
(('1dir', './1dir'),
1761
[('1dir/0file', '0file', 'file'),
1762
('1dir/1dir', '1dir', 'directory'),
1765
(('1dir/1dir', './1dir/1dir'),
1770
return tree, expected_dirblocks
1772
def test_walk_cur_dir(self):
1773
tree, expected_dirblocks = self._get_ascii_tree()
1774
self.build_tree(tree)
1775
result = list(osutils._walkdirs_utf8('.'))
1776
# Filter out stat and abspath
1777
self.assertEqual(expected_dirblocks,
1778
[(dirinfo, [line[0:3] for line in block])
1779
for dirinfo, block in result])
1781
def test_walk_sub_dir(self):
1782
tree, expected_dirblocks = self._get_ascii_tree()
1783
self.build_tree(tree)
1784
# you can search a subdir only, with a supplied prefix.
1785
result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1786
# Filter out stat and abspath
1787
self.assertEqual(expected_dirblocks[1:],
1788
[(dirinfo, [line[0:3] for line in block])
1789
for dirinfo, block in result])
1791
def _get_unicode_tree(self):
1792
name0u = u'0file-\xb6'
1793
name1u = u'1dir-\u062c\u0648'
1794
name2u = u'2file-\u0633'
1798
name1u + '/' + name0u,
1799
name1u + '/' + name1u + '/',
1802
name0 = name0u.encode('UTF-8')
1803
name1 = name1u.encode('UTF-8')
1804
name2 = name2u.encode('UTF-8')
1805
expected_dirblocks = [
1807
[(name0, name0, 'file', './' + name0u),
1808
(name1, name1, 'directory', './' + name1u),
1809
(name2, name2, 'file', './' + name2u),
1812
((name1, './' + name1u),
1813
[(name1 + '/' + name0, name0, 'file', './' + name1u
1815
(name1 + '/' + name1, name1, 'directory', './' + name1u
1819
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1824
return tree, expected_dirblocks
1826
def _filter_out(self, raw_dirblocks):
1827
"""Filter out a walkdirs_utf8 result.
1829
stat field is removed, all native paths are converted to unicode
1831
filtered_dirblocks = []
1832
for dirinfo, block in raw_dirblocks:
1833
dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1836
details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1837
filtered_dirblocks.append((dirinfo, details))
1838
return filtered_dirblocks
1840
def test_walk_unicode_tree(self):
1841
self.requireFeature(tests.UnicodeFilenameFeature)
1842
tree, expected_dirblocks = self._get_unicode_tree()
1843
self.build_tree(tree)
1844
result = list(osutils._walkdirs_utf8('.'))
1845
self.assertEqual(expected_dirblocks, self._filter_out(result))
1847
def test_symlink(self):
1848
self.requireFeature(tests.SymlinkFeature)
1849
self.requireFeature(tests.UnicodeFilenameFeature)
1850
target = u'target\N{Euro Sign}'
1851
link_name = u'l\N{Euro Sign}nk'
1852
os.symlink(target, link_name)
1853
target_utf8 = target.encode('UTF-8')
1854
link_name_utf8 = link_name.encode('UTF-8')
1855
expected_dirblocks = [
1857
[(link_name_utf8, link_name_utf8,
1858
'symlink', './' + link_name),],
1860
result = list(osutils._walkdirs_utf8('.'))
1861
self.assertEqual(expected_dirblocks, self._filter_out(result))
1864
class TestReadLink(tests.TestCaseInTempDir):
1865
"""Exposes os.readlink() problems and the osutils solution.
1867
The only guarantee offered by os.readlink(), starting with 2.6, is that a
1868
unicode string will be returned if a unicode string is passed.
1870
But prior python versions failed to properly encode the passed unicode
1873
_test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
1876
super(tests.TestCaseInTempDir, self).setUp()
1877
self.link = u'l\N{Euro Sign}ink'
1878
self.target = u'targe\N{Euro Sign}t'
1879
os.symlink(self.target, self.link)
1881
def test_os_readlink_link_encoding(self):
1882
if sys.version_info < (2, 6):
1883
self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
1885
self.assertEquals(self.target, os.readlink(self.link))
1887
def test_os_readlink_link_decoding(self):
1888
self.assertEquals(self.target.encode(osutils._fs_enc),
1889
os.readlink(self.link.encode(osutils._fs_enc)))
1892
class TestConcurrency(tests.TestCase):
1895
super(TestConcurrency, self).setUp()
1896
self.overrideAttr(osutils, '_cached_local_concurrency')
1898
def test_local_concurrency(self):
1899
concurrency = osutils.local_concurrency()
1900
self.assertIsInstance(concurrency, int)
1902
def test_local_concurrency_environment_variable(self):
1903
os.environ['BZR_CONCURRENCY'] = '2'
1904
self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1905
os.environ['BZR_CONCURRENCY'] = '3'
1906
self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1907
os.environ['BZR_CONCURRENCY'] = 'foo'
1908
self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1910
def test_option_concurrency(self):
1911
os.environ['BZR_CONCURRENCY'] = '1'
1912
self.run_bzr('rocks --concurrency 42')
1913
# Command line overrides envrionment variable
1914
self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1915
self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1918
class TestFailedToLoadExtension(tests.TestCase):
1920
def _try_loading(self):
1922
import bzrlib._fictional_extension_py
1923
except ImportError, e:
1924
osutils.failed_to_load_extension(e)
1928
super(TestFailedToLoadExtension, self).setUp()
1929
self.overrideAttr(osutils, '_extension_load_failures', [])
1931
def test_failure_to_load(self):
1933
self.assertLength(1, osutils._extension_load_failures)
1934
self.assertEquals(osutils._extension_load_failures[0],
1935
"No module named _fictional_extension_py")
1937
def test_report_extension_load_failures_no_warning(self):
1938
self.assertTrue(self._try_loading())
1939
warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
1940
# it used to give a Python warning; it no longer does
1941
self.assertLength(0, warnings)
1943
def test_report_extension_load_failures_message(self):
1945
trace.push_log_file(log)
1946
self.assertTrue(self._try_loading())
1947
osutils.report_extension_load_failures()
1948
self.assertContainsRe(
1950
r"bzr: warning: some compiled extensions could not be loaded; "
1951
"see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1955
class TestTerminalWidth(tests.TestCase):
1958
tests.TestCase.setUp(self)
1959
self._orig_terminal_size_state = osutils._terminal_size_state
1960
self._orig_first_terminal_size = osutils._first_terminal_size
1961
self.addCleanup(self.restore_osutils_globals)
1962
osutils._terminal_size_state = 'no_data'
1963
osutils._first_terminal_size = None
1965
def restore_osutils_globals(self):
1966
osutils._terminal_size_state = self._orig_terminal_size_state
1967
osutils._first_terminal_size = self._orig_first_terminal_size
1969
def replace_stdout(self, new):
1970
self.overrideAttr(sys, 'stdout', new)
1972
def replace__terminal_size(self, new):
1973
self.overrideAttr(osutils, '_terminal_size', new)
1975
def set_fake_tty(self):
1977
class I_am_a_tty(object):
1981
self.replace_stdout(I_am_a_tty())
1983
def test_default_values(self):
1984
self.assertEqual(80, osutils.default_terminal_width)
1986
def test_defaults_to_BZR_COLUMNS(self):
1987
# BZR_COLUMNS is set by the test framework
1988
self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
1989
os.environ['BZR_COLUMNS'] = '12'
1990
self.assertEqual(12, osutils.terminal_width())
1992
def test_falls_back_to_COLUMNS(self):
1993
del os.environ['BZR_COLUMNS']
1994
self.assertNotEqual('42', os.environ['COLUMNS'])
1996
os.environ['COLUMNS'] = '42'
1997
self.assertEqual(42, osutils.terminal_width())
1999
def test_tty_default_without_columns(self):
2000
del os.environ['BZR_COLUMNS']
2001
del os.environ['COLUMNS']
2003
def terminal_size(w, h):
2007
# We need to override the osutils definition as it depends on the
2008
# running environment that we can't control (PQM running without a
2009
# controlling terminal is one example).
2010
self.replace__terminal_size(terminal_size)
2011
self.assertEqual(42, osutils.terminal_width())
2013
def test_non_tty_default_without_columns(self):
2014
del os.environ['BZR_COLUMNS']
2015
del os.environ['COLUMNS']
2016
self.replace_stdout(None)
2017
self.assertEqual(None, osutils.terminal_width())
2019
def test_no_TIOCGWINSZ(self):
2020
self.requireFeature(term_ios_feature)
2021
termios = term_ios_feature.module
2022
# bug 63539 is about a termios without TIOCGWINSZ attribute
2024
orig = termios.TIOCGWINSZ
2025
except AttributeError:
2026
# We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
2029
self.overrideAttr(termios, 'TIOCGWINSZ')
2030
del termios.TIOCGWINSZ
2031
del os.environ['BZR_COLUMNS']
2032
del os.environ['COLUMNS']
2033
# Whatever the result is, if we don't raise an exception, it's ok.
2034
osutils.terminal_width()
2036
class TestCreationOps(tests.TestCaseInTempDir):
2037
_test_needs_features = [features.chown_feature]
2040
tests.TestCaseInTempDir.setUp(self)
2041
self.overrideAttr(os, 'chown', self._dummy_chown)
2043
# params set by call to _dummy_chown
2044
self.path = self.uid = self.gid = None
2046
def _dummy_chown(self, path, uid, gid):
2047
self.path, self.uid, self.gid = path, uid, gid
2049
def test_copy_ownership_from_path(self):
2050
"""copy_ownership_from_path test with specified src."""
2052
f = open('test_file', 'wt')
2053
osutils.copy_ownership_from_path('test_file', ownsrc)
2056
self.assertEquals(self.path, 'test_file')
2057
self.assertEquals(self.uid, s.st_uid)
2058
self.assertEquals(self.gid, s.st_gid)
2060
def test_copy_ownership_nonesrc(self):
2061
"""copy_ownership_from_path test with src=None."""
2062
f = open('test_file', 'wt')
2063
# should use parent dir for permissions
2064
osutils.copy_ownership_from_path('test_file')
2067
self.assertEquals(self.path, 'test_file')
2068
self.assertEquals(self.uid, s.st_uid)
2069
self.assertEquals(self.gid, s.st_gid)
2071
class TestGetuserUnicode(tests.TestCase):
2073
def test_ascii_user(self):
2074
osutils.set_or_unset_env('LOGNAME', 'jrandom')
2075
self.assertEqual(u'jrandom', osutils.getuser_unicode())
2077
def test_unicode_user(self):
2078
ue = osutils.get_user_encoding()
2079
uni_val, env_val = tests.probe_unicode_in_user_encoding()
2081
raise tests.TestSkipped(
2082
'Cannot find a unicode character that works in encoding %s'
2083
% (osutils.get_user_encoding(),))
2084
uni_username = u'jrandom' + uni_val
2085
encoded_username = uni_username.encode(ue)
2086
osutils.set_or_unset_env('LOGNAME', encoded_username)
2087
self.assertEqual(uni_username, osutils.getuser_unicode())
added
removed
bzrlib/tests/test_osutils.py
