TestMathLib() : TestFixture("TestMathLib") {

}

void run() OVERRIDE {

TEST_CASE(isint);

TEST_CASE(isbin);

TEST_CASE(isdec);

TEST_CASE(isoct);

TEST_CASE(isFloatHex);

TEST_CASE(isIntHex);

TEST_CASE(isValidIntegerSuffix);

TEST_CASE(isnegative);

TEST_CASE(ispositive);

TEST_CASE(isFloat);

TEST_CASE(isDecimalFloat);

TEST_CASE(isGreater);

TEST_CASE(isGreaterEqual);

TEST_CASE(isEqual);

TEST_CASE(isNotEqual);

TEST_CASE(isLess);

TEST_CASE(isLessEqual);

TEST_CASE(calculate);

TEST_CASE(calculate1);

TEST_CASE(typesuffix);

TEST_CASE(toLongNumber);

TEST_CASE(toDoubleNumber);

TEST_CASE(naninf);

TEST_CASE(isNullValue);

TEST_CASE(incdec);

TEST_CASE(sin);

TEST_CASE(cos);

TEST_CASE(tan);

TEST_CASE(abs);

TEST_CASE(toString);

TEST_CASE(characterLiteralsNormalization);

TEST_CASE(CPP14DigitSeparators);

}

void isGreater() const {

ASSERT_EQUALS(true, MathLib::isGreater("1.0", "0.001"));

ASSERT_EQUALS(false, MathLib::isGreater("-1.0", "0.001"));

}

void isGreaterEqual() const {

ASSERT_EQUALS(true, MathLib::isGreaterEqual("1.00", "1.0"));

ASSERT_EQUALS(true, MathLib::isGreaterEqual("1.001", "1.0"));

ASSERT_EQUALS(true, MathLib::isGreaterEqual("1.0", "0.001"));

ASSERT_EQUALS(false, MathLib::isGreaterEqual("-1.0", "0.001"));

}

void isEqual() const {

ASSERT_EQUALS(true, MathLib::isEqual("1.0", "1.0"));

ASSERT_EQUALS(false, MathLib::isEqual("1.", "1.01"));

ASSERT_EQUALS(true, MathLib::isEqual("0.1","1.0E-1"));

}

void isNotEqual() const {

ASSERT_EQUALS(false, MathLib::isNotEqual("1.0", "1.0"));

ASSERT_EQUALS(true, MathLib::isNotEqual("1.", "1.01"));

}

void isLess() const {

ASSERT_EQUALS(false, MathLib::isLess("1.0", "0.001"));

ASSERT_EQUALS(true, MathLib::isLess("-1.0", "0.001"));

}

void isLessEqual() const {

ASSERT_EQUALS(true, MathLib::isLessEqual("1.00", "1.0"));

ASSERT_EQUALS(false, MathLib::isLessEqual("1.001", "1.0"));

ASSERT_EQUALS(false, MathLib::isLessEqual("1.0", "0.001"));

ASSERT_EQUALS(true, MathLib::isLessEqual("-1.0", "0.001"));

}

void calculate() const {

// addition

ASSERT_EQUALS("256", MathLib::add("0xff", "1"));

ASSERT_EQUALS("249", MathLib::add("250", "-1"));

ASSERT_EQUALS("251", MathLib::add("250", "1"));

ASSERT_EQUALS("-2.0", MathLib::add("-1.", "-1"));

ASSERT_EQUALS("-1", MathLib::add("0", "-1"));

ASSERT_EQUALS("1", MathLib::add("1", "0"));

ASSERT_EQUALS("0.0", MathLib::add("0", "0."));

ASSERT_EQUALS("1.00000001", MathLib::add("1", "0.00000001")); // #4016

ASSERT_EQUALS("30666.22", MathLib::add("30666.22", "0.0")); // #4068

// subtraction

ASSERT_EQUALS("254", MathLib::subtract("0xff", "1"));

ASSERT_EQUALS("251", MathLib::subtract("250", "-1"));

ASSERT_EQUALS("249", MathLib::subtract("250", "1"));

ASSERT_EQUALS("0.0", MathLib::subtract("-1.", "-1"));

ASSERT_EQUALS("1", MathLib::subtract("0", "-1"));

ASSERT_EQUALS("1", MathLib::subtract("1", "0"));

ASSERT_EQUALS("0.0", MathLib::subtract("0", "0."));

ASSERT_EQUALS("0.99999999", MathLib::subtract("1", "0.00000001")); // #4016

ASSERT_EQUALS("30666.22", MathLib::subtract("30666.22", "0.0")); // #4068

ASSERT_EQUALS("0.0", MathLib::subtract("0.0", "0.0"));

// multiply

ASSERT_EQUALS("-0.003", MathLib::multiply("-1e-3", "3"));

ASSERT_EQUALS("-11.96", MathLib::multiply("-2.3", "5.2"));

ASSERT_EQUALS("3000.0", MathLib::multiply("1E3", "3"));

ASSERT_EQUALS("3000.0", MathLib::multiply("1E+3", "3"));

ASSERT_EQUALS("3000.0", MathLib::multiply("1.0E3", "3"));

ASSERT_EQUALS("-3000.0", MathLib::multiply("-1.0E3", "3"));

ASSERT_EQUALS("-3000.0", MathLib::multiply("-1.0E+3", "3"));

ASSERT_EQUALS("0.0", MathLib::multiply("+1.0E+3", "0"));

ASSERT_EQUALS("2147483648", MathLib::multiply("2","1073741824"));

ASSERT_EQUALS("536870912", MathLib::multiply("512","1048576"));

// divide

ASSERT_EQUALS("1", MathLib::divide("1", "1"));

ASSERT_EQUALS("0", MathLib::divide("0", "1"));

ASSERT_EQUALS("5", MathLib::divide("-10", "-2"));

ASSERT_EQUALS("-2.5", MathLib::divide("-10.", "4"));

ASSERT_EQUALS("2.5", MathLib::divide("-10.", "-4"));

ASSERT_EQUALS("5.0", MathLib::divide("25.5", "5.1"));

ASSERT_EQUALS("7.0", MathLib::divide("21.", "3"));

ASSERT_EQUALS("1", MathLib::divide("3", "2"));

ASSERT_THROW(MathLib::divide("123", "0"), InternalError); // decimal zero: throw

ASSERT_THROW(MathLib::divide("123", "00"), InternalError); // octal zero: throw

ASSERT_THROW(MathLib::divide("123", "0x0"), InternalError); // hex zero: throw

MathLib::divide("123", "0.0f"); // float zero: don't throw

MathLib::divide("123", "0.0"); // double zero: don't throw

MathLib::divide("123", "0.0L"); // long double zero: don't throw

ASSERT_THROW(MathLib::divide("-9223372036854775808", "-1"), InternalError); // #4520 - out of range => throw

ASSERT_EQUALS("4611686018427387904", MathLib::divide("-9223372036854775808", "-2")); // #6679

// invoke for each supported action

ASSERT_EQUALS("3", MathLib::calculate("2", "1", '+'));

ASSERT_EQUALS("1", MathLib::calculate("2", "1", '-'));

ASSERT_EQUALS("2", MathLib::calculate("2", "1", '*'));

ASSERT_EQUALS("2", MathLib::calculate("2", "1", '/'));

ASSERT_EQUALS("0", MathLib::calculate("2", "1", '%'));

ASSERT_EQUALS("0", MathLib::calculate("1", "2", '&'));

ASSERT_EQUALS("1", MathLib::calculate("1", "1", '|'));

ASSERT_EQUALS("1", MathLib::calculate("0", "1", '^'));

// Unknown action should throw exception

ASSERT_THROW(MathLib::calculate("1","2",'j'),InternalError);

}

