skybison / runtime / int-builtins-test.cpp

// Copyright (c) Facebook, Inc. and its affiliates. (http://www.facebook.com)
#include "int-builtins.h"

#include <cmath>
#include <limits>

#include "gtest/gtest.h"

#include "builtins.h"
#include "handles.h"
#include "objects.h"
#include "runtime.h"
#include "test-utils.h"
#include "type-builtins.h"

namespace py {
namespace testing {

using BoolBuiltinsTest = RuntimeFixture;
using IntBuiltinsTest = RuntimeFixture;
using LargeIntBuiltinsTest = RuntimeFixture;

TEST_F(IntBuiltinsTest, BuiltinBases) {
  HandleScope scope(thread_);

  Type integer(&scope, runtime_->typeAt(LayoutId::kInt));
  EXPECT_EQ(integer.builtinBase(), LayoutId::kInt);

  Type small_int(&scope, runtime_->typeAt(LayoutId::kSmallInt));
  EXPECT_EQ(small_int.builtinBase(), LayoutId::kInt);

  Type large_int(&scope, runtime_->typeAt(LayoutId::kLargeInt));
  EXPECT_EQ(large_int.builtinBase(), LayoutId::kInt);

  Type boolean(&scope, runtime_->typeAt(LayoutId::kBool));
  EXPECT_EQ(boolean.builtinBase(), LayoutId::kInt);
}

TEST_F(IntBuiltinsTest, CompareSmallIntEq) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 1
b = 2
a_eq_b = a == b
a_eq_a = a == a
b_eq_b = b == b
)")
                   .isError());

  Object a_eq_b(&scope, mainModuleAt(runtime_, "a_eq_b"));
  EXPECT_EQ(*a_eq_b, Bool::falseObj());
  Object a_eq_a(&scope, mainModuleAt(runtime_, "a_eq_a"));
  EXPECT_EQ(*a_eq_a, Bool::trueObj());
  Object b_eq_b(&scope, mainModuleAt(runtime_, "b_eq_b"));
  EXPECT_EQ(*b_eq_b, Bool::trueObj());
}

TEST_F(IntBuiltinsTest, CompareSmallIntGe) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 1
b = 2
a_ge_a = a >= a
a_ge_b = a >= b
b_ge_a = b >= a
b_ge_b = b >= b
)")
                   .isError());

  Object a_ge_a(&scope, mainModuleAt(runtime_, "a_ge_a"));
  EXPECT_EQ(*a_ge_a, Bool::trueObj());
  Object a_ge_b(&scope, mainModuleAt(runtime_, "a_ge_b"));
  EXPECT_EQ(*a_ge_b, Bool::falseObj());
  Object b_ge_a(&scope, mainModuleAt(runtime_, "b_ge_a"));
  EXPECT_EQ(*b_ge_a, Bool::trueObj());
  Object b_ge_b(&scope, mainModuleAt(runtime_, "b_ge_b"));
  EXPECT_EQ(*b_ge_b, Bool::trueObj());
}

TEST_F(IntBuiltinsTest, CompareSmallIntGt) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 1
b = 2
a_gt_a = a > a
a_gt_b = a > b
b_gt_a = b > a
b_gt_b = b > b
)")
                   .isError());

  Object a_gt_a(&scope, mainModuleAt(runtime_, "a_gt_a"));
  EXPECT_EQ(*a_gt_a, Bool::falseObj());
  Object a_gt_b(&scope, mainModuleAt(runtime_, "a_gt_b"));
  EXPECT_EQ(*a_gt_b, Bool::falseObj());
  Object b_gt_a(&scope, mainModuleAt(runtime_, "b_gt_a"));
  EXPECT_EQ(*b_gt_a, Bool::trueObj());
  Object b_gt_b(&scope, mainModuleAt(runtime_, "b_gt_b"));
  EXPECT_EQ(*b_gt_b, Bool::falseObj());
}

TEST_F(IntBuiltinsTest, CompareSmallIntLe) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 1
b = 2
a_le_a = a <= a
a_le_b = a <= b
b_le_a = b <= a
b_le_b = b <= b
)")
                   .isError());

  Object a_le_a(&scope, mainModuleAt(runtime_, "a_le_a"));
  EXPECT_EQ(*a_le_a, Bool::trueObj());
  Object a_le_b(&scope, mainModuleAt(runtime_, "a_le_b"));
  EXPECT_EQ(*a_le_b, Bool::trueObj());
  Object b_le_a(&scope, mainModuleAt(runtime_, "b_le_a"));
  EXPECT_EQ(*b_le_a, Bool::falseObj());
  Object b_le_b(&scope, mainModuleAt(runtime_, "b_le_b"));
  EXPECT_EQ(*b_le_b, Bool::trueObj());
}

TEST_F(IntBuiltinsTest, CompareSmallIntLt) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 1
b = 2
a_lt_a = a < a
a_lt_b = a < b
b_lt_a = b < a
b_lt_b = b < b
)")
                   .isError());

  Object a_lt_a(&scope, mainModuleAt(runtime_, "a_lt_a"));
  EXPECT_EQ(*a_lt_a, Bool::falseObj());
  Object a_lt_b(&scope, mainModuleAt(runtime_, "a_lt_b"));
  EXPECT_EQ(*a_lt_b, Bool::trueObj());
  Object b_lt_a(&scope, mainModuleAt(runtime_, "b_lt_a"));
  EXPECT_EQ(*b_lt_a, Bool::falseObj());
  Object b_lt_b(&scope, mainModuleAt(runtime_, "b_lt_b"));
  EXPECT_EQ(*b_lt_b, Bool::falseObj());
}

TEST_F(IntBuiltinsTest, CompareSmallIntNe) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 1
b = 2
a_ne_b = a != b
a_ne_a = a != a
b_ne_b = b != b
)")
                   .isError());

  Object a_ne_b(&scope, mainModuleAt(runtime_, "a_ne_b"));
  EXPECT_EQ(*a_ne_b, Bool::trueObj());
  Object a_ne_a(&scope, mainModuleAt(runtime_, "a_ne_a"));
  EXPECT_EQ(*a_ne_a, Bool::falseObj());
  Object b_ne_b(&scope, mainModuleAt(runtime_, "b_ne_b"));
  EXPECT_EQ(*b_ne_b, Bool::falseObj());
}

TEST_F(IntBuiltinsTest, CompareOpSmallInt) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 1
b = 2
c = 1
a_lt_b = a < b
a_le_b = a <= b
a_eq_b = a == b
a_ge_b = a >= b
a_gt_b = a > b
a_is_c = a is c
a_is_not_c = a is not c
)")
                   .isError());

  Object a_lt_b(&scope, mainModuleAt(runtime_, "a_lt_b"));
  EXPECT_EQ(*a_lt_b, Bool::trueObj());
  Object a_le_b(&scope, mainModuleAt(runtime_, "a_le_b"));
  EXPECT_EQ(*a_le_b, Bool::trueObj());
  Object a_eq_b(&scope, mainModuleAt(runtime_, "a_eq_b"));
  EXPECT_EQ(*a_eq_b, Bool::falseObj());
  Object a_ge_b(&scope, mainModuleAt(runtime_, "a_ge_b"));
  EXPECT_EQ(*a_ge_b, Bool::falseObj());
  Object a_gt_b(&scope, mainModuleAt(runtime_, "a_gt_b"));
  EXPECT_EQ(*a_gt_b, Bool::falseObj());
  Object a_is_c(&scope, mainModuleAt(runtime_, "a_is_c"));
  EXPECT_EQ(*a_is_c, Bool::trueObj());
  Object a_is_not_c(&scope, mainModuleAt(runtime_, "a_is_not_c"));
  EXPECT_EQ(*a_is_not_c, Bool::falseObj());
}

TEST_F(IntBuiltinsTest, UnaryPositiveSmallInt) {
  HandleScope scope(thread_);

  const char* src = R"(
pos = 123
plus_pos = +pos
neg = -123
plus_neg = +neg
)";

  ASSERT_FALSE(runFromCStr(runtime_, src).isError());

  Object plus_pos(&scope, mainModuleAt(runtime_, "plus_pos"));
  EXPECT_TRUE(isIntEqualsWord(*plus_pos, 123));

  Object plus_neg(&scope, mainModuleAt(runtime_, "plus_neg"));
  EXPECT_TRUE(isIntEqualsWord(*plus_neg, -123));
}

TEST_F(IntBuiltinsTest, UnaryNegateSmallInt) {
  HandleScope scope(thread_);

  const char* src = R"(
pos = 123
minus_pos = -pos
neg = -123
minus_neg = -neg
)";

  ASSERT_FALSE(runFromCStr(runtime_, src).isError());

  Object minus_pos(&scope, mainModuleAt(runtime_, "minus_pos"));
  EXPECT_TRUE(isIntEqualsWord(*minus_pos, -123));

  Object minus_neg(&scope, mainModuleAt(runtime_, "minus_neg"));
  EXPECT_TRUE(isIntEqualsWord(*minus_neg, 123));
}

TEST_F(IntBuiltinsTest, TruthyIntPos) {
  HandleScope scope(thread_);
  Int one(&scope, SmallInt::fromWord(1));
  EXPECT_EQ(runBuiltin(METH(int, __bool__), one), Bool::trueObj());
}

TEST_F(IntBuiltinsTest, TruthyIntZero) {
  HandleScope scope(thread_);
  Int zero(&scope, SmallInt::fromWord(0));
  EXPECT_EQ(runBuiltin(METH(int, __bool__), zero), Bool::falseObj());
}

TEST_F(IntBuiltinsTest, InplaceAdd) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 1
a += 0
b = a
a += 2
)")
                   .isError());
  Object a(&scope, mainModuleAt(runtime_, "a"));
  Object b(&scope, mainModuleAt(runtime_, "b"));
  EXPECT_TRUE(isIntEqualsWord(*a, 3));
  EXPECT_TRUE(isIntEqualsWord(*b, 1));
}

TEST_F(IntBuiltinsTest, InplaceMultiply) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 5
a *= 1
b = a
a *= 2
)")
                   .isError());
  Object a(&scope, mainModuleAt(runtime_, "a"));
  Object b(&scope, mainModuleAt(runtime_, "b"));
  EXPECT_TRUE(isIntEqualsWord(*a, 10));
  EXPECT_TRUE(isIntEqualsWord(*b, 5));
}

TEST_F(IntBuiltinsTest, InplaceFloordiv) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 5
a //= 1
b = a
a //= 2
)")
                   .isError());
  Object a(&scope, mainModuleAt(runtime_, "a"));
  Object b(&scope, mainModuleAt(runtime_, "b"));
  EXPECT_TRUE(isIntEqualsWord(*a, 2));
  EXPECT_TRUE(isIntEqualsWord(*b, 5));
}

TEST_F(IntBuiltinsTest, InplaceModulo) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 10
a %= 7
b = a
a %= 2
)")
                   .isError());
  Object a(&scope, mainModuleAt(runtime_, "a"));
  Object b(&scope, mainModuleAt(runtime_, "b"));
  EXPECT_TRUE(isIntEqualsWord(*a, 1));
  EXPECT_TRUE(isIntEqualsWord(*b, 3));
}

TEST_F(IntBuiltinsTest, InplaceSub) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 10
a -= 0
b = a
a -= 7
)")
                   .isError());
  Object a(&scope, mainModuleAt(runtime_, "a"));
  Object b(&scope, mainModuleAt(runtime_, "b"));
  EXPECT_TRUE(isIntEqualsWord(*a, 3));
  EXPECT_TRUE(isIntEqualsWord(*b, 10));
}

TEST_F(IntBuiltinsTest, InplaceXor) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 0xFE
a ^= 0
b = a
a ^= 0x03
)")
                   .isError());
  Object a(&scope, mainModuleAt(runtime_, "a"));
  Object b(&scope, mainModuleAt(runtime_, "b"));
  EXPECT_TRUE(isIntEqualsWord(*a, 0xFD));
  EXPECT_TRUE(isIntEqualsWord(*b, 0xFE));
}

TEST_F(IntBuiltinsTest, DunderAbsWithBoolFalseReturnsZero) {
  HandleScope scope(thread_);
  Int self(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, __abs__), self));
  EXPECT_EQ(result, SmallInt::fromWord(0));
}

TEST_F(IntBuiltinsTest, DunderAbsWithBoolTrueReturnsOne) {
  HandleScope scope(thread_);
  Int self(&scope, Bool::trueObj());
  Object result(&scope, runBuiltin(METH(int, __abs__), self));
  EXPECT_EQ(result, SmallInt::fromWord(1));
}

TEST_F(IntBuiltinsTest, DunderAbsWithPositiveIntReturnsInt) {
  HandleScope scope(thread_);
  Int self(&scope, runtime_->newInt(1234));
  Object result(&scope, runBuiltin(METH(int, __abs__), self));
  EXPECT_TRUE(isIntEqualsWord(*result, 1234));
}

TEST_F(IntBuiltinsTest, DunderAbsWithNegativeIntReturnsInt) {
  HandleScope scope(thread_);
  const uword digits[] = {0x154a0071b091fb7e, 0x9661bb54b4e68c59};
  Int self(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __abs__), self));
  const uword expected_digits[] = {0xeab5ff8e4f6e0482, 0x699e44ab4b1973a6};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderAbsWithIntSubclassReturnsInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, R"(
class X(int): pass
neg = X(-42)
pos = X(42)
zero = X()
)")
                   .isError());
  Object neg(&scope, mainModuleAt(runtime_, "neg"));
  Object pos(&scope, mainModuleAt(runtime_, "pos"));
  Object zero(&scope, mainModuleAt(runtime_, "zero"));
  EXPECT_EQ(runBuiltin(METH(int, __abs__), neg), SmallInt::fromWord(42));
  EXPECT_EQ(runBuiltin(METH(int, __abs__), pos), SmallInt::fromWord(42));
  EXPECT_EQ(runBuiltin(METH(int, __abs__), zero), SmallInt::fromWord(0));
}

TEST_F(IntBuiltinsTest, DunderAddWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);

  Int left(&scope, SmallInt::fromWord(42));
  Int right(&scope, SmallInt::fromWord(-7));
  Object result(&scope, runBuiltin(METH(int, __add__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 35));
}

TEST_F(IntBuiltinsTest, DunderAddWithSmallIntsOverflowReturnsLargeInt) {
  HandleScope scope(thread_);

  Int max_small_int(&scope, SmallInt::fromWord(RawSmallInt::kMaxValue));
  Int one(&scope, SmallInt::fromWord(1));
  Object result(&scope, runBuiltin(METH(int, __add__), max_small_int, one));
  EXPECT_TRUE(isIntEqualsWord(*result, RawSmallInt::kMaxValue + 1));
}

