Fix CPPCheck issues of type style::funcArgNamesDifferent

[eljonny]

Closes #30.

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 87.52%. Comparing base (88a407d) to head (a1ab1e7).
Report is 3 commits behind head on main.

✅ All tests successful. No failed tests found.

Additional details and impacted files

@@           Coverage Diff           @@
##             main     #105   +/-   ##
=======================================
  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 ⚡

---

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

TestCPP/include/internal/TestCPPCommon.h

Lines 88 to 93 in a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	const string& getName () const;
	/**
	* @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 a1ab1e7

	friend std::ostream& operator<< (
	std::ostream& s,
	const 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 a1ab1e7

	std::ostream& s,
	const 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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	const string& TestObjName::getName () const {
	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 a1ab1e7

	std::ostream& operator<< (
	std::ostream& s,
	const 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 a1ab1e7

	std::ostream& s,
	const 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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	#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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	<< 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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	[[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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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/TestCPPTestCase.h

Lines 345 to 350 in a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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 a1ab1e7

	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

TestCPP/src/TestCPPTestCase.cpp

Lines 53 to 58 in a1ab1e7

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

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

TestCPP/src/TestCPPTestCase.cpp

Lines 53 to 58 in a1ab1e7

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

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

!Line: 53 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 54 to 59 in a1ab1e7

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

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

TestCPP/src/TestCPPTestCase.cpp

Lines 54 to 59 in a1ab1e7

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

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

!Line: 54 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 56 to 61 in a1ab1e7

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

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

TestCPP/src/TestCPPTestCase.cpp

Lines 57 to 62 in a1ab1e7

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

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

TestCPP/src/TestCPPTestCase.cpp

Lines 57 to 62 in a1ab1e7

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

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

!Line: 57 - note: remove the using

TestCPP/src/TestCPPTestCase.cpp

Lines 64 to 69 in a1ab1e7

	atomic_int TestCase::stdoutCaptureCasesConstructed;
	atomic_int TestCase::logCaptureCasesConstructed;
	atomic_int TestCase::stderrCaptureCasesConstructed;
	atomic_int TestCase::stdoutCaptureCasesDestroyed;
	atomic_int TestCase::logCaptureCasesDestroyed;
	atomic_int TestCase::stderrCaptureCasesDestroyed;

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

TestCPP/src/TestCPPTestCase.cpp

Lines 72 to 77 in a1ab1e7

	TestCase::stdoutBuffer =
	no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
	unique_ptr<stringstream, void(*)(stringstream*)>(
	nullptr, [](stringstream*){}
	)
	);

!Line: 72 - error: initialization of 'stdoutBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 79 to 84 in a1ab1e7

	TestCase::clogBuffer =
	no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
	unique_ptr<stringstream, void(*)(stringstream*)>(
	nullptr, [](stringstream*){}
	)
	);

!Line: 79 - error: initialization of 'clogBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 86 to 91 in a1ab1e7

	TestCase::stderrBuffer =
	no_destroy<unique_ptr<stringstream, void(*)(stringstream*)>>(
	unique_ptr<stringstream, void(*)(stringstream*)>(
	nullptr, [](stringstream*){}
	)
	);

!Line: 86 - error: initialization of 'stderrBuffer' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 93 to 98 in a1ab1e7

	TestCase::stdoutOriginal =
	no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
	unique_ptr<streambuf, void(*)(streambuf*)>(
	nullptr, [](streambuf*){}
	)
	);

!Line: 93 - error: initialization of 'stdoutOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 100 to 105 in a1ab1e7

	TestCase::clogOriginal =
	no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
	unique_ptr<streambuf, void(*)(streambuf*)>(
	nullptr, [](streambuf*){}
	)
	);

!Line: 100 - error: initialization of 'clogOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 107 to 112 in a1ab1e7

	TestCase::stderrOriginal =
	no_destroy<unique_ptr<streambuf, void(*)(streambuf*)>>(
	unique_ptr<streambuf, void(*)(streambuf*)>(
	nullptr, [](streambuf*){}
	)
	);

!Line: 107 - error: initialization of 'stderrOriginal' with static storage duration may throw an exception that cannot be caught [cert-err58-cpp,-warnings-as-errors]

!Line: 109 - note: possibly throwing constructor declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 114 to 119 in a1ab1e7

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

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

TestCPP/src/TestCPPTestCase.cpp

Lines 121 to 126 in a1ab1e7

	this->notifyTestPassed = testPassedMessage;
	this->test = testFn;
	this->testName = name;
	if (captureOut) {

!Line: 121 - error: 'notifyTestPassed' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 122 to 127 in a1ab1e7

	this->test = testFn;
	this->testName = name;
	if (captureOut) {
	captureStdout();

!Line: 122 - error: 'test' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 122 to 127 in a1ab1e7

	this->test = testFn;
	this->testName = name;
	if (captureOut) {
	captureStdout();

!Line: 122 - error: parameter 'testFn' is passed by value and only copied once; consider moving it to avoid unnecessary copies [performance-unnecessary-value-param,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 124 to 129 in a1ab1e7

	this->testName = name;
	if (captureOut) {
	captureStdout();
	}
	if (captureLog) {

!Line: 124 - error: 'testName' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 145 to 150 in a1ab1e7

	TestCase::TestCase (const TestCase& o) {
	this->outCompareOption(o.option);
	this->setNotifyPassed(o.notifyTestPassed);
	this->pass = o.pass;
	this->lastRunTime = o.lastRunTime;

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

TestCPP/src/TestCPPTestCase.cpp

Lines 149 to 154 in a1ab1e7

	this->pass = o.pass;
	this->lastRunTime = o.lastRunTime;
	this->stdoutCaptured = o.stdoutCaptured;
	this->clogCaptured = o.clogCaptured;
	this->stderrCaptured = o.stderrCaptured;

!Line: 149 - error: 'pass' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 150 to 155 in a1ab1e7

	this->lastRunTime = o.lastRunTime;
	this->stdoutCaptured = o.stdoutCaptured;
	this->clogCaptured = o.clogCaptured;
	this->stderrCaptured = o.stderrCaptured;

!Line: 150 - error: 'lastRunTime' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 152 to 157 in a1ab1e7

	this->stdoutCaptured = o.stdoutCaptured;
	this->clogCaptured = o.clogCaptured;
	this->stderrCaptured = o.stderrCaptured;
	if (this->stdoutCaptured) {
	captureStdout();

!Line: 152 - error: 'stdoutCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 153 to 158 in a1ab1e7

	this->clogCaptured = o.clogCaptured;
	this->stderrCaptured = o.stderrCaptured;
	if (this->stdoutCaptured) {
	captureStdout();
	}

!Line: 153 - error: 'clogCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 154 to 159 in a1ab1e7

	this->stderrCaptured = o.stderrCaptured;
	if (this->stdoutCaptured) {
	captureStdout();
	}
	if (this->clogCaptured) {

!Line: 154 - error: 'stderrCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 170 to 175 in a1ab1e7

	TestCase::TestCase (TestCase&& o) noexcept {
	this->option = std::move(o.option);
	this->setNotifyPassed(std::move(o.notifyTestPassed));
	this->pass = std::move(o.pass);

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

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in a1ab1e7

	this->option = std::move(o.option);
	this->setNotifyPassed(std::move(o.notifyTestPassed));
	this->pass = std::move(o.pass);
	this->lastRunTime = std::move(o.lastRunTime);

!Line: 171 - error: 'option' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in a1ab1e7

	this->option = std::move(o.option);
	this->setNotifyPassed(std::move(o.notifyTestPassed));
	this->pass = std::move(o.pass);
	this->lastRunTime = std::move(o.lastRunTime);

!Line: 171 - error: std::move of the expression of the trivially-copyable type 'TestCaseOutCompareOptions' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 171 to 176 in a1ab1e7

	this->option = std::move(o.option);
	this->setNotifyPassed(std::move(o.notifyTestPassed));
	this->pass = std::move(o.pass);
	this->lastRunTime = std::move(o.lastRunTime);

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

TestCPP/src/TestCPPTestCase.cpp

Lines 173 to 178 in a1ab1e7

	this->setNotifyPassed(std::move(o.notifyTestPassed));
	this->pass = std::move(o.pass);
	this->lastRunTime = std::move(o.lastRunTime);
	this->stdoutCaptured = std::move(o.stdoutCaptured);

!Line: 173 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 173 to 178 in a1ab1e7

	this->setNotifyPassed(std::move(o.notifyTestPassed));
	this->pass = std::move(o.pass);
	this->lastRunTime = std::move(o.lastRunTime);
	this->stdoutCaptured = std::move(o.stdoutCaptured);

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

TestCPP/src/TestCPPTestCase.cpp

Lines 175 to 180 in a1ab1e7

	this->pass = std::move(o.pass);
	this->lastRunTime = std::move(o.lastRunTime);
	this->stdoutCaptured = std::move(o.stdoutCaptured);
	this->clogCaptured = std::move(o.clogCaptured);
	this->stderrCaptured = std::move(o.stderrCaptured);

!Line: 175 - error: 'pass' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 175 to 180 in a1ab1e7

	this->pass = std::move(o.pass);
	this->lastRunTime = std::move(o.lastRunTime);
	this->stdoutCaptured = std::move(o.stdoutCaptured);
	this->clogCaptured = std::move(o.clogCaptured);
	this->stderrCaptured = std::move(o.stderrCaptured);

!Line: 175 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 176 to 181 in a1ab1e7

	this->lastRunTime = std::move(o.lastRunTime);
	this->stdoutCaptured = std::move(o.stdoutCaptured);
	this->clogCaptured = std::move(o.clogCaptured);
	this->stderrCaptured = std::move(o.stderrCaptured);

!Line: 176 - error: 'lastRunTime' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 176 to 181 in a1ab1e7

	this->lastRunTime = std::move(o.lastRunTime);
	this->stdoutCaptured = std::move(o.stdoutCaptured);
	this->clogCaptured = std::move(o.clogCaptured);
	this->stderrCaptured = std::move(o.stderrCaptured);

!Line: 176 - error: std::move of the expression of the trivially-copyable type 'long long' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 176 to 181 in a1ab1e7

	this->lastRunTime = std::move(o.lastRunTime);
	this->stdoutCaptured = std::move(o.stdoutCaptured);
	this->clogCaptured = std::move(o.clogCaptured);
	this->stderrCaptured = std::move(o.stderrCaptured);

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

TestCPP/src/TestCPPTestCase.cpp

Lines 178 to 183 in a1ab1e7

	this->stdoutCaptured = std::move(o.stdoutCaptured);
	this->clogCaptured = std::move(o.clogCaptured);
	this->stderrCaptured = std::move(o.stderrCaptured);
	if (this->stdoutCaptured) {
	captureStdout();

!Line: 178 - error: 'stdoutCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 178 to 183 in a1ab1e7

	this->stdoutCaptured = std::move(o.stdoutCaptured);
	this->clogCaptured = std::move(o.clogCaptured);
	this->stderrCaptured = std::move(o.stderrCaptured);
	if (this->stdoutCaptured) {
	captureStdout();

!Line: 178 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 179 to 184 in a1ab1e7

	this->clogCaptured = std::move(o.clogCaptured);
	this->stderrCaptured = std::move(o.stderrCaptured);
	if (this->stdoutCaptured) {
	captureStdout();
	}

!Line: 179 - error: 'clogCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 179 to 184 in a1ab1e7

	this->clogCaptured = std::move(o.clogCaptured);
	this->stderrCaptured = std::move(o.stderrCaptured);
	if (this->stdoutCaptured) {
	captureStdout();
	}

!Line: 179 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 180 to 185 in a1ab1e7

	this->stderrCaptured = std::move(o.stderrCaptured);
	if (this->stdoutCaptured) {
	captureStdout();
	}
	if (this->clogCaptured) {

!Line: 180 - error: 'stderrCaptured' should be initialized in a member initializer of the constructor [cppcoreguidelines-prefer-member-initializer,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 180 to 185 in a1ab1e7

	this->stderrCaptured = std::move(o.stderrCaptured);
	if (this->stdoutCaptured) {
	captureStdout();
	}
	if (this->clogCaptured) {

!Line: 180 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 192 to 197 in a1ab1e7

	this->testName = std::move(o.testName);
	this->test = std::move(o.test);
	}
	TestCase::~TestCase () {
	if (TestCase::stdoutBuffer.get() != nullptr)

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

TestCPP/src/TestCPPTestCase.cpp

Lines 193 to 198 in a1ab1e7

	this->test = std::move(o.test);
	}
	TestCase::~TestCase () {
	if (TestCase::stdoutBuffer.get() != nullptr)
	{

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

TestCPP/src/TestCPPTestCase.cpp

Lines 203 to 208 in a1ab1e7

	delete TestCase::stdoutBuffer.get().get();
	TestCase::stdoutBuffer.get() = nullptr;
	}
	TestCase::stdoutCaptureCasesDestroyed += 1;
	}

!Line: 203 - error: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead [cppcoreguidelines-owning-memory,-warnings-as-errors]

!Line: 71 - note: variable declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 215 to 220 in a1ab1e7

	delete TestCase::clogBuffer.get().get();
	TestCase::clogBuffer.get() = nullptr;
	}
	TestCase::logCaptureCasesDestroyed += 1;
	}

!Line: 215 - error: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead [cppcoreguidelines-owning-memory,-warnings-as-errors]

!Line: 78 - note: variable declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 227 to 232 in a1ab1e7

	delete TestCase::stderrBuffer.get().get();
	TestCase::stderrBuffer.get() = nullptr;
	}
	TestCase::stderrCaptureCasesDestroyed += 1;
	}

!Line: 227 - error: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead [cppcoreguidelines-owning-memory,-warnings-as-errors]

!Line: 85 - note: variable declared here

TestCPP/src/TestCPPTestCase.cpp

Lines 235 to 240 in a1ab1e7

	TestCase& TestCase::operator= (const TestCase& rhs) {
	this->outCompareOption(rhs.option);
	this->setNotifyPassed(rhs.notifyTestPassed);
	this->pass = rhs.pass;
	this->lastRunTime = rhs.lastRunTime;

!Line: 235 - error: operator=() does not handle self-assignment properly [cert-oop54-cpp,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 235 to 240 in a1ab1e7

	TestCase& TestCase::operator= (const TestCase& rhs) {
	this->outCompareOption(rhs.option);
	this->setNotifyPassed(rhs.notifyTestPassed);
	this->pass = rhs.pass;
	this->lastRunTime = rhs.lastRunTime;

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

TestCPP/src/TestCPPTestCase.cpp

Lines 262 to 267 in a1ab1e7

	TestCase& TestCase::operator= (TestCase&& rhs) noexcept {
	this->option = std::move(rhs.option);
	this->setNotifyPassed(std::move(rhs.notifyTestPassed));
	this->pass = std::move(rhs.pass);

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

TestCPP/src/TestCPPTestCase.cpp

Lines 263 to 268 in a1ab1e7

	this->option = std::move(rhs.option);
	this->setNotifyPassed(std::move(rhs.notifyTestPassed));
	this->pass = std::move(rhs.pass);
	this->lastRunTime = std::move(rhs.lastRunTime);

!Line: 263 - error: std::move of the expression of the trivially-copyable type 'TestCaseOutCompareOptions' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 265 to 270 in a1ab1e7

	this->setNotifyPassed(std::move(rhs.notifyTestPassed));
	this->pass = std::move(rhs.pass);
	this->lastRunTime = std::move(rhs.lastRunTime);
	this->stdoutCaptured = std::move(rhs.stdoutCaptured);

!Line: 265 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 267 to 272 in a1ab1e7

	this->pass = std::move(rhs.pass);
	this->lastRunTime = std::move(rhs.lastRunTime);
	this->stdoutCaptured = std::move(rhs.stdoutCaptured);
	this->clogCaptured = std::move(rhs.clogCaptured);
	this->stderrCaptured = std::move(rhs.stderrCaptured);

!Line: 267 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 268 to 273 in a1ab1e7

	this->lastRunTime = std::move(rhs.lastRunTime);
	this->stdoutCaptured = std::move(rhs.stdoutCaptured);
	this->clogCaptured = std::move(rhs.clogCaptured);
	this->stderrCaptured = std::move(rhs.stderrCaptured);

!Line: 268 - error: std::move of the expression of the trivially-copyable type 'long long' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 270 to 275 in a1ab1e7

	this->stdoutCaptured = std::move(rhs.stdoutCaptured);
	this->clogCaptured = std::move(rhs.clogCaptured);
	this->stderrCaptured = std::move(rhs.stderrCaptured);
	if (this->stdoutCaptured) {
	captureStdout();

!Line: 270 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 271 to 276 in a1ab1e7

	this->clogCaptured = std::move(rhs.clogCaptured);
	this->stderrCaptured = std::move(rhs.stderrCaptured);
	if (this->stdoutCaptured) {
	captureStdout();
	}

!Line: 271 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 272 to 277 in a1ab1e7

	this->stderrCaptured = std::move(rhs.stderrCaptured);
	if (this->stdoutCaptured) {
	captureStdout();
	}
	if (this->clogCaptured) {

!Line: 272 - error: std::move of the expression of the trivially-copyable type 'bool' has no effect; remove std::move() [hicpp-move-const-arg,performance-move-const-arg,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 290 to 295 in a1ab1e7

	long long TestCase::getLastRuntime () const {
	return this->lastRunTime;
	}
	void TestCase::logFailure(ostream& out, const string& failureReason) const {
	out << fixed;

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

TestCPP/src/TestCPPTestCase.cpp

Lines 302 to 307 in a1ab1e7

	<< endl;
	out << TCPPStr::REASON_ << failureReason << endl;
	}
	void TestCase::logTestFailure (const string& failureReason) {
	unique_ptr<ostream> logStream = nullptr;

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

TestCPP/src/TestCPPTestCase.cpp

Lines 303 to 308 in a1ab1e7

	out << TCPPStr::REASON_ << failureReason << endl;
	}
	void TestCase::logTestFailure (const string& failureReason) {
	unique_ptr<ostream> logStream = nullptr;

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

TestCPP/src/TestCPPTestCase.cpp

Lines 309 to 314 in a1ab1e7

	if (this->clogOriginal.get() != nullptr) {
	logStream = unique_ptr<ostream>(
	new ostream(this->clogOriginal.get().get())
	);
	}
	else {

!Line: 309 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 311 to 316 in a1ab1e7

	new ostream(this->clogOriginal.get().get())
	);
	}
	else {
	logStream = unique_ptr<ostream>(&clog);
	}

!Line: 311 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 320 to 325 in a1ab1e7

	if (this->clogOriginal.get() != nullptr) {
	logStream->flush();
	// If someone is looking for something in the message,
	// and it's captured, make sure it's there.
	logFailure(clog, failureReason);

!Line: 320 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 328 to 333 in a1ab1e7

	logStream.release();
	logStream.reset();
	}
	void TestCase::runTest () {
	clog << TCPPStr::START_RUN << this->testName << endl;

!Line: 328 - error: the value returned by this function should not be disregarded; neglecting it may lead to errors [bugprone-unused-return-value,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 333 to 338 in a1ab1e7

	clog << TCPPStr::START_RUN << this->testName << endl;
	this->lastRunTime = duration(this->test).count();
	if (this->notifyTestPassed) {
	clog << fixed;
	clog << setprecision(TCPPNum::TIME_PRECISION);
	clog << TCPPStr::TEST << this->testName << TCPPStr::PASS

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

TestCPP/src/TestCPPTestCase.cpp

Lines 343 to 348 in a1ab1e7

	<< endl;
	}
	this->pass = true;
	}
	bool TestCase::go () {

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

TestCPP/src/TestCPPTestCase.cpp

Lines 348 to 353 in a1ab1e7

	bool TestCase::go () {
	try {
	runTest();
	return true;
	}
	catch(const char * errorMessage) {

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

TestCPP/src/TestCPPTestCase.cpp

Lines 377 to 382 in a1ab1e7

	void TestCase::captureStdout () {
	if (TestCase::stdoutCaptureCasesConstructed ==
	TestCase::stdoutCaptureCasesDestroyed)
	{
	TestCase::stdoutCaptureCasesConstructed += 1;
	TestCase::stdoutBuffer =

!Line: 377 - error: method 'captureStdout' can be made static [readability-convert-member-functions-to-static,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 401 to 406 in a1ab1e7

	void TestCase::captureClog () {
	if (TestCase::logCaptureCasesConstructed ==
	TestCase::logCaptureCasesDestroyed)
	{
	TestCase::logCaptureCasesConstructed += 1;
	TestCase::clogBuffer =

!Line: 401 - error: method 'captureClog' can be made static [readability-convert-member-functions-to-static,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 425 to 430 in a1ab1e7

	void TestCase::captureStdErr () {
	if (TestCase::stderrCaptureCasesConstructed ==
	TestCase::stderrCaptureCasesDestroyed)
	{
	TestCase::stderrCaptureCasesConstructed += 1;
	TestCase::stderrBuffer =

!Line: 425 - error: method 'captureStdErr' can be made static [readability-convert-member-functions-to-static,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 481 to 486 in a1ab1e7

	bool TestCase::checkStdout (const string& against) {
	return checkOutput(TestCase::stdoutBuffer.get()->str(),
	against);
	}
	bool TestCase::checkLog (const string& against) {

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

TestCPP/src/TestCPPTestCase.cpp

Lines 486 to 491 in a1ab1e7

	bool TestCase::checkLog (const string& against) {
	return checkOutput(TestCase::clogBuffer.get()->str(),
	against);
	}
	bool TestCase::checkStderr (const string& against) {

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

TestCPP/src/TestCPPTestCase.cpp

Lines 491 to 496 in a1ab1e7

	bool TestCase::checkStderr (const string& against) {
	return checkOutput(TestCase::stderrBuffer.get()->str(),
	against);
	}
	bool TestCase::checkOutput (const string& source, const string& against)

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

TestCPP/src/TestCPPTestCase.cpp

Lines 496 to 501 in a1ab1e7

	bool TestCase::checkOutput (const string& source, const string& against)
	{
	switch (this->option) {
	case EXACT:
	if (source == against) {
	return true;

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

TestCPP/src/TestCPPTestCase.cpp

Lines 509 to 514 in a1ab1e7

	if (this->clogOriginal.get() != nullptr) {
	ostream tmp(this->clogOriginal.get().get());
	tmp << nomatch.str() << endl;
	tmp.flush();
	}
	else {

!Line: 509 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 510 to 515 in a1ab1e7

	ostream tmp(this->clogOriginal.get().get());
	tmp << nomatch.str() << endl;
	tmp.flush();
	}
	else {
	clog << nomatch.str() << endl;

!Line: 510 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 511 to 516 in a1ab1e7

	tmp << nomatch.str() << endl;
	tmp.flush();
	}
	else {
	clog << nomatch.str() << endl;
	}

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

TestCPP/src/TestCPPTestCase.cpp

Lines 515 to 520 in a1ab1e7

	clog << nomatch.str() << endl;
	}
	return false;
	}

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

TestCPP/src/TestCPPTestCase.cpp

Lines 531 to 536 in a1ab1e7

	if (this->clogOriginal.get() != nullptr) {
	ostream tmp(this->clogOriginal.get().get());
	tmp << nomatch.str() << endl;
	tmp.flush();
	}
	else {

!Line: 531 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 532 to 537 in a1ab1e7

	ostream tmp(this->clogOriginal.get().get());
	tmp << nomatch.str() << endl;
	tmp.flush();
	}
	else {
	clog << nomatch.str() << endl;

!Line: 532 - error: static member accessed through instance [readability-static-accessed-through-instance,-warnings-as-errors]

TestCPP/src/TestCPPTestCase.cpp

Lines 533 to 538 in a1ab1e7

	tmp << nomatch.str() << endl;
	tmp.flush();
	}
	else {
	clog << nomatch.str() << endl;
	}

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

TestCPP/src/TestCPPTestCase.cpp

Lines 537 to 542 in a1ab1e7

	clog << nomatch.str() << endl;
	}
	return false;
	}

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

TestCPP/src/TestCPPTestCase.cpp

Lines 544 to 549 in a1ab1e7

	stringstream re;
	re << TCPPStr::UNK_CMP_OPT << this->option;
	throw TestCPPException(re.str());
	}
	}
	}

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

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