/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: 2018-11-16 23:15:15 UTC
  • mfrom: (7180 work)
  • mto: This revision was merged to the branch mainline in revision 7183.
  • Revision ID: jelmer@jelmer.uk-20181116231515-zqd2yn6kj8lfydyp
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='.')
1129
1137
            ]
1130
1138
        self.build_tree(tree)
1131
1139
        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
 
                ),
 
1140
            (('', '.'),
 
1141
             [('0file', '0file', 'file'),
 
1142
              ('1dir', '1dir', 'directory'),
 
1143
              ('2file', '2file', 'file'),
 
1144
              ]
 
1145
             ),
 
1146
            (('1dir', './1dir'),
 
1147
             [('1dir/0file', '0file', 'file'),
 
1148
              ('1dir/1dir', '1dir', 'directory'),
 
1149
              ]
 
1150
             ),
 
1151
            (('1dir/1dir', './1dir/1dir'),
 
1152
             [
 
1153
                ]
 
1154
             ),
1147
1155
            ]
1148
1156
        result = []
1149
1157
        found_bzrdir = False
1228
1236
            ]
1229
1237
        self.build_tree(tree)
1230
1238
        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
 
                ),
 
1239
            (('', '.'),
 
1240
             [('0file', '0file', 'file'),
 
1241
              ('1dir', '1dir', 'directory'),
 
1242
              ('2file', '2file', 'file'),
 
1243
              ]
 
1244
             ),
 
1245
            (('1dir', './1dir'),
 
1246
             [('1dir/0file', '0file', 'file'),
 
1247
              ('1dir/1dir', '1dir', 'directory'),
 
1248
              ]
 
1249
             ),
 
1250
            (('1dir/1dir', './1dir/1dir'),
 
1251
             [
 
1252
                ]
 
1253
             ),
1246
1254
            ]
1247
1255
        result = []
1248
1256
        found_bzrdir = False
1251
1259
                # this tests the filtering of selected paths
1252
1260
                found_bzrdir = True
1253
1261
                del dirblock[0]
1254
 
            dirdetail = (dirdetail[0].decode('utf-8'), osutils.safe_unicode(dirdetail[1]))
 
1262
            dirdetail = (dirdetail[0].decode('utf-8'),
 
1263
                         osutils.safe_unicode(dirdetail[1]))
1255
1264
            dirblock = [
1256
 
                    (entry[0].decode('utf-8'), entry[1].decode('utf-8'), entry[2])
1257
 
                    for entry in dirblock]
 
1265
                (entry[0].decode('utf-8'), entry[1].decode('utf-8'), entry[2])
 
1266
                for entry in dirblock]
1258
1267
            result.append((dirdetail, dirblock))
1259
1268
 
1260
1269
        self.assertTrue(found_bzrdir)
1327
1336
            ]
1328
1337
        self.build_tree(tree)
1329
1338
        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
 
                ),
 
1339
            ((u'', u'.'),
 
1340
             [(name0, name0, 'file', './' + name0),
 
1341
              (name1, name1, 'directory', './' + name1),
 
1342
              (name2, name2, 'file', './' + name2),
 
1343
              ]
 
1344
             ),
 
1345
            ((name1, './' + name1),
 
1346
             [(name1 + '/' + name0, name0, 'file', './' + name1
 
1347
               + '/' + name0),
 
1348
              (name1 + '/' + name1, name1, 'directory', './' + name1
 
1349
               + '/' + name1),
 
1350
              ]
 
1351
             ),
 
1352
            ((name1 + '/' + name1, './' + name1 + '/' + name1),
 
1353
             [
 
1354
                ]
 
1355
             ),
1347
1356
            ]
1348
1357
        result = list(osutils.walkdirs('.'))
1349
1358
        self._filter_out_stat(result)
1350
1359
        self.assertEqual(expected_dirblocks, result)
1351
 
        result = list(osutils.walkdirs(u'./'+name1, name1))
 
1360
        result = list(osutils.walkdirs(u'./' + name1, name1))
1352
1361
        self._filter_out_stat(result)
1353
1362
        self.assertEqual(expected_dirblocks[1:], result)
1354
1363
 
1374
1383
        name2 = name2.encode('utf8')
1375
1384
 
1376
1385
        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
 
                ),
 