TEST_F(IntBuiltinsTest, DunderAddWithLargeInts) {
  HandleScope scope(thread_);

  const uword digits_left[] = {0xfedcba0987654321, 0x1234567890abcdef};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0x9876543210abcdef, 0xfedcba0123456789};
  Int right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result(&scope, runBuiltin(METH(int, __add__), left, right));
  const uword expected_digits[] = {0x97530e3b98111110, 0x11111079b3f13579};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderAddWithPositiveLargeIntsCarrying) {
  HandleScope scope(thread_);

  const uword digits_left[] = {kMaxUword, kMaxUword, 0};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  Int right(&scope, runtime_->newInt(1));
  Object result(&scope, runBuiltin(METH(int, __add__), left, right));
  const uword expected_digits[] = {0, 0, 1};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderAddWithNegativeLargeIntsCarrying) {
  HandleScope scope(thread_);

  Int left(&scope, runtime_->newInt(-1));
  // The smallest negative number representable with 2 digits.
  const uword digits_right[] = {0, static_cast<uword>(kMinWord)};
  Int right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result(&scope, runBuiltin(METH(int, __add__), left, right));
  const uword expected_digits[] = {kMaxUword, kMaxWord, kMaxUword};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderAndWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  Int left(&scope, SmallInt::fromWord(0x15));   // 0b010101
  Int right(&scope, SmallInt::fromWord(0x38));  // 0b111000
  Object result(&scope, runBuiltin(METH(int, __and__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 0x10));  // 0b10000
}

TEST_F(IntBuiltinsTest, DunderAndWithLargeIntsReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits_left[] = {0x0f, 0x30, 0x1};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0x03, 0xf0, 0x2, 7};
  Int right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result(&scope, runBuiltin(METH(int, __and__), left, right));
  const uword expected_digits[] = {0x03, 0x30};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderAndWithNonIntReturnsNotImplemented) {
  HandleScope scope(thread_);
  const uword digits[] = {1, 2};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, Str::empty());
  Object result(&scope, runBuiltin(METH(int, __and__), left, right));
  EXPECT_TRUE(result.isNotImplementedType());
}

TEST_F(IntBuiltinsTest, DunderAndWithInvalidArgumentLeftRaisesException) {
  HandleScope scope(thread_);
  Object left(&scope, Str::empty());
  const uword digits[] = {1, 2};
  LargeInt right(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __and__), left, right));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, DunderAndWithIntSubclassReturnsInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, R"(
class X(int): pass
left = X(0b0011)
right = X(0b0101)
)")
                   .isError());
  Object left(&scope, mainModuleAt(runtime_, "left"));
  Object right(&scope, mainModuleAt(runtime_, "right"));
  Object result(&scope, runBuiltin(METH(int, __and__), left, right));
  EXPECT_EQ(result, SmallInt::fromWord(1));  // 0b0001
}

TEST_F(IntBuiltinsTest, DunderCeilAliasesDunderInt) {
  HandleScope scope(thread_);
  Type type(&scope, moduleAtByCStr(runtime_, "builtins", "int"));
  Object ceil_name(&scope, Runtime::internStrFromCStr(thread_, "__ceil__"));
  Object ceil_obj(&scope, typeAt(type, ceil_name));
  ASSERT_TRUE(ceil_obj.isFunction());
  Function ceil(&scope, *ceil_obj);
  Object dint_name(&scope, Runtime::internStrFromCStr(thread_, "__int__"));
  Object dint_obj(&scope, typeAt(type, dint_name));
  ASSERT_TRUE(dint_obj.isFunction());
  Function dint(&scope, *ceil_obj);
  EXPECT_EQ(Code::cast(ceil.code()).code(), Code::cast(dint.code()).code());
  EXPECT_EQ(ceil.entry(), dint.entry());
  EXPECT_EQ(ceil.entryKw(), dint.entryKw());
  EXPECT_EQ(ceil.entryEx(), dint.entryEx());
}

TEST_F(IntBuiltinsTest, DunderFloorAliasesDunderInt) {
  Thread* thread = Thread::current();
  HandleScope scope(thread);
  Type type(&scope, moduleAtByCStr(runtime_, "builtins", "int"));
  Object floor_name(&scope, Runtime::internStrFromCStr(thread_, "__floor__"));
  Object floor_obj(&scope, typeAt(type, floor_name));
  ASSERT_TRUE(floor_obj.isFunction());
  Function floor(&scope, *floor_obj);
  Object dint_name(&scope, Runtime::internStrFromCStr(thread_, "__int__"));
  Object dint_obj(&scope, typeAt(type, dint_name));
  ASSERT_TRUE(dint_obj.isFunction());
  Function dint(&scope, *floor_obj);
  EXPECT_EQ(Code::cast(floor.code()).code(), Code::cast(dint.code()).code());
  EXPECT_EQ(floor.entry(), dint.entry());
  EXPECT_EQ(floor.entryKw(), dint.entryKw());
  EXPECT_EQ(floor.entryEx(), dint.entryEx());
}

TEST_F(IntBuiltinsTest, DunderLshiftWithBoolsTrueFalseReturnsSmallInt) {
  HandleScope scope(thread_);
  Object left(&scope, Bool::trueObj());
  Object right(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 1));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithBoolsFalseTrueReturnsSmallInt) {
  HandleScope scope(thread_);
  Object left(&scope, Bool::falseObj());
  Object right(&scope, Bool::trueObj());
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 0));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithBoolSmallIntReturnsLargeInt) {
  HandleScope scope(thread_);
  Object left(&scope, Bool::trueObj());
  Object right(&scope, runtime_->newInt(kBitsPerWord));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  const uword expected_digits[] = {0, 1};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(0xd));  // 0b1101
  Object right(&scope, runtime_->newInt(3));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 0x68));  // 0b1101000
}

TEST_F(IntBuiltinsTest, DunderLshiftWithNegativeSmallIntReturnsSmallInt) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(-2));
  Object right(&scope, runtime_->newInt(1));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, -4));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithZeroReturnsZero) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(0));
  const uword digits[] = {1, 2, 3, 4};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 0));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithBigSmallIntReturnsSmallInt) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(RawSmallInt::kMaxValue >> 1));
  Object right(&scope, runtime_->newInt(1));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, RawSmallInt::kMaxValue - 1));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithBigNegativeSmallIntReturnsSmallInt) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(RawSmallInt::kMinValue >> 1));
  Object right(&scope, runtime_->newInt(1));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, RawSmallInt::kMinValue));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithSmallIntsReturnsLargeInt) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(4));
  Object right(&scope, runtime_->newInt(kBitsPerWord - 4));
  Object result_obj(&scope, runBuiltin(METH(int, __lshift__), left, right));
  ASSERT_TRUE(result_obj.isLargeInt());
  LargeInt result(&scope, *result_obj);
  EXPECT_EQ(result.numDigits(), 1);
  EXPECT_EQ(result.digitAt(0), uword{1} << (kBitsPerWord - 2));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithSmallIntsNegativeReturnsLargeInt) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(-4));
  Object right(&scope, runtime_->newInt(kBitsPerWord - 3));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  const uword expected_digits[] = {static_cast<uword>(-4)
                                   << (kBitsPerWord - 3)};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithSmallIntOverflowReturnsLargeInt) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(4));
  Object right(&scope, runtime_->newInt(kBitsPerWord - 3));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  const uword expected_digits[] = {kHighbitUword, 0};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest,
       DunderLshiftWithNegativeSmallIntOverflowReturnsLargeInt) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(-4));
  Object right(&scope, runtime_->newInt(kBitsPerWord - 2));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  const uword expected_digits[] = {0, kMaxUword};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithLargeIntReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits[] = {1, 1};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(2 * kBitsPerWord + 2));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  const uword expected_digits[] = {0, 0, 4, 4};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithNegativeLargeIntReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits[] = {kMaxUword - 1, kMaxUword - 1};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(2 * kBitsPerWord + 2));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  const uword expected_digits[] = {0, 0, kMaxUword - 7, kMaxUword - 4};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithLargeIntWholeWordReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits[] = {0xfe84754526de453c, 0x47e8218b97f94763};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(kBitsPerWord * 2));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  const uword expected_digits[] = {0, 0, 0xfe84754526de453c,
                                   0x47e8218b97f94763};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithNegativeShiftAmountRaiseValueError) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(0));
  Object right(&scope, runtime_->newInt(-1));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  EXPECT_TRUE(
      raisedWithStr(*result, LayoutId::kValueError, "negative shift count"));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithNonIntSelfRaisesTypeError) {
  HandleScope scope(thread_);
  Object left(&scope, Str::empty());
  Object right(&scope, runtime_->newInt(0));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, DunderLshiftWithNonIntReturnsNotImplemented) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(0));
  Object right(&scope, Str::empty());
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  EXPECT_TRUE(result.isNotImplementedType());
}

TEST_F(IntBuiltinsTest, DunderLshiftWithIntSubclassReturnsInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, R"(
class X(int): pass
left = X(0b1101)
right = X(3)
)")
                   .isError());
  Object left(&scope, mainModuleAt(runtime_, "left"));
  Object right(&scope, mainModuleAt(runtime_, "right"));
  Object result(&scope, runBuiltin(METH(int, __lshift__), left, right));
  EXPECT_EQ(result, SmallInt::fromWord(0x68));  // 0b1101000
}

TEST_F(IntBuiltinsTest, DunderModWithSmallIntReturnsInt) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(-9876));
  Object right(&scope, runtime_->newInt(123));
  Object result(&scope, runBuiltin(METH(int, __mod__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 87));
}

TEST_F(IntBuiltinsTest, DunderModWithZeroRaisesZeroDivisionError) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(2));
  Object right(&scope, runtime_->newInt(0));
  Object result(&scope, runBuiltin(METH(int, __mod__), left, right));
  EXPECT_TRUE(raisedWithStr(*result, LayoutId::kZeroDivisionError,
                            "integer division or modulo by zero"));
}

TEST_F(IntBuiltinsTest, DunderModWithNonIntSelfRaisesTypeError) {
  HandleScope scope(thread_);
  Object left(&scope, Str::empty());
  Object right(&scope, runtime_->newInt(1));
  Object result(&scope, runBuiltin(METH(int, __mod__), left, right));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, DunderModWithNontIntReturnsNotImplemented) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(1));
  Object right(&scope, Str::empty());
  Object result(&scope, runBuiltin(METH(int, __mod__), left, right));
  EXPECT_TRUE(result.isNotImplementedType());
}

TEST_F(IntBuiltinsTest, DunderMulWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);

  Int left(&scope, runtime_->newInt(13));
  Int right(&scope, runtime_->newInt(-3));
  Object result(&scope, runBuiltin(METH(int, __mul__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, -39));
}

TEST_F(IntBuiltinsTest, DunderMulWithSmallIntsReturnsSingleDigitLargeInt) {
  HandleScope scope(thread_);

  Int left(&scope, RawSmallInt::fromWord(RawSmallInt::kMaxValue));
  Int right(&scope, RawSmallInt::fromWord(2));
  Object result(&scope, runBuiltin(METH(int, __mul__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, RawSmallInt::kMaxValue * 2));
}

TEST_F(IntBuiltinsTest, DunderMulWithSmallIntsReturnsLargeInt) {
  HandleScope scope(thread_);

  Int num(&scope, RawSmallInt::fromWord(RawSmallInt::kMaxValue));
  Object result(&scope, runBuiltin(METH(int, __mul__), num, num));
  const uword expected_digits[] = {0x8000000000000001, 0xfffffffffffffff};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderMulWithSmallIntLargeIntReturnsLargeInt) {
  HandleScope scope(thread_);

  Int left(&scope, RawSmallInt::fromWord(-3));
  const uword digits[] = {0xa1b2c3d4e5f67890, 0xaabbccddeeff};
  Int right(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __mul__), left, right));
  const uword expected_digits[] = {0x1ae7b4814e1c9650, 0xfffdffcc99663301};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderMulWithZeroReturnsSmallInt) {
  HandleScope scope(thread_);

  const uword digits[] = {0, 1};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits));
  Int right(&scope, RawSmallInt::fromWord(0));
  Object result(&scope, runBuiltin(METH(int, __mul__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 0));
}

TEST_F(IntBuiltinsTest, DunderMulWithPositiveLargeIntsReturnsLargeInt) {
  HandleScope scope(thread_);

  const uword digits_left[] = {0xfedcba0987654321, 0x1234567890abcdef};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0x0123456789abcdef, 0xfedcba9876543210, 0};
  Int right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result(&scope, runBuiltin(METH(int, __mul__), left, right));
  const uword expected_digits[] = {0x2236d928fe5618cf, 0xaa6c87569f0ec6a4,
                                   0x213cff7595234949, 0x121fa00acd77d743};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderMulWithMaxPositiveLargeIntsReturnsLargeInt) {
  HandleScope scope(thread_);

  const uword digits[] = {kMaxUword, 0};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __mul__), num, num));
  const uword expected_digits[] = {1, kMaxUword - 1, 0};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderMulWithNegativeLargeIntsReturnsLargeInt) {
  HandleScope scope(thread_);

  // Smallest negative number representable with 2 digits.
  const uword digits[] = {0, static_cast<uword>(kMinWord)};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __mul__), num, num));
  const uword expected_digits[] = {0, 0, 0, static_cast<uword>(kMinWord) >> 1};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderMulWithNegativePositiveLargeIntsReturnsLargeInt) {
  HandleScope scope(thread_);

  const uword digits_left[] = {0xada6d35d8ef7c790};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0x3ff2ca02c44fbb1c, 0x5873a2744317c09a};
  Int right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result(&scope, runBuiltin(METH(int, __mul__), left, right));
  const uword expected_digits[] = {0x6d80780b775003c0, 0xb46184fc0839baa0,
                                   0xe38c265747f0661f};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderMulWithPositiveNegativeLargeIntsReturnsLargeInt) {
  HandleScope scope(thread_);

  const uword digits_left[] = {0x3ff2ca02c44fbb1c, 0x5873a2744317c09a};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0xada6d35d8ef7c790};
  Int right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result(&scope, runBuiltin(METH(int, __mul__), left, right));
  const uword expected_digits[] = {0x6d80780b775003c0, 0xb46184fc0839baa0,
                                   0xe38c265747f0661f};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderMulWithNonIntSelfRaisesTypeError) {
  HandleScope scope(thread_);

  Str str(&scope, Str::empty());
  Int right(&scope, runtime_->newInt(1));
  Object result(&scope, runBuiltin(METH(int, __mul__), str, right));
  ASSERT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, DunderMulWithNonIntRightReturnsNotImplemented) {
  HandleScope scope(thread_);

  Int left(&scope, runtime_->newInt(1));
  Str str(&scope, Str::empty());
  Object result(&scope, runBuiltin(METH(int, __mul__), left, str));
  ASSERT_TRUE(result.isNotImplementedType());
}

