create nanomsg sockets in /var/lib by default

This was causing crashes with eglibc which visits the loaded vdso with
an empty dlpi_name.

.bumpversion.cfg

@@ -1,8 +1,27 @@
 [bumpversion]
-current_version = 2.2.0
+current_version = 2.3.0-rc1
 commit = False
+parse = ^
+	(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)   # minimum 'N.N.N'
+	(?:
+	-(?P<prerel>\w+) # 'rc' = release candidate, 'dev' = dev branch
+	(?:
+	(?P<prerelversion>\d+)
+	)?
+	)?
+serialize = 
+	{major}.{minor}.{patch}-{prerel}{prerelversion}
+	{major}.{minor}.{patch}-{prerel}
+	{major}.{minor}.{patch}
 
-[bumpversion:file:CMakeLists.txt]
+[bumpversion:part:prerel]
+optional_value = release
+values = 
+	dev
+	rc
+	release
+
+[bumpversion:file:.cmake/Modules/Properties.cmake]
 
 [bumpversion:file:doc/conf.py]
 

.cmake/Modules/Capabilities.cmake

@@ -1,12 +1,70 @@
-# Copyright (C) 2015 Franklin "Snaipe" Mathieu.
+# Copyright (C) 2015-2016 Franklin "Snaipe" Mathieu.
 # Redistribution and use of this file is allowed according to the terms of the MIT license.
 # For details see the LICENSE file distributed with Criterion.
 
 include(CheckPrototypeDefinition)
+include(CheckLibraryExists)
+include(CheckFunctionExists)
+include(CheckSymbolExists)
+include(PackageUtils)
 
-check_prototype_definition(
-  strtok_s
-  "char *strtok_s(char *strToken, const char *strDelimit, char **context)"
-  NULL
-  "string.h"
-  HAVE_STRTOK_S)
+# Check for packages
+
+cr_find_package (Gettext)
+cr_find_package (Libintl)
+
+if (I18N AND GETTEXT_FOUND AND LIBINTL_LIB_FOUND)
+  set (GettextTranslate_ALL 1)
+  set (GettextTranslate_GMO_BINARY 1)
+  set (ENABLE_NLS 1)
+endif ()
+
+# Check for functions
+
+check_function_exists(strtok_s HAVE_STRTOK_S)
+check_function_exists(strtok_r HAVE_STRTOK_R)
+
+check_library_exists (anl getaddrinfo_a "" HAVE_GETADDRINFO_A)
+
+check_function_exists(funopen HAVE_FUNOPEN)
+check_function_exists(fopencookie HAVE_FOPENCOOKIE)
+check_function_exists(open_memstream HAVE_OPEN_MEMSTREAM)
+
+check_library_exists(rt clock_gettime "time.h" HAVE_CLOCK_GETTIME_RT)
+if (HAVE_CLOCK_GETTIME_RT AND NOT HAVE_LIBRT)
+  set (HAVE_LIBRT 1)
+endif ()
+
+if (NOT HAVE_CLOCK_GETTIME_RT)
+  check_symbol_exists(clock_gettime "time.h" HAVE_CLOCK_GETTIME)
+else ()
+  set (HAVE_CLOCK_GETTIME "${HAVE_CLOCK_GETTIME_RT}" CACHE INTERNAL "Have symbol clock_gettime")
+endif ()
+
+check_symbol_exists(CLOCK_MONOTONIC_RAW "time.h" HAVE_CLOCK_MONOTONIC_RAW)
+
+# Check for C++11
+
+if (LANG_CXX)
+  enable_language(CXX)
+endif ()
+
+if (NOT MSVC AND CMAKE_CXX_COMPILER_WORKS)
+  include(CheckCXXCompilerFlag)
+  CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
+  CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
+
+  if(COMPILER_SUPPORTS_CXX11)
+    set(CXX11_FLAG "-std=c++11")
+  elseif(COMPILER_SUPPORTS_CXX0X)
+    set(CXX11_FLAG "-std=c++0x")
+  else()
+    message(FATAL_ERROR "Compiler ${CMAKE_CXX_COMPILER} has no C++11 support.")
+  endif()
+endif()
+
+# Valgrind support
+
+if (DEV_BUILD)
+  set(ENABLE_VALGRIND_ERRORS 1)
+endif ()

.cmake/Modules/CoverallsGenerateGcov.cmake

@@ -110,7 +110,7 @@ if (GIT_FOUND)
 	# Branch.
 	execute_process(
 		COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD
-		WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+		WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
 		OUTPUT_VARIABLE GIT_BRANCH
 		OUTPUT_STRIP_TRAILING_WHITESPACE
 	)
@@ -118,7 +118,7 @@ if (GIT_FOUND)
 	macro (git_log_format FORMAT_CHARS VAR_NAME)
 		execute_process(
 			COMMAND ${GIT_EXECUTABLE} log -1 --pretty=format:%${FORMAT_CHARS}
-			WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+			WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
 			OUTPUT_VARIABLE ${VAR_NAME}
 			OUTPUT_STRIP_TRAILING_WHITESPACE
 		)

.cmake/Modules/Cram.cmake

@@ -0,0 +1,63 @@
+# Copyright (C) 2015-2016 Franklin "Snaipe" Mathieu.
+# Redistribution and use of this file is allowed according to the terms of the MIT license.
+# For details see the LICENSE file distributed with Criterion.
+
+set(PATH_VAR
+  "${PROJECT_BINARY_DIR}/samples"
+  "${PROJECT_BINARY_DIR}/samples/tests"
+  "${PROJECT_BINARY_DIR}/external/lib"
+  "${PROJECT_BINARY_DIR}/external/bin"
+)
+
+set(NEW_PATH "")
+foreach (P ${PATH_VAR})
+  file (TO_NATIVE_PATH "${P}" P)
+  list (APPEND NEW_PATH "${P}")
+endforeach ()
+set (PATH_VAR "${NEW_PATH}")
+
+if (NOT WIN32)
+  string (REPLACE ";" ":" PATH_VAR "${PATH_VAR}")
+  set(ENV{PATH} "$ENV{PATH}:${PATH_VAR}")
+else ()
+  set(ENV{PATH} "$ENV{PATH};${PATH_VAR}")
+endif ()
+
+set(ENV{LC_ALL} "en_US.utf8")
+set(ENV{CRITERION_ALWAYS_SUCCEED} "1")
+set(ENV{CRITERION_SHORT_FILENAME} "1")
+set(ENV{CRITERION_JOBS} "1")
+set(ENV{CRITERION_DISABLE_TIME_MEASUREMENTS} "1")
+set(ENV{MSYS2_ARG_CONV_EXCL} "--filter=")
+
+if (WIN32)
+  if (ENV{MINGW} STREQUAL "")
+    set (MINGW_HOME "C:/MinGW")
+  else ()
+    file (TO_CMAKE_PATH "$ENV{MINGW}" MINGW_HOME)
+  endif ()
+  if (ENV{CRAM_SHELL} STREQUAL "" AND MINGW_HOME)
+    set (CRAM_SHELL "${MINGW_HOME}/msys/1.0/bin/sh.exe")
+  else ()
+    file (TO_CMAKE_PATH "$ENV{CRAM_SHELL}" CRAM_SHELL)
+  endif ()
+  if (CRAM_SHELL)
+    set(CRAM_OPTS "--shell=${CRAM_SHELL}")
+  endif ()
+endif ()
+
+if ("$ENV{TRAVIS}" STREQUAL "true")
+  execute_process (COMMAND cram -v ${CRAM_OPTS} "${CRAM_PATH}" TIMEOUT 60 RESULT_VARIABLE RES)
+else ()
+  if ("$ENV{PYTHON_BIN}" STREQUAL "")
+    set (PYTHON "python")
+  else ()
+    set (PYTHON "$ENV{PYTHON_BIN}")
+  endif ()
+
+  execute_process (COMMAND ${PYTHON} -m cram -v ${CRAM_OPTS} "${CRAM_PATH}" TIMEOUT 60 RESULT_VARIABLE RES)
+endif ()
+
+if (NOT RES STREQUAL "0")
+  message (FATAL_ERROR "Cram tests failed")
+endif ()

.cmake/Modules/DebConfig.cmake

@@ -7,17 +7,14 @@ set(CPACK_DEBIAN_BUILD_DEPENDS
   debhelper
   cmake
   gettext
-  libpcre3-dev
 )
 
-set(CPACK_DEBIAN_PACKAGE_DEPENDS
-  libpcre3
-)
+set(CPACK_DEBIAN_PACKAGE_DEPENDS)
 
 set(CPACK_DEBIAN_CMAKE_OPTIONS)
-set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_SOURCE_DIR}/description.txt")
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${PROJECT_SOURCE_DIR}/description.txt")
 
-set(CPACK_DEBIAN_PACKAGE_SOURCE_COPY "${CMAKE_SOURCE_DIR}/.cmake/copy-source.sh")
+set(CPACK_DEBIAN_PACKAGE_SOURCE_COPY "${PROJECT_SOURCE_DIR}/.cmake/copy-source.sh")
 
 set(CPACK_DEBIAN_DISTRIBUTION_NAME ubuntu)
 set(CPACK_DEBIAN_DISTRIBUTION_RELEASES precise trusty vivid wily xenial)

.cmake/Modules/DebSourcePPA.cmake

@@ -59,14 +59,14 @@ foreach(LINE ${DESC_LINES})
   set(DEB_LONG_DESCRIPTION "${DEB_LONG_DESCRIPTION} ${LINE}\n")
 endforeach(LINE ${DESC_LINES})
 
-file(REMOVE_RECURSE "${CMAKE_BINARY_DIR}/Debian")
-file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}/Debian")
-set(DEBIAN_SOURCE_ORIG_DIR "${CMAKE_BINARY_DIR}/Debian/${CPACK_DEBIAN_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
+file(REMOVE_RECURSE "${PROJECT_BINARY_DIR}/Debian")
+file(MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/Debian")
+set(DEBIAN_SOURCE_ORIG_DIR "${PROJECT_BINARY_DIR}/Debian/${CPACK_DEBIAN_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
 
 if( CPACK_DEBIAN_PACKAGE_SOURCE_COPY )
-  execute_process(COMMAND ${CPACK_DEBIAN_PACKAGE_SOURCE_COPY} "${CMAKE_SOURCE_DIR}" "${DEBIAN_SOURCE_ORIG_DIR}.orig")
+  execute_process(COMMAND ${CPACK_DEBIAN_PACKAGE_SOURCE_COPY} "${PROJECT_SOURCE_DIR}" "${DEBIAN_SOURCE_ORIG_DIR}.orig")
 else()
-  execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR} "${DEBIAN_SOURCE_ORIG_DIR}.orig")
+  execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory ${PROJECT_SOURCE_DIR} "${DEBIAN_SOURCE_ORIG_DIR}.orig")
   execute_process(COMMAND ${CMAKE_COMMAND} -E remove_directory "${DEBIAN_SOURCE_ORIG_DIR}.orig/.git")
   execute_process(COMMAND ${CMAKE_COMMAND} -E remove_directory "${DEBIAN_SOURCE_ORIG_DIR}.orig/.svn")
 endif()
@@ -77,7 +77,7 @@ foreach(REMOVE_DIR ${CPACK_DEBIAN_PACKAGE_REMOVE_SOURCE_FILES})
 endforeach()
 
 # create the original source tar
-execute_process(COMMAND ${CMAKE_COMMAND} -E tar czf "${CPACK_DEBIAN_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION}.orig.tar.gz" "${CPACK_DEBIAN_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}.orig" WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Debian)
+execute_process(COMMAND ${CMAKE_COMMAND} -E tar czf "${CPACK_DEBIAN_PACKAGE_NAME}_${CPACK_PACKAGE_VERSION}.orig.tar.gz" "${CPACK_DEBIAN_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}.orig" WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/Debian)
 
 set(DEB_SOURCE_CHANGES)
 foreach(RELEASE ${CPACK_DEBIAN_DISTRIBUTION_RELEASES})
@@ -344,4 +344,4 @@ endforeach(RELEASE ${CPACK_DEBIAN_DISTRIBUTION_RELEASES})
 
 ##############################################################################
 # dput ppa:your-lp-id/ppa <source.changes>
-add_custom_target(dput ${DPUT_EXECUTABLE} ${DPUT_HOST} ${DEB_SOURCE_CHANGES} DEPENDS ${DEB_SOURCE_CHANGES} WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Debian)
+add_custom_target(dput ${DPUT_EXECUTABLE} ${DPUT_HOST} ${DEB_SOURCE_CHANGES} DEPENDS ${DEB_SOURCE_CHANGES} WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/Debian)

.cmake/Modules/DebUpload.cmake

@@ -0,0 +1,9 @@
+# Copyright (C) 2015-2016 Franklin "Snaipe" Mathieu.
+# Redistribution and use of this file is allowed according to the terms of the MIT license.
+# For details see the LICENSE file distributed with Criterion.
+
+# Add toolchain patch number for incremental deb builds
+set(PROJECT_VERSION "${PROJECT_VERSION}-2")
+
+include (PackageConfig)
+include (DebConfig)

.cmake/Modules/FindDyncall.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2015 Franklin "Snaipe" Mathieu.
+# Copyright (C) 2015-2016 Franklin "Snaipe" Mathieu.
 # Redistribution and use of this file is allowed according to the terms of the MIT license.
 # For details see the LICENSE file distributed with Criterion.
 

.cmake/Modules/FindLibcsptr.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2015 Franklin "Snaipe" Mathieu.
+# Copyright (C) 2015-2016 Franklin "Snaipe" Mathieu.
 # Redistribution and use of this file is allowed according to the terms of the MIT license.
 # For details see the LICENSE file distributed with Criterion.
 

.cmake/Modules/FindPCRE.cmake

@@ -1,37 +0,0 @@
-# Copyright (C) 2007-2009 LuaDist.
-# Created by Peter Kapec <kapecp@gmail.com>
-# Redistribution and use of this file is allowed according to the terms of the MIT license.
-# For details see the COPYRIGHT file distributed with LuaDist.
-#	Note:
-#		Searching headers and libraries is very simple and is NOT as powerful as scripts
-#		distributed with CMake, because LuaDist defines directories to search for.
-#		Everyone is encouraged to contact the author with improvements. Maybe this file
-#		becomes part of CMake distribution sometimes.
-
-# - Find pcre
-# Find the native PCRE headers and libraries.
-#
-# PCRE_INCLUDE_DIRS	- where to find pcre.h, etc.
-# PCRE_LIBRARIES	- List of libraries when using pcre.
-# PCRE_FOUND	- True if pcre found.
-
-# Look for the header file.
-FIND_PATH(PCRE_INCLUDE_DIR NAMES pcre.h)
-
-# Look for the library.
-FIND_LIBRARY(PCRE_LIBRARY NAMES pcre)
-
-# Handle the QUIETLY and REQUIRED arguments and set PCRE_FOUND to TRUE if all listed variables are TRUE.
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(PCRE DEFAULT_MSG PCRE_LIBRARY PCRE_INCLUDE_DIR)
-
-# Copy the results to the output variables.
-IF(PCRE_FOUND)
-	SET(PCRE_LIBRARIES ${PCRE_LIBRARY})
-	SET(PCRE_INCLUDE_DIRS ${PCRE_INCLUDE_DIR})
-ELSE(PCRE_FOUND)
-	SET(PCRE_LIBRARIES)
-	SET(PCRE_INCLUDE_DIRS)
-ENDIF(PCRE_FOUND)
-
-MARK_AS_ADVANCED(PCRE_INCLUDE_DIRS PCRE_LIBRARIES)

.cmake/Modules/GettextTranslate.cmake

@@ -263,7 +263,13 @@ macro(GettextTranslate)
             COMMAND ${GettextTranslate_MSGMERGE_EXECUTABLE} --lang=${lang}
               ${PO_FILE_NAME} ${TEMPLATE_FILE_ABS} 
               -o ${PO_FILE_NAME}.new
-            COMMAND mv ${PO_FILE_NAME}.new ${PO_FILE_NAME}
+            COMMAND if diff ${PO_FILE_NAME} ${PO_FILE_NAME}.new
+                            --unchanged-line-format='' --old-line-format=''
+                    | grep -v 'POT-Creation-Date' >/dev/null\; then
+                        mv ${PO_FILE_NAME}.new ${PO_FILE_NAME}\;
+                else
+                        rm ${PO_FILE_NAME}.new\;
+                fi
             DEPENDS ${TEMPLATE_FILE_ABS}
           )
       else ()
@@ -271,7 +277,13 @@ macro(GettextTranslate)
             COMMAND ${GettextTranslate_MSGMERGE_EXECUTABLE}
               ${PO_FILE_NAME} ${TEMPLATE_FILE_ABS} 
               -o ${PO_FILE_NAME}.new
-            COMMAND mv ${PO_FILE_NAME}.new ${PO_FILE_NAME}
+            COMMAND if diff ${PO_FILE_NAME} ${PO_FILE_NAME}.new
+                            --unchanged-line-format='' --old-line-format=''
+                    | grep -v 'POT-Creation-Date' >/dev/null\; then
+                        mv ${PO_FILE_NAME}.new ${PO_FILE_NAME}\;
+                else
+                        rm ${PO_FILE_NAME}.new\;
+                fi
             DEPENDS ${TEMPLATE_FILE_ABS}
           )
       endif ()

.cmake/Modules/Options.cmake

@@ -0,0 +1,13 @@
+# Copyright (C) 2015-2016 Franklin "Snaipe" Mathieu.
+# Redistribution and use of this file is allowed according to the terms of the MIT license.
+# For details see the LICENSE file distributed with Criterion.
+
+option(LANG_CXX "Turn on C++ support" ON)
+option(THEORIES "Activate the support for theories" ON)
+option(MINGW_DEFINE_OFF_T "Define off_t and off64_t ourselves before including io.h" OFF)
+option(COVERALLS "Turn on coveralls support" OFF)
+option(COVERALLS_UPLOAD "Upload the generated coveralls json" ON)
+option(DEV_BUILD "Compile in developer mode" OFF)
+option(CTESTS "Turn on the samples and test" ${DEV_BUILD})
+option(I18N "Turn on internationalization" ON)
+option(UPLOAD_DEB "Upload package to launchpad" OFF)

.cmake/Modules/PackageConfig.cmake

@@ -45,7 +45,7 @@ if (WIN32)
   endif ()
 endif ()
 
-set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/debian.copyright")
+set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/debian.copyright")
 extract_version(${PROJECT_VERSION}
     CPACK_PACKAGE_VERSION_MAJOR
     CPACK_PACKAGE_VERSION_MINOR
@@ -55,21 +55,21 @@ extract_version(${PROJECT_VERSION}
 
 set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
 
-file(GLOB TRASH_FILES "${CMAKE_SOURCE_DIR}/*")
+file(GLOB TRASH_FILES "${PROJECT_SOURCE_DIR}/*")
 set(KEEP_FILES
-  "${CMAKE_SOURCE_DIR}/.cmake"
-  "${CMAKE_SOURCE_DIR}/src"
-  "${CMAKE_SOURCE_DIR}/include"
-  "${CMAKE_SOURCE_DIR}/doc"
-  "${CMAKE_SOURCE_DIR}/dev"
-  "${CMAKE_SOURCE_DIR}/po"
-  "${CMAKE_SOURCE_DIR}/dependencies"
-  "${CMAKE_SOURCE_DIR}/CMakeLists.txt"
-  "${CMAKE_SOURCE_DIR}/README.md"
-  "${CMAKE_SOURCE_DIR}/CONTRIBUTING.md"
-  "${CMAKE_SOURCE_DIR}/LICENSE"
-  "${CMAKE_SOURCE_DIR}/ChangeLog"
-  "${CMAKE_SOURCE_DIR}/description.txt"
+  "${PROJECT_SOURCE_DIR}/.cmake"
+  "${PROJECT_SOURCE_DIR}/src"
+  "${PROJECT_SOURCE_DIR}/include"
+  "${PROJECT_SOURCE_DIR}/doc"
+  "${PROJECT_SOURCE_DIR}/dev"
+  "${PROJECT_SOURCE_DIR}/po"
+  "${PROJECT_SOURCE_DIR}/dependencies"
+  "${PROJECT_SOURCE_DIR}/CMakeLists.txt"
+  "${PROJECT_SOURCE_DIR}/README.md"
+  "${PROJECT_SOURCE_DIR}/CONTRIBUTING.md"
+  "${PROJECT_SOURCE_DIR}/LICENSE"
+  "${PROJECT_SOURCE_DIR}/ChangeLog"
+  "${PROJECT_SOURCE_DIR}/description.txt"
 )
 list(REMOVE_ITEM TRASH_FILES ${KEEP_FILES})
 # Escape any '.' characters

.cmake/Modules/PackageUtils.cmake

@@ -0,0 +1,97 @@
+# Copyright (C) 2015-2016 Franklin "Snaipe" Mathieu.
+# Redistribution and use of this file is allowed according to the terms of the MIT license.
+# For details see the LICENSE file distributed with Criterion.
+
+include(CMakeParseArguments)
+
+function (cr_link_package _TARGET _PKG)
+  if (${_PKG}_LIB_FOUND OR ${_PKG}_FOUND)
+    target_link_libraries(${_TARGET} ${${_PKG}_LIBRARIES})
+    include_directories(${${_PKG}_INCLUDE_DIRS})
+  endif ()
+endfunction ()
+
+function (cr_link_libraries _TARGET)
+  set (multiValueArgs IF)
+  cmake_parse_arguments (ARGS "" "" "${multiValueArgs}" ${ARGN})
+
+  if (ARGS_IF)
+    if (${ARGS_IF})
+    else ()
+      return ()
+    endif ()
+  endif ()
+
+  target_link_libraries(${_TARGET} ${ARGS_UNPARSED_ARGUMENTS})
+endfunction ()
+
+function (cr_add_library _LIB)
+  set (options SHARED STATIC)
+  set (oneValueArgs COMPONENT)
+  set (multiValueArgs SOURCES HEADERS PROPERTIES)
+  cmake_parse_arguments (ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  set (flags "")
+  if (ARGS_SHARED)
+    set (flags ${flags} SHARED)
+  elseif (ARGS_STATIC)
+    set (flags ${flags} STATIC)
+  endif ()
+
+  add_library(${_LIB} ${flags} ${ARGS_SOURCES} ${ARGS_HEADERS})
+  set_target_properties(${_LIB} PROPERTIES ${ARGS_PROPERTIES})
+
+  foreach (F ${INTERFACE_FILES})
+    get_filename_component(DEST "${F}" PATH)
+    if (ARGS_COMPONENT)
+      set (install_flags COMPONENT ${ARGS_COMPONENT})
+    endif ()
+    install(FILES "${F}" DESTINATION "${DEST}" ${install_flags})
+  endforeach ()
+
+  install(TARGETS ${_LIB}
+    RUNTIME DESTINATION bin
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib ${install_flags}
+  )
+endfunction ()
+
+find_package(PkgConfig)
+
+macro (cr_find_package _PKG)
+  set (options REQUIRED)
+  set (oneValueArgs PKGCONFIG)
+  cmake_parse_arguments (ARGS "${options}" "${oneValueArgs}" "" ${ARGN})
+
+  string (TOUPPER "${_PKG}" _PKG_UP)
+
+  find_package (${_PKG})
+  if (NOT ${_PKG_UP}_FOUND AND ${_PKG_UP}_LIB_FOUND)
+    set (${_PKG_UP}_FOUND ON)
+  endif ()
+
+  if (NOT ${_PKG_UP}_FOUND AND PKGCONFIG_FOUND)
+    message (STATUS "Checking for package ${_PKG} with pkg-config")
+    if (NOT ARGS_PKGCONFIG)
+      set (ARGS_PKGCONFIG ${_PKG})
+    endif ()
+    pkg_check_modules(${_PKG_UP}_PKG ${ARGS_PKGCONFIG})
+
+    if (${_PKG_UP}_PKG_FOUND)
+      if (${_PKG_UP}_PKG_LIBRARY_DIRS)
+        link_directories(${${_PKG_UP}_PKG_LIBRARY_DIRS})
+      endif ()
+      set (${_PKG_UP}_LIBRARIES ${${_PKG_UP}_PKG_LIBRARIES})
+      set (${_PKG_UP}_INCLUDE_DIRS ${${_PKG_UP}_PKG_INCLUDE_DIRS})
+      set (${_PKG_UP}_FOUND 1)
+    endif()
+  endif ()
+
+  if (NOT ${_PKG_UP}_FOUND AND ARGS_REQUIRED)
+    message (FATAL_ERROR "Could not find required package ${_PKG}")
+  endif ()
+
+  if (${_PKG_UP}_FOUND)
+    set (HAVE_${_PKG_UP} 1)
+  endif ()
+endmacro ()

.cmake/Modules/Properties.cmake

@@ -0,0 +1,41 @@
+# Copyright (C) 2015-2016 Franklin "Snaipe" Mathieu.
+# Redistribution and use of this file is allowed according to the terms of the MIT license.
+# For details see the LICENSE file distributed with Criterion.
+
+set (PROJECT_VERSION "2.3.0-rc1")
+set (PROJECT_SOVERSION 3)
+set (PROJECT_SONAME 3.1.0)
+
+set (LOCALEDIR_REL "share/locale")
+set (LOCALEDIR "${CMAKE_INSTALL_PREFIX}/${LOCALEDIR_REL}")
+string (TOLOWER "${PROJECT_NAME}" PROJECT_NAME_LOWER)
+
+add_definitions(
+  -DCRITERION_BUILDING_DLL=1
+  -DPB_ENABLE_MALLOC=1
+)
+
+set (CMAKE_C_FLAGS_DEFAULT "${CMAKE_C_FLAGS}")
+set (CMAKE_CXX_FLAGS_DEFAULT "${CMAKE_CXX_FLAGS}")
+
+if (MSVC)
+  set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO")
+  add_definitions (-D_CRT_SECURE_NO_WARNINGS=1)
+  add_definitions (-DVC_EXTRALEAN)
+  add_definitions (-DWIN32_LEAN_AND_MEAN)
+  add_definitions (-D_WIN32_WINNT=0x600)
+else ()
+  if (WIN32)
+    set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-no-undefined")
+  endif ()
+
+  set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -std=gnu99 -fvisibility=hidden")
+  if (CMAKE_CXX_COMPILER_WORKS)
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra ${CXX11_FLAG} -fvisibility=hidden")
+  endif ()
+endif ()
+
+include_directories(SYSTEM
+  /usr/local/include
+  /usr/include/GNUstep
+)

.cmake/Modules/Submodules.cmake

@@ -26,31 +26,4 @@ else()
     )
 endif()
 
-### Then, checkout each submodule to the specified commit
-# Note: Execute separate processes here, to make sure each one is run,
-# should one crash (because of branch not existing, this, that ... whatever)
-foreach(GIT_SUBMODULE ${GIT_SUBMODULES})
-
-    if( "${GIT_SUBMODULE_VERSION_${GIT_SUBMODULE}}" STREQUAL "" )
-        message(STATUS "no specific version given for submodule ${GIT_SUBMODULE}, checking out master")
-        set(GIT_SUBMODULE_VERSION_${GIT_SUBMODULE} "master")
-    endif()
-
-    if(${GIT_SUBMODULES_CHECKOUT_QUIET})
-        execute_process(
-            COMMAND             git checkout ${GIT_SUBMODULE_VERSION_${GIT_SUBMODULE}}
-            WORKING_DIRECTORY   ${PROJECT_SOURCE_DIR}/${GIT_SUBMODULES_DIRECTORY}/${GIT_SUBMODULE}
-            OUTPUT_QUIET
-            ERROR_QUIET
-        )
-    else()
-        message(STATUS "checking out ${GIT_SUBMODULE}'s commit/tag ${GIT_SUBMODULE_VERSION_${GIT_SUBMODULE}}")
-        execute_process(
-            COMMAND             git checkout -q ${GIT_SUBMODULE_VERSION_${GIT_SUBMODULE}}
-            WORKING_DIRECTORY   ${PROJECT_SOURCE_DIR}/${GIT_SUBMODULES_DIRECTORY}/${GIT_SUBMODULE}
-        )
-    endif()
-
-endforeach(${GIT_SUBMODULE})
-
 endif()

.cmake/Modules/Subprojects.cmake

@@ -0,0 +1,123 @@
+# Copyright (C) 2015-2016 Franklin "Snaipe" Mathieu.
+# Redistribution and use of this file is allowed according to the terms of the MIT license.
+# For details see the LICENSE file distributed with Criterion.
+
+include(ExternalProject)
+include(CMakeParseArguments)
+
+function (cr_add_subproject _NAME)
+  set (options CMAKE AUTOTOOLS)
+  set (oneValueArgs GIT PATH PREFIX GENERATOR)
+  set (multiValueArgs OPTS IF)
+  cmake_parse_arguments (ARGS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  if (ARGS_IF)
+    if (${ARGS_IF})
+      set (${_NAME}_SUBPROJECT_EXISTS 1 PARENT_SCOPE)
+    else ()
+      return ()
+    endif ()
+  else ()
+    set (${_NAME}_SUBPROJECT_EXISTS 1 PARENT_SCOPE)
+  endif ()
+
+  if (ARGS_PREFIX)
+    set (install_prefix ${CMAKE_BINARY_DIR}/external/${ARGS_PREFIX})
+  else ()
+    set (install_prefix ${CMAKE_BINARY_DIR}/external)
+  endif ()
+
+  if (ARGS_GIT)
+    string(REPLACE "#" ";" git_opts "${ARGS_GIT}")
+    list(LENGTH git_opts git_opts_len)
+    list(GET git_opts 0 repo)
+    set (epa_opts GIT_REPOSITORY "${repo}")
+    if (git_opts_len GREATER 1)
+      list(GET git_opts 1 object)
+      set (epa_opts ${epa_opts} GIT_TAG "${object}")
+    endif ()
+  elseif (ARGS_PATH)
+      set (epa_opts SOURCE_DIR "${CMAKE_SOURCE_DIR}/${ARGS_PATH}")
+  endif ()
+
+  if (ARGS_CMAKE)
+    if (NOT ARGS_GENERATOR)
+      set (ARGS_GENERATOR ${CMAKE_GENERATOR})
+    endif ()
+    if (CMAKE_TOOLCHAIN_FILE)
+      set (ARGS_OPTS ${ARGS_OPTS}
+        "-DCMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}"
+        "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}")
+    endif ()
+    set (build_cmds
+      CONFIGURE_COMMAND ${CMAKE_COMMAND} <SOURCE_DIR>
+        -DCMAKE_INSTALL_PREFIX=${install_prefix}
+        -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+        -G "${ARGS_GENERATOR}"
+        ${ARGS_OPTS}
+      BUILD_COMMAND ${CMAKE_COMMAND} --build "${CMAKE_BINARY_DIR}/${_NAME}"
+      INSTALL_COMMAND ${CMAKE_COMMAND} --build "${CMAKE_BINARY_DIR}/${_NAME}" --target install
+    )
+  elseif (ARGS_AUTOTOOLS)
+    set (make_opts "")
+    if (ARGS_PARALLELIZED)
+      set (make_opts "${make_opts} -j4")
+    endif ()
+    set (build_cmds
+      UPDATE_COMMAND <SOURCE_DIR>/autogen.sh
+      CONFIGURE_COMMAND <SOURCE_DIR>/configure --prefix=${install_prefix} ${ARGS_OPTS}
+      BUILD_COMMAND make ${make_opts}
+      INSTALL_COMMAND make install
+    )
+  endif ()
+
+  externalproject_add(
+    ${_NAME}
+    ${epa_opts}
+
+    PREFIX "${CMAKE_BINARY_DIR}/${_NAME}-build"
+    BINARY_DIR "${CMAKE_BINARY_DIR}/${_NAME}"
+
+    ${build_cmds}
+  )
+
+  if (WIN32)
+    set ("${_NAME}_SHARED_LIB" "${install_prefix}/lib/${_NAME}.dll" PARENT_SCOPE)
+    if (ARGS_GENERATOR MATCHES "(Unix|MSYS|MinGW) Makefiles")
+      set ("${_NAME}_STATIC_LIB" "${install_prefix}/lib/lib${_NAME}.a" PARENT_SCOPE)
+    else ()
+      set ("${_NAME}_STATIC_LIB" "${install_prefix}/lib/${_NAME}.lib" PARENT_SCOPE)
+    endif ()
+  elseif (APPLE)
+    set ("${_NAME}_SHARED_LIB" "${install_prefix}/lib/lib${_NAME}.dylib" PARENT_SCOPE)
+    set ("${_NAME}_STATIC_LIB" "${install_prefix}/lib/lib${_NAME}.a" PARENT_SCOPE)
+  elseif (UNIX)
+    set ("${_NAME}_SHARED_LIB" "${install_prefix}/lib/lib${_NAME}.so" PARENT_SCOPE)
+    set ("${_NAME}_STATIC_LIB" "${install_prefix}/lib/lib${_NAME}.a" PARENT_SCOPE)
+  else ()
+    message (FATAL_ERROR "Could not set proper library path for the current platform")
+  endif ()
+
+endfunction ()
+
+function (cr_link_subproject _TARGET _SUBPROJECT)
+  if (NOT ${_SUBPROJECT}_SUBPROJECT_EXISTS)
+    return ()
+  endif ()
+
+  set (options STATIC SHARED)
+  cmake_parse_arguments (ARGS "${options}" "" "" ${ARGN})
+
+  add_dependencies("${_TARGET}" "${_SUBPROJECT}")
+  if (ARGS_SHARED)
+    target_link_libraries("${_TARGET}" "${${_SUBPROJECT}_SHARED_LIB}")
+  endif ()
+  if (ARGS_STATIC)
+    target_link_libraries("${_TARGET}" "${${_SUBPROJECT}_STATIC_LIB}")
+  endif ()
+endfunction ()
+
+include_directories(${CMAKE_BINARY_DIR}/external/include)
+link_directories(${CMAKE_BINARY_DIR}/external/lib)
+
+

.cmake/Modules/uninstall.cmake

@@ -1,23 +1,19 @@
 set(MANIFEST "${CMAKE_CURRENT_BINARY_DIR}/install_manifest.txt")
  
 if(NOT EXISTS ${MANIFEST})
-message(FATAL_ERROR "Cannot find install manifest: '${MANIFEST}'")
+  message(FATAL_ERROR "Cannot find install manifest: '${MANIFEST}'")
 endif()
  
 file(STRINGS ${MANIFEST} files)
 foreach(file ${files})
-if(EXISTS ${file})
-message(STATUS "Removing file: '${file}'")
- 
-exec_program(
-${CMAKE_COMMAND} ARGS "-E remove ${file}"
-OUTPUT_VARIABLE stdout
-RETURN_VALUE result
-)
-if(NOT "${result}" STREQUAL 0)
-message(FATAL_ERROR "Failed to remove file: '${file}'.")
-endif()
-else()
-MESSAGE(STATUS "File '${file}' does not exist.")
-endif()
-endforeach(file)
+  message(STATUS "Removing file: '${file}'")
+
+  exec_program(
+    ${CMAKE_COMMAND} ARGS "-E remove ${file}"
+    OUTPUT_VARIABLE stdout
+    RETURN_VALUE result
+  )
+  if (NOT "${result}" STREQUAL 0)
+    message(FATAL_ERROR "Failed to remove file: '${file}'.")
+  endif ()
+endforeach ()

.cmake/cram-env.patch

@@ -0,0 +1,18 @@
+--- _test.py.orig	2016-09-03 00:50:27.505527300 +0200
++++ "/c/Program Files/Python35/lib/site-packages/cram/_test.py"	2016-09-03 00:48:48.708932100 +0200
+@@ -143,11 +143,15 @@
+             after.setdefault(pos, []).append(line)
+     stdin.append(b('echo %s %s $?\n' % (usalt, i + 1)))
+ 
++    env = {k: v.decode('utf-8') if isinstance(v, bytes) else v for k, v in env.items()}
++
+     output, retcode = execute(shell + ['-'], stdin=b('').join(stdin),
+                               stdout=PIPE, stderr=STDOUT, env=env)
+     if retcode == 80:
+         return (refout, None, [])
+ 
++    output = output.replace(b'\r\n', b'\n').replace(b'\r', b'\n')
++
+     pos = -1
+     ret = 0
+     for i, line in enumerate(output[:-1].splitlines(True)):

.cmake/cram-osx.patch

@@ -0,0 +1,39 @@
+diff --git a/cram.py b/cram.py
+index 20c4681..3b9f144 100755
+--- a/cram.py
++++ b/cram.py
+@@ -168,14 +168,14 @@ def test(path, shell, indent=2):
+     cmdline = '%s$ ' % indent
+     conline = '%s> ' % indent
+ 
+-    f = open(path)
++    f = open(path, 'r', encoding='utf-8')
+     abspath = os.path.abspath(path)
+     env = os.environ.copy()
+     env['TESTDIR'] = os.path.dirname(abspath)
+     env['TESTFILE'] = os.path.basename(abspath)
+     p = subprocess.Popen([shell, '-'], bufsize=-1, stdin=subprocess.PIPE,
+                          stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+-                         universal_newlines=True, env=env,
++                         universal_newlines=False, env=env,
+                          preexec_fn=makeresetsigpipe(),
+                          close_fds=os.name == 'posix')
+     salt = 'CRAM%s' % time.time()
+@@ -199,7 +199,7 @@ def test(path, shell, indent=2):
+             after.setdefault(pos, []).append(line)
+     stdin.append('echo "\n%s %s $?"\n' % (salt, i + 1))
+ 
+-    output = p.communicate(input=''.join(stdin))[0]
++    output = p.communicate(input=''.join(stdin).encode('utf-8'))[0].decode('utf-8')
+     if p.returncode == 80:
+         return (refout, None, [])
+ 
+@@ -336,7 +336,7 @@ def run(paths, tmpdir, shell, quiet=False, verbose=False, patchcmd=None,
+                 log('!', 'failed\n', verbose)
+                 if not quiet:
+                     log('\n', None, verbose)
+-                errfile = open(errpath, 'w')
++                errfile = open(errpath, 'w', encoding='utf-8')
+                 try:
+                     for line in postout:
+                         errfile.write(line)

.cmake/install_python.ps1

@@ -0,0 +1,229 @@
+# Sample script to install Python and pip under Windows
+# Authors: Olivier Grisel, Jonathan Helmus, Kyle Kastner, and Alex Willmer
+# License: CC0 1.0 Universal: http://creativecommons.org/publicdomain/zero/1.0/
+
+$MINICONDA_URL = "http://repo.continuum.io/miniconda/"
+$BASE_URL = "https://www.python.org/ftp/python/"
+$GET_PIP_URL = "https://bootstrap.pypa.io/get-pip.py"
+$GET_PIP_PATH = "C:\get-pip.py"
+
+$PYTHON_PRERELEASE_REGEX = @"
+(?x)
+(?<major>\d+)
+\.
+(?<minor>\d+)
+\.
+(?<micro>\d+)
+(?<prerelease>[a-z]{1,2}\d+)
+"@
+
+
+function Download ($filename, $url) {
+    $webclient = New-Object System.Net.WebClient
+
+    $basedir = $pwd.Path + "\"
+    $filepath = $basedir + $filename
+    if (Test-Path $filename) {
+        Write-Host "Reusing" $filepath
+        return $filepath
+    }
+
+    # Download and retry up to 3 times in case of network transient errors.
+    Write-Host "Downloading" $filename "from" $url
+    $retry_attempts = 2
+    for ($i = 0; $i -lt $retry_attempts; $i++) {
+        try {
+            $webclient.DownloadFile($url, $filepath)
+            break
+        }
+        Catch [Exception]{
+            Start-Sleep 1
+        }
+    }
+    if (Test-Path $filepath) {
+        Write-Host "File saved at" $filepath
+    } else {
+        # Retry once to get the error message if any at the last try
+        $webclient.DownloadFile($url, $filepath)
+    }
+    return $filepath
+}
+
+
+function ParsePythonVersion ($python_version) {
+    if ($python_version -match $PYTHON_PRERELEASE_REGEX) {
+        return ([int]$matches.major, [int]$matches.minor, [int]$matches.micro,
+                $matches.prerelease)
+    }
+    $version_obj = [version]$python_version
+    return ($version_obj.major, $version_obj.minor, $version_obj.build, "")
+}
+
+
+function DownloadPython ($python_version, $platform_suffix) {
+    $major, $minor, $micro, $prerelease = ParsePythonVersion $python_version
+
+    if (($major -le 2 -and $micro -eq 0) `
+        -or ($major -eq 3 -and $minor -le 2 -and $micro -eq 0) `
+        ) {
+        $dir = "$major.$minor"
+        $python_version = "$major.$minor$prerelease"
+    } else {
+        $dir = "$major.$minor.$micro"
+    }
+
+    if ($prerelease) {
+        if (($major -le 2) `
+            -or ($major -eq 3 -and $minor -eq 1) `
+            -or ($major -eq 3 -and $minor -eq 2) `
+            -or ($major -eq 3 -and $minor -eq 3) `
+            ) {
+            $dir = "$dir/prev"
+        }
+    }
+
+    if (($major -le 2) -or ($major -le 3 -and $minor -le 4)) {
+        $ext = "msi"
+        if ($platform_suffix) {
+            $platform_suffix = ".$platform_suffix"
+        }
+    } else {
+        $ext = "exe"
+        if ($platform_suffix) {
+            $platform_suffix = "-$platform_suffix"
+        }
+    }
+
+    $filename = "python-$python_version$platform_suffix.$ext"
+    $url = "$BASE_URL$dir/$filename"
+    $filepath = Download $filename $url
+    return $filepath
+}
+
+
+function InstallPython ($python_version, $architecture, $python_home) {
+    Write-Host "Installing Python" $python_version "for" $architecture "bit architecture to" $python_home
+    if (Test-Path $python_home) {
+        Write-Host $python_home "already exists, skipping."
+        return $false
+    }
+    if ($architecture -eq "32") {
+        $platform_suffix = ""
+    } else {
+        $platform_suffix = "amd64"
+    }
+    $installer_path = DownloadPython $python_version $platform_suffix
+    $installer_ext = [System.IO.Path]::GetExtension($installer_path)
+    Write-Host "Installing $installer_path to $python_home"
+    $install_log = $python_home + ".log"
+    if ($installer_ext -eq '.msi') {
+        InstallPythonMSI $installer_path $python_home $install_log
+    } else {
+        InstallPythonEXE $installer_path $python_home $install_log
+    }
+    if (Test-Path $python_home) {
+        Write-Host "Python $python_version ($architecture) installation complete"
+    } else {
+        Write-Host "Failed to install Python in $python_home"
+        Get-Content -Path $install_log
+        Exit 1
+    }
+}
+
+
+function InstallPythonEXE ($exepath, $python_home, $install_log) {
+    $install_args = "/quiet InstallAllUsers=1 TargetDir=$python_home"
+    RunCommand $exepath $install_args
+}
+
+
+function InstallPythonMSI ($msipath, $python_home, $install_log) {
+    $install_args = "/qn /log $install_log /i $msipath TARGETDIR=$python_home"
+    $uninstall_args = "/qn /x $msipath"
+    RunCommand "msiexec.exe" $install_args
+    if (-not(Test-Path $python_home)) {
+        Write-Host "Python seems to be installed else-where, reinstalling."
+        RunCommand "msiexec.exe" $uninstall_args
+        RunCommand "msiexec.exe" $install_args
+    }
+}
+
+function RunCommand ($command, $command_args) {
+    Write-Host $command $command_args
+    Start-Process -FilePath $command -ArgumentList $command_args -Wait -Passthru
+}
+
+
+function InstallPip ($python_home) {
+    $pip_path = $python_home + "\Scripts\pip.exe"
+    $python_path = $python_home + "\python.exe"
+    if (-not(Test-Path $pip_path)) {
+        Write-Host "Installing pip..."
+        $webclient = New-Object System.Net.WebClient
+        $webclient.DownloadFile($GET_PIP_URL, $GET_PIP_PATH)
+        Write-Host "Executing:" $python_path $GET_PIP_PATH
+        & $python_path $GET_PIP_PATH
+    } else {
+        Write-Host "pip already installed."
+    }
+}
+
+
+function DownloadMiniconda ($python_version, $platform_suffix) {
+    if ($python_version -eq "3.4") {
+        $filename = "Miniconda3-3.5.5-Windows-" + $platform_suffix + ".exe"
+    } else {
+        $filename = "Miniconda-3.5.5-Windows-" + $platform_suffix + ".exe"
+    }
+    $url = $MINICONDA_URL + $filename
+    $filepath = Download $filename $url
+    return $filepath
+}
+
+
+function InstallMiniconda ($python_version, $architecture, $python_home) {
+    Write-Host "Installing Python" $python_version "for" $architecture "bit architecture to" $python_home
+    if (Test-Path $python_home) {
+        Write-Host $python_home "already exists, skipping."
+        return $false
+    }
+    if ($architecture -eq "32") {
+        $platform_suffix = "x86"
+    } else {
+        $platform_suffix = "x86_64"
+    }
+    $filepath = DownloadMiniconda $python_version $platform_suffix
+    Write-Host "Installing" $filepath "to" $python_home
+    $install_log = $python_home + ".log"
+    $args = "/S /D=$python_home"
+    Write-Host $filepath $args
+    Start-Process -FilePath $filepath -ArgumentList $args -Wait -Passthru
+    if (Test-Path $python_home) {
+        Write-Host "Python $python_version ($architecture) installation complete"
+    } else {
+        Write-Host "Failed to install Python in $python_home"
+        Get-Content -Path $install_log
+        Exit 1
+    }
+}
+
+
+function InstallMinicondaPip ($python_home) {
+    $pip_path = $python_home + "\Scripts\pip.exe"
+    $conda_path = $python_home + "\Scripts\conda.exe"
+    if (-not(Test-Path $pip_path)) {
+        Write-Host "Installing pip..."
+        $args = "install --yes pip"
+        Write-Host $conda_path $args
+        Start-Process -FilePath "$conda_path" -ArgumentList $args -Wait -Passthru
+    } else {
+        Write-Host "pip already installed."
+    }
+}
+
+function main () {
+    InstallPython $env:PYTHON_VERSION $env:PYTHON_ARCH $env:PYTHON
+    InstallPip $env:PYTHON
+}
+
+main

.githooks/canonicalize_filename.sh

@@ -0,0 +1,48 @@
+#!/bin/sh
+
+# Provide the canonicalize filename (physical filename with out any symlinks)
+# like the GNU version readlink with the -f option regardless of the version of
+# readlink (GNU or BSD).
+
+# This file is part of a set of unofficial pre-commit hooks available
+# at github.
+# Link:    https://github.com/githubbrowser/Pre-commit-hooks
+# Contact: David Martin, david.martin.mailbox@googlemail.com
+
+###########################################################
+# There should be no need to change anything below this line.
+
+# Canonicalize by recursively following every symlink in every component of the
+# specified filename.  This should reproduce the results of the GNU version of
+# readlink with the -f option.
+#
+# Reference: http://stackoverflow.com/questions/1055671/how-can-i-get-the-behavior-of-gnus-readlink-f-on-a-mac
+canonicalize_filename () {
+    local target_file="$1"
+    local physical_directory=""
+    local result=""
+
+    # Need to restore the working directory after work.
+    local working_dir="`pwd`"
+
+    cd -- "$(dirname -- "$target_file")"
+    target_file="$(basename -- "$target_file")"
+
+    # Iterate down a (possible) chain of symlinks
+    while [ -L "$target_file" ]
+    do
+        target_file="$(readlink -- "$target_file")"
+        cd -- "$(dirname -- "$target_file")"
+        target_file="$(basename -- "$target_file")"
+    done
+
+    # Compute the canonicalized name by finding the physical path
+    # for the directory we're in and appending the target file.
+    physical_directory="`pwd -P`"
+    result="$physical_directory/$target_file"
+
+    # restore the working directory after work.
+    cd -- "$working_dir"
+
+    echo "$result"
+}

.githooks/install.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+rm -Rf .git/hooks
+ln -s ../.githooks .git/hooks

.githooks/pre-commit

@@ -0,0 +1,171 @@
+#!/bin/sh
+
+# git pre-commit hook that runs an Uncrustify stylecheck.
+# Features:
+#  - abort commit when commit does not comply with the style guidelines
+#  - create a patch of the proposed style changes
+#
+# More info on Uncrustify: http://uncrustify.sourceforge.net/
+
+# This file is part of a set of unofficial pre-commit hooks available
+# at github.
+# Link:    https://github.com/githubbrowser/Pre-commit-hooks
+# Contact: David Martin, david.martin.mailbox@googlemail.com
+
+
+##################################################################
+# CONFIGURATION
+# set uncrustify path or executable
+# UNCRUSTIFY="/usr/bin/uncrustify"
+UNCRUSTIFY="uncrustify"
+
+# set uncrustify config location
+# CONFIG="/home/user/.config/uncrustify.cfg"
+CONFIG=".uncrustify.cfg"
+
+# the source language: C, CPP, D, CS, JAVA, PAWN, VALA, OC, OC+
+# use AUTO to let Uncrustify decide which language a given file uses.
+# the detected language is printed to the console when Uncrustify is called.
+# override if the automatic detection seems off.
+# SOURCE_LANGUAGE="AUTO"
+SOURCE_LANGUAGE="AUTO"
+
+# remove any older patches from previous commits. Set to true or false.
+# DELETE_OLD_PATCHES=false
+DELETE_OLD_PATCHES=false
+
+# only parse files with the extensions in FILE_EXTS. Set to true or false.
+# if false every changed file in the commit will be parsed with Uncrustify.
+# if true only files matching one of the extensions are parsed with Uncrustify.
+# PARSE_EXTS=true
+PARSE_EXTS=true
+
+# file types to parse. Only effective when PARSE_EXTS is true.
+# FILE_EXTS=".c .h .cpp .hpp"
+FILE_EXTS=".c .h .cc .hh .cpp .hpp .hxx"
+
+##################################################################
+# There should be no need to change anything below this line.
+
+. "$(dirname -- "$0")/canonicalize_filename.sh"
+
+# exit on error
+set -e
+
+# check whether the given file matches any of the set extensions
+matches_extension() {
+    local filename="$(basename -- "$1")"
+    local extension=".${filename##*.}"
+    local ext
+
+    for ext in $FILE_EXTS; do [ "$ext" = "$extension" ] && return 0; done
+
+    return 1
+}
+
+# necessary check for initial commit
+if git rev-parse --verify HEAD >/dev/null 2>&1 ; then
+    against=HEAD
+else
+    # Initial commit: diff against an empty tree object
+    against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
+fi
+
+# make sure the config file and executable are correctly set
+if [ ! -f "$CONFIG" ] ; then
+    printf "Error: uncrustify config file not found.\n"
+    printf "Set the correct path in $(canonicalize_filename "$0").\n"
+    exit 1
+fi
+
+if ! command -v "$UNCRUSTIFY" > /dev/null ; then
+    printf "Error: uncrustify executable not found.\n"
+    printf "Set the correct path in $(canonicalize_filename "$0").\n"
+    exit 1
+fi
+
+# create a filename to store our generated patch
+prefix="pre-commit-uncrustify"
+suffix="$(date +%C%y-%m-%d_%Hh%Mm%Ss)"
+patch="/tmp/$prefix-$suffix.patch"
+diff="/tmp/$prefix-$suffix.diff"
+
+# clean up any older uncrustify patches
+$DELETE_OLD_PATCHES && rm -f /tmp/$prefix*.patch
+
+# create one patch containing all changes to the files
+# sed to remove quotes around the filename, if inserted by the system
+# (done sometimes, if the filename contains special characters, like the quote itself)
+git diff-index --cached --diff-filter=ACMR --name-only $against -- | \
+sed -e 's/^"\(.*\)"$/\1/' | \
+while read file
+do
+    # ignore file if we do check for file extensions and the file
+    # does not match any of the extensions specified in $FILE_EXTS
+    if $PARSE_EXTS && ! matches_extension "$file"; then
+        continue;
+    fi
+
+    # escape special characters in the source filename:
+    # - '\': backslash needs to be escaped
+    # - '*': used as matching string => '*' would mean expansion
+    #        (curiously, '?' must not be escaped)
+    # - '[': used as matching string => '[' would mean start of set
+    # - '|': used as sed split char instead of '/', so it needs to be escaped
+    #        in the filename
+    # printf %s particularly important if the filename contains the % character
+    file_escaped_source=$(printf "%s" "$file" | sed -e 's/[\*[|]/\\&/g')
+
+    # escape special characters in the target filename:
+    # phase 1 (characters escaped in the output diff):
+    #     - '\': backslash needs to be escaped in the output diff
+    #     - '"': quote needs to be escaped in the output diff if present inside
+    #            of the filename, as it used to bracket the entire filename part
+    # phase 2 (characters escaped in the match replacement):
+    #     - '\': backslash needs to be escaped again for sed itself
+    #            (i.e. double escaping after phase 1)
+    #     - '&': would expand to matched string
+    #     - '|': used as sed split char instead of '/'
+    # printf %s particularly important if the filename contains the % character
+    file_escaped_target=$(printf "%s" "$file" | sed -e 's/[\"]/\\&/g' -e 's/[\&|]/\\&/g')
+
+    # Uncrustify detects the language automatically if it is not specified
+    language_option=""
+    if [ "$SOURCE_LANGUAGE" != "AUTO" ] ; then
+        language_option="-l $SOURCE_LANGUAGE"
+    fi
+
+    # uncrustify our sourcefile, create a patch with diff and append it to our $patch
+    # The sed call is necessary to transform the patch from
+    #    --- $file timestamp
+    #    +++ - timestamp
+    # to both lines working on the same file and having a a/ and b/ prefix.
+    # Else it can not be applied with 'git apply'.
+    "$UNCRUSTIFY" -q -c "$CONFIG" -f "$file" $language_option | \
+        git --no-pager diff --color=always --no-index -- "$file" - | \
+        tail -n +3 | \
+        sed -e "1s|--- a/$file_escaped_source|--- \"a/$file_escaped_target\"|" \
+            -e "2s|+++ b/-|+++ \"b/$file_escaped_target\"|" | \
+        tee -a "$diff" | \
+        sed -r "s/\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]//g" >> "$patch"
+done
+
+# if no patch has been generated all is ok, clean up the file stub and exit
+if [ ! -s "$patch" ] ; then
+    printf "Files in this commit comply with the uncrustify rules.\n"
+    rm -f "$patch"
+    exit 0
+fi
+
+# a patch has been created, notify the user and exit
+printf "\nThe following differences were found between the code to commit "
+printf "and the uncrustify rules:\n\n"
+cat "$diff"
+rm -f "$diff"
+
+printf "\nYou can apply these changes with:\n git apply $patch\n"
+printf "(may need to be called from the root directory of your repository)\n"
+printf "Aborting commit. Apply changes and commit again or skip checking with"
+printf " --no-verify (not recommended).\n"
+
+exit 1

.gitignore

@@ -18,6 +18,7 @@
 !*.po
 !*.in
 !*.t
+!*.proto
 !.cmake/Modules/*.cmake
 !samples/tests/*.sh
 !samples/**/*.expected

.gitmodules

@@ -10,3 +10,15 @@
 [submodule "dependencies/klib"]
 	path = dependencies/klib
 	url = https://github.com/attractivechaos/klib.git
+[submodule "dependencies/nanopb"]
+	path = dependencies/nanopb
+	url = https://github.com/nanopb/nanopb.git
+[submodule "dependencies/nanomsg"]
+	path = dependencies/nanomsg
+	url = https://github.com/nanomsg/nanomsg.git
+[submodule "dependencies/debugbreak"]
+	path = dependencies/debugbreak
+	url = https://github.com/scottt/debugbreak
+[submodule "dependencies/boxfort"]
+	path = dependencies/boxfort
+	url = https://github.com/Snaipe/BoxFort

.travis.yml

@@ -15,36 +15,69 @@ _anchors:
 
 matrix:
   include:
+    # Style check
+    - compiler: uncrustify
+      language: cpp
+      before_install:
+        - if [[ "$TRAVIS_PULL_REQUEST" == false ]]; then exit 0; fi
+        - |
+            git clone https://github.com/uncrustify/uncrustify /tmp/uncrustify &&
+            pushd /tmp/uncrustify &&
+            git checkout -q 7ae7af9d3483f5f92766ec41bb3ba3efe4747494 &&
+            mkdir build && cd build &&
+            CC=gcc CXX=g++ cmake -DCMAKE_INSTALL_PREFIX=$HOME .. &&
+            make -j4 && make install &&
+            export PATH="$PATH:$HOME/bin" &&
+            popd
+        - >
+            export SOURCES=$(find src include test samples \( \
+              -type f \( \
+                -iname "*.c" -or \
+                -iname "*.h" -or \
+                -iname "*.cc" -or \
+                -iname "*.hxx" \
+              \) -and -not \
+              -iname "*.pb.*" \))
+        - export STYLE_OK=true
+      script:
+        - >
+            for f in $SOURCES; do
+              if ! uncrustify -q --check -c .uncrustify.cfg $f; then
+                uncrustify -q -c .uncrustify.cfg -f $f | git --no-pager diff --no-index --color=always $f -
+                export STYLE_OK=false
+              fi
+            done
+        - $STYLE_OK
+      after_success:
+        - echo "Style check passed."
+
     # Linux Debug, GCC 4.9
     - compiler: gcc-4.9
       addons: *gcc49-packages
       env:
         CONFIGURATION: Debug
         GCOV: gcov-4.9
-        CMAKE_OPTS: -DLANG_OBJC=ON
         COVERAGE: "ON"
-    # Linux Release, GCC 4.9
-    - compiler: gcc-4.9
-      addons: *gcc49-packages
-      env:
-        CONFIGURATION: Release
-        CMAKE_OPTS: -DLANG_OBJC=ON
     # Linux RelWithDebInfo, GCC 4.9
     - compiler: gcc-4.9
       addons: *gcc49-packages
       env:
         CONFIGURATION: RelWithDebInfo
-        CMAKE_OPTS: -DLANG_OBJC=ON
         DEPLOY: true
     # Linux Debug, GCC 4.6
     - compiler: gcc
       env: CONFIGURATION=Debug TESTS=OFF
-    # Linux Release, GCC 4.6
-    - compiler: gcc
-      env: CONFIGURATION=Release TESTS=OFF
     # Linux RelWithDebInfo, GCC 4.6
     - compiler: gcc
-      env: CONFIGURATION=RelWithDebInfo TESTS=OFF
+      env:
+        - CONFIGURATION=RelWithDebInfo
+        - TESTS=OFF
+        # Coverity token
+        - secure: >-
+            n6BHG86ISeYSAVE/i7m1K+XVW0j8PrJ5JxoJwhAGBb1
+            hkCn9sWybGo1HzZsf7rxpkQh/5Va4i+eyOrUt7VWAuF
+            EJN2+mEWqERkWZxiXrS3N9xi74cPFI79eDOTFnPm13e
+            diUX8Ts+IuFy890+tsNHqkEn055l6yOVMtj1LWWtRs=
     # OSX Debug, GCC 4.9
     - os: osx
       compiler: gcc-4.9
@@ -52,10 +85,6 @@ matrix:
         CONFIGURATION: Debug
         GCOV: gcov-4.9
         COVERAGE: "ON"
-    # OSX Release, GCC 4.9
-    - os: osx
-      compiler: gcc-4.9
-      env: CONFIGURATION=Release
     # OSX RelWithDebInfo, GCC 4.9
     - os: osx
       compiler: gcc-4.9
@@ -65,34 +94,23 @@ matrix:
       compiler: clang
       env:
         CONFIGURATION: Debug
-        CMAKE_OPTS: -DLANG_OBJC=ON
-    # OSX Release, Clang
-    - os: osx
-      compiler: clang
-      env:
-        CONFIGURATION: Release
-        CMAKE_OPTS: -DLANG_OBJC=ON
     # OSX RelWithDebInfo, Clang
     - os: osx
       compiler: clang
       env:
         CONFIGURATION: RelWithDebInfo
-        CMAKE_OPTS: -DLANG_OBJC=ON
         DEPLOY: true
 
   allow_failures:
     - compiler: gcc
 
 before_install:
-  - |
-      if [ "$TRAVIS_OS_NAME" = "osx" ] && [ "$CC" = "clang" ]; then
-        brew update
-        brew unlink cmake
-        brew install llvm cmake
-      fi
   - |
       if [ "${TESTS:-ON}" = "ON" ]; then
-        pip install --user cram
+        if [ "$TRAVIS_OS_NAME" = "osx" ]; then
+          export PATH="$(python -m site --user-base)/bin:$PATH"
+        fi
+        travis_retry pip install --user cram==0.7
       fi
   - export CXX=${CC/gcc/g++}; export CXX=${CXX/clang/clang++}
   - $CC --version
@@ -112,7 +130,7 @@ script:
   - |
       if [ "${TESTS:-ON}" = "ON" ]; then
         TERM=dumb cmake --build . --target criterion_tests -- -j4
-        ctest -j4
+        ctest --output-on-failure -j4 --timeout=20
       else
         TERM=dumb cmake --build . -- -j4
       fi
@@ -124,22 +142,30 @@ after_success:
         bash <(curl -s https://codecov.io/bash)
       fi
 
-after_failure:
-  - |
-      if [ "${TESTS:-ON}" = "ON" ]; then
-        cat Testing/Temporary/LastTest.log samples/*.{out,err} ../samples/tests/*.{out,err}
-      fi
-
 before_deploy:
   - make install
   - tar -cvjf criterion-${TRAVIS_TAG}-${TRAVIS_OS_NAME}-x86_64.tar.bz2 criterion-${TRAVIS_TAG}
+  - cd ..
+  - ./.cmake/git-archive-all.sh --prefix criterion-${TRAVIS_TAG} criterion-${TRAVIS_TAG}.tar && bzip2 $_
+
+addons:
+  coverity_scan:
+    project:
+      name: "Snaipe/Criterion"
+      description: "A KISS, Cross-platform C unit testing framework"
+    notification_email: franklinmathieu@gmail.com
+    build_command_prepend: "cmake ."
+    build_command: "make -j4"
+    branch_pattern: coverity_scan
 
 deploy:
   provider: releases
   skip_cleanup: true
   api_key:
     secure: d3l2Ohb2FF3tSXku1d0ASR5dntdnQ48Jyc39IEloDBxFXCselCkYruUQv6p0TA3P+Dmrz4wS7/AFlBMMsQ3XfGFVIOnITiTaGWg5fEpIf7zYsDf0zECPE0MOHMGqJMn3/SrSKdtEA4N84Q4JS7Ou+ewG65mxUDO5Ce60OoEG5JA=
-  file: criterion-${TRAVIS_TAG}-${TRAVIS_OS_NAME}-x86_64.tar.bz2
+  file:
+    - criterion-${TRAVIS_TAG}-${TRAVIS_OS_NAME}-x86_64.tar.bz2
+    - criterion-${TRAVIS_TAG}.tar.bz2
   on:
     repo: Snaipe/Criterion
     tags: true

.uncrustify.cfg

@@ -0,0 +1,239 @@
+#
+# uncrustify config file (initially based on the linux kernel coding style)
+#
+
+input_tab_size                  = 4             # original tab size
+output_tab_size                 = 4             # new tab size
+
+newlines                        = lf            # \n
+
+utf8_force                      = true
+utf8_bom                        = remove
+
+# Indent
+
+indent_with_tabs                = 0             # 1=indent to level only, 2=indent with tabs
+indent_columns                  = 4             # indents are 4 cols
+indent_continue                 = 8             # line continuations are indented by 8 columns
+indent_label                    = -4            # pos: absolute col, neg: relative column
+indent_xml_string               = 2             # embedded XML indents are 2 cols
+indent_ctor_init                = 4             # indent c++ ctor initializer list
+indent_switch_case              = 4             # indent 'case' inside switch statements
+indent_namespace                = false
+indent_extern                   = false
+indent_class                    = false
+indent_class_colon              = true
+indent_access_spec_body         = true
+
+# Newlines
+
+nl_max                          = 2             # no duplicate blank lines
+nl_func_paren                   = remove        # "int foo()" vs "int foo\n()"
+nl_func_decl_start              = ignore
+nl_func_decl_empty              = remove
+nl_func_decl_args               = ignore
+nl_func_decl_end                = remove
+nl_enum_brace                   = remove        # "enum {" vs "enum \n {"
+nl_union_brace                  = remove        # "union {" vs "union \n {"
+nl_struct_brace                 = remove        # "struct {" vs "struct \n {"
+nl_do_brace                     = remove        # "do {" vs "do \n {"
+nl_if_brace                     = remove        # "if () {" vs "if () \n {"
+nl_for_brace                    = remove        # "for () {" vs "for () \n {"
+nl_else_brace                   = remove        # "else {" vs "else \n {"
+nl_while_brace                  = remove        # "while () {" vs "while () \n {"
+nl_switch_brace                 = remove        # "switch () {" vs "switch () \n {"
+nl_brace_while                  = remove        # "} while" vs "} \n while" - cuddle while
+nl_brace_else                   = remove        # "} else" vs "} \n else" - cuddle else
+nl_namespace_brace              = force         # "namespace name {" vs "namespace name \n {"
+nl_func_var_def_blk             = 1
+nl_fcall_brace                  = remove        # "list_for_each() {" vs "list_for_each()\n{"
+nl_fdef_brace                   = add           # "int foo() {" vs "int foo()\n{"
+nl_after_label_colon            = false         # "fail:\nfree(foo);" vs "fail: free(foo);"
+nl_start_of_file                = remove
+nl_end_of_file                  = force
+nl_end_of_file_min              = 1
+nl_comment_func_def             = 1
+nl_assign_leave_one_liners      = true
+nl_class_leave_one_liners       = true
+nl_enum_leave_one_liners        = true
+nl_getset_leave_one_liners      = true
+nl_func_leave_one_liners        = true
+nl_cpp_lambda_leave_one_liners  = true
+nl_while_leave_one_liners       = false
+nl_if_leave_one_liners          = false
+nl_multi_line_define            = true
+nl_func_call_start_multi_line   = false
+nl_func_call_end_multi_line     = false
+
+# Source code modifications
+
+mod_paren_on_return             = remove        # "return 1;" vs "return (1);"
+mod_full_brace_if               = remove        # "if (a) a--;" vs "if (a) { a--; }"
+mod_full_brace_if_chain         = true
+mod_full_brace_for              = remove        # "for () a--;" vs "for () { a--; }"
+mod_full_brace_do               = force         # "do a--; while ();" vs "do { a--; } while ();"
+mod_full_brace_while            = remove        # "while (a) a--;" vs "while (a) { a--; }"
+mod_full_brace_nl               = 3             # don't remove if more than 3 newlines
+
+# Spacing
+
+sp_addr                         = remove
+sp_after_angle                  = force
+sp_after_byref                  = remove
+sp_after_byref_func             = remove
+sp_after_cast                   = force        # "(int) a" vs "(int)a"
+sp_after_class_colon            = force
+sp_after_comma                  = force
+sp_after_dc                     = remove
+sp_after_new                    = force
+sp_after_operator               = remove
+sp_after_operator_sym           = remove
+sp_after_ptr_star               = remove        # "int *foo" vs "int * foo"
+sp_after_ptr_star_func          = remove
+sp_after_semi                   = force
+sp_after_semi_for               = force
+sp_after_semi_for_empty         = remove
+sp_after_sparen                 = force         # "if () {" vs "if (){"
+sp_after_type                   = force
+sp_angle_paren                  = remove
+sp_angle_shift                  = ignore
+sp_angle_word                   = force
+sp_arith                        = force
+sp_assign                       = add
+sp_assign_default               = force
+sp_attribute_paren              = remove
+sp_balance_nested_parens        = false
+sp_before_angle                 = remove
+sp_before_byref                 = force
+sp_before_byref_func            = force
+sp_before_case_colon            = remove
+sp_before_class_colon           = force
+sp_before_comma                 = remove
+sp_before_dc                    = remove
+sp_before_ellipsis              = remove
+sp_before_nl_cont               = force
+sp_before_ptr_star              = force         # "int*" vs "int *"
+sp_before_ptr_star_func         = force
+sp_before_semi                  = remove
+sp_before_semi_for              = remove
+sp_before_semi_for_empty        = remove
+sp_before_sparen                = force         # "if (" vs "if("
+sp_before_square                = remove
+sp_before_tr_emb_cmt            = force
+sp_before_unnamed_byref         = force
+sp_between_ptr_star             = remove        # "int **" vs "int * *"
+sp_bool                         = force
+sp_brace_catch                  = force
+sp_brace_else                   = force         # "}else" vs "} else"
+sp_brace_finally                = force
+sp_brace_typedef                = force
+sp_case_label                   = force
+sp_catch_brace                  = force
+sp_catch_paren                  = force
+sp_cmt_cpp_start                = force
+sp_compare                      = force
+sp_cond_colon                   = add
+sp_cond_question                = add
+sp_cpp_cast_paren               = force
+sp_defined_paren                = force
+sp_deref                        = remove
+sp_else_brace                   = force         # "else{" vs "else {"
+sp_endif_cmt                    = force
+sp_enum_assign                  = force
+sp_finally_brace                = force
+sp_fparen_brace                 = force
+sp_func_call_paren              = remove        # "foo (" vs "foo("
+sp_func_call_user_paren         = remove
+sp_func_class_paren             = remove
+sp_func_def_paren               = remove        # "int foo (){" vs "int foo(){"
+sp_func_proto_paren             = remove        # "int foo ();" vs "int foo();"
+sp_getset_brace                 = force
+sp_incdec                       = remove
+sp_inside_angle                 = remove
+sp_inside_braces                = force         # "{ 1 }" vs "{1}"
+sp_inside_braces_empty          = remove
+sp_inside_braces_enum           = force         # "{ 1 }" vs "{1}"
+sp_inside_braces_struct         = force         # "{ 1 }" vs "{1}"
+sp_inside_fparen                = remove
+sp_inside_fparens               = remove
+sp_inside_paren                 = remove
+sp_inside_paren_cast            = remove
+sp_inside_sparen                = remove
+sp_inside_square                = remove
+sp_inv                          = remove
+sp_macro                        = force
+sp_macro_func                   = force
+sp_member                       = remove
+sp_not                          = remove
+sp_num_before_tr_emb_cmt        = 1
+sp_paren_brace                  = force
+sp_paren_comma                  = ignore
+sp_paren_paren                  = remove        # "((" vs "( ("
+sp_pp_concat                    = force
+sp_pp_stringify                 = remove
+sp_return_paren                 = force         # "return (1);" vs "return(1);"
+sp_sign                         = remove
+sp_sizeof_paren                 = force         # "sizeof (int)" vs "sizeof(int)"
+sp_sparen_brace                 = force
+sp_special_semi                 = remove
+sp_square_fparen                = remove
+sp_template_angle               = add
+sp_throw_paren                  = force
+sp_try_brace                    = force
+
+cmt_sp_before_star_cont         = 0
+cmt_sp_after_star_cont          = 1
+
+# Positioning
+
+pos_arith                       = lead
+pos_assign                      = trail
+pos_bool                        = lead
+pos_compare                     = lead
+pos_conditional                 = lead
+pos_comma                       = trail
+pos_class_comma                 = trail
+pos_class_colon                 = lead
+
+# Alignment
+
+align_with_tabs                 = false         # use tabs to align
+align_on_tabstop                = false         # align on tabstops
+align_enum_equ_span             = 4             # '=' in enum definition
+align_nl_cont                   = true
+align_assign_span               = 0
+align_struct_init_span          = 3             # align stuff in a structure init '= { }'
+align_right_cmt_span            = 3
+align_pp_define_span            = 8
+align_pp_define_gap             = 4
+align_func_params               = false
+align_var_struct_span           = 0
+
+# Comment
+
+cmt_indent_multi                = true
+cmt_c_group                     = false
+cmt_c_nl_start                  = false
+cmt_c_nl_end                    = false
+cmt_cpp_group                   = true
+cmt_cpp_nl_start                = false
+cmt_cpp_nl_end                  = false
+cmt_cpp_to_c                    = true
+cmt_star_cont                   = false
+cmt_multi_check_last            = true
+
+eat_blanks_after_open_brace     = true
+eat_blanks_before_close_brace   = true
+
+# Preprocessor
+
+pp_indent                       = remove
+pp_space                        = force
+pp_space_count                  = 1
+
+# Misc
+
+set cpp_cast nonstd             # nonstd cast attributes
+set compare Op                  # typical (A) Op (B) macro scenarios
+set func_call_user _ N_         # gettext macros
+set attribute CR_FORMAT CR_API CR_PURE CR_INLINE

AUTHORS

@@ -0,0 +1,14 @@
+Maintainer:
+
+* Franklin "Snaipe" Mathieu <franklinmathieu@gmail.com>
+
+Contributors:
+
+* Adeel "am11" Mujahid <adeelbm@outlook.com>
+* Matthias "ailu" Günzel <a1lu@arcor.de>
+* Ben "blinskey" Linskey <ben@benlinskey.com>
+* "kaidowei" <kaidowei@users.noreply.github.com>
+* Howard "hppritcha" Pritchard <howardp@lanl.gov>
+* Kevin "kevinoid" Locke <kevin@kevinlocke.name>
+* László "MrAnno" Várady <laszlo.varady@balabit.com>
+* "offa" <bm-dev@yandex.com>

CMakeLists.txt

@@ -1,318 +1,149 @@
-cmake_minimum_required(VERSION 2.8)
+# Copyright (C) 2015-2016 Franklin "Snaipe" Mathieu.
+# Redistribution and use of this file is allowed according to the terms of the MIT license.
+# For details see the LICENSE file distributed with Criterion.
 
-project(Criterion C)
+cmake_minimum_required (VERSION 2.8)
 
-set(MODULE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/.cmake/Modules")
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${MODULE_DIR})
-set(LIBCSPTR_DISABLE_TESTS ON)
-set(LIBCSPTR_DISABLE_COVERALLS ON)
+project (Criterion C)
 
-# Content options
+set (MODULE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/.cmake/Modules")
+set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${MODULE_DIR})
 
-option(THEORIES "Activate the support for theories" ON)
+if (POLICY CMP0054)
+  # http://www.cmake.org/cmake/help/v3.1/policy/CMP0054.html
+  # This is here to allow conditions to be passed as function parameters
+  cmake_policy (SET CMP0054 OLD)
+endif ()
 
 # Initialization
 
-include(Submodules)
-include(Capabilities)
+include (Options)
+include (Submodules)
+include (Capabilities)
+include (Subprojects)
+include (PackageUtils)
 
-if (MSVC)
-  add_definitions(-D_CRT_SECURE_NO_WARNINGS=1)
+if (NOT WIN32)
+  set (PIC_C_FLAGS "-fPIC")
+  set (VISI_C_FLAGS "-fvisibility=hidden")
+else ()
+  set (PIC_C_FLAGS "")
+  set (VISI_C_FLAGS "")
 endif ()
 
-add_subdirectory(dependencies/libcsptr/ EXCLUDE_FROM_ALL)
+cr_add_subproject (csptr PATH dependencies/libcsptr
+    OPTS
+      -DLIBCSPTR_TESTS=OFF
+      "-DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} ${PIC_C_FLAGS} ${VISI_C_FLAGS}"
+    CMAKE)
 
-if (THEORIES)
-  add_subdirectory(dependencies/dyncall/ EXCLUDE_FROM_ALL)
-  include_directories(dependencies/dyncall/dyncall/)
-endif ()
+cr_add_subproject (dyncall_s PATH dependencies/dyncall
+    OPTS
+      -DLANG_CXX=${LANG_CXX}
+      "-DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} ${PIC_C_FLAGS} ${VISI_C_FLAGS}"
+    CMAKE IF THEORIES)
 
-include_directories(SYSTEM
-  /usr/local/include
-  /usr/include/GNUstep
+cr_add_subproject (nanomsg
+  PATH dependencies/nanomsg
+  OPTS
+    -DNN_TESTS=OFF
+    -DNN_TOOLS=OFF
+    -DNN_STATIC_LIB=ON
+    -DCMAKE_INSTALL_LIBDIR=lib
+    "-DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} ${PIC_C_FLAGS} ${VISI_C_FLAGS}"
+  CMAKE
 )
 
+cr_add_subproject (boxfort PATH dependencies/boxfort
+  OPTS
+    -DBXF_TESTS=OFF
+    -DBXF_SAMPLES=OFF
+    -DBXF_STATIC_LIB=ON
+    -DBXF_FORK_RESILIENCE=OFF
+    -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+    "-DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} ${PIC_C_FLAGS} ${VISI_C_FLAGS}"
+  CMAKE)
+
+add_definitions(-DBXF_STATIC_LIB -DNN_STATIC_LIB)
+
+cr_add_subproject (wingetopt PATH dependencies/wingetopt CMAKE IF MSVC)
+
+include (Properties)
+
+add_definitions (-DNN_STATIC_LIB)
+
 include_directories(
-  dependencies/libcsptr/include/
   dependencies/valgrind/include/
   dependencies/klib/
+  dependencies/nanopb/
+  dependencies/debugbreak/
 )
 
-if (MSVC)
-  add_subdirectory(dependencies/wingetopt/ EXCLUDE_FROM_ALL)
-  include_directories(dependencies/wingetopt/src/)
-endif ()
-
-# Check for C++11
-
-option(LANG_CXX "Turn on C++ support" ON)
-if (LANG_CXX)
-  enable_language(CXX)
-endif ()
-
-if (NOT MSVC AND CMAKE_CXX_COMPILER_WORKS)
-  include(CheckCXXCompilerFlag)
-  CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
-  CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
-
-  if(COMPILER_SUPPORTS_CXX11)
-    set(CXX11_FLAG "-std=c++11")
-  elseif(COMPILER_SUPPORTS_CXX0X)
-    set(CXX11_FLAG "-std=c++0x")
-  else()
-    message(FATAL_ERROR "Compiler ${CMAKE_CXX_COMPILER} has no C++11 support.")
-  endif()
-endif()
-
-# Project setup & environment variables
-
-set(PROJECT_VERSION "2.2.0")
-set(PROJECT_SOVERSION 2)
-set(LOCALEDIR_REL "share/locale")
-set(LOCALEDIR "${CMAKE_INSTALL_PREFIX}/${LOCALEDIR_REL}")
-set(GettextTranslate_ALL 1)
-set(GettextTranslate_GMO_BINARY 1)
-
-add_definitions(-DCRITERION_BUILDING_DLL=1)
-
-set(CMAKE_C_FLAGS_DEFAULT "${CMAKE_C_FLAGS}")
-set(CMAKE_CXX_FLAGS_DEFAULT "${CMAKE_CXX_FLAGS}")
-
-if (NOT MSVC)
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Werror -g -std=gnu99")
-  if (CMAKE_CXX_COMPILER_WORKS)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Werror -g ${CXX11_FLAG}")
-  endif ()
-endif ()
-
-if (MSVC)
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO")
-endif ()
-
-if (WIN32 AND NOT MSVC)
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-no-undefined")
-endif()
-
-# Compilation options
-
-option(MINGW_DEFINE_OFF_T "Define off_t and off64_t ourselves before including io.h" OFF)
-
-# Setup coveralls
-
-option(COVERALLS "Turn on coveralls support" OFF)
-option(COVERALLS_UPLOAD "Upload the generated coveralls json" ON)
-option(DEV_BUILD "Compile in developer mode" OFF)
-option(CTESTS "Turn on the samples and test" ${DEV_BUILD})
-
-if (DEV_BUILD)
-  set(ENABLE_VALGRIND_ERRORS 1)
-endif ()
+# Coverage
 
 if (COVERALLS)
   include(Coveralls)
   coveralls_turn_on_coverage()
 endif()
 
-# Find dependencies
+# I18N
 
-option(I18N "Turn on internationalization" ON)
-
-if (I18N)
-  find_package(Gettext)
-  find_package(Libintl)
-  if (GETTEXT_FOUND AND LIBINTL_LIB_FOUND)
-    include(GettextTranslate)
-    add_subdirectory(po)
-    set(ENABLE_NLS 1)
-  endif ()
+if (I18N AND GETTEXT_FOUND AND LIBINTL_LIB_FOUND)
+  include(GettextTranslate)
+  add_subdirectory(po)
 endif ()
 
-include(CheckLibraryExists)
-CHECK_LIBRARY_EXISTS(rt clock_gettime "time.h" HAVE_CLOCK_GETTIME)
-
-find_package(PCRE)
-
-# List sources and headers
-
-set(SOURCE_FILES
-  src/core/abort.c
-  src/core/abort.h
-  src/core/report.c
-  src/core/report.h
-  src/core/runner.c
-  src/core/runner.h
-  src/core/runner_coroutine.c
-  src/core/runner_coroutine.h
-  src/core/coroutine.h
-  src/core/worker.c
-  src/core/worker.h
-  src/core/stats.c
-  src/core/stats.h
-  src/core/ordered-set.c
-  src/core/test.c
-  src/compat/internal.h
-  src/compat/pipe.c
-  src/compat/pipe.h
-  src/compat/pipe-internal.h
-  src/compat/section.c
-  src/compat/section.h
-  src/compat/process.c
-  src/compat/process.h
-  src/compat/basename.c
-  src/compat/basename.h
-  src/compat/mockfile.c
-  src/compat/time.c
-  src/compat/time.h
-  src/compat/posix.h
-  src/compat/alloc.c
-  src/compat/alloc.h
-  src/compat/processor.c
-  src/compat/processor.h
-  src/io/redirect.c
-  src/io/event.c
-  src/io/event.h
-  src/io/asprintf.c
-  src/io/file.c
-  src/io/output.c
-  src/io/output.h
-  src/io/tap.c
-  src/io/xml.c
-  src/io/json.c
-  src/log/logging.c
-  src/log/normal.c
-  src/string/i18n.c
-  src/string/i18n.h
-  src/entry/options.c
-  src/entry/params.c
-  src/entry/entry.c
-  src/common.h
-  src/config.h
-)
-
-if (THEORIES)
-  set (SOURCE_FILES ${SOURCE_FILES}
-    src/core/theories.c
-  )
-endif ()
-
-if (PCRE_FOUND)
-  set (SOURCE_FILES ${SOURCE_FILES}
-    src/string/extmatch.c
-    src/string/extmatch.h
-  )
-  set(HAVE_PCRE 1)
-endif ()
-
-set(INTERFACE_FILES
-  include/criterion/assert.h
-  include/criterion/abort.h
-  include/criterion/criterion.h
-  include/criterion/event.h
-  include/criterion/hooks.h
-  include/criterion/logging.h
-  include/criterion/types.h
-  include/criterion/options.h
-  include/criterion/stats.h
-  include/criterion/alloc.h
-  include/criterion/parameterized.h
-  include/criterion/redirect.h
-  include/criterion/output.h
-  include/criterion/internal/assert.h
-  include/criterion/internal/test.h
-  include/criterion/internal/common.h
-  include/criterion/internal/ordered-set.h
-  include/criterion/internal/asprintf-compat.h
-  include/criterion/internal/designated-initializer-compat.h
-  include/criterion/internal/preprocess.h
-  include/criterion/internal/parameterized.h
-  include/criterion/internal/stdio_filebuf.hxx
-  include/criterion/internal/stream.hxx
-  include/criterion/internal/hooks.h
-  include/criterion/internal/redirect.h
-  include/criterion/internal/stdio_filebuf.hxx
-)
-
-if (THEORIES)
-  set(INTERFACE_FILES ${INTERFACE_FILES}
-    include/criterion/theories.h
-    include/criterion/internal/theories.h
-  )
-endif()
-
-# Generate the configure file
-
-configure_file(
-  "${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in"
-  "${CMAKE_CURRENT_SOURCE_DIR}/src/config.h"
-)
+# Project
 
 include_directories(include src)
-add_library(criterion SHARED ${SOURCE_FILES} ${INTERFACE_FILES})
-set_target_properties(criterion PROPERTIES
-   VERSION ${PROJECT_VERSION}
-   SOVERSION ${PROJECT_SOVERSION}
+add_subdirectory (src)
+
+cr_add_library(criterion SHARED
+    SOURCES ${SOURCE_FILES}
+    HEADERS ${INTERFACE_FILES}
+    COMPONENT dev
+    PROPERTIES
+       VERSION ${PROJECT_SONAME}
+       SOVERSION ${PROJECT_SOVERSION}
 )
 
-target_link_libraries(criterion csptr)
+cr_link_subproject(criterion csptr STATIC)
+cr_link_subproject(criterion nanomsg STATIC)
+cr_link_subproject(criterion dyncall_s STATIC)
+cr_link_subproject(criterion wingetopt STATIC)
+cr_link_subproject(criterion boxfort STATIC)
 
-if (THEORIES)
-  target_link_libraries(criterion dyncall_s)
-endif ()
+cr_link_libraries(criterion pthread IF NOT WIN32)
+cr_link_libraries(criterion rt IF HAVE_LIBRT)
 
-if (MSVC)
-  target_link_libraries(criterion wingetopt)
-endif ()
+# Required by nanomsg
+cr_link_libraries(criterion anl IF HAVE_GETADDRINFO_A)
+cr_link_libraries(criterion ws2_32 mswsock IF WIN32)
 
-if (HAVE_CLOCK_GETTIME)
-  target_link_libraries(criterion rt)
-endif()
-
-if (PCRE_FOUND)
-  target_link_libraries(criterion ${PCRE_LIBRARIES})
-endif()
-
-if (LIBINTL_LIB_FOUND)
-  target_link_libraries(criterion ${LIBINTL_LIBRARIES})
-  include_directories(${LIBINTL_INCLUDE_DIR})
-endif()
+cr_link_package(criterion LIBINTL)
 
 if (COVERALLS)
   coveralls_setup("${SOURCE_FILES}" ${COVERALLS_UPLOAD})
-endif()
 
-foreach (F ${INTERFACE_FILES})
-  get_filename_component(DEST "${F}" PATH)
-  install(FILES "${F}" DESTINATION "${DEST}" COMPONENT dev)
-endforeach ()
-
-install(TARGETS criterion
-  RUNTIME DESTINATION bin
-  LIBRARY DESTINATION lib
-  ARCHIVE DESTINATION lib COMPONENT dev
-)
-
-add_custom_target(criterion_tests)
-
-add_custom_target(gcov
+  add_custom_target(gcov
     "${CMAKE_COMMAND}"
         -DSOURCE_FILES="${SOURCE_FILES}"
         -DCOV_PATH="${CMAKE_CURRENT_BINARY_DIR}"
         -P "${CMAKE_MODULE_PATH}/Gcov.cmake"
+  )
+endif()
+
+add_custom_target(uninstall
+    "${CMAKE_COMMAND}" -P "${CMAKE_MODULE_PATH}/uninstall.cmake"
 )
 
 if (CTESTS)
-enable_testing()
-add_subdirectory(samples)
-add_subdirectory(test)
+  enable_testing()
+  add_custom_target(criterion_tests)
+  add_subdirectory(samples)
+  add_subdirectory(test)
 endif ()
 
-# Add toolchain patch number for incremental deb builds
-set(PROJECT_VERSION "${PROJECT_VERSION}-2")
-
-include (PackageConfig)
-
-option(UPLOAD_DEB "Upload package to launchpad" OFF)
-
-if (UNIX AND UPLOAD_DEB)
-  include (DebConfig)
+if (UPLOAD_DEB)
+  include (DebUpload)
 endif ()

CONTRIBUTING.md

@@ -7,18 +7,39 @@ be merged.
 
 ## General
 
-* Use 4 (four) spaces for indentation.
-* No trailing whitespaces.
-* 80 chars column limit.
+* Try to respect a 80 chars column limit. Not mandatory, but appreciated.
 * No trash files. Trash files are by-products of the compilation process, or
   generated files that does not need to be under version control.
+* Pull requests must pass the style check. See "Passing the style check" section below.
 * Pull requests must compile and work properly.
 * Pull requests must pass all tests.
-* Pull requests must be mergeable automatically.
+* Pull requests must be mergeable without conflicts.
 * Number of commits in a pull request should be kept to one commit and all
   additional commits must be squashed.
 * You may have more than one commit in a pull request if the commits are
   separate changes, otherwise squash them.
+* Keep your commit messages simple and concise. Good commit messages start
+  with a verb ('Add', 'Fix', ...).
+* Commit messages should follow the format `topic: message`, e.g. `cli: Added --foo flag`.
+  In cases where multiple topics are relevant, use a comma-separated list of topics, e.g.
+  `api,float: Fixed printf format specifiers for long double`
+
+## Passing the style check
+
+This project use an automated style checking process for pull requests defined as
+an uncrustify configuration file named `.uncrustify.cfg`.
+
+To ease the development process, a pre-commit hook is installable by running
+`.githooks/install.sh` from the project root directory. This pre-commit hook
+checks for style, outputs a diff of the changes that need to be done, and
+produces a patch to fix them automatically.
+
+As the automatic style checker is bound to have errors, parts of the code
+that make the checker fail because of their tricky grammar (e.g. Duff devices)
+may be enclosed by `/* *INDENT-OFF* */` and `/* *INDENT-ON* */` to disable
+the style checker on the region. Note that this feature should be used
+*exceptionally*, and that the maintainer will always have the last word regarding
+stylistic choices that cannot pass the style check.
 
 ## Translations
 

ChangeLog

@@ -1,3 +1,56 @@
+2018-09-18  Franklin "Snaipe" Mathieu  <franklinmathieu@gmail.com>
+
+    * criterion: version 2.3.0
+    * Addition: added German translation files (Matthias "ailu" Günzel).
+    * Addition: added a pkg-config file.
+    * Addition: allow tests to be skipped with cr_skip_test() (Matthias "ailu" Günzel).
+    * Addition: assertions on wide-strings are now available (Kevin "kevinoid" Locke).
+    * Addition: crash-mode with --crash to raise a trap when an assertion fails for debugging purposes (Matthias "ailu" Günzel).
+    * Addition: debugging mode with --debug.
+    * Addition: global test timeout with --timeout.
+    * Addition: header files in the public API now have doxygen documentation (Matthias "ailu" Günzel).
+    * Addition: test filtering now works on windows.
+    * Addition: user logging API with cr_log, cr_log_info, cr_log_warning, and cr_log_error.
+    * Breaking: dropped support for MinGW, use MinGW-w64.
+    * Breaking: dropped support for Windows XP, use Windows 7 and later.
+    * Breaking: log_pre_init and log_pre_test in the internal logger API now takes an additional parameter.
+    * Breaking: the SOVERSION now follows the SONAME major independently of the project version.
+    * Change: --pattern has been renamed to --filter.
+    * Change: removed dependency on PCRE for filtering (Matthias "ailu" Günzel).
+    * Change: sections of all loaded shared modules are now inspected for tests and hooks.
+    * Change: setting .exit_code = 0 now enforces the exit code of the test to be 0.
+    * Change: string assertions now print the contents of string parameters ("kaidowei").
+    * Change: tests are no longer executed in parallel on windows by default to mitigate a nanomsg bug (see https://github.com/Snaipe/Criterion/issues/118).
+    * Change: xml reports now includes elapsed times ("kaidowei").
+    * Deprecation: --no-early-exit is now a no-op and should no longer be used.
+    * Deprecation: internal logging API is no longer public, fallbacks to the new logging API.
+    * Fix: fail-fast now works correctly.
+    * Fix: fixed FindCriterion.cmake with the correct package name (László "MrAnno" Várady).
+    * Fix: position-independent executables now work.
+    * Fix: string assertions no longer crash with a NULL parameter ("kaidowei").
+    * Fix: the data pipe no longer gets corrupted when running a large quantity of assertions in parallel.
+    * Fix: using dmalloc on tests now works.
+    * Fix: using the GOLD linker rather than BFD now works.
+    * Fix: using the musl C library now works.
+
+2016-06-20  Franklin "Snaipe" Mathieu  <franklinmathieu@gmail.com>
+
+    * criterion: version 2.2.2
+    * Fix: fixed deadlocks when tests are terminated too fast
+    * Fix: fixed crash during test teardown if spawning new threads in the test
+    * Fix: fixed memory leak in disabled tests
+
+2016-02-06  Franklin "Snaipe" Mathieu  <franklinmathieu@gmail.com>
+
+    * criterion: version 2.2.1
+    * Fix: fixed criterion not being embeddable with CMake's `add_directory`
+    * Fix: fixed resource leaks in the child pump thread
+    * Fix: fixed redirected standard streams being leaked by cr_(assert|expect)_std(out|err)
+    * Fix: fixed out of bounds during assert message sending
+    * Fix: fixed naming convention conflicts for internal variables used by the implementation of cr_assert
+    * Fix: fixed empty format string warning with GCC 4.8
+    * Fix: fixed file-to-file comparison assert message being corrupted
+
 2015-12-08  Franklin "Snaipe" Mathieu  <franklinmathieu@gmail.com>
 
     * criterion: version 2.2.0

README.md

@@ -2,13 +2,11 @@
 <img src="doc/criterion-title.png" height="96" alt="Criterion Logo" />
 =========
 
-[![Unix Build Status](https://travis-ci.org/Snaipe/Criterion.svg?branch=bleeding)](https://travis-ci.org/Snaipe/Criterion) 
+[![Unix Build Status](https://api.travis-ci.org/Snaipe/Criterion.svg?branch=bleeding)](https://travis-ci.org/Snaipe/Criterion) 
 [![Windows Build Status](https://ci.appveyor.com/api/projects/status/github/Snaipe/Criterion?svg=true&branch=bleeding)](https://ci.appveyor.com/project/Snaipe/Criterion/branch/bleeding)
 [![Coverage Status](https://img.shields.io/codecov/c/github/Snaipe/Criterion/bleeding.svg)](https://codecov.io/github/Snaipe/Criterion?branch=bleeding) 
 [![License](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/Snaipe/Criterion/blob/master/LICENSE) 
-[![Version](https://img.shields.io/github/tag/Snaipe/Criterion.svg?label=version&style=flat)](https://github.com/Snaipe/Criterion/releases) 
-
-![Analytics](https://ga-beacon.appspot.com/UA-68371536-1/Criterion/README.md?pixel)
+[![Version](https://img.shields.io/badge/version-v2.3.0--rc1-blue.svg?style=flat)](https://github.com/Snaipe/Criterion/releases) 
 
 A dead-simple, yet extensible, C and C++ unit testing framework.
 
@@ -48,12 +46,7 @@ the user would have with other frameworks:
 
 ### Binary archives
 
-* [Linux (x86_64)](https://github.com/Snaipe/Criterion/releases/download/v2.2.0/criterion-v2.2.0-linux-x86_64.tar.bz2)
-* [OS X (x86_64)](https://github.com/Snaipe/Criterion/releases/download/v2.2.0/criterion-v2.2.0-osx-x86_64.tar.bz2)
-* [Windows (MSVC - x86_64)](https://github.com/Snaipe/Criterion/releases/download/v2.2.0/criterion-v2.2.0-windows-msvc-x86_64.tar.bz2)
-* [Windows (MinGW - x86_64)](https://github.com/Snaipe/Criterion/releases/download/v2.2.0/criterion-v2.2.0-windows-mingw-x86_64.tar.bz2)
-
-[comment]: # (Don't forget to change x86_64 to x64 on windows links on the next release)
+Binary releases are available [on the release page](https://github.com/Snaipe/Criterion/releases)
 
 If you have a different platform, you can still [build the library from source](http://criterion.readthedocs.org/en/latest/setup.html#installation)
 
@@ -77,16 +70,20 @@ Sample tests can be found in the [sample directory][samples].
 
 ### Getting help
 
-Gitter.im chat room: [![Join the chat at https://gitter.im/Snaipe/Criterion](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/Snaipe/Criterion?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)  
-IRC channel: [#criterion][irc-chan] on irc.freenode.net  
+| Channel | Description |
+| --- | --- |
+[![Subscribe to the mailing list](https://img.shields.io/badge/ml-criterion@freelists.org-46BC99.svg)][mailing-list] | Criterion mailing list on freelists.org
+[![Join the chat at https://gitter.im/Snaipe/Criterion](https://badges.gitter.im/Join%20Chat.svg)][gitter-chan] | `Snaipe/Criterion` on gitter.im
+[![Join #criterion on freenode](https://img.shields.io/badge/irc-%23criterion-46BC99.svg)][irc-chan] | `#criterion` on irc.freenode.net
 
 ### Misc
 
+* [autotools skeleton for projects with criterion tests][autotools]
 * [CMake find module for Criterion][find-module]
 
 ## Credits
 
-Logo done by [Greehm](http://www.cargocollective.com/pbouigue)
+Logo made by [Paul Bouigue](http://www.cargocollective.com/pbouigue)
 
 [online-docs]: http://criterion.readthedocs.org/
 [pdf-docs]: http://readthedocs.org/projects/criterion/downloads/pdf/latest/
@@ -101,6 +98,9 @@ Logo done by [Greehm](http://www.cargocollective.com/pbouigue)
 [sample-signal]: ./samples/signal.c
 [sample-report]: ./samples/report.c
 
+[autotools]: ./dev/autotools
 [find-module]: ./dev/FindCriterion.cmake
 
 [irc-chan]: http://webchat.freenode.net/?channels=%23criterion&uio=MTY9dHJ1ZSYyPXRydWUmOT10cnVlJjExPTE5NQ4e
+[gitter-chan]: https://gitter.im/Snaipe/Criterion?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+[mailing-list]: http://www.freelists.org/list/criterion

appveyor.yml

@@ -1,41 +1,58 @@
-version: 2.2.0_b{build}-{branch}
+version: 2.3.0-rc1_b{build}-{branch}
 
 os: Visual Studio 2015
 
-init:
-  - git config --global core.autocrlf input
-  - 'SET PATH=C:\MinGW\bin;%PATH%;C:\MinGW\msys\1.0\bin;%APPVEYOR_BUILD_FOLDER%\build;%APPVEYOR_BUILD_FOLDER%\build\Debug'
-
 environment:
   COVERALLS_REPO_TOKEN:
     secure: 5nuCg+faxFPeppoNNcSwVobswAVFUf8ut83vw8CX/4W2y0kZkGmwEfCUxSQWiQDU
   CI_NAME: appveyor
   CI_JOB_ID: $(APPVEYOR_JOB_ID)
   GCOV_PREFIX: $(APPVEYOR_BUILD_FOLDER)
+  PYTHON_BIN: python
+  PYTHONIOENCODING: "utf-8" # consider cmd encoding to be unicode
+  CRAM_SHELL: "C:\\msys64\\usr\\bin\\sh.exe"
   matrix:
   - COMPILER: mingw
     GENERATOR: "MSYS Makefiles"
-    CXXFLAGS: -D__NO_INLINE__
+    BUILD_FLAGS: -j2
   - COMPILER: msvc
-    GENERATOR: "Visual Studio 14 2015"
+    GENERATOR: "Visual Studio 14 2015 Win64"
     CFLAGS: /MP
     CXXFLAGS: /MP
+    BUILD_FLAGS: /verbosity:m
+
+init:
+  - git config --global core.autocrlf input
+  - set MSYSTEM=MINGW64
+
+  # Disable windows process crash popup
+  # See: https://msdn.microsoft.com/en-us/library/bb513638%28VS.85%29.aspx
+  - reg add "HKLM\SYSTEM\CurrentControlSet\Control\Windows" /f /v ErrorMode /t REG_DWORD /d 2
+  - reg add "HKLM\Software\Microsoft\Windows\Windows Error Reporting" /f /v DontShowUI /t REG_DWORD /d 1
+  - reg add "HKLM\Software\Microsoft\Windows\Windows Error Reporting" /f /v Disable /t REG_DWORD /d 1
+
+  - set PATH=C:\Python35;C:\Python35\Scripts;C:\msys64\mingw64\bin;C:\msys64\mingw32\bin;C:\msys64\usr\bin;%PATH%
+  - set PATH=%PATH%;%APPVEYOR_BUILD_FOLDER%\build;%APPVEYOR_BUILD_FOLDER%\build\Debug;%APPVEYOR_BUILD_FOLDER%\build\external\bin;%APPVEYOR_BUILD_FOLDER%\build\external\lib"
+  - set MSYSTEM=MINGW64
+  - pip install cram==0.7
+
+  # Remove Xamarin msbuild warnings
+  - del "C:\Program Files (x86)\MSBuild\14.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets"
 
 clone_depth: 5
 
-platform:
-  - x86
-  - x64
-
 configuration:
   - Debug
-  - Release
   - RelWithDebInfo
 
 install:
   - ps: $env:RELEASE_NAME = $env:APPVEYOR_REPO_BRANCH -replace "/", "-"
   # Hack to make git think it is on the tip of the repo branch
   - 'git checkout -B %APPVEYOR_REPO_BRANCH%'
+
+  # Patch buggy cram
+  - sh -c "patch /c/Python35/lib/site-packages/cram/_test.py .cmake/cram-env.patch"
+
   # Configure project
   - 'mkdir build && cd build'
   - >
@@ -50,7 +67,8 @@ install:
       ..
 
 build_script:
-  - cmake --build .
+  # open dummy fd 0 to prevent errors at configure time for autoconf dependencies
+  - cmake --build . -- %BUILD_FLAGS% 0<nul
 
 before_deploy:
   - ps: |
@@ -63,20 +81,14 @@ before_deploy:
 test_script:
   - cmake --build . --target criterion_tests
   - ps: |
-        ctest -j2
+        sh -c "ctest --output-on-failure --timeout 10"
         if (-not $lastexitcode -eq 0) {
-            type Testing/Temporary/LastTest.log
+            $host.setshouldexit(1)
         }
 
 #after_test:
 #  - 'make coveralls'
 
-notifications:
-
-  - provider: Email
-    to: [franklinmathieu@gmail.com]
-    on_build_status_changed: true
-
 deploy:
   provider: GitHub
   auth_token:

debian.copyright

@@ -4,7 +4,7 @@ Upstream-Contact: Franklin "Snaipe" Mathieu <franklinmathieu@gmail.com>
 Source: http://github.com/Snaipe/Criterion
 
 Files: *
-Copyright: 2015, Franklin "Snaipe" Mathieu <franklinmathieu@gmail.com>
+Copyright: 2015-2016, Franklin "Snaipe" Mathieu <franklinmathieu@gmail.com>
 License: MIT
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"), to deal

dependencies/boxfort

@@ -0,0 +1 @@
+Subproject commit 9f7ba3716c800a53639c9fe68fd453296f982c99

dependencies/debugbreak

@@ -0,0 +1 @@
+Subproject commit 6b79ec8d8f8d4603111f580a0537f8f31c484c32

dependencies/dyncall

@@ -1 +1 @@
-Subproject commit 180a5b77ff95a17991afdc6e9be3501eca99ad36
+Subproject commit 51e79a84fd91881d7424b28271c6dda4e0d97c11

dependencies/nanomsg

@@ -0,0 +1 @@
+Subproject commit 7e12a20e038234060d41d03c20721d08117f8607

dependencies/nanopb

@@ -0,0 +1 @@
+Subproject commit 56f7c488df99ae655b47b5838055e48b886665a1

dev/FindCriterion.cmake

@@ -4,9 +4,9 @@
 # - Try to find Criterion
 #
 # Once done this will define
-#  CRITERION_FOUND - System has LibXml2
-#  CRITERION_INCLUDE_DIRS - The LibXml2 include directories
-#  CRITERION_LIBRARIES - The libraries needed to use LibXml2
+#  CRITERION_FOUND - System has Criterion
+#  CRITERION_INCLUDE_DIRS - The Criterion include directories
+#  CRITERION_LIBRARIES - The libraries needed to use Criterion
 
 find_package(PkgConfig)
 
@@ -19,9 +19,9 @@ set(CRITERION_LIBRARIES ${CRITERION_LIBRARY})
 set(CRITERION_INCLUDE_DIRS ${CRITERION_INCLUDE_DIR})
 
 include(FindPackageHandleStandardArgs)
-# handle the QUIETLY and REQUIRED arguments and set CRITERION_FOUND to TRUE
+# handle the QUIET and REQUIRED arguments and set CRITERION_FOUND to TRUE
 # if all listed variables are TRUE
-find_package_handle_standard_args(LibXml2 DEFAULT_MSG
+find_package_handle_standard_args(Criterion DEFAULT_MSG
                                   CRITERION_LIBRARY CRITERION_INCLUDE_DIR)
 
 mark_as_advanced(CRITERION_INCLUDE_DIR CRITERION_LIBRARY)

dev/autotools/Makefile.am

@@ -0,0 +1,14 @@
+# use the provided wrapper script to output things properly
+LOG_COMPILER = $(top_srcdir)/build-aux/criterion-tap-test
+
+# use the TAP log driver
+LOG_DRIVER = env AM_TAP_AWK='$(AWK)' $(SHELL) \
+            $(top_srcdir)/build-aux/tap-driver.sh
+
+check_PROGRAMS = criterion_tests
+
+criterion_tests_SOURCES = simple.c
+criterion_tests_LDFLAGS = -lcriterion
+
+TESTS = criterion_tests
+EXTRA_DIST = $(TESTS)

dev/autotools/README.md

@@ -0,0 +1,27 @@
+# Autotools skeleton
+
+This is a project skeleton that uses criterion tests with the TAP test driver.
+
+## Running the tests
+
+The default setup assumes that criterion is installed on your system.
+
+```
+$ ./autogen.sh
+$ mkdir build && cd build
+$ ../configure
+$ make check
+```
+
+## License
+
+The project skeleton is licensed under the [wtfpl](http://www.wtfpl.net). Do
+whatever you want with it.
+
+### License clause
+
+This program is free software. It comes without any warranty, to
+the extent permitted by applicable law. You can redistribute it
+and/or modify it under the terms of the Do What The Fuck You Want
+To Public License, Version 2, as published by Sam Hocevar. See
+http://www.wtfpl.net/ for more details.

dev/autotools/autogen.sh

@@ -0,0 +1,17 @@
+#!/bin/sh -e
+
+# copy TAP driver into build-aux
+automake_ver=$(automake --version | \grep -E -o '[0-9]\.[0-9]{2}')
+
+mkdir -p build-aux
+cp -f /usr/share/automake-$automake_ver/tap-driver.sh build-aux
+
+# create criterion TAP log compiler
+# this is necessary to print TAP (and only TAP) on the standard output,
+# and always exit with 0 to let the TAP driver handle errors itself.
+echo >build-aux/criterion-tap-test """#!/bin/sh
+\$1 -Otap:- --always-succeed 2>&1 >/dev/null
+"""
+chmod +x build-aux/criterion-tap-test
+
+autoreconf -vi

dev/autotools/configure.ac

@@ -0,0 +1,15 @@
+AC_INIT([Criterion Autotools Tests], [1.0], [your@email.com])
+AC_CONFIG_AUX_DIR([build-aux])
+AM_INIT_AUTOMAKE([foreign -Wall -Werror])
+
+AC_CHECK_LIB([criterion], [criterion_initialize], [], [
+  AC_MSG_ERROR([unable to find Criterion])
+], [])
+
+AC_PROG_AWK
+AC_PROG_CC
+
+AC_CONFIG_FILES([Makefile])
+
+AC_REQUIRE_AUX_FILE([tap-driver.sh])
+AC_OUTPUT

dev/autotools/simple.c

@@ -0,0 +1,9 @@
+#include <criterion/criterion.h>
+
+Test(misc, failing) {
+    cr_assert(0);
+}
+
+Test(misc, passing) {
+    cr_assert(1);
+}

doc/_static/style.css

@@ -0,0 +1,25 @@
+.breatheparameterlist li p {
+    display: inline;
+}
+
+.breatheenumvalues li p {
+    display: inline;
+}
+
+.container > dl > dt {
+    display: block;
+    width: 100%;
+    clear: both;
+}
+
+.container > dl > dt:before {
+    content: " ▼ ";
+}
+
+.container > dl > dt.open:before {
+    content: " ▶ ";
+}
+
+.container > dl {
+    margin-bottom: 0 !important; /* Dirty hack */
+}

doc/_templates/page.html

@@ -0,0 +1,17 @@
+{% extends "!page.html" %}
+
+{% set css_files = css_files + ["_static/style.css"] %}
+
+
+{% block footer %}
+ <script type="text/javascript">
+    $(document).ready(function() {
+        $(".container > dl > *").hide();
+        $(".container > dl > dt").show();
+        $(".container > dl > dt").click(function() {
+            $(this).parent().children().not("dt").toggle(400);
+            $(this).parent().children("dt").toggleClass("open");
+        })
+    });
+</script>
+{% endblock %}

doc/assert.rst

@@ -12,136 +12,40 @@ macros to this list. Hence only ``assert`` macros are represented here.
 All ``assert`` macros may take an optional ``printf`` format string and
 parameters.
 
+Base Assertions
+-----------------
+
+.. doxygengroup:: BaseAsserts
+
 Common Assertions
 -----------------
 
-=========================================================================== =========================================================================== ===========================================
-Macro                                                                        Passes if and only if                                                       Notes
-=========================================================================== =========================================================================== ===========================================
-cr_assert(Condition, [FormatString, [Args...]])                              ``Condition`` is true.
---------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_not(Condition, [FormatString, [Args...]])                          ``Condition`` is false.
---------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_null(Value, [FormatString, [Args...]])                             ``Value`` is ``NULL``.
---------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_not_null(Value, [FormatString, [Args...]])                         ``Value`` is not ``NULL``.
---------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_eq(Actual, Expected, [FormatString, [Args...]])                    ``Actual`` is equal to ``Expected``.                                        Compatible with C++ operator overloading
---------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_neq(Actual, Unexpected, [FormatString, [Args...]])                 ``Actual`` is not equal to ``Unexpected``.                                  Compatible with C++ operator overloading
---------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_lt(Actual, Reference, [FormatString, [Args...]])                   ``Actual`` is less than ``Reference``.                                      Compatible with C++ operator overloading
---------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_leq(Actual, Reference, [FormatString, [Args...]])                  ``Actual`` is less or equal to ``Reference``.                               Compatible with C++ operator overloading
---------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_gt(Actual, Reference, [FormatString, [Args...]])                   ``Actual`` is greater than ``Reference``.                                   Compatible with C++ operator overloading
---------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_geq(Actual, Reference, [FormatString, [Args...]])                  ``Actual`` is greater or equal to ``Reference``.                            Compatible with C++ operator overloading
---------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_float_eq(Actual, Expected, Epsilon, [FormatString, [Args...]])     ``Actual`` is equal to ``Expected`` with a tolerance of ``Epsilon``.        Use this to test equality between floats
---------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_float_neq(Actual, Unexpected, Epsilon, [FormatString, [Args...]])  ``Actual`` is not equal to ``Unexpected`` with a tolerance of ``Epsilon``.  Use this to test inequality between floats
-=========================================================================== =========================================================================== ===========================================
+.. doxygengroup:: CommonBinAsserts
+.. doxygengroup:: CommonUnaryAsserts
+.. doxygengroup:: FloatAsserts
 
 String Assertions
 -----------------
 
-Note: these macros are meant to deal with *native* strings, i.e. char arrays.
-Most of them won't work on ``std::string`` in C++, with some exceptions -- for
-``std::string``, you should use regular comparison assersions, as listed above.
+.. doxygengroup:: StringAsserts
 
-================================================================ =================================================================== ===========================================
-Macro                                                            Passes if and only if                                               Notes
-================================================================ =================================================================== ===========================================
-cr_assert_str_empty(Value, [FormatString, [Args...]])            ``Value`` is an empty string.                                       Also works on std::string
----------------------------------------------------------------- ------------------------------------------------------------------- -------------------------------------------
-cr_assert_str_not_empty(Value, [FormatString, [Args...]])        ``Value`` is not an empty string.                                   Also works on std::string
----------------------------------------------------------------- ------------------------------------------------------------------- -------------------------------------------
-cr_assert_str_eq(Actual, Expected, [FormatString, [Args...]])    ``Actual`` is lexicographically equal to ``Expected``.
----------------------------------------------------------------- ------------------------------------------------------------------- -------------------------------------------
-cr_assert_str_neq(Actual, Unexpected, [FormatString, [Args...]]) ``Actual`` is not lexicographically equal to ``Unexpected``.
----------------------------------------------------------------- ------------------------------------------------------------------- -------------------------------------------
-cr_assert_str_lt(Actual, Reference, [FormatString, [Args...]])   ``Actual`` is lexicographically less than ``Reference``.
----------------------------------------------------------------- ------------------------------------------------------------------- -------------------------------------------
-cr_assert_str_leq(Actual, Reference, [FormatString, [Args...]])  ``Actual`` is lexicographically less or equal to ``Reference``.
----------------------------------------------------------------- ------------------------------------------------------------------- -------------------------------------------
-cr_assert_str_gt(Actual, Reference, [FormatString, [Args...]])   ``Actual`` is lexicographically greater than ``Reference``.
----------------------------------------------------------------- ------------------------------------------------------------------- -------------------------------------------
-cr_assert_str_geq(Actual, Reference, [FormatString, [Args...]])  ``Actual`` is lexicographically greater or equal to ``Reference``.
-================================================================ =================================================================== ===========================================
+Wide String Assertions
+----------------------
+
+.. doxygengroup:: WideStringAsserts
 
 Array Assertions
 -----------------
 
-=============================================================================== =========================================================================== ===========================================
-Macro                                                                            Passes if and only if                                                       Notes
-=============================================================================== =========================================================================== ===========================================
-cr_assert_arr_eq(Actual, Expected, [FormatString, [Args...]])                    ``Actual`` is byte-to-byte equal to ``Expected``.                           This should not be used on struct arrays,
-                                                                                                                                                             consider using ``cr_assert_arr_eq_cmp``
-                                                                                                                                                             instead.
-------------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_arr_neq(Actual, Unexpected, [FormatString, [Args...]])                 ``Actual`` is not byte-to-byte equal to ``Unexpected``.                     This should not be used on struct arrays,
-                                                                                                                                                             consider using ``cr_assert_arr_neq_cmp``
-                                                                                                                                                             instead.
-------------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_arr_eq_cmp(Actual, Expected, Size, Cmp, [FormatString, [Args...]])     ``Actual`` is comparatively equal to ``Expected``                           Only available in C++ and GNU C99
-------------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_arr_neq_cmp(Actual, Unexpected, Size, Cmp, [FormatString, [Args...]])  ``Actual`` is not comparatively equal to ``Expected``                       Only available in C++ and GNU C99
-------------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_arr_lt_cmp(Actual, Reference, Size, Cmp, [FormatString, [Args...]])    ``Actual`` is comparatively less than ``Reference``                         Only available in C++ and GNU C99
-------------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_arr_leq_cmp(Actual, Reference, Size, Cmp, [FormatString, [Args...]])   ``Actual`` is comparatively less or equal to ``Reference``                  Only available in C++ and GNU C99
-------------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_arr_gt_cmp(Actual, Reference, Size, Cmp, [FormatString, [Args...]])    ``Actual`` is comparatively greater than ``Reference``                      Only available in C++ and GNU C99
-------------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_arr_geq_cmp(Actual, Reference, Size, Cmp, [FormatString, [Args...]])   ``Actual`` is comparatively greater or equal to ``Reference``               Only available in C++ and GNU C99
-=============================================================================== =========================================================================== ===========================================
+.. doxygengroup:: ArrayAsserts
+.. doxygengroup:: SafeArrCmpAsserts
 
 Exception Assertions
 --------------------
 
-The following assertion macros are only defined for C++.
-
-=============================================================================== =========================================================================== ===========================================
-Macro                                                                           Passes if and only if                                                       Notes
-=============================================================================== =========================================================================== ===========================================
-cr_assert_throw(Statement, Exception, [FormatString, [Args...]])                ``Statement`` throws an instance of ``Exception``.
-------------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_no_throw(Statement, Exception, [FormatString, [Args...]])             ``Statement`` does not throws an instance of ``Exception``.
-------------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_any_throw(Statement, [FormatString, [Args...]])                       ``Statement`` throws any kind of exception.
-------------------------------------------------------------------------------- --------------------------------------------------------------------------- -------------------------------------------
-cr_assert_none_throw(Statement, [FormatString, [Args...]])                      ``Statement`` does not throw any exception.
-=============================================================================== =========================================================================== ===========================================
+.. doxygengroup:: ExceptionAsserts
 
 File Assertions
 ---------------
 
-=================================================================================== ============================================================================ ===========================================
-Macro                                                                               Passes if and only if                                                        Notes
-=================================================================================== ============================================================================ ===========================================
-cr_assert_file_contents_eq_str(File, ExpectedContents, [FormatString, [Args...]])   The contents of ``File`` are equal to the string ``ExpectedContents``.
------------------------------------------------------------------------------------ ---------------------------------------------------------------------------- -------------------------------------------
-cr_assert_file_contents_neq_str(File, ExpectedContents, [FormatString, [Args...]])  The contents of ``File`` are not equal to the string ``ExpectedContents``.
------------------------------------------------------------------------------------ ---------------------------------------------------------------------------- -------------------------------------------
-cr_assert_stdout_eq_str(ExpectedContents, [FormatString, [Args...]])                The contents of ``stdout`` are equal to the string ``ExpectedContents``.
------------------------------------------------------------------------------------ ---------------------------------------------------------------------------- -------------------------------------------
-cr_assert_stdout_neq_str(ExpectedContents, [FormatString, [Args...]])               The contents of ``stdout`` are not equal to the string ``ExpectedContents``.
------------------------------------------------------------------------------------ ---------------------------------------------------------------------------- -------------------------------------------
-cr_assert_stderr_eq_str(ExpectedContents, [FormatString, [Args...]])                The contents of ``stderr`` are equal to the string ``ExpectedContents``.
------------------------------------------------------------------------------------ ---------------------------------------------------------------------------- -------------------------------------------
-cr_assert_stderr_neq_str(ExpectedContents, [FormatString, [Args...]])               The contents of ``stderr`` are not equal to the string ``ExpectedContents``.
------------------------------------------------------------------------------------ ---------------------------------------------------------------------------- -------------------------------------------
-cr_assert_file_contents_eq(File, RefFile, [FormatString, [Args...]])                The contents of ``File`` are equal to the contents of ``RefFile``.
------------------------------------------------------------------------------------ ---------------------------------------------------------------------------- -------------------------------------------
-cr_assert_file_contents_neq(File, RefFile, [FormatString, [Args...]])               The contents of ``File`` are not equal to the contents of ``RefFile``.
------------------------------------------------------------------------------------ ---------------------------------------------------------------------------- -------------------------------------------
-cr_assert_stdout_eq(RefFile, [FormatString, [Args...]])                             The contents of ``stdout`` are equal to the contents of ``RefFile``.
------------------------------------------------------------------------------------ ---------------------------------------------------------------------------- -------------------------------------------
-cr_assert_stdout_neq(RefFile, [FormatString, [Args...]])                            The contents of ``stdout`` are not equal to the contents of ``RefFile``.
------------------------------------------------------------------------------------ ---------------------------------------------------------------------------- -------------------------------------------
-cr_assert_stderr_eq(RefFile, [FormatString, [Args...]])                             The contents of ``stderr`` are equal to the contents of ``RefFile``.
------------------------------------------------------------------------------------ ---------------------------------------------------------------------------- -------------------------------------------
-cr_assert_stderr_neq(RefFile, [FormatString, [Args...]])                            The contents of ``stderr`` are not equal to the contents of ``RefFile``.
-=================================================================================== ============================================================================ ===========================================
-
+.. doxygengroup:: FileAsserts

doc/conf.py

@@ -13,10 +13,25 @@ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "_ext"))
 # If your documentation needs a minimal Sphinx version, state it here.
 #needs_sphinx = '1.0'
 
+# hack for readthedocs to cause it to run doxygen first
+# https://github.com/rtfd/readthedocs.org/issues/388
+on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
+if on_rtd:
+  from subprocess import call
+  call('doxygen')
+
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = []
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.todo',
+    'sphinx.ext.viewcode',
+    'breathe',
+]
+
+breathe_projects = { "criterion-doxygen": "doxyxml/" }
+breathe_default_project = "criterion-doxygen"
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@@ -32,14 +47,14 @@ master_doc = 'index'
 
 # General information about the project.
 project = u'Criterion'
-copyright = u'2015, Franklin "Snaipe" Mathieu'
+copyright = u'2015-2016, Franklin "Snaipe" Mathieu'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
 # built documents.
 #
 # The short X.Y version.
-version = '2.2.0'
+version = '2.3.0-rc1'
 # The full version, including alpha/beta/rc tags.
 release = version
 

doc/debug.rst

@@ -0,0 +1,61 @@
+Debugging and Coverage information
+==================================
+
+.. _gdb-ref:
+
+
+Debugging with GDB
+------------------
+
+In one terminal do:
+
+.. code-block:: bash
+
+    $ ./simple.c.bin --debug
+    Process simple.c.bin created; pid = 20803
+    Listening on port 1234
+
+In another terminal connect to this debug session:
+
+.. code-block:: bash
+
+    $ gdb -q ./test
+    Reading symbols from ./test...done.
+    (gdb) target remote localhost:1234
+    Remote debugging using localhost:1234
+    0x00007ffff7dd9d90 in _start() from target:/lib64/ld-linux-x86-64.so.2
+    (gdb) continue
+    ...
+    [Inferior 1 (process 25269) exited normally]
+    (gdb) q
+
+After ``continue`` the first test is run:
+
+.. code-block:: bash
+
+    Remote debugging from host 127.0.0.1
+    [RUN ] misc::failing
+    [----] /media/data/devel/Criterion/samples/simple.c:4: Assertion failed: The expression 0 is false.
+    [FAIL] misc::failing: (0,00s)
+
+    Child exited with status 0
+
+And a new process is created for the next test:
+
+.. code-block:: bash
+
+    Process /media/data/devel/Criterion/build/samples/simple.c.bin created; pid = 26414
+    Listening on port 1234
+
+Connect your remote debugger to this test with ``remote target localhost:1234``
+and run the test with ``continue``
+
+To use a different port use ``--debug --debug-transport=<protocol>:<port>``
+
+.. _coverage-ref:
+
+Coverage of Criterion tests
+---------------------------
+
+To use gcov, you have to compile your tests with the two GCC Options
+``-fprofile-arcs`` and ``–ftest-coverage``.

doc/env.rst

@@ -16,11 +16,14 @@ Command line arguments
 * ``--ascii``: Don't use fancy unicode symbols or colors in the output.
 * ``-jN or --jobs N``: Use ``N`` parallel jobs to run the tests. ``0`` picks
   a number of jobs ideal for your hardware configuration.
-* ``--pattern [PATTERN]``: Run tests whose string identifier matches
+* ``--filter [PATTERN]``: Run tests whose string identifier matches
   the given shell wildcard pattern (see dedicated section below). (\*nix only)
-* ``--no-early-exit``: The test workers shall not prematurely exit when done and
-  will properly return from the main, cleaning up their process space.
-  This is useful when tracking memory leaks with ``valgrind --tool=memcheck``.
+* ``--debug[=debugger]``: Run tests with a debugging server attached.
+  ``debugger`` can be 'gdb', 'lldb', or 'windbg' (windows only).
+* ``--debug-transport [TRANSPORT]``: Make the debugging server use the
+  specified remote transport. Only transports of the form ``tcp:port`` are
+  currently supported. ``tcp:1234`` is the default.
+* ``--no-early-exit``: This flag is deprecated and no longer does anything.
 * ``-S or --short-filename``: The filenames are displayed in their short form.
 * ``--always-succeed``: The process shall exit with a status of ``0``.
 * ``--tap[=FILE]``: Writes a TAP (Test Anything Protocol) report to FILE.
@@ -43,7 +46,6 @@ Shell Wildcard Pattern
 ----------------------
 
 Extglob patterns in criterion are matched against a test's string identifier.
-This feature is only available on \*nix systems where ``PCRE`` is provided.
 
 In the table below, a ``pattern-list`` is a list of patterns separated by ``|``.
 Any extglob pattern can be constructed by combining any of the following
@@ -82,7 +84,6 @@ Environment Variables
 Environment variables are alternatives to command line switches when set to 1.
 
 * ``CRITERION_ALWAYS_SUCCEED``:  Same as ``--always-succeed``.
-* ``CRITERION_NO_EARLY_EXIT``:   Same as ``--no-early-exit``.
 * ``CRITERION_FAIL_FAST``:       Same as ``--fail-fast``.
 * ``CRITERION_USE_ASCII``:       Same as ``--ascii``.
 * ``CRITERION_JOBS``:            Same as ``--jobs``. Sets the number of jobs to

doc/hooks.rst

@@ -17,9 +17,17 @@ A report hook can be declared using the ``ReportHook`` macro:
 The macro takes a Phase parameter that indicates the phase at which the function
 shall be run. Valid phases are described below.
 
-**Note**: there are no guarantees regarding the order of execution of report hooks
-on the same phase. In other words, all report hooks of a specific phase could
-be executed in any order.
+.. note::
+
+    There are no guarantees regarding the order of execution of report hooks
+    on the same phase. In other words, all report hooks of a specific phase could
+    be executed in any order.
+
+.. note::
+
+    Aborting the runner with any means (abort(), exit(), cr_assert(), ...) is
+    unsupported. If you need to abort the runner, you need to iterate all
+    subsequent tests and set their `disabled` field to 1.
 
 Testing Phases
 --------------

doc/index.rst

@@ -9,9 +9,11 @@ Criterion
     starter
     assert
     hooks
+    logging
     env
     output
     parameterized
     theories
     internal
+    debug
     faq

doc/internal.rst

@@ -30,8 +30,6 @@ logging_threshold   enum criterion_logging_level       The logging level
 ------------------- ---------------------------------- --------------------------------------------------------------
 logger              struct criterion_logger *          The logger (see below)
 ------------------- ---------------------------------- --------------------------------------------------------------
-no_early_exit       bool                               True iff the test worker should exit early
-------------------- ---------------------------------- --------------------------------------------------------------
 always_succeed      bool                               True iff criterion_run_all_tests should always returns 1
 ------------------- ---------------------------------- --------------------------------------------------------------
 use_ascii           bool                               True iff the outputs should use the ASCII charset
@@ -68,9 +66,9 @@ Example main
 
         int result = 0;
         if (criterion_handle_args(argc, argv, true))
-            result = !criterion_run_all_tests(set);
+            result = !criterion_run_all_tests(tests);
 
-        criterion_finalize(set);
+        criterion_finalize(tests);
         return result;
     }
 

doc/logging.rst

@@ -0,0 +1,61 @@
+Logging messages
+================
+
+Sometimes, it might be useful to print some output from within a test
+or fixture -- and while this can be done trivially with a ``printf``,
+it doesn't integrate well with the current output, nor does it work
+*at all* when the process is testing a redirected stdout.
+
+For these cases, Criterion exposes a logging facility:
+
+.. code-block:: c
+
+    #include <criterion/criterion.h>
+    #include <criterion/logging.h>
+
+    Test(suite_name, test_name) {
+        cr_log_info("This is an informational message. They are not displayed "
+            "by default.");
+        cr_log_warn("This is a warning. They indicate some possible malfunction "
+            "or misconfiguration in the test.");
+        cr_log_error("This is an error. They indicate serious problems and "
+            "are usually shown before the test is aborted.");
+    }
+
+``cr_log_info``, ``cr_log_warn`` and ``cr_log_error`` are all macros expanding
+to a call to the ``cr_log`` function. All of them take a mandatory format string,
+followed by optional parameters; for instance:
+
+.. code-block:: c
+
+    cr_log_info("%d + %d = %d", 1, 2, 3);
+
+If using C++, the output stream objects ``info``, ``warn`` and ``error`` are
+defined within the ``criterion::logging`` namespace, and can be used in
+conjunction with ``operator<<``:
+
+.. code-block:: c++
+
+    #include <criterion/criterion.h>
+    #include <criterion/logging.h>
+
+    using criterion::logging::info;
+    using criterion::logging::warn;
+    using criterion::logging::error;
+
+    Test(suite_name, test_name) {
+        info << "This is an informational message. "
+             << "They are not displayed by default."
+             << std::flush;
+        warn << "This is a warning. "
+             << "They indicate some possible malfunction "
+             << "or misconfiguration in the test."
+             << std::flush;
+        error << "This is an error. "
+             << "They indicate serious problems and "
+             << "are usually shown before the test is aborted."
+             << std::flush;
+    }
+
+Note that empty messages are ignored, and newlines in the log message splits
+the passed string into as many messages are there are lines.

doc/parameterized.rst

@@ -14,6 +14,8 @@ Adding parameterized tests
 Adding parameterized tests is done by defining the parameterized test function,
 and the parameter generator function:
 
+.. doxygengroup:: ParameterizedBase
+
 .. code-block:: c
 
     #include <criterion/parameterized.h>
@@ -37,6 +39,10 @@ identifier format.
 ``Type`` is the compound type of the generated array. ``params`` and ``nb_params``
 are the pointer and the length of the generated array, respectively.
 
+.. note::
+    The parameter array must be reachable after the function returns -- as
+    such, local arrays must be declared with `static` or dynamically allocated.
+
 Passing multiple parameters
 ---------------------------
 
@@ -55,7 +61,7 @@ easily use a struct to hold the context as a workaround:
     };
 
     ParameterizedTestParameters(suite_name, test_name) {
-        struct my_params params[] = {
+        static struct my_params params[] = {
             // parameter set
         };
 
@@ -72,7 +78,7 @@ C++ users can also use a simpler syntax before returning an array of parameters:
 .. code-block:: c++
 
     ParameterizedTestParameters(suite_name, test_name) {
-        struct my_params params[] = {
+        static struct my_params params[] = {
             // parameter set
         };
 

doc/requirements.txt

@@ -0,0 +1 @@
+breathe

doc/starter.rst

@@ -6,6 +6,10 @@ Adding tests
 
 Adding tests is done using the ``Test`` macro:
 
+.. doxygendefine:: Test
+
+Example:
+
 .. code-block:: c
 
     #include <criterion/criterion.h>
@@ -147,21 +151,8 @@ Configuration reference
 Here is an exhaustive list of all possible configuration parameters you can
 pass:
 
-============= =============== ==============================================================
-Parameter     Type            Description
-============= =============== ==============================================================
-.description  const char *    Adds a description. Cannot be ``NULL``.
-------------- --------------- --------------------------------------------------------------
-.init         void (*)(void)  Adds a setup function the be executed before the test.
-------------- --------------- --------------------------------------------------------------
-.fini         void (*)(void)  Adds a teardown function the be executed after the test.
-------------- --------------- --------------------------------------------------------------
-.disabled     bool            Disables the test.
-------------- --------------- --------------------------------------------------------------
-.signal       int             Expect the test to raise the specified signal.
-------------- --------------- --------------------------------------------------------------
-.exit_code    int             Expect the test to exit with the specified status.
-============= =============== ==============================================================
+.. doxygenstruct:: criterion_test_extra_data
+    :members:
 
 Setting up suite-wise configuration
 -----------------------------------
@@ -169,6 +160,10 @@ Setting up suite-wise configuration
 Tests under the same suite can have a suite-wise configuration -- this is done
 using the ``TestSuite`` macro:
 
+.. doxygendefine:: TestSuite
+
+Example:
+
 .. code-block:: c
 
     #include <criterion/criterion.h>

doc/theories.rst

@@ -10,6 +10,8 @@ parameters known as "data points".
 Adding theories
 ---------------
 
+.. doxygengroup:: TheoryBase
+
 Adding theories is done by defining data points and a theory function:
 
 .. code-block:: c
@@ -53,53 +55,7 @@ making the test fail.
 
 On top of those, more ``assume`` macro functions are available for common operations:
 
-======================================================= ====================================================
-Macro                                                   Description
-======================================================= ====================================================
-``cr_assume_not(Condition)``                            Assumes Condition is false.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_null(Ptr)``                                 Assumes Ptr is NULL.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_not_null(Ptr)``                             Assumes Ptr is not NULL.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_eq(Actual, Expected)``                      Assumes Actual == Expected.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_neq(Actual, Unexpected)``                   Assumes Actual != Expected.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_lt(Actual, Expected)``                      Assumes Actual < Expected.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_leq(Actual, Expected)``                     Assumes Actual <= Expected.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_gt(Actual, Expected)``                      Assumes Actual > Expected.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_geq(Actual, Expected)``                     Assumes Actual >= Expected.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_float_eq(Actual, Expected, Epsilon)``       Assumes Actual == Expected with an error of Epsilon.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_float_neq(Actual, Unexpected, Epsilon)``    Assumes Actual != Expected with an error of Epsilon.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_str_eq(Actual, Expected)``                  Assumes Actual and Expected are the same string.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_str_neq(Actual, Unexpected)``               Assumes Actual and Expected are not the same string.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_str_lt(Actual, Expected)``                  Assumes Actual is less than Expected
-                                                        lexicographically.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_str_leq(Actual, Expected)``                 Assumes Actual is less or equal to Expected
-                                                        lexicographically.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_str_gt(Actual, Expected)``                  Assumes Actual is greater than Expected
-                                                        lexicographically.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_str_geq(Actual, Expected)``                 Assumes Actual is greater or equal to Expected
-                                                        lexicographically.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_arr_eq(Actual, Expected, Size)``            Assumes all elements of Actual (from 0 to Size - 1)
-                                                        are equals to those of Expected.
-------------------------------------------------------- ----------------------------------------------------
-``cr_assume_arr_neq(Actual, Unexpected, Size)``         Assumes one or more elements of Actual (from 0 to
-                                                        Size - 1) differs from their counterpart in Expected.
-======================================================= ====================================================
+.. doxygengroup:: TheoryInvariants
 
 Configuring theories
 --------------------

include/criterion/abort.h

@@ -21,10 +21,14 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/**
+ * @file
+ * @brief Functions to abort and continue tests
+ *****************************************************************************/
 #ifndef CRITERION_ABORT_H_
-# define CRITERION_ABORT_H_
+#define CRITERION_ABORT_H_
 
-# include "internal/common.h"
+#include "internal/common.h"
 
 CR_BEGIN_C_API
 
@@ -35,13 +39,26 @@ CR_BEGIN_C_API
  */
 CR_API CR_NORETURN void criterion_abort_test(void);
 
+/**
+ *  Aborts the current test, marking it as skipped.
+ *
+ *  This function does not return.
+ */
+CR_API CR_NORETURN void criterion_skip_test(const char *format, ...);
+
 /**
  *  Continues the current test.
  *
  *  Used as a counterpart to criterion_abort_test.
  */
-CR_INLINE static void criterion_continue_test(void) {}
+CR_API void criterion_continue_test(void);
 
+/**
+ *  Kills the current test, marking it as failed.
+ *
+ *  @param[in] msg printf like format string
+ *  @param[in] ... Additional arguments depending on msg
+ */
 CR_API void criterion_test_die(const char *msg, ...);
 
 CR_END_C_API

include/criterion/alloc.h

@@ -21,17 +21,21 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/**
+ * @file
+ * @brief Test intern memory managment
+ *****************************************************************************/
 #ifndef CRITERION_ALLOC_H_
-# define CRITERION_ALLOC_H_
+#define CRITERION_ALLOC_H_
 
-# ifdef __cplusplus
-#  include <memory>
-#  include <cstddef>
+#ifdef __cplusplus
+# include <memory>
+# include <cstddef>
 using std::size_t;
-# else
-#  include <stddef.h>
-# endif
-# include "internal/common.h"
+#else
+# include <stddef.h>
+#endif
+#include "internal/common.h"
 
 CR_BEGIN_C_API
 
@@ -88,177 +92,187 @@ CR_API void cr_free(void *ptr);
 
 CR_END_C_API
 
-# ifdef __cplusplus
-#  include <type_traits>
+#ifdef __cplusplus
+# include <type_traits>
 
-namespace criterion {
+namespace criterion
+{
+void *(*const malloc)(size_t)           = cr_malloc;
+void(*const free)(void *)              = cr_free;
+void *(*const calloc)(size_t, size_t)   = cr_calloc;
+void *(*const realloc)(void *, size_t)  = cr_realloc;
 
-    void *(*const malloc)(size_t)           = cr_malloc;
-    void (*const free)(void *)              = cr_free;
-    void *(*const calloc)(size_t, size_t)   = cr_calloc;
-    void *(*const realloc)(void *, size_t)  = cr_realloc;
+/**
+ *  Allocates and construct a new object.
+ *
+ *  It is undefined behaviour to access a pointer returned by the new
+ *  operator inside a test or its setup and teardown functions;
+ *  new_obj must be used in its place for this purpose.
+ *
+ *  This function is semantically identical to the new operator.
+ *
+ *  @tparam T The type of the object to construct
+ *  @param[in] params The constructor parameters of T.
+ *  @returns The pointer to the newly constructed object.
+ */
+template <typename T, typename... Params>
+T *new_obj(Params... params)
+{
+    T *obj = static_cast<T *>(cr_malloc(sizeof (T)));
 
-    /**
-     *  Allocates and construct a new object.
-     *
-     *  It is undefined behaviour to access a pointer returned by the new
-     *  operator inside a test or its setup and teardown functions;
-     *  new_obj must be used in its place for this purpose.
-     *
-     *  This function is semantically identical to the new operator.
-     *
-     *  @tparam T The type of the object to construct
-     *  @param[in] params The constructor parameters of T.
-     *  @returns The pointer to the newly constructed object.
-     */
-    template<typename T, typename... Params>
-    T* new_obj(Params... params) {
-        T* obj = static_cast<T*>(cr_malloc(sizeof (T)));
-        new (obj) T(params...);
-        return obj;
-    }
+    new (obj) T(params...);
+    return obj;
+}
 
-    /**
-     *  Allocates and construct a new array of primitive types
-     *
-     *  It is undefined behaviour to access a pointer returned by the new[]
-     *  operator inside a test or its setup and teardown functions;
-     *  new_arr must be used in its place for this purpose.
-     *
-     *  This function is semantically identical to the new[] operator.
-     *
-     *  @tparam T The compound type of the array to construct
-     *  @param[in] len The length of the array.
-     *  @returns The pointer to the newly constructed array.
-     */
-    template<typename T>
-    typename std::enable_if<std::is_fundamental<T>::value>::type*
-    new_arr(size_t len) {
-        void *ptr = cr_malloc(sizeof (size_t) + sizeof (T) * len);
-        *(reinterpret_cast<size_t*>(ptr)) = len;
-        T* arr = reinterpret_cast<T*>(reinterpret_cast<size_t*>(ptr) + 1);
-        return arr;
-    }
+/**
+ *  Allocates and construct a new array of primitive types
+ *
+ *  It is undefined behaviour to access a pointer returned by the new[]
+ *  operator inside a test or its setup and teardown functions;
+ *  new_arr must be used in its place for this purpose.
+ *
+ *  This function is semantically identical to the new[] operator.
+ *
+ *  @tparam T The compound type of the array to construct
+ *  @param[in] len The length of the array.
+ *  @returns The pointer to the newly constructed array.
+ */
+template <typename T>
+typename std::enable_if<std::is_fundamental<T>::value>::type
+* new_arr(size_t len) {
+    void *ptr = cr_malloc(sizeof (size_t) + sizeof (T) * len);
 
-    /**
-     *  Allocates and construct a new array of object types
-     *
-     *  It is undefined behaviour to access a pointer returned by the new[]
-     *  operator inside a test or its setup and teardown functions;
-     *  new_arr must be used in its place for this purpose.
-     *
-     *  This function is semantically identical to the new[] operator.
-     *
-     *  @tparam T The compound type of the array to construct
-     *  @param[in] len The length of the array.
-     *  @returns The pointer to the newly constructed array.
-     */
-    template<typename T>
-    T* new_arr(size_t len) {
-        void *ptr = cr_malloc(sizeof (size_t) + sizeof (T) * len);
-        *(reinterpret_cast<size_t*>(ptr)) = len;
+    *(reinterpret_cast<size_t *>(ptr)) = len;
+    T *arr = reinterpret_cast<T *>(reinterpret_cast<size_t *>(ptr) + 1);
+    return arr;
+}
 
-        T* arr = reinterpret_cast<T*>(reinterpret_cast<size_t*>(ptr) + 1);
-        for (size_t i = 0; i < len; ++i)
-            new (arr + i) T();
-        return arr;
-    }
+/**
+ *  Allocates and construct a new array of object types
+ *
+ *  It is undefined behaviour to access a pointer returned by the new[]
+ *  operator inside a test or its setup and teardown functions;
+ *  new_arr must be used in its place for this purpose.
+ *
+ *  This function is semantically identical to the new[] operator.
+ *
+ *  @tparam T The compound type of the array to construct
+ *  @param[in] len The length of the array.
+ *  @returns The pointer to the newly constructed array.
+ */
+template <typename T>
+T *new_arr(size_t len)
+{
+    void *ptr = cr_malloc(sizeof (size_t) + sizeof (T) * len);
 
-    /**
-     *  Destroys and frees an object allocated by new_obj.
-     *
-     *  This function is semantically identical to the delete operator.
-     *
-     *  @tparam T The type of the object to construct
-     *  @param[in] ptr The object to destroy.
-     */
-    template<typename T>
-    void delete_obj(T* ptr) {
-        ptr->~T();
-        cr_free(ptr);
-    }
+    *(reinterpret_cast<size_t *>(ptr)) = len;
 
-    /**
-     *  Destroys and frees an array allocated by delete_arr.
-     *
-     *  This function is semantically identical to the delete[] operator.
-     *
-     *  @tparam T The type of the object to construct
-     *  @param[in] ptr The object to destroy.
-     */
-    template<typename T>
-    void delete_arr(typename std::enable_if<std::is_fundamental<T>::value>::type* ptr) {
-        cr_free(ptr);
-    }
+    T *arr = reinterpret_cast<T *>(reinterpret_cast<size_t *>(ptr) + 1);
+    for (size_t i = 0; i < len; ++i)
+        new (arr + i)T();
+    return arr;
+}
 
-    /**
-     *  Destroys and frees an array allocated by delete_arr.
-     *
-     *  This function is semantically identical to the delete[] operator.
-     *
-     *  @tparam T The type of the object to construct
-     *  @param[in] ptr The object to destroy.
-     */
-    template<typename T>
-    void delete_arr(T* ptr) {
-        size_t *ptr_ = reinterpret_cast<size_t*>(ptr);
-        size_t len = *(ptr_ - 1);
-        T* arr = reinterpret_cast<T*>(ptr_);
-        for (size_t i = 0; i < len; ++i)
-            arr[i].~T();
-        cr_free(ptr_ - 1);
-    }
+/**
+ *  Destroys and frees an object allocated by new_obj.
+ *
+ *  This function is semantically identical to the delete operator.
+ *
+ *  @tparam T The type of the object to construct
+ *  @param[in] ptr The object to destroy.
+ */
+template <typename T>
+void delete_obj(T *ptr)
+{
+    ptr->~T();
+    cr_free(ptr);
+}
 
-    /**
-     *  Allocator for use in the STL.
-     *
-     *  This internally uses calls to the cr_malloc function family, which
-     *  means that STL collections can be safely used inside tests or
-     *  setup/teardown functions if this allocator is used.
-     */
-    template<typename T>
-    struct allocator {
-        typedef T value_type;
-        typedef value_type* pointer;
-        typedef const value_type* const_pointer;
-        typedef value_type& reference;
-        typedef const value_type& const_reference;
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
+/**
+ *  Destroys and frees an array allocated by delete_arr.
+ *
+ *  This function is semantically identical to the delete[] operator.
+ *
+ *  @tparam T The type of the object to construct
+ *  @param[in] ptr The object to destroy.
+ */
+template <typename T>
+void delete_arr(typename std::enable_if<std::is_fundamental<T>::value>::type *ptr)
+{
+    cr_free(ptr);
+}
 
-        template<typename U>
-        struct rebind {
-            typedef allocator<U> other;
-        };
+/**
+ *  Destroys and frees an array allocated by delete_arr.
+ *
+ *  This function is semantically identical to the delete[] operator.
+ *
+ *  @tparam T The type of the object to construct
+ *  @param[in] ptr The object to destroy.
+ */
+template <typename T>
+void delete_arr(T *ptr)
+{
+    size_t *ptr_ = reinterpret_cast<size_t *>(ptr);
+    size_t len = *(ptr_ - 1);
+    T *arr = reinterpret_cast<T *>(ptr_);
 
-        inline explicit allocator() {}
-        inline ~allocator() {}
-        inline explicit allocator(allocator const&) {}
-        template<typename U>
-        inline explicit allocator(allocator<U> const&) {}
+    for (size_t i = 0; i < len; ++i)
+        arr[i].~T();
+    cr_free(ptr_ - 1);
+}
 
-        inline pointer address(reference r) { return &r; }
-        inline const_pointer address(const_reference r) { return &r; }
+/**
+ *  Allocator for use in the STL.
+ *
+ *  This internally uses calls to the cr_malloc function family, which
+ *  means that STL collections can be safely used inside tests or
+ *  setup/teardown functions if this allocator is used.
+ */
+template <typename T>
+struct allocator {
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
 
-        inline pointer allocate(size_type cnt, typename std::allocator<void>::const_pointer = 0) {
-            return reinterpret_cast<pointer>(cr_malloc(cnt * sizeof (T))); 
-        }
-
-        inline void deallocate(pointer p, size_type) { cr_free(p); }
-
-        inline size_type max_size() const {
-            return size_type(-1) / sizeof(T);
-        }
-
-        inline void construct(pointer p, const T& t) { new(p) T(t); }
-        inline void construct(pointer p, T&& t) { new (p) T(std::move(t)); }
-        inline void destroy(pointer p) { p->~T(); }
-
-        inline bool operator==(allocator const&) { return true; }
-        inline bool operator!=(allocator const& a) { return !operator==(a); }
+    template <typename U>
+    struct rebind {
+        typedef allocator<U> other;
     };
 
+    inline explicit allocator() {}
+    inline ~allocator() {}
+    inline explicit allocator(allocator const &) {}
+    template <typename U>
+    inline explicit allocator(allocator<U> const &) {}
+
+    inline pointer address(reference r) { return &r; }
+    inline const_pointer address(const_reference r) { return &r; }
+
+    inline pointer allocate(size_type cnt, typename std::allocator<void>::const_pointer = 0)
+    {
+        return reinterpret_cast<pointer>(cr_malloc(cnt * sizeof (T)));
+    }
+
+    inline void deallocate(pointer p, size_type) { cr_free(p); }
+
+    inline size_type max_size() const
+    {
+        return size_type(-1) / sizeof (T);
+    }
+
+    inline void construct(pointer p, const T &t) { new(p) T(t); }
+    inline void construct(pointer p, T &&t) { new (p) T(std::move(t)); }
+    inline void destroy(pointer p) { p->~T(); }
+
+    inline bool operator==(allocator const &) { return true; }
+    inline bool operator!=(allocator const &a) { return !operator==(a); }
+};
 }
-# endif
+#endif
 
 #endif /* !CRITERION_ALLOC_H_ */

include/criterion/criterion.h

@@ -21,41 +21,39 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/**
+ * @file
+ * @brief Include this to use criterion
+ *****************************************************************************/
 #ifndef CRITERION_H_
-# define CRITERION_H_
+#define CRITERION_H_
 
-# include "types.h"
-# include "assert.h"
-# include "alloc.h"
-
-# include "internal/test.h"
+#include "types.h"
+#include "assert.h"
+#include "alloc.h"
 
 /**
- *  Test(Suite, Name, [Options...]) { Function body }
- *
  *  Defines a new test.
  *
  *  @param Suite   The name of the test suite containing this test.
  *  @param Name    The name of the test.
- *  @param Options An optional sequence of designated initializer key/value
+ *  @param ...     An optional sequence of designated initializer key/value
  *    pairs as described in the `criterion_test_extra_data` structure
- *    (see criterion/types.h).
+ *    (see criterion/types.h).\n
  *    Example: .exit_code = 1
  */
-# define Test(...) CR_EXPAND(CR_TEST_BASE(__VA_ARGS__, .sentinel_ = 0))
+#define Test(Suite, Name, ...)    internal
 
 /**
- *  TestSuite(Name, [Options...]);
- *
  *  Explicitely defines a test suite and its options.
  *
- *  @param Name    The name of the test suite.
- *  @param Options An optional sequence of designated initializer key/value
+ *  @param Name The name of the test suite.
+ *  @param ...  An optional sequence of designated initializer key/value
  *    pairs as described in the `criterion_test_extra_data` structure
  *    (see criterion/types.h).
  *    These options will provide the defaults for each test.
  */
-# define TestSuite(...) CR_EXPAND(CR_SUITE_BASE(__VA_ARGS__, .sentinel_ = 0))
+#define TestSuite(Name, ...)      internal
 
 CR_BEGIN_C_API
 
@@ -111,11 +109,13 @@ CR_API int criterion_handle_args(int argc, char *argv[], bool handle_unknown_arg
  *  @param[in] test  The newly created test.
  */
 CR_API void criterion_register_test(struct criterion_test_set *tests,
-                                    struct criterion_test *test);
+        struct criterion_test *test);
 
-extern const struct criterion_test  *const criterion_current_test;
-extern const struct criterion_suite *const criterion_current_suite;
+CR_API extern const struct criterion_test *const criterion_current_test;
+CR_API extern const struct criterion_suite *const criterion_current_suite;
 
 CR_END_C_API
 
+#include "internal/test.h"
+
 #endif /* !CRITERION_H_ */

include/criterion/embedded.h

@@ -0,0 +1,48 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright © 2015-2016 Franklin "Snaipe" Mathieu <http://snai.pe/>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef CRITERION_EMBEDDED_H_
+#define CRITERION_EMBEDDED_H_
+
+typedef signed long long int cr_ssize;
+typedef unsigned long long int cr_size;
+typedef unsigned char cr_byte;
+typedef int cr_err;
+typedef struct cr_io_ctx cr_io_ctx;
+
+struct cr_embed_vtable {
+    cr_err (*init)(struct cr_io_ctx *ctx);
+    cr_ssize (*send)(const cr_byte *buf, cr_size size);
+    cr_ssize (*recv)(cr_byte *buf, cr_size size);
+    cr_err (*term)(struct cr_io_ctx *ctx);
+};
+
+struct cr_embed_properties {
+    struct cr_embed_vtable vtable;
+    struct cr_io_ctx *ctx;
+};
+
+int cr_embed_init(struct cr_embed_properties *props);
+int cr_embed_term(struct cr_embed_properties *props);
+
+#endif /* !CRITERION_EMBEDDED_H_ */

include/criterion/event.h

@@ -22,18 +22,19 @@
  * THE SOFTWARE.
  */
 #ifndef CRITERION_EVENT_H_
-# define CRITERION_EVENT_H_
+#define CRITERION_EVENT_H_
 
-# ifdef __cplusplus
-#  include <cstddef>
-# else
-#  include <stddef.h>
-# endif
-# include "internal/common.h"
+#ifdef __cplusplus
+# include <cstddef>
+#else
+# include <stddef.h>
+#endif
+#include "internal/common.h"
+#include "stats.h"
 
 CR_BEGIN_C_API
 
-CR_API void criterion_send_event(int kind, void *data, size_t size);
+CR_API void criterion_send_assert(struct criterion_assert_stats *stats);
 
 CR_END_C_API
 

include/criterion/hooks.h

@@ -21,10 +21,14 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/**
+ * @file
+ * @brief Report hooks
+ *****************************************************************************/
 #ifndef CRITERION_HOOKS_H_
-# define CRITERION_HOOKS_H_
+#define CRITERION_HOOKS_H_
 
-# include "internal/hooks.h"
+#include "internal/hooks.h"
 
 /**
  *  This enum lists all the phases of the runner lifecycle.
@@ -63,6 +67,6 @@ typedef void (*f_report_hook)();
  *
  *  @param Kind The report phase to hook the function onto.
  */
-# define ReportHook(Kind) CR_REPORT_HOOK_IMPL(Kind)
+#define ReportHook(Kind)    CR_REPORT_HOOK_IMPL(Kind)
 
 #endif /* !CRITERION_HOOKS_H_ */

include/criterion/internal/asprintf-compat.h

@@ -22,21 +22,22 @@
  * THE SOFTWARE.
  */
 #ifndef CRITERION_ASPRINTF_COMPAT_H_
-# define CRITERION_ASPRINTF_COMPAT_H_
+#define CRITERION_ASPRINTF_COMPAT_H_
 
-# ifdef __cplusplus
-#  include <cstdarg>
-# else
-#  include <stdarg.h>
-# endif
+#ifdef __cplusplus
+# include <cstdarg>
+#else
+# include <stdarg.h>
+#endif
 
-# include "common.h"
+#include "common.h"
 
 CR_BEGIN_C_API
 
 CR_FORMAT(printf, 2, 3)
 CR_API int cr_asprintf(char **strp, const char *fmt, ...);
 CR_API int cr_vasprintf(char **strp, const char *fmt, va_list ap);
+CR_API void cr_asprintf_free(char *buf);
 
 CR_END_C_API
 

include/criterion/internal/common.h

@@ -22,133 +22,118 @@
  * THE SOFTWARE.
  */
 #ifndef CRITERION_COMMON_H_
-# define CRITERION_COMMON_H_
+#define CRITERION_COMMON_H_
 
-# if defined(_MSC_VER)
-#  if _MSC_VER < 1900
-#   error \
-        Your version of MSVC++ is too old, please compile your tests using  \
-        a c99 compiler, like MinGW or MSVC 14.0+ (Included in visual studio \
-        2015)
-#  endif
+#if defined (_MSC_VER)
+# if _MSC_VER < 1900
+#  error                                                                \
+    Your version of MSVC++ is too old, please compile your tests using  \
+    a c99 compiler, like MinGW or MSVC 14.0+ (Included in visual studio \
+    2015)
 # endif
+#endif
 
-# ifndef CR_IS_MSVC
-#  ifdef _MSC_VER
-#   define CR_IS_MSVC _MSC_VER
-#  else
-#   define CR_IS_MSVC 0
-#  endif
-# endif
-
-# ifdef __cplusplus
-#  ifdef __GNUC__
-#   define CR_ATTRIBUTE(Arg) __attribute__((Arg))
-#  else
-#   define CR_ATTRIBUTE(Arg) [[gnu::Arg]]
-#  endif
-#  define CR_BEGIN_C_API extern "C" {
-#  define CR_END_C_API }
+#ifndef CR_IS_MSVC
+# ifdef _MSC_VER
+#  define CR_IS_MSVC    _MSC_VER
 # else
-#  define CR_ATTRIBUTE(Arg) __attribute__((Arg))
-#  define CR_BEGIN_C_API
-#  define CR_END_C_API
+#  define CR_IS_MSVC    0
 # endif
+#endif
 
-# ifdef __APPLE__
-#  define CR_SECTION_START_PREFIX       __first
-#  define CR_SECTION_END_PREFIX         __last
-#  define CR_SECTION_START_SUFFIX(Name) __asm("section$start$__DATA$" Name)
-#  define CR_SECTION_END_SUFFIX(Name)   __asm("section$end$__DATA$" Name)
-#  define CR_SECTION_(Name)             CR_ATTRIBUTE(section("__DATA," Name))
-#  define CR_SECTION_SUFFIX_
-# elif CR_IS_MSVC
-#  define CR_SECTION_START_PREFIX       __start
-#  define CR_SECTION_END_PREFIX         __stop
-#  define CR_SECTION_START_SUFFIX(Name)
-#  define CR_SECTION_END_SUFFIX(Name)
-#  define CR_SECTION_(Name)                 \
-    __pragma(data_seg(push))                \
-    __pragma(section(Name, read))           \
+#ifdef __cplusplus
+# ifdef __GNUC__
+#  define CR_ATTRIBUTE(Arg)               __attribute__((Arg))
+# else
+#  define CR_ATTRIBUTE(Arg)               [[gnu::Arg]]
+# endif
+# define CR_BEGIN_C_API    extern "C" {
+# define CR_END_C_API      }
+#else
+# define CR_ATTRIBUTE(Arg)                __attribute__((Arg))
+# define CR_BEGIN_C_API
+# define CR_END_C_API
+#endif
+
+#ifdef __APPLE__
+# define CR_SECTION_START_SUFFIX(Name)    __asm("section$start$__DATA$" Name)
+# define CR_SECTION_END_SUFFIX(Name)      __asm("section$end$__DATA$" Name)
+# define CR_SECTION_(Name)                CR_ATTRIBUTE(section("__DATA," Name))
+# define CR_SECTION_SUFFIX_
+#elif CR_IS_MSVC
+# define CR_SECTION_START_SUFFIX(Name)
+# define CR_SECTION_END_SUFFIX(Name)
+# define CR_SECTION_(Name)        \
+    __pragma(data_seg(push))      \
+    __pragma(section(Name, read)) \
     __declspec(allocate(Name))
-#  define CR_SECTION_SUFFIX_                \
+# define CR_SECTION_SUFFIX_ \
     __pragma(data_seg(pop))
-# else
-#  define CR_SECTION_START_PREFIX       __start
-#  define CR_SECTION_END_PREFIX         __stop
-#  define CR_SECTION_START_SUFFIX(Name)
-#  define CR_SECTION_END_SUFFIX(Name)
-#  define CR_SECTION_(Name)             CR_ATTRIBUTE(section(Name))
-#  define CR_SECTION_SUFFIX_
-# endif
+#else
+# define CR_SECTION_START_SUFFIX(Name)
+# define CR_SECTION_END_SUFFIX(Name)
+# define CR_SECTION_(Name)                  CR_ATTRIBUTE(section(Name))
+# define CR_SECTION_SUFFIX_
+#endif
 
-# define CR_MAKE_IDENTIFIER_(Prefix, Id) CR_MAKE_IDENTIFIER__(Prefix, Id)
-# define CR_MAKE_IDENTIFIER__(Prefix, Id) Prefix ## _ ## Id
+#define CR_MAKE_IDENTIFIER_(Prefix, Id)     CR_MAKE_IDENTIFIER__(Prefix, Id)
+#define CR_MAKE_IDENTIFIER__(Prefix, Id)    Prefix ## _ ## Id
 
-# define CR_SECTION_START_(Name) CR_MAKE_IDENTIFIER_(CR_SECTION_START_PREFIX, Name)
-# define CR_SECTION_END_(Name)   CR_MAKE_IDENTIFIER_(CR_SECTION_END_PREFIX, Name)
+#ifdef __GNUC__
+# define CR_UNUSED           CR_ATTRIBUTE(unused)
+# define CR_NORETURN         CR_ATTRIBUTE(noreturn)
+# define CR_INLINE           CR_ATTRIBUTE(always_inline) inline
+#elif CR_IS_MSVC
+# define CR_UNUSED           __pragma(warning(suppress: 4100))
+# define CR_NORETURN         __declspec(noreturn)
+# define CR_INLINE           __forceinline
+#else
+# define CR_UNUSED
+# define CR_NORETURN
+# define CR_INLINE           inline
+#endif
 
-# define CR_SECTION_START(Name)  g_ ## Name ## _section_start
-# define CR_SECTION_END(Name)    g_ ## Name ## _section_end
+#ifdef _WIN32
+# define CR_SIZE_T_FORMAT    "%Iu"
+#else
+# define CR_SIZE_T_FORMAT    "%zu"
+#endif
 
-# define CR_DECL_SECTION_LIMITS(Type, Name) CR_DECL_SECTION_LIMITS_(Type, Name)
-# define CR_DECL_SECTION_LIMITS_(Type, Name)                            \
-    extern Type CR_SECTION_START_(Name) CR_SECTION_START_SUFFIX(#Name); \
-    extern Type CR_SECTION_END_(Name)   CR_SECTION_END_SUFFIX(#Name)
+#ifdef __GNUC__
+# define CR_FORMAT(Archetype, Index, Ftc)    CR_ATTRIBUTE(format(Archetype, Index, Ftc))
+#else
+# define CR_FORMAT(Archetype, Index, Ftc)
+#endif
 
-# define CR_IMPL_SECTION_LIMITS(Type, Name)                         \
-    Type *const CR_SECTION_START(Name) = &CR_SECTION_START_(Name);  \
-    Type *const CR_SECTION_END(Name)   = &CR_SECTION_END_(Name)
-
-# ifdef __GNUC__
-#  define CR_UNUSED CR_ATTRIBUTE(unused)
-#  define CR_NORETURN CR_ATTRIBUTE(noreturn)
-#  define CR_INLINE CR_ATTRIBUTE(always_inline) inline
-# elif CR_IS_MSVC
-#  define CR_UNUSED __pragma(warning(suppress:4100))
-#  define CR_NORETURN __declspec(noreturn)
-#  define CR_INLINE __forceinline
-# else
-#  define CR_UNUSED
-#  define CR_NORETURN
-#  define CR_INLINE inline
-# endif
-
-# ifdef _WIN32
-#  define CR_SIZE_T_FORMAT "%Iu"
-# else
-#  define CR_SIZE_T_FORMAT "%zu"
-# endif
-
-# ifdef __GNUC__
-#  define CR_FORMAT(Archetype, Index, Ftc) CR_ATTRIBUTE(format(Archetype, Index, Ftc))
-# else
-#  define CR_FORMAT(Archetype, Index, Ftc)
-# endif
-
-# if defined _WIN32 || defined __CYGWIN__
-#  ifdef CRITERION_BUILDING_DLL
-#   ifdef __GNUC__
-#    define CR_API CR_ATTRIBUTE(dllexport)
-#   else
-#    define CR_API __declspec(dllexport)
-#   endif
+#if defined _WIN32 || defined __CYGWIN__
+# ifdef CRITERION_BUILDING_DLL
+#  ifdef __GNUC__
+#   define CR_API     CR_ATTRIBUTE(dllexport)
 #  else
-#   ifdef __GNUC__
-#    define CR_API CR_ATTRIBUTE(dllimport)
-#   else
-#    define CR_API __declspec(dllimport)
-#   endif
+#   define CR_API     __declspec(dllexport)
 #  endif
+# else
+#  ifdef __GNUC__
+#   define CR_API     CR_ATTRIBUTE(dllimport)
+#  else
+#   define CR_API     __declspec(dllimport)
+#  endif
+# endif
+# define CR_LOCAL
+#else
+# if __GNUC__ >= 4
+#  define CR_API      CR_ATTRIBUTE(visibility("default"))
+#  define CR_LOCAL    CR_ATTRIBUTE(visibility("hidden"))
+# else
+#  define CR_API
 #  define CR_LOCAL
-# else
-#  if __GNUC__ >= 4
-#   define CR_API   CR_ATTRIBUTE(visibility("default"))
-#   define CR_LOCAL CR_ATTRIBUTE(visibility("hidden"))
-#  else
-#   define CR_API
-#   define CR_LOCAL
-#  endif
 # endif
+#endif
+
+#ifdef __cplusplus
+# define CR_STDN      std::
+#else
+# define CR_STDN
+#endif
 
 #endif /* !CRITERION_COMMON_H_ */

include/criterion/internal/deprecation.h

@@ -0,0 +1,41 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright © 2015-2016 Franklin "Snaipe" Mathieu <http://snai.pe/>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef CRITERION_INTERNAL_DEPRECATION_H_
+#define CRITERION_INTERNAL_DEPRECATION_H_
+
+#define CR_DEPRECATED(Msg)               CR_DEPRECATED_(message(Msg))
+
+#ifdef _MSC_VER
+# define CR_DEPRECATED_(Msg)             __pragma(Msg)
+#else
+# define CR_DEPRECATED_(Msg)             _Pragma(#Msg)
+#endif
+
+#ifdef __GNUC__
+# define CR_DEPRECATED_MEMBER(Member)    Member __attribute__((deprecated))
+#else
+# define CR_DEPRECATED_MEMBER(Member)    Member
+#endif
+
+#endif /* !CRITERION_INTERNAL_DEPRECATION_H_ */

include/criterion/internal/designated-initializer-compat.h

@@ -22,104 +22,106 @@
  * THE SOFTWARE.
  */
 #ifndef CRITERION_DESIGNATED_INITIALIZER_COMPAT_HH_
-# define CRITERION_DESIGNATED_INITIALIZER_COMPAT_HH_
+#define CRITERION_DESIGNATED_INITIALIZER_COMPAT_HH_
 
-# include "common.h"
+#include "common.h"
 
-# define CRITERION_ARG_LENGTH(...) CR_EXPAND(CRITERION_ARG_LENGTH_(__VA_ARGS__,\
-    63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45,\
-    44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26,\
-    25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6,\
-    5, 4, 3, 2, 1, 0))
-# define CRITERION_ARG_LENGTH_(_63, _62, _61, _60, _59, _58, _57, _56, _55, _54, _53, \
-    _52, _51, _50, _49, _48, _47, _46, _45, _44, _43, _42, _41, _40, _39, _38, \
-    _37, _36, _35, _34, _33, _32, _31, _30, _29, _28, _27, _26, _25, _24, _23, \
-    _22, _21, _20, _19, _18, _17, _16, _15, _14, _13, _12, _11, _10, _9, _8,   \
-    _7, _6, _5, _4, _3, _2, _1, count, ...) count
+#define CRITERION_ARG_LENGTH(...)                                                       \
+    CR_EXPAND(CRITERION_ARG_LENGTH_(__VA_ARGS__,                                        \
+            63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, \
+            44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, \
+            25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, \
+            5, 4, 3, 2, 1, 0))
+#define CRITERION_ARG_LENGTH_(_63, _62, _61, _60, _59, _58, _57, _56, _55, _54, _53,   \
+            _52, _51, _50, _49, _48, _47, _46, _45, _44, _43, _42, _41, _40, _39, _38, \
+            _37, _36, _35, _34, _33, _32, _31, _30, _29, _28, _27, _26, _25, _24, _23, \
+            _22, _21, _20, _19, _18, _17, _16, _15, _14, _13, _12, _11, _10, _9, _8,   \
+            _7, _6, _5, _4, _3, _2, _1, count, ...)     count
 
-# define CRITERION_APPLY_1(Macro, ...)
-# define CRITERION_APPLY_2(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_1(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_3(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_2(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_4(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_3(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_5(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_4(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_6(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_5(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_7(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_6(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_8(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_7(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_9(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_8(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_10(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_9(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_11(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_10(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_12(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_11(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_13(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_12(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_14(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_13(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_15(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_14(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_16(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_15(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_17(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_16(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_18(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_17(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_19(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_18(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_20(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_19(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_21(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_20(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_22(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_21(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_23(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_22(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_24(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_23(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_25(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_24(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_26(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_25(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_27(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_26(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_28(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_27(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_29(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_28(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_30(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_29(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_31(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_30(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_32(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_31(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_33(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_32(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_34(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_33(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_35(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_34(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_36(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_35(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_37(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_36(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_38(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_37(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_39(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_38(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_40(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_39(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_41(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_40(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_42(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_41(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_43(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_42(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_44(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_43(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_45(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_44(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_46(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_45(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_47(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_46(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_48(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_47(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_49(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_48(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_50(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_49(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_51(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_50(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_52(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_51(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_53(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_52(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_54(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_53(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_55(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_54(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_56(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_55(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_57(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_56(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_58(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_57(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_59(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_58(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_60(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_59(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_61(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_60(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_62(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_61(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_63(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_62(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_64(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_63(Macro, Prefix, __VA_ARGS__))
-# define CRITERION_APPLY_65(Macro, Prefix, Head, ...) Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_64(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_1(Macro, ...)
+#define CRITERION_APPLY_2(Macro, Prefix, Head, ...)     Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_1(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_3(Macro, Prefix, Head, ...)     Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_2(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_4(Macro, Prefix, Head, ...)     Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_3(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_5(Macro, Prefix, Head, ...)     Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_4(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_6(Macro, Prefix, Head, ...)     Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_5(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_7(Macro, Prefix, Head, ...)     Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_6(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_8(Macro, Prefix, Head, ...)     Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_7(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_9(Macro, Prefix, Head, ...)     Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_8(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_10(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_9(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_11(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_10(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_12(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_11(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_13(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_12(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_14(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_13(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_15(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_14(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_16(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_15(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_17(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_16(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_18(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_17(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_19(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_18(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_20(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_19(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_21(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_20(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_22(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_21(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_23(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_22(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_24(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_23(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_25(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_24(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_26(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_25(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_27(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_26(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_28(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_27(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_29(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_28(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_30(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_29(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_31(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_30(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_32(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_31(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_33(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_32(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_34(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_33(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_35(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_34(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_36(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_35(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_37(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_36(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_38(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_37(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_39(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_38(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_40(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_39(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_41(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_40(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_42(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_41(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_43(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_42(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_44(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_43(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_45(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_44(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_46(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_45(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_47(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_46(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_48(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_47(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_49(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_48(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_50(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_49(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_51(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_50(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_52(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_51(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_53(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_52(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_54(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_53(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_55(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_54(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_56(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_55(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_57(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_56(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_58(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_57(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_59(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_58(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_60(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_59(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_61(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_60(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_62(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_61(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_63(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_62(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_64(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_63(Macro, Prefix, __VA_ARGS__))
+#define CRITERION_APPLY_65(Macro, Prefix, Head, ...)    Macro(Prefix, Head) CR_EXPAND(CRITERION_APPLY_64(Macro, Prefix, __VA_ARGS__))
 
-# define CRITERION_APPLY__(Macro, Prefix, n, ...) CR_EXPAND(CRITERION_APPLY_##n(Macro, Prefix, __VA_ARGS__,))
-# define CRITERION_APPLY_(Macro, n, Prefix, ...) CR_EXPAND(CRITERION_APPLY__(Macro, Prefix, n, __VA_ARGS__))
-# define CRITERION_APPLY(Macro, ...) CR_EXPAND(CRITERION_APPLY_(Macro, CRITERION_ARG_LENGTH(__VA_ARGS__), __VA_ARGS__))
+#define CRITERION_APPLY__(Macro, Prefix, n, ...)        CR_EXPAND(CRITERION_APPLY_ ## n(Macro, Prefix, __VA_ARGS__, ))
+#define CRITERION_APPLY_(Macro, n, Prefix, ...)         CR_EXPAND(CRITERION_APPLY__(Macro, Prefix, n, __VA_ARGS__))
+#define CRITERION_APPLY(Macro, ...)                     CR_EXPAND(CRITERION_APPLY_(Macro, CRITERION_ARG_LENGTH(__VA_ARGS__), __VA_ARGS__))
 
-# define CRITERION_ADD_PREFIX_ONCE(Prefix, Field) Prefix Field;
-# define CRITERION_ADD_PREFIX(...) \
+#define CRITERION_ADD_PREFIX_ONCE(Prefix, Field)        Prefix Field;
+#define CRITERION_ADD_PREFIX(...) \
     CR_EXPAND(CRITERION_APPLY(CRITERION_ADD_PREFIX_ONCE, __VA_ARGS__))
 
-# ifdef __cplusplus
-#  define CRITERION_MAKE_STRUCT(Type, ...) []() -> Type {   \
-        Type t;                                             \
-        std::memset(&t, 0, sizeof (t));                     \
-        CR_EXPAND(CRITERION_ADD_PREFIX(t, __VA_ARGS__))     \
-        return t;                                           \
-    }()
-# else
-#  define CRITERION_MAKE_STRUCT(Type, ...) { __VA_ARGS__ }
-# endif
+#ifdef __cplusplus
+# define CRITERION_MAKE_STRUCT(Type, ...)               \
+    []() -> Type {                                      \
+        Type t;                                         \
+        std::memset(&t, 0, sizeof (t));                 \
+        CR_EXPAND(CRITERION_ADD_PREFIX(t, __VA_ARGS__)) \
+        return t;                                       \
+    } ()
+#else
+# define CRITERION_MAKE_STRUCT(Type, ...)               { __VA_ARGS__ }
+#endif
 
 #endif /* !CRITERION_DESIGNATED_INITIALIZER_COMPAT_HH_ */

include/criterion/internal/hooks.h

@@ -22,63 +22,62 @@
  * THE SOFTWARE.
  */
 #ifndef CRITERION_INTERNAL_HOOKS_H_
-# define CRITERION_INTERNAL_HOOKS_H_
+#define CRITERION_INTERNAL_HOOKS_H_
 
-# include "common.h"
-# include "../types.h"
+#include "common.h"
+#include "../types.h"
 
-# define CR_HOOK_IDENTIFIER_(Suffix) CR_HOOK_IDENTIFIER__(__LINE__, Suffix)
-# define CR_HOOK_IDENTIFIER__(Line, Suffix) CR_HOOK_IDENTIFIER___(Line, Suffix)
-# define CR_HOOK_IDENTIFIER___(Line, Suffix) hook_l ## Line ## _ ## Suffix
+#define CR_HOOK_IDENTIFIER_(Suffix)            CR_HOOK_IDENTIFIER__(__LINE__, Suffix)
+#define CR_HOOK_IDENTIFIER__(Line, Suffix)     CR_HOOK_IDENTIFIER___(Line, Suffix)
+#define CR_HOOK_IDENTIFIER___(Line, Suffix)    hook_l ## Line ## _ ## Suffix
 
-# ifdef __cplusplus
-#  define CR_HOOK_PROTOTYPE_ \
+#ifdef __cplusplus
+# define CR_HOOK_PROTOTYPE_ \
     extern "C" void CR_HOOK_IDENTIFIER_(impl)
-# else
-#  define CR_HOOK_PROTOTYPE_ \
+#else
+# define CR_HOOK_PROTOTYPE_ \
     void CR_HOOK_IDENTIFIER_(impl)
-# endif
+#endif
 
-// Section abbreviations
-# define CR_HOOK_SECTION_PRE_ALL       cr_pra
-# define CR_HOOK_SECTION_PRE_SUITE     cr_prs
-# define CR_HOOK_SECTION_PRE_INIT      cr_pri
-# define CR_HOOK_SECTION_PRE_TEST      cr_prt
-# define CR_HOOK_SECTION_ASSERT        cr_ast
-# define CR_HOOK_SECTION_THEORY_FAIL   cr_thf
-# define CR_HOOK_SECTION_TEST_CRASH    cr_tsc
-# define CR_HOOK_SECTION_POST_TEST     cr_pot
-# define CR_HOOK_SECTION_POST_FINI     cr_pof
-# define CR_HOOK_SECTION_POST_SUITE    cr_pos
-# define CR_HOOK_SECTION_POST_ALL      cr_poa
+/* Section abbreviations */
+#define CR_HOOK_SECTION_PRE_ALL           cr_pra
+#define CR_HOOK_SECTION_PRE_SUITE         cr_prs
+#define CR_HOOK_SECTION_PRE_INIT          cr_pri
+#define CR_HOOK_SECTION_PRE_TEST          cr_prt
+#define CR_HOOK_SECTION_ASSERT            cr_ast
+#define CR_HOOK_SECTION_THEORY_FAIL       cr_thf
+#define CR_HOOK_SECTION_TEST_CRASH        cr_tsc
+#define CR_HOOK_SECTION_POST_TEST         cr_pot
+#define CR_HOOK_SECTION_POST_FINI         cr_pof
+#define CR_HOOK_SECTION_POST_SUITE        cr_pos
+#define CR_HOOK_SECTION_POST_ALL          cr_poa
 
-# define CR_HOOK_SECTION(Kind) CR_HOOK_SECTION_ ## Kind
+#define CR_HOOK_SECTION(Kind)               CR_HOOK_SECTION_ ## Kind
 
-# define CR_HOOK_SECTION_STRINGIFY__(Sec) #Sec
-# define CR_HOOK_SECTION_STRINGIFY_(Sec) CR_HOOK_SECTION_STRINGIFY__(Sec)
-# define CR_HOOK_SECTION_STRINGIFY(Kind) CR_HOOK_SECTION_STRINGIFY_(CR_HOOK_SECTION(Kind))
+#define CR_HOOK_SECTION_STRINGIFY__(Sec)    #Sec
+#define CR_HOOK_SECTION_STRINGIFY_(Sec)     CR_HOOK_SECTION_STRINGIFY__(Sec)
+#define CR_HOOK_SECTION_STRINGIFY(Kind)     CR_HOOK_SECTION_STRINGIFY_(CR_HOOK_SECTION(Kind))
 
-# define CR_HOOK_PARAM_TYPE_PRE_ALL        struct criterion_test_set *
-# define CR_HOOK_PARAM_TYPE_PRE_SUITE      struct criterion_suite_set *
-# define CR_HOOK_PARAM_TYPE_PRE_INIT       struct criterion_test *
-# define CR_HOOK_PARAM_TYPE_PRE_TEST       struct criterion_test *
-# define CR_HOOK_PARAM_TYPE_ASSERT         struct criterion_assert_stats *
-# define CR_HOOK_PARAM_TYPE_THEORY_FAIL    struct criterion_theory_stats *
-# define CR_HOOK_PARAM_TYPE_TEST_CRASH     struct criterion_test_stats *
-# define CR_HOOK_PARAM_TYPE_POST_TEST      struct criterion_test_stats *
-# define CR_HOOK_PARAM_TYPE_POST_FINI      struct criterion_test_stats *
-# define CR_HOOK_PARAM_TYPE_POST_SUITE     struct criterion_suite_stats *
-# define CR_HOOK_PARAM_TYPE_POST_ALL       struct criterion_global_stats *
+#define CR_HOOK_PARAM_TYPE_PRE_ALL        struct criterion_test_set *
+#define CR_HOOK_PARAM_TYPE_PRE_SUITE      struct criterion_suite_set *
+#define CR_HOOK_PARAM_TYPE_PRE_INIT       struct criterion_test *
+#define CR_HOOK_PARAM_TYPE_PRE_TEST       struct criterion_test *
+#define CR_HOOK_PARAM_TYPE_ASSERT         struct criterion_assert_stats *
+#define CR_HOOK_PARAM_TYPE_THEORY_FAIL    struct criterion_theory_stats *
+#define CR_HOOK_PARAM_TYPE_TEST_CRASH     struct criterion_test_stats *
+#define CR_HOOK_PARAM_TYPE_POST_TEST      struct criterion_test_stats *
+#define CR_HOOK_PARAM_TYPE_POST_FINI      struct criterion_test_stats *
+#define CR_HOOK_PARAM_TYPE_POST_SUITE     struct criterion_suite_stats *
+#define CR_HOOK_PARAM_TYPE_POST_ALL       struct criterion_global_stats *
 
-# define CR_HOOK_PARAM_TYPE(Kind) CR_HOOK_PARAM_TYPE_ ## Kind
+#define CR_HOOK_PARAM_TYPE(Kind)    CR_HOOK_PARAM_TYPE_ ## Kind
 
-# define CR_REPORT_HOOK_IMPL(Kind)                  \
-    CR_HOOK_PROTOTYPE_(CR_HOOK_PARAM_TYPE(Kind));   \
-    CR_SECTION_(CR_HOOK_SECTION_STRINGIFY(Kind))    \
-    f_report_hook CR_HOOK_IDENTIFIER_(func) =       \
-        (f_report_hook) CR_HOOK_IDENTIFIER_(impl)   \
-    CR_SECTION_SUFFIX_;                             \
+#define CR_REPORT_HOOK_IMPL(Kind)                     \
+    CR_HOOK_PROTOTYPE_(CR_HOOK_PARAM_TYPE(Kind));     \
+    CR_SECTION_(CR_HOOK_SECTION_STRINGIFY(Kind))      \
+    f_report_hook CR_HOOK_IDENTIFIER_(func) =         \
+            (f_report_hook) CR_HOOK_IDENTIFIER_(impl) \
+            CR_SECTION_SUFFIX_;                       \
     CR_HOOK_PROTOTYPE_
 
-
 #endif /* !CRITERION_INTERNAL_HOOKS_H_ */

include/criterion/internal/ordered-set.h

@@ -22,9 +22,9 @@
  * THE SOFTWARE.
  */
 #ifndef CRITERION_ORDERED_SET_H_
-# define CRITERION_ORDERED_SET_H_
+#define CRITERION_ORDERED_SET_H_
 
-# include "../types.h"
+#include "../types.h"
 
 typedef int (*f_criterion_cmp)(void *, void *);
 
@@ -32,7 +32,7 @@ struct criterion_ordered_set {
     struct criterion_ordered_set_node *first;
     size_t size;
     f_criterion_cmp cmp;
-    void (*const dtor)(void *, void *);
+    void(*const dtor)(void *, void *);
 };
 
 struct criterion_ordered_set_node {
@@ -42,17 +42,17 @@ struct criterion_ordered_set_node {
 CR_BEGIN_C_API
 
 CR_API struct criterion_ordered_set *new_ordered_set(f_criterion_cmp cmp,
-                                              void (*dtor)(void *, void *));
+        void (*dtor)(void *, void *));
 
 CR_API void *insert_ordered_set(struct criterion_ordered_set *l,
-                         void *ptr,
-                         size_t size);
+        void *ptr,
+        size_t size);
 
 CR_END_C_API
 
-# define FOREACH_SET(Elt, Set)                                              \
+#define FOREACH_SET(Elt, Set)                                               \
     for (struct criterion_ordered_set_node *n = Set->first; n; n = n->next) \
         for (int cond = 1; cond;)                                           \
-            for (Elt = (void*) (n + 1); cond && (cond = 0, 1);)
+            for (Elt = (void *) (n + 1); cond && (cond = 0, 1);)
 
 #endif /* !CRITERION_ORDERED_SET_H_ */

include/criterion/internal/parameterized.h

@@ -22,10 +22,10 @@
  * THE SOFTWARE.
  */
 #ifndef CRITERION_INTERNAL_PARAMETERIZED_H_
-# define CRITERION_INTERNAL_PARAMETERIZED_H_
+#define CRITERION_INTERNAL_PARAMETERIZED_H_
 
-# include "test.h"
-# include "../types.h"
+#include "test.h"
+#include "../types.h"
 
 struct criterion_test_params {
     size_t size;
@@ -33,83 +33,93 @@ struct criterion_test_params {
     size_t length;
     void (*cleanup)(struct criterion_test_params *);
 
-# ifdef __cplusplus
+#ifdef __cplusplus
     constexpr criterion_test_params(size_t size, void *params, size_t length)
-        : size(size)
-        , params(params)
-        , length(length)
-        , cleanup(nullptr)
+        : size(size),
+        params(params),
+        length(length),
+        cleanup(nullptr)
     {}
 
     constexpr criterion_test_params(size_t size, void *params, size_t length,
-            void (*cleanup)(struct criterion_test_params *))
-        : size(size)
-        , params(params)
-        , length(length)
-        , cleanup(cleanup)
+            void(*cleanup)(struct criterion_test_params *))
+        : size(size),
+        params(params),
+        length(length),
+        cleanup(cleanup)
     {}
 
     template <typename T>
-    constexpr criterion_test_params(std::vector<T, criterion::allocator<T>>& vec,
-            void (*cleanup)(criterion_test_params *) = nullptr)
-        : size(sizeof (T))
-        , params(&vec[0])
-        , length(vec.size())
-        , cleanup(cleanup)
+    constexpr criterion_test_params(std::vector<T, criterion::allocator<T> > &vec,
+            void(*cleanup)(criterion_test_params *) = nullptr)
+        : size(sizeof (T)),
+        params(&vec[0]),
+        length(vec.size()),
+        cleanup(cleanup)
     {}
 
     template <typename T, unsigned int N>
     constexpr criterion_test_params(T (&arr)[N],
-            void (*cleanup)(criterion_test_params *) = nullptr)
-        : size(sizeof (arr[0]))
-        , params(static_cast<void*>(&arr))
-        , length(N)
-        , cleanup(cleanup)
+            void(*cleanup)(criterion_test_params *) = nullptr)
+        : size(sizeof (arr[0])),
+        params(static_cast<void *>(&arr)),
+        length(N),
+        cleanup(cleanup)
     {}
-# endif
+#endif
 };
 
-# ifdef __cplusplus
-#  define CR_PARAM_TEST_PROTOTYPE_(Param, Category, Name) \
+#ifdef __cplusplus
+# define CR_PARAM_TEST_PROTOTYPE_(Param, Category, Name) \
     extern "C" void CR_IDENTIFIER_(Category, Name, impl)(Param)
-# else
-#  define CR_PARAM_TEST_PROTOTYPE_(Param, Category, Name) \
+#else
+# define CR_PARAM_TEST_PROTOTYPE_(Param, Category, Name) \
     void CR_IDENTIFIER_(Category, Name, impl)(Param)
-# endif
+#endif
 
-# define CR_PARAM_TEST_BASE(Param, Category, Name, ...)                        \
-    CR_PARAM_TEST_PROTOTYPE_(Param, Category, Name);                           \
-    CR_TEST_TRAMPOLINE_(Category, Name)                                        \
-    struct criterion_test_extra_data CR_IDENTIFIER_(Category, Name, extra) =   \
-        CR_EXPAND(CRITERION_MAKE_STRUCT(criterion_test_extra_data,             \
-            .lang_ = CR_LANG,                                                  \
-            .kind_ = CR_TEST_PARAMETERIZED,                                    \
-            .param_ = CR_IDENTIFIER_(Category, Name, param),                   \
-            .identifier_ = #Category "/" #Name,                                \
-            .file_    = __FILE__,                                              \
-            .line_    = __LINE__,                                              \
-            __VA_ARGS__                                                        \
-        ));                                                                    \
-    struct criterion_test CR_IDENTIFIER_(Category, Name, meta) = {             \
-        #Name,                                                                 \
-        #Category,                                                             \
-        CR_IDENTIFIER_(Category, Name, jmp),                                   \
-        &CR_IDENTIFIER_(Category, Name, extra)                                 \
-    };                                                                         \
-    CR_SECTION_("cr_tst")                                                      \
-    struct criterion_test *CR_IDENTIFIER_(Category, Name, ptr)                 \
-            = &CR_IDENTIFIER_(Category, Name, meta) CR_SECTION_SUFFIX_;        \
+#define CR_PARAM_TEST_BASE(Param, Category, Name, ...)                       \
+    CR_PARAM_TEST_PROTOTYPE_(Param, Category, Name);                         \
+    CR_TEST_TRAMPOLINE_(Category, Name)                                      \
+    struct criterion_test_extra_data CR_IDENTIFIER_(Category, Name, extra) = \
+            CR_EXPAND(CRITERION_MAKE_STRUCT(criterion_test_extra_data,       \
+                    .compiler_ = CR_COMPILER_,                               \
+                    .lang_ = CR_LANG,                                        \
+                    .kind_ = CR_TEST_PARAMETERIZED,                          \
+                    .param_ = CR_IDENTIFIER_(Category, Name, param),         \
+                    .identifier_ = #Category "/" #Name,                      \
+                    .file_    = __FILE__,                                    \
+                    .line_    = __LINE__,                                    \
+                    __VA_ARGS__                                              \
+                    ));                                                      \
+    struct criterion_test CR_IDENTIFIER_(Category, Name, meta) = {           \
+        #Name,                                                               \
+        #Category,                                                           \
+        CR_IDENTIFIER_(Category,  Name, jmp),                                \
+        &CR_IDENTIFIER_(Category, Name, extra)                               \
+    };                                                                       \
+    CR_SECTION_("cr_tst")                                                    \
+    struct criterion_test *CR_IDENTIFIER_(Category, Name, ptr)               \
+        = &CR_IDENTIFIER_(Category, Name, meta) CR_SECTION_SUFFIX_;          \
     CR_PARAM_TEST_PROTOTYPE_(Param, Category, Name)
 
-# define CR_PARAM_TEST_PARAMS(Category, Name) \
+#define CR_PARAM_TEST_PARAMS(Category, Name) \
     static struct criterion_test_params CR_IDENTIFIER_(Category, Name, param)(void)
 
-# ifdef __cplusplus
-#  define cr_make_param_array_(Type, Array, ...) \
+#ifdef __cplusplus
+# define cr_make_param_array_(Type, Array, ...) \
     criterion_test_params(sizeof (Type), (Array), __VA_ARGS__)
-# else
-#  define cr_make_param_array_(Type, Array, ...) \
-    (struct criterion_test_params) { .size = sizeof (Type), (void*)(Array), __VA_ARGS__ }
-# endif
+#else
+# define cr_make_param_array_(Type, Array, ...) \
+    (struct criterion_test_params) { .size = sizeof (Type), (void *) (Array), __VA_ARGS__ }
+#endif
+
+#undef ParameterizedTest
+#define ParameterizedTest(...)                      CR_EXPAND(CR_PARAM_TEST_BASE(__VA_ARGS__, .sentinel_ = 0))
+
+#undef ParameterizedTestParameters
+#define ParameterizedTestParameters(Suite, Name)    CR_PARAM_TEST_PARAMS(Suite, Name)
+
+#undef cr_make_param_array
+#define cr_make_param_array(...)                    CR_EXPAND(cr_make_param_array_(__VA_ARGS__))
 
 #endif /* !CRITERION_INTERNAL_PARAMETERIZED_H_ */

include/criterion/internal/preprocess.h

@@ -22,52 +22,53 @@
  * THE SOFTWARE.
  */
 #ifndef CRITERION_PREPROCESS_H_
-# define CRITERION_PREPROCESS_H_
+#define CRITERION_PREPROCESS_H_
 
-# define CR_NOOP do {} while(0)
+#define CR_NOOP        do {} while (0)
 
-# ifdef __cplusplus
-#  define CR_NOTHROW throw()
-# else
-#  define CR_NOTHROW
-# endif
+#ifdef __cplusplus
+# define CR_NOTHROW    throw ()
+#else
+# define CR_NOTHROW
+#endif
 
-# define CR_EXPAND(x) x
-# define CR_IDENTITY(...) __VA_ARGS__
+#define CR_EXPAND(x)                      x
+#define CR_IDENTITY(...)                  __VA_ARGS__
 
-# define CR_STR(x) CR_EXPAND(CR_STR_(x))
-# define CR_STR_(x) #x
+#define CR_STR(x)                         CR_EXPAND(CR_STR_(x))
+#define CR_STR_(x)                        #x
 
-# define CR_VA_TAIL(...) CR_EXPAND(CR_VA_TAIL_HELPER(CR_VA_TAIL_SELECT(__VA_ARGS__), __VA_ARGS__))
+#define CR_VA_TAIL(...)                   CR_EXPAND(CR_VA_TAIL_HELPER(CR_VA_TAIL_SELECT(__VA_ARGS__), __VA_ARGS__))
 
-# define CR_VA_TAIL_HELPER(N, ...)  CR_EXPAND(CR_VA_TAIL_HELPER_(N, __VA_ARGS__))
-# define CR_VA_TAIL_HELPER_(N, ...) CR_EXPAND(CR_VA_TAIL_HELPER_##N(__VA_ARGS__))
-# define CR_VA_TAIL_HELPER_1(Head)
-# define CR_VA_TAIL_HELPER_2(Head, ...) __VA_ARGS__
+#define CR_VA_TAIL_HELPER(N, ...)         CR_EXPAND(CR_VA_TAIL_HELPER_(N, __VA_ARGS__))
+#define CR_VA_TAIL_HELPER_(N, ...)        CR_EXPAND(CR_VA_TAIL_HELPER_ ## N(__VA_ARGS__))
+#define CR_VA_TAIL_HELPER_1(Head)
+#define CR_VA_TAIL_HELPER_2(Head, ...)    __VA_ARGS__
 
-# define CR_VA_HEAD(...) CR_EXPAND(CR_VA_HEAD_HELPER(CR_VA_TAIL_SELECT(__VA_ARGS__), __VA_ARGS__))
+#define CR_VA_HEAD(...)                   CR_EXPAND(CR_VA_HEAD_HELPER(CR_VA_TAIL_SELECT(__VA_ARGS__), __VA_ARGS__))
 
-# define CR_VA_HEAD_HELPER(N, ...)  CR_EXPAND(CR_VA_HEAD_HELPER_(N, __VA_ARGS__))
-# define CR_VA_HEAD_HELPER_(N, ...) CR_EXPAND(CR_VA_HEAD_HELPER_##N(__VA_ARGS__))
-# define CR_VA_HEAD_HELPER_1(Head) Head
-# define CR_VA_HEAD_HELPER_2(Head, ...) Head
+#define CR_VA_HEAD_HELPER(N, ...)         CR_EXPAND(CR_VA_HEAD_HELPER_(N, __VA_ARGS__))
+#define CR_VA_HEAD_HELPER_(N, ...)        CR_EXPAND(CR_VA_HEAD_HELPER_ ## N(__VA_ARGS__))
+#define CR_VA_HEAD_HELPER_1(Head)         Head
+#define CR_VA_HEAD_HELPER_2(Head, ...)    Head
 
-# define CR_VA_TAIL_SELECT(...) CR_EXPAND(CR_VA_TAIL_SELECT64(__VA_ARGS__, \
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
-        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \
-        2, 2, 1, _))
+#define CR_VA_TAIL_SELECT(...)                 \
+    CR_EXPAND(CR_VA_TAIL_SELECT64(__VA_ARGS__, \
+            2, 2, 2, 2, 2, 2, 2, 2, 2, 2,      \
+            2, 2, 2, 2, 2, 2, 2, 2, 2, 2,      \
+            2, 2, 2, 2, 2, 2, 2, 2, 2, 2,      \
+            2, 2, 2, 2, 2, 2, 2, 2, 2, 2,      \
+            2, 2, 2, 2, 2, 2, 2, 2, 2, 2,      \
+            2, 2, 2, 2, 2, 2, 2, 2, 2, 2,      \
+            2, 2, 1, _))
 
-# define CR_VA_TAIL_SELECT64( \
+#define CR_VA_TAIL_SELECT64(                              \
         _01, _02, _03, _04, _05, _06, _07, _08, _09, _10, \
         _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
         _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \
         _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \
         _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, \
         _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, \
-        _61, _62, _63, X, ...) X
+        _61, _62, _63, X, ...)            X
 
 #endif /* !CRITERION_PREPROCESS_H_ */

include/criterion/internal/redirect.h

@@ -22,50 +22,148 @@
  * THE SOFTWARE.
  */
 #ifndef CRITERION_INTERNAL_REDIRECT_H_
-# define CRITERION_INTERNAL_REDIRECT_H_
+#define CRITERION_INTERNAL_REDIRECT_H_
 
-# include "common.h"
-# include "assert.h"
+#include "common.h"
+#include "assert.h"
 
-# define cr_assert_redir_op_(Fail, Fun, Op, File, Str, ...)     \
-    CR_EXPAND(cr_assert_impl(                                   \
-            Fail,                                               \
-            !(Fun((File), (Str)) Op 0),                         \
-            dummy,                                              \
-            CRITERION_ASSERT_MSG_FILE_STR_MATCH,                \
-            (CR_STR(File), Str),                                \
-            __VA_ARGS__                                         \
-    ))
+CR_BEGIN_C_API
 
-# define cr_assert_redir_op_va_(Fail, Fun, Op, ...)             \
-    CR_EXPAND(cr_assert_redir_op_(                              \
-            Fail,                                               \
-            Fun,                                                \
-            Op,                                                 \
-            CR_VA_HEAD(__VA_ARGS__),                            \
-            CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)),                \
-            CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))                 \
-    ))
+CR_API int cr_stdout_match_file(CR_STDN FILE *ref);
+CR_API int cr_stdout_match_str(const char *ref);
+CR_API int cr_stderr_match_file(CR_STDN FILE *ref);
+CR_API int cr_stderr_match_str(const char *ref);
 
-# define cr_assert_redir_f_op_(Fail, Fun, Op, File, Ref, ...)   \
-    CR_EXPAND(cr_assert_impl(                                   \
-            Fail,                                               \
-            !(Fun((File), (Ref)) Op 0),                         \
-            dummy,                                              \
-            CRITERION_ASSERT_MSG_FILE_MATCH,                    \
-            (CR_STR(File), CR_STR(Ref)),                        \
-            __VA_ARGS__                                         \
-    ))
+CR_END_C_API
 
-# define cr_assert_redir_f_op_va_(Fail, Fun, Op, ...)           \
-    CR_EXPAND(cr_assert_redir_op_(                              \
-            Fail,                                               \
-            Fun,                                                \
-            Op,                                                 \
-            CR_VA_HEAD(__VA_ARGS__),                            \
-            CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)),                \
-            CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))                 \
-    ))
+#define cr_assert_redir_op_(Fail, Fun, Op, File, Str, ...) \
+    CR_EXPAND(cr_assert_impl(                              \
+                Fail,                                      \
+                !(Fun((File), (Str)) Op 0),                \
+                dummy,                                     \
+                CRITERION_ASSERT_MSG_FILE_STR_MATCH,       \
+                (CR_STR(File), Str),                       \
+                __VA_ARGS__                                \
+                ))
 
+#define cr_assert_redir_op_va_(Fail, Fun, Op, ...)   \
+    CR_EXPAND(cr_assert_redir_op_(                   \
+                Fail,                                \
+                Fun,                                 \
+                Op,                                  \
+                CR_VA_HEAD(__VA_ARGS__),             \
+                CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
+                CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))  \
+                ))
+
+#define cr_assert_redir_f_op_(Fail, Fun, Op, File, Ref, ...) \
+    CR_EXPAND(cr_assert_impl(                                \
+                Fail,                                        \
+                !(Fun((File), (Ref)) Op 0),                  \
+                dummy,                                       \
+                CRITERION_ASSERT_MSG_FILE_MATCH,             \
+                (CR_STR(File), CR_STR(Ref)),                 \
+                __VA_ARGS__                                  \
+                ))
+
+#define cr_assert_redir_f_op_va_(Fail, Fun, Op, ...) \
+    CR_EXPAND(cr_assert_redir_f_op_(                 \
+                Fail,                                \
+                Fun,                                 \
+                Op,                                  \
+                CR_VA_HEAD(__VA_ARGS__),             \
+                CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
+                CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))  \
+                ))
+
+#undef cr_assert_file_contents_eq_str
+#define cr_assert_file_contents_eq_str(...)     CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_ABORT_, cr_file_match_str, ==, __VA_ARGS__))
+#undef cr_expect_file_contents_eq_str
+#define cr_expect_file_contents_eq_str(...)     CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_CONTINUES_, cr_file_match_str, ==, __VA_ARGS__))
+#undef cr_assert_file_contents_neq_str
+#define cr_assert_file_contents_neq_str(...)    CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_ABORT_, cr_file_match_str, !=, __VA_ARGS__))
+#undef cr_expect_file_contents_neq_str
+#define cr_expect_file_contents_neq_str(...)    CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_CONTINUES_, cr_file_match_str, !=, __VA_ARGS__))
+#undef cr_assert_file_contents_eq
+#define cr_assert_file_contents_eq(...)         CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_ABORT_, cr_file_match_file, ==, __VA_ARGS__))
+#undef cr_expect_file_contents_eq
+#define cr_expect_file_contents_eq(...)         CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_CONTINUES_, cr_file_match_file, ==, __VA_ARGS__))
+#undef cr_assert_file_contents_neq
+#define cr_assert_file_contents_neq(...)        CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_ABORT_, cr_file_match_file, !=, __VA_ARGS__))
+#undef cr_expect_file_contents_neq
+#define cr_expect_file_contents_neq(...)        CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_CONTINUES_, cr_file_match_file, !=, __VA_ARGS__))
+
+#undef cr_assert_stdout_eq_str
+#define cr_assert_stdout_eq_str(...)            CR_EXPAND(cr_assert_redir_unop_va_(CR_FAIL_ABORT_, cr_stdout_match_str, ==, stdout, __VA_ARGS__))
+#undef cr_expect_stdout_eq_str
+#define cr_expect_stdout_eq_str(...)            CR_EXPAND(cr_assert_redir_unop_va_(CR_FAIL_CONTINUES_, cr_stdout_match_str, ==, stdout, __VA_ARGS__))
+#undef cr_assert_stdout_neq_str
+#define cr_assert_stdout_neq_str(...)           CR_EXPAND(cr_assert_redir_unop_va_(CR_FAIL_ABORT_, cr_stdout_match_str, !=, stdout, __VA_ARGS__))
+#undef cr_expect_stdout_neq_str
+#define cr_expect_stdout_neq_str(...)           CR_EXPAND(cr_assert_redir_unop_va_(CR_FAIL_CONTINUES_, cr_stdout_match_str, !=, stdout, __VA_ARGS__))
+#undef cr_assert_stderr_eq_str
+#define cr_assert_stderr_eq_str(...)            CR_EXPAND(cr_assert_redir_unop_va_(CR_FAIL_ABORT_, cr_stderr_match_str, ==, stderr, __VA_ARGS__))
+#undef cr_expect_stderr_eq_str
+#define cr_expect_stderr_eq_str(...)            CR_EXPAND(cr_assert_redir_unop_va_(CR_FAIL_CONTINUES_, cr_stderr_match_str, ==, stderr, __VA_ARGS__))
+#undef cr_assert_stderr_neq_str
+#define cr_assert_stderr_neq_str(...)           CR_EXPAND(cr_assert_redir_unop_va_(CR_FAIL_ABORT_, cr_stderr_match_str, !=, stderr, __VA_ARGS__))
+#undef cr_expect_stderr_neq_str
+#define cr_expect_stderr_neq_str(...)           CR_EXPAND(cr_assert_redir_unop_va_(CR_FAIL_CONTINUES_, cr_stderr_match_str, !=, stderr, __VA_ARGS__))
+#undef cr_assert_stdout_eq
+#define cr_assert_stdout_eq(...)                CR_EXPAND(cr_assert_redir_f_unop_va_(CR_FAIL_ABORT_, cr_stdout_match_file, ==, stdout, __VA_ARGS__))
+#undef cr_expect_stdout_eq
+#define cr_expect_stdout_eq(...)                CR_EXPAND(cr_assert_redir_f_unop_va_(CR_FAIL_CONTINUES_, cr_stdout_match_file, ==, stdout, __VA_ARGS__))
+#undef cr_assert_stdout_neq
+#define cr_assert_stdout_neq(...)               CR_EXPAND(cr_assert_redir_f_unop_va_(CR_FAIL_ABORT_, cr_stdout_match_file, !=, stdout, __VA_ARGS__))
+#undef cr_expect_stdout_neq
+#define cr_expect_stdout_neq(...)               CR_EXPAND(cr_assert_redir_f_unop_va_(CR_FAIL_CONTINUES_, cr_stdout_match_file, !=, stdout, __VA_ARGS__))
+#undef cr_assert_stderr_eq
+#define cr_assert_stderr_eq(...)                CR_EXPAND(cr_assert_redir_f_unop_va_(CR_FAIL_ABORT_, cr_stderr_match_file, ==, stderr, __VA_ARGS__))
+#undef cr_expect_stderr_eq
+#define cr_expect_stderr_eq(...)                CR_EXPAND(cr_assert_redir_f_unop_va_(CR_FAIL_CONTINUES_, cr_stderr_match_file, ==, stderr, __VA_ARGS__))
+#undef cr_assert_stderr_neq
+#define cr_assert_stderr_neq(...)               CR_EXPAND(cr_assert_redir_f_unop_va_(CR_FAIL_ABORT_, cr_stderr_match_file, !=, stderr, __VA_ARGS__))
+#undef cr_expect_stderr_neq
+#define cr_expect_stderr_neq(...)               CR_EXPAND(cr_assert_redir_f_unop_va_(CR_FAIL_CONTINUES_, cr_stderr_match_file, !=, stderr, __VA_ARGS__))
+
+#define cr_assert_redir_unop_(Fail, Fun, Op, File, Str, ...) \
+    CR_EXPAND(cr_assert_impl(                                \
+                Fail,                                        \
+                !(Fun((Str)) Op 0),                          \
+                dummy,                                       \
+                CRITERION_ASSERT_MSG_FILE_STR_MATCH,         \
+                (CR_STR(File), Str),                         \
+                __VA_ARGS__                                  \
+                ))
+
+#define cr_assert_redir_unop_va_(Fail, Fun, Op, ...) \
+    CR_EXPAND(cr_assert_redir_unop_(                 \
+                Fail,                                \
+                Fun,                                 \
+                Op,                                  \
+                CR_VA_HEAD(__VA_ARGS__),             \
+                CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)), \
+                CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))  \
+                ))
+
+#define cr_assert_redir_f_unop_(Fail, Fun, Op, File, Ref, ...) \
+    CR_EXPAND(cr_assert_impl(                                  \
+                Fail,                                          \
+                !(Fun((Ref)) Op 0),                            \
+                dummy,                                         \
+                CRITERION_ASSERT_MSG_FILE_MATCH,               \
+                (CR_STR(File), CR_STR(Ref)),                   \
+                __VA_ARGS__                                    \
+                ))
+
+#define cr_assert_redir_f_unop_va_(Fail, Fun, Op, ...) \
+    CR_EXPAND(cr_assert_redir_f_unop_(                 \
+                Fail,                                  \
+                Fun,                                   \
+                Op,                                    \
+                CR_VA_HEAD(__VA_ARGS__),               \
+                CR_VA_HEAD(CR_VA_TAIL(__VA_ARGS__)),   \
+                CR_VA_TAIL(CR_VA_TAIL(__VA_ARGS__))    \
+                ))
 
 #endif /* !CRITERION_INTERNAL_REDIRECT_H_ */

include/criterion/internal/stdio_filebuf.hxx

@@ -1,138 +1,183 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright © 2015-2016 Franklin "Snaipe" Mathieu <http://snai.pe/>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
 #ifndef CRITERION_INTERNAL_STDIO_FILEBUF_HXX_
-# define CRITERION_INTERNAL_STDIO_FILEBUF_HXX_
+#define CRITERION_INTERNAL_STDIO_FILEBUF_HXX_
 
-# include <fstream>
+#include <fstream>
 
+/* *INDENT-OFF* */
 namespace criterion { namespace internal {
+/* *INDENT-ON* */
 
-    template <typename CharT, typename Traits = std::char_traits<CharT>>
-    class stdio_sync_filebuf : public std::basic_streambuf<CharT, Traits> {
-    public:
-        typedef Traits traits;
-        typedef std::basic_filebuf<CharT, Traits> super;
-        typedef typename Traits::int_type int_type;
-        typedef typename Traits::pos_type pos_type;
-        typedef typename Traits::off_type off_type;
+template <typename CharT, typename Traits = std::char_traits<CharT> >
+class stdio_sync_filebuf : public std::basic_streambuf<CharT, Traits> {
+public:
+    typedef Traits traits;
+    typedef std::basic_filebuf<CharT, Traits> super;
+    typedef typename Traits::int_type int_type;
+    typedef typename Traits::pos_type pos_type;
+    typedef typename Traits::off_type off_type;
 
-        stdio_sync_filebuf(std::FILE *file)
-            : file(file)
-            , lastchar(Traits::eof())
-        {}
+    stdio_sync_filebuf(std::FILE *file)
+        : file(file),
+        lastchar(Traits::eof())
+    {}
 
-        stdio_sync_filebuf(stdio_sync_filebuf&& other) = default;
-        stdio_sync_filebuf& operator=(stdio_sync_filebuf&& other) = default;
+    stdio_sync_filebuf(stdio_sync_filebuf &&other) = default;
+    stdio_sync_filebuf &operator=(stdio_sync_filebuf &&other) = default;
 
-        void swap(stdio_sync_filebuf& other) {
-            super::swap(other);
-            std::swap(file, other.file);
-            std::swap(lastchar, other.lastchar);
-        }
+    void swap(stdio_sync_filebuf &other)
+    {
+        super::swap(other);
+        std::swap(file, other.file);
+        std::swap(lastchar, other.lastchar);
+    }
 
-    protected:
-        int_type syncgetc();
-        int_type syncungetc(int_type);
-        int_type syncputc(int_type);
+protected:
+    int_type syncgetc();
+    int_type syncungetc(int_type);
+    int_type syncputc(int_type);
 
-        virtual std::streampos seekoff(std::streamoff off,
-                std::ios_base::seekdir dir,
-                std::ios_base::openmode = std::ios_base::in | std::ios_base::out) {
+    virtual std::streampos seekoff(std::streamoff off,
+            std::ios_base::seekdir dir,
+            std::ios_base::openmode = std::ios_base::in | std::ios_base::out)
+    {
+        int whence;
 
-            int whence;
-            if (dir == std::ios_base::beg)
-                whence = SEEK_SET;
-            else if (dir == std::ios_base::cur)
-                whence = SEEK_CUR;
+        if (dir == std::ios_base::beg)
+            whence = SEEK_SET;
+        else if (dir == std::ios_base::cur)
+            whence = SEEK_CUR;
+        else
+            whence = SEEK_END;
+
+        if (!fseek(file, off, whence))
+            return std::streampos(std::ftell(file));
+        return std::streamoff(-1);
+    }
+
+    virtual std::streampos seekpos(std::streampos pos,
+            std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out)
+    {
+        return seekoff(std::streamoff(pos), std::ios_base::beg, mode);
+    }
+
+    virtual std::streamsize xsgetn(CharT *s, std::streamsize n);
+    virtual std::streamsize xsputn(const CharT *s, std::streamsize n);
+
+    virtual int sync()
+    {
+        return std::fflush(file);
+    }
+
+    virtual int_type underflow()
+    {
+        int_type c = syncgetc();
+
+        return syncungetc(c);
+    }
+
+    virtual int_type uflow()
+    {
+        return lastchar = syncgetc();
+    }
+
+    static inline bool is_eof(int_type c)
+    {
+        static const int_type eof = Traits::eof();
+
+        return Traits::eq_int_type(c, eof);
+    }
+
+    virtual int_type overflow(int_type c = Traits::eof())
+    {
+        int_type ret;
+
+        if (is_eof(c)) {
+            if (std::fflush(file))
+                ret = Traits::eof();
             else
-                whence = SEEK_END;
-
-            if (!fseek(file, off, whence))
-                return std::streampos(std::ftell(file));
-            return std::streamoff(-1);
+                ret = Traits::not_eof(c);
+        } else {
+            ret = syncputc(c);
         }
-
-        virtual std::streampos seekpos(std::streampos pos,
-                std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out) {
-            return seekoff(std::streamoff(pos), std::ios_base::beg, mode);
-        }
-
-        virtual std::streamsize xsgetn(CharT* s, std::streamsize n);
-        virtual std::streamsize xsputn(const CharT* s, std::streamsize n);
-
-        virtual int sync() {
-            return std::fflush(file);
-        }
-
-        virtual int_type underflow() {
-            int_type c = syncgetc();
-            return syncungetc(c);
-        }
-
-        virtual int_type uflow() {
-            return lastchar = syncgetc();
-        }
-
-        static inline bool is_eof(int_type c) {
-            static const int_type eof = Traits::eof();
-            return Traits::eq_int_type(c, eof);
-        }
-
-        virtual int_type overflow(int_type c = Traits::eof()) {
-            int_type ret;
-            if (is_eof(c)) {
-                if (std::fflush(file))
-                    ret = Traits::eof();
-                else
-                    ret = Traits::not_eof(c);
-            } else {
-                ret = syncputc(c);
-            }
-            return ret;
-        }
-
-        virtual int_type pbackfail(int_type c = Traits::eof()) {
-            int_type ret = syncungetc(is_eof(c) && !is_eof(lastchar) ? lastchar : c);
-            lastchar = Traits::eof();
-            return ret;
-        }
-
-    private:
-        std::FILE *file;
-        bool file_open;
-        int_type lastchar;
-    };
-
-    template <>
-    inline stdio_sync_filebuf<char>::int_type
-    stdio_sync_filebuf<char>::syncgetc() {
-        return std::getc(file);
+        return ret;
     }
 
-    template <>
-    inline stdio_sync_filebuf<char>::int_type
-    stdio_sync_filebuf<char>::syncungetc(stdio_sync_filebuf<char>::int_type c) {
-        return std::ungetc(c, file);
+    virtual int_type pbackfail(int_type c = Traits::eof())
+    {
+        int_type ret = syncungetc(is_eof(c) && !is_eof(lastchar) ? lastchar : c);
+
+        lastchar = Traits::eof();
+        return ret;
     }
 
-    template <>
-    inline stdio_sync_filebuf<char>::int_type
-    stdio_sync_filebuf<char>::syncputc(stdio_sync_filebuf<char>::int_type c) {
-        return std::putc(c, file);
-    }
+private:
+    std::FILE *file;
+    bool file_open;
+    int_type lastchar;
+};
 
-    template <>
-    inline std::streamsize
-    stdio_sync_filebuf<char>::xsgetn(char *s, std::streamsize n) {
-        std::streamsize res = std::fread(s, 1, n, file);
-        lastchar = res > 0 ? traits::to_int_type(s[res - 1]) : traits::eof();
-        return res;
-    }
+template <>
+inline stdio_sync_filebuf<char>::int_type
+stdio_sync_filebuf<char>::syncgetc()
+{
+    return std::getc(file);
+}
 
-    template <>
-    inline std::streamsize
-    stdio_sync_filebuf<char>::xsputn(const char *s, std::streamsize n) {
-        return std::fwrite(s, 1, n, file);
-    }
+template <>
+inline stdio_sync_filebuf<char>::int_type
+stdio_sync_filebuf<char>::syncungetc(stdio_sync_filebuf<char>::int_type c)
+{
+    return std::ungetc(c, file);
+}
 
+template <>
+inline stdio_sync_filebuf<char>::int_type
+stdio_sync_filebuf<char>::syncputc(stdio_sync_filebuf<char>::int_type c)
+{
+    return std::putc(c, file);
+}
+
+template <>
+inline std::streamsize
+stdio_sync_filebuf<char>::xsgetn(char *s, std::streamsize n)
+{
+    std::streamsize res = std::fread(s, 1, n, file);
+    lastchar = res > 0 ? traits::to_int_type(s[res - 1]) : traits::eof();
+    return res;
+}
+
+template <>
+inline std::streamsize
+stdio_sync_filebuf<char>::xsputn(const char *s, std::streamsize n)
+{
+    return std::fwrite(s, 1, n, file);
+}
+
+/* *INDENT-OFF* */
 }}
+/* *INDENT-ON* */
 
 #endif /* !CRITERION_INTERNAL_STDIO_FILEBUF_HXX_ */

include/criterion/internal/stream.hxx

@@ -1,110 +1,141 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright © 2015-2016 Franklin "Snaipe" Mathieu <http://snai.pe/>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
 #ifndef CRITERION_INTERNAL_STREAM_HXX_
-# define CRITERION_INTERNAL_STREAM_HXX_
+#define CRITERION_INTERNAL_STREAM_HXX_
 
-# include <fstream>
-# include <cstdio>
-# include <memory>
+#include <fstream>
+#include <cstdio>
+#include <memory>
 
-# include "stdio_filebuf.hxx"
+#include "stdio_filebuf.hxx"
 
+/* *INDENT-OFF* */
 namespace criterion { namespace internal {
+/* *INDENT-ON* */
 
-    template <typename CharT, typename Super>
-    class stream_mixin : public Super {
+template <typename CharT, typename Super>
+class stream_mixin : public Super {
 public:
-        stream_mixin(FILE* f)
-            : Super()
-            , fbuf(new stdio_sync_filebuf<CharT>(f))
-            , file(f)
-        {
-            std::ios::rdbuf(&*fbuf);
-        }
+    stream_mixin(FILE *f)
+        : Super(),
+        fbuf(new stdio_sync_filebuf<CharT>(f)),
+        file(f)
+    {
+        std::ios::rdbuf(&*fbuf);
+    }
 
-# if __cplusplus > 199711L
-        stream_mixin(const stream_mixin& other) = delete;
-        stream_mixin& operator=(const stream_mixin& other) = delete;
-# endif
+#if __cplusplus > 199711L
+    stream_mixin(const stream_mixin &other) = delete;
+    stream_mixin &operator=(const stream_mixin &other) = delete;
+#endif
 
-        stream_mixin(stream_mixin&& other) :
-            fbuf(std::move(other.fbuf)),
-            file(std::move(other.file))
-        {}
+    stream_mixin(stream_mixin &&other) :
+        fbuf(std::move(other.fbuf)),
+        file(std::move(other.file))
+    {}
 
-        stream_mixin& operator=(stream_mixin&& other) {
-            fbuf = std::move(other.fbuf);
-            file = std::move(other.file);
-        }
+    stream_mixin &operator=(stream_mixin &&other)
+    {
+        fbuf = std::move(other.fbuf);
+        file = std::move(other.file);
+    }
 
-        void close(void) {
-            Super::flush();
-            Super::close();
-            std::fclose(file);
-        }
+    void close(void)
+    {
+        Super::flush();
+        Super::close();
+        std::fclose(file);
+    }
 
-    private:
-        std::shared_ptr<stdio_sync_filebuf<CharT>> fbuf;
-        std::FILE* file;
-    };
+private:
+    std::shared_ptr<stdio_sync_filebuf<CharT> > fbuf;
+    std::FILE *file;
+};
 
-    template <typename CharT>
-    class basic_ofstream : public stream_mixin<CharT, std::basic_ofstream<CharT>> {
-        typedef stream_mixin<CharT, std::basic_ofstream<CharT>> super;
-    public:
-        basic_ofstream(FILE* f)
-            : super(f)
-        {}
+template <typename CharT>
+class basic_ofstream : public stream_mixin<CharT, std::basic_ofstream<CharT> > {
+typedef stream_mixin<CharT, std::basic_ofstream<CharT> > super;
+public:
+    basic_ofstream(FILE *f)
+        : super(f)
+    {}
 
-        basic_ofstream(basic_ofstream&& other)
-            : super(std::move(other))
-        {}
-    };
+    basic_ofstream(basic_ofstream &&other)
+        : super(std::move(other))
+    {}
+};
 
-    template <typename CharT>
-    class basic_ifstream : public stream_mixin<CharT, std::basic_ifstream<CharT>> {
-        typedef stream_mixin<CharT, std::basic_ifstream<CharT>> super;
-    public:
-        basic_ifstream(FILE* f)
-            : super(f)
-        {}
+template <typename CharT>
+class basic_ifstream : public stream_mixin<CharT, std::basic_ifstream<CharT> > {
+typedef stream_mixin<CharT, std::basic_ifstream<CharT> > super;
+public:
+    basic_ifstream(FILE *f)
+        : super(f)
+    {}
 
-        basic_ifstream(basic_ifstream&& other)
-            : super(std::move(other))
-        {}
-    };
+    basic_ifstream(basic_ifstream &&other)
+        : super(std::move(other))
+    {}
+};
 
-    template <typename CharT>
-    class basic_fstream : public stream_mixin<CharT, std::basic_fstream<CharT>> {
-        typedef stream_mixin<CharT, std::basic_fstream<CharT>> super;
-    public:
-        basic_fstream(FILE* f)
-            : super(f)
-        {}
+template <typename CharT>
+class basic_fstream : public stream_mixin<CharT, std::basic_fstream<CharT> > {
+typedef stream_mixin<CharT, std::basic_fstream<CharT> > super;
+public:
+    basic_fstream(FILE *f)
+        : super(f)
+    {}
 
-        basic_fstream(basic_fstream&& other)
-            : super(std::move(other))
-        {}
-    };
+    basic_fstream(basic_fstream &&other)
+        : super(std::move(other))
+    {}
+};
 
-    struct get_redirected_out_stream_ {
-        static inline basic_ofstream<char>& call(std::FILE* f) {
-            static std::unique_ptr<basic_ofstream<char>> stream;
+struct get_redirected_out_stream_ {
+    static inline basic_ofstream<char> &call(std::FILE *f)
+    {
+        static std::unique_ptr<basic_ofstream<char> > stream;
 
-            if (!stream)
-                stream.reset(new basic_ofstream<char>(f));
-            return *stream;
-        }
+        if (!stream)
+            stream.reset(new basic_ofstream<char>(f));
+        return *stream;
+    }
+};
 
-    };
+struct get_redirected_in_stream_ {
+    static inline basic_ifstream<char> &call(std::FILE *f)
+    {
+        static std::unique_ptr<basic_ifstream<char> > stream;
 
-    struct get_redirected_in_stream_ {
-        static inline basic_ifstream<char>& call(std::FILE* f) {
-            static std::unique_ptr<basic_ifstream<char>> stream;
-            if (!stream)
-                stream.reset(new basic_ifstream<char>(f));
-            return *stream;
-        }
-    };
+        if (!stream)
+            stream.reset(new basic_ifstream<char>(f));
+        return *stream;
+    }
+};
 
+/* *INDENT-OFF* */
 }}
+/* *INDENT-ON* */
 
 #endif /* !CRITERION_INTERNAL_STREAM_HXX_ */

include/criterion/internal/test.h

@@ -22,45 +22,45 @@
  * THE SOFTWARE.
  */
 #ifndef CRITERION_INTERNAL_TEST_H_
-# define CRITERION_INTERNAL_TEST_H_
+#define CRITERION_INTERNAL_TEST_H_
 
-# include "designated-initializer-compat.h"
-# include "common.h"
+#include "designated-initializer-compat.h"
+#include "common.h"
 
-# ifdef __OBJC__
-#import <Foundation/Foundation.h>
-# endif
+#ifdef __OBJC__
+# import <Foundation/Foundation.h>
+#endif
 
-# ifdef __cplusplus
-#  include <exception>
-# endif
+#ifdef __cplusplus
+# include <exception>
+#endif
 
-# define CR_IDENTIFIER_(Category, Name, Suffix) \
+#define CR_IDENTIFIER_(Category, Name, Suffix) \
     Category ## _ ## Name ## _ ## Suffix
 
-# ifdef __cplusplus
-#  ifdef __OBJC__
-#   define CR_LANG CR_LANG_OBJCXX
-#  else
-#   define CR_LANG CR_LANG_CXX
-#  endif
+#ifdef __cplusplus
+# ifdef __OBJC__
+#  define CR_LANG    CR_LANG_OBJCXX
 # else
-#  ifdef __OBJC__
-#   define CR_LANG CR_LANG_OBJC
-#  else
-#   define CR_LANG CR_LANG_C
-#  endif
+#  define CR_LANG    CR_LANG_CXX
 # endif
+#else
+# ifdef __OBJC__
+#  define CR_LANG    CR_LANG_OBJC
+# else
+#  define CR_LANG    CR_LANG_C
+# endif
+#endif
 
-# ifdef __cplusplus
-#  define CR_TEST_PROTOTYPE_(Category, Name) \
+#ifdef __cplusplus
+# define CR_TEST_PROTOTYPE_(Category, Name) \
     extern "C" void CR_IDENTIFIER_(Category, Name, impl)(void)
-# else
-#  define CR_TEST_PROTOTYPE_(Category, Name) \
+#else
+# define CR_TEST_PROTOTYPE_(Category, Name) \
     void CR_IDENTIFIER_(Category, Name, impl)(void)
-# endif
+#endif
 
-# define CR_SUITE_IDENTIFIER_(Name, Suffix) \
+#define CR_SUITE_IDENTIFIER_(Name, Suffix) \
     suite_ ## Name ## _ ## Suffix
 
 CR_BEGIN_C_API
@@ -78,108 +78,123 @@ static const char *const cr_msg_test_main_other_exception = "Caught some unexpec
 static const char *const cr_msg_test_fini_std_exception = "Caught an unexpected exception during the test finalization: %s.";
 static const char *const cr_msg_test_fini_other_exception = "Caught some unexpected exception during the test finalization.";
 
-# ifdef __cplusplus
-# define CR_TEST_TRAMPOLINE_(Category, Name)                                                        \
-    static inline void CR_IDENTIFIER_(Category, Name, jmp)(void) {                                  \
-        try {                                                                                       \
-            criterion_internal_test_setup();                                                        \
-        } catch (const std::exception &e) {                                                         \
-            criterion_test_die(cr_msg_test_init_std_exception, e.what());                           \
-        } catch (...) {                                                                             \
-            criterion_test_die(cr_msg_test_init_other_exception);                                   \
-        }                                                                                           \
-        try {                                                                                       \
-            criterion_internal_test_main((void(*)(void)) CR_IDENTIFIER_(Category, Name, impl));     \
-        } catch (const std::exception &e) {                                                         \
-            criterion_test_die(cr_msg_test_main_std_exception, e.what());                           \
-        } catch (...) {                                                                             \
-            criterion_test_die(cr_msg_test_main_other_exception);                                   \
-        }                                                                                           \
-        try {                                                                                       \
-            criterion_internal_test_teardown();                                                     \
-        } catch (const std::exception &e) {                                                         \
-            criterion_test_die(cr_msg_test_fini_std_exception, e.what());                           \
-        } catch (...) {                                                                             \
-            criterion_test_die(cr_msg_test_fini_other_exception);                                   \
-        }                                                                                           \
+#ifdef __cplusplus
+# define CR_TEST_TRAMPOLINE_(Category, Name)                                                    \
+    static inline void CR_IDENTIFIER_(Category, Name, jmp)(void) {                              \
+        try {                                                                                   \
+            criterion_internal_test_setup();                                                    \
+        } catch (const std::exception &e) {                                                     \
+            criterion_test_die(cr_msg_test_init_std_exception, e.what());                       \
+        } catch (...) {                                                                         \
+            criterion_test_die(cr_msg_test_init_other_exception);                               \
+        }                                                                                       \
+        try {                                                                                   \
+            criterion_internal_test_main((void (*)(void))CR_IDENTIFIER_(Category, Name, impl)); \
+        } catch (const std::exception &e) {                                                     \
+            criterion_test_die(cr_msg_test_main_std_exception, e.what());                       \
+        } catch (...) {                                                                         \
+            criterion_test_die(cr_msg_test_main_other_exception);                               \
+        }                                                                                       \
+        try {                                                                                   \
+            criterion_internal_test_teardown();                                                 \
+        } catch (const std::exception &e) {                                                     \
+            criterion_test_die(cr_msg_test_fini_std_exception, e.what());                       \
+        } catch (...) {                                                                         \
+            criterion_test_die(cr_msg_test_fini_other_exception);                               \
+        }                                                                                       \
+    }
+#else
+# if defined (__OBJC__) && defined (__EXCEPTIONS)
+#  define CR_TEST_TRAMPOLINE_(Category, Name)                                                   \
+    static inline void CR_IDENTIFIER_(Category, Name, jmp)(void) {                              \
+        @try {                                                                                  \
+            criterion_internal_test_setup();                                                    \
+        } @catch (NSException *e) {                                                             \
+            NSString *reason = [e reason];                                                      \
+            criterion_test_die(cr_msg_test_init_std_exception, [reason UTF8String]);            \
+        } @catch (...) {                                                                        \
+            criterion_test_die(cr_msg_test_init_other_exception);                               \
+        }                                                                                       \
+        @try {                                                                                  \
+            criterion_internal_test_main((void (*)(void))CR_IDENTIFIER_(Category, Name, impl)); \
+        } @catch (NSException *e) {                                                             \
+            NSString *reason = [e reason];                                                      \
+            criterion_test_die(cr_msg_test_main_std_exception, [reason UTF8String]);            \
+        } @catch (...) {                                                                        \
+            criterion_test_die(cr_msg_test_main_other_exception);                               \
+        }                                                                                       \
+        @try {                                                                                  \
+            criterion_internal_test_teardown();                                                 \
+        } @catch (NSException *e) {                                                             \
+            NSString *reason = [e reason];                                                      \
+            criterion_test_die(cr_msg_test_fini_std_exception, [reason UTF8String]);            \
+        } @catch (...) {                                                                        \
+            criterion_test_die(cr_msg_test_fini_other_exception);                               \
+        }                                                                                       \
     }
 # else
-#  if defined(__OBJC__) && defined(__EXCEPTIONS)
-#   define CR_TEST_TRAMPOLINE_(Category, Name)                                                      \
-    static inline void CR_IDENTIFIER_(Category, Name, jmp)(void) {                                  \
-        @try {                                                                                      \
-            criterion_internal_test_setup();                                                        \
-        } @catch (NSException *e) {                                                                 \
-            NSString *reason = [e reason];                                                          \
-            criterion_test_die(cr_msg_test_init_std_exception, [reason UTF8String]);                \
-        } @catch (...) {                                                                            \
-            criterion_test_die(cr_msg_test_init_other_exception);                                   \
-        }                                                                                           \
-        @try {                                                                                      \
-            criterion_internal_test_main((void(*)(void)) CR_IDENTIFIER_(Category, Name, impl));     \
-        } @catch (NSException *e) {                                                                 \
-            NSString *reason = [e reason];                                                          \
-            criterion_test_die(cr_msg_test_main_std_exception, [reason UTF8String]);                \
-        } @catch (...) {                                                                            \
-            criterion_test_die(cr_msg_test_main_other_exception);                                   \
-        }                                                                                           \
-        @try {                                                                                      \
-            criterion_internal_test_teardown();                                                     \
-        } @catch (NSException *e) {                                                                 \
-            NSString *reason = [e reason];                                                          \
-            criterion_test_die(cr_msg_test_fini_std_exception, [reason UTF8String]);                \
-        } @catch (...) {                                                                            \
-            criterion_test_die(cr_msg_test_fini_other_exception);                                   \
-        }                                                                                           \
+#  define CR_TEST_TRAMPOLINE_(Category, Name)                                               \
+    static inline void CR_IDENTIFIER_(Category, Name, jmp)(void) {                          \
+        criterion_internal_test_setup();                                                    \
+        criterion_internal_test_main((void (*)(void))CR_IDENTIFIER_(Category, Name, impl)); \
+        criterion_internal_test_teardown();                                                 \
     }
-#  else
-#   define CR_TEST_TRAMPOLINE_(Category, Name)                                                      \
-    static inline void CR_IDENTIFIER_(Category, Name, jmp)(void) {                                  \
-        criterion_internal_test_setup();                                                            \
-        criterion_internal_test_main((void(*)(void)) CR_IDENTIFIER_(Category, Name, impl));         \
-        criterion_internal_test_teardown();                                                         \
-    }
-#  endif
 # endif
+#endif
 
-# define CR_TEST_BASE(Category, Name, ...)                                     \
-    CR_TEST_PROTOTYPE_(Category, Name);                                        \
-    CR_TEST_TRAMPOLINE_(Category, Name)                                        \
-    struct criterion_test_extra_data CR_IDENTIFIER_(Category, Name, extra) =   \
-        CR_EXPAND(CRITERION_MAKE_STRUCT(criterion_test_extra_data,             \
-            .lang_ = CR_LANG,                                                  \
-            .kind_ = CR_TEST_NORMAL,                                           \
-            .param_ = (struct criterion_test_params(*)(void)) NULL,            \
-            .identifier_ = #Category "/" #Name,                                \
-            .file_    = __FILE__,                                              \
-            .line_    = __LINE__,                                              \
-            __VA_ARGS__                                                        \
-        ));                                                                    \
-    struct criterion_test CR_IDENTIFIER_(Category, Name, meta) = {             \
-        #Name,                                                                 \
-        #Category,                                                             \
-        CR_IDENTIFIER_(Category, Name, jmp),                                   \
-        &CR_IDENTIFIER_(Category, Name, extra)                                 \
-    };                                                                         \
-    CR_SECTION_("cr_tst")                                                      \
-    struct criterion_test *CR_IDENTIFIER_(Category, Name, ptr)                 \
-            = &CR_IDENTIFIER_(Category, Name, meta) CR_SECTION_SUFFIX_;        \
+#if defined (_MSC_VER)
+# define CR_COMPILER_    CR_COMP_MSVC
+#elif defined (__clang__)
+# define CR_COMPILER_    CR_COMP_CLANG
+#elif defined (__GNUC__)
+# define CR_COMPILER_    CR_COMP_GCC
+#else
+# define CR_COMPILER_    CR_COMP_UNKNOWN
+#endif
+
+#define CR_TEST_BASE(Category, Name, ...)                                    \
+    CR_TEST_PROTOTYPE_(Category, Name);                                      \
+    CR_TEST_TRAMPOLINE_(Category, Name)                                      \
+    struct criterion_test_extra_data CR_IDENTIFIER_(Category, Name, extra) = \
+            CR_EXPAND(CRITERION_MAKE_STRUCT(criterion_test_extra_data,       \
+                    .compiler_ = CR_COMPILER_,                               \
+                    .lang_ = CR_LANG,                                        \
+                    .kind_ = CR_TEST_NORMAL,                                 \
+                    .param_ = (struct criterion_test_params (*)(void))NULL,  \
+                    .identifier_ = #Category "/" #Name,                      \
+                    .file_    = __FILE__,                                    \
+                    .line_    = __LINE__,                                    \
+                    __VA_ARGS__                                              \
+                    ));                                                      \
+    struct criterion_test CR_IDENTIFIER_(Category, Name, meta) = {           \
+        #Name,                                                               \
+        #Category,                                                           \
+        CR_IDENTIFIER_(Category,  Name, jmp),                                \
+        &CR_IDENTIFIER_(Category, Name, extra)                               \
+    };                                                                       \
+    CR_SECTION_("cr_tst")                                                    \
+    struct criterion_test *CR_IDENTIFIER_(Category, Name, ptr)               \
+        = &CR_IDENTIFIER_(Category, Name, meta) CR_SECTION_SUFFIX_;          \
     CR_TEST_PROTOTYPE_(Category, Name)
 
-# define CR_SUITE_BASE(Name, ...)                                              \
-    struct criterion_test_extra_data CR_SUITE_IDENTIFIER_(Name, extra) =       \
-        CR_EXPAND(CRITERION_MAKE_STRUCT(criterion_test_extra_data,             \
-            .file_    = __FILE__,                                              \
-            .line_    = 0,                                                     \
-            __VA_ARGS__                                                        \
-        ));                                                                    \
-    struct criterion_suite CR_SUITE_IDENTIFIER_(Name, meta) = {                \
-        #Name,                                                                 \
-        &CR_SUITE_IDENTIFIER_(Name, extra),                                    \
-    };                                                                         \
-    CR_SECTION_("cr_sts")                                                      \
-    struct criterion_suite *CR_SUITE_IDENTIFIER_(Name, ptr)                    \
-	    = &CR_SUITE_IDENTIFIER_(Name, meta) CR_SECTION_SUFFIX_
+#define CR_SUITE_BASE(Name, ...)                                         \
+    struct criterion_test_extra_data CR_SUITE_IDENTIFIER_(Name, extra) = \
+            CR_EXPAND(CRITERION_MAKE_STRUCT(criterion_test_extra_data,   \
+                    .file_    = __FILE__,                                \
+                    .line_    = 0,                                       \
+                    __VA_ARGS__                                          \
+                    ));                                                  \
+    struct criterion_suite CR_SUITE_IDENTIFIER_(Name, meta) = {          \
+        #Name,                                                           \
+        &CR_SUITE_IDENTIFIER_(Name, extra),                              \
+    };                                                                   \
+    CR_SECTION_("cr_sts")                                                \
+    struct criterion_suite *CR_SUITE_IDENTIFIER_(Name, ptr)              \
+        = &CR_SUITE_IDENTIFIER_(Name, meta) CR_SECTION_SUFFIX_
 
+#undef Test
+#define Test(...)         CR_EXPAND(CR_TEST_BASE(__VA_ARGS__, .sentinel_ = 0))
+#undef TestSuite
+#define TestSuite(...)    CR_EXPAND(CR_SUITE_BASE(__VA_ARGS__, .sentinel_ = 0))
 
 #endif /* !CRITERION_INTERNAL_TEST_H_ */

include/criterion/internal/theories.h

@@ -22,23 +22,24 @@
  * THE SOFTWARE.
  */
 #ifndef CRITERION_INTERNAL_THEORIES_H_
-# define CRITERION_INTERNAL_THEORIES_H_
+#define CRITERION_INTERNAL_THEORIES_H_
 
-# include "test.h"
+#include "test.h"
 
-# ifdef __cplusplus
-#  include <cstddef>
+#ifdef __cplusplus
+# include <cstddef>
 using std::size_t;
-# else
-#  include <stddef.h>
-# endif
+#else
+# include <stddef.h>
+#endif
 
-# ifdef __cplusplus
+#ifdef __cplusplus
 template <typename... T>
-constexpr size_t criterion_va_num__(const T &...) {
-    return sizeof...(T);
+constexpr size_t criterion_va_num__(const T & ...)
+{
+    return sizeof ... (T);
 }
-# endif
+#endif
 
 struct criterion_datapoints {
     size_t size;
@@ -53,42 +54,51 @@ CR_API void cr_theory_main(struct criterion_datapoints *dps, size_t datapoints,
 
 CR_END_C_API
 
-# ifdef __cplusplus
-#  define CR_TH_VA_NUM(Type, ...)     criterion_va_num__(__VA_ARGS__)
-#  define CR_TH_TEMP_ARRAY(Type, ...) []() -> Type* { static Type arr[] = { __VA_ARGS__ }; return reinterpret_cast<Type*>(&arr); }()
-# else
-#  define CR_TH_VA_NUM(Type, ...) sizeof ((Type[]) { __VA_ARGS__ }) / sizeof (Type)
-#  define CR_TH_TEMP_ARRAY(Type, ...) &(Type[]) { __VA_ARGS__ }
-# endif
+#ifdef __cplusplus
+# define CR_TH_VA_NUM(Type, ...)        criterion_va_num__(__VA_ARGS__)
+# define CR_TH_TEMP_ARRAY(Type, ...)    []() -> Type * { static Type arr[] = { __VA_ARGS__ }; return reinterpret_cast<Type *>(&arr); } ()
+#else
+# define CR_TH_VA_NUM(Type, ...)        sizeof ((Type[]) { __VA_ARGS__ }) / sizeof (Type)
+# define CR_TH_TEMP_ARRAY(Type, ...)    & (Type[]) { __VA_ARGS__ }
+#endif
 
-# define CR_TH_INTERNAL_TDPS(Category, Name) \
+#define CR_TH_INTERNAL_TDPS(Category, Name) \
     static struct criterion_datapoints CR_IDENTIFIER_(Category, Name, dps)[]
 
-# define CR_TH_INTERNAL_TDP(Category, Name) \
+#define CR_TH_INTERNAL_TDP(Category, Name) \
     (CR_IDENTIFIER_(Category, Name, dps))
 
-# define CR_TH_INTERNAL_DP(Type, ...) { \
-        sizeof (Type), \
-        CR_EXPAND(CR_TH_VA_NUM(Type, __VA_ARGS__)), \
-        #Type, \
+#define CR_TH_INTERNAL_DP(Type, ...)                    \
+    {                                                   \
+        sizeof (Type),                                  \
+        CR_EXPAND(CR_TH_VA_NUM(Type, __VA_ARGS__)),     \
+        #Type,                                          \
         CR_EXPAND(CR_TH_TEMP_ARRAY(Type, __VA_ARGS__)), \
     }
 
-# define CR_NB_DATAPOINTS(Var) \
+#define CR_NB_DATAPOINTS(Var) \
     (sizeof (Var) / sizeof (struct criterion_datapoints))
 
-# define CR_VAARG_ID(Suffix, Category, Name, ...) \
+#define CR_VAARG_ID(Suffix, Category, Name, ...) \
     CR_IDENTIFIER_(Category, Name, Suffix)
 
-# define CR_THEORY_BASE(Args, ...)                                             \
-    void CR_EXPAND(CR_VAARG_ID(theory, __VA_ARGS__,))Args;                     \
-    CR_EXPAND(CR_TEST_BASE(__VA_ARGS__, .sentinel_ = 0)) {                     \
-        cr_theory_main(                                                        \
-                CR_EXPAND(CR_VAARG_ID(dps, __VA_ARGS__,)),                     \
-                CR_NB_DATAPOINTS(CR_EXPAND(CR_VAARG_ID(dps, __VA_ARGS__,))),   \
-                (void(*)(void)) CR_EXPAND(CR_VAARG_ID(theory, __VA_ARGS__,))   \
-            );                                                                 \
-    }                                                                          \
-    void CR_EXPAND(CR_VAARG_ID(theory, __VA_ARGS__,))Args
+#define CR_THEORY_BASE(Args, ...)                                         \
+    void CR_EXPAND(CR_VAARG_ID(theory, __VA_ARGS__, )) Args;              \
+    CR_EXPAND(CR_TEST_BASE(__VA_ARGS__, .sentinel_ = 0)) {                \
+        cr_theory_main(                                                   \
+            CR_EXPAND(CR_VAARG_ID(dps, __VA_ARGS__, )),                   \
+            CR_NB_DATAPOINTS(CR_EXPAND(CR_VAARG_ID(dps, __VA_ARGS__, ))), \
+            (void (*)(void))CR_EXPAND(CR_VAARG_ID(theory, __VA_ARGS__, )) \
+            );                                                            \
+    }                                                                     \
+    void CR_EXPAND(CR_VAARG_ID(theory, __VA_ARGS__, )) Args
+
+#define cr_assume_op_(Op, Actual, Expected)    cr_assume((Actual) Op (Expected))
+
+#define cr_assume_str_op_(Op, Actual, Expected) \
+    cr_assume(strcmp((Actual), (Expected)) Op 0)
+
+#undef Theory
+#define Theory(Args, ...)                      CR_EXPAND(CR_THEORY_BASE(Args, __VA_ARGS__))
 
 #endif /* !CRITERION_INTERNAL_THEORIES_H_ */

include/criterion/logging.h

@@ -21,19 +21,19 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/**
+ * @file
+ * @brief Logging functions
+ *****************************************************************************/
 #ifndef CRITERION_LOGGING_H_
-# define CRITERION_LOGGING_H_
+#define CRITERION_LOGGING_H_
 
-# ifdef __cplusplus
-#  include <cstdarg>
-using std::va_list;
-# else
-#  include <stdbool.h>
-#  include <stdarg.h>
-# endif
-# include "internal/common.h"
-# include "internal/ordered-set.h"
-# include "stats.h"
+#include "internal/common.h"
+#include "internal/ordered-set.h"
+#include "internal/deprecation.h"
+#include "stats.h"
+
+CR_BEGIN_C_API
 
 enum criterion_logging_level {
     CRITERION_INFO = 1,
@@ -42,72 +42,66 @@ enum criterion_logging_level {
     CRITERION_LOG_LEVEL_QUIET = 1 << 30,
 };
 
-enum criterion_logging_prefix {
-    CRITERION_LOGGING_PREFIX_DASHES,
-    CRITERION_LOGGING_PREFIX_EQUALS,
-    CRITERION_LOGGING_PREFIX_RUN,
-    CRITERION_LOGGING_PREFIX_SKIP,
-    CRITERION_LOGGING_PREFIX_PASS,
-    CRITERION_LOGGING_PREFIX_FAIL,
-    CRITERION_LOGGING_PREFIX_ERR,
+enum criterion_severity {
+    CR_LOG_INFO,
+    CR_LOG_WARNING,
+    CR_LOG_ERROR,
 };
 
-struct criterion_prefix_data {
-    const char *prefix;
-    const char *color;
-};
-
-# ifdef CRITERION_LOGGING_COLORS
-#  define CRIT_COLOR_NORMALIZE(Str) (criterion_options.use_ascii ? "" : Str)
-
-#  define CRIT_FG_BOLD  "\33[0;1m"
-#  define CRIT_FG_RED   "\33[0;31m"
-#  define CRIT_FG_GREEN "\33[0;32m"
-#  define CRIT_FG_GOLD  "\33[0;33m"
-#  define CRIT_FG_BLUE  "\33[0;34m"
-#  define CRIT_RESET    "\33[0m"
-
-#  define CR_FG_BOLD  CRIT_COLOR_NORMALIZE(CRIT_FG_BOLD)
-#  define CR_FG_RED   CRIT_COLOR_NORMALIZE(CRIT_FG_RED)
-#  define CR_FG_GREEN CRIT_COLOR_NORMALIZE(CRIT_FG_GREEN)
-#  define CR_FG_GOLD  CRIT_COLOR_NORMALIZE(CRIT_FG_GOLD)
-#  define CR_FG_BLUE  CRIT_COLOR_NORMALIZE(CRIT_FG_BLUE)
-#  define CR_RESET    CRIT_COLOR_NORMALIZE(CRIT_RESET)
-# endif
-
-CR_BEGIN_C_API
-
-extern const struct criterion_prefix_data g_criterion_logging_prefixes[];
-
-# define CRITERION_PREFIX_DASHES (&g_criterion_logging_prefixes[CRITERION_LOGGING_PREFIX_DASHES])
-# define CRITERION_PREFIX_EQUALS (&g_criterion_logging_prefixes[CRITERION_LOGGING_PREFIX_EQUALS])
-# define CRITERION_PREFIX_RUN    (&g_criterion_logging_prefixes[CRITERION_LOGGING_PREFIX_RUN   ])
-# define CRITERION_PREFIX_SKIP   (&g_criterion_logging_prefixes[CRITERION_LOGGING_PREFIX_SKIP  ])
-# define CRITERION_PREFIX_PASS   (&g_criterion_logging_prefixes[CRITERION_LOGGING_PREFIX_PASS  ])
-# define CRITERION_PREFIX_FAIL   (&g_criterion_logging_prefixes[CRITERION_LOGGING_PREFIX_FAIL  ])
-# define CRITERION_PREFIX_ERR    (&g_criterion_logging_prefixes[CRITERION_LOGGING_PREFIX_ERR   ])
-
-CR_API void criterion_vlog(enum criterion_logging_level level, const char *msg, va_list args);
-
-CR_FORMAT(printf, 3, 4)
-CR_API void criterion_plog(enum criterion_logging_level level, const struct criterion_prefix_data *prefix, const char *msg, ...);
-
+/**
+ * Prints a log message
+ *
+ * One can use this function, but it is more convenient to use the 3 macros.
+ *
+ * @param[in] severity Severity level of the log message
+ * @param[in] msg printf like format string
+ * @param[in] ... Additional arguments depending on msg
+ *
+ *****************************************************************************/
 CR_FORMAT(printf, 2, 3)
-CR_API void criterion_log(enum criterion_logging_level level, const char *msg, ...);
+CR_API void cr_log(enum criterion_severity severity, const char *msg, ...);
 
-# define criterion_info(...) criterion_log(CRITERION_INFO, __VA_ARGS__)
-# define criterion_important(...) criterion_log(CRITERION_IMPORTANT, __VA_ARGS__)
+/**
+ * Prints a info message
+ *
+ * Call: cr_log_info(msg, ...)\n
+ * Prints a info message defined by msg and the following optional parameters
+ *
+ * @param[in] msg printf like format string
+ * @param[in] ... Additional arguments depending on msg
+ *
+ *****************************************************************************/
+#define cr_log_info(...)     cr_log(CR_LOG_INFO, __VA_ARGS__)
 
-# define criterion_pinfo(...) criterion_plog(CRITERION_INFO, __VA_ARGS__)
-# define criterion_pimportant(...) criterion_plog(CRITERION_IMPORTANT, __VA_ARGS__)
+/**
+ * Prints a warning message
+ *
+ * Call: cr_log_warn(msg, ...)\n
+ * Prints a warning message defined by msg and the following optional parameters
+ *
+ * @param[in] msg printf like format string
+ * @param[in] ... Additional arguments depending on msg
+ *
+ *****************************************************************************/
+#define cr_log_warn(...)     cr_log(CR_LOG_WARNING, __VA_ARGS__)
 
-# define criterion_perror(...) criterion_plog(CRITERION_IMPORTANT, CRITERION_PREFIX_ERR, __VA_ARGS__)
+/**
+ * Prints a error message
+ *
+ * Call: cr_log_error(msg, ...)\n
+ * Prints a error message defined by msg and the following optional parameters
+ *
+ * @param[in] msg printf like format string
+ * @param[in] ... Additional arguments depending on msg
+ *
+ *****************************************************************************/
+#define cr_log_error(...)    cr_log(CR_LOG_ERROR, __VA_ARGS__)
 
 struct criterion_logger {
     void (*log_pre_all      )(struct criterion_test_set *set);
     void (*log_pre_suite    )(struct criterion_suite_set *set);
-    void (*log_pre_init     )(struct criterion_test *test);
-    void (*log_pre_test     )(struct criterion_test *test);
+    void (*log_pre_init     )(struct criterion_suite *suite, struct criterion_test *test);
+    void (*log_pre_test     )(struct criterion_suite *suite, struct criterion_test *test);
     void (*log_assert       )(struct criterion_assert_stats *stats);
     void (*log_theory_fail  )(struct criterion_theory_stats *stats);
     void (*log_test_timeout )(struct criterion_test_stats *stats);
@@ -119,12 +113,64 @@ struct criterion_logger {
     void (*log_post_fini    )(struct criterion_test_stats *stats);
     void (*log_post_suite   )(struct criterion_suite_stats *stats);
     void (*log_post_all     )(struct criterion_global_stats *stats);
+    void (*log_message      )(enum criterion_severity, const char *msg);
 };
 
 extern struct criterion_logger normal_logging;
 
 CR_END_C_API
 
-#define CR_NORMAL_LOGGING (&normal_logging)
+#define CR_NORMAL_LOGGING    (&normal_logging)
+
+#ifdef __cplusplus
+# include <sstream>
+
+namespace criterion
+{ namespace logging
+  {
+  static void(*const log)(enum criterion_severity, const char *, ...) = cr_log;
+
+  class streambuf : public std::stringbuf {
+  public:
+      streambuf(enum criterion_severity severity__)
+          : std::stringbuf(), severity__(severity__)
+      {}
+
+      virtual int sync() override
+      {
+          criterion::logging::log(severity__, "%s", str().c_str());
+          str(std::string());
+          return 0;
+      }
+  private:
+      enum criterion_severity severity__;
+  };
+
+  class stream : public std::ostream {
+  public:
+      stream(enum criterion_severity severity__)
+          : std::ostream(&buf), buf(severity__)
+      {}
+  private:
+      streambuf buf;
+  };
+
+  stream info { CR_LOG_INFO };
+  stream warn { CR_LOG_WARNING };
+  stream error { CR_LOG_ERROR };
+  } }
+#endif
+
+/* Deprecated old logging system, schedule removal for 3.0 */
+#ifndef CRITERION_NO_COMPAT
+
+# define criterion_log(_, ...)           CR_DEPRECATED("criterion_log is deprecated, please use cr_log instead.") cr_log_info(__VA_ARGS__)
+# define criterion_info(...)             CR_DEPRECATED("criterion_info is deprecated, please use cr_log_info instead.") cr_log_info(__VA_ARGS__)
+# define criterion_pinfo(_, ...)         CR_DEPRECATED("criterion_pinfo is deprecated, please use cr_log_info instead.") cr_log_info(__VA_ARGS__)
+# define criterion_important(...)        CR_DEPRECATED("criterion_important is deprecated, please use cr_log_info instead.") cr_log_info(__VA_ARGS__)
+# define criterion_pimportant(_, ...)    CR_DEPRECATED("criterion_pimportant is deprecated, please use cr_log_info instead.") cr_log_info(__VA_ARGS__)
+# define criterion_perror(...)           CR_DEPRECATED("criterion_perror is deprecated, please use cr_log_error instead.") cr_log_error(__VA_ARGS__)
+
+#endif /* !CRITERION_NO_COMPAT */
 
 #endif /* !CRITERION_LOGGING_H_ */

include/criterion/options.h

@@ -21,14 +21,53 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/**
+ * @file
+ * @brief criterion options
+ *****************************************************************************/
 #ifndef CRITERION_OPTIONS_H_
-# define CRITERION_OPTIONS_H_
+#define CRITERION_OPTIONS_H_
 
-# include <stdbool.h>
-# include "logging.h"
+#include <stdbool.h>
+#include "logging.h"
+#include "internal/common.h"
+
+enum criterion_debugger {
+    /**
+     *  Do not run the underlying test in a debugger
+     */
+    CR_DBG_NONE,
+
+    /**
+     *  Run the test suspended, without a debugger, and print its PID.
+     *
+     *  Allows external debuggers to attach.
+     */
+    CR_DBG_IDLE,
+
+    /**
+     *  Run the test with a debugging server compatible with the compiler
+     *  it was built with.
+     */
+    CR_DBG_NATIVE,
+
+    /**
+     *  Run the test with gdbserver
+     */
+    CR_DBG_GDB,
+
+    /**
+     *  Run the test with lldb-server
+     */
+    CR_DBG_LLDB,
+
+    /**
+     *  Run the test with windbg in server mode
+     */
+    CR_DBG_WINDBG,
+};
 
 struct criterion_options {
-
     /**
      *  The current logging threshold.
      *
@@ -44,13 +83,7 @@ struct criterion_options {
     struct criterion_logger *logger;
 
     /**
-     *  Don't exit the child immediately after finishing to run the test
-     *  function, and perform a full cleanup.
-     *
-     *  Useful when tracking memory leaks, and is immediately implied when
-     *  running the process under valgrind.
-     *
-     *  default: false
+     * This option doesn't do anything and is deprecated.
      */
     bool no_early_exit;
 
@@ -105,6 +138,48 @@ struct criterion_options {
      *  default: true
      */
     bool measure_time;
+
+    /**
+     *  Whether criterion should wait for incoming connections in server mode
+     *
+     *  default: false
+     */
+    bool wait_for_clients;
+
+    /**
+     * Raise a debug trap to crash the test if an assert fails so that a
+     * debugger can gain control.
+     *
+     * default: false
+     */
+    bool crash;
+
+    /**
+     *  Whether criterion should run its tests in a debugging server.
+     *
+     *  The server hangs until a connection from a debugger gets accepted.
+     *
+     *  This forces jobs = 1 and crash = true.
+     *
+     *  default: CR_DBG_NONE;
+     */
+    enum criterion_debugger debug;
+
+    /**
+     *  The TCP port of the debugging server.
+     *
+     *  default: 1234
+     */
+    unsigned debug_port;
+
+    /**
+     *  The default timeout for each test when none is specified, in seconds.
+     *
+     *  If the value is non-positive, no timeout is applied.
+     *
+     *  default: 0
+     */
+    double timeout;
 };
 
 CR_BEGIN_C_API
@@ -112,7 +187,7 @@ CR_BEGIN_C_API
 /**
  *  The runtime options for the test runner.
  */
-extern struct criterion_options criterion_options;
+CR_API extern struct criterion_options criterion_options;
 
 CR_END_C_API
 

include/criterion/output.h

@@ -21,12 +21,16 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/*!
+ * @file
+ * @brief Report functions
+ *****************************************************************************/
 #ifndef CRITERION_OUTPUT_H_
-# define CRITERION_OUTPUT_H_
+#define CRITERION_OUTPUT_H_
 
-# include "stats.h"
+#include "stats.h"
 
-typedef void criterion_reporter(FILE *stream, struct criterion_global_stats *);
+typedef void criterion_reporter (FILE *stream, struct criterion_global_stats *);
 
 /**
  *  Register an output provider.
@@ -36,7 +40,7 @@ typedef void criterion_reporter(FILE *stream, struct criterion_global_stats *);
  *  @returns 1 if no output provider is registered at that name, 0 otherwise,
  *    and -1 on error.
  */
-int criterion_register_output_provider(const char *name, criterion_reporter *reporter);
+CR_API int criterion_register_output_provider(const char *name, criterion_reporter *reporter);
 
 /**
  *  Use an output provider to write a report in a specific path.
@@ -45,6 +49,6 @@ int criterion_register_output_provider(const char *name, criterion_reporter *rep
  *  @param[in] path The path to the file to write the report to.
  *  @returns -1 on error.
  */
-int criterion_add_output(const char *provider, const char *path);
+CR_API int criterion_add_output(const char *provider, const char *path);
 
 #endif /* !CRITERION_OUTPUT_H_ */

include/criterion/parameterized.h

@@ -21,12 +21,20 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/**
+ * @file
+ * @brief Parameterized tests
+ *****************************************************************************/
 #ifndef CRITERION_PARAMETERIZED_H_
-# define CRITERION_PARAMETERIZED_H_
+#define CRITERION_PARAMETERIZED_H_
 
-# include "alloc.h"
-# include "assert.h"
-# include "internal/parameterized.h"
+#include "alloc.h"
+#include "assert.h"
+
+/**
+ * @defgroup ParameterizedBase Parameterized test & generator macros
+ * @{
+ */
 
 /**
  *  ParameterizedTest(Type *param, Suite, Name, [Options...]) { Function Body }
@@ -39,45 +47,57 @@
  *  @param Type    The type of the parameter.
  *  @param Suite   The name of the test suite containing this test.
  *  @param Name    The name of the test.
- *  @param Options An optional sequence of designated initializer key/value
+ *  @param ...     An optional sequence of designated initializer key/value
  *    pairs as described in the `criterion_test_extra_data` structure
  *    (see criterion/types.h).
- *    Example: .exit_code = 1
+ *    Example: `.exit_code = 1`
  */
-# define ParameterizedTest(...) CR_EXPAND(CR_PARAM_TEST_BASE(__VA_ARGS__, .sentinel_ = 0))
+#define ParameterizedTest(Type, Suite, Name, ...)         internal
 
 /**
- *  ParameterizedTestParameters(Suite, Test) { Function Body }
- *
- *  Defines the parameter generator for the associated parameterized test.
+ *  Defines the parameter generator prototype for the associated parameterized
+ *  test.
  *
  *  @param Suite   The name of the test suite containing the test.
  *  @param Test    The name of the test.
  *  @returns A constructed instance of criterion::parameters, or the result of
  *    the cr_make_param_array macro.
  */
-# define ParameterizedTestParameters(Suite, Name) CR_PARAM_TEST_PARAMS(Suite, Name)
+#define ParameterizedTestParameters(Suite, Name)          internal
 
 /**
- *  cr_make_param_array(Type, Array, Len, [Cleanup]);
- *
  *  Constructs a parameter list used as a return value for a parameter generator.
  *
+ *  This is only recommended for C sources. For C++, use `criterion::parameters`
+ *  or `criterion_test_params`.
+ *
  *  @param Type     The type of the array subscript.
  *  @param Array    The array of parameters.
  *  @param Len      The length of the array.
  *  @param Cleanup  The optional cleanup function for the array.
  *  @returns The parameter list.
  */
-# define cr_make_param_array(...) CR_EXPAND(cr_make_param_array_(__VA_ARGS__))
+#define cr_make_param_array(Type, Array, Len, Cleanup)    internal
 
-# ifdef __cplusplus
-#  include <vector>
+/** @} */
 
-namespace criterion {
-    template <typename T>
-    using parameters = std::vector<T, criterion::allocator<T>>;
+#ifdef __cplusplus
+# include <vector>
+
+namespace criterion
+{
+/**
+ *  Represents a C++ dynamic parameter list for a parameter generator.
+ *
+ *  @ingroup ParameterizedBase
+ *
+ *  @param T The type of the parameter.
+ */
+template <typename T>
+using parameters = std::vector<T, criterion::allocator<T> >;
 }
-# endif
+#endif
+
+#include "internal/parameterized.h"
 
 #endif /* !CRITERION_PARAMETERIZED_H_ */

include/criterion/redirect.h

@@ -21,17 +21,20 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/**
+ * @file
+ * @brief Redirect functions and file asserts
+ *****************************************************************************/
 #ifndef CRITERION_REDIRECT_H_
-# define CRITERION_REDIRECT_H_
+#define CRITERION_REDIRECT_H_
 
-# include "internal/common.h"
-# include "internal/redirect.h"
+#include "internal/common.h"
 
-# ifdef __cplusplus
-#  include <cstdio>
-# else
-#  include <stdio.h>
-# endif
+#ifdef __cplusplus
+# include <cstdio>
+#else
+# include <stdio.h>
+#endif
 
 CR_BEGIN_C_API
 
@@ -56,21 +59,21 @@ CR_API void cr_redirect_stdin(void);
  *
  *  @returns the file handle.
  */
-CR_API CR_STDN FILE* cr_get_redirected_stdout(void);
+CR_API CR_STDN FILE *cr_get_redirected_stdout(void);
 
 /**
  *  Get a file handle representing the read-end of the redirected stderr.
  *
  *  @returns the file handle.
  */
-CR_API CR_STDN FILE* cr_get_redirected_stderr(void);
+CR_API CR_STDN FILE *cr_get_redirected_stderr(void);
 
 /**
  *  Get a file handle representing the write-end of the redirected stdin.
  *
  *  @returns the file handle.
  */
-CR_API CR_STDN FILE* cr_get_redirected_stdin(void);
+CR_API CR_STDN FILE *cr_get_redirected_stdin(void);
 
 /**
  *  Compare the contents of a file with a string.
@@ -79,7 +82,7 @@ CR_API CR_STDN FILE* cr_get_redirected_stdin(void);
  *  @param[in] str  The string to compare the contents to.
  *  @returns 1 if the contents of the file is equal to the string, 0 otherwise.
  */
-CR_API int cr_file_match_str(CR_STDN FILE* f, const char *str);
+CR_API int cr_file_match_str(CR_STDN FILE *f, const char *str);
 
 /**
  *  Compare the contents of a file with the contents of another file.
@@ -88,7 +91,7 @@ CR_API int cr_file_match_str(CR_STDN FILE* f, const char *str);
  *  @param[in] ref  The second file to compare the contents to.
  *  @returns 1 if the contents of the files are equal, 0 otherwise.
  */
-CR_API int cr_file_match_file(CR_STDN FILE* f, CR_STDN FILE* ref);
+CR_API int cr_file_match_file(CR_STDN FILE *f, CR_STDN FILE *ref);
 
 /**
  *  Create a file mock.
@@ -100,73 +103,472 @@ CR_API CR_STDN FILE *cr_mock_file_size(size_t max_size);
 
 CR_END_C_API
 
-# define cr_assert_file_contents_eq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_ABORT_,     cr_file_match_str, ==, __VA_ARGS__))
-# define cr_expect_file_contents_eq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_CONTINUES_, cr_file_match_str, ==, __VA_ARGS__))
+/**
+ * @defgroup FileAsserts File content assertions
+ * @{
+ */
 
-# define cr_assert_file_contents_neq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_ABORT_,     cr_file_match_str, !=, __VA_ARGS__))
-# define cr_expect_file_contents_neq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_CONTINUES_, cr_file_match_str, !=, __VA_ARGS__))
+/**
+ * Passes if the contents of \c File are equal to the string \c ExpectedContents
+ *
+ * Passes if the contents of \c File are equal to the string
+ * \c ExpectedContents.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] File Pointer to a FILE object that specifies an input stream
+ * @param[in] ExpectedContents C string with the ExpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_file_contents_eq_str(File, ExpectedContents, FormatString, ...)       internal
 
-# define cr_assert_file_contents_eq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_ABORT_,     cr_file_match_file, ==, __VA_ARGS__))
-# define cr_expect_file_contents_eq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_CONTINUES_, cr_file_match_file, ==, __VA_ARGS__))
+/**
+ * Passes if the contents of \c File are equal to the string \c ExpectedContents
+ *
+ * Passes if the contents of \c File are equal to the string
+ * \c ExpectedContents.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] File Pointer to a FILE object that specifies an input stream
+ * @param[in] ExpectedContents C string with the ExpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_file_contents_eq_str(File, ExpectedContents, FormatString, ...)       internal
 
-# define cr_assert_file_contents_neq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_ABORT_,     cr_file_match_file, !=, __VA_ARGS__))
-# define cr_expect_file_contents_neq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_CONTINUES_, cr_file_match_file, !=, __VA_ARGS__))
+/**
+ * Passes if the contents of \c File are not equal to the string
+ * \c UnexpectedContents
+ *
+ * Passes if the contents of \c File are not equal to the string
+ * \c UnexpectedContents.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] File Pointer to a FILE object that specifies an input stream
+ * @param[in] UnexpectedContents C string with the UnexpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_file_contents_neq_str(File, UnexpectedContents, FormatString, ...)    internal
 
-# define cr_assert_stdout_eq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_ABORT_,     cr_file_match_str, ==, cr_get_redirected_stdout(), __VA_ARGS__))
-# define cr_expect_stdout_eq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_CONTINUES_, cr_file_match_str, ==, cr_get_redirected_stdout(), __VA_ARGS__))
+/**
+ * Passes if the contents of \c File are not equal to the string
+ * \c UnexpectedContents
+ *
+ * Passes if the contents of \c File are not equal to the string
+ * \c UnexpectedContents.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] File Pointer to a FILE object that specifies an input stream
+ * @param[in] UnexpectedContents C string with the UnexpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_file_contents_neq_str(File, UnexpectedContents, FormatString, ...)    internal
 
-# define cr_assert_stdout_neq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_ABORT_,     cr_file_match_str, !=, cr_get_redirected_stdout(), __VA_ARGS__))
-# define cr_expect_stdout_neq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_CONTINUES_, cr_file_match_str, !=, cr_get_redirected_stdout(), __VA_ARGS__))
+/**
+ * Passes if the contents of \c File are equal to the contents of \c RefFile
+ *
+ * Passes if the contents of \c File are equal to the contents of \c RefFile.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] File Pointer to a FILE object that specifies an input stream
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_file_contents_eq(File, RefFile, FormatString, ...)                    internal
 
-# define cr_assert_stderr_eq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_ABORT_,     cr_file_match_str, ==, cr_get_redirected_stderr(), __VA_ARGS__))
-# define cr_expect_stderr_eq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_CONTINUES_, cr_file_match_str, ==, cr_get_redirected_stderr(), __VA_ARGS__))
+/**
+ * Passes if the contents of \c File are equal to the contents of \c RefFile
+ *
+ * Passes if the contents of \c File are equal to the contents of \c RefFile.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] File Pointer to a FILE object that specifies an input stream
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_file_contents_eq(File, RefFile, FormatString, ...)                    internal
 
-# define cr_assert_stderr_neq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_ABORT_,     cr_file_match_str, !=, cr_get_redirected_stderr(), __VA_ARGS__))
-# define cr_expect_stderr_neq_str(...) CR_EXPAND(cr_assert_redir_op_va_(CR_FAIL_CONTINUES_, cr_file_match_str, !=, cr_get_redirected_stderr(), __VA_ARGS__))
+/**
+ * Passes if the contents of \c File are not equal to the contents of
+ * \c RefFile
+ *
+ * Passes if the contents of \c File are not equal to the contents of
+ * \c RefFile.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] File Pointer to a FILE object that specifies an input stream
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_file_contents_neq(File, RefFile, FormatString, ...)                   internal
 
-# define cr_assert_stdout_eq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_ABORT_,     cr_file_match_file, ==, cr_get_redirected_stdout(), __VA_ARGS__))
-# define cr_expect_stdout_eq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_CONTINUES_, cr_file_match_file, ==, cr_get_redirected_stdout(), __VA_ARGS__))
+/**
+ * Passes if the contents of \c File are not equal to the contents of
+ * \c RefFile
+ *
+ * Passes if the contents of \c File are not equal to the contents of
+ * \c RefFile.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] File Pointer to a FILE object that specifies an input stream
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_file_contents_neq(File, RefFile, FormatString, ...)                   internal
 
-# define cr_assert_stdout_neq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_ABORT_,     cr_file_match_file, !=, cr_get_redirected_stdout(), __VA_ARGS__))
-# define cr_expect_stdout_neq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_CONTINUES_, cr_file_match_file, !=, cr_get_redirected_stdout(), __VA_ARGS__))
+/**@}*/
 
-# define cr_assert_stderr_eq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_ABORT_,     cr_file_match_file, ==, cr_get_redirected_stderr(), __VA_ARGS__))
-# define cr_expect_stderr_eq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_CONTINUES_, cr_file_match_file, ==, cr_get_redirected_stderr(), __VA_ARGS__))
+/**
+ * @defgroup StreamAsserts Standard stream assertions
+ * @{
+ */
 
-# define cr_assert_stderr_neq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_ABORT_,     cr_file_match_file, !=, cr_get_redirected_stderr(), __VA_ARGS__))
-# define cr_expect_stderr_neq(...) CR_EXPAND(cr_assert_redir_f_op_va_(CR_FAIL_CONTINUES_, cr_file_match_file, !=, cr_get_redirected_stderr(), __VA_ARGS__))
+/**
+ * Passes if the contents of \c stdout are equal to the contents of the string
+ * \c ExpectedContents
+ *
+ * Passes if the contents of \c stdout are equal to the contents of the string
+ * \c ExpectedContents.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] ExpectedContents C string with the ExpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_stdout_eq_str(ExpectedContents, FormatString, ...)                    internal
 
-# ifdef __cplusplus
-#  include "internal/stream.hxx"
+/**
+ * Passes if the contents of \c stdout are equal to the contents of the string
+ * \c ExpectedContents
+ *
+ * Passes if the contents of \c stdout are equal to the contents of the string
+ * \c ExpectedContents.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] ExpectedContents C string with the ExpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_stdout_eq_str(ExpectedContents, FormatString, ...)                    internal
 
-namespace criterion {
+/**
+ * Passes if the contents of \c stdout are not equal to the contents of the
+ * string \c UnexpectedContents
+ *
+ * Passes if the contents of \c stdout are not equal to the contents of the
+ * string \c UnexpectedContents.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] UnexpectedContents C string with the UnexpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_stdout_neq_str(UnexpectedContents, FormatString, ...)                 internal
 
-    typedef internal::basic_ofstream<char> ofstream;
-    typedef internal::basic_ifstream<char> ifstream;
-    typedef internal::basic_fstream<char>  fstream;
+/**
+ * Passes if the contents of \c stdout are not equal to the contents of the
+ * string \c UnexpectedContents
+ *
+ * Passes if the contents of \c stdout are not equal to the contents of the
+ * string \c UnexpectedContents.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] UnexpectedContents C string with the UnexpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_stdout_neq_str(UnexpectedContents, FormatString, ...)                 internal
 
-    static inline ofstream& get_redirected_cin(void) {
-        return internal::get_redirected_out_stream_::call(cr_get_redirected_stdin());
-    }
+/**
+ * Passes if the contents of \c stderr are equal to the contents of the string
+ * \c ExpectedContents
+ *
+ * Passes if the contents of \c stderr are equal to the contents of the string
+ * \c ExpectedContents.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] ExpectedContents C string with the ExpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_stderr_eq_str(ExpectedContents, FormatString, ...)                    internal
 
-    static inline ifstream& get_redirected_cout(void) {
-        return internal::get_redirected_in_stream_::call(cr_get_redirected_stdout());
-    }
+/**
+ * Passes if the contents of \c stderr are equal to the contents of the string
+ * \c ExpectedContents
+ *
+ * Passes if the contents of \c stderr are equal to the contents of the string
+ * \c ExpectedContents.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] ExpectedContents C string with the ExpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_stderr_eq_str(ExpectedContents, FormatString, ...)                    internal
 
-    static inline ifstream& get_redirected_cerr(void) {
-        return internal::get_redirected_in_stream_::call(cr_get_redirected_stderr());
-    }
+/**
+ * Passes if the contents of \c stderr are not equal to the contents of the
+ * string \c UnexpectedContents
+ *
+ * Passes if the contents of \c stderr are not equal to the contents of the
+ * string \c UnexpectedContents.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] UnexpectedContents C string with the UnexpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_stderr_neq_str(UnexpectedContents, FormatString, ...)                 internal
 
-#  if __GNUC__ >= 5
-    static inline fstream mock_file(size_t max_size) {
-        return fstream(cr_mock_file_size(max_size));
-    }
+/**
+ * Passes if the contents of \c stderr are not equal to the contents of the
+ * string \c UnexpectedContents
+ *
+ * Passes if the contents of \c stderr are not equal to the contents of the
+ * string \c UnexpectedContents.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] UnexpectedContents C string with the UnexpectedContents
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_stderr_neq_str(UnexpectedContents, FormatString, ...)                 internal
 
-    static inline fstream mock_file(void) {
-        return mock_file(4096);
-    }
-#  endif
+/**
+ * Passes if the contents of \c stdout are equal to the contents of \c RefFile
+ *
+ * Passes if the contents of \c stdout are equal to the contents of \c RefFile.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_stdout_eq(RefFile, FormatString, ...)                                 internal
+
+/**
+ * Passes if the contents of \c stdout are equal to the contents of \c RefFile
+ *
+ * Passes if the contents of \c stdout are equal to the contents of \c RefFile.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_stdout_eq(RefFile, FormatString, ...)                                 internal
+
+/**
+ * Passes if the contents of \c stdout are not equal to the contents of \c
+ * RefFile
+ *
+ * Passes if the contents of \c stdout are not equal to the contents of \c
+ * RefFile.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_stdout_neq(RefFile, FormatString, ...)                                internal
+
+/**
+ * Passes if the contents of \c stdout are not equal to the contents of \c
+ * RefFile
+ *
+ * Passes if the contents of \c stdout are not equal to the contents of \c
+ * RefFile.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_stdout_neq(RefFile, FormatString, ...)                                internal
+
+/**
+ * Passes if the contents of \c stderr are equal to the contents of \c RefFile
+ *
+ * Passes if the contents of \c stderr are equal to the contents of \c RefFile.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_stderr_eq(RefFile, FormatString, ...)                                 internal
+
+/**
+ * Passes if the contents of \c stderr are equal to the contents of \c RefFile
+ *
+ * Passes if the contents of \c stderr are equal to the contents of \c RefFile.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_stderr_eq(RefFile, FormatString, ...)                                 internal
+
+/**
+ * Passes if the contents of \c stderr are not equal to the contents of \c
+ * RefFile
+ *
+ * Passes if the contents of \c stderr are not equal to the contents of \c
+ * RefFile.
+ * Otherwise the test is marked as failure and the execution of the function
+ * is aborted.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_assert_stderr_neq(RefFile, FormatString, ...)                                internal
+
+/**
+ * Passes if the contents of \c stderr are not equal to the contents of \c
+ * RefFile
+ *
+ * Passes if the contents of \c stderr are not equal to the contents of \c
+ * RefFile.
+ * Otherwise the test is marked as failure but the execution will continue.
+ *
+ * The optional string is printed on failure.
+ *
+ * @param[in] RefFile Pointer to a FILE object that specifies an input stream
+ * @param[in] FormatString (optional) printf-like format string
+ * @param[in] ... (optional) format string parameters
+ *
+ *****************************************************************************/
+#define cr_expect_stderr_neq(RefFile, FormatString, ...)                                internal
+
+/**@}*/
+
+#ifdef __cplusplus
+# include "internal/stream.hxx"
+
+namespace criterion
+{
+typedef internal::basic_ofstream<char> ofstream;
+typedef internal::basic_ifstream<char> ifstream;
+typedef internal::basic_fstream<char> fstream;
+
+static inline ofstream &get_redirected_cin(void)
+{
+    return internal::get_redirected_out_stream_::call(cr_get_redirected_stdin());
+}
+
+static inline ifstream &get_redirected_cout(void)
+{
+    return internal::get_redirected_in_stream_::call(cr_get_redirected_stdout());
+}
+
+static inline ifstream &get_redirected_cerr(void)
+{
+    return internal::get_redirected_in_stream_::call(cr_get_redirected_stderr());
+}
+
+# if __GNUC__ >= 5
+static inline fstream mock_file(size_t max_size)
+{
+    return fstream(cr_mock_file_size(max_size));
+}
+
+static inline fstream mock_file(void)
+{
+    return mock_file(4096);
 }
 # endif
+}
+#endif
+
+#include "internal/redirect.h"
 
 #endif /* !CRITERION_REDIRECT_H_ */

include/criterion/stats.h

@@ -21,10 +21,21 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/*!
+ * @file
+ * @brief Test stats
+ *****************************************************************************/
 #ifndef CRITERION_STATS_H_
-# define CRITERION_STATS_H_
+#define CRITERION_STATS_H_
 
-# include "types.h"
+#include "types.h"
+#include "internal/deprecation.h"
+
+enum criterion_test_status {
+    CR_STATUS_PASSED = 0,
+    CR_STATUS_FAILED = 1,
+    CR_STATUS_SKIPPED = 2,
+};
 
 struct criterion_assert_stats {
     const char *message;
@@ -38,7 +49,8 @@ struct criterion_assert_stats {
 struct criterion_test_stats {
     struct criterion_test *test;
     struct criterion_assert_stats *asserts;
-    bool failed;
+    bool CR_DEPRECATED_MEMBER(failed);
+    enum criterion_test_status test_status;
     int passed_asserts;
     int failed_asserts;
     int signal;
@@ -48,6 +60,7 @@ struct criterion_test_stats {
     bool crashed;
     unsigned progress;
     const char *file;
+    const char *message;
 
     struct criterion_test_stats *next;
 };

include/criterion/theories.h

@@ -21,11 +21,14 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/*!
+ * @file
+ * @brief Theory tests
+ *****************************************************************************/
 #ifndef CRITERION_THEORIES_H_
-# define CRITERION_THEORIES_H_
+#define CRITERION_THEORIES_H_
 
-# include "criterion.h"
-# include "internal/theories.h"
+#include "criterion.h"
 
 CR_BEGIN_C_API
 
@@ -37,105 +40,361 @@ CR_API void cr_theory_abort(void);
 
 CR_END_C_API
 
-// Theory and datapoint macros
+/**
+ * @defgroup TheoryBase Theory and datapoint macros
+ * @{
+ */
 
 /**
- *  Theory((Params...), Suite, Name, [Options...]) { Function Body }
- *
  *  Defines a new theory test.
  *
  *  The parameters are selected from a cartesian product defined by a
  *  TheoryDataPoints macro.
  *
+ *  Example:
+ *  @code{.c}
+ *  Theory((int arg0, double arg1), suite, test) {
+ *      // function body
+ *  };
+ *  @endcode
+ *
  *  @param Params  A list of function parameters.
  *  @param Suite   The name of the test suite containing this test.
  *  @param Name    The name of the test.
- *  @param Options An optional sequence of designated initializer key/value
+ *  @param ...     An optional sequence of designated initializer key/value
  *    pairs as described in the `criterion_test_extra_data` structure
  *    (see criterion/types.h).
  *    Example: .exit_code = 1
  */
-# define Theory(Args, ...) CR_EXPAND(CR_THEORY_BASE(Args, __VA_ARGS__))
+#define Theory(Params, Suite, Name, ...)    internal
 
 /**
- *  TheoryDataPoints(Suite, Name) = { Datapoints... };
- *
  *  Defines an array of data points.
  *
  *  The types of the specified data points *must* match the types of the
  *  associated theory.
  *
- *  Each entry in the array must be the result of the DataPoints macro.
+ *  Each entry in the array must be the result of the `DataPoints` macro.
+ *
+ *  Example:
+ *  @code{.c}
+ *  TheoryDataPoints(suite, test) = {
+ *      DataPoints(int, 1, 2, 3),               // first theory parameter
+ *      DataPoints(double, 4.2, 0, -INFINITY),  // second theory parameter
+ *  };
+ *  @endcode
  *
  *  @param Suite   The name of the test suite containing this test.
  *  @param Name    The name of the test.
  */
-# define TheoryDataPoints(Category, Name) CR_TH_INTERNAL_TDPS(Category, Name)
+#define TheoryDataPoints(Suite, Name)       CR_TH_INTERNAL_TDPS(Suite, Name)
 
 /**
- *  DataPoints(Type, Values...)
- *
  *  Defines a new set of data points.
  *
- *  @param Type    The type of each data point in the set.
- *  @param Values  The data points in the set.
+ *  @param Type The type of each data point in the set.
+ *  @param ...  The data points in the set.
  */
-# define DataPoints(Type, ...) CR_EXPAND(CR_TH_INTERNAL_DP(Type, __VA_ARGS__))
+#define DataPoints(Type, ...)               CR_EXPAND(CR_TH_INTERNAL_DP(Type, __VA_ARGS__))
 
-// Theory invariants
+/**@}*/
 
-# define cr_assume(Condition) \
-    do { \
-        if (!(Condition)) \
-            cr_theory_abort(); \
+/**
+ * @defgroup TheoryInvariants Theory invariants
+ * @{
+ */
+
+/**
+ * Assumes `Condition` is true
+ *
+ * Evaluates `Condition` and continues execution if it is true.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Condition Condition to test
+ *
+ *****************************************************************************/
+#define cr_assume(Condition)    \
+    do {                        \
+        if (!(Condition))       \
+            cr_theory_abort();  \
     } while (0)
 
-# define cr_assume_not(Condition) cr_assume(!(Condition))
+/**
+ * Assumes `Condition` is false
+ *
+ * Evaluates `Condition` and continues execution if it is false.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Condition Condition to test
+ *
+ *****************************************************************************/
+#define cr_assume_not(Condition)             cr_assume(!(Condition))
 
-# define cr_assume_op_(Op, Actual, Expected) cr_assume((Actual) Op (Expected))
-# define cr_assume_eq(Actual, Expected)  cr_assume_op_(==, Actual, Expected)
-# define cr_assume_neq(Actual, Expected) cr_assume_op_(!=, Actual, Expected)
-# define cr_assume_gt(Actual, Expected)  cr_assume_op_(>, Actual, Expected)
-# define cr_assume_geq(Actual, Expected) cr_assume_op_(>=, Actual, Expected)
-# define cr_assume_lt(Actual, Expected)  cr_assume_op_(<, Actual, Expected)
-# define cr_assume_leq(Actual, Expected) cr_assume_op_(<=, Actual, Expected)
+/**
+ * Assumes `Actual` is equal to `Expected`
+ *
+ * Continues execution if `Actual` is equal to `Expected`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Expected Expected value
+ *
+ *****************************************************************************/
+#define cr_assume_eq(Actual, Expected)       cr_assume_op_(==, Actual, Expected)
 
-# define cr_assume_null(Value)     cr_assume_eq(Value, NULL)
-# define cr_assume_not_null(Value) cr_assume_neq(Value, NULL)
+/**
+ * Assumes `Actual` is not equal to `Unexpected`
+ *
+ * Continues execution if `Actual` is not equal to `Unexpected`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Unexpected Unexpected value
+ *
+ *****************************************************************************/
+#define cr_assume_neq(Actual, Unexpected)    cr_assume_op_(!=, Actual, Unexpected)
 
-# define cr_assume_float_eq(Actual, Expected, Epsilon)  \
-    cr_assume((Expected) - (Actual) <= (Epsilon)        \
-           && (Actual) - (Expected) <= (Epsilon))
+/**
+ * Assumes `Actual` is greater than `Reference`
+ *
+ * Continues execution if `Actual` is greater than `Reference`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Reference Reference value
+ *
+ *****************************************************************************/
+#define cr_assume_gt(Actual, Reference)      cr_assume_op_(>, Actual, Reference)
 
-# define cr_assume_float_neq(Actual, Expected, Epsilon) \
-    cr_assume((Expected) - (Actual) > (Epsilon)         \
-           || (Actual) - (Expected) > (Epsilon))
+/**
+ * Assumes `Actual` is greater or equal to `Reference`
+ *
+ * Continues execution if `Actual` is greater or equal to `Reference`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Reference Reference value
+ *
+ *****************************************************************************/
+#define cr_assume_geq(Actual, Reference)     cr_assume_op_(>=, Actual, Reference)
 
-# define cr_assume_str_op_(Op, Actual, Expected) \
-    cr_assume(strcmp((Actual), (Expected)) Op 0)
+/**
+ * Assumes `Actual` is less than `Reference`
+ *
+ * Continues execution if `Actual` is less than `Reference`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Reference Reference value
+ *
+ *****************************************************************************/
+#define cr_assume_lt(Actual, Reference)      cr_assume_op_(<, Actual, Reference)
 
-# define cr_assume_str_eq(Actual, Expected)  cr_assume_str_op_(==, Actual, Expected)
-# define cr_assume_str_neq(Actual, Expected) cr_assume_str_op_(!=, Actual, Expected)
-# define cr_assume_str_lt(Actual, Expected)  cr_assume_str_op_(<, Actual, Expected)
-# define cr_assume_str_leq(Actual, Expected) cr_assume_str_op_(<=, Actual, Expected)
-# define cr_assume_str_gt(Actual, Expected)  cr_assume_str_op_(>, Actual, Expected)
-# define cr_assume_str_geq(Actual, Expected) cr_assume_str_op_(>=, Actual, Expected)
+/**
+ * Assumes `Actual` is less or equal to `Reference`
+ *
+ * Continues execution if `Actual` is less or equal to `Reference`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Reference Reference value
+ *
+ *****************************************************************************/
+#define cr_assume_leq(Actual, Reference)     cr_assume_op_(<=, Actual, Reference)
 
-# define cr_assume_arr_eq(Actual, Expected, Size)  cr_assume(!memcmp((A), (B), (Size)))
-# define cr_assume_arr_neq(Actual, Expected, Size) cr_assume(memcmp((A), (B), (Size)))
+/**
+ * Assumes `Value` is NULL.
+ *
+ * Continues execution if `Value` is NULL.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Value Value to test
+ *
+ *****************************************************************************/
+#define cr_assume_null(Value)                cr_assume_eq(Value, NULL)
 
-// Deprecated
+/**
+ * Assumes `Value` is not NULL.
+ *
+ * Continues execution if `Value` is not NULL.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Value Value to test
+ *
+ *****************************************************************************/
+#define cr_assume_not_null(Value)            cr_assume_neq(Value, NULL)
 
-# ifndef CRITERION_NO_COMPAT
-#  define cr_assume_strings_eq(...) CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_eq, cr_assume_str_eq) cr_assume_str_eq(__VA_ARGS__)
-#  define cr_assume_strings_neq(...) CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_neq, cr_assume_str_neq) cr_assume_str_neq(__VA_ARGS__)
-#  define cr_assume_strings_lt(...) CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_lt, cr_assume_str_lt) cr_assume_str_lt(__VA_ARGS__)
-#  define cr_assume_strings_leq(...) CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_leq, cr_assume_str_leq) cr_assume_str_leq(__VA_ARGS__)
-#  define cr_assume_strings_gt(...) CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_gt, cr_assume_str_gt) cr_assume_str_gt(__VA_ARGS__)
-#  define cr_assume_strings_geq(...) CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_geq, cr_assume_str_geq) cr_assume_str_geq(__VA_ARGS__)
+/**
+ * Assumes `Actual` is equal to `Expected` with a tolerance of `Epsilon`
+ *
+ * Continues execution if `Actual` is equal to `Expected` with a tolerance of Epsilon.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @note Use this to test equality between floats
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Expected Expected value
+ * @param[in] Epsilon Tolerance between Actual and Expected
+ *
+ *****************************************************************************/
+#define cr_assume_float_eq(Actual, Expected, Epsilon) \
+    cr_assume((Expected) - (Actual) <= (Epsilon)      \
+            && (Actual) - (Expected) <= (Epsilon))
 
-#  define cr_assume_arrays_eq(...) CRITERION_ASSERT_DEPRECATED_B(cr_assume_arrays_eq, cr_assume_arr_eq) cr_assume_arr_eq(__VA_ARGS__)
-#  define cr_assume_arrays_neq(...) CRITERION_ASSERT_DEPRECATED_B(cr_assume_arrays_neq, cr_assume_arr_neq) cr_assume_arr_neq(__VA_ARGS__)
-# endif
+/**
+ * Assumes `Actual` is not equal to `Expected` with a tolerance of `Epsilon`
+ *
+ * Continues execution if `Actual` is not equal to `Expected` with a tolerance of Epsilon.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @note Use this to test equality between floats
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Expected Expected value
+ * @param[in] Epsilon Tolerance between Actual and Expected
+ *
+ *****************************************************************************/
+#define cr_assume_float_neq(Actual, Expected, Epsilon) \
+    cr_assume((Expected) - (Actual) > (Epsilon)        \
+            || (Actual) - (Expected) > (Epsilon))
+
+/**
+ * Assumes `Actual` is lexicographically equal to `Expected`
+ *
+ * Continues execution if `Actual` is lexicographically equal to `Expected`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual String to test
+ * @param[in] Expected Expected string
+ *
+ *****************************************************************************/
+#define cr_assume_str_eq(Actual, Expected)             cr_assume_str_op_(==, Actual, Expected)
+
+/**
+ * Assumes `Actual` is not lexicographically equal to `Unexpected`
+ *
+ * Continues execution if `Actual` is not lexicographically equal to `Unexpected`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual String to test
+ * @param[in] Unexpected Unexpected string
+ *
+ *****************************************************************************/
+#define cr_assume_str_neq(Actual, Unexpected)          cr_assume_str_op_(!=, Actual, Unexpected)
+
+/**
+ * Assumes `Actual` is lexicographically less than `Reference`
+ *
+ * Continues execution if `Actual` is lexicographically less than `Reference`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Reference Reference value
+ *
+ *****************************************************************************/
+#define cr_assume_str_lt(Actual, Reference)            cr_assume_str_op_(<, Actual, Reference)
+
+/**
+ * Assumes `Actual` is lexicographically less or equal to `Reference`
+ *
+ * Continues execution if `Actual` is lexicographically less or equal to `Reference`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Reference Reference value
+ *
+ *****************************************************************************/
+#define cr_assume_str_leq(Actual, Reference)           cr_assume_str_op_(<=, Actual, Reference)
+
+/**
+ * Assumes `Actual` is lexicographically greater than `Reference`
+ *
+ * Continues execution if `Actual` is lexicographically greater than `Reference`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Reference Reference value
+ *
+ *****************************************************************************/
+#define cr_assume_str_gt(Actual, Reference)            cr_assume_str_op_(>, Actual, Reference)
+
+/**
+ * Assumes `Actual` is lexicographically greater or equal to `Reference`
+ *
+ * Continues execution if `Actual` is lexicographically greater or equal to `Reference`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @param[in] Actual Value to test
+ * @param[in] Reference Reference value
+ *
+ *****************************************************************************/
+#define cr_assume_str_geq(Actual, Reference)           cr_assume_str_op_(>=, Actual, Reference)
+
+/**
+ * Assumes `Actual` is byte-to-byte equal to `Expected`
+ *
+ * Continues execution if `Actual` is byte-to-byte equal to `Expected`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @warning This should not be used on struct arrays
+ *
+ * @param[in] Actual Array to test
+ * @param[in] Expected Expected array
+ * @param[in] Size The size of both arrays
+ *
+ *****************************************************************************/
+#define cr_assume_arr_eq(Actual, Expected, Size)       cr_assume(!memcmp((Actual), (Expected), (Size)))
+/**
+ * Assumes `Actual` is not byte-to-byte equal to `Unexpected`
+ *
+ * Continues execution if `Actual` is not byte-to-byte equal to `Unexpected`.
+ * Otherwise the current theory iteration aborts without marking the test as
+ * failure.
+ *
+ * @warning This should not be used on struct arrays
+ *
+ * @param[in] Actual Array to test
+ * @param[in] Unexpected Unexpected array
+ * @param[in] Size The size of both arrays
+ *
+ *****************************************************************************/
+#define cr_assume_arr_neq(Actual, Unexpected, Size)    cr_assume(memcmp((Actual), (Unexpected), (Size)))
+
+/**@}*/
+
+/* Deprecated */
+
+#ifndef CRITERION_NO_COMPAT
+# define cr_assume_strings_eq(...)                     CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_eq, cr_assume_str_eq) cr_assume_str_eq(__VA_ARGS__)
+# define cr_assume_strings_neq(...)                    CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_neq, cr_assume_str_neq) cr_assume_str_neq(__VA_ARGS__)
+# define cr_assume_strings_lt(...)                     CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_lt, cr_assume_str_lt) cr_assume_str_lt(__VA_ARGS__)
+# define cr_assume_strings_leq(...)                    CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_leq, cr_assume_str_leq) cr_assume_str_leq(__VA_ARGS__)
+# define cr_assume_strings_gt(...)                     CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_gt, cr_assume_str_gt) cr_assume_str_gt(__VA_ARGS__)
+# define cr_assume_strings_geq(...)                    CRITERION_ASSERT_DEPRECATED_B(cr_assume_strings_geq, cr_assume_str_geq) cr_assume_str_geq(__VA_ARGS__)
+
+# define cr_assume_arrays_eq(...)                      CRITERION_ASSERT_DEPRECATED_B(cr_assume_arrays_eq, cr_assume_arr_eq) cr_assume_arr_eq(__VA_ARGS__)
+# define cr_assume_arrays_neq(...)                     CRITERION_ASSERT_DEPRECATED_B(cr_assume_arrays_neq, cr_assume_arr_neq) cr_assume_arr_neq(__VA_ARGS__)
+#endif
+
+#include "internal/theories.h"
 
 #endif /* !CRITERION_THEORIES_H_ */

include/criterion/types.h

@@ -21,34 +21,36 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
  */
+/*!
+ * @file
+ * @brief Types for tests
+ *****************************************************************************/
 #ifndef CRITERION_TYPES_H_
-# define CRITERION_TYPES_H_
+#define CRITERION_TYPES_H_
 
-# include "alloc.h"
-# ifdef __cplusplus
-#  include <cstddef>
-#  include <vector>
+#include "alloc.h"
+#ifdef __cplusplus
+# include <cstddef>
+# include <vector>
 using std::size_t;
-# else
-#  include <stdbool.h>
-#  include <stddef.h>
-# endif
-# include "internal/common.h"
+#else
+# include <stdbool.h>
+# include <stddef.h>
+#endif
+#include "internal/common.h"
 
 /**
  *  Enumerates the supported languages for tests
  */
 enum criterion_language {
-    CR_LANG_C,              /// C
-    CR_LANG_CXX,            /// C++
-    CR_LANG_OBJC,           /// Objective-C
-    CR_LANG_OBJCXX,         /// Objective-C++
+    CR_LANG_C,      /* !< C */
+    CR_LANG_CXX,    /* !< C++ */
+    CR_LANG_OBJC,   /* !< Objective-C */
+    CR_LANG_OBJCXX, /* !< Objective-C++ */
 
-    CR_LANG_SIZE_ // leave this at the end
+    CR_LANG_SIZE_   /* leave this at the end */
 };
 
-extern const char *const cr_language_names[CR_LANG_SIZE_];
-
 /**
  *  Enumerates the supported kinds of tests
  */
@@ -57,6 +59,13 @@ enum criterion_test_kind {
     CR_TEST_PARAMETERIZED,
 };
 
+enum criterion_compiler {
+    CR_COMP_UNKNOWN,
+    CR_COMP_GCC,
+    CR_COMP_CLANG,
+    CR_COMP_MSVC,
+};
+
 /**
  *  Represents a set of parameters for a parameterized test.
  */
@@ -67,7 +76,8 @@ struct criterion_test_params;
  *  the Test and TestSuite macros, or other means.
  */
 struct criterion_test_extra_data {
-    // Start of private API
+    /* / @cond CRITERION_TEST_EXTRA_DATA_PRIVATE_API
+       Start of private API */
     /*
      * Warning: the fields below are not meant to be set manually.
      *  Setting them improperly *will* wreck havock in your tests.
@@ -75,22 +85,88 @@ struct criterion_test_extra_data {
      * You've been warned.
      */
     int sentinel_;
+    enum criterion_compiler compiler_;
     enum criterion_language lang_;
     enum criterion_test_kind kind_;
     struct criterion_test_params (*param_)(void);
     const char *identifier_;
     const char *file_;
     unsigned line_;
-    // Enf of private API
+    /* Enf of private API
+       / @endcond */
 
-    void (*init)(void);         /// The setup test fixture
-    void (*fini)(void);         /// The setup test fixture
-    int signal;                 /// The expected signal raised by the test (or 0 if none)
-    int exit_code;              /// The expected exit code returned by the test
-    bool disabled;              /// Whether the test is disabled or not
-    const char *description;    /// The description of a test
-    double timeout;             /// A timeout for the test in seconds
-    void *data;                 /// Extra user data
+    /**
+     * The setup test fixture.
+     *
+     * This function, if provided, will be executed during the initialization
+     * of the test.
+     */
+    void (*init)(void);
+
+    /**
+     * The teardown test fixture.
+     *
+     * This function, if provided, will be executed during the finalization
+     * of the test.
+     */
+    void (*fini)(void);
+
+    /**
+     * The expected signal to be raised by the test.
+     *
+     * If the test does not raise the specified signal, then the test is
+     * marked as failed.
+     *
+     * A value of 0 means that is it not expected for the test to raise any
+     * signal.
+     */
+    int signal;
+
+    /**
+     * The expected exit status to be returned by the test.
+     *
+     * By default, criterion exits the test process with a value of 0. If it
+     * is expected for the test to exit with a non-zero status, this option
+     * can be used.
+     */
+    int exit_code;
+
+    /**
+     * If `true`, skips the test.
+     *
+     * The test will still appear in the test list, but will be marked as
+     * skipped and will not be executed.
+     */
+    bool disabled;
+
+    /**
+     * The long description of a test.
+     *
+     * If a description is provided, it will be printed in test reports, and
+     * logged if the runner runs in verbose mode.
+     */
+    const char *description;
+
+    /**
+     * The timeout for the test, in seconds.
+     *
+     * If the realtime execution of a test takes longer than the specified
+     * value, then the test is immediately aborted and reported as timing out.
+     *
+     * A value of `0` is equivalent to `+INFINITY` and means that the test
+     * does not timeout.
+     *
+     * It is unspecified behaviour for the value of `timeout` to be negative
+     * or `NaN`.
+     */
+    double timeout;
+
+    /**
+     * Extra user data.
+     *
+     * This field is currently unused.
+     */
+    void *data;
 };
 
 /**

po/LINGUAS

@@ -1 +1 @@
-fr
+fr de

po/de.po

@@ -0,0 +1,204 @@
+# German translations for Criterion package
+# German translation for Criterion.
+# Copyright (C) 2016 Franklin Snaipe Mathieu
+# This file is distributed under the same license as the Criterion package.
+#  <a1lu@arcor.de>, 2016.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: Criterion \n"
+"Report-Msgid-Bugs-To: franklinmathieu+criterion@gmail.com\n"
+"POT-Creation-Date: 2016-09-16 11:24+0200\n"
+"PO-Revision-Date: 2016-02-12 11:12+0100\n"
+"Last-Translator:  <a1lu@arcor.de>\n"
+"Language-Team: German\n"
+"Language: de\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+#: src/log/normal.c:42
+#, c-format
+msgid "Criterion v%s\n"
+msgstr "Criterion v%s\n"
+
+#: src/log/normal.c:43
+#, c-format
+msgid "  %s\n"
+msgstr "  %s\n"
+
+#: src/log/normal.c:46
+#, c-format
+msgid "%1$s::%2$s\n"
+msgstr "%1$s::%2$s\n"
+
+#: src/log/normal.c:47
+#, c-format
+msgid "%1$s::%2$s: (%3$3.2fs)\n"
+msgstr "%1$s::%2$s: (%3$3.2fs)\n"
+
+#: src/log/normal.c:48
+#, c-format
+msgid "%1$s::%2$s: Test was skipped\n"
+msgstr "%1$s::%2$s: Test wurde übersprungen\n"
+
+#: src/log/normal.c:49
+#, c-format
+msgid "%1$s::%2$s: Test is disabled\n"
+msgstr "%1$s::%2$s: Test ist deaktiviert\n"
+
+#: src/log/normal.c:50
+#, c-format
+msgid "%1$s%2$s%3$s:%4$s%5$d%6$s: Assertion failed: %7$s\n"
+msgstr "%1$s%2$s%3$s:%4$s%5$d%6$s: Fehlerhafte Behauptung: %7$s\n"
+
+#: src/log/normal.c:51
+#, c-format
+msgid "  Theory %1$s::%2$s failed with the following parameters: (%3$s)\n"
+msgstr ""
+"  Hypothese %1$s::%2$s schlug fehl mit den folgenden Parametern: (%3$s)\n"
+
+#: src/log/normal.c:52
+#, c-format
+msgid "%1$s::%2$s: Timed out. (%3$3.2fs)\n"
+msgstr "%1$s::%2$s: Außerhalb der Vorgabezeit. (%3$3.2fs)\n"
+
+#: src/log/normal.c:53
+#, c-format
+msgid "%1$s%2$s%3$s:%4$s%5$u%6$s: Unexpected signal caught below this line!\n"
+msgstr ""
+"%1$s%2$s%3$s:%4$s%5$u%6$s: Unerwartetes Signal gefangen unterhalb dieser "
+"Zeile!\n"
+
+#: src/log/normal.c:54
+#, c-format
+msgid "%1$s::%2$s: CRASH!\n"
+msgstr "%1$s::%2$s: ABSTURZ!\n"
+
+#: src/log/normal.c:55
+#, c-format
+msgid "%1$s::%2$s: %3$s\n"
+msgstr "%1$s::%2$s: %3$s\n"
+
+#: src/log/normal.c:56
+#, c-format
+msgid ""
+"%1$sWarning! The test `%2$s::%3$s` crashed during its setup or teardown."
+"%4$s\n"
+msgstr ""
+"%1$sWarnung! Der Test `%2$s::%3$s` ist abgestürzt während der "
+"Initialisierung oder Beendung %4$s\n"
+
+#: src/log/normal.c:57
+#, c-format
+msgid ""
+"%1$sWarning! The test `%2$s::%3$s` exited during its setup or teardown.%4$s\n"
+msgstr ""
+"%1$sWarnung! Der Test `%2$s::%3$s` hat sich beendet während der "
+"Initialisierung oder Beendung.%4$s\n"
+
+#: src/log/normal.c:58
+#, c-format
+msgid "Running %1$s%2$lu%3$s test from %4$s%5$s%6$s:\n"
+msgid_plural "Running %1$s%2$lu%3$s tests from %4$s%5$s%6$s:\n"
+msgstr[0] "Führe %1$s%2$lu%3$s Test durch von %4$s%5$s%6$s:\n"
+msgstr[1] "Führe %1$s%2$lu%3$s Tests durch von %4$s%5$s%6$s:\n"
+
+#: src/log/normal.c:60
+#, c-format
+msgid ""
+"%1$sSynthesis: Tested: %2$s%3$lu%4$s | Passing: %5$s%6$lu%7$s | Failing: %8$s"
+"%9$lu%10$s | Crashing: %11$s%12$lu%13$s %14$s\n"
+msgstr ""
+"%1$sSynthese: Getestet: %2$s%3$lu%4$s | Bestanden: %5$s%6$lu%7$s | Fehler: "
+"%8$s%9$lu%10$s | Abstürze: %11$s%12$lu%13$s %14$s\n"
+
+#: src/string/i18n.c:15
+msgid "The conditions for this assertion were not met."
+msgstr "Die Bedingung für diesen Behauptung wurden nicht erfüllt"
+
+#: src/string/i18n.c:16
+#, c-format
+msgid "The expression %s is false."
+msgstr "Der Ausdruck %s ist falsch."
+
+#: src/string/i18n.c:17
+#, c-format
+msgid "%s is null."
+msgstr "%s ist null."
+
+#: src/string/i18n.c:18
+#, c-format
+msgid "%s is not null."
+msgstr "%s ist nicht null."
+
+#: src/string/i18n.c:19
+#, c-format
+msgid "%s is empty."
+msgstr "%s ist leer."
+
+#: src/string/i18n.c:20
+#, c-format
+msgid "The statement `%s` did not throw any exception."
+msgstr "Die Anweisung `%s` hat keine Ausnahme geworfen."
+
+#: src/string/i18n.c:21
+#, c-format
+msgid "The statement `%s` threw some exception."
+msgstr "Die Anweisung `%s` hat Ausnahmen geworfen."
+
+#: src/string/i18n.c:24
+#, c-format
+msgid ""
+"The expression (as strings) %1$s is false: actual=`%2$s` expected=`%3$s`."
+msgstr ""
+"Der Ausdruck (als Zeichenkette) %1$s ist falsch: tatsächlich=`%2$s` "
+"erwartet=`%3$s`."
+
+#: src/string/i18n.c:25
+#, c-format
+msgid "%1$s (`%2$s`) is not empty."
+msgstr "%1$s (`%2$s`) ist nicht leer."
+
+#: src/string/i18n.c:26
+#, c-format
+msgid "The file contents of %1$s does not match the string \"%2$s\"."
+msgstr "Der Inhalt der Datei %1$s ist nicht gleich der Zeichenkette \"%2$s\"."
+
+#: src/string/i18n.c:27
+#, c-format
+msgid "The file contents of %1$s does not match the contents of %2$s."
+msgstr "Der Inhalt der Datei %1$s ist nicht gleich dem Inhalt von %2$s."
+
+#: src/string/i18n.c:28
+#, c-format
+msgid "The statement `%1$s` did throw an instance of the `%2$s` exception."
+msgstr "Die Anweisung `%1$s` hat eine Instanz der Ausname `%2$s` geworfen."
+
+#: src/string/i18n.c:29
+#, c-format
+msgid "The statement `%1$s` did not throw an instance of the `%2$s` exception."
+msgstr "Die Anweisung `%1$s` hat keine Instanz der Ausname `%2$s` geworfen."
+
+#: src/core/runner.c:68
+#, c-format
+msgid ""
+"%1$sWarning! Criterion has detected that it is running under valgrind, but "
+"the number of jobs have been explicitely set. Reports might appear confusing!"
+"%2$s\n"
+msgstr ""
+"%1$sWarnung! Criterion hat festgestellt, dass es unter valgrind läuft, aber "
+"die Anzahl an Aufträgen wurde explizit festgelegt. Die Berichte können "
+"verwirrend sein!%2$s\n"
+
+#: src/io/output.c:36
+#, c-format
+msgid "Could not open the file @ `%1$s` for %2$s reporting: %3$s.\n"
+msgstr ""
+"Konnte die Datei `%1$s` nicht für die Berichte von %2$s öffnen: %3$s.\n"
+
+#: src/io/output.c:37
+#, c-format
+msgid "Writing %1$s report in `%2$s`.\n"
+msgstr "Schreibe Bericht von %1$s nach `%2$s`.\n"

po/fr.po

@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: criterion 2.0.0\n"
 "Report-Msgid-Bugs-To: franklinmathieu+criterion@gmail.com\n"
-"POT-Creation-Date: 2015-11-27 12:24+0100\n"
+"POT-Creation-Date: 2016-09-16 11:24+0200\n"
 "PO-Revision-Date: 2015-04-03 17:58+0200\n"
 "Last-Translator:  <franklinmathieu@gmail.com>\n"
 "Language-Team: French\n"
@@ -28,16 +28,21 @@ msgstr "Criterion v%s\n"
 msgid "  %s\n"
 msgstr "  %s\n"
 
-#: src/log/normal.c:46 src/log/normal.c:48
+#: src/log/normal.c:46
 #, c-format
 msgid "%1$s::%2$s\n"
 msgstr "%1$s::%2$s\n"
 
 #: src/log/normal.c:47
-#, fuzzy, c-format
+#, c-format
 msgid "%1$s::%2$s: (%3$3.2fs)\n"
 msgstr "%1$s::%2$s: (%3$3.2fs)\n"
 
+#: src/log/normal.c:48
+#, c-format
+msgid "%1$s::%2$s: Test was skipped\n"
+msgstr "%1$s::%2$s: Le test a été sauté\n"
+
 #: src/log/normal.c:49
 #, c-format
 msgid "%1$s::%2$s: Test is disabled\n"
@@ -45,43 +50,38 @@ msgstr "%1$s::%2$s: Le test est désactivé\n"
 
 #: src/log/normal.c:50
 #, c-format
-msgid "%1$s::%2$s: Suite is disabled\n"
-msgstr "%1$s::%2$s: La suite est désactivée\n"
-
-#: src/log/normal.c:51
-#, c-format
 msgid "%1$s%2$s%3$s:%4$s%5$d%6$s: Assertion failed: %7$s\n"
 msgstr "%1$s%2$s%3$s:%4$s%5$d%6$s: Échec d'assertion: %7$s\n"
 
-#: src/log/normal.c:52
+#: src/log/normal.c:51
 #, fuzzy, c-format
 msgid "  Theory %1$s::%2$s failed with the following parameters: (%3$s)\n"
 msgstr ""
 "  La théorie %1$s::%2$s a échoué avec les paramètres suivants: (%3$s)\n"
 
-#: src/log/normal.c:53
+#: src/log/normal.c:52
 #, fuzzy, c-format
 msgid "%1$s::%2$s: Timed out. (%3$3.2fs)\n"
 msgstr "%1$s::%2$s: Délai expiré. (%3$3.2fs)\n"
 
-#: src/log/normal.c:54
+#: src/log/normal.c:53
 #, c-format
 msgid "%1$s%2$s%3$s:%4$s%5$u%6$s: Unexpected signal caught below this line!\n"
 msgstr ""
 "%1$s%2$s%3$s:%4$s%5$u%6$s: Un signal inattendu a été reçu après cette "
 "ligne!\n"
 
-#: src/log/normal.c:55
+#: src/log/normal.c:54
 #, c-format
 msgid "%1$s::%2$s: CRASH!\n"
 msgstr "%1$s::%2$s: PLANTAGE!\n"
 
-#: src/log/normal.c:56
+#: src/log/normal.c:55
 #, fuzzy, c-format
 msgid "%1$s::%2$s: %3$s\n"
 msgstr "%1$s::%2$s: (%3$3.2fs)\n"
 
-#: src/log/normal.c:57
+#: src/log/normal.c:56
 #, fuzzy, c-format
 msgid ""
 "%1$sWarning! The test `%2$s::%3$s` crashed during its setup or teardown."
@@ -90,7 +90,7 @@ msgstr ""
 "%1$sAttention! Le test `%2$s::%3$s` a planté pendant son initialisation ou "
 "sa finalisation.%4$s\n"
 
-#: src/log/normal.c:58
+#: src/log/normal.c:57
 #, fuzzy, c-format
 msgid ""
 "%1$sWarning! The test `%2$s::%3$s` exited during its setup or teardown.%4$s\n"
@@ -98,14 +98,14 @@ msgstr ""
 "%1$sAttention! Le test `%2$s::%3$s` a quitté pendant son initialisation ou "
 "sa finalisation.%4$s\n"
 
-#: src/log/normal.c:59
+#: src/log/normal.c:58
 #, c-format
 msgid "Running %1$s%2$lu%3$s test from %4$s%5$s%6$s:\n"
 msgid_plural "Running %1$s%2$lu%3$s tests from %4$s%5$s%6$s:\n"
 msgstr[0] "Lancement de %1$s%2$lu%3$s test dans %4$s%5$s%6$s:\n"
 msgstr[1] "Lancement de %1$s%2$lu%3$s tests dans %4$s%5$s%6$s:\n"
 
-#: src/log/normal.c:61
+#: src/log/normal.c:60
 #, c-format
 msgid ""
 "%1$sSynthesis: Tested: %2$s%3$lu%4$s | Passing: %5$s%6$lu%7$s | Failing: %8$s"
@@ -114,45 +114,30 @@ msgstr ""
 "%1$sSynthèse: Testés: %2$s%3$lu%4$s | Validés: %5$s%6$lu%7$s | Échoués: %8$s"
 "%9$lu%10$s | Plantages: %11$s%12$lu%13$s %14$s\n"
 
-#: src/log/normal.c:77
-#, fuzzy, c-format
-msgid "%s::%s: %s\n"
-msgstr "%1$s::%2$s: (%3$3.2fs)\n"
-
-#: src/string/i18n.c:13
+#: src/string/i18n.c:15
 msgid "The conditions for this assertion were not met."
 msgstr "Les conditions de cette assertion n'ont pas été remplies."
 
-#: src/string/i18n.c:14
+#: src/string/i18n.c:16
 #, c-format
 msgid "The expression %s is false."
 msgstr "L'expression %s est fausse."
 
-#: src/string/i18n.c:15
-#, c-format
-msgid "The expression (as strings) %s is false."
-msgstr "L'expression (en tant que chaînes de caractères) %s est fausse."
-
-#: src/string/i18n.c:16
+#: src/string/i18n.c:17
 #, c-format
 msgid "%s is null."
 msgstr "%s est nul."
 
-#: src/string/i18n.c:17
+#: src/string/i18n.c:18
 #, c-format
 msgid "%s is not null."
 msgstr "%s n'est pas nul."
 
-#: src/string/i18n.c:18
+#: src/string/i18n.c:19
 #, c-format
 msgid "%s is empty."
 msgstr "%s est vide."
 
-#: src/string/i18n.c:19
-#, c-format
-msgid "%s is not empty."
-msgstr "%s n'est pas vide."
-
 #: src/string/i18n.c:20
 #, fuzzy, c-format
 msgid "The statement `%s` did not throw any exception."
@@ -165,38 +150,40 @@ msgstr "L'instruction `%1$s` a levé une exception."
 
 #: src/string/i18n.c:24
 #, c-format
+msgid ""
+"The expression (as strings) %1$s is false: actual=`%2$s` expected=`%3$s`."
+msgstr ""
+"L'expression (en tant que chaînes de caractères) %1$s est fausse: actuel=`"
+"%2$s` attendu=`%3$s`."
+
+#: src/string/i18n.c:25
+#, c-format
+msgid "%1$s (`%2$s`) is not empty."
+msgstr "%1$s (`%2$s`) n'est pas vide."
+
+#: src/string/i18n.c:26
+#, c-format
 msgid "The file contents of %1$s does not match the string \"%2$s\"."
 msgstr ""
 "Le contenu du fichier %1$s ne correspond pas à la chaine de caractères \"%2$s"
 "\"."
 
-#: src/string/i18n.c:25
+#: src/string/i18n.c:27
 #, fuzzy, c-format
 msgid "The file contents of %1$s does not match the contents of %2$s."
 msgstr "Le contenu du fichier %1$s ne correspond pas au contenu de %2$s."
 
-#: src/string/i18n.c:26
+#: src/string/i18n.c:28
 #, c-format
 msgid "The statement `%1$s` did throw an instance of the `%2$s` exception."
 msgstr "L'instruction `%1$s` a levé une instance de l'exception `%2$s`."
 
-#: src/string/i18n.c:27
+#: src/string/i18n.c:29
 #, c-format
 msgid "The statement `%1$s` did not throw an instance of the `%2$s` exception."
 msgstr "L'instruction `%1$s` n'a pas levé d'instance de l'exception `%2$s`."
 
-#: src/core/runner.c:58
-#, c-format
-msgid ""
-"%1$sWarning! Criterion has detected that it is running under valgrind, but "
-"the no_early_exit option is explicitely disabled. Reports will not be "
-"accurate!%2$s\n"
-msgstr ""
-"%1$sAttention! Criterion a détecté qu'il a été lancé avec valgrind, mais "
-"l'option no_early_exit est explicitement désactivée. Les rapports d'erreur "
-"ne seront pas précis!%2$s\n"
-
-#: src/core/runner.c:62
+#: src/core/runner.c:68
 #, c-format
 msgid ""
 "%1$sWarning! Criterion has detected that it is running under valgrind, but "
@@ -207,13 +194,13 @@ msgstr ""
 "nombre de tâches est explicitement défini. Les rapports d'erreur risquent "
 "d'être déroutants!%2$s\n"
 
-#: src/io/output.c:13
+#: src/io/output.c:36
 #, fuzzy, c-format
 msgid "Could not open the file @ `%1$s` for %2$s reporting: %3$s.\n"
 msgstr ""
 "Impossible d'ouvrir le fichier `%1$s` pour faire le rapport %2$s: %3$s.\n"
 
-#: src/io/output.c:14
+#: src/io/output.c:37
 #, c-format
 msgid "Writing %1$s report in `%2$s`.\n"
 msgstr "Écriture du rapport %1$s dans `%2$s`.\n"

samples/CMakeLists.txt

@@ -1,6 +1,11 @@
 if (NOT MSVC)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS_DEFAULT} -std=c99 -Wall -Wextra -pedantic")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_DEFAULT} ${CXX11_FLAG} -Wall -Wextra -pedantic")
+
+  if (MINGW)
+    # see http://sourceforge.net/p/mingw/bugs/2250/
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__NO_INLINE__")
+  endif ()
 endif ()
 
 include_directories(../include)
@@ -17,7 +22,8 @@ set(SAMPLES
   timeout.c
   redirect.c
   parameterized.c
-
+  log.c
+  skip.c
 )
 
 if (CMAKE_CXX_COMPILER_WORKS)
@@ -32,6 +38,8 @@ if (CMAKE_CXX_COMPILER_WORKS)
     simple.cc
     redirect.cc
     parameterized.cc
+    log.cc
+    skip.cc
   )
 endif ()
 
@@ -42,21 +50,6 @@ if (THEORIES)
   endif ()
 endif ()
 
-set(SCRIPTS
-  tap_test
-  xml_test
-  json_test
-  early_exit
-  verbose
-  list
-  fail_fast
-  help
-)
-
-if (HAVE_PCRE)
-    set(SCRIPTS ${SCRIPTS} pattern)
-endif ()
-
 add_custom_target(criterion_samples)
 add_dependencies(criterion_tests criterion_samples)
 
@@ -68,7 +61,6 @@ macro(add_samples DIR_ SAMPLES_)
         add_test(${sample} ${sample}.bin)
         set_property(TEST ${sample} PROPERTY
             ENVIRONMENT "CRITERION_ALWAYS_SUCCEED=1"
-            ENVIRONMENT "CRITERION_NO_EARLY_EXIT=1" # for coverage
         )
     endforeach()
 endmacro()

samples/asserts.c

@@ -15,7 +15,7 @@ Test(asserts, base) {
 
 Test(asserts, old_school) {
     cr_expect_fail("You can fail an assertion with a message from anywhere");
-    cr_assert_fail(); // or without a message
+    cr_assert_fail(); /* or without a message */
 }
 
 Test(asserts, string) {
@@ -34,6 +34,22 @@ Test(asserts, string) {
     cr_assert_str_leq("hello", "hello");
 }
 
+Test(asserts, wstring) {
+    cr_assert_wcs_empty(L"");
+    cr_assert_wcs_not_empty(L"foo");
+
+    cr_assert_wcs_eq(L"hello", L"hello");
+    cr_assert_wcs_neq(L"hello", L"olleh");
+
+    cr_assert_wcs_gt(L"hello", L"hell");
+    cr_assert_wcs_geq(L"hello", L"hell");
+    cr_assert_wcs_geq(L"hello", L"hello");
+
+    cr_assert_wcs_lt(L"hell", L"hello");
+    cr_assert_wcs_leq(L"hell", L"hello");
+    cr_assert_wcs_leq(L"hello", L"hello");
+}
+
 Test(asserts, native) {
     cr_assert_eq(1, 1);
     cr_assert_neq(1, 2);
@@ -57,27 +73,28 @@ struct dummy_struct {
     size_t b;
 };
 
-int eq_dummy(struct dummy_struct *a, struct dummy_struct *b) {
+int eq_dummy(struct dummy_struct *a, struct dummy_struct *b)
+{
     return a->a != b->a || a->b != b->b;
 }
 
 Test(asserts, array) {
-    int arr1[] = {1, 2, 3, 4};
-    int arr2[] = {4, 3, 2, 1};
+    int arr1[] = { 1, 2, 3, 4 };
+    int arr2[] = { 4, 3, 2, 1 };
 
-    cr_assert_arr_eq(arr1, arr1, 4);
-    cr_assert_arr_neq(arr1, arr2, 4);
+    cr_assert_arr_eq(arr1, arr1, 4 * sizeof (int));
+    cr_assert_arr_neq(arr1, arr2, 4 * sizeof (int));
 
 #ifdef __GNUC__
-    struct dummy_struct s1[] = {{4, 2}, {2, 4}};
+    struct dummy_struct s1[] = { { 4, 2 }, { 2, 4 } };
     struct dummy_struct s2[2];
-    memset(s2, 0xFF, sizeof(s2));
+    memset(s2, 0xFF, sizeof (s2));
     s2[0].a = 4;
     s2[0].b = 2;
     s2[1].a = 2;
     s2[1].b = 4;
 
-    // cr_assert_arr_eq(s1, s2, 2); not guaranteed to work on structs.
+    /* cr_assert_arr_eq(s1, s2, 2); not guaranteed to work on structs. */
     cr_assert_arr_eq_cmp(s1, s2, 2, eq_dummy);
 #endif
 }

samples/asserts.cc

@@ -1,6 +1,7 @@
 #include <criterion/criterion.h>
 #include <exception>
 #include <new>
+#include <array>
 
 Test(asserts, base) {
     cr_assert(true);
@@ -17,7 +18,7 @@ Test(asserts, base) {
 
 Test(asserts, old_school) {
     cr_expect_fail("You can fail an assertion with a message from anywhere");
-    cr_assert_fail(); // or without a message
+    cr_assert_fail(); /* or without a message */
 }
 
 Test(asserts, string) {
@@ -36,6 +37,22 @@ Test(asserts, string) {
     cr_assert_str_leq("hello", "hello");
 }
 
+Test(asserts, wstring) {
+    cr_assert_wcs_empty(L"");
+    cr_assert_wcs_not_empty(L"foo");
+
+    cr_assert_wcs_eq(L"hello", L"hello");
+    cr_assert_wcs_neq(L"hello", L"olleh");
+
+    cr_assert_wcs_gt(L"hello", L"hell");
+    cr_assert_wcs_geq(L"hello", L"hell");
+    cr_assert_wcs_geq(L"hello", L"hello");
+
+    cr_assert_wcs_lt(L"hell", L"hello");
+    cr_assert_wcs_leq(L"hell", L"hello");
+    cr_assert_wcs_leq(L"hello", L"hello");
+}
+
 Test(asserts, native) {
     cr_assert_eq(1, 1);
     cr_assert_neq(1, 2);
@@ -57,31 +74,54 @@ Test(asserts, float) {
 struct dummy_struct {
     char a;
     size_t b;
+
+    bool operator==(const struct dummy_struct &rhs) const
+    {
+        return this->a == rhs.a && this->b == rhs.b;
+    }
+
+    bool operator<(const struct dummy_struct &rhs) const
+    {
+        return this->a < rhs.a;
+    }
 };
 
-int eq_dummy(struct dummy_struct *a, struct dummy_struct *b) {
-    return a->a != b->a || a->b != b->b;
+int eq_dummy(struct dummy_struct &a, struct dummy_struct &b)
+{
+    return a == b ? 0 : (a < b ? -1 : 1);
 }
 
 Test(asserts, array) {
-    int arr1[] = {1, 2, 3, 4};
-    int arr2[] = {4, 3, 2, 1};
+    /* 1. (recommended): use std::array and cr_assert_eq */
+    std::array<dummy_struct, 2> cpparr1 = { { { 4, 2 }, { 2, 4 } } };
+    std::array<dummy_struct, 2> cpparr2;
+    memset(&cpparr2[0], 0xFF, 2 * sizeof (struct dummy_struct));
+    cpparr2[0].a = 4;
+    cpparr2[0].b = 2;
+    cpparr2[1].a = 2;
+    cpparr2[1].b = 4;
 
-    cr_assert_arr_eq(arr1, arr1, 4);
-    cr_assert_arr_neq(arr1, arr2, 4);
+    cr_assert_eq(cpparr1, cpparr2);
 
-#ifdef __GNUC__
-    struct dummy_struct s1[] = {{4, 2}, {2, 4}};
+    /* 2. Compare arrays byte-to-byte */
+    int arr1[] = { 1, 2, 3, 4 };
+    int arr2[] = { 4, 3, 2, 1 };
+
+    cr_assert_arr_eq(arr1, arr1, 4 * sizeof (int));
+    cr_assert_arr_neq(arr1, arr2, 4 * sizeof (int));
+
+    /* 3. Compare arrays with a comparison function */
+    struct dummy_struct s1[] = { { 4, 2 }, { 2, 4 } };
     struct dummy_struct s2[2];
-    memset(s2, 0xFF, sizeof(s2));
+    memset(s2, 0xFF, sizeof (s2));
     s2[0].a = 4;
     s2[0].b = 2;
     s2[1].a = 2;
     s2[1].b = 4;
 
-    // cr_assert_arrays_eq(&s1, &s2, 2); not guaranteed to work on structs.
-    cr_assert_arr_eq_cmp(&s1, &s2, 2, eq_dummy);
-#endif
+    /* cr_assert_arr_eq(&s1, &s2, 2 * sizeof (struct dummy_struct));
+       isn't guaranteed to work on structs. */
+    cr_assert_arr_eq_cmp(s1, s2, 2, eq_dummy);
 }
 
 Test(asserts, exception) {

samples/fixtures.c

@@ -1,11 +1,13 @@
 #include <criterion/criterion.h>
 #include <stdio.h>
 
-void setup(void) {
+void setup(void)
+{
     puts("Runs before the test");
 }
 
-void teardown(void) {
+void teardown(void)
+{
     puts("Runs after the test");
 }
 

samples/fixtures.cc

@@ -1,11 +1,13 @@
 #include <criterion/criterion.h>
 #include <stdio.h>
 
-void setup(void) {
+void setup(void)
+{
     puts("Runs before the test");
 }
 
-void teardown(void) {
+void teardown(void)
+{
     puts("Runs after the test");
 }
 

samples/log.c

@@ -0,0 +1,15 @@
+#include <criterion/criterion.h>
+#include <criterion/logging.h>
+
+Test(logging, simple) {
+    cr_log_info("This is an informational message. They are not displayed "
+            "by default.");
+    cr_log_warn("This is a warning. They indicate some possible malfunction "
+            "or misconfiguration in the test.");
+    cr_log_error("This is an error. They indicate serious problems and "
+            "are usually shown before the test is aborted.");
+}
+
+Test(logging, format) {
+    cr_log_info("Log messages are %s.", "printf-formatted strings");
+}

samples/log.cc

@@ -0,0 +1,18 @@
+#include <criterion/criterion.h>
+#include <criterion/logging.h>
+
+using criterion::logging::info;
+using criterion::logging::warn;
+using criterion::logging::error;
+
+Test(logging, stream) {
+    info << "This is an informational message. They are not displayed "
+        "by default."
+         << std::endl;
+    warn << "This is a warning. They indicate some possible malfunction "
+        "or misconfiguration in the test."
+         << std::endl;
+    error << "This is an error. They indicate serious problems and "
+        "are usually shown before the test is aborted."
+          << std::endl;
+}