/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 breezy/tests/test_osutils.py

  • Committer: Jelmer Vernooij
  • Date: 2019-06-02 02:35:46 UTC
  • mfrom: (7309 work)
  • mto: This revision was merged to the branch mainline in revision 7319.
  • Revision ID: jelmer@jelmer.uk-20190602023546-lqco868tnv26d8ow
merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_osutils.py
20
20
 
21
21
import errno
22
22
import os
23
 
import re
24
23
import select
25
24
import socket
26
25
import sys
29
28
 
30
29
from .. import (
31
30
    errors,
32
 
    lazy_regex,
33
31
    osutils,
34
 
    symbol_versioning,
35
32
    tests,
36
33
    trace,
37
34
    win32utils,
60
57
        except ImportError:
61
58
            return False
62
59
 
 
60
 
63
61
UTF8DirReaderFeature = _UTF8DirReaderFeature('breezy._readdir_pyx')
64
62
 
65
63
term_ios_feature = features.ModuleAvailableFeature('termios')
314
312
                raise
315
313
        else:
316
314
            self.assertEqual(
317
 
                    'chardev',
318
 
                    osutils.file_kind(os.path.realpath('/dev/null')))
 
315
                'chardev',
 
316
                osutils.file_kind(os.path.realpath('/dev/null')))
319
317
 
320
318
        mkfifo = getattr(os, 'mkfifo', None)
321
319
        if mkfifo:
405
403
 
406
404
    def test_format_date(self):
407
405
        self.assertRaises(osutils.UnsupportedTimezoneFormat,
408
 
            osutils.format_date, 0, timezone='foo')
 
406
                          osutils.format_date, 0, timezone='foo')
409
407
        self.assertIsInstance(osutils.format_date(0), str)
410
408
        self.assertIsInstance(osutils.format_local_date(0), text_type)
411
409
        # Testing for the actual value of the local weekday without
415
413
 
416
414
    def test_format_date_with_offset_in_original_timezone(self):
417
415
        self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
418
 
            osutils.format_date_with_offset_in_original_timezone(0))
 
416
                         osutils.format_date_with_offset_in_original_timezone(0))
419
417
        self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
420
 
            osutils.format_date_with_offset_in_original_timezone(100000))
 
418
                         osutils.format_date_with_offset_in_original_timezone(100000))
421
419
        self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
422
 
            osutils.format_date_with_offset_in_original_timezone(100000, 7200))
 
420
                         osutils.format_date_with_offset_in_original_timezone(100000, 7200))
423
421
 
424
422
    def test_local_time_offset(self):
425
423
        """Test that local_time_offset() returns a sane value."""
619
617
 
620
618
        # read (max // 2) bytes and verify read size wasn't affected
621
619
        num_bytes_to_read = self.block_size // 2
622
 
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
620
        osutils.pumpfile(from_file, to_file,
 
621
                         num_bytes_to_read, self.block_size)
623
622
        self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
624
623
        self.assertEqual(from_file.get_read_count(), 1)
625
624
 
626
625
        # read (max) bytes and verify read size wasn't affected
627
626
        num_bytes_to_read = self.block_size
628
627
        from_file.reset_read_count()
629
 
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
628
        osutils.pumpfile(from_file, to_file,
 
629
                         num_bytes_to_read, self.block_size)
630
630
        self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
631
631
        self.assertEqual(from_file.get_read_count(), 1)
632
632
 
633
633
        # read (max + 1) bytes and verify read size was limited
634
634
        num_bytes_to_read = self.block_size + 1
635
635
        from_file.reset_read_count()
636
 
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
636
        osutils.pumpfile(from_file, to_file,
 
637
                         num_bytes_to_read, self.block_size)
637
638
        self.assertEqual(from_file.get_max_read_size(), self.block_size)
638
639
        self.assertEqual(from_file.get_read_count(), 2)
639
640
 
640
641
        # finish reading the rest of the data
641
642
        num_bytes_to_read = self.test_data_len - to_file.tell()
642
 
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
643
        osutils.pumpfile(from_file, to_file,
 
644
                         num_bytes_to_read, self.block_size)
643
645
 
644
646
        # report error if the data wasn't equal (we only report the size due
645
647
        # to the length of the data)
712
714
 
713
715
    def test_report_activity(self):
714
716
        activity = []
 
717
 
715
718
        def log_activity(length, direction):
716
719
            activity.append((length, direction))
717
720
        from_file = BytesIO(self.test_data)
735
738
        del activity[:]
736
739
        osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