TEST_F(IntBuiltinsTest, DunderOrWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  Int left(&scope, SmallInt::fromWord(0x15));   // 0b010101
  Int right(&scope, SmallInt::fromWord(0x38));  // 0b111000
  Object result(&scope, runBuiltin(METH(int, __or__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 0x3D));  // 0b111101
}

TEST_F(IntBuiltinsTest, DunderOrWithLargeIntsReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits_left[] = {0x0C, 0xB0, 0xCAFE};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0x03, 0xD0};
  Int right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result(&scope, runBuiltin(METH(int, __or__), left, right));
  const uword expected_digits[] = {0x0F, 0xF0, 0xCAFE};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderOrWithNonIntReturnsNotImplemented) {
  HandleScope scope(thread_);
  const uword digits[] = {1, 2};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, Str::empty());
  Object result(&scope, runBuiltin(METH(int, __or__), left, right));
  EXPECT_TRUE(result.isNotImplementedType());
}

TEST_F(IntBuiltinsTest, DunderOrWithInvalidArgumentLeftRaisesException) {
  HandleScope scope(thread_);
  Object left(&scope, Str::empty());
  const uword digits[] = {1, 2};
  LargeInt right(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __or__), left, right));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, DunderOrWithIntSubclassReturnsInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, R"(
class X(int): pass
left = X(0b0011)
right = X(0b0101)
)")
                   .isError());
  Object left(&scope, mainModuleAt(runtime_, "left"));
  Object right(&scope, mainModuleAt(runtime_, "right"));
  Object result(&scope, runBuiltin(METH(int, __or__), left, right));
  EXPECT_EQ(result, SmallInt::fromWord(7));  // 0b0111
}

TEST_F(IntBuiltinsTest, BinaryAddSmallInt) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = 2
b = 1
c = a + b
)")
                   .isError());

  Object c(&scope, mainModuleAt(runtime_, "c"));
  EXPECT_TRUE(isIntEqualsWord(*c, 3));
}

TEST_F(IntBuiltinsTest, BitLength) {
  HandleScope scope(thread_);

  // (0).bit_length() == 0
  Object num(&scope, SmallInt::fromWord(0));
  Object bit_length(&scope, runBuiltin(METH(int, bit_length), num));
  EXPECT_TRUE(isIntEqualsWord(*bit_length, 0));

  // (1).bit_length() == 1
  num = SmallInt::fromWord(1);
  Object bit_length1(&scope, runBuiltin(METH(int, bit_length), num));
  EXPECT_TRUE(isIntEqualsWord(*bit_length1, 1));

  // (-1).bit_length() == 1
  num = SmallInt::fromWord(1);
  Object bit_length2(&scope, runBuiltin(METH(int, bit_length), num));
  EXPECT_TRUE(isIntEqualsWord(*bit_length2, 1));

  // (SmallInt::kMaxValue).bit_length() == 62
  num = SmallInt::fromWord(RawSmallInt::kMaxValue);
  Object bit_length3(&scope, runBuiltin(METH(int, bit_length), num));
  EXPECT_TRUE(isIntEqualsWord(*bit_length3, 62));

  // (SmallInt::kMinValue).bit_length() == 63
  num = SmallInt::fromWord(RawSmallInt::kMinValue);
  Object bit_length4(&scope, runBuiltin(METH(int, bit_length), num));
  EXPECT_TRUE(isIntEqualsWord(*bit_length4, 63));

  // (kMaxInt64).bit_length() == 63
  num = runtime_->newInt(kMaxInt64);
  Object bit_length5(&scope, runBuiltin(METH(int, bit_length), num));
  EXPECT_TRUE(isIntEqualsWord(*bit_length5, 63));

  // (kMinInt64).bit_length() == 64
  num = runtime_->newInt(kMinInt64);
  Object bit_length6(&scope, runBuiltin(METH(int, bit_length), num));
  EXPECT_TRUE(isIntEqualsWord(*bit_length6, 64));

  uword digits[] = {0, kMaxInt32};
  num = runtime_->newLargeIntWithDigits(digits);
  Object bit_length7(&scope, runBuiltin(METH(int, bit_length), num));
  // 31 bits for kMaxInt32 + 64 bits
  EXPECT_TRUE(isIntEqualsWord(*bit_length7, 95));

  // (kMinInt64 * 4).bit_length() == 66
  uword digits2[] = {0, kMaxUword - 1};  // kMaxUword - 1 == -2
  num = runtime_->newLargeIntWithDigits(digits2);
  Object bit_length8(&scope, runBuiltin(METH(int, bit_length), num));
  EXPECT_TRUE(isIntEqualsWord(*bit_length8, 66));

  // (kMinInt64 * 4 + 3).bit_length() == 65
  uword digits3[] = {3, kMaxUword - 1};  // kMaxUword - 1 == -2
  num = runtime_->newLargeIntWithDigits(digits3);
  Object bit_length9(&scope, runBuiltin(METH(int, bit_length), num));
  EXPECT_TRUE(isIntEqualsWord(*bit_length9, 65));
}

TEST_F(IntBuiltinsTest, CompareLargeIntEq) {
  HandleScope scope(thread_);

  Object a(&scope, runtime_->newInt(RawSmallInt::kMaxValue + 1));
  Object b(&scope, runtime_->newInt(RawSmallInt::kMinValue - 1));
  Object zero(&scope, SmallInt::fromWord(0));
  ASSERT_TRUE(a.isLargeInt());
  ASSERT_TRUE(b.isLargeInt());

  Object cmp_1(&scope, runBuiltin(METH(int, __eq__), a, b));
  ASSERT_TRUE(cmp_1.isBool());
  EXPECT_EQ(*cmp_1, Bool::falseObj());

  Object cmp_2(&scope, runBuiltin(METH(int, __eq__), a, zero));
  ASSERT_TRUE(cmp_2.isBool());
  EXPECT_EQ(*cmp_2, Bool::falseObj());

  Object cmp_3(&scope, runBuiltin(METH(int, __eq__), a, a));
  ASSERT_TRUE(cmp_3.isBool());
  EXPECT_EQ(*cmp_3, Bool::trueObj());

  Object cmp_4(&scope, runBuiltin(METH(int, __eq__), b, a));
  ASSERT_TRUE(cmp_4.isBool());
  EXPECT_EQ(*cmp_4, Bool::falseObj());

  Object cmp_5(&scope, runBuiltin(METH(int, __eq__), b, zero));
  ASSERT_TRUE(cmp_5.isBool());
  EXPECT_EQ(*cmp_5, Bool::falseObj());

  Object cmp_6(&scope, runBuiltin(METH(int, __eq__), b, b));
  ASSERT_TRUE(cmp_6.isBool());
  EXPECT_EQ(*cmp_6, Bool::trueObj());
}

TEST_F(IntBuiltinsTest, CompareLargeIntNe) {
  HandleScope scope(thread_);

  Object a(&scope, runtime_->newInt(RawSmallInt::kMaxValue + 1));
  Object b(&scope, runtime_->newInt(RawSmallInt::kMinValue - 1));
  Object zero(&scope, SmallInt::fromWord(0));
  ASSERT_TRUE(a.isLargeInt());
  ASSERT_TRUE(b.isLargeInt());

  Object cmp_1(&scope, runBuiltin(METH(int, __ne__), a, b));
  ASSERT_TRUE(cmp_1.isBool());
  EXPECT_EQ(*cmp_1, Bool::trueObj());

  Object cmp_2(&scope, runBuiltin(METH(int, __ne__), a, zero));
  ASSERT_TRUE(cmp_2.isBool());
  EXPECT_EQ(*cmp_2, Bool::trueObj());

  Object cmp_3(&scope, runBuiltin(METH(int, __ne__), a, a));
  ASSERT_TRUE(cmp_3.isBool());
  EXPECT_EQ(*cmp_3, Bool::falseObj());

  Object cmp_4(&scope, runBuiltin(METH(int, __ne__), b, a));
  ASSERT_TRUE(cmp_4.isBool());
  EXPECT_EQ(*cmp_4, Bool::trueObj());

  Object cmp_5(&scope, runBuiltin(METH(int, __ne__), b, zero));
  ASSERT_TRUE(cmp_5.isBool());
  EXPECT_EQ(*cmp_5, Bool::trueObj());

  Object cmp_6(&scope, runBuiltin(METH(int, __ne__), b, b));
  ASSERT_TRUE(cmp_6.isBool());
  EXPECT_EQ(*cmp_6, Bool::falseObj());
}

TEST_F(IntBuiltinsTest, DunderFloatWithBoolReturnsFloat) {
  HandleScope scope(thread_);

  Object a(&scope, Bool::trueObj());
  Object a_float(&scope, runBuiltin(METH(int, __float__), a));
  EXPECT_TRUE(isFloatEqualsDouble(*a_float, 1.0));

  Object b(&scope, Bool::falseObj());
  Object b_float(&scope, runBuiltin(METH(int, __float__), b));
  EXPECT_TRUE(isFloatEqualsDouble(*b_float, 0.0));
}

TEST_F(IntBuiltinsTest, DunderFloatWithSmallIntReturnsFloat) {
  HandleScope scope(thread_);

  Int num(&scope, RawSmallInt::fromWord(-7));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  EXPECT_TRUE(isFloatEqualsDouble(*result, -7.0));
}

TEST_F(IntBuiltinsTest, DunderFloatWithOneDigitLargeIntReturnsFloat) {
  HandleScope scope(thread_);

  const uword digits[] = {static_cast<uword>(kMinWord)};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  EXPECT_TRUE(isFloatEqualsDouble(*result, double{kMinWord}));
}

TEST_F(IntBuiltinsTest, DunderFloatWithLargeIntReturnsFloat) {
  HandleScope scope(thread_);

  const uword digits[] = {0x85b3f6fb0496ac6f, 0x129ef6};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  EXPECT_TRUE(isFloatEqualsDouble(
      *result, std::strtod("0x1.29ef685b3f6fbp+84", nullptr)));
}

TEST_F(IntBuiltinsTest, DunderFloatWithNegativeLargeIntReturnsFloat) {
  HandleScope scope(thread_);

  const uword digits[] = {0x937822557f9bad3f, 0xb31911a86c86a071};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  EXPECT_TRUE(isFloatEqualsDouble(
      *result, std::strtod("-0x1.339bb95e4de58p+126", nullptr)));
}

TEST_F(IntBuiltinsTest,
       DunderFloatWithNegativeLargeIntMagnitudeComputationCarriesReturnsFloat) {
  HandleScope scope(thread_);

  const uword digits[] = {1, 0, 0, 0xfffedcc000000000};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  EXPECT_TRUE(
      isFloatEqualsDouble(*result, std::strtod("-0x1.234p240", nullptr)));
}

TEST_F(IntBuiltinsTest, DunderFloatWithLargeIntRoundedDownReturnsFloat) {
  HandleScope scope(thread_);

  // Produce a 1 so that all of the mantissa lies in the high digit but the bit
  // triggering the rounding is in the low digit.
  uword mantissa_high_bit = uword{1} << kDoubleMantissaBits;
  const uword digits[] = {0, mantissa_high_bit};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  EXPECT_TRUE(isFloatEqualsDouble(*result, std::strtod("0x1.p116", nullptr)));
}

TEST_F(IntBuiltinsTest, DunderFloatWithLargeIntRoundedDownToEvenReturnsFloat) {
  HandleScope scope(thread_);

  const uword digits[] = {uword{1} << (kBitsPerWord - kDoubleMantissaBits - 1),
                          1};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  EXPECT_TRUE(isFloatEqualsDouble(*result, std::strtod("0x1.p64", nullptr)));
}

TEST_F(IntBuiltinsTest, DunderFloatWithLargeIntRoundedUpToEvenReturnsFloat) {
  HandleScope scope(thread_);

  uword mantissa_high_bit_plus_one = (uword{1} << kDoubleMantissaBits) + 1;
  const uword digits[] = {kHighbitUword, mantissa_high_bit_plus_one};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  EXPECT_TRUE(isFloatEqualsDouble(
      *result, std::strtod("0x1.0000000000002p116", nullptr)));
}

TEST_F(IntBuiltinsTest,
       DunderFloatWithNegativeLargeIntRoundedDownToEvenReturnsFloat) {
  HandleScope scope(thread_);

  uword mantissa_high_bit = uword{1} << kDoubleMantissaBits;
  const uword digits[] = {0, kHighbitUword, ~mantissa_high_bit};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  EXPECT_TRUE(isFloatEqualsDouble(*result, std::strtod("-0x1.p180", nullptr)));
}

TEST_F(IntBuiltinsTest,
       DunderFloatWithNegativeLargeIntRoundedUpToEvenReturnsFloat) {
  HandleScope scope(thread_);

  uword mantissa_high_bit_plus_one = (uword{1} << kDoubleMantissaBits) | 1;
  const uword digits[] = {0, kHighbitUword, ~mantissa_high_bit_plus_one};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  EXPECT_TRUE(isFloatEqualsDouble(
      *result, std::strtod("-0x1.0000000000002p180", nullptr)));
}

TEST_F(IntBuiltinsTest,
       DunderFloatWithLargeIntRoundedUpIncreasingExponentReturnsFloat) {
  HandleScope scope(thread_);

  uword mantissa_all_one = (uword{1} << (kDoubleMantissaBits + 1)) - 1;
  const uword digits[] = {kHighbitUword, mantissa_all_one};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  EXPECT_TRUE(isFloatEqualsDouble(*result, std::strtod("0x1.p117", nullptr)));
}

