← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_nonascii.py

  • Committer: Robey Pointer
  • Date: 2006-07-01 19:03:33 UTC
  • mfrom: (1829 +trunk)
  • mto: This revision was merged to the branch mainline in revision 1830.
  • Revision ID: robey@lag.net-20060701190333-f58465aec4bd3412
merge from bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_nonascii.py
1
 
# Copyright (C) 2005, 2006, 2008, 2009, 2011 Canonical Ltd
 
1
# Copyright (C) 2005 by Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Test that various operations work in a non-ASCII environment."""
18
18
 
20
20
import sys
21
21
from unicodedata import normalize
22
22
 
23
 
from bzrlib import osutils
24
 
from bzrlib.osutils import pathjoin
25
 
from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped
 
23
from bzrlib.osutils import pathjoin, normalizes_filenames, unicode_filename
 
24
from bzrlib.tests import TestCaseWithTransport, TestSkipped
 
25
from bzrlib.workingtree import WorkingTree
26
26
 
27
27
 
28
28
class NonAsciiTest(TestCaseWithTransport):
40
40
 
41
41
 
42
42
a_circle_c = u'\xe5'
 
43
a_dots_c = u'\xe4'
43
44
a_circle_d = u'a\u030a'
44
 
a_dots_c = u'\xe4'
45
45
a_dots_d = u'a\u0308'
46
46
z_umlat_c = u'\u017d'
47
47
z_umlat_d = u'Z\u030c'
48
 
squared_c = u'\xbc' # This gets mapped to '2' if we use NFK[CD]
49
 
squared_d = u'\xbc'
50
 
quarter_c = u'\xb2' # Gets mapped to u'1\u20444' (1/4) if we use NFK[CD]
51
 
quarter_d = u'\xb2'
52
 
 
53
 
 
54
 
class TestNormalization(TestCase):
55
 
    """Verify that we have our normalizations correct."""
56
 
 
57
 
    def test_normalize(self):
58
 
        self.assertEqual(a_circle_d, normalize('NFD', a_circle_c))
59
 
        self.assertEqual(a_circle_c, normalize('NFC', a_circle_d))
60
 
        self.assertEqual(a_dots_d, normalize('NFD', a_dots_c))
61
 
        self.assertEqual(a_dots_c, normalize('NFC', a_dots_d))
62
 
        self.assertEqual(z_umlat_d, normalize('NFD', z_umlat_c))
63
 
        self.assertEqual(z_umlat_c, normalize('NFC', z_umlat_d))
64
 
        self.assertEqual(squared_d, normalize('NFC', squared_c))
65
 
        self.assertEqual(squared_c, normalize('NFD', squared_d))
66
 
        self.assertEqual(quarter_d, normalize('NFC', quarter_c))
67
 
        self.assertEqual(quarter_c, normalize('NFD', quarter_d))
68
 
 
69
 
 
70
 
class NormalizedFilename(TestCaseWithTransport):
71
 
    """Test normalized_filename and associated helpers"""
72
 
 
73
 
    def test__accessible_normalized_filename(self):
74
 
        anf = osutils._accessible_normalized_filename
75
 
        # normalized_filename should allow plain ascii strings
76
 
        # not just unicode strings
77
 
        self.assertEqual((u'ascii', True), anf('ascii'))
78
 
        self.assertEqual((a_circle_c, True), anf(a_circle_c))
79
 
        self.assertEqual((a_circle_c, True), anf(a_circle_d))
80
 
        self.assertEqual((a_dots_c, True), anf(a_dots_c))
81
 
        self.assertEqual((a_dots_c, True), anf(a_dots_d))
82
 
        self.assertEqual((z_umlat_c, True), anf(z_umlat_c))
83
 
        self.assertEqual((z_umlat_c, True), anf(z_umlat_d))
84
 
        self.assertEqual((squared_c, True), anf(squared_c))
85
 
        self.assertEqual((squared_c, True), anf(squared_d))
86
 
        self.assertEqual((quarter_c, True), anf(quarter_c))
87
 
        self.assertEqual((quarter_c, True), anf(quarter_d))
88
 
 
89
 
    def test__inaccessible_normalized_filename(self):
90
 
        inf = osutils._inaccessible_normalized_filename
91
 
        # normalized_filename should allow plain ascii strings
92
 
        # not just unicode strings
93
 
        self.assertEqual((u'ascii', True), inf('ascii'))
94
 
        self.assertEqual((a_circle_c, True), inf(a_circle_c))
95
 
        self.assertEqual((a_circle_c, False), inf(a_circle_d))
96
 
        self.assertEqual((a_dots_c, True), inf(a_dots_c))
97
 
        self.assertEqual((a_dots_c, False), inf(a_dots_d))
98
 
        self.assertEqual((z_umlat_c, True), inf(z_umlat_c))
99
 
        self.assertEqual((z_umlat_c, False), inf(z_umlat_d))
100
 
        self.assertEqual((squared_c, True), inf(squared_c))
101
 
        self.assertEqual((squared_c, True), inf(squared_d))
102
 
        self.assertEqual((quarter_c, True), inf(quarter_c))
103
 
        self.assertEqual((quarter_c, True), inf(quarter_d))
104
 
 
105
 
    def test_functions(self):
