/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-11 04:08:32 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181111040832-nsljjynzzwmznf3h
Run autopep8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_osutils.py
60
60
        except ImportError:
61
61
            return False
62
62
 
 
63
 
63
64
UTF8DirReaderFeature = _UTF8DirReaderFeature('breezy._readdir_pyx')
64
65
 
65
66
term_ios_feature = features.ModuleAvailableFeature('termios')
314
315
                raise
315
316
        else:
316
317
            self.assertEqual(
317
 
                    'chardev',
318
 
                    osutils.file_kind(os.path.realpath('/dev/null')))
 
318
                'chardev',
 
319
                osutils.file_kind(os.path.realpath('/dev/null')))
319
320
 
320
321
        mkfifo = getattr(os, 'mkfifo', None)
321
322
        if mkfifo:
405
406
 
406
407
    def test_format_date(self):
407
408
        self.assertRaises(osutils.UnsupportedTimezoneFormat,
408
 
            osutils.format_date, 0, timezone='foo')
 
409
                          osutils.format_date, 0, timezone='foo')
409
410
        self.assertIsInstance(osutils.format_date(0), str)
410
411
        self.assertIsInstance(osutils.format_local_date(0), text_type)
411
412
        # Testing for the actual value of the local weekday without
415
416
 
416
417
    def test_format_date_with_offset_in_original_timezone(self):
417
418
        self.assertEqual("Thu 1970-01-01 00:00:00 +0000",
418
 
            osutils.format_date_with_offset_in_original_timezone(0))
 
419
                         osutils.format_date_with_offset_in_original_timezone(0))
419
420
        self.assertEqual("Fri 1970-01-02 03:46:40 +0000",
420
 
            osutils.format_date_with_offset_in_original_timezone(100000))
 
421
                         osutils.format_date_with_offset_in_original_timezone(100000))
421
422
        self.assertEqual("Fri 1970-01-02 05:46:40 +0200",
422
 
            osutils.format_date_with_offset_in_original_timezone(100000, 7200))
 
423
                         osutils.format_date_with_offset_in_original_timezone(100000, 7200))
423
424
 
424
425
    def test_local_time_offset(self):
425
426
        """Test that local_time_offset() returns a sane value."""
619
620
 
620
621
        # read (max // 2) bytes and verify read size wasn't affected
621
622
        num_bytes_to_read = self.block_size // 2
622
 
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
623
        osutils.pumpfile(from_file, to_file,
 
624
                         num_bytes_to_read, self.block_size)
623
625
        self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
624
626
        self.assertEqual(from_file.get_read_count(), 1)
625
627
 
626
628
        # read (max) bytes and verify read size wasn't affected
627
629
        num_bytes_to_read = self.block_size
628
630
        from_file.reset_read_count()
629
 
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
631
        osutils.pumpfile(from_file, to_file,
 
632
                         num_bytes_to_read, self.block_size)
630
633
        self.assertEqual(from_file.get_max_read_size(), num_bytes_to_read)
631
634
        self.assertEqual(from_file.get_read_count(), 1)
632
635
 
633
636
        # read (max + 1) bytes and verify read size was limited
634
637
        num_bytes_to_read = self.block_size + 1
635
638
        from_file.reset_read_count()
636
 
        osutils.pumpfile(from_file, to_file, num_bytes_to_read, self.block_size)
 
639
        osutils.pumpfile(from_file, to_file,
 
640
                         num_bytes_to_read, self.block_size)
637
641
        self.assertEqual(from_file.get_max_read_size(), self.block_size)
638
642
        self.assertEqual(from_file.get_read_count(), 2)
639
643
 
640
644
        # finish reading the rest of the data
641
645
        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)
 
646
        osutils.pumpfile(from_file, to_file,
 
647
                         num_bytes_to_read, self.block_size)
643
648
 
644
649
        # report error if the data wasn't equal (we only report the size due
645
650
        # to the length of the data)
712
717
 
713
718
    def test_report_activity(self):
714
719
        activity = []
 
720
 
715
721
        def log_activity(length, direction):
716
722
            activity.append((length, direction))
717
723
        from_file = BytesIO(self.test_data)
735
741
        del activity[:]
736
742
        osutils.pumpfile(from_file, to_file, buff_size=500, read_length=1028,
737
743
                         report_activity=log_activity, direction='read')
