/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils.py

  • Committer: Andrew Bennetts
  • Date: 2010-01-12 03:53:21 UTC
  • mfrom: (4948 +trunk)
  • mto: This revision was merged to the branch mainline in revision 4964.
  • Revision ID: andrew.bennetts@canonical.com-20100112035321-hofpz5p10224ryj3
Merge lp:bzr, resolving conflicts.

Show diffs side-by-side

added added

removed removed

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