static RawObject largestIntBeforeFloatOverflow(Runtime* runtime) {
  int exponent_bits = kBitsPerDouble - kDoubleMantissaBits - 1;
  word max_unbiased_exponent = (1 << (exponent_bits - 1)) - 1;
  CHECK((max_unbiased_exponent + 1) % kBitsPerWord == 0,
        "assuming max exponent position matches highest bit in digit");
  // Note: Need an extra digit for the sign.
  word num_digits = (max_unbiased_exponent + 1) / kBitsPerWord + 1;
  std::unique_ptr<uword[]> digits(new uword[num_digits]);
  for (word i = 0; i < num_digits - 1; i++) {
    digits[i] = kMaxUword;
  }
  // Set the bit immediately below the mantissa to zero to avoid rounding up.
  digits[num_digits - 2] &= ~(1 << (kBitsPerWord - kDoubleMantissaBits - 2));
  digits[num_digits - 1] = 0;
  return runtime->newLargeIntWithDigits(View<uword>(digits.get(), num_digits));
}

TEST_F(IntBuiltinsTest,
       DunderFloatLargestPossibleLargeIntBeforeOverflowReturnsFloat) {
  HandleScope scope(thread_);

  Int num(&scope, largestIntBeforeFloatOverflow(runtime_));
  Object result(&scope, runBuiltin(METH(int, __float__), num));
  ASSERT_TRUE(result.isFloat());
  EXPECT_TRUE(isFloatEqualsDouble(*result, std::numeric_limits<double>::max()));
}

TEST_F(IntBuiltinsTest, DunderFloatOverflowRaisesOverflowError) {
  HandleScope scope(thread_);

  // Add 1 to the largest number that is still convertible to float.
  Int num0(&scope, largestIntBeforeFloatOverflow(runtime_));
  Int one(&scope, runtime_->newInt(1));
  Int num1(&scope, runBuiltin(METH(int, __add__), num0, one));
  Object result(&scope, runBuiltin(METH(int, __float__), num1));
  EXPECT_TRUE(raised(*result, LayoutId::kOverflowError));
}

TEST_F(IntBuiltinsTest, DunderFloatWithNonIntReturnsError) {
  HandleScope scope(thread_);
  Object none(&scope, NoneType::object());
  Object result(&scope, runBuiltin(METH(int, __int__), none));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, DunderFloordivWithSmallIntReturnsInt) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(42));
  Object right(&scope, runtime_->newInt(9));
  Object result(&scope, runBuiltin(METH(int, __floordiv__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 4));
}

TEST_F(IntBuiltinsTest, DunderFloordivWithZeroRaisesZeroDivisionError) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(2));
  Object right(&scope, runtime_->newInt(0));
  Object result(&scope, runBuiltin(METH(int, __floordiv__), left, right));
  EXPECT_TRUE(raisedWithStr(*result, LayoutId::kZeroDivisionError,
                            "integer division or modulo by zero"));
}

TEST_F(IntBuiltinsTest, DunderFloordivWithNonIntSelfRaisesTypeError) {
  HandleScope scope(thread_);
  Object left(&scope, Str::empty());
  Object right(&scope, runtime_->newInt(1));
  Object result(&scope, runBuiltin(METH(int, __floordiv__), left, right));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, DunderFloordivWithNontIntReturnsNotImplemented) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(1));
  Object right(&scope, Str::empty());
  Object result(&scope, runBuiltin(METH(int, __floordiv__), left, right));
  EXPECT_TRUE(result.isNotImplementedType());
}

TEST_F(LargeIntBuiltinsTest, TruthyLargeInt) {
  ASSERT_FALSE(runFromCStr(runtime_, R"(
value = 46116860184273879030000000
)")
                   .isError());
  HandleScope scope(thread_);
  Object value(&scope, mainModuleAt(runtime_, "value"));
  EXPECT_EQ(runBuiltin(METH(int, __bool__), value), Bool::trueObj());
}

TEST_F(IntBuiltinsTest, CompareLargeIntGe) {
  HandleScope scope(thread_);

  Object a(&scope, runtime_->newInt(RawSmallInt::kMaxValue + 1));
  Object b(&scope, runtime_->newInt(RawSmallInt::kMinValue - 1));
  Object zero(&scope, SmallInt::fromWord(0));
  ASSERT_TRUE(a.isLargeInt());
  ASSERT_TRUE(b.isLargeInt());

  Object cmp_1(&scope, runBuiltin(METH(int, __ge__), a, b));
  ASSERT_TRUE(cmp_1.isBool());
  EXPECT_EQ(*cmp_1, Bool::trueObj());

  Object cmp_2(&scope, runBuiltin(METH(int, __ge__), a, zero));
  ASSERT_TRUE(cmp_2.isBool());
  EXPECT_EQ(*cmp_2, Bool::trueObj());

  Object cmp_3(&scope, runBuiltin(METH(int, __ge__), a, a));
  ASSERT_TRUE(cmp_3.isBool());
  EXPECT_EQ(*cmp_3, Bool::trueObj());

  Object cmp_4(&scope, runBuiltin(METH(int, __ge__), b, a));
  ASSERT_TRUE(cmp_4.isBool());
  EXPECT_EQ(*cmp_4, Bool::falseObj());

  Object cmp_5(&scope, runBuiltin(METH(int, __ge__), b, zero));
  ASSERT_TRUE(cmp_5.isBool());
  EXPECT_EQ(*cmp_5, Bool::falseObj());

  Object cmp_6(&scope, runBuiltin(METH(int, __ge__), b, b));
  ASSERT_TRUE(cmp_6.isBool());
  EXPECT_EQ(*cmp_6, Bool::trueObj());
}

TEST_F(IntBuiltinsTest, CompareLargeIntLe) {
  HandleScope scope(thread_);

  Object a(&scope, runtime_->newInt(RawSmallInt::kMaxValue + 1));
  Object b(&scope, runtime_->newInt(RawSmallInt::kMinValue - 1));
  Object zero(&scope, SmallInt::fromWord(0));
  ASSERT_TRUE(a.isLargeInt());
  ASSERT_TRUE(b.isLargeInt());

  Object cmp_1(&scope, runBuiltin(METH(int, __le__), a, b));
  ASSERT_TRUE(cmp_1.isBool());
  EXPECT_EQ(*cmp_1, Bool::falseObj());

  Object cmp_2(&scope, runBuiltin(METH(int, __le__), a, zero));
  ASSERT_TRUE(cmp_2.isBool());
  EXPECT_EQ(*cmp_2, Bool::falseObj());

  Object cmp_3(&scope, runBuiltin(METH(int, __le__), a, a));
  ASSERT_TRUE(cmp_3.isBool());
  EXPECT_EQ(*cmp_3, Bool::trueObj());

  Object cmp_4(&scope, runBuiltin(METH(int, __le__), b, a));
  ASSERT_TRUE(cmp_4.isBool());
  EXPECT_EQ(*cmp_4, Bool::trueObj());

  Object cmp_5(&scope, runBuiltin(METH(int, __le__), b, zero));
  ASSERT_TRUE(cmp_5.isBool());
  EXPECT_EQ(*cmp_5, Bool::trueObj());

  Object cmp_6(&scope, runBuiltin(METH(int, __le__), b, b));
  ASSERT_TRUE(cmp_6.isBool());
  EXPECT_EQ(*cmp_6, Bool::trueObj());
}

TEST_F(IntBuiltinsTest, CompareLargeIntGt) {
  HandleScope scope(thread_);

  Object a(&scope, runtime_->newInt(RawSmallInt::kMaxValue + 1));
  Object b(&scope, runtime_->newInt(RawSmallInt::kMinValue - 1));
  Object zero(&scope, SmallInt::fromWord(0));
  ASSERT_TRUE(a.isLargeInt());
  ASSERT_TRUE(b.isLargeInt());

  Object cmp_1(&scope, runBuiltin(METH(int, __gt__), a, b));
  ASSERT_TRUE(cmp_1.isBool());
  EXPECT_EQ(*cmp_1, Bool::trueObj());

  Object cmp_2(&scope, runBuiltin(METH(int, __gt__), a, zero));
  ASSERT_TRUE(cmp_2.isBool());
  EXPECT_EQ(*cmp_2, Bool::trueObj());

  Object cmp_3(&scope, runBuiltin(METH(int, __gt__), a, a));
  ASSERT_TRUE(cmp_3.isBool());
  EXPECT_EQ(*cmp_3, Bool::falseObj());

  Object cmp_4(&scope, runBuiltin(METH(int, __gt__), b, a));
  ASSERT_TRUE(cmp_4.isBool());
  EXPECT_EQ(*cmp_4, Bool::falseObj());

  Object cmp_5(&scope, runBuiltin(METH(int, __gt__), b, zero));
  ASSERT_TRUE(cmp_5.isBool());
  EXPECT_EQ(*cmp_5, Bool::falseObj());

  Object cmp_6(&scope, runBuiltin(METH(int, __gt__), b, b));
  ASSERT_TRUE(cmp_6.isBool());
  EXPECT_EQ(*cmp_6, Bool::falseObj());
}

TEST_F(IntBuiltinsTest, CompareLargeIntLt) {
  HandleScope scope(thread_);

  Object a(&scope, runtime_->newInt(RawSmallInt::kMaxValue + 1));
  Object b(&scope, runtime_->newInt(RawSmallInt::kMinValue - 1));
  Object zero(&scope, SmallInt::fromWord(0));
  ASSERT_TRUE(a.isLargeInt());
  ASSERT_TRUE(b.isLargeInt());

  Object cmp_1(&scope, runBuiltin(METH(int, __lt__), a, b));
  ASSERT_TRUE(cmp_1.isBool());
  EXPECT_EQ(*cmp_1, Bool::falseObj());

  Object cmp_2(&scope, runBuiltin(METH(int, __lt__), a, zero));
  ASSERT_TRUE(cmp_2.isBool());
  EXPECT_EQ(*cmp_2, Bool::falseObj());

  Object cmp_3(&scope, runBuiltin(METH(int, __lt__), a, a));
  ASSERT_TRUE(cmp_3.isBool());
  EXPECT_EQ(*cmp_3, Bool::falseObj());

  Object cmp_4(&scope, runBuiltin(METH(int, __lt__), b, a));
  ASSERT_TRUE(cmp_4.isBool());
  EXPECT_EQ(*cmp_4, Bool::trueObj());

  Object cmp_5(&scope, runBuiltin(METH(int, __lt__), b, zero));
  ASSERT_TRUE(cmp_5.isBool());
  EXPECT_EQ(*cmp_5, Bool::trueObj());

  Object cmp_6(&scope, runBuiltin(METH(int, __lt__), b, b));
  ASSERT_TRUE(cmp_6.isBool());
  EXPECT_EQ(*cmp_6, Bool::falseObj());
}

TEST_F(IntBuiltinsTest, DunderIndexAliasesDunderInt) {
  Thread* thread = Thread::current();
  HandleScope scope(thread);
  Type type(&scope, moduleAtByCStr(runtime_, "builtins", "int"));
  Object index_name(&scope, Runtime::internStrFromCStr(thread_, "__index__"));
  Object index_obj(&scope, typeAt(type, index_name));
  ASSERT_TRUE(index_obj.isFunction());
  Function index(&scope, *index_obj);
  Object dint_name(&scope, Runtime::internStrFromCStr(thread_, "__int__"));
  Object dint_obj(&scope, typeAt(type, dint_name));
  ASSERT_TRUE(dint_obj.isFunction());
  Function dint(&scope, *index_obj);
  EXPECT_EQ(Code::cast(index.code()).code(), Code::cast(dint.code()).code());
  EXPECT_EQ(index.entry(), dint.entry());
  EXPECT_EQ(index.entryKw(), dint.entryKw());
  EXPECT_EQ(index.entryEx(), dint.entryEx());
}

TEST_F(IntBuiltinsTest, DunderIntWithBoolFalseReturnsZero) {
  HandleScope scope(thread_);

  Object self(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, __int__), self));
  EXPECT_EQ(result, SmallInt::fromWord(0));
}

TEST_F(IntBuiltinsTest, DunderIntWithBoolTrueReturnsOne) {
  HandleScope scope(thread_);

  Object self(&scope, Bool::trueObj());
  Object result(&scope, runBuiltin(METH(int, __int__), self));
  EXPECT_EQ(result, SmallInt::fromWord(1));
}

TEST_F(IntBuiltinsTest, DunderIntWithSmallIntReturnsSame) {
  HandleScope scope(thread_);

  Object self(&scope, RawSmallInt::fromWord(7));
  Object result(&scope, runBuiltin(METH(int, __int__), self));
  EXPECT_EQ(self, result);
}

TEST_F(IntBuiltinsTest, DunderIntReturnsSameValue) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
a = (7).__int__()
b = int.__int__(7)
)")
                   .isError());
  Object a(&scope, mainModuleAt(runtime_, "a"));
  Object b(&scope, mainModuleAt(runtime_, "b"));
  EXPECT_TRUE(isIntEqualsWord(*a, 7));
  EXPECT_TRUE(isIntEqualsWord(*b, 7));

  Str str(&scope, runtime_->newStrFromCStr("python"));
  Object res(&scope, runBuiltin(METH(int, __int__), str));
  EXPECT_TRUE(res.isError());
}

TEST_F(IntBuiltinsTest, DunderInvertWithBoolTrueReturnsSmallInt) {
  HandleScope scope(thread_);
  Object num(&scope, Bool::trueObj());
  Object result(&scope, runBuiltin(METH(int, __invert__), num));
  ASSERT_TRUE(result.isSmallInt());
  EXPECT_TRUE(isIntEqualsWord(*result, -2));
}

TEST_F(IntBuiltinsTest, DunderInvertWithBoolFalseReturnsSmallInt) {
  HandleScope scope(thread_);
  Object num(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, __invert__), num));
  ASSERT_TRUE(result.isSmallInt());
  EXPECT_TRUE(isIntEqualsWord(*result, -1));
}

TEST_F(IntBuiltinsTest, DunderInvertWithSmallIntReturnsSmallInt) {
  HandleScope scope(thread_);
  Object num(&scope, SmallInt::fromWord(-224466));
  Object result(&scope, runBuiltin(METH(int, __invert__), num));
  ASSERT_TRUE(result.isSmallInt());
  EXPECT_TRUE(isIntEqualsWord(*result, 224465));
}

TEST_F(IntBuiltinsTest, DunderInvertWithLargeIntReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword num_digits[] = {0x6c5bfcb426758496, 0xda8bdbe69c009bc5, 0};
  Object num(&scope, runtime_->newLargeIntWithDigits(num_digits));
  Object result_obj(&scope, runBuiltin(METH(int, __invert__), num));
  ASSERT_TRUE(result_obj.isLargeInt());
  Int result(&scope, *result_obj);
  const uword expected_digits[] = {0x93a4034bd98a7b69, 0x2574241963ff643a,
                                   kMaxUword};
  Int expected(&scope, runtime_->newLargeIntWithDigits(expected_digits));
  EXPECT_EQ(expected.compare(*result), 0);
}

