1
# Copyright (C) 2005-2011 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 (
41
from bzrlib.tests.scenarios import load_tests_apply_scenarios
44
class _UTF8DirReaderFeature(features.Feature):
48
from bzrlib import _readdir_pyx
49
self.reader = _readdir_pyx.UTF8DirReader
54
def feature_name(self):
55
return 'bzrlib._readdir_pyx'
57
UTF8DirReaderFeature = features.ModuleAvailableFeature('bzrlib._readdir_pyx')
59
term_ios_feature = features.ModuleAvailableFeature('termios')
62
def _already_unicode(s):
66
def _utf8_to_unicode(s):
67
return s.decode('UTF-8')
70
def dir_reader_scenarios():
71
# For each dir reader we define:
73
# - native_to_unicode: a function converting the native_abspath as returned
74
# by DirReader.read_dir to its unicode representation
76
# UnicodeDirReader is the fallback, it should be tested on all platforms.
77
scenarios = [('unicode',
78
dict(_dir_reader_class=osutils.UnicodeDirReader,
79
_native_to_unicode=_already_unicode))]
80
# Some DirReaders are platform specific and even there they may not be
82
if UTF8DirReaderFeature.available():
83
from bzrlib import _readdir_pyx
84
scenarios.append(('utf8',
85
dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
86
_native_to_unicode=_utf8_to_unicode)))
88
if test__walkdirs_win32.win32_readdir_feature.available():
90
from bzrlib import _walkdirs_win32
93
dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
94
_native_to_unicode=_already_unicode)))
100
load_tests = load_tests_apply_scenarios
103
class TestContainsWhitespace(tests.TestCase):
105
def test_contains_whitespace(self):
106
self.assertTrue(osutils.contains_whitespace(u' '))
107
self.assertTrue(osutils.contains_whitespace(u'hello there'))
108
self.assertTrue(osutils.contains_whitespace(u'hellothere\n'))
109
self.assertTrue(osutils.contains_whitespace(u'hello\nthere'))
110
self.assertTrue(osutils.contains_whitespace(u'hello\rthere'))
111
self.assertTrue(osutils.contains_whitespace(u'hello\tthere'))
113
# \xa0 is "Non-breaking-space" which on some python locales thinks it
114
# is whitespace, but we do not.
115
self.assertFalse(osutils.contains_whitespace(u''))
116
self.assertFalse(osutils.contains_whitespace(u'hellothere'))
117
self.assertFalse(osutils.contains_whitespace(u'hello\xa0there'))
120
class TestRename(tests.TestCaseInTempDir):
122
def create_file(self, filename, content):
123
f = open(filename, 'wb')
129
def _fancy_rename(self, a, b):
130
osutils.fancy_rename(a, b, rename_func=os.rename,
131
unlink_func=os.unlink)
133
def test_fancy_rename(self):
134
# This should work everywhere
135
self.create_file('a', 'something in a\n')
136
self._fancy_rename('a', 'b')
137
self.assertPathDoesNotExist('a')
138
self.assertPathExists('b')
139
self.check_file_contents('b', 'something in a\n')
141
self.create_file('a', 'new something in a\n')
142
self._fancy_rename('b', 'a')
144
self.check_file_contents('a', 'something in a\n')
146
def test_fancy_rename_fails_source_missing(self):
147
# An exception should be raised, and the target should be left in place
148
self.create_file('target', 'data in target\n')
149
self.assertRaises((IOError, OSError), self._fancy_rename,
150
'missingsource', 'target')
151
self.assertPathExists('target')
152
self.check_file_contents('target', 'data in target\n')
154
def test_fancy_rename_fails_if_source_and_target_missing(self):
155
self.assertRaises((IOError, OSError), self._fancy_rename,
156
'missingsource', 'missingtarget')
158
def test_rename(self):
159
# Rename should be semi-atomic on all platforms
160
self.create_file('a', 'something in a\n')
161
osutils.rename('a', 'b')
162
self.assertPathDoesNotExist('a')
163
self.assertPathExists('b')
164
self.check_file_contents('b', 'something in a\n')
166
self.create_file('a', 'new something in a\n')
167
osutils.rename('b', 'a')
169
self.check_file_contents('a', 'something in a\n')
171
# TODO: test fancy_rename using a MemoryTransport
173
def test_rename_change_case(self):
174
# on Windows we should be able to change filename case by rename
175
self.build_tree(['a', 'b/'])
176
osutils.rename('a', 'A')
177
osutils.rename('b', 'B')
178
# we can't use failUnlessExists on case-insensitive filesystem
179
# so try to check shape of the tree
180
shape = sorted(os.listdir('.'))
181
self.assertEquals(['A', 'B'], shape)
184
class TestRandChars(tests.TestCase):
186
def test_01_rand_chars_empty(self):
187
result = osutils.rand_chars(0)
188
self.assertEqual(result, '')
190
def test_02_rand_chars_100(self):
191
result = osutils.rand_chars(100)
192
self.assertEqual(len(result), 100)
193
self.assertEqual(type(result), str)
194
self.assertContainsRe(result, r'^[a-z0-9]{100}$')
197
class TestIsInside(tests.TestCase):
199
def test_is_inside(self):
200
is_inside = osutils.is_inside
201
self.assertTrue(is_inside('src', 'src/foo.c'))
202
self.assertFalse(is_inside('src', 'srccontrol'))
203
self.assertTrue(is_inside('src', 'src/a/a/a/foo.c'))
204
self.assertTrue(is_inside('foo.c', 'foo.c'))
205
self.assertFalse(is_inside('foo.c', ''))
206
self.assertTrue(is_inside('', 'foo.c'))
208
def test_is_inside_any(self):
209
SRC_FOO_C = osutils.pathjoin('src', 'foo.c')
210
for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
211
(['src'], SRC_FOO_C),
214
self.assert_(osutils.is_inside_any(dirs, fn))
215
for dirs, fn in [(['src'], 'srccontrol'),
216
(['src'], 'srccontrol/foo')]:
217
self.assertFalse(osutils.is_inside_any(dirs, fn))
219
def test_is_inside_or_parent_of_any(self):
220
for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
221
(['src'], 'src/foo.c'),
222
(['src/bar.c'], 'src'),
223
(['src/bar.c', 'bla/foo.c'], 'src'),
226
self.assert_(osutils.is_inside_or_parent_of_any(dirs, fn))
228
for dirs, fn in [(['src'], 'srccontrol'),
229
(['srccontrol/foo.c'], 'src'),
230
(['src'], 'srccontrol/foo')]:
231
self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
234
class TestLstat(tests.TestCaseInTempDir):
236
def test_lstat_matches_fstat(self):
237
# On Windows, lstat and fstat don't always agree, primarily in the
238
# 'st_ino' and 'st_dev' fields. So we force them to be '0' in our
239
# custom implementation.
240
if sys.platform == 'win32':
241
# We only have special lstat/fstat if we have the extension.
242
# Without it, we may end up re-reading content when we don't have
243
# to, but otherwise it doesn't effect correctness.
244
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
245
f = open('test-file.txt', 'wb')
246
self.addCleanup(f.close)
247
f.write('some content\n')
249
self.assertEqualStat(osutils.fstat(f.fileno()),
250
osutils.lstat('test-file.txt'))
253
class TestRmTree(tests.TestCaseInTempDir):
255
def test_rmtree(self):
256
# Check to remove tree with read-only files/dirs
258
f = file('dir/file', 'w')
261
# would like to also try making the directory readonly, but at the
262
# moment python shutil.rmtree doesn't handle that properly - it would
263
# need to chmod the directory before removing things inside it - deferred
264
# for now -- mbp 20060505
265
# osutils.make_readonly('dir')
266
osutils.make_readonly('dir/file')
268
osutils.rmtree('dir')
270
self.assertPathDoesNotExist('dir/file')
271
self.assertPathDoesNotExist('dir')
274
class TestDeleteAny(tests.TestCaseInTempDir):
276
def test_delete_any_readonly(self):
277
# from <https://bugs.launchpad.net/bzr/+bug/218206>
278
self.build_tree(['d/', 'f'])
279
osutils.make_readonly('d')
280
osutils.make_readonly('f')
282
osutils.delete_any('f')
283
osutils.delete_any('d')
286
class TestKind(tests.TestCaseInTempDir):
288
def test_file_kind(self):
289
self.build_tree(['file', 'dir/'])
290
self.assertEquals('file', osutils.file_kind('file'))
291
self.assertEquals('directory', osutils.file_kind('dir/'))
292
if osutils.has_symlinks():
293
os.symlink('symlink', 'symlink')
294
self.assertEquals('symlink', osutils.file_kind('symlink'))
296
# TODO: jam 20060529 Test a block device
298
os.lstat('/dev/null')
300
if e.errno not in (errno.ENOENT,):
303
self.assertEquals('chardev', osutils.file_kind('/dev/null'))
305
mkfifo = getattr(os, 'mkfifo', None)
309
self.assertEquals('fifo', osutils.file_kind('fifo'))
313
AF_UNIX = getattr(socket, 'AF_UNIX', None)
315
s = socket.socket(AF_UNIX)
318
self.assertEquals('socket', osutils.file_kind('socket'))
322
def test_kind_marker(self):
323
self.assertEqual("", osutils.kind_marker("file"))
324
self.assertEqual("/", osutils.kind_marker('directory'))
325
self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
326
self.assertEqual("@", osutils.kind_marker("symlink"))
327
self.assertEqual("+", osutils.kind_marker("tree-reference"))
328
self.assertEqual("", osutils.kind_marker("fifo"))
329
self.assertEqual("", osutils.kind_marker("socket"))
330
self.assertEqual("", osutils.kind_marker("unknown"))
333
class TestUmask(tests.TestCaseInTempDir):
335
def test_get_umask(self):
336
if sys.platform == 'win32':
337
# umask always returns '0', no way to set it
338
self.assertEqual(0, osutils.get_umask())
341
orig_umask = osutils.get_umask()
342
self.addCleanup(os.umask, orig_umask)
344
self.assertEqual(0222, osutils.get_umask())
346
self.assertEqual(0022, osutils.get_umask())
348
self.assertEqual(0002, osutils.get_umask())
350
self.assertEqual(0027, osutils.get_umask())
353
class TestDateTime(tests.TestCase):
355
def assertFormatedDelta(self, expected, seconds):
356
"""Assert osutils.format_delta formats as expected"""
357
actual = osutils.format_delta(seconds)
358
self.assertEqual(expected, actual)
360
def test_format_delta(self):
361
self.assertFormatedDelta('0 seconds ago', 0)
362
self.assertFormatedDelta('1 second ago', 1)
363
self.assertFormatedDelta('10 seconds ago', 10)
364
self.assertFormatedDelta('59 seconds ago', 59)
365
self.assertFormatedDelta('89 seconds ago', 89)
366
self.assertFormatedDelta('1 minute, 30 seconds ago', 90)
367
self.assertFormatedDelta('3 minutes, 0 seconds ago', 180)
368
self.assertFormatedDelta('3 minutes, 1 second ago', 181)
369
self.assertFormatedDelta('10 minutes, 15 seconds ago', 615)
370
self.assertFormatedDelta('30 minutes, 59 seconds ago', 1859)
371
self.assertFormatedDelta('31 minutes, 0 seconds ago', 1860)
372
self.assertFormatedDelta('60 minutes, 0 seconds ago', 3600)
373
self.assertFormatedDelta('89 minutes, 59 seconds ago', 5399)
374
self.assertFormatedDelta('1 hour, 30 minutes ago', 5400)
375
self.assertFormatedDelta('2 hours, 30 minutes ago', 9017)
376
self.assertFormatedDelta('10 hours, 0 minutes ago', 36000)
377
self.assertFormatedDelta('24 hours, 0 minutes ago', 86400)
378
self.assertFormatedDelta('35 hours, 59 minutes ago', 129599)
379
self.assertFormatedDelta('36 hours, 0 minutes ago', 129600)
380
self.assertFormatedDelta('36 hours, 0 minutes ago', 129601)
381
self.assertFormatedDelta('36 hours, 1 minute ago', 129660)
382
self.assertFormatedDelta('36 hours, 1 minute ago', 129661)
383
self.assertFormatedDelta('84 hours, 10 minutes ago', 303002)
385
# We handle when time steps the wrong direction because computers
386
# don't have synchronized clocks.
387
self.assertFormatedDelta('84 hours, 10 minutes in the future', -303002)
388
self.assertFormatedDelta('1 second in the future', -1)
389
self.assertFormatedDelta('2 seconds in the future', -2)
391
def test_format_date(self):
392
self.assertRaises(errors.UnsupportedTimezoneFormat,
393
osutils.format_date, 0, timezone='foo')
394
self.assertIsInstance(osutils.format_date(0), str)
395
self.assertIsInstance(osutils.format_local_date(0), unicode)
396
# Testing for the actual value of the local weekday without
397
# duplicating the code from format_date is difficult.
398
# Instead blackbox.test_locale should check for localized
399
# dates once they do occur in output strings.
401
def test_format_date_with_offset_in_original_timezone(self):
402
self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
403
osutils.format_date_with_offset_in_original_timezone(0))
404
self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
405
osutils.format_date_with_offset_in_original_timezone(100000))
406
self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
407
osutils.format_date_with_offset_in_original_timezone(100000, 7200))
409
def test_local_time_offset(self):
410
"""Test that local_time_offset() returns a sane value."""
411
offset = osutils.local_time_offset()
412
self.assertTrue(isinstance(offset, int))
413
# Test that the offset is no more than a eighteen hours in
415
# Time zone handling is system specific, so it is difficult to
416
# do more specific tests, but a value outside of this range is
418
eighteen_hours = 18 * 3600
419
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
421
def test_local_time_offset_with_timestamp(self):
422
"""Test that local_time_offset() works with a timestamp."""
423
offset = osutils.local_time_offset(1000000000.1234567)
424
self.assertTrue(isinstance(offset, int))
425
eighteen_hours = 18 * 3600
426
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
429
class TestLinks(tests.TestCaseInTempDir):
431
def test_dereference_path(self):
432
self.requireFeature(features.SymlinkFeature)
433
cwd = osutils.realpath('.')
435
bar_path = osutils.pathjoin(cwd, 'bar')
436
# Using './' to avoid bug #1213894 (first path component not
437
# dereferenced) in Python 2.4.1 and earlier
438
self.assertEqual(bar_path, osutils.realpath('./bar'))
439
os.symlink('bar', 'foo')
440
self.assertEqual(bar_path, osutils.realpath('./foo'))
442
# Does not dereference terminal symlinks
443
foo_path = osutils.pathjoin(cwd, 'foo')
444
self.assertEqual(foo_path, osutils.dereference_path('./foo'))
446
# Dereferences parent symlinks
448
baz_path = osutils.pathjoin(bar_path, 'baz')
449
self.assertEqual(baz_path, osutils.dereference_path('./foo/baz'))
451
# Dereferences parent symlinks that are the first path element
452
self.assertEqual(baz_path, osutils.dereference_path('foo/baz'))
454
# Dereferences parent symlinks in absolute paths
455
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
456
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
458
def test_changing_access(self):
459
f = file('file', 'w')
463
# Make a file readonly
464
osutils.make_readonly('file')
465
mode = os.lstat('file').st_mode
466
self.assertEqual(mode, mode & 0777555)
468
# Make a file writable
469
osutils.make_writable('file')
470
mode = os.lstat('file').st_mode
471
self.assertEqual(mode, mode | 0200)
473
if osutils.has_symlinks():
474
# should not error when handed a symlink
475
os.symlink('nonexistent', 'dangling')
476
osutils.make_readonly('dangling')
477
osutils.make_writable('dangling')
479
def test_host_os_dereferences_symlinks(self):
480
osutils.host_os_dereferences_symlinks()
483
class TestCanonicalRelPath(tests.TestCaseInTempDir):
485
_test_needs_features = [features.CaseInsCasePresFilenameFeature]
487
def test_canonical_relpath_simple(self):
488
f = file('MixedCaseName', 'w')
490
actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
491
self.assertEqual('work/MixedCaseName', actual)
493
def test_canonical_relpath_missing_tail(self):
494
os.mkdir('MixedCaseParent')
495
actual = osutils.canonical_relpath(self.test_base_dir,
496
'mixedcaseparent/nochild')
497
self.assertEqual('work/MixedCaseParent/nochild', actual)
500
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
502
def assertRelpath(self, expected, base, path):
503
actual = osutils._cicp_canonical_relpath(base, path)
504
self.assertEqual(expected, actual)
506
def test_simple(self):
507
self.build_tree(['MixedCaseName'])
508
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
509
self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
511
def test_subdir_missing_tail(self):
512
self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
513
base = osutils.realpath(self.get_transport('.').local_abspath('.'))
514
self.assertRelpath('MixedCaseParent/a_child', base,
515
'MixedCaseParent/a_child')
516
self.assertRelpath('MixedCaseParent/a_child', base,
517
'MixedCaseParent/A_Child')
518
self.assertRelpath('MixedCaseParent/not_child', base,
519
'MixedCaseParent/not_child')
521
def test_at_root_slash(self):
522
# We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
524
if osutils.MIN_ABS_PATHLENGTH > 1:
525
raise tests.TestSkipped('relpath requires %d chars'
526
% osutils.MIN_ABS_PATHLENGTH)
527
self.assertRelpath('foo', '/', '/foo')
529
def test_at_root_drive(self):
530
if sys.platform != 'win32':
531
raise tests.TestNotApplicable('we can only test drive-letter relative'
532
' paths on Windows where we have drive'
535
# The specific issue is that when at the root of a drive, 'abspath'
536
# returns "C:/" or just "/". However, the code assumes that abspath
537
# always returns something like "C:/foo" or "/foo" (no trailing slash).
538
self.assertRelpath('foo', 'C:/', 'C:/foo')
539
self.assertRelpath('foo', 'X:/', 'X:/foo')
540
self.assertRelpath('foo', 'X:/', 'X://foo')
543
class TestPumpFile(tests.TestCase):
544
"""Test pumpfile method."""
547
tests.TestCase.setUp(self)
548
# create a test datablock
549
self.block_size = 512
550
pattern = '0123456789ABCDEF'
551
self.test_data = pattern * (3 * self.block_size / len(pattern))
552
self.test_data_len = len(self.test_data)
554
def test_bracket_block_size(self):
555
"""Read data in blocks with the requested read size bracketing the
557
# make sure test data is larger than max read size
558
self.assertTrue(self.test_data_len > self.block_size)
560
from_file = file_utils.FakeReadFile(self.test_data)
563
# read (max / 2) bytes and verify read size wasn't affected
564
num_bytes_to_read = self.block_size / 2
565
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
566
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
567
self.assertEqual(from_file.get_read_count(), 1)
569
# read (max) bytes and verify read size wasn't affected
570
num_bytes_to_read = self.block_size
571
from_file.reset_read_count()
572
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
573
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
574
self.assertEqual(from_file.get_read_count(), 1)
576
# read (max + 1) bytes and verify read size was limited
577
num_bytes_to_read = self.block_size + 1
578
from_file.reset_read_count()
579
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
580
self.assertEqual(from_file.get_max_read_size(), self.block_size)
581
self.assertEqual(from_file.get_read_count(), 2)
583
# finish reading the rest of the data
584
num_bytes_to_read = self.test_data_len - to_file.tell()
585
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
587
# report error if the data wasn't equal (we only report the size due
588
# to the length of the data)
589
response_data = to_file.getvalue()
590
if response_data != self.test_data:
591
message = "Data not equal. Expected %d bytes, received %d."
592
self.fail(message % (len(response_data), self.test_data_len))
594
def test_specified_size(self):
595
"""Request a transfer larger than the maximum block size and verify
596
that the maximum read doesn't exceed the block_size."""
597
# make sure test data is larger than max read size
598
self.assertTrue(self.test_data_len > self.block_size)
600
# retrieve data in blocks
601
from_file = file_utils.FakeReadFile(self.test_data)
603
osutils.pumpfile(from_file, to_file, self.test_data_len,
606
# verify read size was equal to the maximum read size
607
self.assertTrue(from_file.get_max_read_size() > 0)
608
self.assertEqual(from_file.get_max_read_size(), self.block_size)
609
self.assertEqual(from_file.get_read_count(), 3)
611
# report error if the data wasn't equal (we only report the size due
612
# to the length of the data)
613
response_data = to_file.getvalue()
614
if response_data != self.test_data:
615
message = "Data not equal. Expected %d bytes, received %d."
616
self.fail(message % (len(response_data), self.test_data_len))
618
def test_to_eof(self):
619
"""Read to end-of-file and verify that the reads are not larger than
620
the maximum read size."""
621
# make sure test data is larger than max read size
622
self.assertTrue(self.test_data_len > self.block_size)
624
# retrieve data to EOF
625
from_file = file_utils.FakeReadFile(self.test_data)
627
osutils.pumpfile(from_file, to_file, -1, self.block_size)
629
# verify read size was equal to the maximum read size
630
self.assertEqual(from_file.get_max_read_size(), self.block_size)
631
self.assertEqual(from_file.get_read_count(), 4)
633
# report error if the data wasn't equal (we only report the size due
634
# to the length of the data)
635
response_data = to_file.getvalue()
636
if response_data != self.test_data:
637
message = "Data not equal. Expected %d bytes, received %d."
638
self.fail(message % (len(response_data), self.test_data_len))
640
def test_defaults(self):
641
"""Verifies that the default arguments will read to EOF -- this
642
test verifies that any existing usages of pumpfile will not be broken
643
with this new version."""
644
# retrieve data using default (old) pumpfile method
645
from_file = file_utils.FakeReadFile(self.test_data)
647
osutils.pumpfile(from_file, to_file)
649
# report error if the data wasn't equal (we only report the size due
650
# to the length of the data)
651
response_data = to_file.getvalue()
652
if response_data != self.test_data:
653
message = "Data not equal. Expected %d bytes, received %d."
654
self.fail(message % (len(response_data), self.test_data_len))
656
def test_report_activity(self):
658
def log_activity(length, direction):
659
activity.append((length, direction))
660
from_file = StringIO(self.test_data)
662
osutils.pumpfile(from_file, to_file, buff_size=500,
663
report_activity=log_activity, direction='read')
664
self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
665
(36, 'read')], activity)
667
from_file = StringIO(self.test_data)
670
osutils.pumpfile(from_file, to_file, buff_size=500,
671
report_activity=log_activity, direction='write')
672
self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
673
(36, 'write')], activity)
675
# And with a limited amount of data
676
from_file = StringIO(self.test_data)
679
osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
680
report_activity=log_activity, direction='read')
681
self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
685
class TestPumpStringFile(tests.TestCase):
687
def test_empty(self):
689
osutils.pump_string_file("", output)
690
self.assertEqual("", output.getvalue())
692
def test_more_than_segment_size(self):
694
osutils.pump_string_file("123456789", output, 2)
695
self.assertEqual("123456789", output.getvalue())
697
def test_segment_size(self):
699
osutils.pump_string_file("12", output, 2)
700
self.assertEqual("12", output.getvalue())
702
def test_segment_size_multiple(self):
704
osutils.pump_string_file("1234", output, 2)
705
self.assertEqual("1234", output.getvalue())
708
class TestRelpath(tests.TestCase):
710
def test_simple_relpath(self):
711
cwd = osutils.getcwd()
712
subdir = cwd + '/subdir'
713
self.assertEqual('subdir', osutils.relpath(cwd, subdir))
715
def test_deep_relpath(self):
716
cwd = osutils.getcwd()
717
subdir = cwd + '/sub/subsubdir'
718
self.assertEqual('sub/subsubdir', osutils.relpath(cwd, subdir))
720
def test_not_relative(self):
721
self.assertRaises(errors.PathNotChild,
722
osutils.relpath, 'C:/path', 'H:/path')
723
self.assertRaises(errors.PathNotChild,
724
osutils.relpath, 'C:/', 'H:/path')
727
class TestSafeUnicode(tests.TestCase):
729
def test_from_ascii_string(self):
730
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
732
def test_from_unicode_string_ascii_contents(self):
733
self.assertEqual(u'bargam', osutils.safe_unicode(u'bargam'))
735
def test_from_unicode_string_unicode_contents(self):
736
self.assertEqual(u'bargam\xae', osutils.safe_unicode(u'bargam\xae'))
738
def test_from_utf8_string(self):
739
self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
741
def test_bad_utf8_string(self):
742
self.assertRaises(errors.BzrBadParameterNotUnicode,
743
osutils.safe_unicode,
747
class TestSafeUtf8(tests.TestCase):
749
def test_from_ascii_string(self):
751
self.assertEqual('foobar', osutils.safe_utf8(f))
753
def test_from_unicode_string_ascii_contents(self):
754
self.assertEqual('bargam', osutils.safe_utf8(u'bargam'))
756
def test_from_unicode_string_unicode_contents(self):
757
self.assertEqual('bargam\xc2\xae', osutils.safe_utf8(u'bargam\xae'))
759
def test_from_utf8_string(self):
760
self.assertEqual('foo\xc2\xae', osutils.safe_utf8('foo\xc2\xae'))
762
def test_bad_utf8_string(self):
763
self.assertRaises(errors.BzrBadParameterNotUnicode,
764
osutils.safe_utf8, '\xbb\xbb')
767
class TestSafeRevisionId(tests.TestCase):
769
def test_from_ascii_string(self):
770
# this shouldn't give a warning because it's getting an ascii string
771
self.assertEqual('foobar', osutils.safe_revision_id('foobar'))
773
def test_from_unicode_string_ascii_contents(self):
774
self.assertEqual('bargam',
775
osutils.safe_revision_id(u'bargam', warn=False))
777
def test_from_unicode_deprecated(self):
778
self.assertEqual('bargam',
779
self.callDeprecated([osutils._revision_id_warning],
780
osutils.safe_revision_id, u'bargam'))
782
def test_from_unicode_string_unicode_contents(self):
783
self.assertEqual('bargam\xc2\xae',
784
osutils.safe_revision_id(u'bargam\xae', warn=False))
786
def test_from_utf8_string(self):
787
self.assertEqual('foo\xc2\xae',
788
osutils.safe_revision_id('foo\xc2\xae'))
791
"""Currently, None is a valid revision_id"""
792
self.assertEqual(None, osutils.safe_revision_id(None))
795
class TestSafeFileId(tests.TestCase):
797
def test_from_ascii_string(self):
798
self.assertEqual('foobar', osutils.safe_file_id('foobar'))
800
def test_from_unicode_string_ascii_contents(self):
801
self.assertEqual('bargam', osutils.safe_file_id(u'bargam', warn=False))
803
def test_from_unicode_deprecated(self):
804
self.assertEqual('bargam',
805
self.callDeprecated([osutils._file_id_warning],
806
osutils.safe_file_id, u'bargam'))
808
def test_from_unicode_string_unicode_contents(self):
809
self.assertEqual('bargam\xc2\xae',
810
osutils.safe_file_id(u'bargam\xae', warn=False))
812
def test_from_utf8_string(self):
813
self.assertEqual('foo\xc2\xae',
814
osutils.safe_file_id('foo\xc2\xae'))
817
"""Currently, None is a valid revision_id"""
818
self.assertEqual(None, osutils.safe_file_id(None))
821
class TestPosixFuncs(tests.TestCase):
822
"""Test that the posix version of normpath returns an appropriate path
823
when used with 2 leading slashes."""
825
def test_normpath(self):
826
self.assertEqual('/etc/shadow', osutils._posix_normpath('/etc/shadow'))
827
self.assertEqual('/etc/shadow', osutils._posix_normpath('//etc/shadow'))
828
self.assertEqual('/etc/shadow', osutils._posix_normpath('///etc/shadow'))
831
class TestWin32Funcs(tests.TestCase):
832
"""Test that _win32 versions of os utilities return appropriate paths."""
834
def test_abspath(self):
835
self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
836
self.assertEqual('C:/foo', osutils._win32_abspath('C:/foo'))
837
self.assertEqual('//HOST/path', osutils._win32_abspath(r'\\HOST\path'))
838
self.assertEqual('//HOST/path', osutils._win32_abspath('//HOST/path'))
840
def test_realpath(self):
841
self.assertEqual('C:/foo', osutils._win32_realpath('C:\\foo'))
842
self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
844
def test_pathjoin(self):
845
self.assertEqual('path/to/foo',
846
osutils._win32_pathjoin('path', 'to', 'foo'))
847
self.assertEqual('C:/foo',
848
osutils._win32_pathjoin('path\\to', 'C:\\foo'))
849
self.assertEqual('C:/foo',
850
osutils._win32_pathjoin('path/to', 'C:/foo'))
851
self.assertEqual('path/to/foo',
852
osutils._win32_pathjoin('path/to/', 'foo'))
853
self.assertEqual('/foo',
854
osutils._win32_pathjoin('C:/path/to/', '/foo'))
855
self.assertEqual('/foo',
856
osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
858
def test_normpath(self):
859
self.assertEqual('path/to/foo',
860
osutils._win32_normpath(r'path\\from\..\to\.\foo'))
861
self.assertEqual('path/to/foo',
862
osutils._win32_normpath('path//from/../to/./foo'))
864
def test_getcwd(self):
865
cwd = osutils._win32_getcwd()
866
os_cwd = os.getcwdu()
867
self.assertEqual(os_cwd[1:].replace('\\', '/'), cwd[1:])
868
# win32 is inconsistent whether it returns lower or upper case
869
# and even if it was consistent the user might type the other
870
# so we force it to uppercase
871
# running python.exe under cmd.exe return capital C:\\
872
# running win32 python inside a cygwin shell returns lowercase
873
self.assertEqual(os_cwd[0].upper(), cwd[0])
875
def test_fixdrive(self):
876
self.assertEqual('H:/foo', osutils._win32_fixdrive('h:/foo'))
877
self.assertEqual('H:/foo', osutils._win32_fixdrive('H:/foo'))
878
self.assertEqual('C:\\foo', osutils._win32_fixdrive('c:\\foo'))
880
def test_win98_abspath(self):
882
self.assertEqual('C:/foo', osutils._win98_abspath('C:\\foo'))
883
self.assertEqual('C:/foo', osutils._win98_abspath('C:/foo'))
885
self.assertEqual('//HOST/path', osutils._win98_abspath(r'\\HOST\path'))
886
self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
888
cwd = osutils.getcwd().rstrip('/')
889
drive = osutils.ntpath.splitdrive(cwd)[0]
890
self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
891
self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
894
self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
897
class TestWin32FuncsDirs(tests.TestCaseInTempDir):
898
"""Test win32 functions that create files."""
900
def test_getcwd(self):
901
self.requireFeature(features.UnicodeFilenameFeature)
904
# TODO: jam 20060427 This will probably fail on Mac OSX because
905
# it will change the normalization of B\xe5gfors
906
# Consider using a different unicode character, or make
907
# osutils.getcwd() renormalize the path.
908
self.assertEndsWith(osutils._win32_getcwd(), u'mu-\xb5')
910
def test_minimum_path_selection(self):
911
self.assertEqual(set(),
912
osutils.minimum_path_selection([]))
913
self.assertEqual(set(['a']),
914
osutils.minimum_path_selection(['a']))
915
self.assertEqual(set(['a', 'b']),
916
osutils.minimum_path_selection(['a', 'b']))
917
self.assertEqual(set(['a/', 'b']),
918
osutils.minimum_path_selection(['a/', 'b']))
919
self.assertEqual(set(['a/', 'b']),
920
osutils.minimum_path_selection(['a/c', 'a/', 'b']))
921
self.assertEqual(set(['a-b', 'a', 'a0b']),
922
osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
924
def test_mkdtemp(self):
925
tmpdir = osutils._win32_mkdtemp(dir='.')
926
self.assertFalse('\\' in tmpdir)
928
def test_rename(self):
936
osutils._win32_rename('b', 'a')
937
self.assertPathExists('a')
938
self.assertPathDoesNotExist('b')
939
self.assertFileEqual('baz\n', 'a')
941
def test_rename_missing_file(self):
947
osutils._win32_rename('b', 'a')
948
except (IOError, OSError), e:
949
self.assertEqual(errno.ENOENT, e.errno)
950
self.assertFileEqual('foo\n', 'a')
952
def test_rename_missing_dir(self):
955
osutils._win32_rename('b', 'a')
956
except (IOError, OSError), e:
957
self.assertEqual(errno.ENOENT, e.errno)
959
def test_rename_current_dir(self):
962
# You can't rename the working directory
963
# doing rename non-existant . usually
964
# just raises ENOENT, since non-existant
967
osutils._win32_rename('b', '.')
968
except (IOError, OSError), e:
969
self.assertEqual(errno.ENOENT, e.errno)
971
def test_splitpath(self):
972
def check(expected, path):
973
self.assertEqual(expected, osutils.splitpath(path))
976
check(['a', 'b'], 'a/b')
977
check(['a', 'b'], 'a/./b')
978
check(['a', '.b'], 'a/.b')
979
check(['a', '.b'], 'a\\.b')
981
self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
984
class TestParentDirectories(tests.TestCaseInTempDir):
985
"""Test osutils.parent_directories()"""
987
def test_parent_directories(self):
988
self.assertEqual([], osutils.parent_directories('a'))
989
self.assertEqual(['a'], osutils.parent_directories('a/b'))
990
self.assertEqual(['a/b', 'a'], osutils.parent_directories('a/b/c'))
993
class TestMacFuncsDirs(tests.TestCaseInTempDir):
994
"""Test mac special functions that require directories."""
996
def test_getcwd(self):
997
self.requireFeature(features.UnicodeFilenameFeature)
998
os.mkdir(u'B\xe5gfors')
999
os.chdir(u'B\xe5gfors')
1000
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
1002
def test_getcwd_nonnorm(self):
1003
self.requireFeature(features.UnicodeFilenameFeature)
1004
# Test that _mac_getcwd() will normalize this path
1005
os.mkdir(u'Ba\u030agfors')
1006
os.chdir(u'Ba\u030agfors')
1007
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
1010
class TestChunksToLines(tests.TestCase):
1012
def test_smoketest(self):
1013
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
1014
osutils.chunks_to_lines(['foo\nbar', '\nbaz\n']))
1015
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
1016
osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
1018
def test_osutils_binding(self):
1019
from bzrlib.tests import test__chunks_to_lines
1020
if test__chunks_to_lines.compiled_chunkstolines_feature.available():
1021
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1023
from bzrlib._chunks_to_lines_py import chunks_to_lines
1024
self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
1027
class TestSplitLines(tests.TestCase):
1029
def test_split_unicode(self):
1030
self.assertEqual([u'foo\n', u'bar\xae'],
1031
osutils.split_lines(u'foo\nbar\xae'))
1032
self.assertEqual([u'foo\n', u'bar\xae\n'],
1033
osutils.split_lines(u'foo\nbar\xae\n'))
1035
def test_split_with_carriage_returns(self):
1036
self.assertEqual(['foo\rbar\n'],
1037
osutils.split_lines('foo\rbar\n'))
1040
class TestWalkDirs(tests.TestCaseInTempDir):
1042
def assertExpectedBlocks(self, expected, result):
1043
self.assertEqual(expected,
1044
[(dirinfo, [line[0:3] for line in block])
1045
for dirinfo, block in result])
1047
def test_walkdirs(self):
1056
self.build_tree(tree)
1057
expected_dirblocks = [
1059
[('0file', '0file', 'file'),
1060
('1dir', '1dir', 'directory'),
1061
('2file', '2file', 'file'),
1064
(('1dir', './1dir'),
1065
[('1dir/0file', '0file', 'file'),
1066
('1dir/1dir', '1dir', 'directory'),
1069
(('1dir/1dir', './1dir/1dir'),
1075
found_bzrdir = False
1076
for dirdetail, dirblock in osutils.walkdirs('.'):
1077
if len(dirblock) and dirblock[0][1] == '.bzr':
1078
# this tests the filtering of selected paths
1081
result.append((dirdetail, dirblock))
1083
self.assertTrue(found_bzrdir)
1084
self.assertExpectedBlocks(expected_dirblocks, result)
1085
# you can search a subdir only, with a supplied prefix.
1087
for dirblock in osutils.walkdirs('./1dir', '1dir'):
1088
result.append(dirblock)
1089
self.assertExpectedBlocks(expected_dirblocks[1:], result)
1091
def test_walkdirs_os_error(self):
1092
# <https://bugs.launchpad.net/bzr/+bug/338653>
1093
# Pyrex readdir didn't raise useful messages if it had an error
1094
# reading the directory
1095
if sys.platform == 'win32':
1096
raise tests.TestNotApplicable(
1097
"readdir IOError not tested on win32")
1098
self.requireFeature(features.not_running_as_root)
1099
os.mkdir("test-unreadable")
1100
os.chmod("test-unreadable", 0000)
1101
# must chmod it back so that it can be removed
1102
self.addCleanup(os.chmod, "test-unreadable", 0700)
1103
# The error is not raised until the generator is actually evaluated.
1104
# (It would be ok if it happened earlier but at the moment it
1106
e = self.assertRaises(OSError, list, osutils._walkdirs_utf8("."))
1107
self.assertEquals('./test-unreadable', e.filename)
1108
self.assertEquals(errno.EACCES, e.errno)
1109
# Ensure the message contains the file name
1110
self.assertContainsRe(str(e), "\./test-unreadable")
1113
def test_walkdirs_encoding_error(self):
1114
# <https://bugs.launchpad.net/bzr/+bug/488519>
1115
# walkdirs didn't raise a useful message when the filenames
1116
# are not using the filesystem's encoding
1118
# require a bytestring based filesystem
1119
self.requireFeature(features.ByteStringNamedFilesystem)
1130
self.build_tree(tree)
1132
# rename the 1file to a latin-1 filename
1133
os.rename("./1file", "\xe8file")
1134
if "\xe8file" not in os.listdir("."):
1135
self.skip("Lack filesystem that preserves arbitrary bytes")
1137
self._save_platform_info()
1138
win32utils.winver = None # Avoid the win32 detection code
1139
osutils._fs_enc = 'UTF-8'
1141
# this should raise on error
1143
for dirdetail, dirblock in osutils.walkdirs('.'):
1146
self.assertRaises(errors.BadFilenameEncoding, attempt)
1148
def test__walkdirs_utf8(self):
1157
self.build_tree(tree)
1158
expected_dirblocks = [
1160
[('0file', '0file', 'file'),
1161
('1dir', '1dir', 'directory'),
1162
('2file', '2file', 'file'),
1165
(('1dir', './1dir'),
1166
[('1dir/0file', '0file', 'file'),
1167
('1dir/1dir', '1dir', 'directory'),
1170
(('1dir/1dir', './1dir/1dir'),
1176
found_bzrdir = False
1177
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1178
if len(dirblock) and dirblock[0][1] == '.bzr':
1179
# this tests the filtering of selected paths
1182
result.append((dirdetail, dirblock))
1184
self.assertTrue(found_bzrdir)
1185
self.assertExpectedBlocks(expected_dirblocks, result)
1187
# you can search a subdir only, with a supplied prefix.
1189
for dirblock in osutils.walkdirs('./1dir', '1dir'):
1190
result.append(dirblock)
1191
self.assertExpectedBlocks(expected_dirblocks[1:], result)
1193
def _filter_out_stat(self, result):
1194
"""Filter out the stat value from the walkdirs result"""
1195
for dirdetail, dirblock in result:
1197
for info in dirblock:
1198
# Ignore info[3] which is the stat
1199
new_dirblock.append((info[0], info[1], info[2], info[4]))
1200
dirblock[:] = new_dirblock
1202
def _save_platform_info(self):
1203
self.overrideAttr(win32utils, 'winver')
1204
self.overrideAttr(osutils, '_fs_enc')
1205
self.overrideAttr(osutils, '_selected_dir_reader')
1207
def assertDirReaderIs(self, expected):
1208
"""Assert the right implementation for _walkdirs_utf8 is chosen."""
1209
# Force it to redetect
1210
osutils._selected_dir_reader = None
1211
# Nothing to list, but should still trigger the selection logic
1212
self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
1213
self.assertIsInstance(osutils._selected_dir_reader, expected)
1215
def test_force_walkdirs_utf8_fs_utf8(self):
1216
self.requireFeature(UTF8DirReaderFeature)
1217
self._save_platform_info()
1218
win32utils.winver = None # Avoid the win32 detection code
1219
osutils._fs_enc = 'UTF-8'
1220
self.assertDirReaderIs(
1221
UTF8DirReaderFeature.module.UTF8DirReader)
1223
def test_force_walkdirs_utf8_fs_ascii(self):
1224
self.requireFeature(UTF8DirReaderFeature)
1225
self._save_platform_info()
1226
win32utils.winver = None # Avoid the win32 detection code
1227
osutils._fs_enc = 'US-ASCII'
1228
self.assertDirReaderIs(
1229
UTF8DirReaderFeature.module.UTF8DirReader)
1231
def test_force_walkdirs_utf8_fs_ANSI(self):
1232
self.requireFeature(UTF8DirReaderFeature)
1233
self._save_platform_info()
1234
win32utils.winver = None # Avoid the win32 detection code
1235
osutils._fs_enc = 'ANSI_X3.4-1968'
1236
self.assertDirReaderIs(
1237
UTF8DirReaderFeature.module.UTF8DirReader)
1239
def test_force_walkdirs_utf8_fs_latin1(self):
1240
self._save_platform_info()
1241
win32utils.winver = None # Avoid the win32 detection code
1242
osutils._fs_enc = 'latin1'
1243
self.assertDirReaderIs(osutils.UnicodeDirReader)
1245
def test_force_walkdirs_utf8_nt(self):
1246
# Disabled because the thunk of the whole walkdirs api is disabled.
1247
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1248
self._save_platform_info()
1249
win32utils.winver = 'Windows NT'
1250
from bzrlib._walkdirs_win32 import Win32ReadDir
1251
self.assertDirReaderIs(Win32ReadDir)
1253
def test_force_walkdirs_utf8_98(self):
1254
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1255
self._save_platform_info()
1256
win32utils.winver = 'Windows 98'
1257
self.assertDirReaderIs(osutils.UnicodeDirReader)
1259
def test_unicode_walkdirs(self):
1260
"""Walkdirs should always return unicode paths."""
1261
self.requireFeature(features.UnicodeFilenameFeature)
1262
name0 = u'0file-\xb6'
1263
name1 = u'1dir-\u062c\u0648'
1264
name2 = u'2file-\u0633'
1268
name1 + '/' + name0,
1269
name1 + '/' + name1 + '/',
1272
self.build_tree(tree)
1273
expected_dirblocks = [
1275
[(name0, name0, 'file', './' + name0),
1276
(name1, name1, 'directory', './' + name1),
1277
(name2, name2, 'file', './' + name2),
1280
((name1, './' + name1),
1281
[(name1 + '/' + name0, name0, 'file', './' + name1
1283
(name1 + '/' + name1, name1, 'directory', './' + name1
1287
((name1 + '/' + name1, './' + name1 + '/' + name1),
1292
result = list(osutils.walkdirs('.'))
1293
self._filter_out_stat(result)
1294
self.assertEqual(expected_dirblocks, result)
1295
result = list(osutils.walkdirs(u'./'+name1, name1))
1296
self._filter_out_stat(result)
1297
self.assertEqual(expected_dirblocks[1:], result)
1299
def test_unicode__walkdirs_utf8(self):
1300
"""Walkdirs_utf8 should always return utf8 paths.
1302
The abspath portion might be in unicode or utf-8
1304
self.requireFeature(features.UnicodeFilenameFeature)
1305
name0 = u'0file-\xb6'
1306
name1 = u'1dir-\u062c\u0648'
1307
name2 = u'2file-\u0633'
1311
name1 + '/' + name0,
1312
name1 + '/' + name1 + '/',
1315
self.build_tree(tree)
1316
name0 = name0.encode('utf8')
1317
name1 = name1.encode('utf8')
1318
name2 = name2.encode('utf8')
1320
expected_dirblocks = [
1322
[(name0, name0, 'file', './' + name0),
1323
(name1, name1, 'directory', './' + name1),
1324
(name2, name2, 'file', './' + name2),
1327
((name1, './' + name1),
1328
[(name1 + '/' + name0, name0, 'file', './' + name1
1330
(name1 + '/' + name1, name1, 'directory', './' + name1
1334
((name1 + '/' + name1, './' + name1 + '/' + name1),
1340
# For ease in testing, if walkdirs_utf8 returns Unicode, assert that
1341
# all abspaths are Unicode, and encode them back into utf8.
1342
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1343
self.assertIsInstance(dirdetail[0], str)
1344
if isinstance(dirdetail[1], unicode):
1345
dirdetail = (dirdetail[0], dirdetail[1].encode('utf8'))
1346
dirblock = [list(info) for info in dirblock]
1347
for info in dirblock:
1348
self.assertIsInstance(info[4], unicode)
1349
info[4] = info[4].encode('utf8')
1351
for info in dirblock:
1352
self.assertIsInstance(info[0], str)
1353
self.assertIsInstance(info[1], str)
1354
self.assertIsInstance(info[4], str)
1355
# Remove the stat information
1356
new_dirblock.append((info[0], info[1], info[2], info[4]))
1357
result.append((dirdetail, new_dirblock))
1358
self.assertEqual(expected_dirblocks, result)
1360
def test__walkdirs_utf8_with_unicode_fs(self):
1361
"""UnicodeDirReader should be a safe fallback everywhere
1363
The abspath portion should be in unicode
1365
self.requireFeature(features.UnicodeFilenameFeature)
1366
# Use the unicode reader. TODO: split into driver-and-driven unit
1368
self._save_platform_info()
1369
osutils._selected_dir_reader = osutils.UnicodeDirReader()
1370
name0u = u'0file-\xb6'
1371
name1u = u'1dir-\u062c\u0648'
1372
name2u = u'2file-\u0633'
1376
name1u + '/' + name0u,
1377
name1u + '/' + name1u + '/',
1380
self.build_tree(tree)
1381
name0 = name0u.encode('utf8')
1382
name1 = name1u.encode('utf8')
1383
name2 = name2u.encode('utf8')
1385
# All of the abspaths should be in unicode, all of the relative paths
1387
expected_dirblocks = [
1389
[(name0, name0, 'file', './' + name0u),
1390
(name1, name1, 'directory', './' + name1u),
1391
(name2, name2, 'file', './' + name2u),
1394
((name1, './' + name1u),
1395
[(name1 + '/' + name0, name0, 'file', './' + name1u
1397
(name1 + '/' + name1, name1, 'directory', './' + name1u
1401
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1406
result = list(osutils._walkdirs_utf8('.'))
1407
self._filter_out_stat(result)
1408
self.assertEqual(expected_dirblocks, result)
1410
def test__walkdirs_utf8_win32readdir(self):
1411
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1412
self.requireFeature(features.UnicodeFilenameFeature)
1413
from bzrlib._walkdirs_win32 import Win32ReadDir
1414
self._save_platform_info()
1415
osutils._selected_dir_reader = Win32ReadDir()
1416
name0u = u'0file-\xb6'
1417
name1u = u'1dir-\u062c\u0648'
1418
name2u = u'2file-\u0633'
1422
name1u + '/' + name0u,
1423
name1u + '/' + name1u + '/',
1426
self.build_tree(tree)
1427
name0 = name0u.encode('utf8')
1428
name1 = name1u.encode('utf8')
1429
name2 = name2u.encode('utf8')
1431
# All of the abspaths should be in unicode, all of the relative paths
1433
expected_dirblocks = [
1435
[(name0, name0, 'file', './' + name0u),
1436
(name1, name1, 'directory', './' + name1u),
1437
(name2, name2, 'file', './' + name2u),
1440
((name1, './' + name1u),
1441
[(name1 + '/' + name0, name0, 'file', './' + name1u
1443
(name1 + '/' + name1, name1, 'directory', './' + name1u
1447
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1452
result = list(osutils._walkdirs_utf8(u'.'))
1453
self._filter_out_stat(result)
1454
self.assertEqual(expected_dirblocks, result)
1456
def assertStatIsCorrect(self, path, win32stat):
1457
os_stat = os.stat(path)
1458
self.assertEqual(os_stat.st_size, win32stat.st_size)
1459
self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
1460
self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
1461
self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
1462
self.assertEqual(os_stat.st_dev, win32stat.st_dev)
1463
self.assertEqual(os_stat.st_ino, win32stat.st_ino)
1464
self.assertEqual(os_stat.st_mode, win32stat.st_mode)
1466
def test__walkdirs_utf_win32_find_file_stat_file(self):
1467
"""make sure our Stat values are valid"""
1468
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1469
self.requireFeature(features.UnicodeFilenameFeature)
1470
from bzrlib._walkdirs_win32 import Win32ReadDir
1471
name0u = u'0file-\xb6'
1472
name0 = name0u.encode('utf8')
1473
self.build_tree([name0u])
1474
# I hate to sleep() here, but I'm trying to make the ctime different
1477
f = open(name0u, 'ab')
1479
f.write('just a small update')
1483
result = Win32ReadDir().read_dir('', u'.')
1485
self.assertEqual((name0, name0, 'file'), entry[:3])
1486
self.assertEqual(u'./' + name0u, entry[4])
1487
self.assertStatIsCorrect(entry[4], entry[3])
1488
self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
1490
def test__walkdirs_utf_win32_find_file_stat_directory(self):
1491
"""make sure our Stat values are valid"""
1492
self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1493
self.requireFeature(features.UnicodeFilenameFeature)
1494
from bzrlib._walkdirs_win32 import Win32ReadDir
1495
name0u = u'0dir-\u062c\u0648'
1496
name0 = name0u.encode('utf8')
1497
self.build_tree([name0u + '/'])
1499
result = Win32ReadDir().read_dir('', u'.')
1501
self.assertEqual((name0, name0, 'directory'), entry[:3])
1502
self.assertEqual(u'./' + name0u, entry[4])
1503
self.assertStatIsCorrect(entry[4], entry[3])
1505
def assertPathCompare(self, path_less, path_greater):
1506
"""check that path_less and path_greater compare correctly."""
1507
self.assertEqual(0, osutils.compare_paths_prefix_order(
1508
path_less, path_less))
1509
self.assertEqual(0, osutils.compare_paths_prefix_order(
1510
path_greater, path_greater))
1511
self.assertEqual(-1, osutils.compare_paths_prefix_order(
1512
path_less, path_greater))
1513
self.assertEqual(1, osutils.compare_paths_prefix_order(
1514
path_greater, path_less))
1516
def test_compare_paths_prefix_order(self):
1517
# root before all else
1518
self.assertPathCompare("/", "/a")
1519
# alpha within a dir
1520
self.assertPathCompare("/a", "/b")
1521
self.assertPathCompare("/b", "/z")
1522
# high dirs before lower.
1523
self.assertPathCompare("/z", "/a/a")
1524
# except if the deeper dir should be output first
1525
self.assertPathCompare("/a/b/c", "/d/g")
1526
# lexical betwen dirs of the same height
1527
self.assertPathCompare("/a/z", "/z/z")
1528
self.assertPathCompare("/a/c/z", "/a/d/e")
1530
# this should also be consistent for no leading / paths
1531
# root before all else
1532
self.assertPathCompare("", "a")
1533
# alpha within a dir
1534
self.assertPathCompare("a", "b")
1535
self.assertPathCompare("b", "z")
1536
# high dirs before lower.
1537
self.assertPathCompare("z", "a/a")
1538
# except if the deeper dir should be output first
1539
self.assertPathCompare("a/b/c", "d/g")
1540
# lexical betwen dirs of the same height
1541
self.assertPathCompare("a/z", "z/z")
1542
self.assertPathCompare("a/c/z", "a/d/e")
1544
def test_path_prefix_sorting(self):
1545
"""Doing a sort on path prefix should match our sample data."""
1560
dir_sorted_paths = [
1576
sorted(original_paths, key=osutils.path_prefix_key))
1577
# using the comparison routine shoudl work too:
1580
sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
1583
class TestCopyTree(tests.TestCaseInTempDir):
1585
def test_copy_basic_tree(self):
1586
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1587
osutils.copy_tree('source', 'target')
1588
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1589
self.assertEqual(['c'], os.listdir('target/b'))
1591
def test_copy_tree_target_exists(self):
1592
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c',
1594
osutils.copy_tree('source', 'target')
1595
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1596
self.assertEqual(['c'], os.listdir('target/b'))
1598
def test_copy_tree_symlinks(self):
1599
self.requireFeature(features.SymlinkFeature)
1600
self.build_tree(['source/'])
1601
os.symlink('a/generic/path', 'source/lnk')
1602
osutils.copy_tree('source', 'target')
1603
self.assertEqual(['lnk'], os.listdir('target'))
1604
self.assertEqual('a/generic/path', os.readlink('target/lnk'))
1606
def test_copy_tree_handlers(self):
1607
processed_files = []
1608
processed_links = []
1609
def file_handler(from_path, to_path):
1610
processed_files.append(('f', from_path, to_path))
1611
def dir_handler(from_path, to_path):
1612
processed_files.append(('d', from_path, to_path))
1613
def link_handler(from_path, to_path):
1614
processed_links.append((from_path, to_path))
1615
handlers = {'file':file_handler,
1616
'directory':dir_handler,
1617
'symlink':link_handler,
1620
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1621
if osutils.has_symlinks():
1622
os.symlink('a/generic/path', 'source/lnk')
1623
osutils.copy_tree('source', 'target', handlers=handlers)
1625
self.assertEqual([('d', 'source', 'target'),
1626
('f', 'source/a', 'target/a'),
1627
('d', 'source/b', 'target/b'),
1628
('f', 'source/b/c', 'target/b/c'),
1630
self.assertPathDoesNotExist('target')
1631
if osutils.has_symlinks():
1632
self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1635
class TestSetUnsetEnv(tests.TestCase):
1636
"""Test updating the environment"""
1639
super(TestSetUnsetEnv, self).setUp()
1641
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
1642
'Environment was not cleaned up properly.'
1643
' Variable BZR_TEST_ENV_VAR should not exist.')
1645
if 'BZR_TEST_ENV_VAR' in os.environ:
1646
del os.environ['BZR_TEST_ENV_VAR']
1647
self.addCleanup(cleanup)
1650
"""Test that we can set an env variable"""
1651
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1652
self.assertEqual(None, old)
1653
self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
1655
def test_double_set(self):
1656
"""Test that we get the old value out"""
1657
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1658
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
1659
self.assertEqual('foo', old)
1660
self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
1662
def test_unicode(self):
1663
"""Environment can only contain plain strings
1665
So Unicode strings must be encoded.
1667
uni_val, env_val = tests.probe_unicode_in_user_encoding()
1669
raise tests.TestSkipped(
1670
'Cannot find a unicode character that works in encoding %s'
1671
% (osutils.get_user_encoding(),))
1673
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1674
self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
1676
def test_unset(self):
1677
"""Test that passing None will remove the env var"""
1678
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1679
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1680
self.assertEqual('foo', old)
1681
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1682
self.assertFalse('BZR_TEST_ENV_VAR' in os.environ)
1685
class TestSizeShaFile(tests.TestCaseInTempDir):
1687
def test_sha_empty(self):
1688
self.build_tree_contents([('foo', '')])
1689
expected_sha = osutils.sha_string('')
1691
self.addCleanup(f.close)
1692
size, sha = osutils.size_sha_file(f)
1693
self.assertEqual(0, size)
1694
self.assertEqual(expected_sha, sha)
1696
def test_sha_mixed_endings(self):
1697
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1698
self.build_tree_contents([('foo', text)])
1699
expected_sha = osutils.sha_string(text)
1700
f = open('foo', 'rb')
1701
self.addCleanup(f.close)
1702
size, sha = osutils.size_sha_file(f)
1703
self.assertEqual(38, size)
1704
self.assertEqual(expected_sha, sha)
1707
class TestShaFileByName(tests.TestCaseInTempDir):
1709
def test_sha_empty(self):
1710
self.build_tree_contents([('foo', '')])
1711
expected_sha = osutils.sha_string('')
1712
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1714
def test_sha_mixed_endings(self):
1715
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1716
self.build_tree_contents([('foo', text)])
1717
expected_sha = osutils.sha_string(text)
1718
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1721
class TestResourceLoading(tests.TestCaseInTempDir):
1723
def test_resource_string(self):
1724
# test resource in bzrlib
1725
text = osutils.resource_string('bzrlib', 'debug.py')
1726
self.assertContainsRe(text, "debug_flags = set()")
1727
# test resource under bzrlib
1728
text = osutils.resource_string('bzrlib.ui', 'text.py')
1729
self.assertContainsRe(text, "class TextUIFactory")
1730
# test unsupported package
1731
self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1733
# test unknown resource
1734
self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1737
class TestReCompile(tests.TestCase):
1739
def _deprecated_re_compile_checked(self, *args, **kwargs):
1740
return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
1741
osutils.re_compile_checked, *args, **kwargs)
1743
def test_re_compile_checked(self):
1744
r = self._deprecated_re_compile_checked(r'A*', re.IGNORECASE)
1745
self.assertTrue(r.match('aaaa'))
1746
self.assertTrue(r.match('aAaA'))
1748
def test_re_compile_checked_error(self):
1749
# like https://bugs.launchpad.net/bzr/+bug/251352
1751
# Due to possible test isolation error, re.compile is not lazy at
1752
# this point. We re-install lazy compile.
1753
lazy_regex.install_lazy_compile()
1754
err = self.assertRaises(
1755
errors.BzrCommandError,
1756
self._deprecated_re_compile_checked, '*', re.IGNORECASE, 'test case')
1758
'Invalid regular expression in test case: '
1759
'"*" nothing to repeat',
1763
class TestDirReader(tests.TestCaseInTempDir):
1765
scenarios = dir_reader_scenarios()
1768
_dir_reader_class = None
1769
_native_to_unicode = None
1772
tests.TestCaseInTempDir.setUp(self)
1773
self.overrideAttr(osutils,
1774
'_selected_dir_reader', self._dir_reader_class())
1776
def _get_ascii_tree(self):
1784
expected_dirblocks = [
1786
[('0file', '0file', 'file'),
1787
('1dir', '1dir', 'directory'),
1788
('2file', '2file', 'file'),
1791
(('1dir', './1dir'),
1792
[('1dir/0file', '0file', 'file'),
1793
('1dir/1dir', '1dir', 'directory'),
1796
(('1dir/1dir', './1dir/1dir'),
1801
return tree, expected_dirblocks
1803
def test_walk_cur_dir(self):
1804
tree, expected_dirblocks = self._get_ascii_tree()
1805
self.build_tree(tree)
1806
result = list(osutils._walkdirs_utf8('.'))
1807
# Filter out stat and abspath
1808
self.assertEqual(expected_dirblocks,
1809
[(dirinfo, [line[0:3] for line in block])
1810
for dirinfo, block in result])
1812
def test_walk_sub_dir(self):
1813
tree, expected_dirblocks = self._get_ascii_tree()
1814
self.build_tree(tree)
1815
# you can search a subdir only, with a supplied prefix.
1816
result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1817
# Filter out stat and abspath
1818
self.assertEqual(expected_dirblocks[1:],
1819
[(dirinfo, [line[0:3] for line in block])
1820
for dirinfo, block in result])
1822
def _get_unicode_tree(self):
1823
name0u = u'0file-\xb6'
1824
name1u = u'1dir-\u062c\u0648'
1825
name2u = u'2file-\u0633'
1829
name1u + '/' + name0u,
1830
name1u + '/' + name1u + '/',
1833
name0 = name0u.encode('UTF-8')
1834
name1 = name1u.encode('UTF-8')
1835
name2 = name2u.encode('UTF-8')
1836
expected_dirblocks = [
1838
[(name0, name0, 'file', './' + name0u),
1839
(name1, name1, 'directory', './' + name1u),
1840
(name2, name2, 'file', './' + name2u),
1843
((name1, './' + name1u),
1844
[(name1 + '/' + name0, name0, 'file', './' + name1u
1846
(name1 + '/' + name1, name1, 'directory', './' + name1u
1850
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1855
return tree, expected_dirblocks
1857
def _filter_out(self, raw_dirblocks):
1858
"""Filter out a walkdirs_utf8 result.
1860
stat field is removed, all native paths are converted to unicode
1862
filtered_dirblocks = []
1863
for dirinfo, block in raw_dirblocks:
1864
dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1867
details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1868
filtered_dirblocks.append((dirinfo, details))
1869
return filtered_dirblocks
1871
def test_walk_unicode_tree(self):
1872
self.requireFeature(features.UnicodeFilenameFeature)
1873
tree, expected_dirblocks = self._get_unicode_tree()
1874
self.build_tree(tree)
1875
result = list(osutils._walkdirs_utf8('.'))
1876
self.assertEqual(expected_dirblocks, self._filter_out(result))
1878
def test_symlink(self):
1879
self.requireFeature(features.SymlinkFeature)
1880
self.requireFeature(features.UnicodeFilenameFeature)
1881
target = u'target\N{Euro Sign}'
1882
link_name = u'l\N{Euro Sign}nk'
1883
os.symlink(target, link_name)
1884
target_utf8 = target.encode('UTF-8')
1885
link_name_utf8 = link_name.encode('UTF-8')
1886
expected_dirblocks = [
1888
[(link_name_utf8, link_name_utf8,
1889
'symlink', './' + link_name),],
1891
result = list(osutils._walkdirs_utf8('.'))
1892
self.assertEqual(expected_dirblocks, self._filter_out(result))
1895
class TestReadLink(tests.TestCaseInTempDir):
1896
"""Exposes os.readlink() problems and the osutils solution.
1898
The only guarantee offered by os.readlink(), starting with 2.6, is that a
1899
unicode string will be returned if a unicode string is passed.
1901
But prior python versions failed to properly encode the passed unicode
1904
_test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]
1907
super(tests.TestCaseInTempDir, self).setUp()
1908
self.link = u'l\N{Euro Sign}ink'
1909
self.target = u'targe\N{Euro Sign}t'
1910
os.symlink(self.target, self.link)
1912
def test_os_readlink_link_encoding(self):
1913
self.assertEquals(self.target, os.readlink(self.link))
1915
def test_os_readlink_link_decoding(self):
1916
self.assertEquals(self.target.encode(osutils._fs_enc),
1917
os.readlink(self.link.encode(osutils._fs_enc)))
1920
class TestConcurrency(tests.TestCase):
1923
super(TestConcurrency, self).setUp()
1924
self.overrideAttr(osutils, '_cached_local_concurrency')
1926
def test_local_concurrency(self):
1927
concurrency = osutils.local_concurrency()
1928
self.assertIsInstance(concurrency, int)
1930
def test_local_concurrency_environment_variable(self):
1931
self.overrideEnv('BZR_CONCURRENCY', '2')
1932
self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1933
self.overrideEnv('BZR_CONCURRENCY', '3')
1934
self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1935
self.overrideEnv('BZR_CONCURRENCY', 'foo')
1936
self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1938
def test_option_concurrency(self):
1939
self.overrideEnv('BZR_CONCURRENCY', '1')
1940
self.run_bzr('rocks --concurrency 42')
1941
# Command line overrides environment variable
1942
self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1943
self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1946
class TestFailedToLoadExtension(tests.TestCase):
1948
def _try_loading(self):
1950
import bzrlib._fictional_extension_py
1951
except ImportError, e:
1952
osutils.failed_to_load_extension(e)
1956
super(TestFailedToLoadExtension, self).setUp()
1957
self.overrideAttr(osutils, '_extension_load_failures', [])
1959
def test_failure_to_load(self):
1961
self.assertLength(1, osutils._extension_load_failures)
1962
self.assertEquals(osutils._extension_load_failures[0],
1963
"No module named _fictional_extension_py")
1965
def test_report_extension_load_failures_no_warning(self):
1966
self.assertTrue(self._try_loading())
1967
warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
1968
# it used to give a Python warning; it no longer does
1969
self.assertLength(0, warnings)
1971
def test_report_extension_load_failures_message(self):
1973
trace.push_log_file(log)
1974
self.assertTrue(self._try_loading())
1975
osutils.report_extension_load_failures()
1976
self.assertContainsRe(
1978
r"bzr: warning: some compiled extensions could not be loaded; "
1979
"see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1983
class TestTerminalWidth(tests.TestCase):
1986
tests.TestCase.setUp(self)
1987
self._orig_terminal_size_state = osutils._terminal_size_state
1988
self._orig_first_terminal_size = osutils._first_terminal_size
1989
self.addCleanup(self.restore_osutils_globals)
1990
osutils._terminal_size_state = 'no_data'
1991
osutils._first_terminal_size = None
1993
def restore_osutils_globals(self):
1994
osutils._terminal_size_state = self._orig_terminal_size_state
1995
osutils._first_terminal_size = self._orig_first_terminal_size
1997
def replace_stdout(self, new):
1998
self.overrideAttr(sys, 'stdout', new)
2000
def replace__terminal_size(self, new):
2001
self.overrideAttr(osutils, '_terminal_size', new)
2003
def set_fake_tty(self):
2005
class I_am_a_tty(object):
2009
self.replace_stdout(I_am_a_tty())
2011
def test_default_values(self):
2012
self.assertEqual(80, osutils.default_terminal_width)
2014
def test_defaults_to_BZR_COLUMNS(self):
2015
# BZR_COLUMNS is set by the test framework
2016
self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
2017
self.overrideEnv('BZR_COLUMNS', '12')
2018
self.assertEqual(12, osutils.terminal_width())
2020
def test_BZR_COLUMNS_0_no_limit(self):
2021
self.overrideEnv('BZR_COLUMNS', '0')
2022
self.assertEqual(None, osutils.terminal_width())
2024
def test_falls_back_to_COLUMNS(self):
2025
self.overrideEnv('BZR_COLUMNS', None)
2026
self.assertNotEqual('42', os.environ['COLUMNS'])
2028
self.overrideEnv('COLUMNS', '42')
2029
self.assertEqual(42, osutils.terminal_width())
2031
def test_tty_default_without_columns(self):
2032
self.overrideEnv('BZR_COLUMNS', None)
2033
self.overrideEnv('COLUMNS', None)
2035
def terminal_size(w, h):
2039
# We need to override the osutils definition as it depends on the
2040
# running environment that we can't control (PQM running without a
2041
# controlling terminal is one example).
2042
self.replace__terminal_size(terminal_size)
2043
self.assertEqual(42, osutils.terminal_width())
2045
def test_non_tty_default_without_columns(self):
2046
self.overrideEnv('BZR_COLUMNS', None)
2047
self.overrideEnv('COLUMNS', None)
2048
self.replace_stdout(None)
2049
self.assertEqual(None, osutils.terminal_width())
2051
def test_no_TIOCGWINSZ(self):
2052
self.requireFeature(term_ios_feature)
2053
termios = term_ios_feature.module
2054
# bug 63539 is about a termios without TIOCGWINSZ attribute
2056
orig = termios.TIOCGWINSZ
2057
except AttributeError:
2058
# We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
2061
self.overrideAttr(termios, 'TIOCGWINSZ')
2062
del termios.TIOCGWINSZ
2063
self.overrideEnv('BZR_COLUMNS', None)
2064
self.overrideEnv('COLUMNS', None)
2065
# Whatever the result is, if we don't raise an exception, it's ok.
2066
osutils.terminal_width()
2069
class TestCreationOps(tests.TestCaseInTempDir):
2070
_test_needs_features = [features.chown_feature]
2073
tests.TestCaseInTempDir.setUp(self)
2074
self.overrideAttr(os, 'chown', self._dummy_chown)
2076
# params set by call to _dummy_chown
2077
self.path = self.uid = self.gid = None
2079
def _dummy_chown(self, path, uid, gid):
2080
self.path, self.uid, self.gid = path, uid, gid
2082
def test_copy_ownership_from_path(self):
2083
"""copy_ownership_from_path test with specified src."""
2085
f = open('test_file', 'wt')
2086
osutils.copy_ownership_from_path('test_file', ownsrc)
2089
self.assertEquals(self.path, 'test_file')
2090
self.assertEquals(self.uid, s.st_uid)
2091
self.assertEquals(self.gid, s.st_gid)
2093
def test_copy_ownership_nonesrc(self):
2094
"""copy_ownership_from_path test with src=None."""
2095
f = open('test_file', 'wt')
2096
# should use parent dir for permissions
2097
osutils.copy_ownership_from_path('test_file')
2100
self.assertEquals(self.path, 'test_file')
2101
self.assertEquals(self.uid, s.st_uid)
2102
self.assertEquals(self.gid, s.st_gid)
2105
class TestGetuserUnicode(tests.TestCase):
2107
def test_ascii_user(self):
2108
self.overrideEnv('LOGNAME', 'jrandom')
2109
self.assertEqual(u'jrandom', osutils.getuser_unicode())
2111
def test_unicode_user(self):
2112
ue = osutils.get_user_encoding()
2113
uni_val, env_val = tests.probe_unicode_in_user_encoding()
2115
raise tests.TestSkipped(
2116
'Cannot find a unicode character that works in encoding %s'
2117
% (osutils.get_user_encoding(),))
2118
uni_username = u'jrandom' + uni_val
2119
encoded_username = uni_username.encode(ue)
2120
self.overrideEnv('LOGNAME', encoded_username)
2121
self.assertEqual(uni_username, osutils.getuser_unicode())
2122
self.overrideEnv('LOGNAME', u'jrandom\xb6'.encode(ue))
2123
self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())
2125
def test_no_username_bug_660174(self):
2126
self.requireFeature(features.win32_feature)
2127
for name in ('LOGNAME', 'USER', 'LNAME', 'USERNAME'):
2128
self.overrideEnv(name, None)
2129
self.assertEqual(u'UNKNOWN', osutils.getuser_unicode())
2132
class TestBackupNames(tests.TestCase):
2135
super(TestBackupNames, self).setUp()
2138
def backup_exists(self, name):
2139
return name in self.backups
2141
def available_backup_name(self, name):
2142
backup_name = osutils.available_backup_name(name, self.backup_exists)
2143
self.backups.append(backup_name)
2146
def assertBackupName(self, expected, name):
2147
self.assertEqual(expected, self.available_backup_name(name))
2149
def test_empty(self):
2150
self.assertBackupName('file.~1~', 'file')
2152
def test_existing(self):
2153
self.available_backup_name('file')
2154
self.available_backup_name('file')
2155
self.assertBackupName('file.~3~', 'file')
2156
# Empty slots are found, this is not a strict requirement and may be
2157
# revisited if we test against all implementations.
2158
self.backups.remove('file.~2~')
2159
self.assertBackupName('file.~2~', 'file')
2162
class TestFindExecutableInPath(tests.TestCase):
2164
def test_windows(self):
2165
if sys.platform != 'win32':
2166
raise tests.TestSkipped('test requires win32')
2167
self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
2169
osutils.find_executable_on_path('explorer.exe') is not None)
2171
osutils.find_executable_on_path('EXPLORER.EXE') is not None)
2173
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2174
self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2176
def test_other(self):
2177
if sys.platform == 'win32':
2178
raise tests.TestSkipped('test requires non-win32')
2179
self.assertTrue(osutils.find_executable_on_path('sh') is not None)
2181
osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
added
removed
bzrlib/tests/test_osutils.py
