← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
27
27
 
28
28
from bzrlib import (
29
29
    errors,
 
30
    lazy_regex,
30
31
    osutils,
 
32
    symbol_versioning,
31
33
    tests,
 
34
    trace,
32
35
    win32utils,
33
36
    )
34
 
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
35
 
from bzrlib.osutils import (
36
 
        is_inside_any,
37
 
        is_inside_or_parent_of_any,
38
 
        pathjoin,
39
 
        pumpfile,
40
 
        pump_string_file,
41
 
        canonical_relpath,
42
 
        )
43
37
from bzrlib.tests import (
44
 
        Feature,
45
 
        probe_unicode_in_user_encoding,
46
 
        StringIOWrapper,
47
 
        SymlinkFeature,
48
 
        CaseInsCasePresFilenameFeature,
49
 
        TestCase,
50
 
        TestCaseInTempDir,
51
 
        TestSkipped,
52
 
        )
53
 
from bzrlib.tests.file_utils import (
54
 
    FakeReadFile,
 
38
    features,
 
39
    file_utils,
 
40
    test__walkdirs_win32,
55
41
    )
56
 
from bzrlib.tests.test__walkdirs_win32 import Win32ReadDirFeature
57
 
 
58
 
 
59
 
class _UTF8DirReaderFeature(Feature):
 
42
 
 
43
 
 
44
class _UTF8DirReaderFeature(tests.Feature):
60
45
 
61
46
    def _probe(self):
62
47
        try:
71
56
 
72
57
UTF8DirReaderFeature = _UTF8DirReaderFeature()
73
58
 
74
 
 
75
 
class TestOSUtils(TestCaseInTempDir):
 
59
term_ios_feature = tests.ModuleAvailableFeature('termios')
 
60
 
 
61
 
 
62
def _already_unicode(s):
 
63
    return s
 
64
 
 
65
 
 
66
def _utf8_to_unicode(s):
 
67
    return s.decode('UTF-8')
 
68
 
 
69
 
 
70
def dir_reader_scenarios():
 
71
    # For each dir reader we define:
 
72
 
 
73
    # - native_to_unicode: a function converting the native_abspath as returned
 
74
    #   by DirReader.read_dir to its unicode representation
 
75
 
 
76
    # UnicodeDirReader is the fallback, it should be tested on all platforms.
 
77
    scenarios = [('unicode',
 
78
                  dict(_dir_reader_class=osutils.UnicodeDirReader,
 
79
                       _native_to_unicode=_already_unicode))]
 
80
    # Some DirReaders are platform specific and even there they may not be
 
81
    # available.
 
82
    if UTF8DirReaderFeature.available():
 
83
        from bzrlib import _readdir_pyx
 
84
        scenarios.append(('utf8',
 
85
                          dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
 
86
                               _native_to_unicode=_utf8_to_unicode)))
 
87
 
 
88
    if test__walkdirs_win32.win32_readdir_feature.available():
 
89
        try:
 
90
            from bzrlib import _walkdirs_win32
 
91
            scenarios.append(
 
92
                ('win32',
 
93
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
 
94
                      _native_to_unicode=_already_unicode)))
 
95
        except ImportError:
 
96
            pass
 
97
    return scenarios
 
98
 
 
99
 
 
100
def load_tests(basic_tests, module, loader):
 
101
    suite = loader.suiteClass()
 
102
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
 
103
        basic_tests, tests.condition_isinstance(TestDirReader))
 
104
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios(), suite)
 
105
    suite.addTest(remaining_tests)
 
106
    return suite
 
107
 
 
108
 
 
109
class TestContainsWhitespace(tests.TestCase):
76
110
 
77
111
    def test_contains_whitespace(self):
78
112
        self.failUnless(osutils.contains_whitespace(u' '))
88
122
        self.failIf(osutils.contains_whitespace(u'hellothere'))
89
123
        self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
90
124
 
 
125
 
 
126
class TestRename(tests.TestCaseInTempDir):
 
127
 
 
128
    def create_file(self, filename, content):
 
129
        f = open(filename, 'wb')
 
130
        try:
 
131
            f.write(content)
 
132
        finally:
 
133
            f.close()
 
134
 
 
135
    def _fancy_rename(self, a, b):
 
136
        osutils.fancy_rename(a, b, rename_func=os.rename,
 
137
                             unlink_func=os.unlink)
 
138
 
91
139
    def test_fancy_rename(self):
92
140
        # This should work everywhere
93
 
        def rename(a, b):
94
 
            osutils.fancy_rename(a, b,
95
 
                    rename_func=os.rename,
96
 
                    unlink_func=os.unlink)
97
 
 
98
 
        open('a', 'wb').write('something in a\n')
99
 
        rename('a', 'b')
 
141
        self.create_file('a', 'something in a\n')
 
142
        self._fancy_rename('a', 'b')
100
143
        self.failIfExists('a')
101
144
        self.failUnlessExists('b')
102
145
        self.check_file_contents('b', 'something in a\n')
103
146
 
104
 
        open('a', 'wb').write('new something in a\n')
105
 
        rename('b', 'a')
 
147
        self.create_file('a', 'new something in a\n')
 
148
        self._fancy_rename('b', 'a')
106
149
 
107
150
        self.check_file_contents('a', 'something in a\n')
108
151
 
 
152
    def test_fancy_rename_fails_source_missing(self):
 
153
        # An exception should be raised, and the target should be left in place
 
154
        self.create_file('target', 'data in target\n')
 
155
        self.assertRaises((IOError, OSError), self._fancy_rename,
 
156
                          'missingsource', 'target')
 
157
        self.failUnlessExists('target')
 
158
        self.check_file_contents('target', 'data in target\n')
 
159
 
 
160
    def test_fancy_rename_fails_if_source_and_target_missing(self):
 
161
        self.assertRaises((IOError, OSError), self._fancy_rename,
 
162
                          'missingsource', 'missingtarget')
 
163
 
109
164
    def test_rename(self):
110
165
        # Rename should be semi-atomic on all platforms
111
 
        open('a', 'wb').write('something in a\n')
 
166
        self.create_file('a', 'something in a\n')
112
167
        osutils.rename('a', 'b')
113
168
        self.failIfExists('a')
114
169
        self.failUnlessExists('b')
115
170
        self.check_file_contents('b', 'something in a\n')
116
171
 
117
 
        open('a', 'wb').write('new something in a\n')
 
172
        self.create_file('a', 'new something in a\n')
118
173
        osutils.rename('b', 'a')
119
174
 
120
175
        self.check_file_contents('a', 'something in a\n')
131
186
        shape = sorted(os.listdir('.'))
132
187
        self.assertEquals(['A', 'B'], shape)
133
188
 
 
189
 
 
190
class TestRandChars(tests.TestCase):
 
191
 
134
192
    def test_01_rand_chars_empty(self):
135
193
        result = osutils.rand_chars(0)
136
194
        self.assertEqual(result, '')
141
199
        self.assertEqual(type(result), str)
142
200
        self.assertContainsRe(result, r'^[a-z0-9]{100}$')
143
201
 
 
202
 
 
203
class TestIsInside(tests.TestCase):
 
204
 
144
205
    def test_is_inside(self):
145
206
        is_inside = osutils.is_inside
146
207
        self.assertTrue(is_inside('src', 'src/foo.c'))
151
212
        self.assertTrue(is_inside('', 'foo.c'))
152
213
 
153
214
    def test_is_inside_any(self):
154
 
        SRC_FOO_C = pathjoin('src', 'foo.c')
 
215
        SRC_FOO_C = osutils.pathjoin('src', 'foo.c')
155
216
        for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
156
217
                         (['src'], SRC_FOO_C),
157
218
                         (['src'], 'src'),
158
219
                         ]:
159
 
            self.assert_(is_inside_any(dirs, fn))
 
220
            self.assert_(osutils.is_inside_any(dirs, fn))
160
221
        for dirs, fn in [(['src'], 'srccontrol'),
161
222
                         (['src'], 'srccontrol/foo')]:
162
 
            self.assertFalse(is_inside_any(dirs, fn))
 
223
            self.assertFalse(osutils.is_inside_any(dirs, fn))
163
224
 
164
225
    def test_is_inside_or_parent_of_any(self):
165
226
        for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
168
229
                         (['src/bar.c', 'bla/foo.c'], 'src'),
169
230
                         (['src'], 'src'),
170
231
                         ]:
171
 
            self.assert_(is_inside_or_parent_of_any(dirs, fn))
 
