← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-04-08 12:39:40 UTC
  • mfrom: (4266.2.1 tests.output)
  • Revision ID: pqm@pqm.ubuntu.com-20090408123940-kaho6cwr21163fjn
(robertc) Remove clutter from bzr selftest --list. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
27
27
 
28
28
from bzrlib import (
29
29
    errors,
30
 
    lazy_regex,
31
30
    osutils,
32
 
    symbol_versioning,
33
31
    tests,
34
 
    trace,
35
32
    win32utils,
36
33
    )
 
34
from bzrlib.errors import BzrBadParameterNotUnicode, InvalidURL
 
35
from bzrlib.osutils import (
 
36
        canonical_relpath,
 
37
        )
37
38
from bzrlib.tests import (
38
 
    features,
39
 
    file_utils,
40
 
    test__walkdirs_win32,
 
39
        Feature,
 
40
        probe_unicode_in_user_encoding,
 
41
        StringIOWrapper,
 
42
        SymlinkFeature,
 
43
        CaseInsCasePresFilenameFeature,
 
44
        TestCase,
 
45
        TestCaseInTempDir,
 
46
        TestSkipped,
 
47
        )
 
48
from bzrlib.tests.file_utils import (
 
49
    FakeReadFile,
41
50
    )
42
 
 
43
 
 
44
 
class _UTF8DirReaderFeature(tests.Feature):
 
51
from bzrlib.tests.test__walkdirs_win32 import Win32ReadDirFeature
 
52
 
 
53
 
 
54
class _UTF8DirReaderFeature(Feature):
45
55
 
46
56
    def _probe(self):
47
57
        try:
56
66
 
57
67
UTF8DirReaderFeature = _UTF8DirReaderFeature()
58
68
 
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):
 
69
 
 
70
class TestOSUtils(TestCaseInTempDir):
110
71
 
111
72
    def test_contains_whitespace(self):
112
73
        self.failUnless(osutils.contains_whitespace(u' '))
122
83
        self.failIf(osutils.contains_whitespace(u'hellothere'))
123
84
        self.failIf(osutils.contains_whitespace(u'hello\xa0there'))
124
85
 
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
 
 
139
86
    def test_fancy_rename(self):
140
87
        # This should work everywhere
141
 
        self.create_file('a', 'something in a\n')
142
 
        self._fancy_rename('a', 'b')
 
88
        def rename(a, b):
 
89
            osutils.fancy_rename(a, b,
 
90
                    rename_func=os.rename,
 
91
                    unlink_func=os.unlink)
 
92
 
 
93
        open('a', 'wb').write('something in a\n')
 
94
        rename('a', 'b')
143
95
        self.failIfExists('a')
144
96
        self.failUnlessExists('b')
145
97
        self.check_file_contents('b', 'something in a\n')
146
98
 
147
 
        self.create_file('a', 'new something in a\n')
148
 
        self._fancy_rename('b', 'a')
 
99
        open('a', 'wb').write('new something in a\n')
 
100
        rename('b', 'a')
149
101
 
150
102
        self.check_file_contents('a', 'something in a\n')
151
103
 
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
 
 
164
104
    def test_rename(self):
165
105
        # Rename should be semi-atomic on all platforms
166
 
        self.create_file('a', 'something in a\n')
 
106
        open('a', 'wb').write('something in a\n')
167
107
        osutils.rename('a', 'b')
168
108
        self.failIfExists('a')
169
109
        self.failUnlessExists('b')
170
110
        self.check_file_contents('b', 'something in a\n')
171
111
 
172
 
        self.create_file('a', 'new something in a\n')
 
112
        open('a', 'wb').write('new something in a\n')
173
113
        osutils.rename('b', 'a')
174
114
 
175
115
        self.check_file_contents('a', 'something in a\n')
186
126
        shape = sorted(os.listdir('.'))
187
127
        self.assertEquals(['A', 'B'], shape)
188
128
 
189
 
 
190
 
class TestRandChars(tests.TestCase):
191
 
 
192
129
    def test_01_rand_chars_empty(self):
193
130
        result = osutils.rand_chars(0)
194
131
        self.assertEqual(result, '')
199
136
        self.assertEqual(type(result), str)
200
137
        self.assertContainsRe(result, r'^[a-z0-9]{100}$')
201
138
 
202
 
 
203
 
class TestIsInside(tests.TestCase):
204
 
 
205
139
    def test_is_inside(self):
206
140
        is_inside = osutils.is_inside
207
141
        self.assertTrue(is_inside('src', 'src/foo.c'))
236
170
                         (['src'], 'srccontrol/foo')]:
237
171
            self.assertFalse(osutils.is_inside_or_parent_of_any(dirs, fn))
238
172
 
