← 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: 2008-09-24 12:51:22 UTC
  • mto: (3697.7.4 1.7)
  • mto: This revision was merged to the branch mainline in revision 3748.
  • Revision ID: john@arbash-meinel.com-20080924125122-0893ip9kz0ik5cjt
Revert the path2id fix, because to_dir can be anywhere, not just
in the same directory.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for the osutils wrapper."""
18
18
 
19
19
from cStringIO import StringIO
20
20
import errno
21
21
import os
22
 
import re
23
22
import socket
24
23
import stat
25
24
import sys
26
25
import time
27
26
 
 
27
import bzrlib
28
28
from bzrlib import (
29
29
    errors,
30
30
    osutils,
31
31
    tests,
32
 
    trace,
33
32
    win32utils,
34
33
    )
 
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
        )
35
42
from bzrlib.tests import (
36
 
    features,
37
 
    file_utils,
38
 
    test__walkdirs_win32,
 
43
        adapt_tests,
 
44
        Feature,
 
45
        probe_unicode_in_user_encoding,
 
46
        split_suite_by_re,
 
47
        StringIOWrapper,
 
48
        SymlinkFeature,
 
49
        TestCase,
 
50
        TestCaseInTempDir,
 
51
        TestScenarioApplier,
 
52
        TestSkipped,
 
53
        )
 
54
from bzrlib.tests.file_utils import (
 
55
    FakeReadFile,
39
56
    )
40
 
 
41
 
 
42
 
class _UTF8DirReaderFeature(tests.Feature):
 
57
from bzrlib.tests.test__walkdirs_win32 import WalkdirsWin32Feature
 
58
 
 
59
 
 
60
def load_tests(standard_tests, module, loader):
 
61
    """Parameterize readdir tests."""
 
62
    to_adapt, result = split_suite_by_re(standard_tests, "readdir")
 
63
    adapter = TestScenarioApplier()
 
64
    from bzrlib import _readdir_py
 
65
    adapter.scenarios = [('python', {'read_dir': _readdir_py.read_dir})]
 
66
    if ReadDirFeature.available():
 
67
        adapter.scenarios.append(('pyrex',
 
68
            {'read_dir': ReadDirFeature.read_dir}))
 
69
    adapt_tests(to_adapt, adapter, result)
 
70
    return result
 
71
 
 
72
 
 
73
class _ReadDirFeature(Feature):
43
74
 
44
75
    def _probe(self):
45
76
        try:
46
77
            from bzrlib import _readdir_pyx
47
 
            self.reader = _readdir_pyx.UTF8DirReader
 
78
            self.read_dir = _readdir_pyx.read_dir
48
79
            return True
49
80
        except ImportError:
50
81
            return False
52
83
    def feature_name(self):
53
84
        return 'bzrlib._readdir_pyx'
54
85
 
55
 
UTF8DirReaderFeature = _UTF8DirReaderFeature()
56
 
 
57
 
term_ios_feature = tests.ModuleAvailableFeature('termios')
58
 
 
59
 
 
60
 
def _already_unicode(s):
61
 
    return s
62
 
 
63
 
 
64
 
def _utf8_to_unicode(s):
65
 
    return s.decode('UTF-8')
66
 
 
67
 
 
68
 
def dir_reader_scenarios():
69
 
    # For each dir reader we define:
70
 
 
71
 
    # - native_to_unicode: a function converting the native_abspath as returned
72
 
    #   by DirReader.read_dir to its unicode representation
73
 
 
74
 
    # UnicodeDirReader is the fallback, it should be tested on all platforms.
75
 
    scenarios = [('unicode',
76
 
                  dict(_dir_reader_class=osutils.UnicodeDirReader,
77
 
                       _native_to_unicode=_already_unicode))]
78
 
    # Some DirReaders are platform specific and even there they may not be
79
 
    # available.
80
 
    if UTF8DirReaderFeature.available():
81
 
        from bzrlib import _readdir_pyx
82
 
        scenarios.append(('utf8',
83
 
                          dict(_dir_reader_class=_readdir_pyx.UTF8DirReader,
84
 
                               _native_to_unicode=_utf8_to_unicode)))
85
 
 
86
 
    if test__walkdirs_win32.win32_readdir_feature.available():
87
 
        try:
88
 
            from bzrlib import _walkdirs_win32
89
 
            scenarios.append(
90
 
                ('win32',
91
 
                 dict(_dir_reader_class=_walkdirs_win32.Win32ReadDir,
92
 
                      _native_to_unicode=_already_unicode)))
93
 
        except ImportError:
94
 
            pass
95
 
    return scenarios
96
 
 
97
 
 
98
 
def load_tests(basic_tests, module, loader):
99
 
    suite = loader.suiteClass()
100
 
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
101
 
        basic_tests, tests.condition_isinstance(TestDirReader))
102
 
    tests.multiply_tests(dir_reader_tests, dir_reader_scenarios(), suite)
103
 
    suite.addTest(remaining_tests)
104
 
    return suite
105
 
 
106
 
 
107
 
class TestContainsWhitespace(tests.TestCase):
 
86
ReadDirFeature = _ReadDirFeature()
 
87
 
 
88
 
 
89
class TestOSUtils(TestCaseInTempDir):
108
90
 
109
91
    def test_contains_whitespace(self):
110
92
        self.failUnless(osutils.contains_whitespace(u' '))
120
102
        self.failIf(osutils.contains_whitespace(u'hellothere'))
121
103
        self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
122
104
 
123
 
 
124
 
class TestRename(tests.TestCaseInTempDir):
125
 
 
126
 
    def create_file(self, filename, content):
127
 
        f = open(filename, 'wb')
128
 
        try:
129
 
            f.write(content)
130
 
        finally:
131
 
            f.close()
132
 
 
133
 
    def _fancy_rename(self, a, b):
134
 
        osutils.fancy_rename(a, b, rename_func=os.rename,
135
 
                             unlink_func=os.unlink)
136
 
 
137
105
    def test_fancy_rename(self):
138
106
        # This should work everywhere
139
 
        self.create_file('a', 'something in a\n')
140
 
        self._fancy_rename('a', 'b')
 
107
        def rename(a, b):
 
108
            osutils.fancy_rename(a, b,
 
109
                    rename_func=os.rename,
 
110
                    unlink_func=os.unlink)
 
111
 
 
112
        open('a', 'wb').write('something in a\n')
 
113
        rename('a', 'b')
141
114
        self.failIfExists('a')
142
115
        self.failUnlessExists('b')
143
116
        self.check_file_contents('b', 'something in a\n')
144
117
 
145
 
        self.create_file('a', 'new something in a\n')
146
 
        self._fancy_rename('b', 'a')
 
118
        open('a', 'wb').write('new something in a\n')
 
119
        rename('b', 'a')
147
120
 
148
121
        self.check_file_contents('a', 'something in a\n')
149
122
 
150
 
    def test_fancy_rename_fails_source_missing(self):
151
 
        # An exception should be raised, and the target should be left in place
152
 
        self.create_file('target', 'data in target\n')
153
 
        self.assertRaises((IOError, OSError), self._fancy_rename,
154
 
                          'missingsource', 'target')
155
 
        self.failUnlessExists('target')
156
 
        self.check_file_contents('target', 'data in target\n')
157
 
 
158
 
    def test_fancy_rename_fails_if_source_and_target_missing(self):
159
 
        self.assertRaises((IOError, OSError), self._fancy_rename,
160
 
                          'missingsource', 'missingtarget')
161
 
 
162
123
    def test_rename(self):
163
124
        # Rename should be semi-atomic on all platforms
164
 
        self.create_file('a', 'something in a\n')
 
125
        open('a', 'wb').write('something in a\n')
165
126
        osutils.rename('a', 'b')
166
127
        self.failIfExists('a')
167
128
        self.failUnlessExists('b')
168
129
        self.check_file_contents('b', 'something in a\n')
169
130
 
170
 
        self.create_file('a', 'new something in a\n')
 
131
        open('a', 'wb').write('new something in a\n')
171
132
        osutils.rename('b', 'a')
172
133
 
173
134
        self.check_file_contents('a', 'something in a\n')
184
145
        shape = sorted(os.listdir('.'))
185
146
        self.assertEquals(['A', 'B'], shape)
186
147
 
187
 
    def test_rename_error(self):
188
 
        # We wrap os.rename to make it give an error including the filenames
189
 
        # https://bugs.launchpad.net/bzr/+bug/491763
190
 
        err = self.assertRaises(OSError, osutils.rename,
191
 
            'nonexistent', 'target')
192
 
        self.assertContainsString(str(err), 'nonexistent')
193
 
 
194
 
 
195
 
class TestRandChars(tests.TestCase):
196
 
 
197
148
    def test_01_rand_chars_empty(self):
198
149
        result = osutils.rand_chars(0)
199
150
        self.assertEqual(result, '')
204
155
        self.assertEqual(type(result), str)
205
156
        self.assertContainsRe(result, r'^[a-z0-9]{100}$')
206
157
 
207
 
 
208
 
class TestIsInside(tests.TestCase):
209
 
 
210
158
    def test_is_inside(self):
211
159
        is_inside = osutils.is_inside
212
160
        self.assertTrue(is_inside('src', 'src/foo.c'))
217
165
        self.assertTrue(is_inside('', 'foo.c'))
218
166
 
219
167
    def test_is_inside_any(self):
220
 
        SRC_FOO_C = osutils.pathjoin('src', 'foo.c')
 
168
        SRC_FOO_C = pathjoin('src', 'foo.c')
221
169
        for dirs, fn in [(['src', 'doc'], SRC_FOO_C),
222
170
                         (['src'], SRC_FOO_C),
223
171
                         (['src'], 'src'),
224
172
                         ]:
225
 
            self.assert_(osutils.is_inside_any(dirs, fn))
 
173
            self.assert_(is_inside_any(dirs, fn))
226
174
        for dirs, fn in [(['src'], 'srccontrol'),
227
175
                         (['src'], 'srccontrol/foo')]:
228
 
            self.assertFalse(osutils.is_inside_any(dirs, fn))
 
176
            self.assertFalse(is_inside_any(dirs, fn))
229
177
 
230
178
    def test_is_inside_or_parent_of_any(self):
231
179
        for dirs, fn in [(['src', 'doc'], 'src/foo.c'),
234
182
                         (['src/bar.c', 'bla/foo.c'], 'src'),
235
183
                         (['src'], 'src'),
236
184
                         ]:
237
 
            self.assert_(osutils.is_inside_or_parent_of_any(dirs, fn))
238
 
 
 
185
            self.assert_(is_inside_or_parent_of_any(dirs, fn))
 
186
            
239
187
        for dirs, fn in [(['src'], 'srccontrol'),
240
188
                         (['srccontrol/foo.c'], 'src'),
241
189
                         (['src'], 'srccontrol/foo')]:
242
 
            self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
243
 
 
244
 
 
245
 
class TestRmTree(tests.TestCaseInTempDir):
 
190
            self.assertFalse(is_inside_or_parent_of_any(dirs, fn))
246
191
 
247
192
    def test_rmtree(self):
248
193
        # Check to remove tree with read-only files/dirs
262
207
        self.failIfExists('dir/file')
263
208
        self.failIfExists('dir')
264
209
 
265
 
 
266
 
class TestDeleteAny(tests.TestCaseInTempDir):
267
 
 
268
 
    def test_delete_any_readonly(self):
269
 
        # from <https://bugs.launchpad.net/bzr/+bug/218206>
270
 
        self.build_tree(['d/', 'f'])
271
 
        osutils.make_readonly('d')
272
 
        osutils.make_readonly('f')
273
 
 
274
 
        osutils.delete_any('f')
275
 
        osutils.delete_any('d')
276
 
 
277
 
 
278
 
class TestKind(tests.TestCaseInTempDir):
279
 
 
280
210
    def test_file_kind(self):
281
211
        self.build_tree(['file', 'dir/'])
282
212
        self.assertEquals('file', osutils.file_kind('file'))
284
214
        if osutils.has_symlinks():
285
215
            os.symlink('symlink', 'symlink')
286
216
            self.assertEquals('symlink', osutils.file_kind('symlink'))
287
 
 
 
217
        
288
218
        # TODO: jam 20060529 Test a block device
289
219
        try:
290
220
            os.lstat('/dev/null')
312
242
                os.remove('socket')
313
243
 
314
244
    def test_kind_marker(self):
315
 
        self.assertEqual("", osutils.kind_marker("file"))
316
 
        self.assertEqual("/", osutils.kind_marker('directory'))
317
 
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
318
 
        self.assertEqual("@", osutils.kind_marker("symlink"))
319
 
        self.assertEqual("+", osutils.kind_marker("tree-reference"))
320
 
        self.assertEqual("", osutils.kind_marker("fifo"))
321
 
        self.assertEqual("", osutils.kind_marker("socket"))
322
 
        self.assertEqual("", osutils.kind_marker("unknown"))
323
 
 
324
 
 
325
 
class TestUmask(tests.TestCaseInTempDir):
 
245
        self.assertEqual(osutils.kind_marker('file'), '')
 
246
        self.assertEqual(osutils.kind_marker('directory'), '/')
 
247
        self.assertEqual(osutils.kind_marker('symlink'), '@')
 
248
        self.assertEqual(osutils.kind_marker('tree-reference'), '+')
326
249
 
327
250
    def test_get_umask(self):
328
251
        if sys.platform == 'win32':
331
254
            return
332
255
 
333
256
        orig_umask = osutils.get_umask()
334
 
        self.addCleanup(os.umask, orig_umask)
335
 
        os.umask(0222)
336
 
        self.assertEqual(0222, osutils.get_umask())
337
 
        os.umask(0022)
338
 
        self.assertEqual(0022, osutils.get_umask())
339
 
        os.umask(0002)
340
 
        self.assertEqual(0002, osutils.get_umask())
341
 
        os.umask(0027)
342
 
        self.assertEqual(0027, osutils.get_umask())
343
 
 
344
 
 
345
 
class TestDateTime(tests.TestCase):
 
257
        try:
 
258
            os.umask(0222)
 
259
            self.assertEqual(0222, osutils.get_umask())
 
260
            os.umask(0022)
 
261
            self.assertEqual(0022, osutils.get_umask())
 
262
            os.umask(0002)
 
263
            self.assertEqual(0002, osutils.get_umask())
 
264
            os.umask(0027)
 
265
            self.assertEqual(0027, osutils.get_umask())
 
266
        finally:
 
267
            os.umask(orig_umask)
346
268
 
347
269
    def assertFormatedDelta(self, expected, seconds):
348
270
        """Assert osutils.format_delta formats as expected"""
383
305
    def test_format_date(self):
384
306
        self.assertRaises(errors.UnsupportedTimezoneFormat,
385
307
            osutils.format_date, 0, timezone='foo')
386
 
        self.assertIsInstance(osutils.format_date(0), str)
387
 
        self.assertIsInstance(osutils.format_local_date(0), unicode)
388
 
        # Testing for the actual value of the local weekday without
389
 
        # duplicating the code from format_date is difficult.
390
 
        # Instead blackbox.test_locale should check for localized
391
 
        # dates once they do occur in output strings.
392
 
 
393
 
    def test_format_date_with_offset_in_original_timezone(self):
394
 
        self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
395
 
            osutils.format_date_with_offset_in_original_timezone(0))
396
 
        self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
397
 
            osutils.format_date_with_offset_in_original_timezone(100000))
398
 
        self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
399
 
            osutils.format_date_with_offset_in_original_timezone(100000, 7200))
400
 
 
401
 
    def test_local_time_offset(self):
402
 
        """Test that local_time_offset() returns a sane value."""
403
 
        offset = osutils.local_time_offset()
404
 
        self.assertTrue(isinstance(offset, int))
405
 
        # Test that the offset is no more than a eighteen hours in
406
 
        # either direction.
407
 
        # Time zone handling is system specific, so it is difficult to
408
 
        # do more specific tests, but a value outside of this range is
409
 
        # probably wrong.
410
 
        eighteen_hours = 18 * 3600
411
 
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
412
 
 
413
 
    def test_local_time_offset_with_timestamp(self):
414
 
        """Test that local_time_offset() works with a timestamp."""
415
 
        offset = osutils.local_time_offset(1000000000.1234567)
416
 
        self.assertTrue(isinstance(offset, int))
417
 
        eighteen_hours = 18 * 3600
418
 
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
419
 
 
420
 
 
421
 
class TestLinks(tests.TestCaseInTempDir):
422
308
 
423
309
    def test_dereference_path(self):
424
 
        self.requireFeature(tests.SymlinkFeature)
 
310
        self.requireFeature(SymlinkFeature)
425
311
        cwd = osutils.realpath('.')
426
312
        os.mkdir('bar')
427
313
        bar_path = osutils.pathjoin(cwd, 'bar')
430
316
        self.assertEqual(bar_path, osutils.realpath('./bar'))
431
317
        os.symlink('bar', 'foo')
432
318
        self.assertEqual(bar_path, osutils.realpath('./foo'))
433
 
 
 
319
        
434
320
        # Does not dereference terminal symlinks
435
321
        foo_path = osutils.pathjoin(cwd, 'foo')
436
322
        self.assertEqual(foo_path, osutils.dereference_path('./foo'))
468
354
            osutils.make_readonly('dangling')
469
355
            osutils.make_writable('dangling')
470
356
 
 
357
    def test_kind_marker(self):
 
358
        self.assertEqual("", osutils.kind_marker("file"))
 
359
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
 
360
        self.assertEqual("@", osutils.kind_marker("symlink"))
 
361
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
 
362
 
471
363
    def test_host_os_dereferences_symlinks(self):
472
364
        osutils.host_os_dereferences_symlinks()
473
365
 
474
366
 
475
 
class TestCanonicalRelPath(tests.TestCaseInTempDir):
476
 
 
477
 
    _test_needs_features = [tests.CaseInsCasePresFilenameFeature]
478
 
 
479
 
    def test_canonical_relpath_simple(self):
480
 
        f = file('MixedCaseName', 'w')
481
 
        f.close()
482
 
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
483
 
        self.failUnlessEqual('work/MixedCaseName', actual)
484
 
 
485
 
    def test_canonical_relpath_missing_tail(self):
486
 
        os.mkdir('MixedCaseParent')
487
 
        actual = osutils.canonical_relpath(self.test_base_dir,
488
 
                                           'mixedcaseparent/nochild')
489
 
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
490
 
 
491
 
 
492
 
class Test_CICPCanonicalRelpath(tests.TestCaseWithTransport):
493
 
 
494
 
    def assertRelpath(self, expected, base, path):
495
 
        actual = osutils._cicp_canonical_relpath(base, path)
496
 
        self.assertEqual(expected, actual)
497
 
 
498
 
    def test_simple(self):
499
 
        self.build_tree(['MixedCaseName'])
500
 
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
501
 
        self.assertRelpath('MixedCaseName', base, 'mixedcAsename')
502
 
 
503
 
    def test_subdir_missing_tail(self):
504
 
        self.build_tree(['MixedCaseParent/', 'MixedCaseParent/a_child'])
505
 
        base = osutils.realpath(self.get_transport('.').local_abspath('.'))
506
 
        self.assertRelpath('MixedCaseParent/a_child', base,
507
 
                           'MixedCaseParent/a_child')
508
 
        self.assertRelpath('MixedCaseParent/a_child', base,
509
 
                           'MixedCaseParent/A_Child')
510
 
        self.assertRelpath('MixedCaseParent/not_child', base,
511
 
                           'MixedCaseParent/not_child')
512
 
 
513
 
    def test_at_root_slash(self):
514
 
        # We can't test this on Windows, because it has a 'MIN_ABS_PATHLENGTH'
515
 
        # check...
516
 
        if osutils.MIN_ABS_PATHLENGTH > 1:
517
 
            raise tests.TestSkipped('relpath requires %d chars'
518
 
                                    % osutils.MIN_ABS_PATHLENGTH)
519
 
        self.assertRelpath('foo', '/', '/foo')
520
 
 
521
 
    def test_at_root_drive(self):
522
 
        if sys.platform != 'win32':
523
 
            raise tests.TestNotApplicable('we can only test drive-letter relative'
524
 
                                          ' paths on Windows where we have drive'
525
 
                                          ' letters.')
526
 
        # see bug #322807
527
 
        # The specific issue is that when at the root of a drive, 'abspath'
528
 
        # returns "C:/" or just "/". However, the code assumes that abspath
529
 
        # always returns something like "C:/foo" or "/foo" (no trailing slash).
530
 
        self.assertRelpath('foo', 'C:/', 'C:/foo')
531
 
        self.assertRelpath('foo', 'X:/', 'X:/foo')
532
 
        self.assertRelpath('foo', 'X:/', 'X://foo')
533
 
 
534
 
 
535
 
class TestPumpFile(tests.TestCase):
 
367
class TestPumpFile(TestCase):
536
368
    """Test pumpfile method."""
537
 
 
538
369
    def setUp(self):
539
 
        tests.TestCase.setUp(self)
540
370
        # create a test datablock
541
371
        self.block_size = 512
542
372
        pattern = '0123456789ABCDEF'
549
379
        # make sure test data is larger than max read size
550
380
        self.assertTrue(self.test_data_len > self.block_size)
551
381
 
552
 
        from_file = file_utils.FakeReadFile(self.test_data)
 
382
        from_file = FakeReadFile(self.test_data)
553
383
        to_file = StringIO()
554
384
 
555
385
        # read (max / 2) bytes and verify read size wasn't affected
556
386
        num_bytes_to_read = self.block_size / 2
557
 
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
387
        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
558
388
        self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
559
389
        self.assertEqual(from_file.get_read_count(), 1)
560
390
 
561
391
        # read (max) bytes and verify read size wasn't affected
562
392
        num_bytes_to_read = self.block_size
563
393
        from_file.reset_read_count()
564
 
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
394
        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
565
395
        self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
566
396
        self.assertEqual(from_file.get_read_count(), 1)
567
397
 
568
398
        # read (max + 1) bytes and verify read size was limited
569
399
        num_bytes_to_read = self.block_size + 1
570
400
        from_file.reset_read_count()
571
 
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
401
        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
572
402
        self.assertEqual(from_file.get_max_read_size(), self.block_size)
573
403
        self.assertEqual(from_file.get_read_count(), 2)
574
404
 
575
405
        # finish reading the rest of the data
576
406
        num_bytes_to_read = self.test_data_len - to_file.tell()
577
 
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
407
        pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
578
408
 
579
409
        # report error if the data wasn't equal (we only report the size due
580
410
        # to the length of the data)
590
420
        self.assertTrue(self.test_data_len > self.block_size)
591
421
 
592
422
        # retrieve data in blocks
593
 
        from_file = file_utils.FakeReadFile(self.test_data)
 
423
        from_file = FakeReadFile(self.test_data)
594
424
        to_file = StringIO()
595
 
        osutils.pumpfile(from_file, to_file, self.test_data_len,
596
 
                         self.block_size)
 
425
        pumpfile(from_file, to_file, self.test_data_len, self.block_size)
597
426
 
598
427
        # verify read size was equal to the maximum read size
599
428
        self.assertTrue(from_file.get_max_read_size() > 0)
614
443
        self.assertTrue(self.test_data_len > self.block_size)
615
444
 
616
445
        # retrieve data to EOF
617
 
        from_file = file_utils.FakeReadFile(self.test_data)
 
446
        from_file = FakeReadFile(self.test_data)
618
447
        to_file = StringIO()
619
 
        osutils.pumpfile(from_file, to_file, -1, self.block_size)
 
448
        pumpfile(from_file, to_file, -1, self.block_size)
620
449
 
621
450
        # verify read size was equal to the maximum read size
622
451
        self.assertEqual(from_file.get_max_read_size(), self.block_size)
634
463
        test verifies that any existing usages of pumpfile will not be broken
635
464
        with this new version."""