232
            self.assert_(osutils.is_inside_or_parent_of_any(dirs, fn))
172
233
 
173
234
        for dirs, fn in [(['src'], 'srccontrol'),
174
235
                         (['srccontrol/foo.c'], 'src'),
175
236
                         (['src'], 'srccontrol/foo')]:
176
 
            self.assertFalse(is_inside_or_parent_of_any(dirs, fn))
 
237
            self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
 
238
 
 
239
 
 
240
class TestRmTree(tests.TestCaseInTempDir):
177
241
 
178
242
    def test_rmtree(self):
179
243
        # Check to remove tree with read-only files/dirs
193
257
        self.failIfExists('dir/file')
194
258
        self.failIfExists('dir')
195
259
 
 
260
 
 
261
class TestDeleteAny(tests.TestCaseInTempDir):
 
262
 
 
263
    def test_delete_any_readonly(self):
 
264
        # from <https://bugs.launchpad.net/bzr/+bug/218206>
 
265
        self.build_tree(['d/', 'f'])
 
266
        osutils.make_readonly('d')
 
267
        osutils.make_readonly('f')
 
268
 
 
269
        osutils.delete_any('f')
 
270
        osutils.delete_any('d')
 
271
 
 
272
 
 
273
class TestKind(tests.TestCaseInTempDir):
 
274
 
196
275
    def test_file_kind(self):
197
276
        self.build_tree(['file', 'dir/'])
198
277
        self.assertEquals('file', osutils.file_kind('file'))
228
307
                os.remove('socket')
229
308
 
230
309
    def test_kind_marker(self):
231
 
        self.assertEqual(osutils.kind_marker('file'), '')
232
 
        self.assertEqual(osutils.kind_marker('directory'), '/')
233
 
        self.assertEqual(osutils.kind_marker('symlink'), '@')
234
 
        self.assertEqual(osutils.kind_marker('tree-reference'), '+')
 
310
        self.assertEqual("", osutils.kind_marker("file"))
 
311
        self.assertEqual("/", osutils.kind_marker('directory'))
 
312
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
 
313
        self.assertEqual("@", osutils.kind_marker("symlink"))
 
314
        self.assertEqual("+", osutils.kind_marker("tree-reference"))
 
315
        self.assertEqual("", osutils.kind_marker("fifo"))
 
316
        self.assertEqual("", osutils.kind_marker("socket"))
 
317
        self.assertEqual("", osutils.kind_marker("unknown"))
 
318
 
 
319
 
 
320
class TestUmask(tests.TestCaseInTempDir):
235
321
 
236
322
    def test_get_umask(self):
237
323
        if sys.platform == 'win32':
240
326
            return
241
327
 
242
328
        orig_umask = osutils.get_umask()
243
 
        try:
244
 
            os.umask(0222)
245
 
            self.assertEqual(0222, osutils.get_umask())
246
 
            os.umask(0022)
247
 
            self.assertEqual(0022, osutils.get_umask())
248
 
            os.umask(0002)
249
 
            self.assertEqual(0002, osutils.get_umask())
250
 
            os.umask(0027)
251
 
            self.assertEqual(0027, osutils.get_umask())
252
 
        finally:
253
 
            os.umask(orig_umask)
 
329
        self.addCleanup(os.umask, orig_umask)
 
330
        os.umask(0222)
 
331
        self.assertEqual(0222, osutils.get_umask())
 
332
        os.umask(0022)
 
333
        self.assertEqual(0022, osutils.get_umask())
 
334
        os.umask(0002)
 
335
        self.assertEqual(0002, osutils.get_umask())
 
336
        os.umask(0027)
 
337
        self.assertEqual(0027, osutils.get_umask())
 
338
 
 
339
 
 
340
class TestDateTime(tests.TestCase):
254
341
 
255
342
    def assertFormatedDelta(self, expected, seconds):
256
343
        """Assert osutils.format_delta formats as expected"""
298
385
        # Instead blackbox.test_locale should check for localized
299
386
        # dates once they do occur in output strings.
300
387
 
 
388
    def test_format_date_with_offset_in_original_timezone(self):
 
389
        self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
 
390
            osutils.format_date_with_offset_in_original_timezone(0))
 
391
        self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
 
392
            osutils.format_date_with_offset_in_original_timezone(100000))
 
393
        self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
 
394
            osutils.format_date_with_offset_in_original_timezone(100000, 7200))
 
395
 
 
396
    def test_local_time_offset(self):
 
397
        """Test that local_time_offset() returns a sane value."""
 
398
        offset = osutils.local_time_offset()
 
399
        self.assertTrue(isinstance(offset, int))
 
400
        # Test that the offset is no more than a eighteen hours in
 
401
        # either direction.
 
402
        # Time zone handling is system specific, so it is difficult to
 
403
        # do more specific tests, but a value outside of this range is
 
404
        # probably wrong.
 
405
        eighteen_hours = 18 * 3600
 
406
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
407
 
 
408
    def test_local_time_offset_with_timestamp(self):
 
409
        """Test that local_time_offset() works with a timestamp."""
 
410
        offset = osutils.local_time_offset(1000000000.1234567)
 
411
        self.assertTrue(isinstance(offset, int))
 
412
        eighteen_hours = 18 * 3600
 
413
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
414
 
 
415
 
 
416
class TestLinks(tests.TestCaseInTempDir):
 
417
 
301
418
    def test_dereference_path(self):
302
 
        self.requireFeature(SymlinkFeature)
 
419
        self.requireFeature(tests.SymlinkFeature)
303
420
        cwd = osutils.realpath('.')
304
421
        os.mkdir('bar')
305
422
        bar_path = osutils.pathjoin(cwd, 'bar')
346
463
            osutils.make_readonly('dangling')
347
464
            osutils.make_writable('dangling')
348
465
 
349
 
    def test_kind_marker(self):
350
 
        self.assertEqual("", osutils.kind_marker("file"))
351
 
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
352
 
        self.assertEqual("@", osutils.kind_marker("symlink"))
353
 
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
354
 
 
355
466
    def test_host_os_dereferences_symlinks(self):
356
467
        osutils.host_os_dereferences_symlinks()
357
468
 
358
469
 
359
 
class TestCanonicalRelPath(TestCaseInTempDir):
 
470
class TestCanonicalRelPath(tests.TestCaseInTempDir):
360
471
 
361
 
    _test_needs_features = [CaseInsCasePresFilenameFeature]
 
472
    _test_needs_features = [tests.CaseInsCasePresFilenameFeature]
362
473
 
363
474
    def test_canonical_relpath_simple(self):
364
475
        f = file('MixedCaseName', 'w')
365
476
        f.close()
366
 
        self.failUnlessEqual(
367
 
            canonical_relpath(self.test_base_dir, 'mixedcasename'),
368
 
            'work/MixedCaseName')
 
477
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
 
478
        self.failUnlessEqual('work/MixedCaseName', actual)
369
479
 
370
480
    def test_canonical_relpath_missing_tail(self):
371
481
        os.mkdir('MixedCaseParent')
372
 
        self.failUnlessEqual(
373
 
            canonical_relpath(self.test_base_dir, 'mixedcaseparent/nochild'),
374
 
            'work/MixedCaseParent/nochild')
375
 
 
376
 
 
377
 
class TestPumpFile(TestCase):
 
482
        actual = osutils.canonical_relpath(self.test_base_dir,
 
483
                                           'mixedcaseparent/nochild')
 
484
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
 
485
 
 
486
 
 
487
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
 
488
 
 
489
    def assertRelpath(self, expected, base, path):
 
490
        actual = osutils._cicp_canonical_relpath(base, path)
 
491
        self.assertEqual(expected, actual)
 
492
 
 
493
    def test_simple(self):
 
494
        self.build_tree(['MixedCaseName'])
 
495
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
 
496
        self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
 
497
 
 
498
    def test_subdir_missing_tail(self):
 
499
        self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
 
500
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
 
501
        self.assertRelpath('MixedCaseParent/a_child', base,
 
502
                           'MixedCaseParent/a_child')
 
503
        self.assertRelpath('MixedCaseParent/a_child', base,
 
504
                           'MixedCaseParent/A_Child')
 
505
        self.assertRelpath('MixedCaseParent/not_child', base,
 
506
                           'MixedCaseParent/not_child')
 
507
 
 
508
    def test_at_root_slash(self):
 
509
        # We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
 
510
        # check...
 
511
        if osutils.MIN_ABS_PATHLENGTH > 1:
 