TEST_F(IntBuiltinsTest, DunderBoolOnBool) {
  HandleScope scope(thread_);

  Object true_obj(&scope, Bool::trueObj());
  EXPECT_EQ(runBuiltin(METH(int, __bool__), true_obj), Bool::trueObj());

  Object false_obj(&scope, Bool::falseObj());
  EXPECT_EQ(runBuiltin(METH(int, __bool__), false_obj), Bool::falseObj());
}

TEST_F(IntBuiltinsTest, DunderDivmodWithBoolsReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, Bool::trueObj());
  Object right(&scope, Bool::trueObj());
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), 1));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 0));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithSmallIntReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, RawSmallInt::fromWord(4321));
  Object right(&scope, RawSmallInt::fromWord(17));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), 254));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 3));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithSmallIntNegativeDividendNegativeDivisorReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, RawSmallInt::fromWord(-987654321));
  Object right(&scope, RawSmallInt::fromWord(-654));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), 1510174));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), -525));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithSmallIntNegativeDividendReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, RawSmallInt::fromWord(-123456789));
  Object right(&scope, RawSmallInt::fromWord(456));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), -270739));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 195));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithSmallIntNegativeDividendNoRemainderReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, RawSmallInt::fromWord(-94222222181));
  Object right(&scope, RawSmallInt::fromWord(53));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), -1777777777));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 0));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithSmallIntNegativeDivisorReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, RawSmallInt::fromWord(111222333));
  Object right(&scope, RawSmallInt::fromWord(-444));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), -250501));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), -111));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithSmallIntNegativeDivisorNoRemainderReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, RawSmallInt::fromWord(94222222181));
  Object right(&scope, RawSmallInt::fromWord(-53));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), -1777777777));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 0));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithSmallIntAndDivisorMinusOneReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(kMinWord));
  Object right(&scope, runtime_->newInt(-1));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits[] = {kHighbitUword, 0};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 0));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithLargeIntAndDivisorMinusOneReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits[] = {0, kHighbitUword};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(-1));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits[] = {0, kHighbitUword, 0};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 0));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithSingleDigitDivisorReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits[] = {0x4a23475557e990d0, 0x56c1275a8b41bed9};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(77));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits[] = {0x79cb7c896c08a31, 0x1206e39b2042db3};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 19));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithBoolDivisorReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits[] = {0x4a23475557e990d0, 0x56c1275a8b41bed9};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, Bool::trueObj());
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits[] = {0x4a23475557e990d0, 0x56c1275a8b41bed9};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 0));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithSingleDigitNegativeDivisorReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits[] = {0x6d73444a30629c55, 0x2c4ab2d4de16e2ef};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(-87654));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits[] = {0x334af489352d60f6, 0xffffdee26dff7ad9};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), -7591));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithSingleDigitNegativeDivisorNoRemainderReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits[] = {0x6d73444a30629c55, 0x2c4ab2d4de16e2ef};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(-5));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits[] = {0x83b5bf245cb913ef, 0xf72442a239fb6c36};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 0));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithSingleDigitDivisorNegativeDividendReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits[] = {0x94472249c23c1189, 0xffe0519aab10d602};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(12345));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits[] = {0x5b96544c9be595f3, 0xffffff57d046e6d2};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 7790));
}

TEST_F(
    IntBuiltinsTest,
    DunderDivmodWithSingleDigitDivisorNegativeDividendNoRemainderReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits[] = {0x94472249c23c1189, 0xffe0519aab10d602};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(5));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits[] = {0x50db06db8d3f36b5, 0xfff9a9ebbbd02acd};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 0));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithSingleDigitNegativeDivisorNegativeDividendReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits[] = {0x91a950df92c04492, 0xd60eebbadb89de2f};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(-1117392329));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits[] = {0x6aaebd022be4f5c, 0xa1368e9f};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), -108249138));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithJustNotASingleDigitDivisorReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits[] = {0xaaa, 3};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(-0x100000000));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), -12884901889));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), -4294964566));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithBiggerDivisorReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits_left[] = {0x575420c5052ae9c6};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0x383b89d9e2bb74f5, 0x1234};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), 0));
  // The algorithm should take a shortcut and return the dividend unchanged.
  EXPECT_EQ(result.at(1), left);
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithNegativeDividendBiggerDivisorReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(-55));
  const uword digits[] = {0, 1};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), -1));
  const uword expected_digits[] = {~uword{54}, 0};
  EXPECT_TRUE(isIntEqualsDigits(result.at(1), expected_digits));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithDividendBiggerNegativeDivisorReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(55));
  const uword digits[] = {0, kHighbitUword};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), -1));
  const uword expected_digits[] = {55, kHighbitUword};
  EXPECT_TRUE(isIntEqualsDigits(result.at(1), expected_digits));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithNegativeDividendBiggerNegativeDivisorReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(-55));
  const uword digits[] = {0, kMaxUword};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), 0));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), -55));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithLargeIntReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits_left[] = {0x383b89d9e2bb74f5, 0x410f8dceb8660505,
                               0x383b1ab8d7938f4b, 0x87108b9b45b43d};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0x975420c5052ae9c6, 0x3bcd71afac71b2e4};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits1[] = {0x4015dc39ddfb7863, 0x2422dc41b36a89e};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits1));
  const uword expected_digits2[] = {0x58023143a26c3d63, 0x290c5dcb84cbb46f};
  EXPECT_TRUE(isIntEqualsDigits(result.at(1), expected_digits2));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithLargeIntPowerOfTwoReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits_left[] = {0xee31ba892c71000e, 0x7175d128f7c2574a};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0, 1};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), 0x7175d128f7c2574a));
  const uword expected_digits[] = {0xee31ba892c71000e, 0};
  EXPECT_TRUE(isIntEqualsDigits(result.at(1), expected_digits));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithZeroDividendBiggerNegativeDivisorReturnsTuple) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(0));
  const uword digits[] = {0, 1};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), 0));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 0));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithLargeIntNegativeDividendReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits_left[] = {0x72a8be6d697d55c0, 0x9d95978dc878d9ae,
                               0xae86bef7900edb79};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0x9893b50147995ab1, 0x73537a3bc36c3a0e};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits1[] = {0x4b2538374030ad53, 0xffffffffffffffff};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits1));
  const uword expected_digits2[] = {0x2f13a2c4f4b515d, 0x38ab976c676089ea};
  EXPECT_TRUE(isIntEqualsDigits(result.at(1), expected_digits2));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithLargeIntNegativeDivisorReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits_left[] = {0x11000235a5b61b48, 0x54cb34ee1cde8d78,
                               0x2ac801d0ae5dcf65};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0xfb2879c8be1e7dda, 0xf8101cf6608d0f6a};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits1[] = {0x9c248b8175e4f19f, 0xfffffffffffffffa};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits1));
  const uword expected_digits2[] = {0xdc2e58062423b6e2, 0xfa5dd4db30c9589e};
  EXPECT_TRUE(isIntEqualsDigits(result.at(1), expected_digits2));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithLargeIntNegativeDividendNegativeDivisorReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits_left[] = {0xc4b749b3bc2eb7e0, 0x74e4cc72dc8a2e9b,
                               0x46bb00bd468a1799, 0xc29ae4e0ae05134};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0x839c30dba1685693, 0xad0140cf78eaee70,
                                0xd77ec3cef0613585};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits1[] = {0xb320ce53675ba5b0};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits1));
  const uword expected_digits2[] = {0xfbf66d17996573d0, 0xfb57b237e188be27,
                                    0xe9d7473ac0f6b873};
  EXPECT_TRUE(isIntEqualsDigits(result.at(1), expected_digits2));
}

TEST_F(IntBuiltinsTest,
       DunderDivmodWithLargeIntTriggeringNegateBugReturnsTuple) {
  HandleScope scope(thread_);
  const uword digits[] = {1, 0, 1};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(-5));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  const uword expected_digits[] = {0xcccccccccccccccc, 0xcccccccccccccccc};
  EXPECT_TRUE(isIntEqualsDigits(result.at(0), expected_digits));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), -3));
}

TEST_F(IntBuiltinsTest, DunderDivmodReturnsMinWordPlusOneModulo) {
  HandleScope scope(thread_);
  const uword left_digits[] = {1, 1};
  Object left(&scope, runtime_->newLargeIntWithDigits(left_digits));
  const uword right_digits[] = {static_cast<uword>(kMinWord)};
  Object right(&scope, runtime_->newLargeIntWithDigits(right_digits));
  Object result_obj(&scope, runBuiltin(METH(int, __divmod__), left, right));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), -3));
  const uword expected_digits[] = {static_cast<uword>(kMinWord) + 1};
  EXPECT_TRUE(isIntEqualsDigits(result.at(1), expected_digits));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithZeroRaisesZeroDivisionError) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(2));
  Object right(&scope, runtime_->newInt(0));
  Object result(&scope, runBuiltin(METH(int, __divmod__), left, right));
  EXPECT_TRUE(raisedWithStr(*result, LayoutId::kZeroDivisionError,
                            "integer division or modulo by zero"));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithNonIntSelfRaisesTypeError) {
  HandleScope scope(thread_);
  Object left(&scope, Str::empty());
  Object right(&scope, runtime_->newInt(1));
  Object result(&scope, runBuiltin(METH(int, __divmod__), left, right));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, DunderDivmodWithNontIntReturnsNotImplemented) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(1));
  Object right(&scope, Str::empty());
  Object result(&scope, runBuiltin(METH(int, __divmod__), left, right));
  EXPECT_TRUE(result.isNotImplementedType());
}

TEST_F(IntBuiltinsTest, DunderEqOnBool) {
  HandleScope scope(thread_);

  Object true_obj(&scope, Bool::trueObj());
  EXPECT_EQ(runBuiltin(METH(int, __eq__), true_obj, true_obj), Bool::trueObj());

  Object false_obj(&scope, Bool::falseObj());
  EXPECT_EQ(runBuiltin(METH(int, __eq__), true_obj, false_obj),
            Bool::falseObj());

  Object zero(&scope, SmallInt::fromWord(0));
  EXPECT_EQ(runBuiltin(METH(int, __eq__), true_obj, zero), Bool::falseObj());

  Object one(&scope, SmallInt::fromWord(1));
  EXPECT_EQ(runBuiltin(METH(int, __eq__), true_obj, one), Bool::trueObj());
}

TEST_F(IntBuiltinsTest, DunderNeOnBool) {
  HandleScope scope(thread_);

  Object true_obj(&scope, Bool::trueObj());
  EXPECT_EQ(runBuiltin(METH(int, __ne__), true_obj, true_obj),
            Bool::falseObj());

  Object false_obj(&scope, Bool::falseObj());
  EXPECT_EQ(runBuiltin(METH(int, __ne__), true_obj, false_obj),
            Bool::trueObj());

  Object zero(&scope, SmallInt::fromWord(0));
  EXPECT_EQ(runBuiltin(METH(int, __ne__), true_obj, zero), Bool::trueObj());

  Object one(&scope, SmallInt::fromWord(1));
  EXPECT_EQ(runBuiltin(METH(int, __ne__), true_obj, one), Bool::falseObj());
}

TEST_F(IntBuiltinsTest, DunderNegWithSmallIntReturnsSmallInt) {
  HandleScope scope(thread_);
  Object num(&scope, runtime_->newInt(42));
  Object result(&scope, runBuiltin(METH(int, __neg__), num));
  EXPECT_TRUE(isIntEqualsWord(*result, -42));
}

TEST_F(IntBuiltinsTest, DunderNegWithSmallIntReturnsLargeInt) {
  HandleScope scope(thread_);
  Object num(&scope, runtime_->newInt(RawSmallInt::kMinValue));
  Object result(&scope, runBuiltin(METH(int, __neg__), num));
  EXPECT_TRUE(isIntEqualsWord(*result, -RawSmallInt::kMinValue));
}

TEST_F(IntBuiltinsTest, DunderNegWithBoolFalseReturnsSmallInt) {
  HandleScope scope(thread_);
  Object value(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, __neg__), value));
  EXPECT_TRUE(isIntEqualsWord(*result, 0));
}

TEST_F(IntBuiltinsTest, DunderNegWithBoolTrueReturnsSmallInt) {
  HandleScope scope(thread_);
  Object value(&scope, Bool::trueObj());
  Object result(&scope, runBuiltin(METH(int, __neg__), value));
  EXPECT_TRUE(isIntEqualsWord(*result, -1));
}

TEST_F(IntBuiltinsTest, DunderNegWithLargeIntReturnsSmallInt) {
  HandleScope scope(thread_);
  Object num(&scope, runtime_->newInt(-RawSmallInt::kMinValue));
  EXPECT_TRUE(num.isLargeInt());
  Object result(&scope, runBuiltin(METH(int, __neg__), num));
  EXPECT_TRUE(isIntEqualsWord(*result, RawSmallInt::kMinValue));
}

TEST_F(IntBuiltinsTest, DunderNegWithLargeIntReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits[] = {0xad7721b1763aff22, 0x2afce48517f151b2};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __neg__), num));
  const uword expected_digits[] = {0x5288de4e89c500de, 0xd5031b7ae80eae4d};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderNegWithLargeIntCarriesReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits[] = {0, 0xfffffff000000000};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __neg__), num));
  const uword expected_digits[] = {0, 0x1000000000};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderNegWithLargeIntOverflowsReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits[] = {0, kHighbitUword};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __neg__), num));
  const uword expected_digits[] = {0, kHighbitUword, 0};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderNegWithLargeIntShrinksReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits[] = {kHighbitUword, 0};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __neg__), num));
  const uword expected_digits[] = {kHighbitUword};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderNegWithLargeIntNoShrinksReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits[] = {1, kHighbitUword, 0};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __neg__), num));
  const uword expected_digits[] = {kMaxUword, kHighbitUword - 1, kMaxUword};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderPosAliasesDunderInt) {
  Thread* thread = Thread::current();
  HandleScope scope(thread);
  Type type(&scope, moduleAtByCStr(runtime_, "builtins", "int"));
  Object pos_name(&scope, Runtime::internStrFromCStr(thread_, "__pos__"));
  Object pos_obj(&scope, typeAt(type, pos_name));
  ASSERT_TRUE(pos_obj.isFunction());
  Function pos(&scope, *pos_obj);
  Object dint_name(&scope, Runtime::internStrFromCStr(thread_, "__int__"));
  Object dint_obj(&scope, typeAt(type, dint_name));
  ASSERT_TRUE(dint_obj.isFunction());
  Function dint(&scope, *pos_obj);
  EXPECT_EQ(Code::cast(pos.code()).code(), Code::cast(dint.code()).code());
  EXPECT_EQ(pos.entry(), dint.entry());
  EXPECT_EQ(pos.entryKw(), dint.entryKw());
  EXPECT_EQ(pos.entryEx(), dint.entryEx());
}

