← 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: John Arbash Meinel
  • Date: 2010-02-17 17:11:16 UTC
  • mfrom: (4797.2.17 2.1)
  • mto: (4797.2.18 2.1)
  • mto: This revision was merged to the branch mainline in revision 5055.
  • Revision ID: john@arbash-meinel.com-20100217171116-h7t9223ystbnx5h8
merge bzr.2.1 in preparation for NEWS entry.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
1
 
# Copyright (C) 2005, 2006 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Tests for the osutils wrapper."""
18
18
 
 
19
from cStringIO import StringIO
19
20
import errno
20
21
import os
 
22
import re
21
23
import socket
22
24
import stat
23
25
import sys
 
26
import time
24
27
 
25
 
import bzrlib
26
28
from bzrlib import (
27
29
    errors,
28
30
    osutils,
 
31
    tests,
 
32
    trace,
29
33
    win32utils,
30
34
    )
31
 
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
32
35
from bzrlib.tests import (
33
 
        StringIOWrapper,
34
 
        TestCase, 
35
 
        TestCaseInTempDir, 
36
 
        TestSkipped,
37
 
        )
38
 
 
39
 
 
40
 
class TestOSUtils(TestCaseInTempDir):
 
36
    file_utils,
 
37
    test__walkdirs_win32,
 
38
    )
 
39
 
 
40
 
 
41
class _UTF8DirReaderFeature(tests.Feature):
 
42
 
 
43
    def _probe(self):
 
44
        try:
 
45
            from bzrlib import _readdir_pyx
 
46
            self.reader = _readdir_pyx.UTF8DirReader
 
47
            return True
 
48
        except ImportError:
 
49
            return False
 
50
 
 
51
    def feature_name(self):
 
52
        return 'bzrlib._readdir_pyx'
 
53
 
 
54
UTF8DirReaderFeature = _UTF8DirReaderFeature()
 
55
 
 
56
term_ios_feature = tests.ModuleAvailableFeature('termios')
 
57
 
 
58
 
 
59
def _already_unicode(s):
 
60
    return s
 
61
 
 
62
 
 
63
def _utf8_to_unicode(s):
 
64
    return s.decode('UTF-8')
 
65
 
 
66
 
 
67
def dir_reader_scenarios():
 
68
    # For each dir reader we define:
 
69
 
 
70
    # - native_to_unicode: a function converting the native_abspath as returned
 
71
    #   by DirReader.read_dir to its unicode representation
 
72
 
 
73
    # UnicodeDirReader is the fallback, it should be tested on all platforms.
 
74
    scenarios = [('unicode',
 
75
                  dict(_dir_reader_class=osutils.UnicodeDirReader,
 
76
                       _native_to_unicode=_already_unicode))]
 
77
    # Some DirReaders are platform specific and even there they may not be
 
78
    # available.
 
79
    if UTF8DirReaderFeature.available():
 
80
        from bzrlib import _readdir_pyx
 
81
        scenarios.append(('utf8',
 
82
                          dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
 
83
                               _native_to_unicode=_utf8_to_unicode)))
 
84
 
 
85
    if test__walkdirs_win32.win32_readdir_feature.available():
 
86
        try:
 
87
            from bzrlib import _walkdirs_win32
 
88
            scenarios.append(
 
89
                ('win32',
 
90
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
 
91
                      _native_to_unicode=_already_unicode)))
 
92
        except ImportError:
 
93
            pass
 
94
    return scenarios
 
95
 
 
96
 
 
97
def load_tests(basic_tests, module, loader):
 
98
    suite = loader.suiteClass()
 
99
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
 
100
        basic_tests, tests.condition_isinstance(TestDirReader))
 
101
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios(), suite)
 
102
    suite.addTest(remaining_tests)
 
103
    return suite
 
104
 
 
105
 
 
106
class TestContainsWhitespace(tests.TestCase):
41
107
 
42
108
    def test_contains_whitespace(self):
43
109
        self.failUnless(osutils.contains_whitespace(u' '))
53
119
        self.failIf(osutils.contains_whitespace(u'hellothere'))
54
120
        self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
55
121
 
 
122
 
 
123
class TestRename(tests.TestCaseInTempDir):
 
124
 
 
125
    def create_file(self, filename, content):
 
126
        f = open(filename, 'wb')
 
127
        try:
 
128
            f.write(content)
 
129
        finally:
 
130
            f.close()
 
131
 
 
132
    def _fancy_rename(self, a, b):
 
133
        osutils.fancy_rename(a, b, rename_func=os.rename,
 
134
                             unlink_func=os.unlink)
 
135
 
56
136
    def test_fancy_rename(self):
57
137
        # This should work everywhere
58
 
        def rename(a, b):
59
 
            osutils.fancy_rename(a, b,
60
 
                    rename_func=os.rename,
61
 
                    unlink_func=os.unlink)
62
 
 
63
 
        open('a', 'wb').write('something in a\n')
64
 
        rename('a', 'b')
 
138
        self.create_file('a', 'something in a\n')
 
139
        self._fancy_rename('a', 'b')
65
140
        self.failIfExists('a')
66
141
        self.failUnlessExists('b')
67
142
        self.check_file_contents('b', 'something in a\n')
68
143
 
69
 
        open('a', 'wb').write('new something in a\n')
70
 
        rename('b', 'a')
 
144
        self.create_file('a', 'new something in a\n')
 
145
        self._fancy_rename('b', 'a')
71
146
 
72
147
        self.check_file_contents('a', 'something in a\n')
73
148
 
 
149
    def test_fancy_rename_fails_source_missing(self):
 
150
        # An exception should be raised, and the target should be left in place
 
151
        self.create_file('target', 'data in target\n')
 
152
        self.assertRaises((IOError, OSError), self._fancy_rename,
 
153
                          'missingsource', 'target')
 
154
        self.failUnlessExists('target')
 
155
        self.check_file_contents('target', 'data in target\n')
 
156
 
 
157
    def test_fancy_rename_fails_if_source_and_target_missing(self):
 
158
        self.assertRaises((IOError, OSError), self._fancy_rename,
 
159
                          'missingsource', 'missingtarget')
 
160
 
74
161
    def test_rename(self):
75
162
        # Rename should be semi-atomic on all platforms
76
 
        open('a', 'wb').write('something in a\n')
 
163
        self.create_file('a', 'something in a\n')
77
164
        osutils.rename('a', 'b')
78
165
        self.failIfExists('a')
79
166
        self.failUnlessExists('b')
80
167
        self.check_file_contents('b', 'something in a\n')
81
168
 
82
 
        open('a', 'wb').write('new something in a\n')
 
169
        self.create_file('a', 'new something in a\n')
83
170
        osutils.rename('b', 'a')
84
171
 
85
172
        self.check_file_contents('a', 'something in a\n')
86
173
 
87
174
    # TODO: test fancy_rename using a MemoryTransport
88
175
 
 
176
    def test_rename_change_case(self):
 
177
        # on Windows we should be able to change filename case by rename
 
178
        self.build_tree(['a', 'b/'])
 
179
        osutils.rename('a', 'A')
 
180
        osutils.rename('b', 'B')
 
181
        # we can't use failUnlessExists on case-insensitive filesystem
 
182
        # so try to check shape of the tree
 
183
        shape = sorted(os.listdir('.'))
 
184
        self.assertEquals(['A', 'B'], shape)
 
185
 
 
186
 
 
187
class TestRandChars(tests.TestCase):
 
188
 
89
189
    def test_01_rand_chars_empty(self):
90
190
        result = osutils.rand_chars(0)
91
191
        self.assertEqual(result, '')
96
196
        self.assertEqual(type(result), str)
97
197
        self.assertContainsRe(result, r'^[a-z0-9]{100}$')
98
198
 
 
199
 
 
200
class TestIsInside(tests.TestCase):
 
201
 
99
202
    def test_is_inside(self):
100
203
        is_inside = osutils.is_inside
101
204
        self.assertTrue(is_inside('src', 'src/foo.c'))
105
208
        self.assertFalse(is_inside('foo.c', ''))
106
209
        self.assertTrue(is_inside('', 'foo.c'))
107
210
 
 
211
    def test_is_inside_any(self):
 
212
        SRC_FOO_C = osutils.pathjoin('src', 'foo.c')
 
213
        for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
 
214
                         (['src'], SRC_FOO_C),
 
215
                         (['src'], 'src'),
 
216
                         ]:
 
217
            self.assert_(osutils.is_inside_any(dirs, fn))
 
218
        for dirs, fn in [(['src'], 'srccontrol'),
 
219
                         (['src'], 'srccontrol/foo')]:
 
220
            self.assertFalse(osutils.is_inside_any(dirs, fn))
 
221
 
 
222
    def test_is_inside_or_parent_of_any(self):
 
223
        for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
 
224
                         (['src'], 'src/foo.c'),
 
225
                         (['src/bar.c'], 'src'),
 
226
                         (['src/bar.c', 'bla/foo.c'], 'src'),
 
227
                         (['src'], 'src'),
 
228
                         ]:
 
229
            self.assert_(osutils.is_inside_or_parent_of_any(dirs, fn))
 
230
 
 
231
        for dirs, fn in [(['src'], 'srccontrol'),
 
232
                         (['srccontrol/foo.c'], 'src'),
 
233
                         (['src'], 'srccontrol/foo')]:
 