512
            raise tests.TestSkipped('relpath requires %d chars'
 
513
                                    % osutils.MIN_ABS_PATHLENGTH)
 
514
        self.assertRelpath('foo', '/', '/foo')
 
515
 
 
516
    def test_at_root_drive(self):
 
517
        if sys.platform != 'win32':
 
518
            raise tests.TestNotApplicable('we can only test drive-letter relative'
 
519
                                          ' paths on Windows where we have drive'
 
520
                                          ' letters.')
 
521
        # see bug #322807
 
522
        # The specific issue is that when at the root of a drive, 'abspath'
 
523
        # returns "C:/" or just "/". However, the code assumes that abspath
 
524
        # always returns something like "C:/foo" or "/foo" (no trailing slash).
 
525
        self.assertRelpath('foo', 'C:/', 'C:/foo')
 
526
        self.assertRelpath('foo', 'X:/', 'X:/foo')
 
527
        self.assertRelpath('foo', 'X:/', 'X://foo')
 
528
 
 
529
 
 
530
class TestPumpFile(tests.TestCase):
378
531
    """Test pumpfile method."""
 
532
 
379
533
    def setUp(self):
380
 
        TestCase.setUp(self)
 
534
        tests.TestCase.setUp(self)
381
535
        # create a test datablock
382
536
        self.block_size = 512
383
537
        pattern = '0123456789ABCDEF'
390
544
        # make sure test data is larger than max read size
391
545
        self.assertTrue(self.test_data_len > self.block_size)
392
546
 
393
 
        from_file = FakeReadFile(self.test_data)
 
547
        from_file = file_utils.FakeReadFile(self.test_data)
394
548
        to_file = StringIO()
395
549
 
396
550
        # read (max / 2) bytes and verify read size wasn't affected
397
551
        num_bytes_to_read = self.block_size / 2
398
 
        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
552
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
399
553
        self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
400
554
        self.assertEqual(from_file.get_read_count(), 1)
401
555
 
402
556
        # read (max) bytes and verify read size wasn't affected
403
557
        num_bytes_to_read = self.block_size
404
558
        from_file.reset_read_count()
405
 
        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
559
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
406
560
        self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
407
561
        self.assertEqual(from_file.get_read_count(), 1)
408
562
 
409
563
        # read (max + 1) bytes and verify read size was limited
410
564
        num_bytes_to_read = self.block_size + 1
411
565
        from_file.reset_read_count()
412
 
        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
566
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
413
567
        self.assertEqual(from_file.get_max_read_size(), self.block_size)
414
568
        self.assertEqual(from_file.get_read_count(), 2)
415
569
 
416
570
        # finish reading the rest of the data
417
571
        num_bytes_to_read = self.test_data_len - to_file.tell()
418
 
        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
572
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
419
573
 
420
574
        # report error if the data wasn't equal (we only report the size due
421
575
        # to the length of the data)
431
585
        self.assertTrue(self.test_data_len > self.block_size)
432
586
 
433
587
        # retrieve data in blocks
434
 
        from_file = FakeReadFile(self.test_data)
 
588
        from_file = file_utils.FakeReadFile(self.test_data)
435
589
        to_file = StringIO()
436
 
        pumpfile(from_file, to_file, self.test_data_len, self.block_size)
 
590
        osutils.pumpfile(from_file, to_file, self.test_data_len,
 
591
                         self.block_size)
437
592
 
438
593
        # verify read size was equal to the maximum read size
439
594
        self.assertTrue(from_file.get_max_read_size() > 0)
454
609
        self.assertTrue(self.test_data_len > self.block_size)
455
610
 
456
611
        # retrieve data to EOF
457
 
        from_file = FakeReadFile(self.test_data)
 
612
        from_file = file_utils.FakeReadFile(self.test_data)
458
613
        to_file = StringIO()
459
 
        pumpfile(from_file, to_file, -1, self.block_size)
 
614
        osutils.pumpfile(from_file, to_file, -1, self.block_size)
460
615
 
461
616
        # verify read size was equal to the maximum read size
462
617
        self.assertEqual(from_file.get_max_read_size(), self.block_size)
474
629
        test verifies that any existing usages of pumpfile will not be broken
