Fix CPPCheck issues of type error::throwInNoexceptFunction

[eljonny]

Fixes #31.

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 87.52%. Comparing base (3447cda) to head (cf9b3b1).
Report is 3 commits behind head on main.

✅ All tests successful. No failed tests found.

Additional details and impacted files

@@           Coverage Diff           @@
##             main     #102   +/-   ##
=======================================
  Coverage   87.52%   87.52%           
=======================================
  Files          10       10           
  Lines         489      489           
  Branches       61       61           
=======================================
  Hits          428      428           
  Misses         52       52           
  Partials        9        9           

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[github-actions]

⚡ Static analysis result ⚡

🔴 cppcheck found 13 issues! Click here to see details.

TestCPP/include/internal/TestCPPTestCase.h

Lines 199 to 204 in cf9b3b1

	void clearStdoutCapture ();
	/**
	* @brief Clears the captured output from std::clog.
	*
	* This can be used for checking sections of output based on

!Line: 199 - performance: inconclusive: Technically the member function 'TestCPP::TestCase::clearStdoutCapture' can be static (but you may consider moving to unnamed namespace). [functionStatic]

!Line: 463 - note: Technically the member function 'TestCPP::TestCase::clearStdoutCapture' can be static (but you may consider moving to unnamed namespace).
!Line: 199 - note: Technically the member function 'TestCPP::TestCase::clearStdoutCapture' can be static (but you may consider moving to unnamed namespace).

TestCPP/include/internal/TestCPPTestCase.h

Lines 207 to 212 in cf9b3b1

	void clearLogCapture ();
	/**
	* @brief Clears the captured output from stderr.
	*
	* This can be used for checking sections of output based on

!Line: 207 - performance: inconclusive: Technically the member function 'TestCPP::TestCase::clearLogCapture' can be static (but you may consider moving to unnamed namespace). [functionStatic]

!Line: 469 - note: Technically the member function 'TestCPP::TestCase::clearLogCapture' can be static (but you may consider moving to unnamed namespace).
!Line: 207 - note: Technically the member function 'TestCPP::TestCase::clearLogCapture' can be static (but you may consider moving to unnamed namespace).

TestCPP/include/internal/TestCPPTestCase.h

Lines 215 to 220 in cf9b3b1

	void clearStderrCapture ();
	/**
	* @brief Check the argument against what is captured from
	* stdout using the configured comparison mode.
	* @param against The value to check the captured output against

!Line: 215 - performance: inconclusive: Technically the member function 'TestCPP::TestCase::clearStderrCapture' can be static (but you may consider moving to unnamed namespace). [functionStatic]

!Line: 475 - note: Technically the member function 'TestCPP::TestCase::clearStderrCapture' can be static (but you may consider moving to unnamed namespace).
!Line: 215 - note: Technically the member function 'TestCPP::TestCase::clearStderrCapture' can be static (but you may consider moving to unnamed namespace).

TestCPP/include/internal/TestCPPTestCase.h

Lines 292 to 297 in cf9b3b1

	void logFailure (ostream& out, const string& reason);
	/**
	* @brief If a test encounters an error while running, this
	* function will be called to log the test error.
	* @param failureMessage The error message from the test that
	* should be logged.

!Line: 292 - style: inconclusive: Technically the member function 'TestCPP::TestCase::logFailure' can be const. [functionConst]

!Line: 294 - note: Technically the member function 'TestCPP::TestCase::logFailure' can be const.
!Line: 292 - note: Technically the member function 'TestCPP::TestCase::logFailure' can be const.

TestCPP/src/TestCPPTestCase.cpp

Lines 114 to 119 in cf9b3b1

	TestCase::TestCase (TestObjName&& name,
	function<void()> testFn,
	bool msg,
	bool captureOut, bool captureLog,
	bool captureErr,
	TestCase::TestCaseOutCompareOptions opt)

!Line: 114 - style: inconclusive: Function 'TestCase' argument 1 names different: declaration 'testName' definition 'name'. [funcArgNamesDifferent]

!Line: 132 - note: Function 'TestCase' argument 1 names different: declaration 'testName' definition 'name'.
!Line: 114 - note: Function 'TestCase' argument 1 names different: declaration 'testName' definition 'name'.

TestCPP/src/TestCPPTestCase.cpp

Lines 115 to 120 in cf9b3b1

	function<void()> testFn,
	bool msg,
	bool captureOut, bool captureLog,
	bool captureErr,
	TestCase::TestCaseOutCompareOptions opt)
	{

!Line: 115 - style: inconclusive: Function 'TestCase' argument 2 names different: declaration 'test' definition 'testFn'. [funcArgNamesDifferent]

!Line: 133 - note: Function 'TestCase' argument 2 names different: declaration 'test' definition 'testFn'.
!Line: 115 - note: Function 'TestCase' argument 2 names different: declaration 'test' definition 'testFn'.

TestCPP/src/TestCPPTestCase.cpp

Lines 116 to 121 in cf9b3b1

	bool msg,
	bool captureOut, bool captureLog,
	bool captureErr,
	TestCase::TestCaseOutCompareOptions opt)
	{
	this->notifyTestPassed = msg;

!Line: 116 - style: inconclusive: Function 'TestCase' argument 3 names different: declaration 'testPassedMessage' definition 'msg'. [funcArgNamesDifferent]

!Line: 134 - note: Function 'TestCase' argument 3 names different: declaration 'testPassedMessage' definition 'msg'.
!Line: 116 - note: Function 'TestCase' argument 3 names different: declaration 'testPassedMessage' definition 'msg'.

TestCPP/src/TestCPPTestCase.cpp

Lines 306 to 311 in cf9b3b1

	void TestCase::logTestFailure (const string& reason) {
	unique_ptr<ostream> logStream = nullptr;
	if (this->clogOriginal.get() != nullptr) {
	logStream = unique_ptr<ostream>(
	new ostream(this->clogOriginal.get().get())

!Line: 306 - style: inconclusive: Function 'logTestFailure' argument 1 names different: declaration 'failureMessage' definition 'reason'. [funcArgNamesDifferent]

!Line: 299 - note: Function 'logTestFailure' argument 1 names different: declaration 'failureMessage' definition 'reason'.
!Line: 306 - note: Function 'logTestFailure' argument 1 names different: declaration 'failureMessage' definition 'reason'.

TestCPP/src/TestCPPTestCase.cpp

Lines 373 to 378 in cf9b3b1

	void TestCase::setNotifyPassed (bool notify) {
	this->notifyTestPassed = notify;
	}
	void TestCase::captureStdout () {
	if (TestCase::stdoutCaptureCasesConstructed ==

!Line: 373 - style: inconclusive: Function 'setNotifyPassed' argument 1 names different: declaration 'shouldNotify' definition 'notify'. [funcArgNamesDifferent]

!Line: 180 - note: Function 'setNotifyPassed' argument 1 names different: declaration 'shouldNotify' definition 'notify'.
!Line: 373 - note: Function 'setNotifyPassed' argument 1 names different: declaration 'shouldNotify' definition 'notify'.

TestCPP/include/internal/TestCPPTestSuite.h

Lines 112 to 117 in cf9b3b1

	inline addTests () { }
	/**
	* @brief Add one or more tests at once to the test suite.
	* @param test The first test to add.
	* @param tests The rest of the tests to add.

!Line: 112 - performance: inconclusive: Technically the member function 'TestCPP::TestSuite::addTests' can be static (but you may consider moving to unnamed namespace). [functionStatic]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 148 to 153 in cf9b3b1

	unsigned getLastRunFailCount ();
	/**
	* @brief Retrieve the total number of tests in the suite that
	* succeeded (passed) during the last suite run.
	* @return The total number of tests that passed in the last

!Line: 148 - style: inconclusive: Technically the member function 'TestCPP::TestSuite::getLastRunFailCount' can be const. [functionConst]

!Line: 73 - note: Technically the member function 'TestCPP::TestSuite::getLastRunFailCount' can be const.
!Line: 148 - note: Technically the member function 'TestCPP::TestSuite::getLastRunFailCount' can be const.

TestCPP/include/internal/TestCPPTestSuite.h

Lines 156 to 161 in cf9b3b1

	unsigned getLastRunSuccessCount();
	/**
	* @brief Run all tests in the test suite.
	*/
	void run ();