737
740
                         report_activity=log_activity, direction='read')
738
 
        self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
739
 
 
 
741
        self.assertEqual(
 
742
            [(500, 'read'), (500, 'read'), (28, 'read')], activity)
740
743
 
741
744
 
742
745
class TestPumpStringFile(tests.TestCase):
833
836
 
834
837
    def test_from_unicode_string_unicode_contents(self):
835
838
        self.assertRaises(TypeError,
836
 
                         osutils.safe_revision_id, u'bargam\xae')
 
839
                          osutils.safe_revision_id, u'bargam\xae')
837
840
 
838
841
    def test_from_utf8_string(self):
839
842
        self.assertEqual(b'foo\xc2\xae',
871
874
        class DisconnectedSocket(object):
872
875
            def __init__(self, err):
873
876
                self.err = err
 
877
 
874
878
            def send(self, content):
875
879
                raise self.err
 
880
 
876
881
            def close(self):
877
882
                pass
878
883
        # All of these should be treated as ConnectionReset
883
888
        for err in errs:
884
889
            sock = DisconnectedSocket(err)
885
890
            self.assertRaises(errors.ConnectionReset,
886
 
                osutils.send_all, sock, b'some more content')
 
891
                              osutils.send_all, sock, b'some more content')
887
892
 
888
893
    def test_send_with_no_progress(self):
889
894
        # See https://bugs.launchpad.net/bzr/+bug/1047309
892
897
        class NoSendingSocket(object):
893
898
            def __init__(self):
894
899
                self.call_count = 0
 
900
 
895
901
            def send(self, bytes):
896
902
                self.call_count += 1
897
903
                if self.call_count > 100:
910
916
 
911
917
    def test_normpath(self):
912
918
        self.assertEqual('/etc/shadow', osutils._posix_normpath('/etc/shadow'))
913
 
        self.assertEqual('/etc/shadow', osutils._posix_normpath('//etc/shadow'))
914
 
        self.assertEqual('/etc/shadow', osutils._posix_normpath('///etc/shadow'))
 
919
        self.assertEqual(
 
920
            '/etc/shadow', osutils._posix_normpath('//etc/shadow'))
 
921
        self.assertEqual(
 
922
            '/etc/shadow', osutils._posix_normpath('///etc/shadow'))
915
923
 
916
924
 
917
925
class TestWin32Funcs(tests.TestCase):
986
994
 
987
995
    def test_minimum_path_selection(self):
988
996
        self.assertEqual(set(),
989
 
            osutils.minimum_path_selection([]))
 
997
                         osutils.minimum_path_selection([]))
990
998
        self.assertEqual({'a'},
991
 
            osutils.minimum_path_selection(['a']))
 
999
                         osutils.minimum_path_selection(['a']))
992
1000
        self.assertEqual({'a', 'b'},
993
 
            osutils.minimum_path_selection(['a', 'b']))
994
 
        self.assertEqual({'a/', 'b'},
995
 
            osutils.minimum_path_selection(['a/', 'b']))
996
 
        self.assertEqual({'a/', 'b'},
997
 
            osutils.minimum_path_selection(['a/c', 'a/', 'b']))
 
1001
                         osutils.minimum_path_selection(['a', 'b']))
 
1002
        self.assertEqual({'a/', 'b'},
 
1003
                         osutils.minimum_path_selection(['a/', 'b']))
 
1004
        self.assertEqual({'a/', 'b'},
 
1005
                         osutils.minimum_path_selection(['a/c', 'a/', 'b']))
998
1006
        self.assertEqual({'a-b', 'a', 'a0b'},
999
 
            osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
 
1007
                         osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
1000
1008
 
1001
1009
    def test_mkdtemp(self):
1002
1010
        tmpdir = osutils._win32_mkdtemp(dir='.')
1050
1058
        check(['a', 'b'], 'a/b')
1051
1059
        check(['a', 'b'], 'a/./b')
1052
1060
        check(['a', '.b'], 'a/.b')
1053
 
        check(['a', '.b'], 'a\\.b')
 
1061
        if os.path.sep == '\\':
 
1062
            check(['a', '.b'], 'a\\.b')
 
1063
        else:
 
1064
            check(['a\\.b'], 'a\\.b')
1054
1065
 
1055
1066
        self.assertRaises(errors.BzrError, osutils.splitpath, 'a/../b')
1056
1067
 
1129
1140
            ]
1130
1141
        self.build_tree(tree)
