← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_osutils.py

Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_osutils.py
284
284
class TestSafeRevisionId(TestCase):
285
285
 
286
286
    def test_from_ascii_string(self):
287
 
        f = 'foobar'
288
 
        self.assertEqual('foobar', osutils.safe_revision_id(f))
289
 
        self.assertIs(osutils.safe_utf8(f), f)
 
287
        self.assertEqual('foobar', osutils.safe_revision_id('foobar'))
290
288
 
291
289
    def test_from_unicode_string_ascii_contents(self):
292
 
        self.assertEqual('bargam', osutils.safe_revision_id(u'bargam'))
 
290
        self.assertEqual('bargam',
 
291
                         osutils.safe_revision_id(u'bargam', warn=False))
 
292
 
 
293
    def test_from_unicode_deprecated(self):
 
294
        self.assertEqual('bargam',
 
295
            self.callDeprecated([osutils._revision_id_warning],
 
296
                                osutils.safe_revision_id, u'bargam'))
293
297
 
294
298
    def test_from_unicode_string_unicode_contents(self):
295
299
        self.assertEqual('bargam\xc2\xae',
296
 
                         osutils.safe_revision_id(u'bargam\xae'))
 
300
                         osutils.safe_revision_id(u'bargam\xae', warn=False))
297
301
 
298
302
    def test_from_utf8_string(self):
299
303
        self.assertEqual('foo\xc2\xae',
300
304
                         osutils.safe_revision_id('foo\xc2\xae'))
301
305
 
302
 
    def test_bad_utf8_string(self):
303
 
        # This check may eventually go away
304
 
        self.assertRaises(BzrBadParameterNotUnicode,
305
 
                          osutils.safe_revision_id, '\xbb\xbb')
306
 
 
307
306
    def test_none(self):
308
307
        """Currently, None is a valid revision_id"""
309
308
        self.assertEqual(None, osutils.safe_revision_id(None))
312
311
class TestSafeFileId(TestCase):
313
312
 
314
313
    def test_from_ascii_string(self):
315
 
        f = 'foobar'
316
 
        self.assertEqual('foobar', osutils.safe_file_id(f))
 
314
        self.assertEqual('foobar', osutils.safe_file_id('foobar'))
317
315
 
318
316
    def test_from_unicode_string_ascii_contents(self):
319
 
        self.assertEqual('bargam', osutils.safe_file_id(u'bargam'))
 
317
        self.assertEqual('bargam', osutils.safe_file_id(u'bargam', warn=False))
 
318
 
 
319
    def test_from_unicode_deprecated(self):
 
320
        self.assertEqual('bargam',
 
321
            self.callDeprecated([osutils._file_id_warning],
 
322
                                osutils.safe_file_id, u'bargam'))
320
323
 
321
324
    def test_from_unicode_string_unicode_contents(self):
322
325
        self.assertEqual('bargam\xc2\xae',
323
 
                         osutils.safe_file_id(u'bargam\xae'))
 
326
                         osutils.safe_file_id(u'bargam\xae', warn=False))
324
327
 
325
328
    def test_from_utf8_string(self):
326
329
        self.assertEqual('foo\xc2\xae',
327
330
                         osutils.safe_file_id('foo\xc2\xae'))
328
331
 
329
 
    def test_bad_utf8_string(self):
330
 
        # This check may eventually go away
331
 
        self.assertRaises(BzrBadParameterNotUnicode,
332
 
                          osutils.safe_file_id, '\xbb\xbb')
333
 
 
334
332
    def test_none(self):
335
333
        """Currently, None is a valid revision_id"""
336
334
        self.assertEqual(None, osutils.safe_file_id(None))
