1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""Tests for the osutils wrapper."""
19
from cStringIO import StringIO
33
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
34
from bzrlib.osutils import (
36
is_inside_or_parent_of_any,
42
from bzrlib.tests import (
44
probe_unicode_in_user_encoding,
47
CaseInsCasePresFilenameFeature,
52
from bzrlib.tests.file_utils import (
55
from bzrlib.tests.test__walkdirs_win32 import Win32ReadDirFeature
58
class _UTF8DirReaderFeature(Feature):
62
from bzrlib import _readdir_pyx
63
self.reader = _readdir_pyx.UTF8DirReader
68
def feature_name(self):
69
return 'bzrlib._readdir_pyx'
71
UTF8DirReaderFeature = _UTF8DirReaderFeature()
74
class TestOSUtils(TestCaseInTempDir):
76
def test_contains_whitespace(self):
77
self.failUnless(osutils.contains_whitespace(u' '))
78
self.failUnless(osutils.contains_whitespace(u'hello there'))
79
self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
80
self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
81
self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
82
self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
84
# \xa0 is "Non-breaking-space" which on some python locales thinks it
85
# is whitespace, but we do not.
86
self.failIf(osutils.contains_whitespace(u''))
87
self.failIf(osutils.contains_whitespace(u'hellothere'))
88
self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
90
def test_fancy_rename(self):
91
# This should work everywhere
93
osutils.fancy_rename(a, b,
94
rename_func=os.rename,
95
unlink_func=os.unlink)
97
open('a', 'wb').write('something in a\n')
99
self.failIfExists('a')
100
self.failUnlessExists('b')
101
self.check_file_contents('b', 'something in a\n')
103
open('a', 'wb').write('new something in a\n')
106
self.check_file_contents('a', 'something in a\n')
108
def test_rename(self):
109
# Rename should be semi-atomic on all platforms
110
open('a', 'wb').write('something in a\n')
111
osutils.rename('a', 'b')
112
self.failIfExists('a')
113
self.failUnlessExists('b')
114
self.check_file_contents('b', 'something in a\n')
116
open('a', 'wb').write('new something in a\n')
117
osutils.rename('b', 'a')
119
self.check_file_contents('a', 'something in a\n')
121
# TODO: test fancy_rename using a MemoryTransport
123
def test_rename_change_case(self):
124
# on Windows we should be able to change filename case by rename
125
self.build_tree(['a', 'b/'])
126
osutils.rename('a', 'A')
127
osutils.rename('b', 'B')
128
# we can't use failUnlessExists on case-insensitive filesystem
129
# so try to check shape of the tree
130
shape = sorted(os.listdir('.'))
131
self.assertEquals(['A', 'B'], shape)
133
def test_01_rand_chars_empty(self):
134
result = osutils.rand_chars(0)
135
self.assertEqual(result, '')
137
def test_02_rand_chars_100(self):
138
result = osutils.rand_chars(100)
139
self.assertEqual(len(result), 100)
140
self.assertEqual(type(result), str)
141
self.assertContainsRe(result, r'^[a-z0-9]{100}$')
143
def test_is_inside(self):
144
is_inside = osutils.is_inside
145
self.assertTrue(is_inside('src', 'src/foo.c'))
146
self.assertFalse(is_inside('src', 'srccontrol'))
147
self.assertTrue(is_inside('src', 'src/a/a/a/foo.c'))
148
self.assertTrue(is_inside('foo.c', 'foo.c'))
149
self.assertFalse(is_inside('foo.c', ''))
150
self.assertTrue(is_inside('', 'foo.c'))
152
def test_is_inside_any(self):
153
SRC_FOO_C = pathjoin('src', 'foo.c')
154
for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
155
(['src'], SRC_FOO_C),
158
self.assert_(is_inside_any(dirs, fn))
159
for dirs, fn in [(['src'], 'srccontrol'),
160
(['src'], 'srccontrol/foo')]:
161
self.assertFalse(is_inside_any(dirs, fn))
163
def test_is_inside_or_parent_of_any(self):
164
for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
165
(['src'], 'src/foo.c'),
166
(['src/bar.c'], 'src'),
167
(['src/bar.c', 'bla/foo.c'], 'src'),
170
self.assert_(is_inside_or_parent_of_any(dirs, fn))
172
for dirs, fn in [(['src'], 'srccontrol'),
173
(['srccontrol/foo.c'], 'src'),
174
(['src'], 'srccontrol/foo')]:
175
self.assertFalse(is_inside_or_parent_of_any(dirs, fn))
177
def test_rmtree(self):
178
# Check to remove tree with read-only files/dirs
180
f = file('dir/file', 'w')
183
# would like to also try making the directory readonly, but at the
184
# moment python shutil.rmtree doesn't handle that properly - it would
185
# need to chmod the directory before removing things inside it - deferred
186
# for now -- mbp 20060505
187
# osutils.make_readonly('dir')
188
osutils.make_readonly('dir/file')
190
osutils.rmtree('dir')
192
self.failIfExists('dir/file')
193
self.failIfExists('dir')
195
def test_file_kind(self):
196
self.build_tree(['file', 'dir/'])
197
self.assertEquals('file', osutils.file_kind('file'))
198
self.assertEquals('directory', osutils.file_kind('dir/'))
199
if osutils.has_symlinks():
200
os.symlink('symlink', 'symlink')
201
self.assertEquals('symlink', osutils.file_kind('symlink'))
203
# TODO: jam 20060529 Test a block device
205
os.lstat('/dev/null')
207
if e.errno not in (errno.ENOENT,):
210
self.assertEquals('chardev', osutils.file_kind('/dev/null'))
212
mkfifo = getattr(os, 'mkfifo', None)
216
self.assertEquals('fifo', osutils.file_kind('fifo'))
220
AF_UNIX = getattr(socket, 'AF_UNIX', None)
222
s = socket.socket(AF_UNIX)
225
self.assertEquals('socket', osutils.file_kind('socket'))
229
def test_kind_marker(self):
230
self.assertEqual(osutils.kind_marker('file'), '')
231
self.assertEqual(osutils.kind_marker('directory'), '/')
232
self.assertEqual(osutils.kind_marker('symlink'), '@')
233
self.assertEqual(osutils.kind_marker('tree-reference'), '+')
235
def test_get_umask(self):
236
if sys.platform == 'win32':
237
# umask always returns '0', no way to set it
238
self.assertEqual(0, osutils.get_umask())
241
orig_umask = osutils.get_umask()
244
self.assertEqual(0222, osutils.get_umask())
246
self.assertEqual(0022, osutils.get_umask())
248
self.assertEqual(0002, osutils.get_umask())
250
self.assertEqual(0027, osutils.get_umask())
254
def assertFormatedDelta(self, expected, seconds):
255
"""Assert osutils.format_delta formats as expected"""
256
actual = osutils.format_delta(seconds)
257
self.assertEqual(expected, actual)
259
def test_format_delta(self):
260
self.assertFormatedDelta('0 seconds ago', 0)
261
self.assertFormatedDelta('1 second ago', 1)
262
self.assertFormatedDelta('10 seconds ago', 10)
263
self.assertFormatedDelta('59 seconds ago', 59)
264
self.assertFormatedDelta('89 seconds ago', 89)
265
self.assertFormatedDelta('1 minute, 30 seconds ago', 90)
266
self.assertFormatedDelta('3 minutes, 0 seconds ago', 180)
267
self.assertFormatedDelta('3 minutes, 1 second ago', 181)
268
self.assertFormatedDelta('10 minutes, 15 seconds ago', 615)
269
self.assertFormatedDelta('30 minutes, 59 seconds ago', 1859)
270
self.assertFormatedDelta('31 minutes, 0 seconds ago', 1860)
271
self.assertFormatedDelta('60 minutes, 0 seconds ago', 3600)
272
self.assertFormatedDelta('89 minutes, 59 seconds ago', 5399)
273
self.assertFormatedDelta('1 hour, 30 minutes ago', 5400)
274
self.assertFormatedDelta('2 hours, 30 minutes ago', 9017)
275
self.assertFormatedDelta('10 hours, 0 minutes ago', 36000)
276
self.assertFormatedDelta('24 hours, 0 minutes ago', 86400)
277
self.assertFormatedDelta('35 hours, 59 minutes ago', 129599)
278
self.assertFormatedDelta('36 hours, 0 minutes ago', 129600)
279
self.assertFormatedDelta('36 hours, 0 minutes ago', 129601)
280
self.assertFormatedDelta('36 hours, 1 minute ago', 129660)
281
self.assertFormatedDelta('36 hours, 1 minute ago', 129661)
282
self.assertFormatedDelta('84 hours, 10 minutes ago', 303002)
284
# We handle when time steps the wrong direction because computers
285
# don't have synchronized clocks.
286
self.assertFormatedDelta('84 hours, 10 minutes in the future', -303002)
287
self.assertFormatedDelta('1 second in the future', -1)
288
self.assertFormatedDelta('2 seconds in the future', -2)
290
def test_format_date(self):
291
self.assertRaises(errors.UnsupportedTimezoneFormat,
292
osutils.format_date, 0, timezone='foo')
293
self.assertIsInstance(osutils.format_date(0), str)
294
self.assertIsInstance(osutils.format_local_date(0), unicode)
295
# Testing for the actual value of the local weekday without
296
# duplicating the code from format_date is difficult.
297
# Instead blackbox.test_locale should check for localized
298
# dates once they do occur in output strings.
300
def test_dereference_path(self):
301
self.requireFeature(SymlinkFeature)
302
cwd = osutils.realpath('.')
304
bar_path = osutils.pathjoin(cwd, 'bar')
305
# Using './' to avoid bug #1213894 (first path component not
306
# dereferenced) in Python 2.4.1 and earlier
307
self.assertEqual(bar_path, osutils.realpath('./bar'))
308
os.symlink('bar', 'foo')
309
self.assertEqual(bar_path, osutils.realpath('./foo'))
311
# Does not dereference terminal symlinks
312
foo_path = osutils.pathjoin(cwd, 'foo')
313
self.assertEqual(foo_path, osutils.dereference_path('./foo'))
315
# Dereferences parent symlinks
317
baz_path = osutils.pathjoin(bar_path, 'baz')
318
self.assertEqual(baz_path, osutils.dereference_path('./foo/baz'))
320
# Dereferences parent symlinks that are the first path element
321
self.assertEqual(baz_path, osutils.dereference_path('foo/baz'))
323
# Dereferences parent symlinks in absolute paths
324
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
325
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
327
def test_changing_access(self):
328
f = file('file', 'w')
332
# Make a file readonly
333
osutils.make_readonly('file')
334
mode = os.lstat('file').st_mode
335
self.assertEqual(mode, mode & 0777555)
337
# Make a file writable
338
osutils.make_writable('file')
339
mode = os.lstat('file').st_mode
340
self.assertEqual(mode, mode | 0200)
342
if osutils.has_symlinks():
343
# should not error when handed a symlink
344
os.symlink('nonexistent', 'dangling')
345
osutils.make_readonly('dangling')
346
osutils.make_writable('dangling')
348
def test_kind_marker(self):
349
self.assertEqual("", osutils.kind_marker("file"))
350
self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
351
self.assertEqual("@", osutils.kind_marker("symlink"))
352
self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
354
def test_host_os_dereferences_symlinks(self):
355
osutils.host_os_dereferences_symlinks()
358
class TestCanonicalRelPath(TestCaseInTempDir):
360
_test_needs_features = [CaseInsCasePresFilenameFeature]
362
def test_canonical_relpath_simple(self):
363
f = file('MixedCaseName', 'w')
365
self.failUnlessEqual(
366
canonical_relpath(self.test_base_dir, 'mixedcasename'),
367
'work/MixedCaseName')
369
def test_canonical_relpath_missing_tail(self):
370
os.mkdir('MixedCaseParent')
371
self.failUnlessEqual(
372
canonical_relpath(self.test_base_dir, 'mixedcaseparent/nochild'),
373
'work/MixedCaseParent/nochild')
376
class TestPumpFile(TestCase):
377
"""Test pumpfile method."""
380
# create a test datablock
381
self.block_size = 512
382
pattern = '0123456789ABCDEF'
383
self.test_data = pattern * (3 * self.block_size / len(pattern))
384
self.test_data_len = len(self.test_data)
386
def test_bracket_block_size(self):
387
"""Read data in blocks with the requested read size bracketing the
389
# make sure test data is larger than max read size
390
self.assertTrue(self.test_data_len > self.block_size)
392
from_file = FakeReadFile(self.test_data)
395
# read (max / 2) bytes and verify read size wasn't affected
396
num_bytes_to_read = self.block_size / 2
397
pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
398
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
399
self.assertEqual(from_file.get_read_count(), 1)
401
# read (max) bytes and verify read size wasn't affected
402
num_bytes_to_read = self.block_size
403
from_file.reset_read_count()
404
pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
405
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
406
self.assertEqual(from_file.get_read_count(), 1)
408
# read (max + 1) bytes and verify read size was limited
409
num_bytes_to_read = self.block_size + 1
410
from_file.reset_read_count()
411
pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
412
self.assertEqual(from_file.get_max_read_size(), self.block_size)
413
self.assertEqual(from_file.get_read_count(), 2)
415
# finish reading the rest of the data
416
num_bytes_to_read = self.test_data_len - to_file.tell()
417
pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
419
# report error if the data wasn't equal (we only report the size due
420
# to the length of the data)
421
response_data = to_file.getvalue()
422
if response_data != self.test_data:
423
message = "Data not equal. Expected %d bytes, received %d."
424
self.fail(message % (len(response_data), self.test_data_len))
426
def test_specified_size(self):
427
"""Request a transfer larger than the maximum block size and verify
428
that the maximum read doesn't exceed the block_size."""
429
# make sure test data is larger than max read size
430
self.assertTrue(self.test_data_len > self.block_size)
432
# retrieve data in blocks
433
from_file = FakeReadFile(self.test_data)
435
pumpfile(from_file, to_file, self.test_data_len, self.block_size)
437
# verify read size was equal to the maximum read size
438
self.assertTrue(from_file.get_max_read_size() > 0)
439
self.assertEqual(from_file.get_max_read_size(), self.block_size)
440
self.assertEqual(from_file.get_read_count(), 3)
442
# report error if the data wasn't equal (we only report the size due
443
# to the length of the data)
444
response_data = to_file.getvalue()
445
if response_data != self.test_data:
446
message = "Data not equal. Expected %d bytes, received %d."
447
self.fail(message % (len(response_data), self.test_data_len))
449
def test_to_eof(self):
450
"""Read to end-of-file and verify that the reads are not larger than
451
the maximum read size."""
452
# make sure test data is larger than max read size
453
self.assertTrue(self.test_data_len > self.block_size)
455
# retrieve data to EOF
456
from_file = FakeReadFile(self.test_data)
458
pumpfile(from_file, to_file, -1, self.block_size)
460
# verify read size was equal to the maximum read size
461
self.assertEqual(from_file.get_max_read_size(), self.block_size)
462
self.assertEqual(from_file.get_read_count(), 4)
464
# report error if the data wasn't equal (we only report the size due
465
# to the length of the data)
466
response_data = to_file.getvalue()
467
if response_data != self.test_data:
468
message = "Data not equal. Expected %d bytes, received %d."
469
self.fail(message % (len(response_data), self.test_data_len))
471
def test_defaults(self):
472
"""Verifies that the default arguments will read to EOF -- this
473
test verifies that any existing usages of pumpfile will not be broken
474
with this new version."""
475
# retrieve data using default (old) pumpfile method
476
from_file = FakeReadFile(self.test_data)
478
pumpfile(from_file, to_file)
480
# report error if the data wasn't equal (we only report the size due
481
# to the length of the data)
482
response_data = to_file.getvalue()
483
if response_data != self.test_data:
484
message = "Data not equal. Expected %d bytes, received %d."
485
self.fail(message % (len(response_data), self.test_data_len))
487
def test_report_activity(self):
489
def log_activity(length, direction):
490
activity.append((length, direction))
491
from_file = StringIO(self.test_data)
493
pumpfile(from_file, to_file, buff_size=500,
494
report_activity=log_activity, direction='read')
495
self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
496
(36, 'read')], activity)
498
from_file = StringIO(self.test_data)
501
pumpfile(from_file, to_file, buff_size=500,
502
report_activity=log_activity, direction='write')
503
self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
504
(36, 'write')], activity)
506
# And with a limited amount of data
507
from_file = StringIO(self.test_data)
510
pumpfile(from_file, to_file, buff_size=500, read_length=1028,
511
report_activity=log_activity, direction='read')
512
self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
516
class TestPumpStringFile(TestCase):
518
def test_empty(self):
520
pump_string_file("", output)
521
self.assertEqual("", output.getvalue())
523
def test_more_than_segment_size(self):
525
pump_string_file("123456789", output, 2)
526
self.assertEqual("123456789", output.getvalue())
528
def test_segment_size(self):
530
pump_string_file("12", output, 2)
531
self.assertEqual("12", output.getvalue())
533
def test_segment_size_multiple(self):
535
pump_string_file("1234", output, 2)
536
self.assertEqual("1234", output.getvalue())
539
class TestSafeUnicode(TestCase):
541
def test_from_ascii_string(self):
542
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
544
def test_from_unicode_string_ascii_contents(self):
545
self.assertEqual(u'bargam', osutils.safe_unicode(u'bargam'))
547
def test_from_unicode_string_unicode_contents(self):
548
self.assertEqual(u'bargam\xae', osutils.safe_unicode(u'bargam\xae'))
550
def test_from_utf8_string(self):
551
self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
553
def test_bad_utf8_string(self):
554
self.assertRaises(BzrBadParameterNotUnicode,
555
osutils.safe_unicode,
559
class TestSafeUtf8(TestCase):
561
def test_from_ascii_string(self):
563
self.assertEqual('foobar', osutils.safe_utf8(f))
565
def test_from_unicode_string_ascii_contents(self):
566
self.assertEqual('bargam', osutils.safe_utf8(u'bargam'))
568
def test_from_unicode_string_unicode_contents(self):
569
self.assertEqual('bargam\xc2\xae', osutils.safe_utf8(u'bargam\xae'))
571
def test_from_utf8_string(self):
572
self.assertEqual('foo\xc2\xae', osutils.safe_utf8('foo\xc2\xae'))
574
def test_bad_utf8_string(self):
575
self.assertRaises(BzrBadParameterNotUnicode,
576
osutils.safe_utf8, '\xbb\xbb')
579
class TestSafeRevisionId(TestCase):
581
def test_from_ascii_string(self):
582
# this shouldn't give a warning because it's getting an ascii string
583
self.assertEqual('foobar', osutils.safe_revision_id('foobar'))
585
def test_from_unicode_string_ascii_contents(self):
586
self.assertEqual('bargam',
587
osutils.safe_revision_id(u'bargam', warn=False))
589
def test_from_unicode_deprecated(self):
590
self.assertEqual('bargam',
591
self.callDeprecated([osutils._revision_id_warning],
592
osutils.safe_revision_id, u'bargam'))
594
def test_from_unicode_string_unicode_contents(self):
595
self.assertEqual('bargam\xc2\xae',
596
osutils.safe_revision_id(u'bargam\xae', warn=False))
598
def test_from_utf8_string(self):
599
self.assertEqual('foo\xc2\xae',
600
osutils.safe_revision_id('foo\xc2\xae'))
603
"""Currently, None is a valid revision_id"""
604
self.assertEqual(None, osutils.safe_revision_id(None))
607
class TestSafeFileId(TestCase):
609
def test_from_ascii_string(self):
610
self.assertEqual('foobar', osutils.safe_file_id('foobar'))
612
def test_from_unicode_string_ascii_contents(self):
613
self.assertEqual('bargam', osutils.safe_file_id(u'bargam', warn=False))
615
def test_from_unicode_deprecated(self):
616
self.assertEqual('bargam',
617
self.callDeprecated([osutils._file_id_warning],
618
osutils.safe_file_id, u'bargam'))
620
def test_from_unicode_string_unicode_contents(self):
621
self.assertEqual('bargam\xc2\xae',
622
osutils.safe_file_id(u'bargam\xae', warn=False))
624
def test_from_utf8_string(self):
625
self.assertEqual('foo\xc2\xae',
626
osutils.safe_file_id('foo\xc2\xae'))
629
"""Currently, None is a valid revision_id"""
630
self.assertEqual(None, osutils.safe_file_id(None))
633
class TestWin32Funcs(TestCase):
634
"""Test that the _win32 versions of os utilities return appropriate paths."""
636
def test_abspath(self):
637
self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
638
self.assertEqual('C:/foo', osutils._win32_abspath('C:/foo'))
639
self.assertEqual('//HOST/path', osutils._win32_abspath(r'\\HOST\path'))
640
self.assertEqual('//HOST/path', osutils._win32_abspath('//HOST/path'))
642
def test_realpath(self):
643
self.assertEqual('C:/foo', osutils._win32_realpath('C:\\foo'))
644
self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
646
def test_pathjoin(self):
647
self.assertEqual('path/to/foo', osutils._win32_pathjoin('path', 'to', 'foo'))
648
self.assertEqual('C:/foo', osutils._win32_pathjoin('path\\to', 'C:\\foo'))
649
self.assertEqual('C:/foo', osutils._win32_pathjoin('path/to', 'C:/foo'))
650
self.assertEqual('path/to/foo', osutils._win32_pathjoin('path/to/', 'foo'))
651
self.assertEqual('/foo', osutils._win32_pathjoin('C:/path/to/', '/foo'))
652
self.assertEqual('/foo', osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
654
def test_normpath(self):
655
self.assertEqual('path/to/foo', osutils._win32_normpath(r'path\\from\..\to\.\foo'))
656
self.assertEqual('path/to/foo', osutils._win32_normpath('path//from/../to/./foo'))
658
def test_getcwd(self):
659
cwd = osutils._win32_getcwd()
660
os_cwd = os.getcwdu()
661
self.assertEqual(os_cwd[1:].replace('\\', '/'), cwd[1:])
662
# win32 is inconsistent whether it returns lower or upper case
663
# and even if it was consistent the user might type the other
664
# so we force it to uppercase
665
# running python.exe under cmd.exe return capital C:\\
666
# running win32 python inside a cygwin shell returns lowercase
667
self.assertEqual(os_cwd[0].upper(), cwd[0])
669
def test_fixdrive(self):
670
self.assertEqual('H:/foo', osutils._win32_fixdrive('h:/foo'))
671
self.assertEqual('H:/foo', osutils._win32_fixdrive('H:/foo'))
672
self.assertEqual('C:\\foo', osutils._win32_fixdrive('c:\\foo'))
674
def test_win98_abspath(self):
676
self.assertEqual('C:/foo', osutils._win98_abspath('C:\\foo'))
677
self.assertEqual('C:/foo', osutils._win98_abspath('C:/foo'))
679
self.assertEqual('//HOST/path', osutils._win98_abspath(r'\\HOST\path'))
680
self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
682
cwd = osutils.getcwd().rstrip('/')
683
drive = osutils._nt_splitdrive(cwd)[0]
684
self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
685
self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
688
self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
691
class TestWin32FuncsDirs(TestCaseInTempDir):
692
"""Test win32 functions that create files."""
694
def test_getcwd(self):
695
if win32utils.winver == 'Windows 98':
696
raise TestSkipped('Windows 98 cannot handle unicode filenames')
697
# Make sure getcwd can handle unicode filenames
701
raise TestSkipped("Unable to create Unicode filename")
704
# TODO: jam 20060427 This will probably fail on Mac OSX because
705
# it will change the normalization of B\xe5gfors
706
# Consider using a different unicode character, or make
707
# osutils.getcwd() renormalize the path.
708
self.assertEndsWith(osutils._win32_getcwd(), u'mu-\xb5')
710
def test_minimum_path_selection(self):
711
self.assertEqual(set(),
712
osutils.minimum_path_selection([]))
713
self.assertEqual(set(['a', 'b']),
714
osutils.minimum_path_selection(['a', 'b']))
715
self.assertEqual(set(['a/', 'b']),
716
osutils.minimum_path_selection(['a/', 'b']))
717
self.assertEqual(set(['a/', 'b']),
718
osutils.minimum_path_selection(['a/c', 'a/', 'b']))
720
def test_mkdtemp(self):
721
tmpdir = osutils._win32_mkdtemp(dir='.')
722
self.assertFalse('\\' in tmpdir)
724
def test_rename(self):
732
osutils._win32_rename('b', 'a')
733
self.failUnlessExists('a')
734
self.failIfExists('b')
735
self.assertFileEqual('baz\n', 'a')
737
def test_rename_missing_file(self):
743
osutils._win32_rename('b', 'a')
744
except (IOError, OSError), e:
745
self.assertEqual(errno.ENOENT, e.errno)
746
self.assertFileEqual('foo\n', 'a')
748
def test_rename_missing_dir(self):
751
osutils._win32_rename('b', 'a')
752
except (IOError, OSError), e:
753
self.assertEqual(errno.ENOENT, e.errno)
755
def test_rename_current_dir(self):
758
# You can't rename the working directory
759
# doing rename non-existant . usually
760
# just raises ENOENT, since non-existant
763
osutils._win32_rename('b', '.')
764
except (IOError, OSError), e:
765
self.assertEqual(errno.ENOENT, e.errno)
767
def test_splitpath(self):
768
def check(expected, path):
769
self.assertEqual(expected, osutils.splitpath(path))
772
check(['a', 'b'], 'a/b')
773
check(['a', 'b'], 'a/./b')
774
check(['a', '.b'], 'a/.b')
775
check(['a', '.b'], 'a\\.b')
777
self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
780
class TestMacFuncsDirs(TestCaseInTempDir):
781
"""Test mac special functions that require directories."""
783
def test_getcwd(self):
784
# On Mac, this will actually create Ba\u030agfors
785
# but chdir will still work, because it accepts both paths
787
os.mkdir(u'B\xe5gfors')
789
raise TestSkipped("Unable to create Unicode filename")
791
os.chdir(u'B\xe5gfors')
792
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
794
def test_getcwd_nonnorm(self):
795
# Test that _mac_getcwd() will normalize this path
797
os.mkdir(u'Ba\u030agfors')
799
raise TestSkipped("Unable to create Unicode filename")
801
os.chdir(u'Ba\u030agfors')
802
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
805
class TestChunksToLines(TestCase):
807
def test_smoketest(self):
808
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
809
osutils.chunks_to_lines(['foo\nbar', '\nbaz\n']))
810
self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
811
osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
813
def test_osutils_binding(self):
814
from bzrlib.tests import test__chunks_to_lines
815
if test__chunks_to_lines.CompiledChunksToLinesFeature.available():
816
from bzrlib._chunks_to_lines_pyx import chunks_to_lines
818
from bzrlib._chunks_to_lines_py import chunks_to_lines
819
self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
822
class TestSplitLines(TestCase):
824
def test_split_unicode(self):
825
self.assertEqual([u'foo\n', u'bar\xae'],
826
osutils.split_lines(u'foo\nbar\xae'))
827
self.assertEqual([u'foo\n', u'bar\xae\n'],
828
osutils.split_lines(u'foo\nbar\xae\n'))
830
def test_split_with_carriage_returns(self):
831
self.assertEqual(['foo\rbar\n'],
832
osutils.split_lines('foo\rbar\n'))
835
class TestWalkDirs(TestCaseInTempDir):
837
def test_walkdirs(self):
846
self.build_tree(tree)
847
expected_dirblocks = [
849
[('0file', '0file', 'file'),
850
('1dir', '1dir', 'directory'),
851
('2file', '2file', 'file'),
855
[('1dir/0file', '0file', 'file'),
856
('1dir/1dir', '1dir', 'directory'),
859
(('1dir/1dir', './1dir/1dir'),
866
for dirdetail, dirblock in osutils.walkdirs('.'):
867
if len(dirblock) and dirblock[0][1] == '.bzr':
868
# this tests the filtering of selected paths
871
result.append((dirdetail, dirblock))
873
self.assertTrue(found_bzrdir)
874
self.assertEqual(expected_dirblocks,
875
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
876
# you can search a subdir only, with a supplied prefix.
878
for dirblock in osutils.walkdirs('./1dir', '1dir'):
879
result.append(dirblock)
880
self.assertEqual(expected_dirblocks[1:],
881
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
883
def test_walkdirs_os_error(self):
884
# <https://bugs.edge.launchpad.net/bzr/+bug/338653>
885
# Pyrex readdir didn't raise useful messages if it had an error
886
# reading the directory
887
if sys.platform == 'win32':
888
raise tests.TestNotApplicable(
889
"readdir IOError not tested on win32")
890
os.mkdir("test-unreadable")
891
os.chmod("test-unreadable", 0000)
892
# must chmod it back so that it can be removed
893
self.addCleanup(lambda: os.chmod("test-unreadable", 0700))
894
# The error is not raised until the generator is actually evaluated.
895
# (It would be ok if it happened earlier but at the moment it
897
e = self.assertRaises(OSError, list, osutils._walkdirs_utf8("."))
898
self.assertEquals('./test-unreadable', e.filename)
899
self.assertEquals(errno.EACCES, e.errno)
900
# Ensure the message contains the file name
901
self.assertContainsRe(str(e), "\./test-unreadable")
903
def test__walkdirs_utf8(self):
912
self.build_tree(tree)
913
expected_dirblocks = [
915
[('0file', '0file', 'file'),
916
('1dir', '1dir', 'directory'),
917
('2file', '2file', 'file'),
921
[('1dir/0file', '0file', 'file'),
922
('1dir/1dir', '1dir', 'directory'),
925
(('1dir/1dir', './1dir/1dir'),
932
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
933
if len(dirblock) and dirblock[0][1] == '.bzr':
934
# this tests the filtering of selected paths
937
result.append((dirdetail, dirblock))
939
self.assertTrue(found_bzrdir)
940
self.assertEqual(expected_dirblocks,
941
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
942
# you can search a subdir only, with a supplied prefix.
944
for dirblock in osutils.walkdirs('./1dir', '1dir'):
945
result.append(dirblock)
946
self.assertEqual(expected_dirblocks[1:],
947
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
949
def _filter_out_stat(self, result):
950
"""Filter out the stat value from the walkdirs result"""
951
for dirdetail, dirblock in result:
953
for info in dirblock:
954
# Ignore info[3] which is the stat
955
new_dirblock.append((info[0], info[1], info[2], info[4]))
956
dirblock[:] = new_dirblock
958
def _save_platform_info(self):
959
cur_winver = win32utils.winver
960
cur_fs_enc = osutils._fs_enc
961
cur_dir_reader = osutils._selected_dir_reader
963
win32utils.winver = cur_winver
964
osutils._fs_enc = cur_fs_enc
965
osutils._selected_dir_reader = cur_dir_reader
966
self.addCleanup(restore)
968
def assertReadFSDirIs(self, expected):
969
"""Assert the right implementation for _walkdirs_utf8 is chosen."""
970
# Force it to redetect
971
osutils._selected_dir_reader = None
972
# Nothing to list, but should still trigger the selection logic
973
self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
974
self.assertIsInstance(osutils._selected_dir_reader, expected)
976
def test_force_walkdirs_utf8_fs_utf8(self):
977
self.requireFeature(UTF8DirReaderFeature)
978
self._save_platform_info()
979
win32utils.winver = None # Avoid the win32 detection code
980
osutils._fs_enc = 'UTF-8'
981
self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
983
def test_force_walkdirs_utf8_fs_ascii(self):
984
self.requireFeature(UTF8DirReaderFeature)
985
self._save_platform_info()
986
win32utils.winver = None # Avoid the win32 detection code
987
osutils._fs_enc = 'US-ASCII'
988
self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
990
def test_force_walkdirs_utf8_fs_ANSI(self):
991
self.requireFeature(UTF8DirReaderFeature)
992
self._save_platform_info()
993
win32utils.winver = None # Avoid the win32 detection code
994
osutils._fs_enc = 'ANSI_X3.4-1968'
995
self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
997
def test_force_walkdirs_utf8_fs_latin1(self):
998
self._save_platform_info()
999
win32utils.winver = None # Avoid the win32 detection code
1000
osutils._fs_enc = 'latin1'
1001
self.assertReadFSDirIs(osutils.UnicodeDirReader)
1003
def test_force_walkdirs_utf8_nt(self):
1004
# Disabled because the thunk of the whole walkdirs api is disabled.
1005
self.requireFeature(Win32ReadDirFeature)
1006
self._save_platform_info()
1007
win32utils.winver = 'Windows NT'
1008
from bzrlib._walkdirs_win32 import Win32ReadDir
1009
self.assertReadFSDirIs(Win32ReadDir)
1011
def test_force_walkdirs_utf8_98(self):
1012
self.requireFeature(Win32ReadDirFeature)
1013
self._save_platform_info()
1014
win32utils.winver = 'Windows 98'
1015
self.assertReadFSDirIs(osutils.UnicodeDirReader)
1017
def test_unicode_walkdirs(self):
1018
"""Walkdirs should always return unicode paths."""
1019
name0 = u'0file-\xb6'
1020
name1 = u'1dir-\u062c\u0648'
1021
name2 = u'2file-\u0633'
1025
name1 + '/' + name0,
1026
name1 + '/' + name1 + '/',
1030
self.build_tree(tree)
1031
except UnicodeError:
1032
raise TestSkipped('Could not represent Unicode chars'
1033
' in current encoding.')
1034
expected_dirblocks = [
1036
[(name0, name0, 'file', './' + name0),
1037
(name1, name1, 'directory', './' + name1),
1038
(name2, name2, 'file', './' + name2),
1041
((name1, './' + name1),
1042
[(name1 + '/' + name0, name0, 'file', './' + name1
1044
(name1 + '/' + name1, name1, 'directory', './' + name1
1048
((name1 + '/' + name1, './' + name1 + '/' + name1),
1053
result = list(osutils.walkdirs('.'))
1054
self._filter_out_stat(result)
1055
self.assertEqual(expected_dirblocks, result)
1056
result = list(osutils.walkdirs(u'./'+name1, name1))
1057
self._filter_out_stat(result)
1058
self.assertEqual(expected_dirblocks[1:], result)
1060
def test_unicode__walkdirs_utf8(self):
1061
"""Walkdirs_utf8 should always return utf8 paths.
1063
The abspath portion might be in unicode or utf-8
1065
name0 = u'0file-\xb6'
1066
name1 = u'1dir-\u062c\u0648'
1067
name2 = u'2file-\u0633'
1071
name1 + '/' + name0,
1072
name1 + '/' + name1 + '/',
1076
self.build_tree(tree)
1077
except UnicodeError:
1078
raise TestSkipped('Could not represent Unicode chars'
1079
' in current encoding.')
1080
name0 = name0.encode('utf8')
1081
name1 = name1.encode('utf8')
1082
name2 = name2.encode('utf8')
1084
expected_dirblocks = [
1086
[(name0, name0, 'file', './' + name0),
1087
(name1, name1, 'directory', './' + name1),
1088
(name2, name2, 'file', './' + name2),
1091
((name1, './' + name1),
1092
[(name1 + '/' + name0, name0, 'file', './' + name1
1094
(name1 + '/' + name1, name1, 'directory', './' + name1
1098
((name1 + '/' + name1, './' + name1 + '/' + name1),
1104
# For ease in testing, if walkdirs_utf8 returns Unicode, assert that
1105
# all abspaths are Unicode, and encode them back into utf8.
1106
for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
1107
self.assertIsInstance(dirdetail[0], str)
1108
if isinstance(dirdetail[1], unicode):
1109
dirdetail = (dirdetail[0], dirdetail[1].encode('utf8'))
1110
dirblock = [list(info) for info in dirblock]
1111
for info in dirblock:
1112
self.assertIsInstance(info[4], unicode)
1113
info[4] = info[4].encode('utf8')
1115
for info in dirblock:
1116
self.assertIsInstance(info[0], str)
1117
self.assertIsInstance(info[1], str)
1118
self.assertIsInstance(info[4], str)
1119
# Remove the stat information
1120
new_dirblock.append((info[0], info[1], info[2], info[4]))
1121
result.append((dirdetail, new_dirblock))
1122
self.assertEqual(expected_dirblocks, result)
1124
def test__walkdirs_utf8_with_unicode_fs(self):
1125
"""UnicodeDirReader should be a safe fallback everywhere
1127
The abspath portion should be in unicode
1129
# Use the unicode reader. TODO: split into driver-and-driven unit
1131
self._save_platform_info()
1132
osutils._selected_dir_reader = osutils.UnicodeDirReader()
1133
name0u = u'0file-\xb6'
1134
name1u = u'1dir-\u062c\u0648'
1135
name2u = u'2file-\u0633'
1139
name1u + '/' + name0u,
1140
name1u + '/' + name1u + '/',
1144
self.build_tree(tree)
1145
except UnicodeError:
1146
raise TestSkipped('Could not represent Unicode chars'
1147
' in current encoding.')
1148
name0 = name0u.encode('utf8')
1149
name1 = name1u.encode('utf8')
1150
name2 = name2u.encode('utf8')
1152
# All of the abspaths should be in unicode, all of the relative paths
1154
expected_dirblocks = [
1156
[(name0, name0, 'file', './' + name0u),
1157
(name1, name1, 'directory', './' + name1u),
1158
(name2, name2, 'file', './' + name2u),
1161
((name1, './' + name1u),
1162
[(name1 + '/' + name0, name0, 'file', './' + name1u
1164
(name1 + '/' + name1, name1, 'directory', './' + name1u
1168
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1173
result = list(osutils._walkdirs_utf8('.'))
1174
self._filter_out_stat(result)
1175
self.assertEqual(expected_dirblocks, result)
1177
def test__walkdirs_utf8_win32readdir(self):
1178
self.requireFeature(Win32ReadDirFeature)
1179
self.requireFeature(tests.UnicodeFilenameFeature)
1180
from bzrlib._walkdirs_win32 import Win32ReadDir
1181
self._save_platform_info()
1182
osutils._selected_dir_reader = Win32ReadDir()
1183
name0u = u'0file-\xb6'
1184
name1u = u'1dir-\u062c\u0648'
1185
name2u = u'2file-\u0633'
1189
name1u + '/' + name0u,
1190
name1u + '/' + name1u + '/',
1193
self.build_tree(tree)
1194
name0 = name0u.encode('utf8')
1195
name1 = name1u.encode('utf8')
1196
name2 = name2u.encode('utf8')
1198
# All of the abspaths should be in unicode, all of the relative paths
1200
expected_dirblocks = [
1202
[(name0, name0, 'file', './' + name0u),
1203
(name1, name1, 'directory', './' + name1u),
1204
(name2, name2, 'file', './' + name2u),
1207
((name1, './' + name1u),
1208
[(name1 + '/' + name0, name0, 'file', './' + name1u
1210
(name1 + '/' + name1, name1, 'directory', './' + name1u
1214
((name1 + '/' + name1, './' + name1u + '/' + name1u),
1219
result = list(osutils._walkdirs_utf8(u'.'))
1220
self._filter_out_stat(result)
1221
self.assertEqual(expected_dirblocks, result)
1223
def assertStatIsCorrect(self, path, win32stat):
1224
os_stat = os.stat(path)
1225
self.assertEqual(os_stat.st_size, win32stat.st_size)
1226
self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
1227
self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
1228
self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
1229
self.assertEqual(os_stat.st_dev, win32stat.st_dev)
1230
self.assertEqual(os_stat.st_ino, win32stat.st_ino)
1231
self.assertEqual(os_stat.st_mode, win32stat.st_mode)
1233
def test__walkdirs_utf_win32_find_file_stat_file(self):
1234
"""make sure our Stat values are valid"""
1235
self.requireFeature(Win32ReadDirFeature)
1236
self.requireFeature(tests.UnicodeFilenameFeature)
1237
from bzrlib._walkdirs_win32 import Win32ReadDir
1238
name0u = u'0file-\xb6'
1239
name0 = name0u.encode('utf8')
1240
self.build_tree([name0u])
1241
# I hate to sleep() here, but I'm trying to make the ctime different
1244
f = open(name0u, 'ab')
1246
f.write('just a small update')
1250
result = Win32ReadDir().read_dir('', u'.')
1252
self.assertEqual((name0, name0, 'file'), entry[:3])
1253
self.assertEqual(u'./' + name0u, entry[4])
1254
self.assertStatIsCorrect(entry[4], entry[3])
1255
self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
1257
def test__walkdirs_utf_win32_find_file_stat_directory(self):
1258
"""make sure our Stat values are valid"""
1259
self.requireFeature(Win32ReadDirFeature)
1260
self.requireFeature(tests.UnicodeFilenameFeature)
1261
from bzrlib._walkdirs_win32 import Win32ReadDir
1262
name0u = u'0dir-\u062c\u0648'
1263
name0 = name0u.encode('utf8')
1264
self.build_tree([name0u + '/'])
1266
result = Win32ReadDir().read_dir('', u'.')
1268
self.assertEqual((name0, name0, 'directory'), entry[:3])
1269
self.assertEqual(u'./' + name0u, entry[4])
1270
self.assertStatIsCorrect(entry[4], entry[3])
1272
def assertPathCompare(self, path_less, path_greater):
1273
"""check that path_less and path_greater compare correctly."""
1274
self.assertEqual(0, osutils.compare_paths_prefix_order(
1275
path_less, path_less))
1276
self.assertEqual(0, osutils.compare_paths_prefix_order(
1277
path_greater, path_greater))
1278
self.assertEqual(-1, osutils.compare_paths_prefix_order(
1279
path_less, path_greater))
1280
self.assertEqual(1, osutils.compare_paths_prefix_order(
1281
path_greater, path_less))
1283
def test_compare_paths_prefix_order(self):
1284
# root before all else
1285
self.assertPathCompare("/", "/a")
1286
# alpha within a dir
1287
self.assertPathCompare("/a", "/b")
1288
self.assertPathCompare("/b", "/z")
1289
# high dirs before lower.
1290
self.assertPathCompare("/z", "/a/a")
1291
# except if the deeper dir should be output first
1292
self.assertPathCompare("/a/b/c", "/d/g")
1293
# lexical betwen dirs of the same height
1294
self.assertPathCompare("/a/z", "/z/z")
1295
self.assertPathCompare("/a/c/z", "/a/d/e")
1297
# this should also be consistent for no leading / paths
1298
# root before all else
1299
self.assertPathCompare("", "a")
1300
# alpha within a dir
1301
self.assertPathCompare("a", "b")
1302
self.assertPathCompare("b", "z")
1303
# high dirs before lower.
1304
self.assertPathCompare("z", "a/a")
1305
# except if the deeper dir should be output first
1306
self.assertPathCompare("a/b/c", "d/g")
1307
# lexical betwen dirs of the same height
1308
self.assertPathCompare("a/z", "z/z")
1309
self.assertPathCompare("a/c/z", "a/d/e")
1311
def test_path_prefix_sorting(self):
1312
"""Doing a sort on path prefix should match our sample data."""
1327
dir_sorted_paths = [
1343
sorted(original_paths, key=osutils.path_prefix_key))
1344
# using the comparison routine shoudl work too:
1347
sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
1350
class TestCopyTree(TestCaseInTempDir):
1352
def test_copy_basic_tree(self):
1353
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1354
osutils.copy_tree('source', 'target')
1355
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1356
self.assertEqual(['c'], os.listdir('target/b'))
1358
def test_copy_tree_target_exists(self):
1359
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c',
1361
osutils.copy_tree('source', 'target')
1362
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
1363
self.assertEqual(['c'], os.listdir('target/b'))
1365
def test_copy_tree_symlinks(self):
1366
self.requireFeature(SymlinkFeature)
1367
self.build_tree(['source/'])
1368
os.symlink('a/generic/path', 'source/lnk')
1369
osutils.copy_tree('source', 'target')
1370
self.assertEqual(['lnk'], os.listdir('target'))
1371
self.assertEqual('a/generic/path', os.readlink('target/lnk'))
1373
def test_copy_tree_handlers(self):
1374
processed_files = []
1375
processed_links = []
1376
def file_handler(from_path, to_path):
1377
processed_files.append(('f', from_path, to_path))
1378
def dir_handler(from_path, to_path):
1379
processed_files.append(('d', from_path, to_path))
1380
def link_handler(from_path, to_path):
1381
processed_links.append((from_path, to_path))
1382
handlers = {'file':file_handler,
1383
'directory':dir_handler,
1384
'symlink':link_handler,
1387
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1388
if osutils.has_symlinks():
1389
os.symlink('a/generic/path', 'source/lnk')
1390
osutils.copy_tree('source', 'target', handlers=handlers)
1392
self.assertEqual([('d', 'source', 'target'),
1393
('f', 'source/a', 'target/a'),
1394
('d', 'source/b', 'target/b'),
1395
('f', 'source/b/c', 'target/b/c'),
1397
self.failIfExists('target')
1398
if osutils.has_symlinks():
1399
self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1402
#class TestTerminalEncoding has been moved to test_osutils_encodings.py
1403
# [bialix] 2006/12/26
1406
class TestSetUnsetEnv(TestCase):
1407
"""Test updating the environment"""
1410
super(TestSetUnsetEnv, self).setUp()
1412
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
1413
'Environment was not cleaned up properly.'
1414
' Variable BZR_TEST_ENV_VAR should not exist.')
1416
if 'BZR_TEST_ENV_VAR' in os.environ:
1417
del os.environ['BZR_TEST_ENV_VAR']
1419
self.addCleanup(cleanup)
1422
"""Test that we can set an env variable"""
1423
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1424
self.assertEqual(None, old)
1425
self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
1427
def test_double_set(self):
1428
"""Test that we get the old value out"""
1429
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1430
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
1431
self.assertEqual('foo', old)
1432
self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
1434
def test_unicode(self):
1435
"""Environment can only contain plain strings
1437
So Unicode strings must be encoded.
1439
uni_val, env_val = probe_unicode_in_user_encoding()
1441
raise TestSkipped('Cannot find a unicode character that works in'
1442
' encoding %s' % (osutils.get_user_encoding(),))
1444
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1445
self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
1447
def test_unset(self):
1448
"""Test that passing None will remove the env var"""
1449
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
1450
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
1451
self.assertEqual('foo', old)
1452
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
1453
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1456
class TestLocalTimeOffset(TestCase):
1458
def test_local_time_offset(self):
1459
"""Test that local_time_offset() returns a sane value."""
1460
offset = osutils.local_time_offset()
1461
self.assertTrue(isinstance(offset, int))
1462
# Test that the offset is no more than a eighteen hours in
1464
# Time zone handling is system specific, so it is difficult to
1465
# do more specific tests, but a value outside of this range is
1467
eighteen_hours = 18 * 3600
1468
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1470
def test_local_time_offset_with_timestamp(self):
1471
"""Test that local_time_offset() works with a timestamp."""
1472
offset = osutils.local_time_offset(1000000000.1234567)
1473
self.assertTrue(isinstance(offset, int))
1474
eighteen_hours = 18 * 3600
1475
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1478
class TestSizeShaFile(TestCaseInTempDir):
1480
def test_sha_empty(self):
1481
self.build_tree_contents([('foo', '')])
1482
expected_sha = osutils.sha_string('')
1484
self.addCleanup(f.close)
1485
size, sha = osutils.size_sha_file(f)
1486
self.assertEqual(0, size)
1487
self.assertEqual(expected_sha, sha)
1489
def test_sha_mixed_endings(self):
1490
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1491
self.build_tree_contents([('foo', text)])
1492
expected_sha = osutils.sha_string(text)
1494
self.addCleanup(f.close)
1495
size, sha = osutils.size_sha_file(f)
1496
self.assertEqual(38, size)
1497
self.assertEqual(expected_sha, sha)
1500
class TestShaFileByName(TestCaseInTempDir):
1502
def test_sha_empty(self):
1503
self.build_tree_contents([('foo', '')])
1504
expected_sha = osutils.sha_string('')
1505
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1507
def test_sha_mixed_endings(self):
1508
text = 'test\r\nwith\nall\rpossible line endings\r\n'
1509
self.build_tree_contents([('foo', text)])
1510
expected_sha = osutils.sha_string(text)
1511
self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1514
class TestResourceLoading(TestCaseInTempDir):
1516
def test_resource_string(self):
1517
# test resource in bzrlib
1518
text = osutils.resource_string('bzrlib', 'debug.py')
1519
self.assertContainsRe(text, "debug_flags = set()")
1520
# test resource under bzrlib
1521
text = osutils.resource_string('bzrlib.ui', 'text.py')
1522
self.assertContainsRe(text, "class TextUIFactory")
1523
# test unsupported package
1524
self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1526
# test unknown resource
1527
self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
added
removed
bzrlib/tests/test_osutils.py