475
630
        with this new version."""
476
631
        # retrieve data using default (old) pumpfile method
477
 
        from_file = FakeReadFile(self.test_data)
 
632
        from_file = file_utils.FakeReadFile(self.test_data)
478
633
        to_file = StringIO()
479
 
        pumpfile(from_file, to_file)
 
634
        osutils.pumpfile(from_file, to_file)
480
635
 
481
636
        # report error if the data wasn't equal (we only report the size due
482
637
        # to the length of the data)
491
646
            activity.append((length, direction))
492
647
        from_file = StringIO(self.test_data)
493
648
        to_file = StringIO()
494
 
        pumpfile(from_file, to_file, buff_size=500,
495
 
                 report_activity=log_activity, direction='read')
 
649
        osutils.pumpfile(from_file, to_file, buff_size=500,
 
650
                         report_activity=log_activity, direction='read')
496
651
        self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
497
652
                          (36, 'read')], activity)
498
653
 
499
654
        from_file = StringIO(self.test_data)
500
655
        to_file = StringIO()
501
656
        del activity[:]
502
 
        pumpfile(from_file, to_file, buff_size=500,
503
 
                 report_activity=log_activity, direction='write')
 
657
        osutils.pumpfile(from_file, to_file, buff_size=500,
 
658
                         report_activity=log_activity, direction='write')
504
659
        self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
505
660
                          (36, 'write')], activity)
506
661
 
508
663
        from_file = StringIO(self.test_data)
509
664
        to_file = StringIO()
510
665
        del activity[:]
511
 
        pumpfile(from_file, to_file, buff_size=500, read_length=1028,
512
 
                 report_activity=log_activity, direction='read')
 
666
        osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
 
667
                         report_activity=log_activity, direction='read')
513
668
        self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
514
669
 
515
670
 
516
671
 
517
 
class TestPumpStringFile(TestCase):
 
672
class TestPumpStringFile(tests.TestCase):
518
673
 
519
674
    def test_empty(self):
520
675
        output = StringIO()
521
 
        pump_string_file("", output)
 
676
        osutils.pump_string_file("", output)
522
677
        self.assertEqual("", output.getvalue())
523
678
 
524
679
    def test_more_than_segment_size(self):
525
680
        output = StringIO()
526
 
        pump_string_file("123456789", output, 2)
 
681
        osutils.pump_string_file("123456789", output, 2)
527
682
        self.assertEqual("123456789", output.getvalue())
528
683
 
529
684
    def test_segment_size(self):
530
685
        output = StringIO()
531
 
        pump_string_file("12", output, 2)
 
686
        osutils.pump_string_file("12", output, 2)
532
687
        self.assertEqual("12", output.getvalue())
533
688
 
534
689
    def test_segment_size_multiple(self):
535
690
        output = StringIO()
536
 
        pump_string_file("1234", output, 2)
 
691
        osutils.pump_string_file("1234", output, 2)
537
692
        self.assertEqual("1234", output.getvalue())
538
693
 
539
694
 
540
 
class TestSafeUnicode(TestCase):
 
695
class TestRelpath(tests.TestCase):
 
696
 
 
697
    def test_simple_relpath(self):
 
698
        cwd = osutils.getcwd()
 
699
        subdir = cwd + '/subdir'
 
700
        self.assertEqual('subdir', osutils.relpath(cwd, subdir))
 
701
 
 
702
    def test_deep_relpath(self):
 
703
        cwd = osutils.getcwd()
 
704
        subdir = cwd + '/sub/subsubdir'
 
705
        self.assertEqual('sub/subsubdir', osutils.relpath(cwd, subdir))
 
706
 
 
707
    def test_not_relative(self):
 
708
        self.assertRaises(errors.PathNotChild,
 
709
                          osutils.relpath, 'C:/path', 'H:/path')
 
710
        self.assertRaises(errors.PathNotChild,
 
711
                          osutils.relpath, 'C:/', 'H:/path')
 
712
 
 
713
 
 
714
class TestSafeUnicode(tests.TestCase):
541
715
 
542
716
    def test_from_ascii_string(self):
543
717
        self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
552
726
        self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
553
727
 
554
728
    def test_bad_utf8_string(self):
555
 
        self.assertRaises(BzrBadParameterNotUnicode,
 
729
        self.assertRaises(errors.BzrBadParameterNotUnicode,
556
730
                          osutils.safe_unicode,
557
731
                          '\xbb\xbb')
558
732
 
559
733
 
560
 
class TestSafeUtf8(TestCase):
 
734
class TestSafeUtf8(tests.TestCase):
561
735
 
562
736
    def test_from_ascii_string(self):
563
737
        f = 'foobar'
573
747
        self.assertEqual('foo\xc2\xae', osutils.safe_utf8('foo\xc2\xae'))
574
748
 
575
749
    def test_bad_utf8_string(self):
576
 
        self.assertRaises(BzrBadParameterNotUnicode,
 
750
        self.assertRaises(errors.BzrBadParameterNotUnicode,
577
751
                          osutils.safe_utf8, '\xbb\xbb')
578
752
 
579
753
 
580
 
class TestSafeRevisionId(TestCase):
 
754
class TestSafeRevisionId(tests.TestCase):
581
755
 
582
756
    def test_from_ascii_string(self):
583
757
        # this shouldn't give a warning because it's getting an ascii string
605
779
        self.assertEqual(None, osutils.safe_revision_id(None))
606
780
 
607
781
 
608
 
class TestSafeFileId(TestCase):
 
782
class TestSafeFileId(tests.TestCase):
609
783
 
610
784
    def test_from_ascii_string(self):
611
785
        self.assertEqual('foobar', osutils.safe_file_id('foobar'))
631
805
        self.assertEqual(None, osutils.safe_file_id(None))
632
806
 
633
807
 
634
 
class TestWin32Funcs(TestCase):
635
 
    """Test that the _win32 versions of os utilities return appropriate paths."""
 
808
class TestWin32Funcs(tests.TestCase):
 
809
    """Test that _win32 versions of os utilities return appropriate paths."""
636
810
 
637
811
    def test_abspath(self):
638
812
        self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
645
819
        self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
646
820
 
647
821
    def test_pathjoin(self):
648
 
        self.assertEqual('path/to/foo', osutils._win32_pathjoin('path', 'to', 'foo'))
649
 
        self.assertEqual('C:/foo', osutils._win32_pathjoin('path\\to', 'C:\\foo'))
650
 
        self.assertEqual('C:/foo', osutils._win32_pathjoin('path/to', 'C:/foo'))
651
 
        self.assertEqual('path/to/foo', osutils._win32_pathjoin('path/to/', 'foo'))
652
 
        self.assertEqual('/foo', osutils._win32_pathjoin('C:/path/to/', '/foo'))
653
 
        self.assertEqual('/foo', osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
 
822
        self.assertEqual('path/to/foo',
 
823
                         osutils._win32_pathjoin('path', 'to', 'foo'))
 
824
        self.assertEqual('C:/foo',
 
825
                         osutils._win32_pathjoin('path\\to', 'C:\\foo'))
 
826
        self.assertEqual('C:/foo',
 
827
                         osutils._win32_pathjoin('path/to', 'C:/foo'))
 
828
        self.assertEqual('path/to/foo',
 
829
                         osutils._win32_pathjoin('path/to/', 'foo'))
 
830
        self.assertEqual('/foo',
 
831
                         osutils._win32_pathjoin('C:/path/to/', '/foo'))
 
832
        self.assertEqual('/foo',
 
833
                         osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
654
834
 
655
835
    def test_normpath(self):
656
 
        self.assertEqual('path/to/foo', osutils._win32_normpath(r'path\\from\..\to\.\foo'))
657
 
        self.assertEqual('path/to/foo', osutils._win32_normpath('path//from/../to/./foo'))
 
836
        self.assertEqual('path/to/foo',
 
837
                         osutils._win32_normpath(r'path\\from\..\to\.\foo'))
 
838
        self.assertEqual('path/to/foo',
 
839
                         osutils._win32_normpath('path//from/../to/./foo'))
658
840
 
659
841
    def test_getcwd(self):
660
842
        cwd = osutils._win32_getcwd()
681
863
        self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
682
864
        # relative path
683
865
        cwd = osutils.getcwd().rstrip('/')
684
 
        drive = osutils._nt_splitdrive(cwd)[0]
 
866
        drive = osutils.ntpath.splitdrive(cwd)[0]
685
867
        self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
686
868
        self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
687
869
        # unicode path
689
871
        self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
690
872
 
691
873
 
692
 
class TestWin32FuncsDirs(TestCaseInTempDir):
 
874
class TestWin32FuncsDirs(tests.TestCaseInTempDir):
693
875
    """Test win32 functions that create files."""
694
876
 
695
877
    def test_getcwd(self):
696
 
        if win32utils.winver == 'Windows 98':
697
 
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
698
 
        # Make sure getcwd can handle unicode filenames
699
 
        try:
700
 
            os.mkdir(u'mu-\xb5')
701
 
        except UnicodeError:
702
 
            raise TestSkipped("Unable to create Unicode filename")
703
 
 
 
878
        self.requireFeature(tests.UnicodeFilenameFeature)
 
879
        os.mkdir(u'mu-\xb5')
704
880
        os.chdir(u'mu-\xb5')
705
881
        # TODO: jam 20060427 This will probably fail on Mac OSX because
706
882
        #       it will change the normalization of B\xe5gfors
711
887
    def test_minimum_path_selection(self):
712
888
        self.assertEqual(set(),
713
889
            osutils.minimum_path_selection([]))
 
890
        self.assertEqual(set(['a']),
 
891
            osutils.minimum_path_selection(['a']))
714
892
        self.assertEqual(set(['a', 'b']),
715
893
            osutils.minimum_path_selection(['a', 'b']))
716
894
        self.assertEqual(set(['a/', 'b']),
717
895
            osutils.minimum_path_selection(['a/', 'b']))
718
896
        self.assertEqual(set(['a/', 'b']),
719
897
            osutils.minimum_path_selection(['a/c', 'a/', 'b']))
 
898
        self.assertEqual(set(['a-b', 'a', 'a0b']),
 
899
            osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
720
900
 
721
901
    def test_mkdtemp(self):
722
902
        tmpdir = osutils._win32_mkdtemp(dir='.')
778
958
        self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
779
959
 
780
960
 
781
 
class TestMacFuncsDirs(TestCaseInTempDir):
 
961
class TestParentDirectories(tests.TestCaseInTempDir):
 
962
    """Test osutils.parent_directories()"""
 
963
 
 
964
    def test_parent_directories(self):
 
965
        self.assertEqual([], osutils.parent_directories('a'))
 
966
        self.assertEqual(['a'], osutils.parent_directories('a/b'))
 
967
        self.assertEqual(['a/b', 'a'], osutils.parent_directories('a/b/c'))
 
968
 
 
969
 
 
970
class TestMacFuncsDirs(tests.TestCaseInTempDir):
782
971
    """Test mac special functions that require directories."""
783
972
 
784
973
    def test_getcwd(self):
785
 
        # On Mac, this will actually create Ba\u030agfors
786
 
        # but chdir will still work, because it accepts both paths
787
 
        try:
788
 
            os.mkdir(u'B\xe5gfors')
789
 
        except UnicodeError:
790
 
            raise TestSkipped("Unable to create Unicode filename")
791
 
 
 
974
        self.requireFeature(tests.UnicodeFilenameFeature)
 
975
        os.mkdir(u'B\xe5gfors')
792
976
        os.chdir(u'B\xe5gfors')
793
977
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
794
978
 
795
979
    def test_getcwd_nonnorm(self):
 
980
        self.requireFeature(tests.UnicodeFilenameFeature)
796
981
        # Test that _mac_getcwd() will normalize this path
797
 
        try:
798
 
            os.mkdir(u'Ba\u030agfors')
799
 
        except UnicodeError:
800
 
            raise TestSkipped("Unable to create Unicode filename")
801
 
 
 
982
        os.mkdir(u'Ba\u030agfors')
802
983
        os.chdir(u'Ba\u030agfors')
803
984
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
804
985
 
805
986
 
806
 
class TestChunksToLines(TestCase):
 
987
class TestChunksToLines(tests.TestCase):
807
988
 
808
989
    def test_smoketest(self):
809
990
        self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
813
994
 
814
995
    def test_osutils_binding(self):
815
996
        from bzrlib.tests import test__chunks_to_lines
816
 
        if test__chunks_to_lines.CompiledChunksToLinesFeature.available():
 
997
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
817
998
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
818
999
        else:
819
1000
            from bzrlib._chunks_to_lines_py import chunks_to_lines
820
1001
        self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
821
1002
 
822
1003
 
823
 
class TestSplitLines(TestCase):
 
1004
class TestSplitLines(tests.TestCase):
824
1005
 
825
1006
    def test_split_unicode(self):
826
1007
        self.assertEqual([u'foo\n', u'bar\xae'],
833
1014
                         osutils.split_lines('foo\rbar\n'))
834
1015
 
835
1016
 
836
 
class TestWalkDirs(TestCaseInTempDir):
 
1017
class TestWalkDirs(tests.TestCaseInTempDir):
 
1018
 
 
1019
    def assertExpectedBlocks(self, expected, result):
 
1020
        self.assertEqual(expected,
 
1021
                         [(dirinfo, [line[0:3] for line in block])
 
1022
                          for dirinfo, block in result])
837
1023
 
838
1024
    def test_walkdirs(self):
839
1025
        tree = [
872
1058
            result.append((dirdetail, dirblock))
873
1059
 
874
1060
        self.assertTrue(found_bzrdir)
875
 
        self.assertEqual(expected_dirblocks,
876
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
1061
        self.assertExpectedBlocks(expected_dirblocks, result)
877
1062
        # you can search a subdir only, with a supplied prefix.
878
1063
        result = []
879
1064
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
880
1065
            result.append(dirblock)
881
 
        self.assertEqual(expected_dirblocks[1:],
882
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
1066
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
883
1067
 
884
1068
    def test_walkdirs_os_error(self):
885
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/338653>
 
1069
        # <https://bugs.launchpad.net/bzr/+bug/338653>
886
1070
        # Pyrex readdir didn't raise useful messages if it had an error
887
1071
        # reading the directory
888
1072
        if sys.platform == 'win32':
891
1075
        os.mkdir("test-unreadable")
892
1076
        os.chmod("test-unreadable", 0000)
893
1077
        # must chmod it back so that it can be removed
894
 
        self.addCleanup(lambda: os.chmod("test-unreadable", 0700))
 
1078
        self.addCleanup(os.chmod, "test-unreadable", 0700)
895
1079
        # The error is not raised until the generator is actually evaluated.
896
1080
        # (It would be ok if it happened earlier but at the moment it
897
1081
        # doesn't.)
901
1085
        # Ensure the message contains the file name
902
1086
        self.assertContainsRe(str(e), "\./test-unreadable")
903
1087
 
 
1088
 
 
1089
    def test_walkdirs_encoding_error(self):
 
1090
        # <https://bugs.launchpad.net/bzr/+bug/488519>
 
1091
        # walkdirs didn't raise a useful message when the filenames
 
1092
        # are not using the filesystem's encoding
 
1093
 
 
1094
        # require a bytestring based filesystem
 
1095
        self.requireFeature(tests.ByteStringNamedFilesystem)
 
1096
 
 
1097
        tree = [
 
1098
            '.bzr',
 
1099
            '0file',
 
1100
            '1dir/',
 
1101
            '1dir/0file',
 
1102
            '1dir/1dir/',
 
1103
            '1file'
 
1104
            ]
 
1105
 
 
1106
        self.build_tree(tree)
 
1107
 
 
1108
        # rename the 1file to a latin-1 filename
 
1109
        os.rename("./1file", "\xe8file")
 
1110
 
 
1111
        self._save_platform_info()
 
1112
        win32utils.winver = None # Avoid the win32 detection code
 
1113
        osutils._fs_enc = 'UTF-8'
 
1114
 
 
1115
        # this should raise on error
 
1116
        def attempt():
 
1117
            for dirdetail, dirblock in osutils.walkdirs('.'):
 
1118
                pass
 
1119
 
 
1120
        self.assertRaises(errors.BadFilenameEncoding, attempt)
 
1121
 
904
1122
    def test__walkdirs_utf8(self):
905
1123
        tree = [
906
1124
            '.bzr',
938
1156
            result.append((dirdetail, dirblock))
939
1157
 
940
1158
        self.assertTrue(found_bzrdir)
941
 
        self.assertEqual(expected_dirblocks,
942
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
1159
        self.assertExpectedBlocks(expected_dirblocks, result)
 
1160
 
943
1161
        # you can search a subdir only, with a supplied prefix.
944
1162
        result = []
945
1163
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
946
1164
            result.append(dirblock)
947
 
        self.assertEqual(expected_dirblocks[1:],
948
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
1165
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
949
1166
 
950
1167
    def _filter_out_stat(self, result):
951
1168
        """Filter out the stat value from the walkdirs result"""
957
1174
            dirblock[:] = new_dirblock
958
1175
 
959
1176
    def _save_platform_info(self):
960
 
        cur_winver = win32utils.winver
961
 
        cur_fs_enc = osutils._fs_enc
962
 
        cur_dir_reader = osutils._selected_dir_reader
963
 
        def restore():
964
 
            win32utils.winver = cur_winver
965
 
            osutils._fs_enc = cur_fs_enc
966
 
            osutils._selected_dir_reader = cur_dir_reader
967
 
        self.addCleanup(restore)
 
1177
        self.overrideAttr(win32utils, 'winver')
 
1178
        self.overrideAttr(osutils, '_fs_enc')
 
1179
        self.overrideAttr(osutils, '_selected_dir_reader')
968
1180
 
969
 
    def assertReadFSDirIs(self, expected):
 
1181
    def assertDirReaderIs(self, expected):
970
1182
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
971
1183
        # Force it to redetect
972
1184
        osutils._selected_dir_reader = None
979
1191
        self._save_platform_info()
980
1192
        win32utils.winver = None # Avoid the win32 detection code
981
1193
        osutils._fs_enc = 'UTF-8'
982
 
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
 
1194
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
983
1195
 
984
1196
    def test_force_walkdirs_utf8_fs_ascii(self):
985
1197
        self.requireFeature(UTF8DirReaderFeature)
986
1198
        self._save_platform_info()
987
1199
        win32utils.winver = None # Avoid the win32 detection code
988
1200
        osutils._fs_enc = 'US-ASCII'
989
 
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
 
1201
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
990
1202
 
991
1203
    def test_force_walkdirs_utf8_fs_ANSI(self):
992
1204
        self.requireFeature(UTF8DirReaderFeature)
993
1205
        self._save_platform_info()
994
1206
        win32utils.winver = None # Avoid the win32 detection code
995
1207
        osutils._fs_enc = 'ANSI_X3.4-1968'
996
 
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
 
1208
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
997
1209
 
998
1210
    def test_force_walkdirs_utf8_fs_latin1(self):
999
1211
        self._save_platform_info()
1000
1212
        win32utils.winver = None # Avoid the win32 detection code
1001
1213
        osutils._fs_enc = 'latin1'
1002
 
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
 
1214
        self.assertDirReaderIs(osutils.UnicodeDirReader)
1003
1215
 
1004
1216
    def test_force_walkdirs_utf8_nt(self):
1005
1217
        # Disabled because the thunk of the whole walkdirs api is disabled.
1006
 
        self.requireFeature(Win32ReadDirFeature)
 
1218
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1007
1219
        self._save_platform_info()
1008
1220
        win32utils.winver = 'Windows NT'
1009
1221
        from bzrlib._walkdirs_win32 import Win32ReadDir
1010
 
        self.assertReadFSDirIs(Win32ReadDir)
 
1222
        self.assertDirReaderIs(Win32ReadDir)
1011
1223
 
1012
1224
    def test_force_walkdirs_utf8_98(self):
1013
 
        self.requireFeature(Win32ReadDirFeature)
 
1225
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1014
1226
        self._save_platform_info()
1015
1227
        win32utils.winver = 'Windows 98'
1016
 
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
 
1228
        self.assertDirReaderIs(osutils.UnicodeDirReader)
1017
1229
 
1018
1230
    def test_unicode_walkdirs(self):
1019
1231
        """Walkdirs should always return unicode paths."""
 
1232
        self.requireFeature(tests.UnicodeFilenameFeature)
1020
1233
        name0 = u'0file-\xb6'
1021
1234
        name1 = u'1dir-\u062c\u0648'
1022
1235
        name2 = u'2file-\u0633'
1027
1240
            name1 + '/' + name1 + '/',
1028
1241
            name2,
1029
1242
            ]
1030
 
        try:
1031
 
            self.build_tree(tree)
1032
 
        except UnicodeError:
1033
 
            raise TestSkipped('Could not represent Unicode chars'
1034
 
                              ' in current encoding.')
 
1243
        self.build_tree(tree)
1035
1244
        expected_dirblocks = [
1036
1245
                ((u'', u'.'),
1037
1246
                 [(name0, name0, 'file', './' + name0),
1063
1272
 
1064
1273
        The abspath portion might be in unicode or utf-8
1065
1274
        """
 