1131
1142
        expected_dirblocks = [
1132
 
                (('', '.'),
1133
 
                 [('0file', '0file', 'file'),
1134
 
                  ('1dir', '1dir', 'directory'),
1135
 
                  ('2file', '2file', 'file'),
1136
 
                 ]
1137
 
                ),
1138
 
                (('1dir', './1dir'),
1139
 
                 [('1dir/0file', '0file', 'file'),
1140
 
                  ('1dir/1dir', '1dir', 'directory'),
1141
 
                 ]
1142
 
                ),
1143
 
                (('1dir/1dir', './1dir/1dir'),
1144
 
                 [
1145
 
                 ]
1146
 
                ),
 
1143
            (('', '.'),
 
1144
             [('0file', '0file', 'file'),
 
1145
              ('1dir', '1dir', 'directory'),
 
1146
              ('2file', '2file', 'file'),
 
1147
              ]
 
1148
             ),
 
1149
            (('1dir', './1dir'),
 
1150
             [('1dir/0file', '0file', 'file'),
 
1151
              ('1dir/1dir', '1dir', 'directory'),
 
1152
              ]
 
1153
             ),
 
1154
            (('1dir/1dir', './1dir/1dir'),
 
1155
             [
 
1156
                ]
 
1157
             ),
1147
1158
            ]
1148
1159
        result = []
1149
1160
        found_bzrdir = False
1228
1239
            ]
1229
1240
        self.build_tree(tree)
1230
1241
        expected_dirblocks = [
1231
 
                (('', '.'),
1232
 
                 [('0file', '0file', 'file'),
1233
 
                  ('1dir', '1dir', 'directory'),
1234
 
                  ('2file', '2file', 'file'),
1235
 
                 ]
1236
 
                ),
1237
 
                (('1dir', './1dir'),
1238
 
                 [('1dir/0file', '0file', 'file'),
1239
 
                  ('1dir/1dir', '1dir', 'directory'),
1240
 
                 ]
1241
 
                ),
1242
 
                (('1dir/1dir', './1dir/1dir'),
1243
 
                 [
1244
 
                 ]
1245
 
                ),
 
1242
            (('', '.'),
 
1243
             [('0file', '0file', 'file'),
 
1244
              ('1dir', '1dir', 'directory'),
 
1245
              ('2file', '2file', 'file'),
 
1246
              ]
 
1247
             ),
 
1248
            (('1dir', './1dir'),
 
1249
             [('1dir/0file', '0file', 'file'),
 
1250
              ('1dir/1dir', '1dir', 'directory'),
 
1251
              ]
 
1252
             ),
 
1253
            (('1dir/1dir', './1dir/1dir'),
 
1254
             [
 
1255
                ]
 
1256
             ),
1246
1257
            ]
1247
1258
        result = []
1248
1259
        found_bzrdir = False
1251
1262
                # this tests the filtering of selected paths
1252
1263
                found_bzrdir = True
1253
1264
                del dirblock[0]
1254
 
            dirdetail = (dirdetail[0].decode('utf-8'), osutils.safe_unicode(dirdetail[1]))
 
1265
            dirdetail = (dirdetail[0].decode('utf-8'),
 
1266
                         osutils.safe_unicode(dirdetail[1]))
1255
1267
            dirblock = [
1256
 
                    (entry[0].decode('utf-8'), entry[1].decode('utf-8'), entry[2])
1257
 
                    for entry in dirblock]
 
1268
                (entry[0].decode('utf-8'), entry[1].decode('utf-8'), entry[2])
 
1269
                for entry in dirblock]
1258
1270
            result.append((dirdetail, dirblock))
1259
1271
 
1260
1272
        self.assertTrue(found_bzrdir)
1327
1339
            ]
1328
1340
        self.build_tree(tree)
1329
1341
        expected_dirblocks = [
1330
 
                ((u'', u'.'),
1331
 
                 [(name0, name0, 'file', './' + name0),
1332
 
                  (name1, name1, 'directory', './' + name1),
1333
 
                  (name2, name2, 'file', './' + name2),
1334
 
                 ]
1335
 
                ),
1336
 
                ((name1, './' + name1),
1337
 
                 [(name1 + '/' + name0, name0, 'file', './' + name1
1338
 
                                                        + '/' + name0),
1339
 
                  (name1 + '/' + name1, name1, 'directory', './' + name1
1340
 
                                                            + '/' + name1),
1341
 
                 ]
1342
 
                ),
1343
 
                ((name1 + '/' + name1, './' + name1 + '/' + name1),
1344
 
                 [
1345
 
                 ]
1346
 
                ),
 
1342
            ((u'', u'.'),
 
1343
             [(name0, name0, 'file', './' + name0),
 
1344
              (name1, name1, 'directory', './' + name1),
 
1345
              (name2, name2, 'file', './' + name2),
 
1346
              ]
 
1347
             ),
 
1348
            ((name1, './' + name1),
 
1349
             [(name1 + '/' + name0, name0, 'file', './' + name1
 
1350
               + '/' + name0),
 
1351
              (name1 + '/' + name1, name1, 'directory', './' + name1
 
1352
               + '/' + name1),
 
1353
              ]
 
1354
             ),
 
1355
            ((name1 + '/' + name1, './' + name1 + '/' + name1),
 
1356
             [
 
1357
                ]
 
1358
             ),
1347
1359
            ]