TEST_F(IntBuiltinsTest, DunderLtOnBool) {
  HandleScope scope(thread_);

  Object true_obj(&scope, Bool::trueObj());
  Object false_obj(&scope, Bool::falseObj());
  EXPECT_EQ(runBuiltin(METH(int, __lt__), true_obj, false_obj),
            Bool::falseObj());
  EXPECT_EQ(runBuiltin(METH(int, __lt__), false_obj, true_obj),
            Bool::trueObj());

  Object one(&scope, SmallInt::fromWord(1));
  EXPECT_EQ(runBuiltin(METH(int, __lt__), false_obj, one), Bool::trueObj());

  Object minus_one(&scope, SmallInt::fromWord(-1));
  EXPECT_EQ(runBuiltin(METH(int, __lt__), false_obj, minus_one),
            Bool::falseObj());
}

TEST_F(IntBuiltinsTest, DunderGeOnBool) {
  HandleScope scope(thread_);

  Object true_obj(&scope, Bool::trueObj());
  Object false_obj(&scope, Bool::falseObj());
  EXPECT_EQ(runBuiltin(METH(int, __ge__), true_obj, false_obj),
            Bool::trueObj());
  EXPECT_EQ(runBuiltin(METH(int, __ge__), false_obj, true_obj),
            Bool::falseObj());

  Object one(&scope, SmallInt::fromWord(1));
  EXPECT_EQ(runBuiltin(METH(int, __ge__), false_obj, one), Bool::falseObj());

  Object minus_one(&scope, SmallInt::fromWord(-1));
  EXPECT_EQ(runBuiltin(METH(int, __ge__), false_obj, minus_one),
            Bool::trueObj());
}

TEST_F(IntBuiltinsTest, DunderGtOnBool) {
  HandleScope scope(thread_);

  Object true_obj(&scope, Bool::trueObj());
  Object false_obj(&scope, Bool::falseObj());
  EXPECT_EQ(runBuiltin(METH(int, __gt__), true_obj, false_obj),
            Bool::trueObj());
  EXPECT_EQ(runBuiltin(METH(int, __gt__), false_obj, true_obj),
            Bool::falseObj());

  Object one(&scope, SmallInt::fromWord(1));
  EXPECT_EQ(runBuiltin(METH(int, __gt__), false_obj, one), Bool::falseObj());

  Object minus_one(&scope, SmallInt::fromWord(-1));
  EXPECT_EQ(runBuiltin(METH(int, __gt__), false_obj, minus_one),
            Bool::trueObj());
}

TEST_F(IntBuiltinsTest, DunderLeOnBool) {
  HandleScope scope(thread_);

  Object true_obj(&scope, Bool::trueObj());
  Object false_obj(&scope, Bool::falseObj());
  EXPECT_EQ(runBuiltin(METH(int, __le__), true_obj, false_obj),
            Bool::falseObj());
  EXPECT_EQ(runBuiltin(METH(int, __le__), false_obj, true_obj),
            Bool::trueObj());

  Object one(&scope, SmallInt::fromWord(1));
  EXPECT_EQ(runBuiltin(METH(int, __le__), false_obj, one), Bool::trueObj());

  Object minus_one(&scope, SmallInt::fromWord(-1));
  EXPECT_EQ(runBuiltin(METH(int, __le__), false_obj, minus_one),
            Bool::falseObj());
}

TEST_F(IntBuiltinsTest, DunderRoundAliasesDunderInt) {
  Thread* thread = Thread::current();
  HandleScope scope(thread);
  Type type(&scope, moduleAtByCStr(runtime_, "builtins", "int"));
  Object round_name(&scope, Runtime::internStrFromCStr(thread_, "__round__"));
  Object round_obj(&scope, typeAt(type, round_name));
  ASSERT_TRUE(round_obj.isFunction());
  Function round(&scope, *round_obj);
  Object dint_name(&scope, Runtime::internStrFromCStr(thread_, "__int__"));
  Object dint_obj(&scope, typeAt(type, dint_name));
  ASSERT_TRUE(dint_obj.isFunction());
  Function dint(&scope, *round_obj);
  EXPECT_EQ(Code::cast(round.code()).code(), Code::cast(dint.code()).code());
  EXPECT_EQ(round.entry(), dint.entry());
  EXPECT_EQ(round.entryKw(), dint.entryKw());
  EXPECT_EQ(round.entryEx(), dint.entryEx());
}

TEST_F(IntBuiltinsTest, DunderTruncAliasesDunderInt) {
  HandleScope scope(thread_);
  Type type(&scope, moduleAtByCStr(runtime_, "builtins", "int"));
  Object trunc_name(&scope, Runtime::internStrFromCStr(thread_, "__trunc__"));
  Object trunc_obj(&scope, typeAt(type, trunc_name));
  ASSERT_TRUE(trunc_obj.isFunction());
  Function trunc(&scope, *trunc_obj);
  Object dint_name(&scope, Runtime::internStrFromCStr(thread_, "__int__"));
  Object dint_obj(&scope, typeAt(type, dint_name));
  ASSERT_TRUE(dint_obj.isFunction());
  Function dint(&scope, *trunc_obj);
  EXPECT_EQ(Code::cast(trunc.code()).code(), Code::cast(dint.code()).code());
  EXPECT_EQ(trunc.entry(), dint.entry());
  EXPECT_EQ(trunc.entryKw(), dint.entryKw());
  EXPECT_EQ(trunc.entryEx(), dint.entryEx());
}

TEST_F(IntBuiltinsTest, FromBytesWithLittleEndianReturnsLargeInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(
      runFromCStr(runtime_, "result = int.__radd__(True, 41)").isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, 42));
}

TEST_F(IntBuiltinsTest, DunderRandWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(
      runFromCStr(runtime_, "result = int.__rand__(0x123456789, 0x987654321)")
          .isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, 0x103454301));
}

TEST_F(IntBuiltinsTest, DunderReprWithZeroReturnsStr) {
  HandleScope scope(thread_);
  Object num(&scope, runtime_->newInt(0));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(isStrEqualsCStr(*result, "0"));
}

TEST_F(IntBuiltinsTest, DunderReprWithSmallIntReturnsStr) {
  HandleScope scope(thread_);
  Object num(&scope, runtime_->newInt(0xdeadbeef));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(isStrEqualsCStr(*result, "3735928559"));
}

TEST_F(IntBuiltinsTest, DunderReprWithSmallIntMaxReturnsStr) {
  HandleScope scope(thread_);
  Object num(&scope, runtime_->newInt(RawSmallInt::kMaxValue));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(isStrEqualsCStr(*result, "4611686018427387903"));
}

TEST_F(IntBuiltinsTest, DunderReprWithSmallIntMinReturnsStr) {
  HandleScope scope(thread_);
  Object num(&scope, runtime_->newInt(RawSmallInt::kMinValue));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(isStrEqualsCStr(*result, "-4611686018427387904"));
}

TEST_F(IntBuiltinsTest, DunderReprWithBoolFalseReturnsStr) {
  HandleScope scope(thread_);
  Object num(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(isStrEqualsCStr(*result, "0"));
}

TEST_F(IntBuiltinsTest, DunderReprWithBoolTrueReturnsStr) {
  HandleScope scope(thread_);
  Object num(&scope, Bool::trueObj());
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(isStrEqualsCStr(*result, "1"));
}

TEST_F(IntBuiltinsTest, DunderReprWithLargeIntOneDigitReturnsStr) {
  HandleScope scope(thread_);
  const uword digits[] = {0x7ab65f95e6775822};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(isStrEqualsCStr(*result, "8842360015809894434"));
}

TEST_F(IntBuiltinsTest, DunderReprWithLargeIntOneDigitMinReturnsStr) {
  HandleScope scope(thread_);
  const uword digits[] = {0x8000000000000000};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(isStrEqualsCStr(*result, "-9223372036854775808"));
}

TEST_F(IntBuiltinsTest, DunderReprWithLargeIntOneDigitMaxReturnsStr) {
  HandleScope scope(thread_);
  const uword digits[] = {0x7fffffffffffffff};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(isStrEqualsCStr(*result, "9223372036854775807"));
}

TEST_F(IntBuiltinsTest, DunderReprWithLargeIntReturnsStr) {
  HandleScope scope(thread_);

  const uword digits[] = {0x68ccbb7f61087fb7, 0x4081e2972fe52778};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(
      isStrEqualsCStr(*result, "85744993827831399429103580491677204407"));
}

TEST_F(IntBuiltinsTest, DunderReprWithNegativeLargeIntReturnsStr) {
  HandleScope scope(thread_);

  const uword digits[] = {0x49618108301eff93, 0xc70a0c6e0731da35,
                          0x438a2278e8762294, 0xccf89b106c9b714d,
                          0xfa694d4cbdf0b0ba};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(
      isStrEqualsCStr(*result,
                      "-4663013431296140509759060231428418933437027788588076073"
                      "3669209802197774863968523736917349564525"));
}

TEST_F(IntBuiltinsTest, DunderReprWithLargeIntManyZerosReturnsStr) {
  HandleScope scope(thread_);

  const uword digits[] = {0x6ea69b2000000000, 0xf374ff2873cd99de, 0x375c24};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(isStrEqualsCStr(
      *result, "1234567890000000000000000000000000000000000000"));
}

TEST_F(IntBuiltinsTest, DunderReprWithLargeIntCarriesReturnsStr) {
  HandleScope scope(thread_);
  const uword digits[] = {kMaxUword, uword{kMaxWord}, kMaxUword};
  Object num(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(
      isStrEqualsCStr(*result, "-170141183460469231731687303715884105729"));
}

TEST_F(IntBuiltinsTest, DunderReprWithIntSubclassReturnsStr) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, R"(
class X(int): pass
num = X(0xdeadbeef)
)")
                   .isError());
  Object num(&scope, mainModuleAt(runtime_, "num"));
  Object result(&scope, runBuiltin(METH(int, __repr__), num));
  EXPECT_TRUE(isStrEqualsCStr(*result, "3735928559"));
}

TEST_F(IntBuiltinsTest, DunderRdivmodWithSmallIntsReturnsTuple) {
  HandleScope scope(thread_);
  ASSERT_FALSE(
      runFromCStr(runtime_, "result = int.__rdivmod__(3, 11)").isError());
  Object result_obj(&scope, mainModuleAt(runtime_, "result"));
  ASSERT_TRUE(result_obj.isTuple());
  Tuple result(&scope, *result_obj);
  ASSERT_EQ(result.length(), 2);
  EXPECT_TRUE(isIntEqualsWord(result.at(0), 3));
  EXPECT_TRUE(isIntEqualsWord(result.at(1), 2));
}

TEST_F(IntBuiltinsTest, DunderRfloordivWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(
      runFromCStr(runtime_, "result = int.__rfloordiv__(3, 11)").isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, 3));
}

TEST_F(IntBuiltinsTest, DunderRlshiftWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(
      runFromCStr(runtime_, "result = int.__rlshift__(3, -7)").isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, -56));
}

TEST_F(IntBuiltinsTest, DunderRmodWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, "result = int.__rmod__(3, 11)").isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, 2));
}

TEST_F(IntBuiltinsTest, DunderRmulWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(
      runFromCStr(runtime_, "result = int.__rmul__(-321, 123)").isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, -39483));
}

TEST_F(IntBuiltinsTest, DunderRorWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(
      runFromCStr(runtime_, "result = int.__ror__(0x123456789, 0x987654321)")
          .isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, 0x9a76567a9));
}

TEST_F(IntBuiltinsTest, DunderRpowWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, "result = int.__rpow__(8, 2)").isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, 256));
}

TEST_F(IntBuiltinsTest, DunderRrshiftWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, "result = int.__rrshift__(16, 0xf00ddead)")
                   .isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, 0xf00d));
}

TEST_F(IntBuiltinsTest, DunderRshiftWithBoolsReturnsSmallInt) {
  HandleScope scope(thread_);
  Object left(&scope, Bool::trueObj());
  Object right(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 1));
}

TEST_F(IntBuiltinsTest, DunderRshiftWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(-1234));
  Object right(&scope, runtime_->newInt(3));
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, -155));
}

TEST_F(IntBuiltinsTest, DunderRshiftWithOversizedAmountSmallIntReturnsZero) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(1));
  Object right(&scope, runtime_->newInt(kBitsPerWord));
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 0));
}

TEST_F(IntBuiltinsTest, DunderRshiftWithOversizedAmountLargeIntReturnsZero) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(1));
  const uword digits[] = {1, 2};
  Object right(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 0));
}

TEST_F(IntBuiltinsTest, DunderRshiftWithLargeIntOversizedAmountReturnsZero) {
  HandleScope scope(thread_);
  const uword digits[] = {1, 2};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(kBitsPerWord * 3));
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 0));
}

TEST_F(IntBuiltinsTest, DunderRshiftWithLargeIntsReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits[] = {0x188518dcaaa656f7, 0x7459da1092edebab,
                          0x692e3b38af8dcfbe};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(83));
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  const uword expected_digits[] = {0xb9f7ce8b3b42125d, 0xd25c76715f1};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderRshiftWithLargeIntWholeWordReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits[] = {0x1c386fefbb1baf3d, 0x379bcaa886c98c13,
                          0xe0f6379843f98b29, 0};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(kBitsPerWord * 2));
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  const uword expected_digits[] = {0xe0f6379843f98b29, 0};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderRshiftWithLargeIntNegativeReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits[] = {0x3190ff6fa83269bc, 0xe7a1689a33ca9ae6};
  Object left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, runtime_->newInt(13));
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  const uword expected_digits[] = {0xd7318c87fb7d4193, 0xffff3d0b44d19e54};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderRshiftWithNegativeShiftAmountRaisesValueError) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(1));
  Object right(&scope, runtime_->newInt(-4));
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  EXPECT_TRUE(
      raisedWithStr(*result, LayoutId::kValueError, "negative shift count"));
}