void calculate1() const {

ASSERT_EQUALS("0", MathLib::calculate("2", "1", '%'));

ASSERT_EQUALS("2", MathLib::calculate("12", "5", '%'));

ASSERT_EQUALS("1", MathLib::calculate("100", "3", '%'));

#ifndef TEST_MATHLIB_VALUE

// floating point modulo is not defined in C/C++

ASSERT_EQUALS("0.0", MathLib::calculate("2.0", "1.0", '%'));

ASSERT_EQUALS("12.0", MathLib::calculate("12.0", "13.0", '%'));

ASSERT_EQUALS("1.3", MathLib::calculate("5.3", "2.0", '%'));

ASSERT_EQUALS("1.7", MathLib::calculate("18.5", "4.2", '%'));

MathLib::calculate("123", "0.0", '%'); // don't throw

#endif

ASSERT_THROW(MathLib::calculate("123", "0", '%'), InternalError); // throw

ASSERT_EQUALS("0", MathLib::calculate("1", "1", '^'));

ASSERT_EQUALS("3", MathLib::calculate("2", "1", '^'));

}

void typesuffix() const {

ASSERT_EQUALS("2", MathLib::add("1", "1"));

ASSERT_EQUALS("2U", MathLib::add("1U", "1"));

ASSERT_EQUALS("2L", MathLib::add("1L", "1"));

ASSERT_EQUALS("2UL", MathLib::add("1UL", "1"));

ASSERT_EQUALS("2LL", MathLib::add("1LL", "1"));

ASSERT_EQUALS("2LL", MathLib::add("1i64", "1"));

ASSERT_EQUALS("2ULL", MathLib::add("1ULL", "1"));

ASSERT_EQUALS("2ULL", MathLib::add("1ui64","1"));

ASSERT_EQUALS("2U", MathLib::add("1", "1U"));

ASSERT_EQUALS("2U", MathLib::add("1U", "1U"));

ASSERT_EQUALS("2L", MathLib::add("1L", "1U"));

ASSERT_EQUALS("2UL", MathLib::add("1UL", "1U"));

ASSERT_EQUALS("2LL", MathLib::add("1LL", "1U"));

ASSERT_EQUALS("2ULL", MathLib::add("1ULL", "1U"));

ASSERT_EQUALS("2L", MathLib::add("1", "1L"));

ASSERT_EQUALS("2L", MathLib::add("1U", "1L"));

ASSERT_EQUALS("2L", MathLib::add("1L", "1L"));

ASSERT_EQUALS("2UL", MathLib::add("1UL", "1L"));

ASSERT_EQUALS("2LL", MathLib::add("1LL", "1L"));

ASSERT_EQUALS("2ULL", MathLib::add("1ULL", "1L"));

ASSERT_EQUALS("2UL", MathLib::add("1", "1UL"));

ASSERT_EQUALS("2UL", MathLib::add("1U", "1UL"));

ASSERT_EQUALS("2UL", MathLib::add("1L", "1UL"));

ASSERT_EQUALS("2UL", MathLib::add("1UL", "1UL"));

ASSERT_EQUALS("2LL", MathLib::add("1LL", "1UL"));

ASSERT_EQUALS("2ULL", MathLib::add("1ULL", "1UL"));

ASSERT_EQUALS("2UL", MathLib::add("1", "1LU"));

ASSERT_EQUALS("2UL", MathLib::add("1U", "1LU"));

ASSERT_EQUALS("2UL", MathLib::add("1L", "1LU"));

ASSERT_EQUALS("2UL", MathLib::add("1UL", "1LU"));

ASSERT_EQUALS("2LL", MathLib::add("1LL", "1LU"));

ASSERT_EQUALS("2ULL", MathLib::add("1ULL", "1LU"));

ASSERT_EQUALS("2LL", MathLib::add("1", "1LL"));

ASSERT_EQUALS("2LL", MathLib::add("1U", "1LL"));

ASSERT_EQUALS("2LL", MathLib::add("1L", "1LL"));

ASSERT_EQUALS("2LL", MathLib::add("1UL", "1LL"));

ASSERT_EQUALS("2LL", MathLib::add("1LL", "1LL"));

ASSERT_EQUALS("2ULL", MathLib::add("1ULL", "1LL"));

ASSERT_EQUALS("2ULL", MathLib::add("1", "1ULL"));

ASSERT_EQUALS("2ULL", MathLib::add("1U", "1ULL"));

ASSERT_EQUALS("2ULL", MathLib::add("1L", "1ULL"));

ASSERT_EQUALS("2ULL", MathLib::add("1UL", "1ULL"));

ASSERT_EQUALS("2ULL", MathLib::add("1LL", "1ULL"));

ASSERT_EQUALS("2ULL", MathLib::add("1ULL", "1ULL"));

ASSERT_EQUALS("2ULL", MathLib::add("1", "1LLU"));

ASSERT_EQUALS("2ULL", MathLib::add("1U", "1LLU"));

ASSERT_EQUALS("2ULL", MathLib::add("1L", "1LLU"));

ASSERT_EQUALS("2ULL", MathLib::add("1UL", "1LLU"));

ASSERT_EQUALS("2ULL", MathLib::add("1LL", "1LLU"));

ASSERT_EQUALS("2ULL", MathLib::add("1ULL", "1LLU"));

}