1348
1360
        result = list(osutils.walkdirs('.'))
1349
1361
        self._filter_out_stat(result)
1350
1362
        self.assertEqual(expected_dirblocks, result)
1351
 
        result = list(osutils.walkdirs(u'./'+name1, name1))
 
1363
        result = list(osutils.walkdirs(u'./' + name1, name1))
1352
1364
        self._filter_out_stat(result)
1353
1365
        self.assertEqual(expected_dirblocks[1:], result)
1354
1366
 
1374
1386
        name2 = name2.encode('utf8')
1375
1387
 
1376
1388
        expected_dirblocks = [
1377
 
                ((b'', b'.'),
1378
 
                 [(name0, name0, 'file', b'./' + name0),
1379
 
                  (name1, name1, 'directory', b'./' + name1),
1380
 
                  (name2, name2, 'file', b'./' + name2),
1381
 
                 ]
1382
 
                ),
1383
 
                ((name1, b'./' + name1),
1384
 
                 [(name1 + b'/' + name0, name0, 'file', b'./' + name1
1385
 
                                                        + b'/' + name0),
1386
 
                  (name1 + b'/' + name1, name1, 'directory', b'./' + name1
1387
 
                                                            + b'/' + name1),
1388
 
                 ]
1389
 
                ),
1390
 
                ((name1 + b'/' + name1, b'./' + name1 + b'/' + name1),
1391
 
                 [
1392
 
                 ]
1393
 
                ),
 
1389
            ((b'', b'.'),
 
1390
             [(name0, name0, 'file', b'./' + name0),
 
1391
              (name1, name1, 'directory', b'./' + name1),
 
1392
              (name2, name2, 'file', b'./' + name2),
 
1393
              ]
 
1394
             ),
 
1395
            ((name1, b'./' + name1),
 
1396
             [(name1 + b'/' + name0, name0, 'file', b'./' + name1
 
1397
               + b'/' + name0),
 
1398
              (name1 + b'/' + name1, name1, 'directory', b'./' + name1
 
1399
               + b'/' + name1),
 
1400
              ]
 
1401
             ),
 
1402
            ((name1 + b'/' + name1, b'./' + name1 + b'/' + name1),
 
1403
             [
 
1404
                ]
 
1405
             ),
1394
1406
            ]
1395
1407
        result = []
1396
1408
        # For ease in testing, if walkdirs_utf8 returns Unicode, assert that
1441
1453
        # All of the abspaths should be in unicode, all of the relative paths
1442
1454
        # should be in utf8
1443
1455
        expected_dirblocks = [
1444
 
                ((b'', '.'),
1445
 
                 [(name0, name0, 'file', './' + name0u),
1446
 
                  (name1, name1, 'directory', './' + name1u),
1447
 
                  (name2, name2, 'file', './' + name2u),
1448
 
                 ]
1449
 
                ),
1450
 
                ((name1, './' + name1u),
1451
 
                 [(name1 + b'/' + name0, name0, 'file', './' + name1u
1452
 
                                                        + '/' + name0u),
1453
 
                  (name1 + b'/' + name1, name1, 'directory', './' + name1u
1454
 
                                                            + '/' + name1u),
1455
 
                 ]
1456
 
                ),
1457
 
                ((name1 + b'/' + name1, './' + name1u + '/' + name1u),
1458
 
                 [
1459
 
                 ]
1460
 
                ),
 
1456
            ((b'', '.'),
 
1457
             [(name0, name0, 'file', './' + name0u),
 
1458
              (name1, name1, 'directory', './' + name1u),
 
1459
              (name2, name2, 'file', './' + name2u),
 
1460
              ]
 
1461
             ),
 
1462
            ((name1, './' + name1u),
 
1463
             [(name1 + b'/' + name0, name0, 'file', './' + name1u
 
1464
               + '/' + name0u),
 
1465
              (name1 + b'/' + name1, name1, 'directory', './' + name1u
 
1466
               + '/' + name1u),
 
1467
              ]
 
1468
             ),
 
1469
            ((name1 + b'/' + name1, './' + name1u + '/' + name1u),
 
1470
             [
 
1471
                ]
 
1472
             ),
1461
1473
            ]