636
465
        # retrieve data using default (old) pumpfile method
637
 
        from_file = file_utils.FakeReadFile(self.test_data)
 
466
        from_file = FakeReadFile(self.test_data)
638
467
        to_file = StringIO()
639
 
        osutils.pumpfile(from_file, to_file)
 
468
        pumpfile(from_file, to_file)
640
469
 
641
470
        # report error if the data wasn't equal (we only report the size due
642
471
        # to the length of the data)
645
474
            message = "Data not equal.  Expected %d bytes, received %d."
646
475
            self.fail(message % (len(response_data), self.test_data_len))
647
476
 
648
 
    def test_report_activity(self):
649
 
        activity = []
650
 
        def log_activity(length, direction):
651
 
            activity.append((length, direction))
652
 
        from_file = StringIO(self.test_data)
653
 
        to_file = StringIO()
654
 
        osutils.pumpfile(from_file, to_file, buff_size=500,
655
 
                         report_activity=log_activity, direction='read')
656
 
        self.assertEqual([(500, 'read'), (500, 'read'), (500, 'read'),
657
 
                          (36, 'read')], activity)
658
 
 
659
 
        from_file = StringIO(self.test_data)
660
 
        to_file = StringIO()
661
 
        del activity[:]
662
 
        osutils.pumpfile(from_file, to_file, buff_size=500,
663
 
                         report_activity=log_activity, direction='write')