!Line: 156 - style: inconclusive: Technically the member function 'TestCPP::TestSuite::getLastRunSuccessCount' can be const. [functionConst]

!Line: 77 - note: Technically the member function 'TestCPP::TestSuite::getLastRunSuccessCount' can be const.
!Line: 156 - note: Technically the member function 'TestCPP::TestSuite::getLastRunSuccessCount' can be const.

TestCPP/include/internal/TestCPPUtil.h

Lines 81 to 86 in cf9b3b1

	const string& getName ();
	/**
	* @brief Output the test object name to the specified stream.
	* @param s The stream to output to.
	* @param tcName The test object name object.

!Line: 81 - style: inconclusive: Technically the member function 'TestCPP::TestObjName::getName' can be const. [functionConst]

!Line: 59 - note: Technically the member function 'TestCPP::TestObjName::getName' can be const.
!Line: 81 - note: Technically the member function 'TestCPP::TestObjName::getName' can be const.

---

🔴 clang-tidy found 156 issues! Click here to see details.

TestCPP/include/internal/TestCPPCommon.h

Lines 88 to 93 in cf9b3b1

	static constexpr const char * SP = " ";
	static constexpr const char * START_RUN =
	"Starting run of test ";
	static constexpr const char * SUITE = "Suite ";
	static constexpr const char * SUITE_TESTS_PASSED =
	" suite tests passed!";

!Line: 88 - error: variable name 'SP' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 73 to 78 in cf9b3b1

	TestObjName (const char* name);
	/**
	* @brief Get the encapsulated name for the TestCPP object that
	* holds this object.
	* @return The name of the TestCPP object that this object

!Line: 73 - error: single-argument constructors must be marked explicit to avoid unintentional implicit conversions [hicpp-explicit-conversions,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 81 to 86 in cf9b3b1

	const string& getName ();
	/**
	* @brief Output the test object name to the specified stream.
	* @param s The stream to output to.
	* @param tcName The test object name object.

!Line: 81 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 89 to 94 in cf9b3b1

	friend std::ostream& operator<< (
	std::ostream& s,
	TestObjName& tcName
	);
	private:

!Line: 89 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 90 to 95 in cf9b3b1

	std::ostream& s,
	TestObjName& tcName
	);
	private:
	string testCaseName;

!Line: 90 - error: parameter name 's' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 106 to 111 in cf9b3b1

	template <class T> class no_destroy {
	alignas(T) unsigned char data[sizeof(T)];
	public:
	template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
	T& get() { return *reinterpret_cast<T*>(data); }
	};

!Line: 106 - error: constructor does not initialize these fields: data [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 107 to 112 in cf9b3b1

	alignas(T) unsigned char data[sizeof(T)];
	public:
	template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
	T& get() { return *reinterpret_cast<T*>(data); }
	};

!Line: 107 - error: do not declare C-style arrays, use 'std::array' instead [cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 109 to 114 in cf9b3b1

	template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
	T& get() { return *reinterpret_cast<T*>(data); }
	};
	/**
	* @brief Log a message that will only be output when debug

!Line: 109 - error: constructor does not initialize these fields: data [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 109 to 114 in cf9b3b1

	template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
	T& get() { return *reinterpret_cast<T*>(data); }
	};
	/**
	* @brief Log a message that will only be output when debug

!Line: 109 - error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [hicpp-explicit-conversions,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 109 to 114 in cf9b3b1

	template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
	T& get() { return *reinterpret_cast<T*>(data); }
	};
	/**
	* @brief Log a message that will only be output when debug

!Line: 109 - error: parameter name 'ts' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in cf9b3b1

	T& get() { return *reinterpret_cast<T*>(data); }
	};
	/**
	* @brief Log a message that will only be output when debug
	* logging is enabled.

!Line: 110 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 110 to 115 in cf9b3b1

	T& get() { return *reinterpret_cast<T*>(data); }
	};
	/**
	* @brief Log a message that will only be output when debug
	* logging is enabled.

!Line: 110 - error: do not use reinterpret_cast [cppcoreguidelines-pro-type-reinterpret-cast,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 136 to 141 in cf9b3b1

	bool stringContains (const string& source,
	const string& contains);
	/**
	* @brief Safely converts unsigned integer values to signed.
	* @param toCast The unsigned value to convert.

!Line: 136 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 144 to 148 in cf9b3b1

	int unsignedToSigned(unsigned toCast);
	}
	}
	#endif

!Line: 144 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 51 to 56 in cf9b3b1

	if (name) {
	this->testCaseName = name;
	}
	else {
	throw TestCPPException(TCPPStr::NVTN);
	}

!Line: 51 - error: implicit conversion 'const char *' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 59 to 64 in cf9b3b1

	const string& TestObjName::getName () {
	return this->testCaseName;
	}
	std::ostream& operator<< (
	std::ostream& s,

!Line: 59 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 63 to 68 in cf9b3b1

	std::ostream& operator<< (
	std::ostream& s,
	TestObjName& tcName
	)
	{
	s << tcName.getName();

!Line: 63 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 64 to 69 in cf9b3b1

	std::ostream& s,
	TestObjName& tcName
	)
	{
	s << tcName.getName();
	return s;

!Line: 64 - error: parameter name 's' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 78 to 83 in cf9b3b1

	clog << endl;
	}
	#endif
	}
	bool stringContains(const string& source,

!Line: 78 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 83 to 88 in cf9b3b1

	bool stringContains(const string& source,
	const string& contains)
	{
	return source.find(contains) != string::npos;
	}

!Line: 83 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPUtil.cpp

Lines 89 to 94 in cf9b3b1

	int unsignedToSigned(unsigned toCast) {
	if (toCast <= INT_MAX) {
	return static_cast<int>(toCast);
	}
	if (toCast >= static_cast<unsigned>(INT_MIN)) {

!Line: 89 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 28 to 33 in cf9b3b1

	#include <iostream>
	#include "internal/TestCPPExceptions.h"
	#ifdef TESTCPP_STACKTRACE_ENABLED
	#include <boost/stacktrace.hpp>

!Line: 28 - error: included header iostream is not used directly [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 37 to 42 in cf9b3b1

	using std::string;
	using std::runtime_error;
	namespace TestCPP {
	TestCPPException::TestCPPException (const char * msg) :

!Line: 37 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 38 to 43 in cf9b3b1

	using std::runtime_error;
	namespace TestCPP {
	TestCPPException::TestCPPException (const char * msg) :
	runtime_error(msg)

!Line: 38 - error: no header providing "std::runtime_error" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPExceptions.cpp

Lines 66 to 71 in cf9b3b1

	TestCPPException(std::move(msg))
	{
	#ifdef TESTCPP_STACKTRACE_ENABLED
	clog << boost::stacktrace::stacktrace();
	#endif
	}

!Line: 66 - error: std::move of the const variable 'msg' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 49 - note: consider changing the 1st parameter of 'TestCPPException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPExceptions.cpp

Lines 66 to 71 in cf9b3b1

	TestCPPException(std::move(msg))
	{
	#ifdef TESTCPP_STACKTRACE_ENABLED
	clog << boost::stacktrace::stacktrace();
	#endif
	}

!Line: 66 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 84 to 89 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	/**

!Line: 84 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 85 to 90 in cf9b3b1

	throw TestFailedException(std::move(err));
	}
	}
	/**
	* @brief Check that something is not equivalent to something

!Line: 85 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 110 to 115 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	/**

!Line: 110 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 111 to 116 in cf9b3b1

	throw TestFailedException(std::move(err));
	}
	}
	/**
	* @brief Check that a pointer is null.

!Line: 111 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 131 to 136 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	/**

!Line: 131 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 132 to 137 in cf9b3b1

	throw TestFailedException(std::move(err));
	}
	}
	/**
	* @brief Check that a pointer is non-null.

!Line: 132 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 152 to 157 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	/**

!Line: 152 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 153 to 158 in cf9b3b1

	throw TestFailedException(std::move(err));
	}
	}
	/**
	* @brief Verify that a function throws something.

!Line: 153 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/include/internal/TestCPPAssertions.h

Lines 243 to 248 in cf9b3b1

	static const string logTestFailure(
	T1 expectationValue, T2 actual,
	const string& assertionTypeMessage,
	const string& failureMessage,
	const bool logValues
	)

!Line: 243 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 243 to 248 in cf9b3b1

	static const string logTestFailure(
	T1 expectationValue, T2 actual,
	const string& assertionTypeMessage,
	const string& failureMessage,
	const bool logValues
	)

!Line: 243 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 252 to 257 in cf9b3b1

	err << assertionTypeMessage << endl;
	err << failureMessage << endl;
	if (logValues) {
	err << "Expectation value: <" << expectationValue << ">"
	<< endl;

!Line: 252 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 253 to 258 in cf9b3b1

	err << failureMessage << endl;
	if (logValues) {
	err << "Expectation value: <" << expectationValue << ">"
	<< endl;
	err << "Actual: <" << actual << ">" << endl;

!Line: 253 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 265 to 270 in cf9b3b1

	static const string checkEquals(
	T1 expected, T2 actual,
	const string& failureMessage
	)
	{
	if (expected != actual) {

!Line: 265 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 265 to 270 in cf9b3b1

	static const string checkEquals(
	T1 expected, T2 actual,
	const string& failureMessage
	)
	{
	if (expected != actual) {

!Line: 265 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 282 to 287 in cf9b3b1

	static const string checkNotEquals(
	T1 shouldNotBe, T2 actual,
	const string& failureMessage
	)
	{
	if (shouldNotBe == actual) {

!Line: 282 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 282 to 287 in cf9b3b1

	static const string checkNotEquals(
	T1 shouldNotBe, T2 actual,
	const string& failureMessage
	)
	{
	if (shouldNotBe == actual) {

!Line: 282 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 299 to 304 in cf9b3b1

	static const string checkNull(
	T ptr,
	const string& failureMessage
	)
	{
	bool null = ptr == nullptr;

!Line: 299 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 299 to 304 in cf9b3b1

	static const string checkNull(
	T ptr,
	const string& failureMessage
	)
	{
	bool null = ptr == nullptr;

!Line: 299 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 318 to 323 in cf9b3b1

	static const string checkNotNull(
	T ptr,
	const string& failureMessage
	)
	{
	bool notNull = ptr != nullptr;

!Line: 318 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 318 to 323 in cf9b3b1

	static const string checkNotNull(
	T ptr,
	const string& failureMessage
	)
	{
	bool notNull = ptr != nullptr;

!Line: 318 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 387 to 392 in cf9b3b1

	const string TestCPP::Assertions::checkEquals<const char*, const char*>(
	const char* expected, const char* actual,
	const string& failureMessage
	);
	template<>

!Line: 387 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPAssertions.h

Lines 393 to 398 in cf9b3b1

	const string TestCPP::Assertions::checkNotEquals<const char*, const char*>(
	const char* shouldNotBe, const char* actual,
	const string& failureMessage
	);
	#endif

!Line: 393 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 30 to 35 in cf9b3b1

	using std::clog;
	using std::current_exception;
	using std::endl;
	using std::exception;
	using std::exception_ptr;
	using std::function;

!Line: 30 - error: no header providing "std::clog" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 31 to 36 in cf9b3b1

	using std::current_exception;
	using std::endl;
	using std::exception;
	using std::exception_ptr;
	using std::function;
	using std::rethrow_exception;

!Line: 31 - error: no header providing "std::current_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 33 to 38 in cf9b3b1

	using std::exception;
	using std::exception_ptr;
	using std::function;
	using std::rethrow_exception;
	using std::string;
	using std::stringstream;

!Line: 33 - error: no header providing "std::exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 34 to 39 in cf9b3b1

	using std::exception_ptr;
	using std::function;
	using std::rethrow_exception;
	using std::string;
	using std::stringstream;

!Line: 34 - error: no header providing "std::__exception_ptr::exception_ptr" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 35 to 40 in cf9b3b1

	using std::function;
	using std::rethrow_exception;
	using std::string;
	using std::stringstream;
	namespace TestCPP {

!Line: 35 - error: no header providing "std::function" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 36 to 41 in cf9b3b1

	using std::rethrow_exception;
	using std::string;
	using std::stringstream;
	namespace TestCPP {

!Line: 36 - error: no header providing "std::rethrow_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 37 to 42 in cf9b3b1

	using std::string;
	using std::stringstream;
	namespace TestCPP {
	template<>

!Line: 37 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 38 to 43 in cf9b3b1

	using std::stringstream;
	namespace TestCPP {
	template<>
	const string Assertions::checkEquals<const char*, const char*>(

!Line: 38 - error: no header providing "std::stringstream" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 43 to 48 in cf9b3b1

	const string Assertions::checkEquals<const char*, const char*>(
	const char* expected, const char* actual,
	const string& failureMessage
	)
	{
	if (strcmp(expected, actual)) {

!Line: 43 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 43 to 48 in cf9b3b1

	const string Assertions::checkEquals<const char*, const char*>(
	const char* expected, const char* actual,
	const string& failureMessage
	)
	{
	if (strcmp(expected, actual)) {

!Line: 43 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in cf9b3b1

	if (strcmp(expected, actual)) {
	return logTestFailure(
	expected, actual,
	equivalenceAssertionMessage,
	failureMessage,
	true

!Line: 48 - error: function 'strcmp' is called without explicitly comparing result [bugprone-suspicious-string-compare,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in cf9b3b1

	if (strcmp(expected, actual)) {
	return logTestFailure(
	expected, actual,
	equivalenceAssertionMessage,
	failureMessage,
	true

!Line: 48 - error: no header providing "strcmp" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 48 to 53 in cf9b3b1

	if (strcmp(expected, actual)) {
	return logTestFailure(
	expected, actual,
	equivalenceAssertionMessage,
	failureMessage,
	true

!Line: 48 - error: implicit conversion 'int' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 60 to 65 in cf9b3b1

	const string Assertions::checkNotEquals<const char*, const char*>(
	const char* shouldNotBe, const char* actual,
	const string& failureMessage
	)
	{
	if (!strcmp(shouldNotBe, actual)) {

!Line: 60 - error: return type 'const string' (aka 'const basic_string<char>') is 'const'-qualified at the top level, which may reduce code readability without improving const correctness [readability-const-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 60 to 65 in cf9b3b1

	const string Assertions::checkNotEquals<const char*, const char*>(
	const char* shouldNotBe, const char* actual,
	const string& failureMessage
	)
	{
	if (!strcmp(shouldNotBe, actual)) {

!Line: 60 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 65 to 70 in cf9b3b1

	if (!strcmp(shouldNotBe, actual)) {
	return logTestFailure(
	shouldNotBe, actual,
	nonequivalenceAssertionMessage,
	failureMessage,
	true

!Line: 65 - error: implicit conversion 'int' -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 83 to 88 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	template<>

!Line: 83 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 83 to 88 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	template<>

!Line: 83 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 84 to 89 in cf9b3b1

	throw TestFailedException(std::move(err));
	}
	}
	template<>
	void Assertions::assertNotEquals<const char*, const char*>(

!Line: 84 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 84 to 89 in cf9b3b1

	throw TestFailedException(std::move(err));
	}
	}
	template<>
	void Assertions::assertNotEquals<const char*, const char*>(

!Line: 84 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 96 to 101 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	void Assertions::assertThrows (

!Line: 96 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 96 to 101 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	void Assertions::assertThrows (

!Line: 96 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 97 to 102 in cf9b3b1

	throw TestFailedException(std::move(err));
	}
	}
	void Assertions::assertThrows (
	function<void()> shouldThrow,

!Line: 97 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 102 to 107 in cf9b3b1

	function<void()> shouldThrow,
	const string& failureMessage
	)
	{
	try {
	shouldThrow();

!Line: 102 - error: the parameter 'shouldThrow' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 110 to 115 in cf9b3b1

	exception_ptr eptr = current_exception();
	if (eptr) {
	try {
	rethrow_exception(eptr);
	}

!Line: 110 - error: variable 'eptr' of type 'exception_ptr' can be declared 'const' [misc-const-correctness,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 119 to 124 in cf9b3b1

	<< endl;
	}
	}
	else {
	clog << "Something was thrown, not sure what." << endl
	<< "This satisfies the assertion, so no failure is"

!Line: 119 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 123 to 128 in cf9b3b1

	clog << "Something was thrown, not sure what." << endl
	<< "This satisfies the assertion, so no failure is"
	<< " present. "
	<< TestFailedException("Unknown thrown object").
	what();
	}

!Line: 123 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 133 to 138 in cf9b3b1

	throw TestFailedException(std::move(failureMessage));
	}
	void Assertions::assertNoThrows (
	function<void()> shouldNotThrow,
	const string& failureMessage

!Line: 133 - error: std::move of the const variable 'failureMessage' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 137 to 142 in cf9b3b1

	function<void()> shouldNotThrow,
	const string& failureMessage
	)
	{
	try {
	shouldNotThrow();

!Line: 137 - error: the parameter 'shouldNotThrow' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 145 to 150 in cf9b3b1

	throw TestFailedException(std::move(failureMessage));
	}
	}
	void Assertions::assertTrue (
	bool condition,

!Line: 145 - error: std::move of the const variable 'failureMessage' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 164 to 169 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	}

!Line: 164 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 164 to 169 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	}

!Line: 164 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 165 to 170 in cf9b3b1

	throw TestFailedException(std::move(err));
	}
	}
	}
	void Assertions::assertFalse (

!Line: 165 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 185 to 190 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	}

!Line: 185 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 185 to 190 in cf9b3b1

	if (err.size()) {
	throw TestFailedException(std::move(err));
	}
	}
	}

!Line: 185 - error: implicit conversion 'size_type' (aka 'unsigned long') -> 'bool' [readability-implicit-bool-conversion,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 186 to 191 in cf9b3b1

	throw TestFailedException(std::move(err));
	}
	}
	}
	[[noreturn]] void Assertions::fail(string failureMessage) {

!Line: 186 - error: std::move of the const variable 'err' has no effect or make the variable non-const [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

!Line: 98 - note: consider changing the 1st parameter of 'TestFailedException' from 'const string &&' (aka 'const basic_string<char> &&') to 'const string &'

TestCPP/src/TestCPPAssertions.cpp

Lines 191 to 194 in cf9b3b1

	[[noreturn]] void Assertions::fail(string failureMessage) {
	throw TestFailedException(std::move(failureMessage));
	}
	}

!Line: 191 - error: the parameter 'failureMessage' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPAssertions.cpp

Lines 192 to 194 in cf9b3b1

	throw TestFailedException(std::move(failureMessage));
	}
	}

!Line: 192 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 92 to 97 in cf9b3b1

	enum TestCaseOutCompareOptions {
	CONTAINS,
	EXACT
	};
	/**

!Line: 92 - error: enum 'TestCaseOutCompareOptions' uses a larger base type ('unsigned int', size: 4 bytes) than necessary for its value set, consider using 'std::uint8_t' (1 byte) as the base type to reduce its size [performance-enum-size,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 146 to 151 in cf9b3b1

	TestCase (const TestCase& o);
	/**
	* @brief Construct a TestCase by moving all data from another
	* TestCase.
	* @param o Move everything from this TestCase into the new one.

!Line: 146 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 153 to 158 in cf9b3b1

	TestCase (TestCase&& o) noexcept;
	/**
	* @brief Copy a TestCase into another TestCase.
	* @param rhs The test case to copy from.
	* @return A reference to the new TestCase copy.

!Line: 153 - error: parameter name 'o' is too short, expected at least 3 characters [readability-identifier-length,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 160 to 165 in cf9b3b1

	TestCase& operator= (const TestCase& rhs);
	/**
	* @brief Move a TestCase into another TestCase.
	* @param rhs Move everything from this TestCase into the new
	* one.

!Line: 160 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 169 to 174 in cf9b3b1

	TestCase& operator= (TestCase&& rhs) noexcept;
	/**
	* @brief Destroy a TestCase object.
	*/
	~TestCase ();