1462
1474
        result = list(osutils._walkdirs_utf8('.'))
1463
1475
        self._filter_out_stat(result)
1487
1499
        # All of the abspaths should be in unicode, all of the relative paths
1488
1500
        # should be in utf8
1489
1501
        expected_dirblocks = [
1490
 
                (('', '.'),
1491
 
                 [(name0, name0, 'file', './' + name0u),
1492
 
                  (name1, name1, 'directory', './' + name1u),
1493
 
                  (name2, name2, 'file', './' + name2u),
1494
 
                 ]
1495
 
                ),
1496
 
                ((name1, './' + name1u),
1497
 
                 [(name1 + '/' + name0, name0, 'file', './' + name1u
1498
 
                                                        + '/' + name0u),
1499
 
                  (name1 + '/' + name1, name1, 'directory', './' + name1u
1500
 
                                                            + '/' + name1u),
1501
 
                 ]
1502
 
                ),
1503
 
                ((name1 + '/' + name1, './' + name1u + '/' + name1u),
1504
 
                 [
1505
 
                 ]
1506
 
                ),
 
1502
            (('', '.'),
 
1503
             [(name0, name0, 'file', './' + name0u),
 
1504
              (name1, name1, 'directory', './' + name1u),
 
1505
              (name2, name2, 'file', './' + name2u),
 
1506
              ]
 
1507
             ),
 
1508
            ((name1, './' + name1u),
 
1509
             [(name1 + '/' + name0, name0, 'file', './' + name1u
 
1510
               + '/' + name0u),
 
1511
              (name1 + '/' + name1, name1, 'directory', './' + name1u
 
1512
               + '/' + name1u),
 
1513
              ]
 
1514
             ),
 
1515
            ((name1 + '/' + name1, './' + name1u + '/' + name1u),
 
1516
             [
 
1517
                ]
 
1518
             ),
1507
1519
            ]
1508
1520
        result = list(osutils._walkdirs_utf8(u'.'))
1509
1521
        self._filter_out_stat(result)
1659
1671
    def test_copy_tree_handlers(self):
1660
1672
        processed_files = []
1661
1673
        processed_links = []
 
1674
 
1662
1675
        def file_handler(from_path, to_path):
1663
1676
            processed_files.append(('f', from_path, to_path))
 
1677
 
1664
1678
        def dir_handler(from_path, to_path):
1665
1679
            processed_files.append(('d', from_path, to_path))
 
1680
 
1666
1681
        def link_handler(from_path, to_path):
1667
1682
            processed_links.append((from_path, to_path))
1668
1683
        handlers = {'file': file_handler,
1669
1684
                    'directory': dir_handler,
1670
1685
                    'symlink': link_handler,
1671
 
                   }
 
1686
                    }
1672
1687
 
1673
1688
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1674
1689
        if osutils.has_symlinks():
1679
1694
                          ('f', 'source/a', 'target/a'),
1680
1695
                          ('d', 'source/b', 'target/b'),
1681
1696
                          ('f', 'source/b/c', 'target/b/c'),
1682
 
                         ], processed_files)
 
1697
                          ], processed_files)
1683
1698
        self.assertPathDoesNotExist('target')
1684
1699
        if osutils.has_symlinks():
1685
1700
            self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1694
1709
        self.assertEqual(None, os.environ.get('BRZ_TEST_ENV_VAR'),
1695
1710
                         'Environment was not cleaned up properly.'
1696
1711
                         ' Variable BRZ_TEST_ENV_VAR should not exist.')
 
1712
 
1697
1713
        def cleanup():
1698
1714
            if 'BRZ_TEST_ENV_VAR' in os.environ:
1699
1715
                del os.environ['BRZ_TEST_ENV_VAR']
1723
1739
                'Cannot find a unicode character that works in encoding %s'
1724
1740
                % (osutils.get_user_encoding(),))
1725
1741
 
1726
 
        old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', uni_val)
 
1742
        osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', uni_val)
1727
1743
        if PY3:
1728
1744
            self.assertEqual(uni_val, os.environ.get('BRZ_TEST_ENV_VAR'))