559
557
        self.assertEqual(expected_dirblocks[1:],
560
558
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
561
559
 
 
560
    def test__walkdirs_utf8(self):
 
561
        tree = [
 
562
            '.bzr',
 
563
            '0file',
 
564
            '1dir/',
 
565
            '1dir/0file',
 
566
            '1dir/1dir/',
 
567
            '2file'
 
568
            ]
 
569
        self.build_tree(tree)
 
570
        expected_dirblocks = [
 
571
                (('', '.'),
 
572
                 [('0file', '0file', 'file'),
 
573
                  ('1dir', '1dir', 'directory'),
 
574
                  ('2file', '2file', 'file'),
 
575
                 ]
 
576
                ),
 
577
                (('1dir', './1dir'),
 
578
                 [('1dir/0file', '0file', 'file'),
 
579
                  ('1dir/1dir', '1dir', 'directory'),
 
580
                 ]
 
581
                ),
 
582
                (('1dir/1dir', './1dir/1dir'),
 
583
                 [
 
584
                 ]
 
585
                ),
 
586
            ]
 
587
        result = []
 
588
        found_bzrdir = False
 
589
        for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
 
590
            if len(dirblock) and dirblock[0][1] == '.bzr':
 
591
                # this tests the filtering of selected paths
 
592
                found_bzrdir = True
 
593
                del dirblock[0]
 
594
            result.append((dirdetail, dirblock))
 
595
 
 
596
        self.assertTrue(found_bzrdir)
 
597
        self.assertEqual(expected_dirblocks,
 
598
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
599
        # you can search a subdir only, with a supplied prefix.
 
600
        result = []
 
601
        for dirblock in osutils.walkdirs('./1dir', '1dir'):
 
602
            result.append(dirblock)
 
603
        self.assertEqual(expected_dirblocks[1:],
 
604
            [(dirinfo, [line[0:3] for line in block]) for dirinfo, block in result])
 
605
 
 
606
    def _filter_out_stat(self, result):
 
607
        """Filter out the stat value from the walkdirs result"""
 
608
        for dirdetail, dirblock in result:
 
609
            new_dirblock = []
 
610
            for info in dirblock:
 
611
                # Ignore info[3] which is the stat
 
612
                new_dirblock.append((info[0], info[1], info[2], info[4]))
 
613
            dirblock[:] = new_dirblock
 
614
 
 
615
    def test_unicode_walkdirs(self):
 
616
        """Walkdirs should always return unicode paths."""
 
617
        name0 = u'0file-\xb6'
 
618
        name1 = u'1dir-\u062c\u0648'
 
619
        name2 = u'2file-\u0633'
 
620
        tree = [
 
621
            name0,
 
622
            name1 + '/',
 
623
            name1 + '/' + name0,
 
624
            name1 + '/' + name1 + '/',
 
625
            name2,
 
626
            ]
 
627
        try:
 
628
            self.build_tree(tree)
 
629
        except UnicodeError:
 
630
            raise TestSkipped('Could not represent Unicode chars'
 
631
                              ' in current encoding.')
 
632
        expected_dirblocks = [
 
633
                ((u'', u'.'),
 
634
                 [(name0, name0, 'file', './' + name0),
 
635
                  (name1, name1, 'directory', './' + name1),
 
636
                  (name2, name2, 'file', './' + name2),
 
637
                 ]
 
638
                ),
 
639
                ((name1, './' + name1),
 
640
                 [(name1 + '/' + name0, name0, 'file', './' + name1
 
641
                                                        + '/' + name0),
 
642
                  (name1 + '/' + name1, name1, 'directory', './' + name1
 
643
                                                            + '/' + name1),
 
644
                 ]
 
645
                ),
 
646
                ((name1 + '/' + name1, './' + name1 + '/' + name1),
 
647
                 [
 
648
                 ]
 
649
                ),
 
650
            ]
 
651
        result = list(osutils.walkdirs('.'))
 
652
        self._filter_out_stat(result)
 
653
        self.assertEqual(expected_dirblocks, result)
 
654
        result = list(osutils.walkdirs(u'./'+name1, name1))
 
655
        self._filter_out_stat(result)
 
656
        self.assertEqual(expected_dirblocks[1:], result)
 
657
 
 
658
    def test_unicode__walkdirs_utf8(self):
 
659
        """Walkdirs_utf8 should always return utf8 paths.
 
660
 
 
661
        The abspath portion might be in unicode or utf-8
 
662
        """
 
663
        name0 = u'0file-\xb6'
 
664
        name1 = u'1dir-\u062c\u0648'
 
665
        name2 = u'2file-\u0633'
 
666
        tree = [
 
667
            name0,
 
668
            name1 + '/',
 
669
            name1 + '/' + name0,
 
670
            name1 + '/' + name1 + '/',
 
671
            name2,
 
672
            ]
 
673
        try:
 
674
            self.build_tree(tree)
 
675
        except UnicodeError:
 
676
            raise TestSkipped('Could not represent Unicode chars'
 
677
                              ' in current encoding.')
 
678
        name0 = name0.encode('utf8')
 
679
        name1 = name1.encode('utf8')
 
680
        name2 = name2.encode('utf8')
 
681
 
 
682
        expected_dirblocks = [
 
683
                (('', '.'),
 
684
                 [(name0, name0, 'file', './' + name0),
 
685
                  (name1, name1, 'directory', './' + name1),
 
686
                  (name2, name2, 'file', './' + name2),
 
687
                 ]
 
688
                ),
 
689
                ((name1, './' + name1),
 
690
                 [(name1 + '/' + name0, name0, 'file', './' + name1
 
691
                                                        + '/' + name0),
 
692
                  (name1 + '/' + name1, name1, 'directory', './' + name1
 
693
                                                            + '/' + name1),
 
694
                 ]
 
695
                ),
 
696
                ((name1 + '/' + name1, './' + name1 + '/' + name1),
 
697
                 [
 
698
                 ]
 
699
                ),
 
700
            ]
 
701
        result = []
 
702
        # For ease in testing, if walkdirs_utf8 returns Unicode, assert that
 
703
        # all abspaths are Unicode, and encode them back into utf8.
 
704
        for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
 
705
            self.assertIsInstance(dirdetail[0], str)
 
706
            if isinstance(dirdetail[1], unicode):
 
707
                dirdetail[1] = dirdetail[1].encode('utf8')
 
708
                for info in dirblock:
 
709
                    self.assertIsInstance(info[4], unicode)
 
710
                    info[4] = info[4].encode('utf8')
 
711
            new_dirblock = []
 
712
            for info in dirblock:
 
713
                self.assertIsInstance(info[0], str)
 
714
                self.assertIsInstance(info[1], str)
 
715
                self.assertIsInstance(info[4], str)
 
716
                # Remove the stat information
 
717
                new_dirblock.append((info[0], info[1], info[2], info[4]))
 
718
            result.append((dirdetail, new_dirblock))
 
719
        self.assertEqual(expected_dirblocks, result)
 
720
 
 
721
    def test_unicode__walkdirs_unicode_to_utf8(self):
 
722
        """walkdirs_unicode_to_utf8 should be a safe fallback everywhere
 
723
 
 
724
        The abspath portion should be in unicode
 
725
        """
 
726
        name0u = u'0file-\xb6'
 
727
        name1u = u'1dir-\u062c\u0648'
 
728
        name2u = u'2file-\u0633'
 
729
        tree = [
 
730
            name0u,
 
731
            name1u + '/',
 
732
            name1u + '/' + name0u,
 
733
            name1u + '/' + name1u + '/',
 
734
            name2u,
 
735
            ]
 
736
        try:
 
737
            self.build_tree(tree)
 
738
        except UnicodeError:
 
739
            raise TestSkipped('Could not represent Unicode chars'
 
740
                              ' in current encoding.')
 
741
        name0 = name0u.encode('utf8')
 
742
        name1 = name1u.encode('utf8')
 
743
        name2 = name2u.encode('utf8')
 
744
 
 
745
        # All of the abspaths should be in unicode, all of the relative paths
 
746
        # should be in utf8
 
747
        expected_dirblocks = [
 
748
                (('', '.'),
 
749
                 [(name0, name0, 'file', './' + name0u),
 
750
                  (name1, name1, 'directory', './' + name1u),
 
751
                  (name2, name2, 'file', './' + name2u),
 
752
                 ]
 
753
                ),
 
754
                ((name1, './' + name1u),
 
755
                 [(name1 + '/' + name0, name0, 'file', './' + name1u
 
756
                                                        + '/' + name0u),
 
757
                  (name1 + '/' + name1, name1, 'directory', './' + name1u
 
758
                                                            + '/' + name1u),
 
759
                 ]
 
760
                ),
 
761
                ((name1 + '/' + name1, './' + name1u + '/' + name1u),
 
762
                 [
 
763
                 ]
 
764
                ),
 
765
            ]
 
766
        result = list(osutils._walkdirs_unicode_to_utf8('.'))
 
767
        self._filter_out_stat(result)
 
768
        self.assertEqual(expected_dirblocks, result)
 
769
 
562
770
    def assertPathCompare(self, path_less, path_greater):
563
771
        """check that path_less and path_greater compare correctly."""
564
772
        self.assertEqual(0, osutils.compare_paths_prefix_order(