1275
        self.requireFeature(tests.UnicodeFilenameFeature)
1066
1276
        name0 = u'0file-\xb6'
1067
1277
        name1 = u'1dir-\u062c\u0648'
1068
1278
        name2 = u'2file-\u0633'
1073
1283
            name1 + '/' + name1 + '/',
1074
1284
            name2,
1075
1285
            ]
1076
 
        try:
1077
 
            self.build_tree(tree)
1078
 
        except UnicodeError:
1079
 
            raise TestSkipped('Could not represent Unicode chars'
1080
 
                              ' in current encoding.')
 
1286
        self.build_tree(tree)
1081
1287
        name0 = name0.encode('utf8')
1082
1288
        name1 = name1.encode('utf8')
1083
1289
        name2 = name2.encode('utf8')
1127
1333
 
1128
1334
        The abspath portion should be in unicode
1129
1335
        """
 
1336
        self.requireFeature(tests.UnicodeFilenameFeature)
1130
1337
        # Use the unicode reader. TODO: split into driver-and-driven unit
1131
1338
        # tests.
1132
1339
        self._save_platform_info()
1141
1348
            name1u + '/' + name1u + '/',
1142
1349
            name2u,
1143
1350
            ]
1144
 
        try:
1145
 
            self.build_tree(tree)
1146
 
        except UnicodeError:
1147
 
            raise TestSkipped('Could not represent Unicode chars'
1148
 
                              ' in current encoding.')
 
1351
        self.build_tree(tree)
1149
1352
        name0 = name0u.encode('utf8')
1150
1353
        name1 = name1u.encode('utf8')
1151
1354
        name2 = name2u.encode('utf8')
1176
1379
        self.assertEqual(expected_dirblocks, result)
1177
1380
 
1178
1381
    def test__walkdirs_utf8_win32readdir(self):
1179
 
        self.requireFeature(Win32ReadDirFeature)
 
1382
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1180
1383
        self.requireFeature(tests.UnicodeFilenameFeature)
1181
1384
        from bzrlib._walkdirs_win32 import Win32ReadDir
1182
1385
        self._save_platform_info()
1233
1436
 
1234
1437
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1235
1438
        """make sure our Stat values are valid"""
1236
 
        self.requireFeature(Win32ReadDirFeature)
 
1439
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1237
1440
        self.requireFeature(tests.UnicodeFilenameFeature)
1238
1441
        from bzrlib._walkdirs_win32 import Win32ReadDir
1239
1442
        name0u = u'0file-\xb6'
1257
1460
 
1258
1461
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1259
1462
        """make sure our Stat values are valid"""
1260
 
        self.requireFeature(Win32ReadDirFeature)
 
1463
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
1261
1464
        self.requireFeature(tests.UnicodeFilenameFeature)
1262
1465
        from bzrlib._walkdirs_win32 import Win32ReadDir
1263
1466
        name0u = u'0dir-\u062c\u0648'
1348
1551
            sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
1349
1552
 
1350
1553
 
1351
 
class TestCopyTree(TestCaseInTempDir):
 
1554
class TestCopyTree(tests.TestCaseInTempDir):
1352
1555
 
1353
1556
    def test_copy_basic_tree(self):
1354
1557
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1364
1567
        self.assertEqual(['c'], os.listdir('target/b'))
1365
1568
 
1366
1569
    def test_copy_tree_symlinks(self):
1367
 
        self.requireFeature(SymlinkFeature)
 
1570
        self.requireFeature(tests.SymlinkFeature)
1368
1571
        self.build_tree(['source/'])
1369
1572
        os.symlink('a/generic/path', 'source/lnk')
1370
1573
        osutils.copy_tree('source', 'target')
1400
1603
            self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1401
1604
 
1402
1605
 
1403
 
#class TestTerminalEncoding has been moved to test_osutils_encodings.py
1404
 
# [bialix] 2006/12/26
1405
 
 
1406
 
 
1407
 
class TestSetUnsetEnv(TestCase):
 
1606
class TestSetUnsetEnv(tests.TestCase):
1408
1607
    """Test updating the environment"""
1409
1608
 
1410
1609
    def setUp(self):
1416
1615
        def cleanup():
1417
1616
            if 'BZR_TEST_ENV_VAR' in os.environ:
1418
1617
                del os.environ['BZR_TEST_ENV_VAR']
1419
 
 
1420
1618
        self.addCleanup(cleanup)
1421
1619
 
1422
1620
    def test_set(self):
1437
1635
 
1438
1636
        So Unicode strings must be encoded.
1439
1637
        """
