ilusha/unittest-cpp
1
0
Fork 0
mirror of https://github.com/unittest-cpp/unittest-cpp synced 2026-09-29 04:35:29 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Compare commits

base: ilusha:master
Branches Tags
ilusha:master
ilusha:googlecode
ilusha:sourceforge
ilusha:v2.0.0
ilusha:v1.6.1
ilusha:v1.6.0
ilusha:v1.5.1
ilusha:v1.5.0
ilusha:v1.4
..
compare: ilusha:v1.6.1
Branches Tags
ilusha:master
ilusha:googlecode
ilusha:sourceforge
ilusha:v2.0.0
ilusha:v1.6.1
ilusha:v1.6.0
ilusha:v1.5.1
ilusha:v1.5.0
ilusha:v1.4

No commits in common. "master" and "v1.6.1" have entirely different histories.
master ... v1.6.1

24 changed files with 176 additions and 392 deletions
Download patch file Download diff file Expand all files Collapse all files

94
CMakeLists.txt
View file

@ -1,26 +1,10 @@
cmake_minimum_required(VERSION 3.0) cmake_minimum_required(VERSION 2.8.1)
project(UnitTest++ VERSION 2.1.0) project(UnitTest++)
option(UTPP_USE_PLUS_SIGN option(UTPP_USE_PLUS_SIGN "Set this to OFF if you wish to use '-cpp' instead of '++' in lib/include paths" ON)
"Set this to OFF if you wish to use '-cpp' instead of '++' in lib/include paths"
ON)
option(UTPP_INCLUDE_TESTS_IN_BUILD
"Set this to OFF if you do not wish to automatically build or run unit tests as part of the default cmake --build"
ON)
option(UTPP_AMPLIFY_WARNINGS
"Set this to OFF if you wish to use CMake default warning levels; should generally only use to work around support issues for your specific compiler"
ON)
set(LIB_SUFFIX "" CACHE STRING "Identifier to add to end of lib directory name e.g. 64 for lib64") if(MSVC14 OR MSVC12)
# has the support we need
if (MSVC)
# CHECK_CXX_COMPILER_FLAG could be used
# but MSVC version is preferred for feature requirements
if (MSVC14 OR MSVC12)
# has the support we need
else()
message(STATUS "The MSVC compiler version does not support UnitTest++ C++11 features.")
endif()
else() else()
include(CheckCXXCompilerFlag) include(CheckCXXCompilerFlag)
CHECK_CXX_COMPILER_FLAG("-std=c++14" COMPILER_SUPPORTS_CXX14) CHECK_CXX_COMPILER_FLAG("-std=c++14" COMPILER_SUPPORTS_CXX14)
@ -30,18 +14,7 @@ else()
elseif(COMPILER_SUPPORTS_CXX11) elseif(COMPILER_SUPPORTS_CXX11)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
else() else()
message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support.") message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
endif()
endif()
# up warning level for project
if (${UTPP_AMPLIFY_WARNINGS})
# instead of getting compiler specific, we're going to try making an assumption that an existing /W# means
# we are dealing with an MSVC or MSVC-like compiler (e.g. Intel on Windows)
if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX")
else()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Werror")
endif() endif()
endif() endif()
@ -64,8 +37,6 @@ source_group(${platformDir_} FILES ${platformHeaders_} ${platformSources_})
# create the lib # create the lib
add_library(UnitTest++ STATIC ${headers_} ${sources_} ${platformHeaders_} ${platformSources_}) add_library(UnitTest++ STATIC ${headers_} ${sources_} ${platformHeaders_} ${platformSources_})
add_library(UnitTest++::UnitTest++ ALIAS UnitTest++)
if(${UTPP_USE_PLUS_SIGN}) if(${UTPP_USE_PLUS_SIGN})
set_target_properties(UnitTest++ PROPERTIES OUTPUT_NAME UnitTest++) set_target_properties(UnitTest++ PROPERTIES OUTPUT_NAME UnitTest++)
@ -76,25 +47,18 @@ endif()
file(GLOB TEST_SRCS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} tests/*.cpp tests/*.h) file(GLOB TEST_SRCS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} tests/*.cpp tests/*.h)
source_group( "" FILES ${TEST_SRCS}) source_group( "" FILES ${TEST_SRCS})
add_executable(TestUnitTest++ ${TEST_SRCS}) add_executable(TestUnitTest++ ${TEST_SRCS})
include_directories(.)
if(${UTPP_USE_PLUS_SIGN}) if(${UTPP_USE_PLUS_SIGN})
set_target_properties(TestUnitTest++ PROPERTIES OUTPUT_NAME TestUnitTest++) set_target_properties(TestUnitTest++ PROPERTIES OUTPUT_NAME TestUnitTest++)
endif() endif()
target_link_libraries(TestUnitTest++ target_link_libraries(TestUnitTest++ UnitTest++)
PUBLIC
UnitTest++::UnitTest++
)
# run unit tests as post build step # run unit tests as post build step
add_custom_command(TARGET TestUnitTest++ add_custom_command(TARGET TestUnitTest++
POST_BUILD COMMAND TestUnitTest++ POST_BUILD COMMAND TestUnitTest++
COMMENT "Running unit tests") COMMENT "Running unit tests")
if(NOT ${UTPP_INCLUDE_TESTS_IN_BUILD})
set_target_properties(TestUnitTest++ PROPERTIES EXCLUDE_FROM_ALL 1)
endif()
# add install targets # add install targets
# need a custom install path? # need a custom install path?
@ -105,41 +69,11 @@ else()
set (UTPP_INSTALL_DESTINATION "include/UnitTestPP") set (UTPP_INSTALL_DESTINATION "include/UnitTestPP")
endif() endif()
target_include_directories( UnitTest++ set(config_install_dir_ lib/cmake/${PROJECT_NAME})
PUBLIC
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}/include/UnitTest++>
)
set_target_properties(UnitTest++ PROPERTIES DEBUG_POSTFIX "-d")
set_target_properties(TestUnitTest++ PROPERTIES DEBUG_POSTFIX "-d")
set(config_install_dir_ lib${LIB_SUFFIX}/cmake/${PROJECT_NAME})
set(targets_export_name_ "${PROJECT_NAME}Targets") set(targets_export_name_ "${PROJECT_NAME}Targets")
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
cmake/UnitTest++ConfigVersion.cmake
VERSION ${UnitTest++_VERSION}
COMPATIBILITY SameMajorVersion
)
install(TARGETS UnitTest++ EXPORT "${targets_export_name_}" DESTINATION lib${LIB_SUFFIX}) install(TARGETS UnitTest++ EXPORT "${targets_export_name_}" DESTINATION lib)
install(FILES ${headers_} DESTINATION ${UTPP_INSTALL_DESTINATION}) install(FILES ${headers_} DESTINATION ${UTPP_INSTALL_DESTINATION})
install(FILES ${platformHeaders_} DESTINATION ${UTPP_INSTALL_DESTINATION}/${platformDir_}) install(FILES ${platformHeaders_} DESTINATION ${UTPP_INSTALL_DESTINATION}/${platformDir_})
install(FILES install(FILES cmake/UnitTest++Config.cmake DESTINATION "${config_install_dir_}")
cmake/UnitTest++Config.cmake install(EXPORT "${targets_export_name_}" DESTINATION "${config_install_dir_}")
${CMAKE_CURRENT_BINARY_DIR}/cmake/UnitTest++ConfigVersion.cmake
DESTINATION "${config_install_dir_}")
install(EXPORT "${targets_export_name_}" NAMESPACE "UnitTest++::" DESTINATION "${config_install_dir_}")
set(prefix ${CMAKE_INSTALL_PREFIX})
set(exec_prefix ${CMAKE_INSTALL_PREFIX}/bin)
set(libdir ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX})
set(includedir ${CMAKE_INSTALL_PREFIX}/include/UnitTest++)
configure_file("UnitTest++.pc.in" "UnitTest++.pc" @ONLY)
if(${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
set(pkgconfdir ${CMAKE_INSTALL_PREFIX}/libdata/pkgconfig)
else()
set(pkgconfdir ${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/pkgconfig)
endif()
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/UnitTest++.pc"
DESTINATION "${pkgconfdir}")

0
ChangeLog Normal file
View file

6
INSTALL
View file

@ -1,9 +1,3 @@
Preamble: If you are installing UnitTest++ from source, or from a
release prior to 1.6.1, you will need to have autotools installed and
run `autoreconf -i; autoconf` prior to following the standard
instructions below.
Installation Instructions Installation Instructions
************************* *************************

15
README.md
View file

@ -1,6 +1,3 @@
> ### Maintenance of UnitTest++, recently sporadic, is officially on hiatus until 26 November 2020. Subscribe to https://github.com/unittest-cpp/unittest-cpp/issues/180 for updates.
[![Build Status](https://travis-ci.org/unittest-cpp/unittest-cpp.svg?branch=master)](https://travis-ci.org/unittest-cpp/unittest-cpp) [![Build Status](https://travis-ci.org/unittest-cpp/unittest-cpp.svg?branch=master)](https://travis-ci.org/unittest-cpp/unittest-cpp)
[![Build status](https://ci.appveyor.com/api/projects/status/ffs2k8dddts5cyok/branch/master?svg=true)](https://ci.appveyor.com/project/pjohnmeyer/unittest-cpp/branch/master) [![Build status](https://ci.appveyor.com/api/projects/status/ffs2k8dddts5cyok/branch/master?svg=true)](https://ci.appveyor.com/project/pjohnmeyer/unittest-cpp/branch/master)
@ -33,17 +30,17 @@ Via svn:
svn checkout https://github.com/unittest-cpp/unittest-cpp/trunk unittest-cpp svn checkout https://github.com/unittest-cpp/unittest-cpp/trunk unittest-cpp
### Latest release (v2.0.0) ### ### Latest release (v1.6.1) ###
Via git: Via git:
git clone https://github.com/unittest-cpp/unittest-cpp git clone https://github.com/unittest-cpp/unittest-cpp
cd unittest-cpp cd unittest-cpp
git checkout v2.0.0 git checkout v1.6.1
Via svn: Via svn:
svn checkout https://github.com/unittest-cpp/unittest-cpp/tags/v2.0.0 unittest-cpp svn checkout https://github.com/unittest-cpp/unittest-cpp/tags/v1.6.1 unittest-cpp
License License
--------- ---------
@ -80,12 +77,6 @@ Contributors
Historic release notes Historic release notes
---------------------- ----------------------
### Version 2.0.0 (2017-01-13) ###
- Change Check method supporting CHECK macro to accept argument by reference
- Introduce long macro forms (e.g. UNITTEST_CHECK); make short forms optional
- Improved Visual Studio 2015 support
- [Full List](https://github.com/unittest-cpp/unittest-cpp/issues?q=milestone%3A2.0.0+)
### Version 1.6.0 (2016-02-29) ### ### Version 1.6.0 (2016-02-29) ###
- Add REQUIRE macro to end tests early when selected checks fail - Add REQUIRE macro to end tests early when selected checks fail
- [Full List](https://github.com/unittest-cpp/unittest-cpp/issues?q=milestone%3A1.6.0+) - [Full List](https://github.com/unittest-cpp/unittest-cpp/issues?q=milestone%3A1.6.0+)

176
UnitTest++/CheckMacros.h
View file

@ -11,175 +11,162 @@
#include "CurrentTest.h" #include "CurrentTest.h"
#include "ReportAssertImpl.h" #include "ReportAssertImpl.h"
#define UNITTEST_CHECK(value) \ #ifdef CHECK
#error UnitTest++ redefines CHECK
#endif
#ifdef CHECK_EQUAL
#error UnitTest++ redefines CHECK_EQUAL
#endif
#ifdef CHECK_CLOSE
#error UnitTest++ redefines CHECK_CLOSE
#endif
#ifdef CHECK_ARRAY_EQUAL
#error UnitTest++ redefines CHECK_ARRAY_EQUAL
#endif
#ifdef CHECK_ARRAY_CLOSE
#error UnitTest++ redefines CHECK_ARRAY_CLOSE
#endif
#ifdef CHECK_ARRAY2D_CLOSE
#error UnitTest++ redefines CHECK_ARRAY2D_CLOSE
#endif
#define CHECK(value) \
UNITTEST_MULTILINE_MACRO_BEGIN \ UNITTEST_MULTILINE_MACRO_BEGIN \
UNITTEST_IMPL_TRY \ UT_TRY \
({ \ ({ \
if (!UnitTest::Check(value)) \ if (!UnitTest::Check(value)) \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), #value); \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), #value); \
}) \ }) \
UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException) \ UT_RETHROW (UnitTest::RequiredCheckException) \
UNITTEST_IMPL_CATCH (std::exception, e, \ UT_CATCH (std::exception, e, \
{ \ { \
UnitTest::MemoryOutStream UnitTest_message; \ UnitTest::MemoryOutStream message; \
UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK(" #value ")"; \ message << "Unhandled exception (" << e.what() << ") in CHECK(" #value ")"; \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
UnitTest_message.GetText()); \ message.GetText()); \
}) \ }) \
UNITTEST_IMPL_CATCH_ALL \ UT_CATCH_ALL \
({ \ ({ \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
"Unhandled exception in CHECK(" #value ")"); \ "Unhandled exception in CHECK(" #value ")"); \
}) \ }) \
UNITTEST_MULTILINE_MACRO_END UNITTEST_MULTILINE_MACRO_END
#define UNITTEST_CHECK_EQUAL(expected, actual) \ #define CHECK_EQUAL(expected, actual) \
UNITTEST_MULTILINE_MACRO_BEGIN \ UNITTEST_MULTILINE_MACRO_BEGIN \
UNITTEST_IMPL_TRY \ UT_TRY \
({ \ ({ \
UnitTest::CheckEqual(*UnitTest::CurrentTest::Results(), expected, actual, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \ UnitTest::CheckEqual(*UnitTest::CurrentTest::Results(), expected, actual, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
}) \ }) \
UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException) \ UT_RETHROW (UnitTest::RequiredCheckException) \
UNITTEST_IMPL_CATCH (std::exception, e, \ UT_CATCH (std::exception, e, \
{ \ { \
UnitTest::MemoryOutStream UnitTest_message; \ UnitTest::MemoryOutStream message; \
UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")"; \ message << "Unhandled exception (" << e.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")"; \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
UnitTest_message.GetText()); \ message.GetText()); \
}) \ }) \
UNITTEST_IMPL_CATCH_ALL \ UT_CATCH_ALL \
({ \ ({ \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
"Unhandled exception in CHECK_EQUAL(" #expected ", " #actual ")"); \ "Unhandled exception in CHECK_EQUAL(" #expected ", " #actual ")"); \
}) \ }) \
UNITTEST_MULTILINE_MACRO_END UNITTEST_MULTILINE_MACRO_END
#define UNITTEST_CHECK_CLOSE(expected, actual, tolerance) \ #define CHECK_CLOSE(expected, actual, tolerance) \
UNITTEST_MULTILINE_MACRO_BEGIN \ UNITTEST_MULTILINE_MACRO_BEGIN \
UNITTEST_IMPL_TRY \ UT_TRY \
({ \ ({ \
UnitTest::CheckClose(*UnitTest::CurrentTest::Results(), expected, actual, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \ UnitTest::CheckClose(*UnitTest::CurrentTest::Results(), expected, actual, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
}) \ }) \
UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException) \ UT_RETHROW (UnitTest::RequiredCheckException) \
UNITTEST_IMPL_CATCH (std::exception, e, \ UT_CATCH (std::exception, e, \
{ \ { \
UnitTest::MemoryOutStream UnitTest_message; \ UnitTest::MemoryOutStream message; \
UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_CLOSE(" #expected ", " #actual ")"; \ message << "Unhandled exception (" << e.what() << ") in CHECK_CLOSE(" #expected ", " #actual ")"; \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
UnitTest_message.GetText()); \ message.GetText()); \
}) \ }) \
UNITTEST_IMPL_CATCH_ALL \ UT_CATCH_ALL \
({ \ ({ \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
"Unhandled exception in CHECK_CLOSE(" #expected ", " #actual ")"); \ "Unhandled exception in CHECK_CLOSE(" #expected ", " #actual ")"); \
}) \ }) \
UNITTEST_MULTILINE_MACRO_END UNITTEST_MULTILINE_MACRO_END
#define UNITTEST_CHECK_ARRAY_EQUAL(expected, actual, count) \ #define CHECK_ARRAY_EQUAL(expected, actual, count) \
UNITTEST_MULTILINE_MACRO_BEGIN \ UNITTEST_MULTILINE_MACRO_BEGIN \
UNITTEST_IMPL_TRY \ UT_TRY \
({ \ ({ \
UnitTest::CheckArrayEqual(*UnitTest::CurrentTest::Results(), expected, actual, count, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \ UnitTest::CheckArrayEqual(*UnitTest::CurrentTest::Results(), expected, actual, count, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
}) \ }) \
UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException) \ UT_RETHROW (UnitTest::RequiredCheckException) \
UNITTEST_IMPL_CATCH (std::exception, e, \ UT_CATCH (std::exception, e, \
{ \ { \
UnitTest::MemoryOutStream UnitTest_message; \ UnitTest::MemoryOutStream message; \
UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY_EQUAL(" #expected ", " #actual ")"; \ message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY_EQUAL(" #expected ", " #actual ")"; \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
UnitTest_message.GetText()); \ message.GetText()); \
}) \ }) \
UNITTEST_IMPL_CATCH_ALL \ UT_CATCH_ALL \
({ \ ({ \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
"Unhandled exception in CHECK_ARRAY_EQUAL(" #expected ", " #actual ")"); \ "Unhandled exception in CHECK_ARRAY_EQUAL(" #expected ", " #actual ")"); \
}) \ }) \
UNITTEST_MULTILINE_MACRO_END UNITTEST_MULTILINE_MACRO_END
#define UNITTEST_CHECK_ARRAY_CLOSE(expected, actual, count, tolerance) \ #define CHECK_ARRAY_CLOSE(expected, actual, count, tolerance) \
UNITTEST_MULTILINE_MACRO_BEGIN \ UNITTEST_MULTILINE_MACRO_BEGIN \
UNITTEST_IMPL_TRY \ UT_TRY \
({ \ ({ \
UnitTest::CheckArrayClose(*UnitTest::CurrentTest::Results(), expected, actual, count, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \ UnitTest::CheckArrayClose(*UnitTest::CurrentTest::Results(), expected, actual, count, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
}) \ }) \
UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException) \ UT_RETHROW (UnitTest::RequiredCheckException) \
UNITTEST_IMPL_CATCH (std::exception, e, \ UT_CATCH (std::exception, e, \
{ \ { \
UnitTest::MemoryOutStream UnitTest_message; \ UnitTest::MemoryOutStream message; \
UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY_CLOSE(" #expected ", " #actual ")"; \ message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY_CLOSE(" #expected ", " #actual ")"; \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
UnitTest_message.GetText()); \ message.GetText()); \
}) \ }) \
UNITTEST_IMPL_CATCH_ALL \ UT_CATCH_ALL \
({ \ ({ \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
"Unhandled exception in CHECK_ARRAY_CLOSE(" #expected ", " #actual ")"); \ "Unhandled exception in CHECK_ARRAY_CLOSE(" #expected ", " #actual ")"); \
}) \ }) \
UNITTEST_MULTILINE_MACRO_END UNITTEST_MULTILINE_MACRO_END
#define UNITTEST_CHECK_ARRAY2D_CLOSE(expected, actual, rows, columns, tolerance) \ #define CHECK_ARRAY2D_CLOSE(expected, actual, rows, columns, tolerance) \
UNITTEST_MULTILINE_MACRO_BEGIN \ UNITTEST_MULTILINE_MACRO_BEGIN \
UNITTEST_IMPL_TRY \ UT_TRY \
({ \ ({ \
UnitTest::CheckArray2DClose(*UnitTest::CurrentTest::Results(), expected, actual, rows, columns, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \ UnitTest::CheckArray2DClose(*UnitTest::CurrentTest::Results(), expected, actual, rows, columns, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
}) \ }) \
UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException) \ UT_RETHROW (UnitTest::RequiredCheckException) \
UNITTEST_IMPL_CATCH (std::exception, e, \ UT_CATCH (std::exception, e, \
{ \ { \
UnitTest::MemoryOutStream UnitTest_message; \ UnitTest::MemoryOutStream message; \
UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY2D_CLOSE(" #expected ", " #actual ")"; \ message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY2D_CLOSE(" #expected ", " #actual ")"; \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
UnitTest_message.GetText()); \ message.GetText()); \
}) \ }) \
UNITTEST_IMPL_CATCH_ALL \ UT_CATCH_ALL \
({ \ ({ \
UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \ UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), \
"Unhandled exception in CHECK_ARRAY2D_CLOSE(" #expected ", " #actual ")"); \ "Unhandled exception in CHECK_ARRAY2D_CLOSE(" #expected ", " #actual ")"); \
}) \ }) \
UNITTEST_MULTILINE_MACRO_END UNITTEST_MULTILINE_MACRO_END
#ifndef UNITTEST_DISABLE_SHORT_MACROS
#ifdef CHECK
#error CHECK already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_CHECK instead
#else
#define CHECK UNITTEST_CHECK
#endif
#ifdef CHECK_EQUAL
#error CHECK_EQUAL already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_CHECK_EQUAL instead
#else
#define CHECK_EQUAL UNITTEST_CHECK_EQUAL
#endif
#ifdef CHECK_CLOSE
#error CHECK_CLOSE already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_CHECK_CLOSE instead
#else
#define CHECK_CLOSE UNITTEST_CHECK_CLOSE
#endif
#ifdef CHECK_ARRAY_EQUAL
#error CHECK_ARRAY_EQUAL already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_CHECK_ARRAY_EQUAL instead
#else
#define CHECK_ARRAY_EQUAL UNITTEST_CHECK_ARRAY_EQUAL
#endif
#ifdef CHECK_ARRAY_CLOSE
#error CHECK_ARRAY_CLOSE already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_CHECK_ARRAY_CLOSE instead
#else
#define CHECK_ARRAY_CLOSE UNITTEST_CHECK_ARRAY_CLOSE
#endif
#ifdef CHECK_ARRAY2D_CLOSE
#error CHECK_ARRAY2D_CLOSE already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_CHECK_ARRAY2D_CLOSE instead
#else
#define CHECK_ARRAY2D_CLOSE UNITTEST_CHECK_ARRAY2D_CLOSE
#endif
#endif
// CHECK_THROW and CHECK_ASSERT only exist when UNITTEST_NO_EXCEPTIONS isn't defined (see config.h) // CHECK_THROW and CHECK_ASSERT only exist when UNITTEST_NO_EXCEPTIONS isn't defined (see config.h)
#ifndef UNITTEST_NO_EXCEPTIONS #ifndef UNITTEST_NO_EXCEPTIONS
#define UNITTEST_CHECK_THROW(expression, ExpectedExceptionType) \ #define CHECK_THROW(expression, ExpectedExceptionType) \
UNITTEST_MULTILINE_MACRO_BEGIN \ UNITTEST_MULTILINE_MACRO_BEGIN \
bool caught_ = false; \ bool caught_ = false; \
try { expression; } \ try { expression; } \
@ -190,7 +177,7 @@
UNITTEST_MULTILINE_MACRO_END UNITTEST_MULTILINE_MACRO_END
#define UNITTEST_CHECK_ASSERT(expression) \ #define CHECK_ASSERT(expression) \
UNITTEST_MULTILINE_MACRO_BEGIN \ UNITTEST_MULTILINE_MACRO_BEGIN \
UnitTest::Detail::ExpectAssert(true); \ UnitTest::Detail::ExpectAssert(true); \
CHECK_THROW(expression, UnitTest::AssertException); \ CHECK_THROW(expression, UnitTest::AssertException); \
@ -198,19 +185,4 @@
UNITTEST_MULTILINE_MACRO_END UNITTEST_MULTILINE_MACRO_END
#endif #endif
#ifndef UNITTEST_DISABLE_SHORT_MACROS
#ifdef CHECK_THROW
#error CHECK_THROW already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_CHECK_THROW instead
#else
#define CHECK_THROW UNITTEST_CHECK_THROW
#endif
#ifdef CHECK_ASSERT
#error CHECK_ASSERT already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_CHECK_ASSERT instead
#else
#define CHECK_ASSERT UNITTEST_CHECK_ASSERT
#endif
#endif #endif
#endif

32
UnitTest++/Checks.h
View file

@ -9,7 +9,7 @@ namespace UnitTest {
template< typename Value > template< typename Value >
bool Check(Value const& value) bool Check(Value const value)
{ {
return !!value; // doing double negative to avoid silly VS warnings return !!value; // doing double negative to avoid silly VS warnings
} }
@ -57,10 +57,10 @@ namespace UnitTest {
template< typename Expected, typename Actual > template< typename Expected, typename Actual >
void CheckArrayEqual(TestResults& results, Expected const& expected, Actual const& actual, void CheckArrayEqual(TestResults& results, Expected const& expected, Actual const& actual,
size_t const count, TestDetails const& details) int const count, TestDetails const& details)
{ {
bool equal = true; bool equal = true;
for (size_t i = 0; i < count; ++i) for (int i = 0; i < count; ++i)
equal &= (expected[i] == actual[i]); equal &= (expected[i] == actual[i]);
if (!equal) if (!equal)
@ -69,12 +69,12 @@ namespace UnitTest {
stream << "Expected [ "; stream << "Expected [ ";
for (size_t expectedIndex = 0; expectedIndex < count; ++expectedIndex) for (int expectedIndex = 0; expectedIndex < count; ++expectedIndex)
stream << expected[expectedIndex] << " "; stream << expected[expectedIndex] << " ";
stream << "] but was [ "; stream << "] but was [ ";
for (size_t actualIndex = 0; actualIndex < count; ++actualIndex) for (int actualIndex = 0; actualIndex < count; ++actualIndex)
stream << actual[actualIndex] << " "; stream << actual[actualIndex] << " ";
stream << "]"; stream << "]";
@ -84,17 +84,17 @@ namespace UnitTest {
} }
template< typename Expected, typename Actual, typename Tolerance > template< typename Expected, typename Actual, typename Tolerance >
bool ArrayAreClose(Expected const& expected, Actual const& actual, size_t const count, Tolerance const& tolerance) bool ArrayAreClose(Expected const& expected, Actual const& actual, int const count, Tolerance const& tolerance)
{ {
bool equal = true; bool equal = true;
for (size_t i = 0; i < count; ++i) for (int i = 0; i < count; ++i)
equal &= AreClose(expected[i], actual[i], tolerance); equal &= AreClose(expected[i], actual[i], tolerance);
return equal; return equal;
} }
template< typename Expected, typename Actual, typename Tolerance > template< typename Expected, typename Actual, typename Tolerance >
void CheckArrayClose(TestResults& results, Expected const& expected, Actual const& actual, void CheckArrayClose(TestResults& results, Expected const& expected, Actual const& actual,
size_t const count, Tolerance const& tolerance, TestDetails const& details) int const count, Tolerance const& tolerance, TestDetails const& details)
{ {
bool equal = ArrayAreClose(expected, actual, count, tolerance); bool equal = ArrayAreClose(expected, actual, count, tolerance);
@ -103,11 +103,11 @@ namespace UnitTest {
UnitTest::MemoryOutStream stream; UnitTest::MemoryOutStream stream;
stream << "Expected [ "; stream << "Expected [ ";
for (size_t expectedIndex = 0; expectedIndex < count; ++expectedIndex) for (int expectedIndex = 0; expectedIndex < count; ++expectedIndex)
stream << expected[expectedIndex] << " "; stream << expected[expectedIndex] << " ";
stream << "] +/- " << tolerance << " but was [ "; stream << "] +/- " << tolerance << " but was [ ";
for (size_t actualIndex = 0; actualIndex < count; ++actualIndex) for (int actualIndex = 0; actualIndex < count; ++actualIndex)
stream << actual[actualIndex] << " "; stream << actual[actualIndex] << " ";
stream << "]"; stream << "]";
@ -117,10 +117,10 @@ namespace UnitTest {
template< typename Expected, typename Actual, typename Tolerance > template< typename Expected, typename Actual, typename Tolerance >
void CheckArray2DClose(TestResults& results, Expected const& expected, Actual const& actual, void CheckArray2DClose(TestResults& results, Expected const& expected, Actual const& actual,
size_t const rows, size_t const columns, Tolerance const& tolerance, TestDetails const& details) int const rows, int const columns, Tolerance const& tolerance, TestDetails const& details)
{ {
bool equal = true; bool equal = true;
for (size_t i = 0; i < rows; ++i) for (int i = 0; i < rows; ++i)
equal &= ArrayAreClose(expected[i], actual[i], columns, tolerance); equal &= ArrayAreClose(expected[i], actual[i], columns, tolerance);
if (!equal) if (!equal)
@ -129,20 +129,20 @@ namespace UnitTest {
stream << "Expected [ "; stream << "Expected [ ";
for (size_t expectedRow = 0; expectedRow < rows; ++expectedRow) for (int expectedRow = 0; expectedRow < rows; ++expectedRow)
{ {
stream << "[ "; stream << "[ ";
for (size_t expectedColumn = 0; expectedColumn < columns; ++expectedColumn) for (int expectedColumn = 0; expectedColumn < columns; ++expectedColumn)
stream << expected[expectedRow][expectedColumn] << " "; stream << expected[expectedRow][expectedColumn] << " ";
stream << "] "; stream << "] ";
} }
stream << "] +/- " << tolerance << " but was [ "; stream << "] +/- " << tolerance << " but was [ ";
for (size_t actualRow = 0; actualRow < rows; ++actualRow) for (int actualRow = 0; actualRow < rows; ++actualRow)
{ {
stream << "[ "; stream << "[ ";
for (size_t actualColumn = 0; actualColumn < columns; ++actualColumn) for (int actualColumn = 0; actualColumn < columns; ++actualColumn)
stream << actual[actualRow][actualColumn] << " "; stream << actual[actualRow][actualColumn] << " ";
stream << "] "; stream << "] ";
} }

14
UnitTest++/Config.h
View file

@ -16,13 +16,12 @@
#ifdef _USRDLL #ifdef _USRDLL
#define UNITTEST_WIN32_DLL #define UNITTEST_WIN32_DLL
#endif #endif
#define UNITTEST_WIN32 #define UNITTEST_WIN32
#endif #endif
#if defined(unix) || defined(__unix__) || defined(__unix) || defined(linux) || \ #if defined(unix) || defined(__unix__) || defined(__unix) || defined(linux) || \
defined(__APPLE__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__) \ defined(__APPLE__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__)
|| defined (__HAIKU__) || defined(_AIX)
#define UNITTEST_POSIX #define UNITTEST_POSIX
#endif #endif
@ -72,13 +71,4 @@
#define UNIITEST_NS_QUAL_STD(x) ::std::x #define UNIITEST_NS_QUAL_STD(x) ::std::x
#endif #endif
// By default, UnitTest++ will attempt to define "short" macro names like CHECK and CHECK_EQUAL
// for "public" interface macros etc. Defining UNITTEST_DISABLE_SHORT_MACROS in your project
// will disable this behavior, leaving only the longer macros "namespaced" with the UNITTEST_
// prefix.
//
// "Internal" utility macros will only have the UNITTEST_IMPL_ prefix.
// #define UNITTEST_DISABLE_SHORT_MACROS
#endif #endif

20
UnitTest++/ExceptionMacros.h
View file

@ -4,17 +4,17 @@
#include "Config.h" #include "Config.h"
#ifndef UNITTEST_NO_EXCEPTIONS #ifndef UNITTEST_NO_EXCEPTIONS
#define UNITTEST_IMPL_TRY(x) try x #define UT_TRY(x) try x
#define UNITTEST_IMPL_THROW(x) throw x #define UT_THROW(x) throw x
#define UNITTEST_IMPL_RETHROW(ExceptionType) catch(ExceptionType&) { throw; } #define UT_RETHROW(ExceptionType) catch(ExceptionType&) { throw; }
#define UNITTEST_IMPL_CATCH(ExceptionType, ExceptionName, CatchBody) catch(ExceptionType& ExceptionName) CatchBody #define UT_CATCH(ExceptionType, ExceptionName, CatchBody) catch(ExceptionType& ExceptionName) CatchBody
#define UNITTEST_IMPL_CATCH_ALL(CatchBody) catch(...) CatchBody #define UT_CATCH_ALL(CatchBody) catch(...) CatchBody
#else #else
#define UNITTEST_IMPL_TRY(x) x #define UT_TRY(x) x
#define UNITTEST_IMPL_THROW(x) #define UT_THROW(x)
#define UNITTEST_IMPL_RETHROW(ExceptionType) #define UT_RETHROW(ExceptionType)
#define UNITTEST_IMPL_CATCH(ExceptionType, ExceptionName, CatchBody) #define UT_CATCH(ExceptionType, ExceptionName, CatchBody)
#define UNITTEST_IMPL_CATCH_ALL(CatchBody) #define UT_CATCH_ALL(CatchBody)
#endif #endif
#endif #endif

12
UnitTest++/ExecuteTest.h
View file

@ -31,23 +31,23 @@ namespace UnitTest {
{ {
#endif #endif
#ifndef UNITTEST_POSIX #ifndef UNITTEST_POSIX
UNITTEST_IMPL_TRY({ testObject.RunImpl(); }) UT_TRY({ testObject.RunImpl(); })
#else #else
UNITTEST_IMPL_TRY UT_TRY
({ ({
UNITTEST_THROW_SIGNALS_POSIX_ONLY UNITTEST_THROW_SIGNALS_POSIX_ONLY
testObject.RunImpl(); testObject.RunImpl();
}) })
#endif #endif
UNITTEST_IMPL_CATCH(RequiredCheckException, e, { (void)e; }) UT_CATCH(RequiredCheckException, e, { (void)e; })
UNITTEST_IMPL_CATCH(AssertException, e, { (void)e; }) UT_CATCH(AssertException, e, { (void)e; })
UNITTEST_IMPL_CATCH(std::exception, e, UT_CATCH(std::exception, e,
{ {
MemoryOutStream stream; MemoryOutStream stream;
stream << "Unhandled exception: " << e.what(); stream << "Unhandled exception: " << e.what();
CurrentTest::Results()->OnTestFailure(details, stream.GetText()); CurrentTest::Results()->OnTestFailure(details, stream.GetText());
}) })
UNITTEST_IMPL_CATCH_ALL UT_CATCH_ALL
({ ({
CurrentTest::Results()->OnTestFailure(details, "Unhandled exception: test crashed"); CurrentTest::Results()->OnTestFailure(details, "Unhandled exception: test crashed");
}) })

4
UnitTest++/Posix/SignalTranslator.cpp
View file

@ -28,12 +28,12 @@ namespace UnitTest {
sigaction( SIGFPE, &action, &m_old_SIGFPE_action ); sigaction( SIGFPE, &action, &m_old_SIGFPE_action );
sigaction( SIGTRAP, &action, &m_old_SIGTRAP_action ); sigaction( SIGTRAP, &action, &m_old_SIGTRAP_action );
sigaction( SIGBUS, &action, &m_old_SIGBUS_action ); sigaction( SIGBUS, &action, &m_old_SIGBUS_action );
sigaction( SIGILL, &action, &m_old_SIGILL_action ); sigaction( SIGILL, &action, &m_old_SIGBUS_action );
} }
SignalTranslator::~SignalTranslator() SignalTranslator::~SignalTranslator()
{ {
sigaction( SIGILL, &m_old_SIGILL_action, 0 ); sigaction( SIGILL, &m_old_SIGBUS_action, 0 );
sigaction( SIGBUS, &m_old_SIGBUS_action, 0 ); sigaction( SIGBUS, &m_old_SIGBUS_action, 0 );
sigaction( SIGTRAP, &m_old_SIGTRAP_action, 0 ); sigaction( SIGTRAP, &m_old_SIGTRAP_action, 0 );
sigaction( SIGFPE, &m_old_SIGFPE_action, 0 ); sigaction( SIGFPE, &m_old_SIGFPE_action, 0 );

3
UnitTest++/Posix/SignalTranslator.h
View file

@ -22,7 +22,8 @@ namespace UnitTest {
struct sigaction m_old_SIGTRAP_action; struct sigaction m_old_SIGTRAP_action;
struct sigaction m_old_SIGSEGV_action; struct sigaction m_old_SIGSEGV_action;
struct sigaction m_old_SIGBUS_action; struct sigaction m_old_SIGBUS_action;
struct sigaction m_old_SIGILL_action; struct sigaction m_old_SIGABRT_action;
struct sigaction m_old_SIGALRM_action;
}; };
#if !defined (__GNUC__) #if !defined (__GNUC__)

12
UnitTest++/RequireMacros.h
View file

@ -3,14 +3,10 @@
#include "RequiredCheckTestReporter.h" #include "RequiredCheckTestReporter.h"
#define UNITTEST_REQUIRE for(UnitTest::RequiredCheckTestReporter decoratedReporter(*UnitTest::CurrentTest::Results()); decoratedReporter.Next(); ) #ifdef REQUIRE
#error UnitTest++ redefines REQUIRE
#ifndef UNITTEST_DISABLE_SHORT_MACROS
#ifdef REQUIRE
#error REQUIRE already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_REQUIRE instead
#else
#define REQUIRE UNITTEST_REQUIRE
#endif
#endif #endif
#define REQUIRE for(UnitTest::RequiredCheckTestReporter decoratedReporter(*UnitTest::CurrentTest::Results()); decoratedReporter.Next(); )
#endif #endif

3
UnitTest++/RequiredCheckTestReporter.h
View file

@ -19,9 +19,6 @@ namespace UnitTest {
bool Next(); bool Next();
private: private:
RequiredCheckTestReporter(RequiredCheckTestReporter const&);
RequiredCheckTestReporter& operator =(RequiredCheckTestReporter const&);
TestResults& m_results; TestResults& m_results;
TestReporter* m_originalTestReporter; TestReporter* m_originalTestReporter;
ThrowingTestReporter m_throwingReporter; ThrowingTestReporter m_throwingReporter;

59
UnitTest++/TestMacros.h
View file

@ -15,7 +15,19 @@
#include "Posix/SignalTranslator.h" #include "Posix/SignalTranslator.h"
#endif #endif
#define UNITTEST_SUITE(Name) \ #ifdef TEST
#error UnitTest++ redefines TEST
#endif
#ifdef TEST_EX
#error UnitTest++ redefines TEST_EX
#endif
#ifdef TEST_FIXTURE_EX
#error UnitTest++ redefines TEST_FIXTURE_EX
#endif
#define SUITE(Name) \
namespace Suite ## Name { \ namespace Suite ## Name { \
namespace UnitTestSuite { \ namespace UnitTestSuite { \
inline char const* GetSuiteName () { \ inline char const* GetSuiteName () { \
@ -25,36 +37,34 @@
} \ } \
namespace Suite ## Name namespace Suite ## Name
#define UNITTEST_IMPL_TEST(Name, List) \ #define TEST_EX(Name, List) \
class Test ## Name : public UnitTest::Test \ class Test ## Name : public UnitTest::Test \
{ \ { \
public: \ public: \
Test ## Name() : Test(#Name, UnitTestSuite::GetSuiteName(), __FILE__, __LINE__) {} \ Test ## Name() : Test(#Name, UnitTestSuite::GetSuiteName(), __FILE__, __LINE__) {} \
private: \ private: \
virtual void RunImpl() const; \ virtual void RunImpl() const; \
} static test ## Name ## Instance; \ } test ## Name ## Instance; \
\ \
static UnitTest::ListAdder adder ## Name (List, &test ## Name ## Instance); \ UnitTest::ListAdder adder ## Name (List, &test ## Name ## Instance); \
\ \
void Test ## Name::RunImpl() const void Test ## Name::RunImpl() const
#define UNITTEST_TEST(Name) UNITTEST_IMPL_TEST(Name, UnitTest::Test::GetTestList()) #define TEST(Name) TEST_EX(Name, UnitTest::Test::GetTestList())
#define UNITTEST_IMPL_TEST_FIXTURE(Fixture, Name, List) \ #define TEST_FIXTURE_EX(Fixture, Name, List) \
class Fixture ## Name ## Helper : public Fixture \ class Fixture ## Name ## Helper : public Fixture \
{ \ { \
public: \ public: \
explicit Fixture ## Name ## Helper(UnitTest::TestDetails const& details) : m_details(details) {} \ explicit Fixture ## Name ## Helper(UnitTest::TestDetails const& details) : m_details(details) {} \
void RunImpl(); \ void RunImpl(); \
UnitTest::TestDetails const& m_details; \ UnitTest::TestDetails const& m_details; \
virtual ~Fixture ## Name ## Helper(); \
private: \ private: \
Fixture ## Name ## Helper(Fixture ## Name ## Helper const&); \ Fixture ## Name ## Helper(Fixture ## Name ## Helper const&); \
Fixture ## Name ## Helper& operator =(Fixture ## Name ## Helper const&); \ Fixture ## Name ## Helper& operator =(Fixture ## Name ## Helper const&); \
}; \ }; \
Fixture ## Name ## Helper::~Fixture ## Name ## Helper(){} \
\ \
class Test ## Fixture ## Name : public UnitTest::Test \ class Test ## Fixture ## Name : public UnitTest::Test \
{ \ { \
@ -62,30 +72,30 @@
Test ## Fixture ## Name() : Test(#Name, UnitTestSuite::GetSuiteName(), __FILE__, __LINE__) {} \ Test ## Fixture ## Name() : Test(#Name, UnitTestSuite::GetSuiteName(), __FILE__, __LINE__) {} \
private: \ private: \
virtual void RunImpl() const; \ virtual void RunImpl() const; \
} static test ## Fixture ## Name ## Instance; \ } test ## Fixture ## Name ## Instance; \
\ \
static UnitTest::ListAdder adder ## Fixture ## Name (List, &test ## Fixture ## Name ## Instance); \ UnitTest::ListAdder adder ## Fixture ## Name (List, &test ## Fixture ## Name ## Instance); \
\ \
void Test ## Fixture ## Name::RunImpl() const \ void Test ## Fixture ## Name::RunImpl() const \
{ \ { \
volatile bool ctorOk = false; \ volatile bool ctorOk = false; \
UNITTEST_IMPL_TRY \ UT_TRY \
({ \ ({ \
Fixture ## Name ## Helper fixtureHelper(m_details); \ Fixture ## Name ## Helper fixtureHelper(m_details); \
ctorOk = true; \ ctorOk = true; \
UnitTest::ExecuteTest(fixtureHelper, m_details, false); \ UnitTest::ExecuteTest(fixtureHelper, m_details, false); \
}) \ }) \
UNITTEST_IMPL_CATCH (UnitTest::AssertException, e, \ UT_CATCH (UnitTest::AssertException, e, \
{ \ { \
(void)e; \ (void)e; \
}) \ }) \
UNITTEST_IMPL_CATCH (std::exception, e, \ UT_CATCH (std::exception, e, \
{ \ { \
UnitTest::MemoryOutStream stream; \ UnitTest::MemoryOutStream stream; \
stream << "Unhandled exception: " << e.what(); \ stream << "Unhandled exception: " << e.what(); \
UnitTest::CurrentTest::Results()->OnTestFailure(m_details, stream.GetText()); \ UnitTest::CurrentTest::Results()->OnTestFailure(m_details, stream.GetText()); \
}) \ }) \
UNITTEST_IMPL_CATCH_ALL \ UT_CATCH_ALL \
({ \ ({ \
if (ctorOk) \ if (ctorOk) \
{ \ { \
@ -101,26 +111,7 @@
} \ } \
void Fixture ## Name ## Helper::RunImpl() void Fixture ## Name ## Helper::RunImpl()
#define UNITTEST_TEST_FIXTURE(Fixture,Name) UNITTEST_IMPL_TEST_FIXTURE(Fixture, Name, UnitTest::Test::GetTestList()) #define TEST_FIXTURE(Fixture,Name) TEST_FIXTURE_EX(Fixture, Name, UnitTest::Test::GetTestList())
#ifndef UNITTEST_DISABLE_SHORT_MACROS
#ifdef SUITE
#error SUITE already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_SUITE instead
#else
#define SUITE UNITTEST_SUITE
#endif
#ifdef TEST
#error TEST already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_TEST instead
#else
#define TEST UNITTEST_TEST
#endif
#ifdef TEST_FIXTURE
#error TEST_FIXTURE already defined, re-configure with UNITTEST_ENABLE_SHORT_MACROS set to 0 and use UNITTEST_TEST_FIXTURE instead
#else
#define TEST_FIXTURE UNITTEST_TEST_FIXTURE
#endif
#endif
#endif #endif

2
appveyor.yml
View file

@ -1,4 +1,4 @@
version: 2.1.0.{build} version: 1.6.1.{build}
os: os:
- Windows Server 2012 R2 - Windows Server 2012 R2

9
autogen.sh
View file

@ -1,9 +0,0 @@
#!/bin/sh
test -e ./.autotools_aux || mkdir .autotools_aux
libtoolize -cq
aclocal -I m4 --install # Generate aclocal
autoconf # Generate configure script
autoheader # Generate config.h
automake --add-missing --copy # Generate Makefile.in and other scripts

2
configure.ac
View file

@ -23,7 +23,7 @@ AM_CONDITIONAL([WINDOWS],
LT_INIT() LT_INIT()
AC_SUBST([LIBUNITTEST_SO_VERSION], [2:1:0]) AC_SUBST([LIBUNITTEST_SO_VERSION], [1:6:0])
# Checks for programs. # Checks for programs.
AC_PROG_CXX AC_PROG_CXX

2
docs

@ -1 +1 @@
Subproject commit a6963b798400df760e148a6e15e9c13db965a3ec Subproject commit 14495a3a81568e9ce187231b629e4eb7bc7e0350

28
tests/TestChecks.cpp
View file

@ -315,32 +315,4 @@ namespace {
CHECK_EQUAL(1234, reporter.lastFailedLine); CHECK_EQUAL(1234, reporter.lastFailedLine);
} }
class TruthyUnlessCopied
{
public:
TruthyUnlessCopied()
: truthy_(true)
{
}
TruthyUnlessCopied(const TruthyUnlessCopied&)
: truthy_(false)
{
}
operator bool() const
{
return truthy_;
}
private:
bool truthy_;
};
TEST(CheckProperlyDealsWithOperatorBoolOverrides)
{
TruthyUnlessCopied objectThatShouldBeTruthy;
CHECK(objectThatShouldBeTruthy);
}
} }

8
tests/TestExceptions.cpp
View file

@ -253,7 +253,7 @@ namespace {
class ThrowingObject class ThrowingObject
{ {
public: public:
float operator[](size_t) const float operator[](int) const
{ {
throw "Test throw"; throw "Test throw";
} }
@ -262,7 +262,7 @@ namespace {
class StdThrowingObject class StdThrowingObject
{ {
public: public:
float operator[](size_t) const float operator[](int) const
{ {
throw std::runtime_error("Test throw"); throw std::runtime_error("Test throw");
} }
@ -451,7 +451,7 @@ namespace {
class ThrowingObject2D class ThrowingObject2D
{ {
public: public:
float* operator[](size_t) const float* operator[](int) const
{ {
throw "Test throw"; throw "Test throw";
} }
@ -460,7 +460,7 @@ namespace {
class StdThrowingObject2D class StdThrowingObject2D
{ {
public: public:
float* operator[](size_t) const float* operator[](int) const
{ {
throw std::runtime_error("Test throw"); throw std::runtime_error("Test throw");
} }

45
tests/TestLongMacros.cpp
View file

@ -1,45 +0,0 @@
#define UNITTEST_DISABLE_SHORT_MACROS
#include "UnitTest++/UnitTestPP.h"
// This file is not intended to test every little thing, just a few basics to hopefully ensure
// the macros are working and the short macros are not defined.
UNITTEST_SUITE(LongMacros)
{
UNITTEST_TEST(LongCheckMacroWorks)
{
UNITTEST_CHECK(true);
}
class Fixture
{
public:
Fixture() : sanity_(true) {}
protected:
bool sanity_;
};
UNITTEST_TEST_FIXTURE(Fixture, LongFixtureMacroWorks)
{
UNITTEST_REQUIRE UNITTEST_CHECK(sanity_);
}
UNITTEST_TEST(ShortMacrosAreNotDefined)
{
#if defined(CHECK) || \
defined(CHECK_EQUAL) || \
defined(CHECK_CLOSE) || \
defined(CHECK_ARRAY_EQUAL) || \
defined(CHECK_ARRAY_CLOSE) || \
defined(CHECK_ARRAY2D_CLOSE) || \
defined(CHECK_THROW) || \
defined(CHECK_ASSERT) || \
defined(SUITE) || \
defined(TEST) || \
defined(TEST_FIXTURE) || \
defined(REQUIRE)
UNITTEST_CHECK(false);
#endif
}
}

6
tests/TestMemoryOutStream.cpp
View file

@ -11,7 +11,7 @@ using namespace std;
namespace { namespace {
const char* maxSignedIntegralStr(size_t nBytes) const char* const maxSignedIntegralStr(size_t nBytes)
{ {
switch(nBytes) switch(nBytes)
{ {
@ -28,7 +28,7 @@ namespace {
} }
} }
const char* minSignedIntegralStr(size_t nBytes) const char* const minSignedIntegralStr(size_t nBytes)
{ {
switch(nBytes) switch(nBytes)
{ {
@ -45,7 +45,7 @@ namespace {
} }
} }
const char* maxUnsignedIntegralStr(size_t nBytes) const char* const maxUnsignedIntegralStr(size_t nBytes)
{ {
switch(nBytes) switch(nBytes)
{ {

2
tests/TestTest.cpp
View file

@ -72,7 +72,7 @@ namespace {
CHECK_EQUAL(1, results.GetFailureCount()); CHECK_EQUAL(1, results.GetFailureCount());
} }
#if !defined(UNITTEST_MINGW) && !defined(UNITTEST_WIN32) && !defined(__clang__) #if !defined(UNITTEST_MINGW) && !defined(UNITTEST_WIN32)
// Skip this test in debug because some debuggers don't like it. // Skip this test in debug because some debuggers don't like it.
#if defined(NDEBUG) #if defined(NDEBUG)
TEST(CrashingTestsAreReportedAsFailures) TEST(CrashingTestsAreReportedAsFailures)

14
tests/TestTestMacros.cpp
View file

@ -46,7 +46,7 @@ using namespace std;
namespace { namespace {
TestList list1; TestList list1;
UNITTEST_IMPL_TEST(DummyTest, list1) TEST_EX(DummyTest, list1)
{} {}
TEST (TestsAreAddedToTheListThroughMacro) TEST (TestsAreAddedToTheListThroughMacro)
@ -69,7 +69,7 @@ namespace {
}; };
TestList list2; TestList list2;
UNITTEST_IMPL_TEST_FIXTURE(ThrowingThingie, DummyTestName, list2) TEST_FIXTURE_EX(ThrowingThingie, DummyTestName, list2)
{} {}
TEST (ExceptionsInFixtureAreReportedAsHappeningInTheFixture) TEST (ExceptionsInFixtureAreReportedAsHappeningInTheFixture)
@ -113,7 +113,7 @@ namespace {
} }
TestList macroTestList1; TestList macroTestList1;
UNITTEST_IMPL_TEST(MacroTestHelper1, macroTestList1) TEST_EX(MacroTestHelper1, macroTestList1)
{} {}
TEST(TestAddedWithTEST_EXMacroGetsDefaultSuite) TEST(TestAddedWithTEST_EXMacroGetsDefaultSuite)
@ -124,7 +124,7 @@ namespace {
} }
TestList macroTestList2; TestList macroTestList2;
UNITTEST_IMPL_TEST_FIXTURE(DummyFixture, MacroTestHelper2, macroTestList2) TEST_FIXTURE_EX(DummyFixture, MacroTestHelper2, macroTestList2)
{} {}
TEST(TestAddedWithTEST_FIXTURE_EXMacroGetsDefaultSuite) TEST(TestAddedWithTEST_FIXTURE_EXMacroGetsDefaultSuite)
@ -144,7 +144,7 @@ namespace {
}; };
TestList throwingFixtureTestList1; TestList throwingFixtureTestList1;
UNITTEST_IMPL_TEST_FIXTURE(FixtureCtorThrows, FixtureCtorThrowsTestName, throwingFixtureTestList1) TEST_FIXTURE_EX(FixtureCtorThrows, FixtureCtorThrowsTestName, throwingFixtureTestList1)
{} {}
TEST(FixturesWithThrowingCtorsAreFailures) TEST(FixturesWithThrowingCtorsAreFailures)
@ -170,7 +170,7 @@ namespace {
}; };
TestList throwingFixtureTestList2; TestList throwingFixtureTestList2;
UNITTEST_IMPL_TEST_FIXTURE(FixtureDtorThrows, FixtureDtorThrowsTestName, throwingFixtureTestList2) TEST_FIXTURE_EX(FixtureDtorThrows, FixtureDtorThrowsTestName, throwingFixtureTestList2)
{} {}
TEST(FixturesWithThrowingDtorsAreFailures) TEST(FixturesWithThrowingDtorsAreFailures)
@ -200,7 +200,7 @@ namespace {
}; };
TestList ctorAssertFixtureTestList; TestList ctorAssertFixtureTestList;
UNITTEST_IMPL_TEST_FIXTURE(FixtureCtorAsserts, CorrectlyReportsAssertFailureInCtor, ctorAssertFixtureTestList) TEST_FIXTURE_EX(FixtureCtorAsserts, CorrectlyReportsAssertFailureInCtor, ctorAssertFixtureTestList)
{} {}
TEST(CorrectlyReportsFixturesWithCtorsThatAssert) TEST(CorrectlyReportsFixturesWithCtorsThatAssert)