1386
            ((b'', b'.'),
 
1387
             [(name0, name0, 'file', b'./' + name0),
 
1388
              (name1, name1, 'directory', b'./' + name1),
 
1389
              (name2, name2, 'file', b'./' + name2),
 
1390
              ]
 
1391
             ),
 
1392
            ((name1, b'./' + name1),
 
1393
             [(name1 + b'/' + name0, name0, 'file', b'./' + name1
 
1394
               + b'/' + name0),
 
1395
              (name1 + b'/' + name1, name1, 'directory', b'./' + name1
 
1396
               + b'/' + name1),
 
1397
              ]
 
1398
             ),
 
1399
            ((name1 + b'/' + name1, b'./' + name1 + b'/' + name1),
 
1400
             [
 
1401
                ]
 
1402
             ),
1394
1403
            ]
1395
1404
        result = []
1396
1405
        # For ease in testing, if walkdirs_utf8 returns Unicode, assert that
1441
1450
        # All of the abspaths should be in unicode, all of the relative paths
1442
1451
        # should be in utf8
1443
1452
        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
 
                ),
 
1453
            ((b'', '.'),
 
1454
             [(name0, name0, 'file', './' + name0u),
 
1455
              (name1, name1, 'directory', './' + name1u),
 
1456
              (name2, name2, 'file', './' + name2u),
 
1457
              ]
 
1458
             ),
 
1459
            ((name1, './' + name1u),
 
1460
             [(name1 + b'/' + name0, name0, 'file', './' + name1u
 
1461
               + '/' + name0u),
 
1462
              (name1 + b'/' + name1, name1, 'directory', './' + name1u
 
1463
               + '/' + name1u),
 
1464
              ]
 
1465
             ),
 
1466
            ((name1 + b'/' + name1, './' + name1u + '/' + name1u),
 
1467
             [
 
1468
                ]
 
1469
             ),
1461
1470
            ]
1462
1471
        result = list(osutils._walkdirs_utf8('.'))
1463
1472
        self._filter_out_stat(result)
1487
1496
        # All of the abspaths should be in unicode, all of the relative paths
1488
1497
        # should be in utf8
1489
1498
        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
 
                ),
 
1499
            (('', '.'),
 
1500
             [(name0, name0, 'file', './' + name0u),
 
1501
              (name1, name1, 'directory', './' + name1u),
 
1502
              (name2, name2, 'file', './' + name2u),
 
1503
              ]
 
1504
             ),
 
1505
            ((name1, './' + name1u),
 
1506
             [(name1 + '/' + name0, name0, 'file', './' + name1u
 
1507
               + '/' + name0u),
 
1508
              (name1 + '/' + name1, name1, 'directory', './' + name1u
 
1509
               + '/' + name1u),
 
1510
              ]
 
1511
             ),
 
1512
            ((name1 + '/' + name1, './' + name1u + '/' + name1u),
 
1513
             [
 
1514
                ]
 
1515
             ),
1507
1516
            ]
1508
1517
        result = list(osutils._walkdirs_utf8(u'.'))
1509
1518
        self._filter_out_stat(result)
1659
1668
    def test_copy_tree_handlers(self):
1660
1669
        processed_files = []
1661
1670
        processed_links = []
 
1671
 
1662
1672
        def file_handler(from_path, to_path):
1663
1673
            processed_files.append(('f', from_path, to_path))
 
1674
 
1664
1675
        def dir_handler(from_path, to_path):
1665
1676
            processed_files.append(('d', from_path, to_path))
 
1677
 
1666
1678
        def link_handler(from_path, to_path):
1667
1679
            processed_links.append((from_path, to_path))
1668
1680
        handlers = {'file': file_handler,
1669
1681
                    'directory': dir_handler,
1670
1682
                    'symlink': link_handler,
1671
 
                   }
 
1683
                    }
1672
1684
 
1673
1685
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
1674
1686
        if osutils.has_symlinks():
1679
1691
                          ('f', 'source/a', 'target/a'),
1680
1692
                          ('d', 'source/b', 'target/b'),
1681
1693
                          ('f', 'source/b/c', 'target/b/c'),
1682
 
                         ], processed_files)
 
1694
                          ], processed_files)
1683
1695
        self.assertPathDoesNotExist('target')
1684
1696
        if osutils.has_symlinks():
1685
1697
            self.assertEqual([('source/lnk', 'target/lnk')], processed_links)