239
 
 
240
 
class TestRmTree(tests.TestCaseInTempDir):
241
 
 
242
173
    def test_rmtree(self):
243
174
        # Check to remove tree with read-only files/dirs
244
175
        os.mkdir('dir')
257
188
        self.failIfExists('dir/file')
258
189
        self.failIfExists('dir')
259
190
 
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
 
 
275
191
    def test_file_kind(self):
276
192
        self.build_tree(['file', 'dir/'])
277
193
        self.assertEquals('file', osutils.file_kind('file'))
307
223
                os.remove('socket')
308
224
 
309
225
    def test_kind_marker(self):
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):
 
226
        self.assertEqual(osutils.kind_marker('file'), '')
 
227
        self.assertEqual(osutils.kind_marker('directory'), '/')
 
228
        self.assertEqual(osutils.kind_marker('symlink'), '@')
 
229
        self.assertEqual(osutils.kind_marker('tree-reference'), '+')
321
230
 
322
231
    def test_get_umask(self):
323
232
        if sys.platform == 'win32':
326
235
            return
327
236
 
328
237
        orig_umask = osutils.get_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):
 
238
        try:
 
239
            os.umask(0222)
 
240
            self.assertEqual(0222, osutils.get_umask())
 
241
            os.umask(0022)
 
242
            self.assertEqual(0022, osutils.get_umask())
 
243
            os.umask(0002)
 
244
            self.assertEqual(0002, osutils.get_umask())
 
245
            os.umask(0027)
 
246
            self.assertEqual(0027, osutils.get_umask())
 
247
        finally:
 
248
            os.umask(orig_umask)
341
249
 
342
250
    def assertFormatedDelta(self, expected, seconds):
343
251
        """Assert osutils.format_delta formats as expected"""
385
293
        # Instead blackbox.test_locale should check for localized
386
294
        # dates once they do occur in output strings.
387
295
 
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
 
 
418
296
    def test_dereference_path(self):
419
 
        self.requireFeature(tests.SymlinkFeature)
 
297
        self.requireFeature(SymlinkFeature)
420
298
        cwd = osutils.realpath('.')
421
299
        os.mkdir('bar')
422
300
        bar_path = osutils.pathjoin(cwd, 'bar')
463
341
            osutils.make_readonly('dangling')
464
342
            osutils.make_writable('dangling')
465
343
 
 
344
    def test_kind_marker(self):
 
345
        self.assertEqual("", osutils.kind_marker("file"))
 
346
        self.assertEqual("/", osutils.kind_marker(osutils._directory_kind))
 
347
        self.assertEqual("@", osutils.kind_marker("symlink"))
 
348
        self.assertRaises(errors.BzrError, osutils.kind_marker, "unknown")
 
349
 
466
350
    def test_host_os_dereferences_symlinks(self):
467
351
        osutils.host_os_dereferences_symlinks()
468
352
 
469
353
 
470
 
class TestCanonicalRelPath(tests.TestCaseInTempDir):
 
354
class TestCanonicalRelPath(TestCaseInTempDir):
471
355
 
472
 
    _test_needs_features = [tests.CaseInsCasePresFilenameFeature]
 
356
    _test_needs_features = [CaseInsCasePresFilenameFeature]
473
357
 
474
358
    def test_canonical_relpath_simple(self):
475
359
        f = file('MixedCaseName', 'w')
476
360
        f.close()
477
 
        actual = osutils.canonical_relpath(self.test_base_dir, 'mixedcasename')
 
361
        # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
362
        real_base_dir = osutils.realpath(self.test_base_dir)
 
363
        actual = osutils.canonical_relpath(real_base_dir, 'mixedcasename')
478
364
        self.failUnlessEqual('work/MixedCaseName', actual)
479
365
 
480
366
    def test_canonical_relpath_missing_tail(self):
481
367
        os.mkdir('MixedCaseParent')
482
 
        actual = osutils.canonical_relpath(self.test_base_dir,
 
368
        # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
369
        real_base_dir = osutils.realpath(self.test_base_dir)
 
370
        actual = osutils.canonical_relpath(real_base_dir,
483
371
                                           'mixedcaseparent/nochild')
484
372
        self.failUnlessEqual('work/MixedCaseParent/nochild', actual)
485
373
 
486
374
 
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):
 
375
class TestPumpFile(TestCase):
531
376
    """Test pumpfile method."""
532
 
 
533
377
    def setUp(self):
534
 
        tests.TestCase.setUp(self)
 
378
        TestCase.setUp(self)
535
379
        # create a test datablock
536
380
        self.block_size = 512
537
381
        pattern = '0123456789ABCDEF'
544
388
        # make sure test data is larger than max read size
