← 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: Aaron Bentley
  • Date: 2006-06-21 14:30:57 UTC
  • mfrom: (1801.1.1 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 1803.
  • Revision ID: abentley@panoramicfeedback.com-20060621143057-776e4b8d707e430e
Install benchmarks. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

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