leonetienne/GeneralUtility
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Abstracted StringDivision to work with arbitrary containers and digit-types

Browse Source
This commit is contained in:
Leonetienne
2022-02-27 18:56:20 +01:00
parent 1903f19b96
commit 63400955af
5 changed files with 258 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Test/CMakeLists.txt
View File

@@ -11,7 +11,7 @@ add_executable(Test
main.cpp
Ord.cpp
StringDivision.cpp
DigitstringDivision.cpp
BaseX_2_10.cpp
Base10_2_X.cpp
BaseX_2_Y.cpp

187
Test/DigitstringDivision.cpp Normal file
View File

@@ -0,0 +1,187 @@
#include <GeneralUtility.h>
#include "Catch2.h"
#include <string>
#include <vector>
#include <time.h>
#include <sstream>
#include <stdexcept>
// Tests that basic division (base10) is working, with oracle values
TEST_CASE(__FILE__"/Base10", "[DigitstringDivision]")
{
const std::string set = "0123456789";
SECTION("No rest") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("200", 10, set);
REQUIRE(res.first == "20");
REQUIRE(res.second == 0);
}
SECTION("With rest") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("205", 10, set);
REQUIRE(res.first == "20");
REQUIRE(res.second == 5);
}
SECTION("With rest, and divisor > dividend") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("205", 299, set);
REQUIRE(res.first == "0");
REQUIRE(res.second == 205);
}
}
// Tests that basic division (base10) is working, by doing a lot of random, precalculated divisions
TEST_CASE(__FILE__"/Base10_Randoms", "[DigitstringDivision]")
{
srand(time(0));
const std::string set = "0123456789";
// Test 1000 random numbers
for (std::size_t i = 0; i < 1000; i++) {
// Generate random input
const std::uint64_t i_dividend = rand();
const std::uint32_t i_divisor = rand() % 1000000;
// Precalculate expected output
const std::uint32_t expected_result = i_dividend / i_divisor;
const std::uint32_t expected_rest = i_dividend % i_divisor;
// Convert dividend to a string
std::stringstream ss;
ss << i_dividend;
const std::string dividend = ss.str();
// Compute results
const auto res = GeneralUtility::DigitstringDivision(dividend, i_divisor, set);
const std::uint32_t actual_result = std::stoi(res.first);
const std::uint32_t actual_rest = res.second;
// Assertions
REQUIRE(actual_result == expected_result);
REQUIRE(actual_rest == expected_rest);
}
}
// Tests that base16 division is working, with oracle values
TEST_CASE(__FILE__"/Base16", "[DigitstringDivision]")
{
const std::string set = "0123456789abcdef";
SECTION("No rest") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("1f4", 10, set);
REQUIRE(res.first == "32");
REQUIRE(res.second == 0);
}
SECTION("With rest") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("1fd", 10, set);
REQUIRE(res.first == "32");
REQUIRE(res.second == 9);
}
SECTION("With rest, and divisor > dividend") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("1f4", 999, set);
REQUIRE(res.first == "0");
REQUIRE(res.second == 500);
}
}
// Tests that base2 division is working, with oracle values
TEST_CASE(__FILE__"/Base2", "[DigitstringDivision]")
{
const std::string set = "01";
SECTION("No rest") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("111110100", 10, set);
REQUIRE(res.first == "110010");
REQUIRE(res.second == 0);
}
SECTION("With rest") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("111111011", 10, set);
REQUIRE(res.first == "110010");
REQUIRE(res.second == 7);
}
SECTION("With rest, and divisor > dividend") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("111110100", 599, set);
REQUIRE(res.first == "0");
REQUIRE(res.second == 500);
}
}
// Tests that fucking big bases are working, with oracle values
TEST_CASE(__FILE__"/BaseFuckingBig", "[DigitstringDivision]")
{
const std::string set = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
SECTION("No rest") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("9RieQV", 29915, set);
REQUIRE(res.first == "1DGL");
REQUIRE(res.second == 0);
}
SECTION("With rest") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("9RieQZ", 29915, set);
REQUIRE(res.first == "1DGL");
REQUIRE(res.second == 4);
}
SECTION("With rest, and divisor > dividend") {
const auto res = GeneralUtility::DigitstringDivision<std::string>("8x", 600, set);
REQUIRE(res.first == "0");
REQUIRE(res.second == 555);
}
}
// Tests that having a dividend of size 0 returns 0
TEST_CASE(__FILE__"/DividendLengthZero", "[DigitstringDivision]")
{
const auto& res = GeneralUtility::DigitstringDivision<std::string>("", 19, "0123456789");
REQUIRE(res.first == "0");
REQUIRE(res.second == 0);
}
// Tests that a division by zero exception is thrown when appropriate
TEST_CASE(__FILE__"/DivisionByZero", "[DigitstringDivision]")
{
REQUIRE_THROWS_AS(
GeneralUtility::DigitstringDivision<std::string>("699", 0, "0123456789")
, std::overflow_error);
}
// Tests that a logic error is thrown when the supplied set is empty
TEST_CASE(__FILE__"/NoSetSupplied", "[DigitstringDivision]")
{
REQUIRE_THROWS_AS(
GeneralUtility::DigitstringDivision<std::string>("699", 5, "")
, std::logic_error);
}
// Tests that a logic error is thrown if the dividend contains a character not present in the set
TEST_CASE(__FILE__"/InvalidDigitsInDividend", "[DigitstringDivision]")
{
REQUIRE_THROWS_AS(
GeneralUtility::DigitstringDivision<std::string>("699z", 5, "0123465789")
, std::logic_error);
}
// Tests that weird, abstract bases are working, with oracle values
TEST_CASE(__FILE__"/BaseWeird", "[DigitstringDivision]")
{
const std::vector<std::string> set = { "apple", "apricot", "avocado", "banana", "bell pepper", "bilberry" };
SECTION("No rest") {
const auto res = GeneralUtility::DigitstringDivision<std::vector<std::string>>({"apricot", "bilberry", "bell pepper"}, 10, set);
REQUIRE(res.first == std::vector<std::string>({"apricot", "apricot"}));
REQUIRE(res.second == 0);
}
SECTION("With rest") {
const auto res = GeneralUtility::DigitstringDivision<std::vector<std::string>>({"avocado", "apple", "banana"}, 10, set);
REQUIRE(res.first == std::vector<std::string>({"apricot", "apricot"}));
REQUIRE(res.second == 5);
}
SECTION("With rest, and divisor > dividend") {
const auto res = GeneralUtility::DigitstringDivision<std::vector<std::string>>({"apricot", "bilberry", "bell pepper"}, 100, set);
REQUIRE(res.first == std::vector<std::string>({"apple"}));
REQUIRE(res.second == 70);
}
}