664
 
        self.assertEqual([(500, 'write'), (500, 'write'), (500, 'write'),
665
 
                          (36, 'write')], activity)
666
 
 
667
 
        # And with a limited amount of data
668
 
        from_file = StringIO(self.test_data)
669
 
        to_file = StringIO()
670
 
        del activity[:]
671
 
        osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
672
 
                         report_activity=log_activity, direction='read')
673
 
        self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
674
 
 
675
 
 
676
 
 
677
 
class TestPumpStringFile(tests.TestCase):
 
477
 
 
478
class TestPumpStringFile(TestCase):
678
479
 
679
480
    def test_empty(self):
680
481
        output = StringIO()
681
 
        osutils.pump_string_file("", output)
 
482
        pump_string_file("", output)
682
483
        self.assertEqual("", output.getvalue())
683
484
 
684
485
    def test_more_than_segment_size(self):
685
486
        output = StringIO()
686
 
        osutils.pump_string_file("123456789", output, 2)
 
487
        pump_string_file("123456789", output, 2)
687
488
        self.assertEqual("123456789", output.getvalue())
688
489
 
689
490
    def test_segment_size(self):
690
491
        output = StringIO()
691
 
        osutils.pump_string_file("12", output, 2)
 
492
        pump_string_file("12", output, 2)
692
493
        self.assertEqual("12", output.getvalue())
693
494
 
694
495
    def test_segment_size_multiple(self):
695
496
        output = StringIO()
696
 
        osutils.pump_string_file("1234", output, 2)
 
497
        pump_string_file("1234", output, 2)
697
498
        self.assertEqual("1234", output.getvalue())
698
499
 
699
500
 
700
 
class TestRelpath(tests.TestCase):
701
 
 
702
 
    def test_simple_relpath(self):
703
 
        cwd = osutils.getcwd()
704
 
        subdir = cwd + '/subdir'
705
 
        self.assertEqual('subdir', osutils.relpath(cwd, subdir))
706
 
 
707
 
    def test_deep_relpath(self):
708
 
        cwd = osutils.getcwd()
709
 
        subdir = cwd + '/sub/subsubdir'
710
 
        self.assertEqual('sub/subsubdir', osutils.relpath(cwd, subdir))
711
 
 
712
 
    def test_not_relative(self):
713
 
        self.assertRaises(errors.PathNotChild,
714
 
                          osutils.relpath, 'C:/path', 'H:/path')
715
 
        self.assertRaises(errors.PathNotChild,
716
 
                          osutils.relpath, 'C:/', 'H:/path')
717
 
 
718
 
 
719
 
class TestSafeUnicode(tests.TestCase):
 
501
class TestSafeUnicode(TestCase):
720
502
 
721
503
    def test_from_ascii_string(self):
722
504
        self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
731
513
        self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
732
514
 
733
515
    def test_bad_utf8_string(self):