1440
 
        uni_val, env_val = probe_unicode_in_user_encoding()
 
1638
        uni_val, env_val = tests.probe_unicode_in_user_encoding()
1441
1639
        if uni_val is None:
1442
 
            raise TestSkipped('Cannot find a unicode character that works in'
1443
 
                              ' encoding %s' % (osutils.get_user_encoding(),))
 
1640
            raise tests.TestSkipped(
 
1641
                'Cannot find a unicode character that works in encoding %s'
 
1642
                % (osutils.get_user_encoding(),))
1444
1643
 
1445
1644
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1446
1645
        self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
1454
1653
        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1455
1654
 
1456
1655
 
1457
 
class TestLocalTimeOffset(TestCase):
1458
 
 
1459
 
    def test_local_time_offset(self):
1460
 
        """Test that local_time_offset() returns a sane value."""
1461
 
        offset = osutils.local_time_offset()
1462
 
        self.assertTrue(isinstance(offset, int))
1463
 
        # Test that the offset is no more than a eighteen hours in
1464
 
        # either direction.
1465
 
        # Time zone handling is system specific, so it is difficult to
1466
 
        # do more specific tests, but a value outside of this range is
1467
 
        # probably wrong.
1468
 
        eighteen_hours = 18 * 3600
1469
 
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1470
 
 
1471
 
    def test_local_time_offset_with_timestamp(self):
1472
 
        """Test that local_time_offset() works with a timestamp."""
1473
 
        offset = osutils.local_time_offset(1000000000.1234567)
1474
 
        self.assertTrue(isinstance(offset, int))
1475
 
        eighteen_hours = 18 * 3600
1476
 
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1477
 
 
1478
 
 
1479
 
class TestSizeShaFile(TestCaseInTempDir):
 
1656
class TestSizeShaFile(tests.TestCaseInTempDir):
1480
1657
 
1481
1658
    def test_sha_empty(self):
1482
1659
        self.build_tree_contents([('foo', '')])
1491
1668
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
1492
1669
        self.build_tree_contents([('foo', text)])
1493
1670
        expected_sha = osutils.sha_string(text)
1494
 
        f = open('foo')
 
1671
        f = open('foo', 'rb')
1495
1672
        self.addCleanup(f.close)
1496
1673
        size, sha = osutils.size_sha_file(f)
1497
1674
        self.assertEqual(38, size)
1498
1675
        self.assertEqual(expected_sha, sha)
1499
1676
 
1500
1677
 
1501
 
class TestShaFileByName(TestCaseInTempDir):
 
1678
class TestShaFileByName(tests.TestCaseInTempDir):
1502
1679
 
1503
1680
    def test_sha_empty(self):
1504
1681
        self.build_tree_contents([('foo', '')])
1512
1689
        self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1513
1690
 
1514
1691
 
1515
 
class TestResourceLoading(TestCaseInTempDir):
 
1692
class TestResourceLoading(tests.TestCaseInTempDir):
1516
1693
 
1517
1694
    def test_resource_string(self):
1518
1695
        # test resource in bzrlib
1528
1705
        self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1529
1706
 
1530
1707
 
1531
 
class TestReCompile(TestCase):
 
1708
class TestReCompile(tests.TestCase):
 
1709
 
 
1710
    def _deprecated_re_compile_checked(self, *args, **kwargs):
 
1711
        return self.applyDeprecated(symbol_versioning.deprecated_in((2, 2, 0)),
 
1712
            osutils.re_compile_checked, *args, **kwargs)
1532
1713
 
1533
1714
    def test_re_compile_checked(self):
1534
 
        r = osutils.re_compile_checked(r'A*', re.IGNORECASE)
 
1715
        r = self._deprecated_re_compile_checked(r'A*', re.IGNORECASE)
1535
1716
        self.assertTrue(r.match('aaaa'))