1729
1745
        else:
1785
1801
        self.assertContainsRe(text, "class TextUIFactory")
1786
1802
        # test unsupported package
1787
1803
        self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1788
 
            'yyy.xx')
 
1804
                          'yyy.xx')
1789
1805
        # test unknown resource
1790
1806
        self.assertRaises(IOError, osutils.resource_string, 'breezy', 'yyy.xx')
1791
1807
 
1812
1828
            '2file'
1813
1829
            ]
1814
1830
        expected_dirblocks = [
1815
 
                ((b'', '.'),
1816
 
                 [(b'0file', b'0file', 'file', './0file'),
1817
 
                  (b'1dir', b'1dir', 'directory', './1dir'),
1818
 
                  (b'2file', b'2file', 'file', './2file'),
1819
 
                 ]
1820
 
                ),
1821
 
                ((b'1dir', './1dir'),
1822
 
                 [(b'1dir/0file', b'0file', 'file', './1dir/0file'),
1823
 
                  (b'1dir/1dir', b'1dir', 'directory', './1dir/1dir'),
1824
 
                 ]
1825
 
                ),
1826
 
                ((b'1dir/1dir', './1dir/1dir'),
1827
 
                 [
1828
 
                 ]
1829
 
                ),
 
1831
            ((b'', '.'),
 
1832
             [(b'0file', b'0file', 'file', './0file'),
 
1833
              (b'1dir', b'1dir', 'directory', './1dir'),
 
1834
              (b'2file', b'2file', 'file', './2file'),
 
1835
              ]
 
1836
             ),
 
1837
            ((b'1dir', './1dir'),
 
1838
             [(b'1dir/0file', b'0file', 'file', './1dir/0file'),
 
1839
              (b'1dir/1dir', b'1dir', 'directory', './1dir/1dir'),
 
1840
              ]
 
1841
             ),
 
1842
            ((b'1dir/1dir', './1dir/1dir'),
 
1843
             [
 
1844
                ]
 
1845
             ),
1830
1846
            ]
1831
1847
        return tree, expected_dirblocks
1832
1848
 
1836
1852
        result = list(osutils._walkdirs_utf8('.'))
1837
1853
        # Filter out stat and abspath
1838
1854
        self.assertEqual(expected_dirblocks,
1839
 
                self._filter_out(result))
 
1855
                         self._filter_out(result))
1840
1856
 
1841
1857
    def test_walk_sub_dir(self):
1842
1858
        tree, expected_dirblocks = self._get_ascii_tree()
1845
1861
        result = list(osutils._walkdirs_utf8(b'./1dir', b'1dir'))
1846
1862
        # Filter out stat and abspath
1847
1863
        self.assertEqual(expected_dirblocks[1:],
1848
 
                self._filter_out(result))
 
1864
                         self._filter_out(result))
1849
1865
 
1850
1866
    def _get_unicode_tree(self):
1851
1867
        name0u = u'0file-\xb6'
1862
1878
        name1 = name1u.encode('UTF-8')
1863
1879
        name2 = name2u.encode('UTF-8')
1864
1880
        expected_dirblocks = [
1865
 
                ((b'', '.'),
1866
 
                 [(name0, name0, 'file', './' + name0u),
1867
 
                  (name1, name1, 'directory', './' + name1u),
1868
 
                  (name2, name2, 'file', './' + name2u),
1869
 
                 ]
1870
 
                ),
1871
 
                ((name1, './' + name1u),
1872
 
                 [(name1 + b'/' + name0, name0, 'file', './' + name1u
1873
 
                                                        + '/' + name0u),
1874
 
                  (name1 + b'/' + name1, name1, 'directory', './' + name1u
1875
 
                                                            + '/' + name1u),
1876
 
                 ]
1877
 
                ),
1878
 
                ((name1 + b'/' + name1, './' + name1u + '/' + name1u),
1879
 
                 [
1880
 
                 ]
1881
 
                ),
 
1881
            ((b'', '.'),
 
1882
             [(name0, name0, 'file', './' + name0u),
 
1883
              (name1, name1, 'directory', './' + name1u),
 
1884
              (name2, name2, 'file', './' + name2u),
 
1885
              ]
 
1886
             ),
 
1887
            ((name1, './' + name1u),
 
1888
             [(name1 + b'/' + name0, name0, 'file', './' + name1u
 
1889
               + '/' + name0u),
 
1890
              (name1 + b'/' + name1, name1, 'directory', './' + name1u
 
1891
               + '/' + name1u),
 
1892
              ]
 
1893
             ),
 
1894
            ((name1 + b'/' + name1, './' + name1u + '/' + name1u),
 
1895
             [
 
1896
                ]
 
1897
             ),
1882
1898
            ]
