1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
import pathlib
import unittest
from pygame import encode_string, encode_file_path
class RWopsEncodeStringTest(unittest.TestCase):
global getrefcount
def test_obj_None(self):
encoded_string = encode_string(None)
self.assertIsNone(encoded_string)
def test_returns_bytes(self):
u = "Hello"
encoded_string = encode_string(u)
self.assertIsInstance(encoded_string, bytes)
def test_obj_bytes(self):
b = b"encyclop\xE6dia"
encoded_string = encode_string(b, "ascii", "strict")
self.assertIs(encoded_string, b)
def test_encode_unicode(self):
u = "\u00DEe Olde Komp\u00FCter Shoppe"
b = u.encode("utf-8")
self.assertEqual(encode_string(u, "utf-8"), b)
def test_error_fowarding(self):
self.assertRaises(SyntaxError, encode_string)
def test_errors(self):
u = "abc\u0109defg\u011Dh\u0125ij\u0135klmnoprs\u015Dtu\u016Dvz"
b = u.encode("ascii", "ignore")
self.assertEqual(encode_string(u, "ascii", "ignore"), b)
def test_encoding_error(self):
u = "a\x80b"
encoded_string = encode_string(u, "ascii", "strict")
self.assertIsNone(encoded_string)
def test_check_defaults(self):
u = "a\u01F7b"
b = u.encode("unicode_escape", "backslashreplace")
encoded_string = encode_string(u)
self.assertEqual(encoded_string, b)
def test_etype(self):
u = "a\x80b"
self.assertRaises(SyntaxError, encode_string, u, "ascii", "strict", SyntaxError)
def test_etype__invalid(self):
"""Ensures invalid etypes are properly handled."""
for etype in ("SyntaxError", self):
self.assertRaises(TypeError, encode_string, "test", etype=etype)
def test_string_with_null_bytes(self):
b = b"a\x00b\x00c"
encoded_string = encode_string(b, etype=SyntaxError)
encoded_decode_string = encode_string(b.decode(), "ascii", "strict")
self.assertIs(encoded_string, b)
self.assertEqual(encoded_decode_string, b)
try:
from sys import getrefcount as _g
getrefcount = _g # This nonsense is for Python 3.x
except ImportError:
pass
else:
def test_refcount(self):
bpath = b" This is a string that is not cached."[1:]
upath = bpath.decode("ascii")
before = getrefcount(bpath)
bpath = encode_string(bpath)
self.assertEqual(getrefcount(bpath), before)
bpath = encode_string(upath)
self.assertEqual(getrefcount(bpath), before)
def test_smp(self):
utf_8 = b"a\xF0\x93\x82\xA7b"
u = "a\U000130A7b"
b = encode_string(u, "utf-8", "strict", AssertionError)
self.assertEqual(b, utf_8)
def test_pathlib_obj(self):
"""Test loading string representation of pathlib object"""
"""
We do this because pygame functions internally use pg_EncodeString
to decode the filenames passed to them. So if we test that here, we
can safely assume that all those functions do not have any issues
with pathlib objects
"""
encoded = encode_string(pathlib.PurePath("foo"), "utf-8")
self.assertEqual(encoded, b"foo")
encoded = encode_string(pathlib.Path("baz"))
self.assertEqual(encoded, b"baz")
class RWopsEncodeFilePathTest(unittest.TestCase):
# Most tests can be skipped since RWopsEncodeFilePath wraps
# RWopsEncodeString
def test_encoding(self):
u = "Hello"
encoded_file_path = encode_file_path(u)
self.assertIsInstance(encoded_file_path, bytes)
def test_error_fowarding(self):
self.assertRaises(SyntaxError, encode_file_path)
def test_path_with_null_bytes(self):
b = b"a\x00b\x00c"
encoded_file_path = encode_file_path(b)
self.assertIsNone(encoded_file_path)
def test_etype(self):
b = b"a\x00b\x00c"
self.assertRaises(TypeError, encode_file_path, b, TypeError)
def test_etype__invalid(self):
"""Ensures invalid etypes are properly handled."""
for etype in ("SyntaxError", self):
self.assertRaises(TypeError, encode_file_path, "test", etype)
if __name__ == "__main__":
unittest.main()
|
