[mapbox-variant] 01/03: Imported Upstream version 1.1.0
Sebastiaan Couwenberg
sebastic at moszumanska.debian.org
Fri Feb 26 21:41:24 UTC 2016
This is an automated email from the git hooks/post-receive script.
sebastic pushed a commit to branch master
in repository mapbox-variant.
commit ee6f75b52a9a5542f1d481ad0b2ccee5cad2fe5e
Author: Bas Couwenberg <sebastic at xs4all.nl>
Date: Fri Feb 26 21:51:13 2016 +0100
Imported Upstream version 1.1.0
---
.clang-format | 89 +
.gitignore | 8 +
.travis.yml | 127 +
.ycm_extra_conf.py | 40 +
Jamroot | 73 +
LICENSE | 25 +
LICENSE_1_0.txt | 23 +
Makefile | 110 +
README.md | 111 +
appveyor.yml | 17 +
common.gypi | 143 +
doc/other_implementations.md | 15 +
doc/standards_effort.md | 28 +
optional.hpp | 74 +
recursive_wrapper.hpp | 122 +
scripts/build-appveyor.bat | 32 +
scripts/build-local.bat | 7 +
scripts/run_compilation_failure_tests.sh | 50 +
test/bench_variant.cpp | 185 +
test/binary_visitor_test.cpp | 138 +
test/boost_variant_hello_world.cpp | 20 +
test/compilation_failure/default_constructor.cpp | 22 +
test/compilation_failure/empty_typelist.cpp | 11 +
test/compilation_failure/equality.cpp | 11 +
test/compilation_failure/get_type.cpp | 10 +
test/compilation_failure/is_type.cpp | 10 +
.../mutating_visitor_on_const.cpp | 24 +
test/compilation_failure/no-reference.cpp | 9 +
test/include/catch.hpp | 11613 +++++++++++++++++++
test/our_variant_hello_world.cpp | 20 +
test/recursive_wrapper_test.cpp | 125 +
test/reference_wrapper_test.cpp | 76 +
test/t/binary_visitor_1.cpp | 7 +
test/t/binary_visitor_2.cpp | 7 +
test/t/binary_visitor_3.cpp | 7 +
test/t/binary_visitor_4.cpp | 7 +
test/t/binary_visitor_5.cpp | 7 +
test/t/binary_visitor_6.cpp | 7 +
test/t/binary_visitor_impl.hpp | 204 +
test/t/issue21.cpp | 48 +
test/t/mutating_visitor.cpp | 36 +
test/t/optional.cpp | 102 +
test/t/recursive_wrapper.cpp | 158 +
test/t/sizeof.cpp | 52 +
test/t/unary_visitor.cpp | 127 +
test/t/variant.cpp | 570 +
test/unique_ptr_test.cpp | 126 +
test/unit.cpp | 2 +
variant.gyp | 35 +
variant.hpp | 901 ++
variant_io.hpp | 45 +
51 files changed, 15816 insertions(+)
diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..c1aca2a
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,89 @@
+---
+# Mapbox.Variant C/C+ style
+Language: Cpp
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: false
+AlignOperands: true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+ AfterClass: true
+ AfterControlStatement: true
+ AfterEnum: true
+ AfterFunction: true
+ AfterNamespace: false
+ AfterObjCDeclaration: true
+ AfterStruct: true
+ AfterUnion: true
+ BeforeCatch: true
+ BeforeElse: true
+ IndentBraces: false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+ColumnLimit: 0
+CommentPragmas: '^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat: false
+ExperimentalAutoDetectBinPacking: false
+ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeCategories:
+ - Regex: '^"(llvm|llvm-c|clang|clang-c)/'
+ Priority: 2
+ - Regex: '^(<|"(gtest|isl|json)/)'
+ Priority: 3
+ - Regex: '.*'
+ Priority: 1
+IndentCaseLabels: false
+IndentWidth: 4
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Left
+ReflowComments: true
+SortIncludes: true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: Cpp11
+TabWidth: 4
+UseTab: Never
+...
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a9bc860
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,8 @@
+.DS_Store
+out
+profiling
+build
+deps
+*.gcda
+*.gcno
+.ycm_extra_conf.pyc
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..99d0b48
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,127 @@
+language: c
+
+sudo: false
+
+# Save common build configurations as shortcuts, so we can reference them later.
+addons_shortcuts:
+ addons_clang35: &clang35
+ apt:
+ sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.5', 'boost-latest' ]
+ packages: [ 'clang-3.5', 'libboost1.55-all-dev' ]
+ addons_clang36: &clang36
+ apt:
+ sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.6', 'boost-latest' ]
+ packages: [ 'clang-3.6', 'libboost1.55-all-dev' ]
+ addons_clang37: &clang37
+ apt:
+ sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-precise-3.7', 'boost-latest' ]
+ packages: [ 'clang-3.7', 'libboost1.55-all-dev' ]
+ addons_clang38: &clang38
+ apt:
+ sources: [ 'ubuntu-toolchain-r-test', 'llvm-toolchain-precise', 'boost-latest' ]
+ packages: [ 'clang-3.8', 'libboost1.55-all-dev']
+ addons_gcc47: &gcc47
+ apt:
+ sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
+ packages: [ 'g++-4.7', 'libboost1.55-all-dev' ]
+ addons_gcc48: &gcc48
+ apt:
+ sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
+ packages: [ 'g++-4.8', 'libboost1.55-all-dev' ]
+ addons_gcc49: &gcc49
+ apt:
+ sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
+ packages: [ 'g++-4.9', 'libboost1.55-all-dev' ]
+ addons_gcc5: &gcc5
+ apt:
+ sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
+ packages: [ 'g++-5', 'libboost1.55-all-dev' ]
+
+matrix:
+ include:
+ - os: osx
+ osx_image: xcode6
+ compiler: clang
+ - os: osx
+ osx_image: xcode7
+ env: TEST_GYP_BUILD=True
+ compiler: clang
+ - os: linux
+ compiler: "clang35"
+ env: CXX=clang++-3.5
+ addons: *clang35
+ - os: linux
+ compiler: "clang36"
+ env: CXX=clang++-3.6
+ addons: *clang36
+ - os: linux
+ compiler: "clang37"
+ env: CXX=clang++-3.7 COVERAGE=True
+ addons: *clang37
+ - os: linux
+ compiler: "clang38"
+ env: CXX=clang++-3.8
+ addons: *clang38
+ - os: linux
+ compiler: "clang38"
+ env: CXX=clang++-3.8 CXX_STD=c++14
+ addons: *clang38
+ - os: linux
+ compiler: "gcc47"
+ env: CXX=g++-4.7
+ addons: *gcc47
+ - os: linux
+ compiler: "gcc48"
+ env: CXX=g++-4.8
+ addons: *gcc48
+ - os: linux
+ compiler: "gcc49"
+ env: CXX=g++-4.9
+ addons: *gcc49
+ - os: linux
+ compiler: "gcc49"
+ env: CXX=g++-4.9 CXX_STD=c++14
+ addons: *gcc49
+ - os: linux
+ compiler: "gcc5"
+ env: CXX=g++-5 CXXFLAGS="-D_GLIBCXX_USE_CXX11_ABI=0"
+ addons: *gcc5
+ - os: linux
+ compiler: "gcc5"
+ env: CXX=g++-5 CXXFLAGS="-D_GLIBCXX_USE_CXX11_ABI=1"
+ addons: *gcc5
+
+before_install:
+ - echo ${CXX}
+ - if [[ $(uname -s) == 'Linux' ]]; then
+ export PYTHONPATH=$(pwd)/.local/lib/python2.7/site-packages;
+ else
+ brew install boost;
+ export PYTHONPATH=$(pwd)/.local/lib/python/site-packages;
+ fi
+ - if [[ ${COVERAGE:-0} == 'True' ]]; then
+ PYTHONUSERBASE=$(pwd)/.local pip install --user cpp-coveralls;
+ fi
+
+install:
+ - make test
+ - make bench
+ - if [[ $(uname -s) == 'Linux' ]]; then
+ make sizes /usr/include/boost/variant.hpp;
+ else
+ make sizes `brew --prefix`/include/boost/variant.hpp;
+ fi
+ - scripts/run_compilation_failure_tests.sh
+ - if [[ ${TEST_GYP_BUILD:-0} == 'True' ]]; then
+ make clean;
+ make gyp;
+ fi
+
+script:
+ - if [[ ${COVERAGE:-0} == 'True' ]]; then
+ make clean;
+ make coverage;
+ ./out/cov-test;
+ cp unit*gc* test/;
+ ./.local/bin/cpp-coveralls -i optional.hpp -i recursive_wrapper.hpp -i variant.hpp -i variant_io.hpp --gcov-options '\-lp';
+ fi
diff --git a/.ycm_extra_conf.py b/.ycm_extra_conf.py
new file mode 100644
index 0000000..ba74668
--- /dev/null
+++ b/.ycm_extra_conf.py
@@ -0,0 +1,40 @@
+#-----------------------------------------------------------------------------
+#
+# Configuration for YouCompleteMe Vim plugin
+#
+# http://valloric.github.io/YouCompleteMe/
+#
+#-----------------------------------------------------------------------------
+
+from os.path import realpath, dirname
+
+basedir = dirname(realpath(__file__))
+
+# some default flags
+# for more information install clang-3.2-doc package and
+# check UsersManual.html
+flags = [
+'-Werror',
+'-Wall',
+'-Wextra',
+'-pedantic',
+
+'-std=c++11',
+
+# '-x' and 'c++' also required
+# use 'c' for C projects
+'-x',
+'c++',
+
+# include third party libraries
+'-I.',
+]
+
+# youcompleteme is calling this function to get flags
+# You can also set database for flags. Check: JSONCompilationDatabase.html in
+# clang-3.2-doc package
+def FlagsForFile( filename ):
+ return {
+ 'flags': flags,
+ 'do_cache': True
+ }
diff --git a/Jamroot b/Jamroot
new file mode 100644
index 0000000..1e98cf5
--- /dev/null
+++ b/Jamroot
@@ -0,0 +1,73 @@
+# Inofficial and incomplete build file using Boost build system.
+# You should use make unless you know what you are doing.
+
+local BOOST_DIR = "/usr/local" ;
+
+#using clang : : ;
+
+lib system : : <name>boost_system <search>$(BOOST_DIR)/lib ;
+lib timer : chrono : <name>boost_timer <search>$(BOOST_DIR)/lib ;
+lib chrono : system : <name>boost_chrono <search>$(BOOST_DIR)/lib ;
+
+exe variant-test
+ :
+ test/bench_variant.cpp
+ .//system
+ .//timer
+ .//chrono
+ :
+ <include>$(BOOST_DIR)/include
+ <include>./
+ #<define>SINGLE_THREADED
+ <variant>release:<cxxflags>-march=native
+ ;
+
+
+exe binary-visitor-test
+ :
+ test/binary_visitor_test.cpp
+ .//system
+ .//timer
+ .//chrono
+ :
+ <include>$(BOOST_DIR)/include
+ <include>./
+ <variant>release:<cxxflags>-march=native
+ ;
+
+exe recursive-wrapper-test
+ :
+ test/recursive_wrapper_test.cpp
+ .//system
+ .//timer
+ .//chrono
+ :
+ <include>$(BOOST_DIR)/include
+ <include>./
+ <variant>release:<cxxflags>-march=native
+ ;
+
+exe unique-ptr-test
+ :
+ test/unique_ptr_test.cpp
+ .//system
+ .//timer
+ .//chrono
+ :
+ <include>$(BOOST_DIR)/include
+ <include>./
+ <variant>release:<cxxflags>-march=native
+ ;
+
+
+exe reference_wrapper_test
+ :
+ test/reference_wrapper_test.cpp
+ .//system
+ .//timer
+ .//chrono
+ :
+ <include>$(BOOST_DIR)/include
+ <include>./
+ <variant>release:<cxxflags>-march=native
+ ;
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..6c4ce40
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,25 @@
+Copyright (c) MapBox
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice, this
+ list of conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+- Neither the name "MapBox" nor the names of its contributors may be
+ used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
diff --git a/LICENSE_1_0.txt b/LICENSE_1_0.txt
new file mode 100644
index 0000000..36b7cd9
--- /dev/null
+++ b/LICENSE_1_0.txt
@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..3665251
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,110 @@
+
+CXX := $(CXX)
+CXX_STD ?= c++11
+
+BOOST_LIBS = -lboost_timer -lboost_system -lboost_chrono
+RELEASE_FLAGS = -O3 -DNDEBUG -march=native -DSINGLE_THREADED -fvisibility-inlines-hidden
+DEBUG_FLAGS = -O0 -g -DDEBUG -fno-inline-functions
+COMMON_FLAGS = -Wall -pedantic -Wextra -Wsign-compare -Wsign-conversion -Wshadow -Wunused-parameter -std=$(CXX_STD)
+CXXFLAGS := $(CXXFLAGS)
+LDFLAGS := $(LDFLAGS)
+
+OS:=$(shell uname -s)
+ifeq ($(OS),Darwin)
+ CXXFLAGS += -stdlib=libc++
+ LDFLAGS += -stdlib=libc++ -F/ -framework CoreFoundation
+else
+ BOOST_LIBS += -lrt
+endif
+
+ifeq (sizes,$(firstword $(MAKECMDGOALS)))
+ RUN_ARGS := $(wordlist 2,$(words $(MAKECMDGOALS)),$(MAKECMDGOALS))
+ $(eval $(RUN_ARGS):;@:)
+ ifndef RUN_ARGS
+ $(error sizes target requires you pass full path to boost variant.hpp)
+ endif
+ .PHONY: $(RUN_ARGS)
+endif
+
+all: out/bench-variant out/unique_ptr_test out/unique_ptr_test out/recursive_wrapper_test out/binary_visitor_test
+
+./deps/gyp:
+ git clone --depth 1 https://chromium.googlesource.com/external/gyp.git ./deps/gyp
+
+gyp: ./deps/gyp
+ deps/gyp/gyp --depth=. -Goutput_dir=./ --generator-output=./out -f make
+ make V=1 -C ./out tests
+ ./out/Release/tests
+
+out/bench-variant-debug: Makefile test/bench_variant.cpp variant.hpp recursive_wrapper.hpp
+ mkdir -p ./out
+ $(CXX) -o out/bench-variant-debug test/bench_variant.cpp -I./ -pthreads $(DEBUG_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) $(LDFLAGS) $(BOOST_LIBS)
+
+out/bench-variant: Makefile test/bench_variant.cpp variant.hpp recursive_wrapper.hpp
+ mkdir -p ./out
+ $(CXX) -o out/bench-variant test/bench_variant.cpp -I./ $(RELEASE_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) $(LDFLAGS) $(BOOST_LIBS)
+
+out/unique_ptr_test: Makefile test/unique_ptr_test.cpp variant.hpp recursive_wrapper.hpp
+ mkdir -p ./out
+ $(CXX) -o out/unique_ptr_test test/unique_ptr_test.cpp -I./ $(RELEASE_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) $(LDFLAGS) $(BOOST_LIBS)
+
+out/recursive_wrapper_test: Makefile test/recursive_wrapper_test.cpp variant.hpp recursive_wrapper.hpp
+ mkdir -p ./out
+ $(CXX) -o out/recursive_wrapper_test test/recursive_wrapper_test.cpp -I./ $(RELEASE_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) $(LDFLAGS) $(BOOST_LIBS)
+
+out/binary_visitor_test: Makefile test/binary_visitor_test.cpp variant.hpp variant_io.hpp recursive_wrapper.hpp
+ mkdir -p ./out
+ $(CXX) -o out/binary_visitor_test test/binary_visitor_test.cpp -I./ $(RELEASE_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) $(LDFLAGS) $(BOOST_LIBS)
+
+bench: out/bench-variant out/unique_ptr_test out/unique_ptr_test out/recursive_wrapper_test out/binary_visitor_test
+ ./out/bench-variant 100000
+ ./out/unique_ptr_test 100000
+ ./out/recursive_wrapper_test 100000
+ ./out/binary_visitor_test 100000
+
+out/unit.o: Makefile test/unit.cpp
+ mkdir -p ./out
+ $(CXX) -c -o $@ test/unit.cpp -Itest/include $(DEBUG_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS)
+
+out/%.o: test/t/%.cpp Makefile optional.hpp recursive_wrapper.hpp variant.hpp variant_io.hpp
+ mkdir -p ./out
+ $(CXX) -c -o $@ $< -I. -Itest/include $(DEBUG_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS)
+
+out/unit: out/unit.o out/binary_visitor_1.o out/binary_visitor_2.o out/binary_visitor_3.o out/binary_visitor_4.o out/binary_visitor_5.o out/binary_visitor_6.o out/issue21.o out/mutating_visitor.o out/optional.o out/recursive_wrapper.o out/sizeof.o out/unary_visitor.o out/variant.o
+ mkdir -p ./out
+ $(CXX) -o $@ $^ $(LDFLAGS)
+
+test: out/unit
+ ./out/unit
+
+coverage:
+ mkdir -p ./out
+ $(CXX) -o out/cov-test --coverage test/unit.cpp test/t/*.cpp -I./ -Itest/include $(DEBUG_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) $(LDFLAGS)
+
+sizes: Makefile variant.hpp recursive_wrapper.hpp
+ mkdir -p ./out
+ @$(CXX) -o ./out/our_variant_hello_world.out variant.hpp $(RELEASE_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) && du -h ./out/our_variant_hello_world.out
+ @$(CXX) -o ./out/boost_variant_hello_world.out $(RUN_ARGS) $(RELEASE_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) && du -h ./out/boost_variant_hello_world.out
+ @$(CXX) -o ./out/our_variant_hello_world ./test/our_variant_hello_world.cpp -I./ $(RELEASE_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) && du -h ./out/our_variant_hello_world
+ @$(CXX) -o ./out/boost_variant_hello_world ./test/boost_variant_hello_world.cpp -I./ $(RELEASE_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) && du -h ./out/boost_variant_hello_world
+
+profile: out/bench-variant-debug
+ mkdir -p profiling/
+ rm -rf profiling/*
+ iprofiler -timeprofiler -d profiling/ ./out/bench-variant-debug 500000
+
+clean:
+ rm -rf ./out
+ rm -rf *.dSYM
+ rm -f unit.gc*
+ rm -f *gcov
+ rm -f test/unit.gc*
+ rm -f test/*gcov
+ rm -f *.gcda *.gcno
+
+pgo: out Makefile variant.hpp recursive_wrapper.hpp
+ $(CXX) -o out/bench-variant test/bench_variant.cpp -I./ $(RELEASE_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) $(LDFLAGS) $(BOOST_LIBS) -pg -fprofile-generate
+ ./test-variant 500000 >/dev/null 2>/dev/null
+ $(CXX) -o out/bench-variant test/bench_variant.cpp -I./ $(RELEASE_FLAGS) $(COMMON_FLAGS) $(CXXFLAGS) $(LDFLAGS) $(BOOST_LIBS) -fprofile-use
+
+.PHONY: sizes test
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..24cdb57
--- /dev/null
+++ b/README.md
@@ -0,0 +1,111 @@
+# Mapbox Variant
+
+An alternative to `boost::variant` for C++11.
+
+[](https://travis-ci.org/mapbox/variant)
+[](https://ci.appveyor.com/project/Mapbox/variant)
+[](https://coveralls.io/r/mapbox/variant?branch=master)
+
+
+## Why use Mapbox Variant?
+
+Mapbox variant has the same speedy performance of `boost::variant` but is
+faster to compile, results in smaller binaries, and has no dependencies.
+
+For example on OS X 10.9 with clang++ and libc++:
+
+Test | Mapbox Variant | Boost Variant
+---- | -------------- | -------------
+Size of pre-compiled header (release / debug) | 2.8/2.8 MB | 12/15 MB
+Size of simple program linking variant (release / debug) | 8/24 K | 12/40 K
+Time to compile header | 185 ms | 675 ms
+
+(Numbers from an older version of Mapbox variant.)
+
+
+## Goals
+
+Mapbox `variant` has been a very valuable, lightweight alternative for apps
+that can use c++11 or c++14 but that do not want a boost dependency.
+Mapbox `variant` has also been useful in apps that do depend on boost, like
+mapnik, to help (slightly) with compile times and to majorly lessen dependence
+on boost in core headers. The original goal and near term goal is to maintain
+external API compatibility with `boost::variant` such that Mapbox `variant`
+can be a "drop in". At the same time the goal is to stay minimal: Only
+implement the features that are actually needed in existing software. So being
+an "incomplete" implementation is just fine.
+
+Currently Mapbox variant doesn't try to be API compatible with the upcoming
+variant standard, because the standard is not finished and it would be too much
+work. But we'll revisit this decision in the future if needed.
+
+If Mapbox variant is not for you, have a look at [these other
+implementations](doc/other_implementations.md).
+
+Want to know more about the upcoming standard? Have a look at our
+[overview](doc/standards_effort.md).
+
+
+## Depends
+
+ - Compiler supporting `-std=c++11` or `-std=c++14`
+
+Tested with:
+
+ - g++-4.7
+ - g++-4.8
+ - g++-4.9
+ - g++-5
+ - clang++-3.5
+ - clang++-3.6
+ - clang++-3.7
+ - clang++-3.8
+ - Visual Studio 2015
+
+## Usage
+
+There is nothing to build, just include `variant.hpp` and
+`recursive_wrapper.hpp` in your project. Include `variant_io.hpp` if you need
+the `operator<<` overload for variant.
+
+
+## Unit Tests
+
+On Unix systems compile and run the unit tests with `make test`.
+
+On Windows run `scripts/build-local.bat`.
+
+
+## Limitations
+
+* The `variant` can not hold references (something like `variant<int&>` is
+ not possible). You might want to try `std::reference_wrapper` instead.
+
+
+## Deprecations
+
+* The included implementation of `optional` is deprecated and will be removed
+ in a future version. See https://github.com/mapbox/variant/issues/64.
+* Old versions of the code needed visitors to derive from `static_visitor`.
+ This is not needed any more and marked as deprecated. The `static_visitor`
+ class will be removed in future versions.
+
+
+## Benchmarks
+
+The benchmarks depend on:
+
+ - Boost headers (for benchmarking against `boost::variant`)
+ - Boost built with `--with-timer` (used for benchmark timing)
+
+On Unix systems set your boost includes and libs locations and run `make test`:
+
+ export LDFLAGS='-L/opt/boost/lib'
+ export CXXFLAGS='-I/opt/boost/include'
+ make bench
+
+
+## Check object sizes
+
+ make sizes /path/to/boost/variant.hpp
+
diff --git a/appveyor.yml b/appveyor.yml
new file mode 100644
index 0000000..050ad25
--- /dev/null
+++ b/appveyor.yml
@@ -0,0 +1,17 @@
+
+platform:
+ - x64
+ - x86
+
+configuration:
+ - Debug
+ - Release
+
+os: Visual Studio 2015
+
+install:
+ - CALL scripts\build-appveyor.bat
+
+build: off
+test: off
+deploy: off
diff --git a/common.gypi b/common.gypi
new file mode 100644
index 0000000..d4f09f8
--- /dev/null
+++ b/common.gypi
@@ -0,0 +1,143 @@
+{
+ "conditions": [
+ ["OS=='win'", {
+ "target_defaults": {
+ "default_configuration": "Release_x64",
+ "msbuild_toolset":"v140",
+ "msvs_settings": {
+ "VCCLCompilerTool": {
+ "ExceptionHandling": 1, # /EHsc
+ "RuntimeTypeInfo": "true" # /GR
+ }
+ },
+ "configurations": {
+ "Debug_Win32": {
+ "msvs_configuration_platform": "Win32",
+ "defines": [ "DEBUG","_DEBUG"],
+ "msvs_settings": {
+ "VCCLCompilerTool": {
+ "RuntimeLibrary": "1", # static debug /MTd
+ "Optimization": 0, # /Od, no optimization
+ "MinimalRebuild": "false",
+ "OmitFramePointers": "false",
+ "BasicRuntimeChecks": 3 # /RTC1
+ }
+ }
+ },
+ "Debug_x64": {
+ "msvs_configuration_platform": "x64",
+ "defines": [ "DEBUG","_DEBUG"],
+ "msvs_settings": {
+ "VCCLCompilerTool": {
+ "RuntimeLibrary": "1", # static debug /MTd
+ "Optimization": 0, # /Od, no optimization
+ "MinimalRebuild": "false",
+ "OmitFramePointers": "false",
+ "BasicRuntimeChecks": 3 # /RTC1
+ }
+ }
+ },
+ "Release_Win32": {
+ "msvs_configuration_platform": "Win32",
+ "defines": [ "NDEBUG"],
+ "msvs_settings": {
+ "VCCLCompilerTool": {
+ "RuntimeLibrary": 0, # static release
+ "Optimization": 3, # /Ox, full optimization
+ "FavorSizeOrSpeed": 1, # /Ot, favour speed over size
+ "InlineFunctionExpansion": 2, # /Ob2, inline anything eligible
+ "WholeProgramOptimization": "true", # /GL, whole program optimization, needed for LTCG
+ "OmitFramePointers": "true",
+ "EnableFunctionLevelLinking": "true",
+ "EnableIntrinsicFunctions": "true",
+ "AdditionalOptions": [
+ "/MP", # compile across multiple CPUs
+ ],
+ "DebugInformationFormat": "0"
+ },
+ "VCLibrarianTool": {
+ "AdditionalOptions": [
+ "/LTCG" # link time code generation
+ ],
+ },
+ "VCLinkerTool": {
+ "LinkTimeCodeGeneration": 1, # link-time code generation
+ "OptimizeReferences": 2, # /OPT:REF
+ "EnableCOMDATFolding": 2, # /OPT:ICF
+ "LinkIncremental": 1, # disable incremental linking
+ "GenerateDebugInformation": "false"
+ }
+ }
+ },
+ "Release_x64": {
+ "msvs_configuration_platform": "x64",
+ "defines": [ "NDEBUG"],
+ "msvs_settings": {
+ "VCCLCompilerTool": {
+ "RuntimeLibrary": 0, # static release
+ "Optimization": 3, # /Ox, full optimization
+ "FavorSizeOrSpeed": 1, # /Ot, favour speed over size
+ "InlineFunctionExpansion": 2, # /Ob2, inline anything eligible
+ "WholeProgramOptimization": "true", # /GL, whole program optimization, needed for LTCG
+ "OmitFramePointers": "true",
+ "EnableFunctionLevelLinking": "true",
+ "EnableIntrinsicFunctions": "true",
+ "AdditionalOptions": [
+ "/MP", # compile across multiple CPUs
+ ],
+ "DebugInformationFormat": "0"
+ },
+ "VCLibrarianTool": {
+ "AdditionalOptions": [
+ "/LTCG" # link time code generation
+ ],
+ },
+ "VCLinkerTool": {
+ "LinkTimeCodeGeneration": 1, # link-time code generation
+ "OptimizeReferences": 2, # /OPT:REF
+ "EnableCOMDATFolding": 2, # /OPT:ICF
+ "LinkIncremental": 1, # disable incremental linking
+ "GenerateDebugInformation": "false"
+ }
+ }
+ }
+ }
+ }
+ }, {
+ "target_defaults": {
+ "default_configuration": "Release",
+ "xcode_settings": {
+ "CLANG_CXX_LIBRARY": "libc++",
+ "CLANG_CXX_LANGUAGE_STANDARD":"c++11",
+ "GCC_VERSION": "com.apple.compilers.llvm.clang.1_0",
+ },
+ "cflags_cc": ["-std=c++11"],
+ "configurations": {
+ "Debug": {
+ "defines": [
+ "DEBUG"
+ ],
+ "xcode_settings": {
+ "GCC_OPTIMIZATION_LEVEL": "0",
+ "GCC_GENERATE_DEBUGGING_SYMBOLS": "YES",
+ "OTHER_CPLUSPLUSFLAGS": [ "-Wall", "-Wextra", "-pedantic", "-g", "-O0" ]
+ }
+ },
+ "Release": {
+ "defines": [
+ "NDEBUG"
+ ],
+ "xcode_settings": {
+ "GCC_OPTIMIZATION_LEVEL": "3",
+ "GCC_GENERATE_DEBUGGING_SYMBOLS": "NO",
+ "DEAD_CODE_STRIPPING": "YES",
+ "GCC_INLINES_ARE_PRIVATE_EXTERN": "YES",
+ "OTHER_CPLUSPLUSFLAGS": [ "-Wall", "-Wextra", "-pedantic", "-O3" ]
+ }
+ }
+ }
+ }
+ }]
+ ]
+}
+
diff --git a/doc/other_implementations.md b/doc/other_implementations.md
new file mode 100644
index 0000000..a0d8b9b
--- /dev/null
+++ b/doc/other_implementations.md
@@ -0,0 +1,15 @@
+
+# Other implementations of variant and optional
+
+These are some other implementations of `variant` and/or `optional` types.
+They are not necessarily compatible with this implementation. This is an
+incomplete list.
+
+* [Boost Variant](http://www.boost.org/doc/libs/1_59_0/doc/html/variant.html) and [Boost Optional](http://www.boost.org/doc/libs/1_59_0/libs/optional/doc/html/index.html)
+* [Eggs Variant](http://eggs-cpp.github.io/variant/) by [Agustín Bergé](http://talesofcpp.fusionfenix.com/)
+* [anthonyw/variant](https://bitbucket.org/anthonyw/variant) (implementation of P0110R0)
+* [JasonL9000/cppcon14](https://github.com/JasonL9000/cppcon14)
+* [tomilov/variant](https://github.com/tomilov/variant)
+* [akrzemi1/Optional](https://github.com/akrzemi1/Optional)
+* [mpark/variant](https://github.com/mpark/variant)
+
diff --git a/doc/standards_effort.md b/doc/standards_effort.md
new file mode 100644
index 0000000..d2df488
--- /dev/null
+++ b/doc/standards_effort.md
@@ -0,0 +1,28 @@
+
+# Standards efforts
+
+A `variant` type is on planned for inclusion in the C++ Standard, probably in
+C++17. Current working papers are (list extracted from [2015 working group
+papers](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/)):
+
+* 2015-09-28: Variant design review. [P0086R0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0086r0.pdf)
+* 2015-09-28: Variant: a type-safe union without undefined behavior (v2) [P0087R0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0087r0.pdf)
+* 2015-09-27: Variant: a type-safe union that is rarely invalid (v5) [P0088R0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0088r0.pdf)
+* 2015-09-24: Simply a Strong Variant [P0093R0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0093r0.html)
+* 2015-09-24: Simply a Basic Variant [P0094R0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0094r0.html)
+* 2015-09-24: The Case for a Language Based Variant [P0096R0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0095r0.html)
+* 2015-09-25: Implementing the strong guarantee for variant<> assignment [P0110R0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0110r0.html)
+* 2015-09-24: Homogeneous interface for variant, any and optional (Revision 1) [P0032R1](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0032r1.pdf)
+
+Last state can be seen from
+[The Variant Saga: A happy ending?](https://isocpp.org/blog/2015/11/the-variant-saga-a-happy-ending).
+
+The `optional` type is also on the way into the standard. The papers are:
+* 2013-10-03: A proposal to add a utility class to represent optional objects (Revision 5) [N3793](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3793.html)
+* 2014-01-18: Working Draft, Technical Specification on C++ Extensions for Library Fundamentals [N3848](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3848.html)
+
+## Older Papers
+
+* Older working drafts are: N4218 (rev 1), N4516 (rev 2), N4450 (rev 3), and [N4542](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4542.pdf) (rev 4). They have been split into P0086 (general design discussions) and P0087 and P0088 (containing two competing? specs).
+* 2015-07-28: Variant: Discriminated Union with Value Semantics [P0080R0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0080r0.pdf) An alternative proposal to N4542.
+
diff --git a/optional.hpp b/optional.hpp
new file mode 100644
index 0000000..1185894
--- /dev/null
+++ b/optional.hpp
@@ -0,0 +1,74 @@
+#ifndef MAPBOX_UTIL_OPTIONAL_HPP
+#define MAPBOX_UTIL_OPTIONAL_HPP
+
+#pragma message("This implementation of optional is deprecated. See https://github.com/mapbox/variant/issues/64.")
+
+#include <type_traits>
+#include <utility>
+
+#include "variant.hpp"
+
+namespace mapbox {
+namespace util {
+
+template <typename T>
+class optional
+{
+ static_assert(!std::is_reference<T>::value, "optional doesn't support references");
+
+ struct none_type
+ {
+ };
+
+ variant<none_type, T> variant_;
+
+ public:
+ optional() = default;
+
+ optional(optional const& rhs)
+ {
+ if (this != &rhs)
+ { // protect against invalid self-assignment
+ variant_ = rhs.variant_;
+ }
+ }
+
+ optional(T const& v) { variant_ = v; }
+
+ explicit operator bool() const noexcept { return variant_.template is<T>(); }
+
+ T const& get() const { return variant_.template get<T>(); }
+ T& get() { return variant_.template get<T>(); }
+
+ T const& operator*() const { return this->get(); }
+ T operator*() { return this->get(); }
+
+ optional& operator=(T const& v)
+ {
+ variant_ = v;
+ return *this;
+ }
+
+ optional& operator=(optional const& rhs)
+ {
+ if (this != &rhs)
+ {
+ variant_ = rhs.variant_;
+ }
+ return *this;
+ }
+
+ template <typename... Args>
+ void emplace(Args&&... args)
+ {
+ variant_ = T{std::forward<Args>(args)...};
+ }
+
+ void reset() { variant_ = none_type{}; }
+
+}; // class optional
+
+} // namespace util
+} // namespace mapbox
+
+#endif // MAPBOX_UTIL_OPTIONAL_HPP
diff --git a/recursive_wrapper.hpp b/recursive_wrapper.hpp
new file mode 100644
index 0000000..4becdd6
--- /dev/null
+++ b/recursive_wrapper.hpp
@@ -0,0 +1,122 @@
+#ifndef MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
+#define MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
+
+// Based on variant/recursive_wrapper.hpp from boost.
+//
+// Original license:
+//
+// Copyright (c) 2002-2003
+// Eric Friedman, Itay Maman
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <cassert>
+#include <utility>
+
+namespace mapbox {
+namespace util {
+
+template <typename T>
+class recursive_wrapper
+{
+
+ T* p_;
+
+ void assign(T const& rhs)
+ {
+ this->get() = rhs;
+ }
+
+ public:
+ using type = T;
+
+ /**
+ * Default constructor default initializes the internally stored value.
+ * For POD types this means nothing is done and the storage is
+ * uninitialized.
+ *
+ * @throws std::bad_alloc if there is insufficient memory for an object
+ * of type T.
+ * @throws any exception thrown by the default constructur of T.
+ */
+ recursive_wrapper()
+ : p_(new T){};
+
+ ~recursive_wrapper() noexcept { delete p_; };
+
+ recursive_wrapper(recursive_wrapper const& operand)
+ : p_(new T(operand.get())) {}
+
+ recursive_wrapper(T const& operand)
+ : p_(new T(operand)) {}
+
+ recursive_wrapper(recursive_wrapper&& operand)
+ : p_(new T(std::move(operand.get()))) {}
+
+ recursive_wrapper(T&& operand)
+ : p_(new T(std::move(operand))) {}
+
+ inline recursive_wrapper& operator=(recursive_wrapper const& rhs)
+ {
+ assign(rhs.get());
+ return *this;
+ }
+
+ inline recursive_wrapper& operator=(T const& rhs)
+ {
+ assign(rhs);
+ return *this;
+ }
+
+ inline void swap(recursive_wrapper& operand) noexcept
+ {
+ T* temp = operand.p_;
+ operand.p_ = p_;
+ p_ = temp;
+ }
+
+ recursive_wrapper& operator=(recursive_wrapper&& rhs) noexcept
+ {
+ swap(rhs);
+ return *this;
+ }
+
+ recursive_wrapper& operator=(T&& rhs)
+ {
+ get() = std::move(rhs);
+ return *this;
+ }
+
+ T& get()
+ {
+ assert(p_);
+ return *get_pointer();
+ }
+
+ T const& get() const
+ {
+ assert(p_);
+ return *get_pointer();
+ }
+
+ T* get_pointer() { return p_; }
+
+ const T* get_pointer() const { return p_; }
+
+ operator T const&() const { return this->get(); }
+
+ operator T&() { return this->get(); }
+
+}; // class recursive_wrapper
+
+template <typename T>
+inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) noexcept
+{
+ lhs.swap(rhs);
+}
+} // namespace util
+} // namespace mapbox
+
+#endif // MAPBOX_UTIL_RECURSIVE_WRAPPER_HPP
diff --git a/scripts/build-appveyor.bat b/scripts/build-appveyor.bat
new file mode 100644
index 0000000..bdee7ea
--- /dev/null
+++ b/scripts/build-appveyor.bat
@@ -0,0 +1,32 @@
+ at ECHO OFF
+SETLOCAL
+
+SET PATH=c:\python27;%PATH%
+
+ECHO activating VS command prompt
+IF /I "%PLATFORM"=="x64" (
+ CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64
+) ELSE (
+ CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" x86
+)
+
+IF NOT EXIST deps\gyp git clone --quiet --depth 1 https://chromium.googlesource.com/external/gyp.git deps/gyp
+
+CALL deps\gyp\gyp.bat variant.gyp --depth=. ^
+-f msvs ^
+-G msvs_version=2015 ^
+--generator-output=build
+
+SET MSBUILD_PLATFORM=%platform%
+IF /I "%MSBUILD_PLATFORM%" == "x86" SET MSBUILD_PLATFORM=Win32
+
+
+msbuild ^
+build\variant.sln ^
+/nologo ^
+/toolsversion:14.0 ^
+/p:PlatformToolset=v140 ^
+/p:Configuration=%configuration% ^
+/p:Platform=%MSBUILD_PLATFORM%
+
+build\"%configuration%"\tests.exe
diff --git a/scripts/build-local.bat b/scripts/build-local.bat
new file mode 100644
index 0000000..34a2e61
--- /dev/null
+++ b/scripts/build-local.bat
@@ -0,0 +1,7 @@
+ at ECHO OFF
+SETLOCAL
+
+SET platform=x64
+SET configuration=Release
+
+CALL scripts\build-appveyor.bat
\ No newline at end of file
diff --git a/scripts/run_compilation_failure_tests.sh b/scripts/run_compilation_failure_tests.sh
new file mode 100755
index 0000000..c2608fe
--- /dev/null
+++ b/scripts/run_compilation_failure_tests.sh
@@ -0,0 +1,50 @@
+#!/bin/sh
+#
+# Try to compile all programs in the test/compilation_failure directory.
+# Compilation must fail and the error message must match the pattern in the
+# corresponding .pattern file.
+#
+
+DIR="test/compilation_failure"
+CXX=${CXX:-clang++}
+
+if [ `uname -s` = "Darwin" ]; then
+ CXXFLAGS="$CXXFLAGS -stdlib=libc++"
+fi
+
+error_msg() {
+ if [ ! -z "$1" ]; then
+ printf 'output was:\n=======\n%s\n=======\n' "$1"
+ fi
+}
+
+exit_code=0
+for test_code in $DIR/*.cpp; do
+ name=`basename $test_code .cpp`
+
+ result=`${CXX} -std=c++11 -c -o /dev/null -I. ${CXXFLAGS} ${test_code} 2>&1`
+ status=$?
+
+ if [ $status = 1 ]; then
+ expected=`sed -n -e '/@EXPECTED/s/.*: \+//p' ${test_code}`
+ if echo $result | grep -q "$expected"; then
+ echo "$name [OK]"
+ else
+ echo "$name [FAILED - wrong error message]"
+ echo "Expected error message: $expected"
+ error_msg "$result"
+ exit_code=1
+ fi
+ elif [ $status = 0 ]; then
+ echo "$name [FAILED - compile was successful]"
+ error_msg "$result"
+ exit_code=1
+ else
+ echo "$name [FAILED - unknown error in compile]"
+ error_msg "$result"
+ exit_code=1
+ fi
+done
+
+exit ${exit_code}
+
diff --git a/test/bench_variant.cpp b/test/bench_variant.cpp
new file mode 100644
index 0000000..700dac7
--- /dev/null
+++ b/test/bench_variant.cpp
@@ -0,0 +1,185 @@
+
+#include <algorithm>
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+#include <boost/timer/timer.hpp>
+#include <boost/variant.hpp>
+
+#include "variant.hpp"
+
+#define TEXT_SHORT "Test"
+#define TEXT_LONG "Testing various variant implementations with a longish string ........................................."
+#define NUM_SAMPLES 3
+//#define BOOST_VARIANT_MINIMIZE_SIZE
+
+using namespace mapbox;
+
+namespace test {
+
+template <typename V>
+struct Holder
+{
+ typedef V value_type;
+ std::vector<value_type> data;
+
+ template <typename T>
+ void append_move(T&& obj)
+ {
+ data.emplace_back(std::forward<T>(obj));
+ }
+
+ template <typename T>
+ void append(T const& obj)
+ {
+ data.push_back(obj);
+ }
+};
+
+} // namespace test
+
+struct print
+{
+ template <typename T>
+ void operator()(T const& val) const
+ {
+ std::cerr << val << ":" << typeid(T).name() << std::endl;
+ }
+};
+
+template <typename V>
+struct dummy : boost::static_visitor<>
+{
+ dummy(V& v)
+ : v_(v) {}
+
+ template <typename T>
+ void operator()(T&& val) const
+ {
+ v_ = std::move(val);
+ }
+ V& v_;
+};
+
+template <typename V>
+struct dummy2
+{
+ dummy2(V& v)
+ : v_(v) {}
+
+ template <typename T>
+ void operator()(T&& val) const
+ {
+ v_ = std::move(val);
+ }
+ V& v_;
+};
+
+void run_boost_test(std::size_t runs)
+{
+ test::Holder<boost::variant<int, double, std::string>> h;
+ h.data.reserve(runs);
+ for (std::size_t i = 0; i < runs; ++i)
+ {
+ h.append_move(std::string(TEXT_SHORT));
+ h.append_move(std::string(TEXT_LONG));
+ h.append_move(123);
+ h.append_move(3.14159);
+ }
+
+ boost::variant<int, double, std::string> v;
+ for (auto const& v2 : h.data)
+ {
+ dummy<boost::variant<int, double, std::string>> d(v);
+ boost::apply_visitor(d, v2);
+ }
+}
+
+void run_variant_test(std::size_t runs)
+{
+ test::Holder<util::variant<int, double, std::string>> h;
+ h.data.reserve(runs);
+ for (std::size_t i = 0; i < runs; ++i)
+ {
+ h.append_move(std::string(TEXT_SHORT));
+ h.append_move(std::string(TEXT_LONG));
+ h.append_move(123);
+ h.append_move(3.14159);
+ }
+
+ util::variant<int, double, std::string> v;
+ for (auto const& v2 : h.data)
+ {
+ dummy2<util::variant<int, double, std::string>> d(v);
+ util::apply_visitor(d, v2);
+ }
+}
+
+int main(int argc, char** argv)
+{
+ if (argc != 2)
+ {
+ std::cerr << "Usage:" << argv[0] << " <num-runs>" << std::endl;
+ return 1;
+ }
+
+#ifndef SINGLE_THREADED
+ const std::size_t THREADS = 4;
+#endif
+ const std::size_t NUM_RUNS = static_cast<std::size_t>(std::stol(argv[1]));
+
+#ifdef SINGLE_THREADED
+
+ for (std::size_t j = 0; j < NUM_SAMPLES; ++j)
+ {
+
+ {
+ std::cerr << "custom variant: ";
+ boost::timer::auto_cpu_timer t;
+ run_variant_test(NUM_RUNS);
+ }
+ {
+ std::cerr << "boost variant: ";
+ boost::timer::auto_cpu_timer t;
+ run_boost_test(NUM_RUNS);
+ }
+ }
+
+#else
+ for (std::size_t j = 0; j < NUM_SAMPLES; ++j)
+ {
+ {
+ typedef std::vector<std::unique_ptr<std::thread>> thread_group;
+ typedef thread_group::value_type value_type;
+ thread_group tg;
+ std::cerr << "custom variant: ";
+ boost::timer::auto_cpu_timer timer;
+ for (std::size_t i = 0; i < THREADS; ++i)
+ {
+ tg.emplace_back(new std::thread(run_variant_test, NUM_RUNS));
+ }
+ std::for_each(tg.begin(), tg.end(), [](value_type& t) {if (t->joinable()) t->join(); });
+ }
+
+ {
+ typedef std::vector<std::unique_ptr<std::thread>> thread_group;
+ typedef thread_group::value_type value_type;
+ thread_group tg;
+ std::cerr << "boost variant: ";
+ boost::timer::auto_cpu_timer timer;
+ for (std::size_t i = 0; i < THREADS; ++i)
+ {
+ tg.emplace_back(new std::thread(run_boost_test, NUM_RUNS));
+ }
+ std::for_each(tg.begin(), tg.end(), [](value_type& t) {if (t->joinable()) t->join(); });
+ }
+ }
+#endif
+
+ return EXIT_SUCCESS;
+}
diff --git a/test/binary_visitor_test.cpp b/test/binary_visitor_test.cpp
new file mode 100644
index 0000000..fa0f2ea
--- /dev/null
+++ b/test/binary_visitor_test.cpp
@@ -0,0 +1,138 @@
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdlib>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "variant.hpp"
+#include "variant_io.hpp"
+
+using namespace mapbox;
+
+namespace test {
+
+template <typename T>
+struct string_to_number
+{
+};
+
+template <>
+struct string_to_number<double>
+{
+ double operator()(std::string const& str) const
+ {
+ return std::stod(str);
+ }
+};
+
+template <>
+struct string_to_number<std::int64_t>
+{
+ std::int64_t operator()(std::string const& str) const
+ {
+ return std::stoll(str);
+ }
+};
+
+template <>
+struct string_to_number<std::uint64_t>
+{
+ std::uint64_t operator()(std::string const& str) const
+ {
+ return std::stoull(str);
+ }
+};
+
+template <>
+struct string_to_number<bool>
+{
+ bool operator()(std::string const& str) const
+ {
+ bool result;
+ std::istringstream(str) >> std::boolalpha >> result;
+ return result;
+ }
+};
+
+struct javascript_equal_visitor
+{
+ template <typename T>
+ bool operator()(T lhs, T rhs) const
+ {
+ return lhs == rhs;
+ }
+
+ template <typename T, class = typename std::enable_if<std::is_arithmetic<T>::value>::type>
+ bool operator()(T lhs, std::string const& rhs) const
+ {
+ return lhs == string_to_number<T>()(rhs);
+ }
+
+ template <typename T, class = typename std::enable_if<std::is_arithmetic<T>::value>::type>
+ bool operator()(std::string const& lhs, T rhs) const
+ {
+ return string_to_number<T>()(lhs) == rhs;
+ }
+
+ template <typename T0, typename T1>
+ bool operator()(T0 lhs, T1 rhs) const
+ {
+ return lhs == static_cast<T0>(rhs);
+ }
+};
+
+template <typename T>
+struct javascript_equal
+{
+ javascript_equal(T const& lhs)
+ : lhs_(lhs) {}
+
+ bool operator()(T const& rhs) const
+ {
+ return util::apply_visitor(test::javascript_equal_visitor(), lhs_, rhs);
+ }
+ T const& lhs_;
+};
+
+} // namespace test
+
+int main()
+{
+ typedef util::variant<bool, std::int64_t, std::uint64_t, double, std::string> variant_type;
+ variant_type v0(3.14159);
+ variant_type v1(std::string("3.14159"));
+ variant_type v2(std::uint64_t(1));
+
+ std::cerr << v0 << " == " << v1 << " -> "
+ << std::boolalpha << util::apply_visitor(test::javascript_equal_visitor(), v0, v1) << std::endl;
+
+ std::vector<variant_type> vec;
+
+ vec.emplace_back(std::string("1"));
+ vec.push_back(variant_type(std::uint64_t(2)));
+ vec.push_back(variant_type(std::uint64_t(3)));
+ vec.push_back(std::string("3.14159"));
+ vec.emplace_back(3.14159);
+
+ //auto itr = std::find_if(vec.begin(), vec.end(), [&v0](variant_type const& val) {
+ // return util::apply_visitor(test::javascript_equal_visitor(), v0, val);
+ // });
+
+ auto itr = std::find_if(vec.begin(), vec.end(), test::javascript_equal<variant_type>(v2));
+
+ if (itr != std::end(vec))
+ {
+ std::cout << "found " << *itr << std::endl;
+ }
+ else
+ {
+ std::cout << "can't find " << v2 << '\n';
+ }
+
+ return EXIT_SUCCESS;
+}
diff --git a/test/boost_variant_hello_world.cpp b/test/boost_variant_hello_world.cpp
new file mode 100644
index 0000000..fdb200e
--- /dev/null
+++ b/test/boost_variant_hello_world.cpp
@@ -0,0 +1,20 @@
+#include <boost/variant.hpp>
+
+#include <stdexcept>
+
+struct check : boost::static_visitor<>
+{
+ template <typename T>
+ void operator()(T const& val) const
+ {
+ if (val != 0) throw std::runtime_error("invalid");
+ }
+};
+
+int main()
+{
+ typedef boost::variant<bool, int, double> variant_type;
+ variant_type v(0);
+ boost::apply_visitor(check(), v);
+ return 0;
+}
diff --git a/test/compilation_failure/default_constructor.cpp b/test/compilation_failure/default_constructor.cpp
new file mode 100644
index 0000000..c75a8c1
--- /dev/null
+++ b/test/compilation_failure/default_constructor.cpp
@@ -0,0 +1,22 @@
+
+// @EXPECTED: First type in variant must be default constructible to allow default construction of variant
+
+#include <variant.hpp>
+
+// Checks that the first type in a variant must be default constructible to
+// make the variant default constructible.
+
+struct no_def_constructor
+{
+
+ int value;
+
+ no_def_constructor() = delete;
+
+ no_def_constructor(int v) : value(v) {}
+};
+
+int main()
+{
+ mapbox::util::variant<no_def_constructor> x;
+}
diff --git a/test/compilation_failure/empty_typelist.cpp b/test/compilation_failure/empty_typelist.cpp
new file mode 100644
index 0000000..69a631c
--- /dev/null
+++ b/test/compilation_failure/empty_typelist.cpp
@@ -0,0 +1,11 @@
+
+// @EXPECTED: Template parameter type list of variant can not be empty
+
+#include <variant.hpp>
+
+// Empty type list should not work.
+
+int main()
+{
+ mapbox::util::variant<> x;
+}
diff --git a/test/compilation_failure/equality.cpp b/test/compilation_failure/equality.cpp
new file mode 100644
index 0000000..b99a308
--- /dev/null
+++ b/test/compilation_failure/equality.cpp
@@ -0,0 +1,11 @@
+
+// @EXPECTED:
+
+#include <variant.hpp>
+
+int main()
+{
+ mapbox::util::variant<int> x;
+ mapbox::util::variant<double> y;
+ x == y;
+}
diff --git a/test/compilation_failure/get_type.cpp b/test/compilation_failure/get_type.cpp
new file mode 100644
index 0000000..5123eb1
--- /dev/null
+++ b/test/compilation_failure/get_type.cpp
@@ -0,0 +1,10 @@
+
+// @EXPECTED: enable_if
+
+#include <variant.hpp>
+
+int main()
+{
+ mapbox::util::variant<int, double> x;
+ x.get<std::string>();
+}
diff --git a/test/compilation_failure/is_type.cpp b/test/compilation_failure/is_type.cpp
new file mode 100644
index 0000000..a79638e
--- /dev/null
+++ b/test/compilation_failure/is_type.cpp
@@ -0,0 +1,10 @@
+
+// @EXPECTED: invalid type in T in `is<T>()` for this variant
+
+#include <variant.hpp>
+
+int main()
+{
+ mapbox::util::variant<int, double> x;
+ x.is<std::string>();
+}
diff --git a/test/compilation_failure/mutating_visitor_on_const.cpp b/test/compilation_failure/mutating_visitor_on_const.cpp
new file mode 100644
index 0000000..ee77b56
--- /dev/null
+++ b/test/compilation_failure/mutating_visitor_on_const.cpp
@@ -0,0 +1,24 @@
+
+// @EXPECTED: const int
+
+#include <variant.hpp>
+
+struct mutating_visitor
+{
+ mutating_visitor(int val)
+ : val_(val) {}
+
+ void operator()(int& val) const
+ {
+ val = val_;
+ }
+
+ int val_;
+};
+
+int main()
+{
+ const mapbox::util::variant<int> var(123);
+ const mutating_visitor visitor(456);
+ mapbox::util::apply_visitor(visitor, var);
+}
diff --git a/test/compilation_failure/no-reference.cpp b/test/compilation_failure/no-reference.cpp
new file mode 100644
index 0000000..17123ce
--- /dev/null
+++ b/test/compilation_failure/no-reference.cpp
@@ -0,0 +1,9 @@
+
+// @EXPECTED: Variant can not hold reference types
+
+#include <variant.hpp>
+
+int main()
+{
+ mapbox::util::variant<double, int&, long> x{mapbox::util::no_init()};
+}
diff --git a/test/include/catch.hpp b/test/include/catch.hpp
new file mode 100644
index 0000000..dd6e3ed
--- /dev/null
+++ b/test/include/catch.hpp
@@ -0,0 +1,11613 @@
+/*
+ * Catch v1.3.2
+ * Generated: 2015-12-28 15:07:07.166291
+ * ----------------------------------------------------------
+ * This file has been merged from multiple headers. Please don't edit it directly
+ * Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
+#define TWOBLUECUBES_CATCH_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang system_header
+#elif defined __GNUC__
+#pragma GCC system_header
+#endif
+
+// #included from: internal/catch_suppress_warnings.h
+
+#ifdef __clang__
+#ifdef __ICC // icpc defines the __clang__ macro
+#pragma warning(push)
+#pragma warning(disable : 161 1682)
+#else // __ICC
+#pragma clang diagnostic ignored "-Wglobal-constructors"
+#pragma clang diagnostic ignored "-Wvariadic-macros"
+#pragma clang diagnostic ignored "-Wc99-extensions"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#pragma clang diagnostic ignored "-Wc++98-compat"
+#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#pragma clang diagnostic ignored "-Wswitch-enum"
+#pragma clang diagnostic ignored "-Wcovered-switch-default"
+#endif
+#elif defined __GNUC__
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpadded"
+#endif
+#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
+#define CATCH_IMPL
+#endif
+
+#ifdef CATCH_IMPL
+#ifndef CLARA_CONFIG_MAIN
+#define CLARA_CONFIG_MAIN_NOT_DEFINED
+#define CLARA_CONFIG_MAIN
+#endif
+#endif
+
+// #included from: internal/catch_notimplemented_exception.h
+#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED
+
+// #included from: catch_common.h
+#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED
+
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2(name, line) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE(name, line) INTERNAL_CATCH_UNIQUE_NAME_LINE2(name, line)
+#define INTERNAL_CATCH_UNIQUE_NAME(name) INTERNAL_CATCH_UNIQUE_NAME_LINE(name, __LINE__)
+
+#define INTERNAL_CATCH_STRINGIFY2(expr) #expr
+#define INTERNAL_CATCH_STRINGIFY(expr) INTERNAL_CATCH_STRINGIFY2(expr)
+
+#include <algorithm>
+#include <sstream>
+#include <stdexcept>
+
+// #included from: catch_compiler_capabilities.h
+#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+// Detect a number of compiler features - mostly C++11/14 conformance - by compiler
+// The following features are defined:
+//
+// CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported?
+// CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported?
+// CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods
+// CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported?
+// CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported
+// CATCH_CONFIG_CPP11_LONG_LONG : is long long supported?
+// CATCH_CONFIG_CPP11_OVERRIDE : is override supported?
+// CATCH_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr)
+
+// CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported?
+
+// CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported?
+
+// ****************
+// Note to maintainers: if new toggles are added please document them
+// in configuration.md, too
+// ****************
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CATCH_CONFIG_CPP11_NO_NULLPTR) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+// All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11
+
+#ifdef __clang__
+
+#if __has_feature(cxx_nullptr)
+#define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#endif
+
+#if __has_feature(cxx_noexcept)
+#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#endif
+
+#endif // __clang__
+
+////////////////////////////////////////////////////////////////////////////////
+// Borland
+#ifdef __BORLANDC__
+
+#endif // __BORLANDC__
+
+////////////////////////////////////////////////////////////////////////////////
+// EDG
+#ifdef __EDG_VERSION__
+
+#endif // __EDG_VERSION__
+
+////////////////////////////////////////////////////////////////////////////////
+// Digital Mars
+#ifdef __DMC__
+
+#endif // __DMC__
+
+////////////////////////////////////////////////////////////////////////////////
+// GCC
+#ifdef __GNUC__
+
+#if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)
+#define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#endif
+
+// - otherwise more recent versions define __cplusplus >= 201103L
+// and will get picked up below
+
+#endif // __GNUC__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#ifdef _MSC_VER
+
+#if (_MSC_VER >= 1600)
+#define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
+#endif
+
+#if (_MSC_VER >= 1900) // (VC++ 13 (VS2015))
+#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#endif
+
+#endif // _MSC_VER
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Use variadic macros if the compiler supports them
+#if (defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
+ (defined __WAVE__ && __WAVE_HAS_VARIADICS) || \
+ (defined __GNUC__ && __GNUC__ >= 3) || \
+ (!defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L)
+
+#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// C++ language feature support
+
+// catch all support for C++11
+#if defined(__cplusplus) && __cplusplus >= 201103L
+
+#define CATCH_CPP11_OR_GREATER
+
+#if !defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR)
+#define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#endif
+
+#ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
+#endif
+
+#ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
+#endif
+
+#ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM
+#define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM
+#endif
+
+#ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE
+#define CATCH_INTERNAL_CONFIG_CPP11_TUPLE
+#endif
+
+#ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
+#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG)
+#define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE)
+#define CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE
+#endif
+#if !defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR)
+#define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
+#endif
+
+#endif // __cplusplus >= 201103L
+
+// Now set the actual defines based on the above + anything the user has configured
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NO_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_NO_CPP11)
+#define CATCH_CONFIG_CPP11_NULLPTR
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_NO_CPP11)
+#define CATCH_CONFIG_CPP11_NOEXCEPT
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11)
+#define CATCH_CONFIG_CPP11_GENERATED_METHODS
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_NO_CPP11)
+#define CATCH_CONFIG_CPP11_IS_ENUM
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_CPP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_NO_CPP11)
+#define CATCH_CONFIG_CPP11_TUPLE
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONFIG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS)
+#define CATCH_CONFIG_VARIADIC_MACROS
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_CPP11)
+#define CATCH_CONFIG_CPP11_LONG_LONG
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_CPP11)
+#define CATCH_CONFIG_CPP11_OVERRIDE
+#endif
+#if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11)
+#define CATCH_CONFIG_CPP11_UNIQUE_PTR
+#endif
+
+// noexcept support:
+#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)
+#define CATCH_NOEXCEPT noexcept
+#define CATCH_NOEXCEPT_IS(x) noexcept(x)
+#else
+#define CATCH_NOEXCEPT throw()
+#define CATCH_NOEXCEPT_IS(x)
+#endif
+
+// nullptr support
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+#define CATCH_NULL nullptr
+#else
+#define CATCH_NULL NULL
+#endif
+
+// override support
+#ifdef CATCH_CONFIG_CPP11_OVERRIDE
+#define CATCH_OVERRIDE override
+#else
+#define CATCH_OVERRIDE
+#endif
+
+// unique_ptr support
+#ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR
+#define CATCH_AUTO_PTR(T) std::unique_ptr<T>
+#else
+#define CATCH_AUTO_PTR(T) std::auto_ptr<T>
+#endif
+
+namespace Catch {
+
+struct IConfig;
+
+struct CaseSensitive
+{
+ enum Choice
+ {
+ Yes,
+ No
+ };
+};
+
+class NonCopyable
+{
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+ NonCopyable(NonCopyable const&) = delete;
+ NonCopyable(NonCopyable&&) = delete;
+ NonCopyable& operator=(NonCopyable const&) = delete;
+ NonCopyable& operator=(NonCopyable&&) = delete;
+#else
+ NonCopyable(NonCopyable const& info);
+ NonCopyable& operator=(NonCopyable const&);
+#endif
+
+ protected:
+ NonCopyable() {}
+ virtual ~NonCopyable();
+};
+
+class SafeBool
+{
+ public:
+ typedef void (SafeBool::*type)() const;
+
+ static type makeSafe(bool value)
+ {
+ return value ? &SafeBool::trueValue : 0;
+ }
+
+ private:
+ void trueValue() const {}
+};
+
+template <typename ContainerT>
+inline void deleteAll(ContainerT& container)
+{
+ typename ContainerT::const_iterator it = container.begin();
+ typename ContainerT::const_iterator itEnd = container.end();
+ for (; it != itEnd; ++it)
+ delete *it;
+}
+template <typename AssociativeContainerT>
+inline void deleteAllValues(AssociativeContainerT& container)
+{
+ typename AssociativeContainerT::const_iterator it = container.begin();
+ typename AssociativeContainerT::const_iterator itEnd = container.end();
+ for (; it != itEnd; ++it)
+ delete it->second;
+}
+
+bool startsWith(std::string const& s, std::string const& prefix);
+bool endsWith(std::string const& s, std::string const& suffix);
+bool contains(std::string const& s, std::string const& infix);
+void toLowerInPlace(std::string& s);
+std::string toLower(std::string const& s);
+std::string trim(std::string const& str);
+bool replaceInPlace(std::string& str, std::string const& replaceThis, std::string const& withThis);
+
+struct pluralise
+{
+ pluralise(std::size_t count, std::string const& label);
+
+ friend std::ostream& operator<<(std::ostream& os, pluralise const& pluraliser);
+
+ std::size_t m_count;
+ std::string m_label;
+};
+
+struct SourceLineInfo
+{
+
+ SourceLineInfo();
+ SourceLineInfo(char const* _file, std::size_t _line);
+ SourceLineInfo(SourceLineInfo const& other);
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+ SourceLineInfo(SourceLineInfo&&) = default;
+ SourceLineInfo& operator=(SourceLineInfo const&) = default;
+ SourceLineInfo& operator=(SourceLineInfo&&) = default;
+#endif
+ bool empty() const;
+ bool operator==(SourceLineInfo const& other) const;
+ bool operator<(SourceLineInfo const& other) const;
+
+ std::string file;
+ std::size_t line;
+};
+
+std::ostream& operator<<(std::ostream& os, SourceLineInfo const& info);
+
+// This is just here to avoid compiler warnings with macro constants and boolean literals
+inline bool isTrue(bool value) { return value; }
+inline bool alwaysTrue() { return true; }
+inline bool alwaysFalse() { return false; }
+
+void throwLogicError(std::string const& message, SourceLineInfo const& locationInfo);
+
+void seedRng(IConfig const& config);
+unsigned int rngSeed();
+
+// Use this in variadic streaming macros to allow
+// >> +StreamEndStop
+// as well as
+// >> stuff +StreamEndStop
+struct StreamEndStop
+{
+ std::string operator+()
+ {
+ return std::string();
+ }
+};
+template <typename T>
+T const& operator+(T const& value, StreamEndStop)
+{
+ return value;
+}
+}
+
+#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo(__FILE__, static_cast<std::size_t>(__LINE__))
+#define CATCH_INTERNAL_ERROR(msg) ::Catch::throwLogicError(msg, CATCH_INTERNAL_LINEINFO);
+
+#include <ostream>
+
+namespace Catch {
+
+class NotImplementedException : public std::exception
+{
+ public:
+ NotImplementedException(SourceLineInfo const& lineInfo);
+ NotImplementedException(NotImplementedException const&) {}
+
+ virtual ~NotImplementedException() CATCH_NOEXCEPT {}
+
+ virtual const char* what() const CATCH_NOEXCEPT;
+
+ private:
+ std::string m_what;
+ SourceLineInfo m_lineInfo;
+};
+
+} // end namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException(CATCH_INTERNAL_LINEINFO)
+
+// #included from: internal/catch_context.h
+#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED
+
+// #included from: catch_interfaces_generators.h
+#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+struct IGeneratorInfo
+{
+ virtual ~IGeneratorInfo();
+ virtual bool moveNext() = 0;
+ virtual std::size_t getCurrentIndex() const = 0;
+};
+
+struct IGeneratorsForTest
+{
+ virtual ~IGeneratorsForTest();
+
+ virtual IGeneratorInfo& getGeneratorInfo(std::string const& fileInfo, std::size_t size) = 0;
+ virtual bool moveNext() = 0;
+};
+
+IGeneratorsForTest* createGeneratorsForTest();
+
+} // end namespace Catch
+
+// #included from: catch_ptr.hpp
+#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+// An intrusive reference counting smart pointer.
+// T must implement addRef() and release() methods
+// typically implementing the IShared interface
+template <typename T>
+class Ptr
+{
+ public:
+ Ptr() : m_p(CATCH_NULL) {}
+ Ptr(T* p) : m_p(p)
+ {
+ if (m_p)
+ m_p->addRef();
+ }
+ Ptr(Ptr const& other) : m_p(other.m_p)
+ {
+ if (m_p)
+ m_p->addRef();
+ }
+ ~Ptr()
+ {
+ if (m_p)
+ m_p->release();
+ }
+ void reset()
+ {
+ if (m_p)
+ m_p->release();
+ m_p = CATCH_NULL;
+ }
+ Ptr& operator=(T* p)
+ {
+ Ptr temp(p);
+ swap(temp);
+ return *this;
+ }
+ Ptr& operator=(Ptr const& other)
+ {
+ Ptr temp(other);
+ swap(temp);
+ return *this;
+ }
+ void swap(Ptr& other) { std::swap(m_p, other.m_p); }
+ T* get() const { return m_p; }
+ T& operator*() const { return *m_p; }
+ T* operator->() const { return m_p; }
+ bool operator!() const { return m_p == CATCH_NULL; }
+ operator SafeBool::type() const { return SafeBool::makeSafe(m_p != CATCH_NULL); }
+
+ private:
+ T* m_p;
+};
+
+struct IShared : NonCopyable
+{
+ virtual ~IShared();
+ virtual void addRef() const = 0;
+ virtual void release() const = 0;
+};
+
+template <typename T = IShared>
+struct SharedImpl : T
+{
+
+ SharedImpl() : m_rc(0) {}
+
+ virtual void addRef() const
+ {
+ ++m_rc;
+ }
+ virtual void release() const
+ {
+ if (--m_rc == 0)
+ delete this;
+ }
+
+ mutable unsigned int m_rc;
+};
+
+} // end namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#include <memory>
+#include <stdlib.h>
+#include <vector>
+
+namespace Catch {
+
+class TestCase;
+class Stream;
+struct IResultCapture;
+struct IRunner;
+struct IGeneratorsForTest;
+struct IConfig;
+
+struct IContext
+{
+ virtual ~IContext();
+
+ virtual IResultCapture* getResultCapture() = 0;
+ virtual IRunner* getRunner() = 0;
+ virtual size_t getGeneratorIndex(std::string const& fileInfo, size_t totalSize) = 0;
+ virtual bool advanceGeneratorsForCurrentTest() = 0;
+ virtual Ptr<IConfig const> getConfig() const = 0;
+};
+
+struct IMutableContext : IContext
+{
+ virtual ~IMutableContext();
+ virtual void setResultCapture(IResultCapture* resultCapture) = 0;
+ virtual void setRunner(IRunner* runner) = 0;
+ virtual void setConfig(Ptr<IConfig const> const& config) = 0;
+};
+
+IContext& getCurrentContext();
+IMutableContext& getCurrentMutableContext();
+void cleanUpContext();
+Stream createStream(std::string const& streamName);
+}
+
+// #included from: internal/catch_test_registry.hpp
+#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED
+
+// #included from: catch_interfaces_testcase.h
+#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+
+class TestSpec;
+
+struct ITestCase : IShared
+{
+ virtual void invoke() const = 0;
+
+ protected:
+ virtual ~ITestCase();
+};
+
+class TestCase;
+struct IConfig;
+
+struct ITestCaseRegistry
+{
+ virtual ~ITestCaseRegistry();
+ virtual std::vector<TestCase> const& getAllTests() const = 0;
+ virtual std::vector<TestCase> const& getAllTestsSorted(IConfig const& config) const = 0;
+};
+
+bool matchTest(TestCase const& testCase, TestSpec const& testSpec, IConfig const& config);
+std::vector<TestCase> filterTests(std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config);
+std::vector<TestCase> const& getAllTestCasesSorted(IConfig const& config);
+}
+
+namespace Catch {
+
+template <typename C>
+class MethodTestCase : public SharedImpl<ITestCase>
+{
+
+ public:
+ MethodTestCase(void (C::*method)()) : m_method(method) {}
+
+ virtual void invoke() const
+ {
+ C obj;
+ (obj.*m_method)();
+ }
+
+ private:
+ virtual ~MethodTestCase() {}
+
+ void (C::*m_method)();
+};
+
+typedef void (*TestFunction)();
+
+struct NameAndDesc
+{
+ NameAndDesc(const char* _name = "", const char* _description = "")
+ : name(_name), description(_description)
+ {
+ }
+
+ const char* name;
+ const char* description;
+};
+
+void registerTestCase(ITestCase* testCase,
+ char const* className,
+ NameAndDesc const& nameAndDesc,
+ SourceLineInfo const& lineInfo);
+
+struct AutoReg
+{
+
+ AutoReg(TestFunction function,
+ SourceLineInfo const& lineInfo,
+ NameAndDesc const& nameAndDesc);
+
+ template <typename C>
+ AutoReg(void (C::*method)(),
+ char const* className,
+ NameAndDesc const& nameAndDesc,
+ SourceLineInfo const& lineInfo)
+ {
+
+ registerTestCase(new MethodTestCase<C>(method),
+ className,
+ nameAndDesc,
+ lineInfo);
+ }
+
+ ~AutoReg();
+
+ private:
+ AutoReg(AutoReg const&);
+ void operator=(AutoReg const&);
+};
+
+void registerTestCaseFunction(TestFunction function,
+ SourceLineInfo const& lineInfo,
+ NameAndDesc const& nameAndDesc);
+
+} // end namespace Catch
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TESTCASE(...) \
+ static void INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____)(); \
+ namespace { \
+ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME(autoRegistrar)(&INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc(__VA_ARGS__)); \
+ } \
+ static void INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____)()
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_METHOD_AS_TEST_CASE(QualifiedMethod, ...) \
+ namespace { \
+ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME(autoRegistrar)(&QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc(__VA_ARGS__), CATCH_INTERNAL_LINEINFO); \
+ }
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST_CASE_METHOD(ClassName, ...) \
+ namespace { \
+ struct INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____) : ClassName \
+ { \
+ void test(); \
+ }; \
+ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME(autoRegistrar)(&INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____)::test, #ClassName, Catch::NameAndDesc(__VA_ARGS__), CATCH_INTERNAL_LINEINFO); \
+ } \
+ void INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____)::test()
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_REGISTER_TESTCASE(Function, ...) \
+ Catch::AutoReg(Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc(__VA_ARGS__));
+
+#else
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TESTCASE(Name, Desc) \
+ static void INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____)(); \
+ namespace { \
+ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME(autoRegistrar)(&INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____), CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc(Name, Desc)); \
+ } \
+ static void INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____)()
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_METHOD_AS_TEST_CASE(QualifiedMethod, Name, Desc) \
+ namespace { \
+ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME(autoRegistrar)(&QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc(Name, Desc), CATCH_INTERNAL_LINEINFO); \
+ }
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST_CASE_METHOD(ClassName, TestName, Desc) \
+ namespace { \
+ struct INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____) : ClassName \
+ { \
+ void test(); \
+ }; \
+ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME(autoRegistrar)(&INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____)::test, #ClassName, Catch::NameAndDesc(TestName, Desc), CATCH_INTERNAL_LINEINFO); \
+ } \
+ void INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____T_E_S_T____)::test()
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_REGISTER_TESTCASE(Function, Name, Desc) \
+ Catch::AutoReg(Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc(Name, Desc));
+#endif
+
+// #included from: internal/catch_capture.hpp
+#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
+
+// #included from: catch_result_builder.h
+#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED
+
+// #included from: catch_result_type.h
+#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED
+
+namespace Catch {
+
+// ResultWas::OfType enum
+struct ResultWas
+{
+ enum OfType
+ {
+ Unknown = -1,
+ Ok = 0,
+ Info = 1,
+ Warning = 2,
+
+ FailureBit = 0x10,
+
+ ExpressionFailed = FailureBit | 1,
+ ExplicitFailure = FailureBit | 2,
+
+ Exception = 0x100 | FailureBit,
+
+ ThrewException = Exception | 1,
+ DidntThrowException = Exception | 2,
+
+ FatalErrorCondition = 0x200 | FailureBit
+
+ };
+};
+
+inline bool isOk(ResultWas::OfType resultType)
+{
+ return (resultType & ResultWas::FailureBit) == 0;
+}
+inline bool isJustInfo(int flags)
+{
+ return flags == ResultWas::Info;
+}
+
+// ResultDisposition::Flags enum
+struct ResultDisposition
+{
+ enum Flags
+ {
+ Normal = 0x01,
+
+ ContinueOnFailure = 0x02, // Failures fail test, but execution continues
+ FalseTest = 0x04, // Prefix expression with !
+ SuppressFail = 0x08 // Failures are reported but do not fail the test
+ };
+};
+
+inline ResultDisposition::Flags operator|(ResultDisposition::Flags lhs, ResultDisposition::Flags rhs)
+{
+ return static_cast<ResultDisposition::Flags>(static_cast<int>(lhs) | static_cast<int>(rhs));
+}
+
+inline bool shouldContinueOnFailure(int flags) { return (flags & ResultDisposition::ContinueOnFailure) != 0; }
+inline bool isFalseTest(int flags) { return (flags & ResultDisposition::FalseTest) != 0; }
+inline bool shouldSuppressFailure(int flags) { return (flags & ResultDisposition::SuppressFail) != 0; }
+
+} // end namespace Catch
+
+// #included from: catch_assertionresult.h
+#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+struct AssertionInfo
+{
+ AssertionInfo() {}
+ AssertionInfo(std::string const& _macroName,
+ SourceLineInfo const& _lineInfo,
+ std::string const& _capturedExpression,
+ ResultDisposition::Flags _resultDisposition);
+
+ std::string macroName;
+ SourceLineInfo lineInfo;
+ std::string capturedExpression;
+ ResultDisposition::Flags resultDisposition;
+};
+
+struct AssertionResultData
+{
+ AssertionResultData() : resultType(ResultWas::Unknown) {}
+
+ std::string reconstructedExpression;
+ std::string message;
+ ResultWas::OfType resultType;
+};
+
+class AssertionResult
+{
+ public:
+ AssertionResult();
+ AssertionResult(AssertionInfo const& info, AssertionResultData const& data);
+ ~AssertionResult();
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+ AssertionResult(AssertionResult const&) = default;
+ AssertionResult(AssertionResult&&) = default;
+ AssertionResult& operator=(AssertionResult const&) = default;
+ AssertionResult& operator=(AssertionResult&&) = default;
+#endif
+
+ bool isOk() const;
+ bool succeeded() const;
+ ResultWas::OfType getResultType() const;
+ bool hasExpression() const;
+ bool hasMessage() const;
+ std::string getExpression() const;
+ std::string getExpressionInMacro() const;
+ bool hasExpandedExpression() const;
+ std::string getExpandedExpression() const;
+ std::string getMessage() const;
+ SourceLineInfo getSourceInfo() const;
+ std::string getTestMacroName() const;
+
+ protected:
+ AssertionInfo m_info;
+ AssertionResultData m_resultData;
+};
+
+} // end namespace Catch
+
+// #included from: catch_matchers.hpp
+#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED
+
+namespace Catch {
+namespace Matchers {
+namespace Impl {
+
+namespace Generic {
+template <typename ExpressionT>
+class AllOf;
+template <typename ExpressionT>
+class AnyOf;
+template <typename ExpressionT>
+class Not;
+}
+
+template <typename ExpressionT>
+struct Matcher : SharedImpl<IShared>
+{
+ typedef ExpressionT ExpressionType;
+
+ virtual ~Matcher() {}
+ virtual Ptr<Matcher> clone() const = 0;
+ virtual bool match(ExpressionT const& expr) const = 0;
+ virtual std::string toString() const = 0;
+
+ Generic::AllOf<ExpressionT> operator&&(Matcher<ExpressionT> const& other) const;
+ Generic::AnyOf<ExpressionT> operator||(Matcher<ExpressionT> const& other) const;
+ Generic::Not<ExpressionT> operator!() const;
+};
+
+template <typename DerivedT, typename ExpressionT>
+struct MatcherImpl : Matcher<ExpressionT>
+{
+
+ virtual Ptr<Matcher<ExpressionT>> clone() const
+ {
+ return Ptr<Matcher<ExpressionT>>(new DerivedT(static_cast<DerivedT const&>(*this)));
+ }
+};
+
+namespace Generic {
+template <typename ExpressionT>
+class Not : public MatcherImpl<Not<ExpressionT>, ExpressionT>
+{
+ public:
+ explicit Not(Matcher<ExpressionT> const& matcher) : m_matcher(matcher.clone()) {}
+ Not(Not const& other) : m_matcher(other.m_matcher) {}
+
+ virtual bool match(ExpressionT const& expr) const CATCH_OVERRIDE
+ {
+ return !m_matcher->match(expr);
+ }
+
+ virtual std::string toString() const CATCH_OVERRIDE
+ {
+ return "not " + m_matcher->toString();
+ }
+
+ private:
+ Ptr<Matcher<ExpressionT>> m_matcher;
+};
+
+template <typename ExpressionT>
+class AllOf : public MatcherImpl<AllOf<ExpressionT>, ExpressionT>
+{
+ public:
+ AllOf() {}
+ AllOf(AllOf const& other) : m_matchers(other.m_matchers) {}
+
+ AllOf& add(Matcher<ExpressionT> const& matcher)
+ {
+ m_matchers.push_back(matcher.clone());
+ return *this;
+ }
+ virtual bool match(ExpressionT const& expr) const
+ {
+ for (std::size_t i = 0; i < m_matchers.size(); ++i)
+ if (!m_matchers[i]->match(expr))
+ return false;
+ return true;
+ }
+ virtual std::string toString() const
+ {
+ std::ostringstream oss;
+ oss << "( ";
+ for (std::size_t i = 0; i < m_matchers.size(); ++i)
+ {
+ if (i != 0)
+ oss << " and ";
+ oss << m_matchers[i]->toString();
+ }
+ oss << " )";
+ return oss.str();
+ }
+
+ AllOf operator&&(Matcher<ExpressionT> const& other) const
+ {
+ AllOf allOfExpr(*this);
+ allOfExpr.add(other);
+ return allOfExpr;
+ }
+
+ private:
+ std::vector<Ptr<Matcher<ExpressionT>>> m_matchers;
+};
+
+template <typename ExpressionT>
+class AnyOf : public MatcherImpl<AnyOf<ExpressionT>, ExpressionT>
+{
+ public:
+ AnyOf() {}
+ AnyOf(AnyOf const& other) : m_matchers(other.m_matchers) {}
+
+ AnyOf& add(Matcher<ExpressionT> const& matcher)
+ {
+ m_matchers.push_back(matcher.clone());
+ return *this;
+ }
+ virtual bool match(ExpressionT const& expr) const
+ {
+ for (std::size_t i = 0; i < m_matchers.size(); ++i)
+ if (m_matchers[i]->match(expr))
+ return true;
+ return false;
+ }
+ virtual std::string toString() const
+ {
+ std::ostringstream oss;
+ oss << "( ";
+ for (std::size_t i = 0; i < m_matchers.size(); ++i)
+ {
+ if (i != 0)
+ oss << " or ";
+ oss << m_matchers[i]->toString();
+ }
+ oss << " )";
+ return oss.str();
+ }
+
+ AnyOf operator||(Matcher<ExpressionT> const& other) const
+ {
+ AnyOf anyOfExpr(*this);
+ anyOfExpr.add(other);
+ return anyOfExpr;
+ }
+
+ private:
+ std::vector<Ptr<Matcher<ExpressionT>>> m_matchers;
+};
+
+} // namespace Generic
+
+template <typename ExpressionT>
+Generic::AllOf<ExpressionT> Matcher<ExpressionT>::operator&&(Matcher<ExpressionT> const& other) const
+{
+ Generic::AllOf<ExpressionT> allOfExpr;
+ allOfExpr.add(*this);
+ allOfExpr.add(other);
+ return allOfExpr;
+}
+
+template <typename ExpressionT>
+Generic::AnyOf<ExpressionT> Matcher<ExpressionT>::operator||(Matcher<ExpressionT> const& other) const
+{
+ Generic::AnyOf<ExpressionT> anyOfExpr;
+ anyOfExpr.add(*this);
+ anyOfExpr.add(other);
+ return anyOfExpr;
+}
+
+template <typename ExpressionT>
+Generic::Not<ExpressionT> Matcher<ExpressionT>::operator!() const
+{
+ return Generic::Not<ExpressionT>(*this);
+}
+
+namespace StdString {
+
+inline std::string makeString(std::string const& str) { return str; }
+inline std::string makeString(const char* str) { return str ? std::string(str) : std::string(); }
+
+struct CasedString
+{
+ CasedString(std::string const& str, CaseSensitive::Choice caseSensitivity)
+ : m_caseSensitivity(caseSensitivity),
+ m_str(adjustString(str))
+ {
+ }
+ std::string adjustString(std::string const& str) const
+ {
+ return m_caseSensitivity == CaseSensitive::No
+ ? toLower(str)
+ : str;
+ }
+ std::string toStringSuffix() const
+ {
+ return m_caseSensitivity == CaseSensitive::No
+ ? " (case insensitive)"
+ : "";
+ }
+ CaseSensitive::Choice m_caseSensitivity;
+ std::string m_str;
+};
+
+struct Equals : MatcherImpl<Equals, std::string>
+{
+ Equals(std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+ : m_data(str, caseSensitivity)
+ {
+ }
+ Equals(Equals const& other) : m_data(other.m_data) {}
+
+ virtual ~Equals();
+
+ virtual bool match(std::string const& expr) const
+ {
+ return m_data.m_str == m_data.adjustString(expr);
+ ;
+ }
+ virtual std::string toString() const
+ {
+ return "equals: \"" + m_data.m_str + "\"" + m_data.toStringSuffix();
+ }
+
+ CasedString m_data;
+};
+
+struct Contains : MatcherImpl<Contains, std::string>
+{
+ Contains(std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+ : m_data(substr, caseSensitivity) {}
+ Contains(Contains const& other) : m_data(other.m_data) {}
+
+ virtual ~Contains();
+
+ virtual bool match(std::string const& expr) const
+ {
+ return m_data.adjustString(expr).find(m_data.m_str) != std::string::npos;
+ }
+ virtual std::string toString() const
+ {
+ return "contains: \"" + m_data.m_str + "\"" + m_data.toStringSuffix();
+ }
+
+ CasedString m_data;
+};
+
+struct StartsWith : MatcherImpl<StartsWith, std::string>
+{
+ StartsWith(std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+ : m_data(substr, caseSensitivity) {}
+
+ StartsWith(StartsWith const& other) : m_data(other.m_data) {}
+
+ virtual ~StartsWith();
+
+ virtual bool match(std::string const& expr) const
+ {
+ return m_data.adjustString(expr).find(m_data.m_str) == 0;
+ }
+ virtual std::string toString() const
+ {
+ return "starts with: \"" + m_data.m_str + "\"" + m_data.toStringSuffix();
+ }
+
+ CasedString m_data;
+};
+
+struct EndsWith : MatcherImpl<EndsWith, std::string>
+{
+ EndsWith(std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+ : m_data(substr, caseSensitivity) {}
+ EndsWith(EndsWith const& other) : m_data(other.m_data) {}
+
+ virtual ~EndsWith();
+
+ virtual bool match(std::string const& expr) const
+ {
+ return m_data.adjustString(expr).find(m_data.m_str) == expr.size() - m_data.m_str.size();
+ }
+ virtual std::string toString() const
+ {
+ return "ends with: \"" + m_data.m_str + "\"" + m_data.toStringSuffix();
+ }
+
+ CasedString m_data;
+};
+} // namespace StdString
+} // namespace Impl
+
+// The following functions create the actual matcher objects.
+// This allows the types to be inferred
+template <typename ExpressionT>
+inline Impl::Generic::Not<ExpressionT> Not(Impl::Matcher<ExpressionT> const& m)
+{
+ return Impl::Generic::Not<ExpressionT>(m);
+}
+
+template <typename ExpressionT>
+inline Impl::Generic::AllOf<ExpressionT> AllOf(Impl::Matcher<ExpressionT> const& m1,
+ Impl::Matcher<ExpressionT> const& m2)
+{
+ return Impl::Generic::AllOf<ExpressionT>().add(m1).add(m2);
+}
+template <typename ExpressionT>
+inline Impl::Generic::AllOf<ExpressionT> AllOf(Impl::Matcher<ExpressionT> const& m1,
+ Impl::Matcher<ExpressionT> const& m2,
+ Impl::Matcher<ExpressionT> const& m3)
+{
+ return Impl::Generic::AllOf<ExpressionT>().add(m1).add(m2).add(m3);
+}
+template <typename ExpressionT>
+inline Impl::Generic::AnyOf<ExpressionT> AnyOf(Impl::Matcher<ExpressionT> const& m1,
+ Impl::Matcher<ExpressionT> const& m2)
+{
+ return Impl::Generic::AnyOf<ExpressionT>().add(m1).add(m2);
+}
+template <typename ExpressionT>
+inline Impl::Generic::AnyOf<ExpressionT> AnyOf(Impl::Matcher<ExpressionT> const& m1,
+ Impl::Matcher<ExpressionT> const& m2,
+ Impl::Matcher<ExpressionT> const& m3)
+{
+ return Impl::Generic::AnyOf<ExpressionT>().add(m1).add(m2).add(m3);
+}
+
+inline Impl::StdString::Equals Equals(std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+ return Impl::StdString::Equals(str, caseSensitivity);
+}
+inline Impl::StdString::Equals Equals(const char* str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+ return Impl::StdString::Equals(Impl::StdString::makeString(str), caseSensitivity);
+}
+inline Impl::StdString::Contains Contains(std::string const& substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+ return Impl::StdString::Contains(substr, caseSensitivity);
+}
+inline Impl::StdString::Contains Contains(const char* substr, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
+{
+ return Impl::StdString::Contains(Impl::StdString::makeString(substr), caseSensitivity);
+}
+inline Impl::StdString::StartsWith StartsWith(std::string const& substr)
+{
+ return Impl::StdString::StartsWith(substr);
+}
+inline Impl::StdString::StartsWith StartsWith(const char* substr)
+{
+ return Impl::StdString::StartsWith(Impl::StdString::makeString(substr));
+}
+inline Impl::StdString::EndsWith EndsWith(std::string const& substr)
+{
+ return Impl::StdString::EndsWith(substr);
+}
+inline Impl::StdString::EndsWith EndsWith(const char* substr)
+{
+ return Impl::StdString::EndsWith(Impl::StdString::makeString(substr));
+}
+
+} // namespace Matchers
+
+using namespace Matchers;
+
+} // namespace Catch
+
+namespace Catch {
+
+struct TestFailureException
+{
+};
+
+template <typename T>
+class ExpressionLhs;
+
+struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
+
+struct CopyableStream
+{
+ CopyableStream() {}
+ CopyableStream(CopyableStream const& other)
+ {
+ oss << other.oss.str();
+ }
+ CopyableStream& operator=(CopyableStream const& other)
+ {
+ oss.str("");
+ oss << other.oss.str();
+ return *this;
+ }
+ std::ostringstream oss;
+};
+
+class ResultBuilder
+{
+ public:
+ ResultBuilder(char const* macroName,
+ SourceLineInfo const& lineInfo,
+ char const* capturedExpression,
+ ResultDisposition::Flags resultDisposition,
+ char const* secondArg = "");
+
+ template <typename T>
+ ExpressionLhs<T const&> operator<=(T const& operand);
+ ExpressionLhs<bool> operator<=(bool value);
+
+ template <typename T>
+ ResultBuilder& operator<<(T const& value)
+ {
+ m_stream.oss << value;
+ return *this;
+ }
+
+ template <typename RhsT>
+ STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator&&(RhsT const&);
+ template <typename RhsT>
+ STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator||(RhsT const&);
+
+ ResultBuilder& setResultType(ResultWas::OfType result);
+ ResultBuilder& setResultType(bool result);
+ ResultBuilder& setLhs(std::string const& lhs);
+ ResultBuilder& setRhs(std::string const& rhs);
+ ResultBuilder& setOp(std::string const& op);
+
+ void endExpression();
+
+ std::string reconstructExpression() const;
+ AssertionResult build() const;
+
+ void useActiveException(ResultDisposition::Flags resultDisposition = ResultDisposition::Normal);
+ void captureResult(ResultWas::OfType resultType);
+ void captureExpression();
+ void captureExpectedException(std::string const& expectedMessage);
+ void captureExpectedException(Matchers::Impl::Matcher<std::string> const& matcher);
+ void handleResult(AssertionResult const& result);
+ void react();
+ bool shouldDebugBreak() const;
+ bool allowThrows() const;
+
+ private:
+ AssertionInfo m_assertionInfo;
+ AssertionResultData m_data;
+ struct ExprComponents
+ {
+ ExprComponents() : testFalse(false) {}
+ bool testFalse;
+ std::string lhs, rhs, op;
+ } m_exprComponents;
+ CopyableStream m_stream;
+
+ bool m_shouldDebugBreak;
+ bool m_shouldThrow;
+};
+
+} // namespace Catch
+
+// Include after due to circular dependency:
+// #included from: catch_expression_lhs.hpp
+#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED
+
+// #included from: catch_evaluate.hpp
+#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4389) // '==' : signed/unsigned mismatch
+#endif
+
+#include <cstddef>
+
+namespace Catch {
+namespace Internal {
+
+enum Operator
+{
+ IsEqualTo,
+ IsNotEqualTo,
+ IsLessThan,
+ IsGreaterThan,
+ IsLessThanOrEqualTo,
+ IsGreaterThanOrEqualTo
+};
+
+template <Operator Op>
+struct OperatorTraits
+{
+ static const char* getName() { return "*error*"; }
+};
+template <>
+struct OperatorTraits<IsEqualTo>
+{
+ static const char* getName() { return "=="; }
+};
+template <>
+struct OperatorTraits<IsNotEqualTo>
+{
+ static const char* getName() { return "!="; }
+};
+template <>
+struct OperatorTraits<IsLessThan>
+{
+ static const char* getName() { return "<"; }
+};
+template <>
+struct OperatorTraits<IsGreaterThan>
+{
+ static const char* getName() { return ">"; }
+};
+template <>
+struct OperatorTraits<IsLessThanOrEqualTo>
+{
+ static const char* getName() { return "<="; }
+};
+template <>
+struct OperatorTraits<IsGreaterThanOrEqualTo>
+{
+ static const char* getName() { return ">="; }
+};
+
+template <typename T>
+inline T& opCast(T const& t)
+{
+ return const_cast<T&>(t);
+}
+
+// nullptr_t support based on pull request #154 from Konstantin Baumann
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+inline std::nullptr_t opCast(std::nullptr_t)
+{
+ return nullptr;
+}
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+
+// So the compare overloads can be operator agnostic we convey the operator as a template
+// enum, which is used to specialise an Evaluator for doing the comparison.
+template <typename T1, typename T2, Operator Op>
+class Evaluator
+{
+};
+
+template <typename T1, typename T2>
+struct Evaluator<T1, T2, IsEqualTo>
+{
+ static bool evaluate(T1 const& lhs, T2 const& rhs)
+ {
+ return opCast(lhs) == opCast(rhs);
+ }
+};
+template <typename T1, typename T2>
+struct Evaluator<T1, T2, IsNotEqualTo>
+{
+ static bool evaluate(T1 const& lhs, T2 const& rhs)
+ {
+ return opCast(lhs) != opCast(rhs);
+ }
+};
+template <typename T1, typename T2>
+struct Evaluator<T1, T2, IsLessThan>
+{
+ static bool evaluate(T1 const& lhs, T2 const& rhs)
+ {
+ return opCast(lhs) < opCast(rhs);
+ }
+};
+template <typename T1, typename T2>
+struct Evaluator<T1, T2, IsGreaterThan>
+{
+ static bool evaluate(T1 const& lhs, T2 const& rhs)
+ {
+ return opCast(lhs) > opCast(rhs);
+ }
+};
+template <typename T1, typename T2>
+struct Evaluator<T1, T2, IsGreaterThanOrEqualTo>
+{
+ static bool evaluate(T1 const& lhs, T2 const& rhs)
+ {
+ return opCast(lhs) >= opCast(rhs);
+ }
+};
+template <typename T1, typename T2>
+struct Evaluator<T1, T2, IsLessThanOrEqualTo>
+{
+ static bool evaluate(T1 const& lhs, T2 const& rhs)
+ {
+ return opCast(lhs) <= opCast(rhs);
+ }
+};
+
+template <Operator Op, typename T1, typename T2>
+bool applyEvaluator(T1 const& lhs, T2 const& rhs)
+{
+ return Evaluator<T1, T2, Op>::evaluate(lhs, rhs);
+}
+
+// This level of indirection allows us to specialise for integer types
+// to avoid signed/ unsigned warnings
+
+// "base" overload
+template <Operator Op, typename T1, typename T2>
+bool compare(T1 const& lhs, T2 const& rhs)
+{
+ return Evaluator<T1, T2, Op>::evaluate(lhs, rhs);
+}
+
+// unsigned X to int
+template <Operator Op>
+bool compare(unsigned int lhs, int rhs)
+{
+ return applyEvaluator<Op>(lhs, static_cast<unsigned int>(rhs));
+}
+template <Operator Op>
+bool compare(unsigned long lhs, int rhs)
+{
+ return applyEvaluator<Op>(lhs, static_cast<unsigned int>(rhs));
+}
+template <Operator Op>
+bool compare(unsigned char lhs, int rhs)
+{
+ return applyEvaluator<Op>(lhs, static_cast<unsigned int>(rhs));
+}
+
+// unsigned X to long
+template <Operator Op>
+bool compare(unsigned int lhs, long rhs)
+{
+ return applyEvaluator<Op>(lhs, static_cast<unsigned long>(rhs));
+}
+template <Operator Op>
+bool compare(unsigned long lhs, long rhs)
+{
+ return applyEvaluator<Op>(lhs, static_cast<unsigned long>(rhs));
+}
+template <Operator Op>
+bool compare(unsigned char lhs, long rhs)
+{
+ return applyEvaluator<Op>(lhs, static_cast<unsigned long>(rhs));
+}
+
+// int to unsigned X
+template <Operator Op>
+bool compare(int lhs, unsigned int rhs)
+{
+ return applyEvaluator<Op>(static_cast<unsigned int>(lhs), rhs);
+}
+template <Operator Op>
+bool compare(int lhs, unsigned long rhs)
+{
+ return applyEvaluator<Op>(static_cast<unsigned int>(lhs), rhs);
+}
+template <Operator Op>
+bool compare(int lhs, unsigned char rhs)
+{
+ return applyEvaluator<Op>(static_cast<unsigned int>(lhs), rhs);
+}
+
+// long to unsigned X
+template <Operator Op>
+bool compare(long lhs, unsigned int rhs)
+{
+ return applyEvaluator<Op>(static_cast<unsigned long>(lhs), rhs);
+}
+template <Operator Op>
+bool compare(long lhs, unsigned long rhs)
+{
+ return applyEvaluator<Op>(static_cast<unsigned long>(lhs), rhs);
+}
+template <Operator Op>
+bool compare(long lhs, unsigned char rhs)
+{
+ return applyEvaluator<Op>(static_cast<unsigned long>(lhs), rhs);
+}
+
+// pointer to long (when comparing against NULL)
+template <Operator Op, typename T>
+bool compare(long lhs, T* rhs)
+{
+ return Evaluator<T*, T*, Op>::evaluate(reinterpret_cast<T*>(lhs), rhs);
+}
+template <Operator Op, typename T>
+bool compare(T* lhs, long rhs)
+{
+ return Evaluator<T*, T*, Op>::evaluate(lhs, reinterpret_cast<T*>(rhs));
+}
+
+// pointer to int (when comparing against NULL)
+template <Operator Op, typename T>
+bool compare(int lhs, T* rhs)
+{
+ return Evaluator<T*, T*, Op>::evaluate(reinterpret_cast<T*>(lhs), rhs);
+}
+template <Operator Op, typename T>
+bool compare(T* lhs, int rhs)
+{
+ return Evaluator<T*, T*, Op>::evaluate(lhs, reinterpret_cast<T*>(rhs));
+}
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+// long long to unsigned X
+template <Operator Op>
+bool compare(long long lhs, unsigned int rhs)
+{
+ return applyEvaluator<Op>(static_cast<unsigned long>(lhs), rhs);
+}
+template <Operator Op>
+bool compare(long long lhs, unsigned long rhs)
+{
+ return applyEvaluator<Op>(static_cast<unsigned long>(lhs), rhs);
+}
+template <Operator Op>
+bool compare(long long lhs, unsigned long long rhs)
+{
+ return applyEvaluator<Op>(static_cast<unsigned long>(lhs), rhs);
+}
+template <Operator Op>
+bool compare(long long lhs, unsigned char rhs)
+{
+ return applyEvaluator<Op>(static_cast<unsigned long>(lhs), rhs);
+}
+
+// unsigned long long to X
+template <Operator Op>
+bool compare(unsigned long long lhs, int rhs)
+{
+ return applyEvaluator<Op>(static_cast<long>(lhs), rhs);
+}
+template <Operator Op>
+bool compare(unsigned long long lhs, long rhs)
+{
+ return applyEvaluator<Op>(static_cast<long>(lhs), rhs);
+}
+template <Operator Op>
+bool compare(unsigned long long lhs, long long rhs)
+{
+ return applyEvaluator<Op>(static_cast<long>(lhs), rhs);
+}
+template <Operator Op>
+bool compare(unsigned long long lhs, char rhs)
+{
+ return applyEvaluator<Op>(static_cast<long>(lhs), rhs);
+}
+
+// pointer to long long (when comparing against NULL)
+template <Operator Op, typename T>
+bool compare(long long lhs, T* rhs)
+{
+ return Evaluator<T*, T*, Op>::evaluate(reinterpret_cast<T*>(lhs), rhs);
+}
+template <Operator Op, typename T>
+bool compare(T* lhs, long long rhs)
+{
+ return Evaluator<T*, T*, Op>::evaluate(lhs, reinterpret_cast<T*>(rhs));
+}
+#endif // CATCH_CONFIG_CPP11_LONG_LONG
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+// pointer to nullptr_t (when comparing against nullptr)
+template <Operator Op, typename T>
+bool compare(std::nullptr_t, T* rhs)
+{
+ return Evaluator<T*, T*, Op>::evaluate(nullptr, rhs);
+}
+template <Operator Op, typename T>
+bool compare(T* lhs, std::nullptr_t)
+{
+ return Evaluator<T*, T*, Op>::evaluate(lhs, nullptr);
+}
+#endif // CATCH_CONFIG_CPP11_NULLPTR
+
+} // end of namespace Internal
+} // end of namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// #included from: catch_tostring.h
+#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED
+
+#include <cstddef>
+#include <iomanip>
+#include <limits>
+#include <sstream>
+#include <vector>
+
+#ifdef __OBJC__
+// #included from: catch_objc_arc.hpp
+#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED
+
+#import <Foundation/Foundation.h>
+
+#ifdef __has_feature
+#define CATCH_ARC_ENABLED __has_feature(objc_arc)
+#else
+#define CATCH_ARC_ENABLED 0
+#endif
+
+void arcSafeRelease(NSObject* obj);
+id performOptionalSelector(id obj, SEL sel);
+
+#if !CATCH_ARC_ENABLED
+inline void arcSafeRelease(NSObject* obj)
+{
+ [obj release];
+}
+inline id performOptionalSelector(id obj, SEL sel)
+{
+ if ([obj respondsToSelector:sel])
+ return [obj performSelector:sel];
+ return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED
+#define CATCH_ARC_STRONG
+#else
+inline void arcSafeRelease(NSObject*)
+{
+}
+inline id performOptionalSelector(id obj, SEL sel)
+{
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+#endif
+ if ([obj respondsToSelector:sel])
+ return [obj performSelector:sel];
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+ return nil;
+}
+#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
+#define CATCH_ARC_STRONG __strong
+#endif
+
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_TUPLE
+#include <tuple>
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_IS_ENUM
+#include <type_traits>
+#endif
+
+namespace Catch {
+
+// Why we're here.
+template <typename T>
+std::string toString(T const& value);
+
+// Built in overloads
+
+std::string toString(std::string const& value);
+std::string toString(std::wstring const& value);
+std::string toString(const char* const value);
+std::string toString(char* const value);
+std::string toString(const wchar_t* const value);
+std::string toString(wchar_t* const value);
+std::string toString(int value);
+std::string toString(unsigned long value);
+std::string toString(unsigned int value);
+std::string toString(const double value);
+std::string toString(const float value);
+std::string toString(bool value);
+std::string toString(char value);
+std::string toString(signed char value);
+std::string toString(unsigned char value);
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+std::string toString(long long value);
+std::string toString(unsigned long long value);
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+std::string toString(std::nullptr_t);
+#endif
+
+#ifdef __OBJC__
+std::string toString(NSString const* const& nsstring);
+std::string toString(NSString* CATCH_ARC_STRONG const& nsstring);
+std::string toString(NSObject* const& nsObject);
+#endif
+
+namespace Detail {
+
+extern const std::string unprintableString;
+
+struct BorgType
+{
+ template <typename T>
+ BorgType(T const&);
+};
+
+struct TrueType
+{
+ char sizer[1];
+};
+struct FalseType
+{
+ char sizer[2];
+};
+
+TrueType& testStreamable(std::ostream&);
+FalseType testStreamable(FalseType);
+
+FalseType operator<<(std::ostream const&, BorgType const&);
+
+template <typename T>
+struct IsStreamInsertable
+{
+ static std::ostream& s;
+ static T const& t;
+ enum
+ {
+ value = sizeof(testStreamable(s << t)) == sizeof(TrueType)
+ };
+};
+
+#if defined(CATCH_CONFIG_CPP11_IS_ENUM)
+template <typename T,
+ bool IsEnum = std::is_enum<T>::value>
+struct EnumStringMaker
+{
+ static std::string convert(T const&) { return unprintableString; }
+};
+
+template <typename T>
+struct EnumStringMaker<T, true>
+{
+ static std::string convert(T const& v)
+ {
+ return ::Catch::toString(
+ static_cast<typename std::underlying_type<T>::type>(v));
+ }
+};
+#endif
+template <bool C>
+struct StringMakerBase
+{
+#if defined(CATCH_CONFIG_CPP11_IS_ENUM)
+ template <typename T>
+ static std::string convert(T const& v)
+ {
+ return EnumStringMaker<T>::convert(v);
+ }
+#else
+ template <typename T>
+ static std::string convert(T const&)
+ {
+ return unprintableString;
+ }
+#endif
+};
+
+template <>
+struct StringMakerBase<true>
+{
+ template <typename T>
+ static std::string convert(T const& _value)
+ {
+ std::ostringstream oss;
+ oss << _value;
+ return oss.str();
+ }
+};
+
+std::string rawMemoryToString(const void* object, std::size_t size);
+
+template <typename T>
+inline std::string rawMemoryToString(const T& object)
+{
+ return rawMemoryToString(&object, sizeof(object));
+}
+
+} // end namespace Detail
+
+template <typename T>
+struct StringMaker : Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value>
+{
+};
+
+template <typename T>
+struct StringMaker<T*>
+{
+ template <typename U>
+ static std::string convert(U* p)
+ {
+ if (!p)
+ return "NULL";
+ else
+ return Detail::rawMemoryToString(p);
+ }
+};
+
+template <typename R, typename C>
+struct StringMaker<R C::*>
+{
+ static std::string convert(R C::*p)
+ {
+ if (!p)
+ return "NULL";
+ else
+ return Detail::rawMemoryToString(p);
+ }
+};
+
+namespace Detail {
+template <typename InputIterator>
+std::string rangeToString(InputIterator first, InputIterator last);
+}
+
+//template<typename T, typename Allocator>
+//struct StringMaker<std::vector<T, Allocator> > {
+// static std::string convert( std::vector<T,Allocator> const& v ) {
+// return Detail::rangeToString( v.begin(), v.end() );
+// }
+//};
+
+template <typename T, typename Allocator>
+std::string toString(std::vector<T, Allocator> const& v)
+{
+ return Detail::rangeToString(v.begin(), v.end());
+}
+
+#ifdef CATCH_CONFIG_CPP11_TUPLE
+
+// toString for tuples
+namespace TupleDetail {
+template <
+ typename Tuple,
+ std::size_t N = 0,
+ bool = (N < std::tuple_size<Tuple>::value)>
+struct ElementPrinter
+{
+ static void print(const Tuple& tuple, std::ostream& os)
+ {
+ os << (N ? ", " : " ")
+ << Catch::toString(std::get<N>(tuple));
+ ElementPrinter<Tuple, N + 1>::print(tuple, os);
+ }
+};
+
+template <
+ typename Tuple,
+ std::size_t N>
+struct ElementPrinter<Tuple, N, false>
+{
+ static void print(const Tuple&, std::ostream&) {}
+};
+}
+
+template <typename... Types>
+struct StringMaker<std::tuple<Types...>>
+{
+
+ static std::string convert(const std::tuple<Types...>& tuple)
+ {
+ std::ostringstream os;
+ os << '{';
+ TupleDetail::ElementPrinter<std::tuple<Types...>>::print(tuple, os);
+ os << " }";
+ return os.str();
+ }
+};
+#endif // CATCH_CONFIG_CPP11_TUPLE
+
+namespace Detail {
+template <typename T>
+std::string makeString(T const& value)
+{
+ return StringMaker<T>::convert(value);
+}
+} // end namespace Detail
+
+/// \brief converts any type to a string
+///
+/// The default template forwards on to ostringstream - except when an
+/// ostringstream overload does not exist - in which case it attempts to detect
+/// that and writes {?}.
+/// Overload (not specialise) this template for custom typs that you don't want
+/// to provide an ostream overload for.
+template <typename T>
+std::string toString(T const& value)
+{
+ return StringMaker<T>::convert(value);
+}
+
+namespace Detail {
+template <typename InputIterator>
+std::string rangeToString(InputIterator first, InputIterator last)
+{
+ std::ostringstream oss;
+ oss << "{ ";
+ if (first != last)
+ {
+ oss << Catch::toString(*first);
+ for (++first; first != last; ++first)
+ oss << ", " << Catch::toString(*first);
+ }
+ oss << " }";
+ return oss.str();
+}
+}
+
+} // end namespace Catch
+
+namespace Catch {
+
+// Wraps the LHS of an expression and captures the operator and RHS (if any) -
+// wrapping them all in a ResultBuilder object
+template <typename T>
+class ExpressionLhs
+{
+ ExpressionLhs& operator=(ExpressionLhs const&);
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+ ExpressionLhs& operator=(ExpressionLhs&&) = delete;
+#endif
+
+ public:
+ ExpressionLhs(ResultBuilder& rb, T lhs) : m_rb(rb), m_lhs(lhs) {}
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+ ExpressionLhs(ExpressionLhs const&) = default;
+ ExpressionLhs(ExpressionLhs&&) = default;
+#endif
+
+ template <typename RhsT>
+ ResultBuilder& operator==(RhsT const& rhs)
+ {
+ return captureExpression<Internal::IsEqualTo>(rhs);
+ }
+
+ template <typename RhsT>
+ ResultBuilder& operator!=(RhsT const& rhs)
+ {
+ return captureExpression<Internal::IsNotEqualTo>(rhs);
+ }
+
+ template <typename RhsT>
+ ResultBuilder& operator<(RhsT const& rhs)
+ {
+ return captureExpression<Internal::IsLessThan>(rhs);
+ }
+
+ template <typename RhsT>
+ ResultBuilder& operator>(RhsT const& rhs)
+ {
+ return captureExpression<Internal::IsGreaterThan>(rhs);
+ }
+
+ template <typename RhsT>
+ ResultBuilder& operator<=(RhsT const& rhs)
+ {
+ return captureExpression<Internal::IsLessThanOrEqualTo>(rhs);
+ }
+
+ template <typename RhsT>
+ ResultBuilder& operator>=(RhsT const& rhs)
+ {
+ return captureExpression<Internal::IsGreaterThanOrEqualTo>(rhs);
+ }
+
+ ResultBuilder& operator==(bool rhs)
+ {
+ return captureExpression<Internal::IsEqualTo>(rhs);
+ }
+
+ ResultBuilder& operator!=(bool rhs)
+ {
+ return captureExpression<Internal::IsNotEqualTo>(rhs);
+ }
+
+ void endExpression()
+ {
+ bool value = m_lhs ? true : false;
+ m_rb
+ .setLhs(Catch::toString(value))
+ .setResultType(value)
+ .endExpression();
+ }
+
+ // Only simple binary expressions are allowed on the LHS.
+ // If more complex compositions are required then place the sub expression in parentheses
+ template <typename RhsT>
+ STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator+(RhsT const&);
+ template <typename RhsT>
+ STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator-(RhsT const&);
+ template <typename RhsT>
+ STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator/(RhsT const&);
+ template <typename RhsT>
+ STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator*(RhsT const&);
+ template <typename RhsT>
+ STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator&&(RhsT const&);
+ template <typename RhsT>
+ STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator||(RhsT const&);
+
+ private:
+ template <Internal::Operator Op, typename RhsT>
+ ResultBuilder& captureExpression(RhsT const& rhs)
+ {
+ return m_rb
+ .setResultType(Internal::compare<Op>(m_lhs, rhs))
+ .setLhs(Catch::toString(m_lhs))
+ .setRhs(Catch::toString(rhs))
+ .setOp(Internal::OperatorTraits<Op>::getName());
+ }
+
+ private:
+ ResultBuilder& m_rb;
+ T m_lhs;
+};
+
+} // end namespace Catch
+
+namespace Catch {
+
+template <typename T>
+inline ExpressionLhs<T const&> ResultBuilder::operator<=(T const& operand)
+{
+ return ExpressionLhs<T const&>(*this, operand);
+}
+
+inline ExpressionLhs<bool> ResultBuilder::operator<=(bool value)
+{
+ return ExpressionLhs<bool>(*this, value);
+}
+
+} // namespace Catch
+
+// #included from: catch_message.h
+#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+struct MessageInfo
+{
+ MessageInfo(std::string const& _macroName,
+ SourceLineInfo const& _lineInfo,
+ ResultWas::OfType _type);
+
+ std::string macroName;
+ SourceLineInfo lineInfo;
+ ResultWas::OfType type;
+ std::string message;
+ unsigned int sequence;
+
+ bool operator==(MessageInfo const& other) const
+ {
+ return sequence == other.sequence;
+ }
+ bool operator<(MessageInfo const& other) const
+ {
+ return sequence < other.sequence;
+ }
+
+ private:
+ static unsigned int globalCount;
+};
+
+struct MessageBuilder
+{
+ MessageBuilder(std::string const& macroName,
+ SourceLineInfo const& lineInfo,
+ ResultWas::OfType type)
+ : m_info(macroName, lineInfo, type)
+ {
+ }
+
+ template <typename T>
+ MessageBuilder& operator<<(T const& value)
+ {
+ m_stream << value;
+ return *this;
+ }
+
+ MessageInfo m_info;
+ std::ostringstream m_stream;
+};
+
+class ScopedMessage
+{
+ public:
+ ScopedMessage(MessageBuilder const& builder);
+ ScopedMessage(ScopedMessage const& other);
+ ~ScopedMessage();
+
+ MessageInfo m_info;
+};
+
+} // end namespace Catch
+
+// #included from: catch_interfaces_capture.h
+#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+class TestCase;
+class AssertionResult;
+struct AssertionInfo;
+struct SectionInfo;
+struct SectionEndInfo;
+struct MessageInfo;
+class ScopedMessageBuilder;
+struct Counts;
+
+struct IResultCapture
+{
+
+ virtual ~IResultCapture();
+
+ virtual void assertionEnded(AssertionResult const& result) = 0;
+ virtual bool sectionStarted(SectionInfo const& sectionInfo,
+ Counts& assertions) = 0;
+ virtual void sectionEnded(SectionEndInfo const& endInfo) = 0;
+ virtual void sectionEndedEarly(SectionEndInfo const& endInfo) = 0;
+ virtual void pushScopedMessage(MessageInfo const& message) = 0;
+ virtual void popScopedMessage(MessageInfo const& message) = 0;
+
+ virtual std::string getCurrentTestName() const = 0;
+ virtual const AssertionResult* getLastResult() const = 0;
+
+ virtual void handleFatalErrorCondition(std::string const& message) = 0;
+};
+
+IResultCapture& getResultCapture();
+}
+
+// #included from: catch_debugger.h
+#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED
+
+// #included from: catch_platform.h
+#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED
+
+#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
+#define CATCH_PLATFORM_MAC
+#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
+#define CATCH_PLATFORM_IPHONE
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
+#define CATCH_PLATFORM_WINDOWS
+#endif
+
+#include <string>
+
+namespace Catch {
+
+bool isDebuggerActive();
+void writeToDebugConsole(std::string const& text);
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+// The following code snippet based on:
+// http://cocoawithlove.com/2008/03/break-into-debugger.html
+#ifdef DEBUG
+#if defined(__ppc64__) || defined(__ppc__)
+#define CATCH_BREAK_INTO_DEBUGGER() \
+ if (Catch::isDebuggerActive()) \
+ { \
+ __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
+ : \
+ : \
+ : "memory", "r0", "r3", "r4"); \
+ }
+#else
+#define CATCH_BREAK_INTO_DEBUGGER() \
+ if (Catch::isDebuggerActive()) \
+ { \
+ __asm__("int $3\n" \
+ : \
+ :); \
+ }
+#endif
+#endif
+
+#elif defined(_MSC_VER)
+#define CATCH_BREAK_INTO_DEBUGGER() \
+ if (Catch::isDebuggerActive()) \
+ { \
+ __debugbreak(); \
+ }
+#elif defined(__MINGW32__)
+extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+#define CATCH_BREAK_INTO_DEBUGGER() \
+ if (Catch::isDebuggerActive()) \
+ { \
+ DebugBreak(); \
+ }
+#endif
+
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+#define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue();
+#endif
+
+// #included from: catch_interfaces_runner.h
+#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED
+
+namespace Catch {
+class TestCase;
+
+struct IRunner
+{
+ virtual ~IRunner();
+ virtual bool aborting() const = 0;
+};
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// In the event of a failure works out if the debugger needs to be invoked
+// and/or an exception thrown and takes appropriate action.
+// This needs to be done as a macro so the debugger will stop in the user
+// source code rather than in Catch library code
+#define INTERNAL_CATCH_REACT(resultBuilder) \
+ if (resultBuilder.shouldDebugBreak()) CATCH_BREAK_INTO_DEBUGGER(); \
+ resultBuilder.react();
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST(expr, resultDisposition, macroName) \
+ do \
+ { \
+ Catch::ResultBuilder __catchResult(macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition); \
+ try \
+ { \
+ (__catchResult <= expr).endExpression(); \
+ } \
+ catch (...) \
+ { \
+ __catchResult.useActiveException(Catch::ResultDisposition::Normal); \
+ } \
+ INTERNAL_CATCH_REACT(__catchResult) \
+ } while (Catch::isTrue(false && (expr))) // expr here is never evaluated at runtime but it forces the compiler to give it a look
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF(expr, resultDisposition, macroName) \
+ INTERNAL_CATCH_TEST(expr, resultDisposition, macroName); \
+ if (Catch::getResultCapture().getLastResult()->succeeded())
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_ELSE(expr, resultDisposition, macroName) \
+ INTERNAL_CATCH_TEST(expr, resultDisposition, macroName); \
+ if (!Catch::getResultCapture().getLastResult()->succeeded())
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_NO_THROW(expr, resultDisposition, macroName) \
+ do \
+ { \
+ Catch::ResultBuilder __catchResult(macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition); \
+ try \
+ { \
+ expr; \
+ __catchResult.captureResult(Catch::ResultWas::Ok); \
+ } \
+ catch (...) \
+ { \
+ __catchResult.useActiveException(resultDisposition); \
+ } \
+ INTERNAL_CATCH_REACT(__catchResult) \
+ } while (Catch::alwaysFalse())
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS(expr, resultDisposition, matcher, macroName) \
+ do \
+ { \
+ Catch::ResultBuilder __catchResult(macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition, #matcher); \
+ if (__catchResult.allowThrows()) \
+ try \
+ { \
+ expr; \
+ __catchResult.captureResult(Catch::ResultWas::DidntThrowException); \
+ } \
+ catch (...) \
+ { \
+ __catchResult.captureExpectedException(matcher); \
+ } \
+ else \
+ __catchResult.captureResult(Catch::ResultWas::Ok); \
+ INTERNAL_CATCH_REACT(__catchResult) \
+ } while (Catch::alwaysFalse())
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS(expr, exceptionType, resultDisposition, macroName) \
+ do \
+ { \
+ Catch::ResultBuilder __catchResult(macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition); \
+ if (__catchResult.allowThrows()) \
+ try \
+ { \
+ expr; \
+ __catchResult.captureResult(Catch::ResultWas::DidntThrowException); \
+ } \
+ catch (exceptionType) \
+ { \
+ __catchResult.captureResult(Catch::ResultWas::Ok); \
+ } \
+ catch (...) \
+ { \
+ __catchResult.useActiveException(resultDisposition); \
+ } \
+ else \
+ __catchResult.captureResult(Catch::ResultWas::Ok); \
+ INTERNAL_CATCH_REACT(__catchResult) \
+ } while (Catch::alwaysFalse())
+
+///////////////////////////////////////////////////////////////////////////////
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define INTERNAL_CATCH_MSG(messageType, resultDisposition, macroName, ...) \
+ do \
+ { \
+ Catch::ResultBuilder __catchResult(macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition); \
+ __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
+ __catchResult.captureResult(messageType); \
+ INTERNAL_CATCH_REACT(__catchResult) \
+ } while (Catch::alwaysFalse())
+#else
+#define INTERNAL_CATCH_MSG(messageType, resultDisposition, macroName, log) \
+ do \
+ { \
+ Catch::ResultBuilder __catchResult(macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition); \
+ __catchResult << log + ::Catch::StreamEndStop(); \
+ __catchResult.captureResult(messageType); \
+ INTERNAL_CATCH_REACT(__catchResult) \
+ } while (Catch::alwaysFalse())
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_INFO(log, macroName) \
+ Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME(scopedMessage) = Catch::MessageBuilder(macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info) << log;
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT(arg, matcher, resultDisposition, macroName) \
+ do \
+ { \
+ Catch::ResultBuilder __catchResult(macroName, CATCH_INTERNAL_LINEINFO, #arg ", " #matcher, resultDisposition); \
+ try \
+ { \
+ std::string matcherAsString = (matcher).toString(); \
+ __catchResult \
+ .setLhs(Catch::toString(arg)) \
+ .setRhs(matcherAsString == Catch::Detail::unprintableString ? #matcher : matcherAsString) \
+ .setOp("matches") \
+ .setResultType((matcher).match(arg)); \
+ __catchResult.captureExpression(); \
+ } \
+ catch (...) \
+ { \
+ __catchResult.useActiveException(resultDisposition | Catch::ResultDisposition::ContinueOnFailure); \
+ } \
+ INTERNAL_CATCH_REACT(__catchResult) \
+ } while (Catch::alwaysFalse())
+
+// #included from: internal/catch_section.h
+#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED
+
+// #included from: catch_section_info.h
+#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED
+
+// #included from: catch_totals.hpp
+#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED
+
+#include <cstddef>
+
+namespace Catch {
+
+struct Counts
+{
+ Counts() : passed(0), failed(0), failedButOk(0) {}
+
+ Counts operator-(Counts const& other) const
+ {
+ Counts diff;
+ diff.passed = passed - other.passed;
+ diff.failed = failed - other.failed;
+ diff.failedButOk = failedButOk - other.failedButOk;
+ return diff;
+ }
+ Counts& operator+=(Counts const& other)
+ {
+ passed += other.passed;
+ failed += other.failed;
+ failedButOk += other.failedButOk;
+ return *this;
+ }
+
+ std::size_t total() const
+ {
+ return passed + failed + failedButOk;
+ }
+ bool allPassed() const
+ {
+ return failed == 0 && failedButOk == 0;
+ }
+ bool allOk() const
+ {
+ return failed == 0;
+ }
+
+ std::size_t passed;
+ std::size_t failed;
+ std::size_t failedButOk;
+};
+
+struct Totals
+{
+
+ Totals operator-(Totals const& other) const
+ {
+ Totals diff;
+ diff.assertions = assertions - other.assertions;
+ diff.testCases = testCases - other.testCases;
+ return diff;
+ }
+
+ Totals delta(Totals const& prevTotals) const
+ {
+ Totals diff = *this - prevTotals;
+ if (diff.assertions.failed > 0)
+ ++diff.testCases.failed;
+ else if (diff.assertions.failedButOk > 0)
+ ++diff.testCases.failedButOk;
+ else
+ ++diff.testCases.passed;
+ return diff;
+ }
+
+ Totals& operator+=(Totals const& other)
+ {
+ assertions += other.assertions;
+ testCases += other.testCases;
+ return *this;
+ }
+
+ Counts assertions;
+ Counts testCases;
+};
+}
+
+namespace Catch {
+
+struct SectionInfo
+{
+ SectionInfo(SourceLineInfo const& _lineInfo,
+ std::string const& _name,
+ std::string const& _description = std::string());
+
+ std::string name;
+ std::string description;
+ SourceLineInfo lineInfo;
+};
+
+struct SectionEndInfo
+{
+ SectionEndInfo(SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds)
+ : sectionInfo(_sectionInfo), prevAssertions(_prevAssertions), durationInSeconds(_durationInSeconds)
+ {
+ }
+
+ SectionInfo sectionInfo;
+ Counts prevAssertions;
+ double durationInSeconds;
+};
+
+} // end namespace Catch
+
+// #included from: catch_timer.h
+#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED
+
+#ifdef CATCH_PLATFORM_WINDOWS
+typedef unsigned long long uint64_t;
+#else
+#include <stdint.h>
+#endif
+
+namespace Catch {
+
+class Timer
+{
+ public:
+ Timer() : m_ticks(0) {}
+ void start();
+ unsigned int getElapsedMicroseconds() const;
+ unsigned int getElapsedMilliseconds() const;
+ double getElapsedSeconds() const;
+
+ private:
+ uint64_t m_ticks;
+};
+
+} // namespace Catch
+
+#include <string>
+
+namespace Catch {
+
+class Section : NonCopyable
+{
+ public:
+ Section(SectionInfo const& info);
+ ~Section();
+
+ // This indicates whether the section should be executed or not
+ operator bool() const;
+
+ private:
+ SectionInfo m_info;
+
+ std::string m_name;
+ Counts m_assertions;
+ bool m_sectionIncluded;
+ Timer m_timer;
+};
+
+} // end namespace Catch
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define INTERNAL_CATCH_SECTION(...) \
+ if (Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(catch_internal_Section) = Catch::SectionInfo(CATCH_INTERNAL_LINEINFO, __VA_ARGS__))
+#else
+#define INTERNAL_CATCH_SECTION(name, desc) \
+ if (Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(catch_internal_Section) = Catch::SectionInfo(CATCH_INTERNAL_LINEINFO, name, desc))
+#endif
+
+// #included from: internal/catch_generators.hpp
+#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED
+
+#include <iterator>
+#include <stdlib.h>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+template <typename T>
+struct IGenerator
+{
+ virtual ~IGenerator() {}
+ virtual T getValue(std::size_t index) const = 0;
+ virtual std::size_t size() const = 0;
+};
+
+template <typename T>
+class BetweenGenerator : public IGenerator<T>
+{
+ public:
+ BetweenGenerator(T from, T to) : m_from(from), m_to(to) {}
+
+ virtual T getValue(std::size_t index) const
+ {
+ return m_from + static_cast<int>(index);
+ }
+
+ virtual std::size_t size() const
+ {
+ return static_cast<std::size_t>(1 + m_to - m_from);
+ }
+
+ private:
+ T m_from;
+ T m_to;
+};
+
+template <typename T>
+class ValuesGenerator : public IGenerator<T>
+{
+ public:
+ ValuesGenerator() {}
+
+ void add(T value)
+ {
+ m_values.push_back(value);
+ }
+
+ virtual T getValue(std::size_t index) const
+ {
+ return m_values[index];
+ }
+
+ virtual std::size_t size() const
+ {
+ return m_values.size();
+ }
+
+ private:
+ std::vector<T> m_values;
+};
+
+template <typename T>
+class CompositeGenerator
+{
+ public:
+ CompositeGenerator() : m_totalSize(0) {}
+
+ // *** Move semantics, similar to auto_ptr ***
+ CompositeGenerator(CompositeGenerator& other)
+ : m_fileInfo(other.m_fileInfo),
+ m_totalSize(0)
+ {
+ move(other);
+ }
+
+ CompositeGenerator& setFileInfo(const char* fileInfo)
+ {
+ m_fileInfo = fileInfo;
+ return *this;
+ }
+
+ ~CompositeGenerator()
+ {
+ deleteAll(m_composed);
+ }
+
+ operator T() const
+ {
+ size_t overallIndex = getCurrentContext().getGeneratorIndex(m_fileInfo, m_totalSize);
+
+ typename std::vector<const IGenerator<T>*>::const_iterator it = m_composed.begin();
+ typename std::vector<const IGenerator<T>*>::const_iterator itEnd = m_composed.end();
+ for (size_t index = 0; it != itEnd; ++it)
+ {
+ const IGenerator<T>* generator = *it;
+ if (overallIndex >= index && overallIndex < index + generator->size())
+ {
+ return generator->getValue(overallIndex - index);
+ }
+ index += generator->size();
+ }
+ CATCH_INTERNAL_ERROR("Indexed past end of generated range");
+ return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so
+ }
+
+ void add(const IGenerator<T>* generator)
+ {
+ m_totalSize += generator->size();
+ m_composed.push_back(generator);
+ }
+
+ CompositeGenerator& then(CompositeGenerator& other)
+ {
+ move(other);
+ return *this;
+ }
+
+ CompositeGenerator& then(T value)
+ {
+ ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+ valuesGen->add(value);
+ add(valuesGen);
+ return *this;
+ }
+
+ private:
+ void move(CompositeGenerator& other)
+ {
+ std::copy(other.m_composed.begin(), other.m_composed.end(), std::back_inserter(m_composed));
+ m_totalSize += other.m_totalSize;
+ other.m_composed.clear();
+ }
+
+ std::vector<const IGenerator<T>*> m_composed;
+ std::string m_fileInfo;
+ size_t m_totalSize;
+};
+
+namespace Generators {
+template <typename T>
+CompositeGenerator<T> between(T from, T to)
+{
+ CompositeGenerator<T> generators;
+ generators.add(new BetweenGenerator<T>(from, to));
+ return generators;
+}
+
+template <typename T>
+CompositeGenerator<T> values(T val1, T val2)
+{
+ CompositeGenerator<T> generators;
+ ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+ valuesGen->add(val1);
+ valuesGen->add(val2);
+ generators.add(valuesGen);
+ return generators;
+}
+
+template <typename T>
+CompositeGenerator<T> values(T val1, T val2, T val3)
+{
+ CompositeGenerator<T> generators;
+ ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+ valuesGen->add(val1);
+ valuesGen->add(val2);
+ valuesGen->add(val3);
+ generators.add(valuesGen);
+ return generators;
+}
+
+template <typename T>
+CompositeGenerator<T> values(T val1, T val2, T val3, T val4)
+{
+ CompositeGenerator<T> generators;
+ ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
+ valuesGen->add(val1);
+ valuesGen->add(val2);
+ valuesGen->add(val3);
+ valuesGen->add(val4);
+ generators.add(valuesGen);
+ return generators;
+}
+
+} // end namespace Generators
+
+using namespace Generators;
+
+} // end namespace Catch
+
+#define INTERNAL_CATCH_LINESTR2(line) #line
+#define INTERNAL_CATCH_LINESTR(line) INTERNAL_CATCH_LINESTR2(line)
+
+#define INTERNAL_CATCH_GENERATE(expr) expr.setFileInfo(__FILE__ "(" INTERNAL_CATCH_LINESTR(__LINE__) ")")
+
+// #included from: internal/catch_interfaces_exception.h
+#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED
+
+#include <string>
+#include <vector>
+
+// #included from: catch_interfaces_registry_hub.h
+#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+class TestCase;
+struct ITestCaseRegistry;
+struct IExceptionTranslatorRegistry;
+struct IExceptionTranslator;
+struct IReporterRegistry;
+struct IReporterFactory;
+
+struct IRegistryHub
+{
+ virtual ~IRegistryHub();
+
+ virtual IReporterRegistry const& getReporterRegistry() const = 0;
+ virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+ virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
+};
+
+struct IMutableRegistryHub
+{
+ virtual ~IMutableRegistryHub();
+ virtual void registerReporter(std::string const& name, Ptr<IReporterFactory> const& factory) = 0;
+ virtual void registerListener(Ptr<IReporterFactory> const& factory) = 0;
+ virtual void registerTest(TestCase const& testInfo) = 0;
+ virtual void registerTranslator(const IExceptionTranslator* translator) = 0;
+};
+
+IRegistryHub& getRegistryHub();
+IMutableRegistryHub& getMutableRegistryHub();
+void cleanUp();
+std::string translateActiveException();
+}
+
+namespace Catch {
+
+typedef std::string (*exceptionTranslateFunction)();
+
+struct IExceptionTranslator;
+typedef std::vector<const IExceptionTranslator*> ExceptionTranslators;
+
+struct IExceptionTranslator
+{
+ virtual ~IExceptionTranslator();
+ virtual std::string translate(ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd) const = 0;
+};
+
+struct IExceptionTranslatorRegistry
+{
+ virtual ~IExceptionTranslatorRegistry();
+
+ virtual std::string translateActiveException() const = 0;
+};
+
+class ExceptionTranslatorRegistrar
+{
+ template <typename T>
+ class ExceptionTranslator : public IExceptionTranslator
+ {
+ public:
+ ExceptionTranslator(std::string (*translateFunction)(T&))
+ : m_translateFunction(translateFunction)
+ {
+ }
+
+ virtual std::string translate(ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd) const CATCH_OVERRIDE
+ {
+ try
+ {
+ if (it == itEnd)
+ throw;
+ else
+ return (*it)->translate(it + 1, itEnd);
+ }
+ catch (T& ex)
+ {
+ return m_translateFunction(ex);
+ }
+ }
+
+ protected:
+ std::string (*m_translateFunction)(T&);
+ };
+
+ public:
+ template <typename T>
+ ExceptionTranslatorRegistrar(std::string (*translateFunction)(T&))
+ {
+ getMutableRegistryHub().registerTranslator(new ExceptionTranslator<T>(translateFunction));
+ }
+};
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION(signature) \
+ static std::string INTERNAL_CATCH_UNIQUE_NAME(catch_internal_ExceptionTranslator)(signature); \
+ namespace { \
+ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME(catch_internal_ExceptionRegistrar)(&INTERNAL_CATCH_UNIQUE_NAME(catch_internal_ExceptionTranslator)); \
+ } \
+ static std::string INTERNAL_CATCH_UNIQUE_NAME(catch_internal_ExceptionTranslator)(signature)
+
+// #included from: internal/catch_approx.hpp
+#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
+
+#include <cmath>
+#include <limits>
+
+namespace Catch {
+namespace Detail {
+
+class Approx
+{
+ public:
+ explicit Approx(double value)
+ : m_epsilon(std::numeric_limits<float>::epsilon() * 100),
+ m_scale(1.0),
+ m_value(value)
+ {
+ }
+
+ Approx(Approx const& other)
+ : m_epsilon(other.m_epsilon),
+ m_scale(other.m_scale),
+ m_value(other.m_value)
+ {
+ }
+
+ static Approx custom()
+ {
+ return Approx(0);
+ }
+
+ Approx operator()(double value)
+ {
+ Approx approx(value);
+ approx.epsilon(m_epsilon);
+ approx.scale(m_scale);
+ return approx;
+ }
+
+ friend bool operator==(double lhs, Approx const& rhs)
+ {
+ // Thanks to Richard Harris for his help refining this formula
+ return fabs(lhs - rhs.m_value) < rhs.m_epsilon * (rhs.m_scale + (std::max)(fabs(lhs), fabs(rhs.m_value)));
+ }
+
+ friend bool operator==(Approx const& lhs, double rhs)
+ {
+ return operator==(rhs, lhs);
+ }
+
+ friend bool operator!=(double lhs, Approx const& rhs)
+ {
+ return !operator==(lhs, rhs);
+ }
+
+ friend bool operator!=(Approx const& lhs, double rhs)
+ {
+ return !operator==(rhs, lhs);
+ }
+
+ Approx& epsilon(double newEpsilon)
+ {
+ m_epsilon = newEpsilon;
+ return *this;
+ }
+
+ Approx& scale(double newScale)
+ {
+ m_scale = newScale;
+ return *this;
+ }
+
+ std::string toString() const
+ {
+ std::ostringstream oss;
+ oss << "Approx( " << Catch::toString(m_value) << " )";
+ return oss.str();
+ }
+
+ private:
+ double m_epsilon;
+ double m_scale;
+ double m_value;
+};
+}
+
+template <>
+inline std::string toString<Detail::Approx>(Detail::Approx const& value)
+{
+ return value.toString();
+}
+
+} // end namespace Catch
+
+// #included from: internal/catch_interfaces_tag_alias_registry.h
+#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED
+
+// #included from: catch_tag_alias.h
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+struct TagAlias
+{
+ TagAlias(std::string _tag, SourceLineInfo _lineInfo) : tag(_tag), lineInfo(_lineInfo) {}
+
+ std::string tag;
+ SourceLineInfo lineInfo;
+};
+
+struct RegistrarForTagAliases
+{
+ RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo);
+};
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS(alias, spec) \
+ namespace { \
+ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME(AutoRegisterTagAlias)(alias, spec, CATCH_INTERNAL_LINEINFO); \
+ }
+// #included from: catch_option.hpp
+#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED
+
+namespace Catch {
+
+// An optional type
+template <typename T>
+class Option
+{
+ public:
+ Option() : nullableValue(CATCH_NULL) {}
+ Option(T const& _value)
+ : nullableValue(new (storage) T(_value))
+ {
+ }
+ Option(Option const& _other)
+ : nullableValue(_other ? new (storage) T(*_other) : CATCH_NULL)
+ {
+ }
+
+ ~Option()
+ {
+ reset();
+ }
+
+ Option& operator=(Option const& _other)
+ {
+ if (&_other != this)
+ {
+ reset();
+ if (_other)
+ nullableValue = new (storage) T(*_other);
+ }
+ return *this;
+ }
+ Option& operator=(T const& _value)
+ {
+ reset();
+ nullableValue = new (storage) T(_value);
+ return *this;
+ }
+
+ void reset()
+ {
+ if (nullableValue)
+ nullableValue->~T();
+ nullableValue = CATCH_NULL;
+ }
+
+ T& operator*() { return *nullableValue; }
+ T const& operator*() const { return *nullableValue; }
+ T* operator->() { return nullableValue; }
+ const T* operator->() const { return nullableValue; }
+
+ T valueOr(T const& defaultValue) const
+ {
+ return nullableValue ? *nullableValue : defaultValue;
+ }
+
+ bool some() const { return nullableValue != CATCH_NULL; }
+ bool none() const { return nullableValue == CATCH_NULL; }
+
+ bool operator!() const { return nullableValue == CATCH_NULL; }
+ operator SafeBool::type() const
+ {
+ return SafeBool::makeSafe(some());
+ }
+
+ private:
+ T* nullableValue;
+ char storage[sizeof(T)];
+};
+
+} // end namespace Catch
+
+namespace Catch {
+
+struct ITagAliasRegistry
+{
+ virtual ~ITagAliasRegistry();
+ virtual Option<TagAlias> find(std::string const& alias) const = 0;
+ virtual std::string expandAliases(std::string const& unexpandedTestSpec) const = 0;
+
+ static ITagAliasRegistry const& get();
+};
+
+} // end namespace Catch
+
+// These files are included here so the single_include script doesn't put them
+// in the conditionally compiled sections
+// #included from: internal/catch_test_case_info.h
+#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED
+
+#include <set>
+#include <string>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+struct ITestCase;
+
+struct TestCaseInfo
+{
+ enum SpecialProperties
+ {
+ None = 0,
+ IsHidden = 1 << 1,
+ ShouldFail = 1 << 2,
+ MayFail = 1 << 3,
+ Throws = 1 << 4
+ };
+
+ TestCaseInfo(std::string const& _name,
+ std::string const& _className,
+ std::string const& _description,
+ std::set<std::string> const& _tags,
+ SourceLineInfo const& _lineInfo);
+
+ TestCaseInfo(TestCaseInfo const& other);
+
+ friend void setTags(TestCaseInfo& testCaseInfo, std::set<std::string> const& tags);
+
+ bool isHidden() const;
+ bool throws() const;
+ bool okToFail() const;
+ bool expectedToFail() const;
+
+ std::string name;
+ std::string className;
+ std::string description;
+ std::set<std::string> tags;
+ std::set<std::string> lcaseTags;
+ std::string tagsAsString;
+ SourceLineInfo lineInfo;
+ SpecialProperties properties;
+};
+
+class TestCase : public TestCaseInfo
+{
+ public:
+ TestCase(ITestCase* testCase, TestCaseInfo const& info);
+ TestCase(TestCase const& other);
+
+ TestCase withName(std::string const& _newName) const;
+
+ void invoke() const;
+
+ TestCaseInfo const& getTestCaseInfo() const;
+
+ void swap(TestCase& other);
+ bool operator==(TestCase const& other) const;
+ bool operator<(TestCase const& other) const;
+ TestCase& operator=(TestCase const& other);
+
+ private:
+ Ptr<ITestCase> test;
+};
+
+TestCase makeTestCase(ITestCase* testCase,
+ std::string const& className,
+ std::string const& name,
+ std::string const& description,
+ SourceLineInfo const& lineInfo);
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#ifdef __OBJC__
+// #included from: internal/catch_objc.hpp
+#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED
+
+#import <objc/runtime.h>
+
+#include <string>
+
+// NB. Any general catch headers included here must be included
+// in catch.hpp first to make sure they are included by the single
+// header for non obj-usage
+
+///////////////////////////////////////////////////////////////////////////////
+// This protocol is really only here for (self) documenting purposes, since
+// all its methods are optional.
+ at protocol OcFixture
+
+ at optional
+
+- (void)setUp;
+- (void)tearDown;
+
+ at end
+
+namespace Catch {
+
+class OcMethod : public SharedImpl<ITestCase>
+{
+
+ public:
+ OcMethod(Class cls, SEL sel) : m_cls(cls), m_sel(sel) {}
+
+ virtual void invoke() const
+ {
+ id obj = [[m_cls alloc] init];
+
+ performOptionalSelector(obj, @selector(setUp));
+ performOptionalSelector(obj, m_sel);
+ performOptionalSelector(obj, @selector(tearDown));
+
+ arcSafeRelease(obj);
+ }
+
+ private:
+ virtual ~OcMethod() {}
+
+ Class m_cls;
+ SEL m_sel;
+};
+
+namespace Detail {
+
+inline std::string getAnnotation(Class cls,
+ std::string const& annotationName,
+ std::string const& testCaseName)
+{
+ NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+ SEL sel = NSSelectorFromString(selStr);
+ arcSafeRelease(selStr);
+ id value = performOptionalSelector(cls, sel);
+ if (value)
+ return [(NSString*)value UTF8String];
+ return "";
+}
+}
+
+inline size_t registerTestMethods()
+{
+ size_t noTestMethods = 0;
+ int noClasses = objc_getClassList(CATCH_NULL, 0);
+
+ Class* classes = (CATCH_UNSAFE_UNRETAINED Class*)malloc(sizeof(Class) * noClasses);
+ objc_getClassList(classes, noClasses);
+
+ for (int c = 0; c < noClasses; c++)
+ {
+ Class cls = classes[c];
+ {
+ u_int count;
+ Method* methods = class_copyMethodList(cls, &count);
+ for (u_int m = 0; m < count; m++)
+ {
+ SEL selector = method_getName(methods[m]);
+ std::string methodName = sel_getName(selector);
+ if (startsWith(methodName, "Catch_TestCase_"))
+ {
+ std::string testCaseName = methodName.substr(15);
+ std::string name = Detail::getAnnotation(cls, "Name", testCaseName);
+ std::string desc = Detail::getAnnotation(cls, "Description", testCaseName);
+ const char* className = class_getName(cls);
+
+ getMutableRegistryHub().registerTest(makeTestCase(new OcMethod(cls, selector), className, name.c_str(), desc.c_str(), SourceLineInfo()));
+ noTestMethods++;
+ }
+ }
+ free(methods);
+ }
+ }
+ return noTestMethods;
+}
+
+namespace Matchers {
+namespace Impl {
+namespace NSStringMatchers {
+
+template <typename MatcherT>
+struct StringHolder : MatcherImpl<MatcherT, NSString*>
+{
+ StringHolder(NSString* substr) : m_substr([substr copy]) {}
+ StringHolder(StringHolder const& other) : m_substr([other.m_substr copy]) {}
+ StringHolder()
+ {
+ arcSafeRelease(m_substr);
+ }
+
+ NSString* m_substr;
+};
+
+struct Equals : StringHolder<Equals>
+{
+ Equals(NSString* substr) : StringHolder(substr) {}
+
+ virtual bool match(ExpressionType const& str) const
+ {
+ return (str != nil || m_substr == nil) &&
+ [str isEqualToString:m_substr];
+ }
+
+ virtual std::string toString() const
+ {
+ return "equals string: " + Catch::toString(m_substr);
+ }
+};
+
+struct Contains : StringHolder<Contains>
+{
+ Contains(NSString* substr) : StringHolder(substr) {}
+
+ virtual bool match(ExpressionType const& str) const
+ {
+ return (str != nil || m_substr == nil) &&
+ [str rangeOfString:m_substr].location != NSNotFound;
+ }
+
+ virtual std::string toString() const
+ {
+ return "contains string: " + Catch::toString(m_substr);
+ }
+};
+
+struct StartsWith : StringHolder<StartsWith>
+{
+ StartsWith(NSString* substr) : StringHolder(substr) {}
+
+ virtual bool match(ExpressionType const& str) const
+ {
+ return (str != nil || m_substr == nil) &&
+ [str rangeOfString:m_substr].location == 0;
+ }
+
+ virtual std::string toString() const
+ {
+ return "starts with: " + Catch::toString(m_substr);
+ }
+};
+struct EndsWith : StringHolder<EndsWith>
+{
+ EndsWith(NSString* substr) : StringHolder(substr) {}
+
+ virtual bool match(ExpressionType const& str) const
+ {
+ return (str != nil || m_substr == nil) &&
+ [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+ }
+
+ virtual std::string toString() const
+ {
+ return "ends with: " + Catch::toString(m_substr);
+ }
+};
+
+} // namespace NSStringMatchers
+} // namespace Impl
+
+inline Impl::NSStringMatchers::Equals
+Equals(NSString* substr) { return Impl::NSStringMatchers::Equals(substr); }
+
+inline Impl::NSStringMatchers::Contains
+Contains(NSString* substr) { return Impl::NSStringMatchers::Contains(substr); }
+
+inline Impl::NSStringMatchers::StartsWith
+StartsWith(NSString* substr) { return Impl::NSStringMatchers::StartsWith(substr); }
+
+inline Impl::NSStringMatchers::EndsWith
+EndsWith(NSString* substr) { return Impl::NSStringMatchers::EndsWith(substr); }
+
+} // namespace Matchers
+
+using namespace Matchers;
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define OC_TEST_CASE(name, desc) \
+ +(NSString*)INTERNAL_CATCH_UNIQUE_NAME(Catch_Name_test) \
+ { \
+ return @name; \
+ } \
+ +(NSString*)INTERNAL_CATCH_UNIQUE_NAME(Catch_Description_test) \
+ { \
+ return @desc; \
+ } \
+ -(void)INTERNAL_CATCH_UNIQUE_NAME(Catch_TestCase_test)
+
+#endif
+
+#ifdef CATCH_IMPL
+// #included from: internal/catch_impl.hpp
+#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED
+
+// Collect all the implementation files together here
+// These are the equivalent of what would usually be cpp files
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+// #included from: ../catch_session.hpp
+#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
+
+// #included from: internal/catch_commandline.hpp
+#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
+
+// #included from: catch_config.hpp
+#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED
+
+// #included from: catch_test_spec_parser.hpp
+#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// #included from: catch_test_spec.hpp
+#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// #included from: catch_wildcard_pattern.hpp
+#define TWOBLUECUBES_CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+
+namespace Catch {
+class WildcardPattern
+{
+ enum WildcardPosition
+ {
+ NoWildcard = 0,
+ WildcardAtStart = 1,
+ WildcardAtEnd = 2,
+ WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+ };
+
+ public:
+ WildcardPattern(std::string const& pattern, CaseSensitive::Choice caseSensitivity)
+ : m_caseSensitivity(caseSensitivity),
+ m_wildcard(NoWildcard),
+ m_pattern(adjustCase(pattern))
+ {
+ if (startsWith(m_pattern, "*"))
+ {
+ m_pattern = m_pattern.substr(1);
+ m_wildcard = WildcardAtStart;
+ }
+ if (endsWith(m_pattern, "*"))
+ {
+ m_pattern = m_pattern.substr(0, m_pattern.size() - 1);
+ m_wildcard = static_cast<WildcardPosition>(m_wildcard | WildcardAtEnd);
+ }
+ }
+ virtual ~WildcardPattern();
+ virtual bool matches(std::string const& str) const
+ {
+ switch (m_wildcard)
+ {
+ case NoWildcard:
+ return m_pattern == adjustCase(str);
+ case WildcardAtStart:
+ return endsWith(adjustCase(str), m_pattern);
+ case WildcardAtEnd:
+ return startsWith(adjustCase(str), m_pattern);
+ case WildcardAtBothEnds:
+ return contains(adjustCase(str), m_pattern);
+ }
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+ throw std::logic_error("Unknown enum");
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+ }
+
+ private:
+ std::string adjustCase(std::string const& str) const
+ {
+ return m_caseSensitivity == CaseSensitive::No ? toLower(str) : str;
+ }
+ CaseSensitive::Choice m_caseSensitivity;
+ WildcardPosition m_wildcard;
+ std::string m_pattern;
+};
+}
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+class TestSpec
+{
+ struct Pattern : SharedImpl<>
+ {
+ virtual ~Pattern();
+ virtual bool matches(TestCaseInfo const& testCase) const = 0;
+ };
+ class NamePattern : public Pattern
+ {
+ public:
+ NamePattern(std::string const& name)
+ : m_wildcardPattern(toLower(name), CaseSensitive::No)
+ {
+ }
+ virtual ~NamePattern();
+ virtual bool matches(TestCaseInfo const& testCase) const
+ {
+ return m_wildcardPattern.matches(toLower(testCase.name));
+ }
+
+ private:
+ WildcardPattern m_wildcardPattern;
+ };
+
+ class TagPattern : public Pattern
+ {
+ public:
+ TagPattern(std::string const& tag) : m_tag(toLower(tag)) {}
+ virtual ~TagPattern();
+ virtual bool matches(TestCaseInfo const& testCase) const
+ {
+ return testCase.lcaseTags.find(m_tag) != testCase.lcaseTags.end();
+ }
+
+ private:
+ std::string m_tag;
+ };
+
+ class ExcludedPattern : public Pattern
+ {
+ public:
+ ExcludedPattern(Ptr<Pattern> const& underlyingPattern) : m_underlyingPattern(underlyingPattern) {}
+ virtual ~ExcludedPattern();
+ virtual bool matches(TestCaseInfo const& testCase) const { return !m_underlyingPattern->matches(testCase); }
+ private:
+ Ptr<Pattern> m_underlyingPattern;
+ };
+
+ struct Filter
+ {
+ std::vector<Ptr<Pattern>> m_patterns;
+
+ bool matches(TestCaseInfo const& testCase) const
+ {
+ // All patterns in a filter must match for the filter to be a match
+ for (std::vector<Ptr<Pattern>>::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it)
+ if (!(*it)->matches(testCase))
+ return false;
+ return true;
+ }
+ };
+
+ public:
+ bool hasFilters() const
+ {
+ return !m_filters.empty();
+ }
+ bool matches(TestCaseInfo const& testCase) const
+ {
+ // A TestSpec matches if any filter matches
+ for (std::vector<Filter>::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it)
+ if (it->matches(testCase))
+ return true;
+ return false;
+ }
+
+ private:
+ std::vector<Filter> m_filters;
+
+ friend class TestSpecParser;
+};
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+namespace Catch {
+
+class TestSpecParser
+{
+ enum Mode
+ {
+ None,
+ Name,
+ QuotedName,
+ Tag
+ };
+ Mode m_mode;
+ bool m_exclusion;
+ std::size_t m_start, m_pos;
+ std::string m_arg;
+ TestSpec::Filter m_currentFilter;
+ TestSpec m_testSpec;
+ ITagAliasRegistry const* m_tagAliases;
+
+ public:
+ TestSpecParser(ITagAliasRegistry const& tagAliases) : m_tagAliases(&tagAliases) {}
+
+ TestSpecParser& parse(std::string const& arg)
+ {
+ m_mode = None;
+ m_exclusion = false;
+ m_start = std::string::npos;
+ m_arg = m_tagAliases->expandAliases(arg);
+ for (m_pos = 0; m_pos < m_arg.size(); ++m_pos)
+ visitChar(m_arg[m_pos]);
+ if (m_mode == Name)
+ addPattern<TestSpec::NamePattern>();
+ return *this;
+ }
+ TestSpec testSpec()
+ {
+ addFilter();
+ return m_testSpec;
+ }
+
+ private:
+ void visitChar(char c)
+ {
+ if (m_mode == None)
+ {
+ switch (c)
+ {
+ case ' ':
+ return;
+ case '~':
+ m_exclusion = true;
+ return;
+ case '[':
+ return startNewMode(Tag, ++m_pos);
+ case '"':
+ return startNewMode(QuotedName, ++m_pos);
+ default:
+ startNewMode(Name, m_pos);
+ break;
+ }
+ }
+ if (m_mode == Name)
+ {
+ if (c == ',')
+ {
+ addPattern<TestSpec::NamePattern>();
+ addFilter();
+ }
+ else if (c == '[')
+ {
+ if (subString() == "exclude:")
+ m_exclusion = true;
+ else
+ addPattern<TestSpec::NamePattern>();
+ startNewMode(Tag, ++m_pos);
+ }
+ }
+ else if (m_mode == QuotedName && c == '"')
+ addPattern<TestSpec::NamePattern>();
+ else if (m_mode == Tag && c == ']')
+ addPattern<TestSpec::TagPattern>();
+ }
+ void startNewMode(Mode mode, std::size_t start)
+ {
+ m_mode = mode;
+ m_start = start;
+ }
+ std::string subString() const { return m_arg.substr(m_start, m_pos - m_start); }
+ template <typename T>
+ void addPattern()
+ {
+ std::string token = subString();
+ if (startsWith(token, "exclude:"))
+ {
+ m_exclusion = true;
+ token = token.substr(8);
+ }
+ if (!token.empty())
+ {
+ Ptr<TestSpec::Pattern> pattern = new T(token);
+ if (m_exclusion)
+ pattern = new TestSpec::ExcludedPattern(pattern);
+ m_currentFilter.m_patterns.push_back(pattern);
+ }
+ m_exclusion = false;
+ m_mode = None;
+ }
+ void addFilter()
+ {
+ if (!m_currentFilter.m_patterns.empty())
+ {
+ m_testSpec.m_filters.push_back(m_currentFilter);
+ m_currentFilter = TestSpec::Filter();
+ }
+ }
+};
+inline TestSpec parseTestSpec(std::string const& arg)
+{
+ return TestSpecParser(ITagAliasRegistry::get()).parse(arg).testSpec();
+}
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// #included from: catch_interfaces_config.h
+#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+struct Verbosity
+{
+ enum Level
+ {
+ NoOutput = 0,
+ Quiet,
+ Normal
+ };
+};
+
+struct WarnAbout
+{
+ enum What
+ {
+ Nothing = 0x00,
+ NoAssertions = 0x01
+ };
+};
+
+struct ShowDurations
+{
+ enum OrNot
+ {
+ DefaultForReporter,
+ Always,
+ Never
+ };
+};
+struct RunTests
+{
+ enum InWhatOrder
+ {
+ InDeclarationOrder,
+ InLexicographicalOrder,
+ InRandomOrder
+ };
+};
+
+class TestSpec;
+
+struct IConfig : IShared
+{
+
+ virtual ~IConfig();
+
+ virtual bool allowThrows() const = 0;
+ virtual std::ostream& stream() const = 0;
+ virtual std::string name() const = 0;
+ virtual bool includeSuccessfulResults() const = 0;
+ virtual bool shouldDebugBreak() const = 0;
+ virtual bool warnAboutMissingAssertions() const = 0;
+ virtual int abortAfter() const = 0;
+ virtual bool showInvisibles() const = 0;
+ virtual ShowDurations::OrNot showDurations() const = 0;
+ virtual TestSpec const& testSpec() const = 0;
+ virtual RunTests::InWhatOrder runOrder() const = 0;
+ virtual unsigned int rngSeed() const = 0;
+ virtual bool forceColour() const = 0;
+};
+}
+
+// #included from: catch_stream.h
+#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED
+
+// #included from: catch_streambuf.h
+#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED
+
+#include <streambuf>
+
+namespace Catch {
+
+class StreamBufBase : public std::streambuf
+{
+ public:
+ virtual ~StreamBufBase() CATCH_NOEXCEPT;
+};
+}
+
+#include <fstream>
+#include <ostream>
+#include <streambuf>
+
+namespace Catch {
+
+std::ostream& cout();
+std::ostream& cerr();
+
+struct IStream
+{
+ virtual ~IStream() CATCH_NOEXCEPT;
+ virtual std::ostream& stream() const = 0;
+};
+
+class FileStream : public IStream
+{
+ mutable std::ofstream m_ofs;
+
+ public:
+ FileStream(std::string const& filename);
+ virtual ~FileStream() CATCH_NOEXCEPT;
+
+ public: // IStream
+ virtual std::ostream& stream() const CATCH_OVERRIDE;
+};
+
+class CoutStream : public IStream
+{
+ mutable std::ostream m_os;
+
+ public:
+ CoutStream();
+ virtual ~CoutStream() CATCH_NOEXCEPT;
+
+ public: // IStream
+ virtual std::ostream& stream() const CATCH_OVERRIDE;
+};
+
+class DebugOutStream : public IStream
+{
+ std::auto_ptr<StreamBufBase> m_streamBuf;
+ mutable std::ostream m_os;
+
+ public:
+ DebugOutStream();
+ virtual ~DebugOutStream() CATCH_NOEXCEPT;
+
+ public: // IStream
+ virtual std::ostream& stream() const CATCH_OVERRIDE;
+};
+}
+
+#include <ctime>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+
+struct ConfigData
+{
+
+ ConfigData()
+ : listTests(false),
+ listTags(false),
+ listReporters(false),
+ listTestNamesOnly(false),
+ showSuccessfulTests(false),
+ shouldDebugBreak(false),
+ noThrow(false),
+ showHelp(false),
+ showInvisibles(false),
+ forceColour(false),
+ filenamesAsTags(false),
+ abortAfter(-1),
+ rngSeed(0),
+ verbosity(Verbosity::Normal),
+ warnings(WarnAbout::Nothing),
+ showDurations(ShowDurations::DefaultForReporter),
+ runOrder(RunTests::InDeclarationOrder)
+ {
+ }
+
+ bool listTests;
+ bool listTags;
+ bool listReporters;
+ bool listTestNamesOnly;
+
+ bool showSuccessfulTests;
+ bool shouldDebugBreak;
+ bool noThrow;
+ bool showHelp;
+ bool showInvisibles;
+ bool forceColour;
+ bool filenamesAsTags;
+
+ int abortAfter;
+ unsigned int rngSeed;
+
+ Verbosity::Level verbosity;
+ WarnAbout::What warnings;
+ ShowDurations::OrNot showDurations;
+ RunTests::InWhatOrder runOrder;
+
+ std::string outputFilename;
+ std::string name;
+ std::string processName;
+
+ std::vector<std::string> reporterNames;
+ std::vector<std::string> testsOrTags;
+};
+
+class Config : public SharedImpl<IConfig>
+{
+ private:
+ Config(Config const& other);
+ Config& operator=(Config const& other);
+ virtual void dummy();
+
+ public:
+ Config()
+ {
+ }
+
+ Config(ConfigData const& data)
+ : m_data(data),
+ m_stream(openStream())
+ {
+ if (!data.testsOrTags.empty())
+ {
+ TestSpecParser parser(ITagAliasRegistry::get());
+ for (std::size_t i = 0; i < data.testsOrTags.size(); ++i)
+ parser.parse(data.testsOrTags[i]);
+ m_testSpec = parser.testSpec();
+ }
+ }
+
+ virtual ~Config()
+ {
+ }
+
+ std::string const& getFilename() const
+ {
+ return m_data.outputFilename;
+ }
+
+ bool listTests() const { return m_data.listTests; }
+ bool listTestNamesOnly() const { return m_data.listTestNamesOnly; }
+ bool listTags() const { return m_data.listTags; }
+ bool listReporters() const { return m_data.listReporters; }
+
+ std::string getProcessName() const { return m_data.processName; }
+
+ bool shouldDebugBreak() const { return m_data.shouldDebugBreak; }
+
+ std::vector<std::string> getReporterNames() const { return m_data.reporterNames; }
+
+ int abortAfter() const { return m_data.abortAfter; }
+
+ TestSpec const& testSpec() const { return m_testSpec; }
+
+ bool showHelp() const { return m_data.showHelp; }
+ bool showInvisibles() const { return m_data.showInvisibles; }
+
+ // IConfig interface
+ virtual bool allowThrows() const { return !m_data.noThrow; }
+ virtual std::ostream& stream() const { return m_stream->stream(); }
+ virtual std::string name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
+ virtual bool includeSuccessfulResults() const { return m_data.showSuccessfulTests; }
+ virtual bool warnAboutMissingAssertions() const { return m_data.warnings & WarnAbout::NoAssertions; }
+ virtual ShowDurations::OrNot showDurations() const { return m_data.showDurations; }
+ virtual RunTests::InWhatOrder runOrder() const { return m_data.runOrder; }
+ virtual unsigned int rngSeed() const { return m_data.rngSeed; }
+ virtual bool forceColour() const { return m_data.forceColour; }
+
+ private:
+ IStream const* openStream()
+ {
+ if (m_data.outputFilename.empty())
+ return new CoutStream();
+ else if (m_data.outputFilename[0] == '%')
+ {
+ if (m_data.outputFilename == "%debug")
+ return new DebugOutStream();
+ else
+ throw std::domain_error("Unrecognised stream: " + m_data.outputFilename);
+ }
+ else
+ return new FileStream(m_data.outputFilename);
+ }
+ ConfigData m_data;
+
+ std::auto_ptr<IStream const> m_stream;
+ TestSpec m_testSpec;
+};
+
+} // end namespace Catch
+
+// #included from: catch_clara.h
+#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
+
+// Use Catch's value for console width (store Clara's off to the side, if present)
+#ifdef CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
+#undef CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
+
+// Declare Clara inside the Catch namespace
+#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch {
+// #included from: ../external/clara.h
+
+// Only use header guard if we are not using an outer namespace
+#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE)
+
+#ifndef STITCH_CLARA_OPEN_NAMESPACE
+#define TWOBLUECUBES_CLARA_H_INCLUDED
+#define STITCH_CLARA_OPEN_NAMESPACE
+#define STITCH_CLARA_CLOSE_NAMESPACE
+#else
+#define STITCH_CLARA_CLOSE_NAMESPACE }
+#endif
+
+#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE
+
+// ----------- #included from tbc_text_format.h -----------
+
+// Only use header guard if we are not using an outer namespace
+#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE)
+#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+#define TBC_TEXT_FORMAT_H_INCLUDED
+#endif
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+// Use optional outer namespace
+#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
+#endif
+
+namespace Tbc {
+
+#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
+const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
+#else
+const unsigned int consoleWidth = 80;
+#endif
+
+struct TextAttributes
+{
+ TextAttributes()
+ : initialIndent(std::string::npos),
+ indent(0),
+ width(consoleWidth - 1),
+ tabChar('\t')
+ {
+ }
+
+ TextAttributes& setInitialIndent(std::size_t _value)
+ {
+ initialIndent = _value;
+ return *this;
+ }
+ TextAttributes& setIndent(std::size_t _value)
+ {
+ indent = _value;
+ return *this;
+ }
+ TextAttributes& setWidth(std::size_t _value)
+ {
+ width = _value;
+ return *this;
+ }
+ TextAttributes& setTabChar(char _value)
+ {
+ tabChar = _value;
+ return *this;
+ }
+
+ std::size_t initialIndent; // indent of first line, or npos
+ std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos
+ std::size_t width; // maximum width of text, including indent. Longer text will wrap
+ char tabChar; // If this char is seen the indent is changed to current pos
+};
+
+class Text
+{
+ public:
+ Text(std::string const& _str, TextAttributes const& _attr = TextAttributes())
+ : attr(_attr)
+ {
+ std::string wrappableChars = " [({.,/|\\-";
+ std::size_t indent = _attr.initialIndent != std::string::npos
+ ? _attr.initialIndent
+ : _attr.indent;
+ std::string remainder = _str;
+
+ while (!remainder.empty())
+ {
+ if (lines.size() >= 1000)
+ {
+ lines.push_back("... message truncated due to excessive size");
+ return;
+ }
+ std::size_t tabPos = std::string::npos;
+ std::size_t width = (std::min)(remainder.size(), _attr.width - indent);
+ std::size_t pos = remainder.find_first_of('\n');
+ if (pos <= width)
+ {
+ width = pos;
+ }
+ pos = remainder.find_last_of(_attr.tabChar, width);
+ if (pos != std::string::npos)
+ {
+ tabPos = pos;
+ if (remainder[width] == '\n')
+ width--;
+ remainder = remainder.substr(0, tabPos) + remainder.substr(tabPos + 1);
+ }
+
+ if (width == remainder.size())
+ {
+ spliceLine(indent, remainder, width);
+ }
+ else if (remainder[width] == '\n')
+ {
+ spliceLine(indent, remainder, width);
+ if (width <= 1 || remainder.size() != 1)
+ remainder = remainder.substr(1);
+ indent = _attr.indent;
+ }
+ else
+ {
+ pos = remainder.find_last_of(wrappableChars, width);
+ if (pos != std::string::npos && pos > 0)
+ {
+ spliceLine(indent, remainder, pos);
+ if (remainder[0] == ' ')
+ remainder = remainder.substr(1);
+ }
+ else
+ {
+ spliceLine(indent, remainder, width - 1);
+ lines.back() += "-";
+ }
+ if (lines.size() == 1)
+ indent = _attr.indent;
+ if (tabPos != std::string::npos)
+ indent += tabPos;
+ }
+ }
+ }
+
+ void spliceLine(std::size_t _indent, std::string& _remainder, std::size_t _pos)
+ {
+ lines.push_back(std::string(_indent, ' ') + _remainder.substr(0, _pos));
+ _remainder = _remainder.substr(_pos);
+ }
+
+ typedef std::vector<std::string>::const_iterator const_iterator;
+
+ const_iterator begin() const { return lines.begin(); }
+ const_iterator end() const { return lines.end(); }
+ std::string const& last() const { return lines.back(); }
+ std::size_t size() const { return lines.size(); }
+ std::string const& operator[](std::size_t _index) const { return lines[_index]; }
+ std::string toString() const
+ {
+ std::ostringstream oss;
+ oss << *this;
+ return oss.str();
+ }
+
+ inline friend std::ostream& operator<<(std::ostream& _stream, Text const& _text)
+ {
+ for (Text::const_iterator it = _text.begin(), itEnd = _text.end();
+ it != itEnd; ++it)
+ {
+ if (it != _text.begin())
+ _stream << "\n";
+ _stream << *it;
+ }
+ return _stream;
+ }
+
+ private:
+ std::string str;
+ TextAttributes attr;
+ std::vector<std::string> lines;
+};
+
+} // end namespace Tbc
+
+#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+} // end outer namespace
+#endif
+
+#endif // TBC_TEXT_FORMAT_H_INCLUDED
+
+// ----------- end of #include from tbc_text_format.h -----------
+// ........... back in /Users/philnash/Dev/OSS/Clara/srcs/clara.h
+
+#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE
+
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <stdexcept>
+
+// Use optional outer namespace
+#ifdef STITCH_CLARA_OPEN_NAMESPACE
+STITCH_CLARA_OPEN_NAMESPACE
+#endif
+
+namespace Clara {
+
+struct UnpositionalTag
+{
+};
+
+extern UnpositionalTag _;
+
+#ifdef CLARA_CONFIG_MAIN
+UnpositionalTag _;
+#endif
+
+namespace Detail {
+
+#ifdef CLARA_CONSOLE_WIDTH
+const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
+#else
+const unsigned int consoleWidth = 80;
+#endif
+
+using namespace Tbc;
+
+inline bool startsWith(std::string const& str, std::string const& prefix)
+{
+ return str.size() >= prefix.size() && str.substr(0, prefix.size()) == prefix;
+}
+
+template <typename T>
+struct RemoveConstRef
+{
+ typedef T type;
+};
+template <typename T>
+struct RemoveConstRef<T&>
+{
+ typedef T type;
+};
+template <typename T>
+struct RemoveConstRef<T const&>
+{
+ typedef T type;
+};
+template <typename T>
+struct RemoveConstRef<T const>
+{
+ typedef T type;
+};
+
+template <typename T>
+struct IsBool
+{
+ static const bool value = false;
+};
+template <>
+struct IsBool<bool>
+{
+ static const bool value = true;
+};
+
+template <typename T>
+void convertInto(std::string const& _source, T& _dest)
+{
+ std::stringstream ss;
+ ss << _source;
+ ss >> _dest;
+ if (ss.fail())
+ throw std::runtime_error("Unable to convert " + _source + " to destination type");
+}
+inline void convertInto(std::string const& _source, std::string& _dest)
+{
+ _dest = _source;
+}
+inline void convertInto(std::string const& _source, bool& _dest)
+{
+ std::string sourceLC = _source;
+ std::transform(sourceLC.begin(), sourceLC.end(), sourceLC.begin(), ::tolower);
+ if (sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on")
+ _dest = true;
+ else if (sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off")
+ _dest = false;
+ else
+ throw std::runtime_error("Expected a boolean value but did not recognise:\n '" + _source + "'");
+}
+inline void convertInto(bool _source, bool& _dest)
+{
+ _dest = _source;
+}
+template <typename T>
+inline void convertInto(bool, T&)
+{
+ throw std::runtime_error("Invalid conversion");
+}
+
+template <typename ConfigT>
+struct IArgFunction
+{
+ virtual ~IArgFunction() {}
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+ IArgFunction() = default;
+ IArgFunction(IArgFunction const&) = default;
+#endif
+ virtual void set(ConfigT& config, std::string const& value) const = 0;
+ virtual void setFlag(ConfigT& config) const = 0;
+ virtual bool takesArg() const = 0;
+ virtual IArgFunction* clone() const = 0;
+};
+
+template <typename ConfigT>
+class BoundArgFunction
+{
+ public:
+ BoundArgFunction() : functionObj(CATCH_NULL) {}
+ BoundArgFunction(IArgFunction<ConfigT>* _functionObj) : functionObj(_functionObj) {}
+ BoundArgFunction(BoundArgFunction const& other) : functionObj(other.functionObj ? other.functionObj->clone() : CATCH_NULL) {}
+ BoundArgFunction& operator=(BoundArgFunction const& other)
+ {
+ IArgFunction<ConfigT>* newFunctionObj = other.functionObj ? other.functionObj->clone() : CATCH_NULL;
+ delete functionObj;
+ functionObj = newFunctionObj;
+ return *this;
+ }
+ ~BoundArgFunction() { delete functionObj; }
+
+ void set(ConfigT& config, std::string const& value) const
+ {
+ functionObj->set(config, value);
+ }
+ void setFlag(ConfigT& config) const
+ {
+ functionObj->setFlag(config);
+ }
+ bool takesArg() const { return functionObj->takesArg(); }
+
+ bool isSet() const
+ {
+ return functionObj != CATCH_NULL;
+ }
+
+ private:
+ IArgFunction<ConfigT>* functionObj;
+};
+
+template <typename C>
+struct NullBinder : IArgFunction<C>
+{
+ virtual void set(C&, std::string const&) const {}
+ virtual void setFlag(C&) const {}
+ virtual bool takesArg() const { return true; }
+ virtual IArgFunction<C>* clone() const { return new NullBinder(*this); }
+};
+
+template <typename C, typename M>
+struct BoundDataMember : IArgFunction<C>
+{
+ BoundDataMember(M C::*_member) : member(_member) {}
+ virtual void set(C& p, std::string const& stringValue) const
+ {
+ convertInto(stringValue, p.*member);
+ }
+ virtual void setFlag(C& p) const
+ {
+ convertInto(true, p.*member);
+ }
+ virtual bool takesArg() const { return !IsBool<M>::value; }
+ virtual IArgFunction<C>* clone() const { return new BoundDataMember(*this); }
+ M C::*member;
+};
+template <typename C, typename M>
+struct BoundUnaryMethod : IArgFunction<C>
+{
+ BoundUnaryMethod(void (C::*_member)(M)) : member(_member) {}
+ virtual void set(C& p, std::string const& stringValue) const
+ {
+ typename RemoveConstRef<M>::type value;
+ convertInto(stringValue, value);
+ (p.*member)(value);
+ }
+ virtual void setFlag(C& p) const
+ {
+ typename RemoveConstRef<M>::type value;
+ convertInto(true, value);
+ (p.*member)(value);
+ }
+ virtual bool takesArg() const { return !IsBool<M>::value; }
+ virtual IArgFunction<C>* clone() const { return new BoundUnaryMethod(*this); }
+ void (C::*member)(M);
+};
+template <typename C>
+struct BoundNullaryMethod : IArgFunction<C>
+{
+ BoundNullaryMethod(void (C::*_member)()) : member(_member) {}
+ virtual void set(C& p, std::string const& stringValue) const
+ {
+ bool value;
+ convertInto(stringValue, value);
+ if (value)
+ (p.*member)();
+ }
+ virtual void setFlag(C& p) const
+ {
+ (p.*member)();
+ }
+ virtual bool takesArg() const { return false; }
+ virtual IArgFunction<C>* clone() const { return new BoundNullaryMethod(*this); }
+ void (C::*member)();
+};
+
+template <typename C>
+struct BoundUnaryFunction : IArgFunction<C>
+{
+ BoundUnaryFunction(void (*_function)(C&)) : function(_function) {}
+ virtual void set(C& obj, std::string const& stringValue) const
+ {
+ bool value;
+ convertInto(stringValue, value);
+ if (value)
+ function(obj);
+ }
+ virtual void setFlag(C& p) const
+ {
+ function(p);
+ }
+ virtual bool takesArg() const { return false; }
+ virtual IArgFunction<C>* clone() const { return new BoundUnaryFunction(*this); }
+ void (*function)(C&);
+};
+
+template <typename C, typename T>
+struct BoundBinaryFunction : IArgFunction<C>
+{
+ BoundBinaryFunction(void (*_function)(C&, T)) : function(_function) {}
+ virtual void set(C& obj, std::string const& stringValue) const
+ {
+ typename RemoveConstRef<T>::type value;
+ convertInto(stringValue, value);
+ function(obj, value);
+ }
+ virtual void setFlag(C& obj) const
+ {
+ typename RemoveConstRef<T>::type value;
+ convertInto(true, value);
+ function(obj, value);
+ }
+ virtual bool takesArg() const { return !IsBool<T>::value; }
+ virtual IArgFunction<C>* clone() const { return new BoundBinaryFunction(*this); }
+ void (*function)(C&, T);
+};
+
+} // namespace Detail
+
+struct Parser
+{
+ Parser() : separators(" \t=:") {}
+
+ struct Token
+ {
+ enum Type
+ {
+ Positional,
+ ShortOpt,
+ LongOpt
+ };
+ Token(Type _type, std::string const& _data) : type(_type), data(_data) {}
+ Type type;
+ std::string data;
+ };
+
+ void parseIntoTokens(int argc, char const* const* argv, std::vector<Parser::Token>& tokens) const
+ {
+ const std::string doubleDash = "--";
+ for (int i = 1; i < argc && argv[i] != doubleDash; ++i)
+ parseIntoTokens(argv[i], tokens);
+ }
+ void parseIntoTokens(std::string arg, std::vector<Parser::Token>& tokens) const
+ {
+ while (!arg.empty())
+ {
+ Parser::Token token(Parser::Token::Positional, arg);
+ arg = "";
+ if (token.data[0] == '-')
+ {
+ if (token.data.size() > 1 && token.data[1] == '-')
+ {
+ token = Parser::Token(Parser::Token::LongOpt, token.data.substr(2));
+ }
+ else
+ {
+ token = Parser::Token(Parser::Token::ShortOpt, token.data.substr(1));
+ if (token.data.size() > 1 && separators.find(token.data[1]) == std::string::npos)
+ {
+ arg = "-" + token.data.substr(1);
+ token.data = token.data.substr(0, 1);
+ }
+ }
+ }
+ if (token.type != Parser::Token::Positional)
+ {
+ std::size_t pos = token.data.find_first_of(separators);
+ if (pos != std::string::npos)
+ {
+ arg = token.data.substr(pos + 1);
+ token.data = token.data.substr(0, pos);
+ }
+ }
+ tokens.push_back(token);
+ }
+ }
+ std::string separators;
+};
+
+template <typename ConfigT>
+struct CommonArgProperties
+{
+ CommonArgProperties() {}
+ CommonArgProperties(Detail::BoundArgFunction<ConfigT> const& _boundField) : boundField(_boundField) {}
+
+ Detail::BoundArgFunction<ConfigT> boundField;
+ std::string description;
+ std::string detail;
+ std::string placeholder; // Only value if boundField takes an arg
+
+ bool takesArg() const
+ {
+ return !placeholder.empty();
+ }
+ void validate() const
+ {
+ if (!boundField.isSet())
+ throw std::logic_error("option not bound");
+ }
+};
+struct OptionArgProperties
+{
+ std::vector<std::string> shortNames;
+ std::string longName;
+
+ bool hasShortName(std::string const& shortName) const
+ {
+ return std::find(shortNames.begin(), shortNames.end(), shortName) != shortNames.end();
+ }
+ bool hasLongName(std::string const& _longName) const
+ {
+ return _longName == longName;
+ }
+};
+struct PositionalArgProperties
+{
+ PositionalArgProperties() : position(-1) {}
+ int position; // -1 means non-positional (floating)
+
+ bool isFixedPositional() const
+ {
+ return position != -1;
+ }
+};
+
+template <typename ConfigT>
+class CommandLine
+{
+
+ struct Arg : CommonArgProperties<ConfigT>, OptionArgProperties, PositionalArgProperties
+ {
+ Arg() {}
+ Arg(Detail::BoundArgFunction<ConfigT> const& _boundField) : CommonArgProperties<ConfigT>(_boundField) {}
+
+ using CommonArgProperties<ConfigT>::placeholder; // !TBD
+
+ std::string dbgName() const
+ {
+ if (!longName.empty())
+ return "--" + longName;
+ if (!shortNames.empty())
+ return "-" + shortNames[0];
+ return "positional args";
+ }
+ std::string commands() const
+ {
+ std::ostringstream oss;
+ bool first = true;
+ std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
+ for (; it != itEnd; ++it)
+ {
+ if (first)
+ first = false;
+ else
+ oss << ", ";
+ oss << "-" << *it;
+ }
+ if (!longName.empty())
+ {
+ if (!first)
+ oss << ", ";
+ oss << "--" << longName;
+ }
+ if (!placeholder.empty())
+ oss << " <" << placeholder << ">";
+ return oss.str();
+ }
+ };
+
+ typedef CATCH_AUTO_PTR(Arg) ArgAutoPtr;
+
+ friend void addOptName(Arg& arg, std::string const& optName)
+ {
+ if (optName.empty())
+ return;
+ if (Detail::startsWith(optName, "--"))
+ {
+ if (!arg.longName.empty())
+ throw std::logic_error("Only one long opt may be specified. '" + arg.longName + "' already specified, now attempting to add '" + optName + "'");
+ arg.longName = optName.substr(2);
+ }
+ else if (Detail::startsWith(optName, "-"))
+ arg.shortNames.push_back(optName.substr(1));
+ else
+ throw std::logic_error("option must begin with - or --. Option was: '" + optName + "'");
+ }
+ friend void setPositionalArg(Arg& arg, int position)
+ {
+ arg.position = position;
+ }
+
+ class ArgBuilder
+ {
+ public:
+ ArgBuilder(Arg* arg) : m_arg(arg) {}
+
+ // Bind a non-boolean data member (requires placeholder string)
+ template <typename C, typename M>
+ void bind(M C::*field, std::string const& placeholder)
+ {
+ m_arg->boundField = new Detail::BoundDataMember<C, M>(field);
+ m_arg->placeholder = placeholder;
+ }
+ // Bind a boolean data member (no placeholder required)
+ template <typename C>
+ void bind(bool C::*field)
+ {
+ m_arg->boundField = new Detail::BoundDataMember<C, bool>(field);
+ }
+
+ // Bind a method taking a single, non-boolean argument (requires a placeholder string)
+ template <typename C, typename M>
+ void bind(void (C::*unaryMethod)(M), std::string const& placeholder)
+ {
+ m_arg->boundField = new Detail::BoundUnaryMethod<C, M>(unaryMethod);
+ m_arg->placeholder = placeholder;
+ }
+
+ // Bind a method taking a single, boolean argument (no placeholder string required)
+ template <typename C>
+ void bind(void (C::*unaryMethod)(bool))
+ {
+ m_arg->boundField = new Detail::BoundUnaryMethod<C, bool>(unaryMethod);
+ }
+
+ // Bind a method that takes no arguments (will be called if opt is present)
+ template <typename C>
+ void bind(void (C::*nullaryMethod)())
+ {
+ m_arg->boundField = new Detail::BoundNullaryMethod<C>(nullaryMethod);
+ }
+
+ // Bind a free function taking a single argument - the object to operate on (no placeholder string required)
+ template <typename C>
+ void bind(void (*unaryFunction)(C&))
+ {
+ m_arg->boundField = new Detail::BoundUnaryFunction<C>(unaryFunction);
+ }
+
+ // Bind a free function taking a single argument - the object to operate on (requires a placeholder string)
+ template <typename C, typename T>
+ void bind(void (*binaryFunction)(C&, T), std::string const& placeholder)
+ {
+ m_arg->boundField = new Detail::BoundBinaryFunction<C, T>(binaryFunction);
+ m_arg->placeholder = placeholder;
+ }
+
+ ArgBuilder& describe(std::string const& description)
+ {
+ m_arg->description = description;
+ return *this;
+ }
+ ArgBuilder& detail(std::string const& _detail)
+ {
+ m_arg->detail = _detail;
+ return *this;
+ }
+
+ protected:
+ Arg* m_arg;
+ };
+
+ class OptBuilder : public ArgBuilder
+ {
+ public:
+ OptBuilder(Arg* arg) : ArgBuilder(arg) {}
+ OptBuilder(OptBuilder& other) : ArgBuilder(other) {}
+
+ OptBuilder& operator[](std::string const& optName)
+ {
+ addOptName(*ArgBuilder::m_arg, optName);
+ return *this;
+ }
+ };
+
+ public:
+ CommandLine()
+ : m_boundProcessName(new Detail::NullBinder<ConfigT>()),
+ m_highestSpecifiedArgPosition(0),
+ m_throwOnUnrecognisedTokens(false)
+ {
+ }
+ CommandLine(CommandLine const& other)
+ : m_boundProcessName(other.m_boundProcessName),
+ m_options(other.m_options),
+ m_positionalArgs(other.m_positionalArgs),
+ m_highestSpecifiedArgPosition(other.m_highestSpecifiedArgPosition),
+ m_throwOnUnrecognisedTokens(other.m_throwOnUnrecognisedTokens)
+ {
+ if (other.m_floatingArg.get())
+ m_floatingArg.reset(new Arg(*other.m_floatingArg));
+ }
+
+ CommandLine& setThrowOnUnrecognisedTokens(bool shouldThrow = true)
+ {
+ m_throwOnUnrecognisedTokens = shouldThrow;
+ return *this;
+ }
+
+ OptBuilder operator[](std::string const& optName)
+ {
+ m_options.push_back(Arg());
+ addOptName(m_options.back(), optName);
+ OptBuilder builder(&m_options.back());
+ return builder;
+ }
+
+ ArgBuilder operator[](int position)
+ {
+ m_positionalArgs.insert(std::make_pair(position, Arg()));
+ if (position > m_highestSpecifiedArgPosition)
+ m_highestSpecifiedArgPosition = position;
+ setPositionalArg(m_positionalArgs[position], position);
+ ArgBuilder builder(&m_positionalArgs[position]);
+ return builder;
+ }
+
+ // Invoke this with the _ instance
+ ArgBuilder operator[](UnpositionalTag)
+ {
+ if (m_floatingArg.get())
+ throw std::logic_error("Only one unpositional argument can be added");
+ m_floatingArg.reset(new Arg());
+ ArgBuilder builder(m_floatingArg.get());
+ return builder;
+ }
+
+ template <typename C, typename M>
+ void bindProcessName(M C::*field)
+ {
+ m_boundProcessName = new Detail::BoundDataMember<C, M>(field);
+ }
+ template <typename C, typename M>
+ void bindProcessName(void (C::*_unaryMethod)(M))
+ {
+ m_boundProcessName = new Detail::BoundUnaryMethod<C, M>(_unaryMethod);
+ }
+
+ void optUsage(std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth) const
+ {
+ typename std::vector<Arg>::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
+ std::size_t maxWidth = 0;
+ for (it = itBegin; it != itEnd; ++it)
+ maxWidth = (std::max)(maxWidth, it->commands().size());
+
+ for (it = itBegin; it != itEnd; ++it)
+ {
+ Detail::Text usageText(it->commands(), Detail::TextAttributes()
+ .setWidth(maxWidth + indent)
+ .setIndent(indent));
+ Detail::Text desc(it->description, Detail::TextAttributes()
+ .setWidth(width - maxWidth - 3));
+
+ for (std::size_t i = 0; i < (std::max)(usageText.size(), desc.size()); ++i)
+ {
+ std::string usageCol = i < usageText.size() ? usageText[i] : "";
+ os << usageCol;
+
+ if (i < desc.size() && !desc[i].empty())
+ os << std::string(indent + 2 + maxWidth - usageCol.size(), ' ')
+ << desc[i];
+ os << "\n";
+ }
+ }
+ }
+ std::string optUsage() const
+ {
+ std::ostringstream oss;
+ optUsage(oss);
+ return oss.str();
+ }
+
+ void argSynopsis(std::ostream& os) const
+ {
+ for (int i = 1; i <= m_highestSpecifiedArgPosition; ++i)
+ {
+ if (i > 1)
+ os << " ";
+ typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find(i);
+ if (it != m_positionalArgs.end())
+ os << "<" << it->second.placeholder << ">";
+ else if (m_floatingArg.get())
+ os << "<" << m_floatingArg->placeholder << ">";
+ else
+ throw std::logic_error("non consecutive positional arguments with no floating args");
+ }
+ // !TBD No indication of mandatory args
+ if (m_floatingArg.get())
+ {
+ if (m_highestSpecifiedArgPosition > 1)
+ os << " ";
+ os << "[<" << m_floatingArg->placeholder << "> ...]";
+ }
+ }
+ std::string argSynopsis() const
+ {
+ std::ostringstream oss;
+ argSynopsis(oss);
+ return oss.str();
+ }
+
+ void usage(std::ostream& os, std::string const& procName) const
+ {
+ validate();
+ os << "usage:\n " << procName << " ";
+ argSynopsis(os);
+ if (!m_options.empty())
+ {
+ os << " [options]\n\nwhere options are: \n";
+ optUsage(os, 2);
+ }
+ os << "\n";
+ }
+ std::string usage(std::string const& procName) const
+ {
+ std::ostringstream oss;
+ usage(oss, procName);
+ return oss.str();
+ }
+
+ ConfigT parse(int argc, char const* const* argv) const
+ {
+ ConfigT config;
+ parseInto(argc, argv, config);
+ return config;
+ }
+
+ std::vector<Parser::Token> parseInto(int argc, char const* const* argv, ConfigT& config) const
+ {
+ std::string processName = argv[0];
+ std::size_t lastSlash = processName.find_last_of("/\\");
+ if (lastSlash != std::string::npos)
+ processName = processName.substr(lastSlash + 1);
+ m_boundProcessName.set(config, processName);
+ std::vector<Parser::Token> tokens;
+ Parser parser;
+ parser.parseIntoTokens(argc, argv, tokens);
+ return populate(tokens, config);
+ }
+
+ std::vector<Parser::Token> populate(std::vector<Parser::Token> const& tokens, ConfigT& config) const
+ {
+ validate();
+ std::vector<Parser::Token> unusedTokens = populateOptions(tokens, config);
+ unusedTokens = populateFixedArgs(unusedTokens, config);
+ unusedTokens = populateFloatingArgs(unusedTokens, config);
+ return unusedTokens;
+ }
+
+ std::vector<Parser::Token> populateOptions(std::vector<Parser::Token> const& tokens, ConfigT& config) const
+ {
+ std::vector<Parser::Token> unusedTokens;
+ std::vector<std::string> errors;
+ for (std::size_t i = 0; i < tokens.size(); ++i)
+ {
+ Parser::Token const& token = tokens[i];
+ typename std::vector<Arg>::const_iterator it = m_options.begin(), itEnd = m_options.end();
+ for (; it != itEnd; ++it)
+ {
+ Arg const& arg = *it;
+
+ try
+ {
+ if ((token.type == Parser::Token::ShortOpt && arg.hasShortName(token.data)) ||
+ (token.type == Parser::Token::LongOpt && arg.hasLongName(token.data)))
+ {
+ if (arg.takesArg())
+ {
+ if (i == tokens.size() - 1 || tokens[i + 1].type != Parser::Token::Positional)
+ errors.push_back("Expected argument to option: " + token.data);
+ else
+ arg.boundField.set(config, tokens[++i].data);
+ }
+ else
+ {
+ arg.boundField.setFlag(config);
+ }
+ break;
+ }
+ }
+ catch (std::exception& ex)
+ {
+ errors.push_back(std::string(ex.what()) + "\n- while parsing: (" + arg.commands() + ")");
+ }
+ }
+ if (it == itEnd)
+ {
+ if (token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens)
+ unusedTokens.push_back(token);
+ else if (errors.empty() && m_throwOnUnrecognisedTokens)
+ errors.push_back("unrecognised option: " + token.data);
+ }
+ }
+ if (!errors.empty())
+ {
+ std::ostringstream oss;
+ for (std::vector<std::string>::const_iterator it = errors.begin(), itEnd = errors.end();
+ it != itEnd;
+ ++it)
+ {
+ if (it != errors.begin())
+ oss << "\n";
+ oss << *it;
+ }
+ throw std::runtime_error(oss.str());
+ }
+ return unusedTokens;
+ }
+ std::vector<Parser::Token> populateFixedArgs(std::vector<Parser::Token> const& tokens, ConfigT& config) const
+ {
+ std::vector<Parser::Token> unusedTokens;
+ int position = 1;
+ for (std::size_t i = 0; i < tokens.size(); ++i)
+ {
+ Parser::Token const& token = tokens[i];
+ typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find(position);
+ if (it != m_positionalArgs.end())
+ it->second.boundField.set(config, token.data);
+ else
+ unusedTokens.push_back(token);
+ if (token.type == Parser::Token::Positional)
+ position++;
+ }
+ return unusedTokens;
+ }
+ std::vector<Parser::Token> populateFloatingArgs(std::vector<Parser::Token> const& tokens, ConfigT& config) const
+ {
+ if (!m_floatingArg.get())
+ return tokens;
+ std::vector<Parser::Token> unusedTokens;
+ for (std::size_t i = 0; i < tokens.size(); ++i)
+ {
+ Parser::Token const& token = tokens[i];
+ if (token.type == Parser::Token::Positional)
+ m_floatingArg->boundField.set(config, token.data);
+ else
+ unusedTokens.push_back(token);
+ }
+ return unusedTokens;
+ }
+
+ void validate() const
+ {
+ if (m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get())
+ throw std::logic_error("No options or arguments specified");
+
+ for (typename std::vector<Arg>::const_iterator it = m_options.begin(),
+ itEnd = m_options.end();
+ it != itEnd; ++it)
+ it->validate();
+ }
+
+ private:
+ Detail::BoundArgFunction<ConfigT> m_boundProcessName;
+ std::vector<Arg> m_options;
+ std::map<int, Arg> m_positionalArgs;
+ ArgAutoPtr m_floatingArg;
+ int m_highestSpecifiedArgPosition;
+ bool m_throwOnUnrecognisedTokens;
+};
+
+} // end namespace Clara
+
+STITCH_CLARA_CLOSE_NAMESPACE
+#undef STITCH_CLARA_OPEN_NAMESPACE
+#undef STITCH_CLARA_CLOSE_NAMESPACE
+
+#endif // TWOBLUECUBES_CLARA_H_INCLUDED
+#undef STITCH_CLARA_OPEN_NAMESPACE
+
+// Restore Clara's value for console width, if present
+#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+#include <fstream>
+
+namespace Catch {
+
+inline void abortAfterFirst(ConfigData& config) { config.abortAfter = 1; }
+inline void abortAfterX(ConfigData& config, int x)
+{
+ if (x < 1)
+ throw std::runtime_error("Value after -x or --abortAfter must be greater than zero");
+ config.abortAfter = x;
+}
+inline void addTestOrTags(ConfigData& config, std::string const& _testSpec) { config.testsOrTags.push_back(_testSpec); }
+inline void addReporterName(ConfigData& config, std::string const& _reporterName) { config.reporterNames.push_back(_reporterName); }
+
+inline void addWarning(ConfigData& config, std::string const& _warning)
+{
+ if (_warning == "NoAssertions")
+ config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions);
+ else
+ throw std::runtime_error("Unrecognised warning: '" + _warning + "'");
+}
+inline void setOrder(ConfigData& config, std::string const& order)
+{
+ if (startsWith("declared", order))
+ config.runOrder = RunTests::InDeclarationOrder;
+ else if (startsWith("lexical", order))
+ config.runOrder = RunTests::InLexicographicalOrder;
+ else if (startsWith("random", order))
+ config.runOrder = RunTests::InRandomOrder;
+ else
+ throw std::runtime_error("Unrecognised ordering: '" + order + "'");
+}
+inline void setRngSeed(ConfigData& config, std::string const& seed)
+{
+ if (seed == "time")
+ {
+ config.rngSeed = static_cast<unsigned int>(std::time(0));
+ }
+ else
+ {
+ std::stringstream ss;
+ ss << seed;
+ ss >> config.rngSeed;
+ if (ss.fail())
+ throw std::runtime_error("Argment to --rng-seed should be the word 'time' or a number");
+ }
+}
+inline void setVerbosity(ConfigData& config, int level)
+{
+ // !TBD: accept strings?
+ config.verbosity = static_cast<Verbosity::Level>(level);
+}
+inline void setShowDurations(ConfigData& config, bool _showDurations)
+{
+ config.showDurations = _showDurations
+ ? ShowDurations::Always
+ : ShowDurations::Never;
+}
+inline void loadTestNamesFromFile(ConfigData& config, std::string const& _filename)
+{
+ std::ifstream f(_filename.c_str());
+ if (!f.is_open())
+ throw std::domain_error("Unable to load input file: " + _filename);
+
+ std::string line;
+ while (std::getline(f, line))
+ {
+ line = trim(line);
+ if (!line.empty() && !startsWith(line, "#"))
+ addTestOrTags(config, "\"" + line + "\",");
+ }
+}
+
+inline Clara::CommandLine<ConfigData> makeCommandLineParser()
+{
+
+ using namespace Clara;
+ CommandLine<ConfigData> cli;
+
+ cli.bindProcessName(&ConfigData::processName);
+
+ cli["-?"]["-h"]["--help"]
+ .describe("display usage information")
+ .bind(&ConfigData::showHelp);
+
+ cli["-l"]["--list-tests"]
+ .describe("list all/matching test cases")
+ .bind(&ConfigData::listTests);
+
+ cli["-t"]["--list-tags"]
+ .describe("list all/matching tags")
+ .bind(&ConfigData::listTags);
+
+ cli["-s"]["--success"]
+ .describe("include successful tests in output")
+ .bind(&ConfigData::showSuccessfulTests);
+
+ cli["-b"]["--break"]
+ .describe("break into debugger on failure")
+ .bind(&ConfigData::shouldDebugBreak);
+
+ cli["-e"]["--nothrow"]
+ .describe("skip exception tests")
+ .bind(&ConfigData::noThrow);
+
+ cli["-i"]["--invisibles"]
+ .describe("show invisibles (tabs, newlines)")
+ .bind(&ConfigData::showInvisibles);
+
+ cli["-o"]["--out"]
+ .describe("output filename")
+ .bind(&ConfigData::outputFilename, "filename");
+
+ cli["-r"]["--reporter"]
+ // .placeholder( "name[:filename]" )
+ .describe("reporter to use (defaults to console)")
+ .bind(&addReporterName, "name");
+
+ cli["-n"]["--name"]
+ .describe("suite name")
+ .bind(&ConfigData::name, "name");
+
+ cli["-a"]["--abort"]
+ .describe("abort at first failure")
+ .bind(&abortAfterFirst);
+
+ cli["-x"]["--abortx"]
+ .describe("abort after x failures")
+ .bind(&abortAfterX, "no. failures");
+
+ cli["-w"]["--warn"]
+ .describe("enable warnings")
+ .bind(&addWarning, "warning name");
+
+ // - needs updating if reinstated
+ // cli.into( &setVerbosity )
+ // .describe( "level of verbosity (0=no output)" )
+ // .shortOpt( "v")
+ // .longOpt( "verbosity" )
+ // .placeholder( "level" );
+
+ cli[_]
+ .describe("which test or tests to use")
+ .bind(&addTestOrTags, "test name, pattern or tags");
+
+ cli["-d"]["--durations"]
+ .describe("show test durations")
+ .bind(&setShowDurations, "yes/no");
+
+ cli["-f"]["--input-file"]
+ .describe("load test names to run from a file")
+ .bind(&loadTestNamesFromFile, "filename");
+
+ cli["-#"]["--filenames-as-tags"]
+ .describe("adds a tag for the filename")
+ .bind(&ConfigData::filenamesAsTags);
+
+ // Less common commands which don't have a short form
+ cli["--list-test-names-only"]
+ .describe("list all/matching test cases names only")
+ .bind(&ConfigData::listTestNamesOnly);
+
+ cli["--list-reporters"]
+ .describe("list all reporters")
+ .bind(&ConfigData::listReporters);
+
+ cli["--order"]
+ .describe("test case order (defaults to decl)")
+ .bind(&setOrder, "decl|lex|rand");
+
+ cli["--rng-seed"]
+ .describe("set a specific seed for random numbers")
+ .bind(&setRngSeed, "'time'|number");
+
+ cli["--force-colour"]
+ .describe("force colourised output")
+ .bind(&ConfigData::forceColour);
+
+ return cli;
+}
+
+} // end namespace Catch
+
+// #included from: internal/catch_list.hpp
+#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED
+
+// #included from: catch_text.h
+#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED
+
+#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
+
+#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch
+// #included from: ../external/tbc_text_format.h
+// Only use header guard if we are not using an outer namespace
+#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+#ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#endif
+#else
+#define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
+#endif
+#endif
+#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#include <sstream>
+#include <string>
+#include <vector>
+
+// Use optional outer namespace
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
+#endif
+
+namespace Tbc {
+
+#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
+const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
+#else
+const unsigned int consoleWidth = 80;
+#endif
+
+struct TextAttributes
+{
+ TextAttributes()
+ : initialIndent(std::string::npos),
+ indent(0),
+ width(consoleWidth - 1),
+ tabChar('\t')
+ {
+ }
+
+ TextAttributes& setInitialIndent(std::size_t _value)
+ {
+ initialIndent = _value;
+ return *this;
+ }
+ TextAttributes& setIndent(std::size_t _value)
+ {
+ indent = _value;
+ return *this;
+ }
+ TextAttributes& setWidth(std::size_t _value)
+ {
+ width = _value;
+ return *this;
+ }
+ TextAttributes& setTabChar(char _value)
+ {
+ tabChar = _value;
+ return *this;
+ }
+
+ std::size_t initialIndent; // indent of first line, or npos
+ std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos
+ std::size_t width; // maximum width of text, including indent. Longer text will wrap
+ char tabChar; // If this char is seen the indent is changed to current pos
+};
+
+class Text
+{
+ public:
+ Text(std::string const& _str, TextAttributes const& _attr = TextAttributes())
+ : attr(_attr)
+ {
+ std::string wrappableChars = " [({.,/|\\-";
+ std::size_t indent = _attr.initialIndent != std::string::npos
+ ? _attr.initialIndent
+ : _attr.indent;
+ std::string remainder = _str;
+
+ while (!remainder.empty())
+ {
+ if (lines.size() >= 1000)
+ {
+ lines.push_back("... message truncated due to excessive size");
+ return;
+ }
+ std::size_t tabPos = std::string::npos;
+ std::size_t width = (std::min)(remainder.size(), _attr.width - indent);
+ std::size_t pos = remainder.find_first_of('\n');
+ if (pos <= width)
+ {
+ width = pos;
+ }
+ pos = remainder.find_last_of(_attr.tabChar, width);
+ if (pos != std::string::npos)
+ {
+ tabPos = pos;
+ if (remainder[width] == '\n')
+ width--;
+ remainder = remainder.substr(0, tabPos) + remainder.substr(tabPos + 1);
+ }
+
+ if (width == remainder.size())
+ {
+ spliceLine(indent, remainder, width);
+ }
+ else if (remainder[width] == '\n')
+ {
+ spliceLine(indent, remainder, width);
+ if (width <= 1 || remainder.size() != 1)
+ remainder = remainder.substr(1);
+ indent = _attr.indent;
+ }
+ else
+ {
+ pos = remainder.find_last_of(wrappableChars, width);
+ if (pos != std::string::npos && pos > 0)
+ {
+ spliceLine(indent, remainder, pos);
+ if (remainder[0] == ' ')
+ remainder = remainder.substr(1);
+ }
+ else
+ {
+ spliceLine(indent, remainder, width - 1);
+ lines.back() += "-";
+ }
+ if (lines.size() == 1)
+ indent = _attr.indent;
+ if (tabPos != std::string::npos)
+ indent += tabPos;
+ }
+ }
+ }
+
+ void spliceLine(std::size_t _indent, std::string& _remainder, std::size_t _pos)
+ {
+ lines.push_back(std::string(_indent, ' ') + _remainder.substr(0, _pos));
+ _remainder = _remainder.substr(_pos);
+ }
+
+ typedef std::vector<std::string>::const_iterator const_iterator;
+
+ const_iterator begin() const { return lines.begin(); }
+ const_iterator end() const { return lines.end(); }
+ std::string const& last() const { return lines.back(); }
+ std::size_t size() const { return lines.size(); }
+ std::string const& operator[](std::size_t _index) const { return lines[_index]; }
+ std::string toString() const
+ {
+ std::ostringstream oss;
+ oss << *this;
+ return oss.str();
+ }
+
+ inline friend std::ostream& operator<<(std::ostream& _stream, Text const& _text)
+ {
+ for (Text::const_iterator it = _text.begin(), itEnd = _text.end();
+ it != itEnd; ++it)
+ {
+ if (it != _text.begin())
+ _stream << "\n";
+ _stream << *it;
+ }
+ return _stream;
+ }
+
+ private:
+ std::string str;
+ TextAttributes attr;
+ std::vector<std::string> lines;
+};
+
+} // end namespace Tbc
+
+#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+} // end outer namespace
+#endif
+
+#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
+#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+
+namespace Catch {
+using Tbc::Text;
+using Tbc::TextAttributes;
+}
+
+// #included from: catch_console_colour.hpp
+#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+
+namespace Catch {
+
+struct Colour
+{
+ enum Code
+ {
+ None = 0,
+
+ White,
+ Red,
+ Green,
+ Blue,
+ Cyan,
+ Yellow,
+ Grey,
+
+ Bright = 0x10,
+
+ BrightRed = Bright | Red,
+ BrightGreen = Bright | Green,
+ LightGrey = Bright | Grey,
+ BrightWhite = Bright | White,
+
+ // By intention
+ FileName = LightGrey,
+ Warning = Yellow,
+ ResultError = BrightRed,
+ ResultSuccess = BrightGreen,
+ ResultExpectedFailure = Warning,
+
+ Error = BrightRed,
+ Success = Green,
+
+ OriginalExpression = Cyan,
+ ReconstructedExpression = Yellow,
+
+ SecondaryText = LightGrey,
+ Headers = White
+ };
+
+ // Use constructed object for RAII guard
+ Colour(Code _colourCode);
+ Colour(Colour const& other);
+ ~Colour();
+
+ // Use static method for one-shot changes
+ static void use(Code _colourCode);
+
+ private:
+ bool m_moved;
+};
+
+inline std::ostream& operator<<(std::ostream& os, Colour const&) { return os; }
+
+} // end namespace Catch
+
+// #included from: catch_interfaces_reporter.h
+#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED
+
+#include <assert.h>
+#include <map>
+#include <ostream>
+#include <string>
+
+namespace Catch {
+struct ReporterConfig
+{
+ explicit ReporterConfig(Ptr<IConfig const> const& _fullConfig)
+ : m_stream(&_fullConfig->stream()), m_fullConfig(_fullConfig) {}
+
+ ReporterConfig(Ptr<IConfig const> const& _fullConfig, std::ostream& _stream)
+ : m_stream(&_stream), m_fullConfig(_fullConfig) {}
+
+ std::ostream& stream() const { return *m_stream; }
+ Ptr<IConfig const> fullConfig() const { return m_fullConfig; }
+
+ private:
+ std::ostream* m_stream;
+ Ptr<IConfig const> m_fullConfig;
+};
+
+struct ReporterPreferences
+{
+ ReporterPreferences()
+ : shouldRedirectStdOut(false)
+ {
+ }
+
+ bool shouldRedirectStdOut;
+};
+
+template <typename T>
+struct LazyStat : Option<T>
+{
+ LazyStat() : used(false) {}
+ LazyStat& operator=(T const& _value)
+ {
+ Option<T>::operator=(_value);
+ used = false;
+ return *this;
+ }
+ void reset()
+ {
+ Option<T>::reset();
+ used = false;
+ }
+ bool used;
+};
+
+struct TestRunInfo
+{
+ TestRunInfo(std::string const& _name) : name(_name) {}
+ std::string name;
+};
+struct GroupInfo
+{
+ GroupInfo(std::string const& _name,
+ std::size_t _groupIndex,
+ std::size_t _groupsCount)
+ : name(_name),
+ groupIndex(_groupIndex),
+ groupsCounts(_groupsCount)
+ {
+ }
+
+ std::string name;
+ std::size_t groupIndex;
+ std::size_t groupsCounts;
+};
+
+struct AssertionStats
+{
+ AssertionStats(AssertionResult const& _assertionResult,
+ std::vector<MessageInfo> const& _infoMessages,
+ Totals const& _totals)
+ : assertionResult(_assertionResult),
+ infoMessages(_infoMessages),
+ totals(_totals)
+ {
+ if (assertionResult.hasMessage())
+ {
+ // Copy message into messages list.
+ // !TBD This should have been done earlier, somewhere
+ MessageBuilder builder(assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType());
+ builder << assertionResult.getMessage();
+ builder.m_info.message = builder.m_stream.str();
+
+ infoMessages.push_back(builder.m_info);
+ }
+ }
+ virtual ~AssertionStats();
+
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+ AssertionStats(AssertionStats const&) = default;
+ AssertionStats(AssertionStats&&) = default;
+ AssertionStats& operator=(AssertionStats const&) = default;
+ AssertionStats& operator=(AssertionStats&&) = default;
+#endif
+
+ AssertionResult assertionResult;
+ std::vector<MessageInfo> infoMessages;
+ Totals totals;
+};
+
+struct SectionStats
+{
+ SectionStats(SectionInfo const& _sectionInfo,
+ Counts const& _assertions,
+ double _durationInSeconds,
+ bool _missingAssertions)
+ : sectionInfo(_sectionInfo),
+ assertions(_assertions),
+ durationInSeconds(_durationInSeconds),
+ missingAssertions(_missingAssertions)
+ {
+ }
+ virtual ~SectionStats();
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+ SectionStats(SectionStats const&) = default;
+ SectionStats(SectionStats&&) = default;
+ SectionStats& operator=(SectionStats const&) = default;
+ SectionStats& operator=(SectionStats&&) = default;
+#endif
+
+ SectionInfo sectionInfo;
+ Counts assertions;
+ double durationInSeconds;
+ bool missingAssertions;
+};
+
+struct TestCaseStats
+{
+ TestCaseStats(TestCaseInfo const& _testInfo,
+ Totals const& _totals,
+ std::string const& _stdOut,
+ std::string const& _stdErr,
+ bool _aborting)
+ : testInfo(_testInfo),
+ totals(_totals),
+ stdOut(_stdOut),
+ stdErr(_stdErr),
+ aborting(_aborting)
+ {
+ }
+ virtual ~TestCaseStats();
+
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+ TestCaseStats(TestCaseStats const&) = default;
+ TestCaseStats(TestCaseStats&&) = default;
+ TestCaseStats& operator=(TestCaseStats const&) = default;
+ TestCaseStats& operator=(TestCaseStats&&) = default;
+#endif
+
+ TestCaseInfo testInfo;
+ Totals totals;
+ std::string stdOut;
+ std::string stdErr;
+ bool aborting;
+};
+
+struct TestGroupStats
+{
+ TestGroupStats(GroupInfo const& _groupInfo,
+ Totals const& _totals,
+ bool _aborting)
+ : groupInfo(_groupInfo),
+ totals(_totals),
+ aborting(_aborting)
+ {
+ }
+ TestGroupStats(GroupInfo const& _groupInfo)
+ : groupInfo(_groupInfo),
+ aborting(false)
+ {
+ }
+ virtual ~TestGroupStats();
+
+#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
+ TestGroupStats(TestGroupStats const&) = default;
+ TestGroupStats(TestGroupStats&&) = default;
+ TestGroupStats& operator=(TestGroupStats const&) = default;
+ TestGroupStats& operator=(TestGroupStats&&) = default;
+#endif
+
+ GroupInfo groupInfo;
+ Totals totals;
+ bool aborting;
+};
+
+struct TestRunStats
+{
+ TestRunStats(TestRunInfo const& _runInfo,
+ Totals const& _totals,
+ bool _aborting)
+ : runInfo(_runInfo),
+ totals(_totals),
+ aborting(_aborting)
+ {
+ }
+ virtual ~TestRunStats();
+
+#ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS
+ TestRunStats(TestRunStats const& _other)
+ : runInfo(_other.runInfo),
+ totals(_other.totals),
+ aborting(_other.aborting)
+ {
+ }
+#else
+ TestRunStats(TestRunStats const&) = default;
+ TestRunStats(TestRunStats&&) = default;
+ TestRunStats& operator=(TestRunStats const&) = default;
+ TestRunStats& operator=(TestRunStats&&) = default;
+#endif
+
+ TestRunInfo runInfo;
+ Totals totals;
+ bool aborting;
+};
+
+struct IStreamingReporter : IShared
+{
+ virtual ~IStreamingReporter();
+
+ // Implementing class must also provide the following static method:
+ // static std::string getDescription();
+
+ virtual ReporterPreferences getPreferences() const = 0;
+
+ virtual void noMatchingTestCases(std::string const& spec) = 0;
+
+ virtual void testRunStarting(TestRunInfo const& testRunInfo) = 0;
+ virtual void testGroupStarting(GroupInfo const& groupInfo) = 0;
+
+ virtual void testCaseStarting(TestCaseInfo const& testInfo) = 0;
+ virtual void sectionStarting(SectionInfo const& sectionInfo) = 0;
+
+ virtual void assertionStarting(AssertionInfo const& assertionInfo) = 0;
+
+ // The return value indicates if the messages buffer should be cleared:
+ virtual bool assertionEnded(AssertionStats const& assertionStats) = 0;
+
+ virtual void sectionEnded(SectionStats const& sectionStats) = 0;
+ virtual void testCaseEnded(TestCaseStats const& testCaseStats) = 0;
+ virtual void testGroupEnded(TestGroupStats const& testGroupStats) = 0;
+ virtual void testRunEnded(TestRunStats const& testRunStats) = 0;
+
+ virtual void skipTest(TestCaseInfo const& testInfo) = 0;
+};
+
+struct IReporterFactory : IShared
+{
+ virtual ~IReporterFactory();
+ virtual IStreamingReporter* create(ReporterConfig const& config) const = 0;
+ virtual std::string getDescription() const = 0;
+};
+
+struct IReporterRegistry
+{
+ typedef std::map<std::string, Ptr<IReporterFactory>> FactoryMap;
+ typedef std::vector<Ptr<IReporterFactory>> Listeners;
+
+ virtual ~IReporterRegistry();
+ virtual IStreamingReporter* create(std::string const& name, Ptr<IConfig const> const& config) const = 0;
+ virtual FactoryMap const& getFactories() const = 0;
+ virtual Listeners const& getListeners() const = 0;
+};
+
+Ptr<IStreamingReporter> addReporter(Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter);
+}
+
+#include <algorithm>
+#include <limits>
+
+namespace Catch {
+
+inline std::size_t listTests(Config const& config)
+{
+
+ TestSpec testSpec = config.testSpec();
+ if (config.testSpec().hasFilters())
+ Catch::cout() << "Matching test cases:\n";
+ else
+ {
+ Catch::cout() << "All available test cases:\n";
+ testSpec = TestSpecParser(ITagAliasRegistry::get()).parse("*").testSpec();
+ }
+
+ std::size_t matchedTests = 0;
+ TextAttributes nameAttr, tagsAttr;
+ nameAttr.setInitialIndent(2).setIndent(4);
+ tagsAttr.setIndent(6);
+
+ std::vector<TestCase> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+ for (std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+ it != itEnd;
+ ++it)
+ {
+ matchedTests++;
+ TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
+ Colour::Code colour = testCaseInfo.isHidden()
+ ? Colour::SecondaryText
+ : Colour::None;
+ Colour colourGuard(colour);
+
+ Catch::cout() << Text(testCaseInfo.name, nameAttr) << std::endl;
+ if (!testCaseInfo.tags.empty())
+ Catch::cout() << Text(testCaseInfo.tagsAsString, tagsAttr) << std::endl;
+ }
+
+ if (!config.testSpec().hasFilters())
+ Catch::cout() << pluralise(matchedTests, "test case") << "\n"
+ << std::endl;
+ else
+ Catch::cout() << pluralise(matchedTests, "matching test case") << "\n"
+ << std::endl;
+ return matchedTests;
+}
+
+inline std::size_t listTestsNamesOnly(Config const& config)
+{
+ TestSpec testSpec = config.testSpec();
+ if (!config.testSpec().hasFilters())
+ testSpec = TestSpecParser(ITagAliasRegistry::get()).parse("*").testSpec();
+ std::size_t matchedTests = 0;
+ std::vector<TestCase> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+ for (std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+ it != itEnd;
+ ++it)
+ {
+ matchedTests++;
+ TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
+ Catch::cout() << testCaseInfo.name << std::endl;
+ }
+ return matchedTests;
+}
+
+struct TagInfo
+{
+ TagInfo() : count(0) {}
+ void add(std::string const& spelling)
+ {
+ ++count;
+ spellings.insert(spelling);
+ }
+ std::string all() const
+ {
+ std::string out;
+ for (std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
+ it != itEnd;
+ ++it)
+ out += "[" + *it + "]";
+ return out;
+ }
+ std::set<std::string> spellings;
+ std::size_t count;
+};
+
+inline std::size_t listTags(Config const& config)
+{
+ TestSpec testSpec = config.testSpec();
+ if (config.testSpec().hasFilters())
+ Catch::cout() << "Tags for matching test cases:\n";
+ else
+ {
+ Catch::cout() << "All available tags:\n";
+ testSpec = TestSpecParser(ITagAliasRegistry::get()).parse("*").testSpec();
+ }
+
+ std::map<std::string, TagInfo> tagCounts;
+
+ std::vector<TestCase> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+ for (std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
+ it != itEnd;
+ ++it)
+ {
+ for (std::set<std::string>::const_iterator tagIt = it->getTestCaseInfo().tags.begin(),
+ tagItEnd = it->getTestCaseInfo().tags.end();
+ tagIt != tagItEnd;
+ ++tagIt)
+ {
+ std::string tagName = *tagIt;
+ std::string lcaseTagName = toLower(tagName);
+ std::map<std::string, TagInfo>::iterator countIt = tagCounts.find(lcaseTagName);
+ if (countIt == tagCounts.end())
+ countIt = tagCounts.insert(std::make_pair(lcaseTagName, TagInfo())).first;
+ countIt->second.add(tagName);
+ }
+ }
+
+ for (std::map<std::string, TagInfo>::const_iterator countIt = tagCounts.begin(),
+ countItEnd = tagCounts.end();
+ countIt != countItEnd;
+ ++countIt)
+ {
+ std::ostringstream oss;
+ oss << " " << std::setw(2) << countIt->second.count << " ";
+ Text wrapper(countIt->second.all(), TextAttributes()
+ .setInitialIndent(0)
+ .setIndent(oss.str().size())
+ .setWidth(CATCH_CONFIG_CONSOLE_WIDTH - 10));
+ Catch::cout() << oss.str() << wrapper << "\n";
+ }
+ Catch::cout() << pluralise(tagCounts.size(), "tag") << "\n"
+ << std::endl;
+ return tagCounts.size();
+}
+
+inline std::size_t listReporters(Config const& /*config*/)
+{
+ Catch::cout() << "Available reporters:\n";
+ IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+ IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it;
+ std::size_t maxNameLen = 0;
+ for (it = itBegin; it != itEnd; ++it)
+ maxNameLen = (std::max)(maxNameLen, it->first.size());
+
+ for (it = itBegin; it != itEnd; ++it)
+ {
+ Text wrapper(it->second->getDescription(), TextAttributes()
+ .setInitialIndent(0)
+ .setIndent(7 + maxNameLen)
+ .setWidth(CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8));
+ Catch::cout() << " "
+ << it->first
+ << ":"
+ << std::string(maxNameLen - it->first.size() + 2, ' ')
+ << wrapper << "\n";
+ }
+ Catch::cout() << std::endl;
+ return factories.size();
+}
+
+inline Option<std::size_t> list(Config const& config)
+{
+ Option<std::size_t> listedCount;
+ if (config.listTests())
+ listedCount = listedCount.valueOr(0) + listTests(config);
+ if (config.listTestNamesOnly())
+ listedCount = listedCount.valueOr(0) + listTestsNamesOnly(config);
+ if (config.listTags())
+ listedCount = listedCount.valueOr(0) + listTags(config);
+ if (config.listReporters())
+ listedCount = listedCount.valueOr(0) + listReporters(config);
+ return listedCount;
+}
+
+} // end namespace Catch
+
+// #included from: internal/catch_run_context.hpp
+#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED
+
+// #included from: catch_test_case_tracker.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+
+#include <assert.h>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace TestCaseTracking {
+
+struct ITracker : SharedImpl<>
+{
+ virtual ~ITracker();
+
+ // static queries
+ virtual std::string name() const = 0;
+
+ // dynamic queries
+ virtual bool isComplete() const = 0; // Successfully completed or failed
+ virtual bool isSuccessfullyCompleted() const = 0;
+ virtual bool isOpen() const = 0; // Started but not complete
+ virtual bool hasChildren() const = 0;
+
+ virtual ITracker& parent() = 0;
+
+ // actions
+ virtual void close() = 0; // Successfully complete
+ virtual void fail() = 0;
+ virtual void markAsNeedingAnotherRun() = 0;
+
+ virtual void addChild(Ptr<ITracker> const& child) = 0;
+ virtual ITracker* findChild(std::string const& name) = 0;
+ virtual void openChild() = 0;
+};
+
+class TrackerContext
+{
+
+ enum RunState
+ {
+ NotStarted,
+ Executing,
+ CompletedCycle
+ };
+
+ Ptr<ITracker> m_rootTracker;
+ ITracker* m_currentTracker;
+ RunState m_runState;
+
+ public:
+ static TrackerContext& instance()
+ {
+ static TrackerContext s_instance;
+ return s_instance;
+ }
+
+ TrackerContext()
+ : m_currentTracker(CATCH_NULL),
+ m_runState(NotStarted)
+ {
+ }
+
+ ITracker& startRun();
+
+ void endRun()
+ {
+ m_rootTracker.reset();
+ m_currentTracker = CATCH_NULL;
+ m_runState = NotStarted;
+ }
+
+ void startCycle()
+ {
+ m_currentTracker = m_rootTracker.get();
+ m_runState = Executing;
+ }
+ void completeCycle()
+ {
+ m_runState = CompletedCycle;
+ }
+
+ bool completedCycle() const
+ {
+ return m_runState == CompletedCycle;
+ }
+ ITracker& currentTracker()
+ {
+ return *m_currentTracker;
+ }
+ void setCurrentTracker(ITracker* tracker)
+ {
+ m_currentTracker = tracker;
+ }
+};
+
+class TrackerBase : public ITracker
+{
+ protected:
+ enum CycleState
+ {
+ NotStarted,
+ Executing,
+ ExecutingChildren,
+ NeedsAnotherRun,
+ CompletedSuccessfully,
+ Failed
+ };
+ class TrackerHasName
+ {
+ std::string m_name;
+
+ public:
+ TrackerHasName(std::string const& name) : m_name(name) {}
+ bool operator()(Ptr<ITracker> const& tracker)
+ {
+ return tracker->name() == m_name;
+ }
+ };
+ typedef std::vector<Ptr<ITracker>> Children;
+ std::string m_name;
+ TrackerContext& m_ctx;
+ ITracker* m_parent;
+ Children m_children;
+ CycleState m_runState;
+
+ public:
+ TrackerBase(std::string const& name, TrackerContext& ctx, ITracker* parent)
+ : m_name(name),
+ m_ctx(ctx),
+ m_parent(parent),
+ m_runState(NotStarted)
+ {
+ }
+ virtual ~TrackerBase();
+
+ virtual std::string name() const CATCH_OVERRIDE
+ {
+ return m_name;
+ }
+ virtual bool isComplete() const CATCH_OVERRIDE
+ {
+ return m_runState == CompletedSuccessfully || m_runState == Failed;
+ }
+ virtual bool isSuccessfullyCompleted() const CATCH_OVERRIDE
+ {
+ return m_runState == CompletedSuccessfully;
+ }
+ virtual bool isOpen() const CATCH_OVERRIDE
+ {
+ return m_runState != NotStarted && !isComplete();
+ }
+ virtual bool hasChildren() const CATCH_OVERRIDE
+ {
+ return !m_children.empty();
+ }
+
+ virtual void addChild(Ptr<ITracker> const& child) CATCH_OVERRIDE
+ {
+ m_children.push_back(child);
+ }
+
+ virtual ITracker* findChild(std::string const& name) CATCH_OVERRIDE
+ {
+ Children::const_iterator it = std::find_if(m_children.begin(), m_children.end(), TrackerHasName(name));
+ return (it != m_children.end())
+ ? it->get()
+ : CATCH_NULL;
+ }
+ virtual ITracker& parent() CATCH_OVERRIDE
+ {
+ assert(m_parent); // Should always be non-null except for root
+ return *m_parent;
+ }
+
+ virtual void openChild() CATCH_OVERRIDE
+ {
+ if (m_runState != ExecutingChildren)
+ {
+ m_runState = ExecutingChildren;
+ if (m_parent)
+ m_parent->openChild();
+ }
+ }
+ void open()
+ {
+ m_runState = Executing;
+ moveToThis();
+ if (m_parent)
+ m_parent->openChild();
+ }
+
+ virtual void close() CATCH_OVERRIDE
+ {
+
+ // Close any still open children (e.g. generators)
+ while (&m_ctx.currentTracker() != this)
+ m_ctx.currentTracker().close();
+
+ switch (m_runState)
+ {
+ case NotStarted:
+ case CompletedSuccessfully:
+ case Failed:
+ throw std::logic_error("Illogical state");
+
+ case NeedsAnotherRun:
+ break;
+ ;
+
+ case Executing:
+ m_runState = CompletedSuccessfully;
+ break;
+ case ExecutingChildren:
+ if (m_children.empty() || m_children.back()->isComplete())
+ m_runState = CompletedSuccessfully;
+ break;
+
+ default:
+ throw std::logic_error("Unexpected state");
+ }
+ moveToParent();
+ m_ctx.completeCycle();
+ }
+ virtual void fail() CATCH_OVERRIDE
+ {
+ m_runState = Failed;
+ if (m_parent)
+ m_parent->markAsNeedingAnotherRun();
+ moveToParent();
+ m_ctx.completeCycle();
+ }
+ virtual void markAsNeedingAnotherRun() CATCH_OVERRIDE
+ {
+ m_runState = NeedsAnotherRun;
+ }
+
+ private:
+ void moveToParent()
+ {
+ assert(m_parent);
+ m_ctx.setCurrentTracker(m_parent);
+ }
+ void moveToThis()
+ {
+ m_ctx.setCurrentTracker(this);
+ }
+};
+
+class SectionTracker : public TrackerBase
+{
+ public:
+ SectionTracker(std::string const& name, TrackerContext& ctx, ITracker* parent)
+ : TrackerBase(name, ctx, parent)
+ {
+ }
+ virtual ~SectionTracker();
+
+ static SectionTracker& acquire(TrackerContext& ctx, std::string const& name)
+ {
+ SectionTracker* section = CATCH_NULL;
+
+ ITracker& currentTracker = ctx.currentTracker();
+ if (ITracker* childTracker = currentTracker.findChild(name))
+ {
+ section = dynamic_cast<SectionTracker*>(childTracker);
+ assert(section);
+ }
+ else
+ {
+ section = new SectionTracker(name, ctx, ¤tTracker);
+ currentTracker.addChild(section);
+ }
+ if (!ctx.completedCycle() && !section->isComplete())
+ {
+
+ section->open();
+ }
+ return *section;
+ }
+};
+
+class IndexTracker : public TrackerBase
+{
+ int m_size;
+ int m_index;
+
+ public:
+ IndexTracker(std::string const& name, TrackerContext& ctx, ITracker* parent, int size)
+ : TrackerBase(name, ctx, parent),
+ m_size(size),
+ m_index(-1)
+ {
+ }
+ virtual ~IndexTracker();
+
+ static IndexTracker& acquire(TrackerContext& ctx, std::string const& name, int size)
+ {
+ IndexTracker* tracker = CATCH_NULL;
+
+ ITracker& currentTracker = ctx.currentTracker();
+ if (ITracker* childTracker = currentTracker.findChild(name))
+ {
+ tracker = dynamic_cast<IndexTracker*>(childTracker);
+ assert(tracker);
+ }
+ else
+ {
+ tracker = new IndexTracker(name, ctx, ¤tTracker, size);
+ currentTracker.addChild(tracker);
+ }
+
+ if (!ctx.completedCycle() && !tracker->isComplete())
+ {
+ if (tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun)
+ tracker->moveNext();
+ tracker->open();
+ }
+
+ return *tracker;
+ }
+
+ int index() const { return m_index; }
+
+ void moveNext()
+ {
+ m_index++;
+ m_children.clear();
+ }
+
+ virtual void close() CATCH_OVERRIDE
+ {
+ TrackerBase::close();
+ if (m_runState == CompletedSuccessfully && m_index < m_size - 1)
+ m_runState = Executing;
+ }
+};
+
+inline ITracker& TrackerContext::startRun()
+{
+ m_rootTracker = new SectionTracker("{root}", *this, CATCH_NULL);
+ m_currentTracker = CATCH_NULL;
+ m_runState = Executing;
+ return *m_rootTracker;
+}
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+using TestCaseTracking::IndexTracker;
+
+} // namespace Catch
+
+// #included from: catch_fatal_condition.hpp
+#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
+
+namespace Catch {
+
+// Report the error condition then exit the process
+inline void fatal(std::string const& message, int exitCode)
+{
+ IContext& context = Catch::getCurrentContext();
+ IResultCapture* resultCapture = context.getResultCapture();
+ resultCapture->handleFatalErrorCondition(message);
+
+ if (Catch::alwaysTrue()) // avoids "no return" warnings
+ exit(exitCode);
+}
+
+} // namespace Catch
+
+#if defined(CATCH_PLATFORM_WINDOWS) /////////////////////////////////////////
+
+namespace Catch {
+
+struct FatalConditionHandler
+{
+ void reset() {}
+};
+
+} // namespace Catch
+
+#else // Not Windows - assumed to be POSIX compatible //////////////////////////
+
+#include <signal.h>
+
+namespace Catch {
+
+struct SignalDefs
+{
+ int id;
+ const char* name;
+};
+extern SignalDefs signalDefs[];
+SignalDefs signalDefs[] = {
+ {SIGINT, "SIGINT - Terminal interrupt signal"},
+ {SIGILL, "SIGILL - Illegal instruction signal"},
+ {SIGFPE, "SIGFPE - Floating point error signal"},
+ {SIGSEGV, "SIGSEGV - Segmentation violation signal"},
+ {SIGTERM, "SIGTERM - Termination request signal"},
+ {SIGABRT, "SIGABRT - Abort (abnormal termination) signal"}};
+
+struct FatalConditionHandler
+{
+
+ static void handleSignal(int sig)
+ {
+ for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i)
+ if (sig == signalDefs[i].id)
+ fatal(signalDefs[i].name, -sig);
+ fatal("<unknown signal>", -sig);
+ }
+
+ FatalConditionHandler() : m_isSet(true)
+ {
+ for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i)
+ signal(signalDefs[i].id, handleSignal);
+ }
+ ~FatalConditionHandler()
+ {
+ reset();
+ }
+ void reset()
+ {
+ if (m_isSet)
+ {
+ for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i)
+ signal(signalDefs[i].id, SIG_DFL);
+ m_isSet = false;
+ }
+ }
+
+ bool m_isSet;
+};
+
+} // namespace Catch
+
+#endif // not Windows
+
+#include <set>
+#include <string>
+
+namespace Catch {
+
+class StreamRedirect
+{
+
+ public:
+ StreamRedirect(std::ostream& stream, std::string& targetString)
+ : m_stream(stream),
+ m_prevBuf(stream.rdbuf()),
+ m_targetString(targetString)
+ {
+ stream.rdbuf(m_oss.rdbuf());
+ }
+
+ ~StreamRedirect()
+ {
+ m_targetString += m_oss.str();
+ m_stream.rdbuf(m_prevBuf);
+ }
+
+ private:
+ std::ostream& m_stream;
+ std::streambuf* m_prevBuf;
+ std::ostringstream m_oss;
+ std::string& m_targetString;
+};
+
+///////////////////////////////////////////////////////////////////////////
+
+class RunContext : public IResultCapture, public IRunner
+{
+
+ RunContext(RunContext const&);
+ void operator=(RunContext const&);
+
+ public:
+ explicit RunContext(Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter)
+ : m_runInfo(_config->name()),
+ m_context(getCurrentMutableContext()),
+ m_activeTestCase(CATCH_NULL),
+ m_config(_config),
+ m_reporter(reporter)
+ {
+ m_context.setRunner(this);
+ m_context.setConfig(m_config);
+ m_context.setResultCapture(this);
+ m_reporter->testRunStarting(m_runInfo);
+ }
+
+ virtual ~RunContext()
+ {
+ m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+ }
+
+ void testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount)
+ {
+ m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
+ }
+ void testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount)
+ {
+ m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
+ }
+
+ Totals runTest(TestCase const& testCase)
+ {
+ Totals prevTotals = m_totals;
+
+ std::string redirectedCout;
+ std::string redirectedCerr;
+
+ TestCaseInfo testInfo = testCase.getTestCaseInfo();
+
+ m_reporter->testCaseStarting(testInfo);
+
+ m_activeTestCase = &testCase;
+
+ do
+ {
+ m_trackerContext.startRun();
+ do
+ {
+ m_trackerContext.startCycle();
+ m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, testInfo.name);
+ runCurrentTest(redirectedCout, redirectedCerr);
+ } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
+ }
+ // !TBD: deprecated - this will be replaced by indexed trackers
+ while (getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting());
+
+ Totals deltaTotals = m_totals.delta(prevTotals);
+ m_totals.testCases += deltaTotals.testCases;
+ m_reporter->testCaseEnded(TestCaseStats(testInfo,
+ deltaTotals,
+ redirectedCout,
+ redirectedCerr,
+ aborting()));
+
+ m_activeTestCase = CATCH_NULL;
+ m_testCaseTracker = CATCH_NULL;
+
+ return deltaTotals;
+ }
+
+ Ptr<IConfig const> config() const
+ {
+ return m_config;
+ }
+
+ private: // IResultCapture
+ virtual void assertionEnded(AssertionResult const& result)
+ {
+ if (result.getResultType() == ResultWas::Ok)
+ {
+ m_totals.assertions.passed++;
+ }
+ else if (!result.isOk())
+ {
+ m_totals.assertions.failed++;
+ }
+
+ if (m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)))
+ m_messages.clear();
+
+ // Reset working state
+ m_lastAssertionInfo = AssertionInfo("", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}", m_lastAssertionInfo.resultDisposition);
+ m_lastResult = result;
+ }
+
+ virtual bool sectionStarted(
+ SectionInfo const& sectionInfo,
+ Counts& assertions)
+ {
+ std::ostringstream oss;
+ oss << sectionInfo.name << "@" << sectionInfo.lineInfo;
+
+ ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, oss.str());
+ if (!sectionTracker.isOpen())
+ return false;
+ m_activeSections.push_back(§ionTracker);
+
+ m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+ m_reporter->sectionStarting(sectionInfo);
+
+ assertions = m_totals.assertions;
+
+ return true;
+ }
+ bool testForMissingAssertions(Counts& assertions)
+ {
+ if (assertions.total() != 0)
+ return false;
+ if (!m_config->warnAboutMissingAssertions())
+ return false;
+ if (m_trackerContext.currentTracker().hasChildren())
+ return false;
+ m_totals.assertions.failed++;
+ assertions.failed++;
+ return true;
+ }
+
+ virtual void sectionEnded(SectionEndInfo const& endInfo)
+ {
+ Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+ bool missingAssertions = testForMissingAssertions(assertions);
+
+ if (!m_activeSections.empty())
+ {
+ m_activeSections.back()->close();
+ m_activeSections.pop_back();
+ }
+
+ m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
+ m_messages.clear();
+ }
+
+ virtual void sectionEndedEarly(SectionEndInfo const& endInfo)
+ {
+ if (m_unfinishedSections.empty())
+ m_activeSections.back()->fail();
+ else
+ m_activeSections.back()->close();
+ m_activeSections.pop_back();
+
+ m_unfinishedSections.push_back(endInfo);
+ }
+
+ virtual void pushScopedMessage(MessageInfo const& message)
+ {
+ m_messages.push_back(message);
+ }
+
+ virtual void popScopedMessage(MessageInfo const& message)
+ {
+ m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+ }
+
+ virtual std::string getCurrentTestName() const
+ {
+ return m_activeTestCase
+ ? m_activeTestCase->getTestCaseInfo().name
+ : "";
+ }
+
+ virtual const AssertionResult* getLastResult() const
+ {
+ return &m_lastResult;
+ }
+
+ virtual void handleFatalErrorCondition(std::string const& message)
+ {
+ ResultBuilder resultBuilder = makeUnexpectedResultBuilder();
+ resultBuilder.setResultType(ResultWas::FatalErrorCondition);
+ resultBuilder << message;
+ resultBuilder.captureExpression();
+
+ handleUnfinishedSections();
+
+ // Recreate section for test case (as we will lose the one that was in scope)
+ TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+ SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description);
+
+ Counts assertions;
+ assertions.failed = 1;
+ SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
+ m_reporter->sectionEnded(testCaseSectionStats);
+
+ TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo();
+
+ Totals deltaTotals;
+ deltaTotals.testCases.failed = 1;
+ m_reporter->testCaseEnded(TestCaseStats(testInfo,
+ deltaTotals,
+ "",
+ "",
+ false));
+ m_totals.testCases.failed++;
+ testGroupEnded("", m_totals, 1, 1);
+ m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+ }
+
+ public:
+ // !TBD We need to do this another way!
+ bool aborting() const
+ {
+ return m_totals.assertions.failed == static_cast<std::size_t>(m_config->abortAfter());
+ }
+
+ private:
+ void runCurrentTest(std::string& redirectedCout, std::string& redirectedCerr)
+ {
+ TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+ SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description);
+ m_reporter->sectionStarting(testCaseSection);
+ Counts prevAssertions = m_totals.assertions;
+ double duration = 0;
+ try
+ {
+ m_lastAssertionInfo = AssertionInfo("TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal);
+
+ seedRng(*m_config);
+
+ Timer timer;
+ timer.start();
+ if (m_reporter->getPreferences().shouldRedirectStdOut)
+ {
+ StreamRedirect coutRedir(Catch::cout(), redirectedCout);
+ StreamRedirect cerrRedir(Catch::cerr(), redirectedCerr);
+ invokeActiveTestCase();
+ }
+ else
+ {
+ invokeActiveTestCase();
+ }
+ duration = timer.getElapsedSeconds();
+ }
+ catch (TestFailureException&)
+ {
+ // This just means the test was aborted due to failure
+ }
+ catch (...)
+ {
+ makeUnexpectedResultBuilder().useActiveException();
+ }
+ m_testCaseTracker->close();
+ handleUnfinishedSections();
+ m_messages.clear();
+
+ Counts assertions = m_totals.assertions - prevAssertions;
+ bool missingAssertions = testForMissingAssertions(assertions);
+
+ if (testCaseInfo.okToFail())
+ {
+ std::swap(assertions.failedButOk, assertions.failed);
+ m_totals.assertions.failed -= assertions.failedButOk;
+ m_totals.assertions.failedButOk += assertions.failedButOk;
+ }
+
+ SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
+ m_reporter->sectionEnded(testCaseSectionStats);
+ }
+
+ void invokeActiveTestCase()
+ {
+ FatalConditionHandler fatalConditionHandler; // Handle signals
+ m_activeTestCase->invoke();
+ fatalConditionHandler.reset();
+ }
+
+ private:
+ ResultBuilder makeUnexpectedResultBuilder() const
+ {
+ return ResultBuilder(m_lastAssertionInfo.macroName.c_str(),
+ m_lastAssertionInfo.lineInfo,
+ m_lastAssertionInfo.capturedExpression.c_str(),
+ m_lastAssertionInfo.resultDisposition);
+ }
+
+ void handleUnfinishedSections()
+ {
+ // If sections ended prematurely due to an exception we stored their
+ // infos here so we can tear them down outside the unwind process.
+ for (std::vector<SectionEndInfo>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
+ itEnd = m_unfinishedSections.rend();
+ it != itEnd;
+ ++it)
+ sectionEnded(*it);
+ m_unfinishedSections.clear();
+ }
+
+ TestRunInfo m_runInfo;
+ IMutableContext& m_context;
+ TestCase const* m_activeTestCase;
+ ITracker* m_testCaseTracker;
+ ITracker* m_currentSectionTracker;
+ AssertionResult m_lastResult;
+
+ Ptr<IConfig const> m_config;
+ Totals m_totals;
+ Ptr<IStreamingReporter> m_reporter;
+ std::vector<MessageInfo> m_messages;
+ AssertionInfo m_lastAssertionInfo;
+ std::vector<SectionEndInfo> m_unfinishedSections;
+ std::vector<ITracker*> m_activeSections;
+ TrackerContext m_trackerContext;
+};
+
+IResultCapture& getResultCapture()
+{
+ if (IResultCapture* capture = getCurrentContext().getResultCapture())
+ return *capture;
+ else
+ throw std::logic_error("No result capture instance");
+}
+
+} // end namespace Catch
+
+// #included from: internal/catch_version.h
+#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED
+
+namespace Catch {
+
+// Versioning information
+struct Version
+{
+ Version(unsigned int _majorVersion,
+ unsigned int _minorVersion,
+ unsigned int _patchNumber,
+ std::string const& _branchName,
+ unsigned int _buildNumber);
+
+ unsigned int const majorVersion;
+ unsigned int const minorVersion;
+ unsigned int const patchNumber;
+
+ // buildNumber is only used if branchName is not null
+ std::string const branchName;
+ unsigned int const buildNumber;
+
+ friend std::ostream& operator<<(std::ostream& os, Version const& version);
+
+ private:
+ void operator=(Version const&);
+};
+
+extern Version libraryVersion;
+}
+
+#include <fstream>
+#include <limits>
+#include <stdlib.h>
+
+namespace Catch {
+
+Ptr<IStreamingReporter> createReporter(std::string const& reporterName, Ptr<Config> const& config)
+{
+ Ptr<IStreamingReporter> reporter = getRegistryHub().getReporterRegistry().create(reporterName, config.get());
+ if (!reporter)
+ {
+ std::ostringstream oss;
+ oss << "No reporter registered with name: '" << reporterName << "'";
+ throw std::domain_error(oss.str());
+ }
+ return reporter;
+}
+
+Ptr<IStreamingReporter> makeReporter(Ptr<Config> const& config)
+{
+ std::vector<std::string> reporters = config->getReporterNames();
+ if (reporters.empty())
+ reporters.push_back("console");
+
+ Ptr<IStreamingReporter> reporter;
+ for (std::vector<std::string>::const_iterator it = reporters.begin(), itEnd = reporters.end();
+ it != itEnd;
+ ++it)
+ reporter = addReporter(reporter, createReporter(*it, config));
+ return reporter;
+}
+Ptr<IStreamingReporter> addListeners(Ptr<IConfig const> const& config, Ptr<IStreamingReporter> reporters)
+{
+ IReporterRegistry::Listeners listeners = getRegistryHub().getReporterRegistry().getListeners();
+ for (IReporterRegistry::Listeners::const_iterator it = listeners.begin(), itEnd = listeners.end();
+ it != itEnd;
+ ++it)
+ reporters = addReporter(reporters, (*it)->create(ReporterConfig(config)));
+ return reporters;
+}
+
+Totals runTests(Ptr<Config> const& config)
+{
+
+ Ptr<IConfig const> iconfig = config.get();
+
+ Ptr<IStreamingReporter> reporter = makeReporter(config);
+ reporter = addListeners(iconfig, reporter);
+
+ RunContext context(iconfig, reporter);
+
+ Totals totals;
+
+ context.testGroupStarting(config->name(), 1, 1);
+
+ TestSpec testSpec = config->testSpec();
+ if (!testSpec.hasFilters())
+ testSpec = TestSpecParser(ITagAliasRegistry::get()).parse("~[.]").testSpec(); // All not hidden tests
+
+ std::vector<TestCase> const& allTestCases = getAllTestCasesSorted(*iconfig);
+ for (std::vector<TestCase>::const_iterator it = allTestCases.begin(), itEnd = allTestCases.end();
+ it != itEnd;
+ ++it)
+ {
+ if (!context.aborting() && matchTest(*it, testSpec, *iconfig))
+ totals += context.runTest(*it);
+ else
+ reporter->skipTest(*it);
+ }
+
+ context.testGroupEnded(iconfig->name(), totals, 1, 1);
+ return totals;
+}
+
+void applyFilenamesAsTags(IConfig const& config)
+{
+ std::vector<TestCase> const& tests = getAllTestCasesSorted(config);
+ for (std::size_t i = 0; i < tests.size(); ++i)
+ {
+ TestCase& test = const_cast<TestCase&>(tests[i]);
+ std::set<std::string> tags = test.tags;
+
+ std::string filename = test.lineInfo.file;
+ std::string::size_type lastSlash = filename.find_last_of("\\/");
+ if (lastSlash != std::string::npos)
+ filename = filename.substr(lastSlash + 1);
+
+ std::string::size_type lastDot = filename.find_last_of(".");
+ if (lastDot != std::string::npos)
+ filename = filename.substr(0, lastDot);
+
+ tags.insert("#" + filename);
+ setTags(test, tags);
+ }
+}
+
+class Session : NonCopyable
+{
+ static bool alreadyInstantiated;
+
+ public:
+ struct OnUnusedOptions
+ {
+ enum DoWhat
+ {
+ Ignore,
+ Fail
+ };
+ };
+
+ Session()
+ : m_cli(makeCommandLineParser())
+ {
+ if (alreadyInstantiated)
+ {
+ std::string msg = "Only one instance of Catch::Session can ever be used";
+ Catch::cerr() << msg << std::endl;
+ throw std::logic_error(msg);
+ }
+ alreadyInstantiated = true;
+ }
+ ~Session()
+ {
+ Catch::cleanUp();
+ }
+
+ void showHelp(std::string const& processName)
+ {
+ Catch::cout() << "\nCatch v" << libraryVersion << "\n";
+
+ m_cli.usage(Catch::cout(), processName);
+ Catch::cout() << "For more detail usage please see the project docs\n"
+ << std::endl;
+ }
+
+ int applyCommandLine(int argc, char const* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail)
+ {
+ try
+ {
+ m_cli.setThrowOnUnrecognisedTokens(unusedOptionBehaviour == OnUnusedOptions::Fail);
+ m_unusedTokens = m_cli.parseInto(argc, argv, m_configData);
+ if (m_configData.showHelp)
+ showHelp(m_configData.processName);
+ m_config.reset();
+ }
+ catch (std::exception& ex)
+ {
+ {
+ Colour colourGuard(Colour::Red);
+ Catch::cerr()
+ << "\nError(s) in input:\n"
+ << Text(ex.what(), TextAttributes().setIndent(2))
+ << "\n\n";
+ }
+ m_cli.usage(Catch::cout(), m_configData.processName);
+ return (std::numeric_limits<int>::max)();
+ }
+ return 0;
+ }
+
+ void useConfigData(ConfigData const& _configData)
+ {
+ m_configData = _configData;
+ m_config.reset();
+ }
+
+ int run(int argc, char const* const argv[])
+ {
+
+ int returnCode = applyCommandLine(argc, argv);
+ if (returnCode == 0)
+ returnCode = run();
+ return returnCode;
+ }
+
+ int run()
+ {
+ if (m_configData.showHelp)
+ return 0;
+
+ try
+ {
+ config(); // Force config to be constructed
+
+ seedRng(*m_config);
+
+ if (m_configData.filenamesAsTags)
+ applyFilenamesAsTags(*m_config);
+
+ // Handle list request
+ if (Option<std::size_t> listed = list(config()))
+ return static_cast<int>(*listed);
+
+ return static_cast<int>(runTests(m_config).assertions.failed);
+ }
+ catch (std::exception& ex)
+ {
+ Catch::cerr() << ex.what() << std::endl;
+ return (std::numeric_limits<int>::max)();
+ }
+ }
+
+ Clara::CommandLine<ConfigData> const& cli() const
+ {
+ return m_cli;
+ }
+ std::vector<Clara::Parser::Token> const& unusedTokens() const
+ {
+ return m_unusedTokens;
+ }
+ ConfigData& configData()
+ {
+ return m_configData;
+ }
+ Config& config()
+ {
+ if (!m_config)
+ m_config = new Config(m_configData);
+ return *m_config;
+ }
+
+ private:
+ Clara::CommandLine<ConfigData> m_cli;
+ std::vector<Clara::Parser::Token> m_unusedTokens;
+ ConfigData m_configData;
+ Ptr<Config> m_config;
+};
+
+bool Session::alreadyInstantiated = false;
+
+} // end namespace Catch
+
+// #included from: catch_registry_hub.hpp
+#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED
+
+// #included from: catch_test_case_registry_impl.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+
+#include <algorithm>
+#include <iostream>
+#include <set>
+#include <sstream>
+#include <vector>
+
+namespace Catch {
+
+struct LexSort
+{
+ bool operator()(TestCase i, TestCase j) const { return (i < j); }
+};
+struct RandomNumberGenerator
+{
+ int operator()(int n) const { return std::rand() % n; }
+};
+
+inline std::vector<TestCase> sortTests(IConfig const& config, std::vector<TestCase> const& unsortedTestCases)
+{
+
+ std::vector<TestCase> sorted = unsortedTestCases;
+
+ switch (config.runOrder())
+ {
+ case RunTests::InLexicographicalOrder:
+ std::sort(sorted.begin(), sorted.end(), LexSort());
+ break;
+ case RunTests::InRandomOrder:
+ {
+ seedRng(config);
+
+ RandomNumberGenerator rng;
+ std::random_shuffle(sorted.begin(), sorted.end(), rng);
+ }
+ break;
+ case RunTests::InDeclarationOrder:
+ // already in declaration order
+ break;
+ }
+ return sorted;
+}
+bool matchTest(TestCase const& testCase, TestSpec const& testSpec, IConfig const& config)
+{
+ return testSpec.matches(testCase) && (config.allowThrows() || !testCase.throws());
+}
+
+void enforceNoDuplicateTestCases(std::vector<TestCase> const& functions)
+{
+ std::set<TestCase> seenFunctions;
+ for (std::vector<TestCase>::const_iterator it = functions.begin(), itEnd = functions.end();
+ it != itEnd;
+ ++it)
+ {
+ std::pair<std::set<TestCase>::const_iterator, bool> prev = seenFunctions.insert(*it);
+ if (!prev.second)
+ {
+ Catch::cerr()
+ << Colour(Colour::Red)
+ << "error: TEST_CASE( \"" << it->name << "\" ) already defined.\n"
+ << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
+ << "\tRedefined at " << it->getTestCaseInfo().lineInfo << std::endl;
+ exit(1);
+ }
+ }
+}
+
+std::vector<TestCase> filterTests(std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config)
+{
+ std::vector<TestCase> filtered;
+ filtered.reserve(testCases.size());
+ for (std::vector<TestCase>::const_iterator it = testCases.begin(), itEnd = testCases.end();
+ it != itEnd;
+ ++it)
+ if (matchTest(*it, testSpec, config))
+ filtered.push_back(*it);
+ return filtered;
+}
+std::vector<TestCase> const& getAllTestCasesSorted(IConfig const& config)
+{
+ return getRegistryHub().getTestCaseRegistry().getAllTestsSorted(config);
+}
+
+class TestRegistry : public ITestCaseRegistry
+{
+ public:
+ TestRegistry()
+ : m_currentSortOrder(RunTests::InDeclarationOrder),
+ m_unnamedCount(0)
+ {
+ }
+ virtual ~TestRegistry();
+
+ virtual void registerTest(TestCase const& testCase)
+ {
+ std::string name = testCase.getTestCaseInfo().name;
+ if (name == "")
+ {
+ std::ostringstream oss;
+ oss << "Anonymous test case " << ++m_unnamedCount;
+ return registerTest(testCase.withName(oss.str()));
+ }
+ m_functions.push_back(testCase);
+ }
+
+ virtual std::vector<TestCase> const& getAllTests() const
+ {
+ return m_functions;
+ }
+ virtual std::vector<TestCase> const& getAllTestsSorted(IConfig const& config) const
+ {
+ if (m_sortedFunctions.empty())
+ enforceNoDuplicateTestCases(m_functions);
+
+ if (m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty())
+ {
+ m_sortedFunctions = sortTests(config, m_functions);
+ m_currentSortOrder = config.runOrder();
+ }
+ return m_sortedFunctions;
+ }
+
+ private:
+ std::vector<TestCase> m_functions;
+ mutable RunTests::InWhatOrder m_currentSortOrder;
+ mutable std::vector<TestCase> m_sortedFunctions;
+ size_t m_unnamedCount;
+ std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
+};
+
+///////////////////////////////////////////////////////////////////////////
+
+class FreeFunctionTestCase : public SharedImpl<ITestCase>
+{
+ public:
+ FreeFunctionTestCase(TestFunction fun) : m_fun(fun) {}
+
+ virtual void invoke() const
+ {
+ m_fun();
+ }
+
+ private:
+ virtual ~FreeFunctionTestCase();
+
+ TestFunction m_fun;
+};
+
+inline std::string extractClassName(std::string const& classOrQualifiedMethodName)
+{
+ std::string className = classOrQualifiedMethodName;
+ if (startsWith(className, "&"))
+ {
+ std::size_t lastColons = className.rfind("::");
+ std::size_t penultimateColons = className.rfind("::", lastColons - 1);
+ if (penultimateColons == std::string::npos)
+ penultimateColons = 1;
+ className = className.substr(penultimateColons, lastColons - penultimateColons);
+ }
+ return className;
+}
+
+void registerTestCase(ITestCase* testCase,
+ char const* classOrQualifiedMethodName,
+ NameAndDesc const& nameAndDesc,
+ SourceLineInfo const& lineInfo)
+{
+
+ getMutableRegistryHub().registerTest(makeTestCase(testCase,
+ extractClassName(classOrQualifiedMethodName),
+ nameAndDesc.name,
+ nameAndDesc.description,
+ lineInfo));
+}
+void registerTestCaseFunction(TestFunction function,
+ SourceLineInfo const& lineInfo,
+ NameAndDesc const& nameAndDesc)
+{
+ registerTestCase(new FreeFunctionTestCase(function), "", nameAndDesc, lineInfo);
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+AutoReg::AutoReg(TestFunction function,
+ SourceLineInfo const& lineInfo,
+ NameAndDesc const& nameAndDesc)
+{
+ registerTestCaseFunction(function, lineInfo, nameAndDesc);
+}
+
+AutoReg::~AutoReg() {}
+
+} // end namespace Catch
+
+// #included from: catch_reporter_registry.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+
+#include <map>
+
+namespace Catch {
+
+class ReporterRegistry : public IReporterRegistry
+{
+
+ public:
+ virtual ~ReporterRegistry() CATCH_OVERRIDE {}
+
+ virtual IStreamingReporter* create(std::string const& name, Ptr<IConfig const> const& config) const CATCH_OVERRIDE
+ {
+ FactoryMap::const_iterator it = m_factories.find(name);
+ if (it == m_factories.end())
+ return CATCH_NULL;
+ return it->second->create(ReporterConfig(config));
+ }
+
+ void registerReporter(std::string const& name, Ptr<IReporterFactory> const& factory)
+ {
+ m_factories.insert(std::make_pair(name, factory));
+ }
+ void registerListener(Ptr<IReporterFactory> const& factory)
+ {
+ m_listeners.push_back(factory);
+ }
+
+ virtual FactoryMap const& getFactories() const CATCH_OVERRIDE
+ {
+ return m_factories;
+ }
+ virtual Listeners const& getListeners() const CATCH_OVERRIDE
+ {
+ return m_listeners;
+ }
+
+ private:
+ FactoryMap m_factories;
+ Listeners m_listeners;
+};
+}
+
+// #included from: catch_exception_translator_registry.hpp
+#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+
+#ifdef __OBJC__
+#import "Foundation/Foundation.h"
+#endif
+
+namespace Catch {
+
+class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry
+{
+ public:
+ ~ExceptionTranslatorRegistry()
+ {
+ deleteAll(m_translators);
+ }
+
+ virtual void registerTranslator(const IExceptionTranslator* translator)
+ {
+ m_translators.push_back(translator);
+ }
+
+ virtual std::string translateActiveException() const
+ {
+ try
+ {
+#ifdef __OBJC__
+ // In Objective-C try objective-c exceptions first
+ @try
+ {
+ return tryTranslators();
+ }
+ @catch (NSException* exception)
+ {
+ return Catch::toString([exception description]);
+ }
+#else
+ return tryTranslators();
+#endif
+ }
+ catch (TestFailureException&)
+ {
+ throw;
+ }
+ catch (std::exception& ex)
+ {
+ return ex.what();
+ }
+ catch (std::string& msg)
+ {
+ return msg;
+ }
+ catch (const char* msg)
+ {
+ return msg;
+ }
+ catch (...)
+ {
+ return "Unknown exception";
+ }
+ }
+
+ std::string tryTranslators() const
+ {
+ if (m_translators.empty())
+ throw;
+ else
+ return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
+ }
+
+ private:
+ std::vector<const IExceptionTranslator*> m_translators;
+};
+}
+
+namespace Catch {
+
+namespace {
+
+class RegistryHub : public IRegistryHub, public IMutableRegistryHub
+{
+
+ RegistryHub(RegistryHub const&);
+ void operator=(RegistryHub const&);
+
+ public: // IRegistryHub
+ RegistryHub()
+ {
+ }
+ virtual IReporterRegistry const& getReporterRegistry() const CATCH_OVERRIDE
+ {
+ return m_reporterRegistry;
+ }
+ virtual ITestCaseRegistry const& getTestCaseRegistry() const CATCH_OVERRIDE
+ {
+ return m_testCaseRegistry;
+ }
+ virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() CATCH_OVERRIDE
+ {
+ return m_exceptionTranslatorRegistry;
+ }
+
+ public: // IMutableRegistryHub
+ virtual void registerReporter(std::string const& name, Ptr<IReporterFactory> const& factory) CATCH_OVERRIDE
+ {
+ m_reporterRegistry.registerReporter(name, factory);
+ }
+ virtual void registerListener(Ptr<IReporterFactory> const& factory) CATCH_OVERRIDE
+ {
+ m_reporterRegistry.registerListener(factory);
+ }
+ virtual void registerTest(TestCase const& testInfo) CATCH_OVERRIDE
+ {
+ m_testCaseRegistry.registerTest(testInfo);
+ }
+ virtual void registerTranslator(const IExceptionTranslator* translator) CATCH_OVERRIDE
+ {
+ m_exceptionTranslatorRegistry.registerTranslator(translator);
+ }
+
+ private:
+ TestRegistry m_testCaseRegistry;
+ ReporterRegistry m_reporterRegistry;
+ ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+};
+
+// Single, global, instance
+inline RegistryHub*& getTheRegistryHub()
+{
+ static RegistryHub* theRegistryHub = CATCH_NULL;
+ if (!theRegistryHub)
+ theRegistryHub = new RegistryHub();
+ return theRegistryHub;
+}
+}
+
+IRegistryHub& getRegistryHub()
+{
+ return *getTheRegistryHub();
+}
+IMutableRegistryHub& getMutableRegistryHub()
+{
+ return *getTheRegistryHub();
+}
+void cleanUp()
+{
+ delete getTheRegistryHub();
+ getTheRegistryHub() = CATCH_NULL;
+ cleanUpContext();
+}
+std::string translateActiveException()
+{
+ return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+}
+
+} // end namespace Catch
+
+// #included from: catch_notimplemented_exception.hpp
+#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED
+
+#include <ostream>
+
+namespace Catch {
+
+NotImplementedException::NotImplementedException(SourceLineInfo const& lineInfo)
+ : m_lineInfo(lineInfo)
+{
+ std::ostringstream oss;
+ oss << lineInfo << ": function ";
+ oss << "not implemented";
+ m_what = oss.str();
+}
+
+const char* NotImplementedException::what() const CATCH_NOEXCEPT
+{
+ return m_what.c_str();
+}
+
+} // end namespace Catch
+
+// #included from: catch_context_impl.hpp
+#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED
+
+// #included from: catch_stream.hpp
+#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED
+
+#include <cstdio>
+#include <iostream>
+#include <stdexcept>
+
+namespace Catch {
+
+template <typename WriterF, size_t bufferSize = 256>
+class StreamBufImpl : public StreamBufBase
+{
+ char data[bufferSize];
+ WriterF m_writer;
+
+ public:
+ StreamBufImpl()
+ {
+ setp(data, data + sizeof(data));
+ }
+
+ ~StreamBufImpl() CATCH_NOEXCEPT
+ {
+ sync();
+ }
+
+ private:
+ int overflow(int c)
+ {
+ sync();
+
+ if (c != EOF)
+ {
+ if (pbase() == epptr())
+ m_writer(std::string(1, static_cast<char>(c)));
+ else
+ sputc(static_cast<char>(c));
+ }
+ return 0;
+ }
+
+ int sync()
+ {
+ if (pbase() != pptr())
+ {
+ m_writer(std::string(pbase(), static_cast<std::string::size_type>(pptr() - pbase())));
+ setp(pbase(), epptr());
+ }
+ return 0;
+ }
+};
+
+///////////////////////////////////////////////////////////////////////////
+
+FileStream::FileStream(std::string const& filename)
+{
+ m_ofs.open(filename.c_str());
+ if (m_ofs.fail())
+ {
+ std::ostringstream oss;
+ oss << "Unable to open file: '" << filename << "'";
+ throw std::domain_error(oss.str());
+ }
+}
+
+std::ostream& FileStream::stream() const
+{
+ return m_ofs;
+}
+
+struct OutputDebugWriter
+{
+
+ void operator()(std::string const& str)
+ {
+ writeToDebugConsole(str);
+ }
+};
+
+DebugOutStream::DebugOutStream()
+ : m_streamBuf(new StreamBufImpl<OutputDebugWriter>()),
+ m_os(m_streamBuf.get())
+{
+}
+
+std::ostream& DebugOutStream::stream() const
+{
+ return m_os;
+}
+
+// Store the streambuf from cout up-front because
+// cout may get redirected when running tests
+CoutStream::CoutStream()
+ : m_os(Catch::cout().rdbuf())
+{
+}
+
+std::ostream& CoutStream::stream() const
+{
+ return m_os;
+}
+
+#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
+std::ostream& cout()
+{
+ return std::cout;
+}
+std::ostream& cerr()
+{
+ return std::cerr;
+}
+#endif
+}
+
+namespace Catch {
+
+class Context : public IMutableContext
+{
+
+ Context() : m_config(CATCH_NULL), m_runner(CATCH_NULL), m_resultCapture(CATCH_NULL) {}
+ Context(Context const&);
+ void operator=(Context const&);
+
+ public: // IContext
+ virtual IResultCapture* getResultCapture()
+ {
+ return m_resultCapture;
+ }
+ virtual IRunner* getRunner()
+ {
+ return m_runner;
+ }
+ virtual size_t getGeneratorIndex(std::string const& fileInfo, size_t totalSize)
+ {
+ return getGeneratorsForCurrentTest()
+ .getGeneratorInfo(fileInfo, totalSize)
+ .getCurrentIndex();
+ }
+ virtual bool advanceGeneratorsForCurrentTest()
+ {
+ IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
+ return generators && generators->moveNext();
+ }
+
+ virtual Ptr<IConfig const> getConfig() const
+ {
+ return m_config;
+ }
+
+ public: // IMutableContext
+ virtual void setResultCapture(IResultCapture* resultCapture)
+ {
+ m_resultCapture = resultCapture;
+ }
+ virtual void setRunner(IRunner* runner)
+ {
+ m_runner = runner;
+ }
+ virtual void setConfig(Ptr<IConfig const> const& config)
+ {
+ m_config = config;
+ }
+
+ friend IMutableContext& getCurrentMutableContext();
+
+ private:
+ IGeneratorsForTest* findGeneratorsForCurrentTest()
+ {
+ std::string testName = getResultCapture()->getCurrentTestName();
+
+ std::map<std::string, IGeneratorsForTest*>::const_iterator it =
+ m_generatorsByTestName.find(testName);
+ return it != m_generatorsByTestName.end()
+ ? it->second
+ : CATCH_NULL;
+ }
+
+ IGeneratorsForTest& getGeneratorsForCurrentTest()
+ {
+ IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
+ if (!generators)
+ {
+ std::string testName = getResultCapture()->getCurrentTestName();
+ generators = createGeneratorsForTest();
+ m_generatorsByTestName.insert(std::make_pair(testName, generators));
+ }
+ return *generators;
+ }
+
+ private:
+ Ptr<IConfig const> m_config;
+ IRunner* m_runner;
+ IResultCapture* m_resultCapture;
+ std::map<std::string, IGeneratorsForTest*> m_generatorsByTestName;
+};
+
+namespace {
+Context* currentContext = CATCH_NULL;
+}
+IMutableContext& getCurrentMutableContext()
+{
+ if (!currentContext)
+ currentContext = new Context();
+ return *currentContext;
+}
+IContext& getCurrentContext()
+{
+ return getCurrentMutableContext();
+}
+
+void cleanUpContext()
+{
+ delete currentContext;
+ currentContext = CATCH_NULL;
+}
+}
+
+// #included from: catch_console_colour_impl.hpp
+#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED
+
+namespace Catch {
+namespace {
+
+struct IColourImpl
+{
+ virtual ~IColourImpl() {}
+ virtual void use(Colour::Code _colourCode) = 0;
+};
+
+struct NoColourImpl : IColourImpl
+{
+ void use(Colour::Code) {}
+
+ static IColourImpl* instance()
+ {
+ static NoColourImpl s_instance;
+ return &s_instance;
+ }
+};
+
+} // anon namespace
+} // namespace Catch
+
+#if !defined(CATCH_CONFIG_COLOUR_NONE) && !defined(CATCH_CONFIG_COLOUR_WINDOWS) && !defined(CATCH_CONFIG_COLOUR_ANSI)
+#ifdef CATCH_PLATFORM_WINDOWS
+#define CATCH_CONFIG_COLOUR_WINDOWS
+#else
+#define CATCH_CONFIG_COLOUR_ANSI
+#endif
+#endif
+
+#if defined(CATCH_CONFIG_COLOUR_WINDOWS) /////////////////////////////////////////
+
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
+#ifdef __AFXDLL
+#include <AfxWin.h>
+#else
+#include <windows.h>
+#endif
+
+namespace Catch {
+namespace {
+
+class Win32ColourImpl : public IColourImpl
+{
+ public:
+ Win32ColourImpl() : stdoutHandle(GetStdHandle(STD_OUTPUT_HANDLE))
+ {
+ CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+ GetConsoleScreenBufferInfo(stdoutHandle, &csbiInfo);
+ originalForegroundAttributes = csbiInfo.wAttributes & ~(BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY);
+ originalBackgroundAttributes = csbiInfo.wAttributes & ~(FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY);
+ }
+
+ virtual void use(Colour::Code _colourCode)
+ {
+ switch (_colourCode)
+ {
+ case Colour::None:
+ return setTextAttribute(originalForegroundAttributes);
+ case Colour::White:
+ return setTextAttribute(FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE);
+ case Colour::Red:
+ return setTextAttribute(FOREGROUND_RED);
+ case Colour::Green:
+ return setTextAttribute(FOREGROUND_GREEN);
+ case Colour::Blue:
+ return setTextAttribute(FOREGROUND_BLUE);
+ case Colour::Cyan:
+ return setTextAttribute(FOREGROUND_BLUE | FOREGROUND_GREEN);
+ case Colour::Yellow:
+ return setTextAttribute(FOREGROUND_RED | FOREGROUND_GREEN);
+ case Colour::Grey:
+ return setTextAttribute(0);
+
+ case Colour::LightGrey:
+ return setTextAttribute(FOREGROUND_INTENSITY);
+ case Colour::BrightRed:
+ return setTextAttribute(FOREGROUND_INTENSITY | FOREGROUND_RED);
+ case Colour::BrightGreen:
+ return setTextAttribute(FOREGROUND_INTENSITY | FOREGROUND_GREEN);
+ case Colour::BrightWhite:
+ return setTextAttribute(FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE);
+
+ case Colour::Bright:
+ throw std::logic_error("not a colour");
+ }
+ }
+
+ private:
+ void setTextAttribute(WORD _textAttribute)
+ {
+ SetConsoleTextAttribute(stdoutHandle, _textAttribute | originalBackgroundAttributes);
+ }
+ HANDLE stdoutHandle;
+ WORD originalForegroundAttributes;
+ WORD originalBackgroundAttributes;
+};
+
+IColourImpl* platformColourInstance()
+{
+ static Win32ColourImpl s_instance;
+ return &s_instance;
+}
+
+} // end anon namespace
+} // end namespace Catch
+
+#elif defined(CATCH_CONFIG_COLOUR_ANSI) //////////////////////////////////////
+
+#include <unistd.h>
+
+namespace Catch {
+namespace {
+
+// use POSIX/ ANSI console terminal codes
+// Thanks to Adam Strzelecki for original contribution
+// (http://github.com/nanoant)
+// https://github.com/philsquared/Catch/pull/131
+class PosixColourImpl : public IColourImpl
+{
+ public:
+ virtual void use(Colour::Code _colourCode)
+ {
+ switch (_colourCode)
+ {
+ case Colour::None:
+ case Colour::White:
+ return setColour("[0m");
+ case Colour::Red:
+ return setColour("[0;31m");
+ case Colour::Green:
+ return setColour("[0;32m");
+ case Colour::Blue:
+ return setColour("[0:34m");
+ case Colour::Cyan:
+ return setColour("[0;36m");
+ case Colour::Yellow:
+ return setColour("[0;33m");
+ case Colour::Grey:
+ return setColour("[1;30m");
+
+ case Colour::LightGrey:
+ return setColour("[0;37m");
+ case Colour::BrightRed:
+ return setColour("[1;31m");
+ case Colour::BrightGreen:
+ return setColour("[1;32m");
+ case Colour::BrightWhite:
+ return setColour("[1;37m");
+
+ case Colour::Bright:
+ throw std::logic_error("not a colour");
+ }
+ }
+ static IColourImpl* instance()
+ {
+ static PosixColourImpl s_instance;
+ return &s_instance;
+ }
+
+ private:
+ void setColour(const char* _escapeCode)
+ {
+ Catch::cout() << '\033' << _escapeCode;
+ }
+};
+
+IColourImpl* platformColourInstance()
+{
+ Ptr<IConfig const> config = getCurrentContext().getConfig();
+ return (config && config->forceColour()) || isatty(STDOUT_FILENO)
+ ? PosixColourImpl::instance()
+ : NoColourImpl::instance();
+}
+
+} // end anon namespace
+} // end namespace Catch
+
+#else // not Windows or ANSI ///////////////////////////////////////////////
+
+namespace Catch {
+
+static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); }
+
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+namespace Catch {
+
+Colour::Colour(Code _colourCode) : m_moved(false) { use(_colourCode); }
+Colour::Colour(Colour const& _other) : m_moved(false) { const_cast<Colour&>(_other).m_moved = true; }
+Colour::~Colour()
+{
+ if (!m_moved) use(None);
+}
+
+void Colour::use(Code _colourCode)
+{
+ static IColourImpl* impl = isDebuggerActive()
+ ? NoColourImpl::instance()
+ : platformColourInstance();
+ impl->use(_colourCode);
+}
+
+} // end namespace Catch
+
+// #included from: catch_generators_impl.hpp
+#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+struct GeneratorInfo : IGeneratorInfo
+{
+
+ GeneratorInfo(std::size_t size)
+ : m_size(size),
+ m_currentIndex(0)
+ {
+ }
+
+ bool moveNext()
+ {
+ if (++m_currentIndex == m_size)
+ {
+ m_currentIndex = 0;
+ return false;
+ }
+ return true;
+ }
+
+ std::size_t getCurrentIndex() const
+ {
+ return m_currentIndex;
+ }
+
+ std::size_t m_size;
+ std::size_t m_currentIndex;
+};
+
+///////////////////////////////////////////////////////////////////////////
+
+class GeneratorsForTest : public IGeneratorsForTest
+{
+
+ public:
+ ~GeneratorsForTest()
+ {
+ deleteAll(m_generatorsInOrder);
+ }
+
+ IGeneratorInfo& getGeneratorInfo(std::string const& fileInfo, std::size_t size)
+ {
+ std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find(fileInfo);
+ if (it == m_generatorsByName.end())
+ {
+ IGeneratorInfo* info = new GeneratorInfo(size);
+ m_generatorsByName.insert(std::make_pair(fileInfo, info));
+ m_generatorsInOrder.push_back(info);
+ return *info;
+ }
+ return *it->second;
+ }
+
+ bool moveNext()
+ {
+ std::vector<IGeneratorInfo*>::const_iterator it = m_generatorsInOrder.begin();
+ std::vector<IGeneratorInfo*>::const_iterator itEnd = m_generatorsInOrder.end();
+ for (; it != itEnd; ++it)
+ {
+ if ((*it)->moveNext())
+ return true;
+ }
+ return false;
+ }
+
+ private:
+ std::map<std::string, IGeneratorInfo*> m_generatorsByName;
+ std::vector<IGeneratorInfo*> m_generatorsInOrder;
+};
+
+IGeneratorsForTest* createGeneratorsForTest()
+{
+ return new GeneratorsForTest();
+}
+
+} // end namespace Catch
+
+// #included from: catch_assertionresult.hpp
+#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED
+
+namespace Catch {
+
+AssertionInfo::AssertionInfo(std::string const& _macroName,
+ SourceLineInfo const& _lineInfo,
+ std::string const& _capturedExpression,
+ ResultDisposition::Flags _resultDisposition)
+ : macroName(_macroName),
+ lineInfo(_lineInfo),
+ capturedExpression(_capturedExpression),
+ resultDisposition(_resultDisposition)
+{
+}
+
+AssertionResult::AssertionResult() {}
+
+AssertionResult::AssertionResult(AssertionInfo const& info, AssertionResultData const& data)
+ : m_info(info),
+ m_resultData(data)
+{
+}
+
+AssertionResult::~AssertionResult() {}
+
+// Result was a success
+bool AssertionResult::succeeded() const
+{
+ return Catch::isOk(m_resultData.resultType);
+}
+
+// Result was a success, or failure is suppressed
+bool AssertionResult::isOk() const
+{
+ return Catch::isOk(m_resultData.resultType) || shouldSuppressFailure(m_info.resultDisposition);
+}
+
+ResultWas::OfType AssertionResult::getResultType() const
+{
+ return m_resultData.resultType;
+}
+
+bool AssertionResult::hasExpression() const
+{
+ return !m_info.capturedExpression.empty();
+}
+
+bool AssertionResult::hasMessage() const
+{
+ return !m_resultData.message.empty();
+}
+
+std::string AssertionResult::getExpression() const
+{
+ if (isFalseTest(m_info.resultDisposition))
+ return "!" + m_info.capturedExpression;
+ else
+ return m_info.capturedExpression;
+}
+std::string AssertionResult::getExpressionInMacro() const
+{
+ if (m_info.macroName.empty())
+ return m_info.capturedExpression;
+ else
+ return m_info.macroName + "( " + m_info.capturedExpression + " )";
+}
+
+bool AssertionResult::hasExpandedExpression() const
+{
+ return hasExpression() && getExpandedExpression() != getExpression();
+}
+
+std::string AssertionResult::getExpandedExpression() const
+{
+ return m_resultData.reconstructedExpression;
+}
+
+std::string AssertionResult::getMessage() const
+{
+ return m_resultData.message;
+}
+SourceLineInfo AssertionResult::getSourceInfo() const
+{
+ return m_info.lineInfo;
+}
+
+std::string AssertionResult::getTestMacroName() const
+{
+ return m_info.macroName;
+}
+
+} // end namespace Catch
+
+// #included from: catch_test_case_info.hpp
+#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED
+
+namespace Catch {
+
+inline TestCaseInfo::SpecialProperties parseSpecialTag(std::string const& tag)
+{
+ if (startsWith(tag, ".") ||
+ tag == "hide" ||
+ tag == "!hide")
+ return TestCaseInfo::IsHidden;
+ else if (tag == "!throws")
+ return TestCaseInfo::Throws;
+ else if (tag == "!shouldfail")
+ return TestCaseInfo::ShouldFail;
+ else if (tag == "!mayfail")
+ return TestCaseInfo::MayFail;
+ else
+ return TestCaseInfo::None;
+}
+inline bool isReservedTag(std::string const& tag)
+{
+ return parseSpecialTag(tag) == TestCaseInfo::None && tag.size() > 0 && !isalnum(tag[0]);
+}
+inline void enforceNotReservedTag(std::string const& tag, SourceLineInfo const& _lineInfo)
+{
+ if (isReservedTag(tag))
+ {
+ {
+ Colour colourGuard(Colour::Red);
+ Catch::cerr()
+ << "Tag name [" << tag << "] not allowed.\n"
+ << "Tag names starting with non alpha-numeric characters are reserved\n";
+ }
+ {
+ Colour colourGuard(Colour::FileName);
+ Catch::cerr() << _lineInfo << std::endl;
+ }
+ exit(1);
+ }
+}
+
+TestCase makeTestCase(ITestCase* _testCase,
+ std::string const& _className,
+ std::string const& _name,
+ std::string const& _descOrTags,
+ SourceLineInfo const& _lineInfo)
+{
+ bool isHidden(startsWith(_name, "./")); // Legacy support
+
+ // Parse out tags
+ std::set<std::string> tags;
+ std::string desc, tag;
+ bool inTag = false;
+ for (std::size_t i = 0; i < _descOrTags.size(); ++i)
+ {
+ char c = _descOrTags[i];
+ if (!inTag)
+ {
+ if (c == '[')
+ inTag = true;
+ else
+ desc += c;
+ }
+ else
+ {
+ if (c == ']')
+ {
+ TestCaseInfo::SpecialProperties prop = parseSpecialTag(tag);
+ if (prop == TestCaseInfo::IsHidden)
+ isHidden = true;
+ else if (prop == TestCaseInfo::None)
+ enforceNotReservedTag(tag, _lineInfo);
+
+ tags.insert(tag);
+ tag.clear();
+ inTag = false;
+ }
+ else
+ tag += c;
+ }
+ }
+ if (isHidden)
+ {
+ tags.insert("hide");
+ tags.insert(".");
+ }
+
+ TestCaseInfo info(_name, _className, desc, tags, _lineInfo);
+ return TestCase(_testCase, info);
+}
+
+void setTags(TestCaseInfo& testCaseInfo, std::set<std::string> const& tags)
+{
+ testCaseInfo.tags = tags;
+ testCaseInfo.lcaseTags.clear();
+
+ std::ostringstream oss;
+ for (std::set<std::string>::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it)
+ {
+ oss << "[" << *it << "]";
+ std::string lcaseTag = toLower(*it);
+ testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>(testCaseInfo.properties | parseSpecialTag(lcaseTag));
+ testCaseInfo.lcaseTags.insert(lcaseTag);
+ }
+ testCaseInfo.tagsAsString = oss.str();
+}
+
+TestCaseInfo::TestCaseInfo(std::string const& _name,
+ std::string const& _className,
+ std::string const& _description,
+ std::set<std::string> const& _tags,
+ SourceLineInfo const& _lineInfo)
+ : name(_name),
+ className(_className),
+ description(_description),
+ lineInfo(_lineInfo),
+ properties(None)
+{
+ setTags(*this, _tags);
+}
+
+TestCaseInfo::TestCaseInfo(TestCaseInfo const& other)
+ : name(other.name),
+ className(other.className),
+ description(other.description),
+ tags(other.tags),
+ lcaseTags(other.lcaseTags),
+ tagsAsString(other.tagsAsString),
+ lineInfo(other.lineInfo),
+ properties(other.properties)
+{
+}
+
+bool TestCaseInfo::isHidden() const
+{
+ return (properties & IsHidden) != 0;
+}
+bool TestCaseInfo::throws() const
+{
+ return (properties & Throws) != 0;
+}
+bool TestCaseInfo::okToFail() const
+{
+ return (properties & (ShouldFail | MayFail)) != 0;
+}
+bool TestCaseInfo::expectedToFail() const
+{
+ return (properties & (ShouldFail)) != 0;
+}
+
+TestCase::TestCase(ITestCase* testCase, TestCaseInfo const& info) : TestCaseInfo(info), test(testCase) {}
+
+TestCase::TestCase(TestCase const& other)
+ : TestCaseInfo(other),
+ test(other.test)
+{
+}
+
+TestCase TestCase::withName(std::string const& _newName) const
+{
+ TestCase other(*this);
+ other.name = _newName;
+ return other;
+}
+
+void TestCase::swap(TestCase& other)
+{
+ test.swap(other.test);
+ name.swap(other.name);
+ className.swap(other.className);
+ description.swap(other.description);
+ tags.swap(other.tags);
+ lcaseTags.swap(other.lcaseTags);
+ tagsAsString.swap(other.tagsAsString);
+ std::swap(TestCaseInfo::properties, static_cast<TestCaseInfo&>(other).properties);
+ std::swap(lineInfo, other.lineInfo);
+}
+
+void TestCase::invoke() const
+{
+ test->invoke();
+}
+
+bool TestCase::operator==(TestCase const& other) const
+{
+ return test.get() == other.test.get() &&
+ name == other.name &&
+ className == other.className;
+}
+
+bool TestCase::operator<(TestCase const& other) const
+{
+ return name < other.name;
+}
+TestCase& TestCase::operator=(TestCase const& other)
+{
+ TestCase temp(other);
+ swap(temp);
+ return *this;
+}
+
+TestCaseInfo const& TestCase::getTestCaseInfo() const
+{
+ return *this;
+}
+
+} // end namespace Catch
+
+// #included from: catch_version.hpp
+#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED
+
+namespace Catch {
+
+Version::Version(unsigned int _majorVersion,
+ unsigned int _minorVersion,
+ unsigned int _patchNumber,
+ std::string const& _branchName,
+ unsigned int _buildNumber)
+ : majorVersion(_majorVersion),
+ minorVersion(_minorVersion),
+ patchNumber(_patchNumber),
+ branchName(_branchName),
+ buildNumber(_buildNumber)
+{
+}
+
+std::ostream& operator<<(std::ostream& os, Version const& version)
+{
+ os << version.majorVersion << "."
+ << version.minorVersion << "."
+ << version.patchNumber;
+
+ if (!version.branchName.empty())
+ {
+ os << "-" << version.branchName
+ << "." << version.buildNumber;
+ }
+ return os;
+}
+
+Version libraryVersion(1, 3, 2, "", 0);
+}
+
+// #included from: catch_message.hpp
+#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED
+
+namespace Catch {
+
+MessageInfo::MessageInfo(std::string const& _macroName,
+ SourceLineInfo const& _lineInfo,
+ ResultWas::OfType _type)
+ : macroName(_macroName),
+ lineInfo(_lineInfo),
+ type(_type),
+ sequence(++globalCount)
+{
+}
+
+// This may need protecting if threading support is added
+unsigned int MessageInfo::globalCount = 0;
+
+////////////////////////////////////////////////////////////////////////////
+
+ScopedMessage::ScopedMessage(MessageBuilder const& builder)
+ : m_info(builder.m_info)
+{
+ m_info.message = builder.m_stream.str();
+ getResultCapture().pushScopedMessage(m_info);
+}
+ScopedMessage::ScopedMessage(ScopedMessage const& other)
+ : m_info(other.m_info)
+{
+}
+
+ScopedMessage::~ScopedMessage()
+{
+ getResultCapture().popScopedMessage(m_info);
+}
+
+} // end namespace Catch
+
+// #included from: catch_legacy_reporter_adapter.hpp
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED
+
+// #included from: catch_legacy_reporter_adapter.h
+#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED
+
+namespace Catch {
+// Deprecated
+struct IReporter : IShared
+{
+ virtual ~IReporter();
+
+ virtual bool shouldRedirectStdout() const = 0;
+
+ virtual void StartTesting() = 0;
+ virtual void EndTesting(Totals const& totals) = 0;
+ virtual void StartGroup(std::string const& groupName) = 0;
+ virtual void EndGroup(std::string const& groupName, Totals const& totals) = 0;
+ virtual void StartTestCase(TestCaseInfo const& testInfo) = 0;
+ virtual void EndTestCase(TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr) = 0;
+ virtual void StartSection(std::string const& sectionName, std::string const& description) = 0;
+ virtual void EndSection(std::string const& sectionName, Counts const& assertions) = 0;
+ virtual void NoAssertionsInSection(std::string const& sectionName) = 0;
+ virtual void NoAssertionsInTestCase(std::string const& testName) = 0;
+ virtual void Aborted() = 0;
+ virtual void Result(AssertionResult const& result) = 0;
+};
+
+class LegacyReporterAdapter : public SharedImpl<IStreamingReporter>
+{
+ public:
+ LegacyReporterAdapter(Ptr<IReporter> const& legacyReporter);
+ virtual ~LegacyReporterAdapter();
+
+ virtual ReporterPreferences getPreferences() const;
+ virtual void noMatchingTestCases(std::string const&);
+ virtual void testRunStarting(TestRunInfo const&);
+ virtual void testGroupStarting(GroupInfo const& groupInfo);
+ virtual void testCaseStarting(TestCaseInfo const& testInfo);
+ virtual void sectionStarting(SectionInfo const& sectionInfo);
+ virtual void assertionStarting(AssertionInfo const&);
+ virtual bool assertionEnded(AssertionStats const& assertionStats);
+ virtual void sectionEnded(SectionStats const& sectionStats);
+ virtual void testCaseEnded(TestCaseStats const& testCaseStats);
+ virtual void testGroupEnded(TestGroupStats const& testGroupStats);
+ virtual void testRunEnded(TestRunStats const& testRunStats);
+ virtual void skipTest(TestCaseInfo const&);
+
+ private:
+ Ptr<IReporter> m_legacyReporter;
+};
+}
+
+namespace Catch {
+LegacyReporterAdapter::LegacyReporterAdapter(Ptr<IReporter> const& legacyReporter)
+ : m_legacyReporter(legacyReporter)
+{
+}
+LegacyReporterAdapter::~LegacyReporterAdapter() {}
+
+ReporterPreferences LegacyReporterAdapter::getPreferences() const
+{
+ ReporterPreferences prefs;
+ prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout();
+ return prefs;
+}
+
+void LegacyReporterAdapter::noMatchingTestCases(std::string const&) {}
+void LegacyReporterAdapter::testRunStarting(TestRunInfo const&)
+{
+ m_legacyReporter->StartTesting();
+}
+void LegacyReporterAdapter::testGroupStarting(GroupInfo const& groupInfo)
+{
+ m_legacyReporter->StartGroup(groupInfo.name);
+}
+void LegacyReporterAdapter::testCaseStarting(TestCaseInfo const& testInfo)
+{
+ m_legacyReporter->StartTestCase(testInfo);
+}
+void LegacyReporterAdapter::sectionStarting(SectionInfo const& sectionInfo)
+{
+ m_legacyReporter->StartSection(sectionInfo.name, sectionInfo.description);
+}
+void LegacyReporterAdapter::assertionStarting(AssertionInfo const&)
+{
+ // Not on legacy interface
+}
+
+bool LegacyReporterAdapter::assertionEnded(AssertionStats const& assertionStats)
+{
+ if (assertionStats.assertionResult.getResultType() != ResultWas::Ok)
+ {
+ for (std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
+ it != itEnd;
+ ++it)
+ {
+ if (it->type == ResultWas::Info)
+ {
+ ResultBuilder rb(it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal);
+ rb << it->message;
+ rb.setResultType(ResultWas::Info);
+ AssertionResult result = rb.build();
+ m_legacyReporter->Result(result);
+ }
+ }
+ }
+ m_legacyReporter->Result(assertionStats.assertionResult);
+ return true;
+}
+void LegacyReporterAdapter::sectionEnded(SectionStats const& sectionStats)
+{
+ if (sectionStats.missingAssertions)
+ m_legacyReporter->NoAssertionsInSection(sectionStats.sectionInfo.name);
+ m_legacyReporter->EndSection(sectionStats.sectionInfo.name, sectionStats.assertions);
+}
+void LegacyReporterAdapter::testCaseEnded(TestCaseStats const& testCaseStats)
+{
+ m_legacyReporter->EndTestCase(testCaseStats.testInfo,
+ testCaseStats.totals,
+ testCaseStats.stdOut,
+ testCaseStats.stdErr);
+}
+void LegacyReporterAdapter::testGroupEnded(TestGroupStats const& testGroupStats)
+{
+ if (testGroupStats.aborting)
+ m_legacyReporter->Aborted();
+ m_legacyReporter->EndGroup(testGroupStats.groupInfo.name, testGroupStats.totals);
+}
+void LegacyReporterAdapter::testRunEnded(TestRunStats const& testRunStats)
+{
+ m_legacyReporter->EndTesting(testRunStats.totals);
+}
+void LegacyReporterAdapter::skipTest(TestCaseInfo const&)
+{
+}
+}
+
+// #included from: catch_timer.hpp
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wc++11-long-long"
+#endif
+
+#ifdef CATCH_PLATFORM_WINDOWS
+#include <windows.h>
+#else
+#include <sys/time.h>
+#endif
+
+namespace Catch {
+
+namespace {
+#ifdef CATCH_PLATFORM_WINDOWS
+uint64_t getCurrentTicks()
+{
+ static uint64_t hz = 0, hzo = 0;
+ if (!hz)
+ {
+ QueryPerformanceFrequency(reinterpret_cast<LARGE_INTEGER*>(&hz));
+ QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&hzo));
+ }
+ uint64_t t;
+ QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&t));
+ return ((t - hzo) * 1000000) / hz;
+}
+#else
+uint64_t getCurrentTicks()
+{
+ timeval t;
+ gettimeofday(&t, CATCH_NULL);
+ return static_cast<uint64_t>(t.tv_sec) * 1000000ull + static_cast<uint64_t>(t.tv_usec);
+}
+#endif
+}
+
+void Timer::start()
+{
+ m_ticks = getCurrentTicks();
+}
+unsigned int Timer::getElapsedMicroseconds() const
+{
+ return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
+}
+unsigned int Timer::getElapsedMilliseconds() const
+{
+ return static_cast<unsigned int>(getElapsedMicroseconds() / 1000);
+}
+double Timer::getElapsedSeconds() const
+{
+ return getElapsedMicroseconds() / 1000000.0;
+}
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+// #included from: catch_common.hpp
+#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED
+
+namespace Catch {
+
+bool startsWith(std::string const& s, std::string const& prefix)
+{
+ return s.size() >= prefix.size() && s.substr(0, prefix.size()) == prefix;
+}
+bool endsWith(std::string const& s, std::string const& suffix)
+{
+ return s.size() >= suffix.size() && s.substr(s.size() - suffix.size(), suffix.size()) == suffix;
+}
+bool contains(std::string const& s, std::string const& infix)
+{
+ return s.find(infix) != std::string::npos;
+}
+void toLowerInPlace(std::string& s)
+{
+ std::transform(s.begin(), s.end(), s.begin(), ::tolower);
+}
+std::string toLower(std::string const& s)
+{
+ std::string lc = s;
+ toLowerInPlace(lc);
+ return lc;
+}
+std::string trim(std::string const& str)
+{
+ static char const* whitespaceChars = "\n\r\t ";
+ std::string::size_type start = str.find_first_not_of(whitespaceChars);
+ std::string::size_type end = str.find_last_not_of(whitespaceChars);
+
+ return start != std::string::npos ? str.substr(start, 1 + end - start) : "";
+}
+
+bool replaceInPlace(std::string& str, std::string const& replaceThis, std::string const& withThis)
+{
+ bool replaced = false;
+ std::size_t i = str.find(replaceThis);
+ while (i != std::string::npos)
+ {
+ replaced = true;
+ str = str.substr(0, i) + withThis + str.substr(i + replaceThis.size());
+ if (i < str.size() - withThis.size())
+ i = str.find(replaceThis, i + withThis.size());
+ else
+ i = std::string::npos;
+ }
+ return replaced;
+}
+
+pluralise::pluralise(std::size_t count, std::string const& label)
+ : m_count(count),
+ m_label(label)
+{
+}
+
+std::ostream& operator<<(std::ostream& os, pluralise const& pluraliser)
+{
+ os << pluraliser.m_count << " " << pluraliser.m_label;
+ if (pluraliser.m_count != 1)
+ os << "s";
+ return os;
+}
+
+SourceLineInfo::SourceLineInfo() : line(0) {}
+SourceLineInfo::SourceLineInfo(char const* _file, std::size_t _line)
+ : file(_file),
+ line(_line)
+{
+}
+SourceLineInfo::SourceLineInfo(SourceLineInfo const& other)
+ : file(other.file),
+ line(other.line)
+{
+}
+bool SourceLineInfo::empty() const
+{
+ return file.empty();
+}
+bool SourceLineInfo::operator==(SourceLineInfo const& other) const
+{
+ return line == other.line && file == other.file;
+}
+bool SourceLineInfo::operator<(SourceLineInfo const& other) const
+{
+ return line < other.line || (line == other.line && file < other.file);
+}
+
+void seedRng(IConfig const& config)
+{
+ if (config.rngSeed() != 0)
+ std::srand(config.rngSeed());
+}
+unsigned int rngSeed()
+{
+ return getCurrentContext().getConfig()->rngSeed();
+}
+
+std::ostream& operator<<(std::ostream& os, SourceLineInfo const& info)
+{
+#ifndef __GNUG__
+ os << info.file << "(" << info.line << ")";
+#else
+ os << info.file << ":" << info.line;
+#endif
+ return os;
+}
+
+void throwLogicError(std::string const& message, SourceLineInfo const& locationInfo)
+{
+ std::ostringstream oss;
+ oss << locationInfo << ": Internal Catch error: '" << message << "'";
+ if (alwaysTrue())
+ throw std::logic_error(oss.str());
+}
+}
+
+// #included from: catch_section.hpp
+#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED
+
+namespace Catch {
+
+SectionInfo::SectionInfo(SourceLineInfo const& _lineInfo,
+ std::string const& _name,
+ std::string const& _description)
+ : name(_name),
+ description(_description),
+ lineInfo(_lineInfo)
+{
+}
+
+Section::Section(SectionInfo const& info)
+ : m_info(info),
+ m_sectionIncluded(getResultCapture().sectionStarted(m_info, m_assertions))
+{
+ m_timer.start();
+}
+
+Section::~Section()
+{
+ if (m_sectionIncluded)
+ {
+ SectionEndInfo endInfo(m_info, m_assertions, m_timer.getElapsedSeconds());
+ if (std::uncaught_exception())
+ getResultCapture().sectionEndedEarly(endInfo);
+ else
+ getResultCapture().sectionEnded(endInfo);
+ }
+}
+
+// This indicates whether the section should be executed or not
+Section::operator bool() const
+{
+ return m_sectionIncluded;
+}
+
+} // end namespace Catch
+
+// #included from: catch_debugger.hpp
+#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED
+
+#include <iostream>
+
+#ifdef CATCH_PLATFORM_MAC
+
+#include <assert.h>
+#include <stdbool.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+namespace Catch {
+
+// The following function is taken directly from the following technical note:
+// http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
+
+// Returns true if the current process is being debugged (either
+// running under the debugger or has a debugger attached post facto).
+bool isDebuggerActive()
+{
+
+ int mib[4];
+ struct kinfo_proc info;
+ size_t size;
+
+ // Initialize the flags so that, if sysctl fails for some bizarre
+ // reason, we get a predictable result.
+
+ info.kp_proc.p_flag = 0;
+
+ // Initialize mib, which tells sysctl the info we want, in this case
+ // we're looking for information about a specific process ID.
+
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_PID;
+ mib[3] = getpid();
+
+ // Call sysctl.
+
+ size = sizeof(info);
+ if (sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, CATCH_NULL, 0) != 0)
+ {
+ Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n"
+ << std::endl;
+ return false;
+ }
+
+ // We're being debugged if the P_TRACED flag is set.
+
+ return ((info.kp_proc.p_flag & P_TRACED) != 0);
+}
+} // namespace Catch
+
+#elif defined(_MSC_VER)
+extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+namespace Catch {
+bool isDebuggerActive()
+{
+ return IsDebuggerPresent() != 0;
+}
+}
+#elif defined(__MINGW32__)
+extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+namespace Catch {
+bool isDebuggerActive()
+{
+ return IsDebuggerPresent() != 0;
+}
+}
+#else
+namespace Catch {
+inline bool isDebuggerActive() { return false; }
+}
+#endif // Platform
+
+#ifdef CATCH_PLATFORM_WINDOWS
+extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char*);
+namespace Catch {
+void writeToDebugConsole(std::string const& text)
+{
+ ::OutputDebugStringA(text.c_str());
+}
+}
+#else
+namespace Catch {
+void writeToDebugConsole(std::string const& text)
+{
+ // !TBD: Need a version for Mac/ XCode and other IDEs
+ Catch::cout() << text;
+}
+}
+#endif // Platform
+
+// #included from: catch_tostring.hpp
+#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED
+
+namespace Catch {
+
+namespace Detail {
+
+const std::string unprintableString = "{?}";
+
+namespace {
+const int hexThreshold = 255;
+
+struct Endianness
+{
+ enum Arch
+ {
+ Big,
+ Little
+ };
+
+ static Arch which()
+ {
+ union _
+ {
+ int asInt;
+ char asChar[sizeof(int)];
+ } u;
+
+ u.asInt = 1;
+ return (u.asChar[sizeof(int) - 1] == 1) ? Big : Little;
+ }
+};
+}
+
+std::string rawMemoryToString(const void* object, std::size_t size)
+{
+ // Reverse order for little endian architectures
+ int i = 0, end = static_cast<int>(size), inc = 1;
+ if (Endianness::which() == Endianness::Little)
+ {
+ i = end - 1;
+ end = inc = -1;
+ }
+
+ unsigned char const* bytes = static_cast<unsigned char const*>(object);
+ std::ostringstream os;
+ os << "0x" << std::setfill('0') << std::hex;
+ for (; i != end; i += inc)
+ os << std::setw(2) << static_cast<unsigned>(bytes[i]);
+ return os.str();
+}
+}
+
+std::string toString(std::string const& value)
+{
+ std::string s = value;
+ if (getCurrentContext().getConfig()->showInvisibles())
+ {
+ for (size_t i = 0; i < s.size(); ++i)
+ {
+ std::string subs;
+ switch (s[i])
+ {
+ case '\n':
+ subs = "\\n";
+ break;
+ case '\t':
+ subs = "\\t";
+ break;
+ default:
+ break;
+ }
+ if (!subs.empty())
+ {
+ s = s.substr(0, i) + subs + s.substr(i + 1);
+ ++i;
+ }
+ }
+ }
+ return "\"" + s + "\"";
+}
+std::string toString(std::wstring const& value)
+{
+
+ std::string s;
+ s.reserve(value.size());
+ for (size_t i = 0; i < value.size(); ++i)
+ s += value[i] <= 0xff ? static_cast<char>(value[i]) : '?';
+ return Catch::toString(s);
+}
+
+std::string toString(const char* const value)
+{
+ return value ? Catch::toString(std::string(value)) : std::string("{null string}");
+}
+
+std::string toString(char* const value)
+{
+ return Catch::toString(static_cast<const char*>(value));
+}
+
+std::string toString(const wchar_t* const value)
+{
+ return value ? Catch::toString(std::wstring(value)) : std::string("{null string}");
+}
+
+std::string toString(wchar_t* const value)
+{
+ return Catch::toString(static_cast<const wchar_t*>(value));
+}
+
+std::string toString(int value)
+{
+ std::ostringstream oss;
+ oss << value;
+ if (value > Detail::hexThreshold)
+ oss << " (0x" << std::hex << value << ")";
+ return oss.str();
+}
+
+std::string toString(unsigned long value)
+{
+ std::ostringstream oss;
+ oss << value;
+ if (value > Detail::hexThreshold)
+ oss << " (0x" << std::hex << value << ")";
+ return oss.str();
+}
+
+std::string toString(unsigned int value)
+{
+ return Catch::toString(static_cast<unsigned long>(value));
+}
+
+template <typename T>
+std::string fpToString(T value, int precision)
+{
+ std::ostringstream oss;
+ oss << std::setprecision(precision)
+ << std::fixed
+ << value;
+ std::string d = oss.str();
+ std::size_t i = d.find_last_not_of('0');
+ if (i != std::string::npos && i != d.size() - 1)
+ {
+ if (d[i] == '.')
+ i++;
+ d = d.substr(0, i + 1);
+ }
+ return d;
+}
+
+std::string toString(const double value)
+{
+ return fpToString(value, 10);
+}
+std::string toString(const float value)
+{
+ return fpToString(value, 5) + "f";
+}
+
+std::string toString(bool value)
+{
+ return value ? "true" : "false";
+}
+
+std::string toString(char value)
+{
+ return value < ' '
+ ? toString(static_cast<unsigned int>(value))
+ : Detail::makeString(value);
+}
+
+std::string toString(signed char value)
+{
+ return toString(static_cast<char>(value));
+}
+
+std::string toString(unsigned char value)
+{
+ return toString(static_cast<char>(value));
+}
+
+#ifdef CATCH_CONFIG_CPP11_LONG_LONG
+std::string toString(long long value)
+{
+ std::ostringstream oss;
+ oss << value;
+ if (value > Detail::hexThreshold)
+ oss << " (0x" << std::hex << value << ")";
+ return oss.str();
+}
+std::string toString(unsigned long long value)
+{
+ std::ostringstream oss;
+ oss << value;
+ if (value > Detail::hexThreshold)
+ oss << " (0x" << std::hex << value << ")";
+ return oss.str();
+}
+#endif
+
+#ifdef CATCH_CONFIG_CPP11_NULLPTR
+std::string toString(std::nullptr_t)
+{
+ return "nullptr";
+}
+#endif
+
+#ifdef __OBJC__
+std::string toString(NSString const* const& nsstring)
+{
+ if (!nsstring)
+ return "nil";
+ return "@" + toString([nsstring UTF8String]);
+}
+std::string toString(NSString* CATCH_ARC_STRONG const& nsstring)
+{
+ if (!nsstring)
+ return "nil";
+ return "@" + toString([nsstring UTF8String]);
+}
+std::string toString(NSObject* const& nsObject)
+{
+ return toString([nsObject description]);
+}
+#endif
+
+} // end namespace Catch
+
+// #included from: catch_result_builder.hpp
+#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED
+
+namespace Catch {
+
+std::string capturedExpressionWithSecondArgument(std::string const& capturedExpression, std::string const& secondArg)
+{
+ return secondArg.empty() || secondArg == "\"\""
+ ? capturedExpression
+ : capturedExpression + ", " + secondArg;
+}
+ResultBuilder::ResultBuilder(char const* macroName,
+ SourceLineInfo const& lineInfo,
+ char const* capturedExpression,
+ ResultDisposition::Flags resultDisposition,
+ char const* secondArg)
+ : m_assertionInfo(macroName, lineInfo, capturedExpressionWithSecondArgument(capturedExpression, secondArg), resultDisposition),
+ m_shouldDebugBreak(false),
+ m_shouldThrow(false)
+{
+}
+
+ResultBuilder& ResultBuilder::setResultType(ResultWas::OfType result)
+{
+ m_data.resultType = result;
+ return *this;
+}
+ResultBuilder& ResultBuilder::setResultType(bool result)
+{
+ m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed;
+ return *this;
+}
+ResultBuilder& ResultBuilder::setLhs(std::string const& lhs)
+{
+ m_exprComponents.lhs = lhs;
+ return *this;
+}
+ResultBuilder& ResultBuilder::setRhs(std::string const& rhs)
+{
+ m_exprComponents.rhs = rhs;
+ return *this;
+}
+ResultBuilder& ResultBuilder::setOp(std::string const& op)
+{
+ m_exprComponents.op = op;
+ return *this;
+}
+
+void ResultBuilder::endExpression()
+{
+ m_exprComponents.testFalse = isFalseTest(m_assertionInfo.resultDisposition);
+ captureExpression();
+}
+
+void ResultBuilder::useActiveException(ResultDisposition::Flags resultDisposition)
+{
+ m_assertionInfo.resultDisposition = resultDisposition;
+ m_stream.oss << Catch::translateActiveException();
+ captureResult(ResultWas::ThrewException);
+}
+
+void ResultBuilder::captureResult(ResultWas::OfType resultType)
+{
+ setResultType(resultType);
+ captureExpression();
+}
+void ResultBuilder::captureExpectedException(std::string const& expectedMessage)
+{
+ if (expectedMessage.empty())
+ captureExpectedException(Matchers::Impl::Generic::AllOf<std::string>());
+ else
+ captureExpectedException(Matchers::Equals(expectedMessage));
+}
+
+void ResultBuilder::captureExpectedException(Matchers::Impl::Matcher<std::string> const& matcher)
+{
+
+ assert(m_exprComponents.testFalse == false);
+ AssertionResultData data = m_data;
+ data.resultType = ResultWas::Ok;
+ data.reconstructedExpression = m_assertionInfo.capturedExpression;
+
+ std::string actualMessage = Catch::translateActiveException();
+ if (!matcher.match(actualMessage))
+ {
+ data.resultType = ResultWas::ExpressionFailed;
+ data.reconstructedExpression = actualMessage;
+ }
+ AssertionResult result(m_assertionInfo, data);
+ handleResult(result);
+}
+
+void ResultBuilder::captureExpression()
+{
+ AssertionResult result = build();
+ handleResult(result);
+}
+void ResultBuilder::handleResult(AssertionResult const& result)
+{
+ getResultCapture().assertionEnded(result);
+
+ if (!result.isOk())
+ {
+ if (getCurrentContext().getConfig()->shouldDebugBreak())
+ m_shouldDebugBreak = true;
+ if (getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal))
+ m_shouldThrow = true;
+ }
+}
+void ResultBuilder::react()
+{
+ if (m_shouldThrow)
+ throw Catch::TestFailureException();
+}
+
+bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; }
+bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); }
+
+AssertionResult ResultBuilder::build() const
+{
+ assert(m_data.resultType != ResultWas::Unknown);
+
+ AssertionResultData data = m_data;
+
+ // Flip bool results if testFalse is set
+ if (m_exprComponents.testFalse)
+ {
+ if (data.resultType == ResultWas::Ok)
+ data.resultType = ResultWas::ExpressionFailed;
+ else if (data.resultType == ResultWas::ExpressionFailed)
+ data.resultType = ResultWas::Ok;
+ }
+
+ data.message = m_stream.oss.str();
+ data.reconstructedExpression = reconstructExpression();
+ if (m_exprComponents.testFalse)
+ {
+ if (m_exprComponents.op == "")
+ data.reconstructedExpression = "!" + data.reconstructedExpression;
+ else
+ data.reconstructedExpression = "!(" + data.reconstructedExpression + ")";
+ }
+ return AssertionResult(m_assertionInfo, data);
+}
+std::string ResultBuilder::reconstructExpression() const
+{
+ if (m_exprComponents.op == "")
+ return m_exprComponents.lhs.empty() ? m_assertionInfo.capturedExpression : m_exprComponents.op + m_exprComponents.lhs;
+ else if (m_exprComponents.op == "matches")
+ return m_exprComponents.lhs + " " + m_exprComponents.rhs;
+ else if (m_exprComponents.op != "!")
+ {
+ if (m_exprComponents.lhs.size() + m_exprComponents.rhs.size() < 40 &&
+ m_exprComponents.lhs.find("\n") == std::string::npos &&
+ m_exprComponents.rhs.find("\n") == std::string::npos)
+ return m_exprComponents.lhs + " " + m_exprComponents.op + " " + m_exprComponents.rhs;
+ else
+ return m_exprComponents.lhs + "\n" + m_exprComponents.op + "\n" + m_exprComponents.rhs;
+ }
+ else
+ return "{can't expand - use " + m_assertionInfo.macroName + "_FALSE( " + m_assertionInfo.capturedExpression.substr(1) + " ) instead of " + m_assertionInfo.macroName + "( " + m_assertionInfo.capturedExpression + " ) for better diagnostics}";
+}
+
+} // end namespace Catch
+
+// #included from: catch_tag_alias_registry.hpp
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+// #included from: catch_tag_alias_registry.h
+#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED
+
+#include <map>
+
+namespace Catch {
+
+class TagAliasRegistry : public ITagAliasRegistry
+{
+ public:
+ virtual ~TagAliasRegistry();
+ virtual Option<TagAlias> find(std::string const& alias) const;
+ virtual std::string expandAliases(std::string const& unexpandedTestSpec) const;
+ void add(char const* alias, char const* tag, SourceLineInfo const& lineInfo);
+ static TagAliasRegistry& get();
+
+ private:
+ std::map<std::string, TagAlias> m_registry;
+};
+
+} // end namespace Catch
+
+#include <iostream>
+#include <map>
+
+namespace Catch {
+
+TagAliasRegistry::~TagAliasRegistry() {}
+
+Option<TagAlias> TagAliasRegistry::find(std::string const& alias) const
+{
+ std::map<std::string, TagAlias>::const_iterator it = m_registry.find(alias);
+ if (it != m_registry.end())
+ return it->second;
+ else
+ return Option<TagAlias>();
+}
+
+std::string TagAliasRegistry::expandAliases(std::string const& unexpandedTestSpec) const
+{
+ std::string expandedTestSpec = unexpandedTestSpec;
+ for (std::map<std::string, TagAlias>::const_iterator it = m_registry.begin(), itEnd = m_registry.end();
+ it != itEnd;
+ ++it)
+ {
+ std::size_t pos = expandedTestSpec.find(it->first);
+ if (pos != std::string::npos)
+ {
+ expandedTestSpec = expandedTestSpec.substr(0, pos) +
+ it->second.tag +
+ expandedTestSpec.substr(pos + it->first.size());
+ }
+ }
+ return expandedTestSpec;
+}
+
+void TagAliasRegistry::add(char const* alias, char const* tag, SourceLineInfo const& lineInfo)
+{
+
+ if (!startsWith(alias, "[@") || !endsWith(alias, "]"))
+ {
+ std::ostringstream oss;
+ oss << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n"
+ << lineInfo;
+ throw std::domain_error(oss.str().c_str());
+ }
+ if (!m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second)
+ {
+ std::ostringstream oss;
+ oss << "error: tag alias, \"" << alias << "\" already registered.\n"
+ << "\tFirst seen at " << find(alias)->lineInfo << "\n"
+ << "\tRedefined at " << lineInfo;
+ throw std::domain_error(oss.str().c_str());
+ }
+}
+
+TagAliasRegistry& TagAliasRegistry::get()
+{
+ static TagAliasRegistry instance;
+ return instance;
+}
+
+ITagAliasRegistry::~ITagAliasRegistry() {}
+ITagAliasRegistry const& ITagAliasRegistry::get() { return TagAliasRegistry::get(); }
+
+RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo)
+{
+ try
+ {
+ TagAliasRegistry::get().add(alias, tag, lineInfo);
+ }
+ catch (std::exception& ex)
+ {
+ Colour colourGuard(Colour::Red);
+ Catch::cerr() << ex.what() << std::endl;
+ exit(1);
+ }
+}
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_multi.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_MULTI_HPP_INCLUDED
+
+namespace Catch {
+
+class MultipleReporters : public SharedImpl<IStreamingReporter>
+{
+ typedef std::vector<Ptr<IStreamingReporter>> Reporters;
+ Reporters m_reporters;
+
+ public:
+ void add(Ptr<IStreamingReporter> const& reporter)
+ {
+ m_reporters.push_back(reporter);
+ }
+
+ public: // IStreamingReporter
+ virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE
+ {
+ return m_reporters[0]->getPreferences();
+ }
+
+ virtual void noMatchingTestCases(std::string const& spec) CATCH_OVERRIDE
+ {
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ (*it)->noMatchingTestCases(spec);
+ }
+
+ virtual void testRunStarting(TestRunInfo const& testRunInfo) CATCH_OVERRIDE
+ {
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ (*it)->testRunStarting(testRunInfo);
+ }
+
+ virtual void testGroupStarting(GroupInfo const& groupInfo) CATCH_OVERRIDE
+ {
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ (*it)->testGroupStarting(groupInfo);
+ }
+
+ virtual void testCaseStarting(TestCaseInfo const& testInfo) CATCH_OVERRIDE
+ {
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ (*it)->testCaseStarting(testInfo);
+ }
+
+ virtual void sectionStarting(SectionInfo const& sectionInfo) CATCH_OVERRIDE
+ {
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ (*it)->sectionStarting(sectionInfo);
+ }
+
+ virtual void assertionStarting(AssertionInfo const& assertionInfo) CATCH_OVERRIDE
+ {
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ (*it)->assertionStarting(assertionInfo);
+ }
+
+ // The return value indicates if the messages buffer should be cleared:
+ virtual bool assertionEnded(AssertionStats const& assertionStats) CATCH_OVERRIDE
+ {
+ bool clearBuffer = false;
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ clearBuffer |= (*it)->assertionEnded(assertionStats);
+ return clearBuffer;
+ }
+
+ virtual void sectionEnded(SectionStats const& sectionStats) CATCH_OVERRIDE
+ {
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ (*it)->sectionEnded(sectionStats);
+ }
+
+ virtual void testCaseEnded(TestCaseStats const& testCaseStats) CATCH_OVERRIDE
+ {
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ (*it)->testCaseEnded(testCaseStats);
+ }
+
+ virtual void testGroupEnded(TestGroupStats const& testGroupStats) CATCH_OVERRIDE
+ {
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ (*it)->testGroupEnded(testGroupStats);
+ }
+
+ virtual void testRunEnded(TestRunStats const& testRunStats) CATCH_OVERRIDE
+ {
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ (*it)->testRunEnded(testRunStats);
+ }
+
+ virtual void skipTest(TestCaseInfo const& testInfo) CATCH_OVERRIDE
+ {
+ for (Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
+ it != itEnd;
+ ++it)
+ (*it)->skipTest(testInfo);
+ }
+};
+
+Ptr<IStreamingReporter> addReporter(Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter)
+{
+ Ptr<IStreamingReporter> resultingReporter;
+
+ if (existingReporter)
+ {
+ MultipleReporters* multi = dynamic_cast<MultipleReporters*>(existingReporter.get());
+ if (!multi)
+ {
+ multi = new MultipleReporters;
+ resultingReporter = Ptr<IStreamingReporter>(multi);
+ if (existingReporter)
+ multi->add(existingReporter);
+ }
+ else
+ resultingReporter = existingReporter;
+ multi->add(additionalReporter);
+ }
+ else
+ resultingReporter = additionalReporter;
+
+ return resultingReporter;
+}
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_xml.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED
+
+// #included from: catch_reporter_bases.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED
+
+#include <cstring>
+
+namespace Catch {
+
+struct StreamingReporterBase : SharedImpl<IStreamingReporter>
+{
+
+ StreamingReporterBase(ReporterConfig const& _config)
+ : m_config(_config.fullConfig()),
+ stream(_config.stream())
+ {
+ m_reporterPrefs.shouldRedirectStdOut = false;
+ }
+
+ virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE
+ {
+ return m_reporterPrefs;
+ }
+
+ virtual ~StreamingReporterBase() CATCH_OVERRIDE;
+
+ virtual void noMatchingTestCases(std::string const&) CATCH_OVERRIDE {}
+
+ virtual void testRunStarting(TestRunInfo const& _testRunInfo) CATCH_OVERRIDE
+ {
+ currentTestRunInfo = _testRunInfo;
+ }
+ virtual void testGroupStarting(GroupInfo const& _groupInfo) CATCH_OVERRIDE
+ {
+ currentGroupInfo = _groupInfo;
+ }
+
+ virtual void testCaseStarting(TestCaseInfo const& _testInfo) CATCH_OVERRIDE
+ {
+ currentTestCaseInfo = _testInfo;
+ }
+ virtual void sectionStarting(SectionInfo const& _sectionInfo) CATCH_OVERRIDE
+ {
+ m_sectionStack.push_back(_sectionInfo);
+ }
+
+ virtual void sectionEnded(SectionStats const& /* _sectionStats */) CATCH_OVERRIDE
+ {
+ m_sectionStack.pop_back();
+ }
+ virtual void testCaseEnded(TestCaseStats const& /* _testCaseStats */) CATCH_OVERRIDE
+ {
+ currentTestCaseInfo.reset();
+ }
+ virtual void testGroupEnded(TestGroupStats const& /* _testGroupStats */) CATCH_OVERRIDE
+ {
+ currentGroupInfo.reset();
+ }
+ virtual void testRunEnded(TestRunStats const& /* _testRunStats */) CATCH_OVERRIDE
+ {
+ currentTestCaseInfo.reset();
+ currentGroupInfo.reset();
+ currentTestRunInfo.reset();
+ }
+
+ virtual void skipTest(TestCaseInfo const&) CATCH_OVERRIDE
+ {
+ // Don't do anything with this by default.
+ // It can optionally be overridden in the derived class.
+ }
+
+ Ptr<IConfig const> m_config;
+ std::ostream& stream;
+
+ LazyStat<TestRunInfo> currentTestRunInfo;
+ LazyStat<GroupInfo> currentGroupInfo;
+ LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+ std::vector<SectionInfo> m_sectionStack;
+ ReporterPreferences m_reporterPrefs;
+};
+
+struct CumulativeReporterBase : SharedImpl<IStreamingReporter>
+{
+ template <typename T, typename ChildNodeT>
+ struct Node : SharedImpl<>
+ {
+ explicit Node(T const& _value) : value(_value) {}
+ virtual ~Node() {}
+
+ typedef std::vector<Ptr<ChildNodeT>> ChildNodes;
+ T value;
+ ChildNodes children;
+ };
+ struct SectionNode : SharedImpl<>
+ {
+ explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+ virtual ~SectionNode();
+
+ bool operator==(SectionNode const& other) const
+ {
+ return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+ }
+ bool operator==(Ptr<SectionNode> const& other) const
+ {
+ return operator==(*other);
+ }
+
+ SectionStats stats;
+ typedef std::vector<Ptr<SectionNode>> ChildSections;
+ typedef std::vector<AssertionStats> Assertions;
+ ChildSections childSections;
+ Assertions assertions;
+ std::string stdOut;
+ std::string stdErr;
+ };
+
+ struct BySectionInfo
+ {
+ BySectionInfo(SectionInfo const& other) : m_other(other) {}
+ BySectionInfo(BySectionInfo const& other) : m_other(other.m_other) {}
+ bool operator()(Ptr<SectionNode> const& node) const
+ {
+ return node->stats.sectionInfo.lineInfo == m_other.lineInfo;
+ }
+
+ private:
+ void operator=(BySectionInfo const&);
+ SectionInfo const& m_other;
+ };
+
+ typedef Node<TestCaseStats, SectionNode> TestCaseNode;
+ typedef Node<TestGroupStats, TestCaseNode> TestGroupNode;
+ typedef Node<TestRunStats, TestGroupNode> TestRunNode;
+
+ CumulativeReporterBase(ReporterConfig const& _config)
+ : m_config(_config.fullConfig()),
+ stream(_config.stream())
+ {
+ m_reporterPrefs.shouldRedirectStdOut = false;
+ }
+ ~CumulativeReporterBase();
+
+ virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE
+ {
+ return m_reporterPrefs;
+ }
+
+ virtual void testRunStarting(TestRunInfo const&) CATCH_OVERRIDE {}
+ virtual void testGroupStarting(GroupInfo const&) CATCH_OVERRIDE {}
+
+ virtual void testCaseStarting(TestCaseInfo const&) CATCH_OVERRIDE {}
+
+ virtual void sectionStarting(SectionInfo const& sectionInfo) CATCH_OVERRIDE
+ {
+ SectionStats incompleteStats(sectionInfo, Counts(), 0, false);
+ Ptr<SectionNode> node;
+ if (m_sectionStack.empty())
+ {
+ if (!m_rootSection)
+ m_rootSection = new SectionNode(incompleteStats);
+ node = m_rootSection;
+ }
+ else
+ {
+ SectionNode& parentNode = *m_sectionStack.back();
+ SectionNode::ChildSections::const_iterator it =
+ std::find_if(parentNode.childSections.begin(),
+ parentNode.childSections.end(),
+ BySectionInfo(sectionInfo));
+ if (it == parentNode.childSections.end())
+ {
+ node = new SectionNode(incompleteStats);
+ parentNode.childSections.push_back(node);
+ }
+ else
+ node = *it;
+ }
+ m_sectionStack.push_back(node);
+ m_deepestSection = node;
+ }
+
+ virtual void assertionStarting(AssertionInfo const&) CATCH_OVERRIDE {}
+
+ virtual bool assertionEnded(AssertionStats const& assertionStats)
+ {
+ assert(!m_sectionStack.empty());
+ SectionNode& sectionNode = *m_sectionStack.back();
+ sectionNode.assertions.push_back(assertionStats);
+ return true;
+ }
+ virtual void sectionEnded(SectionStats const& sectionStats) CATCH_OVERRIDE
+ {
+ assert(!m_sectionStack.empty());
+ SectionNode& node = *m_sectionStack.back();
+ node.stats = sectionStats;
+ m_sectionStack.pop_back();
+ }
+ virtual void testCaseEnded(TestCaseStats const& testCaseStats) CATCH_OVERRIDE
+ {
+ Ptr<TestCaseNode> node = new TestCaseNode(testCaseStats);
+ assert(m_sectionStack.size() == 0);
+ node->children.push_back(m_rootSection);
+ m_testCases.push_back(node);
+ m_rootSection.reset();
+
+ assert(m_deepestSection);
+ m_deepestSection->stdOut = testCaseStats.stdOut;
+ m_deepestSection->stdErr = testCaseStats.stdErr;
+ }
+ virtual void testGroupEnded(TestGroupStats const& testGroupStats) CATCH_OVERRIDE
+ {
+ Ptr<TestGroupNode> node = new TestGroupNode(testGroupStats);
+ node->children.swap(m_testCases);
+ m_testGroups.push_back(node);
+ }
+ virtual void testRunEnded(TestRunStats const& testRunStats) CATCH_OVERRIDE
+ {
+ Ptr<TestRunNode> node = new TestRunNode(testRunStats);
+ node->children.swap(m_testGroups);
+ m_testRuns.push_back(node);
+ testRunEndedCumulative();
+ }
+ virtual void testRunEndedCumulative() = 0;
+
+ virtual void skipTest(TestCaseInfo const&) CATCH_OVERRIDE {}
+
+ Ptr<IConfig const> m_config;
+ std::ostream& stream;
+ std::vector<AssertionStats> m_assertions;
+ std::vector<std::vector<Ptr<SectionNode>>> m_sections;
+ std::vector<Ptr<TestCaseNode>> m_testCases;
+ std::vector<Ptr<TestGroupNode>> m_testGroups;
+
+ std::vector<Ptr<TestRunNode>> m_testRuns;
+
+ Ptr<SectionNode> m_rootSection;
+ Ptr<SectionNode> m_deepestSection;
+ std::vector<Ptr<SectionNode>> m_sectionStack;
+ ReporterPreferences m_reporterPrefs;
+};
+
+template <char C>
+char const* getLineOfChars()
+{
+ static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+ if (!*line)
+ {
+ memset(line, C, CATCH_CONFIG_CONSOLE_WIDTH - 1);
+ line[CATCH_CONFIG_CONSOLE_WIDTH - 1] = 0;
+ }
+ return line;
+}
+
+struct TestEventListenerBase : StreamingReporterBase
+{
+ TestEventListenerBase(ReporterConfig const& _config)
+ : StreamingReporterBase(_config)
+ {
+ }
+
+ virtual void assertionStarting(AssertionInfo const&) CATCH_OVERRIDE {}
+ virtual bool assertionEnded(AssertionStats const&) CATCH_OVERRIDE
+ {
+ return false;
+ }
+};
+
+} // end namespace Catch
+
+// #included from: ../internal/catch_reporter_registrars.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+
+namespace Catch {
+
+template <typename T>
+class LegacyReporterRegistrar
+{
+
+ class ReporterFactory : public IReporterFactory
+ {
+ virtual IStreamingReporter* create(ReporterConfig const& config) const
+ {
+ return new LegacyReporterAdapter(new T(config));
+ }
+
+ virtual std::string getDescription() const
+ {
+ return T::getDescription();
+ }
+ };
+
+ public:
+ LegacyReporterRegistrar(std::string const& name)
+ {
+ getMutableRegistryHub().registerReporter(name, new ReporterFactory());
+ }
+};
+
+template <typename T>
+class ReporterRegistrar
+{
+
+ class ReporterFactory : public SharedImpl<IReporterFactory>
+ {
+
+ // *** Please Note ***:
+ // - If you end up here looking at a compiler error because it's trying to register
+ // your custom reporter class be aware that the native reporter interface has changed
+ // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
+ // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter.
+ // However please consider updating to the new interface as the old one is now
+ // deprecated and will probably be removed quite soon!
+ // Please contact me via github if you have any questions at all about this.
+ // In fact, ideally, please contact me anyway to let me know you've hit this - as I have
+ // no idea who is actually using custom reporters at all (possibly no-one!).
+ // The new interface is designed to minimise exposure to interface changes in the future.
+ virtual IStreamingReporter* create(ReporterConfig const& config) const
+ {
+ return new T(config);
+ }
+
+ virtual std::string getDescription() const
+ {
+ return T::getDescription();
+ }
+ };
+
+ public:
+ ReporterRegistrar(std::string const& name)
+ {
+ getMutableRegistryHub().registerReporter(name, new ReporterFactory());
+ }
+};
+
+template <typename T>
+class ListenerRegistrar
+{
+
+ class ListenerFactory : public SharedImpl<IReporterFactory>
+ {
+
+ virtual IStreamingReporter* create(ReporterConfig const& config) const
+ {
+ return new T(config);
+ }
+ virtual std::string getDescription() const
+ {
+ return "";
+ }
+ };
+
+ public:
+ ListenerRegistrar()
+ {
+ getMutableRegistryHub().registerListener(new ListenerFactory());
+ }
+};
+}
+
+#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER(name, reporterType) \
+ namespace { \
+ Catch::LegacyReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType(name); \
+ }
+
+#define INTERNAL_CATCH_REGISTER_REPORTER(name, reporterType) \
+ namespace { \
+ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType(name); \
+ }
+
+#define INTERNAL_CATCH_REGISTER_LISTENER(listenerType) \
+ namespace { \
+ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; \
+ }
+
+// #included from: ../internal/catch_xmlwriter.hpp
+#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
+
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+class XmlEncode
+{
+ public:
+ enum ForWhat
+ {
+ ForTextNodes,
+ ForAttributes
+ };
+
+ XmlEncode(std::string const& str, ForWhat forWhat = ForTextNodes)
+ : m_str(str),
+ m_forWhat(forWhat)
+ {
+ }
+
+ void encodeTo(std::ostream& os) const
+ {
+
+ // Apostrophe escaping not necessary if we always use " to write attributes
+ // (see: http://www.w3.org/TR/xml/#syntax)
+
+ for (std::size_t i = 0; i < m_str.size(); ++i)
+ {
+ char c = m_str[i];
+ switch (c)
+ {
+ case '<':
+ os << "<";
+ break;
+ case '&':
+ os << "&";
+ break;
+
+ case '>':
+ // See: http://www.w3.org/TR/xml/#syntax
+ if (i > 2 && m_str[i - 1] == ']' && m_str[i - 2] == ']')
+ os << ">";
+ else
+ os << c;
+ break;
+
+ case '\"':
+ if (m_forWhat == ForAttributes)
+ os << """;
+ else
+ os << c;
+ break;
+
+ default:
+ // Escape control chars - based on contribution by @espenalb in PR #465
+ if ((c < '\x09') || (c > '\x0D' && c < '\x20') || c == '\x7F')
+ os << "&#x" << std::uppercase << std::hex << static_cast<int>(c);
+ else
+ os << c;
+ }
+ }
+ }
+
+ friend std::ostream& operator<<(std::ostream& os, XmlEncode const& xmlEncode)
+ {
+ xmlEncode.encodeTo(os);
+ return os;
+ }
+
+ private:
+ std::string m_str;
+ ForWhat m_forWhat;
+};
+
+class XmlWriter
+{
+ public:
+ class ScopedElement
+ {
+ public:
+ ScopedElement(XmlWriter* writer)
+ : m_writer(writer)
+ {
+ }
+
+ ScopedElement(ScopedElement const& other)
+ : m_writer(other.m_writer)
+ {
+ other.m_writer = CATCH_NULL;
+ }
+
+ ~ScopedElement()
+ {
+ if (m_writer)
+ m_writer->endElement();
+ }
+
+ ScopedElement& writeText(std::string const& text, bool indent = true)
+ {
+ m_writer->writeText(text, indent);
+ return *this;
+ }
+
+ template <typename T>
+ ScopedElement& writeAttribute(std::string const& name, T const& attribute)
+ {
+ m_writer->writeAttribute(name, attribute);
+ return *this;
+ }
+
+ private:
+ mutable XmlWriter* m_writer;
+ };
+
+ XmlWriter()
+ : m_tagIsOpen(false),
+ m_needsNewline(false),
+ m_os(&Catch::cout())
+ {
+ }
+
+ XmlWriter(std::ostream& os)
+ : m_tagIsOpen(false),
+ m_needsNewline(false),
+ m_os(&os)
+ {
+ }
+
+ ~XmlWriter()
+ {
+ while (!m_tags.empty())
+ endElement();
+ }
+
+ XmlWriter& startElement(std::string const& name)
+ {
+ ensureTagClosed();
+ newlineIfNecessary();
+ stream() << m_indent << "<" << name;
+ m_tags.push_back(name);
+ m_indent += " ";
+ m_tagIsOpen = true;
+ return *this;
+ }
+
+ ScopedElement scopedElement(std::string const& name)
+ {
+ ScopedElement scoped(this);
+ startElement(name);
+ return scoped;
+ }
+
+ XmlWriter& endElement()
+ {
+ newlineIfNecessary();
+ m_indent = m_indent.substr(0, m_indent.size() - 2);
+ if (m_tagIsOpen)
+ {
+ stream() << "/>\n";
+ m_tagIsOpen = false;
+ }
+ else
+ {
+ stream() << m_indent << "</" << m_tags.back() << ">\n";
+ }
+ m_tags.pop_back();
+ return *this;
+ }
+
+ XmlWriter& writeAttribute(std::string const& name, std::string const& attribute)
+ {
+ if (!name.empty() && !attribute.empty())
+ stream() << " " << name << "=\"" << XmlEncode(attribute, XmlEncode::ForAttributes) << "\"";
+ return *this;
+ }
+
+ XmlWriter& writeAttribute(std::string const& name, bool attribute)
+ {
+ stream() << " " << name << "=\"" << (attribute ? "true" : "false") << "\"";
+ return *this;
+ }
+
+ template <typename T>
+ XmlWriter& writeAttribute(std::string const& name, T const& attribute)
+ {
+ std::ostringstream oss;
+ oss << attribute;
+ return writeAttribute(name, oss.str());
+ }
+
+ XmlWriter& writeText(std::string const& text, bool indent = true)
+ {
+ if (!text.empty())
+ {
+ bool tagWasOpen = m_tagIsOpen;
+ ensureTagClosed();
+ if (tagWasOpen && indent)
+ stream() << m_indent;
+ stream() << XmlEncode(text);
+ m_needsNewline = true;
+ }
+ return *this;
+ }
+
+ XmlWriter& writeComment(std::string const& text)
+ {
+ ensureTagClosed();
+ stream() << m_indent << "<!--" << text << "-->";
+ m_needsNewline = true;
+ return *this;
+ }
+
+ XmlWriter& writeBlankLine()
+ {
+ ensureTagClosed();
+ stream() << "\n";
+ return *this;
+ }
+
+ void setStream(std::ostream& os)
+ {
+ m_os = &os;
+ }
+
+ private:
+ XmlWriter(XmlWriter const&);
+ void operator=(XmlWriter const&);
+
+ std::ostream& stream()
+ {
+ return *m_os;
+ }
+
+ void ensureTagClosed()
+ {
+ if (m_tagIsOpen)
+ {
+ stream() << ">\n";
+ m_tagIsOpen = false;
+ }
+ }
+
+ void newlineIfNecessary()
+ {
+ if (m_needsNewline)
+ {
+ stream() << "\n";
+ m_needsNewline = false;
+ }
+ }
+
+ bool m_tagIsOpen;
+ bool m_needsNewline;
+ std::vector<std::string> m_tags;
+ std::string m_indent;
+ std::ostream* m_os;
+};
+}
+// #included from: catch_reenable_warnings.h
+
+#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED
+
+#ifdef __clang__
+#ifdef __ICC // icpc defines the __clang__ macro
+#pragma warning(pop)
+#else
+#pragma clang diagnostic pop
+#endif
+#elif defined __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+namespace Catch {
+class XmlReporter : public StreamingReporterBase
+{
+ public:
+ XmlReporter(ReporterConfig const& _config)
+ : StreamingReporterBase(_config),
+ m_sectionDepth(0)
+ {
+ m_reporterPrefs.shouldRedirectStdOut = true;
+ }
+
+ virtual ~XmlReporter() CATCH_OVERRIDE;
+
+ static std::string getDescription()
+ {
+ return "Reports test results as an XML document";
+ }
+
+ public: // StreamingReporterBase
+ virtual void noMatchingTestCases(std::string const& s) CATCH_OVERRIDE
+ {
+ StreamingReporterBase::noMatchingTestCases(s);
+ }
+
+ virtual void testRunStarting(TestRunInfo const& testInfo) CATCH_OVERRIDE
+ {
+ StreamingReporterBase::testRunStarting(testInfo);
+ m_xml.setStream(stream);
+ m_xml.startElement("Catch");
+ if (!m_config->name().empty())
+ m_xml.writeAttribute("name", m_config->name());
+ }
+
+ virtual void testGroupStarting(GroupInfo const& groupInfo) CATCH_OVERRIDE
+ {
+ StreamingReporterBase::testGroupStarting(groupInfo);
+ m_xml.startElement("Group")
+ .writeAttribute("name", groupInfo.name);
+ }
+
+ virtual void testCaseStarting(TestCaseInfo const& testInfo) CATCH_OVERRIDE
+ {
+ StreamingReporterBase::testCaseStarting(testInfo);
+ m_xml.startElement("TestCase").writeAttribute("name", trim(testInfo.name));
+
+ if (m_config->showDurations() == ShowDurations::Always)
+ m_testCaseTimer.start();
+ }
+
+ virtual void sectionStarting(SectionInfo const& sectionInfo) CATCH_OVERRIDE
+ {
+ StreamingReporterBase::sectionStarting(sectionInfo);
+ if (m_sectionDepth++ > 0)
+ {
+ m_xml.startElement("Section")
+ .writeAttribute("name", trim(sectionInfo.name))
+ .writeAttribute("description", sectionInfo.description);
+ }
+ }
+
+ virtual void assertionStarting(AssertionInfo const&) CATCH_OVERRIDE {}
+
+ virtual bool assertionEnded(AssertionStats const& assertionStats) CATCH_OVERRIDE
+ {
+ const AssertionResult& assertionResult = assertionStats.assertionResult;
+
+ // Print any info messages in <Info> tags.
+ if (assertionStats.assertionResult.getResultType() != ResultWas::Ok)
+ {
+ for (std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
+ it != itEnd;
+ ++it)
+ {
+ if (it->type == ResultWas::Info)
+ {
+ m_xml.scopedElement("Info")
+ .writeText(it->message);
+ }
+ else if (it->type == ResultWas::Warning)
+ {
+ m_xml.scopedElement("Warning")
+ .writeText(it->message);
+ }
+ }
+ }
+
+ // Drop out if result was successful but we're not printing them.
+ if (!m_config->includeSuccessfulResults() && isOk(assertionResult.getResultType()))
+ return true;
+
+ // Print the expression if there is one.
+ if (assertionResult.hasExpression())
+ {
+ m_xml.startElement("Expression")
+ .writeAttribute("success", assertionResult.succeeded())
+ .writeAttribute("type", assertionResult.getTestMacroName())
+ .writeAttribute("filename", assertionResult.getSourceInfo().file)
+ .writeAttribute("line", assertionResult.getSourceInfo().line);
+
+ m_xml.scopedElement("Original")
+ .writeText(assertionResult.getExpression());
+ m_xml.scopedElement("Expanded")
+ .writeText(assertionResult.getExpandedExpression());
+ }
+
+ // And... Print a result applicable to each result type.
+ switch (assertionResult.getResultType())
+ {
+ case ResultWas::ThrewException:
+ m_xml.scopedElement("Exception")
+ .writeAttribute("filename", assertionResult.getSourceInfo().file)
+ .writeAttribute("line", assertionResult.getSourceInfo().line)
+ .writeText(assertionResult.getMessage());
+ break;
+ case ResultWas::FatalErrorCondition:
+ m_xml.scopedElement("Fatal Error Condition")
+ .writeAttribute("filename", assertionResult.getSourceInfo().file)
+ .writeAttribute("line", assertionResult.getSourceInfo().line)
+ .writeText(assertionResult.getMessage());
+ break;
+ case ResultWas::Info:
+ m_xml.scopedElement("Info")
+ .writeText(assertionResult.getMessage());
+ break;
+ case ResultWas::Warning:
+ // Warning will already have been written
+ break;
+ case ResultWas::ExplicitFailure:
+ m_xml.scopedElement("Failure")
+ .writeText(assertionResult.getMessage());
+ break;
+ default:
+ break;
+ }
+
+ if (assertionResult.hasExpression())
+ m_xml.endElement();
+
+ return true;
+ }
+
+ virtual void sectionEnded(SectionStats const& sectionStats) CATCH_OVERRIDE
+ {
+ StreamingReporterBase::sectionEnded(sectionStats);
+ if (--m_sectionDepth > 0)
+ {
+ XmlWriter::ScopedElement e = m_xml.scopedElement("OverallResults");
+ e.writeAttribute("successes", sectionStats.assertions.passed);
+ e.writeAttribute("failures", sectionStats.assertions.failed);
+ e.writeAttribute("expectedFailures", sectionStats.assertions.failedButOk);
+
+ if (m_config->showDurations() == ShowDurations::Always)
+ e.writeAttribute("durationInSeconds", sectionStats.durationInSeconds);
+
+ m_xml.endElement();
+ }
+ }
+
+ virtual void testCaseEnded(TestCaseStats const& testCaseStats) CATCH_OVERRIDE
+ {
+ StreamingReporterBase::testCaseEnded(testCaseStats);
+ XmlWriter::ScopedElement e = m_xml.scopedElement("OverallResult");
+ e.writeAttribute("success", testCaseStats.totals.assertions.allOk());
+
+ if (m_config->showDurations() == ShowDurations::Always)
+ e.writeAttribute("durationInSeconds", m_testCaseTimer.getElapsedSeconds());
+
+ m_xml.endElement();
+ }
+
+ virtual void testGroupEnded(TestGroupStats const& testGroupStats) CATCH_OVERRIDE
+ {
+ StreamingReporterBase::testGroupEnded(testGroupStats);
+ // TODO: Check testGroupStats.aborting and act accordingly.
+ m_xml.scopedElement("OverallResults")
+ .writeAttribute("successes", testGroupStats.totals.assertions.passed)
+ .writeAttribute("failures", testGroupStats.totals.assertions.failed)
+ .writeAttribute("expectedFailures", testGroupStats.totals.assertions.failedButOk);
+ m_xml.endElement();
+ }
+
+ virtual void testRunEnded(TestRunStats const& testRunStats) CATCH_OVERRIDE
+ {
+ StreamingReporterBase::testRunEnded(testRunStats);
+ m_xml.scopedElement("OverallResults")
+ .writeAttribute("successes", testRunStats.totals.assertions.passed)
+ .writeAttribute("failures", testRunStats.totals.assertions.failed)
+ .writeAttribute("expectedFailures", testRunStats.totals.assertions.failedButOk);
+ m_xml.endElement();
+ }
+
+ private:
+ Timer m_testCaseTimer;
+ XmlWriter m_xml;
+ int m_sectionDepth;
+};
+
+INTERNAL_CATCH_REGISTER_REPORTER("xml", XmlReporter)
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_junit.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED
+
+#include <assert.h>
+
+namespace Catch {
+
+class JunitReporter : public CumulativeReporterBase
+{
+ public:
+ JunitReporter(ReporterConfig const& _config)
+ : CumulativeReporterBase(_config),
+ xml(_config.stream())
+ {
+ m_reporterPrefs.shouldRedirectStdOut = true;
+ }
+
+ virtual ~JunitReporter() CATCH_OVERRIDE;
+
+ static std::string getDescription()
+ {
+ return "Reports test results in an XML format that looks like Ant's junitreport target";
+ }
+
+ virtual void noMatchingTestCases(std::string const& /*spec*/) CATCH_OVERRIDE {}
+
+ virtual void testRunStarting(TestRunInfo const& runInfo) CATCH_OVERRIDE
+ {
+ CumulativeReporterBase::testRunStarting(runInfo);
+ xml.startElement("testsuites");
+ }
+
+ virtual void testGroupStarting(GroupInfo const& groupInfo) CATCH_OVERRIDE
+ {
+ suiteTimer.start();
+ stdOutForSuite.str("");
+ stdErrForSuite.str("");
+ unexpectedExceptions = 0;
+ CumulativeReporterBase::testGroupStarting(groupInfo);
+ }
+
+ virtual bool assertionEnded(AssertionStats const& assertionStats) CATCH_OVERRIDE
+ {
+ if (assertionStats.assertionResult.getResultType() == ResultWas::ThrewException)
+ unexpectedExceptions++;
+ return CumulativeReporterBase::assertionEnded(assertionStats);
+ }
+
+ virtual void testCaseEnded(TestCaseStats const& testCaseStats) CATCH_OVERRIDE
+ {
+ stdOutForSuite << testCaseStats.stdOut;
+ stdErrForSuite << testCaseStats.stdErr;
+ CumulativeReporterBase::testCaseEnded(testCaseStats);
+ }
+
+ virtual void testGroupEnded(TestGroupStats const& testGroupStats) CATCH_OVERRIDE
+ {
+ double suiteTime = suiteTimer.getElapsedSeconds();
+ CumulativeReporterBase::testGroupEnded(testGroupStats);
+ writeGroup(*m_testGroups.back(), suiteTime);
+ }
+
+ virtual void testRunEndedCumulative() CATCH_OVERRIDE
+ {
+ xml.endElement();
+ }
+
+ void writeGroup(TestGroupNode const& groupNode, double suiteTime)
+ {
+ XmlWriter::ScopedElement e = xml.scopedElement("testsuite");
+ TestGroupStats const& stats = groupNode.value;
+ xml.writeAttribute("name", stats.groupInfo.name);
+ xml.writeAttribute("errors", unexpectedExceptions);
+ xml.writeAttribute("failures", stats.totals.assertions.failed - unexpectedExceptions);
+ xml.writeAttribute("tests", stats.totals.assertions.total());
+ xml.writeAttribute("hostname", "tbd"); // !TBD
+ if (m_config->showDurations() == ShowDurations::Never)
+ xml.writeAttribute("time", "");
+ else
+ xml.writeAttribute("time", suiteTime);
+ xml.writeAttribute("timestamp", "tbd"); // !TBD
+
+ // Write test cases
+ for (TestGroupNode::ChildNodes::const_iterator
+ it = groupNode.children.begin(),
+ itEnd = groupNode.children.end();
+ it != itEnd;
+ ++it)
+ writeTestCase(**it);
+
+ xml.scopedElement("system-out").writeText(trim(stdOutForSuite.str()), false);
+ xml.scopedElement("system-err").writeText(trim(stdErrForSuite.str()), false);
+ }
+
+ void writeTestCase(TestCaseNode const& testCaseNode)
+ {
+ TestCaseStats const& stats = testCaseNode.value;
+
+ // All test cases have exactly one section - which represents the
+ // test case itself. That section may have 0-n nested sections
+ assert(testCaseNode.children.size() == 1);
+ SectionNode const& rootSection = *testCaseNode.children.front();
+
+ std::string className = stats.testInfo.className;
+
+ if (className.empty())
+ {
+ if (rootSection.childSections.empty())
+ className = "global";
+ }
+ writeSection(className, "", rootSection);
+ }
+
+ void writeSection(std::string const& className,
+ std::string const& rootName,
+ SectionNode const& sectionNode)
+ {
+ std::string name = trim(sectionNode.stats.sectionInfo.name);
+ if (!rootName.empty())
+ name = rootName + "/" + name;
+
+ if (!sectionNode.assertions.empty() ||
+ !sectionNode.stdOut.empty() ||
+ !sectionNode.stdErr.empty())
+ {
+ XmlWriter::ScopedElement e = xml.scopedElement("testcase");
+ if (className.empty())
+ {
+ xml.writeAttribute("classname", name);
+ xml.writeAttribute("name", "root");
+ }
+ else
+ {
+ xml.writeAttribute("classname", className);
+ xml.writeAttribute("name", name);
+ }
+ xml.writeAttribute("time", Catch::toString(sectionNode.stats.durationInSeconds));
+
+ writeAssertions(sectionNode);
+
+ if (!sectionNode.stdOut.empty())
+ xml.scopedElement("system-out").writeText(trim(sectionNode.stdOut), false);
+ if (!sectionNode.stdErr.empty())
+ xml.scopedElement("system-err").writeText(trim(sectionNode.stdErr), false);
+ }
+ for (SectionNode::ChildSections::const_iterator
+ it = sectionNode.childSections.begin(),
+ itEnd = sectionNode.childSections.end();
+ it != itEnd;
+ ++it)
+ if (className.empty())
+ writeSection(name, "", **it);
+ else
+ writeSection(className, name, **it);
+ }
+
+ void writeAssertions(SectionNode const& sectionNode)
+ {
+ for (SectionNode::Assertions::const_iterator
+ it = sectionNode.assertions.begin(),
+ itEnd = sectionNode.assertions.end();
+ it != itEnd;
+ ++it)
+ writeAssertion(*it);
+ }
+ void writeAssertion(AssertionStats const& stats)
+ {
+ AssertionResult const& result = stats.assertionResult;
+ if (!result.isOk())
+ {
+ std::string elementName;
+ switch (result.getResultType())
+ {
+ case ResultWas::ThrewException:
+ case ResultWas::FatalErrorCondition:
+ elementName = "error";
+ break;
+ case ResultWas::ExplicitFailure:
+ elementName = "failure";
+ break;
+ case ResultWas::ExpressionFailed:
+ elementName = "failure";
+ break;
+ case ResultWas::DidntThrowException:
+ elementName = "failure";
+ break;
+
+ // We should never see these here:
+ case ResultWas::Info:
+ case ResultWas::Warning:
+ case ResultWas::Ok:
+ case ResultWas::Unknown:
+ case ResultWas::FailureBit:
+ case ResultWas::Exception:
+ elementName = "internalError";
+ break;
+ }
+
+ XmlWriter::ScopedElement e = xml.scopedElement(elementName);
+
+ xml.writeAttribute("message", result.getExpandedExpression());
+ xml.writeAttribute("type", result.getTestMacroName());
+
+ std::ostringstream oss;
+ if (!result.getMessage().empty())
+ oss << result.getMessage() << "\n";
+ for (std::vector<MessageInfo>::const_iterator
+ it = stats.infoMessages.begin(),
+ itEnd = stats.infoMessages.end();
+ it != itEnd;
+ ++it)
+ if (it->type == ResultWas::Info)
+ oss << it->message << "\n";
+
+ oss << "at " << result.getSourceInfo();
+ xml.writeText(oss.str(), false);
+ }
+ }
+
+ XmlWriter xml;
+ Timer suiteTimer;
+ std::ostringstream stdOutForSuite;
+ std::ostringstream stdErrForSuite;
+ unsigned int unexpectedExceptions;
+};
+
+INTERNAL_CATCH_REGISTER_REPORTER("junit", JunitReporter)
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_console.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+namespace Catch {
+
+struct ConsoleReporter : StreamingReporterBase
+{
+ ConsoleReporter(ReporterConfig const& _config)
+ : StreamingReporterBase(_config),
+ m_headerPrinted(false)
+ {
+ }
+
+ virtual ~ConsoleReporter() CATCH_OVERRIDE;
+ static std::string getDescription()
+ {
+ return "Reports test results as plain lines of text";
+ }
+
+ virtual void noMatchingTestCases(std::string const& spec) CATCH_OVERRIDE
+ {
+ stream << "No test cases matched '" << spec << "'" << std::endl;
+ }
+
+ virtual void assertionStarting(AssertionInfo const&) CATCH_OVERRIDE
+ {
+ }
+
+ virtual bool assertionEnded(AssertionStats const& _assertionStats) CATCH_OVERRIDE
+ {
+ AssertionResult const& result = _assertionStats.assertionResult;
+
+ bool printInfoMessages = true;
+
+ // Drop out if result was successful and we're not printing those
+ if (!m_config->includeSuccessfulResults() && result.isOk())
+ {
+ if (result.getResultType() != ResultWas::Warning)
+ return false;
+ printInfoMessages = false;
+ }
+
+ lazyPrint();
+
+ AssertionPrinter printer(stream, _assertionStats, printInfoMessages);
+ printer.print();
+ stream << std::endl;
+ return true;
+ }
+
+ virtual void sectionStarting(SectionInfo const& _sectionInfo) CATCH_OVERRIDE
+ {
+ m_headerPrinted = false;
+ StreamingReporterBase::sectionStarting(_sectionInfo);
+ }
+ virtual void sectionEnded(SectionStats const& _sectionStats) CATCH_OVERRIDE
+ {
+ if (_sectionStats.missingAssertions)
+ {
+ lazyPrint();
+ Colour colour(Colour::ResultError);
+ if (m_sectionStack.size() > 1)
+ stream << "\nNo assertions in section";
+ else
+ stream << "\nNo assertions in test case";
+ stream << " '" << _sectionStats.sectionInfo.name << "'\n"
+ << std::endl;
+ }
+ if (m_headerPrinted)
+ {
+ if (m_config->showDurations() == ShowDurations::Always)
+ stream << "Completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
+ m_headerPrinted = false;
+ }
+ else
+ {
+ if (m_config->showDurations() == ShowDurations::Always)
+ stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << std::endl;
+ }
+ StreamingReporterBase::sectionEnded(_sectionStats);
+ }
+
+ virtual void testCaseEnded(TestCaseStats const& _testCaseStats) CATCH_OVERRIDE
+ {
+ StreamingReporterBase::testCaseEnded(_testCaseStats);
+ m_headerPrinted = false;
+ }
+ virtual void testGroupEnded(TestGroupStats const& _testGroupStats) CATCH_OVERRIDE
+ {
+ if (currentGroupInfo.used)
+ {
+ printSummaryDivider();
+ stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+ printTotals(_testGroupStats.totals);
+ stream << "\n"
+ << std::endl;
+ }
+ StreamingReporterBase::testGroupEnded(_testGroupStats);
+ }
+ virtual void testRunEnded(TestRunStats const& _testRunStats) CATCH_OVERRIDE
+ {
+ printTotalsDivider(_testRunStats.totals);
+ printTotals(_testRunStats.totals);
+ stream << std::endl;
+ StreamingReporterBase::testRunEnded(_testRunStats);
+ }
+
+ private:
+ class AssertionPrinter
+ {
+ void operator=(AssertionPrinter const&);
+
+ public:
+ AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+ : stream(_stream),
+ stats(_stats),
+ result(_stats.assertionResult),
+ colour(Colour::None),
+ message(result.getMessage()),
+ messages(_stats.infoMessages),
+ printInfoMessages(_printInfoMessages)
+ {
+ switch (result.getResultType())
+ {
+ case ResultWas::Ok:
+ colour = Colour::Success;
+ passOrFail = "PASSED";
+ //if( result.hasMessage() )
+ if (_stats.infoMessages.size() == 1)
+ messageLabel = "with message";
+ if (_stats.infoMessages.size() > 1)
+ messageLabel = "with messages";
+ break;
+ case ResultWas::ExpressionFailed:
+ if (result.isOk())
+ {
+ colour = Colour::Success;
+ passOrFail = "FAILED - but was ok";
+ }
+ else
+ {
+ colour = Colour::Error;
+ passOrFail = "FAILED";
+ }
+ if (_stats.infoMessages.size() == 1)
+ messageLabel = "with message";
+ if (_stats.infoMessages.size() > 1)
+ messageLabel = "with messages";
+ break;
+ case ResultWas::ThrewException:
+ colour = Colour::Error;
+ passOrFail = "FAILED";
+ messageLabel = "due to unexpected exception with message";
+ break;
+ case ResultWas::FatalErrorCondition:
+ colour = Colour::Error;
+ passOrFail = "FAILED";
+ messageLabel = "due to a fatal error condition";
+ break;
+ case ResultWas::DidntThrowException:
+ colour = Colour::Error;
+ passOrFail = "FAILED";
+ messageLabel = "because no exception was thrown where one was expected";
+ break;
+ case ResultWas::Info:
+ messageLabel = "info";
+ break;
+ case ResultWas::Warning:
+ messageLabel = "warning";
+ break;
+ case ResultWas::ExplicitFailure:
+ passOrFail = "FAILED";
+ colour = Colour::Error;
+ if (_stats.infoMessages.size() == 1)
+ messageLabel = "explicitly with message";
+ if (_stats.infoMessages.size() > 1)
+ messageLabel = "explicitly with messages";
+ break;
+ // These cases are here to prevent compiler warnings
+ case ResultWas::Unknown:
+ case ResultWas::FailureBit:
+ case ResultWas::Exception:
+ passOrFail = "** internal error **";
+ colour = Colour::Error;
+ break;
+ }
+ }
+
+ void print() const
+ {
+ printSourceInfo();
+ if (stats.totals.assertions.total() > 0)
+ {
+ if (result.isOk())
+ stream << "\n";
+ printResultType();
+ printOriginalExpression();
+ printReconstructedExpression();
+ }
+ else
+ {
+ stream << "\n";
+ }
+ printMessage();
+ }
+
+ private:
+ void printResultType() const
+ {
+ if (!passOrFail.empty())
+ {
+ Colour colourGuard(colour);
+ stream << passOrFail << ":\n";
+ }
+ }
+ void printOriginalExpression() const
+ {
+ if (result.hasExpression())
+ {
+ Colour colourGuard(Colour::OriginalExpression);
+ stream << " ";
+ stream << result.getExpressionInMacro();
+ stream << "\n";
+ }
+ }
+ void printReconstructedExpression() const
+ {
+ if (result.hasExpandedExpression())
+ {
+ stream << "with expansion:\n";
+ Colour colourGuard(Colour::ReconstructedExpression);
+ stream << Text(result.getExpandedExpression(), TextAttributes().setIndent(2)) << "\n";
+ }
+ }
+ void printMessage() const
+ {
+ if (!messageLabel.empty())
+ stream << messageLabel << ":"
+ << "\n";
+ for (std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
+ it != itEnd;
+ ++it)
+ {
+ // If this assertion is a warning ignore any INFO messages
+ if (printInfoMessages || it->type != ResultWas::Info)
+ stream << Text(it->message, TextAttributes().setIndent(2)) << "\n";
+ }
+ }
+ void printSourceInfo() const
+ {
+ Colour colourGuard(Colour::FileName);
+ stream << result.getSourceInfo() << ": ";
+ }
+
+ std::ostream& stream;
+ AssertionStats const& stats;
+ AssertionResult const& result;
+ Colour::Code colour;
+ std::string passOrFail;
+ std::string messageLabel;
+ std::string message;
+ std::vector<MessageInfo> messages;
+ bool printInfoMessages;
+ };
+
+ void lazyPrint()
+ {
+
+ if (!currentTestRunInfo.used)
+ lazyPrintRunInfo();
+ if (!currentGroupInfo.used)
+ lazyPrintGroupInfo();
+
+ if (!m_headerPrinted)
+ {
+ printTestCaseAndSectionHeader();
+ m_headerPrinted = true;
+ }
+ }
+ void lazyPrintRunInfo()
+ {
+ stream << "\n"
+ << getLineOfChars<'~'>() << "\n";
+ Colour colour(Colour::SecondaryText);
+ stream << currentTestRunInfo->name
+ << " is a Catch v" << libraryVersion << " host application.\n"
+ << "Run with -? for options\n\n";
+
+ if (m_config->rngSeed() != 0)
+ stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
+
+ currentTestRunInfo.used = true;
+ }
+ void lazyPrintGroupInfo()
+ {
+ if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1)
+ {
+ printClosedHeader("Group: " + currentGroupInfo->name);
+ currentGroupInfo.used = true;
+ }
+ }
+ void printTestCaseAndSectionHeader()
+ {
+ assert(!m_sectionStack.empty());
+ printOpenHeader(currentTestCaseInfo->name);
+
+ if (m_sectionStack.size() > 1)
+ {
+ Colour colourGuard(Colour::Headers);
+
+ std::vector<SectionInfo>::const_iterator
+ it = m_sectionStack.begin() + 1, // Skip first section (test case)
+ itEnd = m_sectionStack.end();
+ for (; it != itEnd; ++it)
+ printHeaderString(it->name, 2);
+ }
+
+ SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+ if (!lineInfo.empty())
+ {
+ stream << getLineOfChars<'-'>() << "\n";
+ Colour colourGuard(Colour::FileName);
+ stream << lineInfo << "\n";
+ }
+ stream << getLineOfChars<'.'>() << "\n"
+ << std::endl;
+ }
+
+ void printClosedHeader(std::string const& _name)
+ {
+ printOpenHeader(_name);
+ stream << getLineOfChars<'.'>() << "\n";
+ }
+ void printOpenHeader(std::string const& _name)
+ {
+ stream << getLineOfChars<'-'>() << "\n";
+ {
+ Colour colourGuard(Colour::Headers);
+ printHeaderString(_name);
+ }
+ }
+
+ // if string has a : in first line will set indent to follow it on
+ // subsequent lines
+ void printHeaderString(std::string const& _string, std::size_t indent = 0)
+ {
+ std::size_t i = _string.find(": ");
+ if (i != std::string::npos)
+ i += 2;
+ else
+ i = 0;
+ stream << Text(_string, TextAttributes()
+ .setIndent(indent + i)
+ .setInitialIndent(indent))
+ << "\n";
+ }
+
+ struct SummaryColumn
+ {
+
+ SummaryColumn(std::string const& _label, Colour::Code _colour)
+ : label(_label),
+ colour(_colour)
+ {
+ }
+ SummaryColumn addRow(std::size_t count)
+ {
+ std::ostringstream oss;
+ oss << count;
+ std::string row = oss.str();
+ for (std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it)
+ {
+ while (it->size() < row.size())
+ *it = " " + *it;
+ while (it->size() > row.size())
+ row = " " + row;
+ }
+ rows.push_back(row);
+ return *this;
+ }
+
+ std::string label;
+ Colour::Code colour;
+ std::vector<std::string> rows;
+ };
+
+ void printTotals(Totals const& totals)
+ {
+ if (totals.testCases.total() == 0)
+ {
+ stream << Colour(Colour::Warning) << "No tests ran\n";
+ }
+ else if (totals.assertions.total() > 0 && totals.assertions.allPassed())
+ {
+ stream << Colour(Colour::ResultSuccess) << "All tests passed";
+ stream << " ("
+ << pluralise(totals.assertions.passed, "assertion") << " in "
+ << pluralise(totals.testCases.passed, "test case") << ")"
+ << "\n";
+ }
+ else
+ {
+
+ std::vector<SummaryColumn> columns;
+ columns.push_back(SummaryColumn("", Colour::None)
+ .addRow(totals.testCases.total())
+ .addRow(totals.assertions.total()));
+ columns.push_back(SummaryColumn("passed", Colour::Success)
+ .addRow(totals.testCases.passed)
+ .addRow(totals.assertions.passed));
+ columns.push_back(SummaryColumn("failed", Colour::ResultError)
+ .addRow(totals.testCases.failed)
+ .addRow(totals.assertions.failed));
+ columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
+ .addRow(totals.testCases.failedButOk)
+ .addRow(totals.assertions.failedButOk));
+
+ printSummaryRow("test cases", columns, 0);
+ printSummaryRow("assertions", columns, 1);
+ }
+ }
+ void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row)
+ {
+ for (std::vector<SummaryColumn>::const_iterator it = cols.begin(); it != cols.end(); ++it)
+ {
+ std::string value = it->rows[row];
+ if (it->label.empty())
+ {
+ stream << label << ": ";
+ if (value != "0")
+ stream << value;
+ else
+ stream << Colour(Colour::Warning) << "- none -";
+ }
+ else if (value != "0")
+ {
+ stream << Colour(Colour::LightGrey) << " | ";
+ stream << Colour(it->colour)
+ << value << " " << it->label;
+ }
+ }
+ stream << "\n";
+ }
+
+ static std::size_t makeRatio(std::size_t number, std::size_t total)
+ {
+ std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+ return (ratio == 0 && number > 0) ? 1 : ratio;
+ }
+ static std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k)
+ {
+ if (i > j && i > k)
+ return i;
+ else if (j > k)
+ return j;
+ else
+ return k;
+ }
+
+ void printTotalsDivider(Totals const& totals)
+ {
+ if (totals.testCases.total() > 0)
+ {
+ std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
+ std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
+ std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
+ while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+ findMax(failedRatio, failedButOkRatio, passedRatio)++;
+ while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
+ findMax(failedRatio, failedButOkRatio, passedRatio)--;
+
+ stream << Colour(Colour::Error) << std::string(failedRatio, '=');
+ stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
+ if (totals.testCases.allPassed())
+ stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
+ else
+ stream << Colour(Colour::Success) << std::string(passedRatio, '=');
+ }
+ else
+ {
+ stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
+ }
+ stream << "\n";
+ }
+ void printSummaryDivider()
+ {
+ stream << getLineOfChars<'-'>() << "\n";
+ }
+
+ private:
+ bool m_headerPrinted;
+};
+
+INTERNAL_CATCH_REGISTER_REPORTER("console", ConsoleReporter)
+
+} // end namespace Catch
+
+// #included from: ../reporters/catch_reporter_compact.hpp
+#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED
+
+namespace Catch {
+
+struct CompactReporter : StreamingReporterBase
+{
+
+ CompactReporter(ReporterConfig const& _config)
+ : StreamingReporterBase(_config)
+ {
+ }
+
+ virtual ~CompactReporter();
+
+ static std::string getDescription()
+ {
+ return "Reports test results on a single line, suitable for IDEs";
+ }
+
+ virtual ReporterPreferences getPreferences() const
+ {
+ ReporterPreferences prefs;
+ prefs.shouldRedirectStdOut = false;
+ return prefs;
+ }
+
+ virtual void noMatchingTestCases(std::string const& spec)
+ {
+ stream << "No test cases matched '" << spec << "'" << std::endl;
+ }
+
+ virtual void assertionStarting(AssertionInfo const&)
+ {
+ }
+
+ virtual bool assertionEnded(AssertionStats const& _assertionStats)
+ {
+ AssertionResult const& result = _assertionStats.assertionResult;
+
+ bool printInfoMessages = true;
+
+ // Drop out if result was successful and we're not printing those
+ if (!m_config->includeSuccessfulResults() && result.isOk())
+ {
+ if (result.getResultType() != ResultWas::Warning)
+ return false;
+ printInfoMessages = false;
+ }
+
+ AssertionPrinter printer(stream, _assertionStats, printInfoMessages);
+ printer.print();
+
+ stream << std::endl;
+ return true;
+ }
+
+ virtual void testRunEnded(TestRunStats const& _testRunStats)
+ {
+ printTotals(_testRunStats.totals);
+ stream << "\n"
+ << std::endl;
+ StreamingReporterBase::testRunEnded(_testRunStats);
+ }
+
+ private:
+ class AssertionPrinter
+ {
+ void operator=(AssertionPrinter const&);
+
+ public:
+ AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+ : stream(_stream), stats(_stats), result(_stats.assertionResult), messages(_stats.infoMessages), itMessage(_stats.infoMessages.begin()), printInfoMessages(_printInfoMessages)
+ {
+ }
+
+ void print()
+ {
+ printSourceInfo();
+
+ itMessage = messages.begin();
+
+ switch (result.getResultType())
+ {
+ case ResultWas::Ok:
+ printResultType(Colour::ResultSuccess, passedString());
+ printOriginalExpression();
+ printReconstructedExpression();
+ if (!result.hasExpression())
+ printRemainingMessages(Colour::None);
+ else
+ printRemainingMessages();
+ break;
+ case ResultWas::ExpressionFailed:
+ if (result.isOk())
+ printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
+ else
+ printResultType(Colour::Error, failedString());
+ printOriginalExpression();
+ printReconstructedExpression();
+ printRemainingMessages();
+ break;
+ case ResultWas::ThrewException:
+ printResultType(Colour::Error, failedString());
+ printIssue("unexpected exception with message:");
+ printMessage();
+ printExpressionWas();
+ printRemainingMessages();
+ break;
+ case ResultWas::FatalErrorCondition:
+ printResultType(Colour::Error, failedString());
+ printIssue("fatal error condition with message:");
+ printMessage();
+ printExpressionWas();
+ printRemainingMessages();
+ break;
+ case ResultWas::DidntThrowException:
+ printResultType(Colour::Error, failedString());
+ printIssue("expected exception, got none");
+ printExpressionWas();
+ printRemainingMessages();
+ break;
+ case ResultWas::Info:
+ printResultType(Colour::None, "info");
+ printMessage();
+ printRemainingMessages();
+ break;
+ case ResultWas::Warning:
+ printResultType(Colour::None, "warning");
+ printMessage();
+ printRemainingMessages();
+ break;
+ case ResultWas::ExplicitFailure:
+ printResultType(Colour::Error, failedString());
+ printIssue("explicitly");
+ printRemainingMessages(Colour::None);
+ break;
+ // These cases are here to prevent compiler warnings
+ case ResultWas::Unknown:
+ case ResultWas::FailureBit:
+ case ResultWas::Exception:
+ printResultType(Colour::Error, "** internal error **");
+ break;
+ }
+ }
+
+ private:
+ // Colour::LightGrey
+
+ static Colour::Code dimColour() { return Colour::FileName; }
+
+#ifdef CATCH_PLATFORM_MAC
+ static const char* failedString()
+ {
+ return "FAILED";
+ }
+ static const char* passedString() { return "PASSED"; }
+#else
+ static const char* failedString()
+ {
+ return "failed";
+ }
+ static const char* passedString() { return "passed"; }
+#endif
+
+ void printSourceInfo() const
+ {
+ Colour colourGuard(Colour::FileName);
+ stream << result.getSourceInfo() << ":";
+ }
+
+ void printResultType(Colour::Code colour, std::string passOrFail) const
+ {
+ if (!passOrFail.empty())
+ {
+ {
+ Colour colourGuard(colour);
+ stream << " " << passOrFail;
+ }
+ stream << ":";
+ }
+ }
+
+ void printIssue(std::string issue) const
+ {
+ stream << " " << issue;
+ }
+
+ void printExpressionWas()
+ {
+ if (result.hasExpression())
+ {
+ stream << ";";
+ {
+ Colour colour(dimColour());
+ stream << " expression was:";
+ }
+ printOriginalExpression();
+ }
+ }
+
+ void printOriginalExpression() const
+ {
+ if (result.hasExpression())
+ {
+ stream << " " << result.getExpression();
+ }
+ }
+
+ void printReconstructedExpression() const
+ {
+ if (result.hasExpandedExpression())
+ {
+ {
+ Colour colour(dimColour());
+ stream << " for: ";
+ }
+ stream << result.getExpandedExpression();
+ }
+ }
+
+ void printMessage()
+ {
+ if (itMessage != messages.end())
+ {
+ stream << " '" << itMessage->message << "'";
+ ++itMessage;
+ }
+ }
+
+ void printRemainingMessages(Colour::Code colour = dimColour())
+ {
+ if (itMessage == messages.end())
+ return;
+
+ // using messages.end() directly yields compilation error:
+ std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+ const std::size_t N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+
+ {
+ Colour colourGuard(colour);
+ stream << " with " << pluralise(N, "message") << ":";
+ }
+
+ for (; itMessage != itEnd;)
+ {
+ // If this assertion is a warning ignore any INFO messages
+ if (printInfoMessages || itMessage->type != ResultWas::Info)
+ {
+ stream << " '" << itMessage->message << "'";
+ if (++itMessage != itEnd)
+ {
+ Colour colourGuard(dimColour());
+ stream << " and";
+ }
+ }
+ }
+ }
+
+ private:
+ std::ostream& stream;
+ AssertionStats const& stats;
+ AssertionResult const& result;
+ std::vector<MessageInfo> messages;
+ std::vector<MessageInfo>::const_iterator itMessage;
+ bool printInfoMessages;
+ };
+
+ // Colour, message variants:
+ // - white: No tests ran.
+ // - red: Failed [both/all] N test cases, failed [both/all] M assertions.
+ // - white: Passed [both/all] N test cases (no assertions).
+ // - red: Failed N tests cases, failed M assertions.
+ // - green: Passed [both/all] N tests cases with M assertions.
+
+ std::string bothOrAll(std::size_t count) const
+ {
+ return count == 1 ? "" : count == 2 ? "both " : "all ";
+ }
+
+ void printTotals(const Totals& totals) const
+ {
+ if (totals.testCases.total() == 0)
+ {
+ stream << "No tests ran.";
+ }
+ else if (totals.testCases.failed == totals.testCases.total())
+ {
+ Colour colour(Colour::ResultError);
+ const std::string qualify_assertions_failed =
+ totals.assertions.failed == totals.assertions.total() ? bothOrAll(totals.assertions.failed) : "";
+ stream << "Failed " << bothOrAll(totals.testCases.failed)
+ << pluralise(totals.testCases.failed, "test case") << ", "
+ "failed "
+ << qualify_assertions_failed << pluralise(totals.assertions.failed, "assertion") << ".";
+ }
+ else if (totals.assertions.total() == 0)
+ {
+ stream << "Passed " << bothOrAll(totals.testCases.total())
+ << pluralise(totals.testCases.total(), "test case")
+ << " (no assertions).";
+ }
+ else if (totals.assertions.failed)
+ {
+ Colour colour(Colour::ResultError);
+ stream << "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
+ "failed "
+ << pluralise(totals.assertions.failed, "assertion") << ".";
+ }
+ else
+ {
+ Colour colour(Colour::ResultSuccess);
+ stream << "Passed " << bothOrAll(totals.testCases.passed)
+ << pluralise(totals.testCases.passed, "test case") << " with " << pluralise(totals.assertions.passed, "assertion") << ".";
+ }
+ }
+};
+
+INTERNAL_CATCH_REGISTER_REPORTER("compact", CompactReporter)
+
+} // end namespace Catch
+
+namespace Catch {
+// These are all here to avoid warnings about not having any out of line
+// virtual methods
+NonCopyable::~NonCopyable() {}
+IShared::~IShared() {}
+IStream::~IStream() CATCH_NOEXCEPT {}
+FileStream::~FileStream() CATCH_NOEXCEPT {}
+CoutStream::~CoutStream() CATCH_NOEXCEPT {}
+DebugOutStream::~DebugOutStream() CATCH_NOEXCEPT {}
+StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {}
+IContext::~IContext() {}
+IResultCapture::~IResultCapture() {}
+ITestCase::~ITestCase() {}
+ITestCaseRegistry::~ITestCaseRegistry() {}
+IRegistryHub::~IRegistryHub() {}
+IMutableRegistryHub::~IMutableRegistryHub() {}
+IExceptionTranslator::~IExceptionTranslator() {}
+IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {}
+IReporter::~IReporter() {}
+IReporterFactory::~IReporterFactory() {}
+IReporterRegistry::~IReporterRegistry() {}
+IStreamingReporter::~IStreamingReporter() {}
+AssertionStats::~AssertionStats() {}
+SectionStats::~SectionStats() {}
+TestCaseStats::~TestCaseStats() {}
+TestGroupStats::~TestGroupStats() {}
+TestRunStats::~TestRunStats() {}
+CumulativeReporterBase::SectionNode::~SectionNode() {}
+CumulativeReporterBase::~CumulativeReporterBase() {}
+
+StreamingReporterBase::~StreamingReporterBase() {}
+ConsoleReporter::~ConsoleReporter() {}
+CompactReporter::~CompactReporter() {}
+IRunner::~IRunner() {}
+IMutableContext::~IMutableContext() {}
+IConfig::~IConfig() {}
+XmlReporter::~XmlReporter() {}
+JunitReporter::~JunitReporter() {}
+TestRegistry::~TestRegistry() {}
+FreeFunctionTestCase::~FreeFunctionTestCase() {}
+IGeneratorInfo::~IGeneratorInfo() {}
+IGeneratorsForTest::~IGeneratorsForTest() {}
+WildcardPattern::~WildcardPattern() {}
+TestSpec::Pattern::~Pattern() {}
+TestSpec::NamePattern::~NamePattern() {}
+TestSpec::TagPattern::~TagPattern() {}
+TestSpec::ExcludedPattern::~ExcludedPattern() {}
+
+Matchers::Impl::StdString::Equals::~Equals() {}
+Matchers::Impl::StdString::Contains::~Contains() {}
+Matchers::Impl::StdString::StartsWith::~StartsWith() {}
+Matchers::Impl::StdString::EndsWith::~EndsWith() {}
+
+void Config::dummy() {}
+
+namespace TestCaseTracking {
+ITracker::~ITracker() {}
+TrackerBase::~TrackerBase() {}
+SectionTracker::~SectionTracker() {}
+IndexTracker::~IndexTracker() {}
+}
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif
+
+#ifdef CATCH_CONFIG_MAIN
+// #included from: internal/catch_default_main.hpp
+#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
+
+#ifndef __OBJC__
+
+// Standard C/C++ main entry point
+int main(int argc, char* argv[])
+{
+ return Catch::Session().run(argc, argv);
+}
+
+#else // __OBJC__
+
+// Objective-C entry point
+int main(int argc, char* const argv[])
+{
+#if !CATCH_ARC_ENABLED
+ NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+#endif
+
+ Catch::registerTestMethods();
+ int result = Catch::Session().run(argc, (char* const*)argv);
+
+#if !CATCH_ARC_ENABLED
+ [pool drain];
+#endif
+
+ return result;
+}
+
+#endif // __OBJC__
+
+#endif
+
+#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
+#undef CLARA_CONFIG_MAIN
+#endif
+
+//////
+
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE(expr) INTERNAL_CATCH_TEST(expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE")
+#define CATCH_REQUIRE_FALSE(expr) INTERNAL_CATCH_TEST(expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "CATCH_REQUIRE_FALSE")
+
+#define CATCH_REQUIRE_THROWS(expr) INTERNAL_CATCH_THROWS(expr, Catch::ResultDisposition::Normal, "", "CATCH_REQUIRE_THROWS")
+#define CATCH_REQUIRE_THROWS_AS(expr, exceptionType) INTERNAL_CATCH_THROWS_AS(expr, exceptionType, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THROWS_AS")
+#define CATCH_REQUIRE_THROWS_WITH(expr, matcher) INTERNAL_CATCH_THROWS(expr, Catch::ResultDisposition::Normal, matcher, "CATCH_REQUIRE_THROWS_WITH")
+#define CATCH_REQUIRE_NOTHROW(expr) INTERNAL_CATCH_NO_THROW(expr, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_NOTHROW")
+
+#define CATCH_CHECK(expr) INTERNAL_CATCH_TEST(expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK")
+#define CATCH_CHECK_FALSE(expr) INTERNAL_CATCH_TEST(expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CATCH_CHECK_FALSE")
+#define CATCH_CHECKED_IF(expr) INTERNAL_CATCH_IF(expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_IF")
+#define CATCH_CHECKED_ELSE(expr) INTERNAL_CATCH_ELSE(expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECKED_ELSE")
+#define CATCH_CHECK_NOFAIL(expr) INTERNAL_CATCH_TEST(expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CATCH_CHECK_NOFAIL")
+
+#define CATCH_CHECK_THROWS(expr) INTERNAL_CATCH_THROWS(expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS")
+#define CATCH_CHECK_THROWS_AS(expr, exceptionType) INTERNAL_CATCH_THROWS_AS(expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THROWS_AS")
+#define CATCH_CHECK_THROWS_WITH(expr, matcher) INTERNAL_CATCH_THROWS(expr, Catch::ResultDisposition::ContinueOnFailure, matcher, "CATCH_CHECK_THROWS_WITH")
+#define CATCH_CHECK_NOTHROW(expr) INTERNAL_CATCH_NO_THROW(expr, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_NOTHROW")
+
+#define CHECK_THAT(arg, matcher) INTERNAL_CHECK_THAT(arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CATCH_CHECK_THAT")
+#define CATCH_REQUIRE_THAT(arg, matcher) INTERNAL_CHECK_THAT(arg, matcher, Catch::ResultDisposition::Normal, "CATCH_REQUIRE_THAT")
+
+#define CATCH_INFO(msg) INTERNAL_CATCH_INFO(msg, "CATCH_INFO")
+#define CATCH_WARN(msg) INTERNAL_CATCH_MSG(Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "CATCH_WARN", msg)
+#define CATCH_SCOPED_INFO(msg) INTERNAL_CATCH_INFO(msg, "CATCH_INFO")
+#define CATCH_CAPTURE(msg) INTERNAL_CATCH_INFO(#msg " := " << msg, "CATCH_CAPTURE")
+#define CATCH_SCOPED_CAPTURE(msg) INTERNAL_CATCH_INFO(#msg " := " << msg, "CATCH_CAPTURE")
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define CATCH_TEST_CASE(...) INTERNAL_CATCH_TESTCASE(__VA_ARGS__)
+#define CATCH_TEST_CASE_METHOD(className, ...) INTERNAL_CATCH_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define CATCH_METHOD_AS_TEST_CASE(method, ...) INTERNAL_CATCH_METHOD_AS_TEST_CASE(method, __VA_ARGS__)
+#define CATCH_REGISTER_TEST_CASE(...) INTERNAL_CATCH_REGISTER_TESTCASE(__VA_ARGS__)
+#define CATCH_SECTION(...) INTERNAL_CATCH_SECTION(__VA_ARGS__)
+#define CATCH_FAIL(...) INTERNAL_CATCH_MSG(Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__)
+#define CATCH_SUCCEED(...) INTERNAL_CATCH_MSG(Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", __VA_ARGS__)
+#else
+#define CATCH_TEST_CASE(name, description) INTERNAL_CATCH_TESTCASE(name, description)
+#define CATCH_TEST_CASE_METHOD(className, name, description) INTERNAL_CATCH_TEST_CASE_METHOD(className, name, description)
+#define CATCH_METHOD_AS_TEST_CASE(method, name, description) INTERNAL_CATCH_METHOD_AS_TEST_CASE(method, name, description)
+#define CATCH_REGISTER_TEST_CASE(function, name, description) INTERNAL_CATCH_REGISTER_TESTCASE(function, name, description)
+#define CATCH_SECTION(name, description) INTERNAL_CATCH_SECTION(name, description)
+#define CATCH_FAIL(msg) INTERNAL_CATCH_MSG(Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", msg)
+#define CATCH_SUCCEED(msg) INTERNAL_CATCH_MSG(Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "CATCH_SUCCEED", msg)
+#endif
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE("", "")
+
+#define CATCH_REGISTER_REPORTER(name, reporterType) INTERNAL_CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LEGACY_REPORTER(name, reporterType) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER(name, reporterType)
+
+#define CATCH_GENERATE(expr) INTERNAL_CATCH_GENERATE(expr)
+
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define CATCH_SCENARIO(...) CATCH_TEST_CASE("Scenario: " __VA_ARGS__)
+#define CATCH_SCENARIO_METHOD(className, ...) INTERNAL_CATCH_TEST_CASE_METHOD(className, "Scenario: " __VA_ARGS__)
+#else
+#define CATCH_SCENARIO(name, tags) CATCH_TEST_CASE("Scenario: " name, tags)
+#define CATCH_SCENARIO_METHOD(className, name, tags) INTERNAL_CATCH_TEST_CASE_METHOD(className, "Scenario: " name, tags)
+#endif
+#define CATCH_GIVEN(desc) CATCH_SECTION(std::string("Given: ") + desc, "")
+#define CATCH_WHEN(desc) CATCH_SECTION(std::string(" When: ") + desc, "")
+#define CATCH_AND_WHEN(desc) CATCH_SECTION(std::string(" And: ") + desc, "")
+#define CATCH_THEN(desc) CATCH_SECTION(std::string(" Then: ") + desc, "")
+#define CATCH_AND_THEN(desc) CATCH_SECTION(std::string(" And: ") + desc, "")
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE(expr) INTERNAL_CATCH_TEST(expr, Catch::ResultDisposition::Normal, "REQUIRE")
+#define REQUIRE_FALSE(expr) INTERNAL_CATCH_TEST(expr, Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, "REQUIRE_FALSE")
+
+#define REQUIRE_THROWS(expr) INTERNAL_CATCH_THROWS(expr, Catch::ResultDisposition::Normal, "", "REQUIRE_THROWS")
+#define REQUIRE_THROWS_AS(expr, exceptionType) INTERNAL_CATCH_THROWS_AS(expr, exceptionType, Catch::ResultDisposition::Normal, "REQUIRE_THROWS_AS")
+#define REQUIRE_THROWS_WITH(expr, matcher) INTERNAL_CATCH_THROWS(expr, Catch::ResultDisposition::Normal, matcher, "REQUIRE_THROWS_WITH")
+#define REQUIRE_NOTHROW(expr) INTERNAL_CATCH_NO_THROW(expr, Catch::ResultDisposition::Normal, "REQUIRE_NOTHROW")
+
+#define CHECK(expr) INTERNAL_CATCH_TEST(expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK")
+#define CHECK_FALSE(expr) INTERNAL_CATCH_TEST(expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, "CHECK_FALSE")
+#define CHECKED_IF(expr) INTERNAL_CATCH_IF(expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_IF")
+#define CHECKED_ELSE(expr) INTERNAL_CATCH_ELSE(expr, Catch::ResultDisposition::ContinueOnFailure, "CHECKED_ELSE")
+#define CHECK_NOFAIL(expr) INTERNAL_CATCH_TEST(expr, Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, "CHECK_NOFAIL")
+
+#define CHECK_THROWS(expr) INTERNAL_CATCH_THROWS(expr, Catch::ResultDisposition::ContinueOnFailure, "", "CHECK_THROWS")
+#define CHECK_THROWS_AS(expr, exceptionType) INTERNAL_CATCH_THROWS_AS(expr, exceptionType, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THROWS_AS")
+#define CHECK_THROWS_WITH(expr, matcher) INTERNAL_CATCH_THROWS(expr, Catch::ResultDisposition::ContinueOnFailure, matcher, "CHECK_THROWS_WITH")
+#define CHECK_NOTHROW(expr) INTERNAL_CATCH_NO_THROW(expr, Catch::ResultDisposition::ContinueOnFailure, "CHECK_NOTHROW")
+
+#define CHECK_THAT(arg, matcher) INTERNAL_CHECK_THAT(arg, matcher, Catch::ResultDisposition::ContinueOnFailure, "CHECK_THAT")
+#define REQUIRE_THAT(arg, matcher) INTERNAL_CHECK_THAT(arg, matcher, Catch::ResultDisposition::Normal, "REQUIRE_THAT")
+
+#define INFO(msg) INTERNAL_CATCH_INFO(msg, "INFO")
+#define WARN(msg) INTERNAL_CATCH_MSG(Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, "WARN", msg)
+#define SCOPED_INFO(msg) INTERNAL_CATCH_INFO(msg, "INFO")
+#define CAPTURE(msg) INTERNAL_CATCH_INFO(#msg " := " << msg, "CAPTURE")
+#define SCOPED_CAPTURE(msg) INTERNAL_CATCH_INFO(#msg " := " << msg, "CAPTURE")
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define TEST_CASE(...) INTERNAL_CATCH_TESTCASE(__VA_ARGS__)
+#define TEST_CASE_METHOD(className, ...) INTERNAL_CATCH_TEST_CASE_METHOD(className, __VA_ARGS__)
+#define METHOD_AS_TEST_CASE(method, ...) INTERNAL_CATCH_METHOD_AS_TEST_CASE(method, __VA_ARGS__)
+#define REGISTER_TEST_CASE(...) INTERNAL_CATCH_REGISTER_TESTCASE(__VA_ARGS__)
+#define SECTION(...) INTERNAL_CATCH_SECTION(__VA_ARGS__)
+#define FAIL(...) INTERNAL_CATCH_MSG(Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", __VA_ARGS__)
+#define SUCCEED(...) INTERNAL_CATCH_MSG(Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", __VA_ARGS__)
+#else
+#define TEST_CASE(name, description) INTERNAL_CATCH_TESTCASE(name, description)
+#define TEST_CASE_METHOD(className, name, description) INTERNAL_CATCH_TEST_CASE_METHOD(className, name, description)
+#define METHOD_AS_TEST_CASE(method, name, description) INTERNAL_CATCH_METHOD_AS_TEST_CASE(method, name, description)
+#define REGISTER_TEST_CASE(method, name, description) INTERNAL_CATCH_REGISTER_TESTCASE(method, name, description)
+#define SECTION(name, description) INTERNAL_CATCH_SECTION(name, description)
+#define FAIL(msg) INTERNAL_CATCH_MSG(Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "FAIL", msg)
+#define SUCCEED(msg) INTERNAL_CATCH_MSG(Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, "SUCCEED", msg)
+#endif
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE("", "")
+
+#define REGISTER_REPORTER(name, reporterType) INTERNAL_CATCH_REGISTER_REPORTER(name, reporterType)
+#define REGISTER_LEGACY_REPORTER(name, reporterType) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER(name, reporterType)
+
+#define GENERATE(expr) INTERNAL_CATCH_GENERATE(expr)
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION(signature) INTERNAL_CATCH_TRANSLATE_EXCEPTION(signature)
+
+// "BDD-style" convenience wrappers
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#define SCENARIO(...) TEST_CASE("Scenario: " __VA_ARGS__)
+#define SCENARIO_METHOD(className, ...) INTERNAL_CATCH_TEST_CASE_METHOD(className, "Scenario: " __VA_ARGS__)
+#else
+#define SCENARIO(name, tags) TEST_CASE("Scenario: " name, tags)
+#define SCENARIO_METHOD(className, name, tags) INTERNAL_CATCH_TEST_CASE_METHOD(className, "Scenario: " name, tags)
+#endif
+#define GIVEN(desc) SECTION(std::string(" Given: ") + desc, "")
+#define WHEN(desc) SECTION(std::string(" When: ") + desc, "")
+#define AND_WHEN(desc) SECTION(std::string("And when: ") + desc, "")
+#define THEN(desc) SECTION(std::string(" Then: ") + desc, "")
+#define AND_THEN(desc) SECTION(std::string(" And: ") + desc, "")
+
+using Catch::Detail::Approx;
+
+#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
diff --git a/test/our_variant_hello_world.cpp b/test/our_variant_hello_world.cpp
new file mode 100644
index 0000000..be5996b
--- /dev/null
+++ b/test/our_variant_hello_world.cpp
@@ -0,0 +1,20 @@
+#include "variant.hpp"
+
+#include <stdexcept>
+
+struct check
+{
+ template <typename T>
+ void operator()(T const& val) const
+ {
+ if (val != 0) throw std::runtime_error("invalid");
+ }
+};
+
+int main()
+{
+ typedef mapbox::util::variant<bool, int, double> variant_type;
+ variant_type v(0);
+ mapbox::util::apply_visitor(check(), v);
+ return 0;
+}
diff --git a/test/recursive_wrapper_test.cpp b/test/recursive_wrapper_test.cpp
new file mode 100644
index 0000000..0492af4
--- /dev/null
+++ b/test/recursive_wrapper_test.cpp
@@ -0,0 +1,125 @@
+
+#include <cstdlib>
+#include <iostream>
+#include <string>
+#include <typeinfo>
+#include <utility>
+
+#include <boost/timer/timer.hpp>
+
+#include "variant.hpp"
+
+using namespace mapbox;
+
+namespace test {
+
+struct add;
+struct sub;
+
+template <typename OpTag>
+struct binary_op;
+
+typedef util::variant<int,
+ util::recursive_wrapper<binary_op<add>>,
+ util::recursive_wrapper<binary_op<sub>>>
+ expression;
+
+template <typename Op>
+struct binary_op
+{
+ expression left; // variant instantiated here...
+ expression right;
+
+ binary_op(expression&& lhs, expression&& rhs)
+ : left(std::move(lhs)), right(std::move(rhs))
+ {
+ }
+};
+
+struct print
+{
+ template <typename T>
+ void operator()(T const& val) const
+ {
+ std::cerr << val << ":" << typeid(T).name() << std::endl;
+ }
+};
+
+struct test
+{
+ template <typename T>
+ std::string operator()(T const& obj) const
+ {
+ return std::string("TYPE_ID=") + typeid(obj).name();
+ }
+};
+
+struct calculator
+{
+ public:
+ int operator()(int value) const
+ {
+ return value;
+ }
+
+ int operator()(binary_op<add> const& binary) const
+ {
+ return util::apply_visitor(calculator(), binary.left) + util::apply_visitor(calculator(), binary.right);
+ }
+
+ int operator()(binary_op<sub> const& binary) const
+ {
+ return util::apply_visitor(calculator(), binary.left) - util::apply_visitor(calculator(), binary.right);
+ }
+};
+
+struct to_string
+{
+ public:
+ std::string operator()(int value) const
+ {
+ return std::to_string(value);
+ }
+
+ std::string operator()(binary_op<add> const& binary) const
+ {
+ return util::apply_visitor(to_string(), binary.left) + std::string("+") + util::apply_visitor(to_string(), binary.right);
+ }
+
+ std::string operator()(binary_op<sub> const& binary) const
+ {
+ return util::apply_visitor(to_string(), binary.left) + std::string("-") + util::apply_visitor(to_string(), binary.right);
+ }
+};
+
+} // namespace test
+
+int main(int argc, char** argv)
+{
+ if (argc != 2)
+ {
+ std::cerr << "Usage" << argv[0] << " <num-iter>" << std::endl;
+ return EXIT_FAILURE;
+ }
+
+ const std::size_t NUM_ITER = static_cast<std::size_t>(std::stol(argv[1]));
+
+ test::expression sum(test::binary_op<test::add>(2, 3));
+ test::expression result(test::binary_op<test::sub>(std::move(sum), 4));
+
+ std::cerr << "TYPE OF RESULT-> " << util::apply_visitor(test::test(), result) << std::endl;
+
+ int total = 0;
+ {
+ boost::timer::auto_cpu_timer t;
+ for (std::size_t i = 0; i < NUM_ITER; ++i)
+ {
+ total += util::apply_visitor(test::calculator(), result);
+ }
+ }
+ std::cerr << "total=" << total << std::endl;
+
+ std::cerr << util::apply_visitor(test::to_string(), result) << "=" << util::apply_visitor(test::calculator(), result) << std::endl;
+
+ return EXIT_SUCCESS;
+}
diff --git a/test/reference_wrapper_test.cpp b/test/reference_wrapper_test.cpp
new file mode 100644
index 0000000..dc1209f
--- /dev/null
+++ b/test/reference_wrapper_test.cpp
@@ -0,0 +1,76 @@
+#include <cstdlib>
+#include <functional>
+#include <iostream>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+#include <vector>
+
+#include "variant.hpp"
+
+using namespace mapbox;
+
+namespace test {
+
+struct point
+{
+ public:
+ point(double x_, double y_)
+ : x(x_), y(y_) {}
+ double x;
+ double y;
+};
+
+struct line_string : std::vector<point>
+{
+};
+struct polygon : std::vector<line_string>
+{
+};
+using variant = util::variant<std::reference_wrapper<const point>,
+ std::reference_wrapper<const line_string>,
+ std::reference_wrapper<const polygon>>;
+
+struct print
+{
+ using result_type = void;
+ void operator()(point const& pt) const
+ {
+ std::cerr << "Point(" << pt.x << "," << pt.y << ")" << std::endl;
+ }
+ void operator()(line_string const& line) const
+ {
+ std::cerr << "Line(";
+ for (auto const& pt : line)
+ {
+ std::cerr << pt.x << " " << pt.y << ",";
+ }
+ std::cerr << ")" << std::endl;
+ }
+ template <typename T>
+ void operator()(T const& val) const
+ {
+ std::cerr << typeid(T).name() << std::endl;
+ }
+};
+}
+
+int main()
+{
+ std::cerr << sizeof(test::polygon) << std::endl;
+ std::cerr << sizeof(test::variant) << std::endl;
+ test::point pt(123, 456);
+ test::variant var = std::cref(pt);
+ util::apply_visitor(test::print(), var);
+ test::line_string line;
+ line.push_back(pt);
+ line.push_back(pt);
+ line.push_back(test::point(999, 333));
+ var = std::cref(line);
+ util::apply_visitor(test::print(), var);
+ std::cerr << "Is line (cref) ? " << var.is<std::reference_wrapper<test::line_string const>>() << std::endl;
+ auto const& line2 = var.get<test::line_string>(); // accessing underlying type of std::reference_wrapper<T>
+ test::print printer;
+ printer(line2);
+ return EXIT_SUCCESS;
+}
diff --git a/test/t/binary_visitor_1.cpp b/test/t/binary_visitor_1.cpp
new file mode 100644
index 0000000..298a40b
--- /dev/null
+++ b/test/t/binary_visitor_1.cpp
@@ -0,0 +1,7 @@
+
+#include "variant.hpp"
+
+#define NAME_EXT " i-d"
+using variant_type = mapbox::util::variant<int, double>;
+
+#include "binary_visitor_impl.hpp"
diff --git a/test/t/binary_visitor_2.cpp b/test/t/binary_visitor_2.cpp
new file mode 100644
index 0000000..33768b6
--- /dev/null
+++ b/test/t/binary_visitor_2.cpp
@@ -0,0 +1,7 @@
+
+#include "variant.hpp"
+
+#define NAME_EXT " b-i-d"
+using variant_type = mapbox::util::variant<bool, int, double>;
+
+#include "binary_visitor_impl.hpp"
diff --git a/test/t/binary_visitor_3.cpp b/test/t/binary_visitor_3.cpp
new file mode 100644
index 0000000..d35af4e
--- /dev/null
+++ b/test/t/binary_visitor_3.cpp
@@ -0,0 +1,7 @@
+
+#include "variant.hpp"
+
+#define NAME_EXT " i-d-b"
+using variant_type = mapbox::util::variant<int, double, bool>;
+
+#include "binary_visitor_impl.hpp"
diff --git a/test/t/binary_visitor_4.cpp b/test/t/binary_visitor_4.cpp
new file mode 100644
index 0000000..daacc1b
--- /dev/null
+++ b/test/t/binary_visitor_4.cpp
@@ -0,0 +1,7 @@
+
+#include "variant.hpp"
+
+#define NAME_EXT " b-i-d-c"
+using variant_type = mapbox::util::variant<bool, int, double, char>;
+
+#include "binary_visitor_impl.hpp"
diff --git a/test/t/binary_visitor_5.cpp b/test/t/binary_visitor_5.cpp
new file mode 100644
index 0000000..28669be
--- /dev/null
+++ b/test/t/binary_visitor_5.cpp
@@ -0,0 +1,7 @@
+
+#include "variant.hpp"
+
+#define NAME_EXT " b-i-c-d-i"
+using variant_type = mapbox::util::variant<bool, int, char, double, int>;
+
+#include "binary_visitor_impl.hpp"
diff --git a/test/t/binary_visitor_6.cpp b/test/t/binary_visitor_6.cpp
new file mode 100644
index 0000000..c881b0f
--- /dev/null
+++ b/test/t/binary_visitor_6.cpp
@@ -0,0 +1,7 @@
+
+#include "variant.hpp"
+
+#define NAME_EXT " b-i-i-d-c-u"
+using variant_type = mapbox::util::variant<bool, int, int, double, char, short int>;
+
+#include "binary_visitor_impl.hpp"
diff --git a/test/t/binary_visitor_impl.hpp b/test/t/binary_visitor_impl.hpp
new file mode 100644
index 0000000..4d9a43f
--- /dev/null
+++ b/test/t/binary_visitor_impl.hpp
@@ -0,0 +1,204 @@
+
+#include <type_traits>
+
+#include "catch.hpp"
+
+#include "variant_io.hpp"
+
+struct add_visitor
+{
+ add_visitor() {}
+
+ template <typename A, typename B>
+ double operator()(A a, B b) const
+ {
+ return a + b;
+ }
+};
+
+TEST_CASE("const binary visitor works on const variants" NAME_EXT, "[visitor][binary visitor]")
+{
+ const variant_type a{7};
+ const variant_type b = 3;
+ const variant_type c{7.1};
+ const variant_type d = 2.9;
+
+ const add_visitor v;
+
+ REQUIRE(mapbox::util::apply_visitor(v, a, b) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, c, d) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, a, c) == Approx(14.1));
+ REQUIRE(mapbox::util::apply_visitor(v, a, d) == Approx(9.9));
+
+ REQUIRE(mapbox::util::apply_visitor(v, b, a) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, d, c) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, c, a) == Approx(14.1));
+ REQUIRE(mapbox::util::apply_visitor(v, d, a) == Approx(9.9));
+}
+
+TEST_CASE("non-const binary visitor works on const variants" NAME_EXT, "[visitor][binary visitor]")
+{
+ const variant_type a = 7;
+ const variant_type b = 3;
+ const variant_type c = 7.1;
+ const variant_type d = 2.9;
+
+ add_visitor v;
+
+ REQUIRE(mapbox::util::apply_visitor(v, a, b) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, c, d) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, a, c) == Approx(14.1));
+ REQUIRE(mapbox::util::apply_visitor(v, a, d) == Approx(9.9));
+
+ REQUIRE(mapbox::util::apply_visitor(v, b, a) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, d, c) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, c, a) == Approx(14.1));
+ REQUIRE(mapbox::util::apply_visitor(v, d, a) == Approx(9.9));
+}
+
+TEST_CASE("const binary visitor works on non-const variants" NAME_EXT, "[visitor][binary visitor]")
+{
+ variant_type a = 7;
+ variant_type b = 3;
+ variant_type c = 7.1;
+ variant_type d = 2.9;
+
+ const add_visitor v;
+
+ REQUIRE(mapbox::util::apply_visitor(v, a, b) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, c, d) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, a, c) == Approx(14.1));
+ REQUIRE(mapbox::util::apply_visitor(v, a, d) == Approx(9.9));
+
+ REQUIRE(mapbox::util::apply_visitor(v, b, a) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, d, c) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, c, a) == Approx(14.1));
+ REQUIRE(mapbox::util::apply_visitor(v, d, a) == Approx(9.9));
+}
+
+TEST_CASE("non-const binary visitor works on non-const variants" NAME_EXT, "[visitor][binary visitor]")
+{
+ variant_type a = 7;
+ variant_type b = 3;
+ variant_type c = 7.1;
+ variant_type d = 2.9;
+
+ add_visitor v;
+
+ REQUIRE(mapbox::util::apply_visitor(v, a, b) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, c, d) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, a, c) == Approx(14.1));
+ REQUIRE(mapbox::util::apply_visitor(v, a, d) == Approx(9.9));
+
+ REQUIRE(mapbox::util::apply_visitor(v, b, a) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, d, c) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(v, c, a) == Approx(14.1));
+ REQUIRE(mapbox::util::apply_visitor(v, d, a) == Approx(9.9));
+}
+
+TEST_CASE("rvalue binary visitor works on const variants" NAME_EXT, "[visitor][binary visitor]")
+{
+ const variant_type a = 7;
+ const variant_type b = 3;
+ const variant_type c = 7.1;
+ const variant_type d = 2.9;
+
+ REQUIRE(mapbox::util::apply_visitor(add_visitor{}, a, b) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(add_visitor{}, c, d) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(add_visitor{}, a, c) == Approx(14.1));
+ REQUIRE(mapbox::util::apply_visitor(add_visitor{}, a, d) == Approx(9.9));
+
+ REQUIRE(mapbox::util::apply_visitor(add_visitor{}, b, a) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(add_visitor{}, d, c) == Approx(10));
+ REQUIRE(mapbox::util::apply_visitor(add_visitor{}, c, a) == Approx(14.1));
+ REQUIRE(mapbox::util::apply_visitor(add_visitor{}, d, a) == Approx(9.9));
+}
+
+struct sum_mul_visitor
+{
+ double sum;
+
+ sum_mul_visitor() : sum(0.0) {}
+
+ template <typename A, typename B>
+ double operator()(A a, B b)
+ {
+ double m = a * b;
+ sum += m;
+ return m;
+ }
+};
+
+TEST_CASE("mutable binary visitor works" NAME_EXT, "[visitor][binary visitor]")
+{
+ const variant_type a = 2;
+ const variant_type b = 3;
+ const variant_type c = 0.1;
+ const variant_type d = 0.2;
+
+ sum_mul_visitor v;
+
+ REQUIRE(mapbox::util::apply_visitor(v, a, b) == Approx(6));
+ REQUIRE(mapbox::util::apply_visitor(v, c, d) == Approx(0.02));
+ REQUIRE(mapbox::util::apply_visitor(v, a, c) == Approx(0.2));
+ REQUIRE(mapbox::util::apply_visitor(v, a, d) == Approx(0.4));
+
+ REQUIRE(v.sum == Approx(6.62));
+
+ REQUIRE(mapbox::util::apply_visitor(v, b, a) == Approx(6));
+ REQUIRE(mapbox::util::apply_visitor(v, d, c) == Approx(0.02));
+ REQUIRE(mapbox::util::apply_visitor(v, c, a) == Approx(0.2));
+ REQUIRE(mapbox::util::apply_visitor(v, d, a) == Approx(0.4));
+}
+
+struct swap_visitor
+{
+ swap_visitor(){};
+
+ template <typename A, typename B>
+ void operator()(A& a, B& b) const
+ {
+ using T = typename std::common_type<A, B>::type;
+ T tmp = a;
+ a = b;
+ b = tmp;
+ }
+};
+
+TEST_CASE("static mutating visitor on mutable variants works" NAME_EXT, "[visitor][binary visitor]")
+{
+ variant_type a = 2;
+ variant_type b = 3;
+ variant_type c = 0.1;
+ variant_type d = 0.2;
+
+ const swap_visitor v;
+
+ SECTION("swap a and b")
+ {
+ mapbox::util::apply_visitor(v, a, b);
+ REQUIRE(a.get<int>() == 3);
+ REQUIRE(b.get<int>() == 2);
+ }
+
+ SECTION("swap c and d")
+ {
+ mapbox::util::apply_visitor(v, c, d);
+ REQUIRE(c.get<double>() == Approx(0.2));
+ REQUIRE(d.get<double>() == Approx(0.1));
+ }
+
+ SECTION("swap a and c")
+ {
+ mapbox::util::apply_visitor(v, a, c);
+ REQUIRE(a.get<int>() == 0);
+ REQUIRE(c.get<double>() == Approx(2.0));
+ }
+
+ SECTION("swap c and a")
+ {
+ mapbox::util::apply_visitor(v, c, a);
+ REQUIRE(a.get<int>() == 0);
+ REQUIRE(c.get<double>() == Approx(2.0));
+ }
+}
diff --git a/test/t/issue21.cpp b/test/t/issue21.cpp
new file mode 100644
index 0000000..b952313
--- /dev/null
+++ b/test/t/issue21.cpp
@@ -0,0 +1,48 @@
+
+#include "catch.hpp"
+
+#include "variant.hpp"
+#include "variant_io.hpp"
+
+// https://github.com/mapbox/variant/issues/21
+
+static int count;
+
+struct t1
+{
+ int value;
+ t1(int v) : value(v)
+ {
+ ++count;
+ }
+ ~t1()
+ {
+ --count;
+ }
+};
+
+struct t2
+{
+ int value;
+ t2(int v) : value(v)
+ { // constructor fails
+ throw std::runtime_error("fail");
+ }
+};
+
+TEST_CASE("set() works cleanly even if the constructor throws ", "[variant]")
+{
+
+ using variant_type = mapbox::util::variant<t1, t2>;
+
+ count = 0;
+ {
+ variant_type v{42};
+ REQUIRE(v.is<t1>());
+ REQUIRE(v.get<t1>().value == 42);
+ REQUIRE_THROWS({
+ v.set<t2>(13);
+ });
+ }
+ REQUIRE(count == 0);
+}
diff --git a/test/t/mutating_visitor.cpp b/test/t/mutating_visitor.cpp
new file mode 100644
index 0000000..f07afb8
--- /dev/null
+++ b/test/t/mutating_visitor.cpp
@@ -0,0 +1,36 @@
+
+#include "catch.hpp"
+
+#include "variant.hpp"
+#include "variant_io.hpp"
+
+#include <string>
+
+template <typename T>
+struct mutating_visitor
+{
+ mutating_visitor(T& val)
+ : val_(val) {}
+
+ void operator()(T& val) const
+ {
+ val = val_;
+ }
+
+ template <typename T1>
+ void operator()(T1&) const
+ {
+ } // no-op
+
+ T& val_;
+};
+
+TEST_CASE("variant visitation", "[visitor][unary visitor]")
+{
+ mapbox::util::variant<int, double, std::string> var(123);
+ REQUIRE(var.get<int>() == 123);
+ int val = 456;
+ const mutating_visitor<int> visitor(val);
+ mapbox::util::apply_visitor(visitor, var);
+ REQUIRE(var.get<int>() == 456);
+}
diff --git a/test/t/optional.cpp b/test/t/optional.cpp
new file mode 100644
index 0000000..b77beda
--- /dev/null
+++ b/test/t/optional.cpp
@@ -0,0 +1,102 @@
+
+#include "catch.hpp"
+
+#include "optional.hpp"
+
+struct dummy
+{
+ dummy(int _m_1, int _m_2) : m_1(_m_1), m_2(_m_2) {}
+ int m_1;
+ int m_2;
+};
+
+TEST_CASE("optional can be instantiated with a POD type", "[optional]")
+{
+ mapbox::util::optional<int> dbl_opt;
+
+ REQUIRE(!dbl_opt);
+ dbl_opt = 3;
+ REQUIRE(dbl_opt);
+
+ REQUIRE(dbl_opt.get() == 3);
+ REQUIRE(*dbl_opt == 3);
+}
+
+TEST_CASE("copy c'tor", "[optional]")
+{
+ mapbox::util::optional<int> dbl_opt;
+
+ REQUIRE(!dbl_opt);
+ dbl_opt = 3;
+ REQUIRE(dbl_opt);
+
+ mapbox::util::optional<int> other = dbl_opt;
+
+ REQUIRE(other.get() == 3);
+ REQUIRE(*other == 3);
+}
+
+TEST_CASE("const operator*, const get()", "[optional]")
+{
+ const mapbox::util::optional<int> dbl_opt = 3;
+
+ REQUIRE(dbl_opt);
+
+ auto pi1 = dbl_opt.get();
+ auto pi2 = *dbl_opt;
+
+ REQUIRE(pi1 == 3);
+ REQUIRE(pi2 == 3);
+}
+
+TEST_CASE("non-const operator*, non-const get()", "[optional]")
+{
+ mapbox::util::optional<int> dbl_opt = 3;
+
+ REQUIRE(dbl_opt);
+
+ auto pi1 = dbl_opt.get();
+ auto pi2 = *dbl_opt;
+
+ REQUIRE(pi1 == 3);
+ REQUIRE(pi2 == 3);
+}
+
+TEST_CASE("emplace initialization, reset", "[optional]")
+{
+ mapbox::util::optional<dummy> dummy_opt;
+ REQUIRE(!dummy_opt);
+
+ // rvalues, baby!
+ dummy_opt.emplace(1, 2);
+ REQUIRE(dummy_opt);
+ REQUIRE(dummy_opt.get().m_1 == 1);
+ REQUIRE((*dummy_opt).m_2 == 2);
+
+ dummy_opt.reset();
+ REQUIRE(!dummy_opt);
+}
+
+TEST_CASE("assignment", "[optional]")
+{
+ mapbox::util::optional<int> a;
+ mapbox::util::optional<int> b;
+
+ a = 1;
+ b = 3;
+ REQUIRE(a.get() == 1);
+ REQUIRE(b.get() == 3);
+ b = a;
+ REQUIRE(a.get() == b.get());
+ REQUIRE(b.get() == 1);
+}
+
+TEST_CASE("self assignment", "[optional]")
+{
+ mapbox::util::optional<int> a;
+
+ a = 1;
+ REQUIRE(a.get() == 1);
+ a = a;
+ REQUIRE(a.get() == 1);
+}
diff --git a/test/t/recursive_wrapper.cpp b/test/t/recursive_wrapper.cpp
new file mode 100644
index 0000000..b2dec45
--- /dev/null
+++ b/test/t/recursive_wrapper.cpp
@@ -0,0 +1,158 @@
+
+#include "catch.hpp"
+
+#include "recursive_wrapper.hpp"
+
+#include <type_traits>
+#include <utility>
+
+using rwi = mapbox::util::recursive_wrapper<int>;
+using rwp = mapbox::util::recursive_wrapper<std::pair<int, int>>;
+
+static_assert(std::is_same<rwi::type, int>::value, "type check failed");
+
+TEST_CASE("recursive wrapper of int")
+{
+
+ SECTION("construct with value")
+ {
+ rwi a{7};
+
+ REQUIRE(a.get() == 7);
+ REQUIRE(*a.get_pointer() == 7);
+
+ a = 8;
+ REQUIRE(a.get() == 8);
+
+ rwi b{a};
+ REQUIRE(b.get() == 8);
+
+ rwi c;
+ c = b;
+ REQUIRE(b.get() == 8);
+ REQUIRE(c.get() == 8);
+
+ c = 9;
+ REQUIRE(c.get() == 9);
+
+ int x = 10;
+ c = x;
+ REQUIRE(c.get() == 10);
+
+ b = std::move(c);
+ REQUIRE(b.get() == 10);
+ }
+
+ SECTION("construct with const reference")
+ {
+ int i = 7;
+ rwi a{i};
+
+ REQUIRE(a.get() == 7);
+ }
+
+ SECTION("implicit conversion to reference of underlying type")
+ {
+
+ SECTION("const")
+ {
+ rwi const a{7};
+ REQUIRE(a.get() == 7);
+ REQUIRE(*a.get_pointer() == 7);
+
+ rwi::type const& underlying = a;
+ REQUIRE(underlying == 7);
+ }
+
+ SECTION("non const")
+ {
+ rwi a{7};
+ REQUIRE(a.get() == 7);
+ REQUIRE(*a.get_pointer() == 7);
+
+ rwi::type& underlying = a;
+ REQUIRE(underlying == 7);
+ a = 8;
+ REQUIRE(underlying == 8);
+ }
+ }
+}
+
+TEST_CASE("move of recursive wrapper")
+{
+ rwi a{1};
+
+ SECTION("move constructor")
+ {
+ rwi b{std::move(a)};
+ REQUIRE(b.get() == 1);
+ }
+
+ SECTION("operator= on rvalue")
+ {
+ rwi b{2};
+ b = std::move(a);
+ REQUIRE(b.get() == 1);
+ }
+}
+
+TEST_CASE("swap")
+{
+ rwi a{1};
+ rwi b{2};
+
+ REQUIRE(a.get() == 1);
+ REQUIRE(b.get() == 2);
+
+ using std::swap;
+ swap(a, b);
+
+ REQUIRE(a.get() == 2);
+ REQUIRE(b.get() == 1);
+}
+
+TEST_CASE("recursive wrapper of pair<int, int>")
+{
+
+ SECTION("default constructed")
+ {
+ rwp a;
+ REQUIRE(a.get().first == 0);
+ REQUIRE(a.get().second == 0);
+ }
+
+ SECTION("construct with value")
+ {
+ rwp a{std::make_pair(1, 2)};
+
+ REQUIRE(a.get().first == 1);
+ REQUIRE(a.get().second == 2);
+
+ REQUIRE(a.get_pointer()->first == 1);
+ REQUIRE(a.get_pointer()->second == 2);
+
+ a = {3, 4};
+ REQUIRE(a.get().first == 3);
+ REQUIRE(a.get().second == 4);
+
+ rwp b{a};
+ REQUIRE(b.get().first == 3);
+ REQUIRE(b.get().second == 4);
+
+ rwp c;
+ c = b;
+ REQUIRE(b.get().first == 3);
+ REQUIRE(b.get().second == 4);
+ REQUIRE(c.get().first == 3);
+ REQUIRE(c.get().second == 4);
+
+ c = {5, 6};
+ REQUIRE(c.get().first == 5);
+ REQUIRE(c.get().second == 6);
+
+ b = std::move(c);
+ REQUIRE(b.get().first == 5);
+ REQUIRE(b.get().second == 6);
+ // REQUIRE(c.get_pointer() == nullptr);
+ }
+}
diff --git a/test/t/sizeof.cpp b/test/t/sizeof.cpp
new file mode 100644
index 0000000..0e74ce5
--- /dev/null
+++ b/test/t/sizeof.cpp
@@ -0,0 +1,52 @@
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+
+#include "catch.hpp"
+
+#include "variant.hpp"
+#include "variant_io.hpp"
+
+struct some_struct
+{
+ int a;
+ bool b;
+ std::string c;
+};
+
+using variant_internal_index_type = size_t;
+
+TEST_CASE("size of variants")
+{
+ constexpr const auto min_overhead = sizeof(variant_internal_index_type);
+
+ using namespace std; // workaround for bug in GCC <= 4.8 where max_align_t is not in std
+ constexpr const auto max_overhead = alignof(max_align_t) + min_overhead;
+
+ using v1 = mapbox::util::variant<int>;
+ using v2 = mapbox::util::variant<int, bool, int64_t>;
+ using v3 = mapbox::util::variant<int, std::string>;
+ using v4 = mapbox::util::variant<std::string, std::string>;
+ using v5 = mapbox::util::variant<some_struct>;
+
+ constexpr const auto si = sizeof(int);
+ constexpr const auto sb = sizeof(bool);
+ constexpr const auto si64 = sizeof(int64_t);
+ constexpr const auto sd = sizeof(double);
+ constexpr const auto sstr = sizeof(std::string);
+ constexpr const auto spi = sizeof(std::pair<int, int>);
+ constexpr const auto ss = sizeof(some_struct);
+
+ REQUIRE(sizeof(v1) <= max_overhead + si);
+ REQUIRE(sizeof(v2) <= max_overhead + std::max({si, sb, si64}));
+ REQUIRE(sizeof(v3) <= max_overhead + std::max({si, sstr}));
+ REQUIRE(sizeof(v4) <= max_overhead + sstr);
+ REQUIRE(sizeof(v5) <= max_overhead + ss);
+
+ REQUIRE(sizeof(v1) >= min_overhead + si);
+ REQUIRE(sizeof(v2) >= min_overhead + std::max({si, sb, si64}));
+ REQUIRE(sizeof(v3) >= min_overhead + std::max({si, sstr}));
+ REQUIRE(sizeof(v4) >= min_overhead + sstr);
+ REQUIRE(sizeof(v5) >= min_overhead + ss);
+}
diff --git a/test/t/unary_visitor.cpp b/test/t/unary_visitor.cpp
new file mode 100644
index 0000000..8df6110
--- /dev/null
+++ b/test/t/unary_visitor.cpp
@@ -0,0 +1,127 @@
+
+#include "catch.hpp"
+
+#include "variant.hpp"
+#include "variant_io.hpp"
+
+#include <string>
+
+struct some_visitor
+{
+ int var_;
+
+ some_visitor(int init)
+ : var_(init) {}
+
+ int operator()(int val) const
+ {
+ return var_ + val;
+ }
+
+ int operator()(double val) const
+ {
+ return var_ + int(val);
+ }
+
+ int operator()(const std::string&) const
+ {
+ return 0;
+ }
+};
+
+TEST_CASE("non-const visitor works on const variants", "[visitor][unary visitor]")
+{
+ using variant_type = const mapbox::util::variant<int, double, std::string>;
+ variant_type var1(123);
+ variant_type var2(3.2);
+ variant_type var3("foo");
+ REQUIRE(var1.get<int>() == 123);
+ REQUIRE(var2.get<double>() == Approx(3.2));
+ REQUIRE(var3.get<std::string>() == "foo");
+
+ some_visitor visitor{1};
+
+ REQUIRE(mapbox::util::apply_visitor(visitor, var1) == 124);
+ REQUIRE(mapbox::util::apply_visitor(visitor, var2) == 4);
+ REQUIRE(mapbox::util::apply_visitor(visitor, var3) == 0);
+}
+
+TEST_CASE("const visitor works on const variants", "[visitor][unary visitor]")
+{
+ using variant_type = const mapbox::util::variant<int, double, std::string>;
+ variant_type var1(123);
+ variant_type var2(3.2);
+ variant_type var3("foo");
+ REQUIRE(var1.get<int>() == 123);
+ REQUIRE(var2.get<double>() == Approx(3.2));
+ REQUIRE(var3.get<std::string>() == "foo");
+
+ const some_visitor visitor{1};
+
+ REQUIRE(mapbox::util::apply_visitor(visitor, var1) == 124);
+ REQUIRE(mapbox::util::apply_visitor(visitor, var2) == 4);
+ REQUIRE(mapbox::util::apply_visitor(visitor, var3) == 0);
+}
+
+TEST_CASE("rvalue visitor works on const variants", "[visitor][unary visitor]")
+{
+ using variant_type = const mapbox::util::variant<int, double, std::string>;
+ variant_type var1(123);
+ variant_type var2(3.2);
+ variant_type var3("foo");
+ REQUIRE(var1.get<int>() == 123);
+ REQUIRE(var2.get<double>() == Approx(3.2));
+ REQUIRE(var3.get<std::string>() == "foo");
+
+ REQUIRE(mapbox::util::apply_visitor(some_visitor{1}, var1) == 124);
+ REQUIRE(mapbox::util::apply_visitor(some_visitor{1}, var2) == 4);
+ REQUIRE(mapbox::util::apply_visitor(some_visitor{1}, var3) == 0);
+}
+
+TEST_CASE("visitor works on rvalue variants", "[visitor][unary visitor]")
+{
+ using variant_type = const mapbox::util::variant<int, double, std::string>;
+
+ REQUIRE(mapbox::util::apply_visitor(some_visitor{1}, variant_type{123}) == 124);
+ REQUIRE(mapbox::util::apply_visitor(some_visitor{1}, variant_type{3.2}) == 4);
+ REQUIRE(mapbox::util::apply_visitor(some_visitor{1}, variant_type{"foo"}) == 0);
+}
+
+struct total_sizeof
+{
+ total_sizeof() : total_(0) {}
+
+ template <class Value>
+ int operator()(const Value&) const
+ {
+ total_ += int(sizeof(Value));
+ return total_;
+ }
+
+ int result() const
+ {
+ return total_;
+ }
+
+ mutable int total_;
+
+}; // total_sizeof
+
+TEST_CASE("changes in visitor should be visible", "[visitor][unary visitor]")
+{
+ using variant_type = mapbox::util::variant<int, std::string, double>;
+ variant_type v;
+ total_sizeof ts;
+ v = 5.9;
+ REQUIRE(mapbox::util::apply_visitor(ts, v) == sizeof(double));
+ REQUIRE(ts.result() == sizeof(double));
+}
+
+TEST_CASE("changes in const visitor (with mutable internals) should be visible", "[visitor][unary visitor]")
+{
+ using variant_type = const mapbox::util::variant<int, std::string, double>;
+ variant_type v{"foo"};
+ const total_sizeof ts;
+ REQUIRE(mapbox::util::apply_visitor(ts, v) == sizeof(std::string));
+ REQUIRE(ts.result() == sizeof(std::string));
+}
diff --git a/test/t/variant.cpp b/test/t/variant.cpp
new file mode 100644
index 0000000..36655a5
--- /dev/null
+++ b/test/t/variant.cpp
@@ -0,0 +1,570 @@
+#include "catch.hpp"
+
+#include "variant.hpp"
+#include "variant_io.hpp"
+
+#include <algorithm>
+#include <cstdint>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
+
+// Hack to make nullptr work with Catch
+namespace std {
+
+template <class C, class T>
+std::basic_ostream<C, T>& operator<<(std::basic_ostream<C, T>& os, std::nullptr_t)
+{
+ return os << (void*)nullptr;
+}
+}
+
+TEST_CASE("variant can be moved into vector", "[variant]")
+{
+ using variant_type = mapbox::util::variant<bool, std::string>;
+ variant_type v(std::string("test"));
+ std::vector<variant_type> vec;
+ vec.emplace_back(std::move(v));
+ REQUIRE(v.get<std::string>() != std::string("test"));
+ REQUIRE(vec.at(0).get<std::string>() == std::string("test"));
+}
+
+TEST_CASE("variant should support built-in types", "[variant]")
+{
+ SECTION("bool")
+ {
+ mapbox::util::variant<bool> v(true);
+ REQUIRE(v.valid());
+ REQUIRE(v.is<bool>());
+ REQUIRE(v.which() == 0);
+ REQUIRE(v.get<bool>() == true);
+ v.set<bool>(false);
+ REQUIRE(v.get<bool>() == false);
+ v = true;
+ REQUIRE(v == mapbox::util::variant<bool>(true));
+ }
+ SECTION("nullptr")
+ {
+ using value_type = std::nullptr_t;
+ mapbox::util::variant<value_type> v(nullptr);
+ REQUIRE(v.valid());
+ REQUIRE(v.is<value_type>());
+ REQUIRE(v.which() == 0);
+ REQUIRE(v.get<value_type>() == nullptr);
+ REQUIRE(v == mapbox::util::variant<value_type>(nullptr));
+ }
+ SECTION("unique_ptr")
+ {
+ using value_type = std::unique_ptr<std::string>;
+ mapbox::util::variant<value_type> v(value_type(new std::string("hello")));
+ REQUIRE(v.valid());
+ REQUIRE(v.is<value_type>());
+ REQUIRE(v.which() == 0);
+ REQUIRE(*v.get<value_type>().get() == *value_type(new std::string("hello")).get());
+ REQUIRE(*v.get<value_type>() == "hello");
+ }
+ SECTION("string")
+ {
+ using value_type = std::string;
+ mapbox::util::variant<value_type> v(value_type("hello"));
+ REQUIRE(v.valid());
+ REQUIRE(v.is<value_type>());
+ REQUIRE(v.which() == 0);
+ REQUIRE(v.get<value_type>() == value_type("hello"));
+ v.set<value_type>(value_type("there"));
+ REQUIRE(v.get<value_type>() == value_type("there"));
+ v = value_type("variant");
+ REQUIRE(v == mapbox::util::variant<value_type>(value_type("variant")));
+ }
+ SECTION("size_t")
+ {
+ using value_type = std::size_t;
+ mapbox::util::variant<value_type> v(std::numeric_limits<value_type>::max());
+ REQUIRE(v.valid());
+ REQUIRE(v.is<value_type>());
+ REQUIRE(v.which() == 0);
+ REQUIRE(v.get<value_type>() == std::numeric_limits<value_type>::max());
+ v.set<value_type>(value_type(0));
+ REQUIRE(v.get<value_type>() == value_type(0));
+ v = value_type(1);
+ REQUIRE(v == mapbox::util::variant<value_type>(value_type(1)));
+ }
+ SECTION("int8_t")
+ {
+ using value_type = std::int8_t;
+ mapbox::util::variant<value_type> v(std::numeric_limits<value_type>::max());
+ REQUIRE(v.valid());
+ REQUIRE(v.is<value_type>());
+ REQUIRE(v.which() == 0);
+ REQUIRE(v.get<value_type>() == std::numeric_limits<value_type>::max());
+ v.set<value_type>(0);
+ REQUIRE(v.get<value_type>() == value_type(0));
+ v = value_type(1);
+ REQUIRE(v == mapbox::util::variant<value_type>(value_type(1)));
+ }
+ SECTION("int16_t")
+ {
+ using value_type = std::int16_t;
+ mapbox::util::variant<value_type> v(std::numeric_limits<value_type>::max());
+ REQUIRE(v.valid());
+ REQUIRE(v.is<value_type>());
+ REQUIRE(v.which() == 0);
+ REQUIRE(v.get<value_type>() == std::numeric_limits<value_type>::max());
+ v.set<value_type>(0);
+ REQUIRE(v.get<value_type>() == value_type(0));
+ v = value_type(1);
+ REQUIRE(v == mapbox::util::variant<value_type>(value_type(1)));
+ }
+ SECTION("int32_t")
+ {
+ using value_type = std::int32_t;
+ mapbox::util::variant<value_type> v(std::numeric_limits<value_type>::max());
+ REQUIRE(v.valid());
+ REQUIRE(v.is<value_type>());
+ REQUIRE(v.which() == 0);
+ REQUIRE(v.get<value_type>() == std::numeric_limits<value_type>::max());
+ v.set<value_type>(0);
+ REQUIRE(v.get<value_type>() == value_type(0));
+ v = value_type(1);
+ REQUIRE(v == mapbox::util::variant<value_type>(value_type(1)));
+ }
+ SECTION("int64_t")
+ {
+ using value_type = std::int64_t;
+ mapbox::util::variant<value_type> v(std::numeric_limits<value_type>::max());
+ REQUIRE(v.valid());
+ REQUIRE(v.is<value_type>());
+ REQUIRE(v.which() == 0);
+ REQUIRE(v.get<value_type>() == std::numeric_limits<value_type>::max());
+ v.set<value_type>(0);
+ REQUIRE(v.get<value_type>() == value_type(0));
+ v = value_type(1);
+ REQUIRE(v == mapbox::util::variant<value_type>(value_type(1)));
+ }
+}
+
+struct MissionInteger
+{
+ using value_type = uint64_t;
+ value_type val_;
+
+ public:
+ MissionInteger(uint64_t val) : val_(val) {}
+
+ bool operator==(MissionInteger const& rhs) const
+ {
+ return (val_ == rhs.get());
+ }
+
+ uint64_t get() const
+ {
+ return val_;
+ }
+};
+
+std::ostream& operator<<(std::ostream& os, MissionInteger const& rhs)
+{
+ os << rhs.get();
+ return os;
+}
+
+TEST_CASE("variant should support custom types", "[variant]")
+{
+ // http://www.missionintegers.com/integer/34838300
+ mapbox::util::variant<MissionInteger> v(MissionInteger(34838300));
+ REQUIRE(v.valid());
+ REQUIRE(v.is<MissionInteger>());
+ REQUIRE(v.which() == 0);
+ REQUIRE(v.get<MissionInteger>() == MissionInteger(34838300));
+ REQUIRE(v.get<MissionInteger>().get() == MissionInteger::value_type(34838300));
+ // TODO: should both of the set usages below compile?
+ v.set<MissionInteger>(MissionInteger::value_type(0));
+ v.set<MissionInteger>(MissionInteger(0));
+ REQUIRE(v.get<MissionInteger>().get() == MissionInteger::value_type(0));
+ v = MissionInteger(1);
+ REQUIRE(v == mapbox::util::variant<MissionInteger>(MissionInteger(1)));
+}
+
+TEST_CASE("variant::which() returns zero based index of stored type", "[variant]")
+{
+ using variant_type = mapbox::util::variant<bool, std::string, std::uint64_t, std::int64_t, double, float>;
+ // which() returns index in forward order
+ REQUIRE(0 == variant_type(true).which());
+ REQUIRE(1 == variant_type(std::string("test")).which());
+ REQUIRE(2 == variant_type(std::uint64_t(0)).which());
+ REQUIRE(3 == variant_type(std::int64_t(0)).which());
+ REQUIRE(4 == variant_type(double(0.0)).which());
+ REQUIRE(5 == variant_type(float(0.0)).which());
+}
+
+TEST_CASE("get with wrong type (here: double) should throw", "[variant]")
+{
+ using variant_type = mapbox::util::variant<int, double>;
+ variant_type var = 5;
+ REQUIRE(var.is<int>());
+ REQUIRE_FALSE(var.is<double>());
+ REQUIRE(var.get<int>() == 5);
+ REQUIRE_THROWS_AS({
+ var.get<double>();
+ },
+ mapbox::util::bad_variant_access&);
+}
+
+TEST_CASE("get with wrong type (here: int) should throw", "[variant]")
+{
+ using variant_type = mapbox::util::variant<int, double>;
+ variant_type var = 5.0;
+ REQUIRE(var.is<double>());
+ REQUIRE_FALSE(var.is<int>());
+ REQUIRE(var.get<double>() == 5.0);
+ REQUIRE(mapbox::util::get<double>(var) == 5.0);
+ REQUIRE_THROWS_AS({
+ var.get<int>();
+ },
+ mapbox::util::bad_variant_access&);
+ REQUIRE_THROWS_AS({
+ mapbox::util::get<int>(var);
+ },
+ mapbox::util::bad_variant_access&);
+}
+
+TEST_CASE("get on const varint with wrong type (here: int) should throw", "[variant]")
+{
+ using variant_type = mapbox::util::variant<int, double>;
+ const variant_type var = 5.0;
+ REQUIRE(var.is<double>());
+ REQUIRE_FALSE(var.is<int>());
+ REQUIRE(var.get<double>() == 5.0);
+ REQUIRE(mapbox::util::get<double>(var) == 5.0);
+ REQUIRE_THROWS_AS({
+ var.get<int>();
+ },
+ mapbox::util::bad_variant_access&);
+ REQUIRE_THROWS_AS({
+ mapbox::util::get<int>(var);
+ },
+ mapbox::util::bad_variant_access&);
+}
+
+TEST_CASE("get with any type should throw if not initialized", "[variant]")
+{
+ mapbox::util::variant<int, double> var{mapbox::util::no_init()};
+ REQUIRE_THROWS_AS({
+ var.get<int>();
+ },
+ mapbox::util::bad_variant_access&);
+ REQUIRE_THROWS_AS({
+ var.get<double>();
+ },
+ mapbox::util::bad_variant_access&);
+}
+
+TEST_CASE("no_init variant can be copied and moved from", "[variant]")
+{
+ using variant_type = mapbox::util::variant<int, double>;
+
+ variant_type v1{mapbox::util::no_init()};
+ variant_type v2{42};
+ variant_type v3{23};
+
+ REQUIRE(v2.get<int>() == 42);
+ v2 = v1;
+ REQUIRE_THROWS_AS({
+ v2.get<int>();
+ },
+ mapbox::util::bad_variant_access&);
+
+ REQUIRE(v3.get<int>() == 23);
+ v3 = std::move(v1);
+ REQUIRE_THROWS_AS({
+ v3.get<int>();
+ },
+ mapbox::util::bad_variant_access&);
+}
+
+TEST_CASE("no_init variant can be copied and moved to", "[variant]")
+{
+ using variant_type = mapbox::util::variant<int, double>;
+
+ variant_type v1{42};
+ variant_type v2{mapbox::util::no_init()};
+ variant_type v3{mapbox::util::no_init()};
+
+ REQUIRE_THROWS_AS({
+ v2.get<int>();
+ },
+ mapbox::util::bad_variant_access&);
+
+ REQUIRE(v1.get<int>() == 42);
+ v2 = v1;
+ REQUIRE(v2.get<int>() == 42);
+ REQUIRE(v1.get<int>() == 42);
+
+ REQUIRE_THROWS_AS({
+ v3.get<int>();
+ },
+ mapbox::util::bad_variant_access&);
+
+ v3 = std::move(v1);
+ REQUIRE(v3.get<int>() == 42);
+}
+
+TEST_CASE("implicit conversion", "[variant][implicit conversion]")
+{
+ using variant_type = mapbox::util::variant<int>;
+ variant_type var(5.0); // converted to int
+ REQUIRE(var.get<int>() == 5);
+ var = 6.0; // works for operator=, too
+ REQUIRE(var.get<int>() == 6);
+}
+
+TEST_CASE("implicit conversion to first type in variant type list", "[variant][implicit conversion]")
+{
+ using variant_type = mapbox::util::variant<long, char>;
+ variant_type var = 5.0; // converted to long
+ REQUIRE(var.get<long>() == 5);
+ REQUIRE_THROWS_AS({
+ var.get<char>();
+ },
+ mapbox::util::bad_variant_access&);
+}
+
+TEST_CASE("implicit conversion to unsigned char", "[variant][implicit conversion]")
+{
+ using variant_type = mapbox::util::variant<unsigned char>;
+ variant_type var = 100.0;
+ CHECK(var.get<unsigned char>() == static_cast<unsigned char>(100.0));
+ CHECK(var.get<unsigned char>() == static_cast<unsigned char>(static_cast<unsigned int>(100.0)));
+}
+
+struct dummy
+{
+};
+
+TEST_CASE("implicit conversion to a suitable type", "[variant][implicit conversion]")
+{
+ using mapbox::util::variant;
+ CHECK_NOTHROW((variant<dummy, float, std::string>(123)).get<float>());
+ CHECK_NOTHROW((variant<dummy, float, std::string>("foo")).get<std::string>());
+}
+
+TEST_CASE("value_traits for non-convertible type", "[variant::detail]")
+{
+ namespace detail = mapbox::util::detail;
+ using target_type = detail::value_traits<dummy, int>::target_type;
+ CHECK((std::is_same<target_type, void>::value) == true);
+}
+
+TEST_CASE("Type indexing should work with variants with duplicated types", "[variant::detail]")
+{
+ // Index is in reverse order
+ REQUIRE((mapbox::util::detail::value_traits<bool, bool, int, double, std::string>::index == 3));
+ REQUIRE((mapbox::util::detail::value_traits<bool, bool, int, double, int>::index == 3));
+ REQUIRE((mapbox::util::detail::value_traits<int, bool, int, double, std::string>::index == 2));
+ REQUIRE((mapbox::util::detail::value_traits<int, bool, int, double, int>::index == 2));
+ REQUIRE((mapbox::util::detail::value_traits<double, bool, int, double, std::string>::index == 1));
+ REQUIRE((mapbox::util::detail::value_traits<bool, bool, int, bool, std::string>::index == 3));
+ REQUIRE((mapbox::util::detail::value_traits<std::string, bool, int, double, std::string>::index == 0));
+ REQUIRE((mapbox::util::detail::value_traits<dummy, bool, int, double, std::string>::index == mapbox::util::detail::invalid_value));
+ REQUIRE((mapbox::util::detail::value_traits<std::vector<int>, bool, int, double, std::string>::index == mapbox::util::detail::invalid_value));
+}
+
+TEST_CASE("variant default constructor", "[variant][default constructor]")
+{
+ // By default variant is initialised with (default constructed) first type in template parameters pack
+ // As a result first type in Types... must be default constructable
+ // NOTE: index in reverse order -> index = N - 1
+ using variant_type = mapbox::util::variant<int, double, std::string>;
+ REQUIRE(variant_type{}.which() == 0);
+ REQUIRE(variant_type{}.valid());
+ REQUIRE_FALSE(variant_type{mapbox::util::no_init()}.valid());
+}
+
+TEST_CASE("variant printer", "[visitor][unary visitor][printer]")
+{
+ using variant_type = mapbox::util::variant<int, double, std::string>;
+ std::vector<variant_type> var = {2.1, 123, "foo", 456};
+ std::stringstream out;
+ std::copy(var.begin(), var.end(), std::ostream_iterator<variant_type>(out, ","));
+ out << var[2];
+ REQUIRE(out.str() == "2.1,123,foo,456,foo");
+}
+
+TEST_CASE("swapping variants should do the right thing", "[variant]")
+{
+ using variant_type = mapbox::util::variant<int, double, std::string>;
+ variant_type a = 7;
+ variant_type b = 3;
+ variant_type c = 3.141;
+ variant_type d = "foo";
+ variant_type e = "a long string that is longer than small string optimization";
+
+ using std::swap;
+ swap(a, b);
+ REQUIRE(a.get<int>() == 3);
+ REQUIRE(a.which() == 0);
+ REQUIRE(b.get<int>() == 7);
+ REQUIRE(b.which() == 0);
+
+ swap(b, c);
+ REQUIRE(b.get<double>() == Approx(3.141));
+ REQUIRE(b.which() == 1);
+ REQUIRE(c.get<int>() == 7);
+ REQUIRE(c.which() == 0);
+
+ swap(b, d);
+ REQUIRE(b.get<std::string>() == "foo");
+ REQUIRE(b.which() == 2);
+ REQUIRE(d.get<double>() == Approx(3.141));
+ REQUIRE(d.which() == 1);
+
+ swap(b, e);
+ REQUIRE(b.get<std::string>() == "a long string that is longer than small string optimization");
+ REQUIRE(b.which() == 2);
+ REQUIRE(e.get<std::string>() == "foo");
+ REQUIRE(e.which() == 2);
+}
+
+TEST_CASE("variant should work with equality operators")
+{
+ using variant_type = mapbox::util::variant<int, std::string>;
+
+ variant_type a{1};
+ variant_type b{1};
+ variant_type c{2};
+ variant_type s{"foo"};
+
+ REQUIRE(a == a);
+ REQUIRE(a == b);
+ REQUIRE_FALSE(a == c);
+ REQUIRE_FALSE(a == s);
+ REQUIRE_FALSE(c == s);
+
+ REQUIRE_FALSE(a != a);
+ REQUIRE_FALSE(a != b);
+ REQUIRE(a != c);
+ REQUIRE(a != s);
+ REQUIRE(c != s);
+}
+
+TEST_CASE("variant should work with comparison operators")
+{
+ using variant_type = mapbox::util::variant<int, std::string>;
+
+ variant_type a{1};
+ variant_type b{1};
+ variant_type c{2};
+ variant_type s{"foo"};
+ variant_type t{"bar"};
+
+ REQUIRE_FALSE(a < a);
+ REQUIRE_FALSE(a < b);
+ REQUIRE(a < c);
+ REQUIRE(a < s);
+ REQUIRE(c < s);
+ REQUIRE(t < s);
+
+ REQUIRE_FALSE(a > a);
+ REQUIRE_FALSE(a > b);
+ REQUIRE_FALSE(a > c);
+ REQUIRE_FALSE(a > s);
+ REQUIRE_FALSE(c > s);
+ REQUIRE_FALSE(t > s);
+
+ REQUIRE(a <= a);
+ REQUIRE(a <= b);
+ REQUIRE(a <= c);
+ REQUIRE(a <= s);
+ REQUIRE(c <= s);
+ REQUIRE(t <= s);
+
+ REQUIRE(a >= a);
+ REQUIRE(a >= b);
+ REQUIRE_FALSE(a >= c);
+ REQUIRE_FALSE(a >= s);
+ REQUIRE_FALSE(c >= s);
+ REQUIRE_FALSE(t >= s);
+}
+
+TEST_CASE("storing reference wrappers works")
+{
+ using variant_type = mapbox::util::variant<std::reference_wrapper<int>, std::reference_wrapper<double>>;
+
+ int a = 1;
+ variant_type v{std::ref(a)};
+ REQUIRE(v.get<int>() == 1);
+ REQUIRE(mapbox::util::get<int>(v) == 1);
+ REQUIRE_THROWS_AS({
+ v.get<double>();
+ },
+ mapbox::util::bad_variant_access&);
+ REQUIRE_THROWS_AS({
+ mapbox::util::get<double>(v);
+ },
+ mapbox::util::bad_variant_access&);
+ a = 2;
+ REQUIRE(v.get<int>() == 2);
+ v.get<int>() = 3;
+ REQUIRE(a == 3);
+
+ double b = 3.141;
+ v = std::ref(b);
+ REQUIRE(v.get<double>() == Approx(3.141));
+ REQUIRE(mapbox::util::get<double>(v) == Approx(3.141));
+ REQUIRE_THROWS_AS({
+ v.get<int>();
+ },
+ mapbox::util::bad_variant_access&);
+ REQUIRE_THROWS_AS({
+ mapbox::util::get<int>(v);
+ },
+ mapbox::util::bad_variant_access&);
+ b = 2.718;
+ REQUIRE(v.get<double>() == Approx(2.718));
+ a = 3;
+ REQUIRE(v.get<double>() == Approx(2.718));
+ v.get<double>() = 4.1;
+ REQUIRE(b == Approx(4.1));
+
+ REQUIRE_THROWS_AS({
+ v.get<int>() = 4;
+ },
+ mapbox::util::bad_variant_access&);
+}
+
+TEST_CASE("storing reference wrappers to consts works")
+{
+ using variant_type = mapbox::util::variant<std::reference_wrapper<int const>, std::reference_wrapper<double const>>;
+
+ int a = 1;
+ variant_type v{std::cref(a)};
+ REQUIRE(v.get<int const>() == 1);
+ REQUIRE(v.get<int>() == 1); // this works (see #82)
+ REQUIRE(mapbox::util::get<int const>(v) == 1);
+ // REQUIRE(mapbox::util::get<int>(v) == 1); // this doesn't work (see #82)
+ REQUIRE_THROWS_AS({
+ v.get<double const>();
+ },
+ mapbox::util::bad_variant_access&);
+ REQUIRE_THROWS_AS({
+ mapbox::util::get<double const>(v);
+ },
+ mapbox::util::bad_variant_access&);
+
+ double b = 3.141;
+ v = std::cref(b);
+ REQUIRE(v.get<double const>() == Approx(3.141));
+ REQUIRE(mapbox::util::get<double const>(v) == Approx(3.141));
+ REQUIRE_THROWS_AS({
+ v.get<int const>();
+ },
+ mapbox::util::bad_variant_access&);
+ REQUIRE_THROWS_AS({
+ mapbox::util::get<int const>(v);
+ },
+ mapbox::util::bad_variant_access&);
+}
diff --git a/test/unique_ptr_test.cpp b/test/unique_ptr_test.cpp
new file mode 100644
index 0000000..6578991
--- /dev/null
+++ b/test/unique_ptr_test.cpp
@@ -0,0 +1,126 @@
+
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <typeinfo>
+#include <utility>
+
+#include <boost/timer/timer.hpp>
+
+#include "variant.hpp"
+
+using namespace mapbox;
+
+namespace test {
+
+struct add;
+struct sub;
+
+template <typename OpTag>
+struct binary_op;
+
+typedef util::variant<int,
+ std::unique_ptr<binary_op<add>>,
+ std::unique_ptr<binary_op<sub>>>
+ expression;
+
+template <typename Op>
+struct binary_op
+{
+ expression left; // variant instantiated here...
+ expression right;
+
+ binary_op(expression&& lhs, expression&& rhs)
+ : left(std::move(lhs)), right(std::move(rhs))
+ {
+ }
+};
+
+struct print
+{
+ template <typename T>
+ void operator()(T const& val) const
+ {
+ std::cerr << val << ":" << typeid(T).name() << std::endl;
+ }
+};
+
+struct test
+{
+ template <typename T>
+ std::string operator()(T const& obj) const
+ {
+ return std::string("TYPE_ID=") + typeid(obj).name();
+ }
+};
+
+struct calculator
+{
+ public:
+ int operator()(int value) const
+ {
+ return value;
+ }
+
+ int operator()(std::unique_ptr<binary_op<add>> const& binary) const
+ {
+ return util::apply_visitor(calculator(), binary->left) + util::apply_visitor(calculator(), binary->right);
+ }
+
+ int operator()(std::unique_ptr<binary_op<sub>> const& binary) const
+ {
+ return util::apply_visitor(calculator(), binary->left) - util::apply_visitor(calculator(), binary->right);
+ }
+};
+
+struct to_string
+{
+ public:
+ std::string operator()(int value) const
+ {
+ return std::to_string(value);
+ }
+
+ std::string operator()(std::unique_ptr<binary_op<add>> const& binary) const
+ {
+ return util::apply_visitor(to_string(), binary->left) + std::string("+") + util::apply_visitor(to_string(), binary->right);
+ }
+
+ std::string operator()(std::unique_ptr<binary_op<sub>> const& binary) const
+ {
+ return util::apply_visitor(to_string(), binary->left) + std::string("-") + util::apply_visitor(to_string(), binary->right);
+ }
+};
+
+} // namespace test
+
+int main(int argc, char** argv)
+{
+ if (argc != 2)
+ {
+ std::cerr << "Usage" << argv[0] << " <num-iter>" << std::endl;
+ return EXIT_FAILURE;
+ }
+
+ const std::size_t NUM_ITER = static_cast<std::size_t>(std::stol(argv[1]));
+
+ test::expression sum(std::unique_ptr<test::binary_op<test::add>>(new test::binary_op<test::add>(2, 3)));
+ test::expression result(std::unique_ptr<test::binary_op<test::sub>>(new test::binary_op<test::sub>(std::move(sum), 4)));
+
+ std::cerr << "TYPE OF RESULT-> " << util::apply_visitor(test::test(), result) << std::endl;
+
+ int total = 0;
+ {
+ boost::timer::auto_cpu_timer t;
+ for (std::size_t i = 0; i < NUM_ITER; ++i)
+ {
+ total += util::apply_visitor(test::calculator(), result);
+ }
+ }
+ std::cerr << "total=" << total << std::endl;
+
+ std::cerr << util::apply_visitor(test::to_string(), result) << "=" << util::apply_visitor(test::calculator(), result) << std::endl;
+
+ return EXIT_SUCCESS;
+}
diff --git a/test/unit.cpp b/test/unit.cpp
new file mode 100644
index 0000000..0c7c351
--- /dev/null
+++ b/test/unit.cpp
@@ -0,0 +1,2 @@
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
diff --git a/variant.gyp b/variant.gyp
new file mode 100644
index 0000000..b1f3801
--- /dev/null
+++ b/variant.gyp
@@ -0,0 +1,35 @@
+{
+ "includes": [
+ "common.gypi"
+ ],
+ "targets": [
+ {
+ "target_name": "tests",
+ "type": "executable",
+ "sources": [
+ "test/unit.cpp",
+ "test/t/binary_visitor_1.cpp",
+ "test/t/binary_visitor_2.cpp",
+ "test/t/binary_visitor_3.cpp",
+ "test/t/binary_visitor_4.cpp",
+ "test/t/binary_visitor_5.cpp",
+ "test/t/binary_visitor_6.cpp",
+ "test/t/issue21.cpp",
+ "test/t/mutating_visitor.cpp",
+ "test/t/optional.cpp",
+ "test/t/recursive_wrapper.cpp",
+ "test/t/sizeof.cpp",
+ "test/t/unary_visitor.cpp",
+ "test/t/variant.cpp"
+ ],
+ "xcode_settings": {
+ "SDKROOT": "macosx",
+ "SUPPORTED_PLATFORMS":["macosx"]
+ },
+ "include_dirs": [
+ "./",
+ "test/include"
+ ]
+ }
+ ]
+}
diff --git a/variant.hpp b/variant.hpp
new file mode 100644
index 0000000..db5d3c8
--- /dev/null
+++ b/variant.hpp
@@ -0,0 +1,901 @@
+#ifndef MAPBOX_UTIL_VARIANT_HPP
+#define MAPBOX_UTIL_VARIANT_HPP
+
+#include <cassert>
+#include <cstddef> // size_t
+#include <new> // operator new
+#include <stdexcept> // runtime_error
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+
+#include "recursive_wrapper.hpp"
+
+// clang-format off
+// [[deprecated]] is only available in C++14, use this for the time being
+#if __cplusplus <= 201103L
+# ifdef __GNUC__
+# define MAPBOX_VARIANT_DEPRECATED __attribute__((deprecated))
+# elif defined(_MSC_VER)
+# define MAPBOX_VARIANT_DEPRECATED __declspec(deprecated)
+# else
+# define MAPBOX_VARIANT_DEPRECATED
+# endif
+#else
+# define MAPBOX_VARIANT_DEPRECATED [[deprecated]]
+#endif
+
+
+#ifdef _MSC_VER
+ // https://msdn.microsoft.com/en-us/library/bw1hbe6y.aspx
+ #ifdef NDEBUG
+ #define VARIANT_INLINE __forceinline
+ #else
+ #define VARIANT_INLINE __declspec(noinline)
+ #endif
+#else
+ #ifdef NDEBUG
+ #define VARIANT_INLINE inline __attribute__((always_inline))
+ #else
+ #define VARIANT_INLINE __attribute__((noinline))
+ #endif
+#endif
+// clang-format on
+
+#define VARIANT_MAJOR_VERSION 1
+#define VARIANT_MINOR_VERSION 1
+#define VARIANT_PATCH_VERSION 0
+
+#define VARIANT_VERSION (VARIANT_MAJOR_VERSION * 100000) + (VARIANT_MINOR_VERSION * 100) + (VARIANT_PATCH_VERSION)
+
+namespace mapbox {
+namespace util {
+
+// XXX This should derive from std::logic_error instead of std::runtime_error.
+// See https://github.com/mapbox/variant/issues/48 for details.
+class bad_variant_access : public std::runtime_error
+{
+
+ public:
+ explicit bad_variant_access(const std::string& what_arg)
+ : runtime_error(what_arg) {}
+
+ explicit bad_variant_access(const char* what_arg)
+ : runtime_error(what_arg) {}
+
+}; // class bad_variant_access
+
+template <typename R = void>
+struct MAPBOX_VARIANT_DEPRECATED static_visitor
+{
+ using result_type = R;
+
+ protected:
+ static_visitor() {}
+ ~static_visitor() {}
+};
+
+namespace detail {
+
+static constexpr std::size_t invalid_value = std::size_t(-1);
+
+template <typename T, typename... Types>
+struct direct_type;
+
+template <typename T, typename First, typename... Types>
+struct direct_type<T, First, Types...>
+{
+ static constexpr std::size_t index = std::is_same<T, First>::value
+ ? sizeof...(Types)
+ : direct_type<T, Types...>::index;
+};
+
+template <typename T>
+struct direct_type<T>
+{
+ static constexpr std::size_t index = invalid_value;
+};
+
+template <typename T, typename... Types>
+struct convertible_type;
+
+template <typename T, typename First, typename... Types>
+struct convertible_type<T, First, Types...>
+{
+ static constexpr std::size_t index = std::is_convertible<T, First>::value
+ ? sizeof...(Types)
+ : convertible_type<T, Types...>::index;
+};
+
+template <typename T>
+struct convertible_type<T>
+{
+ static constexpr std::size_t index = invalid_value;
+};
+
+template <typename T, typename... Types>
+struct value_traits
+{
+ using value_type = typename std::remove_reference<T>::type;
+ static constexpr std::size_t direct_index = direct_type<value_type, Types...>::index;
+ static constexpr bool is_direct = direct_index != invalid_value;
+ static constexpr std::size_t index = is_direct ? direct_index : convertible_type<value_type, Types...>::index;
+ static constexpr bool is_valid = index != invalid_value;
+ static constexpr std::size_t tindex = is_valid ? sizeof...(Types)-index : 0;
+ using target_type = typename std::tuple_element<tindex, std::tuple<void, Types...>>::type;
+};
+
+// check if T is in Types...
+template <typename T, typename... Types>
+struct has_type;
+
+template <typename T, typename First, typename... Types>
+struct has_type<T, First, Types...>
+{
+ static constexpr bool value = std::is_same<T, First>::value || has_type<T, Types...>::value;
+};
+
+template <typename T>
+struct has_type<T> : std::false_type
+{
+};
+
+template <typename T, typename... Types>
+struct is_valid_type;
+
+template <typename T, typename First, typename... Types>
+struct is_valid_type<T, First, Types...>
+{
+ static constexpr bool value = std::is_convertible<T, First>::value || is_valid_type<T, Types...>::value;
+};
+
+template <typename T>
+struct is_valid_type<T> : std::false_type
+{
+};
+
+template <typename T, typename R = void>
+struct enable_if_type
+{
+ using type = R;
+};
+
+template <typename F, typename V, typename Enable = void>
+struct result_of_unary_visit
+{
+ using type = typename std::result_of<F(V&)>::type;
+};
+
+template <typename F, typename V>
+struct result_of_unary_visit<F, V, typename enable_if_type<typename F::result_type>::type>
+{
+ using type = typename F::result_type;
+};
+
+template <typename F, typename V, typename Enable = void>
+struct result_of_binary_visit
+{
+ using type = typename std::result_of<F(V&, V&)>::type;
+};
+
+template <typename F, typename V>
+struct result_of_binary_visit<F, V, typename enable_if_type<typename F::result_type>::type>
+{
+ using type = typename F::result_type;
+};
+
+template <std::size_t arg1, std::size_t... others>
+struct static_max;
+
+template <std::size_t arg>
+struct static_max<arg>
+{
+ static const std::size_t value = arg;
+};
+
+template <std::size_t arg1, std::size_t arg2, std::size_t... others>
+struct static_max<arg1, arg2, others...>
+{
+ static const std::size_t value = arg1 >= arg2 ? static_max<arg1, others...>::value : static_max<arg2, others...>::value;
+};
+
+template <typename... Types>
+struct variant_helper;
+
+template <typename T, typename... Types>
+struct variant_helper<T, Types...>
+{
+ VARIANT_INLINE static void destroy(const std::size_t type_index, void* data)
+ {
+ if (type_index == sizeof...(Types))
+ {
+ reinterpret_cast<T*>(data)->~T();
+ }
+ else
+ {
+ variant_helper<Types...>::destroy(type_index, data);
+ }
+ }
+
+ VARIANT_INLINE static void move(const std::size_t old_type_index, void* old_value, void* new_value)
+ {
+ if (old_type_index == sizeof...(Types))
+ {
+ new (new_value) T(std::move(*reinterpret_cast<T*>(old_value)));
+ }
+ else
+ {
+ variant_helper<Types...>::move(old_type_index, old_value, new_value);
+ }
+ }
+
+ VARIANT_INLINE static void copy(const std::size_t old_type_index, const void* old_value, void* new_value)
+ {
+ if (old_type_index == sizeof...(Types))
+ {
+ new (new_value) T(*reinterpret_cast<const T*>(old_value));
+ }
+ else
+ {
+ variant_helper<Types...>::copy(old_type_index, old_value, new_value);
+ }
+ }
+};
+
+template <>
+struct variant_helper<>
+{
+ VARIANT_INLINE static void destroy(const std::size_t, void*) {}
+ VARIANT_INLINE static void move(const std::size_t, void*, void*) {}
+ VARIANT_INLINE static void copy(const std::size_t, const void*, void*) {}
+};
+
+template <typename T>
+struct unwrapper
+{
+ static T const& apply_const(T const& obj) { return obj; }
+ static T& apply(T& obj) { return obj; }
+};
+
+template <typename T>
+struct unwrapper<recursive_wrapper<T>>
+{
+ static auto apply_const(recursive_wrapper<T> const& obj)
+ -> typename recursive_wrapper<T>::type const&
+ {
+ return obj.get();
+ }
+ static auto apply(recursive_wrapper<T>& obj)
+ -> typename recursive_wrapper<T>::type&
+ {
+ return obj.get();
+ }
+};
+
+template <typename T>
+struct unwrapper<std::reference_wrapper<T>>
+{
+ static auto apply_const(std::reference_wrapper<T> const& obj)
+ -> typename std::reference_wrapper<T>::type const&
+ {
+ return obj.get();
+ }
+ static auto apply(std::reference_wrapper<T>& obj)
+ -> typename std::reference_wrapper<T>::type&
+ {
+ return obj.get();
+ }
+};
+
+template <typename F, typename V, typename R, typename... Types>
+struct dispatcher;
+
+template <typename F, typename V, typename R, typename T, typename... Types>
+struct dispatcher<F, V, R, T, Types...>
+{
+ VARIANT_INLINE static R apply_const(V const& v, F&& f)
+ {
+ if (v.template is<T>())
+ {
+ return f(unwrapper<T>::apply_const(v.template get<T>()));
+ }
+ else
+ {
+ return dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f));
+ }
+ }
+
+ VARIANT_INLINE static R apply(V& v, F&& f)
+ {
+ if (v.template is<T>())
+ {
+ return f(unwrapper<T>::apply(v.template get<T>()));
+ }
+ else
+ {
+ return dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f));
+ }
+ }
+};
+
+template <typename F, typename V, typename R, typename T>
+struct dispatcher<F, V, R, T>
+{
+ VARIANT_INLINE static R apply_const(V const& v, F&& f)
+ {
+ return f(unwrapper<T>::apply_const(v.template get<T>()));
+ }
+
+ VARIANT_INLINE static R apply(V& v, F&& f)
+ {
+ return f(unwrapper<T>::apply(v.template get<T>()));
+ }
+};
+
+template <typename F, typename V, typename R, typename T, typename... Types>
+struct binary_dispatcher_rhs;
+
+template <typename F, typename V, typename R, typename T0, typename T1, typename... Types>
+struct binary_dispatcher_rhs<F, V, R, T0, T1, Types...>
+{
+ VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
+ {
+ if (rhs.template is<T1>()) // call binary functor
+ {
+ return f(unwrapper<T0>::apply_const(lhs.template get<T0>()),
+ unwrapper<T1>::apply_const(rhs.template get<T1>()));
+ }
+ else
+ {
+ return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply_const(lhs, rhs, std::forward<F>(f));
+ }
+ }
+
+ VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
+ {
+ if (rhs.template is<T1>()) // call binary functor
+ {
+ return f(unwrapper<T0>::apply(lhs.template get<T0>()),
+ unwrapper<T1>::apply(rhs.template get<T1>()));
+ }
+ else
+ {
+ return binary_dispatcher_rhs<F, V, R, T0, Types...>::apply(lhs, rhs, std::forward<F>(f));
+ }
+ }
+};
+
+template <typename F, typename V, typename R, typename T0, typename T1>
+struct binary_dispatcher_rhs<F, V, R, T0, T1>
+{
+ VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
+ {
+ return f(unwrapper<T0>::apply_const(lhs.template get<T0>()),
+ unwrapper<T1>::apply_const(rhs.template get<T1>()));
+ }
+
+ VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
+ {
+ return f(unwrapper<T0>::apply(lhs.template get<T0>()),
+ unwrapper<T1>::apply(rhs.template get<T1>()));
+ }
+};
+
+template <typename F, typename V, typename R, typename T, typename... Types>
+struct binary_dispatcher_lhs;
+
+template <typename F, typename V, typename R, typename T0, typename T1, typename... Types>
+struct binary_dispatcher_lhs<F, V, R, T0, T1, Types...>
+{
+ VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
+ {
+ if (lhs.template is<T1>()) // call binary functor
+ {
+ return f(unwrapper<T1>::apply_const(lhs.template get<T1>()),
+ unwrapper<T0>::apply_const(rhs.template get<T0>()));
+ }
+ else
+ {
+ return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply_const(lhs, rhs, std::forward<F>(f));
+ }
+ }
+
+ VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
+ {
+ if (lhs.template is<T1>()) // call binary functor
+ {
+ return f(unwrapper<T1>::apply(lhs.template get<T1>()),
+ unwrapper<T0>::apply(rhs.template get<T0>()));
+ }
+ else
+ {
+ return binary_dispatcher_lhs<F, V, R, T0, Types...>::apply(lhs, rhs, std::forward<F>(f));
+ }
+ }
+};
+
+template <typename F, typename V, typename R, typename T0, typename T1>
+struct binary_dispatcher_lhs<F, V, R, T0, T1>
+{
+ VARIANT_INLINE static R apply_const(V const& lhs, V const& rhs, F&& f)
+ {
+ return f(unwrapper<T1>::apply_const(lhs.template get<T1>()),
+ unwrapper<T0>::apply_const(rhs.template get<T0>()));
+ }
+
+ VARIANT_INLINE static R apply(V& lhs, V& rhs, F&& f)
+ {
+ return f(unwrapper<T1>::apply(lhs.template get<T1>()),
+ unwrapper<T0>::apply(rhs.template get<T0>()));
+ }
+};
+
+template <typename F, typename V, typename R, typename... Types>
+struct binary_dispatcher;
+
+template <typename F, typename V, typename R, typename T, typename... Types>
+struct binary_dispatcher<F, V, R, T, Types...>
+{
+ VARIANT_INLINE static R apply_const(V const& v0, V const& v1, F&& f)
+ {
+ if (v0.template is<T>())
+ {
+ if (v1.template is<T>())
+ {
+ return f(unwrapper<T>::apply_const(v0.template get<T>()),
+ unwrapper<T>::apply_const(v1.template get<T>())); // call binary functor
+ }
+ else
+ {
+ return binary_dispatcher_rhs<F, V, R, T, Types...>::apply_const(v0, v1, std::forward<F>(f));
+ }
+ }
+ else if (v1.template is<T>())
+ {
+ return binary_dispatcher_lhs<F, V, R, T, Types...>::apply_const(v0, v1, std::forward<F>(f));
+ }
+ return binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f));
+ }
+
+ VARIANT_INLINE static R apply(V& v0, V& v1, F&& f)
+ {
+ if (v0.template is<T>())
+ {
+ if (v1.template is<T>())
+ {
+ return f(unwrapper<T>::apply(v0.template get<T>()),
+ unwrapper<T>::apply(v1.template get<T>())); // call binary functor
+ }
+ else
+ {
+ return binary_dispatcher_rhs<F, V, R, T, Types...>::apply(v0, v1, std::forward<F>(f));
+ }
+ }
+ else if (v1.template is<T>())
+ {
+ return binary_dispatcher_lhs<F, V, R, T, Types...>::apply(v0, v1, std::forward<F>(f));
+ }
+ return binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f));
+ }
+};
+
+template <typename F, typename V, typename R, typename T>
+struct binary_dispatcher<F, V, R, T>
+{
+ VARIANT_INLINE static R apply_const(V const& v0, V const& v1, F&& f)
+ {
+ return f(unwrapper<T>::apply_const(v0.template get<T>()),
+ unwrapper<T>::apply_const(v1.template get<T>())); // call binary functor
+ }
+
+ VARIANT_INLINE static R apply(V& v0, V& v1, F&& f)
+ {
+ return f(unwrapper<T>::apply(v0.template get<T>()),
+ unwrapper<T>::apply(v1.template get<T>())); // call binary functor
+ }
+};
+
+// comparator functors
+struct equal_comp
+{
+ template <typename T>
+ bool operator()(T const& lhs, T const& rhs) const
+ {
+ return lhs == rhs;
+ }
+};
+
+struct less_comp
+{
+ template <typename T>
+ bool operator()(T const& lhs, T const& rhs) const
+ {
+ return lhs < rhs;
+ }
+};
+
+template <typename Variant, typename Comp>
+class comparer
+{
+ public:
+ explicit comparer(Variant const& lhs) noexcept
+ : lhs_(lhs) {}
+ comparer& operator=(comparer const&) = delete;
+ // visitor
+ template <typename T>
+ bool operator()(T const& rhs_content) const
+ {
+ T const& lhs_content = lhs_.template get<T>();
+ return Comp()(lhs_content, rhs_content);
+ }
+
+ private:
+ Variant const& lhs_;
+};
+
+// True if Predicate matches for all of the types Ts
+template <template <typename> class Predicate, typename... Ts>
+struct static_all_of : std::is_same<std::tuple<std::true_type, typename Predicate<Ts>::type...>,
+ std::tuple<typename Predicate<Ts>::type..., std::true_type>>
+{
+};
+
+// True if Predicate matches for none of the types Ts
+template <template <typename> class Predicate, typename... Ts>
+struct static_none_of : std::is_same<std::tuple<std::false_type, typename Predicate<Ts>::type...>,
+ std::tuple<typename Predicate<Ts>::type..., std::false_type>>
+{
+};
+
+} // namespace detail
+
+struct no_init
+{
+};
+
+template <typename... Types>
+class variant
+{
+ static_assert(sizeof...(Types) > 0, "Template parameter type list of variant can not be empty");
+ static_assert(detail::static_none_of<std::is_reference, Types...>::value, "Variant can not hold reference types. Maybe use std::reference?");
+
+ private:
+ static const std::size_t data_size = detail::static_max<sizeof(Types)...>::value;
+ static const std::size_t data_align = detail::static_max<alignof(Types)...>::value;
+
+ using first_type = typename std::tuple_element<0, std::tuple<Types...>>::type;
+ using data_type = typename std::aligned_storage<data_size, data_align>::type;
+ using helper_type = detail::variant_helper<Types...>;
+
+ std::size_t type_index;
+ data_type data;
+
+ public:
+ VARIANT_INLINE variant() noexcept(std::is_nothrow_default_constructible<first_type>::value)
+ : type_index(sizeof...(Types)-1)
+ {
+ static_assert(std::is_default_constructible<first_type>::value, "First type in variant must be default constructible to allow default construction of variant");
+ new (&data) first_type();
+ }
+
+ VARIANT_INLINE variant(no_init) noexcept
+ : type_index(detail::invalid_value) {}
+
+ // http://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers
+ template <typename T, typename Traits = detail::value_traits<T, Types...>,
+ typename Enable = typename std::enable_if<Traits::is_valid>::type>
+ VARIANT_INLINE variant(T&& val) noexcept(std::is_nothrow_constructible<typename Traits::target_type, T&&>::value)
+ : type_index(Traits::index)
+ {
+ new (&data) typename Traits::target_type(std::forward<T>(val));
+ }
+
+ VARIANT_INLINE variant(variant<Types...> const& old)
+ : type_index(old.type_index)
+ {
+ helper_type::copy(old.type_index, &old.data, &data);
+ }
+
+ VARIANT_INLINE variant(variant<Types...>&& old) noexcept(std::is_nothrow_move_constructible<std::tuple<Types...>>::value)
+ : type_index(old.type_index)
+ {
+ helper_type::move(old.type_index, &old.data, &data);
+ }
+
+ private:
+ VARIANT_INLINE void copy_assign(variant<Types...> const& rhs)
+ {
+ helper_type::destroy(type_index, &data);
+ type_index = detail::invalid_value;
+ helper_type::copy(rhs.type_index, &rhs.data, &data);
+ type_index = rhs.type_index;
+ }
+
+ VARIANT_INLINE void move_assign(variant<Types...>&& rhs)
+ {
+ helper_type::destroy(type_index, &data);
+ type_index = detail::invalid_value;
+ helper_type::move(rhs.type_index, &rhs.data, &data);
+ type_index = rhs.type_index;
+ }
+
+ public:
+ VARIANT_INLINE variant<Types...>& operator=(variant<Types...>&& other)
+ {
+ move_assign(std::move(other));
+ return *this;
+ }
+
+ VARIANT_INLINE variant<Types...>& operator=(variant<Types...> const& other)
+ {
+ copy_assign(other);
+ return *this;
+ }
+
+ // conversions
+ // move-assign
+ template <typename T>
+ VARIANT_INLINE variant<Types...>& operator=(T&& rhs) noexcept
+ {
+ variant<Types...> temp(std::forward<T>(rhs));
+ move_assign(std::move(temp));
+ return *this;
+ }
+
+ // copy-assign
+ template <typename T>
+ VARIANT_INLINE variant<Types...>& operator=(T const& rhs)
+ {
+ variant<Types...> temp(rhs);
+ copy_assign(temp);
+ return *this;
+ }
+
+ template <typename T>
+ VARIANT_INLINE bool is() const
+ {
+ static_assert(detail::has_type<T, Types...>::value, "invalid type in T in `is<T>()` for this variant");
+ return type_index == detail::direct_type<T, Types...>::index;
+ }
+
+ VARIANT_INLINE bool valid() const
+ {
+ return type_index != detail::invalid_value;
+ }
+
+ template <typename T, typename... Args>
+ VARIANT_INLINE void set(Args&&... args)
+ {
+ helper_type::destroy(type_index, &data);
+ type_index = detail::invalid_value;
+ new (&data) T(std::forward<Args>(args)...);
+ type_index = detail::direct_type<T, Types...>::index;
+ }
+
+ // get<T>()
+ template <typename T, typename std::enable_if<
+ (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ VARIANT_INLINE T& get()
+ {
+ if (type_index == detail::direct_type<T, Types...>::index)
+ {
+ return *reinterpret_cast<T*>(&data);
+ }
+ else
+ {
+ throw bad_variant_access("in get<T>()");
+ }
+ }
+
+ template <typename T, typename std::enable_if<
+ (detail::direct_type<T, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ VARIANT_INLINE T const& get() const
+ {
+ if (type_index == detail::direct_type<T, Types...>::index)
+ {
+ return *reinterpret_cast<T const*>(&data);
+ }
+ else
+ {
+ throw bad_variant_access("in get<T>()");
+ }
+ }
+
+ // get<T>() - T stored as recursive_wrapper<T>
+ template <typename T, typename std::enable_if<
+ (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ VARIANT_INLINE T& get()
+ {
+ if (type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index)
+ {
+ return (*reinterpret_cast<recursive_wrapper<T>*>(&data)).get();
+ }
+ else
+ {
+ throw bad_variant_access("in get<T>()");
+ }
+ }
+
+ template <typename T, typename std::enable_if<
+ (detail::direct_type<recursive_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ VARIANT_INLINE T const& get() const
+ {
+ if (type_index == detail::direct_type<recursive_wrapper<T>, Types...>::index)
+ {
+ return (*reinterpret_cast<recursive_wrapper<T> const*>(&data)).get();
+ }
+ else
+ {
+ throw bad_variant_access("in get<T>()");
+ }
+ }
+
+ // get<T>() - T stored as std::reference_wrapper<T>
+ template <typename T, typename std::enable_if<
+ (detail::direct_type<std::reference_wrapper<T>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ VARIANT_INLINE T& get()
+ {
+ if (type_index == detail::direct_type<std::reference_wrapper<T>, Types...>::index)
+ {
+ return (*reinterpret_cast<std::reference_wrapper<T>*>(&data)).get();
+ }
+ else
+ {
+ throw bad_variant_access("in get<T>()");
+ }
+ }
+
+ template <typename T, typename std::enable_if<
+ (detail::direct_type<std::reference_wrapper<T const>, Types...>::index != detail::invalid_value)>::type* = nullptr>
+ VARIANT_INLINE T const& get() const
+ {
+ if (type_index == detail::direct_type<std::reference_wrapper<T const>, Types...>::index)
+ {
+ return (*reinterpret_cast<std::reference_wrapper<T const> const*>(&data)).get();
+ }
+ else
+ {
+ throw bad_variant_access("in get<T>()");
+ }
+ }
+
+ // This function is deprecated because it returns an internal index field.
+ // Use which() instead.
+ MAPBOX_VARIANT_DEPRECATED VARIANT_INLINE std::size_t get_type_index() const
+ {
+ return type_index;
+ }
+
+ VARIANT_INLINE int which() const noexcept
+ {
+ return static_cast<int>(sizeof...(Types)-type_index - 1);
+ }
+
+ // visitor
+ // unary
+ template <typename F, typename V, typename R = typename detail::result_of_unary_visit<F, first_type>::type>
+ auto VARIANT_INLINE static visit(V const& v, F&& f)
+ -> decltype(detail::dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f)))
+ {
+ return detail::dispatcher<F, V, R, Types...>::apply_const(v, std::forward<F>(f));
+ }
+ // non-const
+ template <typename F, typename V, typename R = typename detail::result_of_unary_visit<F, first_type>::type>
+ auto VARIANT_INLINE static visit(V& v, F&& f)
+ -> decltype(detail::dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f)))
+ {
+ return detail::dispatcher<F, V, R, Types...>::apply(v, std::forward<F>(f));
+ }
+
+ // binary
+ // const
+ template <typename F, typename V, typename R = typename detail::result_of_binary_visit<F, first_type>::type>
+ auto VARIANT_INLINE static binary_visit(V const& v0, V const& v1, F&& f)
+ -> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f)))
+ {
+ return detail::binary_dispatcher<F, V, R, Types...>::apply_const(v0, v1, std::forward<F>(f));
+ }
+ // non-const
+ template <typename F, typename V, typename R = typename detail::result_of_binary_visit<F, first_type>::type>
+ auto VARIANT_INLINE static binary_visit(V& v0, V& v1, F&& f)
+ -> decltype(detail::binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f)))
+ {
+ return detail::binary_dispatcher<F, V, R, Types...>::apply(v0, v1, std::forward<F>(f));
+ }
+
+ ~variant() noexcept // no-throw destructor
+ {
+ helper_type::destroy(type_index, &data);
+ }
+
+ // comparison operators
+ // equality
+ VARIANT_INLINE bool operator==(variant const& rhs) const
+ {
+ assert(valid() && rhs.valid());
+ if (this->which() != rhs.which())
+ {
+ return false;
+ }
+ detail::comparer<variant, detail::equal_comp> visitor(*this);
+ return visit(rhs, visitor);
+ }
+
+ VARIANT_INLINE bool operator!=(variant const& rhs) const
+ {
+ return !(*this == rhs);
+ }
+
+ // less than
+ VARIANT_INLINE bool operator<(variant const& rhs) const
+ {
+ assert(valid() && rhs.valid());
+ if (this->which() != rhs.which())
+ {
+ return this->which() < rhs.which();
+ }
+ detail::comparer<variant, detail::less_comp> visitor(*this);
+ return visit(rhs, visitor);
+ }
+ VARIANT_INLINE bool operator>(variant const& rhs) const
+ {
+ return rhs < *this;
+ }
+ VARIANT_INLINE bool operator<=(variant const& rhs) const
+ {
+ return !(*this > rhs);
+ }
+ VARIANT_INLINE bool operator>=(variant const& rhs) const
+ {
+ return !(*this < rhs);
+ }
+};
+
+// unary visitor interface
+// const
+template <typename F, typename V>
+auto VARIANT_INLINE apply_visitor(F&& f, V const& v) -> decltype(V::visit(v, std::forward<F>(f)))
+{
+ return V::visit(v, std::forward<F>(f));
+}
+
+// non-const
+template <typename F, typename V>
+auto VARIANT_INLINE apply_visitor(F&& f, V& v) -> decltype(V::visit(v, std::forward<F>(f)))
+{
+ return V::visit(v, std::forward<F>(f));
+}
+
+// binary visitor interface
+// const
+template <typename F, typename V>
+auto VARIANT_INLINE apply_visitor(F&& f, V const& v0, V const& v1) -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
+{
+ return V::binary_visit(v0, v1, std::forward<F>(f));
+}
+
+// non-const
+template <typename F, typename V>
+auto VARIANT_INLINE apply_visitor(F&& f, V& v0, V& v1) -> decltype(V::binary_visit(v0, v1, std::forward<F>(f)))
+{
+ return V::binary_visit(v0, v1, std::forward<F>(f));
+}
+
+// getter interface
+template <typename ResultType, typename T>
+ResultType& get(T& var)
+{
+ return var.template get<ResultType>();
+}
+
+template <typename ResultType, typename T>
+ResultType const& get(T const& var)
+{
+ return var.template get<ResultType>();
+}
+} // namespace util
+} // namespace mapbox
+
+#endif // MAPBOX_UTIL_VARIANT_HPP
diff --git a/variant_io.hpp b/variant_io.hpp
new file mode 100644
index 0000000..e64cbad
--- /dev/null
+++ b/variant_io.hpp
@@ -0,0 +1,45 @@
+#ifndef MAPBOX_UTIL_VARIANT_IO_HPP
+#define MAPBOX_UTIL_VARIANT_IO_HPP
+
+#include <iosfwd>
+
+#include "variant.hpp"
+
+namespace mapbox {
+namespace util {
+
+namespace detail {
+// operator<< helper
+template <typename Out>
+class printer
+{
+ public:
+ explicit printer(Out& out)
+ : out_(out) {}
+ printer& operator=(printer const&) = delete;
+
+ // visitor
+ template <typename T>
+ void operator()(T const& operand) const
+ {
+ out_ << operand;
+ }
+
+ private:
+ Out& out_;
+};
+}
+
+// operator<<
+template <typename CharT, typename Traits, typename... Types>
+VARIANT_INLINE std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& out, variant<Types...> const& rhs)
+{
+ detail::printer<std::basic_ostream<CharT, Traits>> visitor(out);
+ apply_visitor(visitor, rhs);
+ return out;
+}
+} // namespace util
+} // namespace mapbox
+
+#endif // MAPBOX_UTIL_VARIANT_IO_HPP
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-grass/mapbox-variant.git
More information about the Pkg-grass-devel
mailing list