bernsteinbear.com
this repo has no description
1// Copyright (c) Facebook, Inc. and its affiliates. (http://www.facebook.com)
2#include "Python.h"
3#include "gtest/gtest.h"
4
5#include "capi-fixture.h"
6#include "capi-testing.h"
7
8namespace py {
9namespace testing {
10
11using ExceptionsExtensionApiTest = ExtensionApi;
12
13TEST_F(ExceptionsExtensionApiTest, ExceptionClassCheckWithNonTypeReturnsZero) {
14 PyObjectPtr obj(PyLong_FromLong(5));
15 EXPECT_EQ(PyExceptionClass_Check(obj.get()), 0);
16}
17
18TEST_F(ExceptionsExtensionApiTest,
19 ExceptionClassCheckWithNonExceptionSubclassReturnsZero) {
20 PyRun_SimpleString(R"(
21class C(str):
22 pass
23)");
24 PyObjectPtr c_type(mainModuleGet("C"));
25 EXPECT_EQ(PyExceptionClass_Check(c_type.get()), 0);
26}
27
28TEST_F(ExceptionsExtensionApiTest,
29 ExceptionClassCheckWithExceptionClassReturnsOne) {
30 EXPECT_EQ(PyExceptionClass_Check(PyExc_BaseException), 1);
31 EXPECT_EQ(PyExceptionClass_Check(PyExc_Exception), 1);
32}
33
34TEST_F(ExceptionsExtensionApiTest,
35 ExceptionClassCheckWithExceptionSubclassReturnsOne) {
36 PyRun_SimpleString(R"(
37class C(TypeError):
38 pass
39)");
40 PyObjectPtr c_type(mainModuleGet("C"));
41 EXPECT_EQ(PyExceptionClass_Check(c_type.get()), 1);
42}
43
44TEST_F(ExceptionsExtensionApiTest,
45 ExceptionInstanceCheckWithNonExceptionReturnsZero) {
46 PyObjectPtr obj(PyLong_FromLong(5));
47 EXPECT_EQ(PyExceptionInstance_Check(obj.get()), 0);
48}
49
50TEST_F(ExceptionsExtensionApiTest,
51 ExceptionInstanceCheckWithExceptionReturnsOne) {
52 PyRun_SimpleString("obj = TypeError()");
53 PyObjectPtr obj(mainModuleGet("obj"));
54 EXPECT_EQ(PyExceptionInstance_Check(obj.get()), 1);
55}
56
57TEST_F(ExceptionsExtensionApiTest,
58 ExceptionInstanceCheckWithExceptionSubclassReturnsOne) {
59 PyRun_SimpleString(R"(
60class C(TypeError):
61 pass
62obj = C()
63)");
64 PyObjectPtr obj(mainModuleGet("obj"));
65 EXPECT_EQ(PyExceptionInstance_Check(obj.get()), 1);
66}
67
68TEST_F(ExceptionsExtensionApiTest, GettingCauseWithoutSettingItReturnsNull) {
69 PyRun_SimpleString("a = TypeError()");
70 PyObjectPtr exc(mainModuleGet("a"));
71 PyObjectPtr cause(PyException_GetCause(exc));
72 ASSERT_EQ(PyErr_Occurred(), nullptr);
73 EXPECT_EQ(cause, nullptr);
74}
75
76TEST_F(ExceptionsExtensionApiTest, GettingCauseAfterSetReturnsSameObject) {
77 PyRun_SimpleString("a = TypeError()");
78 PyObjectPtr exc(mainModuleGet("a"));
79 PyObjectPtr str(PyUnicode_FromString(""));
80 // Since SetCause steals a reference, but we want to keept the object around
81 // we need to incref it before passing it to the function
82 Py_INCREF(str);
83 PyException_SetCause(exc, str);
84 PyObjectPtr cause(PyException_GetCause(exc));
85 ASSERT_EQ(PyErr_Occurred(), nullptr);
86 EXPECT_EQ(cause, str);
87}
88
89TEST_F(ExceptionsExtensionApiTest, SettingCauseWithNullSetsCauseToNull) {
90 PyRun_SimpleString("a = TypeError()");
91 PyObjectPtr exc(mainModuleGet("a"));
92 PyException_SetCause(exc, PyUnicode_FromString(""));
93 PyException_SetCause(exc, nullptr);
94 PyObjectPtr cause(PyException_GetCause(exc));
95 ASSERT_EQ(PyErr_Occurred(), nullptr);
96 EXPECT_EQ(cause, nullptr);
97}
98
99TEST_F(ExceptionsExtensionApiTest, GettingContextWithoutSettingItReturnsNull) {
100 PyRun_SimpleString("a = TypeError()");
101 PyObjectPtr exc(mainModuleGet("a"));
102 PyObjectPtr context(PyException_GetContext(exc));
103 ASSERT_EQ(PyErr_Occurred(), nullptr);
104 EXPECT_EQ(context, nullptr);
105}
106
107TEST_F(ExceptionsExtensionApiTest, GettingContextAfterSetReturnsSameObject) {
108 PyRun_SimpleString("a = TypeError()");
109 PyObjectPtr exc(mainModuleGet("a"));
110 PyObjectPtr str(PyUnicode_FromString(""));
111 // Since SetContext steals a reference, but we want to keept the object around
112 // we need to incref it before passing it to the function
113 Py_INCREF(str);
114 PyException_SetContext(exc, str);
115 PyObjectPtr context(PyException_GetContext(exc));
116 ASSERT_EQ(PyErr_Occurred(), nullptr);
117 EXPECT_EQ(context, str);
118}
119
120TEST_F(ExceptionsExtensionApiTest, SettingContextWithNullSetsContextToNull) {
121 PyRun_SimpleString("a = TypeError()");
122 PyObjectPtr exc(mainModuleGet("a"));
123 PyException_SetContext(exc, PyUnicode_FromString(""));
124 PyException_SetContext(exc, nullptr);
125 PyObjectPtr context(PyException_GetContext(exc));
126 ASSERT_EQ(PyErr_Occurred(), nullptr);
127 EXPECT_EQ(context, nullptr);
128}
129
130TEST_F(ExceptionsExtensionApiTest,
131 GettingTracebackWithoutSettingItReturnsNull) {
132 PyRun_SimpleString("a = TypeError()");
133 PyObjectPtr exc(mainModuleGet("a"));
134 EXPECT_EQ(PyException_GetTraceback(exc), nullptr);
135}
136
137TEST_F(ExceptionsExtensionApiTest, SetTracebackWithNoneSetsNone) {
138 // TODO(bsimmers): Once we have a way of creating a real traceback object,
139 // test that as well.
140 PyRun_SimpleString("a = TypeError()");
141 PyObjectPtr exc(mainModuleGet("a"));
142 ASSERT_EQ(PyException_SetTraceback(exc, Py_None), 0);
143 ASSERT_EQ(PyErr_Occurred(), nullptr);
144
145 PyObjectPtr tb(PyException_GetTraceback(exc));
146 EXPECT_EQ(tb, Py_None);
147}
148
149TEST_F(ExceptionsExtensionApiTest, SetTracebackWithBadArgRaisesTypeError) {
150 PyRun_SimpleString("a = TypeError()");
151 PyObjectPtr exc(mainModuleGet("a"));
152 PyObjectPtr bad_tb(PyLong_FromLong(123));
153 ASSERT_EQ(PyException_SetTraceback(exc, bad_tb), -1);
154 ASSERT_EQ(PyErr_ExceptionMatches(PyExc_TypeError), 1);
155}
156
157TEST_F(ExceptionsExtensionApiTest, SetTracebackWithNullptrRaisesTypeError) {
158 PyRun_SimpleString("a = TypeError()");
159 PyObjectPtr exc(mainModuleGet("a"));
160 ASSERT_EQ(PyException_SetTraceback(exc, nullptr), -1);
161 ASSERT_EQ(PyErr_ExceptionMatches(PyExc_TypeError), 1);
162}
163
164TEST_F(ExceptionsExtensionApiTest, UnicodeDecodeErrorCreateReturnsNewInstance) {
165 const char* encoding = "utf8";
166 const char* object = "abcd";
167 Py_ssize_t length = 5;
168 Py_ssize_t start = 2;
169 Py_ssize_t end = 4;
170 const char* reason = u8"\U0001F37B";
171
172 PyObjectPtr result(PyUnicodeDecodeError_Create(encoding, object, length,
173 start, end, reason));
174 ASSERT_EQ(PyErr_Occurred(), nullptr);
175 ASSERT_NE(result, nullptr);
176 EXPECT_TRUE(PyObject_HasAttrString(result, "encoding"));
177 EXPECT_EQ(PyUnicode_CompareWithASCIIString(
178 PyObject_GetAttrString(result, "encoding"), encoding),
179 0);
180 EXPECT_TRUE(PyObject_HasAttrString(result, "object"));
181 const char* object_attr =
182 PyBytes_AsString(PyObject_GetAttrString(result, "object"));
183 EXPECT_EQ(strcmp(object_attr, object), 0);
184 EXPECT_TRUE(PyObject_HasAttrString(result, "start"));
185 EXPECT_EQ(PyLong_AsLong(PyObject_GetAttrString(result, "start")), start);
186 EXPECT_TRUE(PyObject_HasAttrString(result, "end"));
187 EXPECT_EQ(PyLong_AsLong(PyObject_GetAttrString(result, "end")), end);
188 EXPECT_TRUE(PyObject_HasAttrString(result, "reason"));
189 PyObjectPtr reason_obj(PyUnicode_FromString(reason));
190 EXPECT_EQ(
191 PyUnicode_Compare(PyObject_GetAttrString(result, "reason"), reason_obj),
192 0);
193}
194
195TEST_F(ExceptionsExtensionApiTest,
196 UnicodeDecodeErrorGetEncodingWithNonStrEncodingRaisesTypeError) {
197 PyRun_SimpleString(R"(
198exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
199exc.encoding = 5 # not a valid encoding
200)");
201 PyObjectPtr exc(mainModuleGet("exc"));
202 EXPECT_EQ(PyUnicodeDecodeError_GetEncoding(exc), nullptr);
203 ASSERT_NE(PyErr_Occurred(), nullptr);
204 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
205}
206
207TEST_F(ExceptionsExtensionApiTest,
208 UnicodeDecodeErrorGetEncodingReturnsEncodingAttr) {
209 PyRun_SimpleString(R"(
210exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
211)");
212 PyObjectPtr exc(mainModuleGet("exc"));
213 PyObjectPtr result(PyUnicodeDecodeError_GetEncoding(exc));
214 ASSERT_NE(result, nullptr);
215 EXPECT_EQ(PyErr_Occurred(), nullptr);
216 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "utf8"), 0);
217}
218
219TEST_F(ExceptionsExtensionApiTest,
220 UnicodeDecodeErrorGetObjectWithNonBytesObjectRaisesTypeError) {
221 PyRun_SimpleString(R"(
222exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
223exc.object = 5 # not a valid object
224)");
225 PyObjectPtr exc(mainModuleGet("exc"));
226 EXPECT_EQ(PyUnicodeDecodeError_GetObject(exc), nullptr);
227 ASSERT_NE(PyErr_Occurred(), nullptr);
228 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
229}
230
231TEST_F(ExceptionsExtensionApiTest,
232 UnicodeDecodeErrorGetObjectReturnsObjectAttr) {
233 PyRun_SimpleString(R"(
234exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
235)");
236 PyObjectPtr exc(mainModuleGet("exc"));
237 PyObjectPtr result(PyUnicodeDecodeError_GetObject(exc));
238 ASSERT_NE(result, nullptr);
239 EXPECT_EQ(PyErr_Occurred(), nullptr);
240 const char* object_string = PyBytes_AsString(result);
241 EXPECT_EQ(strcmp(object_string, "object"), 0);
242}
243
244TEST_F(ExceptionsExtensionApiTest,
245 UnicodeDecodeErrorGetReasonWithNonStrReasonRaisesTypeError) {
246 PyRun_SimpleString(R"(
247exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
248exc.reason = 5 # not a valid reason
249)");
250 PyObjectPtr exc(mainModuleGet("exc"));
251 EXPECT_EQ(PyUnicodeDecodeError_GetReason(exc), nullptr);
252 ASSERT_NE(PyErr_Occurred(), nullptr);
253 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
254}
255
256TEST_F(ExceptionsExtensionApiTest,
257 UnicodeDecodeErrorGetReasonReturnsReasonAttr) {
258 PyRun_SimpleString(R"(
259exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
260)");
261 PyObjectPtr exc(mainModuleGet("exc"));
262 PyObjectPtr result(PyUnicodeDecodeError_GetReason(exc));
263 ASSERT_NE(result, nullptr);
264 EXPECT_EQ(PyErr_Occurred(), nullptr);
265 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "reason"), 0);
266}
267
268TEST_F(ExceptionsExtensionApiTest, UnicodeDecodeErrorSetReasonSetsReasonAttr) {
269 PyRun_SimpleString(R"(
270exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
271)");
272 PyObjectPtr exc(mainModuleGet("exc"));
273 PyUnicodeDecodeError_SetReason(exc, "foobar");
274 ASSERT_EQ(PyErr_Occurred(), nullptr);
275 PyObjectPtr result(PyUnicodeDecodeError_GetReason(exc));
276 EXPECT_EQ(PyErr_Occurred(), nullptr);
277 ASSERT_NE(result, nullptr);
278 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "foobar"), 0);
279}
280
281TEST_F(ExceptionsExtensionApiTest, UnicodeDecodeErrorGetStartReturnsStartAttr) {
282 PyRun_SimpleString(R"(
283exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
284)");
285 PyObjectPtr exc(mainModuleGet("exc"));
286 Py_ssize_t start = 0;
287 ASSERT_EQ(PyUnicodeDecodeError_GetStart(exc, &start), 0);
288 EXPECT_EQ(PyErr_Occurred(), nullptr);
289 EXPECT_EQ(start, 2);
290}
291
292TEST_F(ExceptionsExtensionApiTest, UnicodeDecodeErrorGetStartReturnsStartInt) {
293 PyRun_SimpleString(R"(
294class C(int): pass
295exc = UnicodeDecodeError("utf8", b"object", C(2), 4, "reason")
296)");
297 PyObjectPtr exc(mainModuleGet("exc"));
298 Py_ssize_t start = 0;
299 ASSERT_EQ(PyUnicodeDecodeError_GetStart(exc, &start), 0);
300 EXPECT_EQ(PyErr_Occurred(), nullptr);
301 EXPECT_EQ(start, 2);
302}
303
304TEST_F(ExceptionsExtensionApiTest,
305 UnicodeDecodeErrorGetStartWithNonBytesObjectRaisesTypeError) {
306 PyRun_SimpleString(R"(
307exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
308exc.object = 5 # not a valid object
309)");
310 PyObjectPtr exc(mainModuleGet("exc"));
311 Py_ssize_t start = 0;
312 ASSERT_EQ(PyUnicodeDecodeError_GetStart(exc, &start), -1);
313 ASSERT_NE(PyErr_Occurred(), nullptr);
314 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
315}
316
317TEST_F(ExceptionsExtensionApiTest,
318 UnicodeDecodeErrorGetStartWithNegativeStartReturnsZero) {
319 PyRun_SimpleString(R"(
320exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
321exc.start = -5
322)");
323 PyObjectPtr exc(mainModuleGet("exc"));
324 Py_ssize_t start = -1;
325 ASSERT_EQ(PyUnicodeDecodeError_GetStart(exc, &start), 0);
326 EXPECT_EQ(PyErr_Occurred(), nullptr);
327 EXPECT_EQ(start, 0);
328}
329
330TEST_F(ExceptionsExtensionApiTest,
331 UnicodeDecodeErrorGetStartWithStartGreaterThanSizeReturnsSizeMinusOne) {
332 PyRun_SimpleString(R"(
333exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
334exc.start = 10
335)");
336 PyObjectPtr exc(mainModuleGet("exc"));
337 Py_ssize_t start = 0;
338 ASSERT_EQ(PyUnicodeDecodeError_GetStart(exc, &start), 0);
339 EXPECT_EQ(PyErr_Occurred(), nullptr);
340 EXPECT_EQ(start, 5);
341}
342
343TEST_F(ExceptionsExtensionApiTest, UnicodeDecodeErrorGetEndReturnsEndAttr) {
344 PyRun_SimpleString(R"(
345exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
346)");
347 PyObjectPtr exc(mainModuleGet("exc"));
348 Py_ssize_t end = 0;
349 ASSERT_EQ(PyUnicodeDecodeError_GetEnd(exc, &end), 0);
350 EXPECT_EQ(PyErr_Occurred(), nullptr);
351 EXPECT_EQ(end, 4);
352}
353
354TEST_F(ExceptionsExtensionApiTest, UnicodeDecodeErrorGetEndReturnsEndInt) {
355 PyRun_SimpleString(R"(
356class C(int): pass
357exc = UnicodeDecodeError("utf8", b"object", 2, C(4), "reason")
358)");
359 PyObjectPtr exc(mainModuleGet("exc"));
360 Py_ssize_t end = 0;
361 ASSERT_EQ(PyUnicodeDecodeError_GetEnd(exc, &end), 0);
362 EXPECT_EQ(PyErr_Occurred(), nullptr);
363 EXPECT_EQ(end, 4);
364}
365
366TEST_F(ExceptionsExtensionApiTest,
367 UnicodeDecodeErrorGetEndWithNonBytesObjectRaisesTypeError) {
368 PyRun_SimpleString(R"(
369exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
370exc.object = 5 # not a valid object
371)");
372 PyObjectPtr exc(mainModuleGet("exc"));
373 Py_ssize_t end = 0;
374 ASSERT_EQ(PyUnicodeDecodeError_GetEnd(exc, &end), -1);
375 ASSERT_NE(PyErr_Occurred(), nullptr);
376 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
377}
378
379TEST_F(ExceptionsExtensionApiTest,
380 UnicodeDecodeErrorGetEndWithEndLessThanOneReturnsOne) {
381 PyRun_SimpleString(R"(
382exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
383exc.end = -5
384)");
385 PyObjectPtr exc(mainModuleGet("exc"));
386 Py_ssize_t end = 0;
387 ASSERT_EQ(PyUnicodeDecodeError_GetEnd(exc, &end), 0);
388 EXPECT_EQ(PyErr_Occurred(), nullptr);
389 EXPECT_EQ(end, 1);
390}
391
392TEST_F(ExceptionsExtensionApiTest,
393 UnicodeDecodeErrorGetEndWithEndGreaterThanSizeReturnsSize) {
394 PyRun_SimpleString(R"(
395exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
396exc.end = 10
397)");
398 PyObjectPtr exc(mainModuleGet("exc"));
399 Py_ssize_t end = 0;
400 ASSERT_EQ(PyUnicodeDecodeError_GetEnd(exc, &end), 0);
401 EXPECT_EQ(PyErr_Occurred(), nullptr);
402 EXPECT_EQ(end, 6); // len("object")
403}
404
405TEST_F(ExceptionsExtensionApiTest, UnicodeDecodeErrorSetStartSetsStartAttr) {
406 PyRun_SimpleString(R"(
407exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
408)");
409 PyObjectPtr exc(mainModuleGet("exc"));
410 ASSERT_EQ(PyUnicodeDecodeError_SetStart(exc, 5), 0);
411 ASSERT_EQ(PyErr_Occurred(), nullptr);
412 Py_ssize_t start = 0;
413 ASSERT_EQ(PyUnicodeDecodeError_GetStart(exc, &start), 0);
414 EXPECT_EQ(PyErr_Occurred(), nullptr);
415 EXPECT_EQ(start, 5);
416}
417
418TEST_F(ExceptionsExtensionApiTest, UnicodeDecodeErrorSetEndSetsEndAttr) {
419 PyRun_SimpleString(R"(
420exc = UnicodeDecodeError("utf8", b"object", 2, 4, "reason")
421)");
422 PyObjectPtr exc(mainModuleGet("exc"));
423 ASSERT_EQ(PyUnicodeDecodeError_SetEnd(exc, 5), 0);
424 ASSERT_EQ(PyErr_Occurred(), nullptr);
425 Py_ssize_t end = 0;
426 ASSERT_EQ(PyUnicodeDecodeError_GetEnd(exc, &end), 0);
427 EXPECT_EQ(PyErr_Occurred(), nullptr);
428 EXPECT_EQ(end, 5);
429}
430
431TEST_F(ExceptionsExtensionApiTest,
432 UnicodeDecodeErrorSubclassSetEndGetEndReturnsEnd) {
433 PyRun_SimpleString(R"(
434class ErrorSubclass(UnicodeDecodeError): pass
435exc = ErrorSubclass("utf8", b"object", 2, 4, "reason")
436)");
437 PyObjectPtr exc(mainModuleGet("exc"));
438 ASSERT_EQ(PyUnicodeDecodeError_SetEnd(exc, 5), 0);
439 ASSERT_EQ(PyErr_Occurred(), nullptr);
440 Py_ssize_t end = 0;
441 ASSERT_EQ(PyUnicodeDecodeError_GetEnd(exc, &end), 0);
442 EXPECT_EQ(PyErr_Occurred(), nullptr);
443 EXPECT_EQ(end, 5);
444}
445
446TEST_F(ExceptionsExtensionApiTest,
447 UnicodeDecodeErrorSubclassSetStartGetStartReturnsStart) {
448 PyRun_SimpleString(R"(
449class ErrorSubclass(UnicodeDecodeError): pass
450exc = ErrorSubclass("utf8", b"object", 2, 4, "reason")
451)");
452 PyObjectPtr exc(mainModuleGet("exc"));
453 ASSERT_EQ(PyUnicodeDecodeError_SetStart(exc, 5), 0);
454 ASSERT_EQ(PyErr_Occurred(), nullptr);
455 Py_ssize_t end = 0;
456 ASSERT_EQ(PyUnicodeDecodeError_GetStart(exc, &end), 0);
457 EXPECT_EQ(PyErr_Occurred(), nullptr);
458 EXPECT_EQ(end, 5);
459}
460
461TEST_F(ExceptionsExtensionApiTest,
462 UnicodeDecodeErrorSubclassSetReasonGetReasonReturnsReason) {
463 PyRun_SimpleString(R"(
464class ErrorSubclass(UnicodeDecodeError): pass
465exc = ErrorSubclass("utf8", b"object", 2, 4, "reason")
466)");
467 PyObjectPtr exc(mainModuleGet("exc"));
468 PyUnicodeDecodeError_SetReason(exc, "foobar");
469 ASSERT_EQ(PyErr_Occurred(), nullptr);
470 PyObjectPtr result(PyUnicodeDecodeError_GetReason(exc));
471 EXPECT_EQ(PyErr_Occurred(), nullptr);
472 ASSERT_NE(result, nullptr);
473 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "foobar"), 0);
474}
475
476TEST_F(ExceptionsExtensionApiTest,
477 UnicodeEncodeErrorGetEncodingWithNonStrEncodingRaisesTypeError) {
478 PyRun_SimpleString(R"(
479exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
480exc.encoding = 5 # not a valid encoding
481)");
482 PyObjectPtr exc(mainModuleGet("exc"));
483 EXPECT_EQ(PyUnicodeEncodeError_GetEncoding(exc), nullptr);
484 ASSERT_NE(PyErr_Occurred(), nullptr);
485 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
486}
487
488TEST_F(ExceptionsExtensionApiTest,
489 UnicodeEncodeErrorGetEncodingReturnsEncodingAttr) {
490 PyRun_SimpleString(R"(
491exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
492)");
493 PyObjectPtr exc(mainModuleGet("exc"));
494 PyObjectPtr result(PyUnicodeEncodeError_GetEncoding(exc));
495 ASSERT_NE(result, nullptr);
496 EXPECT_EQ(PyErr_Occurred(), nullptr);
497 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "utf8"), 0);
498}
499
500TEST_F(ExceptionsExtensionApiTest,
501 UnicodeEncodeErrorGetObjectWithNonStrObjectRaisesTypeError) {
502 PyRun_SimpleString(R"(
503exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
504exc.object = 5 # not a valid object
505)");
506 PyObjectPtr exc(mainModuleGet("exc"));
507 EXPECT_EQ(PyUnicodeEncodeError_GetObject(exc), nullptr);
508 ASSERT_NE(PyErr_Occurred(), nullptr);
509 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
510}
511
512TEST_F(ExceptionsExtensionApiTest,
513 UnicodeEncodeErrorGetObjectReturnsObjectAttr) {
514 PyRun_SimpleString(R"(
515exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
516)");
517 PyObjectPtr exc(mainModuleGet("exc"));
518 PyObjectPtr result(PyUnicodeEncodeError_GetObject(exc));
519 ASSERT_NE(result, nullptr);
520 EXPECT_EQ(PyErr_Occurred(), nullptr);
521 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "object"), 0);
522}
523
524TEST_F(ExceptionsExtensionApiTest,
525 UnicodeEncodeErrorGetReasonWithNonStrReasonRaisesTypeError) {
526 PyRun_SimpleString(R"(
527exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
528exc.reason = 5 # not a valid reason
529)");
530 PyObjectPtr exc(mainModuleGet("exc"));
531 EXPECT_EQ(PyUnicodeEncodeError_GetReason(exc), nullptr);
532 ASSERT_NE(PyErr_Occurred(), nullptr);
533 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
534}
535
536TEST_F(ExceptionsExtensionApiTest,
537 UnicodeEncodeErrorGetReasonReturnsReasonAttr) {
538 PyRun_SimpleString(R"(
539exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
540)");
541 PyObjectPtr exc(mainModuleGet("exc"));
542 PyObjectPtr result(PyUnicodeEncodeError_GetReason(exc));
543 ASSERT_NE(result, nullptr);
544 EXPECT_EQ(PyErr_Occurred(), nullptr);
545 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "reason"), 0);
546}
547
548TEST_F(ExceptionsExtensionApiTest, UnicodeEncodeErrorSetReasonSetsReasonAttr) {
549 PyRun_SimpleString(R"(
550exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
551)");
552 PyObjectPtr exc(mainModuleGet("exc"));
553 PyUnicodeEncodeError_SetReason(exc, "foobar");
554 ASSERT_EQ(PyErr_Occurred(), nullptr);
555 PyObjectPtr result(PyUnicodeEncodeError_GetReason(exc));
556 ASSERT_NE(result, nullptr);
557 EXPECT_EQ(PyErr_Occurred(), nullptr);
558 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "foobar"), 0);
559}
560
561TEST_F(ExceptionsExtensionApiTest, UnicodeEncodeErrorGetStartReturnsStartAttr) {
562 PyRun_SimpleString(R"(
563exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
564)");
565 PyObjectPtr exc(mainModuleGet("exc"));
566 Py_ssize_t start = 0;
567 ASSERT_EQ(PyUnicodeEncodeError_GetStart(exc, &start), 0);
568 EXPECT_EQ(PyErr_Occurred(), nullptr);
569 EXPECT_EQ(start, 2);
570}
571
572TEST_F(ExceptionsExtensionApiTest, UnicodeEncodeErrorGetStartReturnsStartInt) {
573 PyRun_SimpleString(R"(
574class C(int): pass
575exc = UnicodeEncodeError("utf8", "object", C(2), 4, "reason")
576)");
577 PyObjectPtr exc(mainModuleGet("exc"));
578 Py_ssize_t start = 0;
579 ASSERT_EQ(PyUnicodeEncodeError_GetStart(exc, &start), 0);
580 EXPECT_EQ(PyErr_Occurred(), nullptr);
581 EXPECT_EQ(start, 2);
582}
583
584TEST_F(ExceptionsExtensionApiTest,
585 UnicodeEncodeErrorGetStartWithNonStrObjectRaisesTypeError) {
586 PyRun_SimpleString(R"(
587exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
588exc.object = 5 # not a valid object
589)");
590 PyObjectPtr exc(mainModuleGet("exc"));
591 Py_ssize_t start = 0;
592 ASSERT_EQ(PyUnicodeEncodeError_GetStart(exc, &start), -1);
593 ASSERT_NE(PyErr_Occurred(), nullptr);
594 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
595}
596
597TEST_F(ExceptionsExtensionApiTest,
598 UnicodeEncodeErrorGetStartWithNegativeStartReturnsZero) {
599 PyRun_SimpleString(R"(
600exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
601exc.start = -5
602)");
603 PyObjectPtr exc(mainModuleGet("exc"));
604 Py_ssize_t start = -1;
605 ASSERT_EQ(PyUnicodeEncodeError_GetStart(exc, &start), 0);
606 EXPECT_EQ(PyErr_Occurred(), nullptr);
607 EXPECT_EQ(start, 0);
608}
609
610TEST_F(ExceptionsExtensionApiTest,
611 UnicodeEncodeErrorGetStartWithStartGreaterThanSizeReturnsSizeMinusOne) {
612 PyRun_SimpleString(R"(
613exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
614exc.start = 10
615)");
616 PyObjectPtr exc(mainModuleGet("exc"));
617 Py_ssize_t start = 0;
618 ASSERT_EQ(PyUnicodeEncodeError_GetStart(exc, &start), 0);
619 EXPECT_EQ(PyErr_Occurred(), nullptr);
620 EXPECT_EQ(start, 5);
621}
622
623TEST_F(ExceptionsExtensionApiTest, UnicodeEncodeErrorGetEndReturnsEndAttr) {
624 PyRun_SimpleString(R"(
625exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
626)");
627 PyObjectPtr exc(mainModuleGet("exc"));
628 Py_ssize_t end = 0;
629 ASSERT_EQ(PyUnicodeEncodeError_GetEnd(exc, &end), 0);
630 EXPECT_EQ(PyErr_Occurred(), nullptr);
631 EXPECT_EQ(end, 4);
632}
633
634TEST_F(ExceptionsExtensionApiTest, UnicodeEncodeErrorGetEndReturnsEndInt) {
635 PyRun_SimpleString(R"(
636class C(int): pass
637exc = UnicodeEncodeError("utf8", "object", 2, C(4), "reason")
638)");
639 PyObjectPtr exc(mainModuleGet("exc"));
640 Py_ssize_t end = 0;
641 ASSERT_EQ(PyUnicodeEncodeError_GetEnd(exc, &end), 0);
642 EXPECT_EQ(PyErr_Occurred(), nullptr);
643 EXPECT_EQ(end, 4);
644}
645
646TEST_F(ExceptionsExtensionApiTest,
647 UnicodeEncodeErrorGetEndWithNonStrObjectRaisesTypeError) {
648 PyRun_SimpleString(R"(
649exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
650exc.object = 5 # not a valid object
651)");
652 PyObjectPtr exc(mainModuleGet("exc"));
653 Py_ssize_t end = 0;
654 ASSERT_EQ(PyUnicodeEncodeError_GetEnd(exc, &end), -1);
655 ASSERT_NE(PyErr_Occurred(), nullptr);
656 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
657}
658
659TEST_F(ExceptionsExtensionApiTest,
660 UnicodeEncodeErrorGetEndWithEndLessThanOneReturnsOne) {
661 PyRun_SimpleString(R"(
662exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
663exc.end = -5
664)");
665 PyObjectPtr exc(mainModuleGet("exc"));
666 Py_ssize_t end = 0;
667 ASSERT_EQ(PyUnicodeEncodeError_GetEnd(exc, &end), 0);
668 EXPECT_EQ(PyErr_Occurred(), nullptr);
669 EXPECT_EQ(end, 1);
670}
671
672TEST_F(ExceptionsExtensionApiTest,
673 UnicodeEncodeErrorGetEndWithEndGreaterThanSizeReturnsSize) {
674 PyRun_SimpleString(R"(
675exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
676exc.end = 10
677)");
678 PyObjectPtr exc(mainModuleGet("exc"));
679 Py_ssize_t end = 0;
680 ASSERT_EQ(PyUnicodeEncodeError_GetEnd(exc, &end), 0);
681 EXPECT_EQ(PyErr_Occurred(), nullptr);
682 EXPECT_EQ(end, 6); // len("object")
683}
684
685TEST_F(ExceptionsExtensionApiTest, UnicodeEncodeErrorSetStartSetsStartAttr) {
686 PyRun_SimpleString(R"(
687exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
688)");
689 PyObjectPtr exc(mainModuleGet("exc"));
690 ASSERT_EQ(PyUnicodeEncodeError_SetStart(exc, 5), 0);
691 ASSERT_EQ(PyErr_Occurred(), nullptr);
692 Py_ssize_t start = 0;
693 ASSERT_EQ(PyUnicodeEncodeError_GetStart(exc, &start), 0);
694 EXPECT_EQ(PyErr_Occurred(), nullptr);
695 EXPECT_EQ(start, 5);
696}
697
698TEST_F(ExceptionsExtensionApiTest, UnicodeEncodeErrorSetEndSetsEndAttr) {
699 PyRun_SimpleString(R"(
700exc = UnicodeEncodeError("utf8", "object", 2, 4, "reason")
701)");
702 PyObjectPtr exc(mainModuleGet("exc"));
703 ASSERT_EQ(PyUnicodeEncodeError_SetEnd(exc, 5), 0);
704 ASSERT_EQ(PyErr_Occurred(), nullptr);
705 Py_ssize_t end = 0;
706 ASSERT_EQ(PyUnicodeEncodeError_GetEnd(exc, &end), 0);
707 EXPECT_EQ(PyErr_Occurred(), nullptr);
708 EXPECT_EQ(end, 5);
709}
710
711TEST_F(ExceptionsExtensionApiTest,
712 UnicodeEncodeErrorSubclassSetEndGetEndReturnsEnd) {
713 PyRun_SimpleString(R"(
714class ErrorSubclass(UnicodeEncodeError): pass
715exc = ErrorSubclass("utf8", "object", 2, 4, "reason")
716)");
717 PyObjectPtr exc(mainModuleGet("exc"));
718 ASSERT_EQ(PyUnicodeEncodeError_SetEnd(exc, 5), 0);
719 ASSERT_EQ(PyErr_Occurred(), nullptr);
720 Py_ssize_t end = 0;
721 ASSERT_EQ(PyUnicodeEncodeError_GetEnd(exc, &end), 0);
722 EXPECT_EQ(PyErr_Occurred(), nullptr);
723 EXPECT_EQ(end, 5);
724}
725
726TEST_F(ExceptionsExtensionApiTest,
727 UnicodeEncodeErrorSubclassSetStartGetStartReturnsStart) {
728 PyRun_SimpleString(R"(
729class ErrorSubclass(UnicodeEncodeError): pass
730exc = ErrorSubclass("utf8", "object", 2, 4, "reason")
731)");
732 PyObjectPtr exc(mainModuleGet("exc"));
733 ASSERT_EQ(PyUnicodeEncodeError_SetStart(exc, 5), 0);
734 ASSERT_EQ(PyErr_Occurred(), nullptr);
735 Py_ssize_t end = 0;
736 ASSERT_EQ(PyUnicodeEncodeError_GetStart(exc, &end), 0);
737 EXPECT_EQ(PyErr_Occurred(), nullptr);
738 EXPECT_EQ(end, 5);
739}
740
741TEST_F(ExceptionsExtensionApiTest,
742 UnicodeEncodeErrorSubclassSetReasonGetReasonReturnsReason) {
743 PyRun_SimpleString(R"(
744class ErrorSubclass(UnicodeEncodeError): pass
745exc = ErrorSubclass("utf8", "object", 2, 4, "reason")
746)");
747 PyObjectPtr exc(mainModuleGet("exc"));
748 PyUnicodeEncodeError_SetReason(exc, "foobar");
749 ASSERT_EQ(PyErr_Occurred(), nullptr);
750 PyObjectPtr result(PyUnicodeEncodeError_GetReason(exc));
751 EXPECT_EQ(PyErr_Occurred(), nullptr);
752 ASSERT_NE(result, nullptr);
753 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "foobar"), 0);
754}
755
756TEST_F(ExceptionsExtensionApiTest,
757 UnicodeTranslateErrorGetObjectWithNonBytesObjectRaisesTypeError) {
758 PyRun_SimpleString(R"(
759exc = UnicodeTranslateError("object", 2, 4, "reason")
760exc.object = 5 # not a valid object
761)");
762 PyObjectPtr exc(mainModuleGet("exc"));
763 EXPECT_EQ(PyUnicodeTranslateError_GetObject(exc), nullptr);
764 ASSERT_NE(PyErr_Occurred(), nullptr);
765 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
766}
767
768TEST_F(ExceptionsExtensionApiTest,
769 UnicodeTranslateErrorGetObjectReturnsObjectAttr) {
770 PyRun_SimpleString(R"(
771exc = UnicodeTranslateError("object", 2, 4, "reason")
772)");
773 PyObjectPtr exc(mainModuleGet("exc"));
774 PyObjectPtr result(PyUnicodeTranslateError_GetObject(exc));
775 ASSERT_NE(result, nullptr);
776 EXPECT_EQ(PyErr_Occurred(), nullptr);
777 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "object"), 0);
778}
779
780TEST_F(ExceptionsExtensionApiTest,
781 UnicodeTranslateErrorGetReasonWithNonStrReasonRaisesTypeError) {
782 PyRun_SimpleString(R"(
783exc = UnicodeTranslateError("object", 2, 4, "reason")
784exc.reason = 5 # not a valid reason
785)");
786 PyObjectPtr exc(mainModuleGet("exc"));
787 EXPECT_EQ(PyUnicodeTranslateError_GetReason(exc), nullptr);
788 ASSERT_NE(PyErr_Occurred(), nullptr);
789 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
790}
791
792TEST_F(ExceptionsExtensionApiTest,
793 UnicodeTranslateErrorGetReasonReturnsReasonAttr) {
794 PyRun_SimpleString(R"(
795exc = UnicodeTranslateError("object", 2, 4, "reason")
796)");
797 PyObjectPtr exc(mainModuleGet("exc"));
798 PyObjectPtr result(PyUnicodeTranslateError_GetReason(exc));
799 ASSERT_NE(result, nullptr);
800 EXPECT_EQ(PyErr_Occurred(), nullptr);
801 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "reason"), 0);
802}
803
804TEST_F(ExceptionsExtensionApiTest,
805 UnicodeTranslateErrorSetReasonSetsReasonAttr) {
806 PyRun_SimpleString(R"(
807exc = UnicodeTranslateError("object", 2, 4, "reason")
808)");
809 PyObjectPtr exc(mainModuleGet("exc"));
810 PyUnicodeTranslateError_SetReason(exc, "foobar");
811 ASSERT_EQ(PyErr_Occurred(), nullptr);
812 PyObjectPtr result(PyUnicodeTranslateError_GetReason(exc));
813 ASSERT_NE(result, nullptr);
814 EXPECT_EQ(PyErr_Occurred(), nullptr);
815 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "foobar"), 0);
816}
817
818TEST_F(ExceptionsExtensionApiTest,
819 UnicodeTranslateErrorGetStartReturnsStartAttr) {
820 PyRun_SimpleString(R"(
821exc = UnicodeTranslateError("object", 2, 4, "reason")
822)");
823 PyObjectPtr exc(mainModuleGet("exc"));
824 Py_ssize_t start = 0;
825 ASSERT_EQ(PyUnicodeTranslateError_GetStart(exc, &start), 0);
826 EXPECT_EQ(PyErr_Occurred(), nullptr);
827 EXPECT_EQ(start, 2);
828}
829
830TEST_F(ExceptionsExtensionApiTest,
831 UnicodeTranslateErrorGetStartWithNonStrObjectRaisesTypeError) {
832 PyRun_SimpleString(R"(
833exc = UnicodeTranslateError("object", 2, 4, "reason")
834exc.object = 5 # not a valid object
835)");
836 PyObjectPtr exc(mainModuleGet("exc"));
837 Py_ssize_t start = 0;
838 ASSERT_EQ(PyUnicodeTranslateError_GetStart(exc, &start), -1);
839 ASSERT_NE(PyErr_Occurred(), nullptr);
840 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
841}
842
843TEST_F(ExceptionsExtensionApiTest,
844 UnicodeTranslateErrorGetStartWithNegativeStartReturnsZero) {
845 PyRun_SimpleString(R"(
846exc = UnicodeTranslateError("object", 2, 4, "reason")
847exc.start = -5
848)");
849 PyObjectPtr exc(mainModuleGet("exc"));
850 Py_ssize_t start = -1;
851 ASSERT_EQ(PyUnicodeTranslateError_GetStart(exc, &start), 0);
852 EXPECT_EQ(PyErr_Occurred(), nullptr);
853 EXPECT_EQ(start, 0);
854}
855
856TEST_F(
857 ExceptionsExtensionApiTest,
858 UnicodeTranslateErrorGetStartWithStartGreaterThanSizeReturnsSizeMinusOne) {
859 PyRun_SimpleString(R"(
860exc = UnicodeTranslateError("object", 2, 4, "reason")
861exc.start = 10
862)");
863 PyObjectPtr exc(mainModuleGet("exc"));
864 Py_ssize_t start = 0;
865 ASSERT_EQ(PyUnicodeTranslateError_GetStart(exc, &start), 0);
866 EXPECT_EQ(PyErr_Occurred(), nullptr);
867 EXPECT_EQ(start, 5);
868}
869
870TEST_F(ExceptionsExtensionApiTest, UnicodeTranslateErrorGetEndReturnsEndAttr) {
871 PyRun_SimpleString(R"(
872exc = UnicodeTranslateError("object", 2, 4, "reason")
873)");
874 PyObjectPtr exc(mainModuleGet("exc"));
875 Py_ssize_t end = 0;
876 ASSERT_EQ(PyUnicodeTranslateError_GetEnd(exc, &end), 0);
877 EXPECT_EQ(PyErr_Occurred(), nullptr);
878 EXPECT_EQ(end, 4);
879}
880
881TEST_F(ExceptionsExtensionApiTest,
882 UnicodeTranslateErrorGetEndWithNonStrObjectRaisesTypeError) {
883 PyRun_SimpleString(R"(
884exc = UnicodeTranslateError("object", 2, 4, "reason")
885exc.object = 5 # not a valid object
886)");
887 PyObjectPtr exc(mainModuleGet("exc"));
888 Py_ssize_t end = 0;
889 ASSERT_EQ(PyUnicodeTranslateError_GetEnd(exc, &end), -1);
890 ASSERT_NE(PyErr_Occurred(), nullptr);
891 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
892}
893
894TEST_F(ExceptionsExtensionApiTest,
895 UnicodeTranslateErrorGetEndWithEndLessThanOneReturnsOne) {
896 PyRun_SimpleString(R"(
897exc = UnicodeTranslateError("object", 2, 4, "reason")
898exc.end = -5
899)");
900 PyObjectPtr exc(mainModuleGet("exc"));
901 Py_ssize_t end = 0;
902 ASSERT_EQ(PyUnicodeTranslateError_GetEnd(exc, &end), 0);
903 EXPECT_EQ(PyErr_Occurred(), nullptr);
904 EXPECT_EQ(end, 1);
905}
906
907TEST_F(ExceptionsExtensionApiTest,
908 UnicodeTranslateErrorGetEndWithEndGreaterThanSizeReturnsSize) {
909 PyRun_SimpleString(R"(
910exc = UnicodeTranslateError("object", 2, 4, "reason")
911exc.end = 10
912)");
913 PyObjectPtr exc(mainModuleGet("exc"));
914 Py_ssize_t end = 0;
915 ASSERT_EQ(PyUnicodeTranslateError_GetEnd(exc, &end), 0);
916 EXPECT_EQ(PyErr_Occurred(), nullptr);
917 EXPECT_EQ(end, 6); // len("object")
918}
919
920TEST_F(ExceptionsExtensionApiTest, UnicodeTranslateErrorSetStartSetsStartAttr) {
921 PyRun_SimpleString(R"(
922exc = UnicodeTranslateError("object", 2, 4, "reason")
923)");
924 PyObjectPtr exc(mainModuleGet("exc"));
925 ASSERT_EQ(PyUnicodeTranslateError_SetStart(exc, 5), 0);
926 ASSERT_EQ(PyErr_Occurred(), nullptr);
927 Py_ssize_t start = 0;
928 ASSERT_EQ(PyUnicodeTranslateError_GetStart(exc, &start), 0);
929 EXPECT_EQ(PyErr_Occurred(), nullptr);
930 EXPECT_EQ(start, 5);
931}
932
933TEST_F(ExceptionsExtensionApiTest, UnicodeTranslateErrorSetEndSetsEndAttr) {
934 PyRun_SimpleString(R"(
935exc = UnicodeTranslateError("object", 2, 4, "reason")
936)");
937 PyObjectPtr exc(mainModuleGet("exc"));
938 ASSERT_EQ(PyUnicodeTranslateError_SetEnd(exc, 5), 0);
939 ASSERT_EQ(PyErr_Occurred(), nullptr);
940 Py_ssize_t end = 0;
941 ASSERT_EQ(PyUnicodeTranslateError_GetEnd(exc, &end), 0);
942 EXPECT_EQ(PyErr_Occurred(), nullptr);
943 EXPECT_EQ(end, 5);
944}
945
946TEST_F(ExceptionsExtensionApiTest,
947 UnicodeTranslateErrorSubclassSetEndGetEndReturnsEnd) {
948 PyRun_SimpleString(R"(
949class ErrorSubclass(UnicodeTranslateError): pass
950exc = ErrorSubclass("object", 2, 4, "reason")
951)");
952 PyObjectPtr exc(mainModuleGet("exc"));
953 ASSERT_EQ(PyUnicodeTranslateError_SetEnd(exc, 5), 0);
954 ASSERT_EQ(PyErr_Occurred(), nullptr);
955 Py_ssize_t end = 0;
956 ASSERT_EQ(PyUnicodeTranslateError_GetEnd(exc, &end), 0);
957 EXPECT_EQ(PyErr_Occurred(), nullptr);
958 EXPECT_EQ(end, 5);
959}
960
961TEST_F(ExceptionsExtensionApiTest,
962 UnicodeTranslateErrorSubclassSetStartGetStartReturnsStart) {
963 PyRun_SimpleString(R"(
964class ErrorSubclass(UnicodeTranslateError): pass
965exc = ErrorSubclass("object", 2, 4, "reason")
966)");
967 PyObjectPtr exc(mainModuleGet("exc"));
968 ASSERT_EQ(PyUnicodeTranslateError_SetStart(exc, 5), 0);
969 ASSERT_EQ(PyErr_Occurred(), nullptr);
970 Py_ssize_t end = 0;
971 ASSERT_EQ(PyUnicodeTranslateError_GetStart(exc, &end), 0);
972 EXPECT_EQ(PyErr_Occurred(), nullptr);
973 EXPECT_EQ(end, 5);
974}
975
976TEST_F(ExceptionsExtensionApiTest,
977 UnicodeTranslateErrorSubclassSetReasonGetReasonReturnsReason) {
978 PyRun_SimpleString(R"(
979class ErrorSubclass(UnicodeTranslateError): pass
980exc = ErrorSubclass("object", 2, 4, "reason")
981)");
982 PyObjectPtr exc(mainModuleGet("exc"));
983 PyUnicodeTranslateError_SetReason(exc, "foobar");
984 ASSERT_EQ(PyErr_Occurred(), nullptr);
985 PyObjectPtr result(PyUnicodeTranslateError_GetReason(exc));
986 EXPECT_EQ(PyErr_Occurred(), nullptr);
987 ASSERT_NE(result, nullptr);
988 EXPECT_EQ(PyUnicode_CompareWithASCIIString(result, "foobar"), 0);
989}
990
991} // namespace testing
992} // namespace py