/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_nonascii.py

  • Committer: Jelmer Vernooij
  • Date: 2020-05-24 00:39:50 UTC
  • mto: This revision was merged to the branch mainline in revision 7504.
  • Revision ID: jelmer@jelmer.uk-20200524003950-bbc545r76vc5yajg
Add github action.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_nonascii.py
 
1
# Copyright (C) 2005, 2006, 2008, 2009, 2011 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
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
 
16
 
 
17
"""Test that various operations work in a non-ASCII environment."""
 
18
 
 
19
import os
 
20
import sys
 
21
from unicodedata import normalize
 
22
 
 
23
from .. import osutils
 
24
from ..osutils import pathjoin
 
25
from . import TestCase, TestCaseWithTransport, TestSkipped
 
26
 
 
27
 
 
28
class NonAsciiTest(TestCaseWithTransport):
 
29
 
 
30
    def test_add_in_nonascii_branch(self):
 
31
        """Test adding in a non-ASCII branch."""
 
32
        br_dir = u"\u1234"
 
33
        try:
 
34
            wt = self.make_branch_and_tree(br_dir)
 
35
        except UnicodeEncodeError:
 
36
            raise TestSkipped("filesystem can't accomodate nonascii names")
 
37
            return
 
38
        with open(pathjoin(br_dir, "a"), "w") as f:
 
39
            f.write("hello")
 
40
        wt.add(["a"], [b"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
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)
 
110
        else:
 
111
            self.assertEqual(osutils.normalized_filename,
 
112
                             osutils._inaccessible_normalized_filename)
 
113
 
 
114
    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
        try:
 
121
            self.build_tree(files)
 
122
        except UnicodeError:
 
123
            raise TestSkipped("filesystem cannot create unicode files")
 
124
 
 
125
        if sys.platform == 'darwin':
 
126
            expected = sorted(
 
127
                [a_circle_d + '.1', a_dots_d + '.2', z_umlat_d + '.3'])
 
128
        else:
 
129
            expected = sorted(files)
 
130
 
 
131
        present = sorted(os.listdir(u'.'))
 
132
        self.assertEqual(expected, present)
 
133
 
 
134
    def test_access_normalized(self):
 
135
        # We should always be able to access files created with
 
136
        # normalized filenames
 
137
        # With FAT32 and certain encodings on win32
 
138
        # a_circle_c and a_dots_c actually map to the same file
 
139
        # adding a suffix kicks in the 'preserving but insensitive'
 
140
        # route, and maintains the right files
 
141
        files = [a_circle_c + '.1', a_dots_c + '.2', z_umlat_c + '.3',
 
142
                 squared_c + '.4', quarter_c + '.5']
 
143
        try:
 
144
            self.build_tree(files, line_endings='native')
 
145
        except UnicodeError:
 
146
            raise TestSkipped("filesystem cannot create unicode files")
 
147
 
 
148
        for fname in files:
 
149
            # We should get an exception if we can't open the file at
 
150
            # this location.
 
151
            path, can_access = osutils.normalized_filename(fname)
 
152
 
 
153
            self.assertEqual(path, fname)
 
154
            self.assertTrue(can_access)
 
155
 
 
156
            with open(path, 'rb') as f:
 
157
                # Check the contents
 
158
                shouldbe = b'contents of %s%s' % (path.encode('utf8'),
 
159
                                                  os.linesep.encode('utf-8'))
 
160
                actual = f.read()
 
161
            self.assertEqual(shouldbe, actual,
 
162
                             'contents of %r is incorrect: %r != %r'
 
163
                             % (path, shouldbe, actual))
 
164
 
 
165
    def test_access_non_normalized(self):
 
166
        # Sometimes we can access non-normalized files by their normalized
 
167
        # path, verify that normalized_filename returns the right info
 
168
        files = [a_circle_d + '.1', a_dots_d + '.2', z_umlat_d + '.3']
 
169
 
 
170
        try:
 
171
            self.build_tree(files)
 
172
        except UnicodeError:
 
173
            raise TestSkipped("filesystem cannot create unicode files")
 
174
 
 
175
        for fname in files:
 
176
            # We should get an exception if we can't open the file at
 
177
            # this location.
 
178
            path, can_access = osutils.normalized_filename(fname)
 
179
 
 
180
            self.assertNotEqual(path, fname)
 
181
 
 
182
            # We should always be able to access them from the name
 
183
            # they were created with
 
184
            f = open(fname, 'rb')
 
185
            f.close()
 
186
 
 
187
            # And normalized_filename sholud tell us correctly if we can
 
188
            # access them by an alternate name
 
189
            if can_access:
 
190
                f = open(path, 'rb')
 
191
                f.close()
 
192
            else:
 
193
                self.assertRaises(IOError, open, path, 'rb')