← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_nonascii.py

Fix BzrDir.create_workingtree for NULL_REVISION

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_nonascii.py
17
17
"""Test that various operations work in a non-ASCII environment."""
18
18
 
19
19
import os
20
 
 
21
 
from bzrlib.tests import TestCaseInTempDir
22
 
from bzrlib.branch import Branch
23
 
 
24
 
 
25
 
class NonAsciiTest(TestCaseInTempDir):
 
20
import sys
 
21
from unicodedata import normalize
 
22
 
 
23
from bzrlib import osutils
 
24
from bzrlib.osutils import pathjoin
 
25
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
26
from bzrlib.workingtree import WorkingTree
 
27
 
 
28
 
 
29
class NonAsciiTest(TestCaseWithTransport):
26
30
 
27
31
    def test_add_in_nonascii_branch(self):
28
32
        """Test adding in a non-ASCII branch."""
29
33
        br_dir = u"\u1234"
30
34
        try:
31
 
            os.mkdir(br_dir)
32
 
            os.chdir(br_dir)
 
35
            wt = self.make_branch_and_tree(br_dir)
33
36
        except UnicodeEncodeError:
34
 
            self.log("filesystem can't accomodate nonascii names")
 
37
            raise TestSkipped("filesystem can't accomodate nonascii names")
35
38
            return
36
 
        br = Branch.initialize(u".")
37
 
        file("a", "w").write("hello")
38
 
        br.working_tree().add(["a"], ["a-id"])
 
39
        file(pathjoin(br_dir, "a"), "w").write("hello")
 
40
        wt.add(["a"], ["a-id"])
 
41
 
 
42
 
 
43
a_circle_c = u'\xe5'
 
44
a_circle_d = u'a\u030a'
 
45
a_dots_c = u'\xe4'
 
46
a_dots_d = u'a\u0308'
 
47
z_umlat_c = u'\u017d'
 
48
z_umlat_d = u'Z\u030c'
 
49
 
 
50
 
 
51
class TestNormalization(TestCase):
 
52
    """Verify that we have our normalizations correct."""
 
53
 
 
54
    def test_normalize(self):
 
55
        self.assertEqual(a_circle_d, normalize('NFKD', a_circle_c))
 
56
        self.assertEqual(a_circle_c, normalize('NFKC', a_circle_d))
 
57
        self.assertEqual(a_dots_d, normalize('NFKD', a_dots_c))
 
58
        self.assertEqual(a_dots_c, normalize('NFKC', a_dots_d))
 
59
        self.assertEqual(z_umlat_d, normalize('NFKD', z_umlat_c))
 
60
        self.assertEqual(z_umlat_c, normalize('NFKC', z_umlat_d))
 
61
 
 
62
 
 
63
class NormalizedFilename(TestCaseWithTransport):
 
64
    """Test normalized_filename and associated helpers"""
 
65
 
 
66
    def test__accessible_normalized_filename(self):
 
67
        anf = osutils._accessible_normalized_filename
 
68
        # normalized_filename should allow plain ascii strings
 
69
        # not just unicode strings
 
70
        self.assertEqual((u'ascii', True), anf('ascii'))
 
71
        self.assertEqual((a_circle_c, True), anf(a_circle_c))
 
72
        self.assertEqual((a_circle_c, True), anf(a_circle_d))
 
73
        self.assertEqual((a_dots_c, True), anf(a_dots_c))
 
74
        self.assertEqual((a_dots_c, True), anf(a_dots_d))
 
75
        self.assertEqual((z_umlat_c, True), anf(z_umlat_c))
 
76
        self.assertEqual((z_umlat_c, True), anf(z_umlat_d))
 
77
 
 
78
    def test__inaccessible_normalized_filename(self):
 
79
        inf = osutils._inaccessible_normalized_filename
 
80
        # normalized_filename should allow plain ascii strings
 
81
        # not just unicode strings
 
82
        self.assertEqual((u'ascii', True), inf('ascii'))
 
83
        self.assertEqual((a_circle_c, True), inf(a_circle_c))
 
84
        self.assertEqual((a_circle_c, False), inf(a_circle_d))
 
85
        self.assertEqual((a_dots_c, True), inf(a_dots_c))
 