1536
1717
        self.assertTrue(r.match('aAaA'))
1537
1718
 
1538
1719
    def test_re_compile_checked_error(self):
1539
1720
        # like https://bugs.launchpad.net/bzr/+bug/251352
 
1721
 
 
1722
        # Due to possible test isolation error, re.compile is not lazy at
 
1723
        # this point. We re-install lazy compile.
 
1724
        lazy_regex.install_lazy_compile()
1540
1725
        err = self.assertRaises(
1541
1726
            errors.BzrCommandError,
1542
 
            osutils.re_compile_checked, '*', re.IGNORECASE, 'test case')
 
1727
            self._deprecated_re_compile_checked, '*', re.IGNORECASE, 'test case')
1543
1728
        self.assertEqual(
1544
 
            "Invalid regular expression in test case: '*': "
1545
 
            "nothing to repeat",
 
1729
            'Invalid regular expression in test case: '
 
1730
            '"*" nothing to repeat',
1546
1731
            str(err))
 
1732
 
 
1733
 
 
1734
class TestDirReader(tests.TestCaseInTempDir):
 
1735
 
 
1736
    # Set by load_tests
 
1737
    _dir_reader_class = None
 
1738
    _native_to_unicode = None
 
1739
 
 
1740
    def setUp(self):
 
1741
        tests.TestCaseInTempDir.setUp(self)
 
1742
        self.overrideAttr(osutils,
 
1743
                          '_selected_dir_reader', self._dir_reader_class())
 
1744
 
 
1745
    def _get_ascii_tree(self):
 
1746
        tree = [
 
1747
            '0file',
 
1748
            '1dir/',
 
1749
            '1dir/0file',
 
1750
            '1dir/1dir/',
 
1751
            '2file'
 
1752
            ]
 
1753
        expected_dirblocks = [
 
1754
                (('', '.'),
 
1755
                 [('0file', '0file', 'file'),
 
1756
                  ('1dir', '1dir', 'directory'),
 
1757
                  ('2file', '2file', 'file'),
 
1758
                 ]
 
1759
                ),
 
1760
                (('1dir', './1dir'),
 
1761
                 [('1dir/0file', '0file', 'file'),
 
1762
                  ('1dir/1dir', '1dir', 'directory'),
 
1763
                 ]
 
1764
                ),
 
1765
                (('1dir/1dir', './1dir/1dir'),
 
1766
                 [
 
1767
                 ]
 
1768
                ),
 
1769
            ]
 
1770
        return tree, expected_dirblocks
 
1771
 
 
1772
    def test_walk_cur_dir(self):
 
1773
        tree, expected_dirblocks = self._get_ascii_tree()
 
1774
        self.build_tree(tree)
 
1775
        result = list(osutils._walkdirs_utf8('.'))
 
1776
        # Filter out stat and abspath
 
1777
        self.assertEqual(expected_dirblocks,
 
1778
                         [(dirinfo, [line[0:3] for line in block])
 
1779
                          for dirinfo, block in result])
 
1780
 
 
1781
    def test_walk_sub_dir(self):
 
1782
        tree, expected_dirblocks = self._get_ascii_tree()
 
1783
        self.build_tree(tree)
 
1784
        # you can search a subdir only, with a supplied prefix.
 
1785
        result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
 
1786
        # Filter out stat and abspath
 
1787
        self.assertEqual(expected_dirblocks[1:],
 
1788
                         [(dirinfo, [line[0:3] for line in block])
 
1789
                          for dirinfo, block in result])
 
1790
 
 
1791
    def _get_unicode_tree(self):
 
1792
        name0u = u'0file-\xb6'
 
1793
        name1u = u'1dir-\u062c\u0648'
 
1794
        name2u = u'2file-\u0633'
 
1795
        tree = [
 
1796
            name0u,
 
1797
            name1u + '/',
 
1798
            name1u + '/' + name0u,
 
1799
            name1u + '/' + name1u + '/',
 
1800
            name2u,
 
1801
            ]
 
1802
        name0 = name0u.encode('UTF-8')
 
1803
        name1 = name1u.encode('UTF-8')
 
1804
        name2 = name2u.encode('UTF-8')
 
1805
        expected_dirblocks = [
 
1806
                (('', '.'),
 
1807
                 [(name0, name0, 'file', './' + name0u),
 
1808
                  (name1, name1, 'directory', './' + name1u),
 
1809
                  (name2, name2, 'file', './' + name2u),
 
1810
                 ]
 
1811
                ),
 
1812
                ((name1, './' + name1u),
 
1813
                 [(name1 + '/' + name0, name0, 'file', './' + name1u
 
1814
                                                        + '/' + name0u),
 
1815
                  (name1 + '/' + name1, name1, 'directory', './' + name1u
 
1816
                                                            + '/' + name1u),
 
1817
                 ]
 
1818
                ),
 
1819
                ((name1 + '/' + name1, './' + name1u + '/' + name1u),
 
1820
                 [
 
1821
                 ]
 
1822
                ),
 
1823
            ]
 
1824
        return tree, expected_dirblocks
 
1825
 
 
1826
    def _filter_out(self, raw_dirblocks):
 
1827
        """Filter out a walkdirs_utf8 result.
 
1828
 
 
1829
        stat field is removed, all native paths are converted to unicode
 
1830
        """
 
1831
        filtered_dirblocks = []
 
1832
        for dirinfo, block in raw_dirblocks:
 
1833
            dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
 
1834
            details = []
 
1835
            for line in block:
 
1836
                details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
 
1837
            filtered_dirblocks.append((dirinfo, details))
 
1838
        return filtered_dirblocks
 
1839
 
 
1840
    def test_walk_unicode_tree(self):
 
1841
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1842
        tree, expected_dirblocks = self._get_unicode_tree()
 
1843
        self.build_tree(tree)
 
1844
        result = list(osutils._walkdirs_utf8('.'))
 
1845
        self.assertEqual(expected_dirblocks, self._filter_out(result))
 
1846
 
 
1847
    def test_symlink(self):
 
1848
        self.requireFeature(tests.SymlinkFeature)
 
1849
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1850
        target = u'target\N{Euro Sign}'
 
1851
        link_name = u'l\N{Euro Sign}nk'
 
1852
        os.symlink(target, link_name)
 
1853
        target_utf8 = target.encode('UTF-8')
 
1854
        link_name_utf8 = link_name.encode('UTF-8')
 
1855
        expected_dirblocks = [
 
1856
                (('', '.'),
 
1857
                 [(link_name_utf8, link_name_utf8,
 
1858
                   'symlink', './' + link_name),],
 
1859
                 )]
 
1860
        result = list(osutils._walkdirs_utf8('.'))
 
1861
        self.assertEqual(expected_dirblocks, self._filter_out(result))
 
1862
 
 
1863
 
 
1864
class TestReadLink(tests.TestCaseInTempDir):
 
1865
    """Exposes os.readlink() problems and the osutils solution.
 
1866
 
 
1867
    The only guarantee offered by os.readlink(), starting with 2.6, is that a
 
1868
    unicode string will be returned if a unicode string is passed.
 
1869
 
 
1870
    But prior python versions failed to properly encode the passed unicode
 
1871
    string.
 
1872
    """
 
1873
    _test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
 
1874
 
 
1875
    def setUp(self):
 
1876
        super(tests.TestCaseInTempDir, self).setUp()
 
1877
        self.link = u'l\N{Euro Sign}ink'
 
1878
        self.target = u'targe\N{Euro Sign}t'
 
1879
        os.symlink(self.target, self.link)
 
1880
 
 
1881
    def test_os_readlink_link_encoding(self):
 
1882
        if sys.version_info < (2, 6):
 
1883
            self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
 
1884
        else:
 
1885
            self.assertEquals(self.target,  os.readlink(self.link))
 
1886
 
 
1887
    def test_os_readlink_link_decoding(self):
 
1888
        self.assertEquals(self.target.encode(osutils._fs_enc),
 
1889
                          os.readlink(self.link.encode(osutils._fs_enc)))
 
1890
 
 
1891
 
 
1892
class TestConcurrency(tests.TestCase):
 
1893
 
 
1894
    def setUp(self):
 
1895
        super(TestConcurrency, self).setUp()
 
1896
        self.overrideAttr(osutils, '_cached_local_concurrency')
 
1897
 
 
1898
    def test_local_concurrency(self):
 
1899
        concurrency = osutils.local_concurrency()
 
1900
        self.assertIsInstance(concurrency, int)
 
