3183 lines
67 KiB
C++
3183 lines
67 KiB
C++
#include "big.h"
|
|
|
|
#include <cstdint>
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
static int bign_compare_to(const struct bign *b, const char *ref) {
|
|
if (b->data == nullptr) {
|
|
return 4242;
|
|
}
|
|
|
|
struct bign bref;
|
|
bign_create_from_string(&bref, ref);
|
|
int cmp = bign_cmp(b, &bref);
|
|
bign_destroy(&bref);
|
|
return cmp;
|
|
}
|
|
|
|
static void bign_create_random(struct bign *self) {
|
|
static const int SizeMin = 3;
|
|
static const int SizeMax = 50;
|
|
int size = SizeMin + std::rand() / (RAND_MAX / (SizeMax - SizeMin));
|
|
assert(SizeMin <= size && size <= SizeMax);
|
|
|
|
self->size = size;
|
|
self->capacity = size;
|
|
self->data = static_cast<uint32_t*>(std::calloc(size, sizeof(uint32_t)));
|
|
|
|
for (int i = 0; i < size; ++i) {
|
|
self->data[i] = (rand() << 16) + rand();
|
|
}
|
|
|
|
if (self->data[size - 1] == 0) {
|
|
self->data[size - 1] = 1;
|
|
}
|
|
}
|
|
|
|
static int bigz_compare_to(const struct bigz *b, const char *ref, unsigned base) {
|
|
if (b->n.data == nullptr) {
|
|
return 4242;
|
|
}
|
|
|
|
struct bigz bref;
|
|
bigz_create_from_string(&bref, ref, base);
|
|
|
|
int cmp = bigz_cmp(b, &bref);
|
|
bigz_destroy(&bref);
|
|
return cmp;
|
|
}
|
|
|
|
TEST(BigN, CreateEmpty) {
|
|
struct bign b1;
|
|
bign_create_empty(&b1);
|
|
|
|
EXPECT_EQ(b1.size, 0u);
|
|
EXPECT_EQ(b1.data, nullptr);
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CreateFromValue) {
|
|
struct bign b1;
|
|
bign_create_from_value(&b1, UINT32_C(42));
|
|
|
|
EXPECT_EQ(b1.size, 1u);
|
|
EXPECT_EQ(b1.data[0], UINT32_C(42));
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CreateFromStringZero) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0");
|
|
|
|
EXPECT_EQ(b1.size, 1u);
|
|
EXPECT_EQ(b1.data[0], UINT32_C(0));
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CreateFromStringZeroes) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "00000000");
|
|
|
|
EXPECT_EQ(b1.size, 1u);
|
|
EXPECT_EQ(b1.data[0], UINT32_C(0));
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CreateFromStringDigit) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "29A");
|
|
|
|
EXPECT_EQ(b1.size, 1u);
|
|
EXPECT_EQ(b1.data[0], UINT32_C(0x29A));
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CreateFromStringLong) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
EXPECT_EQ(b1.size, 6u);
|
|
EXPECT_EQ(b1.data[5], UINT32_C(0xE38C3BA9));
|
|
EXPECT_EQ(b1.data[4], UINT32_C(0x48CDEA56));
|
|
EXPECT_EQ(b1.data[3], UINT32_C(0x73926BFF));
|
|
EXPECT_EQ(b1.data[2], UINT32_C(0xDBAECBF7));
|
|
EXPECT_EQ(b1.data[1], UINT32_C(0x82B3F2C3));
|
|
EXPECT_EQ(b1.data[0], UINT32_C(0x32F1C3F2));
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CreateFromStringAllDigit) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0123456789ABCDEFabcdef");
|
|
|
|
EXPECT_EQ(b1.size, 3u);
|
|
EXPECT_EQ(b1.data[2], UINT32_C(0x012345));
|
|
EXPECT_EQ(b1.data[1], UINT32_C(0x6789ABCD));
|
|
EXPECT_EQ(b1.data[0], UINT32_C(0xEFABCDEF));
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CreateFromStringWithZero) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000000000000042");
|
|
|
|
EXPECT_EQ(b1.size, 1u);
|
|
EXPECT_EQ(b1.data[0], UINT32_C(0x42));
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CmpSame) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
int cmp = bign_cmp(&b1, &b1);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CmpEqual) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
int cmp = bign_cmp(&b1, &b2);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CmpSameSizeGreater) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F1");
|
|
|
|
int cmp = bign_cmp(&b1, &b2);
|
|
EXPECT_GT(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CmpSameSizeLower) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F3");
|
|
|
|
int cmp = bign_cmp(&b1, &b2);
|
|
EXPECT_LT(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CmpDifferentSize) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
struct bign b2;
|
|
bign_create_from_value(&b2, UINT32_C(42));
|
|
|
|
{
|
|
int cmp = bign_cmp(&b1, &b2);
|
|
EXPECT_GT(cmp, 0);
|
|
}
|
|
|
|
{
|
|
int cmp = bign_cmp(&b2, &b1);
|
|
EXPECT_LT(cmp, 0);
|
|
}
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CmpToZero) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000000000000000");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0000000100000000");
|
|
|
|
int cmp = bign_cmp(&b1, &b2);
|
|
EXPECT_LT(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CmpZeroEqual) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0");
|
|
|
|
int cmp = bign_cmp_zero(&b1);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CmpZeroZeroEqual) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000000000000000");
|
|
|
|
int cmp = bign_cmp_zero(&b1);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CmpZeroDifferent) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
int cmp = bign_cmp_zero(&b1);
|
|
EXPECT_GT(cmp, 0);
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, Copy) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
struct bign b2;
|
|
bign_create_empty(&b2);
|
|
|
|
bign_copy_from_other(&b2, &b1);
|
|
|
|
EXPECT_EQ(b2.size, 6u);
|
|
|
|
if (b2.size == 6u) {
|
|
EXPECT_EQ(b2.data[5], UINT32_C(0xE38C3BA9));
|
|
EXPECT_EQ(b2.data[4], UINT32_C(0x48CDEA56));
|
|
EXPECT_EQ(b2.data[3], UINT32_C(0x73926BFF));
|
|
EXPECT_EQ(b2.data[2], UINT32_C(0xDBAECBF7));
|
|
EXPECT_EQ(b2.data[1], UINT32_C(0x82B3F2C3));
|
|
EXPECT_EQ(b2.data[0], UINT32_C(0x32F1C3F2));
|
|
|
|
EXPECT_EQ(bign_cmp(&b1, &b2), 0);
|
|
}
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, CopyInNonEmpty) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "158EFA739BFA8362FBCD");
|
|
|
|
bign_copy_from_other(&b2, &b1);
|
|
|
|
EXPECT_EQ(b2.size, 6u);
|
|
|
|
if (b2.size == 6u) {
|
|
EXPECT_EQ(b2.data[5], UINT32_C(0xE38C3BA9));
|
|
EXPECT_EQ(b2.data[4], UINT32_C(0x48CDEA56));
|
|
EXPECT_EQ(b2.data[3], UINT32_C(0x73926BFF));
|
|
EXPECT_EQ(b2.data[2], UINT32_C(0xDBAECBF7));
|
|
EXPECT_EQ(b2.data[1], UINT32_C(0x82B3F2C3));
|
|
EXPECT_EQ(b2.data[0], UINT32_C(0x32F1C3F2));
|
|
|
|
EXPECT_EQ(bign_cmp(&b1, &b2), 0);
|
|
}
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, Move) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
uint32_t *ptr = b1.data;
|
|
|
|
struct bign b2;
|
|
bign_create_empty(&b2);
|
|
|
|
bign_move_from_other(&b2, &b1);
|
|
|
|
EXPECT_EQ(b2.size, 6u);
|
|
|
|
if (b2.size == 6u) {
|
|
|
|
EXPECT_EQ(b2.data[5], UINT32_C(0xE38C3BA9));
|
|
EXPECT_EQ(b2.data[4], UINT32_C(0x48CDEA56));
|
|
EXPECT_EQ(b2.data[3], UINT32_C(0x73926BFF));
|
|
EXPECT_EQ(b2.data[2], UINT32_C(0xDBAECBF7));
|
|
EXPECT_EQ(b2.data[1], UINT32_C(0x82B3F2C3));
|
|
EXPECT_EQ(b2.data[0], UINT32_C(0x32F1C3F2));
|
|
|
|
EXPECT_EQ(ptr, b2.data);
|
|
|
|
EXPECT_EQ(b1.size, 0u);
|
|
EXPECT_EQ(b1.capacity, 0u);
|
|
EXPECT_EQ(b1.data, nullptr);
|
|
}
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, MoveInNonEmpty) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
uint32_t *ptr = b1.data;
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "158EFA739BFA8362FBCD");
|
|
|
|
bign_move_from_other(&b2, &b1);
|
|
|
|
EXPECT_EQ(b2.size, 6u);
|
|
|
|
if (b2.size == 6u) {
|
|
|
|
EXPECT_EQ(b2.data[5], UINT32_C(0xE38C3BA9));
|
|
EXPECT_EQ(b2.data[4], UINT32_C(0x48CDEA56));
|
|
EXPECT_EQ(b2.data[3], UINT32_C(0x73926BFF));
|
|
EXPECT_EQ(b2.data[2], UINT32_C(0xDBAECBF7));
|
|
EXPECT_EQ(b2.data[1], UINT32_C(0x82B3F2C3));
|
|
EXPECT_EQ(b2.data[0], UINT32_C(0x32F1C3F2));
|
|
|
|
EXPECT_EQ(ptr, b2.data);
|
|
|
|
EXPECT_EQ(b1.size, 0u);
|
|
EXPECT_EQ(b1.capacity, 0u);
|
|
EXPECT_EQ(b1.data, nullptr);
|
|
}
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, Print) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000000000000000A948CDEA56730000000BFF0782B30000000032F1C3F2");
|
|
|
|
bign_print(&b1); puts("");
|
|
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
/*
|
|
* add
|
|
*/
|
|
|
|
TEST(BigN, AddSingleDigit) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "12");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "34");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_add(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "46");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, AddSingleDigitToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "12");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "34");
|
|
|
|
bign_add(&b1, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b1, "46");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, AddManyDigits) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "1212121212121212");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "3434343434343434");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_add(&b3, &b1, &b2);
|
|
|
|
|
|
int cmp = bign_compare_to(&b3, "4646464646464646");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, AddManyDigitsToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "1212121212121212");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "3434343434343434");
|
|
|
|
bign_add(&b1, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b1, "4646464646464646");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, AddManyDigitsWithCarry) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_add(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "10000000000000000");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, AddManyDigitsWithCarryToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1");
|
|
|
|
bign_add(&b1, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b1, "10000000000000000");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, AddMax) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_add(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "1fffffffffffffffe");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
/*
|
|
* sub
|
|
*/
|
|
|
|
TEST(BigN, SubSingleDigit) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "46");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "34");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_sub(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "12");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, SubSingleDigitToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "46");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "34");
|
|
|
|
bign_sub(&b1, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b1, "12");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, SubManyDigits) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "4646464646464646");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "3434343434343434");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_sub(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "1212121212121212");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, SubManyDigitsToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "4646464646464646");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "3434343434343434");
|
|
|
|
bign_sub(&b1, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b1, "1212121212121212");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, SubManyDigitsWithCarry) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "10000000000000000");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_sub(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "FFFFFFFFFFFFFFFF");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, SubManyDigitsWithCarryToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "10000000000000000");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1");
|
|
|
|
bign_sub(&b1, &b1, &b2);
|
|
int cmp = bign_compare_to(&b1, "FFFFFFFFFFFFFFFF");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, SubMax) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "10000000000000000");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_sub(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "1");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
|
|
// TODO: X - 0
|
|
|
|
/*
|
|
* mul
|
|
*/
|
|
|
|
TEST(BigN, MulSingleDigit) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "42");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "69");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_mul(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "1b12");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, MulSingleDigitToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "42");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "69");
|
|
|
|
bign_mul(&b1, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b1, "1b12");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
|
|
TEST(BigN, MulManyDigits) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "69426942694269");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "12");
|
|
|
|
{
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
bign_mul(&b3, &b1, &b2);
|
|
int cmp = bign_compare_to(&b3, "766ab66ab66ab62");
|
|
EXPECT_EQ(cmp, 0);
|
|
bign_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
bign_mul(&b3, &b2, &b1);
|
|
int cmp = bign_compare_to(&b3, "766ab66ab66ab62");
|
|
EXPECT_EQ(cmp, 0);
|
|
bign_destroy(&b3);
|
|
}
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, MulManyDigitsToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "69426942694269");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "12");
|
|
|
|
bign_mul(&b1, &b1, &b2);
|
|
int cmp = bign_compare_to(&b1, "766ab66ab66ab62");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
|
|
TEST(BigN, MulManyDigitsWithCarry) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "4269426942694269");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1200000012");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_mul(&b3, &b1, &b2);
|
|
|
|
|
|
int cmp = bign_compare_to(&b3, "4ab66ab6b56cd56c8ab66ab62");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, MulManyDigitsWithCarryToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "4269426942694269");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1200000012");
|
|
|
|
bign_mul(&b1, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b1, "4ab66ab6b56cd56c8ab66ab62");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, MulMax) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_mul(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "fffffffffffffffe0000000000000001");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, MulRsa768) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "d982ec7b440e2869d2535e51f91bacc3eb6eba042e106e6f875c3d17e53db65fffd6e4e9a36084ce60f83d754dd7f701");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "eebe6dd23ce7e99c0e2249fecc4418c34af74e418bfa714c3791828414ab18f32fd7e093062a49b030225cc845f99ab5");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_mul(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "cad984557c97e039431a226ad727f0c6d43ef3d418469f1b375049b229843ee9f83b1f97738ac274f5f61f401f21f1913e4b64bb31b55a38d398c0dfed00b1392f0889711c44b359e7976c617fcc734f06e3e95c26476091b52f462e79413db5");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
/*
|
|
* mul short TODO
|
|
*/
|
|
|
|
|
|
/*
|
|
* mul karatsuba
|
|
*/
|
|
|
|
TEST(BigN, MulKaratsubaSingleDigit) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "42");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "69");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_mul_karatsuba(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "1b12");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, MulKaratsubaSingleDigitToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "42");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "69");
|
|
|
|
bign_mul_karatsuba(&b1, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b1, "1b12");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
|
|
TEST(BigN, MulKaratsubaManyDigits) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "69426942694269");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "12");
|
|
|
|
{
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
bign_mul_karatsuba(&b3, &b1, &b2);
|
|
int cmp = bign_compare_to(&b3, "766ab66ab66ab62");
|
|
EXPECT_EQ(cmp, 0);
|
|
bign_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
bign_mul_karatsuba(&b3, &b2, &b1);
|
|
int cmp = bign_compare_to(&b3, "766ab66ab66ab62");
|
|
EXPECT_EQ(cmp, 0);
|
|
bign_destroy(&b3);
|
|
}
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, MulKaratsubaManyDigitsToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "69426942694269");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "12");
|
|
|
|
bign_mul_karatsuba(&b1, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b1, "766ab66ab66ab62");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
|
|
TEST(BigN, MulKaratsubaManyDigitsWithCarry) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "4269426942694269");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1200000012");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_mul_karatsuba(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "4ab66ab6b56cd56c8ab66ab62");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, MulKaratsubaManyDigitsWithCarryToSelf) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "4269426942694269");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1200000012");
|
|
|
|
bign_mul_karatsuba(&b1, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b1, "4ab66ab6b56cd56c8ab66ab62");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, MulKaratsubaMax) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_mul_karatsuba(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "fffffffffffffffe0000000000000001");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, MulKaratsubaRsa768) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "d982ec7b440e2869d2535e51f91bacc3eb6eba042e106e6f875c3d17e53db65fffd6e4e9a36084ce60f83d754dd7f701");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "eebe6dd23ce7e99c0e2249fecc4418c34af74e418bfa714c3791828414ab18f32fd7e093062a49b030225cc845f99ab5");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_mul_karatsuba(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "cad984557c97e039431a226ad727f0c6d43ef3d418469f1b375049b229843ee9f83b1f97738ac274f5f61f401f21f1913e4b64bb31b55a38d398c0dfed00b1392f0889711c44b359e7976c617fcc734f06e3e95c26476091b52f462e79413db5");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
/*
|
|
* div
|
|
*/
|
|
|
|
TEST(BigN, DivSingleDigit) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "69");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "42");
|
|
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
|
|
bign_div(&q, &r, &b1, &b2);
|
|
|
|
int cmpq = bign_compare_to(&q, "1");
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bign_compare_to(&r, "27");
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivSingleDigitReverse) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "69");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "42");
|
|
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
|
|
bign_div(&q, &r, &b2, &b1);
|
|
|
|
int cmpq = bign_compare_to(&q, "0");
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bign_compare_to(&r, "42");
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivShort) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "4269");
|
|
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
|
|
bign_div(&q, &r, &b1, &b2);
|
|
|
|
|
|
int cmpq = bign_compare_to(&q, "36d289377777bc42aa33c0180efb449c6ca5908b4dc2c");
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bign_compare_to(&r, "1de6");
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivShortMax) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "FFFFFFFF");
|
|
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
|
|
bign_div(&q, &r, &b1, &b2);
|
|
|
|
int cmpq = bign_compare_to(&q, "100000001");
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bign_compare_to(&r, "0");
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivManyDigits) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "426999FEAB350EB291B3F1098");
|
|
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
|
|
bign_div(&q, &r, &b1, &b2);
|
|
|
|
int cmpq = bign_compare_to(&q, "36d20a18b7884e2890017831");
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bign_compare_to(&r, "222ada30e45d62ecadb8056da");
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivMax) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "FFFFFFFFFFFFFFFF");
|
|
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
|
|
bign_div(&q, &r, &b1, &b2);
|
|
|
|
int cmpq = bign_compare_to(&q, "1");
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bign_compare_to(&r, "0");
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
|
|
/*
|
|
* tests from http://www.hackersdelight.org/hdcodetxt/divmnu64.c.txt
|
|
* the first three tests are errors
|
|
*/
|
|
|
|
TEST(BigN, DivCase3) {
|
|
// test #3
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "00000003");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "00000002");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000001");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000001");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase4) {
|
|
// test #4
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "00000003");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "00000003");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000001");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase5) {
|
|
// test #5
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "00000003");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "00000004");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000000");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000003");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase6) {
|
|
// test #6
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "00000000");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "ffffffff");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000000");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase7) {
|
|
// test #7
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "ffffffff");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "00000001");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "ffffffff");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase8) {
|
|
// test #8
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "ffffffff");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "ffffffff");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000001");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase9) {
|
|
// test #9
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "ffffffff");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "00000003");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "55555555");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase10) {
|
|
// test #10
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "ffffffffffffffff");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "00000001");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "ffffffffffffffff");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase11) {
|
|
// test #11
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "ffffffffffffffff");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "ffffffff");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "0000000100000001");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase12) {
|
|
// test #12
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "fffffffeffffffff");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "ffffffff");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000000ffffffff");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "fffffffe");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase13) {
|
|
// test #13
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000123400005678");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "00009abc");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "000000001e1dba76");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00006bd0");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase14) {
|
|
// test #14
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000000000000000");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0000000100000000");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000000");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "0000000000000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase15) {
|
|
// test #15
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000000700000000");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0000000300000000");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000002");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "0000000100000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase16) {
|
|
// test #16
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000000700000005");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0000000300000000");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000002");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "0000000100000005");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase17) {
|
|
// test #17
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000000600000000");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0000000200000000");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000003");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "0000000000000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase18) {
|
|
// test #18
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "80000000");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "40000001");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000001");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "3fffffff");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase19) {
|
|
// test #19
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "8000000000000000");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "40000001");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000001fffffff8");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000008");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase20) {
|
|
// test #20
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "8000000000000000");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "4000000000000001");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000001");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "3fffffffffffffff");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase21) {
|
|
// test #21
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000bcde0000789a");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0000bcde0000789a");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000001");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "0000000000000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase22) {
|
|
// test #22
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000bcde0000789b");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0000bcde0000789a");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000001");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "0000000000000001");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase23) {
|
|
// test #23
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000bcde00007899");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0000bcde0000789a");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000000");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "0000bcde00007899");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase24) {
|
|
// test #24
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000ffff0000ffff");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0000ffff0000ffff");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000001");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "0000000000000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase25) {
|
|
// test #25
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000ffff0000ffff");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0000000100000000");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "0000ffff");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "000000000000ffff");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase26) {
|
|
// test #26
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0000012300004567000089ab");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0000000100000000");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "0000012300004567");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000000000089ab");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase27) {
|
|
// test #27
|
|
// Shows that first qhat can = b + 1.
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "000080000000fffe00000000");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "000080000000ffff");
|
|
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000000ffffffff");
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bign_compare_to(&r, "00007fff0000ffff");
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase28) {
|
|
// test #28
|
|
// Adding back step req'd.
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "800000000000000000000003");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "200000000000000000000001");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000003");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "200000000000000000000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase29) {
|
|
// test #29
|
|
// Adding back step req'd.
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "000080000000000000000003");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "000020000000000000000001");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000003");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "000020000000000000000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase30) {
|
|
// test #30
|
|
// Add back req'd.
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "00007fff000080000000000000000000");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "000080000000000000000001");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000000fffe0000");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00007fffffffffff00020000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase31) {
|
|
// test #31
|
|
// Shows that mult-sub quantity cannot be treated as signed.
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "00008000000000000000fffe00000000");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "00008000000000000000ffff");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000000ffffffff");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00007fffffffffff0000ffff");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase32) {
|
|
// test #32
|
|
// Shows that mult-sub quantity cannot be treated as signed.
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "8000000000000000fffffffe00000000");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "80000000000000000000ffff");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "0000000100000000");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "00000000fffeffff00000000");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, DivCase33) {
|
|
// test #33
|
|
// Shows that mult-sub quantity cannot be treated as signed.
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "8000000000000000fffffffe00000000");
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "8000000000000000ffffffff");
|
|
struct bign q;
|
|
bign_create_empty(&q);
|
|
struct bign r;
|
|
bign_create_empty(&r);
|
|
bign_div(&q, &r, &b1, &b2);
|
|
int cmpq = bign_compare_to(&q, "00000000ffffffff");
|
|
EXPECT_EQ(cmpq, 0);
|
|
int cmpr = bign_compare_to(&r, "7fffffffffffffffffffffff");
|
|
EXPECT_EQ(cmpr, 0);
|
|
bign_destroy(&r);
|
|
bign_destroy(&q);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
|
|
/*
|
|
* exp
|
|
*/
|
|
|
|
// exp( , 0)
|
|
|
|
TEST(BigN, ExpXPowerZero) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "1234567890ABCDEF");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "0");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_exp(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "1");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
// exp( , 1)
|
|
|
|
TEST(BigN, ExpXPowerOne) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "1234567890ABCDEF");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_print(&b3);
|
|
|
|
bign_exp(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "1234567890ABCDEF");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
// exp(0, )
|
|
|
|
TEST(BigN, ExpZeroPowerN) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "0");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1234567890ABCDEF");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_exp(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "0");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
// exp(1, )
|
|
|
|
TEST(BigN, ExpOnePowerN) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "1");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1234567890ABCDEF");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_exp(&b3, &b1, &b2);
|
|
|
|
int cmp = bign_compare_to(&b3, "1");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
// exp(sm, sm)
|
|
|
|
TEST(BigN, ExpSmallPowerSmall) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "31");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "56");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_exp(&b3, &b1, &b2);
|
|
|
|
bign_print(&b3);
|
|
|
|
int cmp = bign_compare_to(&b3, "7491caf9dd4e6cc7aa542df60f1437aad480c03e54f97e58230a7952097d3710e2c0af4562b67af9f8e46b8c40beaa50fadf46423471861e4efce4f21");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
// exp(lg, sm)
|
|
|
|
TEST(BigN, ExpLargePowerSmall) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "123456789");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "13");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_exp(&b3, &b1, &b2);
|
|
|
|
bign_print(&b3);
|
|
|
|
int cmp = bign_compare_to(&b3, "b9def572bcd526c6bc46607dde0446ad6da1f4c4302fd57a1bec55d6157b328aeabe4525706f87494c647dca5fd70e1c33bbc93a4291fcf0eb957d7262a84b96148baee40ed8836bbeef433d9");
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
// exp(sm, lg)
|
|
|
|
TEST(BigN, ExpSmallPowerLarge) {
|
|
struct bign b1;
|
|
bign_create_from_string(&b1, "2");
|
|
|
|
struct bign b2;
|
|
bign_create_from_string(&b2, "1000");
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_exp(&b3, &b1, &b2);
|
|
|
|
EXPECT_EQ(b3.size, 129u);
|
|
|
|
if (b3.size == 129u) {
|
|
EXPECT_EQ(b3.data[128], UINT32_C(1));
|
|
|
|
for (int i = 0; i < 128; ++i) {
|
|
EXPECT_EQ(b3.data[i], UINT32_C(0));
|
|
}
|
|
}
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigN, RandomAddSub) {
|
|
static const int Iterations = 1000;
|
|
|
|
for (int i = 0; i < Iterations; ++i) {
|
|
struct bign b1;
|
|
|
|
bign_create_random(&b1);
|
|
|
|
struct bign b2;
|
|
bign_create_random(&b2);
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
|
|
bign_add(&b3, &b1, &b2);
|
|
|
|
struct bign b4;
|
|
bign_create_empty(&b4);
|
|
|
|
|
|
bign_sub(&b4, &b3, &b2);
|
|
|
|
int cmp = bign_cmp(&b4, &b1);
|
|
|
|
bign_destroy(&b4);
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
|
|
ASSERT_EQ(cmp, 0);
|
|
}
|
|
|
|
}
|
|
|
|
TEST(BigN, RandomMulMul) {
|
|
static const int Iterations = 100;
|
|
|
|
for (int i = 0; i < Iterations; ++i) {
|
|
struct bign b1;
|
|
bign_create_random(&b1);
|
|
|
|
struct bign b2;
|
|
bign_create_random(&b2);
|
|
|
|
struct bign b3;
|
|
bign_create_empty(&b3);
|
|
|
|
bign_mul(&b3, &b1, &b2);
|
|
|
|
struct bign b4;
|
|
bign_create_empty(&b4);
|
|
|
|
bign_mul_karatsuba(&b4, &b1, &b2);
|
|
|
|
int cmp = bign_cmp(&b3, &b4);
|
|
|
|
bign_destroy(&b4);
|
|
bign_destroy(&b3);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
|
|
ASSERT_EQ(cmp, 0);
|
|
}
|
|
|
|
}
|
|
|
|
TEST(BigN, RandomMulDiv) {
|
|
static const int Iterations = 1000;
|
|
|
|
for (int i = 0; i < Iterations; ++i) {
|
|
struct bign b1;
|
|
bign_create_random(&b1);
|
|
|
|
struct bign b2;
|
|
bign_create_random(&b2);
|
|
|
|
struct bign quo;
|
|
bign_create_empty(&quo);
|
|
|
|
struct bign rem;
|
|
bign_create_empty(&rem);
|
|
|
|
bign_div(&quo, &rem, &b1, &b2);
|
|
|
|
struct bign b3;
|
|
bign_create_random(&b3);
|
|
|
|
bign_mul(&b3, &quo, &b2);
|
|
bign_add(&b3, &b3, &rem);
|
|
|
|
int cmp = bign_cmp(&b3, &b1);
|
|
|
|
bign_destroy(&b3);
|
|
bign_destroy(&rem);
|
|
bign_destroy(&quo);
|
|
bign_destroy(&b2);
|
|
bign_destroy(&b1);
|
|
|
|
ASSERT_EQ(cmp, 0);
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* BigZ
|
|
*/
|
|
|
|
TEST(BigZ, CreateEmpty) {
|
|
struct bigz b1;
|
|
bigz_create_empty(&b1);
|
|
|
|
EXPECT_EQ(b1.n.size, 0u);
|
|
EXPECT_EQ(b1.n.data, nullptr);
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CreateFromValuePositive) {
|
|
struct bigz b1;
|
|
bigz_create_from_value(&b1, INT32_C(42));
|
|
|
|
EXPECT_TRUE(b1.positive);
|
|
EXPECT_EQ(b1.n.size, 1u);
|
|
EXPECT_EQ(b1.n.data[0], UINT32_C(42));
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CreateFromValueNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_value(&b1, INT32_C(-42));
|
|
|
|
EXPECT_FALSE(b1.positive);
|
|
EXPECT_EQ(b1.n.size, 1u);
|
|
EXPECT_EQ(b1.n.data[0], UINT32_C(42));
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CreateFromValuePositiveMax) {
|
|
struct bigz b1;
|
|
bigz_create_from_value(&b1, INT32_MAX);
|
|
|
|
uint32_t ref = INT32_MAX;
|
|
|
|
EXPECT_TRUE(b1.positive);
|
|
EXPECT_EQ(b1.n.size, 1u);
|
|
EXPECT_EQ(b1.n.data[0], ref);
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CreateFromValueNegativeMin) {
|
|
struct bigz b1;
|
|
bigz_create_from_value(&b1, INT32_MIN);
|
|
|
|
EXPECT_FALSE(b1.positive);
|
|
EXPECT_EQ(b1.n.size, 1u);
|
|
EXPECT_EQ(b1.n.data[0], UINT32_C(2147483648));
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CreateFromStringPositiveZero) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "0", 10);
|
|
|
|
EXPECT_TRUE(b1.positive);
|
|
EXPECT_EQ(b1.n.size, 1u);
|
|
EXPECT_EQ(b1.n.data[0], UINT32_C(0));
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CreateFromStringNegativeZero) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-0", 10);
|
|
|
|
EXPECT_FALSE(b1.positive);
|
|
EXPECT_EQ(b1.n.size, 1u);
|
|
EXPECT_EQ(b1.n.data[0], UINT32_C(0));
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CreateFromStringBinary) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "1001101101111010010010101101101011110110011100010001110111010001010001011110100010101010", 2);
|
|
|
|
EXPECT_TRUE(b1.positive);
|
|
EXPECT_EQ(b1.n.size, 3u);
|
|
EXPECT_EQ(b1.n.data[0], UINT32_C(0xd145e8aa));
|
|
EXPECT_EQ(b1.n.data[1], UINT32_C(0xdaf6711d));
|
|
EXPECT_EQ(b1.n.data[2], UINT32_C(0x9b7a4a));
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CreateFromStringDecimal) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "15497642151661527013020516797518124587412201", 10);
|
|
|
|
EXPECT_TRUE(b1.positive);
|
|
EXPECT_EQ(b1.n.size, 5u);
|
|
EXPECT_EQ(b1.n.data[0], UINT32_C(0x1507eae9));
|
|
EXPECT_EQ(b1.n.data[1], UINT32_C(0x7698c6e5));
|
|
EXPECT_EQ(b1.n.data[2], UINT32_C(0x57589b7b));
|
|
EXPECT_EQ(b1.n.data[3], UINT32_C(0x7a1cba70));
|
|
EXPECT_EQ(b1.n.data[4], UINT32_C(0xb1e7));
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CreateFromStringDecimalNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-15497642151661527013020516797518124587412201", 10);
|
|
|
|
EXPECT_FALSE(b1.positive);
|
|
EXPECT_EQ(b1.n.size, 5u);
|
|
EXPECT_EQ(b1.n.data[0], UINT32_C(0x1507eae9));
|
|
EXPECT_EQ(b1.n.data[1], UINT32_C(0x7698c6e5));
|
|
EXPECT_EQ(b1.n.data[2], UINT32_C(0x57589b7b));
|
|
EXPECT_EQ(b1.n.data[3], UINT32_C(0x7a1cba70));
|
|
EXPECT_EQ(b1.n.data[4], UINT32_C(0xb1e7));
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CmpSame) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
|
|
int cmp = bigz_cmp(&b1, &b1);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CmpEqualPositive) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
|
|
int cmp = bigz_cmp(&b1, &b2);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CmpEqualNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
|
|
int cmp = bigz_cmp(&b1, &b2);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CmpDifferentSign) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
|
|
{
|
|
int cmp = bigz_cmp(&b1, &b2);
|
|
EXPECT_GT(cmp, 0);
|
|
}
|
|
|
|
{
|
|
int cmp = bigz_cmp(&b2, &b1);
|
|
EXPECT_LT(cmp, 0);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
// TODO: negative negative
|
|
|
|
TEST(BigZ, CmpPositiveNegativeZero) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "0", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-0", 10);
|
|
|
|
{
|
|
int cmp = bigz_cmp(&b1, &b2);
|
|
EXPECT_EQ(cmp, 0);
|
|
}
|
|
|
|
{
|
|
int cmp = bigz_cmp(&b2, &b1);
|
|
EXPECT_EQ(cmp, 0);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CmpZeroEqualPositiveZero) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "0", 10);
|
|
|
|
int cmp = bigz_cmp_zero(&b1);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CmpZeroEqualNegativeZero) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-0", 10);
|
|
|
|
int cmp = bigz_cmp_zero(&b1);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CmpZeroPositive) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "12345678987654321", 10);
|
|
|
|
int cmp = bigz_cmp_zero(&b1);
|
|
EXPECT_GT(cmp, 0);
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CmpZeroNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-12345678987654321", 10);
|
|
|
|
int cmp = bigz_cmp_zero(&b1);
|
|
EXPECT_LT(cmp, 0);
|
|
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
|
|
TEST(BigZ, Copy) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
|
|
struct bigz b2;
|
|
bigz_create_empty(&b2);
|
|
|
|
bigz_copy_from_other(&b2, &b1);
|
|
|
|
EXPECT_FALSE(b2.positive);
|
|
EXPECT_EQ(b2.n.size, 6u);
|
|
|
|
if (b2.n.size == 6u) {
|
|
EXPECT_EQ(b2.n.data[5], UINT32_C(0xE38C3BA9));
|
|
EXPECT_EQ(b2.n.data[4], UINT32_C(0x48CDEA56));
|
|
EXPECT_EQ(b2.n.data[3], UINT32_C(0x73926BFF));
|
|
EXPECT_EQ(b2.n.data[2], UINT32_C(0xDBAECBF7));
|
|
EXPECT_EQ(b2.n.data[1], UINT32_C(0x82B3F2C3));
|
|
EXPECT_EQ(b2.n.data[0], UINT32_C(0x32F1C3F2));
|
|
|
|
EXPECT_EQ(bigz_cmp(&b1, &b2), 0);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, CopyInNonEmpty) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "EF193C2DFAC33C2FF3D89274801", 16);
|
|
|
|
bigz_copy_from_other(&b2, &b1);
|
|
|
|
EXPECT_FALSE(b2.positive);
|
|
EXPECT_EQ(b2.n.size, 6u);
|
|
|
|
if (b2.n.size == 6u) {
|
|
EXPECT_EQ(b2.n.data[5], UINT32_C(0xE38C3BA9));
|
|
EXPECT_EQ(b2.n.data[4], UINT32_C(0x48CDEA56));
|
|
EXPECT_EQ(b2.n.data[3], UINT32_C(0x73926BFF));
|
|
EXPECT_EQ(b2.n.data[2], UINT32_C(0xDBAECBF7));
|
|
EXPECT_EQ(b2.n.data[1], UINT32_C(0x82B3F2C3));
|
|
EXPECT_EQ(b2.n.data[0], UINT32_C(0x32F1C3F2));
|
|
|
|
EXPECT_EQ(bigz_cmp(&b1, &b2), 0);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, Move) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
|
|
uint32_t *ptr = b1.n.data;
|
|
|
|
struct bigz b2;
|
|
bigz_create_empty(&b2);
|
|
|
|
bigz_move_from_other(&b2, &b1);
|
|
|
|
EXPECT_FALSE(b2.positive);
|
|
EXPECT_EQ(b2.n.size, 6u);
|
|
|
|
if (b2.n.size == 6u) {
|
|
EXPECT_EQ(b2.n.data[5], UINT32_C(0xE38C3BA9));
|
|
EXPECT_EQ(b2.n.data[4], UINT32_C(0x48CDEA56));
|
|
EXPECT_EQ(b2.n.data[3], UINT32_C(0x73926BFF));
|
|
EXPECT_EQ(b2.n.data[2], UINT32_C(0xDBAECBF7));
|
|
EXPECT_EQ(b2.n.data[1], UINT32_C(0x82B3F2C3));
|
|
EXPECT_EQ(b2.n.data[0], UINT32_C(0x32F1C3F2));
|
|
|
|
EXPECT_EQ(ptr, b2.n.data);
|
|
|
|
EXPECT_EQ(b1.n.size, 0u);
|
|
EXPECT_EQ(b1.n.capacity, 0u);
|
|
EXPECT_EQ(b1.n.data, nullptr);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, MoveInNonEmpty) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
|
|
uint32_t *ptr = b1.n.data;
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "EF193C2DFAC33C2FF3D89274801", 16);
|
|
|
|
bigz_move_from_other(&b2, &b1);
|
|
|
|
EXPECT_FALSE(b2.positive);
|
|
EXPECT_EQ(b2.n.size, 6u);
|
|
|
|
if (b2.n.size == 6u) {
|
|
EXPECT_EQ(b2.n.data[5], UINT32_C(0xE38C3BA9));
|
|
EXPECT_EQ(b2.n.data[4], UINT32_C(0x48CDEA56));
|
|
EXPECT_EQ(b2.n.data[3], UINT32_C(0x73926BFF));
|
|
EXPECT_EQ(b2.n.data[2], UINT32_C(0xDBAECBF7));
|
|
EXPECT_EQ(b2.n.data[1], UINT32_C(0x82B3F2C3));
|
|
EXPECT_EQ(b2.n.data[0], UINT32_C(0x32F1C3F2));
|
|
|
|
EXPECT_EQ(ptr, b2.n.data);
|
|
|
|
EXPECT_EQ(b1.n.size, 0u);
|
|
EXPECT_EQ(b1.n.capacity, 0u);
|
|
EXPECT_EQ(b1.n.data, nullptr);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
// TEST(BigZ, Print) {
|
|
// struct bigz b1;
|
|
// bigz_create_from_string(&b1, "-E38C3BA948CDEA5673926BFFDBAECBF782B3F2C332F1C3F2", 16);
|
|
//
|
|
// bigz_print(&b1); puts("");
|
|
//
|
|
// bigz_destroy(&b1);
|
|
// }
|
|
|
|
TEST(BigZ, AddPositivePositive) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "46578458745802102102145458458245485441416", 10);
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_add(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "324808583067597272281203376099393387231117", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_add(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "324808583067597272281203376099393387231117", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, AddPositiveNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-46578458745802102102145458458245485441416", 10);
|
|
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_add(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "231651665575993068076912459182902416348285", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_add(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "231651665575993068076912459182902416348285", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, AddNegativePositive) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "46578458745802102102145458458245485441416", 10);
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_add(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-231651665575993068076912459182902416348285", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_add(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-231651665575993068076912459182902416348285", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, AddNegativeNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-46578458745802102102145458458245485441416", 10);
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_add(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-324808583067597272281203376099393387231117", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_add(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-324808583067597272281203376099393387231117", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(BigZ, SubPositivePositive) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "46578458745802102102145458458245485441416", 10);
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_sub(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "231651665575993068076912459182902416348285", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_sub(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-231651665575993068076912459182902416348285", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, SubPositiveNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-46578458745802102102145458458245485441416", 10);
|
|
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_sub(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "324808583067597272281203376099393387231117", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_sub(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-324808583067597272281203376099393387231117", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, SubNegativePositive) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "46578458745802102102145458458245485441416", 10);
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_sub(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-324808583067597272281203376099393387231117", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_sub(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "324808583067597272281203376099393387231117", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, SubNegativeNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-46578458745802102102145458458245485441416", 10);
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_sub(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-231651665575993068076912459182902416348285", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_sub(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "231651665575993068076912459182902416348285", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
|
|
TEST(BigZ, MulPositivePositive) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "4657845874580210210", 10);
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_mul(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "1295953036756212640552727646158429498971649147282135793047210", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_mul(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "1295953036756212640552727646158429498971649147282135793047210", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, MulPositiveNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-4657845874580210210", 10);
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_mul(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-1295953036756212640552727646158429498971649147282135793047210", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_mul(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-1295953036756212640552727646158429498971649147282135793047210", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, MulNegativePositive) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "4657845874580210210", 10);
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_mul(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-1295953036756212640552727646158429498971649147282135793047210", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_mul(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "-1295953036756212640552727646158429498971649147282135793047210", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, MulNegativeNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-4657845874580210210", 10);
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_mul(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "1295953036756212640552727646158429498971649147282135793047210", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
{
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_mul(&b3, &b2, &b1);
|
|
|
|
int cmp = bigz_compare_to(&b3, "1295953036756212640552727646158429498971649147282135793047210", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
}
|
|
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
|
|
TEST(BigZ, DivPositivePositive) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "4657845874580210210", 10);
|
|
|
|
struct bigz q;
|
|
bigz_create_empty(&q);
|
|
|
|
struct bigz r;
|
|
bigz_create_empty(&r);
|
|
|
|
bigz_div(&q, &r, &b1, &b2);
|
|
|
|
int cmpq = bigz_compare_to(&q, "59733647658934344963858", 10);
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bigz_compare_to(&r, "2948551563409199521", 10);
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bigz_destroy(&r);
|
|
bigz_destroy(&q);
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, DivPositiveNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-4657845874580210210", 10);
|
|
|
|
struct bigz q;
|
|
bigz_create_empty(&q);
|
|
|
|
struct bigz r;
|
|
bigz_create_empty(&r);
|
|
|
|
bigz_div(&q, &r, &b1, &b2);
|
|
|
|
int cmpq = bigz_compare_to(&q, "-59733647658934344963858", 10);
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bigz_compare_to(&r, "2948551563409199521", 10);
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bigz_destroy(&r);
|
|
bigz_destroy(&q);
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, DivNegativePositive) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "4657845874580210210", 10);
|
|
|
|
struct bigz q;
|
|
bigz_create_empty(&q);
|
|
|
|
struct bigz r;
|
|
bigz_create_empty(&r);
|
|
|
|
bigz_div(&q, &r, &b1, &b2);
|
|
|
|
// int cmpq = bigz_compare_to(&q, "-59733647658934344963858", 10);
|
|
int cmpq = bigz_compare_to(&q, "-59733647658934344963859", 10);
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
// int cmpr = bigz_compare_to(&r, "-2948551563409199521", 10);
|
|
int cmpr = bigz_compare_to(&r, "1709294311171010689", 10);
|
|
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bigz_destroy(&r);
|
|
bigz_destroy(&q);
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, DivNegativeNegative) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-278230124321795170179057917641147901789701", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-4657845874580210210", 10);
|
|
|
|
struct bigz q;
|
|
bigz_create_empty(&q);
|
|
|
|
struct bigz r;
|
|
bigz_create_empty(&r);
|
|
|
|
bigz_div(&q, &r, &b1, &b2);
|
|
|
|
// int cmpq = bigz_compare_to(&q, "59733647658934344963858", 10);
|
|
int cmpq = bigz_compare_to(&q, "59733647658934344963859", 10);
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
// int cmpr = bigz_compare_to(&r, "-2948551563409199521", 10);
|
|
int cmpr = bigz_compare_to(&r, "1709294311171010689", 10);
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bigz_destroy(&r);
|
|
bigz_destroy(&q);
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
|
|
|
|
TEST(BigZ, DivPositivePositiveZeroRemainder) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "278230124321795170179054969089584492590180", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "4657845874580210210", 10);
|
|
|
|
struct bigz q;
|
|
bigz_create_empty(&q);
|
|
|
|
struct bigz r;
|
|
bigz_create_empty(&r);
|
|
|
|
bigz_div(&q, &r, &b1, &b2);
|
|
|
|
int cmpq = bigz_compare_to(&q, "59733647658934344963858", 10);
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bigz_compare_to(&r, "0", 10);
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bigz_destroy(&r);
|
|
bigz_destroy(&q);
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, DivPositiveNegativeZeroRemainder) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "278230124321795170179054969089584492590180", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-4657845874580210210", 10);
|
|
|
|
struct bigz q;
|
|
bigz_create_empty(&q);
|
|
|
|
struct bigz r;
|
|
bigz_create_empty(&r);
|
|
|
|
bigz_div(&q, &r, &b1, &b2);
|
|
|
|
int cmpq = bigz_compare_to(&q, "-59733647658934344963858", 10);
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bigz_compare_to(&r, "0", 10);
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bigz_destroy(&r);
|
|
bigz_destroy(&q);
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, DivNegativePositiveZeroRemainder) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-278230124321795170179054969089584492590180", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "4657845874580210210", 10);
|
|
|
|
struct bigz q;
|
|
bigz_create_empty(&q);
|
|
|
|
struct bigz r;
|
|
bigz_create_empty(&r);
|
|
|
|
bigz_div(&q, &r, &b1, &b2);
|
|
|
|
int cmpq = bigz_compare_to(&q, "-59733647658934344963858", 10);
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bigz_compare_to(&r, "0", 10);
|
|
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bigz_destroy(&r);
|
|
bigz_destroy(&q);
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, DivNegativeNegativeZeroRemainder) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "-278230124321795170179054969089584492590180", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "-4657845874580210210", 10);
|
|
|
|
struct bigz q;
|
|
bigz_create_empty(&q);
|
|
|
|
struct bigz r;
|
|
bigz_create_empty(&r);
|
|
|
|
bigz_div(&q, &r, &b1, &b2);
|
|
|
|
int cmpq = bigz_compare_to(&q, "59733647658934344963858", 10);
|
|
EXPECT_EQ(cmpq, 0);
|
|
|
|
int cmpr = bigz_compare_to(&r, "0", 10);
|
|
EXPECT_EQ(cmpr, 0);
|
|
|
|
bigz_destroy(&r);
|
|
bigz_destroy(&q);
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
}
|
|
|
|
TEST(BigZ, GcdCoprime) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "1533918542734615245164352154619195752815244561235899341531", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "1533918542734615245164352154619195752815244561235899341532", 10);
|
|
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_gcd(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "1", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
|
|
}
|
|
|
|
TEST(BigZ, GcdRsa768) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "d982ec7b440e2869d2535e51f91bacc3eb6eba042e106e6f875c3d17e53db65fffd6e4e9a36084ce60f83d754dd7f701", 16);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "eebe6dd23ce7e99c0e2249fecc4418c34af74e418bfa714c3791828414ab18f32fd7e093062a49b030225cc845f99ab5", 16);
|
|
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_gcd(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "1", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
|
|
}
|
|
|
|
TEST(BigZ, GcdNotCoprime) {
|
|
struct bigz b1;
|
|
bigz_create_from_string(&b1, "829029200588685010168228367991253899050528829049", 10);
|
|
|
|
struct bigz b2;
|
|
bigz_create_from_string(&b2, "92196793900174799975899442851691027900097961", 10);
|
|
|
|
struct bigz b3;
|
|
bigz_create_empty(&b3);
|
|
|
|
bigz_gcd(&b3, &b1, &b2);
|
|
|
|
int cmp = bigz_compare_to(&b3, "97713221", 10);
|
|
EXPECT_EQ(cmp, 0);
|
|
|
|
bigz_destroy(&b3);
|
|
bigz_destroy(&b2);
|
|
bigz_destroy(&b1);
|
|
|
|
}
|
|
|
|
|
|
int main(int argc, char **argv) {
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|