!Line: 169 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 224 to 229 in cf9b3b1

	bool checkStdout (const string& against);
	/**
	* @brief Check the argument against what is captured from
	* std::clog using the configured comparison mode.
	* @param against The value to check the captured output against

!Line: 224 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 233 to 238 in cf9b3b1

	bool checkLog (const string& against);
	/**
	* @brief Check the argument against what is captured from
	* stderr using the configured comparison mode.
	* @param against The value to check the captured output against

!Line: 233 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 243 to 248 in cf9b3b1

	bool checkStderr (const string& against);
	/**
	* @brief Run the test case.
	* @return True if the test ran successfully, false otherwise.
	*/

!Line: 243 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 249 to 254 in cf9b3b1

	bool go ();
	/**
	* @brief Returns the duration of the last run in nanoseconds.
	* @return The duration of the last run of this TestCase in
	* nanoseconds.

!Line: 249 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 256 to 261 in cf9b3b1

	long long getLastRuntime () const;
	private:
	bool notifyTestPassed = false;
	bool pass = false;
	bool stdoutCaptured = false;

!Line: 256 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 315 to 320 in cf9b3b1

	bool checkOutput (const string& source, const string& against);
	static atomic_int stdoutCaptureCasesConstructed;
	static atomic_int logCaptureCasesConstructed;
	static atomic_int stderrCaptureCasesConstructed;
	static atomic_int stdoutCaptureCasesDestroyed;

!Line: 315 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 345 to 350 in cf9b3b1

	static nanoseconds duration (F func, Args&&... args)
	{
	auto start = system_clock::now();
	func(forward<Args>(args)...);
	return duration_cast<nanoseconds>(
	system_clock::now() - start

!Line: 345 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 79 to 84 in cf9b3b1

	TestSuite (TestObjName&& newSuiteName,
	typename enable_if<sizeof...(TestType) == 0>::type)
	{
	commonInit(std::forward<TestObjName>(newSuiteName));
	}

!Line: 79 - error: constructor does not initialize these fields: firstRun, testSuitePassedMessage, lastRunSucceeded, lastRunSuccessCount, lastRunFailCount, totalRuntime [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 79 to 84 in cf9b3b1

	TestSuite (TestObjName&& newSuiteName,
	typename enable_if<sizeof...(TestType) == 0>::type)
	{
	commonInit(std::forward<TestObjName>(newSuiteName));
	}

!Line: 79 - error: rvalue reference parameter 'newSuiteName' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 80 to 85 in cf9b3b1

	typename enable_if<sizeof...(TestType) == 0>::type)
	{
	commonInit(std::forward<TestObjName>(newSuiteName));
	}
	/**

!Line: 80 - error: all parameters should be named in a function [hicpp-named-parameter,readability-named-parameter,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 90 to 95 in cf9b3b1

	TestSuite (TestObjName&& newSuiteName, TestType ...tests)
	{
	commonInit(std::forward<TestObjName>(newSuiteName));
	this->addTests(tests...);
	}

!Line: 90 - error: constructor does not initialize these fields: firstRun, testSuitePassedMessage, lastRunSucceeded, lastRunSuccessCount, lastRunFailCount, totalRuntime [cppcoreguidelines-pro-type-member-init,hicpp-member-init,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 90 to 95 in cf9b3b1

	TestSuite (TestObjName&& newSuiteName, TestType ...tests)
	{
	commonInit(std::forward<TestObjName>(newSuiteName));
	this->addTests(tests...);
	}

!Line: 90 - error: constructors that are callable with a single argument must be marked explicit to avoid unintentional implicit conversions [hicpp-explicit-conversions,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 90 to 95 in cf9b3b1

	TestSuite (TestObjName&& newSuiteName, TestType ...tests)
	{
	commonInit(std::forward<TestObjName>(newSuiteName));
	this->addTests(tests...);
	}

!Line: 90 - error: rvalue reference parameter 'newSuiteName' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 112 to 117 in cf9b3b1

	inline addTests () { }
	/**
	* @brief Add one or more tests at once to the test suite.
	* @param test The first test to add.
	* @param tests The rest of the tests to add.

!Line: 112 - error: function 'addTests' has inline specifier but is implicitly inlined [readability-redundant-inline-specifier,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 112 to 117 in cf9b3b1

	inline addTests () { }
	/**
	* @brief Add one or more tests at once to the test suite.
	* @param test The first test to add.
	* @param tests The rest of the tests to add.

!Line: 112 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 148 to 153 in cf9b3b1

	unsigned getLastRunFailCount ();
	/**
	* @brief Retrieve the total number of tests in the suite that
	* succeeded (passed) during the last suite run.
	* @return The total number of tests that passed in the last

!Line: 148 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 156 to 161 in cf9b3b1

	unsigned getLastRunSuccessCount();
	/**
	* @brief Run all tests in the test suite.
	*/
	void run ();

