@@ -55,6 +55,21 @@ def duplicate_string(text):
55
55
class StrSubclass (str ):
56
56
pass
57
57
58
+ class OtherStrSubclass (str ):
59
+ pass
60
+
61
+ class WithStr :
62
+ def __init__ (self , value ):
63
+ self .value = value
64
+ def __str__ (self ):
65
+ return self .value
66
+
67
+ class WithRepr :
68
+ def __init__ (self , value ):
69
+ self .value = value
70
+ def __repr__ (self ):
71
+ return self .value
72
+
58
73
class UnicodeTest (string_tests .CommonTest ,
59
74
string_tests .MixinStrUnicodeUserStringTest ,
60
75
string_tests .MixinStrUnicodeTest ,
@@ -84,6 +99,10 @@ def __repr__(self):
84
99
self .assertEqual (realresult , result )
85
100
self .assertTrue (object is not realresult )
86
101
102
+ def assertTypedEqual (self , actual , expected ):
103
+ self .assertIs (type (actual ), type (expected ))
104
+ self .assertEqual (actual , expected )
105
+
87
106
def test_literals (self ):
88
107
self .assertEqual ('\xff ' , '\u00ff ' )
89
108
self .assertEqual ('\uffff ' , '\U0000ffff ' )
@@ -130,10 +149,13 @@ def test_ascii(self):
130
149
self .assertEqual (ascii ("\U00010000 " * 39 + "\uffff " * 4096 ),
131
150
ascii ("\U00010000 " * 39 + "\uffff " * 4096 ))
132
151
133
- class WrongRepr :
134
- def __repr__ (self ):
135
- return b'byte-repr'
136
- self .assertRaises (TypeError , ascii , WrongRepr ())
152
+ self .assertTypedEqual (ascii ('\U0001f40d ' ), r"'\U0001f40d'" )
153
+ self .assertTypedEqual (ascii (StrSubclass ('abc' )), "'abc'" )
154
+ self .assertTypedEqual (ascii (WithRepr ('<abc>' )), '<abc>' )
155
+ self .assertTypedEqual (ascii (WithRepr (StrSubclass ('<abc>' ))), StrSubclass ('<abc>' ))
156
+ self .assertTypedEqual (ascii (WithRepr ('<\U0001f40d >' )), r'<\U0001f40d>' )
157
+ self .assertTypedEqual (ascii (WithRepr (StrSubclass ('<\U0001f40d >' ))), r'<\U0001f40d>' )
158
+ self .assertRaises (TypeError , ascii , WithRepr (b'byte-repr' ))
137
159
138
160
def test_repr (self ):
139
161
if not sys .platform .startswith ('java' ):
@@ -172,10 +194,13 @@ def test_repr(self):
172
194
self .assertEqual (repr ("\U00010000 " * 39 + "\uffff " * 4096 ),
173
195
repr ("\U00010000 " * 39 + "\uffff " * 4096 ))
174
196
175
- class WrongRepr :
176
- def __repr__ (self ):
177
- return b'byte-repr'
178
- self .assertRaises (TypeError , repr , WrongRepr ())
197
+ self .assertTypedEqual (repr ('\U0001f40d ' ), "'\U0001f40d '" )
198
+ self .assertTypedEqual (repr (StrSubclass ('abc' )), "'abc'" )
199
+ self .assertTypedEqual (repr (WithRepr ('<abc>' )), '<abc>' )
200
+ self .assertTypedEqual (repr (WithRepr (StrSubclass ('<abc>' ))), StrSubclass ('<abc>' ))
201
+ self .assertTypedEqual (repr (WithRepr ('<\U0001f40d >' )), '<\U0001f40d >' )
202
+ self .assertTypedEqual (repr (WithRepr (StrSubclass ('<\U0001f40d >' ))), StrSubclass ('<\U0001f40d >' ))
203
+ self .assertRaises (TypeError , repr , WithRepr (b'byte-repr' ))
179
204
180
205
def test_iterators (self ):
181
206
# Make sure unicode objects have an __iter__ method
@@ -2381,28 +2406,37 @@ def test_ucs4(self):
2381
2406
2382
2407
def test_conversion (self ):
2383
2408
# Make sure __str__() works properly
2384
- class ObjectToStr :
2385
- def __str__ (self ):
2386
- return "foo"
2387
-
2388
- class StrSubclassToStr (str ):
2389
- def __str__ (self ):
2390
- return "foo"
2391
-
2392
- class StrSubclassToStrSubclass (str ):
2393
- def __new__ (cls , content = "" ):
2394
- return str .__new__ (cls , 2 * content )
2395
- def __str__ (self ):
2409
+ class StrWithStr (str ):
2410
+ def __new__ (cls , value ):
2411
+ self = str .__new__ (cls , "" )
2412
+ self .value = value
2396
2413
return self
2414
+ def __str__ (self ):
2415
+ return self .value
2397
2416
2398
- self .assertEqual (str (ObjectToStr ()), "foo" )
2399
- self .assertEqual (str (StrSubclassToStr ("bar" )), "foo" )
2400
- s = str (StrSubclassToStrSubclass ("foo" ))
2401
- self .assertEqual (s , "foofoo" )
2402
- self .assertIs (type (s ), StrSubclassToStrSubclass )
2403
- s = StrSubclass (StrSubclassToStrSubclass ("foo" ))
2404
- self .assertEqual (s , "foofoo" )
2405
- self .assertIs (type (s ), StrSubclass )
2417
+ self .assertTypedEqual (str (WithStr ('abc' )), 'abc' )
2418
+ self .assertTypedEqual (str (WithStr (StrSubclass ('abc' ))), StrSubclass ('abc' ))
2419
+ self .assertTypedEqual (StrSubclass (WithStr ('abc' )), StrSubclass ('abc' ))
2420
+ self .assertTypedEqual (StrSubclass (WithStr (StrSubclass ('abc' ))),
2421
+ StrSubclass ('abc' ))
2422
+ self .assertTypedEqual (StrSubclass (WithStr (OtherStrSubclass ('abc' ))),
2423
+ StrSubclass ('abc' ))
2424
+
2425
+ self .assertTypedEqual (str (StrWithStr ('abc' )), 'abc' )
2426
+ self .assertTypedEqual (str (StrWithStr (StrSubclass ('abc' ))), StrSubclass ('abc' ))
2427
+ self .assertTypedEqual (StrSubclass (StrWithStr ('abc' )), StrSubclass ('abc' ))
2428
+ self .assertTypedEqual (StrSubclass (StrWithStr (StrSubclass ('abc' ))),
2429
+ StrSubclass ('abc' ))
2430
+ self .assertTypedEqual (StrSubclass (StrWithStr (OtherStrSubclass ('abc' ))),
2431
+ StrSubclass ('abc' ))
2432
+
2433
+ self .assertTypedEqual (str (WithRepr ('<abc>' )), '<abc>' )
2434
+ self .assertTypedEqual (str (WithRepr (StrSubclass ('<abc>' ))), StrSubclass ('<abc>' ))
2435
+ self .assertTypedEqual (StrSubclass (WithRepr ('<abc>' )), StrSubclass ('<abc>' ))
2436
+ self .assertTypedEqual (StrSubclass (WithRepr (StrSubclass ('<abc>' ))),
2437
+ StrSubclass ('<abc>' ))
2438
+ self .assertTypedEqual (StrSubclass (WithRepr (OtherStrSubclass ('<abc>' ))),
2439
+ StrSubclass ('<abc>' ))
2406
2440
2407
2441
def test_unicode_repr (self ):
2408
2442
class s1 :
0 commit comments