545
389
        self.assertTrue(self.test_data_len > self.block_size)
546
390
 
547
 
        from_file = file_utils.FakeReadFile(self.test_data)
 
391
        from_file = FakeReadFile(self.test_data)
548
392
        to_file = StringIO()
549
393
 
550
394
        # read (max / 2) bytes and verify read size wasn't affected
585
429
        self.assertTrue(self.test_data_len > self.block_size)
586
430
 
587
431
        # retrieve data in blocks
588
 
        from_file = file_utils.FakeReadFile(self.test_data)
 
432
        from_file = FakeReadFile(self.test_data)
589
433
        to_file = StringIO()
590
434
        osutils.pumpfile(from_file, to_file, self.test_data_len,
591
435
                         self.block_size)
609
453
        self.assertTrue(self.test_data_len > self.block_size)
610
454
 
611
455
        # retrieve data to EOF
612
 
        from_file = file_utils.FakeReadFile(self.test_data)
 
456
        from_file = FakeReadFile(self.test_data)
613
457
        to_file = StringIO()
614
458
        osutils.pumpfile(from_file, to_file, -1, self.block_size)
615
459
 
629
473
        test verifies that any existing usages of pumpfile will not be broken
630
474
        with this new version."""
631
475
        # retrieve data using default (old) pumpfile method
632
 
        from_file = file_utils.FakeReadFile(self.test_data)
 
476
        from_file = FakeReadFile(self.test_data)
633
477
        to_file = StringIO()
634
478
        osutils.pumpfile(from_file, to_file)
635
479
 
669
513
 
670
514
 
671
515
 
672
 
class TestPumpStringFile(tests.TestCase):
 
516
class TestPumpStringFile(TestCase):
673
517
 
674
518
    def test_empty(self):
675
519
        output = StringIO()
692
536
        self.assertEqual("1234", output.getvalue())
693
537
 
694
538
 
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):
 
539
class TestSafeUnicode(TestCase):
715
540
 
716
541
    def test_from_ascii_string(self):
717
542
        self.assertEqual(u'foobar', osutils.safe_unicode('foobar'))
726
551
        self.assertEqual(u'foo\xae', osutils.safe_unicode('foo\xc2\xae'))
727
552
 
728
553
    def test_bad_utf8_string(self):
729
 
        self.assertRaises(errors.BzrBadParameterNotUnicode,
 
554
        self.assertRaises(BzrBadParameterNotUnicode,
730
555
                          osutils.safe_unicode,
731
556
                          '\xbb\xbb')
732
557
 
733
558
 
734
 
class TestSafeUtf8(tests.TestCase):
 
559
class TestSafeUtf8(TestCase):
735
560
 
736
561
    def test_from_ascii_string(self):
737
562
        f = 'foobar'
747
572
        self.assertEqual('foo\xc2\xae', osutils.safe_utf8('foo\xc2\xae'))
748
573
 
749
574
    def test_bad_utf8_string(self):
750
 
        self.assertRaises(errors.BzrBadParameterNotUnicode,
 
575
        self.assertRaises(BzrBadParameterNotUnicode,
751
576
                          osutils.safe_utf8, '\xbb\xbb')
752
577
 
753
578
 
754
 
class TestSafeRevisionId(tests.TestCase):
 
579
class TestSafeRevisionId(TestCase):
755
580
 
756
581
    def test_from_ascii_string(self):
757
582
        # this shouldn't give a warning because it's getting an ascii string
779
604
        self.assertEqual(None, osutils.safe_revision_id(None))
780
605
 
781
606
 
782
 
class TestSafeFileId(tests.TestCase):
 
607
class TestSafeFileId(TestCase):
783
608
 
784
609
    def test_from_ascii_string(self):
785
610
        self.assertEqual('foobar', osutils.safe_file_id('foobar'))
805
630
        self.assertEqual(None, osutils.safe_file_id(None))
806
631
 
807
632
 
808
 
class TestWin32Funcs(tests.TestCase):
809
 
    """Test that _win32 versions of os utilities return appropriate paths."""
 
633
class TestWin32Funcs(TestCase):
 
634
    """Test that the _win32 versions of os utilities return appropriate paths."""
810
635
 
811
636
    def test_abspath(self):
812
637
        self.assertEqual('C:/foo', osutils._win32_abspath('C:\\foo'))
819
644
        self.assertEqual('C:/foo', osutils._win32_realpath('C:/foo'))
820
645
 
821
646
    def test_pathjoin(self):
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'))
 
647
        self.assertEqual('path/to/foo', osutils._win32_pathjoin('path', 'to', 'foo'))
 
648
        self.assertEqual('C:/foo', osutils._win32_pathjoin('path\\to', 'C:\\foo'))
 
649
        self.assertEqual('C:/foo', osutils._win32_pathjoin('path/to', 'C:/foo'))
 
650
        self.assertEqual('path/to/foo', osutils._win32_pathjoin('path/to/', 'foo'))
 
651
        self.assertEqual('/foo', osutils._win32_pathjoin('C:/path/to/', '/foo'))
 
652
        self.assertEqual('/foo', osutils._win32_pathjoin('C:\\path\\to\\', '\\foo'))
834
653
 
835
654
    def test_normpath(self):
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'))
 
655
        self.assertEqual('path/to/foo', osutils._win32_normpath(r'path\\from\..\to\.\foo'))
 
656
        self.assertEqual('path/to/foo', osutils._win32_normpath('path//from/../to/./foo'))
840
657
 
841
658
    def test_getcwd(self):
842
659
        cwd = osutils._win32_getcwd()
863
680
        self.assertEqual('//HOST/path', osutils._win98_abspath('//HOST/path'))
864
681
        # relative path
865
682
        cwd = osutils.getcwd().rstrip('/')
866
 
        drive = osutils.ntpath.splitdrive(cwd)[0]
 
683
        drive = osutils._nt_splitdrive(cwd)[0]
867
684
        self.assertEqual(cwd+'/path', osutils._win98_abspath('path'))
868
685
        self.assertEqual(drive+'/path', osutils._win98_abspath('/path'))
869
686
        # unicode path
871
688
        self.assertEqual(cwd+'/'+u, osutils._win98_abspath(u))
872
689
 
873
690
 
874
 
class TestWin32FuncsDirs(tests.TestCaseInTempDir):
 
691
class TestWin32FuncsDirs(TestCaseInTempDir):
875
692
    """Test win32 functions that create files."""
876
693
 
877
694
    def test_getcwd(self):
878
 
        self.requireFeature(tests.UnicodeFilenameFeature)
879
 
        os.mkdir(u'mu-\xb5')
 
695
        if win32utils.winver == 'Windows 98':
 
696
            raise TestSkipped('Windows 98 cannot handle unicode filenames')
 
697
        # Make sure getcwd can handle unicode filenames
 
698
        try:
 
699
            os.mkdir(u'mu-\xb5')
 
700
        except UnicodeError:
 
701
            raise TestSkipped("Unable to create Unicode filename")
 
702
 
880
703
        os.chdir(u'mu-\xb5')
881
704
        # TODO: jam 20060427 This will probably fail on Mac OSX because
882
705
        #       it will change the normalization of B\xe5gfors
887
710
    def test_minimum_path_selection(self):
888
711
        self.assertEqual(set(),
889
712
            osutils.minimum_path_selection([]))
890
 
        self.assertEqual(set(['a']),
891
 
            osutils.minimum_path_selection(['a']))
892
713
        self.assertEqual(set(['a', 'b']),
893
714
            osutils.minimum_path_selection(['a', 'b']))
894
715
        self.assertEqual(set(['a/', 'b']),
895
716
            osutils.minimum_path_selection(['a/', 'b']))
896
717
        self.assertEqual(set(['a/', 'b']),
897
718
            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
719
 
901
720
    def test_mkdtemp(self):
902
721
        tmpdir = osutils._win32_mkdtemp(dir='.')
958
777
        self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
959
778
 
960
779
 
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):
 
780
class TestMacFuncsDirs(TestCaseInTempDir):
971
781
    """Test mac special functions that require directories."""
972
782
 
973
783
    def test_getcwd(self):
974
 
        self.requireFeature(tests.UnicodeFilenameFeature)
975
 
        os.mkdir(u'B\xe5gfors')
 
784
        # On Mac, this will actually create Ba\u030agfors
 
785
        # but chdir will still work, because it accepts both paths
 
786
        try:
 
787
            os.mkdir(u'B\xe5gfors')
 
788
        except UnicodeError:
 
789
            raise TestSkipped("Unable to create Unicode filename")
 
790
 
976
791
        os.chdir(u'B\xe5gfors')
977
792
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
978
793
 
979
794
    def test_getcwd_nonnorm(self):
980
 
        self.requireFeature(tests.UnicodeFilenameFeature)
981
795
        # Test that _mac_getcwd() will normalize this path
982
 
        os.mkdir(u'Ba\u030agfors')
 
796
        try:
 
797
            os.mkdir(u'Ba\u030agfors')
 
798
        except UnicodeError:
 
799
            raise TestSkipped("Unable to create Unicode filename")
 
800
 
983
801
        os.chdir(u'Ba\u030agfors')
984
802
        self.assertEndsWith(osutils._mac_getcwd(), u'B\xe5gfors')
985
803
 
986
804
 
987
 
class TestChunksToLines(tests.TestCase):
 
805
class TestChunksToLines(TestCase):
988
806
 
989
807
    def test_smoketest(self):
990
808
        self.assertEqual(['foo\n', 'bar\n', 'baz\n'],
994
812
 
995
813
    def test_osutils_binding(self):
996
814
        from bzrlib.tests import test__chunks_to_lines
997
 
        if test__chunks_to_lines.compiled_chunkstolines_feature.available():
 
815
        if test__chunks_to_lines.CompiledChunksToLinesFeature.available():
998
816
            from bzrlib._chunks_to_lines_pyx import chunks_to_lines
999
817
        else:
1000
818
            from bzrlib._chunks_to_lines_py import chunks_to_lines
1001
819
        self.assertIs(chunks_to_lines, osutils.chunks_to_lines)
1002
820
 
1003
821
 
1004
 
class TestSplitLines(tests.TestCase):
 
822
class TestSplitLines(TestCase):
1005
823
 
1006
824
    def test_split_unicode(self):
1007
825
        self.assertEqual([u'foo\n', u'bar\xae'],
1014
832
                         osutils.split_lines('foo\rbar\n'))
1015
833
 
1016
834
 
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])
 
835
class TestWalkDirs(TestCaseInTempDir):
1023
836
 
1024
837
    def test_walkdirs(self):
1025
838
        tree = [
1058
871
            result.append((dirdetail, dirblock))
1059
872
 
1060
873
        self.assertTrue(found_bzrdir)
1061
 
        self.assertExpectedBlocks(expected_dirblocks, result)
 
874
        self.assertEqual(expected_dirblocks,
 
875
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1062
876
        # you can search a subdir only, with a supplied prefix.
1063
877
        result = []
1064
878
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
1065
879
            result.append(dirblock)
1066
 
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
 
880
        self.assertEqual(expected_dirblocks[1:],
 
881
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1067
882
 
1068
883
    def test_walkdirs_os_error(self):
1069
 
        # <https://bugs.launchpad.net/bzr/+bug/338653>
 
884
        # <https://bugs.edge.launchpad.net/bzr/+bug/338653>
1070
885
        # Pyrex readdir didn't raise useful messages if it had an error
1071
886
        # reading the directory
1072
887
        if sys.platform == 'win32':
1075
890
        os.mkdir("test-unreadable")
1076
891
        os.chmod("test-unreadable", 0000)
1077
892
        # must chmod it back so that it can be removed
1078
 
        self.addCleanup(os.chmod, "test-unreadable", 0700)
 
893
        self.addCleanup(lambda: os.chmod("test-unreadable", 0700))
1079
894
        # The error is not raised until the generator is actually evaluated.
1080
895
        # (It would be ok if it happened earlier but at the moment it
1081
896
        # doesn't.)
1085
900
        # Ensure the message contains the file name
1086
901
        self.assertContainsRe(str(e), "\./test-unreadable")
1087
902
 
1088
 
 
1089
 
    def test_walkdirs_encoding_error(self):
1090
 
        # <https://bugs.launchpad.net/bzr/+bug/488519>
1091
 
        # walkdirs didn't raise a useful message when the filenames
1092
 
        # are not using the filesystem's encoding
1093
 
 
1094
 
        # require a bytestring based filesystem
1095
 
        self.requireFeature(tests.ByteStringNamedFilesystem)
1096
 
 
1097
 
        tree = [
1098
 
            '.bzr',
1099
 
            '0file',
1100
 
            '1dir/',
1101
 
            '1dir/0file',
1102
 
            '1dir/1dir/',
1103
 
            '1file'
1104
 
            ]
1105
 
 
1106
 
        self.build_tree(tree)
1107
 
 
1108
 
        # rename the 1file to a latin-1 filename
1109
 
        os.rename("./1file", "\xe8file")
1110
 
 
1111
 
        self._save_platform_info()
1112
 
        win32utils.winver = None # Avoid the win32 detection code
1113
 
        osutils._fs_enc = 'UTF-8'
1114
 
 
1115
 
        # this should raise on error
1116
 
        def attempt():
1117
 
            for dirdetail, dirblock in osutils.walkdirs('.'):
1118
 
                pass
1119
 
 
1120
 
        self.assertRaises(errors.BadFilenameEncoding, attempt)
1121
 
 
1122
903
    def test__walkdirs_utf8(self):
1123
904
        tree = [
1124
905
            '.bzr',
1156
937
            result.append((dirdetail, dirblock))
1157
938
 
1158
939
        self.assertTrue(found_bzrdir)
1159
 
        self.assertExpectedBlocks(expected_dirblocks, result)
1160
 
 
 
940
        self.assertEqual(expected_dirblocks,
 
941
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1161
942
        # you can search a subdir only, with a supplied prefix.
1162
943
        result = []
1163
944
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
1164
945
            result.append(dirblock)
1165
 
        self.assertExpectedBlocks(expected_dirblocks[1:], result)
 
946
        self.assertEqual(expected_dirblocks[1:],
 
947
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
1166
948
 
1167
949
    def _filter_out_stat(self, result):
1168
950
        """Filter out the stat value from the walkdirs result"""
1174
956
            dirblock[:] = new_dirblock
1175
957
 
1176
958
    def _save_platform_info(self):
1177
 
        self.overrideAttr(win32utils, 'winver')
1178
 
        self.overrideAttr(osutils, '_fs_enc')
1179
 
        self.overrideAttr(osutils, '_selected_dir_reader')
 
959
        cur_winver = win32utils.winver
 
960
        cur_fs_enc = osutils._fs_enc
 
961
        cur_dir_reader = osutils._selected_dir_reader
 
962
        def restore():
 
963
            win32utils.winver = cur_winver
 
964
            osutils._fs_enc = cur_fs_enc
 
965
            osutils._selected_dir_reader = cur_dir_reader
 
966
        self.addCleanup(restore)
1180
967
 
1181
 
    def assertDirReaderIs(self, expected):
 
968
    def assertReadFSDirIs(self, expected):
1182
969
        """Assert the right implementation for _walkdirs_utf8 is chosen."""
1183
970
        # Force it to redetect
1184
971
        osutils._selected_dir_reader = None
1191
978
        self._save_platform_info()
1192
979
        win32utils.winver = None # Avoid the win32 detection code
1193
980
        osutils._fs_enc = 'UTF-8'
1194
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
981
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
1195
982
 
1196
983
    def test_force_walkdirs_utf8_fs_ascii(self):
1197
984
        self.requireFeature(UTF8DirReaderFeature)
1198
985
        self._save_platform_info()
1199
986
        win32utils.winver = None # Avoid the win32 detection code
1200
987
        osutils._fs_enc = 'US-ASCII'
1201
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
988
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
1202
989
 
1203
990
    def test_force_walkdirs_utf8_fs_ANSI(self):
1204
991
        self.requireFeature(UTF8DirReaderFeature)
1205
992
        self._save_platform_info()
1206
993
        win32utils.winver = None # Avoid the win32 detection code
1207
994
        osutils._fs_enc = 'ANSI_X3.4-1968'
1208
 
        self.assertDirReaderIs(UTF8DirReaderFeature.reader)
 
995
        self.assertReadFSDirIs(UTF8DirReaderFeature.reader)
1209
996
 
1210
997
    def test_force_walkdirs_utf8_fs_latin1(self):
1211
998
        self._save_platform_info()
1212
999
        win32utils.winver = None # Avoid the win32 detection code
1213
1000
        osutils._fs_enc = 'latin1'
1214
 
        self.assertDirReaderIs(osutils.UnicodeDirReader)
 
1001
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
1215
1002
 
1216
1003
    def test_force_walkdirs_utf8_nt(self):
1217
1004
        # Disabled because the thunk of the whole walkdirs api is disabled.
1218
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1005
        self.requireFeature(Win32ReadDirFeature)
1219
1006
        self._save_platform_info()
1220
1007
        win32utils.winver = 'Windows NT'
1221
1008
        from bzrlib._walkdirs_win32 import Win32ReadDir
1222
 
        self.assertDirReaderIs(Win32ReadDir)
 
1009
        self.assertReadFSDirIs(Win32ReadDir)
1223
1010
 
1224
1011
    def test_force_walkdirs_utf8_98(self):
1225
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1012
        self.requireFeature(Win32ReadDirFeature)
1226
1013
        self._save_platform_info()
1227
1014
        win32utils.winver = 'Windows 98'
1228
 
        self.assertDirReaderIs(osutils.UnicodeDirReader)
 
1015
        self.assertReadFSDirIs(osutils.UnicodeDirReader)
1229
1016
 
1230
1017
    def test_unicode_walkdirs(self):
1231
1018
        """Walkdirs should always return unicode paths."""
1232
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1233
1019
        name0 = u'0file-\xb6'
1234
1020
        name1 = u'1dir-\u062c\u0648'
1235
1021
        name2 = u'2file-\u0633'
1240
1026
            name1 + '/' + name1 + '/',
1241
1027
            name2,
1242
1028
            ]
1243
 
        self.build_tree(tree)
 
1029
        try:
 
1030
            self.build_tree(tree)
 
1031
        except UnicodeError:
 
1032
            raise TestSkipped('Could not represent Unicode chars'
 
1033
                              ' in current encoding.')
1244
1034
        expected_dirblocks = [
1245
1035
                ((u'', u'.'),
1246
1036
                 [(name0, name0, 'file', './' + name0),
1272
1062
 
1273
1063
        The abspath portion might be in unicode or utf-8
1274
1064
        """