!Line: 156 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestSuite.h

Lines 181 to 186 in cf9b3b1

	void commonInit(TestObjName&& newSuiteName) {
	this->firstRun = true;
	this->testSuitePassedMessage = true;
	this->lastRunSucceeded = true;
	this->lastRunFailCount = zeroInit;

!Line: 181 - error: rvalue reference parameter 'newSuiteName' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 36 to 41 in cf9b3b1

	using std::cerr;
	using std::clog;
	using std::cout;
	using std::endl;
	using std::exception;
	using std::fixed;

!Line: 36 - error: no header providing "std::cerr" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 37 to 42 in cf9b3b1

	using std::clog;
	using std::cout;
	using std::endl;
	using std::exception;
	using std::fixed;
	using std::function;

!Line: 37 - error: no header providing "std::clog" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 38 to 43 in cf9b3b1

	using std::cout;
	using std::endl;
	using std::exception;
	using std::fixed;
	using std::function;
	using std::invalid_argument;

!Line: 38 - error: no header providing "std::cout" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 38 to 43 in cf9b3b1

	using std::cout;
	using std::endl;
	using std::exception;
	using std::fixed;
	using std::function;
	using std::invalid_argument;

!Line: 38 - error: using decl 'cout' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 38 - note: remove the using

TestCPP/src/TestCPPTestSuite.cpp

Lines 40 to 45 in cf9b3b1

	using std::exception;
	using std::fixed;
	using std::function;
	using std::invalid_argument;
	using std::ostream;
	using std::rethrow_exception;

!Line: 40 - error: no header providing "std::exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 41 to 46 in cf9b3b1

	using std::fixed;
	using std::function;
	using std::invalid_argument;
	using std::ostream;
	using std::rethrow_exception;
	using std::runtime_error;

!Line: 41 - error: no header providing "std::fixed" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 42 to 47 in cf9b3b1

	using std::function;
	using std::invalid_argument;
	using std::ostream;
	using std::rethrow_exception;
	using std::runtime_error;
	using std::setprecision;

!Line: 42 - error: no header providing "std::function" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 43 to 48 in cf9b3b1

	using std::invalid_argument;
	using std::ostream;
	using std::rethrow_exception;
	using std::runtime_error;
	using std::setprecision;
	using std::string;

!Line: 43 - error: no header providing "std::invalid_argument" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 43 to 48 in cf9b3b1

	using std::invalid_argument;
	using std::ostream;
	using std::rethrow_exception;
	using std::runtime_error;
	using std::setprecision;
	using std::string;

!Line: 43 - error: using decl 'invalid_argument' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 43 - note: remove the using

TestCPP/src/TestCPPTestSuite.cpp

Lines 44 to 49 in cf9b3b1

	using std::ostream;
	using std::rethrow_exception;
	using std::runtime_error;
	using std::setprecision;
	using std::string;
	using std::tuple;

!Line: 44 - error: no header providing "std::ostream" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 45 to 50 in cf9b3b1

	using std::rethrow_exception;
	using std::runtime_error;
	using std::setprecision;
	using std::string;
	using std::tuple;

!Line: 45 - error: no header providing "std::rethrow_exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 45 to 50 in cf9b3b1

	using std::rethrow_exception;
	using std::runtime_error;
	using std::setprecision;
	using std::string;
	using std::tuple;

!Line: 45 - error: using decl 'rethrow_exception' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 45 - note: remove the using

TestCPP/src/TestCPPTestSuite.cpp

Lines 46 to 51 in cf9b3b1

	using std::runtime_error;
	using std::setprecision;
	using std::string;
	using std::tuple;
	using TCPPNum = TestCPP::TestCPPCommon::Nums;

!Line: 46 - error: no header providing "std::runtime_error" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 46 to 51 in cf9b3b1

	using std::runtime_error;
	using std::setprecision;
	using std::string;
	using std::tuple;
	using TCPPNum = TestCPP::TestCPPCommon::Nums;

!Line: 46 - error: using decl 'runtime_error' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 46 - note: remove the using

TestCPP/src/TestCPPTestSuite.cpp

Lines 48 to 53 in cf9b3b1

	using std::string;
	using std::tuple;
	using TCPPNum = TestCPP::TestCPPCommon::Nums;
	using TCPPStr = TestCPP::TestCPPCommon::Strings;

!Line: 48 - error: no header providing "std::string" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 49 to 54 in cf9b3b1

	using std::tuple;
	using TCPPNum = TestCPP::TestCPPCommon::Nums;
	using TCPPStr = TestCPP::TestCPPCommon::Strings;
	namespace TestCPP {

!Line: 49 - error: no header providing "std::tuple" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 69 to 74 in cf9b3b1

	void TestSuite::setSuiteName (TestObjName&& testSuiteName) {
	this->suiteName = std::move(testSuiteName);
	}
	unsigned TestSuite::getLastRunFailCount () {
	return this->lastRunFailCount;

!Line: 69 - error: no header providing "TestCPP::TestObjName" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 70 to 75 in cf9b3b1

	this->suiteName = std::move(testSuiteName);
	}
	unsigned TestSuite::getLastRunFailCount () {
	return this->lastRunFailCount;
	}

!Line: 70 - error: no header providing "std::move" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 73 to 78 in cf9b3b1

	unsigned TestSuite::getLastRunFailCount () {
	return this->lastRunFailCount;
	}
	unsigned TestSuite::getLastRunSuccessCount() {
	return this->lastRunSuccessCount;

!Line: 73 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 73 to 78 in cf9b3b1

	unsigned TestSuite::getLastRunFailCount () {
	return this->lastRunFailCount;
	}
	unsigned TestSuite::getLastRunSuccessCount() {
	return this->lastRunSuccessCount;

!Line: 73 - error: method 'getLastRunFailCount' can be made const [readability-make-member-function-const,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 77 to 82 in cf9b3b1

	unsigned TestSuite::getLastRunSuccessCount() {
	return this->lastRunSuccessCount;
	}
	void TestSuite::run () {
	if (this->tests.size() == 0) {

!Line: 77 - error: use a trailing return type for this function [modernize-use-trailing-return-type,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 77 to 82 in cf9b3b1

	unsigned TestSuite::getLastRunSuccessCount() {
	return this->lastRunSuccessCount;
	}
	void TestSuite::run () {
	if (this->tests.size() == 0) {

!Line: 77 - error: method 'getLastRunSuccessCount' can be made const [readability-make-member-function-const,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 82 to 87 in cf9b3b1

	if (this->tests.size() == 0) {
	clog << TCPPStr::NTR << endl;
	return;
	}
	if (!this->firstRun) {

!Line: 82 - error: the 'empty' method should be used to check for emptiness instead of 'size' [readability-container-size-empty,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 83 to 88 in cf9b3b1

	clog << TCPPStr::NTR << endl;
	return;
	}
	if (!this->firstRun) {
	this->lastRunSucceeded = true;

!Line: 83 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 97 to 102 in cf9b3b1

	clog << endl
	<< TCPPStr::START_RUN << TCPPStr::SUITE
	<< TCPPStr::APOS << this->suiteName << TCPPStr::APOS
	<< endl
	<< endl;

!Line: 97 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 100 to 105 in cf9b3b1

	<< endl
	<< endl;
	for (TestCase test : this->tests) {
	bool testPassed = false;
	try {

!Line: 100 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 101 to 106 in cf9b3b1

	<< endl;
	for (TestCase test : this->tests) {
	bool testPassed = false;
	try {
	testPassed = test.go();

!Line: 101 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 110 to 115 in cf9b3b1

	<< endl;
	}
	catch (...) {
	cerr << TCPPStr::UNK_EXC
	<< endl;
	}

!Line: 110 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 114 to 119 in cf9b3b1

	<< endl;
	}
	if (!testPassed) {
	this->lastRunFailCount++;

!Line: 114 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 131 to 136 in cf9b3b1

	clog << endl;
	if (this->testSuitePassedMessage &&
	this->lastRunFailCount == 0) {
	clog << TCPPStr::ALL << TCPPStr::APOS << this->suiteName
	<< TCPPStr::APOS << TCPPStr::SUITE_TESTS_PASSED

!Line: 131 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 137 to 142 in cf9b3b1

	<< endl;
	}
	double suiteRuntimeElapsed = static_cast<double>(
	this->totalRuntime)/TCPPNum::NANOS_IN_SEC;

!Line: 137 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 140 to 145 in cf9b3b1

	double suiteRuntimeElapsed = static_cast<double>(
	this->totalRuntime)/TCPPNum::NANOS_IN_SEC;
	clog << fixed;
	clog << setprecision(0);
	clog << TCPPStr::FINISHED_SUITE << TCPPStr::APOS

!Line: 140 - error: variable 'suiteRuntimeElapsed' of type 'double' can be declared 'const' [misc-const-correctness,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 151 to 156 in cf9b3b1

	<< endl;
	}
	/**
	* @brief Add a test to this test suite.
	*

!Line: 151 - error: do not use 'endl' with streams; use '\n' instead [performance-avoid-endl,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 160 to 165 in cf9b3b1

	void TestSuite::addTest (TestCase&& test) {
	this->tests.emplace_back(test);
	}
	/**
	* @brief Add a test to this test suite.

!Line: 160 - error: rvalue reference parameter 'test' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/src/TestCPPTestSuite.cpp

Lines 173 to 178 in cf9b3b1

	test)
	{
	this->tests.emplace_back(
	std::get<0>(test),
	std::get<1>(test),
	this->testSuitePassedMessage

!Line: 173 - error: rvalue reference parameter 'test' is never moved from inside the function body [cppcoreguidelines-rvalue-reference-param-not-moved,-warnings-as-errors]

TestCPP/include/internal/TestCPPTestCase.h

Lines 131 to 136 in cf9b3b1

	TestCase (
	TestObjName&& testName,
	function<void()> test,
	bool testPassedMessage = true,
	bool captureOut = false,
	bool captureLog = false,

!Line: 131 - error: function 'TestCPP::TestCase::TestCase' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name,-warnings-as-errors]

!Line: 114 - note: the definition seen here
!Line: 131 - note: differing parameters are named here: ('testPassedMessage'), in definition: ('msg')

TestCPP/include/internal/TestCPPTestCase.h

Lines 299 to 304 in cf9b3b1

	void logTestFailure (const string& failureMessage);
	/**
	* @brief Internal test run controller.
	*/
	void runTest ();
	/**

!Line: 299 - error: function 'TestCPP::TestCase::logTestFailure' has a definition with different parameter names [readability-inconsistent-declaration-parameter-name,-warnings-as-errors]

!Line: 306 - note: the definition seen here
!Line: 299 - note: differing parameters are named here: ('failureMessage'), in definition: ('reason')

TestCPP/include/internal/TestCPPTestCase.h

Lines 345 to 350 in cf9b3b1

	static nanoseconds duration (F func, Args&&... args)
	{
	auto start = system_clock::now();
	func(forward<Args>(args)...);
	return duration_cast<nanoseconds>(
	system_clock::now() - start

!Line: 345 - error: the parameter 'func' is copied for each invocation but only used as a const reference; consider making it a const reference [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/include/internal/TestCPPUtil.h

Lines 109 to 114 in cf9b3b1

	template <class... Ts> no_destroy(Ts&&... ts) { new (data) T(std::forward<Ts>(ts)...); }
	T& get() { return *reinterpret_cast<T*>(data); }
	};
	/**
	* @brief Log a message that will only be output when debug

!Line: 109 - error: do not implicitly decay an array into a pointer; consider using gsl::array_view or an explicit cast instead [cppcoreguidelines-pro-bounds-array-to-pointer-decay,hicpp-no-array-decay,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 45 to 50 in cf9b3b1

	using std::cerr;
	using std::clog;
	using std::cout;
	using std::endl;
	using std::exception;
	using std::fixed;

!Line: 45 - error: no header providing "std::cerr" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 46 to 51 in cf9b3b1

	using std::clog;
	using std::cout;
	using std::endl;
	using std::exception;
	using std::fixed;
	using std::function;

!Line: 46 - error: no header providing "std::clog" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 47 to 52 in cf9b3b1

	using std::cout;
	using std::endl;
	using std::exception;
	using std::fixed;
	using std::function;
	using std::invalid_argument;

!Line: 47 - error: no header providing "std::cout" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 49 to 54 in cf9b3b1

	using std::exception;
	using std::fixed;
	using std::function;
	using std::invalid_argument;
	using std::rethrow_exception;
	using std::runtime_error;

!Line: 49 - error: no header providing "std::exception" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 50 to 55 in cf9b3b1

	using std::fixed;
	using std::function;
	using std::invalid_argument;
	using std::rethrow_exception;
	using std::runtime_error;
	using std::setprecision;

!Line: 50 - error: no header providing "std::fixed" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 51 to 56 in cf9b3b1

	using std::function;
	using std::invalid_argument;
	using std::rethrow_exception;
	using std::runtime_error;
	using std::setprecision;
	using std::string;

!Line: 51 - error: no header providing "std::function" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 52 to 57 in cf9b3b1

	using std::invalid_argument;
	using std::rethrow_exception;
	using std::runtime_error;
	using std::setprecision;
	using std::string;
	using std::tuple;

!Line: 52 - error: no header providing "std::invalid_argument" is directly included [misc-include-cleaner,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 52 to 57 in cf9b3b1

	using std::invalid_argument;
	using std::rethrow_exception;
	using std::runtime_error;
	using std::setprecision;
	using std::string;
	using std::tuple;

!Line: 52 - error: using decl 'invalid_argument' is unused [misc-unused-using-decls,-warnings-as-errors]

!Line: 52 - note: remove the using

!Maximum character count per GitHub comment has been reached! Not all warnings/errors has been parsed!