thunderbrewhq/squall
1
0
Fork 0
mirror of https://github.com/thunderbrewhq/squall.git synced 2025-12-12 02:22:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

chore(big): simplify SBig tests

Browse source
This commit is contained in:
Adam Heinermann 2024-11-15 09:51:27 -08:00 • committed by superp00t
parent c31e976595
commit c616d351a9
2 changed files with 53 additions and 783 deletions
Download patch file Download diff file Expand all files Collapse all files

264
test/Big.cpp
View file

@ -3,82 +3,40 @@
#include <string> #include <string>
TEST_CASE("SBigAdd", "[big]") { TEST_CASE("SBigAdd", "[big]") {
BigDataTest a, b, c;
SECTION("adds 0 and 1") { SECTION("adds 0 and 1") {
BigData* a;
SBigNew(&a);
BigData* b;
SBigNew(&b);
SBigFromUnsigned(b, 0); SBigFromUnsigned(b, 0);
BigData* c;
SBigNew(&c);
SBigFromUnsigned(c, 1); SBigFromUnsigned(c, 1);
SBigAdd(a, b, c); SBigAdd(a, b, c);
CHECK(a->Primary().Count() == 1); CHECK(a->Primary().Count() == 1);
CHECK(a->Primary()[0] == 1); CHECK(a->Primary()[0] == 1);
SBigDel(a);
SBigDel(b);
SBigDel(c);
} }
SECTION("adds 1 and 2") { SECTION("adds 1 and 2") {
BigData* a;
SBigNew(&a);
BigData* b;
SBigNew(&b);
SBigFromUnsigned(b, 1); SBigFromUnsigned(b, 1);
BigData* c;
SBigNew(&c);
SBigFromUnsigned(c, 2); SBigFromUnsigned(c, 2);
SBigAdd(a, b, c); SBigAdd(a, b, c);
CHECK(a->Primary().Count() == 1); CHECK(a->Primary().Count() == 1);
CHECK(a->Primary()[0] == 3); CHECK(a->Primary()[0] == 3);
SBigDel(a);
SBigDel(b);
SBigDel(c);
} }
SECTION("adds 0x12345678 and 0x23456789") { SECTION("adds 0x12345678 and 0x23456789") {
BigData* a;
SBigNew(&a);
BigData* b;
SBigNew(&b);
SBigFromUnsigned(b, 0x12345678); SBigFromUnsigned(b, 0x12345678);
BigData* c;
SBigNew(&c);
SBigFromUnsigned(c, 0x23456789); SBigFromUnsigned(c, 0x23456789);
SBigAdd(a, b, c); SBigAdd(a, b, c);
CHECK(a->Primary().Count() == 1); CHECK(a->Primary().Count() == 1);
CHECK(a->Primary()[0] == 0x3579BE01); CHECK(a->Primary()[0] == 0x3579BE01);
SBigDel(a);
SBigDel(b);
SBigDel(c);
} }
SECTION("adds 0xFFFFFFFF and 0xF0F0F0F0") { SECTION("adds 0xFFFFFFFF and 0xF0F0F0F0") {
BigData* a;
SBigNew(&a);
BigData* b;
SBigNew(&b);
SBigFromUnsigned(b, 0xFFFFFFFF); SBigFromUnsigned(b, 0xFFFFFFFF);
BigData* c;
SBigNew(&c);
SBigFromUnsigned(c, 0xF0F0F0F0); SBigFromUnsigned(c, 0xF0F0F0F0);
SBigAdd(a, b, c); SBigAdd(a, b, c);
@ -86,17 +44,11 @@ TEST_CASE("SBigAdd", "[big]") {
CHECK(a->Primary().Count() == 2); CHECK(a->Primary().Count() == 2);
CHECK(a->Primary()[0] == 0xF0F0F0EF); CHECK(a->Primary()[0] == 0xF0F0F0EF);
CHECK(a->Primary()[1] == 0x1); CHECK(a->Primary()[1] == 0x1);
SBigDel(a);
SBigDel(b);
SBigDel(c);
} }
} }
TEST_CASE("SBigAnd", "[big]") { TEST_CASE("SBigAnd", "[big]") {
BigDataTest a; BigDataTest a, b, c;
BigDataTest b;
BigDataTest c;
SECTION("overwrites output") { SECTION("overwrites output") {
SBigFromUnsigned(a, 123456); SBigFromUnsigned(a, 123456);
@ -130,61 +82,45 @@ TEST_CASE("SBigAnd", "[big]") {
} }
TEST_CASE("SBigBitLen", "[big]") { TEST_CASE("SBigBitLen", "[big]") {
BigDataTest num;
SECTION("returns bit length of 1") { SECTION("returns bit length of 1") {
BigData* num;
SBigNew(&num);
SBigFromUnsigned(num, 1); SBigFromUnsigned(num, 1);
uint32_t len; uint32_t len;
SBigBitLen(num, &len); SBigBitLen(num, &len);
CHECK(len == 1); CHECK(len == 1);
SBigDel(num);
} }
SECTION("returns bit length of 5") { SECTION("returns bit length of 5") {
BigData* num;
SBigNew(&num);
SBigFromUnsigned(num, 5); SBigFromUnsigned(num, 5);
uint32_t len; uint32_t len;
SBigBitLen(num, &len); SBigBitLen(num, &len);
CHECK(len == 3); CHECK(len == 3);
SBigDel(num);
} }
SECTION("returns bit length of 0xFFFF") { SECTION("returns bit length of 0xFFFF") {
BigData* num;
SBigNew(&num);
SBigFromUnsigned(num, 0xFFFF); SBigFromUnsigned(num, 0xFFFF);
uint32_t len; uint32_t len;
SBigBitLen(num, &len); SBigBitLen(num, &len);
CHECK(len == 16); CHECK(len == 16);
SBigDel(num);
} }
SECTION("returns bit length of 0xFFFFFFFF") { SECTION("returns bit length of 0xFFFFFFFF") {
BigData* num;
SBigNew(&num);
SBigFromUnsigned(num, 0xFFFFFFFF); SBigFromUnsigned(num, 0xFFFFFFFF);
uint32_t len; uint32_t len;
SBigBitLen(num, &len); SBigBitLen(num, &len);
CHECK(len == 32); CHECK(len == 32);
SBigDel(num);
} }
SECTION("returns bit length of 0x22222222AAAAAAAA") { SECTION("returns bit length of 0x22222222AAAAAAAA") {
BigData* num;
SBigNew(&num);
uint64_t num_ = 0x22222222AAAAAAAA; uint64_t num_ = 0x22222222AAAAAAAA;
SBigFromBinary(num, reinterpret_cast<uint8_t*>(&num_), sizeof(num_)); SBigFromBinary(num, reinterpret_cast<uint8_t*>(&num_), sizeof(num_));
@ -192,25 +128,17 @@ TEST_CASE("SBigBitLen", "[big]") {
SBigBitLen(num, &len); SBigBitLen(num, &len);
CHECK(len == 62); CHECK(len == 62);
SBigDel(num);
} }
} }
TEST_CASE("SBigCompare", "[big]") { TEST_CASE("SBigCompare", "[big]") {
SECTION("compares 10 and 1") { BigDataTest a, b;
BigData* a;
SBigNew(&a);
SBigFromUnsigned(a, 10);
BigData* b; SECTION("compares 10 and 1") {
SBigNew(&b); SBigFromUnsigned(a, 10);
SBigFromUnsigned(b, 1); SBigFromUnsigned(b, 1);
CHECK(SBigCompare(a, b) == 1); CHECK(SBigCompare(a, b) == 1);
SBigDel(a);
SBigDel(b);
} }
} }
@ -319,29 +247,23 @@ TEST_CASE("SBigDiv", "[big]") {
} }
TEST_CASE("SBigFromBinary", "[big]") { TEST_CASE("SBigFromBinary", "[big]") {
BigDataTest num;
SECTION("creates bigdata from 0") { SECTION("creates bigdata from 0") {
BigData* num;
SBigNew(&num);
uint32_t data = 0; uint32_t data = 0;
SBigFromBinary(num, reinterpret_cast<uint8_t*>(&data), sizeof(data)); SBigFromBinary(num, reinterpret_cast<uint8_t*>(&data), sizeof(data));
CHECK(num->Primary().Count() == 1); CHECK(num->Primary().Count() == 1);
CHECK(num->Primary()[0] == 0); CHECK(num->Primary()[0] == 0);
SBigDel(num);
} }
SECTION("creates bigdata from 0x123456789ABCDEF0") { SECTION("creates bigdata from 0x123456789ABCDEF0") {
BigData* num;
SBigNew(&num);
uint64_t data = 0x123456789ABCDEF0; uint64_t data = 0x123456789ABCDEF0;
SBigFromBinary(num, reinterpret_cast<uint8_t*>(&data), sizeof(data)); SBigFromBinary(num, reinterpret_cast<uint8_t*>(&data), sizeof(data));
CHECK(num->Primary().Count() == 2); CHECK(num->Primary().Count() == 2);
CHECK(num->Primary()[0] == 0x9ABCDEF0); CHECK(num->Primary()[0] == 0x9ABCDEF0);
CHECK(num->Primary()[1] == 0x12345678); CHECK(num->Primary()[1] == 0x12345678);
SBigDel(num);
} }
} }
@ -372,26 +294,20 @@ TEST_CASE("SBigFromStr", "[big]") {
} }
TEST_CASE("SBigFromUnsigned", "[big]") { TEST_CASE("SBigFromUnsigned", "[big]") {
BigDataTest num;
SECTION("creates bigdata from 0") { SECTION("creates bigdata from 0") {
BigData* num;
SBigNew(&num);
SBigFromUnsigned(num, 0); SBigFromUnsigned(num, 0);
CHECK(num->Primary().Count() == 1); CHECK(num->Primary().Count() == 1);
CHECK(num->Primary()[0] == 0); CHECK(num->Primary()[0] == 0);
SBigDel(num);
} }
SECTION("creates bigdata from 0x12345678") { SECTION("creates bigdata from 0x12345678") {
BigData* num;
SBigNew(&num);
SBigFromUnsigned(num, 0x12345678); SBigFromUnsigned(num, 0x12345678);
CHECK(num->Primary().Count() == 1); CHECK(num->Primary().Count() == 1);
CHECK(num->Primary()[0] == 0x12345678); CHECK(num->Primary()[0] == 0x12345678);
SBigDel(num);
} }
} }
TEST_CASE("SBigInc", "[big]") { TEST_CASE("SBigInc", "[big]") {
@ -507,16 +423,9 @@ TEST_CASE("SBigIsZero", "[big]") {
} }
TEST_CASE("SBigMod", "[big]") { TEST_CASE("SBigMod", "[big]") {
BigDataTest a, b, c;
SECTION("mods 7 by 4") { SECTION("mods 7 by 4") {
BigData* a;
SBigNew(&a);
BigData* b;
SBigNew(&b);
SBigFromUnsigned(b, 7); SBigFromUnsigned(b, 7);
BigData* c;
SBigNew(&c);
SBigFromUnsigned(c, 4); SBigFromUnsigned(c, 4);
SBigMod(a, b, c); SBigMod(a, b, c);
@ -525,30 +434,14 @@ TEST_CASE("SBigMod", "[big]") {
CHECK(a->Primary().Count() == 1); CHECK(a->Primary().Count() == 1);
CHECK(a->Primary()[0] == 3); CHECK(a->Primary()[0] == 3);
SBigDel(a);
SBigDel(b);
SBigDel(c);
} }
SECTION("mods 7 by 4 then mods 9 by 5") { SECTION("mods 7 by 4 then mods 9 by 5") {
BigData* a; BigDataTest b1, c1, b2, c2;
SBigNew(&a);
BigData* b1;
SBigNew(&b1);
SBigFromUnsigned(b1, 7); SBigFromUnsigned(b1, 7);
BigData* c1;
SBigNew(&c1);
SBigFromUnsigned(c1, 4); SBigFromUnsigned(c1, 4);
BigData* b2;
SBigNew(&b2);
SBigFromUnsigned(b2, 9); SBigFromUnsigned(b2, 9);
BigData* c2;
SBigNew(&c2);
SBigFromUnsigned(c2, 5); SBigFromUnsigned(c2, 5);
SBigMod(a, b1, c1); SBigMod(a, b1, c1);
@ -564,25 +457,11 @@ TEST_CASE("SBigMod", "[big]") {
CHECK(a->Primary().Count() == 1); CHECK(a->Primary().Count() == 1);
CHECK(a->Primary()[0] == 4); CHECK(a->Primary()[0] == 4);
SBigDel(a);
SBigDel(b1);
SBigDel(c1);
SBigDel(b2);
SBigDel(c2);
} }
SECTION("mods 0x9999444488885555 by 0xFFFFFFFF") { SECTION("mods 0x9999444488885555 by 0xFFFFFFFF") {
BigData* a;
SBigNew(&a);
BigData* b;
SBigNew(&b);
uint64_t b_ = 0x9999444488885555; uint64_t b_ = 0x9999444488885555;
SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_)); SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
BigData* c;
SBigNew(&c);
SBigFromUnsigned(c, 0xFFFFFFFF); SBigFromUnsigned(c, 0xFFFFFFFF);
SBigMod(a, b, c); SBigMod(a, b, c);
@ -591,24 +470,14 @@ TEST_CASE("SBigMod", "[big]") {
CHECK(a->Primary().Count() == 1); CHECK(a->Primary().Count() == 1);
CHECK(a->Primary()[0] == 0x2221999A); CHECK(a->Primary()[0] == 0x2221999A);
SBigDel(a);
SBigDel(b);
SBigDel(c);
} }
} }
TEST_CASE("SBigMul", "[big]") { TEST_CASE("SBigMul", "[big]") {
BigDataTest a, b, c;
SECTION("multiplies 0 and 1") { SECTION("multiplies 0 and 1") {
BigData* a;
SBigNew(&a);
BigData* b;
SBigNew(&b);
SBigFromUnsigned(b, 0); SBigFromUnsigned(b, 0);
BigData* c;
SBigNew(&c);
SBigFromUnsigned(c, 1); SBigFromUnsigned(c, 1);
SBigMul(a, b, c); SBigMul(a, b, c);
@ -616,22 +485,10 @@ TEST_CASE("SBigMul", "[big]") {
a->Primary().Trim(); a->Primary().Trim();
CHECK(a->Primary().Count() == 0); CHECK(a->Primary().Count() == 0);
SBigDel(a);
SBigDel(b);
SBigDel(c);
} }
SECTION("multiplies 2 and 4") { SECTION("multiplies 2 and 4") {
BigData* a;
SBigNew(&a);
BigData* b;
SBigNew(&b);
SBigFromUnsigned(b, 2); SBigFromUnsigned(b, 2);
BigData* c;
SBigNew(&c);
SBigFromUnsigned(c, 4); SBigFromUnsigned(c, 4);
SBigMul(a, b, c); SBigMul(a, b, c);
@ -640,22 +497,10 @@ TEST_CASE("SBigMul", "[big]") {
CHECK(a->Primary().Count() == 1); CHECK(a->Primary().Count() == 1);
CHECK(a->Primary()[0] == 8); CHECK(a->Primary()[0] == 8);
SBigDel(a);
SBigDel(b);
SBigDel(c);
} }
SECTION("multiplies 0xFFFFFFFF and 0x100") { SECTION("multiplies 0xFFFFFFFF and 0x100") {
BigData* a;
SBigNew(&a);
BigData* b;
SBigNew(&b);
SBigFromUnsigned(b, 0xFFFFFFFF); SBigFromUnsigned(b, 0xFFFFFFFF);
BigData* c;
SBigNew(&c);
SBigFromUnsigned(c, 0x100); SBigFromUnsigned(c, 0x100);
SBigMul(a, b, c); SBigMul(a, b, c);
@ -665,22 +510,10 @@ TEST_CASE("SBigMul", "[big]") {
CHECK(a->Primary().Count() == 2); CHECK(a->Primary().Count() == 2);
CHECK(a->Primary()[0] == 0xFFFFFF00); CHECK(a->Primary()[0] == 0xFFFFFF00);
CHECK(a->Primary()[1] == 0xFF); CHECK(a->Primary()[1] == 0xFF);
SBigDel(a);
SBigDel(b);
SBigDel(c);
} }
SECTION("multiplies 0xFFFFFF and 0x11223344") { SECTION("multiplies 0xFFFFFF and 0x11223344") {
BigData* a;
SBigNew(&a);
BigData* b;
SBigNew(&b);
SBigFromUnsigned(b, 0xFFFFFF); SBigFromUnsigned(b, 0xFFFFFF);
BigData* c;
SBigNew(&c);
SBigFromUnsigned(c, 0x11223344); SBigFromUnsigned(c, 0x11223344);
SBigMul(a, b, c); SBigMul(a, b, c);
@ -690,28 +523,14 @@ TEST_CASE("SBigMul", "[big]") {
CHECK(a->Primary().Count() == 2); CHECK(a->Primary().Count() == 2);
CHECK(a->Primary()[0] == 0x32DDCCBC); CHECK(a->Primary()[0] == 0x32DDCCBC);
CHECK(a->Primary()[1] == 0x112233); CHECK(a->Primary()[1] == 0x112233);
SBigDel(a);
SBigDel(b);
SBigDel(c);
} }
} }
TEST_CASE("SBigPowMod", "[big]") { TEST_CASE("SBigPowMod", "[big]") {
BigDataTest a, b, c, d;
SECTION("takes 256 to the 8th power and mods the result by 999") { SECTION("takes 256 to the 8th power and mods the result by 999") {
BigData* a;
SBigNew(&a);
BigData* b;
SBigNew(&b);
SBigFromUnsigned(b, 256); SBigFromUnsigned(b, 256);
BigData* c;
SBigNew(&c);
SBigFromUnsigned(c, 8); SBigFromUnsigned(c, 8);
BigData* d;
SBigNew(&d);
SBigFromUnsigned(d, 999); SBigFromUnsigned(d, 999);
SBigPowMod(a, b, c, d); SBigPowMod(a, b, c, d);
@ -720,11 +539,6 @@ TEST_CASE("SBigPowMod", "[big]") {
CHECK(a->Primary().Count() == 1); CHECK(a->Primary().Count() == 1);
CHECK(a->Primary()[0] == 160); CHECK(a->Primary()[0] == 160);
SBigDel(a);
SBigDel(b);
SBigDel(c);
SBigDel(d);
} }
} }
@ -820,12 +634,9 @@ TEST_CASE("SBigOr", "[big]") {
} }
TEST_CASE("SBigShl", "[big]") { TEST_CASE("SBigShl", "[big]") {
SECTION("shifts 256 left 7 bits") { BigDataTest a, b;
BigData* a;
SBigNew(&a);
BigData* b; SECTION("shifts 256 left 7 bits") {
SBigNew(&b);
SBigFromUnsigned(b, 256); SBigFromUnsigned(b, 256);
SBigShl(a, b, 7); SBigShl(a, b, 7);
@ -834,19 +645,13 @@ TEST_CASE("SBigShl", "[big]") {
CHECK(a->Primary().Count() == 1); CHECK(a->Primary().Count() == 1);
CHECK(a->Primary()[0] == 32768); CHECK(a->Primary()[0] == 32768);
SBigDel(a);
SBigDel(b);
} }
} }
TEST_CASE("SBigShr", "[big]") { TEST_CASE("SBigShr", "[big]") {
SECTION("shifts 256 right 7 bits") { BigDataTest a, b;
BigData* a;
SBigNew(&a);
BigData* b; SECTION("shifts 256 right 7 bits") {
SBigNew(&b);
SBigFromUnsigned(b, 256); SBigFromUnsigned(b, 256);
SBigShr(a, b, 7); SBigShr(a, b, 7);
@ -855,19 +660,13 @@ TEST_CASE("SBigShr", "[big]") {
CHECK(a->Primary().Count() == 1); CHECK(a->Primary().Count() == 1);
CHECK(a->Primary()[0] == 2); CHECK(a->Primary()[0] == 2);
SBigDel(a);
SBigDel(b);
} }
} }
TEST_CASE("SBigSquare", "[big]") { TEST_CASE("SBigSquare", "[big]") {
SECTION("squares 0xFFFFFFFF") { BigDataTest a, b;
BigData* a;
SBigNew(&a);
BigData* b; SECTION("squares 0xFFFFFFFF") {
SBigNew(&b);
SBigFromUnsigned(b, 0xFFFFFFFF); SBigFromUnsigned(b, 0xFFFFFFFF);
SBigSquare(a, b); SBigSquare(a, b);
@ -877,9 +676,6 @@ TEST_CASE("SBigSquare", "[big]") {
CHECK(a->Primary().Count() == 2); CHECK(a->Primary().Count() == 2);
CHECK(a->Primary()[0] == 0x1); CHECK(a->Primary()[0] == 0x1);
CHECK(a->Primary()[1] == 0xFFFFFFFE); CHECK(a->Primary()[1] == 0xFFFFFFFE);
SBigDel(a);
SBigDel(b);
} }
} }
@ -910,9 +706,9 @@ TEST_CASE("SBigSub", "[big]") {
} }
TEST_CASE("SBigToBinaryBuffer", "[big]") { TEST_CASE("SBigToBinaryBuffer", "[big]") {
BigDataTest num;
SECTION("returns expected buffer for bigdata representing 0") { SECTION("returns expected buffer for bigdata representing 0") {
BigData* num;
SBigNew(&num);
SBigFromUnsigned(num, 0); SBigFromUnsigned(num, 0);
uint8_t buffer[4]; uint8_t buffer[4];
@ -920,13 +716,9 @@ TEST_CASE("SBigToBinaryBuffer", "[big]") {
SBigToBinaryBuffer(num, buffer, sizeof(buffer), &bytes); SBigToBinaryBuffer(num, buffer, sizeof(buffer), &bytes);
REQUIRE(bytes == 0); REQUIRE(bytes == 0);
SBigDel(num);
} }
SECTION("returns expected buffer for bigdata representing 0x12345678") { SECTION("returns expected buffer for bigdata representing 0x12345678") {
BigData* num;
SBigNew(&num);
SBigFromUnsigned(num, 0x12345678); SBigFromUnsigned(num, 0x12345678);
uint8_t buffer[4]; uint8_t buffer[4];
@ -935,13 +727,9 @@ TEST_CASE("SBigToBinaryBuffer", "[big]") {
CHECK(bytes == 4); CHECK(bytes == 4);
CHECK(*reinterpret_cast<uint32_t*>(buffer) == 0x12345678); CHECK(*reinterpret_cast<uint32_t*>(buffer) == 0x12345678);
SBigDel(num);
} }
SECTION("returns expected buffer for bigdata representing 0x123456789ABCDEF0") { SECTION("returns expected buffer for bigdata representing 0x123456789ABCDEF0") {
BigData* num;
SBigNew(&num);
uint64_t data = 0x123456789ABCDEF0; uint64_t data = 0x123456789ABCDEF0;
SBigFromBinary(num, reinterpret_cast<uint8_t*>(&data), sizeof(data)); SBigFromBinary(num, reinterpret_cast<uint8_t*>(&data), sizeof(data));
@ -951,7 +739,5 @@ TEST_CASE("SBigToBinaryBuffer", "[big]") {
CHECK(bytes == 8); CHECK(bytes == 8);
CHECK(*reinterpret_cast<uint64_t*>(buffer) == 0x123456789ABCDEF0); CHECK(*reinterpret_cast<uint64_t*>(buffer) == 0x123456789ABCDEF0);
SBigDel(num);
} }
} }

570
test/big/Ops.cpp
View file

File diff suppressed because it is too large Load diff