1883
1899
        return tree, expected_dirblocks
1884
1900
 
1892
1908
            dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1893
1909
            details = []
1894
1910
            for line in block:
1895
 
                details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
 
1911
                details.append(
 
1912
                    line[0:3] + (self._native_to_unicode(line[4]), ))
1896
1913
            filtered_dirblocks.append((dirinfo, details))
1897
1914
        return filtered_dirblocks
1898
1915
 
1909
1926
        target = u'target\N{Euro Sign}'
1910
1927
        link_name = u'l\N{Euro Sign}nk'
1911
1928
        os.symlink(target, link_name)
1912
 
        target_utf8 = target.encode('UTF-8')
1913
1929
        link_name_utf8 = link_name.encode('UTF-8')
1914
1930
        expected_dirblocks = [
1915
 
                ((b'', '.'),
1916
 
                 [(link_name_utf8, link_name_utf8,
1917
 
                   'symlink', './' + link_name),],
1918
 
                 )]
 
1931
            ((b'', '.'),
 
1932
             [(link_name_utf8, link_name_utf8,
 
1933
               'symlink', './' + link_name), ],
 
1934
             )]
1919
1935
        result = list(osutils._walkdirs_utf8('.'))
1920
1936
        self.assertEqual(expected_dirblocks, self._filter_out(result))
1921
1937
 
1929
1945
    But prior python versions failed to properly encode the passed unicode
1930
1946
    string.