149
Test/StringDivision.cpp
View File

@@ -1,149 +0,0 @@
#include <GeneralUtility.h>
#include "Catch2.h"
#include <string>
#include <vector>
#include <time.h>
#include <sstream>
#include <stdexcept>
// Tests that basic division (base10) is working, with oracle values
TEST_CASE(__FILE__"/Base10", "[StringDivision]")
{
const std::string set = "0123456789";
SECTION("No rest") {
const auto res = GeneralUtility::StringDivision("200", 10, set);
REQUIRE(res.first == "20");
REQUIRE(res.second == 0);
}
SECTION("With rest") {
const auto res = GeneralUtility::StringDivision("205", 10, set);
REQUIRE(res.first == "20");
REQUIRE(res.second == 5);
}
SECTION("With rest, and divisor > dividend") {
const auto res = GeneralUtility::StringDivision("205", 299, set);
REQUIRE(res.first == "0");
REQUIRE(res.second == 205);
}
}
// Tests that basic division (base10) is working, by doing a lot of random, precalculated divisions
TEST_CASE(__FILE__"/Base10_Randoms", "[StringDivision]")
{
srand(time(0));
const std::string set = "0123456789";
// Test 1000 random numbers
for (std::size_t i = 0; i < 1000; i++) {
// Generate random input
const std::uint64_t i_dividend = rand();
const std::uint32_t i_divisor = rand() % 1000000;
// Precalculate expected output
const std::uint32_t expected_result = i_dividend / i_divisor;
const std::uint32_t expected_rest = i_dividend % i_divisor;
// Convert dividend to a string
std::stringstream ss;
ss << i_dividend;
const std::string dividend = ss.str();
// Compute results
const auto res = GeneralUtility::StringDivision(dividend, i_divisor, set);
const std::uint32_t actual_result = std::stoi(res.first);
const std::uint32_t actual_rest = res.second;
// Assertions
REQUIRE(actual_result == expected_result);
REQUIRE(actual_rest == expected_rest);
}
}
// Tests that base16 division is working, with oracle values
TEST_CASE(__FILE__"/Base16", "[StringDivision]")
{
const std::string set = "0123456789abcdef";
SECTION("No rest") {
const auto res = GeneralUtility::StringDivision("1f4", 10, set);
REQUIRE(res.first == "32");
REQUIRE(res.second == 0);
}
SECTION("With rest") {
const auto res = GeneralUtility::StringDivision("1fd", 10, set);
REQUIRE(res.first == "32");
REQUIRE(res.second == 9);
}
SECTION("With rest, and divisor > dividend") {
const auto res = GeneralUtility::StringDivision("1f4", 999, set);
REQUIRE(res.first == "0");
REQUIRE(res.second == 500);
}
}
// Tests that base2 division is working, with oracle values
TEST_CASE(__FILE__"/Base2", "[StringDivision]")
{
const std::string set = "01";
SECTION("No rest") {
const auto res = GeneralUtility::StringDivision("111110100", 10, set);
REQUIRE(res.first == "110010");
REQUIRE(res.second == 0);
}
SECTION("With rest") {
const auto res = GeneralUtility::StringDivision("111111011", 10, set);
REQUIRE(res.first == "110010");
REQUIRE(res.second == 7);
}
SECTION("With rest, and divisor > dividend") {
const auto res = GeneralUtility::StringDivision("111110100", 599, set);
REQUIRE(res.first == "0");
REQUIRE(res.second == 500);
}
}
// Tests that fucking big bases are working, with oracle values
TEST_CASE(__FILE__"/BaseFuckingBig", "[StringDivision]")
{
const std::string set = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
SECTION("No rest") {
const auto res = GeneralUtility::StringDivision("9RieQV", 29915, set);
REQUIRE(res.first == "1DGL");
REQUIRE(res.second == 0);
}
SECTION("With rest") {
const auto res = GeneralUtility::StringDivision("9RieQZ", 29915, set);
REQUIRE(res.first == "1DGL");
REQUIRE(res.second == 4);
}
SECTION("With rest, and divisor > dividend") {
const auto res = GeneralUtility::StringDivision("8x", 600, set);
REQUIRE(res.first == "0");
REQUIRE(res.second == 555);
}
}
// Tests that a division by zero exception is thrown when appropriate
TEST_CASE(__FILE__"/DivisionByZero", "[StringDivision]")
{
REQUIRE_THROWS_AS(
GeneralUtility::StringDivision("699", 0)
, std::overflow_error);
}
// Tests that a logic error is thrown when the supplied set is empty
TEST_CASE(__FILE__"/NoSetSupplied", "[StringDivision]")
{
REQUIRE_THROWS_AS(
GeneralUtility::StringDivision("699", 5, "")
, std::logic_error);
}