1694
1706
        self.assertEqual(None, os.environ.get('BRZ_TEST_ENV_VAR'),
1695
1707
                         'Environment was not cleaned up properly.'
1696
1708
                         ' Variable BRZ_TEST_ENV_VAR should not exist.')
 
1709
 
1697
1710
        def cleanup():
1698
1711
            if 'BRZ_TEST_ENV_VAR' in os.environ:
1699
1712
                del os.environ['BRZ_TEST_ENV_VAR']
1723
1736
                'Cannot find a unicode character that works in encoding %s'
1724
1737
                % (osutils.get_user_encoding(),))
1725
1738
 
1726
 
        old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', uni_val)
 
1739
        osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', uni_val)
1727
1740
        if PY3:
1728
1741
            self.assertEqual(uni_val, os.environ.get('BRZ_TEST_ENV_VAR'))
1729
1742
        else:
1785
1798
        self.assertContainsRe(text, "class TextUIFactory")
1786
1799
        # test unsupported package
1787
1800
        self.assertRaises(errors.BzrError, osutils.resource_string, 'zzzz',
1788
 
            'yyy.xx')
 
1801
                          'yyy.xx')
1789
1802
        # test unknown resource
1790
1803
        self.assertRaises(IOError, osutils.resource_string, 'breezy', 'yyy.xx')
1791
1804
 
1812
1825
            '2file'
1813
1826
            ]
1814
1827
        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
 
                ),
 
1828
            ((b'', '.'),
 
1829
             [(b'0file', b'0file', 'file', './0file'),
 
1830
              (b'1dir', b'1dir', 'directory', './1dir'),
 
1831
              (b'2file', b'2file', 'file', './2file'),
 
1832
              ]
 
1833
             ),
 
1834
            ((b'1dir', './1dir'),
 
1835
             [(b'1dir/0file', b'0file', 'file', './1dir/0file'),
 
1836
              (b'1dir/1dir', b'1dir', 'directory', './1dir/1dir'),
 
1837
              ]
 
1838
             ),
 
1839
            ((b'1dir/1dir', './1dir/1dir'),
 
1840
             [
 
1841
                ]
 
1842
             ),
1830
1843
            ]
1831
1844
        return tree, expected_dirblocks
1832
1845
 
1836
1849
        result = list(osutils._walkdirs_utf8('.'))
1837
1850
        # Filter out stat and abspath
1838
1851
        self.assertEqual(expected_dirblocks,
1839
 
                self._filter_out(result))
 
1852
                         self._filter_out(result))
1840
1853
 
1841
1854
    def test_walk_sub_dir(self):
1842
1855
        tree, expected_dirblocks = self._get_ascii_tree()
1845
1858
        result = list(osutils._walkdirs_utf8(b'./1dir', b'1dir'))
1846
1859
        # Filter out stat and abspath
1847
1860
        self.assertEqual(expected_dirblocks[1:],
1848
 
                self._filter_out(result))
 
1861
                         self._filter_out(result))
1849
1862
 
1850
1863
    def _get_unicode_tree(self):
1851
1864
        name0u = u'0file-\xb6'
1862
1875
        name1 = name1u.encode('UTF-8')
1863
1876
        name2 = name2u.encode('UTF-8')
1864
1877
        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
 
                ),
 
1878
            ((b'', '.'),
 
1879
             [(name0, name0, 'file', './' + name0u),
 
1880
              (name1, name1, 'directory', './' + name1u),
 
1881
              (name2, name2, 'file', './' + name2u),
 
1882
              ]
 
1883
             ),
 
1884
            ((name1, './' + name1u),
 
1885
             [(name1 + b'/' + name0, name0, 'file', './' + name1u
 
1886
               + '/' + name0u),
 
1887
              (name1 + b'/' + name1, name1, 'directory', './' + name1u
 
1888
               + '/' + name1u),
 
1889
              ]
 
1890
             ),
 
1891
            ((name1 + b'/' + name1, './' + name1u + '/' + name1u),
 
1892
             [
 
1893
                ]
 
1894
             ),
1882
1895
            ]
1883
1896
        return tree, expected_dirblocks
1884
1897
 
1892
1905
            dirinfo = (dirinfo[0], self._native_to_unicode(dirinfo[1]))
1893
1906
            details = []
1894
1907
            for line in block:
1895
 
                details.append(line[0:3] + (self._native_to_unicode(line[4]), ))
 
1908
                details.append(
 
1909
                    line[0:3] + (self._native_to_unicode(line[4]), ))