106
 
        if osutils.normalizes_filenames():
107
 
            self.assertEqual(osutils.normalized_filename,
108
 
                             osutils._accessible_normalized_filename)
 
48
 
 
49
 
 
50
class UnicodeFilename(TestCaseWithTransport):
 
51
    """Test that UnicodeFilename returns the expected values."""
 
52
 
 
53
    def test_a_circle(self):
 
54
        self.assertEqual(a_circle_d, normalize('NFKD', a_circle_c))
 
55
        self.assertEqual(a_circle_c, normalize('NFKC', a_circle_d))
 
56
 
 
57
        self.assertEqual((a_circle_c, True), unicode_filename(a_circle_c))
 
58
        if normalizes_filenames():
 
59
            self.assertEqual((a_circle_c, True), unicode_filename(a_circle_d))
109
60
        else:
110
 
            self.assertEqual(osutils.normalized_filename,
111
 
                             osutils._inaccessible_normalized_filename)
 
61
            self.assertEqual((a_circle_d, False), unicode_filename(a_circle_d))
112
62
 
113
63
    def test_platform(self):
114
 
        # With FAT32 and certain encodings on win32
115
 
        # a_circle_c and a_dots_c actually map to the same file
116
 
        # adding a suffix kicks in the 'preserving but insensitive'
117
 
        # route, and maintains the right files
118
 
        files = [a_circle_c+'.1', a_dots_c+'.2', z_umlat_c+'.3']
119
64
        try:
120
 
            self.build_tree(files)
 
65
            self.build_tree([a_circle_c, a_dots_c, z_umlat_c])
121
66
        except UnicodeError:
122
67
            raise TestSkipped("filesystem cannot create unicode files")
123
68
 
124
69
        if sys.platform == 'darwin':
125
 
            expected = sorted([a_circle_d+'.1', a_dots_d+'.2', z_umlat_d+'.3'])
 
70
            expected = sorted([a_circle_d, a_dots_d, z_umlat_d])
126
71
        else:
127
 
            expected = sorted(files)
 
72
            expected = sorted([a_circle_c, a_dots_c, z_umlat_c])
128
73
 
129
74
        present = sorted(os.listdir(u'.'))
130
75
        self.assertEqual(expected, present)
131
76
 
132
 
    def test_access_normalized(self):
133
 
        # We should always be able to access files created with
134
 
        # normalized filenames
135
 
        # With FAT32 and certain encodings on win32
136
 
        # a_circle_c and a_dots_c actually map to the same file
137
 
        # adding a suffix kicks in the 'preserving but insensitive'
138
 
        # route, and maintains the right files
139
 
        files = [a_circle_c+'.1', a_dots_c+'.2', z_umlat_c+'.3',
140
 
                 squared_c+'.4', quarter_c+'.5']
 
77
    def test_access(self):
 
78
        # We should always be able to access files by the path returned
 
79
        # from unicode_filename
 
80
        files = [a_circle_c, a_dots_c, z_umlat_c]
141
81
        try:
142
 
            self.build_tree(files, line_endings='native')
 
82
            self.build_tree(files)
143
83
        except UnicodeError:
144
84
            raise TestSkipped("filesystem cannot create unicode files")
145
85
 
146
86
        for fname in files:
 
87
            path = unicode_filename(fname)[0]
147
88
            # We should get an exception if we can't open the file at
148
89
            # this location.
149
 
            path, can_access = osutils.normalized_filename(fname)
150
 
 
151
 
            self.assertEqual(path, fname)
152
 
            self.assertTrue(can_access)
153
 
 
154
90
            f = open(path, 'rb')
155
 
            try:
156
 
                # Check the contents
157
 
                shouldbe = 'contents of %s%s' % (path.encode('utf8'),
158
 
                                                 os.linesep)
159
 
                actual = f.read()
160
 
            finally:
161
 
                f.close()
162
 
            self.assertEqual(shouldbe, actual,
163
 
                             'contents of %r is incorrect: %r != %r'
164
 
                             % (path, shouldbe, actual))
165
 
 
166
 
    def test_access_non_normalized(self):
167
 
        # Sometimes we can access non-normalized files by their normalized
168
 
        # path, verify that normalized_filename returns the right info
169
 
        files = [a_circle_d+'.1', a_dots_d+'.2', z_umlat_d+'.3']
170
 
 
171
 
        try:
172
 
            self.build_tree(files)
173
 
        except UnicodeError:
174
 
            raise TestSkipped("filesystem cannot create unicode files")
175
 
 
176
 
        for fname in files:
177
 
            # We should get an exception if we can't open the file at
178
 
            # this location.
179
 
            path, can_access = osutils.normalized_filename(fname)
180
 
 
181
 
            self.assertNotEqual(path, fname)
182
 
 
183
 
            # We should always be able to access them from the name
184
 
            # they were created with
185
 
            f = open(fname, 'rb')
186
91
            f.close()
187
92
 
188
 
            # And normalized_filename sholud tell us correctly if we can
189
 
            # access them by an alternate name
190
 
            if can_access:
191
 
                f = open(path, 'rb')
192
 
                f.close()
193
 
            else:
194
 
                self.assertRaises(IOError, open, path, 'rb')
 
93