1
# Copyright (C) 2005, 2006 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."""
31
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
32
from bzrlib.tests import (
40
class TestOSUtils(TestCaseInTempDir):
42
def test_contains_whitespace(self):
43
self.failUnless(osutils.contains_whitespace(u' '))
44
self.failUnless(osutils.contains_whitespace(u'hello there'))
45
self.failUnless(osutils.contains_whitespace(u'hellothere\n'))
46
self.failUnless(osutils.contains_whitespace(u'hello\nthere'))
47
self.failUnless(osutils.contains_whitespace(u'hello\rthere'))
48
self.failUnless(osutils.contains_whitespace(u'hello\tthere'))
50
# \xa0 is "Non-breaking-space" which on some python locales thinks it
51
# is whitespace, but we do not.
52
self.failIf(osutils.contains_whitespace(u''))
53
self.failIf(osutils.contains_whitespace(u'hellothere'))
54
self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
56
def test_fancy_rename(self):
57
# This should work everywhere
59
osutils.fancy_rename(a, b,
60
rename_func=os.rename,
61
unlink_func=os.unlink)
63
open('a', 'wb').write('something in a\n')
65
self.failIfExists('a')
66
self.failUnlessExists('b')
67
self.check_file_contents('b', 'something in a\n')
69
open('a', 'wb').write('new something in a\n')
72
self.check_file_contents('a', 'something in a\n')
74
def test_rename(self):
75
# Rename should be semi-atomic on all platforms
76
open('a', 'wb').write('something in a\n')
77
osutils.rename('a', 'b')
78
self.failIfExists('a')
79
self.failUnlessExists('b')
80
self.check_file_contents('b', 'something in a\n')
82
open('a', 'wb').write('new something in a\n')
83
osutils.rename('b', 'a')
85
self.check_file_contents('a', 'something in a\n')
87
# TODO: test fancy_rename using a MemoryTransport
89
def test_01_rand_chars_empty(self):
90
result = osutils.rand_chars(0)
91
self.assertEqual(result, '')
93
def test_02_rand_chars_100(self):
94
result = osutils.rand_chars(100)
95
self.assertEqual(len(result), 100)
96
self.assertEqual(type(result), str)
97
self.assertContainsRe(result, r'^[a-z0-9]{100}$')
99
def test_is_inside(self):
100
is_inside = osutils.is_inside
101
self.assertTrue(is_inside('src', 'src/foo.c'))
102
self.assertFalse(is_inside('src', 'srccontrol'))
103
self.assertTrue(is_inside('src', 'src/a/a/a/foo.c'))
104
self.assertTrue(is_inside('foo.c', 'foo.c'))
105
self.assertFalse(is_inside('foo.c', ''))
106
self.assertTrue(is_inside('', 'foo.c'))
108
def test_rmtree(self):
109
# Check to remove tree with read-only files/dirs
111
f = file('dir/file', 'w')
114
# would like to also try making the directory readonly, but at the
115
# moment python shutil.rmtree doesn't handle that properly - it would
116
# need to chmod the directory before removing things inside it - deferred
117
# for now -- mbp 20060505
118
# osutils.make_readonly('dir')
119
osutils.make_readonly('dir/file')
121
osutils.rmtree('dir')
123
self.failIfExists('dir/file')
124
self.failIfExists('dir')
126
def test_file_kind(self):
127
self.build_tree(['file', 'dir/'])
128
self.assertEquals('file', osutils.file_kind('file'))
129
self.assertEquals('directory', osutils.file_kind('dir/'))
130
if osutils.has_symlinks():
131
os.symlink('symlink', 'symlink')
132
self.assertEquals('symlink', osutils.file_kind('symlink'))
134
# TODO: jam 20060529 Test a block device
136
os.lstat('/dev/null')
138
if e.errno not in (errno.ENOENT,):
141
self.assertEquals('chardev', osutils.file_kind('/dev/null'))
143
mkfifo = getattr(os, 'mkfifo', None)
147
self.assertEquals('fifo', osutils.file_kind('fifo'))
151
AF_UNIX = getattr(socket, 'AF_UNIX', None)
153
s = socket.socket(AF_UNIX)
156
self.assertEquals('socket', osutils.file_kind('socket'))
160
def test_get_umask(self):
161
if sys.platform == 'win32':
162
# umask always returns '0', no way to set it
163
self.assertEqual(0, osutils.get_umask())
166
orig_umask = osutils.get_umask()
169
self.assertEqual(0222, osutils.get_umask())
171
self.assertEqual(0022, osutils.get_umask())
173
self.assertEqual(0002, osutils.get_umask())
175
self.assertEqual(0027, osutils.get_umask())
179
def assertFormatedDelta(self, expected, seconds):
180
"""Assert osutils.format_delta formats as expected"""
181
actual = osutils.format_delta(seconds)
182
self.assertEqual(expected, actual)
184
def test_format_delta(self):
185
self.assertFormatedDelta('0 seconds ago', 0)
186
self.assertFormatedDelta('1 second ago', 1)
187
self.assertFormatedDelta('10 seconds ago', 10)
188
self.assertFormatedDelta('59 seconds ago', 59)
189
self.assertFormatedDelta('89 seconds ago', 89)
190
self.assertFormatedDelta('1 minute, 30 seconds ago', 90)
191
self.assertFormatedDelta('3 minutes, 0 seconds ago', 180)
192
self.assertFormatedDelta('3 minutes, 1 second ago', 181)
193
self.assertFormatedDelta('10 minutes, 15 seconds ago', 615)
194
self.assertFormatedDelta('30 minutes, 59 seconds ago', 1859)
195
self.assertFormatedDelta('31 minutes, 0 seconds ago', 1860)
196
self.assertFormatedDelta('60 minutes, 0 seconds ago', 3600)
197
self.assertFormatedDelta('89 minutes, 59 seconds ago', 5399)
198
self.assertFormatedDelta('1 hour, 30 minutes ago', 5400)
199
self.assertFormatedDelta('2 hours, 30 minutes ago', 9017)
200
self.assertFormatedDelta('10 hours, 0 minutes ago', 36000)
201
self.assertFormatedDelta('24 hours, 0 minutes ago', 86400)
202
self.assertFormatedDelta('35 hours, 59 minutes ago', 129599)
203
self.assertFormatedDelta('36 hours, 0 minutes ago', 129600)
204
self.assertFormatedDelta('36 hours, 0 minutes ago', 129601)
205
self.assertFormatedDelta('36 hours, 1 minute ago', 129660)
206
self.assertFormatedDelta('36 hours, 1 minute ago', 129661)
207
self.assertFormatedDelta('84 hours, 10 minutes ago', 303002)
209
# We handle when time steps the wrong direction because computers
210
# don't have synchronized clocks.
211
self.assertFormatedDelta('84 hours, 10 minutes in the future', -303002)
212
self.assertFormatedDelta('1 second in the future', -1)
213
self.assertFormatedDelta('2 seconds in the future', -2)
215
def test_dereference_path(self):
216
if not osutils.has_symlinks():
217
raise TestSkipped('Symlinks are not supported on this platform')
218
cwd = osutils.realpath('.')
220
bar_path = osutils.pathjoin(cwd, 'bar')
221
# Using './' to avoid bug #1213894 (first path component not
222
# dereferenced) in Python 2.4.1 and earlier
223
self.assertEqual(bar_path, osutils.realpath('./bar'))
224
os.symlink('bar', 'foo')
225
self.assertEqual(bar_path, osutils.realpath('./foo'))
227
# Does not dereference terminal symlinks
228
foo_path = osutils.pathjoin(cwd, 'foo')
229
self.assertEqual(foo_path, osutils.dereference_path('./foo'))
231
# Dereferences parent symlinks
233
baz_path = osutils.pathjoin(bar_path, 'baz')
234
self.assertEqual(baz_path, osutils.dereference_path('./foo/baz'))
236
# Dereferences parent symlinks that are the first path element
237
self.assertEqual(baz_path, osutils.dereference_path('foo/baz'))
239
# Dereferences parent symlinks in absolute paths
240
foo_baz_path = osutils.pathjoin(foo_path, 'baz')
241
self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
244
class TestSafeUnicode(TestCase):
246
def test_from_ascii_string(self):
247
self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
249
def test_from_unicode_string_ascii_contents(self):
250
self.assertEqual(u'bargam', osutils.safe_unicode(u'bargam'))
252
def test_from_unicode_string_unicode_contents(self):
253
self.assertEqual(u'bargam\xae', osutils.safe_unicode(u'bargam\xae'))
255
def test_from_utf8_string(self):
256
self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
258
def test_bad_utf8_string(self):
259
self.assertRaises(BzrBadParameterNotUnicode,
260
osutils.safe_unicode,
264
class TestSafeUtf8(TestCase):
266
def test_from_ascii_string(self):
268
self.assertEqual('foobar', osutils.safe_utf8(f))
270
def test_from_unicode_string_ascii_contents(self):
271
self.assertEqual('bargam', osutils.safe_utf8(u'bargam'))
273
def test_from_unicode_string_unicode_contents(self):
274
self.assertEqual('bargam\xc2\xae', osutils.safe_utf8(u'bargam\xae'))
276
def test_from_utf8_string(self):
277
self.assertEqual('foo\xc2\xae', osutils.safe_utf8('foo\xc2\xae'))
279
def test_bad_utf8_string(self):
280
self.assertRaises(BzrBadParameterNotUnicode,
281
osutils.safe_utf8, '\xbb\xbb')
284
class TestSafeRevisionId(TestCase):
286
def test_from_ascii_string(self):
287
self.assertEqual('foobar', osutils.safe_revision_id('foobar'))
289
def test_from_unicode_string_ascii_contents(self):
290
self.assertEqual('bargam',
291
osutils.safe_revision_id(u'bargam', warn=False))
293
def test_from_unicode_deprecated(self):
294
self.assertEqual('bargam',
295
self.callDeprecated([osutils._revision_id_warning],
296
osutils.safe_revision_id, u'bargam'))
298
def test_from_unicode_string_unicode_contents(self):
299
self.assertEqual('bargam\xc2\xae',
300
osutils.safe_revision_id(u'bargam\xae', warn=False))
302
def test_from_utf8_string(self):
303
self.assertEqual('foo\xc2\xae',
304
osutils.safe_revision_id('foo\xc2\xae'))
307
"""Currently, None is a valid revision_id"""
308
self.assertEqual(None, osutils.safe_revision_id(None))
311
class TestSafeFileId(TestCase):
313
def test_from_ascii_string(self):
314
self.assertEqual('foobar', osutils.safe_file_id('foobar'))
316
def test_from_unicode_string_ascii_contents(self):
317
self.assertEqual('bargam', osutils.safe_file_id(u'bargam', warn=False))
319
def test_from_unicode_deprecated(self):
320
self.assertEqual('bargam',
321
self.callDeprecated([osutils._file_id_warning],
322
osutils.safe_file_id, u'bargam'))
324
def test_from_unicode_string_unicode_contents(self):
325
self.assertEqual('bargam\xc2\xae',
326
osutils.safe_file_id(u'bargam\xae', warn=False))
328
def test_from_utf8_string(self):
329
self.assertEqual('foo\xc2\xae',
330
osutils.safe_file_id('foo\xc2\xae'))
333
"""Currently, None is a valid revision_id"""
334
self.assertEqual(None, osutils.safe_file_id(None))
337
class TestWin32Funcs(TestCase):
338
"""Test that the _win32 versions of os utilities return appropriate paths."""
340
def test_abspath(self):
341
self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
342
self.assertEqual('C:/foo', osutils._win32_abspath('C:/foo'))
343
self.assertEqual('//HOST/path', osutils._win32_abspath(r'\\HOST\path'))
344
self.assertEqual('//HOST/path', osutils._win32_abspath('//HOST/path'))
346
def test_realpath(self):
347
self.assertEqual('C:/foo', osutils._win32_realpath('C:\\foo'))
348
self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
350
def test_pathjoin(self):
351
self.assertEqual('path/to/foo', osutils._win32_pathjoin('path', 'to', 'foo'))
352
self.assertEqual('C:/foo', osutils._win32_pathjoin('path\\to', 'C:\\foo'))
353
self.assertEqual('C:/foo', osutils._win32_pathjoin('path/to', 'C:/foo'))
354
self.assertEqual('path/to/foo', osutils._win32_pathjoin('path/to/', 'foo'))
355
self.assertEqual('/foo', osutils._win32_pathjoin('C:/path/to/', '/foo'))
356
self.assertEqual('/foo', osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
358
def test_normpath(self):
359
self.assertEqual('path/to/foo', osutils._win32_normpath(r'path\\from\..\to\.\foo'))
360
self.assertEqual('path/to/foo', osutils._win32_normpath('path//from/../to/./foo'))
362
def test_getcwd(self):
363
cwd = osutils._win32_getcwd()
364
os_cwd = os.getcwdu()
365
self.assertEqual(os_cwd[1:].replace('\\', '/'), cwd[1:])
366
# win32 is inconsistent whether it returns lower or upper case
367
# and even if it was consistent the user might type the other
368
# so we force it to uppercase
369
# running python.exe under cmd.exe return capital C:\\
370
# running win32 python inside a cygwin shell returns lowercase
371
self.assertEqual(os_cwd[0].upper(), cwd[0])
373
def test_fixdrive(self):
374
self.assertEqual('H:/foo', osutils._win32_fixdrive('h:/foo'))
375
self.assertEqual('H:/foo', osutils._win32_fixdrive('H:/foo'))
376
self.assertEqual('C:\\foo', osutils._win32_fixdrive('c:\\foo'))
378
def test_win98_abspath(self):
380
self.assertEqual('C:/foo', osutils._win98_abspath('C:\\foo'))
381
self.assertEqual('C:/foo', osutils._win98_abspath('C:/foo'))
383
self.assertEqual('//HOST/path', osutils._win98_abspath(r'\\HOST\path'))
384
self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
386
cwd = osutils.getcwd().rstrip('/')
387
drive = osutils._nt_splitdrive(cwd)[0]
388
self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
389
self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
392
self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
395
class TestWin32FuncsDirs(TestCaseInTempDir):
396
"""Test win32 functions that create files."""
398
def test_getcwd(self):
399
if win32utils.winver == 'Windows 98':
400
raise TestSkipped('Windows 98 cannot handle unicode filenames')
401
# Make sure getcwd can handle unicode filenames
405
raise TestSkipped("Unable to create Unicode filename")
408
# TODO: jam 20060427 This will probably fail on Mac OSX because
409
# it will change the normalization of B\xe5gfors
410
# Consider using a different unicode character, or make
411
# osutils.getcwd() renormalize the path.
412
self.assertEndsWith(osutils._win32_getcwd(), u'mu-\xb5')
414
def test_mkdtemp(self):
415
tmpdir = osutils._win32_mkdtemp(dir='.')
416
self.assertFalse('\\' in tmpdir)
418
def test_rename(self):
426
osutils._win32_rename('b', 'a')
427
self.failUnlessExists('a')
428
self.failIfExists('b')
429
self.assertFileEqual('baz\n', 'a')
431
def test_rename_missing_file(self):
437
osutils._win32_rename('b', 'a')
438
except (IOError, OSError), e:
439
self.assertEqual(errno.ENOENT, e.errno)
440
self.assertFileEqual('foo\n', 'a')
442
def test_rename_missing_dir(self):
445
osutils._win32_rename('b', 'a')
446
except (IOError, OSError), e:
447
self.assertEqual(errno.ENOENT, e.errno)
449
def test_rename_current_dir(self):
452
# You can't rename the working directory
453
# doing rename non-existant . usually
454
# just raises ENOENT, since non-existant
457
osutils._win32_rename('b', '.')
458
except (IOError, OSError), e:
459
self.assertEqual(errno.ENOENT, e.errno)
461
def test_splitpath(self):
462
def check(expected, path):
463
self.assertEqual(expected, osutils.splitpath(path))
466
check(['a', 'b'], 'a/b')
467
check(['a', 'b'], 'a/./b')
468
check(['a', '.b'], 'a/.b')
469
check(['a', '.b'], 'a\\.b')
471
self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
474
class TestMacFuncsDirs(TestCaseInTempDir):
475
"""Test mac special functions that require directories."""
477
def test_getcwd(self):
478
# On Mac, this will actually create Ba\u030agfors
479
# but chdir will still work, because it accepts both paths
481
os.mkdir(u'B\xe5gfors')
483
raise TestSkipped("Unable to create Unicode filename")
485
os.chdir(u'B\xe5gfors')
486
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
488
def test_getcwd_nonnorm(self):
489
# Test that _mac_getcwd() will normalize this path
491
os.mkdir(u'Ba\u030agfors')
493
raise TestSkipped("Unable to create Unicode filename")
495
os.chdir(u'Ba\u030agfors')
496
self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
499
class TestSplitLines(TestCase):
501
def test_split_unicode(self):
502
self.assertEqual([u'foo\n', u'bar\xae'],
503
osutils.split_lines(u'foo\nbar\xae'))
504
self.assertEqual([u'foo\n', u'bar\xae\n'],
505
osutils.split_lines(u'foo\nbar\xae\n'))
507
def test_split_with_carriage_returns(self):
508
self.assertEqual(['foo\rbar\n'],
509
osutils.split_lines('foo\rbar\n'))
512
class TestWalkDirs(TestCaseInTempDir):
514
def test_walkdirs(self):
523
self.build_tree(tree)
524
expected_dirblocks = [
526
[('0file', '0file', 'file'),
527
('1dir', '1dir', 'directory'),
528
('2file', '2file', 'file'),
532
[('1dir/0file', '0file', 'file'),
533
('1dir/1dir', '1dir', 'directory'),
536
(('1dir/1dir', './1dir/1dir'),
543
for dirdetail, dirblock in osutils.walkdirs('.'):
544
if len(dirblock) and dirblock[0][1] == '.bzr':
545
# this tests the filtering of selected paths
548
result.append((dirdetail, dirblock))
550
self.assertTrue(found_bzrdir)
551
self.assertEqual(expected_dirblocks,
552
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
553
# you can search a subdir only, with a supplied prefix.
555
for dirblock in osutils.walkdirs('./1dir', '1dir'):
556
result.append(dirblock)
557
self.assertEqual(expected_dirblocks[1:],
558
[(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
560
def assertPathCompare(self, path_less, path_greater):
561
"""check that path_less and path_greater compare correctly."""
562
self.assertEqual(0, osutils.compare_paths_prefix_order(
563
path_less, path_less))
564
self.assertEqual(0, osutils.compare_paths_prefix_order(
565
path_greater, path_greater))
566
self.assertEqual(-1, osutils.compare_paths_prefix_order(
567
path_less, path_greater))
568
self.assertEqual(1, osutils.compare_paths_prefix_order(
569
path_greater, path_less))
571
def test_compare_paths_prefix_order(self):
572
# root before all else
573
self.assertPathCompare("/", "/a")
575
self.assertPathCompare("/a", "/b")
576
self.assertPathCompare("/b", "/z")
577
# high dirs before lower.
578
self.assertPathCompare("/z", "/a/a")
579
# except if the deeper dir should be output first
580
self.assertPathCompare("/a/b/c", "/d/g")
581
# lexical betwen dirs of the same height
582
self.assertPathCompare("/a/z", "/z/z")
583
self.assertPathCompare("/a/c/z", "/a/d/e")
585
# this should also be consistent for no leading / paths
586
# root before all else
587
self.assertPathCompare("", "a")
589
self.assertPathCompare("a", "b")
590
self.assertPathCompare("b", "z")
591
# high dirs before lower.
592
self.assertPathCompare("z", "a/a")
593
# except if the deeper dir should be output first
594
self.assertPathCompare("a/b/c", "d/g")
595
# lexical betwen dirs of the same height
596
self.assertPathCompare("a/z", "z/z")
597
self.assertPathCompare("a/c/z", "a/d/e")
599
def test_path_prefix_sorting(self):
600
"""Doing a sort on path prefix should match our sample data."""
631
sorted(original_paths, key=osutils.path_prefix_key))
632
# using the comparison routine shoudl work too:
635
sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
638
class TestCopyTree(TestCaseInTempDir):
640
def test_copy_basic_tree(self):
641
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
642
osutils.copy_tree('source', 'target')
643
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
644
self.assertEqual(['c'], os.listdir('target/b'))
646
def test_copy_tree_target_exists(self):
647
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c',
649
osutils.copy_tree('source', 'target')
650
self.assertEqual(['a', 'b'], sorted(os.listdir('target')))
651
self.assertEqual(['c'], os.listdir('target/b'))
653
def test_copy_tree_symlinks(self):
654
if not osutils.has_symlinks():
656
self.build_tree(['source/'])
657
os.symlink('a/generic/path', 'source/lnk')
658
osutils.copy_tree('source', 'target')
659
self.assertEqual(['lnk'], os.listdir('target'))
660
self.assertEqual('a/generic/path', os.readlink('target/lnk'))
662
def test_copy_tree_handlers(self):
665
def file_handler(from_path, to_path):
666
processed_files.append(('f', from_path, to_path))
667
def dir_handler(from_path, to_path):
668
processed_files.append(('d', from_path, to_path))
669
def link_handler(from_path, to_path):
670
processed_links.append((from_path, to_path))
671
handlers = {'file':file_handler,
672
'directory':dir_handler,
673
'symlink':link_handler,
676
self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
677
if osutils.has_symlinks():
678
os.symlink('a/generic/path', 'source/lnk')
679
osutils.copy_tree('source', 'target', handlers=handlers)
681
self.assertEqual([('d', 'source', 'target'),
682
('f', 'source/a', 'target/a'),
683
('d', 'source/b', 'target/b'),
684
('f', 'source/b/c', 'target/b/c'),
686
self.failIfExists('target')
687
if osutils.has_symlinks():
688
self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
691
#class TestTerminalEncoding has been moved to test_osutils_encodings.py
692
# [bialix] 2006/12/26
695
class TestSetUnsetEnv(TestCase):
696
"""Test updating the environment"""
699
super(TestSetUnsetEnv, self).setUp()
701
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'),
702
'Environment was not cleaned up properly.'
703
' Variable BZR_TEST_ENV_VAR should not exist.')
705
if 'BZR_TEST_ENV_VAR' in os.environ:
706
del os.environ['BZR_TEST_ENV_VAR']
708
self.addCleanup(cleanup)
711
"""Test that we can set an env variable"""
712
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
713
self.assertEqual(None, old)
714
self.assertEqual('foo', os.environ.get('BZR_TEST_ENV_VAR'))
716
def test_double_set(self):
717
"""Test that we get the old value out"""
718
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
719
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'bar')
720
self.assertEqual('foo', old)
721
self.assertEqual('bar', os.environ.get('BZR_TEST_ENV_VAR'))
723
def test_unicode(self):
724
"""Environment can only contain plain strings
726
So Unicode strings must be encoded.
728
# Try a few different characters, to see if we can get
729
# one that will be valid in the user_encoding
730
possible_vals = [u'm\xb5', u'\xe1', u'\u0410']
731
for uni_val in possible_vals:
733
env_val = uni_val.encode(bzrlib.user_encoding)
734
except UnicodeEncodeError:
735
# Try a different character
740
raise TestSkipped('Cannot find a unicode character that works in'
741
' encoding %s' % (bzrlib.user_encoding,))
743
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
744
self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
746
def test_unset(self):
747
"""Test that passing None will remove the env var"""
748
osutils.set_or_unset_env('BZR_TEST_ENV_VAR', 'foo')
749
old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', None)
750
self.assertEqual('foo', old)
751
self.assertEqual(None, os.environ.get('BZR_TEST_ENV_VAR'))
752
self.failIf('BZR_TEST_ENV_VAR' in os.environ)
755
class TestLocalTimeOffset(TestCase):
757
def test_local_time_offset(self):
758
"""Test that local_time_offset() returns a sane value."""
759
offset = osutils.local_time_offset()
760
self.assertTrue(isinstance(offset, int))
761
# Test that the offset is no more than a eighteen hours in
763
# Time zone handling is system specific, so it is difficult to
764
# do more specific tests, but a value outside of this range is
766
eighteen_hours = 18 * 3600
767
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
769
def test_local_time_offset_with_timestamp(self):
770
"""Test that local_time_offset() works with a timestamp."""
771
offset = osutils.local_time_offset(1000000000.1234567)
772
self.assertTrue(isinstance(offset, int))
773
eighteen_hours = 18 * 3600
774
self.assertTrue(-eighteen_hours < offset < eighteen_hours)
added
removed
bzrlib/tests/test_osutils.py