738
 
        self.assertEqual([(500, 'read'), (500, 'read'), (28, 'read')], activity)
739
 
 
 
744
        self.assertEqual(
 
745
            [(500, 'read'), (500, 'read'), (28, 'read')], activity)
740
746
 
741
747
 
742
748
class TestPumpStringFile(tests.TestCase):
833
839
 
834
840
    def test_from_unicode_string_unicode_contents(self):
835
841
        self.assertRaises(TypeError,
836
 
                         osutils.safe_revision_id, u'bargam\xae')
 
842
                          osutils.safe_revision_id, u'bargam\xae')
837
843
 
838
844
    def test_from_utf8_string(self):
839
845
        self.assertEqual(b'foo\xc2\xae',
871
877
        class DisconnectedSocket(object):
872
878
            def __init__(self, err):
873
879
                self.err = err
 
880
 
874
881
            def send(self, content):
875
882
                raise self.err
 
883
 
876
884
            def close(self):
877
885
                pass
878
886
        # All of these should be treated as ConnectionReset
883
891
        for err in errs:
884
892
            sock = DisconnectedSocket(err)
885
893
            self.assertRaises(errors.ConnectionReset,
886
 
                osutils.send_all, sock, b'some more content')
 
894
                              osutils.send_all, sock, b'some more content')
887
895
 
888
896
    def test_send_with_no_progress(self):
889
897
        # See https://bugs.launchpad.net/bzr/+bug/1047309
892
900
        class NoSendingSocket(object):
893
901
            def __init__(self):
894
902
                self.call_count = 0
 
903
 
895
904
            def send(self, bytes):
896
905
                self.call_count += 1
897
906
                if self.call_count > 100:
910
919
 
911
920
    def test_normpath(self):
912
921
        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'))
 
922
        self.assertEqual(
 
923
            '/etc/shadow', osutils._posix_normpath('//etc/shadow'))
 
924
        self.assertEqual(
 
925
            '/etc/shadow', osutils._posix_normpath('///etc/shadow'))
915
926
 
916
927
 
917
928
class TestWin32Funcs(tests.TestCase):
986
997
 
987
998
    def test_minimum_path_selection(self):
988
999
        self.assertEqual(set(),
989
 
            osutils.minimum_path_selection([]))
 
1000
                         osutils.minimum_path_selection([]))
990
1001
        self.assertEqual({'a'},
991
 
            osutils.minimum_path_selection(['a']))
 
1002
                         osutils.minimum_path_selection(['a']))
992
1003
        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']))
 
1004
                         osutils.minimum_path_selection(['a', 'b']))
 
1005
        self.assertEqual({'a/', 'b'},
 
1006
                         osutils.minimum_path_selection(['a/', 'b']))
 
1007
        self.assertEqual({'a/', 'b'},
 
1008
                         osutils.minimum_path_selection(['a/c', 'a/', 'b']))
998
1009
        self.assertEqual({'a-b', 'a', 'a0b'},
999
 
            osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
 
1010
                         osutils.minimum_path_selection(['a-b', 'a/b', 'a0b', 'a']))
1000
1011
 
1001
1012
    def test_mkdtemp(self):
1002
1013
        tmpdir = osutils._win32_mkdtemp(dir='.')
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']
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
 
1912
1929
        target_utf8 = target.encode('UTF-8')
1913
1930
        link_name_utf8 = link_name.encode('UTF-8')
1914
1931
        expected_dirblocks = [
1915
 
                ((b'', '.'),
1916
 
                 [(link_name_utf8, link_name_utf8,
1917
 
                   'symlink', './' + link_name),],
1918
 
                 )]
 
1932
            ((b'', '.'),
 
1933
             [(link_name_utf8, link_name_utf8,
 
1934
               'symlink', './' + link_name), ],
 
1935
             )]
1919
1936
        result = list(osutils._walkdirs_utf8('.'))
1920
1937
        self.assertEqual(expected_dirblocks, self._filter_out(result))
1921
1938
 
1929
1946
    But prior python versions failed to properly encode the passed unicode
1930
1947
    string.