1275
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1276
1065
        name0 = u'0file-\xb6'
1277
1066
        name1 = u'1dir-\u062c\u0648'
1278
1067
        name2 = u'2file-\u0633'
1283
1072
            name1 + '/' + name1 + '/',
1284
1073
            name2,
1285
1074
            ]
1286
 
        self.build_tree(tree)
 
1075
        try:
 
1076
            self.build_tree(tree)
 
1077
        except UnicodeError:
 
1078
            raise TestSkipped('Could not represent Unicode chars'
 
1079
                              ' in current encoding.')
1287
1080
        name0 = name0.encode('utf8')
1288
1081
        name1 = name1.encode('utf8')
1289
1082
        name2 = name2.encode('utf8')
1333
1126
 
1334
1127
        The abspath portion should be in unicode
1335
1128
        """
1336
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1337
1129
        # Use the unicode reader. TODO: split into driver-and-driven unit
1338
1130
        # tests.
1339
1131
        self._save_platform_info()
1348
1140
            name1u + '/' + name1u + '/',
1349
1141
            name2u,
1350
1142
            ]
1351
 
        self.build_tree(tree)
 
1143
        try:
 
1144
            self.build_tree(tree)
 
1145
        except UnicodeError:
 
1146
            raise TestSkipped('Could not represent Unicode chars'
 
1147
                              ' in current encoding.')
1352
1148
        name0 = name0u.encode('utf8')
1353
1149
        name1 = name1u.encode('utf8')
1354
1150
        name2 = name2u.encode('utf8')
1379
1175
        self.assertEqual(expected_dirblocks, result)
1380
1176
 
1381
1177
    def test__walkdirs_utf8_win32readdir(self):
1382
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1178
        self.requireFeature(Win32ReadDirFeature)
1383
1179
        self.requireFeature(tests.UnicodeFilenameFeature)
1384
1180
        from bzrlib._walkdirs_win32 import Win32ReadDir
1385
1181
        self._save_platform_info()
1436
1232
 
1437
1233
    def test__walkdirs_utf_win32_find_file_stat_file(self):
1438
1234
        """make sure our Stat values are valid"""
1439
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1235
        self.requireFeature(Win32ReadDirFeature)
1440
1236
        self.requireFeature(tests.UnicodeFilenameFeature)
1441
1237
        from bzrlib._walkdirs_win32 import Win32ReadDir
1442
1238
        name0u = u'0file-\xb6'
1460
1256
 
1461
1257
    def test__walkdirs_utf_win32_find_file_stat_directory(self):
1462
1258
        """make sure our Stat values are valid"""
1463
 
        self.requireFeature(test__walkdirs_win32.win32_readdir_feature)
 
1259
        self.requireFeature(Win32ReadDirFeature)
1464
1260
        self.requireFeature(tests.UnicodeFilenameFeature)
1465
1261
        from bzrlib._walkdirs_win32 import Win32ReadDir
1466
1262
        name0u = u'0dir-\u062c\u0648'
1551
1347
            sorted(original_paths, cmp=osutils.compare_paths_prefix_order))
1552
1348
 
1553
1349
 
1554
 
class TestCopyTree(tests.TestCaseInTempDir):
 
1350
class TestCopyTree(TestCaseInTempDir):
1555
1351
 
1556
1352
    def test_copy_basic_tree(self):
1557
1353
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1567
1363
        self.assertEqual(['c'], os.listdir('target/b'))
1568
1364
 
1569
1365
    def test_copy_tree_symlinks(self):
1570
 
        self.requireFeature(tests.SymlinkFeature)
 
1366
        self.requireFeature(SymlinkFeature)
1571
1367
        self.build_tree(['source/'])
1572
1368
        os.symlink('a/generic/path', 'source/lnk')
1573
1369
        osutils.copy_tree('source', 'target')
1603
1399
            self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1604
1400
 
1605
1401
 
1606
 
class TestSetUnsetEnv(tests.TestCase):
 
1402
#class TestTerminalEncoding has been moved to test_osutils_encodings.py
 
1403
# [bialix] 2006/12/26
 
1404
 
 
1405
 
 
1406
class TestSetUnsetEnv(TestCase):
1607
1407
    """Test updating the environment"""
1608
1408
 
1609
1409
    def setUp(self):
1615
1415
        def cleanup():
1616
1416
            if 'BZR_TEST_ENV_VAR' in os.environ:
1617
1417
                del os.environ['BZR_TEST_ENV_VAR']
 
1418
 
1618
1419
        self.addCleanup(cleanup)
1619
1420
 
1620
1421
    def test_set(self):
1635
1436
 
1636
1437
        So Unicode strings must be encoded.
1637
1438
        """