void toLongNumber() const {

// from hex

ASSERT_EQUALS(0, MathLib::toLongNumber("0x0"));

ASSERT_EQUALS(0, MathLib::toLongNumber("-0x0"));

ASSERT_EQUALS(0, MathLib::toLongNumber("+0x0"));

ASSERT_EQUALS(10, MathLib::toLongNumber("0xa"));

ASSERT_EQUALS(10995, MathLib::toLongNumber("0x2AF3"));

ASSERT_EQUALS(-10, MathLib::toLongNumber("-0xa"));

ASSERT_EQUALS(-10995, MathLib::toLongNumber("-0x2AF3"));

ASSERT_EQUALS(10, MathLib::toLongNumber("+0xa"));

ASSERT_EQUALS(10995, MathLib::toLongNumber("+0x2AF3"));

// from octal

ASSERT_EQUALS(8, MathLib::toLongNumber("010"));

ASSERT_EQUALS(8, MathLib::toLongNumber("+010"));

ASSERT_EQUALS(-8, MathLib::toLongNumber("-010"));

ASSERT_EQUALS(125, MathLib::toLongNumber("0175"));

ASSERT_EQUALS(125, MathLib::toLongNumber("+0175"));

ASSERT_EQUALS(-125, MathLib::toLongNumber("-0175"));

// from binary

ASSERT_EQUALS(0, MathLib::toLongNumber("0b0"));

ASSERT_EQUALS(1, MathLib::toLongNumber("0b1"));

ASSERT_EQUALS(1, MathLib::toLongNumber("0b1U"));

ASSERT_EQUALS(1, MathLib::toLongNumber("0b1L"));

ASSERT_EQUALS(1, MathLib::toLongNumber("0b1LU"));

ASSERT_EQUALS(1, MathLib::toLongNumber("0b1LL"));

ASSERT_EQUALS(1, MathLib::toLongNumber("0b1LLU"));

ASSERT_EQUALS(1, MathLib::toLongNumber("+0b1"));

ASSERT_EQUALS(-1, MathLib::toLongNumber("-0b1"));

ASSERT_EQUALS(215, MathLib::toLongNumber("0b11010111"));

ASSERT_EQUALS(-215, MathLib::toLongNumber("-0b11010111"));

ASSERT_EQUALS(215, MathLib::toLongNumber("0B11010111"));

// from base 10

ASSERT_EQUALS(10, MathLib::toLongNumber("10"));

ASSERT_EQUALS(10, MathLib::toLongNumber("10."));

ASSERT_EQUALS(10, MathLib::toLongNumber("10.0"));

ASSERT_EQUALS(100, MathLib::toLongNumber("10E+1"));

ASSERT_EQUALS(1, MathLib::toLongNumber("10E-1"));

ASSERT_EQUALS(100, MathLib::toLongNumber("+10E+1"));

ASSERT_EQUALS(-1, MathLib::toLongNumber("-10E-1"));

ASSERT_EQUALS(100, MathLib::toLongNumber("+10.E+1"));

ASSERT_EQUALS(-1, MathLib::toLongNumber("-10.E-1"));

ASSERT_EQUALS(100, MathLib::toLongNumber("+10.0E+1"));

ASSERT_EQUALS(-1, MathLib::toLongNumber("-10.0E-1"));

// from char

ASSERT_EQUALS((int)('A'), MathLib::toLongNumber("'A'"));

ASSERT_EQUALS((int)('\x10'), MathLib::toLongNumber("'\\x10'"));

ASSERT_EQUALS((int)('\100'), MathLib::toLongNumber("'\\100'"));

ASSERT_EQUALS((int)('\200'), MathLib::toLongNumber("'\\200'"));

ASSERT_EQUALS((int)(L'A'), MathLib::toLongNumber("L'A'"));

ASSERT_EQUALS(-8552249625308161526, MathLib::toLongNumber("0x89504e470d0a1a0a"));

ASSERT_EQUALS(-8481036456200365558, MathLib::toLongNumber("0x8a4d4e470d0a1a0a"));

ASSERT_EQUALS(9894494448401390090ULL, MathLib::toULongNumber("0x89504e470d0a1a0a"));

ASSERT_EQUALS(9965707617509186058ULL, MathLib::toULongNumber("0x8a4d4e470d0a1a0a"));

// zero input

ASSERT_EQUALS(0, MathLib::toULongNumber("0"));

ASSERT_EQUALS(0, MathLib::toULongNumber("-0"));

ASSERT_EQUALS(0, MathLib::toULongNumber("+0"));

ASSERT_EQUALS(0U, MathLib::toULongNumber("0U"));

ASSERT_EQUALS(0, MathLib::toULongNumber("-0x0"));

ASSERT_EQUALS(1U, MathLib::toULongNumber("1U"));

ASSERT_EQUALS(10000U, MathLib::toULongNumber("1e4"));

ASSERT_EQUALS(10000U, MathLib::toULongNumber("1e4"));

ASSERT_EQUALS(0xFF00000000000000UL, MathLib::toULongNumber("0xFF00000000000000UL"));

ASSERT_EQUALS(0x0A00000000000000UL, MathLib::toULongNumber("0x0A00000000000000UL"));

ASSERT_EQUALS(0, MathLib::toULongNumber("0b0"));

ASSERT_EQUALS(1, MathLib::toULongNumber("0b1"));

ASSERT_EQUALS(1, MathLib::toULongNumber("0b1U"));

ASSERT_EQUALS(1, MathLib::toULongNumber("0b1L"));

ASSERT_EQUALS(1, MathLib::toULongNumber("0b1LU"));

ASSERT_EQUALS(1, MathLib::toULongNumber("0b1LL"));

ASSERT_EQUALS(1, MathLib::toULongNumber("0b1LLU"));

ASSERT_EQUALS(9U, MathLib::toULongNumber("011"));

ASSERT_EQUALS(5U, MathLib::toULongNumber("0b101"));

// from long long

/*

ASSERT_EQUALS(0x0A00000000000000LL, MathLib::toLongNumber("0x0A00000000000000LL"));

// min/max numeric limits

ASSERT_EQUALS(std::numeric_limits<long long>::min(), MathLib::toLongNumber(std::to_string(std::numeric_limits<long long>::min())));

ASSERT_EQUALS(std::numeric_limits<long long>::max(), MathLib::toLongNumber(std::to_string(std::numeric_limits<long long>::max())));

ASSERT_EQUALS(std::numeric_limits<unsigned long long>::min(), MathLib::toLongNumber(std::to_string(std::numeric_limits<unsigned long long>::min())));

ASSERT_EQUALS(std::numeric_limits<unsigned long long>::max(), MathLib::toLongNumber(std::to_string(std::numeric_limits<unsigned long long>::max())));

ASSERT_EQUALS(std::numeric_limits<long long>::min(), MathLib::toULongNumber(std::to_string(std::numeric_limits<long long>::min())));

ASSERT_EQUALS(std::numeric_limits<long long>::max(), MathLib::toULongNumber(std::to_string(std::numeric_limits<long long>::max())));

ASSERT_EQUALS(std::numeric_limits<unsigned long long>::min(), MathLib::toULongNumber(std::to_string(std::numeric_limits<unsigned long long>::min())));

ASSERT_EQUALS(std::numeric_limits<unsigned long long>::max(), MathLib::toULongNumber(std::to_string(std::numeric_limits<unsigned long long>::max())));

// min/max and out-of-bounds - hex

{

const MathLib::bigint i = 0xFFFFFFFFFFFFFFFF;

ASSERT_EQUALS(i, MathLib::toLongNumber(std::to_string(i)));

ASSERT_EQUALS(i, MathLib::toLongNumber("0xFFFFFFFFFFFFFFFF"));

}

{

const MathLib::biguint u = 0xFFFFFFFFFFFFFFFF;

ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));

ASSERT_EQUALS(u, MathLib::toULongNumber("0xFFFFFFFFFFFFFFFF"));

}

{

const MathLib::bigint i = -0xFFFFFFFFFFFFFFFF;

ASSERT_EQUALS(i, MathLib::toLongNumber(std::to_string(i)));

ASSERT_EQUALS(i, MathLib::toLongNumber("-0xFFFFFFFFFFFFFFFF"));

}

{

const MathLib::biguint u = -0xFFFFFFFFFFFFFFFF;

ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));

ASSERT_EQUALS(u, MathLib::toULongNumber("-0xFFFFFFFFFFFFFFFF"));

}

ASSERT_THROW(MathLib::toLongNumber("0x10000000000000000"), InternalError);

ASSERT_THROW(MathLib::toULongNumber("0x10000000000000000"), InternalError);

ASSERT_THROW(MathLib::toLongNumber("-0x10000000000000000"), InternalError);

ASSERT_THROW(MathLib::toULongNumber("-0x10000000000000000"), InternalError);

// min/max and out-of-bounds - octal

{

const MathLib::bigint i = 01777777777777777777777;

ASSERT_EQUALS(i, MathLib::toLongNumber(std::to_string(i)));

ASSERT_EQUALS(i, MathLib::toLongNumber("01777777777777777777777"));

}

{

const MathLib::biguint u = 01777777777777777777777;

ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));

ASSERT_EQUALS(u, MathLib::toULongNumber("01777777777777777777777"));

}

{

const MathLib::bigint i = -01777777777777777777777;

ASSERT_EQUALS(i, MathLib::toLongNumber(std::to_string(i)));

ASSERT_EQUALS(i, MathLib::toLongNumber("-01777777777777777777777"));

}

{

const MathLib::biguint u = -01777777777777777777777;

ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));

ASSERT_EQUALS(u, MathLib::toULongNumber("-01777777777777777777777"));

}

ASSERT_THROW(MathLib::toLongNumber("02000000000000000000000"), InternalError);

ASSERT_THROW(MathLib::toULongNumber("02000000000000000000000"), InternalError);

ASSERT_THROW(MathLib::toLongNumber("-02000000000000000000000"), InternalError);

ASSERT_THROW(MathLib::toULongNumber("-02000000000000000000000"), InternalError);

// min/max and out-of-bounds - decimal

{

const MathLib::bigint i = 18446744073709551615;

ASSERT_EQUALS(i, MathLib::toLongNumber(std::to_string(i)));

ASSERT_EQUALS(i, MathLib::toLongNumber("18446744073709551615"));

}

{

const MathLib::biguint u = 18446744073709551615;

ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));

ASSERT_EQUALS(u, MathLib::toULongNumber("18446744073709551615"));

}

{

const MathLib::bigint i = -18446744073709551615;

ASSERT_EQUALS(i, MathLib::toLongNumber(std::to_string(i)));

ASSERT_EQUALS(i, MathLib::toLongNumber("-18446744073709551615"));

}

{

const MathLib::biguint u = -18446744073709551615;

ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));

ASSERT_EQUALS(u, MathLib::toULongNumber("-18446744073709551615"));

}

ASSERT_THROW(MathLib::toLongNumber("18446744073709551616"), InternalError);

ASSERT_THROW(MathLib::toULongNumber("18446744073709551616"), InternalError);

ASSERT_THROW(MathLib::toLongNumber("-18446744073709551616"), InternalError);

ASSERT_THROW(MathLib::toULongNumber("-18446744073709551616"), InternalError);

// TODO: test binary

// TODO: test floating point

// TODO: test with 128-bit values

}

void toDoubleNumber() const {

ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1"), 0.001);

ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("0x1"), 0.001);

ASSERT_EQUALS_DOUBLE(10.0, MathLib::toDoubleNumber("10"), 0.001);

ASSERT_EQUALS_DOUBLE(1000.0, MathLib::toDoubleNumber("10E+2"), 0.001);

ASSERT_EQUALS_DOUBLE(100.0, MathLib::toDoubleNumber("1.0E+2"), 0.001);

ASSERT_EQUALS_DOUBLE(-100.0, MathLib::toDoubleNumber("-1.0E+2"), 0.001);

ASSERT_EQUALS_DOUBLE(-1e+10, MathLib::toDoubleNumber("-1.0E+10"), 1);

ASSERT_EQUALS_DOUBLE(100.0, MathLib::toDoubleNumber("+1.0E+2"), 0.001);

ASSERT_EQUALS_DOUBLE(1e+10, MathLib::toDoubleNumber("+1.0E+10"), 1);

ASSERT_EQUALS_DOUBLE(100.0, MathLib::toDoubleNumber("1.0E+2"), 0.001);

ASSERT_EQUALS_DOUBLE(1e+10, MathLib::toDoubleNumber("1.0E+10"), 1);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("0E+0"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("0E-0"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("0E+00"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("0E-00"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("-0E+00"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("+0E-00"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("0"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("0."), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("0.0"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("-0"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("+0"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("-0."), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("+0."), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("-0.0"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0, MathLib::toDoubleNumber("+0.0"), 0.000001);

ASSERT_EQUALS_DOUBLE('0', MathLib::toDoubleNumber("'0'"), 0.000001);

ASSERT_EQUALS_DOUBLE(L'0', MathLib::toDoubleNumber("L'0'"), 0.000001);

ASSERT_EQUALS_DOUBLE(192, MathLib::toDoubleNumber("0x0.3p10"), 0.000001);

ASSERT_EQUALS_DOUBLE(5.42101e-20, MathLib::toDoubleNumber("0x1p-64"), 1e-20);

ASSERT_EQUALS_DOUBLE(3.14159, MathLib::toDoubleNumber("0x1.921fb5p+1"), 0.000001);

ASSERT_EQUALS_DOUBLE(2006, MathLib::toDoubleNumber("0x1.f58000p+10"), 0.000001);

ASSERT_EQUALS_DOUBLE(1e-010, MathLib::toDoubleNumber("0x1.b7cdfep-34"), 0.000001);

ASSERT_EQUALS_DOUBLE(.484375, MathLib::toDoubleNumber("0x1.fp-2"), 0.000001);

ASSERT_EQUALS_DOUBLE(9.0, MathLib::toDoubleNumber("0x1.2P3"), 0.000001);

ASSERT_EQUALS_DOUBLE(0.0625, MathLib::toDoubleNumber("0x.1P0"), 0.000001);

// verify: string --> double --> string conversion

ASSERT_EQUALS("1.0", MathLib::toString(MathLib::toDoubleNumber("1.0f")));

ASSERT_EQUALS("1.0", MathLib::toString(MathLib::toDoubleNumber("1.0")));

ASSERT_EQUALS("0.0", MathLib::toString(MathLib::toDoubleNumber("0.0f")));

ASSERT_EQUALS("0.0", MathLib::toString(MathLib::toDoubleNumber("0.0")));

ASSERT_EQUALS("-1.0", MathLib::toString(MathLib::toDoubleNumber("-1.0f")));

ASSERT_EQUALS("-1.0", MathLib::toString(MathLib::toDoubleNumber("-1.0")));

ASSERT_EQUALS("0.0", MathLib::toString(MathLib::toDoubleNumber("-0.0f")));

ASSERT_EQUALS("0.0", MathLib::toString(MathLib::toDoubleNumber("-0.0")));

ASSERT_EQUALS("1.0", MathLib::toString(MathLib::toDoubleNumber("+1.0f")));

ASSERT_EQUALS("1.0", MathLib::toString(MathLib::toDoubleNumber("+1.0")));

ASSERT_EQUALS("0.0", MathLib::toString(MathLib::toDoubleNumber("+0.0f")));

ASSERT_EQUALS("0.0", MathLib::toString(MathLib::toDoubleNumber("+0.0")));

ASSERT_EQUALS("0.0", MathLib::toString(MathLib::toDoubleNumber("-0")));

ASSERT_EQUALS("0.0", MathLib::toString(MathLib::toDoubleNumber("-0.")));

ASSERT_EQUALS("0.0", MathLib::toString(MathLib::toDoubleNumber("-0.0")));

}

void isint() const {

// zero tests

ASSERT_EQUALS(true, MathLib::isInt("0"));

ASSERT_EQUALS(false, MathLib::isInt("0."));

ASSERT_EQUALS(false, MathLib::isInt("0.0"));

ASSERT_EQUALS(false, MathLib::isInt("-0."));

ASSERT_EQUALS(false, MathLib::isInt("+0."));

ASSERT_EQUALS(false, MathLib::isInt("-0.0"));

ASSERT_EQUALS(false, MathLib::isInt("+0.0"));

ASSERT_EQUALS(false, MathLib::isInt("+0.0E+1"));

ASSERT_EQUALS(false, MathLib::isInt("+0.0E-1"));

ASSERT_EQUALS(false, MathLib::isInt("-0.0E+1"));

ASSERT_EQUALS(false, MathLib::isInt("-0.0E-1"));

ASSERT_EQUALS(true, MathLib::isInt("1"));

ASSERT_EQUALS(true, MathLib::isInt("-1"));

ASSERT_EQUALS(true, MathLib::isInt("+1"));

ASSERT_EQUALS(false, MathLib::isInt("+1E+1"));

ASSERT_EQUALS(false, MathLib::isInt("+1E+10000"));

ASSERT_EQUALS(false, MathLib::isInt("-1E+1"));

ASSERT_EQUALS(false, MathLib::isInt("-1E+10000"));

ASSERT_EQUALS(false, MathLib::isInt("-1E-1"));

ASSERT_EQUALS(false, MathLib::isInt("-1E-10000"));

ASSERT_EQUALS(true, MathLib::isInt("0xff"));

ASSERT_EQUALS(true, MathLib::isInt("0xa"));

ASSERT_EQUALS(true, MathLib::isInt("0b1000"));

ASSERT_EQUALS(true, MathLib::isInt("0B1000"));

ASSERT_EQUALS(true, MathLib::isInt("0l"));

ASSERT_EQUALS(true, MathLib::isInt("0L"));

ASSERT_EQUALS(true, MathLib::isInt("0ul"));

ASSERT_EQUALS(true, MathLib::isInt("0ull"));

ASSERT_EQUALS(true, MathLib::isInt("0llu"));

ASSERT_EQUALS(true, MathLib::isInt("333L"));

ASSERT_EQUALS(true, MathLib::isInt("330L"));

ASSERT_EQUALS(true, MathLib::isInt("330llu"));

ASSERT_EQUALS(true, MathLib::isInt("07"));

ASSERT_EQUALS(true, MathLib::isInt("0123"));

ASSERT_EQUALS(false, MathLib::isInt("0.4"));

ASSERT_EQUALS(false, MathLib::isInt("2352.3f"));

ASSERT_EQUALS(false, MathLib::isInt("0.00004"));

ASSERT_EQUALS(false, MathLib::isInt("2352.00001f"));

ASSERT_EQUALS(false, MathLib::isInt(".4"));

ASSERT_EQUALS(false, MathLib::isInt("1.0E+1"));

ASSERT_EQUALS(false, MathLib::isInt("1.0E-1"));

ASSERT_EQUALS(false, MathLib::isInt("-1.0E+1"));

ASSERT_EQUALS(false, MathLib::isInt("+1.0E-1"));

ASSERT_EQUALS(false, MathLib::isInt("-1.E+1"));

ASSERT_EQUALS(false, MathLib::isInt("+1.E-1"));

ASSERT_EQUALS(false, MathLib::isInt(" 1.0E+1"));

// with whitespace in front

ASSERT_EQUALS(false, MathLib::isInt(" 1.0E-1"));

ASSERT_EQUALS(false, MathLib::isInt(" -1.0E+1"));

ASSERT_EQUALS(false, MathLib::isInt(" +1.0E-1"));

ASSERT_EQUALS(false, MathLib::isInt(" -1.E+1"));

ASSERT_EQUALS(false, MathLib::isInt(" +1.E-1"));

// with whitespace in front and end

ASSERT_EQUALS(false, MathLib::isInt(" 1.0E-1 "));

ASSERT_EQUALS(false, MathLib::isInt(" -1.0E+1 "));

ASSERT_EQUALS(false, MathLib::isInt(" +1.0E-1 "));

ASSERT_EQUALS(false, MathLib::isInt(" -1.E+1 "));

ASSERT_EQUALS(false, MathLib::isInt(" +1.E-1 "));

// with whitespace in front and end

ASSERT_EQUALS(false, MathLib::isInt("1.0E-1 "));

ASSERT_EQUALS(false, MathLib::isInt("-1.0E+1 "));

ASSERT_EQUALS(false, MathLib::isInt("+1.0E-1 "));

ASSERT_EQUALS(false, MathLib::isInt("-1.E+1 "));

ASSERT_EQUALS(false, MathLib::isInt("+1.E-1 "));

// test some garbage

ASSERT_EQUALS(false, MathLib::isInt("u"));

ASSERT_EQUALS(false, MathLib::isInt("l"));

ASSERT_EQUALS(false, MathLib::isInt("ul"));

ASSERT_EQUALS(false, MathLib::isInt("ll"));

ASSERT_EQUALS(false, MathLib::isInt("U"));

ASSERT_EQUALS(false, MathLib::isInt("L"));

ASSERT_EQUALS(false, MathLib::isInt("uL"));

ASSERT_EQUALS(false, MathLib::isInt("LL"));

ASSERT_EQUALS(false, MathLib::isInt("e2"));

ASSERT_EQUALS(false, MathLib::isInt("E2"));

ASSERT_EQUALS(false, MathLib::isInt(".e2"));

ASSERT_EQUALS(false, MathLib::isInt(".E2"));

ASSERT_EQUALS(false, MathLib::isInt("0x"));

ASSERT_EQUALS(false, MathLib::isInt("0xu"));

ASSERT_EQUALS(false, MathLib::isInt("0xl"));

ASSERT_EQUALS(false, MathLib::isInt("0xul"));

// test empty string

ASSERT_EQUALS(false, MathLib::isInt(""));

}

void isbin() const {

// positive testing

ASSERT_EQUALS(true, MathLib::isBin("0b0"));

ASSERT_EQUALS(true, MathLib::isBin("0b1"));

ASSERT_EQUALS(true, MathLib::isBin("+0b1"));

ASSERT_EQUALS(true, MathLib::isBin("-0b1"));

ASSERT_EQUALS(true, MathLib::isBin("0b11010111"));

ASSERT_EQUALS(true, MathLib::isBin("-0b11010111"));

ASSERT_EQUALS(true, MathLib::isBin("0B11010111"));

ASSERT_EQUALS(true, MathLib::isBin("0b11010111u"));

ASSERT_EQUALS(true, MathLib::isBin("0b11010111ul"));

ASSERT_EQUALS(true, MathLib::isBin("0b11010111ull"));

ASSERT_EQUALS(true, MathLib::isBin("0b11010111l"));

ASSERT_EQUALS(true, MathLib::isBin("0b11010111ll"));

ASSERT_EQUALS(true, MathLib::isBin("0b11010111llu"));

ASSERT_EQUALS(true, MathLib::isBin("0b11010111l"));

ASSERT_EQUALS(true, MathLib::isBin("0b11010111lu"));

ASSERT_EQUALS(false, MathLib::isBin("0b11010111lul")); // Suffix LUL not allowed

// negative testing

ASSERT_EQUALS(false, MathLib::isBin("100101bx"));

ASSERT_EQUALS(false, MathLib::isBin("0"));

ASSERT_EQUALS(false, MathLib::isBin("0B"));

ASSERT_EQUALS(false, MathLib::isBin("0C"));

ASSERT_EQUALS(false, MathLib::isBin("+0B"));

ASSERT_EQUALS(false, MathLib::isBin("-0B"));

ASSERT_EQUALS(false, MathLib::isBin("-0Bx"));

ASSERT_EQUALS(false, MathLib::isBin("0b11010111x"));

ASSERT_EQUALS(false, MathLib::isBin("0b11010111ux"));

ASSERT_EQUALS(false, MathLib::isBin("0b11010111lx"));

ASSERT_EQUALS(false, MathLib::isBin("0b11010111lux"));

ASSERT_EQUALS(false, MathLib::isBin("0b11010111ulx"));

ASSERT_EQUALS(false, MathLib::isBin("0b11010111lulx"));

ASSERT_EQUALS(false, MathLib::isBin("0b11010111ullx"));

ASSERT_EQUALS(false, MathLib::isBin("0b11010111lll"));

// test empty string

ASSERT_EQUALS(false, MathLib::isBin(""));

}

void isnegative() const {

ASSERT_EQUALS(true, MathLib::isNegative("-1"));

ASSERT_EQUALS(true, MathLib::isNegative("-1."));

ASSERT_EQUALS(true, MathLib::isNegative("-1.0"));

ASSERT_EQUALS(true, MathLib::isNegative("-1.0E+2"));

ASSERT_EQUALS(true, MathLib::isNegative("-1.0E-2"));

ASSERT_EQUALS(false, MathLib::isNegative("+1"));

ASSERT_EQUALS(false, MathLib::isNegative("+1."));

ASSERT_EQUALS(false, MathLib::isNegative("+1.0"));

ASSERT_EQUALS(false, MathLib::isNegative("+1.0E+2"));

ASSERT_EQUALS(false, MathLib::isNegative("+1.0E-2"));

// test empty string

ASSERT_EQUALS(false, MathLib::isNegative(""));

}

void isoct() const {

// octal number format: [+|-]0[0-7][suffix]

// positive testing

ASSERT_EQUALS(true, MathLib::isOct("010"));

ASSERT_EQUALS(true, MathLib::isOct("+010"));

ASSERT_EQUALS(true, MathLib::isOct("-010"));

ASSERT_EQUALS(true, MathLib::isOct("0175"));

ASSERT_EQUALS(true, MathLib::isOct("+0175"));

ASSERT_EQUALS(true, MathLib::isOct("-0175"));

ASSERT_EQUALS(true, MathLib::isOct("00"));

ASSERT_EQUALS(true, MathLib::isOct("02"));

ASSERT_EQUALS(true, MathLib::isOct("+042"));

ASSERT_EQUALS(true, MathLib::isOct("-042"));

ASSERT_EQUALS(true, MathLib::isOct("+042U"));

ASSERT_EQUALS(true, MathLib::isOct("-042U"));

ASSERT_EQUALS(true, MathLib::isOct("+042L"));

ASSERT_EQUALS(true, MathLib::isOct("-042L"));

ASSERT_EQUALS(true, MathLib::isOct("+042LU"));

ASSERT_EQUALS(true, MathLib::isOct("-042LU"));

ASSERT_EQUALS(true, MathLib::isOct("+042UL"));

ASSERT_EQUALS(true, MathLib::isOct("-042UL"));

ASSERT_EQUALS(true, MathLib::isOct("+042ULL"));

ASSERT_EQUALS(true, MathLib::isOct("-042ULL"));

ASSERT_EQUALS(true, MathLib::isOct("+042LLU"));

ASSERT_EQUALS(true, MathLib::isOct("-042LLU"));

// test empty string

ASSERT_EQUALS(false, MathLib::isOct(""));

// negative testing

ASSERT_EQUALS(false, MathLib::isOct("0"));

ASSERT_EQUALS(false, MathLib::isOct("-0x175"));

ASSERT_EQUALS(false, MathLib::isOct("-0_garbage_"));

ASSERT_EQUALS(false, MathLib::isOct(" "));

ASSERT_EQUALS(false, MathLib::isOct(" "));

ASSERT_EQUALS(false, MathLib::isOct("02."));

ASSERT_EQUALS(false, MathLib::isOct("02E2"));

ASSERT_EQUALS(false, MathLib::isOct("+042x"));

ASSERT_EQUALS(false, MathLib::isOct("-042x"));

ASSERT_EQUALS(false, MathLib::isOct("+042Ux"));

ASSERT_EQUALS(false, MathLib::isOct("-042Ux"));

ASSERT_EQUALS(false, MathLib::isOct("+042Lx"));

ASSERT_EQUALS(false, MathLib::isOct("-042Lx"));

ASSERT_EQUALS(false, MathLib::isOct("+042ULx"));

ASSERT_EQUALS(false, MathLib::isOct("-042ULx"));

ASSERT_EQUALS(false, MathLib::isOct("+042LLx"));

ASSERT_EQUALS(false, MathLib::isOct("-042LLx"));

ASSERT_EQUALS(false, MathLib::isOct("+042ULLx"));

ASSERT_EQUALS(false, MathLib::isOct("-042ULLx"));

ASSERT_EQUALS(false, MathLib::isOct("+042LLUx"));

ASSERT_EQUALS(false, MathLib::isOct("-042LLUx"));

ASSERT_EQUALS(false, MathLib::isOct("+042LUL"));

ASSERT_EQUALS(false, MathLib::isOct("-042LUL"));

// white space in front

ASSERT_EQUALS(false, MathLib::isOct(" -042ULL"));

// trailing white space

ASSERT_EQUALS(false, MathLib::isOct("-042ULL "));

// front and trailing white space

ASSERT_EQUALS(false, MathLib::isOct(" -042ULL "));

ASSERT_EQUALS(false, MathLib::isOct("+042LUL+0"));

}

void isFloatHex() const {

// hex number syntax: [sign]0x[hexnumbers][suffix]

ASSERT_EQUALS(true, MathLib::isFloatHex("0x1.999999999999ap-4"));

ASSERT_EQUALS(true, MathLib::isFloatHex("0x0.3p10"));

ASSERT_EQUALS(true, MathLib::isFloatHex("0x1.fp3"));

ASSERT_EQUALS(true, MathLib::isFloatHex("0x1P-1"));

ASSERT_EQUALS(true, MathLib::isFloatHex("0xcc.ccccccccccdp-11"));

ASSERT_EQUALS(true, MathLib::isFloatHex("0x3.243F6A88p+03"));

ASSERT_EQUALS(true, MathLib::isFloatHex("0xA.Fp-10"));

ASSERT_EQUALS(true, MathLib::isFloatHex("0x1.2p-10f"));

ASSERT_EQUALS(true, MathLib::isFloatHex("0x1.2p+10F"));

ASSERT_EQUALS(true, MathLib::isFloatHex("0x1.2p+10l"));

ASSERT_EQUALS(true, MathLib::isFloatHex("0x1.2p+10L"));

ASSERT_EQUALS(true, MathLib::isFloatHex("0X.2p-0"));

ASSERT_EQUALS(false, MathLib::isFloatHex(""));

ASSERT_EQUALS(false, MathLib::isFloatHex("0"));

ASSERT_EQUALS(false, MathLib::isFloatHex("0x"));

ASSERT_EQUALS(false, MathLib::isFloatHex("0xa"));

ASSERT_EQUALS(false, MathLib::isFloatHex("+0x"));

ASSERT_EQUALS(false, MathLib::isFloatHex("-0x"));

ASSERT_EQUALS(false, MathLib::isFloatHex("0x"));

ASSERT_EQUALS(false, MathLib::isFloatHex("0x."));

ASSERT_EQUALS(false, MathLib::isFloatHex("0XP"));

ASSERT_EQUALS(false, MathLib::isFloatHex("0xx"));

ASSERT_EQUALS(false, MathLib::isFloatHex("0x1P+-1"));

ASSERT_EQUALS(false, MathLib::isFloatHex("0x1p+10e"));

ASSERT_EQUALS(false, MathLib::isFloatHex("0x1p+1af"));

ASSERT_EQUALS(false, MathLib::isFloatHex("0x1p+10LL"));

}

void isIntHex() const {

// hex number syntax: [sign]0x[hexnumbers][suffix]

// positive testing

ASSERT_EQUALS(true, MathLib::isIntHex("0xa"));

ASSERT_EQUALS(true, MathLib::isIntHex("0x2AF3"));

ASSERT_EQUALS(true, MathLib::isIntHex("-0xa"));

ASSERT_EQUALS(true, MathLib::isIntHex("-0x2AF3"));

ASSERT_EQUALS(true, MathLib::isIntHex("+0xa"));

ASSERT_EQUALS(true, MathLib::isIntHex("+0x2AF3"));

ASSERT_EQUALS(true, MathLib::isIntHex("0x0"));

ASSERT_EQUALS(true, MathLib::isIntHex("+0x0"));

ASSERT_EQUALS(true, MathLib::isIntHex("-0x0"));

ASSERT_EQUALS(true, MathLib::isIntHex("+0x0U"));

ASSERT_EQUALS(true, MathLib::isIntHex("-0x0U"));

ASSERT_EQUALS(true, MathLib::isIntHex("+0x0L"));

ASSERT_EQUALS(true, MathLib::isIntHex("-0x0L"));

ASSERT_EQUALS(true, MathLib::isIntHex("+0x0LU"));

ASSERT_EQUALS(true, MathLib::isIntHex("-0x0LU"));

ASSERT_EQUALS(true, MathLib::isIntHex("+0x0UL"));

ASSERT_EQUALS(true, MathLib::isIntHex("-0x0UL"));

ASSERT_EQUALS(true, MathLib::isIntHex("+0x0LL"));

ASSERT_EQUALS(true, MathLib::isIntHex("-0x0LL"));

ASSERT_EQUALS(true, MathLib::isIntHex("+0x0ULL"));

ASSERT_EQUALS(true, MathLib::isIntHex("-0x0ULL"));

ASSERT_EQUALS(true, MathLib::isIntHex("+0x0LLU"));

ASSERT_EQUALS(true, MathLib::isIntHex("-0x0LLU"));

// negative testing

ASSERT_EQUALS(false, MathLib::isIntHex("+0x"));

ASSERT_EQUALS(false, MathLib::isIntHex("-0x"));

ASSERT_EQUALS(false, MathLib::isIntHex("0x"));

ASSERT_EQUALS(false, MathLib::isIntHex("0xl"));

ASSERT_EQUALS(false, MathLib::isIntHex("0xx"));

ASSERT_EQUALS(false, MathLib::isIntHex("-0175"));

ASSERT_EQUALS(false, MathLib::isIntHex("-0_garbage_"));

ASSERT_EQUALS(false, MathLib::isIntHex(" "));

ASSERT_EQUALS(false, MathLib::isIntHex(" "));

ASSERT_EQUALS(false, MathLib::isIntHex("0"));

ASSERT_EQUALS(false, MathLib::isIntHex("+0x0Z"));

ASSERT_EQUALS(false, MathLib::isIntHex("-0x0Z"));

ASSERT_EQUALS(false, MathLib::isIntHex("+0x0Uz"));

ASSERT_EQUALS(false, MathLib::isIntHex("-0x0Uz"));

ASSERT_EQUALS(false, MathLib::isIntHex("+0x0Lz"));

ASSERT_EQUALS(false, MathLib::isIntHex("-0x0Lz"));

ASSERT_EQUALS(false, MathLib::isIntHex("+0x0LUz"));

ASSERT_EQUALS(false, MathLib::isIntHex("-0x0LUz"));

ASSERT_EQUALS(false, MathLib::isIntHex("+0x0ULz"));

ASSERT_EQUALS(false, MathLib::isIntHex("-0x0ULz"));

ASSERT_EQUALS(false, MathLib::isIntHex("+0x0LLz"));

ASSERT_EQUALS(false, MathLib::isIntHex("-0x0LLz"));

ASSERT_EQUALS(false, MathLib::isIntHex("+0x0ULLz"));

ASSERT_EQUALS(false, MathLib::isIntHex("-0x0ULLz"));

ASSERT_EQUALS(false, MathLib::isIntHex("+0x0LLUz"));

ASSERT_EQUALS(false, MathLib::isIntHex("-0x0LLUz"));

ASSERT_EQUALS(false, MathLib::isIntHex("0x0+0"));

ASSERT_EQUALS(false, MathLib::isIntHex("e2"));

ASSERT_EQUALS(false, MathLib::isIntHex("+E2"));

// test empty string

ASSERT_EQUALS(false, MathLib::isIntHex(""));

}

void isValidIntegerSuffix() const {

// negative testing

ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix(""));

ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("ux"));

ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("ulx"));

ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("lx"));

ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("lux"));