test/bej_common_test.cpp

#include "bej_common.h"

#include <float.h>

#include <gmock/gmock-matchers.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

namespace libbej
{

TEST(BejCommonTest, BejGetUnsignedIntegerTest)
{
    constexpr uint8_t bytes[] = {0xab, 0xcd, 0xef, 0x12,
                                 0x13, 0x65, 0x23, 0x89};
    EXPECT_THAT(bejGetUnsignedInteger(bytes, /*numOfBytes=*/1), 0xab);
    EXPECT_THAT(bejGetUnsignedInteger(bytes, /*numOfBytes=*/2), 0xcdab);
    EXPECT_THAT(bejGetUnsignedInteger(bytes, /*numOfBytes=*/5), 0x1312efcdab);
    EXPECT_THAT(bejGetUnsignedInteger(bytes, /*numOfBytes=*/8),
                0x8923651312efcdab);
}

TEST(BejCommonTest, BejGetNnintTest)
{
    constexpr uint8_t nnint1[] = {0x03, 0xcd, 0xef, 0x12};
    constexpr uint8_t nnint2[] = {0x08, 0xab, 0xcd, 0xef, 0x12,
                                  0x13, 0x65, 0x23, 0x89};
    EXPECT_THAT(bejGetNnint(nnint1), 0x12efcd);
    EXPECT_THAT(bejGetNnint(nnint2), 0x8923651312efcdab);
}

TEST(BejCommonTest, BejGetNnintSizeTest)
{
    constexpr uint8_t nnint1[] = {0x03, 0xcd, 0xef, 0x12};
    constexpr uint8_t nnint2[] = {0x08, 0xab, 0xcd, 0xef, 0x12,
                                  0x13, 0x65, 0x23, 0x89};
    EXPECT_THAT(bejGetNnintSize(nnint1), 4);
    EXPECT_THAT(bejGetNnintSize(nnint2), 9);
}

TEST(BejCommonTest, BejGetDoubleFromBejReal)
{
    BejReal real;
    double output;

    real.valid_exp = false;
    real.exp = 0;
    real.whole = 1;
    real.zeroCount = 3;
    real.fract = 525;
    EXPECT_EQ(bejGetDoubleFromBejReal(&real, &output), 0);
    EXPECT_DOUBLE_EQ(output, 1.000525);

    real.valid_exp = false;
    real.exp = 0;
    real.whole = 225;
    real.zeroCount = 3;
    real.fract = 0;
    EXPECT_EQ(bejGetDoubleFromBejReal(&real, &output), 0);
    EXPECT_DOUBLE_EQ(output, 225);

    real.valid_exp = false;
    real.exp = 0;
    real.whole = 0;
    real.zeroCount = 0;
    real.fract = 1;
    EXPECT_EQ(bejGetDoubleFromBejReal(&real, &output), 0);
    EXPECT_DOUBLE_EQ(output, 0.1);

    real.valid_exp = false;
    real.exp = 0;
    real.whole = 0;
    real.zeroCount = 5;
    real.fract = 1024;
    EXPECT_EQ(bejGetDoubleFromBejReal(&real, &output), 0);
    EXPECT_DOUBLE_EQ(output, 0.000001024);

    real.valid_exp = false;
    real.exp = 0;
    real.whole = 0;
    real.zeroCount = 0;
    real.fract = 0;
    EXPECT_EQ(bejGetDoubleFromBejReal(&real, &output), 0);
    EXPECT_DOUBLE_EQ(output, 0);

    real.valid_exp = false;
    real.exp = 0;
    real.whole = -1;
    real.zeroCount = 3;
    real.fract = 345;
    EXPECT_EQ(bejGetDoubleFromBejReal(&real, &output), 0);
    EXPECT_DOUBLE_EQ(output, -1.000345);

    real.valid_exp = false;
    real.exp = 0;
    real.whole = -1;
    real.zeroCount = 3;
    real.fract = UINT64_MAX;
    EXPECT_EQ(bejGetDoubleFromBejReal(&real, &output), 0);
    EXPECT_DOUBLE_EQ(output, -1.00018446744073709551615);

    real.valid_exp = false;
    real.exp = 0;
    real.whole = 1;
    real.zeroCount = 19;
    real.fract = UINT64_MAX;
    EXPECT_EQ(bejGetDoubleFromBejReal(&real, &output), 0);
    EXPECT_DOUBLE_EQ(output, 1.000000000000000000018446744073709551615);
}

TEST(BejCommonTest, BejGetDoubleFromBejRealWithExp)
{
    BejReal real;
    double output;
    real.valid_exp = true;
    real.exp = -1;
    real.whole = -2;
    real.zeroCount = 0;
    real.fract = 56;
    EXPECT_EQ(bejGetDoubleFromBejReal(&real, &output), 0);
    EXPECT_DOUBLE_EQ(output, -0.256);
}

TEST(BejCommonTest, BejGetDoubleFromBejRealWithTooLargeExp)
{
    BejReal real;
    double output;

    real.valid_exp = true;
    real.exp = std::log10(DBL_MAX) + 1;
    real.whole = 1;
    real.zeroCount = 3;
    real.fract = 525;
    EXPECT_NE(bejGetDoubleFromBejReal(&real, &output), 0);
}

TEST(BejCommonTest, BejGetDoubleFromBejRealWithTooLargeValue)
{
    BejReal real;
    double output;

    real.valid_exp = true;
    real.exp = std::log10(DBL_MAX);
    real.whole = 10;
    real.zeroCount = 3;
    real.fract = 525;
    EXPECT_NE(bejGetDoubleFromBejReal(&real, &output), 0);
}

TEST(BejCommonTest, BejGetDoubleFromBejRealZeroCountFail)
{
    BejReal real;
    double output;

    real.valid_exp = false;
    real.exp = 0;
    real.whole = 1;
    real.zeroCount = 20;
    real.fract = 525;
    EXPECT_NE(bejGetDoubleFromBejReal(&real, &output), 0);
}

} // namespace libbej