← 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-08-02 17:16:12 UTC
  • mto: This revision was merged to the branch mainline in revision 5369.
  • Revision ID: john@arbash-meinel.com-20100802171612-rdh5ods70w2bl3j7
We also have to re-implement it for _simple_set_pyx.pyx

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