1638
 
        uni_val, env_val = tests.probe_unicode_in_user_encoding()
 
1439
        uni_val, env_val = probe_unicode_in_user_encoding()
1639
1440
        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(),))
 
1441
            raise TestSkipped('Cannot find a unicode character that works in'
 
1442
                              ' encoding %s' % (osutils.get_user_encoding(),))
1643
1443
 
1644
1444
        old = osutils.set_or_unset_env('BZR_TEST_ENV_VAR', uni_val)
1645
1445
        self.assertEqual(env_val, os.environ.get('BZR_TEST_ENV_VAR'))
1653
1453
        self.failIf('BZR_TEST_ENV_VAR' in os.environ)
1654
1454
 
1655
1455
 
1656
 
class TestSizeShaFile(tests.TestCaseInTempDir):
 
1456
class TestLocalTimeOffset(TestCase):
 
1457
 
 
1458
    def test_local_time_offset(self):
 
1459
        """Test that local_time_offset() returns a sane value."""
 
1460
        offset = osutils.local_time_offset()
 
1461
        self.assertTrue(isinstance(offset, int))
 
1462
        # Test that the offset is no more than a eighteen hours in
 
1463
        # either direction.
 
1464
        # Time zone handling is system specific, so it is difficult to
 
1465
        # do more specific tests, but a value outside of this range is
 