1931
1947
    """
1932
 
    _test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]
 
1948
    _test_needs_features = [features.SymlinkFeature,
 
1949
                            features.UnicodeFilenameFeature]
1933
1950
 
1934
1951
    def setUp(self):
1935
1952
        super(tests.TestCaseInTempDir, self).setUp()
1938
1955
        os.symlink(self.target, self.link)
1939
1956
 
1940
1957
    def test_os_readlink_link_encoding(self):
1941
 
        self.assertEqual(self.target,  os.readlink(self.link))
 
1958
        self.assertEqual(self.target, os.readlink(self.link))
1942
1959
 
1943
1960
    def test_os_readlink_link_decoding(self):
1944
1961
        self.assertEqual(self.target.encode(osutils._fs_enc),
1945
 
                          os.readlink(self.link.encode(osutils._fs_enc)))
 
1962
                         os.readlink(self.link.encode(osutils._fs_enc)))
1946
1963
 
1947
1964
 
1948
1965
class TestConcurrency(tests.TestCase):
1975
1992
 
1976
1993
    def _try_loading(self):
1977
1994
        try:
1978
 
            import breezy._fictional_extension_py
 
1995
            import breezy._fictional_extension_py  # noqa: F401
1979
1996
        except ImportError as e:
1980
1997
            osutils.failed_to_load_extension(e)
1981
1998
            return True
1988
2005
        self._try_loading()
1989
2006
        self.assertLength(1, osutils._extension_load_failures)
1990
2007
        if PY3:
1991
 
            self.assertEqual(osutils._extension_load_failures[0],
 
2008
            self.assertEqual(
 
2009
                osutils._extension_load_failures[0],
1992
2010
                "No module named 'breezy._fictional_extension_py'")
1993
2011
        else:
1994
2012
            self.assertEqual(osutils._extension_load_failures[0],
1995
 
                "No module named _fictional_extension_py")
 
2013
                             "No module named _fictional_extension_py")
1996
2014
 
1997
2015
    def test_report_extension_load_failures_no_warning(self):
1998
2016
        self.assertTrue(self._try_loading())
1999
 
        warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
 
2017
        warnings, result = self.callCatchWarnings(
 
2018
            osutils.report_extension_load_failures)
2000
2019
        # it used to give a Python warning; it no longer does
2001
2020
        self.assertLength(0, warnings)
2002
2021
 
2085
2104
        termios = term_ios_feature.module
2086
2105
        # bug 63539 is about a termios without TIOCGWINSZ attribute
2087
2106
        try:
2088
 
            orig = termios.TIOCGWINSZ
 
2107
            termios.TIOCGWINSZ
2089
2108
        except AttributeError:
2090
2109
            # We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
2091
2110
            pass
2114
2133
    def test_copy_ownership_from_path(self):
2115
2134
        """copy_ownership_from_path test with specified src."""
2116
2135
        ownsrc = '/'
2117
 
        f = open('test_file', 'wt')
 
2136
        open('test_file', 'wt').close()
2118
2137
        osutils.copy_ownership_from_path('test_file', ownsrc)
2119
2138
 
2120
2139
        s = os.stat(ownsrc)
2124
2143
 
2125
2144
    def test_copy_ownership_nonesrc(self):
2126
2145
        """copy_ownership_from_path test with src=None."""
2127
 
        f = open('test_file', 'wt')
 
2146
        open('test_file', 'wt').close()
2128
2147
        # should use parent dir for permissions
2129
2148
        osutils.copy_ownership_from_path('test_file')
2130
2149
 
2153
2172
        self.overrideEnv('BRZ_TEST_PATH', '/home/\xa7test')
2154
2173
        self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
2155
2174
        self.assertEqual(u'/home/\xa7test',
2156
 
            osutils._posix_path_from_environ('BRZ_TEST_PATH'))
 
2175
                         osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2157
2176
        osutils._fs_enc = "iso8859-5"
2158
2177
        if PY3:
2159
2178
            # In Python 3, os.environ returns unicode.
2160
2179
            self.assertEqual(u'/home/\xa7test',
2161
 
                osutils._posix_path_from_environ('BRZ_TEST_PATH'))
 
2180
                             osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2162
2181
        else:
2163
2182
            self.assertEqual(u'/home/\u0407test',
2164
 
                osutils._posix_path_from_environ('BRZ_TEST_PATH'))
 
2183
                             osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2165
2184
            osutils._fs_enc = "utf-8"
2166
 
            self.assertRaises(errors.BadFilenameEncoding,
 
2185
            self.assertRaises(
 
2186
                errors.BadFilenameEncoding,
2167
2187
                osutils._posix_path_from_environ, 'BRZ_TEST_PATH')
2168
2188
 
2169
2189
 
2194
2214
            # In python 3, os.environ returns unicode
2195
2215
            self.assertEqual(u'/home/\xa7test', osutils._posix_get_home_dir())
2196
2216
        else:
2197
 
            self.assertEqual(u'/home/\u0407test', osutils._posix_get_home_dir())
 
2217
            self.assertEqual(u'/home/\u0407test',
 
2218
                             osutils._posix_get_home_dir())
2198
2219
            osutils._fs_enc = "utf-8"
2199
2220
            self.assertRaises(errors.BadFilenameEncoding,
2200
 
                osutils._posix_get_home_dir)
 
2221
                              osutils._posix_get_home_dir)
2201
2222
 
2202
2223
 
2203
2224
class TestGetuserUnicode(tests.TestCase):
2210
2231
        if sys.platform == "win32":
2211
2232
            # Disable use of platform calls on windows so envvar is used
2212
2233
            self.overrideAttr(win32utils, 'has_ctypes', False)
2213
 
            return 'USERNAME' # only variable used on windows
2214
 
        return 'LOGNAME' # first variable checked by getpass.getuser()
 
2234
            return 'USERNAME'  # only variable used on windows
 
2235
        return 'LOGNAME'  # first variable checked by getpass.getuser()
2215
2236
 
2216
2237
    def test_ascii_user(self):
2217
2238
        self.overrideEnv(self.envvar_to_override(), 'jrandom')
2268
2289
    def test_windows(self):
2269
2290
        if sys.platform != 'win32':
2270
2291
            raise tests.TestSkipped('test requires win32')
2271
 
        self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
 
2292
        self.assertTrue(osutils.find_executable_on_path(
 
2293
            'explorer') is not None)
2272
2294
        self.assertTrue(
2273
2295
            osutils.find_executable_on_path('explorer.exe') is not None)
2274
2296
        self.assertTrue(
2276
2298
        self.assertTrue(
2277
2299
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2278
2300
        self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2279
 
        
 
2301
 
2280
2302
    def test_windows_app_path(self):
2281
2303
        if sys.platform != 'win32':
2282
2304
            raise tests.TestSkipped('test requires win32')
2283
2305
        # Override PATH env var so that exe can only be found on App Path
2284
2306
        self.overrideEnv('PATH', '')
2285
2307
        # Internt Explorer is always registered in the App Path
2286
 
        self.assertTrue(osutils.find_executable_on_path('iexplore') is not None)
 
2308
        self.assertTrue(osutils.find_executable_on_path(
 
2309
            'iexplore') is not None)
2287
2310
 
2288
2311
    def test_other(self):
2289
2312
        if sys.platform == 'win32':