TEST_F(IntBuiltinsTest, DunderRshiftWithNonIntSelfRaisesTypeError) {
  HandleScope scope(thread_);
  Object left(&scope, Str::empty());
  Object right(&scope, runtime_->newInt(0));
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, DunderRshiftWithNonIntReturnsNotImplemented) {
  HandleScope scope(thread_);
  Object left(&scope, runtime_->newInt(0));
  Object right(&scope, Str::empty());
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  EXPECT_TRUE(result.isNotImplementedType());
}

TEST_F(IntBuiltinsTest, DunderRshiftWithIntSubclassReturnsInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, R"(
class X(int): pass
left = X(-1234)
right = X(3)
)")
                   .isError());
  Object left(&scope, mainModuleAt(runtime_, "left"));
  Object right(&scope, mainModuleAt(runtime_, "right"));
  Object result(&scope, runBuiltin(METH(int, __rshift__), left, right));
  EXPECT_EQ(result, SmallInt::fromWord(-155));
}

TEST_F(IntBuiltinsTest, DunderStrAliasesDunderRepr) {
  Thread* thread = Thread::current();
  HandleScope scope(thread);
  Type type(&scope, moduleAtByCStr(runtime_, "builtins", "int"));
  Object str_name(&scope, Runtime::internStrFromCStr(thread_, "__str__"));
  Object str_obj(&scope, typeAt(type, str_name));
  ASSERT_TRUE(str_obj.isFunction());
  Function str(&scope, *str_obj);
  Object repr_name(&scope, Runtime::internStrFromCStr(thread_, "__repr__"));
  Object repr_obj(&scope, typeAt(type, repr_name));
  ASSERT_TRUE(repr_obj.isFunction());
  Function repr(&scope, *str_obj);
  EXPECT_EQ(Code::cast(str.code()).code(), Code::cast(repr.code()).code());
  EXPECT_EQ(str.entry(), repr.entry());
  EXPECT_EQ(str.entryKw(), repr.entryKw());
  EXPECT_EQ(str.entryEx(), repr.entryEx());
}

TEST_F(IntBuiltinsTest, DunderSubWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);

  Int left(&scope, SmallInt::fromWord(42));
  Int right(&scope, SmallInt::fromWord(-7));
  Object result(&scope, runBuiltin(METH(int, __sub__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 49));
}

TEST_F(IntBuiltinsTest, DunderSubWithSmallIntsOverflowReturnsLargeInt) {
  HandleScope scope(thread_);

  Int min_small_int(&scope, SmallInt::fromWord(RawSmallInt::kMinValue));
  Int one(&scope, SmallInt::fromWord(1));
  Object result(&scope, runBuiltin(METH(int, __sub__), min_small_int, one));
  EXPECT_TRUE(isIntEqualsWord(*result, RawSmallInt::kMinValue - 1));
}

TEST_F(IntBuiltinsTest, DunderSubWithLargeIntsReturnsLargeInt) {
  HandleScope scope(thread_);

  const uword digits_left[] = {0xfedcba0987654321, 0x1234567890abcdef};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0x9876543210abcdef, 0xfedcba0123456789};
  Int right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result(&scope, runBuiltin(METH(int, __sub__), left, right));
  const uword expected_digits[] = {0x666665d776b97532, 0x13579c776d666666};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest,
       DunderSubWithPositiveLargeIntsBorrowingReturnsLargeInt) {
  HandleScope scope(thread_);

  Int left(&scope, runtime_->newInt(1));
  const uword digits_right[] = {kMaxUword, kMaxUword, 0};
  Int right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result(&scope, runBuiltin(METH(int, __sub__), left, right));
  const uword expected_digits[] = {2, 0, kMaxUword};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest,
       DunderSubWithNegativeLargeIntsBorrowingReturnsLargeInt) {
  HandleScope scope(thread_);

  // The smallest negative number representable with 2 digits.
  const uword digits_left[] = {0, static_cast<uword>(kMinWord)};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  Int right(&scope, runtime_->newInt(1));
  Object result(&scope, runBuiltin(METH(int, __sub__), left, right));
  const uword expected_digits[] = {kMaxUword, uword{kMaxWord}, kMaxUword};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderSubWithNonIntSelfRaisesTypeError) {
  HandleScope scope(thread_);

  Str str(&scope, Str::empty());
  Int right(&scope, runtime_->newInt(1));
  Object result(&scope, runBuiltin(METH(int, __sub__), str, right));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, DunderSubWithNonIntRightReturnsNotImplemented) {
  HandleScope scope(thread_);

  Int left(&scope, runtime_->newInt(1));
  Str str(&scope, Str::empty());
  Object result(&scope, runBuiltin(METH(int, __sub__), left, str));
  EXPECT_TRUE(result.isNotImplementedType());
}

TEST_F(IntBuiltinsTest, DunderXorWithSmallIntsReturnsSmallInt) {
  HandleScope scope(thread_);
  Int left(&scope, SmallInt::fromWord(0x15));   // 0b010101
  Int right(&scope, SmallInt::fromWord(0x38));  // 0b111000
  Object result(&scope, runBuiltin(METH(int, __xor__), left, right));
  EXPECT_TRUE(isIntEqualsWord(*result, 0x2D));  // 0b101101
}

TEST_F(IntBuiltinsTest, DunderXorWithLargeIntsReturnsLargeInt) {
  HandleScope scope(thread_);
  const uword digits_left[] = {0x0f, 0x30, 0xCAFE};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits_left));
  const uword digits_right[] = {0x03, 0xf0};
  Int right(&scope, runtime_->newLargeIntWithDigits(digits_right));
  Object result(&scope, runBuiltin(METH(int, __xor__), left, right));
  const uword expected_digits[] = {0x0C, 0xC0, 0xCAFE};
  EXPECT_TRUE(isIntEqualsDigits(*result, expected_digits));
}

TEST_F(IntBuiltinsTest, DunderXorWithNonIntReturnsNotImplemented) {
  HandleScope scope(thread_);
  const uword digits[] = {1, 2};
  Int left(&scope, runtime_->newLargeIntWithDigits(digits));
  Object right(&scope, Str::empty());
  Object result(&scope, runBuiltin(METH(int, __xor__), left, right));
  EXPECT_TRUE(result.isNotImplementedType());
}

TEST_F(IntBuiltinsTest, DunderXorWithInvalidArgumentLeftRaisesException) {
  HandleScope scope(thread_);
  Object left(&scope, Str::empty());
  const uword digits[] = {1, 2};
  LargeInt right(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result(&scope, runBuiltin(METH(int, __xor__), left, right));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, DunderXorWithIntSubclassReturnsInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, R"(
class X(int): pass
left = X(0b0011)
right = X(0b0101)
)")
                   .isError());
  Object left(&scope, mainModuleAt(runtime_, "left"));
  Object right(&scope, mainModuleAt(runtime_, "right"));
  Object result(&scope, runBuiltin(METH(int, __xor__), left, right));
  EXPECT_EQ(result, SmallInt::fromWord(6));  // 0b0110
}

TEST_F(IntBuiltinsTest, ToBytesWithByteorderLittleEndianReturnsBytes) {
  HandleScope scope(thread_);

  Int num(&scope, SmallInt::fromWord(42));
  Int length(&scope, SmallInt::fromWord(3));
  Str byteorder(&scope, runtime_->newStrFromCStr("little"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, length, byteorder,
                                   signed_obj));

  const byte bytes[] = {42, 0, 0};
  EXPECT_TRUE(isBytesEqualsBytes(result, bytes));
}

TEST_F(IntBuiltinsTest, ToBytesWithIntSubclassReturnsBytes) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, R"(
class X(int): pass
num = X(42)
length = X(3)
)")
                   .isError());
  Object num(&scope, mainModuleAt(runtime_, "num"));
  Object length(&scope, mainModuleAt(runtime_, "length"));
  Object byteorder(&scope, runtime_->newStrFromCStr("little"));
  Object signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, length, byteorder,
                                   signed_obj));
  const byte bytes[] = {42, 0, 0};
  EXPECT_TRUE(isBytesEqualsBytes(result, bytes));
}

TEST_F(IntBuiltinsTest, ToBytesWithByteorderBigEndianReturnsBytes) {
  HandleScope scope(thread_);

  Int num(&scope, SmallInt::fromWord(42));
  Int length(&scope, SmallInt::fromWord(2));
  Str byteorder(&scope, runtime_->newStrFromCStr("big"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, length, byteorder,
                                   signed_obj));
  const byte bytes[] = {0, 42};
  EXPECT_TRUE(isBytesEqualsBytes(result, bytes));
}

TEST_F(IntBuiltinsTest, ToBytesKwReturnsBytes) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
x0 = (0x1234).to_bytes(2, 'little')
x1 = (0x1234).to_bytes(2, 'little', signed=False)
x2 = (0x1234).to_bytes(2, 'little', signed=True)
x3 = (0x1234).to_bytes(2, byteorder='little')
x4 = (0x1234).to_bytes(length=2, byteorder='little')
x5 = (0x1234).to_bytes(2, byteorder='little', signed=False)
x6 = (0x1234).to_bytes(signed=False, byteorder='little', length=2)
)")
                   .isError());
  const byte bytes[] = {0x34, 0x12};
  for (const char* name : {"x0", "x1", "x2", "x3", "x4", "x5", "x6"}) {
    Object x(&scope, mainModuleAt(runtime_, name));
    EXPECT_TRUE(isBytesEqualsBytes(x, bytes)) << name;
  }
}

TEST_F(IntBuiltinsTest, ToBytesKwWithNegativeNumberReturnsBytes) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
x0 = (-777).to_bytes(4, 'little', signed=True)
)")
                   .isError());
  Object x(&scope, mainModuleAt(runtime_, "x0"));
  const byte bytes[] = {0xf7, 0xfc, 0xff, 0xff};
  EXPECT_TRUE(isBytesEqualsBytes(x, bytes));
}

TEST_F(IntBuiltinsTest, ToBytesWithSignedFalseReturnsBytes) {
  HandleScope scope(thread_);

  Str byteorder(&scope, runtime_->newStrFromCStr("little"));

  // Test that the following numbers work fine with `signed=False` (they are the
  // same numbers that are expected to overflow with `signed=True` in
  // ToBytesWithSignedTrueOverflowRaisesOverflowError)
  Int length_1(&scope, SmallInt::fromWord(1));
  Int num_128(&scope, SmallInt::fromWord(128));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result_128(&scope, runBuiltin(METH(int, to_bytes), num_128, length_1,
                                       byteorder, signed_obj));
  const byte bytes[] = {0x80};
  EXPECT_TRUE(isBytesEqualsBytes(result_128, bytes));

  Int length_2(&scope, SmallInt::fromWord(2));
  Int num_32768(&scope, SmallInt::fromWord(32768));
  Object result_32768(&scope, runBuiltin(METH(int, to_bytes), num_32768,
                                         length_2, byteorder, signed_obj));
  const byte bytes2[] = {0, 0x80};
  EXPECT_TRUE(isBytesEqualsBytes(result_32768, bytes2));

  Int length_8(&scope, SmallInt::fromWord(8));
  const uword digits[] = {0x8000000000000000, 0};
  Int num_min_word(&scope, runtime_->newLargeIntWithDigits(digits));
  Object result_min_word(&scope, runBuiltin(METH(int, to_bytes), num_min_word,
                                            length_8, byteorder, signed_obj));
  const byte bytes3[] = {0, 0, 0, 0, 0, 0, 0, 0x80};
  EXPECT_TRUE(isBytesEqualsBytes(result_min_word, bytes3));
}

TEST_F(IntBuiltinsTest, ToBytesWithLargeBufferByteorderBigEndianReturnsBytes) {
  HandleScope scope(thread_);

  // Test sign extension with zero when the buffer is larger than necessary.
  Int num(&scope, SmallInt::fromWord(0xcafebabe));
  Int length(&scope, SmallInt::fromWord(10));
  Str byteorder(&scope, runtime_->newStrFromCStr("big"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, length, byteorder,
                                   signed_obj));
  const byte bytes[] = {0, 0, 0, 0, 0, 0, 0xca, 0xfe, 0xba, 0xbe};
  EXPECT_TRUE(isBytesEqualsBytes(result, bytes));
}

TEST_F(IntBuiltinsTest,
       ToBytesWithLargeBufferByteorderLittleEndianReturnsBytes) {
  HandleScope scope(thread_);

  // Test sign extension with zero when the buffer is larger than necessary.
  Int num(&scope, SmallInt::fromWord(0xcafebabe));
  Int length(&scope, SmallInt::fromWord(10));
  Str byteorder(&scope, runtime_->newStrFromCStr("little"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, length, byteorder,
                                   signed_obj));
  const byte bytes[] = {0xbe, 0xba, 0xfe, 0xca, 0, 0, 0, 0, 0, 0};
  EXPECT_TRUE(isBytesEqualsBytes(result, bytes));
}

