walkero
/
cppcheck
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
cppcheck/test/testmathlib.cpp

1494 lines
80 KiB
C++
Raw Normal View History

added testing for mathlib
2009-04-06 19:08:13 +02:00
/*
* Cppcheck - A tool for static C/C++ code analysis
Update copyright year
2023-01-28 10:16:34 +01:00
* Copyright (C) 2007-2023 Cppcheck team.
added testing for mathlib
2009-04-06 19:08:13 +02:00
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
Fix GPL comments in all files. ">." was missing from the end.
2009-09-27 17:08:31 +02:00
* along with this program. If not, see <http://www.gnu.org/licenses/>.
added testing for mathlib
2009-04-06 19:08:13 +02:00
*/
iwyu - include what you use
2017-05-27 04:33:47 +02:00
iwyu.yml: use a distro which has the latest `include-what-you-use` / enabled Qt mappings / cleaned up includes (#4885)
2023-04-08 16:08:47 +02:00
#include "errortypes.h"
refactoring the folder structure
2009-10-25 12:49:06 +01:00
#include "mathlib.h"
renamed some files in the `test` folder (#4705)
2023-01-27 08:18:32 +01:00
#include "fixture.h"
added testing for mathlib
2009-04-06 19:08:13 +02:00
some MathLib adjustments for out-of-range numbers after std::stringstream removal (#3100)
2021-02-13 19:10:45 +01:00
#include <limits>
avoid dependency on transitive includes - based on include-what-you-use (#3757)
2022-01-27 19:03:20 +01:00
#include <string>
some MathLib adjustments for out-of-range numbers after std::stringstream removal (#3100)
2021-02-13 19:10:45 +01:00
iwyu - include what you use
2017-05-27 04:33:47 +02:00
Refactorization: Moved declaration of errout, ... to testsuite.h, uniformized style
2015-03-11 22:26:33 +01:00
changed the astyle formatting flags
2011-10-13 20:53:06 +02:00
class TestMathLib : public TestFixture {
added testing for mathlib
2009-04-06 19:08:13 +02:00
public:
Format with uncrustify (#3388)
2021-08-07 20:51:18 +02:00
TestMathLib() : TestFixture("TestMathLib") {}
added testing for mathlib
2009-04-06 19:08:13 +02:00
private:
removed OVERRIDE and FINAL defines and use the keywords directly (#3767)
2022-02-10 23:02:24 +01:00
void run() override {
Don't warn about division by zero if zero if floating point number. Fix bug from mathlib isInt() and add test case from which few are false positives
2009-09-01 21:06:46 +02:00
TEST_CASE(isint);
MathLib::isBin(): fix missing detection of U and L suffix combinations. Added missing test cases.
2014-03-10 17:23:07 +01:00
TEST_CASE(isbin);
astyle formatting
2014-11-14 21:43:37 +01:00
TEST_CASE(isdec);
MathLib::isOct() fix missing detection of U and L suffix combinations and unittests.
2014-03-09 21:14:14 +01:00
TEST_CASE(isoct);
MathLib::isFloat now detects C99 hexadecimal float literals. MathLib::isDecimalFloat was added for C++ and pre-C99 compatibility.
2015-07-26 19:21:53 +02:00
TEST_CASE(isFloatHex);
TEST_CASE(isIntHex);
Implement MathLib::isFloatHex to detect C99 hexadecimal floating pointer literals. Rename MathLib::isHex to MathLib::isIntHex
2015-07-26 08:06:56 +02:00
TEST_CASE(isValidIntegerSuffix);
ticket #1513 new check: Detecting obviously wrong math call arguments passed to math functions)
2010-04-02 02:19:38 +02:00
TEST_CASE(isnegative);
Improved simplifyMathFunctions when simplifying special cases of pow(x,y)-function.
2013-09-29 15:11:09 +02:00
TEST_CASE(ispositive);
Fix some glitches from previous commit to TestMathLib
2015-07-26 19:47:27 +02:00
TEST_CASE(isFloat);
MathLib::isFloat now detects C99 hexadecimal float literals. MathLib::isDecimalFloat was added for C++ and pre-C99 compatibility.
2015-07-26 19:21:53 +02:00
TEST_CASE(isDecimalFloat);
fixed -Wextra-semi-stmt Clang warnings (#2553) * fixed -Wextra-semi-stmt Clang warnings * adjusted REDIRECT macro to require a semicolon * testmathlib.cpp: rolled back accidental change
2020-04-21 17:27:51 +02:00
TEST_CASE(isGreater);
TEST_CASE(isGreaterEqual);
TEST_CASE(isEqual);
TEST_CASE(isNotEqual);
TEST_CASE(isLess);
TEST_CASE(isLessEqual);
Tidy up MathLib::isInt() - using a state machine approach
2014-04-10 22:46:55 +02:00
TEST_CASE(calculate);
TEST_CASE(calculate1);
MathLib: Try to keep type suffix in constant calculations
2015-06-15 19:01:56 +02:00
TEST_CASE(typesuffix);
MathLib::toLongNumber: Better handling of '\x12' and '\000' char constants
2015-11-20 18:57:48 +01:00
TEST_CASE(toLongNumber);
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
TEST_CASE(toULongNumber);
MathLib::toLongNumber: Better handling of '\x12' and '\000' char constants
2015-11-20 18:57:48 +01:00
TEST_CASE(toDoubleNumber);
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
TEST_CASE(naninf);
TEST_CASE(isNullValue);
#633 Adding tests for some MathLib member functions, should reach 100% function coverage now
2014-11-16 18:09:21 +01:00
TEST_CASE(sin);
TEST_CASE(cos);
TEST_CASE(tan);
TEST_CASE(abs);
Improved test coverage of MathLib.
2014-12-03 18:24:27 +01:00
TEST_CASE(toString);
Ticket #7137: Properly detect C++14 digit separators. (#802) Add an optional extended description…
2016-06-04 22:55:55 +02:00
TEST_CASE(CPP14DigitSeparators);
testmathlib: improved testcoverage of mathlib
2011-07-19 09:10:34 +02:00
}
astyle formatting
2014-11-20 14:20:09 +01:00
void isGreater() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(true, MathLib::isGreater("1.0", "0.001"));
testmathlib: improved testcoverage of mathlib
2011-07-19 09:10:34 +02:00
ASSERT_EQUALS(false, MathLib::isGreater("-1.0", "0.001"));
}
astyle formatting
2014-11-20 14:20:09 +01:00
void isGreaterEqual() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
testmathlib: improved testcoverage of mathlib
2011-07-19 09:10:34 +02:00
ASSERT_EQUALS(false, MathLib::isGreaterEqual("-1.0", "0.001"));
}
astyle formatting
2014-11-20 14:20:09 +01:00
void isEqual() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
testmathlib: improved testcoverage of mathlib
2011-07-19 09:10:34 +02:00
}
astyle formatting
2014-11-20 14:20:09 +01:00
void isNotEqual() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(false, MathLib::isNotEqual("1.0", "1.0"));
ASSERT_EQUALS(true, MathLib::isNotEqual("1.", "1.01"));
testmathlib: improved testcoverage of mathlib
2011-07-19 09:10:34 +02:00
}
astyle formatting
2014-11-20 14:20:09 +01:00
void isLess() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(false, MathLib::isLess("1.0", "0.001"));
ASSERT_EQUALS(true, MathLib::isLess("-1.0", "0.001"));
testmathlib: improved testcoverage of mathlib
2011-07-19 09:10:34 +02:00
}
astyle formatting
2014-11-20 14:20:09 +01:00
void isLessEqual() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
added testing for mathlib
2009-04-06 19:08:13 +02:00
}
astyle formatting
2014-11-20 14:20:09 +01:00
void calculate() const {
astyle formatting
2009-12-27 17:46:24 +01:00
// addition
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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
extended testcases of mathlib; fixed zero conversion: +0 and -0 is converted to 0
2009-12-27 14:30:23 +01:00
astyle formatting
2009-12-27 17:46:24 +01:00
// subtraction
extended testcases of mathlib; fixed zero conversion: +0 and -0 is converted to 0
2009-12-27 14:30:23 +01:00
ASSERT_EQUALS("254", MathLib::subtract("0xff", "1"));
ASSERT_EQUALS("251", MathLib::subtract("250", "-1"));
ASSERT_EQUALS("249", MathLib::subtract("250", "1"));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
extended testcases of mathlib; fixed zero conversion: +0 and -0 is converted to 0
2009-12-27 14:30:23 +01:00
astyle formatting
2009-12-27 17:46:24 +01:00
// multiply
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
extended testcases of mathlib; fixed zero conversion: +0 and -0 is converted to 0
2009-12-27 14:30:23 +01:00
astyle formatting
2009-12-27 17:46:24 +01:00
// divide
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS("1", MathLib::divide("1", "1"));
ASSERT_EQUALS("0", MathLib::divide("0", "1"));
ASSERT_EQUALS("5", MathLib::divide("-10", "-2"));
extended testcases of mathlib; fixed zero conversion: +0 and -0 is converted to 0
2009-12-27 14:30:23 +01:00
ASSERT_EQUALS("-2.5", MathLib::divide("-10.", "4"));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_THROW_EQUALS(MathLib::divide("123", "0"), InternalError, "Internal Error: Division by zero"); // decimal zero: throw
ASSERT_THROW_EQUALS(MathLib::divide("123", "00"), InternalError, "Internal Error: Division by zero"); // octal zero: throw
ASSERT_THROW_EQUALS(MathLib::divide("123", "0x0"), InternalError, "Internal Error: Division by zero"); // hex zero: throw
MathLib: Added robustness tests for 'MathLib::divide()'.
2019-05-25 23:06:50 +02:00
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
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_THROW_EQUALS(MathLib::divide("-9223372036854775808", "-1"), InternalError, "Internal Error: Division overflow"); // #4520 - out of range => throw
#6779 internal error: division overflow. Previous error handling (see #4520) was too restrictive.
2015-06-20 23:15:35 +02:00
ASSERT_EQUALS("4611686018427387904", MathLib::divide("-9223372036854775808", "-2")); // #6679
MathLib: Added robustness tests for 'MathLib::divide()'.
2019-05-25 23:06:50 +02:00
extended testcases of mathlib; fixed zero conversion: +0 and -0 is converted to 0
2009-12-27 14:30:23 +01:00
Improve test coverage for MathLib::calculate()
2020-01-09 16:18:03 +01:00
// 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", '^'));
Add InternalError and change MathLib to throw it in case of an error. - Previously MathLib errors did not provide a filename, but after this change at least source file name should be printed and if token is provided, also line number should be printed. - Change also Token to use InternalError - Modify Cppcheck-class to catch InternalError instead of Token - Run dmake to update Makefile
2012-01-08 21:19:44 +01:00
// Unknown action should throw exception
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_THROW_EQUALS(MathLib::calculate("1","2",'j'),InternalError, "Unexpected action 'j' in MathLib::calculate(). Please report this to Cppcheck developers.");
added testing for mathlib
2009-04-06 19:08:13 +02:00
}
testing mathlib: Test that conversion to numbers work
2009-05-02 11:12:49 +02:00
astyle formatting
2014-11-20 14:20:09 +01:00
void calculate1() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS("0", MathLib::calculate("2", "1", '%'));
ASSERT_EQUALS("2", MathLib::calculate("12", "5", '%'));
ASSERT_EQUALS("1", MathLib::calculate("100", "3", '%'));
MathLib: Add TEST_MATHLIB_VALUE that is used to test MathLib::value
2015-07-15 17:36:41 +02:00
#ifndef TEST_MATHLIB_VALUE
// floating point modulo is not defined in C/C++
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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", '%'));
Throw an InternalError when trying to divide (or modulo) by zero in MathLib.
2012-09-06 20:15:32 +02:00
MathLib::calculate("123", "0.0", '%'); // don't throw
MathLib: Add TEST_MATHLIB_VALUE that is used to test MathLib::value
2015-07-15 17:36:41 +02:00
#endif
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_THROW_EQUALS(MathLib::calculate("123", "0", '%'), InternalError, "Internal Error: Division by zero"); // throw
#633 Adding tests for some MathLib member functions, should reach 100% function coverage now
2014-11-16 18:09:21 +01:00
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS("0", MathLib::calculate("1", "1", '^'));
ASSERT_EQUALS("3", MathLib::calculate("2", "1", '^'));
fixed ticket 3693. Added modulus operator to Mathlib + unittests. Added a test to checkother to ensure the testcase of ticket 3693 does not trigger an error message.
2012-04-12 14:02:09 +02:00
}
MathLib: Try to keep type suffix in constant calculations
2015-06-15 19:01:56 +02:00
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"));
MathLib, ValueType: Support integer suffix "i64"
2016-07-26 13:19:28 +02:00
ASSERT_EQUALS("2LL", MathLib::add("1i64", "1"));
MathLib: Try to keep type suffix in constant calculations
2015-06-15 19:01:56 +02:00
ASSERT_EQUALS("2ULL", MathLib::add("1ULL", "1"));
MathLib, ValueType: Support integer suffix "i64"
2016-07-26 13:19:28 +02:00
ASSERT_EQUALS("2ULL", MathLib::add("1ui64","1"));
MathLib: Try to keep type suffix in constant calculations
2015-06-15 19:01:56 +02:00
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"));
MathLib::intsuffix: Added support for LLU and LU suffixes.
2015-06-16 19:12:18 +02:00
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"));
MathLib: Try to keep type suffix in constant calculations
2015-06-15 19:01:56 +02:00
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"));
MathLib::intsuffix: Added support for LLU and LU suffixes.
2015-06-16 19:12:18 +02:00
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"));
MathLib: Try to keep type suffix in constant calculations
2015-06-15 19:01:56 +02:00
}
MathLib::toLongNumber: Better handling of '\x12' and '\000' char constants
2015-11-20 18:57:48 +01:00
void toLongNumber() const {
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
// zero input
ASSERT_EQUALS(0, MathLib::toLongNumber("0"));
ASSERT_EQUALS(0, MathLib::toLongNumber("-0"));
ASSERT_EQUALS(0, MathLib::toLongNumber("+0"));
ASSERT_EQUALS(0, MathLib::toLongNumber("0L"));
ASSERT_EQUALS(0, MathLib::toLongNumber("0l"));
ASSERT_EQUALS(0, MathLib::toLongNumber("0LL"));
ASSERT_EQUALS(0, MathLib::toLongNumber("0ll"));
ASSERT_EQUALS(0, MathLib::toLongNumber("0U"));
ASSERT_EQUALS(0, MathLib::toLongNumber("0u"));
ASSERT_EQUALS(0, MathLib::toLongNumber("0UL"));
ASSERT_EQUALS(0, MathLib::toLongNumber("0ul"));
ASSERT_EQUALS(0, MathLib::toLongNumber("0ULL"));
ASSERT_EQUALS(0, MathLib::toLongNumber("0ull"));
ASSERT_EQUALS(0, MathLib::toLongNumber("0i64")); // Visual Studio-specific
ASSERT_EQUALS(0, MathLib::toLongNumber("0ui64")); // Visual Studio-specific
// TODO: needs to fail
//ASSERT_EQUALS(0, MathLib::toLongNumber("0lll"));
//ASSERT_EQUALS(0, MathLib::toLongNumber("0uu"));
ASSERT_EQUALS(1U, MathLib::toLongNumber("1U"));
ASSERT_EQUALS(10000U, MathLib::toLongNumber("1e4"));
ASSERT_EQUALS(10000U, MathLib::toLongNumber("1e4"));
ASSERT_EQUALS(0xFF00000000000000UL, MathLib::toLongNumber("0xFF00000000000000UL"));
ASSERT_EQUALS(0x0A00000000000000UL, MathLib::toLongNumber("0x0A00000000000000UL"));
astyle formatting
2009-12-27 17:46:24 +01:00
// from hex
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
added further testcases to testmathlib::convert(); now the conversion of +-[hexnumber|octalnumber] works correctly
2009-12-27 15:18:18 +01:00
ASSERT_EQUALS(-10995, MathLib::toLongNumber("-0x2AF3"));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(10, MathLib::toLongNumber("+0xa"));
ASSERT_EQUALS(10995, MathLib::toLongNumber("+0x2AF3"));
added further testcases to testmathlib::convert(); now the conversion of +-[hexnumber|octalnumber] works correctly
2009-12-27 15:18:18 +01:00
astyle formatting
2009-12-27 17:46:24 +01:00
// from octal
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
added further testcases to testmathlib::convert(); now the conversion of +-[hexnumber|octalnumber] works correctly
2009-12-27 15:18:18 +01:00
Implemented support for binary numbers (#4113)
2012-09-10 21:13:32 +02:00
// from binary
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(0, MathLib::toLongNumber("0b0"));
ASSERT_EQUALS(1, MathLib::toLongNumber("0b1"));
Mathlib: Fix value of suffixed binary integer literal (#2487)
2020-01-12 08:11:12 +01:00
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"));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(1, MathLib::toLongNumber("+0b1"));
ASSERT_EQUALS(-1, MathLib::toLongNumber("-0b1"));
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_EQUALS(9U, MathLib::toLongNumber("011"));
ASSERT_EQUALS(5U, MathLib::toLongNumber("0b101"));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(215, MathLib::toLongNumber("0b11010111"));
ASSERT_EQUALS(-215, MathLib::toLongNumber("-0b11010111"));
ASSERT_EQUALS(215, MathLib::toLongNumber("0B11010111"));
Implemented support for binary numbers (#4113)
2012-09-10 21:13:32 +02:00
astyle formatting
2009-12-27 17:46:24 +01:00
// from base 10
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
Corrections for non-Microsoft compilers
2015-06-28 12:34:08 +02:00
MathLib::toLongNumber: Better handling of '\x12' and '\000' char constants
2015-11-20 18:57:48 +01:00
// from char
ASSERT_EQUALS((int)('A'), MathLib::toLongNumber("'A'"));
MathLib: fix for octal char literal '\200'
2016-10-16 13:42:20 +02:00
ASSERT_EQUALS((int)('\x10'), MathLib::toLongNumber("'\\x10'"));
ASSERT_EQUALS((int)('\100'), MathLib::toLongNumber("'\\100'"));
ASSERT_EQUALS((int)('\200'), MathLib::toLongNumber("'\\200'"));
Keep prefix in string and char literals (#2272) Keeping the prefix in the token allows cppcheck to print the correct string and char literals in debug and error messages. To achieve this, move some of the helper functions from token.cpp to utils.h so that checks that look at string and char literals can reuse them. This is a large part of this commit. Note that the only user visible change is that when string and char literals are printed in error messages, the prefix is now included. For example: int f() { return test.substr( 0 , 4 ) == U"Hello" ? 0 : 1 ; }; now prints U"Hello" instead of "Hello" in the error message.
2019-10-16 11:41:33 +02:00
ASSERT_EQUALS((int)(L'A'), MathLib::toLongNumber("L'A'"));
Fix some compiler in MathLib::characterLiteralToLongNumber + some small refactoring
2015-11-23 20:41:21 +01:00
Corrections for non-Microsoft compilers
2015-06-28 12:34:08 +02:00
ASSERT_EQUALS(-8552249625308161526, MathLib::toLongNumber("0x89504e470d0a1a0a"));
ASSERT_EQUALS(-8481036456200365558, MathLib::toLongNumber("0x8a4d4e470d0a1a0a"));
added acos() check to ticket #1513; added testcases for MathLib::toDoubleNumber(), now double conversion of zeros is handled correctly; changed assertEquals() function of testsuite parameters from unsigned int to double. This is needed to avoid overflow of unsigned int by comparing negative floating point values.
2010-04-02 20:23:37 +02:00
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
// from long long
/*
* ASSERT_EQUALS(0xFF00000000000000LL, MathLib::toLongNumber("0xFF00000000000000LL"));
* This does not work in a portable way!
* While it succeeds on 32bit Visual Studio it fails on Linux 64bit because it is greater than 0x7FFFFFFFFFFFFFFF (=LLONG_MAX)
*/
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())));
// 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::bigint i = -0xFFFFFFFFFFFFFFFF;
ASSERT_EQUALS(i, MathLib::toLongNumber(std::to_string(i)));
ASSERT_EQUALS(i, MathLib::toLongNumber("-0xFFFFFFFFFFFFFFFF"));
}
ASSERT_THROW_EQUALS(MathLib::toLongNumber("0x10000000000000000"), InternalError, "Internal Error. MathLib::toLongNumber: out_of_range: 0x10000000000000000");
ASSERT_THROW_EQUALS(MathLib::toLongNumber("-0x10000000000000000"), InternalError, "Internal Error. MathLib::toLongNumber: out_of_range: -0x10000000000000000");
// 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::bigint i = -01777777777777777777777;
ASSERT_EQUALS(i, MathLib::toLongNumber(std::to_string(i)));
ASSERT_EQUALS(i, MathLib::toLongNumber("-01777777777777777777777"));
}
ASSERT_THROW_EQUALS(MathLib::toLongNumber("02000000000000000000000"), InternalError, "Internal Error. MathLib::toLongNumber: out_of_range: 02000000000000000000000");
ASSERT_THROW_EQUALS(MathLib::toLongNumber("-02000000000000000000000"), InternalError, "Internal Error. MathLib::toLongNumber: out_of_range: -02000000000000000000000");
// min/max and out-of-bounds - decimal
fixed/suppressed several compiler warnings (#5327)
2023-08-16 19:35:53 +02:00
SUPPRESS_WARNING_CLANG_PUSH("-Wimplicitly-unsigned-literal")
SUPPRESS_WARNING_GCC_PUSH("-Woverflow")
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
{
const MathLib::bigint i = 18446744073709551615;
ASSERT_EQUALS(i, MathLib::toLongNumber(std::to_string(i)));
ASSERT_EQUALS(i, MathLib::toLongNumber("18446744073709551615"));
}
{
const MathLib::bigint i = -18446744073709551615;
ASSERT_EQUALS(i, MathLib::toLongNumber(std::to_string(i)));
ASSERT_EQUALS(i, MathLib::toLongNumber("-18446744073709551615"));
}
fixed/suppressed several compiler warnings (#5327)
2023-08-16 19:35:53 +02:00
SUPPRESS_WARNING_GCC_POP
SUPPRESS_WARNING_CLANG_POP
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
fixed/suppressed several compiler warnings (#5327)
2023-08-16 19:35:53 +02:00
ASSERT_THROW_EQUALS(MathLib::toLongNumber("18446744073709551616"), InternalError, "Internal Error. MathLib::toLongNumber: out_of_range: 18446744073709551616");
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_THROW_EQUALS(MathLib::toLongNumber("-18446744073709551616"), InternalError, "Internal Error. MathLib::toLongNumber: out_of_range: -18446744073709551616");
ASSERT_THROW_EQUALS(MathLib::toLongNumber("invalid"), InternalError, "Internal Error. MathLib::toLongNumber: invalid_argument: invalid");
ASSERT_THROW_EQUALS(MathLib::toLongNumber("1invalid"), InternalError, "Internal Error. MathLib::toLongNumber: input was not completely consumed: 1invalid");
ASSERT_THROW_EQUALS(MathLib::toLongNumber("1 invalid"), InternalError, "Internal Error. MathLib::toLongNumber: input was not completely consumed: 1 invalid");
// TODO: test binary
// TODO: test floating point
// TODO: test with 128-bit values
}
void toULongNumber() const {
Improved test coverage of MathLib.
2014-12-03 18:24:27 +01:00
// zero input
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_EQUALS(0, MathLib::toULongNumber("0"));
ASSERT_EQUALS(0, MathLib::toULongNumber("-0"));
ASSERT_EQUALS(0, MathLib::toULongNumber("+0"));
ASSERT_EQUALS(0, MathLib::toULongNumber("0L"));
ASSERT_EQUALS(0, MathLib::toULongNumber("0l"));
ASSERT_EQUALS(0, MathLib::toULongNumber("0LL"));
ASSERT_EQUALS(0, MathLib::toULongNumber("0ll"));
ASSERT_EQUALS(0, MathLib::toULongNumber("0U"));
ASSERT_EQUALS(0, MathLib::toULongNumber("0u"));
ASSERT_EQUALS(0, MathLib::toULongNumber("0UL"));
ASSERT_EQUALS(0, MathLib::toULongNumber("0ul"));
ASSERT_EQUALS(0, MathLib::toULongNumber("0ULL"));
ASSERT_EQUALS(0, MathLib::toULongNumber("0ull"));
ASSERT_EQUALS(0, MathLib::toULongNumber("0i64")); // Visual Studio-specific
ASSERT_EQUALS(0, MathLib::toULongNumber("0ui64")); // Visual Studio-specific
// TODO: needs to fail
//ASSERT_EQUALS(0, MathLib::toULongNumber("0lll"));
//ASSERT_EQUALS(0, MathLib::toULongNumber("0uu"));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(1U, MathLib::toULongNumber("1U"));
ASSERT_EQUALS(10000U, MathLib::toULongNumber("1e4"));
ASSERT_EQUALS(10000U, MathLib::toULongNumber("1e4"));
Increase test coverage for MathLib
2014-11-26 17:35:32 +01:00
ASSERT_EQUALS(0xFF00000000000000UL, MathLib::toULongNumber("0xFF00000000000000UL"));
ASSERT_EQUALS(0x0A00000000000000UL, MathLib::toULongNumber("0x0A00000000000000UL"));
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
// from hex
ASSERT_EQUALS(0, MathLib::toULongNumber("0x0"));
ASSERT_EQUALS(0, MathLib::toULongNumber("-0x0"));
ASSERT_EQUALS(0, MathLib::toULongNumber("+0x0"));
ASSERT_EQUALS(10, MathLib::toULongNumber("0xa"));
ASSERT_EQUALS(10995, MathLib::toULongNumber("0x2AF3"));
ASSERT_EQUALS(-10, MathLib::toULongNumber("-0xa"));
ASSERT_EQUALS(-10995, MathLib::toULongNumber("-0x2AF3"));
ASSERT_EQUALS(10, MathLib::toULongNumber("+0xa"));
ASSERT_EQUALS(10995, MathLib::toULongNumber("+0x2AF3"));
// from octal
ASSERT_EQUALS(8, MathLib::toULongNumber("010"));
ASSERT_EQUALS(8, MathLib::toULongNumber("+010"));
ASSERT_EQUALS(-8, MathLib::toULongNumber("-010"));
ASSERT_EQUALS(125, MathLib::toULongNumber("0175"));
ASSERT_EQUALS(125, MathLib::toULongNumber("+0175"));
ASSERT_EQUALS(-125, MathLib::toULongNumber("-0175"));
// from binary
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(1, MathLib::toULongNumber("+0b1"));
ASSERT_EQUALS(-1, MathLib::toULongNumber("-0b1"));
ASSERT_EQUALS(9U, MathLib::toULongNumber("011"));
ASSERT_EQUALS(5U, MathLib::toULongNumber("0b101"));
ASSERT_EQUALS(215, MathLib::toULongNumber("0b11010111"));
ASSERT_EQUALS(-215, MathLib::toULongNumber("-0b11010111"));
ASSERT_EQUALS(215, MathLib::toULongNumber("0B11010111"));
// from base 10
ASSERT_EQUALS(10, MathLib::toULongNumber("10"));
ASSERT_EQUALS(10, MathLib::toULongNumber("10."));
ASSERT_EQUALS(10, MathLib::toULongNumber("10.0"));
ASSERT_EQUALS(100, MathLib::toULongNumber("10E+1"));
ASSERT_EQUALS(1, MathLib::toULongNumber("10E-1"));
ASSERT_EQUALS(100, MathLib::toULongNumber("+10E+1"));
ASSERT_EQUALS(-1, MathLib::toULongNumber("-10E-1"));
ASSERT_EQUALS(100, MathLib::toULongNumber("+10.E+1"));
ASSERT_EQUALS(-1, MathLib::toULongNumber("-10.E-1"));
ASSERT_EQUALS(100, MathLib::toULongNumber("+10.0E+1"));
ASSERT_EQUALS(-1, MathLib::toULongNumber("-10.0E-1"));
// from char
ASSERT_EQUALS((int)('A'), MathLib::toULongNumber("'A'"));
ASSERT_EQUALS((int)('\x10'), MathLib::toULongNumber("'\\x10'"));
ASSERT_EQUALS((int)('\100'), MathLib::toULongNumber("'\\100'"));
ASSERT_EQUALS((int)('\200'), MathLib::toULongNumber("'\\200'"));
ASSERT_EQUALS((int)(L'A'), MathLib::toULongNumber("L'A'"));
ASSERT_EQUALS(9894494448401390090ULL, MathLib::toULongNumber("0x89504e470d0a1a0a"));
ASSERT_EQUALS(9965707617509186058ULL, MathLib::toULongNumber("0x8a4d4e470d0a1a0a"));
Increase test coverage for MathLib
2014-11-26 17:35:32 +01:00
Fixed #4295 (False positive: Expression '(X & 0xFF00000000000000LL)==0xa00000000000000' always evaluates to false (64-bit value))
2012-11-27 17:37:49 +01:00
// from long long
Corrections for non-Microsoft compilers
2015-06-28 12:34:08 +02:00
/*
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
* ASSERT_EQUALS(0xFF00000000000000LL, MathLib::toULongNumber("0xFF00000000000000LL"));
Corrections for non-Microsoft compilers
2015-06-28 12:34:08 +02:00
* This does not work in a portable way!
Fixed typo in comment. No functional changes.
2015-07-15 15:29:35 +02:00
* While it succeeds on 32bit Visual Studio it fails on Linux 64bit because it is greater than 0x7FFFFFFFFFFFFFFF (=LLONG_MAX)
Fix compiler error (VS2010) and warning
2015-11-22 16:56:44 +01:00
*/
Corrections for non-Microsoft compilers
2015-06-28 12:34:08 +02:00
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_EQUALS(0x0A00000000000000LL, MathLib::toULongNumber("0x0A00000000000000LL"));
some MathLib adjustments for out-of-range numbers after std::stringstream removal (#3100)
2021-02-13 19:10:45 +01:00
// min/max numeric limits
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::biguint u = 0xFFFFFFFFFFFFFFFF;
ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));
ASSERT_EQUALS(u, MathLib::toULongNumber("0xFFFFFFFFFFFFFFFF"));
}
{
const MathLib::biguint u = -0xFFFFFFFFFFFFFFFF;
ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));
ASSERT_EQUALS(u, MathLib::toULongNumber("-0xFFFFFFFFFFFFFFFF"));
}
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_THROW_EQUALS(MathLib::toULongNumber("0x10000000000000000"), InternalError, "Internal Error. MathLib::toULongNumber: out_of_range: 0x10000000000000000");
ASSERT_THROW_EQUALS(MathLib::toULongNumber("-0x10000000000000000"), InternalError, "Internal Error. MathLib::toULongNumber: out_of_range: -0x10000000000000000");
some MathLib adjustments for out-of-range numbers after std::stringstream removal (#3100)
2021-02-13 19:10:45 +01:00
// min/max and out-of-bounds - octal
{
const MathLib::biguint u = 01777777777777777777777;
ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));
ASSERT_EQUALS(u, MathLib::toULongNumber("01777777777777777777777"));
}
{
const MathLib::biguint u = -01777777777777777777777;
ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));
ASSERT_EQUALS(u, MathLib::toULongNumber("-01777777777777777777777"));
}
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_THROW_EQUALS(MathLib::toULongNumber("02000000000000000000000"), InternalError, "Internal Error. MathLib::toULongNumber: out_of_range: 02000000000000000000000");
ASSERT_THROW_EQUALS(MathLib::toULongNumber("-02000000000000000000000"), InternalError, "Internal Error. MathLib::toULongNumber: out_of_range: -02000000000000000000000");
some MathLib adjustments for out-of-range numbers after std::stringstream removal (#3100)
2021-02-13 19:10:45 +01:00
// min/max and out-of-bounds - decimal
fixed/suppressed several compiler warnings (#5327)
2023-08-16 19:35:53 +02:00
SUPPRESS_WARNING_CLANG_PUSH("-Wimplicitly-unsigned-literal")
SUPPRESS_WARNING_GCC_PUSH("-Woverflow")
some MathLib adjustments for out-of-range numbers after std::stringstream removal (#3100)
2021-02-13 19:10:45 +01:00
{
const MathLib::biguint u = 18446744073709551615;
ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));
ASSERT_EQUALS(u, MathLib::toULongNumber("18446744073709551615"));
}
{
const MathLib::biguint u = -18446744073709551615;
ASSERT_EQUALS(u, MathLib::toULongNumber(std::to_string(u)));
ASSERT_EQUALS(u, MathLib::toULongNumber("-18446744073709551615"));
}
fixed/suppressed several compiler warnings (#5327)
2023-08-16 19:35:53 +02:00
SUPPRESS_WARNING_GCC_POP
SUPPRESS_WARNING_CLANG_POP
some MathLib adjustments for out-of-range numbers after std::stringstream removal (#3100)
2021-02-13 19:10:45 +01:00
fixed/suppressed several compiler warnings (#5327)
2023-08-16 19:35:53 +02:00
ASSERT_THROW_EQUALS(MathLib::toULongNumber("18446744073709551616"), InternalError, "Internal Error. MathLib::toULongNumber: out_of_range: 18446744073709551616");
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_THROW_EQUALS(MathLib::toULongNumber("-18446744073709551616"), InternalError, "Internal Error. MathLib::toULongNumber: out_of_range: -18446744073709551616");
ASSERT_THROW_EQUALS(MathLib::toULongNumber("invalid"), InternalError, "Internal Error. MathLib::toULongNumber: invalid_argument: invalid");
ASSERT_THROW_EQUALS(MathLib::toULongNumber("1invalid"), InternalError, "Internal Error. MathLib::toULongNumber: input was not completely consumed: 1invalid");
ASSERT_THROW_EQUALS(MathLib::toULongNumber("1 invalid"), InternalError, "Internal Error. MathLib::toULongNumber: input was not completely consumed: 1 invalid");
some MathLib adjustments for out-of-range numbers after std::stringstream removal (#3100)
2021-02-13 19:10:45 +01:00
// TODO: test binary
// TODO: test floating point
// TODO: test with 128-bit values
MathLib::toLongNumber: Better handling of '\x12' and '\000' char constants
2015-11-20 18:57:48 +01:00
}
Fixed #4295 (False positive: Expression '(X & 0xFF00000000000000LL)==0xa00000000000000' always evaluates to false (64-bit value))
2012-11-27 17:37:49 +01:00
improve constness of functions as per cppchecks suggestions.
2017-01-07 14:13:22 +01:00
void toDoubleNumber() const {
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
// float values
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1."), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1.f"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1.F"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1.l"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1.L"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1.0"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1.0f"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1.0F"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1.0l"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1.0L"), 0.001);
Improve test coverage for reading numbers represented as strings
2020-01-21 17:29:33 +01:00
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("0x1"), 0.001);
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS_DOUBLE(10.0, MathLib::toDoubleNumber("10"), 0.001);
testsuite: don't compare doubles with !=
2017-10-10 22:40:49 +02:00
ASSERT_EQUALS_DOUBLE(1000.0, MathLib::toDoubleNumber("10E+2"), 0.001);
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_EQUALS_DOUBLE(1000.0, MathLib::toDoubleNumber("10E+2l"), 0.001);
ASSERT_EQUALS_DOUBLE(1000.0, MathLib::toDoubleNumber("10E+2L"), 0.001);
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS_DOUBLE(100.0, MathLib::toDoubleNumber("1.0E+2"), 0.001);
testsuite: don't compare doubles with !=
2017-10-10 22:40:49 +02:00
ASSERT_EQUALS_DOUBLE(-100.0, MathLib::toDoubleNumber("-1.0E+2"), 0.001);
ASSERT_EQUALS_DOUBLE(-1e+10, MathLib::toDoubleNumber("-1.0E+10"), 1);
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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);
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
// valid non-float values
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1l"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1L"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1ll"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1LL"), 0.001);
fixed #11428 - improved handling of suffixes in `MathLib::to{Double|ULong|Long}Number()` (#4635) * fixed #11428 - improved handling of suffices in `MathLib::to{Double|ULong|Long}Number()` * testmathlib.cpp: adjustments for `libc++` * mathlib.cpp: added TODO
2022-12-13 07:52:45 +01:00
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1u"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1U"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1ul"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1UL"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1ULL"), 0.001);
// TODO: make these work with libc++
#ifndef _LIBCPP_VERSION
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1i64"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1I64"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1ui64"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1UI64"), 0.001);
ASSERT_EQUALS_DOUBLE(1.0, MathLib::toDoubleNumber("1I64"), 0.001);
#endif
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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);
Keep prefix in string and char literals (#2272) Keeping the prefix in the token allows cppcheck to print the correct string and char literals in debug and error messages. To achieve this, move some of the helper functions from token.cpp to utils.h so that checks that look at string and char literals can reuse them. This is a large part of this commit. Note that the only user visible change is that when string and char literals are printed in error messages, the prefix is now included. For example: int f() { return test.substr( 0 , 4 ) == U"Hello" ? 0 : 1 ; }; now prints U"Hello" instead of "Hello" in the error message.
2019-10-16 11:41:33 +02:00
ASSERT_EQUALS_DOUBLE(L'0', MathLib::toDoubleNumber("L'0'"), 0.000001);
astyle fix
2010-04-02 20:42:06 +02:00
Implement hexadecimal float conversion in MathLib::toDoubleNumber ind… (#1506) * Implement hexadecimal float conversion in MathLib::toDoubleNumber independent of C99/C++17 * Refactor MathLib::isFloatHex and cure some false results
2018-12-06 22:16:16 +01:00
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);
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
// from char
ASSERT_EQUALS_DOUBLE((double)('A'), MathLib::toDoubleNumber("'A'"), 0.000001);
ASSERT_EQUALS_DOUBLE((double)('\x10'), MathLib::toDoubleNumber("'\\x10'"), 0.000001);
ASSERT_EQUALS_DOUBLE((double)('\100'), MathLib::toDoubleNumber("'\\100'"), 0.000001);
ASSERT_EQUALS_DOUBLE((double)('\200'), MathLib::toDoubleNumber("'\\200'"), 0.000001);
ASSERT_EQUALS_DOUBLE((double)(L'A'), MathLib::toDoubleNumber("L'A'"), 0.000001);
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("invalid"), InternalError, "Internal Error. MathLib::toDoubleNumber: conversion failed: invalid");
#ifdef _LIBCPP_VERSION
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1invalid"), InternalError, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1invalid");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.1invalid"), InternalError, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1.1invalid");
#else
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1invalid"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1invalid");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.1invalid"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.1invalid");
#endif
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1 invalid"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1 invalid");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("-1e-08.0"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: -1e-08.0");
fixed #11428 - improved handling of suffixes in `MathLib::to{Double|ULong|Long}Number()` (#4635) * fixed #11428 - improved handling of suffices in `MathLib::to{Double|ULong|Long}Number()` * testmathlib.cpp: adjustments for `libc++` * mathlib.cpp: added TODO
2022-12-13 07:52:45 +01:00
// invalid suffices
#ifdef _LIBCPP_VERSION
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1f"), InternalError, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1f");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1F"), InternalError, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1F");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.ff"), InternalError, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1.ff");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.FF"), InternalError, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1.FF");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.0ff"), InternalError, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1.0ff");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.0FF"), InternalError, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1.0FF");
#else
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1f"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1f");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1F"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1F");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.ff"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.ff");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.FF"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.FF");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.0ff"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.0ff");
ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.0FF"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.0FF");
#endif
// TODO: needs to fail
//ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.ll"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.ll");
//ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.0LL"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.0LL");
//ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.0ll"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.0ll");
//ASSERT_THROW_EQUALS(MathLib::toDoubleNumber("1.0LL"), InternalError, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.0LL");
simplifyMathFunctions: added support for exp(),sqrt(),cbrt() functions.
2013-09-29 18:11:17 +02:00
// verify: string --> double --> string conversion
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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")));
testing mathlib: Test that conversion to numbers work
2009-05-02 11:12:49 +02:00
}
Don't warn about division by zero if zero if floating point number. Fix bug from mathlib isInt() and add test case from which few are false positives
2009-09-01 21:06:46 +02:00
astyle formatting
2014-11-20 14:20:09 +01:00
void isint() const {
astyle formatting
2009-12-27 17:46:24 +01:00
// zero tests
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(true, MathLib::isInt("0"));
added further testcases to testmathlib::isint()
2009-12-27 14:46:47 +01:00
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"));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
added further testcases to testmathlib::isint()
2009-12-27 14:46:47 +01:00
ASSERT_EQUALS(false, MathLib::isInt("-1E-1"));
astyle formatting
2009-12-27 17:46:24 +01:00
ASSERT_EQUALS(false, MathLib::isInt("-1E-10000"));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
Don't warn about division by zero if zero if floating point number. Fix bug from mathlib isInt() and add test case from which few are false positives
2009-09-01 21:06:46 +02:00
ASSERT_EQUALS(false, MathLib::isInt("0.4"));
ASSERT_EQUALS(false, MathLib::isInt("2352.3f"));
added further testcases to testmathlib::isint()
2009-12-27 14:46:47 +01:00
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"));
coverage report fix: more testcases for mathlib::isInt() added in order to get a better coverage
2010-04-02 22:18:50 +02:00
ASSERT_EQUALS(false, MathLib::isInt(" 1.0E+1"));
Fixed some spelling mistakes
2010-12-15 18:45:53 +01:00
// with whitespace in front
coverage report fix: more testcases for mathlib::isInt() added in order to get a better coverage
2010-04-02 22:18:50 +02:00
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"));
Fixed some spelling mistakes
2010-12-15 18:45:53 +01:00
// with whitespace in front and end
coverage report fix: more testcases for mathlib::isInt() added in order to get a better coverage
2010-04-02 22:18:50 +02:00
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 "));
Fixed some spelling mistakes
2010-12-15 18:45:53 +01:00
// with whitespace in front and end
coverage report fix: more testcases for mathlib::isInt() added in order to get a better coverage
2010-04-02 22:18:50 +02:00
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 "));
mathlib:isInt() now handles calles of 'u' and 'l' correctly; testcases added
2010-05-12 23:49:09 +02:00
// 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"));
Fixed #5304 (Wrong simplification of numbers like 001E+07 to 1.0)
2014-02-20 16:56:49 +01:00
ASSERT_EQUALS(false, MathLib::isInt("e2"));
ASSERT_EQUALS(false, MathLib::isInt("E2"));
ASSERT_EQUALS(false, MathLib::isInt(".e2"));
ASSERT_EQUALS(false, MathLib::isInt(".E2"));
Fixed #5571 (Clean up MathLib::isInt())
2014-03-16 11:55:44 +01:00
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(""));
Don't warn about division by zero if zero if floating point number. Fix bug from mathlib isInt() and add test case from which few are false positives
2009-09-01 21:06:46 +02:00
}
ticket #1513 new check: Detecting obviously wrong math call arguments passed to math functions)
2010-04-02 02:19:38 +02:00
astyle formatting
2014-11-20 14:20:09 +01:00
void isbin() const {
MathLib::isBin(): fix missing detection of U and L suffix combinations. Added missing test cases.
2014-03-10 17:23:07 +01:00
// 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(""));
}
astyle formatting
2014-11-20 14:20:09 +01:00
void isnegative() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
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"));
ticket #1513 new check: Detecting obviously wrong math call arguments passed to math functions)
2010-04-02 02:19:38 +02:00
astyle formatting
2010-04-02 07:32:03 +02:00
ASSERT_EQUALS(false, MathLib::isNegative("+1"));
ticket #1513 new check: Detecting obviously wrong math call arguments passed to math functions)
2010-04-02 02:19:38 +02:00
ASSERT_EQUALS(false, MathLib::isNegative("+1."));
ASSERT_EQUALS(false, MathLib::isNegative("+1.0"));
ASSERT_EQUALS(false, MathLib::isNegative("+1.0E+2"));
astyle formatting
2010-04-02 07:32:03 +02:00
ASSERT_EQUALS(false, MathLib::isNegative("+1.0E-2"));
Fixed #5571 (Clean up MathLib::isInt())
2014-03-16 11:55:44 +01:00
// test empty string
ASSERT_EQUALS(false, MathLib::isNegative(""));
astyle formatting
2010-04-02 07:32:03 +02:00
}
ticket #1513 new check: Detecting obviously wrong math call arguments passed to math functions)
2010-04-02 02:19:38 +02:00
astyle formatting
2014-11-20 14:20:09 +01:00
void isoct() const {
MathLib::isOct() fix missing detection of U and L suffix combinations and unittests.
2014-03-09 21:14:14 +01:00
// 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 "));
Tidy up MathLib::isInt() - using a state machine approach
2014-04-10 22:46:55 +02:00
ASSERT_EQUALS(false, MathLib::isOct("+042LUL+0"));
MathLib::isOct() fix missing detection of U and L suffix combinations and unittests.
2014-03-09 21:14:14 +01:00
}
MathLib::isFloat now detects C99 hexadecimal float literals. MathLib::isDecimalFloat was added for C++ and pre-C99 compatibility.
2015-07-26 19:21:53 +02:00
void isFloatHex() const {
Implement MathLib::isFloatHex to detect C99 hexadecimal floating pointer literals. Rename MathLib::isHex to MathLib::isIntHex
2015-07-26 08:06:56 +02:00
// 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"));
Fix some glitches from previous commit to TestMathLib
2015-07-26 19:47:27 +02:00
ASSERT_EQUALS(true, MathLib::isFloatHex("0xA.Fp-10"));
Implement hexadecimal float conversion in MathLib::toDoubleNumber ind… (#1506) * Implement hexadecimal float conversion in MathLib::toDoubleNumber independent of C99/C++17 * Refactor MathLib::isFloatHex and cure some false results
2018-12-06 22:16:16 +01:00
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"));
Implement MathLib::isFloatHex to detect C99 hexadecimal floating pointer literals. Rename MathLib::isHex to MathLib::isIntHex
2015-07-26 08:06:56 +02:00
Implement hexadecimal float conversion in MathLib::toDoubleNumber ind… (#1506) * Implement hexadecimal float conversion in MathLib::toDoubleNumber independent of C99/C++17 * Refactor MathLib::isFloatHex and cure some false results
2018-12-06 22:16:16 +01:00
ASSERT_EQUALS(false, MathLib::isFloatHex(""));
Implement MathLib::isFloatHex to detect C99 hexadecimal floating pointer literals. Rename MathLib::isHex to MathLib::isIntHex
2015-07-26 08:06:56 +02:00
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"));
improved testing of calculations in valueflow
2015-07-26 12:00:42 +02:00
ASSERT_EQUALS(false, MathLib::isFloatHex("0x."));
ASSERT_EQUALS(false, MathLib::isFloatHex("0XP"));
Implement MathLib::isFloatHex to detect C99 hexadecimal floating pointer literals. Rename MathLib::isHex to MathLib::isIntHex
2015-07-26 08:06:56 +02:00
ASSERT_EQUALS(false, MathLib::isFloatHex("0xx"));
Implement hexadecimal float conversion in MathLib::toDoubleNumber ind… (#1506) * Implement hexadecimal float conversion in MathLib::toDoubleNumber independent of C99/C++17 * Refactor MathLib::isFloatHex and cure some false results
2018-12-06 22:16:16 +01:00
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"));
Implement MathLib::isFloatHex to detect C99 hexadecimal floating pointer literals. Rename MathLib::isHex to MathLib::isIntHex
2015-07-26 08:06:56 +02:00
}
MathLib::isFloat now detects C99 hexadecimal float literals. MathLib::isDecimalFloat was added for C++ and pre-C99 compatibility.
2015-07-26 19:21:53 +02:00
void isIntHex() const {
MathLib:isHex(): fix detection of missing suffixes (U,L).
2014-03-11 20:02:04 +01:00
// hex number syntax: [sign]0x[hexnumbers][suffix]
// positive testing
Implement MathLib::isFloatHex to detect C99 hexadecimal floating pointer literals. Rename MathLib::isHex to MathLib::isIntHex
2015-07-26 08:06:56 +02:00
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"));
Support integer Z suffix and user defined literals with _ suffix (#10807, #11438) (#5130) Co-authored-by: Carl Morgan <no-reply@crown.com>
2023-06-08 20:03:41 +02:00
ASSERT_EQUALS(true, MathLib::isIntHex("+0x0Z"));
ASSERT_EQUALS(true, MathLib::isIntHex("-0x0Z"));
ASSERT_EQUALS(true, MathLib::isIntHex("+0x0ZU"));
ASSERT_EQUALS(true, MathLib::isIntHex("-0x0ZU"));
ASSERT_EQUALS(true, MathLib::isIntHex("+0x0UZ"));
ASSERT_EQUALS(true, MathLib::isIntHex("-0x0UZ"));
ASSERT_EQUALS(true, MathLib::isIntHex("+0x0Uz"));
ASSERT_EQUALS(true, MathLib::isIntHex("-0x0Uz"));
MathLib:isHex(): fix detection of missing suffixes (U,L).
2014-03-11 20:02:04 +01:00
// negative testing
Implement MathLib::isFloatHex to detect C99 hexadecimal floating pointer literals. Rename MathLib::isHex to MathLib::isIntHex
2015-07-26 08:06:56 +02:00
ASSERT_EQUALS(false, MathLib::isIntHex("+0x"));
ASSERT_EQUALS(false, MathLib::isIntHex("-0x"));
ASSERT_EQUALS(false, MathLib::isIntHex("0x"));
Address compiler warning
2018-12-19 14:39:04 +01:00
ASSERT_EQUALS(false, MathLib::isIntHex("0xl"));
Implement MathLib::isFloatHex to detect C99 hexadecimal floating pointer literals. Rename MathLib::isHex to MathLib::isIntHex
2015-07-26 08:06:56 +02:00
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("+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"));
MathLib:isHex(): fix detection of missing suffixes (U,L).
2014-03-11 20:02:04 +01:00
// test empty string
Implement MathLib::isFloatHex to detect C99 hexadecimal floating pointer literals. Rename MathLib::isHex to MathLib::isIntHex
2015-07-26 08:06:56 +02:00
ASSERT_EQUALS(false, MathLib::isIntHex(""));
MathLib:isHex(): fix detection of missing suffixes (U,L).
2014-03-11 20:02:04 +01:00
}
Various clang-tidy fixes (#2192) * use range loops * removed redundant string initializations * use nullptr * use proper boolean false * removed unnecessary continue from end of loop * removed unnecessary c_str() usage * use emplace_back() * removed redundant void arguments
2019-09-25 15:25:19 +02:00
void isValidIntegerSuffix() const {
Fixed #6281: MathLib: Long integer suffix i64 is not supported.
2014-11-20 10:23:09 +01:00
// negative testing
Correct detection of Microsoft extensions in MathLib::isValidIntegerSuffix. Remove public overloaded implementation which was not used outside mathlib.cpp. (#1531)
2018-12-20 12:20:31 +01:00
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix(""));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("ux"));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("ulx"));
fixed #11428 - improved handling of suffixes in `MathLib::to{Double|ULong|Long}Number()` (#4635) * fixed #11428 - improved handling of suffices in `MathLib::to{Double|ULong|Long}Number()` * testmathlib.cpp: adjustments for `libc++` * mathlib.cpp: added TODO
2022-12-13 07:52:45 +01:00
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("uu"));
Correct detection of Microsoft extensions in MathLib::isValidIntegerSuffix. Remove public overloaded implementation which was not used outside mathlib.cpp. (#1531)
2018-12-20 12:20:31 +01:00
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("lx"));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("lux"));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("lll"));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("garbage"));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("llu "));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("i"));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("iX"));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("i6X"));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("i64X"));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("i64 "));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("i66"));
Fixed #6281: MathLib: Long integer suffix i64 is not supported.
2014-11-20 10:23:09 +01:00
// positive testing
Correct detection of Microsoft extensions in MathLib::isValidIntegerSuffix. Remove public overloaded implementation which was not used outside mathlib.cpp. (#1531)
2018-12-20 12:20:31 +01:00
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("u"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("ul"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("ull"));
Support integer Z suffix and user defined literals with _ suffix (#10807, #11438) (#5130) Co-authored-by: Carl Morgan <no-reply@crown.com>
2023-06-08 20:03:41 +02:00
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("uz"));
Correct detection of Microsoft extensions in MathLib::isValidIntegerSuffix. Remove public overloaded implementation which was not used outside mathlib.cpp. (#1531)
2018-12-20 12:20:31 +01:00
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("l"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("lu"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("ll"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("llu"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("llU"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("LLU"));
Support integer Z suffix and user defined literals with _ suffix (#10807, #11438) (#5130) Co-authored-by: Carl Morgan <no-reply@crown.com>
2023-06-08 20:03:41 +02:00
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("z"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("Z"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("zu"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("UZ"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("ZU"));
Correct detection of Microsoft extensions in MathLib::isValidIntegerSuffix. Remove public overloaded implementation which was not used outside mathlib.cpp. (#1531)
2018-12-20 12:20:31 +01:00
// Microsoft extensions:
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("i64"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("I64"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("ui64"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("UI64"));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("i64", false));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("I64", false));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("ui64", false));
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("UI64", false));
Support integer Z suffix and user defined literals with _ suffix (#10807, #11438) (#5130) Co-authored-by: Carl Morgan <no-reply@crown.com>
2023-06-08 20:03:41 +02:00
// User defined suffix literals
ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("_"));
ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("_MyUserDefinedLiteral"));
Fixed #6281: MathLib: Long integer suffix i64 is not supported.
2014-11-20 10:23:09 +01:00
}
astyle formatting
2014-11-20 14:20:09 +01:00
void ispositive() const {
Improved simplifyMathFunctions when simplifying special cases of pow(x,y)-function.
2013-09-29 15:11:09 +02:00
ASSERT_EQUALS(false, MathLib::isPositive("-1"));
ASSERT_EQUALS(false, MathLib::isPositive("-1."));
ASSERT_EQUALS(false, MathLib::isPositive("-1.0"));
ASSERT_EQUALS(false, MathLib::isPositive("-1.0E+2"));
ASSERT_EQUALS(false, MathLib::isPositive("-1.0E-2"));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(true, MathLib::isPositive("+1"));
ASSERT_EQUALS(true, MathLib::isPositive("+1."));
ASSERT_EQUALS(true, MathLib::isPositive("+1.0"));
ASSERT_EQUALS(true, MathLib::isPositive("+1.0E+2"));
ASSERT_EQUALS(true, MathLib::isPositive("+1.0E-2"));
Fixed #5571 (Clean up MathLib::isInt())
2014-03-16 11:55:44 +01:00
// test empty string
MathLib::isFloat now detects C99 hexadecimal float literals. MathLib::isDecimalFloat was added for C++ and pre-C99 compatibility.
2015-07-26 19:21:53 +02:00
ASSERT_EQUALS(false, MathLib::isPositive("")); // "" is neither positive nor negative
Improved simplifyMathFunctions when simplifying special cases of pow(x,y)-function.
2013-09-29 15:11:09 +02:00
}
MathLib::isFloat now detects C99 hexadecimal float literals. MathLib::isDecimalFloat was added for C++ and pre-C99 compatibility.
2015-07-26 19:21:53 +02:00
void isFloat() const {
Fix some glitches from previous commit to TestMathLib
2015-07-26 19:47:27 +02:00
ASSERT_EQUALS(false, MathLib::isFloat(""));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(true, MathLib::isFloat("0.f"));
ASSERT_EQUALS(true, MathLib::isFloat("0.f"));
ASSERT_EQUALS(true, MathLib::isFloat("0xA.Fp-10"));
Support integer Z suffix and user defined literals with _ suffix (#10807, #11438) (#5130) Co-authored-by: Carl Morgan <no-reply@crown.com>
2023-06-08 20:03:41 +02:00
// User defined suffix literals
ASSERT_EQUALS(false, MathLib::isFloat("0_"));
ASSERT_EQUALS(false, MathLib::isFloat("0._"));
ASSERT_EQUALS(false, MathLib::isFloat("0.1_"));
ASSERT_EQUALS(true, MathLib::isFloat("0.0_MyUserDefinedLiteral"));
ASSERT_EQUALS(true, MathLib::isFloat("0._MyUserDefinedLiteral"));
MathLib::isFloat now detects C99 hexadecimal float literals. MathLib::isDecimalFloat was added for C++ and pre-C99 compatibility.
2015-07-26 19:21:53 +02:00
}
void isDecimalFloat() const {
ASSERT_EQUALS(false, MathLib::isDecimalFloat(""));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("."));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("..."));
ASSERT_EQUALS(false, MathLib::isDecimalFloat(".e"));
Refactor methods for identification of numeric literals. (#1514)
2018-12-10 12:10:26 +01:00
ASSERT_EQUALS(false, MathLib::isDecimalFloat(".e2"));
MathLib::isFloat now detects C99 hexadecimal float literals. MathLib::isDecimalFloat was added for C++ and pre-C99 compatibility.
2015-07-26 19:21:53 +02:00
ASSERT_EQUALS(false, MathLib::isDecimalFloat(".E"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+E."));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+e."));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("-E."));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("-e."));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("-X"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+X"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("-."));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("-."));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("-"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat(" "));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("0"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("0 "));
ASSERT_EQUALS(false, MathLib::isDecimalFloat(" 0 "));
ASSERT_EQUALS(false, MathLib::isDecimalFloat(" 0"));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0."));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.f"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.F"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.l"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.L"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("0. "));
ASSERT_EQUALS(false, MathLib::isDecimalFloat(" 0. "));
ASSERT_EQUALS(false, MathLib::isDecimalFloat(" 0."));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("0.."));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("..0.."));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("..0"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.0"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.0f"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.0F"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.0l"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.0L"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("-0."));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+0."));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("-0.0"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+0.0"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0E0"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+0E0"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+0E0"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+0E+0"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+0E-0"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("-0E+0"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("-0E-0"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+0.0E+1"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+0.0E-1"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("-0.0E+1"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("-0.0E-1"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("1"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("-1"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+1"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1e+1"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+1"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+100"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+100f"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+100F"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+100l"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+100L"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+007")); // to be sure about #5485
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+001f"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+001F"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+001l"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+001L"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1E+10000"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("-1E+1"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("-1E+10000"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat(".1250E+04"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("-1E-1"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("-1E-10000"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1.23e+01"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("+1.23E+01"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+1e+x"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+1E+X"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+1E+001lX"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+1E+001LX"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+1E+001f2"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+1E+001F2"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+1e+003x"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("+1E+003X"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.4"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("2352.3f"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("2352.3F"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("2352.3l"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("2352.3L"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.00004"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("2352.00001f"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("2352.00001F"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("2352.00001l"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("2352.00001L"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat(".4"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat(".3e2"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("1.0E+1"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("1.0E-1"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("-1.0E+1"));
Support integer Z suffix and user defined literals with _ suffix (#10807, #11438) (#5130) Co-authored-by: Carl Morgan <no-reply@crown.com>
2023-06-08 20:03:41 +02:00
// User defined suffix literals
ASSERT_EQUALS(false, MathLib::isDecimalFloat("0_"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat(".1_"));
ASSERT_EQUALS(false, MathLib::isDecimalFloat("0.1_"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.0_MyUserDefinedLiteral"));
ASSERT_EQUALS(true, MathLib::isDecimalFloat(".1_MyUserDefinedLiteral"));
astyle formatting
2010-04-02 07:32:03 +02:00
}
MathLib: Return inf.0 for NAN and INF calculations
2013-07-19 09:27:33 +02:00
astyle formatting
2014-11-20 14:20:09 +01:00
void naninf() const {
Fixed #5142 (False positive with floating-point special cases in conditions)
2013-11-04 11:56:43 +01:00
ASSERT_EQUALS("nan.0", MathLib::divide("0.0", "0.0")); // nan
astyle run [ci skip]
2014-05-16 23:01:21 +02:00
ASSERT_EQUALS("nan.0", MathLib::divide("0.0", "0.f")); // nan (#5875)
ASSERT_EQUALS("nan.0", MathLib::divide("-0.0", "0.f")); // nan (#5875)
ASSERT_EQUALS("nan.0", MathLib::divide("-0.f", "0.f")); // nan (#5875)
ASSERT_EQUALS("nan.0", MathLib::divide("-0.0", "-0.f")); // nan (#5875)
ASSERT_EQUALS("nan.0", MathLib::divide("-.0", "-0.f")); // nan (#5875)
ASSERT_EQUALS("nan.0", MathLib::divide("0.0", "-0.f")); // nan (#5875)
ASSERT_EQUALS("nan.0", MathLib::divide("0.f", "-0.f")); // nan (#5875)
MathLib: Return inf.0 for NAN and INF calculations
2013-07-19 09:27:33 +02:00
ASSERT_EQUALS("inf.0", MathLib::divide("3.0", "0.0")); // inf
astyle run [ci skip]
2014-05-16 23:01:21 +02:00
ASSERT_EQUALS("inf.0", MathLib::divide("3.0", "0.f")); // inf (#5875)
Fixed #5142 (False positive with floating-point special cases in conditions)
2013-11-02 22:58:23 +01:00
ASSERT_EQUALS("-inf.0", MathLib::divide("-3.0", "0.0")); // -inf (#5142)
astyle run [ci skip]
2014-05-16 23:01:21 +02:00
ASSERT_EQUALS("-inf.0", MathLib::divide("-3.0", "0.0f")); // -inf (#5142)
Fix #11368 FP "Same value in both branches of ternary operator" on plus and minus zero (#4569) Fix #11368 FP "Same value in both branches of ternary operator" on plus and minus zero
2022-10-31 15:18:25 +01:00
ASSERT_EQUALS("inf.0", MathLib::divide("-3.0", "-0.0f")); // inf (#5142)
MathLib: Return inf.0 for NAN and INF calculations
2013-07-19 09:27:33 +02:00
}
astyle formatting
2014-11-14 21:43:37 +01:00
Various clang-tidy fixes (#2192) * use range loops * removed redundant string initializations * use nullptr * use proper boolean false * removed unnecessary continue from end of loop * removed unnecessary c_str() usage * use emplace_back() * removed redundant void arguments
2019-09-25 15:25:19 +02:00
void isdec() const {
MathLib: Added test for isDec() and removed not required state.
2014-11-14 04:29:35 +01:00
// positive testing
ASSERT_EQUALS(true, MathLib::isDec("1"));
ASSERT_EQUALS(true, MathLib::isDec("+1"));
ASSERT_EQUALS(true, MathLib::isDec("-1"));
ASSERT_EQUALS(true, MathLib::isDec("-100"));
ASSERT_EQUALS(true, MathLib::isDec("-1L"));
ASSERT_EQUALS(true, MathLib::isDec("1UL"));
// negative testing
ASSERT_EQUALS(false, MathLib::isDec("-1."));
ASSERT_EQUALS(false, MathLib::isDec("+1."));
ASSERT_EQUALS(false, MathLib::isDec("-x"));
ASSERT_EQUALS(false, MathLib::isDec("+x"));
ASSERT_EQUALS(false, MathLib::isDec("x"));
Refactor methods for identification of numeric literals. (#1514)
2018-12-10 12:10:26 +01:00
ASSERT_EQUALS(false, MathLib::isDec(""));
Support integer Z suffix and user defined literals with _ suffix (#10807, #11438) (#5130) Co-authored-by: Carl Morgan <no-reply@crown.com>
2023-06-08 20:03:41 +02:00
// User defined suffix literals
ASSERT_EQUALS(false, MathLib::isDec("0_"));
ASSERT_EQUALS(false, MathLib::isDec("+0_"));
ASSERT_EQUALS(false, MathLib::isDec("-1_"));
ASSERT_EQUALS(true, MathLib::isDec("0_MyUserDefinedLiteral"));
ASSERT_EQUALS(true, MathLib::isDec("+1_MyUserDefinedLiteral"));
ASSERT_EQUALS(true, MathLib::isDec("-1_MyUserDefinedLiteral"));
astyle formatting
2014-11-14 21:43:37 +01:00
}
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
astyle formatting
2014-11-20 14:20:09 +01:00
void isNullValue() const {
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
// inter zero value
ASSERT_EQUALS(true, MathLib::isNullValue("0"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0"));
// inter zero value (octal)
ASSERT_EQUALS(true, MathLib::isNullValue("00"));
ASSERT_EQUALS(true, MathLib::isNullValue("+00"));
ASSERT_EQUALS(true, MathLib::isNullValue("-00"));
// inter zero value (hex)
ASSERT_EQUALS(true, MathLib::isNullValue("0x0"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0x0"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0x0"));
Bugfix Mathlib::isNullValue for hexadecimal numbers (#2517)
2020-02-02 16:40:36 +01:00
ASSERT_EQUALS(true, MathLib::isNullValue("+0X0"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0X0"));
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
// unsigned integer zero value
ASSERT_EQUALS(true, MathLib::isNullValue("0U"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0U"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0U"));
// long integer zero value
ASSERT_EQUALS(true, MathLib::isNullValue("0L"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0L"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0L"));
// unsigned long integer zero value
ASSERT_EQUALS(true, MathLib::isNullValue("0UL"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0UL"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0UL"));
// unsigned long integer zero value
ASSERT_EQUALS(true, MathLib::isNullValue("0LU"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0LU"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0LU"));
// long long integer zero value
ASSERT_EQUALS(true, MathLib::isNullValue("0LL"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0LL"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0LL"));
testmathlib: Fixed typo in comment, no functional changes.
2015-01-14 00:51:50 +01:00
// long long unsigned zero value
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
ASSERT_EQUALS(true, MathLib::isNullValue("0LLU"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0LLU"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0LLU"));
// unsigned long long zero value
ASSERT_EQUALS(true, MathLib::isNullValue("0ULL"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0ULL"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0ULL"));
// floating pointer zero value (no trailing zero after dot)
ASSERT_EQUALS(true, MathLib::isNullValue("0."));
ASSERT_EQUALS(true, MathLib::isNullValue("+0."));
ASSERT_EQUALS(true, MathLib::isNullValue("-0."));
// floating pointer zero value (1 trailing zero after dot)
ASSERT_EQUALS(true, MathLib::isNullValue("0.0"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0.0"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0.0"));
// floating pointer zero value (3 trailing zeros after dot)
ASSERT_EQUALS(true, MathLib::isNullValue("0.000"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0.000"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0.000"));
// floating pointer zero value (no trailing zero after dot)
ASSERT_EQUALS(true, MathLib::isNullValue("00."));
ASSERT_EQUALS(true, MathLib::isNullValue("+00."));
ASSERT_EQUALS(true, MathLib::isNullValue("-00."));
// floating pointer zero value (1 trailing zero after dot)
ASSERT_EQUALS(true, MathLib::isNullValue("00.0"));
ASSERT_EQUALS(true, MathLib::isNullValue("+00.0"));
ASSERT_EQUALS(true, MathLib::isNullValue("-00.0"));
// floating pointer zero value (3 trailing zero after dot)
ASSERT_EQUALS(true, MathLib::isNullValue("00.000"));
ASSERT_EQUALS(true, MathLib::isNullValue("+00.000"));
ASSERT_EQUALS(true, MathLib::isNullValue("-00.000"));
// floating pointer zero value (3 trailing zero after dot)
ASSERT_EQUALS(true, MathLib::isNullValue(".000"));
// integer scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0E0"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0E0"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0E0"));
Bugfix Mathlib::isNullValue for hexadecimal numbers (#2517)
2020-02-02 16:40:36 +01:00
ASSERT_EQUALS(true, MathLib::isNullValue("+0e0"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0e0"));
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
// integer scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0E1"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0E1"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0E1"));
// integer scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0E42"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0E42"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0E42"));
// integer scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0E429999"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0E429999"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0E429999"));
// integer scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0E+1"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0E+1"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0E+1"));
// integer scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0E+42"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0E+42"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0E+42"));
// integer scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0E+429999"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0E+429999"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0E+429999"));
// integer scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0E-1"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0E-1"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0E-1"));
// integer scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0E-42"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0E-42"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0E-42"));
// integer scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0E-429999"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0E-429999"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0E-429999"));
// floating point scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0.E0"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0.E0"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0.E0"));
// floating point scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0.E-0"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0.E-0"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0.E+0"));
// floating point scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0.E+0"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0.E+0"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0.E+0"));
// floating point scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("0.00E-0"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0.00E-0"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0.00E-0"));
// floating point scientific notation
ASSERT_EQUALS(true, MathLib::isNullValue("00000.00E-000000000"));
ASSERT_EQUALS(true, MathLib::isNullValue("+00000.00E-000000000"));
ASSERT_EQUALS(true, MathLib::isNullValue("-00000.00E-000000000"));
// floating point scientific notation (suffix f)
ASSERT_EQUALS(true, MathLib::isNullValue("0.f"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0.f"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0.f"));
// floating point scientific notation (suffix f)
ASSERT_EQUALS(true, MathLib::isNullValue("0.0f"));
Bugfix Mathlib::isNullValue for hexadecimal numbers (#2517)
2020-02-02 16:40:36 +01:00
ASSERT_EQUALS(true, MathLib::isNullValue("0.0F"));
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
ASSERT_EQUALS(true, MathLib::isNullValue("+0.0f"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0.0f"));
// floating point scientific notation (suffix f)
ASSERT_EQUALS(true, MathLib::isNullValue("00.0f"));
ASSERT_EQUALS(true, MathLib::isNullValue("+00.0f"));
ASSERT_EQUALS(true, MathLib::isNullValue("-00.0f"));
// floating point scientific notation (suffix f)
ASSERT_EQUALS(true, MathLib::isNullValue("00.00f"));
ASSERT_EQUALS(true, MathLib::isNullValue("+00.00f"));
ASSERT_EQUALS(true, MathLib::isNullValue("-00.00f"));
// floating point scientific notation (suffix f)
ASSERT_EQUALS(true, MathLib::isNullValue("00.00E+1f"));
ASSERT_EQUALS(true, MathLib::isNullValue("+00.00E+1f"));
ASSERT_EQUALS(true, MathLib::isNullValue("-00.00E+1f"));
Bugfix Mathlib::isNullValue for hexadecimal numbers (#2517)
2020-02-02 16:40:36 +01:00
// hex float
ASSERT_EQUALS(true, MathLib::isNullValue("0x0p3"));
ASSERT_EQUALS(true, MathLib::isNullValue("0X0P3"));
ASSERT_EQUALS(true, MathLib::isNullValue("0X0p-3"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0x0p3"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0x0p3"));
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
MathLib::isNullValue(): Fixed bug in detecting zero values. Improved test coverage of MathLib::IsNullValue().
2014-04-12 02:14:50 +02:00
// binary numbers
ASSERT_EQUALS(true, MathLib::isNullValue("0b00"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0b00"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0b00"));
// binary numbers (long)
ASSERT_EQUALS(true, MathLib::isNullValue("0b00L"));
ASSERT_EQUALS(true, MathLib::isNullValue("+0b00L"));
ASSERT_EQUALS(true, MathLib::isNullValue("-0b00L"));
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
// negative testing
ASSERT_EQUALS(false, MathLib::isNullValue("0.1"));
ASSERT_EQUALS(false, MathLib::isNullValue("1.0"));
ASSERT_EQUALS(false, MathLib::isNullValue("0.01"));
Bugfix Mathlib::isNullValue for hexadecimal numbers (#2517)
2020-02-02 16:40:36 +01:00
ASSERT_EQUALS(false, MathLib::isNullValue("0xF"));
ASSERT_EQUALS(false, MathLib::isNullValue("0XFF"));
ASSERT_EQUALS(false, MathLib::isNullValue("0b01"));
ASSERT_EQUALS(false, MathLib::isNullValue("0B01"));
ASSERT_EQUALS(false, MathLib::isNullValue("0x1p0"));
ASSERT_EQUALS(false, MathLib::isNullValue("0x1P0"));
ASSERT_EQUALS(false, MathLib::isNullValue("0xap0"));
ASSERT_EQUALS(false, MathLib::isNullValue("0xbp0"));
ASSERT_EQUALS(false, MathLib::isNullValue("0xcp0"));
ASSERT_EQUALS(false, MathLib::isNullValue("0xdp0"));
ASSERT_EQUALS(false, MathLib::isNullValue("0xep0"));
ASSERT_EQUALS(false, MathLib::isNullValue("0xfp0"));
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
ASSERT_EQUALS(false, MathLib::isNullValue("-00.01e-12"));
ASSERT_EQUALS(false, MathLib::isNullValue("-00.01e+12"));
ASSERT_EQUALS(false, MathLib::isNullValue(""));
Implemented a slower but shorter version of MathLib::isNullValue() as suggested by PKeuS. Removed not needed test cases. Improved doxygen documentation for MathLib::IsNullValue().
2014-04-14 05:27:38 +02:00
ASSERT_EQUALS(false, MathLib::isNullValue(" "));
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
ASSERT_EQUALS(false, MathLib::isNullValue("x"));
ASSERT_EQUALS(false, MathLib::isNullValue("garbage"));
MathLib::isNullValue(): Fixed bug in detecting zero values. Improved test coverage of MathLib::IsNullValue().
2014-04-12 02:14:50 +02:00
ASSERT_EQUALS(false, MathLib::isNullValue("UL"));
Fix redundant FP assignment with unsigned zero (#2521) * Refactor isNullOperand out of FwdAnalysis * Improve isNullOperand * Fix redundantAssignment FP with unsigned zero * isNullValue check number * Enhance isNullOperand to handle c++ casts Also handle cast of NULL.
2020-02-09 11:16:08 +01:00
ASSERT_EQUALS(false, MathLib::isNullValue("-ENOMEM"));
MathLib:IsNullValue(): using a Finite State Machine to determine a string value contains a numeric NULL value. The NULL value can be Integer, Binary, Hex, Octal. The corresponding unit test cases are also included.
2014-04-11 01:27:05 +02:00
}
Fixed #5885 - fsanitize=undefined: signed integer overflow: 2147483647 + 1 cannot be represented in type 'int' in lib/tokenize.cpp.
2014-05-29 18:25:01 +02:00
Fixed some const correctness issues in the test suite.
2015-01-19 18:00:05 +01:00
void sin() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS("0.0", MathLib::sin("0"));
#633 Adding tests for some MathLib member functions, should reach 100% function coverage now
2014-11-16 18:09:21 +01:00
}
Fixed some const correctness issues in the test suite.
2015-01-19 18:00:05 +01:00
void cos() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS("1.0", MathLib::cos("0"));
#633 Adding tests for some MathLib member functions, should reach 100% function coverage now
2014-11-16 18:09:21 +01:00
}
Fixed some const correctness issues in the test suite.
2015-01-19 18:00:05 +01:00
void tan() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS("0.0", MathLib::tan("0"));
#633 Adding tests for some MathLib member functions, should reach 100% function coverage now
2014-11-16 18:09:21 +01:00
}
Fixed some const correctness issues in the test suite.
2015-01-19 18:00:05 +01:00
void abs() const {
Bugfix valuetype for some integer constants (#2545)
2020-02-19 07:51:39 +01:00
ASSERT_EQUALS("", MathLib::abs(""));
ASSERT_EQUALS("0", MathLib::abs("0"));
ASSERT_EQUALS("+0", MathLib::abs("+0"));
ASSERT_EQUALS("0", MathLib::abs("-0"));
ASSERT_EQUALS("+1", MathLib::abs("+1"));
ASSERT_EQUALS("+1.0", MathLib::abs("+1.0"));
ASSERT_EQUALS("1", MathLib::abs("-1"));
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS("1.0", MathLib::abs("-1.0"));
Bugfix valuetype for some integer constants (#2545)
2020-02-19 07:51:39 +01:00
ASSERT_EQUALS("9007199254740991", MathLib::abs("9007199254740991"));
#633 Adding tests for some MathLib member functions, should reach 100% function coverage now
2014-11-16 18:09:21 +01:00
}
Improved test coverage of MathLib.
2014-12-03 18:24:27 +01:00
Fixed some const correctness issues in the test suite.
2015-01-19 18:00:05 +01:00
void toString() const {
Updated AStyle to version 3.0.1
2018-01-08 20:20:33 +01:00
ASSERT_EQUALS("0.0", MathLib::toString(0.0));
ASSERT_EQUALS("0.0", MathLib::toString(+0.0));
ASSERT_EQUALS("0.0", MathLib::toString(-0.0));
improved `MathLib::to{ULong|Long|Double}Number()` and increased test coverage / added CMake option `USE_LIBCXX` / fixed #10695 (#4611)
2022-12-07 09:20:09 +01:00
ASSERT_EQUALS("1e-08", MathLib::toString(0.00000001));
ASSERT_EQUALS("-1e-08", MathLib::toString(-0.00000001));
fixed #6316 (Use std::to_string() in place of MathLib::toString() ...) - deleted default implementation of `Mathlib::toString()` (#5341) It was also used inconsistently and seemed to imply there is some special handling which wasn't the case. It was just an alias for `std::to_string()` for non-`double` types. So there was no need for it. --------- Co-authored-by: Robert Reif <reif@earthlink.net>
2023-08-17 16:46:32 +02:00
ASSERT_EQUALS("2.22507385851e-308", MathLib::toString(std::numeric_limits<double>::min()));
ASSERT_EQUALS("1.79769313486e+308", MathLib::toString(std::numeric_limits<double>::max()));
Improved test coverage of MathLib.
2014-12-03 18:24:27 +01:00
}
Ticket #7452: Properly interpret escape sequences in character literals.
2016-05-15 15:48:24 +02:00
improve constness of functions as per cppchecks suggestions.
2017-01-07 14:13:22 +01:00
void CPP14DigitSeparators() const { // Ticket #7137, #7565
Ticket #7137: Properly detect C++14 digit separators. (#802) Add an optional extended description…
2016-06-04 22:55:55 +02:00
ASSERT(MathLib::isDigitSeparator("'", 0) == false);
ASSERT(MathLib::isDigitSeparator("123'0;", 3));
ASSERT(MathLib::isDigitSeparator("foo(1'2);", 5));
ASSERT(MathLib::isDigitSeparator("foo(1,1'2);", 7));
ASSERT(MathLib::isDigitSeparator("int a=1'234-1'2-'0';", 7));
ASSERT(MathLib::isDigitSeparator("int a=1'234-1'2-'0';", 13));
ASSERT(MathLib::isDigitSeparator("int a=1'234-1'2-'0';", 16) == false);
ASSERT(MathLib::isDigitSeparator("int b=1+9'8;", 9));
ASSERT(MathLib::isDigitSeparator("if (1'2) { char c = 'c'; }", 5));
ASSERT(MathLib::isDigitSeparator("if (120%1'2) { char c = 'c'; }", 9));
ASSERT(MathLib::isDigitSeparator("if (120&1'2) { char c = 'c'; }", 9));
ASSERT(MathLib::isDigitSeparator("if (120|1'2) { char c = 'c'; }", 9));
ASSERT(MathLib::isDigitSeparator("if (120%1'2) { char c = 'c'; }", 24) == false);
ASSERT(MathLib::isDigitSeparator("if (120%1'2) { char c = 'c'; }", 26) == false);
Ticket #7565: Handle numbers with several C++14 integer separators.
2016-07-01 23:22:16 +02:00
ASSERT(MathLib::isDigitSeparator("0b0000001'0010'01110", 14));
Ticket #7137: Properly detect C++14 digit separators. (#802) Add an optional extended description…
2016-06-04 22:55:55 +02:00
}
added testing for mathlib
2009-04-06 19:08:13 +02:00
};
REGISTER_TEST(TestMathLib)