Extend hiatus to 26 November

See #180

CMakeLists.txt

@@ -1,10 +1,26 @@
-cmake_minimum_required(VERSION 2.8.1)
-project(UnitTest++)
+cmake_minimum_required(VERSION 3.0)
+project(UnitTest++ VERSION 2.1.0)
 
-option(UTPP_USE_PLUS_SIGN "Set this to OFF if you wish to use '-cpp' instead of '++' in lib/include paths" ON)
+option(UTPP_USE_PLUS_SIGN
+    "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)
 
-if(MSVC14 OR MSVC12)
-    # has the support we need
+set(LIB_SUFFIX "" CACHE STRING "Identifier to add to end of lib directory name e.g. 64 for lib64")
+
+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()
     include(CheckCXXCompilerFlag)
     CHECK_CXX_COMPILER_FLAG("-std=c++14" COMPILER_SUPPORTS_CXX14)
@@ -14,7 +30,18 @@ else()
     elseif(COMPILER_SUPPORTS_CXX11)
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
     else()
-            message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
+        message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support.")
+    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()
 
@@ -37,6 +64,8 @@ source_group(${platformDir_} FILES ${platformHeaders_} ${platformSources_})
 
 # create the lib
 add_library(UnitTest++ STATIC ${headers_} ${sources_} ${platformHeaders_} ${platformSources_})
+add_library(UnitTest++::UnitTest++ ALIAS UnitTest++)
+
 
 if(${UTPP_USE_PLUS_SIGN})
 	set_target_properties(UnitTest++ PROPERTIES OUTPUT_NAME UnitTest++)
@@ -47,18 +76,25 @@ endif()
 file(GLOB TEST_SRCS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} tests/*.cpp tests/*.h)
 source_group( "" FILES ${TEST_SRCS})
 add_executable(TestUnitTest++ ${TEST_SRCS})
-include_directories(.)
+
 
 if(${UTPP_USE_PLUS_SIGN})
 	set_target_properties(TestUnitTest++ PROPERTIES OUTPUT_NAME TestUnitTest++)
 endif()
 
-target_link_libraries(TestUnitTest++ UnitTest++)
+target_link_libraries(TestUnitTest++ 
+	PUBLIC
+		UnitTest++::UnitTest++
+	)
 
 # run unit tests as post build step
 add_custom_command(TARGET TestUnitTest++
-	POST_BUILD COMMAND TestUnitTest++
-	COMMENT "Running unit tests")
+    POST_BUILD COMMAND TestUnitTest++
+    COMMENT "Running unit tests")
+
+if(NOT ${UTPP_INCLUDE_TESTS_IN_BUILD})
+    set_target_properties(TestUnitTest++ PROPERTIES EXCLUDE_FROM_ALL 1)
+endif()
 
 # add install targets
 # need a custom install path?
@@ -69,11 +105,41 @@ else()
 	set (UTPP_INSTALL_DESTINATION "include/UnitTestPP")
 endif()
 
-set(config_install_dir_ lib/cmake/${PROJECT_NAME})
-set(targets_export_name_ "${PROJECT_NAME}Targets")
+target_include_directories( UnitTest++
+	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")
 
-install(TARGETS UnitTest++ EXPORT "${targets_export_name_}" DESTINATION lib)
+set(config_install_dir_ lib${LIB_SUFFIX}/cmake/${PROJECT_NAME})
+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(FILES ${headers_} DESTINATION ${UTPP_INSTALL_DESTINATION})
 install(FILES ${platformHeaders_} DESTINATION ${UTPP_INSTALL_DESTINATION}/${platformDir_})
-install(FILES cmake/UnitTest++Config.cmake DESTINATION "${config_install_dir_}")
-install(EXPORT "${targets_export_name_}" DESTINATION "${config_install_dir_}")
+install(FILES 
+	cmake/UnitTest++Config.cmake 
+	${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}")

INSTALL

@@ -1,3 +1,9 @@
+
+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
 *************************
 

README.md

@@ -1,3 +1,6 @@
+>  ### 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://ci.appveyor.com/api/projects/status/ffs2k8dddts5cyok/branch/master?svg=true)](https://ci.appveyor.com/project/pjohnmeyer/unittest-cpp/branch/master)
 
@@ -30,17 +33,17 @@ Via svn:
 
     svn checkout https://github.com/unittest-cpp/unittest-cpp/trunk unittest-cpp
 
-### Latest release (v1.6.1) ###
+### Latest release (v2.0.0) ###
 
 Via git:
 
     git clone https://github.com/unittest-cpp/unittest-cpp
     cd unittest-cpp
-    git checkout v1.6.1
+    git checkout v2.0.0
 
 Via svn:
 
-    svn checkout https://github.com/unittest-cpp/unittest-cpp/tags/v1.6.1 unittest-cpp
+    svn checkout https://github.com/unittest-cpp/unittest-cpp/tags/v2.0.0 unittest-cpp
 
 License
 ---------
@@ -77,6 +80,12 @@ Contributors
 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) ###
 - 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+)

UnitTest++/CheckMacros.h

@@ -11,162 +11,175 @@
 #include "CurrentTest.h"
 #include "ReportAssertImpl.h"
 
-#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)                                                                                                                  \
+#define UNITTEST_CHECK(value)                                      \
    UNITTEST_MULTILINE_MACRO_BEGIN                                                                                                     \
-   UT_TRY                                                                                                                             \
+   UNITTEST_IMPL_TRY                                                                                                                             \
    ({                                                                                                                                 \
       if (!UnitTest::Check(value))                                                                                                    \
          UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__), #value); \
    })                                                                                                                                 \
-   UT_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UT_CATCH (std::exception, e,                                                                                                       \
+   UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
+   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                       \
    {                                                                                                                                  \
-      UnitTest::MemoryOutStream message;                                                                                              \
-      message << "Unhandled exception (" << e.what() << ") in CHECK(" #value ")";                                                     \
+      UnitTest::MemoryOutStream UnitTest_message;                                                                                     \
+      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK(" #value ")";                                            \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),             \
-                                                      message.GetText());                                                             \
+                                                      UnitTest_message.GetText());                                                    \
    })                                                                                                                                 \
-   UT_CATCH_ALL                                                                                                                       \
+   UNITTEST_IMPL_CATCH_ALL                                                                                                                       \
       ({                                                                                                                              \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),             \
                                                       "Unhandled exception in CHECK(" #value ")");                                    \
    })                                                                                                                                 \
    UNITTEST_MULTILINE_MACRO_END
 
-#define CHECK_EQUAL(expected, actual)                                                                                                                \
+#define UNITTEST_CHECK_EQUAL(expected, actual)                                                                                                                \
    UNITTEST_MULTILINE_MACRO_BEGIN                                                                                                                    \
-   UT_TRY                                                                                                                                            \
+   UNITTEST_IMPL_TRY                                                                                                                                            \
    ({                                                                                                                                                \
       UnitTest::CheckEqual(*UnitTest::CurrentTest::Results(), expected, actual, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                \
-   UT_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UT_CATCH (std::exception, e,                                                                                                                      \
+   UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
+   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                      \
    {                                                                                                                                                 \
-      UnitTest::MemoryOutStream message;                                                                                                             \
-      message << "Unhandled exception (" << e.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")";                                              \
+      UnitTest::MemoryOutStream UnitTest_message;                                                                                                    \
+      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_EQUAL(" #expected ", " #actual ")";                                     \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                            \
-                                                      message.GetText());                                                                            \
+                                                      UnitTest_message.GetText());                                                                   \
    })                                                                                                                                                \
-   UT_CATCH_ALL                                                                                                                                      \
+   UNITTEST_IMPL_CATCH_ALL                                                                                                                                      \
    ({                                                                                                                                                \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                            \
                                                       "Unhandled exception in CHECK_EQUAL(" #expected ", " #actual ")");                             \
    })                                                                                                                                                \
    UNITTEST_MULTILINE_MACRO_END
 
-#define CHECK_CLOSE(expected, actual, tolerance)                                                                                                                \
+#define UNITTEST_CHECK_CLOSE(expected, actual, tolerance)                                                                                                                \
    UNITTEST_MULTILINE_MACRO_BEGIN                                                                                                                               \
-   UT_TRY                                                                                                                                                       \
+   UNITTEST_IMPL_TRY                                                                                                                                                       \
    ({                                                                                                                                                           \
       UnitTest::CheckClose(*UnitTest::CurrentTest::Results(), expected, actual, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                           \
-   UT_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UT_CATCH (std::exception, e,                                                                                                                                 \
+   UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
+   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                                 \
    {                                                                                                                                                            \
-      UnitTest::MemoryOutStream message;                                                                                                                        \
-      message << "Unhandled exception (" << e.what() << ") in CHECK_CLOSE(" #expected ", " #actual ")";                                                         \
+      UnitTest::MemoryOutStream UnitTest_message;                                                                                                               \
+      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_CLOSE(" #expected ", " #actual ")";                                                \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                       \
-                                                      message.GetText());                                                                                       \
+                                                      UnitTest_message.GetText());                                                                              \
    })                                                                                                                                                           \
-   UT_CATCH_ALL                                                                                                                                                 \
+   UNITTEST_IMPL_CATCH_ALL                                                                                                                                                 \
    ({                                                                                                                                                           \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                       \
                                                       "Unhandled exception in CHECK_CLOSE(" #expected ", " #actual ")");                                        \
    })                                                                                                                                                           \
    UNITTEST_MULTILINE_MACRO_END
 
-#define CHECK_ARRAY_EQUAL(expected, actual, count)                                                                                                               \
+#define UNITTEST_CHECK_ARRAY_EQUAL(expected, actual, count)                                                                                                               \
    UNITTEST_MULTILINE_MACRO_BEGIN                                                                                                                                \
-   UT_TRY                                                                                                                                                        \
+   UNITTEST_IMPL_TRY                                                                                                                                                        \
       ({                                                                                                                                                         \
       UnitTest::CheckArrayEqual(*UnitTest::CurrentTest::Results(), expected, actual, count, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                            \
-   UT_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UT_CATCH (std::exception, e,                                                                                                                                  \
+   UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
+   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                                  \
    {                                                                                                                                                             \
-      UnitTest::MemoryOutStream message;                                                                                                                         \
-      message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY_EQUAL(" #expected ", " #actual ")";                                                    \
+      UnitTest::MemoryOutStream UnitTest_message;                                                                                                                \
+      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY_EQUAL(" #expected ", " #actual ")";                                           \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                        \
-                                                      message.GetText());                                                                                        \
+                                                      UnitTest_message.GetText());                                                                               \
    })                                                                                                                                                            \
-   UT_CATCH_ALL                                                                                                                                                  \
+   UNITTEST_IMPL_CATCH_ALL                                                                                                                                                  \
       ({                                                                                                                                                         \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                        \
                                                       "Unhandled exception in CHECK_ARRAY_EQUAL(" #expected ", " #actual ")");                                   \
    })                                                                                                                                                            \
    UNITTEST_MULTILINE_MACRO_END
 
-#define CHECK_ARRAY_CLOSE(expected, actual, count, tolerance)                                                                                                               \
+#define UNITTEST_CHECK_ARRAY_CLOSE(expected, actual, count, tolerance)                                                                                                               \
    UNITTEST_MULTILINE_MACRO_BEGIN                                                                                                                                           \
-   UT_TRY                                                                                                                                                                   \
+   UNITTEST_IMPL_TRY                                                                                                                                                                   \
       ({                                                                                                                                                                    \
       UnitTest::CheckArrayClose(*UnitTest::CurrentTest::Results(), expected, actual, count, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                                       \
-   UT_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UT_CATCH (std::exception, e,                                                                                                                                             \
+   UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
+   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                                             \
    {                                                                                                                                                                        \
-      UnitTest::MemoryOutStream message;                                                                                                                                    \
-      message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY_CLOSE(" #expected ", " #actual ")";                                                               \
+      UnitTest::MemoryOutStream UnitTest_message;                                                                                                                           \
+      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY_CLOSE(" #expected ", " #actual ")";                                                      \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                                   \
-                                                      message.GetText());                                                                                                   \
+                                                      UnitTest_message.GetText());                                                                                          \
    })                                                                                                                                                                       \
-   UT_CATCH_ALL                                                                                                                                                             \
+   UNITTEST_IMPL_CATCH_ALL                                                                                                                                                             \
       ({                                                                                                                                                                    \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                                   \
                                                       "Unhandled exception in CHECK_ARRAY_CLOSE(" #expected ", " #actual ")");                                              \
    })                                                                                                                                                                       \
    UNITTEST_MULTILINE_MACRO_END
 
-#define CHECK_ARRAY2D_CLOSE(expected, actual, rows, columns, tolerance)                                                                                                               \
+#define UNITTEST_CHECK_ARRAY2D_CLOSE(expected, actual, rows, columns, tolerance)                                                                                                               \
    UNITTEST_MULTILINE_MACRO_BEGIN                                                                                                                                                     \
-   UT_TRY                                                                                                                                                                             \
+   UNITTEST_IMPL_TRY                                                                                                                                                                             \
       ({                                                                                                                                                                              \
       UnitTest::CheckArray2DClose(*UnitTest::CurrentTest::Results(), expected, actual, rows, columns, tolerance, UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__)); \
    })                                                                                                                                                                                 \
-   UT_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
-   UT_CATCH (std::exception, e,                                                                                                                                                       \
+   UNITTEST_IMPL_RETHROW (UnitTest::RequiredCheckException)                                                                                                               \
+   UNITTEST_IMPL_CATCH (std::exception, e,                                                                                                                                                       \
    {                                                                                                                                                                                  \
-      UnitTest::MemoryOutStream message;                                                                                                                                              \
-      message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY2D_CLOSE(" #expected ", " #actual ")";                                                                       \
+      UnitTest::MemoryOutStream UnitTest_message;                                                                                                                                     \
+      UnitTest_message << "Unhandled exception (" << e.what() << ") in CHECK_ARRAY2D_CLOSE(" #expected ", " #actual ")";                                                              \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                                             \
-                                                      message.GetText());                                                                                                             \
+                                                      UnitTest_message.GetText());                                                                                                    \
    })                                                                                                                                                                                 \
-   UT_CATCH_ALL                                                                                                                                                                       \
+   UNITTEST_IMPL_CATCH_ALL                                                                                                                                                                       \
       ({                                                                                                                                                                              \
       UnitTest::CurrentTest::Results()->OnTestFailure(UnitTest::TestDetails(*UnitTest::CurrentTest::Details(), __LINE__),                                                             \
                                                       "Unhandled exception in CHECK_ARRAY2D_CLOSE(" #expected ", " #actual ")");                                                      \
    })                                                                                                                                                                                 \
    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)
 #ifndef UNITTEST_NO_EXCEPTIONS
 
-#define CHECK_THROW(expression, ExpectedExceptionType)                                                                                                                                      \
+#define UNITTEST_CHECK_THROW(expression, ExpectedExceptionType)                                                                                                                                      \
    UNITTEST_MULTILINE_MACRO_BEGIN                                                                                                                                                           \
    bool caught_ = false;                                                                                                                                                                    \
    try { expression; }                                                                                                                                                                      \
@@ -177,7 +190,7 @@
    UNITTEST_MULTILINE_MACRO_END
 
 
-#define CHECK_ASSERT(expression)                       \
+#define UNITTEST_CHECK_ASSERT(expression)                       \
    UNITTEST_MULTILINE_MACRO_BEGIN                      \
    UnitTest::Detail::ExpectAssert(true);               \
    CHECK_THROW(expression, UnitTest::AssertException); \
@@ -185,4 +198,19 @@
    UNITTEST_MULTILINE_MACRO_END
 #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
+

UnitTest++/Checks.h

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

UnitTest++/Config.h

@@ -16,12 +16,13 @@
    #ifdef _USRDLL
       #define UNITTEST_WIN32_DLL
    #endif
- 
+
    #define UNITTEST_WIN32
 #endif
 
 #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
 #endif
 
@@ -71,4 +72,13 @@
    #define UNIITEST_NS_QUAL_STD(x) ::std::x
 #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

UnitTest++/ExceptionMacros.h

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

UnitTest++/ExecuteTest.h

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

UnitTest++/Posix/SignalTranslator.cpp

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

UnitTest++/Posix/SignalTranslator.h

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

UnitTest++/RequireMacros.h

@@ -3,10 +3,14 @@
 
 #include "RequiredCheckTestReporter.h"
 
-#ifdef REQUIRE
-    #error UnitTest++ redefines REQUIRE
+#define UNITTEST_REQUIRE for(UnitTest::RequiredCheckTestReporter decoratedReporter(*UnitTest::CurrentTest::Results()); decoratedReporter.Next(); )
+
+#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
 
-#define REQUIRE for(UnitTest::RequiredCheckTestReporter decoratedReporter(*UnitTest::CurrentTest::Results()); decoratedReporter.Next(); )
-
 #endif

UnitTest++/RequiredCheckTestReporter.h

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

UnitTest++/TestMacros.h

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

appveyor.yml

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

autogen.sh

@@ -0,0 +1,9 @@
+#!/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 

configure.ac

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

docs

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

tests/TestChecks.cpp

@@ -315,4 +315,32 @@ namespace {
       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);
+   }
+
 }

tests/TestExceptions.cpp

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

tests/TestLongMacros.cpp

@@ -0,0 +1,45 @@
+#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
+   }
+}

tests/TestMemoryOutStream.cpp

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

tests/TestTest.cpp

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

tests/TestTestMacros.cpp

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