734
 
        self.assertRaises(errors.BzrBadParameterNotUnicode,
 
516
        self.assertRaises(BzrBadParameterNotUnicode,
735
517
                          osutils.safe_unicode,
736
518
                          '\xbb\xbb')
737
519
 
738
520
 
739
 
class TestSafeUtf8(tests.TestCase):
 
521
class TestSafeUtf8(TestCase):
740
522
 
741
523
    def test_from_ascii_string(self):
742
524
        f = 'foobar'
752
534
        self.assertEqual('foo\xc2\xae', osutils.safe_utf8('foo\xc2\xae'))
753
535
 
754
536
    def test_bad_utf8_string(self):
755
 
        self.assertRaises(errors.BzrBadParameterNotUnicode,
 
537
        self.assertRaises(BzrBadParameterNotUnicode,
756
538
                          osutils.safe_utf8, '\xbb\xbb')
757
539
 
758
540
 
759
 
class TestSafeRevisionId(tests.TestCase):
 
541
class TestSafeRevisionId(TestCase):
760
542
 
761
543
    def test_from_ascii_string(self):
762
544
        # this shouldn't give a warning because it's getting an ascii string
784
566
        self.assertEqual(None, osutils.safe_revision_id(None))
785
567
 
786
568
 
787
 
class TestSafeFileId(tests.TestCase):
 
569
class TestSafeFileId(TestCase):
788
570
 
789
571
    def test_from_ascii_string(self):
790
572
        self.assertEqual('foobar', osutils.safe_file_id('foobar'))
810
592
        self.assertEqual(None, osutils.safe_file_id(None))
811
593
 
812
594
 
813
 
class TestWin32Funcs(tests.TestCase):
814
 
    """Test that _win32 versions of os utilities return appropriate paths."""
 
595
class TestWin32Funcs(TestCase):
 
596
    """Test that the _win32 versions of os utilities return appropriate paths."""
815
597
 
816
598
    def test_abspath(self):
817
599
        self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
824
606
        self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
825
607
 
826
608
    def test_pathjoin(self):
827
 
        self.assertEqual('path/to/foo',
828
 
                         osutils._win32_pathjoin('path', 'to', 'foo'))
829
 
        self.assertEqual('C:/foo',
830
 
                         osutils._win32_pathjoin('path\\to', 'C:\\foo'))
831
 
        self.assertEqual('C:/foo',
832
 
                         osutils._win32_pathjoin('path/to', 'C:/foo'))
833
 
        self.assertEqual('path/to/foo',
834
 
                         osutils._win32_pathjoin('path/to/', 'foo'))
835
 
        self.assertEqual('/foo',
836
 
                         osutils._win32_pathjoin('C:/path/to/', '/foo'))
837
 
        self.assertEqual('/foo',
838
 
                         osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
 
609
        self.assertEqual('path/to/foo', osutils._win32_pathjoin('path', 'to', 'foo'))
 
610
        self.assertEqual('C:/foo', osutils._win32_pathjoin('path\\to', 'C:\\foo'))
 
611
        self.assertEqual('C:/foo', osutils._win32_pathjoin('path/to', 'C:/foo'))
 
612
        self.assertEqual('path/to/foo', osutils._win32_pathjoin('path/to/', 'foo'))
 
613
        self.assertEqual('/foo', osutils._win32_pathjoin('C:/path/to/', '/foo'))
 
614
        self.assertEqual('/foo', osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
839
615
 
840
616
    def test_normpath(self):
841
 
        self.assertEqual('path/to/foo',
842
 
                         osutils._win32_normpath(r'path\\from\..\to\.\foo'))
843
 
        self.assertEqual('path/to/foo',
844
 
                         osutils._win32_normpath('path//from/../to/./foo'))
 
617
        self.assertEqual('path/to/foo', osutils._win32_normpath(r'path\\from\..\to\.\foo'))
 
618
        self.assertEqual('path/to/foo', osutils._win32_normpath('path//from/../to/./foo'))
845
619
 
846
620
    def test_getcwd(self):
847
621
        cwd = osutils._win32_getcwd()
876
650
        self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
877
651
 
878
652
 
879
 
class TestWin32FuncsDirs(tests.TestCaseInTempDir):
 
653
class TestWin32FuncsDirs(TestCaseInTempDir):
880
654
    """Test win32 functions that create files."""
 
655
    
 
656
    def test_getcwd(self):
 
657
        if win32utils.winver == 'Windows 98':
 
658
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
 
659
        # Make sure getcwd can handle unicode filenames
 
660
        try:
 
661
            os.mkdir(u'mu-\xb5')
 
662
        except UnicodeError:
 
663
            raise TestSkipped("Unable to create Unicode filename")
881
664
 
882
 
    def test_getcwd(self):
883
 
        self.requireFeature(tests.UnicodeFilenameFeature)
884
 
        os.mkdir(u'mu-\xb5')
885
665
        os.chdir(u'mu-\xb5')
886
666
        # TODO: jam 20060427 This will probably fail on Mac OSX because
887
667
        #       it will change the normalization of B\xe5gfors
892
672
    def test_minimum_path_selection(self):
893
673
        self.assertEqual(set(),
894
674
            osutils.minimum_path_selection([]))
895
 
        self.assertEqual(set(['a']),
896
 
            osutils.minimum_path_selection(['a']))
897
675
        self.assertEqual(set(['a', 'b']),
898
676
            osutils.minimum_path_selection(['a', 'b']))
899
677
        self.assertEqual(set(['a/', 'b']),
900
678
            osutils.minimum_path_selection(['a/', 'b']))
901
679
        self.assertEqual(set(['a/', 'b']),
902
680
            osutils.minimum_path_selection(['a/c', 'a/', 'b']))
903
 
        self.assertEqual(set(['a-b', 'a', 'a0b']),
904
 
            osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
905
681
 
906
682
    def test_mkdtemp(self):
907
683
        tmpdir = osutils._win32_mkdtemp(dir='.')
963
739
        self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
964
740
 
965
741
 
966
 
class TestParentDirectories(tests.TestCaseInTempDir):
967
 
    """Test osutils.parent_directories()"""
968
 
 
969
 
    def test_parent_directories(self):
970
 
        self.assertEqual([], osutils.parent_directories('a'))
971
 
        self.assertEqual(['a'], osutils.parent_directories('a/b'))
972
 
        self.assertEqual(['a/b', 'a'], osutils.parent_directories('a/b/c'))
973
 
 
974
 
 
975
 
class TestMacFuncsDirs(tests.TestCaseInTempDir):
 
742
class TestMacFuncsDirs(TestCaseInTempDir):
976
743
    """Test mac special functions that require directories."""
977
744
 
978
745
    def test_getcwd(self):
979
 
        self.requireFeature(tests.UnicodeFilenameFeature)
980
 
        os.mkdir(u'B\xe5gfors')
 
746
        # On Mac, this will actually create Ba\u030agfors
 
747
        # but chdir will still work, because it accepts both paths
 
748
        try:
 
749
            os.mkdir(u'B\xe5gfors')
 
750
        except UnicodeError:
 
751
            raise TestSkipped("Unable to create Unicode filename")
 
752
 
981
753
        os.chdir(u'B\xe5gfors')
982
754
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
983
755
 
984
756
    def test_getcwd_nonnorm(self):
985
 
        self.requireFeature(tests.UnicodeFilenameFeature)
986
757
        # Test that _mac_getcwd() will normalize this path
987
 
        os.mkdir(u'Ba\u030agfors')
 
758
        try:
 
759
            os.mkdir(u'Ba\u030agfors')
 
760
        except UnicodeError:
 
761
            raise TestSkipped("Unable to create Unicode filename")
 
762
 
988
763
        os.chdir(u'Ba\u030agfors')
989
764
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
990
765
 
991
766
 
992
 
class TestChunksToLines(tests.TestCase):
993
 
 
994
 
    def test_smoketest(self):
995
 
        self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
996
 
                         osutils.chunks_to_lines(['foo\nbar', '\nbaz\n']))
997
 
        self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
998
 
                         osutils.chunks_to_lines(['foo\n', 'bar\n', 'baz\n']))
999
 
 
1000
 
    def test_osutils_binding(self):
1001
 
        from bzrlib.tests import test__chunks_to_lines
1002
 
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
1003
 
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
1004
 
        else:
1005
 
            from bzrlib._chunks_to_lines_py import chunks_to_lines
1006
 
        self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
1007
 
 
1008
 
 
1009
 
class TestSplitLines(tests.TestCase):
 
767
class TestSplitLines(TestCase):
1010
768
 
1011
769
    def test_split_unicode(self):
1012
770
        self.assertEqual([u'foo\n', u'bar\xae'],
1019
777
                         osutils.split_lines('foo\rbar\n'))
1020
778
 
1021
779
 
1022
 
class TestWalkDirs(tests.TestCaseInTempDir):
1023
 
 
1024
 
    def assertExpectedBlocks(self, expected, result):
1025
 
        self.assertEqual(expected,
1026
 
                         [(dirinfo, [line[0:3] for line in block])
1027
 
                          for dirinfo, block in result])
1028
 
 
 
780
class TestWalkDirs(TestCaseInTempDir):
 
781
 
 
782
    def test_readdir(self):
 
783
        tree = [
 
784
            '.bzr/',
 
785
            '0file',
 
786
            '1dir/',
 
787
            '1dir/0file',
 
788
            '1dir/1dir/',
 
789
            '2file'
 
790
            ]
 
791
        self.build_tree(tree)
 
792
        expected_names = ['.bzr', '0file', '1dir', '2file']
 
793
        # read_dir returns pairs, which form a table with either None in all
 
794
        # the first columns, or a sort key to get best on-disk-read order, 
 
795
        # and the disk path name in utf-8 encoding in the second column.
 
796
        read_result = self.read_dir('.')
 
797
        # The second column is always the names, and every name except "." and
 
798
        # ".." should be present.
 
799
        names = sorted([row[1] for row in read_result])
 
800
        self.assertEqual(expected_names, names)
 
801
        expected_sort_key = None
 
802
        if read_result[0][0] is None:
 
803
            # No sort key returned - all keys must None
 
804
            operator = self.assertEqual
 
805
        else:
 
806
            # A sort key in the first row implies sort keys in the other rows.
 
807
            operator = self.assertNotEqual
 
808
        for row in read_result:
 
809
            operator(None, row[0])
 
810
 
 
811
    def test_compiled_extension_exists(self):
 
812
        self.requireFeature(ReadDirFeature)
 
813
        
1029
814
    def test_walkdirs(self):
1030
815
        tree = [
1031
816
            '.bzr',
1063
848
            result.append((dirdetail, dirblock))
1064
849
 
1065
850
        self.assertTrue(found_bzrdir)
1066
 
        self.assertExpectedBlocks(expected_dirblocks, result)
 
851
        self.assertEqual(expected_dirblocks,
 
852
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1067
853
        # you can search a subdir only, with a supplied prefix.
1068
854
        result = []
1069
855
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
1070
856
            result.append(dirblock)
1071
 
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
1072
 
 
1073
 
    def test_walkdirs_os_error(self):
1074
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/338653>
1075
 
        # Pyrex readdir didn't raise useful messages if it had an error
1076
 
        # reading the directory
1077
 
        if sys.platform == 'win32':
1078
 
            raise tests.TestNotApplicable(
1079
 
                "readdir IOError not tested on win32")
1080
 
        os.mkdir("test-unreadable")
1081
 
        os.chmod("test-unreadable", 0000)
1082
 
        # must chmod it back so that it can be removed
1083
 
        self.addCleanup(os.chmod, "test-unreadable", 0700)
1084
 
        # The error is not raised until the generator is actually evaluated.
1085
 
        # (It would be ok if it happened earlier but at the moment it
1086
 
        # doesn't.)
1087
 
        e = self.assertRaises(OSError, list, osutils._walkdirs_utf8("."))
1088
 
        self.assertEquals('./test-unreadable', e.filename)
1089
 
        self.assertEquals(errno.EACCES, e.errno)
1090
 
        # Ensure the message contains the file name
1091
 
        self.assertContainsRe(str(e), "\./test-unreadable")
 
857
        self.assertEqual(expected_dirblocks[1:],
 
858
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1092
859
 
1093
860
    def test__walkdirs_utf8(self):
1094
861
        tree = [
1127
894
            result.append((dirdetail, dirblock))
1128
895
 
1129
896
        self.assertTrue(found_bzrdir)
1130
 
        self.assertExpectedBlocks(expected_dirblocks, result)
1131
 
 
 
897
        self.assertEqual(expected_dirblocks,
 
898
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1132
899
        # you can search a subdir only, with a supplied prefix.
1133
900
        result = []
1134
901
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
1135
902
            result.append(dirblock)
1136
 
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
 
903
        self.assertEqual(expected_dirblocks[1:],
 
904
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1137
905
 
1138
906
    def _filter_out_stat(self, result):
1139
907
        """Filter out the stat value from the walkdirs result"""
1144
912
                new_dirblock.append((info[0], info[1], info[2], info[4]))
1145
913
            dirblock[:] = new_dirblock
1146
914
 
 
915
    def test__walkdirs_utf8_selection(self):
 
916
        # Just trigger the function once, to make sure it has selected a real
 
917
        # implementation.
 
918
        list(osutils._walkdirs_utf8('.'))
 
919
        if WalkdirsWin32Feature.available():
 
920
            # If the compiled form is available, make sure it is used
 
921
            from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
 
922
            self.assertIs(_walkdirs_utf8_win32_find_file,
 
923
                          osutils._real_walkdirs_utf8)
 
924
        elif sys.platform == 'win32':
 
925
            self.assertIs(osutils._walkdirs_unicode_to_utf8,
 
926
                          osutils._real_walkdirs_utf8)
 
927
        elif osutils._fs_enc.upper() in ('UTF-8', 'ASCII', 'ANSI_X3.4-1968'): # ascii
 
928
            self.assertIs(osutils._walkdirs_fs_utf8,
 
929
                          osutils._real_walkdirs_utf8)
 
930
        else:
 
931
            self.assertIs(osutils._walkdirs_unicode_to_utf8,
 
932
                          osutils._real_walkdirs_utf8)
 
933
 
1147
934
    def _save_platform_info(self):
1148
 
        self.overrideAttr(win32utils, 'winver')
1149
 
        self.overrideAttr(osutils, '_fs_enc')
1150
 
        self.overrideAttr(osutils, '_selected_dir_reader')
 
935
        cur_winver = win32utils.winver
 
936
        cur_fs_enc = osutils._fs_enc
 
937
        cur_real_walkdirs_utf8 = osutils._real_walkdirs_utf8
 
938
        def restore():
 
939
            win32utils.winver = cur_winver
 
940
            osutils._fs_enc = cur_fs_enc
 
941
            osutils._real_walkdirs_utf8 = cur_real_walkdirs_utf8
 
942
        self.addCleanup(restore)
1151
943
 
1152
 
    def assertDirReaderIs(self, expected):
 
944
    def assertWalkdirsUtf8Is(self, expected):
1153
945
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
1154
946
        # Force it to redetect
1155
 
        osutils._selected_dir_reader = None
 
947
        osutils._real_walkdirs_utf8 = None
1156
948
        # Nothing to list, but should still trigger the selection logic
1157
949
        self.assertEqual([(('', '.'), [])], list(osutils._walkdirs_utf8('.')))
1158
 
        self.assertIsInstance(osutils._selected_dir_reader, expected)
 
950
        self.assertIs(expected, osutils._real_walkdirs_utf8)
1159
951
 
1160
952
    def test_force_walkdirs_utf8_fs_utf8(self):
1161
 
        self.requireFeature(UTF8DirReaderFeature)
1162
953
        self._save_platform_info()
1163
954
        win32utils.winver = None # Avoid the win32 detection code
1164
955
        osutils._fs_enc = 'UTF-8'
1165
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
956
        self.assertWalkdirsUtf8Is(osutils._walkdirs_fs_utf8)
1166
957
 
1167
958
    def test_force_walkdirs_utf8_fs_ascii(self):
1168
 
        self.requireFeature(UTF8DirReaderFeature)
1169
959
        self._save_platform_info()
1170
960
        win32utils.winver = None # Avoid the win32 detection code
1171
961
        osutils._fs_enc = 'US-ASCII'
1172
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
962
        self.assertWalkdirsUtf8Is(osutils._walkdirs_fs_utf8)
1173
963
 
1174
964
    def test_force_walkdirs_utf8_fs_ANSI(self):
1175
 
        self.requireFeature(UTF8DirReaderFeature)
1176
965
        self._save_platform_info()
1177
966
        win32utils.winver = None # Avoid the win32 detection code
1178
967
        osutils._fs_enc = 'ANSI_X3.4-1968'
1179
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
968
        self.assertWalkdirsUtf8Is(osutils._walkdirs_fs_utf8)
1180
969
 
1181
970
    def test_force_walkdirs_utf8_fs_latin1(self):
1182
971
        self._save_platform_info()
1183
972
        win32utils.winver = None # Avoid the win32 detection code
1184
973
        osutils._fs_enc = 'latin1'
1185
 
        self.assertDirReaderIs(osutils.UnicodeDirReader)
 
974
        self.assertWalkdirsUtf8Is(osutils._walkdirs_unicode_to_utf8)
1186
975
 
1187
976
    def test_force_walkdirs_utf8_nt(self):
1188
 
        # Disabled because the thunk of the whole walkdirs api is disabled.
1189
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
977
        self.requireFeature(WalkdirsWin32Feature)
1190
978
        self._save_platform_info()
1191
979
        win32utils.winver = 'Windows NT'
1192
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
1193
 
        self.assertDirReaderIs(Win32ReadDir)
 
980
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
 
981
        self.assertWalkdirsUtf8Is(_walkdirs_utf8_win32_find_file)
1194
982
 
1195
 
    def test_force_walkdirs_utf8_98(self):
1196
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
983
    def test_force_walkdirs_utf8_nt(self):
 
984
        self.requireFeature(WalkdirsWin32Feature)
1197
985
        self._save_platform_info()
1198
986
        win32utils.winver = 'Windows 98'
1199
 
        self.assertDirReaderIs(osutils.UnicodeDirReader)
 
987
        self.assertWalkdirsUtf8Is(osutils._walkdirs_unicode_to_utf8)
1200
988
 
1201
989
    def test_unicode_walkdirs(self):
1202
990
        """Walkdirs should always return unicode paths."""
1203
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1204
991
        name0 = u'0file-\xb6'
1205
992
        name1 = u'1dir-\u062c\u0648'
1206
993
        name2 = u'2file-\u0633'
1211
998
            name1 + '/' + name1 + '/',
1212
999
            name2,
1213
1000
            ]
1214
 
        self.build_tree(tree)
 
1001
        try:
 
1002
            self.build_tree(tree)
 
1003
        except UnicodeError:
 
1004
            raise TestSkipped('Could not represent Unicode chars'
 
1005
                              ' in current encoding.')
1215
1006
        expected_dirblocks = [
1216
1007
                ((u'', u'.'),
1217
1008
                 [(name0, name0, 'file', './' + name0),
1243
1034
 
1244
1035
        The abspath portion might be in unicode or utf-8
1245
1036
        """
1246
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1247
1037
        name0 = u'0file-\xb6'
1248
1038
        name1 = u'1dir-\u062c\u0648'
1249
1039
        name2 = u'2file-\u0633'
1254
1044
            name1 + '/' + name1 + '/',
1255
1045
            name2,
1256
1046
            ]
1257
 
        self.build_tree(tree)
 
1047
        try:
 
1048
            self.build_tree(tree)
 
1049
        except UnicodeError:
 
1050
            raise TestSkipped('Could not represent Unicode chars'
 
1051
                              ' in current encoding.')
1258
1052
        name0 = name0.encode('utf8')
1259
1053
        name1 = name1.encode('utf8')
1260
1054
        name2 = name2.encode('utf8')
1299
1093
            result.append((dirdetail, new_dirblock))
1300
1094
        self.assertEqual(expected_dirblocks, result)
1301
1095
 
1302
 
    def test__walkdirs_utf8_with_unicode_fs(self):
1303
 
        """UnicodeDirReader should be a safe fallback everywhere
 
1096
    def test_unicode__walkdirs_unicode_to_utf8(self):
 
1097
        """walkdirs_unicode_to_utf8 should be a safe fallback everywhere
1304
1098
 
1305
1099
        The abspath portion should be in unicode
1306
1100
        """
1307
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1308
 
        # Use the unicode reader. TODO: split into driver-and-driven unit
1309
 
        # tests.
1310
 
        self._save_platform_info()
1311
 
        osutils._selected_dir_reader = osutils.UnicodeDirReader()
1312
1101
        name0u = u'0file-\xb6'
1313
1102
        name1u = u'1dir-\u062c\u0648'
1314
1103
        name2u = u'2file-\u0633'
1319
1108
            name1u + '/' + name1u + '/',
1320
1109
            name2u,
1321
1110
            ]
1322
 
        self.build_tree(tree)
 
1111
        try:
 
1112
            self.build_tree(tree)
 
1113
        except UnicodeError:
 
1114
            raise TestSkipped('Could not represent Unicode chars'
 
1115
                              ' in current encoding.')
1323
1116
        name0 = name0u.encode('utf8')
1324
1117
        name1 = name1u.encode('utf8')
1325
1118
        name2 = name2u.encode('utf8')
1345
1138
                 ]
1346
1139
                ),
1347
1140
            ]
1348
 
        result = list(osutils._walkdirs_utf8('.'))
 
1141
        result = list(osutils._walkdirs_unicode_to_utf8('.'))
1349
1142
        self._filter_out_stat(result)
1350
1143
        self.assertEqual(expected_dirblocks, result)
1351
1144
 
1352
 
    def test__walkdirs_utf8_win32readdir(self):
1353
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1145
    def test__walkdirs_utf_win32_find_file(self):
 
1146
        self.requireFeature(WalkdirsWin32Feature)
1354
1147
        self.requireFeature(tests.UnicodeFilenameFeature)
1355
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
1356
 
        self._save_platform_info()
1357
 
        osutils._selected_dir_reader = Win32ReadDir()
 
1148
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
1358
1149
        name0u = u'0file-\xb6'
1359
1150
        name1u = u'1dir-\u062c\u0648'
1360
1151
        name2u = u'2file-\u0633'
1391
1182
                 ]
1392
1183
                ),
1393
1184
            ]
1394
 
        result = list(osutils._walkdirs_utf8(u'.'))
 
1185
        result = list(_walkdirs_utf8_win32_find_file(u'.'))
1395
1186
        self._filter_out_stat(result)
1396
1187
        self.assertEqual(expected_dirblocks, result)
1397
1188
 
1407
1198
 
1408
1199
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1409
1200
        """make sure our Stat values are valid"""
1410
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1201
        self.requireFeature(WalkdirsWin32Feature)
1411
1202
        self.requireFeature(tests.UnicodeFilenameFeature)
1412
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1203
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
1413
1204
        name0u = u'0file-\xb6'
1414
1205
        name0 = name0u.encode('utf8')
1415
1206
        self.build_tree([name0u])
1422
1213
        finally:
1423
1214
            f.close()
1424
1215
 
1425
 
        result = Win32ReadDir().read_dir('', u'.')
1426
 
        entry = result[0]
 
1216
        result = list(_walkdirs_utf8_win32_find_file(u'.'))
 
1217
        entry = result[0][1][0]
1427
1218
        self.assertEqual((name0, name0, 'file'), entry[:3])
1428
1219
        self.assertEqual(u'./' + name0u, entry[4])
1429
1220
        self.assertStatIsCorrect(entry[4], entry[3])
1431
1222
 
1432
1223
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1433
1224
        """make sure our Stat values are valid"""
1434
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1225
        self.requireFeature(WalkdirsWin32Feature)
1435
1226
        self.requireFeature(tests.UnicodeFilenameFeature)
1436
 
        from bzrlib._walkdirs_win32 import Win32ReadDir
 
1227
        from bzrlib._walkdirs_win32 import _walkdirs_utf8_win32_find_file
1437
1228
        name0u = u'0dir-\u062c\u0648'
1438
1229
        name0 = name0u.encode('utf8')
1439
1230
        self.build_tree([name0u + '/'])
1440
1231
 
1441
 
        result = Win32ReadDir().read_dir('', u'.')
1442
 
        entry = result[0]
 
1232
        result = list(_walkdirs_utf8_win32_find_file(u'.'))
 
1233
        entry = result[0][1][0]
1443
1234
        self.assertEqual((name0, name0, 'directory'), entry[:3])
1444
1235
        self.assertEqual(u'./' + name0u, entry[4])
1445
1236
        self.assertStatIsCorrect(entry[4], entry[3])
1522
1313
            sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
1523
1314
 
1524
1315
 
1525
 
class TestCopyTree(tests.TestCaseInTempDir):
1526
 
 
 
1316
class TestCopyTree(TestCaseInTempDir):
 
1317
    
1527
1318
    def test_copy_basic_tree(self):
1528
1319
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1529
1320
        osutils.copy_tree('source', 'target')
1538
1329
        self.assertEqual(['c'], os.listdir('target/b'))
1539
1330
 
1540
1331
    def test_copy_tree_symlinks(self):
1541
 
        self.requireFeature(tests.SymlinkFeature)
 
1332
        self.requireFeature(SymlinkFeature)
1542
1333
        self.build_tree(['source/'])
1543
1334
        os.symlink('a/generic/path', 'source/lnk')
1544
1335
        osutils.copy_tree('source', 'target')
1574
1365
            self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1575
1366
 
1576
1367
 
1577
 
class TestSetUnsetEnv(tests.TestCase):
 
1368
#class TestTerminalEncoding has been moved to test_osutils_encodings.py
 
1369
# [bialix] 2006/12/26
 
1370
 
 
1371
 
 
1372
class TestSetUnsetEnv(TestCase):
1578
1373
    """Test updating the environment"""
1579
1374
 
1580
1375
    def setUp(self):
1586
1381
        def cleanup():
1587
1382
            if 'BZR_TEST_ENV_VAR' in os.environ:
1588
1383
                del os.environ['BZR_TEST_ENV_VAR']
 
1384
 
1589
1385
        self.addCleanup(cleanup)
1590
1386
 
1591
1387
    def test_set(self):
1603
1399
 
1604
1400
    def test_unicode(self):
1605
1401
        """Environment can only contain plain strings
1606
 
 
 
1402
        
1607
1403
        So Unicode strings must be encoded.
1608
1404
        """
1609
 
        uni_val, env_val = tests.probe_unicode_in_user_encoding()
 
1405
        uni_val, env_val = probe_unicode_in_user_encoding()
1610
1406
        if uni_val is None:
1611
 
            raise tests.TestSkipped(
1612
 
                'Cannot find a unicode character that works in encoding %s'
1613
 
                % (osutils.get_user_encoding(),))
 
1407
            raise TestSkipped('Cannot find a unicode character that works in'
 
1408
                              ' encoding %s' % (bzrlib.user_encoding,))
1614
1409
 
1615
1410
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1616
1411
        self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
1624
1419
        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1625
1420
 
1626
1421
 
1627
 
class TestSizeShaFile(tests.TestCaseInTempDir):
1628
 
 
1629
 
    def test_sha_empty(self):
1630
 
        self.build_tree_contents([('foo', '')])
1631
 
        expected_sha = osutils.sha_string('')
1632
 
        f = open('foo')
1633
 
        self.addCleanup(f.close)
1634
 
        size, sha = osutils.size_sha_file(f)
1635
 
        self.assertEqual(0, size)
1636
 
        self.assertEqual(expected_sha, sha)
1637
 
 
1638
 
    def test_sha_mixed_endings(self):
1639
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
1640
 
        self.build_tree_contents([('foo', text)])
1641
 
        expected_sha = osutils.sha_string(text)
1642
 
        f = open('foo', 'rb')
1643
 
        self.addCleanup(f.close)
1644
 
        size, sha = osutils.size_sha_file(f)
1645
 
        self.assertEqual(38, size)
1646
 
        self.assertEqual(expected_sha, sha)
1647
 
 
1648
 
 
1649
 
class TestShaFileByName(tests.TestCaseInTempDir):
1650
 
 
1651
 
    def test_sha_empty(self):
1652
 
        self.build_tree_contents([('foo', '')])
1653
 
        expected_sha = osutils.sha_string('')
1654
 
        self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1655
 
 
1656
 
    def test_sha_mixed_endings(self):
1657
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
1658
 
        self.build_tree_contents([('foo', text)])
1659
 
        expected_sha = osutils.sha_string(text)
1660
 
        self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1661
 
 
1662
 
 
1663
 
class TestResourceLoading(tests.TestCaseInTempDir):
 
1422
class TestLocalTimeOffset(TestCase):
 
1423
 
 
1424
    def test_local_time_offset(self):
 
1425
        """Test that local_time_offset() returns a sane value."""
 
1426
        offset = osutils.local_time_offset()
 
1427
        self.assertTrue(isinstance(offset, int))
 
1428
        # Test that the offset is no more than a eighteen hours in
 
1429
        # either direction.
 
1430
        # Time zone handling is system specific, so it is difficult to
 
1431
        # do more specific tests, but a value outside of this range is
 
1432
        # probably wrong.
 
1433
        eighteen_hours = 18 * 3600
 
1434
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
1435
 
 
1436
    def test_local_time_offset_with_timestamp(self):
 
1437
        """Test that local_time_offset() works with a timestamp."""
 
1438
        offset = osutils.local_time_offset(1000000000.1234567)
 
1439
        self.assertTrue(isinstance(offset, int))
 
1440
        eighteen_hours = 18 * 3600
 
1441
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
1442
 
 
1443
 
 
1444
class TestShaFileByName(TestCaseInTempDir):
 
1445
 
 
1446
    def test_sha_empty(self):
 
1447
        self.build_tree_contents([('foo', '')])
 
1448
        expected_sha = osutils.sha_string('')
 
1449
        self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
 
1450
 
 
1451
    def test_sha_mixed_endings(self):
 
1452
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
 
1453
        self.build_tree_contents([('foo', text)])
 
1454
        expected_sha = osutils.sha_string(text)
 
1455
        self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
 
1456
 
 
1457
 
 
1458
_debug_text = \
 
1459
r'''# Copyright (C) 2005, 2006 Canonical Ltd
 
1460
#
 
1461
# This program is free software; you can redistribute it and/or modify
 
1462
# it under the terms of the GNU General Public License as published by
 
1463
# the Free Software Foundation; either version 2 of the License, or
 
1464
# (at your option) any later version.
 
1465
#
 
1466
# This program is distributed in the hope that it will be useful,
 
1467
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
1468
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
1469
# GNU General Public License for more details.
 
1470
#
 
1471
# You should have received a copy of the GNU General Public License
 
1472
# along with this program; if not, write to the Free Software
 
1473
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
1474
 
 
1475
 
 
1476
# NOTE: If update these, please also update the help for global-options in
 
1477
#       bzrlib/help_topics/__init__.py
 
1478
 
 
1479
debug_flags = set()
 
1480
"""Set of flags that enable different debug behaviour.
 
1481
 
 
1482
These are set with eg ``-Dlock`` on the bzr command line.
 
1483
 
 
1484
Options include:
 
1485
 
 
1486
 * auth - show authentication sections used
 
1487
 * error - show stack traces for all top level exceptions
 
1488
 * evil - capture call sites that do expensive or badly-scaling operations.
 
1489
 * fetch - trace history copying between repositories
 
1490
 * graph - trace graph traversal information
 
1491
 * hashcache - log every time a working file is read to determine its hash
 
1492
 * hooks - trace hook execution
 
1493
 * hpss - trace smart protocol requests and responses
 
1494
 * http - trace http connections, requests and responses
 
1495
 * index - trace major index operations
 
1496
 * knit - trace knit operations
 
1497
 * lock - trace when lockdir locks are taken or released
 
1498
 * merge - emit information for debugging merges
 
1499
 * pack - emit information about pack operations
 
1500
 
 
1501
"""
 
1502
'''
 
1503
 
 
1504
 
 
1505
class TestResourceLoading(TestCaseInTempDir):
1664
1506
 
1665
1507
    def test_resource_string(self):
1666
1508
        # test resource in bzrlib
1667
1509
        text = osutils.resource_string('bzrlib', 'debug.py')
1668
 
        self.assertContainsRe(text, "debug_flags = set()")
 
1510
        self.assertEquals(_debug_text, text)
1669
1511
        # test resource under bzrlib
1670
1512
        text = osutils.resource_string('bzrlib.ui', 'text.py')
1671
1513
        self.assertContainsRe(text, "class TextUIFactory")
1674
1516
            'yyy.xx')
1675
1517
        # test unknown resource
1676
1518
        self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1677
 
 
1678
 
 
1679
 
class TestReCompile(tests.TestCase):
1680
 
 
1681
 
    def test_re_compile_checked(self):
1682
 
        r = osutils.re_compile_checked(r'A*', re.IGNORECASE)
1683
 
        self.assertTrue(r.match('aaaa'))
1684
 
        self.assertTrue(r.match('aAaA'))
1685
 
 
1686
 
    def test_re_compile_checked_error(self):
1687
 
        # like https://bugs.launchpad.net/bzr/+bug/251352
1688
 
        err = self.assertRaises(
1689
 
            errors.BzrCommandError,
1690
 
            osutils.re_compile_checked, '*', re.IGNORECASE, 'test case')
1691
 
        self.assertEqual(
1692
 
            "Invalid regular expression in test case: '*': "
1693
 
            "nothing to repeat",
1694
 
            str(err))
1695
 
 
1696
 
 
1697
 
class TestDirReader(tests.TestCaseInTempDir):
1698
 
 
1699
 
    # Set by load_tests
1700
 
    _dir_reader_class = None
1701
 
    _native_to_unicode = None
1702
 
 
1703
 
    def setUp(self):
1704
 
        tests.TestCaseInTempDir.setUp(self)
1705
 
        self.overrideAttr(osutils,
1706
 
                          '_selected_dir_reader', self._dir_reader_class())
1707
 
 
1708
 
    def _get_ascii_tree(self):
1709
 
        tree = [
1710
 
            '0file',
1711
 
            '1dir/',
1712
 
            '1dir/0file',
1713
 
            '1dir/1dir/',
1714
 
            '2file'
1715
 
            ]
1716
 
        expected_dirblocks = [
1717
 
                (('', '.'),
1718
 
                 [('0file', '0file', 'file'),
1719
 
                  ('1dir', '1dir', 'directory'),
1720
 
                  ('2file', '2file', 'file'),
1721
 
                 ]
1722
 
                ),
1723
 
                (('1dir', './1dir'),
1724
 
                 [('1dir/0file', '0file', 'file'),
1725
 
                  ('1dir/1dir', '1dir', 'directory'),
1726
 
                 ]
1727
 
                ),
1728
 
                (('1dir/1dir', './1dir/1dir'),
1729
 
                 [
1730
 
                 ]
1731
 
                ),
1732
 
            ]
1733
 
        return tree, expected_dirblocks
1734
 
 
1735
 
    def test_walk_cur_dir(self):
1736
 
        tree, expected_dirblocks = self._get_ascii_tree()
1737
 
        self.build_tree(tree)
1738
 
        result = list(osutils._walkdirs_utf8('.'))
1739
 
        # Filter out stat and abspath
1740
 
        self.assertEqual(expected_dirblocks,
1741
 
                         [(dirinfo, [line[0:3] for line in block])
1742
 
                          for dirinfo, block in result])
1743
 
 
1744
 
    def test_walk_sub_dir(self):
1745
 
        tree, expected_dirblocks = self._get_ascii_tree()
1746
 
        self.build_tree(tree)
1747
 
        # you can search a subdir only, with a supplied prefix.
1748
 
        result = list(osutils._walkdirs_utf8('./1dir', '1dir'))
1749
 
        # Filter out stat and abspath
1750
 
        self.assertEqual(expected_dirblocks[1:],
1751
 
                         [(dirinfo, [line[0:3] for line in block])
1752
 
                          for dirinfo, block in result])
1753
 
 
1754
 
    def _get_unicode_tree(self):
1755
 
        name0u = u'0file-\xb6'
1756
 
        name1u = u'1dir-\u062c\u0648'
1757
 
        name2u = u'2file-\u0633'
1758
 
        tree = [
1759
 
            name0u,
1760
 
            name1u + '/',
1761
 
            name1u + '/' + name0u,
1762
 
            name1u + '/' + name1u + '/',
1763
 
            name2u,
1764
 
            ]
1765
 
        name0 = name0u.encode('UTF-8')
1766
 
        name1 = name1u.encode('UTF-8')
1767
 
        name2 = name2u.encode('UTF-8')
1768
 
        expected_dirblocks = [
1769
 
                (('', '.'),
1770
 
                 [(name0, name0, 'file', './' + name0u),
1771
 
                  (name1, name1, 'directory', './' + name1u),
1772
 
                  (name2, name2, 'file', './' + name2u),
1773
 
                 ]
1774
 
                ),
1775
 
                ((name1, './' + name1u),
1776
 
                 [(name1 + '/' + name0, name0, 'file', './' + name1u
1777
 
                                                        + '/' + name0u),
1778
 
                  (name1 + '/' + name1, name1, 'directory', './' + name1u
1779
 
                                                            + '/' + name1u),
1780
 
                 ]
1781
 
                ),
1782
 
                ((name1 + '/' + name1, './' + name1u + '/' + name1u),
1783
 
                 [
1784
 
                 ]
1785
 
                ),
1786
 
            ]
1787
 
        return tree, expected_dirblocks
1788
 
 
1789
 
    def _filter_out(self, raw_dirblocks):
1790
 
        """Filter out a walkdirs_utf8 result.
1791
 
 
1792
 
        stat field is removed, all native paths are converted to unicode
1793
 
        """
1794
 
        filtered_dirblocks = []
1795
 
        for dirinfo, block in raw_dirblocks:
1796
 
            dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1797
 
            details = []
1798
 
            for line in block:
1799
 
                details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
1800
 
            filtered_dirblocks.append((dirinfo, details))
1801
 
        return filtered_dirblocks
1802
 
 
1803
 
    def test_walk_unicode_tree(self):
1804
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1805
 
        tree, expected_dirblocks = self._get_unicode_tree()
1806
 
        self.build_tree(tree)
1807
 
        result = list(osutils._walkdirs_utf8('.'))
1808
 
        self.assertEqual(expected_dirblocks, self._filter_out(result))
1809
 
 
1810
 
    def test_symlink(self):
1811
 
        self.requireFeature(tests.SymlinkFeature)
1812
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1813
 
        target = u'target\N{Euro Sign}'
1814
 
        link_name = u'l\N{Euro Sign}nk'
1815
 
        os.symlink(target, link_name)
1816
 
        target_utf8 = target.encode('UTF-8')
1817
 
        link_name_utf8 = link_name.encode('UTF-8')
1818
 
        expected_dirblocks = [
1819
 
                (('', '.'),
1820
 
                 [(link_name_utf8, link_name_utf8,
1821
 
                   'symlink', './' + link_name),],
1822
 
                 )]
1823
 
        result = list(osutils._walkdirs_utf8('.'))
1824
 
        self.assertEqual(expected_dirblocks, self._filter_out(result))
1825
 
 
1826
 
 
1827
 
class TestReadLink(tests.TestCaseInTempDir):
1828
 
    """Exposes os.readlink() problems and the osutils solution.
1829
 
 
1830
 
    The only guarantee offered by os.readlink(), starting with 2.6, is that a
1831
 
    unicode string will be returned if a unicode string is passed.
1832
 
 
1833
 
    But prior python versions failed to properly encode the passed unicode
1834
 
    string.
1835
 
    """
1836
 
    _test_needs_features = [tests.SymlinkFeature, tests.UnicodeFilenameFeature]
1837
 
 
1838
 
    def setUp(self):
1839
 
        super(tests.TestCaseInTempDir, self).setUp()
1840
 
        self.link = u'l\N{Euro Sign}ink'
1841
 
        self.target = u'targe\N{Euro Sign}t'
1842
 
        os.symlink(self.target, self.link)
1843
 
 
1844
 
    def test_os_readlink_link_encoding(self):
1845
 
        if sys.version_info < (2, 6):
1846
 
            self.assertRaises(UnicodeEncodeError, os.readlink, self.link)
1847
 
        else:
1848
 
            self.assertEquals(self.target,  os.readlink(self.link))
1849
 
 
1850
 
    def test_os_readlink_link_decoding(self):
1851
 
        self.assertEquals(self.target.encode(osutils._fs_enc),
1852
 
                          os.readlink(self.link.encode(osutils._fs_enc)))
1853
 
 
1854
 
 
1855
 
class TestConcurrency(tests.TestCase):
1856
 
 
1857
 
    def setUp(self):
1858
 
        super(TestConcurrency, self).setUp()
1859
 
        self.overrideAttr(osutils, '_cached_local_concurrency')
1860
 
 
1861
 
    def test_local_concurrency(self):
1862
 
        concurrency = osutils.local_concurrency()
1863
 
        self.assertIsInstance(concurrency, int)
1864
 
 
1865
 
    def test_local_concurrency_environment_variable(self):
1866
 
        os.environ['BZR_CONCURRENCY'] = '2'
1867
 
        self.assertEqual(2, osutils.local_concurrency(use_cache=False))
1868
 
        os.environ['BZR_CONCURRENCY'] = '3'
1869
 
        self.assertEqual(3, osutils.local_concurrency(use_cache=False))
1870
 
        os.environ['BZR_CONCURRENCY'] = 'foo'
1871
 
        self.assertEqual(1, osutils.local_concurrency(use_cache=False))
1872
 
 
1873
 
    def test_option_concurrency(self):
1874
 
        os.environ['BZR_CONCURRENCY'] = '1'
1875
 
        self.run_bzr('rocks --concurrency 42')
1876
 
        # Command line overrides envrionment variable
1877
 
        self.assertEquals('42', os.environ['BZR_CONCURRENCY'])
1878
 
        self.assertEquals(42, osutils.local_concurrency(use_cache=False))
1879
 
 
1880
 
 
1881
 
class TestFailedToLoadExtension(tests.TestCase):
1882
 
 
1883
 
    def _try_loading(self):
1884
 
        try:
1885
 
            import bzrlib._fictional_extension_py
1886
 
        except ImportError, e:
1887
 
            osutils.failed_to_load_extension(e)
1888
 
            return True
1889
 
 
1890
 
    def setUp(self):
1891
 
        super(TestFailedToLoadExtension, self).setUp()
1892
 
        self.overrideAttr(osutils, '_extension_load_failures', [])
1893
 
 
1894
 
    def test_failure_to_load(self):
1895
 
        self._try_loading()
1896
 
        self.assertLength(1, osutils._extension_load_failures)
1897
 
        self.assertEquals(osutils._extension_load_failures[0],
1898
 
            "No module named _fictional_extension_py")
1899
 
 
1900
 
    def test_report_extension_load_failures_no_warning(self):
1901
 
        self.assertTrue(self._try_loading())
1902
 
        warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
1903
 
        # it used to give a Python warning; it no longer does
1904
 
        self.assertLength(0, warnings)
1905
 
 
1906
 
    def test_report_extension_load_failures_message(self):
1907
 
        log = StringIO()
1908
 
        trace.push_log_file(log)
1909
 
        self.assertTrue(self._try_loading())
1910
 
        osutils.report_extension_load_failures()
1911
 
        self.assertContainsRe(
1912
 
            log.getvalue(),
1913
 
            r"bzr: warning: some compiled extensions could not be loaded; "
1914
 
            "see <https://answers\.launchpad\.net/bzr/\+faq/703>\n"
1915
 
            )
1916
 
 
1917
 
 
1918
 
class TestTerminalWidth(tests.TestCase):
1919
 
 
1920
 
    def replace_stdout(self, new):
1921
 
        self.overrideAttr(sys, 'stdout', new)
1922
 
 
1923
 
    def replace__terminal_size(self, new):
1924
 
        self.overrideAttr(osutils, '_terminal_size', new)
1925
 
 
1926
 
    def set_fake_tty(self):
1927
 
 
1928
 
        class I_am_a_tty(object):
1929
 
            def isatty(self):
1930
 
                return True
1931
 
 
1932
 
        self.replace_stdout(I_am_a_tty())
1933
 
 
1934
 
    def test_default_values(self):
1935
 
        self.assertEqual(80, osutils.default_terminal_width)
1936
 
 
1937
 
    def test_defaults_to_BZR_COLUMNS(self):
1938
 
        # BZR_COLUMNS is set by the test framework
1939
 
        self.assertNotEqual('12', os.environ['BZR_COLUMNS'])
1940
 
        os.environ['BZR_COLUMNS'] = '12'
1941
 
        self.assertEqual(12, osutils.terminal_width())
1942
 
 
1943
 
    def test_falls_back_to_COLUMNS(self):
1944
 
        del os.environ['BZR_COLUMNS']
1945
 
        self.assertNotEqual('42', os.environ['COLUMNS'])
1946
 
        self.set_fake_tty()
1947
 
        os.environ['COLUMNS'] = '42'
1948
 
        self.assertEqual(42, osutils.terminal_width())
1949
 
 
1950
 
    def test_tty_default_without_columns(self):
1951
 
        del os.environ['BZR_COLUMNS']
1952
 
        del os.environ['COLUMNS']
1953
 
 
1954
 
        def terminal_size(w, h):
1955
 
            return 42, 42
1956
 
 
1957
 
        self.set_fake_tty()
1958
 
        # We need to override the osutils definition as it depends on the
1959
 
        # running environment that we can't control (PQM running without a
1960
 
        # controlling terminal is one example).
1961
 
        self.replace__terminal_size(terminal_size)
1962
 
        self.assertEqual(42, osutils.terminal_width())
1963
 
 
1964
 
    def test_non_tty_default_without_columns(self):
1965
 
        del os.environ['BZR_COLUMNS']
1966
 
        del os.environ['COLUMNS']
1967
 
        self.replace_stdout(None)
1968
 
        self.assertEqual(None, osutils.terminal_width())
1969
 
 
1970
 
    def test_no_TIOCGWINSZ(self):
1971
 
        self.requireFeature(term_ios_feature)
1972
 
        termios = term_ios_feature.module
1973
 
        # bug 63539 is about a termios without TIOCGWINSZ attribute
1974
 
        try:
1975
 
            orig = termios.TIOCGWINSZ
1976
 
        except AttributeError:
1977
 
            # We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
1978
 
            pass
1979
 
        else:
1980
 
            self.overrideAttr(termios, 'TIOCGWINSZ')
1981
 
            del termios.TIOCGWINSZ
1982
 
        del os.environ['BZR_COLUMNS']
1983
 
        del os.environ['COLUMNS']
1984
 
        # Whatever the result is, if we don't raise an exception, it's ok.
1985
 
        osutils.terminal_width()
1986
 
 
1987
 
class TestCreationOps(tests.TestCaseInTempDir):
1988
 
    _test_needs_features = [features.chown_feature]
1989
 
 
1990
 
    def setUp(self):
1991
 
        tests.TestCaseInTempDir.setUp(self)
1992
 
        self.overrideAttr(os, 'chown', self._dummy_chown)
1993
 
 
1994
 
        # params set by call to _dummy_chown
1995
 
        self.path = self.uid = self.gid = None
1996
 
 
1997
 
    def _dummy_chown(self, path, uid, gid):
1998
 
        self.path, self.uid, self.gid = path, uid, gid
1999
 
 
2000
 
    def test_copy_ownership_from_path(self):
2001
 
        """copy_ownership_from_path test with specified src."""
2002
 
        ownsrc = '/'
2003
 
        f = open('test_file', 'wt')
2004
 
        osutils.copy_ownership_from_path('test_file', ownsrc)
2005
 
 
2006
 
        s = os.stat(ownsrc)
2007
 
        self.assertEquals(self.path, 'test_file')
2008
 
        self.assertEquals(self.uid, s.st_uid)
2009
 
        self.assertEquals(self.gid, s.st_gid)
2010
 
 
2011
 
    def test_copy_ownership_nonesrc(self):
2012
 
        """copy_ownership_from_path test with src=None."""
2013
 
        f = open('test_file', 'wt')
2014
 
        # should use parent dir for permissions
2015
 
        osutils.copy_ownership_from_path('test_file')
2016
 
 
2017
 
        s = os.stat('..')
2018
 
        self.assertEquals(self.path, 'test_file')
2019
 
        self.assertEquals(self.uid, s.st_uid)
2020
 
        self.assertEquals(self.gid, s.st_gid)