bernsteinbear.com
this repo has no description
1// Copyright (c) Facebook, Inc. and its affiliates. (http://www.facebook.com)
2#include <cmath>
3
4#include "Python.h"
5#include "gtest/gtest.h"
6
7#include "capi-fixture.h"
8#include "capi-testing.h"
9
10namespace py {
11namespace testing {
12
13using LongExtensionApiTest = ExtensionApi;
14
15TEST_F(LongExtensionApiTest, GCDWithSameNumberReturnsSameNumber) {
16 PyObjectPtr dividend(PyLong_FromLong(3));
17 PyObjectPtr divisor(PyLong_FromLong(3));
18 EXPECT_EQ(PyLong_AsLong(_PyLong_GCD(dividend, divisor)), 3);
19}
20
21TEST_F(LongExtensionApiTest, GCDWithDifferentNumbersReturnsGCD) {
22 PyObjectPtr dividend(PyLong_FromLong(3));
23 PyObjectPtr divisor(PyLong_FromLong(6));
24 EXPECT_EQ(PyLong_AsLong(_PyLong_GCD(dividend, divisor)), 3);
25}
26
27TEST_F(LongExtensionApiTest, GCDWithOneNegativeReturnsPositive) {
28 PyObjectPtr dividend(PyLong_FromLong(-3));
29 PyObjectPtr divisor(PyLong_FromLong(3));
30 EXPECT_EQ(PyLong_AsLong(_PyLong_GCD(dividend, divisor)), 3);
31}
32
33TEST_F(LongExtensionApiTest, GCDWithBothNegativeReturnsPositive) {
34 PyObjectPtr dividend(PyLong_FromLong(-1));
35 PyObjectPtr divisor(PyLong_FromLong(-2));
36 EXPECT_EQ(PyLong_AsLong(_PyLong_GCD(dividend, divisor)), 1);
37}
38
39TEST_F(LongExtensionApiTest, GCDWithZeroAndThreeReturnsThree) {
40 PyObjectPtr dividend(PyLong_FromLong(0));
41 PyObjectPtr divisor(PyLong_FromLong(3));
42 EXPECT_EQ(PyLong_AsLong(_PyLong_GCD(dividend, divisor)), 3);
43}
44
45TEST_F(LongExtensionApiTest, GCDWithThreeAndZeroReturnsThree) {
46 PyObjectPtr dividend(PyLong_FromLong(3));
47 PyObjectPtr divisor(PyLong_FromLong(0));
48 EXPECT_EQ(PyLong_AsLong(_PyLong_GCD(dividend, divisor)), 3);
49}
50TEST_F(LongExtensionApiTest, GCDWithZeroandNegativeReturnsOne) {
51 PyObjectPtr dividend(PyLong_FromLong(0));
52 PyObjectPtr divisor(PyLong_FromLong(-1));
53 EXPECT_EQ(PyLong_AsLong(_PyLong_GCD(dividend, divisor)), 1);
54}
55
56TEST_F(LongExtensionApiTest, GCDWithsSameLargeIntsReturnsSame) {
57 PyObjectPtr dividend(PyLong_FromString("7FFFFFFFFFFFFFFF", nullptr, 16));
58 PyObjectPtr divisor(PyLong_FromString("7FFFFFFFFFFFFFFF", nullptr, 16));
59 PyObjectPtr expected(PyLong_FromString("7FFFFFFFFFFFFFFF", nullptr, 16));
60 int res =
61 PyObject_RichCompareBool(_PyLong_GCD(dividend, divisor), expected, Py_EQ);
62 EXPECT_EQ(res, 1);
63}
64
65TEST_F(LongExtensionApiTest, GCDWithLargeIntsReturnsGCD) {
66 PyObjectPtr dividend(PyLong_FromString("7FFFFFFFFFFFFFFF", nullptr, 16));
67 PyObjectPtr divisor(PyLong_FromString("FFFFFFFFFFFFFFFE", nullptr, 16));
68 PyObjectPtr expected(PyLong_FromString("7FFFFFFFFFFFFFFF", nullptr, 16));
69 int res =
70 PyObject_RichCompareBool(_PyLong_GCD(dividend, divisor), expected, Py_EQ);
71 EXPECT_EQ(res, 1);
72}
73
74TEST_F(LongExtensionApiTest, GCDWithLargeIntsReturnsSmallIntGCD) {
75 PyObjectPtr dividend(PyLong_FromString("FFFFFFFFFFFFFFFE", nullptr, 16));
76 PyObjectPtr divisor(PyLong_FromString("10000000000000002", nullptr, 16));
77 EXPECT_EQ(PyLong_AsLong(_PyLong_GCD(dividend, divisor)), 2);
78}
79
80TEST_F(LongExtensionApiTest, CheckWithIntReturnsTrue) {
81 PyObjectPtr pylong(PyLong_FromLong(10));
82 EXPECT_TRUE(PyLong_Check(pylong));
83 EXPECT_TRUE(PyLong_CheckExact(pylong));
84
85 pylong = PyLong_FromLongLong(10);
86 EXPECT_TRUE(PyLong_Check(pylong));
87 EXPECT_TRUE(PyLong_CheckExact(pylong));
88
89 pylong = PyLong_FromUnsignedLong(10);
90 EXPECT_TRUE(PyLong_Check(pylong));
91 EXPECT_TRUE(PyLong_CheckExact(pylong));
92
93 pylong = PyLong_FromUnsignedLongLong(10);
94 EXPECT_TRUE(PyLong_Check(pylong));
95 EXPECT_TRUE(PyLong_CheckExact(pylong));
96
97 pylong = PyLong_FromSsize_t(10);
98 EXPECT_TRUE(PyLong_Check(pylong));
99 EXPECT_TRUE(PyLong_CheckExact(pylong));
100}
101
102TEST_F(LongExtensionApiTest, CheckWithIntSubclass) {
103 PyRun_SimpleString(R"(
104class X(int): pass
105x = X()
106)");
107 PyObjectPtr x(mainModuleGet("x"));
108 EXPECT_TRUE(PyLong_Check(x));
109 EXPECT_FALSE(PyLong_CheckExact(x));
110}
111
112TEST_F(LongExtensionApiTest, CheckExactWithBoolReturnsFalse) {
113 EXPECT_TRUE(PyLong_Check(Py_False));
114 EXPECT_TRUE(PyLong_Check(Py_True));
115 EXPECT_FALSE(PyLong_CheckExact(Py_False));
116 EXPECT_FALSE(PyLong_CheckExact(Py_True));
117}
118
119TEST_F(LongExtensionApiTest, CheckWithTypeReturnsFalse) {
120 PyObjectPtr pylong(PyLong_FromLong(10));
121 PyObject* type = reinterpret_cast<PyObject*>(Py_TYPE(pylong));
122 EXPECT_FALSE(PyLong_Check(type));
123 EXPECT_FALSE(PyLong_CheckExact(type));
124}
125
126TEST_F(LongExtensionApiTest, AsDoubleWithNullRaisesSystemError) {
127 EXPECT_EQ(PyLong_AsDouble(nullptr), -1.0);
128 ASSERT_NE(PyErr_Occurred(), nullptr);
129 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_SystemError));
130}
131
132TEST_F(LongExtensionApiTest, AsDoubleWithNonIntRaisesTypeError) {
133 PyObjectPtr obj(PyList_New(0));
134 EXPECT_EQ(PyLong_AsDouble(obj), -1.0);
135 ASSERT_NE(PyErr_Occurred(), nullptr);
136 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
137}
138
139TEST_F(LongExtensionApiTest, AsDoubleWithSmallIntReturnsDouble) {
140 PyObjectPtr obj(PyLong_FromLong(10));
141 EXPECT_EQ(PyLong_AsDouble(obj), 10.0);
142 EXPECT_EQ(PyErr_Occurred(), nullptr);
143}
144
145TEST_F(LongExtensionApiTest, AsDoubleWithNegativeIntReturnsDouble) {
146 PyObjectPtr obj(PyLong_FromLong(-40));
147 EXPECT_EQ(PyLong_AsDouble(obj), -40.0);
148 EXPECT_EQ(PyErr_Occurred(), nullptr);
149}
150
151TEST_F(LongExtensionApiTest, AsDoubleWithLargeIntReturnsDouble) {
152 unsigned char bytes[9] = {1};
153 double expected = std::pow(2, 64);
154 PyObjectPtr obj(_PyLong_FromByteArray(bytes, sizeof(bytes), false, false));
155 EXPECT_EQ(PyLong_AsDouble(obj), expected);
156 EXPECT_EQ(PyErr_Occurred(), nullptr);
157}
158
159TEST_F(LongExtensionApiTest, AsDoubleWithIntSubclassReturnsDouble) {
160 PyRun_SimpleString(R"(
161class X(int): pass
162x = X(42)
163)");
164 PyObjectPtr x(mainModuleGet("x"));
165 ASSERT_EQ(PyErr_Occurred(), nullptr);
166 EXPECT_EQ(PyLong_AsDouble(x), 42.0);
167}
168
169TEST_F(LongExtensionApiTest, AsDoubleWithOverflowRaisesOverflowError) {
170 unsigned char bytes[129] = {1};
171 PyObjectPtr obj(_PyLong_FromByteArray(bytes, sizeof(bytes), false, false));
172 EXPECT_EQ(PyLong_AsDouble(obj), -1.0);
173 ASSERT_NE(PyErr_Occurred(), nullptr);
174 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
175}
176
177TEST_F(LongExtensionApiTest, AsIntWithNullRaisesSystemError) {
178 ASSERT_EQ(_PyLong_AsInt(nullptr), -1);
179 ASSERT_NE(PyErr_Occurred(), nullptr);
180 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_SystemError));
181}
182
183TEST_F(LongExtensionApiTest, AsIntWithNonIntegerRaisesTypeError) {
184 ASSERT_EQ(_PyLong_AsInt(Py_None), -1);
185 ASSERT_NE(PyErr_Occurred(), nullptr);
186 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
187}
188
189TEST_F(LongExtensionApiTest, AsIntWithLongMaxRaisesOverflowError) {
190 PyObjectPtr num(PyLong_FromLongLong(static_cast<long long>(INT_MAX) + 1));
191 ASSERT_EQ(_PyLong_AsInt(num), -1);
192 ASSERT_NE(PyErr_Occurred(), nullptr);
193 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
194}
195
196TEST_F(LongExtensionApiTest, AsIntWithIntSubclassReturnsInt) {
197 PyRun_SimpleString(R"(
198class X(int): pass
199x = X(42)
200)");
201 PyObjectPtr x(mainModuleGet("x"));
202 ASSERT_EQ(PyErr_Occurred(), nullptr);
203 EXPECT_EQ(_PyLong_AsInt(x), 42);
204}
205
206TEST_F(LongExtensionApiTest, AsIntWithInvalidDunderIntRaisesTypeError) {
207 PyRun_SimpleString(R"(
208class X:
209 def __int__(self): return ""
210x = X()
211)");
212 PyObjectPtr x(mainModuleGet("x"));
213 ASSERT_EQ(_PyLong_AsInt(x), -1);
214 ASSERT_NE(PyErr_Occurred(), nullptr);
215 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
216}
217
218TEST_F(LongExtensionApiTest, AsIntWithValidDunderIntReturnsInt) {
219 PyRun_SimpleString(R"(
220class X:
221 def __int__(self): return 42
222x = X()
223)");
224 PyObjectPtr x(mainModuleGet("x"));
225 ASSERT_EQ(PyErr_Occurred(), nullptr);
226 EXPECT_EQ(_PyLong_AsInt(x), 42);
227}
228
229TEST_F(LongExtensionApiTest, AsLongWithNullReturnsNegative) {
230 long res = PyLong_AsLong(nullptr);
231 EXPECT_EQ(res, -1);
232
233 ASSERT_NE(PyErr_Occurred(), nullptr);
234 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_SystemError));
235}
236
237TEST_F(LongExtensionApiTest, AsLongWithNonIntegerReturnsNegative) {
238 long res = PyLong_AsLong(Py_None);
239 EXPECT_EQ(res, -1);
240 EXPECT_NE(PyErr_Occurred(), nullptr);
241 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
242}
243
244TEST_F(LongExtensionApiTest, AsLongWithIntSubclassReturnsLong) {
245 PyRun_SimpleString(R"(
246class X(int): pass
247x = X(42)
248)");
249 PyObjectPtr x(mainModuleGet("x"));
250 ASSERT_EQ(PyErr_Occurred(), nullptr);
251 EXPECT_EQ(PyLong_AsLong(x), 42);
252}
253
254TEST_F(LongExtensionApiTest, AsLongWithInvalidDunderInt) {
255 PyRun_SimpleString(R"(
256class X:
257 def __int__(self):
258 return "not an int"
259x = X()
260)");
261 PyObjectPtr x(mainModuleGet("x"));
262 EXPECT_EQ(PyLong_AsLong(x), -1l);
263 EXPECT_NE(PyErr_Occurred(), nullptr);
264 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
265}
266
267TEST_F(LongExtensionApiTest, AsLongWithValidDunderInt) {
268 PyRun_SimpleString(R"(
269class X:
270 def __int__(self):
271 return -7
272x = X()
273)");
274 PyObjectPtr x(mainModuleGet("x"));
275 EXPECT_EQ(PyLong_AsLong(x), -7);
276 EXPECT_EQ(PyErr_Occurred(), nullptr);
277}
278
279TEST_F(LongExtensionApiTest, AsLongWithBoolReturnsLong) {
280 EXPECT_EQ(PyLong_AsLong(Py_True), 1);
281 EXPECT_EQ(PyLong_AsLong(Py_False), 0);
282}
283
284TEST_F(LongExtensionApiTest, FromStringReturnsLong) {
285 PyObjectPtr long0(PyLong_FromString("1", nullptr, 10));
286 ASSERT_EQ(PyErr_Occurred(), nullptr);
287 EXPECT_TRUE(PyLong_CheckExact(long0));
288 EXPECT_EQ(PyLong_AsSsize_t(long0), 1);
289
290 PyObjectPtr long1(PyLong_FromString("1000", nullptr, 10));
291 ASSERT_EQ(PyErr_Occurred(), nullptr);
292 EXPECT_TRUE(PyLong_CheckExact(long1));
293 EXPECT_EQ(PyLong_AsSsize_t(long1), 1000);
294
295 PyObjectPtr long2(PyLong_FromString("100", nullptr, 2));
296 ASSERT_EQ(PyErr_Occurred(), nullptr);
297 EXPECT_TRUE(PyLong_CheckExact(long2));
298 EXPECT_EQ(PyLong_AsSsize_t(long2), 4);
299}
300
301TEST_F(LongExtensionApiTest, FromStringWithInvalidIntRaisesValueError) {
302 EXPECT_EQ(PyLong_FromString("foo", nullptr, 10), nullptr);
303 ASSERT_NE(PyErr_Occurred(), nullptr);
304 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_ValueError));
305}
306
307TEST_F(LongExtensionApiTest, FromLongReturnsLong) {
308 const int val = 10;
309 PyObjectPtr pylong(PyLong_FromLong(val));
310 ASSERT_EQ(PyErr_Occurred(), nullptr);
311 EXPECT_TRUE(PyLong_CheckExact(pylong));
312
313 EXPECT_EQ(PyLong_AsLong(pylong), val);
314 EXPECT_EQ(PyLong_AsLongLong(pylong), val);
315 EXPECT_EQ(PyLong_AsSsize_t(pylong), val);
316
317 auto const val2 = std::numeric_limits<long>::min();
318 PyObjectPtr pylong2(PyLong_FromLong(val2));
319 ASSERT_EQ(PyErr_Occurred(), nullptr);
320 EXPECT_TRUE(PyLong_CheckExact(pylong2));
321 EXPECT_EQ(PyLong_AsLong(pylong2), val2);
322
323 auto const val3 = std::numeric_limits<long>::max();
324 PyObjectPtr pylong3(PyLong_FromLong(val3));
325 ASSERT_EQ(PyErr_Occurred(), nullptr);
326 EXPECT_TRUE(PyLong_CheckExact(pylong3));
327 EXPECT_EQ(PyLong_AsLong(pylong3), val3);
328}
329
330TEST_F(LongExtensionApiTest, FromUnsignedReturnsLong) {
331 auto const ulmax = std::numeric_limits<unsigned long>::max();
332 PyObjectPtr pylong(PyLong_FromUnsignedLong(ulmax));
333 ASSERT_EQ(PyErr_Occurred(), nullptr);
334 EXPECT_TRUE(PyLong_CheckExact(pylong));
335 EXPECT_EQ(PyLong_AsUnsignedLong(pylong), ulmax);
336 EXPECT_EQ(PyLong_AsUnsignedLongLong(pylong), ulmax);
337 EXPECT_EQ(PyLong_AsSize_t(pylong), ulmax);
338
339 auto const ullmax = std::numeric_limits<unsigned long long>::max();
340 PyObjectPtr pylong2(PyLong_FromUnsignedLongLong(ullmax));
341 ASSERT_EQ(PyErr_Occurred(), nullptr);
342 EXPECT_TRUE(PyLong_CheckExact(pylong2));
343 EXPECT_EQ(PyLong_AsUnsignedLongLong(pylong2), ullmax);
344
345 auto const uval = 1234UL;
346 PyObjectPtr pylong3(PyLong_FromUnsignedLong(uval));
347 ASSERT_EQ(PyErr_Occurred(), nullptr);
348 EXPECT_TRUE(PyLong_CheckExact(pylong3));
349 EXPECT_EQ(PyLong_AsUnsignedLong(pylong3), uval);
350}
351
352static PyObject* lshift(long num, long shift) {
353 PyObject* num_obj = PyLong_FromLong(num);
354 PyObject* shift_obj = PyLong_FromLong(shift);
355 PyObject* result = PyNumber_Lshift(num_obj, shift_obj);
356 Py_DECREF(num_obj);
357 Py_DECREF(shift_obj);
358 return result;
359}
360
361TEST_F(LongExtensionApiTest, NumBitsWithZeroReturnsZero) {
362 PyObjectPtr num(PyLong_FromLong(0));
363 EXPECT_EQ(_PyLong_NumBits(num), size_t{0});
364}
365
366TEST_F(LongExtensionApiTest, NumBitsWithOneReturnsOne) {
367 PyObjectPtr num(PyLong_FromLong(1));
368 EXPECT_EQ(_PyLong_NumBits(num), size_t{1});
369}
370
371TEST_F(LongExtensionApiTest, NumBitsWithNegativeOneReturnsOne) {
372 PyObjectPtr num(PyLong_FromLong(-1));
373 EXPECT_EQ(_PyLong_NumBits(num), size_t{1});
374}
375
376TEST_F(LongExtensionApiTest, NumBitsWithTwoReturnsTwo) {
377 PyObjectPtr num(PyLong_FromLong(2));
378 EXPECT_EQ(_PyLong_NumBits(num), size_t{2});
379}
380
381TEST_F(LongExtensionApiTest, NumBitsWithNegativeTwoReturnsTwo) {
382 PyObjectPtr num(PyLong_FromLong(-2));
383 EXPECT_EQ(_PyLong_NumBits(num), size_t{2});
384}
385
386TEST_F(LongExtensionApiTest, NumBitsWithThreeReturnsTwo) {
387 PyObjectPtr num(PyLong_FromLong(3));
388 EXPECT_EQ(_PyLong_NumBits(num), size_t{2});
389}
390
391TEST_F(LongExtensionApiTest, NumBitsWithNegativeThreeReturnsTwo) {
392 PyObjectPtr num(PyLong_FromLong(-3));
393 EXPECT_EQ(_PyLong_NumBits(num), size_t{2});
394}
395
396TEST_F(LongExtensionApiTest, NumBitsWithFourReturnsThree) {
397 PyObjectPtr num(PyLong_FromLong(4));
398 EXPECT_EQ(_PyLong_NumBits(num), size_t{3});
399}
400
401TEST_F(LongExtensionApiTest, NumBitsWithNegativeFourReturnsThree) {
402 PyObjectPtr num(PyLong_FromLong(-4));
403 EXPECT_EQ(_PyLong_NumBits(num), size_t{3});
404}
405
406TEST_F(LongExtensionApiTest, NumBitsCpythonTests) {
407 PyObjectPtr i0(PyLong_FromLong(0x7fffL));
408 EXPECT_EQ(_PyLong_NumBits(i0), size_t{15});
409 PyObjectPtr negative_i0(PyLong_FromLong(-0x7fffL));
410 EXPECT_EQ(_PyLong_NumBits(negative_i0), size_t{15});
411
412 PyObjectPtr i1(PyLong_FromLong(0xffffL));
413 EXPECT_EQ(_PyLong_NumBits(i1), size_t{16});
414 PyObjectPtr negative_i1(PyLong_FromLong(-0xffffL));
415 EXPECT_EQ(_PyLong_NumBits(negative_i1), size_t{16});
416
417 PyObjectPtr i2(PyLong_FromLong(0xfffffffL));
418 EXPECT_EQ(_PyLong_NumBits(i2), size_t{28});
419 PyObjectPtr negative_i2(PyLong_FromLong(-0xfffffffL));
420 EXPECT_EQ(_PyLong_NumBits(negative_i2), size_t{28});
421
422 PyObjectPtr i3(PyLong_FromLong(PY_SSIZE_T_MAX));
423 EXPECT_EQ(_PyLong_NumBits(i3), size_t{63});
424 PyObjectPtr negative_i3(PyLong_FromLong(PY_SSIZE_T_MIN));
425 EXPECT_EQ(_PyLong_NumBits(negative_i3), size_t{64});
426}
427
428TEST_F(LongExtensionApiTest, Overflow) {
429 PyObjectPtr pylong(lshift(1, 100));
430
431 EXPECT_EQ(PyLong_AsUnsignedLong(pylong), -1UL);
432 ASSERT_NE(PyErr_Occurred(), nullptr);
433 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
434 PyErr_Clear();
435
436 EXPECT_EQ(PyLong_AsLong(pylong), -1);
437 ASSERT_NE(PyErr_Occurred(), nullptr);
438 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
439 PyErr_Clear();
440
441 EXPECT_EQ(PyLong_AsSsize_t(pylong), -1);
442 ASSERT_NE(PyErr_Occurred(), nullptr);
443 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
444 PyErr_Clear();
445
446 pylong = PyLong_FromLong(-123);
447 EXPECT_EQ(PyLong_AsUnsignedLongLong(pylong), -1ULL);
448 ASSERT_NE(PyErr_Occurred(), nullptr);
449 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
450}
451
452TEST_F(LongExtensionApiTest, AsLongAndOverflow) {
453 auto const ulmax = std::numeric_limits<unsigned long>::max();
454 auto const lmax = std::numeric_limits<long>::max();
455
456 PyObjectPtr pylong(PyLong_FromUnsignedLong(ulmax));
457 ASSERT_EQ(PyErr_Occurred(), nullptr);
458 int overflow = 0;
459 EXPECT_EQ(PyLong_AsLongAndOverflow(pylong, &overflow), -1);
460 EXPECT_EQ(overflow, 1);
461 overflow = 0;
462 EXPECT_EQ(PyLong_AsLongLongAndOverflow(pylong, &overflow), -1);
463 EXPECT_EQ(overflow, 1);
464
465 pylong = PyLong_FromLong(lmax);
466 ASSERT_EQ(PyErr_Occurred(), nullptr);
467 overflow = 1;
468 EXPECT_EQ(PyLong_AsLongAndOverflow(pylong, &overflow), lmax);
469 EXPECT_EQ(overflow, 0);
470 overflow = 1;
471 EXPECT_EQ(PyLong_AsLongLongAndOverflow(pylong, &overflow), lmax);
472 EXPECT_EQ(overflow, 0);
473
474 pylong = lshift(-1, 100);
475 overflow = 0;
476 EXPECT_EQ(PyLong_AsLongAndOverflow(pylong, &overflow), -1);
477 EXPECT_EQ(overflow, -1);
478 overflow = 0;
479 EXPECT_EQ(PyLong_AsLongLongAndOverflow(pylong, &overflow), -1);
480 EXPECT_EQ(overflow, -1);
481}
482
483TEST_F(LongExtensionApiTest, AsUnsignedLongMaskWithMax) {
484 auto const ulmax = std::numeric_limits<unsigned long>::max();
485 PyObjectPtr pylong(PyLong_FromUnsignedLong(ulmax));
486 EXPECT_EQ(PyLong_AsUnsignedLongMask(pylong), ulmax);
487 EXPECT_EQ(PyErr_Occurred(), nullptr);
488 EXPECT_EQ(PyLong_AsUnsignedLongLongMask(pylong), ulmax);
489 EXPECT_EQ(PyErr_Occurred(), nullptr);
490
491 auto const ullmax = std::numeric_limits<unsigned long long>::max();
492 pylong = PyLong_FromUnsignedLongLong(ullmax);
493 EXPECT_EQ(PyLong_AsUnsignedLongLongMask(pylong), ullmax);
494 EXPECT_EQ(PyErr_Occurred(), nullptr);
495}
496
497TEST_F(LongExtensionApiTest, AsUnsignedLongMaskWithLargeInt) {
498 PyObjectPtr largeint(lshift(1, 100));
499 PyObjectPtr pylong(PyNumber_Or(largeint, PyObjectPtr(PyLong_FromLong(123))));
500 EXPECT_EQ(PyLong_AsUnsignedLongMask(pylong), 123UL);
501 EXPECT_EQ(PyErr_Occurred(), nullptr);
502 EXPECT_EQ(PyLong_AsUnsignedLongLongMask(pylong), 123ULL);
503 EXPECT_EQ(PyErr_Occurred(), nullptr);
504}
505
506TEST_F(LongExtensionApiTest, AsUnsignedLongMaskWithNegative) {
507 PyObjectPtr pylong(PyLong_FromLong(-17));
508 EXPECT_EQ(PyLong_AsUnsignedLongMask(pylong), -17UL);
509 EXPECT_EQ(PyErr_Occurred(), nullptr);
510 EXPECT_EQ(PyLong_AsUnsignedLongLongMask(pylong), -17ULL);
511 EXPECT_EQ(PyErr_Occurred(), nullptr);
512}
513
514TEST_F(LongExtensionApiTest, FromLongWithZeroReturnsZero) {
515 PyObjectPtr pylong(PyLong_FromLong(0));
516 ASSERT_EQ(PyErr_Occurred(), nullptr);
517 ASSERT_TRUE(PyLong_CheckExact(pylong));
518 EXPECT_EQ(PyLong_AsLong(pylong), 0);
519}
520
521TEST_F(LongExtensionApiTest,
522 AsByteArrayUnsignedWithNegativeRaisesOverflowError) {
523 PyObjectPtr num(PyLong_FromLong(-1));
524 PyLongObject* obj = num.asLongObject();
525 unsigned char dst[1];
526 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, false), -1);
527 ASSERT_NE(PyErr_Occurred(), nullptr);
528 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
529}
530
531TEST_F(LongExtensionApiTest, AsByteArrayUnsignedWithZeroWritesZero) {
532 PyObjectPtr num(PyLong_FromLong(0));
533 PyLongObject* obj = num.asLongObject();
534 unsigned char dst[1];
535 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, false), 0);
536 ASSERT_EQ(PyErr_Occurred(), nullptr);
537 EXPECT_EQ(dst[0], 0);
538}
539
540TEST_F(LongExtensionApiTest, AsByteArrayUnsignedWritesMaxUnsignedByte) {
541 PyObjectPtr num(PyLong_FromLong(0xff));
542 PyLongObject* obj = num.asLongObject();
543 unsigned char dst[1];
544 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, false), 0);
545 ASSERT_EQ(PyErr_Occurred(), nullptr);
546 EXPECT_EQ(dst[0], 0xff);
547}
548
549TEST_F(LongExtensionApiTest,
550 AsByteArrayUnsignedOverflowWritesByteAndRaisesOverflowError) {
551 PyObjectPtr num(PyLong_FromLong(0x0100));
552 PyLongObject* obj = num.asLongObject();
553 unsigned char dst[1];
554 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, true), -1);
555 ASSERT_NE(PyErr_Occurred(), nullptr);
556 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
557 EXPECT_EQ(dst[0], 0x00);
558}
559
560TEST_F(LongExtensionApiTest, AsByteArrayUnsignedWritesBytesBigEndian) {
561 PyObjectPtr num(PyLong_FromLong(0xface));
562 PyLongObject* obj = num.asLongObject();
563 unsigned char dst[3];
564 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, false), 0);
565 ASSERT_EQ(PyErr_Occurred(), nullptr);
566 EXPECT_EQ(dst[0], 0x00);
567 EXPECT_EQ(dst[1], 0xfa);
568 EXPECT_EQ(dst[2], 0xce);
569}
570
571TEST_F(LongExtensionApiTest, AsByteArrayUnsigedWritesBytesLittleEndian) {
572 PyObjectPtr num(PyLong_FromLong(0xface));
573 PyLongObject* obj = num.asLongObject();
574 unsigned char dst[3];
575 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), true, false), 0);
576 ASSERT_EQ(PyErr_Occurred(), nullptr);
577 EXPECT_EQ(dst[0], 0xce);
578 EXPECT_EQ(dst[1], 0xfa);
579 EXPECT_EQ(dst[2], 0x00);
580}
581
582TEST_F(LongExtensionApiTest, AsByteArraySignedWritesMaxSignedByte) {
583 PyObjectPtr num(PyLong_FromLong(0x7f));
584 PyLongObject* obj = num.asLongObject();
585 unsigned char dst[1];
586 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, true), 0);
587 ASSERT_EQ(PyErr_Occurred(), nullptr);
588 EXPECT_EQ(dst[0], 0x7f);
589}
590
591TEST_F(LongExtensionApiTest, AsByteArraySignedWritesMinSignedByte) {
592 PyObjectPtr num(PyLong_FromLong(-0x80));
593 PyLongObject* obj = num.asLongObject();
594 unsigned char dst[1];
595 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, true), 0);
596 ASSERT_EQ(PyErr_Occurred(), nullptr);
597 EXPECT_EQ(dst[0], 0x80);
598}
599
600TEST_F(LongExtensionApiTest,
601 AsByteArraySignedOverflowWritesByteAndRaisesOverflowError) {
602 PyObjectPtr num(PyLong_FromLong(0x80));
603 PyLongObject* obj = num.asLongObject();
604 unsigned char dst[1];
605 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, true), -1);
606 ASSERT_NE(PyErr_Occurred(), nullptr);
607 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
608 EXPECT_EQ(dst[0], 0x80);
609}
610
611TEST_F(LongExtensionApiTest,
612 AsByteArraySignedUnderflowWritesByteAndRaisesOverflowError) {
613 PyObjectPtr num(PyLong_FromLong(-0x81));
614 PyLongObject* obj = num.asLongObject();
615 unsigned char dst[1];
616 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, true), -1);
617 ASSERT_NE(PyErr_Occurred(), nullptr);
618 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
619 EXPECT_EQ(dst[0], 0x7f);
620}
621
622TEST_F(LongExtensionApiTest, AsByteArraySignedPositiveWritesBytesBigEndian) {
623 PyObjectPtr num(PyLong_FromLong(0xface));
624 PyLongObject* obj = num.asLongObject();
625 unsigned char dst[3];
626 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, true), 0);
627 ASSERT_EQ(PyErr_Occurred(), nullptr);
628 EXPECT_EQ(dst[0], 0x00);
629 EXPECT_EQ(dst[1], 0xfa);
630 EXPECT_EQ(dst[2], 0xce);
631}
632
633TEST_F(LongExtensionApiTest, AsByteArraySignedPositiveWritesBytesLittleEndian) {
634 PyObjectPtr num(PyLong_FromLong(0xface));
635 PyLongObject* obj = num.asLongObject();
636 unsigned char dst[3];
637 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), true, true), 0);
638 ASSERT_EQ(PyErr_Occurred(), nullptr);
639 EXPECT_EQ(dst[0], 0xce);
640 EXPECT_EQ(dst[1], 0xfa);
641 EXPECT_EQ(dst[2], 0x00);
642}
643
644TEST_F(LongExtensionApiTest, AsByteArraySignedNegativeWritesBytesBigEndian) {
645 PyObjectPtr num(PyLong_FromLong(-0xface));
646 PyLongObject* obj = num.asLongObject();
647 unsigned char dst[3];
648 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, true), 0);
649 ASSERT_EQ(PyErr_Occurred(), nullptr);
650 EXPECT_EQ(dst[0], 0xff);
651 EXPECT_EQ(dst[1], 0x05);
652 EXPECT_EQ(dst[2], 0x32);
653}
654
655TEST_F(LongExtensionApiTest, AsByteArraySignedNegativeWritesBytesLittleEndian) {
656 PyObjectPtr num(PyLong_FromLong(-0xface));
657 PyLongObject* obj = num.asLongObject();
658 unsigned char dst[3];
659 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), true, true), 0);
660 ASSERT_EQ(PyErr_Occurred(), nullptr);
661 EXPECT_EQ(dst[0], 0x32);
662 EXPECT_EQ(dst[1], 0x05);
663 EXPECT_EQ(dst[2], 0xff);
664}
665
666TEST_F(LongExtensionApiTest, AsByteArrayWithIntSubclassWritesBytes) {
667 PyRun_SimpleString(R"(
668class X(int): pass
669x = X(0xface)
670)");
671 PyObjectPtr x(mainModuleGet("x"));
672 PyLongObject* obj = x.asLongObject();
673 unsigned char dst[3];
674 ASSERT_EQ(_PyLong_AsByteArray(obj, dst, sizeof(dst), false, true), 0);
675 ASSERT_EQ(PyErr_Occurred(), nullptr);
676 EXPECT_EQ(dst[0], 0x00);
677 EXPECT_EQ(dst[1], 0xfa);
678 EXPECT_EQ(dst[2], 0xce);
679}
680
681TEST_F(LongExtensionApiTest, CopyWithIntReturnsInt) {
682 PyObjectPtr x(PyLong_FromLong(42));
683 PyObjectPtr result(_PyLong_Copy(x.asLongObject()));
684 EXPECT_TRUE(PyLong_CheckExact(result));
685 EXPECT_TRUE(isLongEqualsLong(result, 42));
686}
687
688TEST_F(LongExtensionApiTest, CopyWithIntSubclassReturnsExactInt) {
689 PyRun_SimpleString(R"(
690class X(int): pass
691x = X(42)
692)");
693 PyObjectPtr x(mainModuleGet("x"));
694 PyObjectPtr result(_PyLong_Copy(x.asLongObject()));
695 EXPECT_TRUE(PyLong_CheckExact(result));
696 EXPECT_TRUE(isLongEqualsLong(result, 42));
697}
698
699TEST_F(LongExtensionApiTest, DivmodNearWithNonIntDividendRaisesTypeError) {
700 PyObjectPtr a(PyUnicode_FromString("not an int"));
701 PyObjectPtr b(PyLong_FromLong(0));
702 ASSERT_EQ(_PyLong_DivmodNear(a, b), nullptr);
703 ASSERT_NE(PyErr_Occurred(), nullptr);
704 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
705}
706
707TEST_F(LongExtensionApiTest, DivmodNearWithNonIntDivisorRaisesTypeError) {
708 PyObjectPtr a(PyLong_FromLong(0));
709 PyObjectPtr b(PyUnicode_FromString("not an int"));
710 ASSERT_EQ(_PyLong_DivmodNear(a, b), nullptr);
711 ASSERT_NE(PyErr_Occurred(), nullptr);
712 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
713}
714
715TEST_F(LongExtensionApiTest, DivmodNearWithZeroDivisorRaisesZeroDivisionError) {
716 PyObjectPtr a(PyLong_FromLong(0));
717 PyObjectPtr b(PyLong_FromLong(0));
718 ASSERT_EQ(_PyLong_DivmodNear(a, b), nullptr);
719 ASSERT_NE(PyErr_Occurred(), nullptr);
720 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_ZeroDivisionError));
721}
722
723TEST_F(LongExtensionApiTest, DivmodNearRoundsToEven) {
724 PyObjectPtr a(PyLong_FromLong(44));
725 PyObjectPtr b(PyLong_FromLong(8));
726 PyObjectPtr result(_PyLong_DivmodNear(a, b));
727 ASSERT_TRUE(PyTuple_CheckExact(result));
728 ASSERT_EQ(PyTuple_Size(result), 2);
729
730 PyObject* quotient = PyTuple_GetItem(result, 0);
731 ASSERT_TRUE(PyLong_CheckExact(quotient));
732 EXPECT_EQ(PyLong_AsLong(quotient), 6);
733
734 PyObject* remainder = PyTuple_GetItem(result, 1);
735 ASSERT_TRUE(PyLong_CheckExact(remainder));
736 EXPECT_EQ(PyLong_AsLong(remainder), -4);
737}
738
739TEST_F(LongExtensionApiTest, DivmodNearWithNegativeDividendReturnsTuple) {
740 PyObjectPtr a(PyLong_FromLong(-43));
741 PyObjectPtr b(PyLong_FromLong(5));
742 PyObjectPtr result(_PyLong_DivmodNear(a, b));
743 ASSERT_TRUE(PyTuple_CheckExact(result));
744 ASSERT_EQ(PyTuple_Size(result), 2);
745
746 PyObject* quotient = PyTuple_GetItem(result, 0);
747 ASSERT_TRUE(PyLong_CheckExact(quotient));
748 EXPECT_EQ(PyLong_AsLong(quotient), -9);
749
750 PyObject* remainder = PyTuple_GetItem(result, 1);
751 ASSERT_TRUE(PyLong_CheckExact(remainder));
752 EXPECT_EQ(PyLong_AsLong(remainder), 2);
753}
754
755TEST_F(LongExtensionApiTest, DivmodNearWithNegativeDivisorReturnsTuple) {
756 PyObjectPtr a(PyLong_FromLong(43));
757 PyObjectPtr b(PyLong_FromLong(-5));
758 PyObjectPtr result(_PyLong_DivmodNear(a, b));
759 ASSERT_TRUE(PyTuple_CheckExact(result));
760 ASSERT_EQ(PyTuple_Size(result), 2);
761
762 PyObject* quotient = PyTuple_GetItem(result, 0);
763 ASSERT_TRUE(PyLong_CheckExact(quotient));
764 EXPECT_EQ(PyLong_AsLong(quotient), -9);
765
766 PyObject* remainder = PyTuple_GetItem(result, 1);
767 ASSERT_TRUE(PyLong_CheckExact(remainder));
768 EXPECT_EQ(PyLong_AsLong(remainder), -2);
769}
770
771TEST_F(LongExtensionApiTest, DivmodNearWithNegativesReturnsTuple) {
772 PyObjectPtr a(PyLong_FromLong(-43));
773 PyObjectPtr b(PyLong_FromLong(-5));
774 PyObjectPtr result(_PyLong_DivmodNear(a, b));
775 ASSERT_TRUE(PyTuple_CheckExact(result));
776 ASSERT_EQ(PyTuple_Size(result), 2);
777
778 PyObject* quotient = PyTuple_GetItem(result, 0);
779 ASSERT_TRUE(PyLong_CheckExact(quotient));
780 EXPECT_EQ(PyLong_AsLong(quotient), 9);
781
782 PyObject* remainder = PyTuple_GetItem(result, 1);
783 ASSERT_TRUE(PyLong_CheckExact(remainder));
784 EXPECT_EQ(PyLong_AsLong(remainder), 2);
785}
786
787TEST_F(LongExtensionApiTest, FromByteArrayWithZeroSizeReturnsZero) {
788 PyObjectPtr num(_PyLong_FromByteArray(nullptr, 0, false, false));
789 ASSERT_EQ(PyErr_Occurred(), nullptr);
790 ASSERT_TRUE(PyLong_CheckExact(num));
791 EXPECT_EQ(PyLong_AsLong(num), 0);
792}
793
794TEST_F(LongExtensionApiTest, FromByteArrayBigEndianUnsignedReturnsBytes) {
795 const unsigned char source[] = {0x2c, 0xff, 0x00, 0x42};
796 PyObjectPtr num(_PyLong_FromByteArray(source, 4, false, false));
797 ASSERT_EQ(PyErr_Occurred(), nullptr);
798 ASSERT_TRUE(PyLong_CheckExact(num));
799 EXPECT_EQ(PyLong_AsLong(num), 0x2cff0042);
800}
801
802TEST_F(LongExtensionApiTest, FromByteArrayLittleEndianUnsignedReturnsBytes) {
803 const unsigned char source[] = {0x2c, 0xff, 0x00, 0x42};
804 PyObjectPtr num(_PyLong_FromByteArray(source, 4, true, false));
805 ASSERT_EQ(PyErr_Occurred(), nullptr);
806 ASSERT_TRUE(PyLong_CheckExact(num));
807 EXPECT_EQ(PyLong_AsLong(num), 0x4200ff2c);
808}
809
810TEST_F(LongExtensionApiTest, FromByteArrayBigEndianSignedPositiveReturnsBytes) {
811 const unsigned char source[] = {0x2c, 0xff, 0x00, 0x42};
812 PyObjectPtr num(_PyLong_FromByteArray(source, 4, false, true));
813 ASSERT_EQ(PyErr_Occurred(), nullptr);
814 ASSERT_TRUE(PyLong_CheckExact(num));
815 EXPECT_EQ(PyLong_AsLong(num), 0x2cff0042);
816}
817
818TEST_F(LongExtensionApiTest, FromByteArrayBigEndianSignedNegativeReturnsBytes) {
819 const unsigned char source[] = {0xff, 0x2c, 0x00, 0x42};
820 PyObjectPtr num(_PyLong_FromByteArray(source, 4, false, true));
821 ASSERT_EQ(PyErr_Occurred(), nullptr);
822 ASSERT_TRUE(PyLong_CheckExact(num));
823 EXPECT_EQ(PyLong_AsLong(num), -0x00d3ffbe);
824}
825
826TEST_F(LongExtensionApiTest, FromByteArrayReturnsBytesWithSize) {
827 const unsigned char source[] = {0x01, 0x02, 0x03};
828 PyObjectPtr num(_PyLong_FromByteArray(source, 2, true, true));
829 ASSERT_EQ(PyErr_Occurred(), nullptr);
830 ASSERT_TRUE(PyLong_CheckExact(num));
831 EXPECT_EQ(PyLong_AsLong(num), 0x0201);
832}
833
834TEST_F(LongExtensionApiTest, SignZeroReturnsZero) {
835 PyObjectPtr zero(PyLong_FromLong(0));
836 ASSERT_EQ(_PyLong_Sign(zero), 0);
837}
838
839TEST_F(LongExtensionApiTest, SignPositiveLongReturnsOne) {
840 PyObjectPtr positive1(PyLong_FromLong(1));
841 ASSERT_EQ(_PyLong_Sign(positive1), 1);
842 PyObjectPtr positive1234(PyLong_FromLong(1234));
843 ASSERT_EQ(_PyLong_Sign(positive1234), 1);
844}
845
846TEST_F(LongExtensionApiTest, SignNegativeReturnsNegativeOne) {
847 PyObjectPtr negative1(PyLong_FromLong(-1));
848 ASSERT_EQ(_PyLong_Sign(negative1), -1);
849 PyObjectPtr negative5678(PyLong_FromLong(-5678));
850 ASSERT_EQ(_PyLong_Sign(negative5678), -1);
851}
852
853TEST_F(LongExtensionApiTest, SignWithIntSubclassReturnsSign) {
854 PyRun_SimpleString(R"(
855class X(int): pass
856a = X(-42)
857b = X(0)
858c = X(42)
859)");
860 PyObjectPtr a(mainModuleGet("a"));
861 PyObjectPtr b(mainModuleGet("b"));
862 PyObjectPtr c(mainModuleGet("c"));
863 EXPECT_EQ(_PyLong_Sign(a), -1);
864 EXPECT_EQ(_PyLong_Sign(b), 0);
865 EXPECT_EQ(_PyLong_Sign(c), 1);
866}
867
868TEST_F(LongExtensionApiTest, FromVoidPtrReturnsLong) {
869 unsigned long long max_as_int =
870 std::numeric_limits<unsigned long long>::max();
871 void* max_as_ptr = reinterpret_cast<void*>(max_as_int);
872 PyObjectPtr pylong(PyLong_FromVoidPtr(max_as_ptr));
873 EXPECT_EQ(PyLong_AsVoidPtr(pylong), max_as_ptr);
874 EXPECT_EQ(PyLong_AsUnsignedLongLong(pylong), max_as_int);
875
876 unsigned long long zero_as_int = 0ULL;
877 void* zero_as_ptr = reinterpret_cast<void*>(zero_as_int);
878 pylong = PyLong_FromVoidPtr(zero_as_ptr);
879 EXPECT_EQ(PyLong_AsVoidPtr(pylong), zero_as_ptr);
880 EXPECT_EQ(PyLong_AsUnsignedLongLong(pylong), zero_as_int);
881
882 unsigned long long num_as_int = 1234ULL;
883 void* num_as_ptr = reinterpret_cast<void*>(num_as_int);
884 pylong = PyLong_FromVoidPtr(num_as_ptr);
885 EXPECT_EQ(PyLong_AsVoidPtr(pylong), num_as_ptr);
886 EXPECT_EQ(PyLong_AsUnsignedLongLong(pylong), num_as_int);
887}
888
889TEST_F(LongExtensionApiTest, FromDoubleReturnsLong) {
890 PyObjectPtr pylong(PyLong_FromDouble(12.34));
891 ASSERT_EQ(PyErr_Occurred(), nullptr);
892 ASSERT_EQ(PyLong_Check(pylong), 1);
893 EXPECT_EQ(PyLong_AsLong(pylong), 12);
894}
895
896TEST_F(LongExtensionApiTest, FromDoubleRaisesAndReturnsNull) {
897 PyObjectPtr pylong(
898 PyLong_FromDouble(std::numeric_limits<double>::infinity()));
899 ASSERT_NE(PyErr_Occurred(), nullptr);
900 EXPECT_EQ(pylong, nullptr);
901}
902
903TEST_F(LongExtensionApiTest, LshiftWithZeroReturnsZero) {
904 PyObjectPtr result(_PyLong_Lshift(_PyLong_Zero, 10));
905 EXPECT_TRUE(isLongEqualsLong(result, 0));
906}
907
908TEST_F(LongExtensionApiTest, LshiftWithNonzeroShiftsBits) {
909 PyObjectPtr pos_result(_PyLong_Lshift(_PyLong_One, 10));
910 EXPECT_TRUE(isLongEqualsLong(pos_result, 1024));
911
912 PyObjectPtr neg(PyLong_FromLong(-5));
913 PyObjectPtr neg_result(_PyLong_Lshift(neg, 4));
914 EXPECT_TRUE(isLongEqualsLong(neg_result, -80));
915}
916
917TEST_F(LongExtensionApiTest, OneIsOne) {
918 EXPECT_TRUE(isLongEqualsLong(_PyLong_One, 1));
919}
920
921TEST_F(LongExtensionApiTest, RshiftWithZeroReturnsZero) {
922 PyObjectPtr result(_PyLong_Rshift(_PyLong_Zero, 10));
923 EXPECT_TRUE(isLongEqualsLong(result, 0));
924}
925
926TEST_F(LongExtensionApiTest, RshiftWithNonzeroShiftsBits) {
927 PyObjectPtr pos(PyLong_FromLong(257));
928 PyObjectPtr pos_result(_PyLong_Rshift(pos, 3));
929 EXPECT_TRUE(isLongEqualsLong(pos_result, 32));
930
931 PyObjectPtr neg(PyLong_FromLong(-17));
932 PyObjectPtr neg_result(_PyLong_Rshift(neg, 2));
933 EXPECT_TRUE(isLongEqualsLong(neg_result, -5));
934}
935
936TEST_F(LongExtensionApiTest, SizeTConverterWithNonIntRaisesTypeError) {
937 size_t ignored;
938 PyObjectPtr tuple(PyTuple_New(0));
939 EXPECT_EQ(_PyLong_Size_t_Converter(tuple, &ignored), 0);
940 ASSERT_NE(PyErr_Occurred(), nullptr);
941 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
942}
943
944TEST_F(LongExtensionApiTest, SizeTConverterWithNegativeRaisesValueError) {
945 size_t ignored;
946 PyObjectPtr negative(PyLong_FromLong(-10));
947 EXPECT_EQ(_PyLong_Size_t_Converter(negative, &ignored), 0);
948 ASSERT_NE(PyErr_Occurred(), nullptr);
949 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_ValueError));
950}
951
952TEST_F(LongExtensionApiTest, SizeTConverterWithLargeIntRaisesOverflowError) {
953 size_t ignored;
954 PyObjectPtr large(PyLong_FromString("10000000000000002", nullptr, 16));
955 EXPECT_EQ(_PyLong_Size_t_Converter(large, &ignored), 0);
956 ASSERT_NE(PyErr_Occurred(), nullptr);
957 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
958}
959
960TEST_F(LongExtensionApiTest, SizeTConverterSetsSizeT) {
961 size_t result;
962 PyObjectPtr num(PyLong_FromLong(42));
963 EXPECT_EQ(_PyLong_Size_t_Converter(num, &result), 1);
964 ASSERT_EQ(PyErr_Occurred(), nullptr);
965 EXPECT_EQ(result, static_cast<unsigned>(42));
966}
967
968TEST_F(LongExtensionApiTest, UnsignedIntConverterWithNonIntRaisesTypeError) {
969 unsigned int ignored;
970 PyObjectPtr tuple(PyTuple_New(0));
971 EXPECT_EQ(_PyLong_UnsignedInt_Converter(tuple, &ignored), 0);
972 ASSERT_NE(PyErr_Occurred(), nullptr);
973 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
974}
975
976TEST_F(LongExtensionApiTest, UnsignedIntConverterWithNegativeRaisesValueError) {
977 unsigned int ignored;
978 PyObjectPtr negative(PyLong_FromLong(-10));
979 EXPECT_EQ(_PyLong_UnsignedInt_Converter(negative, &ignored), 0);
980 ASSERT_NE(PyErr_Occurred(), nullptr);
981 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_ValueError));
982}
983
984TEST_F(LongExtensionApiTest,
985 UnsignedIntConverterWithLargeIntRaisesOverflowError) {
986 unsigned int ignored;
987 PyObjectPtr large(PyLong_FromString("10000000000000002", nullptr, 16));
988 EXPECT_EQ(_PyLong_UnsignedInt_Converter(large, &ignored), 0);
989 ASSERT_NE(PyErr_Occurred(), nullptr);
990 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
991}
992
993TEST_F(LongExtensionApiTest, UnsignedIntConverterSetsUnsignedInt) {
994 unsigned int result;
995 PyObjectPtr num(PyLong_FromLong(42));
996 EXPECT_EQ(_PyLong_UnsignedInt_Converter(num, &result), 1);
997 ASSERT_EQ(PyErr_Occurred(), nullptr);
998 EXPECT_EQ(result, static_cast<unsigned>(42));
999}
1000
1001TEST_F(LongExtensionApiTest, UnsignedLongConverterWithNonIntRaisesTypeError) {
1002 unsigned long ignored;
1003 PyObjectPtr tuple(PyTuple_New(0));
1004 EXPECT_EQ(_PyLong_UnsignedLong_Converter(tuple, &ignored), 0);
1005 ASSERT_NE(PyErr_Occurred(), nullptr);
1006 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
1007}
1008
1009TEST_F(LongExtensionApiTest,
1010 UnsignedLongConverterWithNegativeRaisesValueError) {
1011 unsigned long ignored;
1012 PyObjectPtr negative(PyLong_FromLong(-10));
1013 EXPECT_EQ(_PyLong_UnsignedLong_Converter(negative, &ignored), 0);
1014 ASSERT_NE(PyErr_Occurred(), nullptr);
1015 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_ValueError));
1016}
1017
1018TEST_F(LongExtensionApiTest,
1019 UnsignedLongConverterWithLargeIntRaisesOverflowError) {
1020 unsigned long ignored;
1021 PyObjectPtr large(PyLong_FromString("10000000000000002", nullptr, 16));
1022 EXPECT_EQ(_PyLong_UnsignedLong_Converter(large, &ignored), 0);
1023 ASSERT_NE(PyErr_Occurred(), nullptr);
1024 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
1025}
1026
1027TEST_F(LongExtensionApiTest, UnsignedLongConverterSetsUnsignedLong) {
1028 unsigned long result;
1029 PyObjectPtr num(PyLong_FromLong(42));
1030 EXPECT_EQ(_PyLong_UnsignedLong_Converter(num, &result), 1);
1031 ASSERT_EQ(PyErr_Occurred(), nullptr);
1032 EXPECT_EQ(result, static_cast<unsigned>(42));
1033}
1034
1035TEST_F(LongExtensionApiTest,
1036 UnsignedLongLongConverterWithNonIntRaisesTypeError) {
1037 unsigned long long ignored;
1038 PyObjectPtr tuple(PyTuple_New(0));
1039 EXPECT_EQ(_PyLong_UnsignedLongLong_Converter(tuple, &ignored), 0);
1040 ASSERT_NE(PyErr_Occurred(), nullptr);
1041 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
1042}
1043
1044TEST_F(LongExtensionApiTest,
1045 UnsignedLongLongConverterWithNegativeRaisesValueError) {
1046 unsigned long long ignored;
1047 PyObjectPtr negative(PyLong_FromLong(-10));
1048 EXPECT_EQ(_PyLong_UnsignedLongLong_Converter(negative, &ignored), 0);
1049 ASSERT_NE(PyErr_Occurred(), nullptr);
1050 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_ValueError));
1051}
1052
1053TEST_F(LongExtensionApiTest,
1054 UnsignedLongLongConverterWithLargeIntRaisesOverflowError) {
1055 unsigned long long ignored;
1056 PyObjectPtr large(PyLong_FromString("10000000000000002", nullptr, 16));
1057 EXPECT_EQ(_PyLong_UnsignedLongLong_Converter(large, &ignored), 0);
1058 ASSERT_NE(PyErr_Occurred(), nullptr);
1059 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
1060}
1061
1062TEST_F(LongExtensionApiTest, UnsignedLongLongConverterSetsUnsignedLongLong) {
1063 unsigned long long result;
1064 PyObjectPtr num(PyLong_FromLong(42));
1065 EXPECT_EQ(_PyLong_UnsignedLongLong_Converter(num, &result), 1);
1066 ASSERT_EQ(PyErr_Occurred(), nullptr);
1067 EXPECT_EQ(result, static_cast<unsigned>(42));
1068}
1069
1070TEST_F(LongExtensionApiTest, UnsignedShortConverterWithNonIntRaisesTypeError) {
1071 unsigned short ignored;
1072 PyObjectPtr tuple(PyTuple_New(0));
1073 EXPECT_EQ(_PyLong_UnsignedShort_Converter(tuple, &ignored), 0);
1074 ASSERT_NE(PyErr_Occurred(), nullptr);
1075 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_TypeError));
1076}
1077
1078TEST_F(LongExtensionApiTest,
1079 UnsignedShortConverterWithNegativeRaisesValueError) {
1080 unsigned short ignored;
1081 PyObjectPtr negative(PyLong_FromLong(-10));
1082 EXPECT_EQ(_PyLong_UnsignedShort_Converter(negative, &ignored), 0);
1083 ASSERT_NE(PyErr_Occurred(), nullptr);
1084 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_ValueError));
1085}
1086
1087TEST_F(LongExtensionApiTest,
1088 UnsignedShortConverterWithLargeIntRaisesOverflowError) {
1089 unsigned short ignored;
1090 PyObjectPtr large(PyLong_FromString("10000000000000002", nullptr, 16));
1091 EXPECT_EQ(_PyLong_UnsignedShort_Converter(large, &ignored), 0);
1092 ASSERT_NE(PyErr_Occurred(), nullptr);
1093 EXPECT_TRUE(PyErr_ExceptionMatches(PyExc_OverflowError));
1094}
1095
1096TEST_F(LongExtensionApiTest, UnsignedShortConverterSetsUnsignedShort) {
1097 unsigned short result;
1098 PyObjectPtr num(PyLong_FromLong(42));
1099 EXPECT_EQ(_PyLong_UnsignedShort_Converter(num, &result), 1);
1100 ASSERT_EQ(PyErr_Occurred(), nullptr);
1101 EXPECT_EQ(result, static_cast<unsigned>(42));
1102}
1103
1104TEST_F(LongExtensionApiTest, ZeroIsZero) {
1105 EXPECT_TRUE(isLongEqualsLong(_PyLong_Zero, 0));
1106}
1107
1108} // namespace testing
1109} // namespace py