1901
 
 
1902
    def test_local_concurrency_environment_variable(self):
 
1903
        os.environ['BZR_CONCURRENCY'] = '2'
 
1904
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
 
1905
        os.environ['BZR_CONCURRENCY'] = '3'
 
1906
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
 
1907
        os.environ['BZR_CONCURRENCY'] = 'foo'
 
1908
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
 
1909
 
 
1910
    def test_option_concurrency(self):
 
1911
        os.environ['BZR_CONCURRENCY'] = '1'
 
1912
        self.run_bzr('rocks --concurrency 42')
 
1913
        # Command line overrides envrionment variable
 
1914
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
 
1915
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
 
1916
 
 
1917
 
 
1918
class TestFailedToLoadExtension(tests.TestCase):
 
1919
 
 
1920
    def _try_loading(self):
 
1921
        try:
 
1922
            import bzrlib._fictional_extension_py
 
1923
        except ImportError, e:
 
1924
            osutils.failed_to_load_extension(e)
 
1925
            return True
 
1926
 
 
1927
    def setUp(self):
 
1928
        super(TestFailedToLoadExtension, self).setUp()
 
1929
        self.overrideAttr(osutils, '_extension_load_failures', [])
 
1930
 
 
1931
    def test_failure_to_load(self):
 
1932
        self._try_loading()
 
1933
        self.assertLength(1, osutils._extension_load_failures)
 
1934
        self.assertEquals(osutils._extension_load_failures[0],
 
1935
            "No module named _fictional_extension_py")
 
1936
 
 
1937
    def test_report_extension_load_failures_no_warning(self):
 
1938
        self.assertTrue(self._try_loading())
 
1939
        warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
 
1940
        # it used to give a Python warning; it no longer does
 
1941
        self.assertLength(0, warnings)
 
1942
 
 
1943
    def test_report_extension_load_failures_message(self):
 
1944
        log = StringIO()
 
1945
        trace.push_log_file(log)
 
1946
        self.assertTrue(self._try_loading())
 
1947
        osutils.report_extension_load_failures()
 
1948
        self.assertContainsRe(
 
1949
            log.getvalue(),
 
1950
            r"bzr: warning: some compiled extensions could not be loaded; "
 
1951
            "see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
 
1952
            )
 
1953
 
 
1954
 
 
1955
class TestTerminalWidth(tests.TestCase):
 
1956
 
 
1957
    def setUp(self):
 
1958
        tests.TestCase.setUp(self)
 
1959
        self._orig_terminal_size_state = osutils._terminal_size_state
 
1960
        self._orig_first_terminal_size = osutils._first_terminal_size
 
1961
        self.addCleanup(self.restore_osutils_globals)
 
1962
        osutils._terminal_size_state = 'no_data'
 
1963
        osutils._first_terminal_size = None
 
1964
 
 
1965
    def restore_osutils_globals(self):
 
1966
        osutils._terminal_size_state = self._orig_terminal_size_state
 
1967
        osutils._first_terminal_size = self._orig_first_terminal_size
 
1968
 
 
1969
    def replace_stdout(self, new):
 
1970
        self.overrideAttr(sys, 'stdout', new)
 
1971
 
 
1972
    def replace__terminal_size(self, new):
 
1973
        self.overrideAttr(osutils, '_terminal_size', new)
 
1974
 
 
1975
    def set_fake_tty(self):
 
1976
 
 
1977
        class I_am_a_tty(object):
 
1978
            def isatty(self):
 
1979
                return True
 
1980
 
 
1981
        self.replace_stdout(I_am_a_tty())
 
1982
 
 
1983
    def test_default_values(self):
 
1984
        self.assertEqual(80, osutils.default_terminal_width)
 
1985
 
 
1986
    def test_defaults_to_BZR_COLUMNS(self):
 
1987
        # BZR_COLUMNS is set by the test framework
 
1988
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
 
1989
        os.environ['BZR_COLUMNS'] = '12'
 
1990
        self.assertEqual(12, osutils.terminal_width())
 
1991
 
 
1992
    def test_falls_back_to_COLUMNS(self):
 
1993
        del os.environ['BZR_COLUMNS']
 
1994
        self.assertNotEqual('42', os.environ['COLUMNS'])
 
1995
        self.set_fake_tty()
 
1996
        os.environ['COLUMNS'] = '42'
 
1997
        self.assertEqual(42, osutils.terminal_width())
 
1998
 
 
1999
    def test_tty_default_without_columns(self):
 
2000
        del os.environ['BZR_COLUMNS']
 
2001
        del os.environ['COLUMNS']
 
2002
 
 
2003
        def terminal_size(w, h):
 
2004
            return 42, 42
 
2005
 
 
2006
        self.set_fake_tty()
 
2007
        # We need to override the osutils definition as it depends on the
 
2008
        # running environment that we can't control (PQM running without a
 
2009
        # controlling terminal is one example).
 
2010
        self.replace__terminal_size(terminal_size)
 
2011
        self.assertEqual(42, osutils.terminal_width())
 
2012
 
 
2013
    def test_non_tty_default_without_columns(self):
 
2014
        del os.environ['BZR_COLUMNS']
 
2015
        del os.environ['COLUMNS']
 
2016
        self.replace_stdout(None)
 
2017
        self.assertEqual(None, osutils.terminal_width())
 
2018
 
 
2019
    def test_no_TIOCGWINSZ(self):
 
2020
        self.requireFeature(term_ios_feature)
 
2021
        termios = term_ios_feature.module
 
2022
        # bug 63539 is about a termios without TIOCGWINSZ attribute
 
2023
        try:
 
2024
            orig = termios.TIOCGWINSZ
 
2025
        except AttributeError:
 
2026
            # We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
 
2027
            pass
 
2028
        else:
 
2029
            self.overrideAttr(termios, 'TIOCGWINSZ')
 
2030
            del termios.TIOCGWINSZ
 
2031
        del os.environ['BZR_COLUMNS']
 
2032
        del os.environ['COLUMNS']
 
2033
        # Whatever the result is, if we don't raise an exception, it's ok.
 
2034
        osutils.terminal_width()
 
2035
 
 
2036
class TestCreationOps(tests.TestCaseInTempDir):
 
2037
    _test_needs_features = [features.chown_feature]
 
2038
 
 
2039
    def setUp(self):
 
2040
        tests.TestCaseInTempDir.setUp(self)
 
2041
        self.overrideAttr(os, 'chown', self._dummy_chown)
 
2042
 
 
2043
        # params set by call to _dummy_chown
 
2044
        self.path = self.uid = self.gid = None
 
2045
 
 
2046
    def _dummy_chown(self, path, uid, gid):
 
2047
        self.path, self.uid, self.gid = path, uid, gid
 
2048
 
 
2049
    def test_copy_ownership_from_path(self):
 
2050
        """copy_ownership_from_path test with specified src."""
 
2051
        ownsrc = '/'
 
2052
        f = open('test_file', 'wt')
 
2053
        osutils.copy_ownership_from_path('test_file', ownsrc)
 
2054
 
 
2055
        s = os.stat(ownsrc)
 
2056
        self.assertEquals(self.path, 'test_file')
 
2057
        self.assertEquals(self.uid, s.st_uid)
 
2058
        self.assertEquals(self.gid, s.st_gid)
 
2059
 
 
2060
    def test_copy_ownership_nonesrc(self):
 
2061
        """copy_ownership_from_path test with src=None."""
 
2062
        f = open('test_file', 'wt')
 
2063
        # should use parent dir for permissions
 
2064
        osutils.copy_ownership_from_path('test_file')
 
2065
 
 
2066
        s = os.stat('..')
 
2067
        self.assertEquals(self.path, 'test_file')
 
2068
        self.assertEquals(self.uid, s.st_uid)
 
2069
        self.assertEquals(self.gid, s.st_gid)
 
2070
 
 
2071
class TestGetuserUnicode(tests.TestCase):
 
2072
 
 
2073
    def test_ascii_user(self):
 
2074
        osutils.set_or_unset_env('LOGNAME', 'jrandom')
 
2075
        self.assertEqual(u'jrandom', osutils.getuser_unicode())
 
2076
 
 
2077
    def test_unicode_user(self):
 
2078
        ue = osutils.get_user_encoding()
 
2079
        osutils.set_or_unset_env('LOGNAME', u'jrandom\xb6'.encode(ue))
 
2080
        self.assertEqual(u'jrandom\xb6', osutils.getuser_unicode())