234
            self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
 
235
 
 
236
 
 
237
class TestRmTree(tests.TestCaseInTempDir):
 
238
 
108
239
    def test_rmtree(self):
109
240
        # Check to remove tree with read-only files/dirs
110
241
        os.mkdir('dir')
123
254
        self.failIfExists('dir/file')
124
255
        self.failIfExists('dir')
125
256
 
 
257
 
 
258
class TestDeleteAny(tests.TestCaseInTempDir):
 
259
 
 
260
    def test_delete_any_readonly(self):
 
261
        # from <https://bugs.launchpad.net/bzr/+bug/218206>
 
262
        self.build_tree(['d/', 'f'])
 
263
        osutils.make_readonly('d')
 
264
        osutils.make_readonly('f')
 
265
 
 
266
        osutils.delete_any('f')
 
267
        osutils.delete_any('d')
 
268
 
 
269
 
 
270
class TestKind(tests.TestCaseInTempDir):
 
271
 
126
272
    def test_file_kind(self):
127
273
        self.build_tree(['file', 'dir/'])
128
274
        self.assertEquals('file', osutils.file_kind('file'))
130
276
        if osutils.has_symlinks():
131
277
            os.symlink('symlink', 'symlink')
132
278
            self.assertEquals('symlink', osutils.file_kind('symlink'))
133
 
        
 
279
 
134
280
        # TODO: jam 20060529 Test a block device
135
281
        try:
136
282
            os.lstat('/dev/null')
158
304
                os.remove('socket')
159
305
 
160
306
    def test_kind_marker(self):
161
 
        self.assertEqual(osutils.kind_marker('file'), '')
162
 
        self.assertEqual(osutils.kind_marker('directory'), '/')
163
 
        self.assertEqual(osutils.kind_marker('symlink'), '@')
164
 
        self.assertEqual(osutils.kind_marker('tree-reference'), '+')
 
307
        self.assertEqual("", osutils.kind_marker("file"))
 
308
        self.assertEqual("/", osutils.kind_marker('directory'))
 
309
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
 
310
        self.assertEqual("@", osutils.kind_marker("symlink"))
 
311
        self.assertEqual("+", osutils.kind_marker("tree-reference"))
 
312
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
 
313
 
 
314
 
 
315
class TestUmask(tests.TestCaseInTempDir):
165
316
 
166
317
    def test_get_umask(self):
167
318
        if sys.platform == 'win32':
170
321
            return
171
322
 
172
323
        orig_umask = osutils.get_umask()
173
 
        try:
174
 
            os.umask(0222)
175
 
            self.assertEqual(0222, osutils.get_umask())
176
 
            os.umask(0022)
177
 
            self.assertEqual(0022, osutils.get_umask())
178
 
            os.umask(0002)
179
 
            self.assertEqual(0002, osutils.get_umask())
180
 
            os.umask(0027)
181
 
            self.assertEqual(0027, osutils.get_umask())
182
 
        finally:
183
 
            os.umask(orig_umask)
 
324
        self.addCleanup(os.umask, orig_umask)
 
325
        os.umask(0222)
 
326
        self.assertEqual(0222, osutils.get_umask())
 
327
        os.umask(0022)
 
328
        self.assertEqual(0022, osutils.get_umask())
 
329
        os.umask(0002)
 
330
        self.assertEqual(0002, osutils.get_umask())
 
331
        os.umask(0027)
 
332
        self.assertEqual(0027, osutils.get_umask())
 
333
 
 
334
 
 
335
class TestDateTime(tests.TestCase):
184
336
 
185
337
    def assertFormatedDelta(self, expected, seconds):
186
338
        """Assert osutils.format_delta formats as expected"""
218
370
        self.assertFormatedDelta('1 second in the future', -1)
219
371
        self.assertFormatedDelta('2 seconds in the future', -2)
220
372
 
 
373
    def test_format_date(self):
 
374
        self.assertRaises(errors.UnsupportedTimezoneFormat,
 
375
            osutils.format_date, 0, timezone='foo')
 
376
        self.assertIsInstance(osutils.format_date(0), str)
 
377
        self.assertIsInstance(osutils.format_local_date(0), unicode)
 
378
        # Testing for the actual value of the local weekday without
 
379
        # duplicating the code from format_date is difficult.
 
380
        # Instead blackbox.test_locale should check for localized
 
381
        # dates once they do occur in output strings.
 
382
 
 
383
    def test_format_date_with_offset_in_original_timezone(self):
 
384
        self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
 
385
            osutils.format_date_with_offset_in_original_timezone(0))
 
386
        self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
 
387
            osutils.format_date_with_offset_in_original_timezone(100000))
 
388
        self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
 
389
            osutils.format_date_with_offset_in_original_timezone(100000, 7200))
 
390
 
 
391
    def test_local_time_offset(self):
 
392
        """Test that local_time_offset() returns a sane value."""
 
393
        offset = osutils.local_time_offset()
 
394
        self.assertTrue(isinstance(offset, int))
 
395
        # Test that the offset is no more than a eighteen hours in
 
396
        # either direction.
 
397
        # Time zone handling is system specific, so it is difficult to
 
398
        # do more specific tests, but a value outside of this range is
 
399
        # probably wrong.
 
400
        eighteen_hours = 18 * 3600
 
401
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
402
 
 
403
    def test_local_time_offset_with_timestamp(self):
 
404
        """Test that local_time_offset() works with a timestamp."""
 
405
        offset = osutils.local_time_offset(1000000000.1234567)
 
406
        self.assertTrue(isinstance(offset, int))
 
407
        eighteen_hours = 18 * 3600
 
408
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
409
 
 
410
 
 
411
class TestLinks(tests.TestCaseInTempDir):
 
412
 
221
413
    def test_dereference_path(self):
222
 
        if not osutils.has_symlinks():
223
 
            raise TestSkipped('Symlinks are not supported on this platform')
 
414
        self.requireFeature(tests.SymlinkFeature)
224
415
        cwd = osutils.realpath('.')
225
416
        os.mkdir('bar')
226
417
        bar_path = osutils.pathjoin(cwd, 'bar')
229
420
        self.assertEqual(bar_path, osutils.realpath('./bar'))
230
421
        os.symlink('bar', 'foo')
231
422
        self.assertEqual(bar_path, osutils.realpath('./foo'))
232
 
        
 
423
 
233
424
        # Does not dereference terminal symlinks
234
425
        foo_path = osutils.pathjoin(cwd, 'foo')
235
426
        self.assertEqual(foo_path, osutils.dereference_path('./foo'))
246
437
        foo_baz_path = osutils.pathjoin(foo_path, 'baz')
247
438
        self.assertEqual(baz_path, osutils.dereference_path(foo_baz_path))
248
439
 
249
 
 
250
440
    def test_changing_access(self):
251
441
        f = file('file', 'w')
252
442
        f.write('monkey')
254
444
 
255
445
        # Make a file readonly
256
446
        osutils.make_readonly('file')
257
 
        mode = osutils.lstat('file').st_mode
 
447
        mode = os.lstat('file').st_mode
258
448
        self.assertEqual(mode, mode & 0777555)
259
449
 
260
450
        # Make a file writable
261
451
        osutils.make_writable('file')
262
 
        mode = osutils.lstat('file').st_mode
 
452
        mode = os.lstat('file').st_mode
263
453
        self.assertEqual(mode, mode | 0200)
264
454
 
265
455
        if osutils.has_symlinks():
268
458
            osutils.make_readonly('dangling')
269
459
            osutils.make_writable('dangling')
270
460
 
271
 
 
272
 
    def test_kind_marker(self):
273
 
        self.assertEqual("", osutils.kind_marker("file"))
274
 
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
275
 
        self.assertEqual("@", osutils.kind_marker("symlink"))
276
 
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
277
 
 
278
 
 
279
 
class TestSafeUnicode(TestCase):
 
461
    def test_host_os_dereferences_symlinks(self):
 
462
        osutils.host_os_dereferences_symlinks()
 
463
 
 
464
 
 
465
class TestCanonicalRelPath(tests.TestCaseInTempDir):
 
466
 
 
467
    _test_needs_features = [tests.CaseInsCasePresFilenameFeature]
 
468
 
 
469
    def test_canonical_relpath_simple(self):
 
470
        f = file('MixedCaseName', 'w')
 
471
        f.close()
 
472
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
 
473
        self.failUnlessEqual('work/MixedCaseName', actual)
 
474
 
 
475
    def test_canonical_relpath_missing_tail(self):
 
476
        os.mkdir('MixedCaseParent')
 
477
        actual = osutils.canonical_relpath(self.test_base_dir,
 
478
                                           'mixedcaseparent/nochild')
 
479
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
 
480
 
 
481
 
 
482
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
 
483
 
 
484
    def assertRelpath(self, expected, base, path):
 
485
        actual = osutils._cicp_canonical_relpath(base, path)
 
486
        self.assertEqual(expected, actual)
 
487
 
 
488
    def test_simple(self):
 
489
        self.build_tree(['MixedCaseName'])
 
490
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
 
491
        self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
 
492
 
 
493
    def test_subdir_missing_tail(self):
 
494
        self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
 
495
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
 
496
        self.assertRelpath('MixedCaseParent/a_child', base,
 
497
                           'MixedCaseParent/a_child')
 
