File Coverage

t/to_chars.cc

Criterion	Covered	Total	%
statement	31	53	58.4
branch	634	1750	36.2
condition			n/a
subroutine			n/a
pod			n/a
total	665	1803	36.8

#include "test.h"
#include
#include

using panda::string;

struct Exc : std::exception {};

template  struct nstr;
template <> struct nstr {
    static string min () { return "-128"; }
    static string max () { return "127"; }
};
template <> struct nstr {
    static string min () { return "0"; }
    static string max () { return "255"; }
};
template <> struct nstr {
    static string min () { return "-32768"; }
    static string max () { return "32767"; }
};
template <> struct nstr {
    static string min () { return "0"; }
    static string max () { return "65535"; }
};
template <> struct nstr {
    static string min () { return "-2147483648"; }
    static string max () { return "2147483647"; }
};
template <> struct nstr {
    static string min () { return "0"; }
    static string max () { return "4294967295"; }
};
template <> struct nstr {
    static string min () { return "-9223372036854775808"; }
    static string max () { return "9223372036854775807"; }
};
template <> struct nstr {
    static string min () { return "0"; }
    static string max () { return "18446744073709551615"; }
};

template
string tci (Int val, int base = 10, size_t buflen = 100) {
    string s;
    char* buf = s.reserve(buflen);
    char* bufend = buf + buflen;
    auto res = panda::to_chars(buf, bufend, val, base);
    s.length(res.ptr - buf);
    if (res.ec) throw Exc();
    return s;
}

template ::is_signed>
struct test_sign_dependent;

template
struct test_sign_dependent {
    static void run () {
        SECTION("negative number") {
            REQUIRE(tci(-99) == "-99");
        }

        SECTION("no space") {
            REQUIRE_THROWS_AS(tci(-123, 10, 3), Exc);
        }

        SECTION("min") {
            REQUIRE(tci(std::numeric_limits::min()) == nstr::min());
        }
    }
};

template
struct test_sign_dependent {
    static void run () {}
};

template
void to_chars_test() {
    SECTION("positive number") {
        REQUIRE(tci(12) == "12");
    }

    SECTION("zero") {
        REQUIRE(tci(0) == "0");
    }

    SECTION("max") {
        REQUIRE(tci(std::numeric_limits::max()) == nstr::max());
    }

    SECTION("8-base") {
        REQUIRE(tci(10, 8) == "12");
    }

    SECTION("16-base") {
        REQUIRE(tci(10, 16) == "a");
    }

    SECTION("no space") {
        REQUIRE_THROWS_AS(tci(123, 10, 2), Exc);
    }

    test_sign_dependent::run();
}

TEST_CASE("to_chars int8_t",   "[to_chars]") { to_chars_test(); }
TEST_CASE("to_chars int16_t",  "[to_chars]") { to_chars_test(); }
TEST_CASE("to_chars int32_t",  "[to_chars]") { to_chars_test(); }
TEST_CASE("to_chars int64_t",  "[to_chars]") { to_chars_test(); }
TEST_CASE("to_chars uint8_t",  "[to_chars]") { to_chars_test(); }
TEST_CASE("to_chars uint16_t", "[to_chars]") { to_chars_test(); }
TEST_CASE("to_chars uint32_t", "[to_chars]") { to_chars_test(); }
TEST_CASE("to_chars uint64_t", "[to_chars]") { to_chars_test(); }