1466
        # probably wrong.
 
1467
        eighteen_hours = 18 * 3600
 
1468
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
1469
 
 
1470
    def test_local_time_offset_with_timestamp(self):
 
1471
        """Test that local_time_offset() works with a timestamp."""
 
1472
        offset = osutils.local_time_offset(1000000000.1234567)
 
1473
        self.assertTrue(isinstance(offset, int))
 
1474
        eighteen_hours = 18 * 3600
 
1475
        self.assertTrue(-eighteen_hours < offset < eighteen_hours)
 
1476
 
 
1477
 
 
1478
class TestSizeShaFile(TestCaseInTempDir):
1657
1479
 
1658
1480
    def test_sha_empty(self):
1659
1481
        self.build_tree_contents([('foo', '')])
1668
1490
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
1669
1491
        self.build_tree_contents([('foo', text)])
1670
1492
        expected_sha = osutils.sha_string(text)
1671
 
        f = open('foo', 'rb')
 
1493
        f = open('foo')
1672
1494
        self.addCleanup(f.close)
1673
1495
        size, sha = osutils.size_sha_file(f)
1674
1496
        self.assertEqual(38, size)
1675
1497
        self.assertEqual(expected_sha, sha)
1676
1498
 
1677
1499
 
1678
 
class TestShaFileByName(tests.TestCaseInTempDir):
 