1896
1910
            filtered_dirblocks.append((dirinfo, details))
1897
1911
        return filtered_dirblocks
1898
1912
 
1909
1923
        target = u'target\N{Euro Sign}'
1910
1924
        link_name = u'l\N{Euro Sign}nk'
1911
1925
        os.symlink(target, link_name)
1912
 
        target_utf8 = target.encode('UTF-8')
1913
1926
        link_name_utf8 = link_name.encode('UTF-8')
1914
1927
        expected_dirblocks = [
1915
 
                ((b'', '.'),
1916
 
                 [(link_name_utf8, link_name_utf8,
1917
 
                   'symlink', './' + link_name),],
1918
 
                 )]
 
1928
            ((b'', '.'),
 
1929
             [(link_name_utf8, link_name_utf8,
 
1930
               'symlink', './' + link_name), ],
 
1931
             )]
1919
1932
        result = list(osutils._walkdirs_utf8('.'))
1920
1933
        self.assertEqual(expected_dirblocks, self._filter_out(result))
1921
1934
 
1929
1942
    But prior python versions failed to properly encode the passed unicode
1930
1943
    string.
1931
1944
    """
1932
 
    _test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]
 
1945
    _test_needs_features = [features.SymlinkFeature,
 
1946
                            features.UnicodeFilenameFeature]
1933
1947
 
1934
1948
    def setUp(self):
1935
1949
        super(tests.TestCaseInTempDir, self).setUp()
1938
1952
        os.symlink(self.target, self.link)
1939
1953
 
1940
1954
    def test_os_readlink_link_encoding(self):
1941
 
        self.assertEqual(self.target,  os.readlink(self.link))
 
1955
        self.assertEqual(self.target, os.readlink(self.link))
1942
1956
 
1943
1957
    def test_os_readlink_link_decoding(self):
1944
1958
        self.assertEqual(self.target.encode(osutils._fs_enc),
1945
 
                          os.readlink(self.link.encode(osutils._fs_enc)))
 
1959
                         os.readlink(self.link.encode(osutils._fs_enc)))
1946
1960
 
1947
1961
 
1948
1962
class TestConcurrency(tests.TestCase):
1975
1989
 
1976
1990
    def _try_loading(self):
1977
1991
        try:
1978
 
            import breezy._fictional_extension_py
 
1992
            import breezy._fictional_extension_py  # noqa: F401
1979
1993
        except ImportError as e:
1980
1994
            osutils.failed_to_load_extension(e)
1981
1995
            return True
1988
2002
        self._try_loading()
1989
2003
        self.assertLength(1, osutils._extension_load_failures)
1990
2004
        if PY3:
1991
 
            self.assertEqual(osutils._extension_load_failures[0],
 
2005
            self.assertEqual(
 
2006
                osutils._extension_load_failures[0],
1992
2007
                "No module named 'breezy._fictional_extension_py'")
1993
2008
        else:
1994
2009
            self.assertEqual(osutils._extension_load_failures[0],
1995
 
                "No module named _fictional_extension_py")
 
2010
                             "No module named _fictional_extension_py")
1996
2011
 
1997
2012
    def test_report_extension_load_failures_no_warning(self):
1998
2013
        self.assertTrue(self._try_loading())
1999
 
        warnings, result = self.callCatchWarnings(osutils.report_extension_load_failures)
 
2014
        warnings, result = self.callCatchWarnings(
 
2015
            osutils.report_extension_load_failures)
2000
2016
        # it used to give a Python warning; it no longer does
2001
2017
        self.assertLength(0, warnings)
2002
2018
 
2085
2101
        termios = term_ios_feature.module
2086
2102
        # bug 63539 is about a termios without TIOCGWINSZ attribute
2087
2103
        try:
2088
 
            orig = termios.TIOCGWINSZ
 
2104
            termios.TIOCGWINSZ
2089
2105
        except AttributeError:
2090
2106
            # We won't remove TIOCGWINSZ, because it doesn't exist anyway :)
2091
2107
            pass
2114
2130
    def test_copy_ownership_from_path(self):
2115
2131
        """copy_ownership_from_path test with specified src."""
2116
2132
        ownsrc = '/'
2117
 
        f = open('test_file', 'wt')
 
2133
        open('test_file', 'wt').close()
2118
2134
        osutils.copy_ownership_from_path('test_file', ownsrc)
2119
2135
 
2120
2136
        s = os.stat(ownsrc)
2124
2140
 
2125
2141
    def test_copy_ownership_nonesrc(self):
2126
2142
        """copy_ownership_from_path test with src=None."""
2127
 
        f = open('test_file', 'wt')
 
2143
        open('test_file', 'wt').close()
2128
2144
        # should use parent dir for permissions
2129
2145
        osutils.copy_ownership_from_path('test_file')
2130
2146
 
2153
2169
        self.overrideEnv('BRZ_TEST_PATH', '/home/\xa7test')
2154
2170
        self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
2155
2171
        self.assertEqual(u'/home/\xa7test',
2156
 
            osutils._posix_path_from_environ('BRZ_TEST_PATH'))
 
2172
                         osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2157
2173
        osutils._fs_enc = "iso8859-5"
2158
2174
        if PY3:
2159
2175
            # In Python 3, os.environ returns unicode.
2160
2176
            self.assertEqual(u'/home/\xa7test',
2161
 
                osutils._posix_path_from_environ('BRZ_TEST_PATH'))
 
2177
                             osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2162
2178
        else:
2163
2179
            self.assertEqual(u'/home/\u0407test',
2164
 
                osutils._posix_path_from_environ('BRZ_TEST_PATH'))
 
2180
                             osutils._posix_path_from_environ('BRZ_TEST_PATH'))
2165
2181
            osutils._fs_enc = "utf-8"
2166
 
            self.assertRaises(errors.BadFilenameEncoding,
 
2182
            self.assertRaises(
 
2183
                errors.BadFilenameEncoding,
2167
2184
                osutils._posix_path_from_environ, 'BRZ_TEST_PATH')
2168
2185
 
2169
2186
 
2194
2211
            # In python 3, os.environ returns unicode
2195
2212
            self.assertEqual(u'/home/\xa7test', osutils._posix_get_home_dir())
2196
2213
        else:
2197
 
            self.assertEqual(u'/home/\u0407test', osutils._posix_get_home_dir())
 
2214
            self.assertEqual(u'/home/\u0407test',
 
2215
                             osutils._posix_get_home_dir())
2198
2216
            osutils._fs_enc = "utf-8"
2199
2217
            self.assertRaises(errors.BadFilenameEncoding,
2200
 
                osutils._posix_get_home_dir)
 
2218
                              osutils._posix_get_home_dir)
2201
2219
 
2202
2220
 
2203
2221
class TestGetuserUnicode(tests.TestCase):
2210
2228
        if sys.platform == "win32":
2211
2229
            # Disable use of platform calls on windows so envvar is used
2212
2230
            self.overrideAttr(win32utils, 'has_ctypes', False)
2213
 
            return 'USERNAME' # only variable used on windows
2214
 
        return 'LOGNAME' # first variable checked by getpass.getuser()
 
2231
            return 'USERNAME'  # only variable used on windows
 
2232
        return 'LOGNAME'  # first variable checked by getpass.getuser()
2215
2233
 
2216
2234
    def test_ascii_user(self):
2217
2235
        self.overrideEnv(self.envvar_to_override(), 'jrandom')
2268
2286
    def test_windows(self):
2269
2287
        if sys.platform != 'win32':
2270
2288
            raise tests.TestSkipped('test requires win32')
2271
 
        self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
 
2289
        self.assertTrue(osutils.find_executable_on_path(
 
2290
            'explorer') is not None)
2272
2291
        self.assertTrue(
2273
2292
            osutils.find_executable_on_path('explorer.exe') is not None)
2274
2293
        self.assertTrue(
2276
2295
        self.assertTrue(
2277
2296
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2278
2297
        self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2279
 
        
 
2298
 
2280
2299
    def test_windows_app_path(self):
2281
2300
        if sys.platform != 'win32':
2282
2301
            raise tests.TestSkipped('test requires win32')
2283
2302
        # Override PATH env var so that exe can only be found on App Path
2284
2303
        self.overrideEnv('PATH', '')
2285
2304
        # Internt Explorer is always registered in the App Path
2286
 
        self.assertTrue(osutils.find_executable_on_path('iexplore') is not None)
 
2305
        self.assertTrue(osutils.find_executable_on_path(
 
2306
            'iexplore') is not None)
2287
2307
 
2288
2308
    def test_other(self):
2289
2309
        if sys.platform == 'win32':