498
        self.assertRelpath('MixedCaseParent/a_child', base,
 
499
                           'MixedCaseParent/A_Child')
 
500
        self.assertRelpath('MixedCaseParent/not_child', base,
 
501
                           'MixedCaseParent/not_child')
 
502
 
 
503
    def test_at_root_slash(self):
 
504
        # We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
 
505
        # check...
 
506
        if osutils.MIN_ABS_PATHLENGTH > 1:
 
507
            raise tests.TestSkipped('relpath requires %d chars'
 
508
                                    % osutils.MIN_ABS_PATHLENGTH)
 
509
        self.assertRelpath('foo', '/', '/foo')
 
510
 
 
511
    def test_at_root_drive(self):
 
512
        if sys.platform != 'win32':
 
513
            raise tests.TestNotApplicable('we can only test drive-letter relative'
 
514
                                          ' paths on Windows where we have drive'
 
515
                                          ' letters.')
 
516
        # see bug #322807
 
517
        # The specific issue is that when at the root of a drive, 'abspath'
 
518
        # returns "C:/" or just "/". However, the code assumes that abspath
 
519
        # always returns something like "C:/foo" or "/foo" (no trailing slash).
 
520
        self.assertRelpath('foo', 'C:/', 'C:/foo')
 
521
        self.assertRelpath('foo', 'X:/', 'X:/foo')
 
522
        self.assertRelpath('foo', 'X:/', 'X://foo')
 
523
 
 
524
 
 
525
class TestPumpFile(tests.TestCase):
 
526
    """Test pumpfile method."""
 
527
 
 
528
    def setUp(self):
 
529
        tests.TestCase.setUp(self)
 
530
        # create a test datablock
 
531
        self.block_size = 512
 
532
        pattern = '0123456789ABCDEF'
 
533
        self.test_data = pattern * (3 * self.block_size / len(pattern))
 
534
        self.test_data_len = len(self.test_data)
 
535
 
 
536
    def test_bracket_block_size(self):
 
537
        """Read data in blocks with the requested read size bracketing the
 
538
        block size."""
 
539
        # make sure test data is larger than max read size
 
540
        self.assertTrue(self.test_data_len > self.block_size)
 
541
 
 
542
        from_file = file_utils.FakeReadFile(self.test_data)
 
543
        to_file = StringIO()
 
544
 
 
545
        # read (max / 2) bytes and verify read size wasn't affected
 
546
        num_bytes_to_read = self.block_size / 2
 
547
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
548
        self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
 
549
        self.assertEqual(from_file.get_read_count(), 1)
 
550
 
 
551
        # read (max) bytes and verify read size wasn't affected
 
552
        num_bytes_to_read = self.block_size
 
553
        from_file.reset_read_count()
 
554
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
555
        self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
 
556
        self.assertEqual(from_file.get_read_count(), 1)
 
557
 
 
558
        # read (max + 1) bytes and verify read size was limited
 
559
        num_bytes_to_read = self.block_size + 1
 
560
        from_file.reset_read_count()
 
561
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
562
        self.assertEqual(from_file.get_max_read_size(), self.block_size)
 
563
        self.assertEqual(from_file.get_read_count(), 2)
 
564
 
 
565
        # finish reading the rest of the data
 
566
        num_bytes_to_read = self.test_data_len - to_file.tell()
 
567
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
568
 
 
569
        # report error if the data wasn't equal (we only report the size due
 
570
        # to the length of the data)
 
571
        response_data = to_file.getvalue()
 
572
        if response_data != self.test_data:
 
573
            message = "Data not equal.  Expected %d bytes, received %d."
 
574
            self.fail(message % (len(response_data), self.test_data_len))
 
575
 
 
576
    def test_specified_size(self):
 
577
        """Request a transfer larger than the maximum block size and verify
 
578
        that the maximum read doesn't exceed the block_size."""
 
579
        # make sure test data is larger than max read size
 
580
        self.assertTrue(self.test_data_len > self.block_size)
 
581
 
 
582
        # retrieve data in blocks
 
583
        from_file = file_utils.FakeReadFile(self.test_data)
 
584
        to_file = StringIO()
 
585
        osutils.pumpfile(from_file, to_file, self.test_data_len,
 
586
                         self.block_size)
 
587
 
 
588
        # verify read size was equal to the maximum read size
 
589
        self.assertTrue(from_file.get_max_read_size() > 0)
 
590
        self.assertEqual(from_file.get_max_read_size(), self.block_size)
 
591
        self.assertEqual(from_file.get_read_count(), 3)
 
592
 
 
593
        # report error if the data wasn't equal (we only report the size due
 
594
        # to the length of the data)
 
595
        response_data = to_file.getvalue()
 
596
        if response_data != self.test_data:
 
597
            message = "Data not equal.  Expected %d bytes, received %d."
 
598
            self.fail(message % (len(response_data), self.test_data_len))
 
599
 
 
600
    def test_to_eof(self):
 
601
        """Read to end-of-file and verify that the reads are not larger than
 
602
        the maximum read size."""
 
603
        # make sure test data is larger than max read size
 
604
        self.assertTrue(self.test_data_len > self.block_size)
 
605
 
 
606
        # retrieve data to EOF
 
607
        from_file = file_utils.FakeReadFile(self.test_data)
 
608
        to_file = StringIO()
 
609
        osutils.pumpfile(from_file, to_file, -1, self.block_size)
 
610
 
 
611
        # verify read size was equal to the maximum read size
 
612
        self.assertEqual(from_file.get_max_read_size(), self.block_size)
 
613
        self.assertEqual(from_file.get_read_count(), 4)
 
614
 
 
615
        # report error if the data wasn't equal (we only report the size due
 
616
        # to the length of the data)
 
617
        response_data = to_file.getvalue()
 
618
        if response_data != self.test_data:
 
619
            message = "Data not equal.  Expected %d bytes, received %d."
 
620
            self.fail(message % (len(response_data), self.test_data_len))
 
621
 
 
622
    def test_defaults(self):
 
623
        """Verifies that the default arguments will read to EOF -- this
 
624
        test verifies that any existing usages of pumpfile will not be broken
 
625
        with this new version."""
 
626
        # retrieve data using default (old) pumpfile method
 
627
        from_file = file_utils.FakeReadFile(self.test_data)
 
628
        to_file = StringIO()
 
629
        osutils.pumpfile(from_file, to_file)
 
630
 
 
631
        # report error if the data wasn't equal (we only report the size due
 
632
        # to the length of the data)
 
633
        response_data = to_file.getvalue()
 
634
        if response_data != self.test_data:
 
635
            message = "Data not equal.  Expected %d bytes, received %d."
 
636
            self.fail(message % (len(response_data), self.test_data_len))
 
637
 
 
638
    def test_report_activity(self):
 
639
        activity = []
 
640
        def log_activity(length, direction):
 
641
            activity.append((length, direction))
 
642
        from_file = StringIO(self.test_data)
 
643
        to_file = StringIO()
 
644
        osutils.pumpfile(from_file, to_file, buff_size=500,
 
645
                         report_activity=log_activity, direction='read')
 
646
        self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
 
647
                          (36, 'read')], activity)
 
648
 
 
649
        from_file = StringIO(self.test_data)
 
650
        to_file = StringIO()
 
651
        del activity[:]
 
652
        osutils.pumpfile(from_file, to_file, buff_size=500,
 
653
                         report_activity=log_activity, direction='write')
 
654
        self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
 
655
                          (36, 'write')], activity)
 
656
 
 
657
        # And with a limited amount of data
 
658
        from_file = StringIO(self.test_data)
 
659
        to_file = StringIO()
 
660
        del activity[:]
 
661
        osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
 
662
                         report_activity=log_activity, direction='read')
 
663
        self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
 
664
 
 
665
 
 
666
 
 
667
class TestPumpStringFile(tests.TestCase):
 
668
 
 
669
    def test_empty(self):
 
670
        output = StringIO()
 
671
        osutils.pump_string_file("", output)
 
672
        self.assertEqual("", output.getvalue())
 
673
 
 
674
    def test_more_than_segment_size(self):
 
675
        output = StringIO()
 
676
        osutils.pump_string_file("123456789", output, 2)
 
677
        self.assertEqual("123456789", output.getvalue())
 
678
 
 
679
    def test_segment_size(self):
 
680
        output = StringIO()
 
681
        osutils.pump_string_file("12", output, 2)
 
682
        self.assertEqual("12", output.getvalue())
 
683
 
 
684
    def test_segment_size_multiple(self):
 
685
        output = StringIO()
 
686
        osutils.pump_string_file("1234", output, 2)
 
687
        self.assertEqual("1234", output.getvalue())
 
688
 
 
689
 
 
690
class TestRelpath(tests.TestCase):
 
691
 
 
692
    def test_simple_relpath(self):
 
693
        cwd = osutils.getcwd()
 
694
        subdir = cwd + '/subdir'
 
695
        self.assertEqual('subdir', osutils.relpath(cwd, subdir))
 
696
 
 
697
    def test_deep_relpath(self):
 
698
        cwd = osutils.getcwd()
 
699
        subdir = cwd + '/sub/subsubdir'
 
700
        self.assertEqual('sub/subsubdir', osutils.relpath(cwd, subdir))
 
701
 
 
702
    def test_not_relative(self):
 