86
        self.assertEqual((a_dots_c, False), inf(a_dots_d))
 
87
        self.assertEqual((z_umlat_c, True), inf(z_umlat_c))
 
88
        self.assertEqual((z_umlat_c, False), inf(z_umlat_d))
 
89
 
 
90
    def test_functions(self):
 
91
        if osutils.normalizes_filenames():
 
92
            self.assertEqual(osutils.normalized_filename,
 
93
                             osutils._accessible_normalized_filename)
 
94
        else:
 
95
            self.assertEqual(osutils.normalized_filename,
 
96
                             osutils._inaccessible_normalized_filename)
 
97
 
 
98
    def test_platform(self):
 
99
        # With FAT32 and certain encodings on win32
 
100
        # a_circle_c and a_dots_c actually map to the same file
 
101
        # adding a suffix kicks in the 'preserving but insensitive'
 
102
        # route, and maintains the right files
 
103
        files = [a_circle_c+'.1', a_dots_c+'.2', z_umlat_c+'.3']
 
104
        try:
 
105
            self.build_tree(files)
 
106
        except UnicodeError:
 
107
            raise TestSkipped("filesystem cannot create unicode files")
 
108
 
 
109
        if sys.platform == 'darwin':
 
110
            expected = sorted([a_circle_d+'.1', a_dots_d+'.2', z_umlat_d+'.3'])
 
111
        else:
 
112
            expected = sorted(files)
 
113
 
 
114
        present = sorted(os.listdir(u'.'))
 
115
        self.assertEqual(expected, present)
 
116
 
 
117
    def test_access_normalized(self):
 
118
        # We should always be able to access files created with 
 
119
        # normalized filenames
 
120
        # With FAT32 and certain encodings on win32
 
121
        # a_circle_c and a_dots_c actually map to the same file
 
122
        # adding a suffix kicks in the 'preserving but insensitive'
 
123
        # route, and maintains the right files
 
124
        files = [a_circle_c+'.1', a_dots_c+'.2', z_umlat_c+'.3']
 
125
        try:
 
126
            self.build_tree(files)
 
127
        except UnicodeError:
 
128
            raise TestSkipped("filesystem cannot create unicode files")
 
129
 
 
130
        for fname in files:
 
131
            # We should get an exception if we can't open the file at
 
132
            # this location.
 
133
            path, can_access = osutils.normalized_filename(fname)
 
134
 
 
135
            self.assertEqual(path, fname)
 
136
            self.assertTrue(can_access)
 
137
 
 
138
            f = open(path, 'rb')
 
139
            try:
 
140
                # Check the contents
 
141
                shouldbe = 'contents of %s%s' % (path.encode('utf8'),
 
142
                                                 os.linesep)
 
143
                actual = f.read()
 
144
            finally:
 
145
                f.close()
 
146
            self.assertEqual(shouldbe, actual, 
 
147
                             'contents of %s is incorrect: %r != %r'
 
148
                             % (path, shouldbe, actual))
 
149
 
 
150
    def test_access_non_normalized(self):
 
151
        # Sometimes we can access non-normalized files by their normalized
 
152
        # path, verify that normalized_filename returns the right info
 
153
        files = [a_circle_d+'.1', a_dots_d+'.2', z_umlat_d+'.3']
 
154
 
 
155
        try:
 
156
            self.build_tree(files)
 
157
        except UnicodeError:
 
158
            raise TestSkipped("filesystem cannot create unicode files")
 
159
 
 
160
        for fname in files:
 
161
            # We should get an exception if we can't open the file at
 
162
            # this location.
 
163
            path, can_access = osutils.normalized_filename(fname)
 
164
 
 
165
            self.assertNotEqual(path, fname)
 
166
 
 
167
            # We should always be able to access them from the name
 
168
            # they were created with
 
169
            f = open(fname, 'rb')
 
170
            f.close()
 
171
 
 
172
            # And normalized_filename sholud tell us correctly if we can
 
173
            # access them by an alternate name
 
174
            if can_access:
 
175
                f = open(path, 'rb')
 
176
                f.close()
 
177
            else:
 
178
                self.assertRaises(IOError, open, path, 'rb')