1500
class TestShaFileByName(TestCaseInTempDir):
1679
1501
 
1680
1502
    def test_sha_empty(self):
1681
1503
        self.build_tree_contents([('foo', '')])
1689
1511
        self.assertEqual(expected_sha, osutils.sha_file_by_name('foo'))
1690
1512
 
1691
1513
 
1692
 
class TestResourceLoading(tests.TestCaseInTempDir):
 
1514
class TestResourceLoading(TestCaseInTempDir):
1693
1515
 
1694
1516
    def test_resource_string(self):
1695
1517
        # test resource in bzrlib
1705
1527
        self.assertRaises(IOError, osutils.resource_string, 'bzrlib', 'yyy.xx')
1706
1528
 
1707
1529
 
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)
 
1530
class TestReCompile(TestCase):
1713
1531
 
1714
1532
    def test_re_compile_checked(self):
1715
 
        r = self._deprecated_re_compile_checked(r'A*', re.IGNORECASE)
 
1533
        r = osutils.re_compile_checked(r'A*', re.IGNORECASE)
1716
1534
        self.assertTrue(r.match('aaaa'))
1717
1535
        self.assertTrue(r.match('aAaA'))
1718
1536
 
1719
1537
    def test_re_compile_checked_error(self):
1720
1538
        # 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
1539
        err = self.assertRaises(
1726
1540
            errors.BzrCommandError,
1727
 
            self._deprecated_re_compile_checked, '*', re.IGNORECASE, 'test case')
 
1541
            osutils.re_compile_checked, '*', re.IGNORECASE, 'test case')
1728
1542
        self.assertEqual(
1729
 
            'Invalid regular expression in test case: '
1730
 
            '"*" nothing to repeat',
 
1543
            "Invalid regular expression in test case: '*': "
 
1544
            "nothing to repeat",
1731
1545
            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())