TEST_F(IntBuiltinsTest, ToBytesWithSignedTrueReturnsBytes) {
  HandleScope scope(thread_);

  ASSERT_FALSE(runFromCStr(runtime_, R"(
result = (0x7fffffffffffffff).to_bytes(8, 'little', signed=True)
)")
                   .isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  const byte bytes[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f};
  EXPECT_TRUE(isBytesEqualsBytes(result, bytes));

  ASSERT_FALSE(runFromCStr(runtime_, R"(
result_n_128 = (-128).to_bytes(1, 'little', signed=True)
)")
                   .isError());
  Object result_n_128(&scope, mainModuleAt(runtime_, "result_n_128"));
  const byte bytes2[] = {0x80};
  EXPECT_TRUE(isBytesEqualsBytes(result_n_128, bytes2));

  ASSERT_FALSE(runFromCStr(runtime_, R"(
result_n_32768 = (-32768).to_bytes(2, 'little', signed=True)
)")
                   .isError());
  Object result_n_32768(&scope, mainModuleAt(runtime_, "result_n_32768"));
  const byte bytes3[] = {0, 0x80};
  EXPECT_TRUE(isBytesEqualsBytes(result_n_32768, bytes3));

  ASSERT_FALSE(runFromCStr(runtime_, R"(
result_n_min_word = (-9223372036854775808).to_bytes(8, 'little', signed=True)
)")
                   .isError());
  Object result_n_min_word(&scope, mainModuleAt(runtime_, "result_n_min_word"));
  const byte bytes4[] = {0, 0, 0, 0, 0, 0, 0, 0x80};
  EXPECT_TRUE(isBytesEqualsBytes(result_n_min_word, bytes4));
}

TEST_F(IntBuiltinsTest,
       ToBytesWithNegativeNumberLargeBufferBigEndianReturnsBytes) {
  HandleScope scope(thread_);

  // test sign extension for negative number when buffer is larger than
  // necessary.
  ASSERT_FALSE(runFromCStr(runtime_, R"(
result = (-1024).to_bytes(7, 'big', signed=True)
)")
                   .isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  const byte bytes[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0};
  EXPECT_TRUE(isBytesEqualsBytes(result, bytes));
}

TEST_F(IntBuiltinsTest, ToBytesWithZeroLengthBigEndianReturnsEmptyBytes) {
  HandleScope scope(thread_);

  Int num(&scope, SmallInt::fromWord(0));
  Int length(&scope, SmallInt::fromWord(0));
  Str byteorder(&scope, runtime_->newStrFromCStr("big"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, length, byteorder,
                                   signed_obj));
  ASSERT_TRUE(isBytesEqualsBytes(result, View<byte>(nullptr, 0)));
}

TEST_F(IntBuiltinsTest, ToBytesWithZeroLengthLittleEndianReturnsEmptyBytes) {
  HandleScope scope(thread_);

  Int num(&scope, SmallInt::fromWord(0));
  Int length(&scope, SmallInt::fromWord(0));
  Str byteorder(&scope, runtime_->newStrFromCStr("little"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, length, byteorder,
                                   signed_obj));
  ASSERT_TRUE(isBytesEqualsBytes(result, View<byte>(nullptr, 0)));
}

TEST_F(IntBuiltinsTest, ToBytesWithSignedFalseRaisesOverflowError) {
  HandleScope scope(thread_);

  Int num(&scope, SmallInt::fromWord(256));
  Int length(&scope, SmallInt::fromWord(1));
  Str byteorder(&scope, runtime_->newStrFromCStr("little"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, length, byteorder,
                                   signed_obj));
  EXPECT_TRUE(raised(*result, LayoutId::kOverflowError));
}

TEST_F(IntBuiltinsTest, ToBytesWithBigOverflowRaisesOverflowError) {
  HandleScope scope(thread_);

  const uword digits[] = {1, 2, 3};
  Int num(&scope, runtime_->newLargeIntWithDigits(digits));
  Int length(&scope, SmallInt::fromWord(13));
  Str byteorder(&scope, runtime_->newStrFromCStr("little"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, length, byteorder,
                                   signed_obj));
  EXPECT_TRUE(raised(*result, LayoutId::kOverflowError));
}

TEST_F(IntBuiltinsTest, ToBytesWithSignedTrueRaisesOverflowError) {
  Thread* thread = Thread::current();

  // Now check that signed=True with the same inputs triggers an error.
  EXPECT_TRUE(raisedWithStr(runFromCStr(runtime_, R"(
result = (128).to_bytes(1, 'little', signed=True)
)"),
                            LayoutId::kOverflowError,
                            "int too big to convert"));
  thread->clearPendingException();

  EXPECT_TRUE(raisedWithStr(runFromCStr(runtime_, R"(
result = (32768).to_bytes(2, 'little', signed=True)
)"),
                            LayoutId::kOverflowError,
                            "int too big to convert"));
  thread->clearPendingException();

  EXPECT_TRUE(raisedWithStr(runFromCStr(runtime_, R"(
result = (0x8000000000000000).to_bytes(8, 'little', signed=True)
)"),
                            LayoutId::kOverflowError,
                            "int too big to convert"));
}

TEST_F(IntBuiltinsTest, ToBytesWithNonIntRaisesTypeError) {
  HandleScope scope(thread_);

  Str str(&scope, runtime_->newStrFromCStr("not an int"));
  Int length(&scope, SmallInt::fromWord(10));
  Str byteorder(&scope, runtime_->newStrFromCStr("little"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), str, length, byteorder,
                                   signed_obj));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, ToBytesWithInvalidLengthArgRaisesTypeError) {
  HandleScope scope(thread_);
  Int num(&scope, SmallInt::fromWord(42));
  Str not_a_length(&scope, runtime_->newStrFromCStr("not a length"));
  Str byteorder(&scope, runtime_->newStrFromCStr("little"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, not_a_length,
                                   byteorder, signed_obj));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(IntBuiltinsTest, ToBytesWithInvalidLengthArgRaisesValueError) {
  HandleScope scope(thread_);
  Int num(&scope, SmallInt::fromWord(42));
  Int negative_length(&scope, SmallInt::fromWord(-3));
  Str byteorder(&scope, runtime_->newStrFromCStr("little"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, negative_length,
                                   byteorder, signed_obj));
  EXPECT_TRUE(raised(*result, LayoutId::kValueError));
}

TEST_F(IntBuiltinsTest, ToBytesWithInvalidLengthArgRaisesOverflowError) {
  HandleScope scope(thread_);
  Int num(&scope, SmallInt::fromWord(42));
  const uword digits[] = {0, 1024};
  Int huge_length(&scope, runtime_->newLargeIntWithDigits(digits));
  Str byteorder(&scope, runtime_->newStrFromCStr("little"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, huge_length,
                                   byteorder, signed_obj));
  EXPECT_TRUE(raised(*result, LayoutId::kOverflowError));
}

TEST_F(IntBuiltinsTest, ToBytesWithNegativeNumberRaisesOverflowError) {
  HandleScope scope(thread_);

  Int num(&scope, SmallInt::fromWord(-1));
  Int length(&scope, SmallInt::fromWord(10));
  Str byteorder(&scope, runtime_->newStrFromCStr("little"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, length, byteorder,
                                   signed_obj));
  EXPECT_TRUE(raised(*result, LayoutId::kOverflowError));
}

TEST_F(IntBuiltinsTest, ToBytesWithInvalidByteorderStringRaisesValueError) {
  HandleScope scope(thread_);

  Int num(&scope, SmallInt::fromWord(42));
  Int length(&scope, SmallInt::fromWord(3));
  Str invalid_byteorder(&scope, runtime_->newStrFromCStr("hello"));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope, runBuiltin(METH(int, to_bytes), num, length,
                                   invalid_byteorder, signed_obj));
  EXPECT_TRUE(raised(*result, LayoutId::kValueError));
}

TEST_F(IntBuiltinsTest, ToBytesWithInvalidByteorderTypeRaisesTypeError) {
  HandleScope scope(thread_);

  Int num(&scope, SmallInt::fromWord(42));
  Int length(&scope, SmallInt::fromWord(3));
  Bool signed_obj(&scope, Bool::falseObj());
  Object result(&scope,
                runBuiltin(METH(int, to_bytes), num, length, num, signed_obj));
  EXPECT_TRUE(raised(*result, LayoutId::kTypeError));
}

TEST_F(BoolBuiltinsTest, NewFromNonZeroIntegerReturnsTrue) {
  HandleScope scope(thread_);
  Type type(&scope, runtime_->typeAt(LayoutId::kBool));
  Int num(&scope, SmallInt::fromWord(2));

  Bool result(&scope, runBuiltin(METH(bool, __new__), type, num));
  EXPECT_TRUE(result.value());
}

TEST_F(BoolBuiltinsTest, NewFromZerorReturnsFalse) {
  HandleScope scope(thread_);
  Type type(&scope, runtime_->typeAt(LayoutId::kBool));
  Int num(&scope, SmallInt::fromWord(0));

  Bool result(&scope, runBuiltin(METH(bool, __new__), type, num));
  EXPECT_FALSE(result.value());
}

TEST_F(BoolBuiltinsTest, NewFromTrueReturnsTrue) {
  HandleScope scope(thread_);
  Type type(&scope, runtime_->typeAt(LayoutId::kBool));
  Object true_obj(&scope, Bool::trueObj());

  Bool result(&scope, runBuiltin(METH(bool, __new__), type, true_obj));
  EXPECT_TRUE(result.value());
}

TEST_F(BoolBuiltinsTest, NewFromFalseReturnsTrue) {
  HandleScope scope(thread_);
  Type type(&scope, runtime_->typeAt(LayoutId::kBool));
  Object false_obj(&scope, Bool::falseObj());

  Bool result(&scope, runBuiltin(METH(bool, __new__), type, false_obj));
  EXPECT_FALSE(result.value());
}

TEST_F(BoolBuiltinsTest, NewFromNoneIsFalse) {
  HandleScope scope(thread_);
  Type type(&scope, runtime_->typeAt(LayoutId::kBool));
  Object none(&scope, NoneType::object());

  Bool result(&scope, runBuiltin(METH(bool, __new__), type, none));
  EXPECT_FALSE(result.value());
}

TEST_F(BoolBuiltinsTest, NewFromUserDefinedType) {
  ASSERT_FALSE(runFromCStr(runtime_, R"(
class Foo:
  def __bool__(self):
    return True

class Bar:
  def __bool__(self):
    return False

foo = Foo()
bar = Bar()
)")
                   .isError());
  HandleScope scope(thread_);
  Object foo(&scope, mainModuleAt(runtime_, "foo"));
  Object bar(&scope, mainModuleAt(runtime_, "bar"));

  {
    Type type(&scope, runtime_->typeAt(LayoutId::kBool));
    Bool result(&scope, runBuiltin(METH(bool, __new__), type, foo));
    EXPECT_TRUE(result.value());
  }
  {
    Type type(&scope, runtime_->typeAt(LayoutId::kBool));
    Bool result(&scope, runBuiltin(METH(bool, __new__), type, bar));
    EXPECT_FALSE(result.value());
  }
}

TEST_F(IntBuiltinsTest, DunderTrueDivWithZeroLeftReturnsZero) {
  HandleScope scope(thread_);
  Int left(&scope, SmallInt::fromWord(0));
  Int right(&scope, SmallInt::fromWord(17));
  Object result(&scope, runBuiltin(METH(int, __truediv__), left, right));
  ASSERT_TRUE(result.isFloat());
  Float flt(&scope, *result);
  EXPECT_EQ(flt.value(), 0.0);
}

TEST_F(IntBuiltinsTest, DunderTrueDivWithBoolFalseRaisesZeroDivisionError) {
  HandleScope scope(thread_);
  Object numerator(&scope, SmallInt::fromWord(10));
  Object denominator(&scope, Bool::falseObj());
  EXPECT_TRUE(
      raisedWithStr(runBuiltin(METH(int, __truediv__), numerator, denominator),
                    LayoutId::kZeroDivisionError, "division by zero"));
}

TEST_F(IntBuiltinsTest, DunderTrueDivWithIntZeroRaisesZeroDivisionError) {
  HandleScope scope(thread_);
  Object numerator(&scope, SmallInt::fromWord(10));
  Object denominator(&scope, SmallInt::fromWord(0));
  EXPECT_TRUE(
      raisedWithStr(runBuiltin(METH(int, __truediv__), numerator, denominator),
                    LayoutId::kZeroDivisionError, "division by zero"));
}

TEST_F(IntBuiltinsTest, DunderTrueDivWithFloatRightReturnsNotImplemented) {
  HandleScope scope(thread_);
  Object left(&scope, SmallInt::fromWord(100));
  Object right(&scope, runtime_->newFloat(1.5));
  Object result(&scope, runBuiltin(METH(int, __truediv__), left, right));
  EXPECT_EQ(result, NotImplementedType::object());
}

TEST_F(IntBuiltinsTest, DunderTrueDivWithSmallIntsReturnsFloat) {
  HandleScope scope(thread_);

  Object num1(&scope, SmallInt::fromWord(6));
  Object num2(&scope, SmallInt::fromWord(3));
  Float result(&scope, runBuiltin(METH(int, __truediv__), num1, num2));
  EXPECT_NEAR(result.value(), 2.0, DBL_EPSILON);

  num1 = SmallInt::fromWord(7);
  num2 = SmallInt::fromWord(3);
  result = runBuiltin(METH(int, __truediv__), num1, num2);
  EXPECT_NEAR(result.value(), 2.3333333333333335, DBL_EPSILON);
}

TEST_F(IntBuiltinsTest, ConjugateAliasesDunderInt) {
  Thread* thread = Thread::current();
  HandleScope scope(thread);
  Type type(&scope, moduleAtByCStr(runtime_, "builtins", "int"));
  Object conjugate_name(&scope,
                        Runtime::internStrFromCStr(thread_, "conjugate"));
  Object conjugate_obj(&scope, typeAt(type, conjugate_name));
  ASSERT_TRUE(conjugate_obj.isFunction());
  Function conjugate(&scope, *conjugate_obj);
  Object dint_name(&scope, Runtime::internStrFromCStr(thread_, "__int__"));
  Object dint_obj(&scope, typeAt(type, dint_name));
  ASSERT_TRUE(dint_obj.isFunction());
  Function dint(&scope, *conjugate_obj);
  EXPECT_EQ(Code::cast(conjugate.code()).code(),
            Code::cast(dint.code()).code());
  EXPECT_EQ(conjugate.entry(), dint.entry());
  EXPECT_EQ(conjugate.entryKw(), dint.entryKw());
  EXPECT_EQ(conjugate.entryEx(), dint.entryEx());
}

TEST_F(IntBuiltinsTest, DenominatorReturnsOne) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, "result = (44).denominator").isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, 1));
}

TEST_F(IntBuiltinsTest, ImagReturnsZero) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, "result = (44).imag").isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, 0));
}

TEST_F(IntBuiltinsTest, NumeratorReturnsInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, "result = (44).numerator").isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, 44));
}

TEST_F(IntBuiltinsTest, RealReturnsInt) {
  HandleScope scope(thread_);
  ASSERT_FALSE(runFromCStr(runtime_, "result = (44).real").isError());
  Object result(&scope, mainModuleAt(runtime_, "result"));
  EXPECT_TRUE(isIntEqualsWord(*result, 44));
}

TEST_F(IntBuiltinsTest, CompareWithBigNegativeNumber) {
  ASSERT_FALSE(runFromCStr(runtime_, "a = -46116860184273879030000").isError());
  HandleScope scope(thread_);
  Int a(&scope, mainModuleAt(runtime_, "a"));
  Int b(&scope, SmallInt::fromWord(SmallInt::kMinValue));
  EXPECT_LT(a.compare(*b), 0);
  EXPECT_GT(b.compare(*a), 0);
}

}  // namespace testing
}  // namespace py