703
        self.assertRaises(errors.PathNotChild,
 
704
                          osutils.relpath, 'C:/path', 'H:/path')
 
705
        self.assertRaises(errors.PathNotChild,
 
706
                          osutils.relpath, 'C:/', 'H:/path')
 
707
 
 
708
 
 
709
class TestSafeUnicode(tests.TestCase):
280
710
 
281
711
    def test_from_ascii_string(self):
282
712
        self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
291
721
        self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
292
722
 
293
723
    def test_bad_utf8_string(self):
294
 
        self.assertRaises(BzrBadParameterNotUnicode,
 
724
        self.assertRaises(errors.BzrBadParameterNotUnicode,
295
725
                          osutils.safe_unicode,
296
726
                          '\xbb\xbb')
297
727
 
298
728
 
299
 
class TestSafeUtf8(TestCase):
 
729
class TestSafeUtf8(tests.TestCase):
300
730
 
301
731
    def test_from_ascii_string(self):
302
732
        f = 'foobar'
312
742
        self.assertEqual('foo\xc2\xae', osutils.safe_utf8('foo\xc2\xae'))
313
743
 
314
744
    def test_bad_utf8_string(self):
315
 
        self.assertRaises(BzrBadParameterNotUnicode,
 
745
        self.assertRaises(errors.BzrBadParameterNotUnicode,
316
746
                          osutils.safe_utf8, '\xbb\xbb')
317
747
 
318
748
 
319
 
class TestSafeRevisionId(TestCase):
 
749
class TestSafeRevisionId(tests.TestCase):
320
750
 
321
751
    def test_from_ascii_string(self):
 
752
        # this shouldn't give a warning because it's getting an ascii string
322
753
        self.assertEqual('foobar', osutils.safe_revision_id('foobar'))
323
754
 
324
755
    def test_from_unicode_string_ascii_contents(self):
343
774
        self.assertEqual(None, osutils.safe_revision_id(None))
344
775
 
345
776
 
346
 
class TestSafeFileId(TestCase):
 
777
class TestSafeFileId(tests.TestCase):
347
778
 
348
779
    def test_from_ascii_string(self):
349
780
        self.assertEqual('foobar', osutils.safe_file_id('foobar'))
369
800
        self.assertEqual(None, osutils.safe_file_id(None))
370
801
 
371
802
 
372
 
class TestWin32Funcs(TestCase):
373
 
    """Test that the _win32 versions of os utilities return appropriate paths."""
 
803
class TestWin32Funcs(tests.TestCase):
 
804
    """Test that _win32 versions of os utilities return appropriate paths."""
374
805
 
375
806
    def test_abspath(self):
376
807
        self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
383
814
        self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
384
815
 
385
816
    def test_pathjoin(self):
386
 
        self.assertEqual('path/to/foo', osutils._win32_pathjoin('path', 'to', 'foo'))
387
 
        self.assertEqual('C:/foo', osutils._win32_pathjoin('path\\to', 'C:\\foo'))
388
 
        self.assertEqual('C:/foo', osutils._win32_pathjoin('path/to', 'C:/foo'))
389
 
        self.assertEqual('path/to/foo', osutils._win32_pathjoin('path/to/', 'foo'))
390
 
        self.assertEqual('/foo', osutils._win32_pathjoin('C:/path/to/', '/foo'))
391
 
        self.assertEqual('/foo', osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
 
817
        self.assertEqual('path/to/foo',
 
818
                         osutils._win32_pathjoin('path', 'to', 'foo'))
 
819
        self.assertEqual('C:/foo',
 
820
                         osutils._win32_pathjoin('path\\to', 'C:\\foo'))
 
821
        self.assertEqual('C:/foo',
 
822
                         osutils._win32_pathjoin('path/to', 'C:/foo'))
 
823
        self.assertEqual('path/to/foo',
 
824
                         osutils._win32_pathjoin('path/to/', 'foo'))
 
825
        self.assertEqual('/foo',
 
826
                         osutils._win32_pathjoin('C:/path/to/', '/foo'))
 
827
        self.assertEqual('/foo',
 
828
                         osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
392
829
 
393
830
    def test_normpath(self):
394
 
        self.assertEqual('path/to/foo', osutils._win32_normpath(r'path\\from\..\to\.\foo'))
395
 
        self.assertEqual('path/to/foo', osutils._win32_normpath('path//from/../to/./foo'))
 
831
        self.assertEqual('path/to/foo',
 
832
                         osutils._win32_normpath(r'path\\from\..\to\.\foo'))
 
833
        self.assertEqual('path/to/foo',
 
834
                         osutils._win32_normpath('path//from/../to/./foo'))
396
835
 
397
836
    def test_getcwd(self):
398
837
        cwd = osutils._win32_getcwd()
427
866
        self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
428
867
 
429
868
 
430
 
class TestWin32FuncsDirs(TestCaseInTempDir):
 
869
class TestWin32FuncsDirs(tests.TestCaseInTempDir):
431
870
    """Test win32 functions that create files."""
432
 
    
 
871
 
433
872
    def test_getcwd(self):
434
 
        if win32utils.winver == 'Windows 98':
435
 
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
436
 
        # Make sure getcwd can handle unicode filenames
437
 
        try:
438
 
            os.mkdir(u'mu-\xb5')
439
 
        except UnicodeError:
440
 
            raise TestSkipped("Unable to create Unicode filename")
441
 
 
 
873
        self.requireFeature(tests.UnicodeFilenameFeature)
 
874
        os.mkdir(u'mu-\xb5')
442
875
        os.chdir(u'mu-\xb5')
443
876
        # TODO: jam 20060427 This will probably fail on Mac OSX because
444
877
        #       it will change the normalization of B\xe5gfors
446
879
        #       osutils.getcwd() renormalize the path.
447
880
        self.assertEndsWith(osutils._win32_getcwd(), u'mu-\xb5')
448
881
 
 
882
    def test_minimum_path_selection(self):
 
883
        self.assertEqual(set(),
 
884
            osutils.minimum_path_selection([]))
 
885
        self.assertEqual(set(['a']),
 
886
            osutils.minimum_path_selection(['a']))
 
887
        self.assertEqual(set(['a', 'b']),
 
888
            osutils.minimum_path_selection(['a', 'b']))
 
889
        self.assertEqual(set(['a/', 'b']),
 
890
            osutils.minimum_path_selection(['a/', 'b']))
 
891
        self.assertEqual(set(['a/', 'b']),
 
892
            osutils.minimum_path_selection(['a/c', 'a/', 'b']))
 
893
        self.assertEqual(set(['a-b', 'a', 'a0b']),
 
894
            osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
 
895
 
449
896
    def test_mkdtemp(self):
450
897
        tmpdir = osutils._win32_mkdtemp(dir='.')
451
898
        self.assertFalse('\\' in tmpdir)
506
953
        self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
507
954
 
508
955
 
509
 
class TestMacFuncsDirs(TestCaseInTempDir):
 
956
class TestParentDirectories(tests.TestCaseInTempDir):
 
957
    """Test osutils.parent_directories()"""
 
958
 
 
959
    def test_parent_directories(self):
 
960
        self.assertEqual([], osutils.parent_directories('a'))
 
961
        self.assertEqual(['a'], osutils.parent_directories('a/b'))
 
962
        self.assertEqual(['a/b', 'a'], osutils.parent_directories('a/b/c'))
 
963
 
 
964
 
 
965
class TestMacFuncsDirs(tests.TestCaseInTempDir):
510
966
    """Test mac special functions that require directories."""
511
967
 
512
968
    def test_getcwd(self):
513
 
        # On Mac, this will actually create Ba\u030agfors
514
 
        # but chdir will still work, because it accepts both paths
515
 
        try:
516
 
            os.mkdir(u'B\xe5gfors')
517
 
        except UnicodeError:
518
 
            raise TestSkipped("Unable to create Unicode filename")
519
 
 
 
969
        self.requireFeature(tests.UnicodeFilenameFeature)
 
970
        os.mkdir(u'B\xe5gfors')
520
971
        os.chdir(u'B\xe5gfors')
521
972
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
522
973
 
523
974
    def test_getcwd_nonnorm(self):
 
975
        self.requireFeature(tests.UnicodeFilenameFeature)
524
976
        # Test that _mac_getcwd() will normalize this path
525
 
        try:
526
 
            os.mkdir(u'Ba\u030agfors')
527
 
        except UnicodeError:
528
 
            raise TestSkipped("Unable to create Unicode filename")
529
 
 
 
977
        os.mkdir(u'Ba\u030agfors')
530
978
        os.chdir(u'Ba\u030agfors')
531
979
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
532
980
 
533
981
 
534
 
class TestSplitLines(TestCase):
 
982
class TestChunksToLines(tests.TestCase):
 
983
 
 
984
    def test_smoketest(self):
 
985
        self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
 
986
                         osutils.chunks_to_lines(['foo\nbar', '\nbaz\n']))
 
987
        self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
 
988
                         osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
 
989
 
 
990
    def test_osutils_binding(self):
 
991
        from bzrlib.tests import test__chunks_to_lines
 
992
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
 
993
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
 
994
        else:
 
995
            from bzrlib._chunks_to_lines_py import chunks_to_lines
 
996
        self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
 
997
 
 
998
 
 
999
class TestSplitLines(tests.TestCase):
535
1000
 
536
1001
    def test_split_unicode(self):
537
1002
        self.assertEqual([u'foo\n', u'bar\xae'],
544
1009
                         osutils.split_lines('foo\rbar\n'))
545
1010
 
546
1011
 
547
 
class TestWalkDirs(TestCaseInTempDir):
 
1012
class TestWalkDirs(tests.TestCaseInTempDir):
 
1013
 
 
1014
    def assertExpectedBlocks(self, expected, result):
 
1015
        self.assertEqual(expected,
 
1016
                         [(dirinfo, [line[0:3] for line in block])
 
1017
                          for dirinfo, block in result])
548
1018
 
549
1019
    def test_walkdirs(self):
550
1020
        tree = [
583
1053
            result.append((dirdetail, dirblock))
584
1054
 
585
1055
        self.assertTrue(found_bzrdir)
586
 
        self.assertEqual(expected_dirblocks,
587
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
1056
        self.assertExpectedBlocks(expected_dirblocks, result)
588
1057
        # you can search a subdir only, with a supplied prefix.
589
1058
        result = []
590
1059
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
591
1060
            result.append(dirblock)
592
 
        self.assertEqual(expected_dirblocks[1:],
593
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
1061
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
 
1062
 
 
1063
    def test_walkdirs_os_error(self):
 
1064
        # <https://bugs.edge.launchpad.net/bzr/+bug/338653>
 
1065
        # Pyrex readdir didn't raise useful messages if it had an error
 
1066
        # reading the directory
 
1067
        if sys.platform == 'win32':
 
1068
            raise tests.TestNotApplicable(
 
1069
                "readdir IOError not tested on win32")
 
1070
        os.mkdir("test-unreadable")
 
1071
        os.chmod("test-unreadable", 0000)
 
1072
        # must chmod it back so that it can be removed
 
1073
        self.addCleanup(os.chmod, "test-unreadable", 0700)
 
1074
        # The error is not raised until the generator is actually evaluated.
 
1075
        # (It would be ok if it happened earlier but at the moment it
 
1076
        # doesn't.)
 
1077
        e = self.assertRaises(OSError, list, osutils._walkdirs_utf8("."))
 
1078
        self.assertEquals('./test-unreadable', e.filename)
 
1079
        self.assertEquals(errno.EACCES, e.errno)
 
1080
        # Ensure the message contains the file name
 
1081
        self.assertContainsRe(str(e), "\./test-unreadable")
594
1082
 
595
1083
    def test__walkdirs_utf8(self):
596
1084
        tree = [
629
1117
            result.append((dirdetail, dirblock))
630
1118
 
631
1119
        self.assertTrue(found_bzrdir)
632
 
        self.assertEqual(expected_dirblocks,
633
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
1120
        self.assertExpectedBlocks(expected_dirblocks, result)
 
1121
 
634
1122
        # you can search a subdir only, with a supplied prefix.
635
1123
        result = []
636
1124
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
637
1125
            result.append(dirblock)
638
 
        self.assertEqual(expected_dirblocks[1:],
639
 
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
1126
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
640
1127
 
641
1128
    def _filter_out_stat(self, result):
642
1129
        """Filter out the stat value from the walkdirs result"""
647
1134
                new_dirblock.append((info[0], info[1], info[2], info[4]))
648
1135
            dirblock[:] = new_dirblock
649
1136
 
 
1137
    def _save_platform_info(self):
 
1138
        cur_winver = win32utils.winver
 
1139
        cur_fs_enc = osutils._fs_enc
 
1140
        cur_dir_reader = osutils._selected_dir_reader
 
1141
        def restore():
 
1142
            win32utils.winver = cur_winver
 
1143
            osutils._fs_enc = cur_fs_enc
 
1144
            osutils._selected_dir_reader = cur_dir_reader
 
1145
        self.addCleanup(restore)
 
1146
 
 
1147
    def assertDirReaderIs(self, expected):
 
1148
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
 
1149
        # Force it to redetect
 
1150
        osutils._selected_dir_reader = None
 
1151
        # Nothing to list, but should still trigger the selection logic
 
1152
        self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
 
1153
        self.assertIsInstance(osutils._selected_dir_reader, expected)
 
1154
 
 
1155
    def test_force_walkdirs_utf8_fs_utf8(self):
 
1156
        self.requireFeature(UTF8DirReaderFeature)
 
1157
        self._save_platform_info()
 
1158
        win32utils.winver = None # Avoid the win32 detection code
 
1159
        osutils._fs_enc = 'UTF-8'
 
1160
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
1161
 
 
1162
    def test_force_walkdirs_utf8_fs_ascii(self):
 
1163
        self.requireFeature(UTF8DirReaderFeature)
 
1164
        self._save_platform_info()
 
1165
        win32utils.winver = None # Avoid the win32 detection code
 
1166
        osutils._fs_enc = 'US-ASCII'
 
1167
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
1168
 
 
1169
    def test_force_walkdirs_utf8_fs_ANSI(self):
 
1170
        self.requireFeature(UTF8DirReaderFeature)
 
1171
        self._save_platform_info()
 
1172
        win32utils.winver = None # Avoid the win32 detection code
 
1173
        osutils._fs_enc = 'ANSI_X3.4-1968'
 
1174
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
1175
 
 
1176
    def test_force_walkdirs_utf8_fs_latin1(self):
 
1177
        self._save_platform_info()
 
1178
        win32utils.winver = None # Avoid the win32 detection code
 
1179
        osutils._fs_enc = 'latin1'
 
1180
        self.assertDirReaderIs(osutils.UnicodeDirReader)
 
1181
 
 
1182
    def test_force_walkdirs_utf8_nt(self):
 
1183
        # Disabled because the thunk of the whole walkdirs api is disabled.
 
1184
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1185
        self._save_platform_info()
 
1186
        win32utils.winver = 'Windows NT'
 
1187
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1188
        self.assertDirReaderIs(Win32ReadDir)
 
1189
 
 
1190
    def test_force_walkdirs_utf8_98(self):
 
1191
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1192
        self._save_platform_info()
 
1193
        win32utils.winver = 'Windows 98'
 
1194
        self.assertDirReaderIs(osutils.UnicodeDirReader)
 
1195
 
650
1196
    def test_unicode_walkdirs(self):
651
1197
        """Walkdirs should always return unicode paths."""
 
1198
        self.requireFeature(tests.UnicodeFilenameFeature)
652
1199
        name0 = u'0file-\xb6'
653
1200
        name1 = u'1dir-\u062c\u0648'
654
1201
        name2 = u'2file-\u0633'
659
1206
            name1 + '/' + name1 + '/',
660
1207
            name2,
661
1208
            ]
662
 
        try:
663
 
            self.build_tree(tree)
664
 
        except UnicodeError:
665
 
            raise TestSkipped('Could not represent Unicode chars'
666
 
                              ' in current encoding.')
 
1209
        self.build_tree(tree)
667
1210
        expected_dirblocks = [
668
1211
                ((u'', u'.'),
669
1212
                 [(name0, name0, 'file', './' + name0),
695
1238
 
696
1239
        The abspath portion might be in unicode or utf-8
697
1240
        """
 
1241
        self.requireFeature(tests.UnicodeFilenameFeature)
698
1242
        name0 = u'0file-\xb6'
699
1243
        name1 = u'1dir-\u062c\u0648'
700
1244
        name2 = u'2file-\u0633'
705
1249
            name1 + '/' + name1 + '/',
706
1250
            name2,
707
1251
            ]
708
 
        try:
709
 
            self.build_tree(tree)
710
 
        except UnicodeError:
711
 
            raise TestSkipped('Could not represent Unicode chars'
712
 
                              ' in current encoding.')
 
1252
        self.build_tree(tree)
713
1253
        name0 = name0.encode('utf8')
714
1254
        name1 = name1.encode('utf8')
715
1255
        name2 = name2.encode('utf8')
754
1294
            result.append((dirdetail, new_dirblock))
755
1295
        self.assertEqual(expected_dirblocks, result)
756
1296
 
757
 
    def test_unicode__walkdirs_unicode_to_utf8(self):
758
 
        """walkdirs_unicode_to_utf8 should be a safe fallback everywhere
 
1297
    def test__walkdirs_utf8_with_unicode_fs(self):
 
1298
        """UnicodeDirReader should be a safe fallback everywhere
759
1299
 
760
1300
        The abspath portion should be in unicode
761
1301
        """
762
 
        name0u = u'0file-\xb6'
763
 
        name1u = u'1dir-\u062c\u0648'
764
 
        name2u = u'2file-\u0633'
765
 
        tree = [
766
 
            name0u,
767
 
            name1u + '/',
768
 
            name1u + '/' + name0u,
769
 
            name1u + '/' + name1u + '/',
770
 
            name2u,
771
 
            ]
 
1302
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1303
        # Use the unicode reader. TODO: split into driver-and-driven unit
 
1304
        # tests.
 
1305
        self._save_platform_info()
 
1306
        osutils._selected_dir_reader = osutils.UnicodeDirReader()
 
1307
        name0u = u'0file-\xb6'
 
1308
        name1u = u'1dir-\u062c\u0648'
 
1309
        name2u = u'2file-\u0633'
 
1310
        tree = [
 
1311
            name0u,
 
1312
            name1u + '/',
 
1313
            name1u + '/' + name0u,
 
1314
            name1u + '/' + name1u + '/',
 
1315
            name2u,
 
1316
            ]
 
1317
        self.build_tree(tree)
 
1318
        name0 = name0u.encode('utf8')
 
1319
        name1 = name1u.encode('utf8')
 
1320
        name2 = name2u.encode('utf8')
 
1321
 
 
1322
        # All of the abspaths should be in unicode, all of the relative paths
 
1323
        # should be in utf8
 
1324
        expected_dirblocks = [
 
1325
                (('', '.'),
 
1326
                 [(name0, name0, 'file', './' + name0u),
 
1327
                  (name1, name1, 'directory', './' + name1u),
 
1328
                  (name2, name2, 'file', './' + name2u),
 
1329
                 ]
 
1330
                ),
 
1331
                ((name1, './' + name1u),
 
1332
                 [(name1 + '/' + name0, name0, 'file', './' + name1u
 
1333
                                                        + '/' + name0u),
 
1334
                  (name1 + '/' + name1, name1, 'directory', './' + name1u
 
1335
                                                            + '/' + name1u),
 
1336
                 ]
 
1337
                ),
 
1338
                ((name1 + '/' + name1, './' + name1u + '/' + name1u),
 
1339
                 [
 
1340
                 ]
 
1341
                ),
 
1342
            ]
 
1343
        result = list(osutils._walkdirs_utf8('.'))
 
1344
        self._filter_out_stat(result)
 
1345
        self.assertEqual(expected_dirblocks, result)
 
1346
 
 
1347
    def test__walkdirs_utf8_win32readdir(self):
 
1348
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1349
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1350
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1351
        self._save_platform_info()
 
1352
        osutils._selected_dir_reader = Win32ReadDir()
 
1353
        name0u = u'0file-\xb6'
 
1354
        name1u = u'1dir-\u062c\u0648'
 
1355
        name2u = u'2file-\u0633'
 
1356
        tree = [
 
1357
            name0u,
 
1358
            name1u + '/',
 
1359
            name1u + '/' + name0u,
 
1360
            name1u + '/' + name1u + '/',
 
1361
            name2u,
 
1362
            ]
 
1363
        self.build_tree(tree)
 
1364
        name0 = name0u.encode('utf8')
 
1365
        name1 = name1u.encode('utf8')
 
1366
        name2 = name2u.encode('utf8')
 
1367
 
 
1368
        # All of the abspaths should be in unicode, all of the relative paths
 
1369
        # should be in utf8
 
1370
        expected_dirblocks = [
 
1371
                (('', '.'),
 
1372
                 [(name0, name0, 'file', './' + name0u),
 
1373
                  (name1, name1, 'directory', './' + name1u),
 
1374
                  (name2, name2, 'file', './' + name2u),
 
1375
                 ]
 
1376
                ),
 
1377
                ((name1, './' + name1u),
 
1378
                 [(name1 + '/' + name0, name0, 'file', './' + name1u
 
1379
                                                        + '/' + name0u),
 
1380
                  (name1 + '/' + name1, name1, 'directory', './' + name1u
 
1381
                                                            + '/' + name1u),
 
1382
                 ]
 
1383
                ),
 
1384
                ((name1 + '/' + name1, './' + name1u + '/' + name1u),
 
1385
                 [
 
1386
                 ]
 
1387
                ),
 
1388
            ]
 
1389
        result = list(osutils._walkdirs_utf8(u'.'))
 
1390
        self._filter_out_stat(result)
 
1391
        self.assertEqual(expected_dirblocks, result)
 
1392
 
 
1393
    def assertStatIsCorrect(self, path, win32stat):
 
1394
        os_stat = os.stat(path)
 
1395
        self.assertEqual(os_stat.st_size, win32stat.st_size)
 
1396
        self.assertAlmostEqual(os_stat.st_mtime, win32stat.st_mtime, places=4)
 
1397
        self.assertAlmostEqual(os_stat.st_ctime, win32stat.st_ctime, places=4)
 
1398
        self.assertAlmostEqual(os_stat.st_atime, win32stat.st_atime, places=4)
 
1399
        self.assertEqual(os_stat.st_dev, win32stat.st_dev)
 
1400
        self.assertEqual(os_stat.st_ino, win32stat.st_ino)
 
1401
        self.assertEqual(os_stat.st_mode, win32stat.st_mode)
 
1402
 
 
1403
    def test__walkdirs_utf_win32_find_file_stat_file(self):
 
1404
        """make sure our Stat values are valid"""
 
1405
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1406
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1407
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1408
        name0u = u'0file-\xb6'
 
1409
        name0 = name0u.encode('utf8')
 
1410
        self.build_tree([name0u])
 
1411
        # I hate to sleep() here, but I'm trying to make the ctime different
 
1412
        # from the mtime
 
1413
        time.sleep(2)
 
1414
        f = open(name0u, 'ab')
772
1415
        try:
773
 
            self.build_tree(tree)
774
 
        except UnicodeError:
775
 
            raise TestSkipped('Could not represent Unicode chars'
776
 
                              ' in current encoding.')
 
1416
            f.write('just a small update')
 
1417
        finally:
 
1418
            f.close()
 
1419
 
 
1420
        result = Win32ReadDir().read_dir('', u'.')
 
1421
        entry = result[0]
 
1422
        self.assertEqual((name0, name0, 'file'), entry[:3])
 
1423
        self.assertEqual(u'./' + name0u, entry[4])
 
1424
        self.assertStatIsCorrect(entry[4], entry[3])
 
1425
        self.assertNotEqual(entry[3].st_mtime, entry[3].st_ctime)
 
1426
 
 
1427
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
 
1428
        """make sure our Stat values are valid"""
 
1429
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1430
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1431
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1432
        name0u = u'0dir-\u062c\u0648'
777
1433
        name0 = name0u.encode('utf8')
778
 
        name1 = name1u.encode('utf8')
779
 
        name2 = name2u.encode('utf8')
 
1434
        self.build_tree([name0u + '/'])
780
1435
 
781
 
        # All of the abspaths should be in unicode, all of the relative paths
782
 
        # should be in utf8
783
 
        expected_dirblocks = [
784
 
                (('', '.'),
785
 
                 [(name0, name0, 'file', './' + name0u),
786
 
                  (name1, name1, 'directory', './' + name1u),
787
 
                  (name2, name2, 'file', './' + name2u),
788
 
                 ]
789
 
                ),
790
 
                ((name1, './' + name1u),
791
 
                 [(name1 + '/' + name0, name0, 'file', './' + name1u
792
 
                                                        + '/' + name0u),
793
 
                  (name1 + '/' + name1, name1, 'directory', './' + name1u
794
 
                                                            + '/' + name1u),
795
 
                 ]
796
 
                ),
797
 
                ((name1 + '/' + name1, './' + name1u + '/' + name1u),
798
 
                 [
799
 
                 ]
800
 
                ),
801
 
            ]
802
 
        result = list(osutils._walkdirs_unicode_to_utf8('.'))
803
 
        self._filter_out_stat(result)
804
 
        self.assertEqual(expected_dirblocks, result)
 
1436
        result = Win32ReadDir().read_dir('', u'.')
 
1437
        entry = result[0]
 
1438
        self.assertEqual((name0, name0, 'directory'), entry[:3])
 
1439
        self.assertEqual(u'./' + name0u, entry[4])
 
1440
        self.assertStatIsCorrect(entry[4], entry[3])
805
1441
 
806
1442
    def assertPathCompare(self, path_less, path_greater):
807
1443
        """check that path_less and path_greater compare correctly."""
881
1517
            sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
882
1518
 
883
1519
 
884
 
class TestCopyTree(TestCaseInTempDir):
885
 
    
 
1520
class TestCopyTree(tests.TestCaseInTempDir):
 
1521
 
886
1522
    def test_copy_basic_tree(self):
887
1523
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
888
1524
        osutils.copy_tree('source', 'target')
897
1533
        self.assertEqual(['c'], os.listdir('target/b'))
898
1534
 
899
1535
    def test_copy_tree_symlinks(self):
900
 
        if not osutils.has_symlinks():
901
 
            return
 
1536
        self.requireFeature(tests.SymlinkFeature)
902
1537
        self.build_tree(['source/'])
903
1538
        os.symlink('a/generic/path', 'source/lnk')
904
1539
        osutils.copy_tree('source', 'target')
934
1569
            self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
935
1570
 
936
1571
 
937
 
#class TestTerminalEncoding has been moved to test_osutils_encodings.py
938
 
# [bialix] 2006/12/26
939
 
 
940
 
 
941
 
class TestSetUnsetEnv(TestCase):
 
1572
class TestSetUnsetEnv(tests.TestCase):
942
1573
    """Test updating the environment"""
943
1574
 
944
1575
    def setUp(self):
968
1599
 
969
1600
    def test_unicode(self):
970
1601
        """Environment can only contain plain strings
971
 
        
 
1602
 
972
1603
        So Unicode strings must be encoded.
973
1604
        """
974
 
        # Try a few different characters, to see if we can get
975
 
        # one that will be valid in the user_encoding
976
 
        possible_vals = [u'm\xb5', u'\xe1', u'\u0410']
977
 
        for uni_val in possible_vals:
978
 
            try:
979
 
                env_val = uni_val.encode(bzrlib.user_encoding)
980
 
            except UnicodeEncodeError:
981
 
                # Try a different character
982
 
                pass
983
 
            else:
984
 
                break
985
 
        else:
986
 
            raise TestSkipped('Cannot find a unicode character that works in'
987
 
                              ' encoding %s' % (bzrlib.user_encoding,))
 
1605
        uni_val, env_val = tests.probe_unicode_in_user_encoding()
 
1606
        if uni_val is None:
 
1607
            raise tests.TestSkipped(
 
1608
                'Cannot find a unicode character that works in encoding %s'
 
1609
                % (osutils.get_user_encoding(),))
988
1610
 
989
1611
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
990
1612
        self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
998
1620
        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
999
1621
 
1000
1622
 
1001
 
class TestLocalTimeOffset(TestCase):
1002
 
 
1003
 
    def test_local_time_offset(self):
1004
 
        """Test that local_time_offset() returns a sane value."""
1005
 
        offset = osutils.local_time_offset()
1006
 
        self.assertTrue(isinstance(offset, int))
1007
 
        # Test that the offset is no more than a eighteen hours in
1008
 
        # either direction.
1009
 
        # Time zone handling is system specific, so it is difficult to
1010
 
        # do more specific tests, but a value outside of this range is
1011
 
        # probably wrong.
1012
 
        eighteen_hours = 18 * 3600
1013
 
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
1014
 
 
1015
 
    def test_local_time_offset_with_timestamp(self):
1016
 
        """Test that local_time_offset() works with a timestamp."""
1017
 
        offset = osutils.local_time_offset(1000000000.1234567)
1018
 
        self.assertTrue(isinstance(offset, int))
1019
 
        eighteen_hours = 18 * 3600
1020
 
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
1623
class TestSizeShaFile(tests.TestCaseInTempDir):
 
1624
 
 
1625
    def test_sha_empty(self):
 
1626
        self.build_tree_contents([('foo', '')])
 
1627
        expected_sha = osutils.sha_string('')
 
1628
        f = open('foo')
 
1629
        self.addCleanup(f.close)
 
1630
        size, sha = osutils.size_sha_file(f)
 
1631
        self.assertEqual(0, size)
 
1632
        self.assertEqual(expected_sha, sha)
 
1633
 
 
1634
    def test_sha_mixed_endings(self):
 
1635
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
 
1636
        self.build_tree_contents([('foo', text)])
 
1637
        expected_sha = osutils.sha_string(text)
 
1638
        f = open('foo', 'rb')
 
1639
        self.addCleanup(f.close)
 
1640
        size, sha = osutils.size_sha_file(f)
 
1641
        self.assertEqual(38, size)
 
1642
        self.assertEqual(expected_sha, sha)
 
1643
 
 
1644
 
 
1645
class TestShaFileByName(tests.TestCaseInTempDir):
 
1646
 
 
1647
    def test_sha_empty(self):
 
1648
        self.build_tree_contents([('foo', '')])
 
1649
        expected_sha = osutils.sha_string('')
 
1650
        self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
 
1651
 
 
1652
    def test_sha_mixed_endings(self):
 
1653
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
 
1654
        self.build_tree_contents([('foo', text)])
 
1655
        expected_sha = osutils.sha_string(text)
 
1656
        self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
 
1657
 
 
1658
 
 
1659
class TestResourceLoading(tests.TestCaseInTempDir):
 
1660
 
 
1661
    def test_resource_string(self):
 
1662
        # test resource in bzrlib
 
1663
        text = osutils.resource_string('bzrlib', 'debug.py')
 
1664
        self.assertContainsRe(text, "debug_flags = set()")
 
1665
        # test resource under bzrlib
 
1666
        text = osutils.resource_string('bzrlib.ui', 'text.py')
 
1667
        self.assertContainsRe(text, "class TextUIFactory")
 
1668
        # test unsupported package
 
1669
        self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
 
1670
            'yyy.xx')
 
1671
        # test unknown resource
 
1672
        self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
 
1673
 
 
1674
 
 
1675
class TestReCompile(tests.TestCase):
 
1676
 
 
1677
    def test_re_compile_checked(self):
 
1678
        r = osutils.re_compile_checked(r'A*', re.IGNORECASE)
 
1679
        self.assertTrue(r.match('aaaa'))
 
1680
        self.assertTrue(r.match('aAaA'))
 
1681
 
 
1682
    def test_re_compile_checked_error(self):
 
1683
        # like https://bugs.launchpad.net/bzr/+bug/251352
 
1684
        err = self.assertRaises(
 
1685
            errors.BzrCommandError,
 
1686
            osutils.re_compile_checked, '*', re.IGNORECASE, 'test case')
 
1687
        self.assertEqual(
 
1688
            "Invalid regular expression in test case: '*': "
 
1689
            "nothing to repeat",
 
1690
            str(err))
 
1691
 
 
1692
 
 
1693
class TestDirReader(tests.TestCaseInTempDir):
 
1694
 
 
1695
    # Set by load_tests
 
1696
    _dir_reader_class = None
 
1697
    _native_to_unicode = None
 
1698
 
 
1699
    def setUp(self):
 
1700
        tests.TestCaseInTempDir.setUp(self)
 
1701
 
 
1702
        # Save platform specific info and reset it
 
1703
        cur_dir_reader = osutils._selected_dir_reader
 
1704
 
 
1705
        def restore():
 
1706
            osutils._selected_dir_reader = cur_dir_reader
 
1707
        self.addCleanup(restore)
 
1708
 
 
1709
        osutils._selected_dir_reader = self._dir_reader_class()
 
1710
 
 
1711
    def _get_ascii_tree(self):
 
1712
        tree = [
 
1713
            '0file',
 
1714
            '1dir/',
 
1715
            '1dir/0file',
 
1716
            '1dir/1dir/',
 
1717
            '2file'
 
1718
            ]
 
1719
        expected_dirblocks = [
 
1720
                (('', '.'),
 
1721
                 [('0file', '0file', 'file'),
 
1722
                  ('1dir', '1dir', 'directory'),
 
1723
                  ('2file', '2file', 'file'),
 
1724
                 ]
 
1725
                ),
 
1726
                (('1dir', './1dir'),
 
1727
                 [('1dir/0file', '0file', 'file'),
 
1728
                  ('1dir/1dir', '1dir', 'directory'),
 
1729
                 ]
 
1730
                ),
 
1731
                (('1dir/1dir', './1dir/1dir'),
 
1732
                 [
 
1733
                 ]
 
1734
                ),
 
1735
            ]
 
1736
        return tree, expected_dirblocks
 
1737
 
 
1738
    def test_walk_cur_dir(self):
 
1739
        tree, expected_dirblocks = self._get_ascii_tree()
 
1740
        self.build_tree(tree)
 
1741
        result = list(osutils._walkdirs_utf8('.'))
 
1742
        # Filter out stat and abspath
 
1743
        self.assertEqual(expected_dirblocks,
 
1744
                         [(dirinfo, [line[0:3] for line in block])
 
1745
                          for dirinfo, block in result])
 
1746
 
 
1747
    def test_walk_sub_dir(self):
 
1748
        tree, expected_dirblocks = self._get_ascii_tree()
 
1749
        self.build_tree(tree)
 
1750
        # you can search a subdir only, with a supplied prefix.
 
1751
        result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
 
1752
        # Filter out stat and abspath
 
1753
        self.assertEqual(expected_dirblocks[1:],
 
1754
                         [(dirinfo, [line[0:3] for line in block])
 
1755
                          for dirinfo, block in result])
 
1756
 
 
1757
    def _get_unicode_tree(self):
 
1758
        name0u = u'0file-\xb6'
 
1759
        name1u = u'1dir-\u062c\u0648'
 
1760
        name2u = u'2file-\u0633'
 
1761
        tree = [
 
1762
            name0u,
 
1763
            name1u + '/',
 
1764
            name1u + '/' + name0u,
 
1765
            name1u + '/' + name1u + '/',
 
1766
            name2u,
 
1767
            ]
 
1768
        name0 = name0u.encode('UTF-8')
 
1769
        name1 = name1u.encode('UTF-8')
 
1770
        name2 = name2u.encode('UTF-8')
 
1771
        expected_dirblocks = [
 
1772
                (('', '.'),
 
1773
                 [(name0, name0, 'file', './' + name0u),
 
1774
                  (name1, name1, 'directory', './' + name1u),
 
1775
                  (name2, name2, 'file', './' + name2u),
 
1776
                 ]
 
1777
                ),
 
1778
                ((name1, './' + name1u),
 
1779
                 [(name1 + '/' + name0, name0, 'file', './' + name1u
 
1780
                                                        + '/' + name0u),
 
1781
                  (name1 + '/' + name1, name1, 'directory', './' + name1u
 
1782
                                                            + '/' + name1u),
 
1783
                 ]
 
1784
                ),
 
1785
                ((name1 + '/' + name1, './' + name1u + '/' + name1u),
 
1786
                 [
 
1787
                 ]
 
1788
                ),
 
1789
            ]
 
1790
        return tree, expected_dirblocks
 
1791
 
 
1792
    def _filter_out(self, raw_dirblocks):
 
1793
        """Filter out a walkdirs_utf8 result.
 
1794
 
 
1795
        stat field is removed, all native paths are converted to unicode
 
1796
        """
 
1797
        filtered_dirblocks = []
 
1798
        for dirinfo, block in raw_dirblocks:
 
1799
            dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
 
1800
            details = []
 
1801
            for line in block:
 
1802
                details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
 
1803
            filtered_dirblocks.append((dirinfo, details))
 
1804
        return filtered_dirblocks
 
1805
 
 
1806
    def test_walk_unicode_tree(self):
 
1807
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1808
        tree, expected_dirblocks = self._get_unicode_tree()
 
1809
        self.build_tree(tree)
 
1810
        result = list(osutils._walkdirs_utf8('.'))
 
1811
        self.assertEqual(expected_dirblocks, self._filter_out(result))
 
1812
 
 
1813
    def test_symlink(self):
 
1814
        self.requireFeature(tests.SymlinkFeature)
 
1815
        self.requireFeature(tests.UnicodeFilenameFeature)
 
1816
        target = u'target\N{Euro Sign}'
 
1817
        link_name = u'l\N{Euro Sign}nk'
 
1818
        os.symlink(target, link_name)
 
1819
        target_utf8 = target.encode('UTF-8')
 
1820
        link_name_utf8 = link_name.encode('UTF-8')
 
1821
        expected_dirblocks = [
 
1822
                (('', '.'),
 
1823
                 [(link_name_utf8, link_name_utf8,
 
1824
                   'symlink', './' + link_name),],
 
1825
                 )]
 
1826
        result = list(osutils._walkdirs_utf8('.'))
 
1827
        self.assertEqual(expected_dirblocks, self._filter_out(result))
 
1828
 
 
1829
 
 
1830
class TestReadLink(tests.TestCaseInTempDir):
 
1831
    """Exposes os.readlink() problems and the osutils solution.
 
1832
 
 
1833
    The only guarantee offered by os.readlink(), starting with 2.6, is that a
 
1834
    unicode string will be returned if a unicode string is passed.
 
1835
 
 
1836
    But prior python versions failed to properly encode the passed unicode
 
1837
    string.
 
1838
    """
 
1839
    _test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
 
1840
 
 
1841
    def setUp(self):
 
1842
        super(tests.TestCaseInTempDir, self).setUp()
 
1843
        self.link = u'l\N{Euro Sign}ink'
 
1844
        self.target = u'targe\N{Euro Sign}t'
 
1845
        os.symlink(self.target, self.link)
 
1846
 
 
1847
    def test_os_readlink_link_encoding(self):
 
1848
        if sys.version_info < (2, 6):
 
1849
            self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
 
1850
        else:
 
1851
            self.assertEquals(self.target,  os.readlink(self.link))
 
1852
 
 
1853
    def test_os_readlink_link_decoding(self):
 
1854
        self.assertEquals(self.target.encode(osutils._fs_enc),
 
1855
                          os.readlink(self.link.encode(osutils._fs_enc)))
 
1856
 
 
1857
 
 
1858
class TestConcurrency(tests.TestCase):
 
1859
 
 
1860
    def setUp(self):
 
1861
        super(TestConcurrency, self).setUp()
 
1862
        orig = osutils._cached_local_concurrency
 
1863
        def restore():
 
1864
            osutils._cached_local_concurrency = orig
 
1865
        self.addCleanup(restore)
 
1866
 
 
1867
    def test_local_concurrency(self):
 
1868
        concurrency = osutils.local_concurrency()
 
1869
        self.assertIsInstance(concurrency, int)
 
1870
 
 
1871
    def test_local_concurrency_environment_variable(self):
 
1872
        os.environ['BZR_CONCURRENCY'] = '2'
 
1873
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
 
1874
        os.environ['BZR_CONCURRENCY'] = '3'
 
1875
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
 
1876
        os.environ['BZR_CONCURRENCY'] = 'foo'
 
1877
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
 
1878
 
 
1879
    def test_option_concurrency(self):
 
1880
        os.environ['BZR_CONCURRENCY'] = '1'
 
1881
        self.run_bzr('rocks --concurrency 42')
 
1882
        # Command line overrides envrionment variable
 
1883
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
 
1884
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
 
1885
 
 
1886
 
 
1887
class TestFailedToLoadExtension(tests.TestCase):
 
1888
 
 
1889
    def _try_loading(self):
 
1890
        try:
 
1891
            import bzrlib._fictional_extension_py
 
1892
        except ImportError, e:
 
1893
            osutils.failed_to_load_extension(e)
 
1894
            return True
 
1895
 
 
1896
    def setUp(self):
 
1897
        super(TestFailedToLoadExtension, self).setUp()
 
1898
        self.saved_failures = osutils._extension_load_failures[:]
 
1899
        del osutils._extension_load_failures[:]
 
1900
        self.addCleanup(self.restore_failures)
 
1901
 
 
1902
    def restore_failures(self):
 
1903
        osutils._extension_load_failures = self.saved_failures
 
1904
 
 
1905
    def test_failure_to_load(self):
 
1906
        self._try_loading()
 
1907
        self.assertLength(1, osutils._extension_load_failures)
 
1908
        self.assertEquals(osutils._extension_load_failures[0],
 
1909
            "No module named _fictional_extension_py")
 
1910
 
 
1911
    def test_report_extension_load_failures_no_warning(self):
 
1912
        self.assertTrue(self._try_loading())
 
1913
        warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
 
1914
        # it used to give a Python warning; it no longer does
 
1915
        self.assertLength(0, warnings)
 
1916
 
 
1917
    def test_report_extension_load_failures_message(self):
 
1918
        log = StringIO()
 
1919
        trace.push_log_file(log)
 
1920
        self.assertTrue(self._try_loading())
 
1921
        osutils.report_extension_load_failures()
 
1922
        self.assertContainsRe(
 
1923
            log.getvalue(),
 
1924
            r"bzr: warning: some compiled extensions could not be loaded; "
 
1925
            "see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
 
1926
            )
 
1927
 
 
1928
 
 
1929
class TestTerminalWidth(tests.TestCase):
 
1930
 
 
1931
    def replace_stdout(self, new):
 
1932
        orig_stdout = sys.stdout
 
1933
        def restore():
 
1934
            sys.stdout = orig_stdout
 
1935
        self.addCleanup(restore)
 
1936
        sys.stdout = new
 
1937
 
 
1938
    def replace__terminal_size(self, new):
 
1939
        orig__terminal_size = osutils._terminal_size
 
1940
        def restore():
 
1941
            osutils._terminal_size = orig__terminal_size
 
1942
        self.addCleanup(restore)
 
1943
        osutils._terminal_size = new
 
1944
 
 
1945
    def set_fake_tty(self):
 
1946
 
 
1947
        class I_am_a_tty(object):
 
1948
            def isatty(self):
 
1949
                return True
 
1950
 
 
1951
        self.replace_stdout(I_am_a_tty())
 
1952
 
 
1953
    def test_default_values(self):
 
1954
        self.assertEqual(80, osutils.default_terminal_width)
 
1955
 
 
1956
    def test_defaults_to_BZR_COLUMNS(self):
 
1957
        # BZR_COLUMNS is set by the test framework
 
1958
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
 
1959
        os.environ['BZR_COLUMNS'] = '12'
 
1960
        self.assertEqual(12, osutils.terminal_width())
 
1961
 
 
1962
    def test_falls_back_to_COLUMNS(self):
 
1963
        del os.environ['BZR_COLUMNS']
 
1964
        self.assertNotEqual('42', os.environ['COLUMNS'])
 
1965
        self.set_fake_tty()
 
1966
        os.environ['COLUMNS'] = '42'
 
1967
        self.assertEqual(42, osutils.terminal_width())
 
1968
 
 
1969
    def test_tty_default_without_columns(self):
 
1970
        del os.environ['BZR_COLUMNS']
 
1971
        del os.environ['COLUMNS']
 
1972
 
 
1973
        def terminal_size(w, h):
 
1974
            return 42, 42
 
1975
 
 
1976
        self.set_fake_tty()
 
1977
        # We need to override the osutils definition as it depends on the
 
1978
        # running environment that we can't control (PQM running without a
 
1979
        # controlling terminal is one example).
 
1980
        self.replace__terminal_size(terminal_size)
 
1981
        self.assertEqual(42, osutils.terminal_width())
 
1982
 
 
1983
    def test_non_tty_default_without_columns(self):
 
1984
        del os.environ['BZR_COLUMNS']
 
1985
        del os.environ['COLUMNS']
 
1986
        self.replace_stdout(None)
 
1987
        self.assertEqual(None, osutils.terminal_width())
 
1988
 
 
1989
    def test_no_TIOCGWINSZ(self):
 
1990
        self.requireFeature(term_ios_feature)
 
1991
        termios = term_ios_feature.module
 
1992
        # bug 63539 is about a termios without TIOCGWINSZ attribute
 
1993
        try:
 
1994
            orig = termios.TIOCGWINSZ
 
1995
        except AttributeError:
 
1996
            # We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
 
1997
            pass
 
1998
        else:
 
1999
            def restore():
 
2000
                termios.TIOCGWINSZ = orig
 
2001
            self.addCleanup(restore)
 
2002
            del termios.TIOCGWINSZ
 
2003
        del os.environ['BZR_COLUMNS']
 
2004
        del os.environ['COLUMNS']
 
2005
        # Whatever the result is, if we don't raise an exception, it's ok.
 
2006
        osutils.terminal_width()