1931
1948
    """
1932
 
    _test_needs_features = [features.SymlinkFeature, features.UnicodeFilenameFeature]
 
1949
    _test_needs_features = [features.SymlinkFeature,
 
1950
                            features.UnicodeFilenameFeature]
1933
1951
 
1934
1952
    def setUp(self):
1935
1953
        super(tests.TestCaseInTempDir, self).setUp()
1938
1956
        os.symlink(self.target, self.link)
1939
1957
 
1940
1958
    def test_os_readlink_link_encoding(self):
1941
 
        self.assertEqual(self.target,  os.readlink(self.link))
 
1959
        self.assertEqual(self.target, os.readlink(self.link))
1942
1960
 
1943
1961
    def test_os_readlink_link_decoding(self):
1944
1962
        self.assertEqual(self.target.encode(osutils._fs_enc),
1945
 
                          os.readlink(self.link.encode(osutils._fs_enc)))
 
1963
                         os.readlink(self.link.encode(osutils._fs_enc)))
1946
1964
 
1947
1965
 
1948
1966
class TestConcurrency(tests.TestCase):
1989
2007
        self.assertLength(1, osutils._extension_load_failures)
1990
2008
        if PY3:
1991
2009
            self.assertEqual(osutils._extension_load_failures[0],
1992
 
                "No module named 'breezy._fictional_extension_py'")
 
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
 
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
2185
            self.assertRaises(errors.BadFilenameEncoding,
2167
 
                osutils._posix_path_from_environ, 'BRZ_TEST_PATH')
 
2186
                              osutils._posix_path_from_environ, 'BRZ_TEST_PATH')
2168
2187
 
2169
2188
 
2170
2189
class TestGetHomeDir(tests.TestCase):
2194
2213
            # In python 3, os.environ returns unicode
2195
2214
            self.assertEqual(u'/home/\xa7test', osutils._posix_get_home_dir())
2196
2215
        else:
2197
 
            self.assertEqual(u'/home/\u0407test', osutils._posix_get_home_dir())
 
2216
            self.assertEqual(u'/home/\u0407test',
 
2217
                             osutils._posix_get_home_dir())
2198
2218
            osutils._fs_enc = "utf-8"
2199
2219
            self.assertRaises(errors.BadFilenameEncoding,
2200
 
                osutils._posix_get_home_dir)
 
2220
                              osutils._posix_get_home_dir)
2201
2221
 
2202
2222
 
2203
2223
class TestGetuserUnicode(tests.TestCase):
2210
2230
        if sys.platform == "win32":
2211
2231
            # Disable use of platform calls on windows so envvar is used
2212
2232
            self.overrideAttr(win32utils, 'has_ctypes', False)
2213
 
            return 'USERNAME' # only variable used on windows
2214
 
        return 'LOGNAME' # first variable checked by getpass.getuser()
 
2233
            return 'USERNAME'  # only variable used on windows
 
2234
        return 'LOGNAME'  # first variable checked by getpass.getuser()
2215
2235
 
2216
2236
    def test_ascii_user(self):
2217
2237
        self.overrideEnv(self.envvar_to_override(), 'jrandom')
2268
2288
    def test_windows(self):
2269
2289
        if sys.platform != 'win32':
2270
2290
            raise tests.TestSkipped('test requires win32')
2271
 
        self.assertTrue(osutils.find_executable_on_path('explorer') is not None)
 
2291
        self.assertTrue(osutils.find_executable_on_path(
 
2292
            'explorer') is not None)
2272
2293
        self.assertTrue(
2273
2294
            osutils.find_executable_on_path('explorer.exe') is not None)
2274
2295
        self.assertTrue(
2276
2297
        self.assertTrue(
2277
2298
            osutils.find_executable_on_path('THIS SHOULD NOT EXIST') is None)
2278
2299
        self.assertTrue(osutils.find_executable_on_path('file.txt') is None)
2279
 
        
 
2300
 
2280
2301
    def test_windows_app_path(self):
2281
2302
        if sys.platform != 'win32':
2282
2303
            raise tests.TestSkipped('test requires win32')
2283
2304
        # Override PATH env var so that exe can only be found on App Path
2284
2305
        self.overrideEnv('PATH', '')
2285
2306
        # Internt Explorer is always registered in the App Path
2286
 
        self.assertTrue(osutils.find_executable_on_path('iexplore') is not None)
 
2307
        self.assertTrue(osutils.find_executable_on_path(
 
2308
            'iexplore') is not None)
2287
2309
 
2288
2310
    def test_other(self):
2289
2311
        if sys.platform == 'win32':