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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Tests for the osutils wrapper."""
19
from cStringIO import StringIO
34
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
35
from bzrlib.osutils import (
38
from bzrlib.tests import (
40
probe_unicode_in_user_encoding,
43
CaseInsCasePresFilenameFeature,
48
from bzrlib.tests.file_utils import (
51
from bzrlib.tests.test__walkdirs_win32 import Win32ReadDirFeature
54
class _UTF8DirReaderFeature(Feature):
58
from bzrlib import _readdir_pyx
59
self.reader = _readdir_pyx.UTF8DirReader
64
def feature_name(self):
65
return 'bzrlib._readdir_pyx'
67
UTF8DirReaderFeature = _UTF8DirReaderFeature()
70
class TestOSUtils(TestCaseInTempDir):
72
def test_contains_whitespace(self):
73
self.failUnless(osutils.contains_whitespace(u' '))
74
self.failUnless(osutils.contains_whitespace(u'hello there'))
75
self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
76
self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
77
self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
78
self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
80
# \xa0 is "Non-breaking-space" which on some python locales thinks it
81
# is whitespace, but we do not.
82
self.failIf(osutils.contains_whitespace(u''))
83
self.failIf(osutils.contains_whitespace(u'hellothere'))
84
self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
86
def test_fancy_rename(self):
87
# This should work everywhere
89
osutils.fancy_rename(a, b,
90
rename_func=os.rename,
91
unlink_func=os.unlink)
93
open('a', 'wb').write('something in a\n')
95
self.failIfExists('a')
96
self.failUnlessExists('b')
97
self.check_file_contents('b', 'something in a\n')
99
open('a', 'wb').write('new something in a\n')
102
self.check_file_contents('a', 'something in a\n')
104
def test_rename(self):
105
# Rename should be semi-atomic on all platforms
106
open('a', 'wb').write('something in a\n')
107
osutils.rename('a', 'b')
108
self.failIfExists('a')
109
self.failUnlessExists('b')
110
self.check_file_contents('b', 'something in a\n')
112
open('a', 'wb').write('new something in a\n')
113
osutils.rename('b', 'a')
115
self.check_file_contents('a', 'something in a\n')
117
# TODO: test fancy_rename using a MemoryTransport
119
def test_rename_change_case(self):
120
# on Windows we should be able to change filename case by rename
121
self.build_tree(['a', 'b/'])
122
osutils.rename('a', 'A')
123
osutils.rename('b', 'B')
124
# we can't use failUnlessExists on case-insensitive filesystem
125
# so try to check shape of the tree
126
shape = sorted(os.listdir('.'))
127
self.assertEquals(['A', 'B'], shape)
129
def test_01_rand_chars_empty(self):
130
result = osutils.rand_chars(0)
131
self.assertEqual(result, '')
133
def test_02_rand_chars_100(self):
134
result = osutils.rand_chars(100)
135
self.assertEqual(len(result), 100)
136
self.assertEqual(type(result), str)
137
self.assertContainsRe(result, r'^[a-z0-9]{100}$')
139
def test_is_inside(self):
140
is_inside = osutils.is_inside
141
self.assertTrue(is_inside('src', 'src/foo.c'))
142
self.assertFalse(is_inside('src', 'srccontrol'))
143
self.assertTrue(is_inside('src', 'src/a/a/a/foo.c'))
144
self.assertTrue(is_inside('foo.c', 'foo.c'))
145
self.assertFalse(is_inside('foo.c', ''))
146
self.assertTrue(is_inside('', 'foo.c'))
148
def test_is_inside_any(self):
149
SRC_FOO_C = osutils.pathjoin('src', 'foo.c')
150
for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
151
(['src'], SRC_FOO_C),
154
self.assert_(osutils.is_inside_any(dirs, fn))
155
for dirs, fn in [(['src'], 'srccontrol'),
156
(['src'], 'srccontrol/foo')]:
157
self.assertFalse(osutils.is_inside_any(dirs, fn))
159
def test_is_inside_or_parent_of_any(self):
160
for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
161
(['src'], 'src/foo.c'),
162
(['src/bar.c'], 'src'),
163
(['src/bar.c', 'bla/foo.c'], 'src'),
166
self.assert_(osutils.is_inside_or_parent_of_any(dirs, fn))
168
for dirs, fn in [(['src'], 'srccontrol'),
169
(['srccontrol/foo.c'], 'src'),
170
(['src'], 'srccontrol/foo')]:
171
self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
173
def test_rmtree(self):
174
# Check to remove tree with read-only files/dirs
176
f = file('dir/file', 'w')
179
# would like to also try making the directory readonly, but at the
180
# moment python shutil.rmtree doesn't handle that properly - it would
181
# need to chmod the directory before removing things inside it - deferred
182
# for now -- mbp 20060505
183
# osutils.make_readonly('dir')
184
osutils.make_readonly('dir/file')
186
osutils.rmtree('dir')
188
self.failIfExists('dir/file')
189
self.failIfExists('dir')
191
def test_file_kind(self):
192
self.build_tree(['file', 'dir/'])
193
self.assertEquals('file', osutils.file_kind('file'))
194
self.assertEquals('directory', osutils.file_kind('dir/'))
195
if osutils.has_symlinks():
196
os.symlink('symlink', 'symlink')
197
self.assertEquals('symlink', osutils.file_kind('symlink'))
199
# TODO: jam 20060529 Test a block device
201
os.lstat('/dev/null')
203
if e.errno not in (errno.ENOENT,):
206
self.assertEquals('chardev', osutils.file_kind('/dev/null'))
208
mkfifo = getattr(os, 'mkfifo', None)
212
self.assertEquals('fifo', osutils.file_kind('fifo'))
216
AF_UNIX = getattr(socket, 'AF_UNIX', None)
218
s = socket.socket(AF_UNIX)
221
self.assertEquals('socket', osutils.file_kind('socket'))
225
def test_kind_marker(self):
226
self.assertEqual(osutils.kind_marker('file'), '')
227
self.assertEqual(osutils.kind_marker('directory'), '/')
228
self.assertEqual(osutils.kind_marker('symlink'), '@')
229
self.assertEqual(osutils.kind_marker('tree-reference'), '+')
231
def test_get_umask(self):
232
if sys.platform == 'win32':
233
# umask always returns '0', no way to set it
234
self.assertEqual(0, osutils.get_umask())
237
orig_umask = osutils.get_umask()
240
self.assertEqual(0222, osutils.get_umask())
242
self.assertEqual(0022, osutils.get_umask())
244
self.assertEqual(0002, osutils.get_umask())
246
self.assertEqual(0027, osutils.get_umask())
250
def assertFormatedDelta(self, expected, seconds):
251
"""Assert osutils.format_delta formats as expected"""
252
actual = osutils.format_delta(seconds)
253
self.assertEqual(expected, actual)
255
def test_format_delta(self):
256
self.assertFormatedDelta('0 seconds ago', 0)
257
self.assertFormatedDelta('1 second ago', 1)
258
self.assertFormatedDelta('10 seconds ago', 10)
259
self.assertFormatedDelta('59 seconds ago', 59)
260
self.assertFormatedDelta('89 seconds ago', 89)
261
self.assertFormatedDelta('1 minute, 30 seconds ago', 90)
262
self.assertFormatedDelta('3 minutes, 0 seconds ago', 180)
263
self.assertFormatedDelta('3 minutes, 1 second ago', 181)
264
self.assertFormatedDelta('10 minutes, 15 seconds ago', 615)
265
self.assertFormatedDelta('30 minutes, 59 seconds ago', 1859)
266
self.assertFormatedDelta('31 minutes, 0 seconds ago', 1860)
267
self.assertFormatedDelta('60 minutes, 0 seconds ago', 3600)
268
self.assertFormatedDelta('89 minutes, 59 seconds ago', 5399)
269
self.assertFormatedDelta('1 hour, 30 minutes ago', 5400)
270
self.assertFormatedDelta('2 hours, 30 minutes ago', 9017)
271
self.assertFormatedDelta('10 hours, 0 minutes ago', 36000)
272
self.assertFormatedDelta('24 hours, 0 minutes ago', 86400)
273
self.assertFormatedDelta('35 hours, 59 minutes ago', 129599)
274
self.assertFormatedDelta('36 hours, 0 minutes ago', 129600)
275
self.assertFormatedDelta('36 hours, 0 minutes ago', 129601)
276
self.assertFormatedDelta('36 hours, 1 minute ago', 129660)
277
self.assertFormatedDelta('36 hours, 1 minute ago', 129661)
278
self.assertFormatedDelta('84 hours, 10 minutes ago', 303002)
280
# We handle when time steps the wrong direction because computers
281
# don't have synchronized clocks.
282
self.assertFormatedDelta('84 hours, 10 minutes in the future', -303002)
283
self.assertFormatedDelta('1 second in the future', -1)
284
self.assertFormatedDelta('2 seconds in the future', -2)
286
def test_format_date(self):
287
self.assertRaises(errors.UnsupportedTimezoneFormat,
288
osutils.format_date, 0, timezone='foo')
289
self.assertIsInstance(osutils.format_date(0), str)
290
self.assertIsInstance(osutils.format_local_date(0), unicode)
291
# Testing for the actual value of the local weekday without
292
# duplicating the code from format_date is difficult.
293
# Instead blackbox.test_locale should check for localized
294
# dates once they do occur in output strings.
296
def test_dereference_path(self):
297
self.requireFeature(SymlinkFeature)
298
cwd = osutils.realpath('.')
300
bar_path = osutils.pathjoin(cwd, 'bar')
301
# Using './' to avoid bug #1213894 (first path component not
302
# dereferenced) in Python 2.4.1 and earlier
303
self.assertEqual(bar_path, osutils.realpath('./bar'))
304
os.symlink('bar', 'foo')
305
self.assertEqual(bar_path, osutils.realpath('./foo'))
307
# Does not dereference terminal symlinks
308
foo_path = osutils.pathjoin(cwd, 'foo')
309
self.assertEqual(foo_path, osutils.dereference_path('./foo'))
311
# Dereferences parent symlinks
313
baz_path = osutils.pathjoin(bar_path, 'baz')
314
self.assertEqual(baz_path, osutils.dereference_path('./foo/baz'))
316
# Dereferences parent symlinks that are the first path element
317
self.assertEqual(baz_path, osutils.dereference_path('foo/baz'))
319
# Dereferences parent symlinks in absolute paths
320
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
321
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
323
def test_changing_access(self):
324
f = file('file', 'w')
328
# Make a file readonly
329
osutils.make_readonly('file')
330
mode = os.lstat('file').st_mode
331
self.assertEqual(mode, mode & 0777555)
333
# Make a file writable
334
osutils.make_writable('file')
335
mode = os.lstat('file').st_mode
336
self.assertEqual(mode, mode | 0200)
338
if osutils.has_symlinks():
339
# should not error when handed a symlink
340
os.symlink('nonexistent', 'dangling')
341
osutils.make_readonly('dangling')
342
osutils.make_writable('dangling')
344
def test_kind_marker(self):
345
self.assertEqual("", osutils.kind_marker("file"))
346
self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
347
self.assertEqual("@", osutils.kind_marker("symlink"))
348
self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
350
def test_host_os_dereferences_symlinks(self):
351
osutils.host_os_dereferences_symlinks()
354
class TestCanonicalRelPath(TestCaseInTempDir):
356
_test_needs_features = [CaseInsCasePresFilenameFeature]
358
def test_canonical_relpath_simple(self):
359
f = file('MixedCaseName', 'w')
361
# Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
362
real_base_dir = osutils.realpath(self.test_base_dir)
363
actual = osutils.canonical_relpath(real_base_dir, 'mixedcasename')
364
self.failUnlessEqual('work/MixedCaseName', actual)
366
def test_canonical_relpath_missing_tail(self):
367
os.mkdir('MixedCaseParent')
368
# Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
369
real_base_dir = osutils.realpath(self.test_base_dir)
370
actual = osutils.canonical_relpath(real_base_dir,
371
'mixedcaseparent/nochild')
372
self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
375
class TestPumpFile(TestCase):
376
"""Test pumpfile method."""
379
# create a test datablock
380
self.block_size = 512
381
pattern = '0123456789ABCDEF'
382
self.test_data = pattern * (3 * self.block_size / len(pattern))
383
self.test_data_len = len(self.test_data)
385
def test_bracket_block_size(self):
386
"""Read data in blocks with the requested read size bracketing the
388
# make sure test data is larger than max read size
389
self.assertTrue(self.test_data_len > self.block_size)
391
from_file = FakeReadFile(self.test_data)
394
# read (max / 2) bytes and verify read size wasn't affected
395
num_bytes_to_read = self.block_size / 2
396
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
397
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
398
self.assertEqual(from_file.get_read_count(), 1)
400
# read (max) bytes and verify read size wasn't affected
401
num_bytes_to_read = self.block_size
402
from_file.reset_read_count()
403
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
404
self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
405
self.assertEqual(from_file.get_read_count(), 1)
407
# read (max + 1) bytes and verify read size was limited
408
num_bytes_to_read = self.block_size + 1
409
from_file.reset_read_count()
410
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
411
self.assertEqual(from_file.get_max_read_size(), self.block_size)
412
self.assertEqual(from_file.get_read_count(), 2)
414
# finish reading the rest of the data
415
num_bytes_to_read = self.test_data_len - to_file.tell()
416
osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
418
# report error if the data wasn't equal (we only report the size due
419
# to the length of the data)
420
response_data = to_file.getvalue()
421
if response_data != self.test_data:
422
message = "Data not equal. Expected %d bytes, received %d."
423
self.fail(message % (len(response_data), self.test_data_len))
425
def test_specified_size(self):
426
"""Request a transfer larger than the maximum block size and verify
427
that the maximum read doesn't exceed the block_size."""
428
# make sure test data is larger than max read size
429
self.assertTrue(self.test_data_len > self.block_size)
431
# retrieve data in blocks
432
from_file = FakeReadFile(self.test_data)
434
osutils.pumpfile(from_file, to_file, self.test_data_len,
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
osutils.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
osutils.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
osutils.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
osutils.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
osutils.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
osutils.pump_string_file("", output)
521
self.assertEqual("", output.getvalue())
523
def test_more_than_segment_size(self):
525
osutils.pump_string_file("123456789", output, 2)
526
self.assertEqual("123456789", output.getvalue())
528
def test_segment_size(self):
530
osutils.pump_string_file("12", output, 2)
531
self.assertEqual("12", output.getvalue())
533
def test_segment_size_multiple(self):
535
osutils.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')
1530
class TestReCompile(TestCase):
1532
def test_re_compile_checked(self):
1533
r = osutils.re_compile_checked(r'A*', re.IGNORECASE)
1534
self.assertTrue(r.match('aaaa'))
1535
self.assertTrue(r.match('aAaA'))
1537
def test_re_compile_checked_error(self):
1538
# like https://bugs.launchpad.net/bzr/+bug/251352
1539
err = self.assertRaises(
1540
errors.BzrCommandError,
1541
osutils.re_compile_checked, '*', re.IGNORECASE, 'test case')
1543
"Invalid regular expression in test case: '*': "
1544
"nothing to repeat",
added
removed
bzrlib/tests/test_osutils.py
