From d157c711f330c4128abf21cb06f1857a296cd766077a8186e0e92ede111fccf5 Mon Sep 17 00:00:00 2001 From: Christophe Marin Date: Tue, 10 Oct 2023 11:17:49 +0000 Subject: [PATCH] New krita dependency OBS-URL: https://build.opensuse.org/package/show/KDE:Extra/zug?expand=0&rev=1 --- .gitattributes | 23 + .gitignore | 1 + 0001-Drop-unused-copy-of-Catch2.patch | 16971 ++++++++++++++++++++++++ zug-0.1.0.tar.gz | 3 + zug.changes | 10 + zug.spec | 73 + 6 files changed, 17081 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 0001-Drop-unused-copy-of-Catch2.patch create mode 100644 zug-0.1.0.tar.gz create mode 100644 zug.changes create mode 100644 zug.spec diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57affb6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.osc diff --git a/0001-Drop-unused-copy-of-Catch2.patch b/0001-Drop-unused-copy-of-Catch2.patch new file mode 100644 index 0000000..070a0f3 --- /dev/null +++ b/0001-Drop-unused-copy-of-Catch2.patch @@ -0,0 +1,16971 @@ +From b469615311c78ccea1d6a9ebdb33319b1e8dfe6c Mon Sep 17 00:00:00 2001 +From: Pino Toscano +Date: Sun, 30 Jul 2023 07:49:35 +0200 +Subject: [PATCH 1/3] nix: disable tests & examples + +- the tests are not run or even built +- the examples are not installed +so it is better to simply disable them; this also avoids requiring +packages needed only for them. +--- + default.nix | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/default.nix b/default.nix +index 28c0b55..4b4511f 100644 +--- a/default.nix ++++ b/default.nix +@@ -14,6 +14,10 @@ stdenv.mkDerivation rec { + cmake + boost + ]; ++ cmakeFlags = [ ++ "-Dzug_BUILD_TESTS=OFF" ++ "-Dzug_BUILD_EXAMPLES=OFF" ++ ]; + meta = with lib; { + homepage = "https://github.com/arximboldi/zug"; + description = "library for functional interactive c++ programs"; + +From b7eb15fd7c4e26c42f673a566e0d561c49ac5bca Mon Sep 17 00:00:00 2001 +From: Pino Toscano +Date: Sat, 29 Jul 2023 09:14:27 +0200 +Subject: [PATCH 2/3] Switch to system Catch2 + +In case the tests are enabled, require a system installed version of +Catch2: +- find it using its CMake config file +- use the Catch2::Catch2 CMake target +- stop using the tools/include subdirectory in the include path + +Also adapt the Nix configuration for this. +--- + CMakeLists.txt | 4 ++-- + shell.nix | 1 + + test/CMakeLists.txt | 2 +- + 3 files changed, 4 insertions(+), 3 deletions(-) + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 92acf58..0da46a3 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -49,9 +49,9 @@ add_custom_target(check + + # the library, local development target + if(zug_BUILD_TESTS) ++ find_package(Catch2 REQUIRED) ++ + add_library(zug-dev INTERFACE) +- target_include_directories(zug-dev SYSTEM INTERFACE +- "$/tools/include") + target_link_libraries(zug-dev INTERFACE zug) + if (ENABLE_COVERAGE) + target_compile_options(zug-dev INTERFACE "--coverage") +diff --git a/shell.nix b/shell.nix +index 8303f05..f484777 100644 +--- a/shell.nix ++++ b/shell.nix +@@ -33,6 +33,7 @@ the-stdenv.mkDerivation rec { + buildInputs = [ + cmake + boost ++ catch2 + ccache + old-nixpkgs.doxygen + (old-nixpkgs.python.withPackages (ps: [ +diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt +index e87395c..bea9d9a 100644 +--- a/test/CMakeLists.txt ++++ b/test/CMakeLists.txt +@@ -32,6 +32,6 @@ foreach(_file IN LISTS zug_unit_tests) + set_target_properties(${_target} PROPERTIES OUTPUT_NAME ${_output}) + add_dependencies(tests ${_target}) + target_compile_definitions(${_target} PUBLIC CATCH_CONFIG_MAIN) +- target_link_libraries(${_target} PUBLIC zug-dev) ++ target_link_libraries(${_target} PUBLIC zug-dev Catch2::Catch2) + add_test("test/${_output}" ${_output}) + endforeach() + +From 975221cd66b903cb6594d3223dc9a34d1446a573 Mon Sep 17 00:00:00 2001 +From: Pino Toscano +Date: Sat, 29 Jul 2023 09:16:02 +0200 +Subject: [PATCH 3/3] Drop unused copy of Catch2 + +Now that the system version of Catch2 is used, the embedded copy is no +more needed. +--- + tools/include/catch2/catch.hpp | 16865 ------------------------------- + 1 file changed, 16865 deletions(-) + delete mode 100644 tools/include/catch2/catch.hpp + +diff --git a/tools/include/catch2/catch.hpp b/tools/include/catch2/catch.hpp +deleted file mode 100644 +index 303f664..0000000 +--- a/tools/include/catch2/catch.hpp ++++ /dev/null +@@ -1,16865 +0,0 @@ +-/* +- * Catch v2.9.1 +- * Generated: 2019-06-17 11:59:24.363643 +- * ---------------------------------------------------------- +- * This file has been merged from multiple headers. Please don't edit it directly +- * Copyright (c) 2019 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 +-// start catch.hpp +- +- +-#define CATCH_VERSION_MAJOR 2 +-#define CATCH_VERSION_MINOR 9 +-#define CATCH_VERSION_PATCH 1 +- +-#ifdef __clang__ +-# pragma clang system_header +-#elif defined __GNUC__ +-# pragma GCC system_header +-#endif +- +-// start 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 push +-# pragma clang diagnostic ignored "-Wpadded" +-# pragma clang diagnostic ignored "-Wswitch-enum" +-# pragma clang diagnostic ignored "-Wcovered-switch-default" +-# endif +-#elif defined __GNUC__ +- // Because REQUIREs trigger GCC's -Wparentheses, and because still +- // supported version of g++ have only buggy support for _Pragmas, +- // Wparentheses have to be suppressed globally. +-# pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details +- +-# pragma GCC diagnostic push +-# pragma GCC diagnostic ignored "-Wunused-variable" +-# pragma GCC diagnostic ignored "-Wpadded" +-#endif +-// end catch_suppress_warnings.h +-#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER) +-# define CATCH_IMPL +-# define CATCH_CONFIG_ALL_PARTS +-#endif +- +-// In the impl file, we want to have access to all parts of the headers +-// Can also be used to sanely support PCHs +-#if defined(CATCH_CONFIG_ALL_PARTS) +-# define CATCH_CONFIG_EXTERNAL_INTERFACES +-# if defined(CATCH_CONFIG_DISABLE_MATCHERS) +-# undef CATCH_CONFIG_DISABLE_MATCHERS +-# endif +-# if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER) +-# define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER +-# endif +-#endif +- +-#if !defined(CATCH_CONFIG_IMPL_ONLY) +-// start catch_platform.h +- +-#ifdef __APPLE__ +-# include +-# if TARGET_OS_OSX == 1 +-# define CATCH_PLATFORM_MAC +-# elif TARGET_OS_IPHONE == 1 +-# define CATCH_PLATFORM_IPHONE +-# endif +- +-#elif defined(linux) || defined(__linux) || defined(__linux__) +-# define CATCH_PLATFORM_LINUX +- +-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__) +-# define CATCH_PLATFORM_WINDOWS +-#endif +- +-// end catch_platform.h +- +-#ifdef CATCH_IMPL +-# ifndef CLARA_CONFIG_MAIN +-# define CLARA_CONFIG_MAIN_NOT_DEFINED +-# define CLARA_CONFIG_MAIN +-# endif +-#endif +- +-// start catch_user_interfaces.h +- +-namespace Catch { +- unsigned int rngSeed(); +-} +- +-// end catch_user_interfaces.h +-// start catch_tag_alias_autoregistrar.h +- +-// start catch_common.h +- +-// start catch_compiler_capabilities.h +- +-// Detect a number of compiler features - by compiler +-// The following features are defined: +-// +-// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported? +-// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported? +-// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported? +-// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled? +-// **************** +-// Note to maintainers: if new toggles are added please document them +-// in configuration.md, too +-// **************** +- +-// In general each macro has a _NO_ form +-// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) 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. +- +-#ifdef __cplusplus +- +-# if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L) +-# define CATCH_CPP14_OR_GREATER +-# endif +- +-# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) +-# define CATCH_CPP17_OR_GREATER +-# endif +- +-#endif +- +-#if defined(CATCH_CPP17_OR_GREATER) +-# define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS +-#endif +- +-#ifdef __clang__ +- +-# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ +- _Pragma( "clang diagnostic push" ) \ +- _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \ +- _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"") +-# define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \ +- _Pragma( "clang diagnostic pop" ) +- +-# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ +- _Pragma( "clang diagnostic push" ) \ +- _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) +-# define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \ +- _Pragma( "clang diagnostic pop" ) +- +-# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \ +- _Pragma( "clang diagnostic push" ) \ +- _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" ) +-# define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS \ +- _Pragma( "clang diagnostic pop" ) +- +-# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \ +- _Pragma( "clang diagnostic push" ) \ +- _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" ) +-# define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS \ +- _Pragma( "clang diagnostic pop" ) +- +-#endif // __clang__ +- +-//////////////////////////////////////////////////////////////////////////////// +-// Assume that non-Windows platforms support posix signals by default +-#if !defined(CATCH_PLATFORM_WINDOWS) +- #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS +-#endif +- +-//////////////////////////////////////////////////////////////////////////////// +-// We know some environments not to support full POSIX signals +-#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__) +- #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS +-#endif +- +-#ifdef __OS400__ +-# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS +-# define CATCH_CONFIG_COLOUR_NONE +-#endif +- +-//////////////////////////////////////////////////////////////////////////////// +-// Android somehow still does not support std::to_string +-#if defined(__ANDROID__) +-# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING +-#endif +- +-//////////////////////////////////////////////////////////////////////////////// +-// Not all Windows environments support SEH properly +-#if defined(__MINGW32__) +-# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH +-#endif +- +-//////////////////////////////////////////////////////////////////////////////// +-// PS4 +-#if defined(__ORBIS__) +-# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE +-#endif +- +-//////////////////////////////////////////////////////////////////////////////// +-// Cygwin +-#ifdef __CYGWIN__ +- +-// Required for some versions of Cygwin to declare gettimeofday +-// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin +-# define _BSD_SOURCE +-// some versions of cygwin (most) do not support std::to_string. Use the libstd check. +-// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813 +-# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \ +- && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF)) +- +-# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING +- +-# endif +-#endif // __CYGWIN__ +- +-//////////////////////////////////////////////////////////////////////////////// +-// Visual C++ +-#ifdef _MSC_VER +- +-# if _MSC_VER >= 1900 // Visual Studio 2015 or newer +-# define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS +-# endif +- +-// Universal Windows platform does not support SEH +-// Or console colours (or console at all...) +-# if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP) +-# define CATCH_CONFIG_COLOUR_NONE +-# else +-# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH +-# endif +- +-// MSVC traditional preprocessor needs some workaround for __VA_ARGS__ +-// _MSVC_TRADITIONAL == 0 means new conformant preprocessor +-// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor +-# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL) +-# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +-# endif +-#endif // _MSC_VER +- +-#if defined(_REENTRANT) || defined(_MSC_VER) +-// Enable async processing, as -pthread is specified or no additional linking is required +-# define CATCH_INTERNAL_CONFIG_USE_ASYNC +-#endif // _MSC_VER +- +-//////////////////////////////////////////////////////////////////////////////// +-// Check if we are compiled with -fno-exceptions or equivalent +-#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND) +-# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED +-#endif +- +-//////////////////////////////////////////////////////////////////////////////// +-// DJGPP +-#ifdef __DJGPP__ +-# define CATCH_INTERNAL_CONFIG_NO_WCHAR +-#endif // __DJGPP__ +- +-//////////////////////////////////////////////////////////////////////////////// +-// Embarcadero C++Build +-#if defined(__BORLANDC__) +- #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN +-#endif +- +-//////////////////////////////////////////////////////////////////////////////// +- +-// Use of __COUNTER__ is suppressed during code analysis in +-// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly +-// handled by it. +-// Otherwise all supported compilers support COUNTER macro, +-// but user still might want to turn it off +-#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L ) +- #define CATCH_INTERNAL_CONFIG_COUNTER +-#endif +- +-//////////////////////////////////////////////////////////////////////////////// +-// Check if string_view is available and usable +-// The check is split apart to work around v140 (VS2015) preprocessor issue... +-#if defined(__has_include) +-#if __has_include() && defined(CATCH_CPP17_OR_GREATER) +-# define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW +-#endif +-#endif +- +-//////////////////////////////////////////////////////////////////////////////// +-// Check if optional is available and usable +-#if defined(__has_include) +-# if __has_include() && defined(CATCH_CPP17_OR_GREATER) +-# define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL +-# endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) +-#endif // __has_include +- +-//////////////////////////////////////////////////////////////////////////////// +-// Check if variant is available and usable +-#if defined(__has_include) +-# if __has_include() && defined(CATCH_CPP17_OR_GREATER) +-# if defined(__clang__) && (__clang_major__ < 8) +- // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852 +- // fix should be in clang 8, workaround in libstdc++ 8.2 +-# include +-# if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) +-# define CATCH_CONFIG_NO_CPP17_VARIANT +-# else +-# define CATCH_INTERNAL_CONFIG_CPP17_VARIANT +-# endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9) +-# else +-# define CATCH_INTERNAL_CONFIG_CPP17_VARIANT +-# endif // defined(__clang__) && (__clang_major__ < 8) +-# endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) +-#endif // __has_include +- +-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) +-# define CATCH_CONFIG_COUNTER +-#endif +-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH) +-# define CATCH_CONFIG_WINDOWS_SEH +-#endif +-// This is set by default, because we assume that unix compilers are posix-signal-compatible by default. +-#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS) +-# define CATCH_CONFIG_POSIX_SIGNALS +-#endif +-// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions. +-#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR) +-# define CATCH_CONFIG_WCHAR +-#endif +- +-#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING) +-# define CATCH_CONFIG_CPP11_TO_STRING +-#endif +- +-#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL) +-# define CATCH_CONFIG_CPP17_OPTIONAL +-#endif +- +-#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) +-# define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS +-#endif +- +-#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW) +-# define CATCH_CONFIG_CPP17_STRING_VIEW +-#endif +- +-#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT) +-# define CATCH_CONFIG_CPP17_VARIANT +-#endif +- +-#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT) +-# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE +-#endif +- +-#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE) +-# define CATCH_CONFIG_NEW_CAPTURE +-#endif +- +-#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) +-# define CATCH_CONFIG_DISABLE_EXCEPTIONS +-#endif +- +-#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN) +-# define CATCH_CONFIG_POLYFILL_ISNAN +-#endif +- +-#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC) +-# define CATCH_CONFIG_USE_ASYNC +-#endif +- +-#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) +-# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS +-# define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS +-#endif +-#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS) +-# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS +-# define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS +-#endif +-#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS) +-# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS +-# define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS +-#endif +-#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS) +-# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS +-# define CATCH_INTERNAL_UNSUPPRESS_ZERO_VARIADIC_WARNINGS +-#endif +- +-#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) +-#define CATCH_TRY if ((true)) +-#define CATCH_CATCH_ALL if ((false)) +-#define CATCH_CATCH_ANON(type) if ((false)) +-#else +-#define CATCH_TRY try +-#define CATCH_CATCH_ALL catch (...) +-#define CATCH_CATCH_ANON(type) catch (type) +-#endif +- +-#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) +-#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +-#endif +- +-// end catch_compiler_capabilities.h +-#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 ) +-#ifdef CATCH_CONFIG_COUNTER +-# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ ) +-#else +-# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) +-#endif +- +-#include +-#include +-#include +- +-// We need a dummy global operator<< so we can bring it into Catch namespace later +-struct Catch_global_namespace_dummy {}; +-std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy); +- +-namespace Catch { +- +- struct CaseSensitive { enum Choice { +- Yes, +- No +- }; }; +- +- class NonCopyable { +- NonCopyable( NonCopyable const& ) = delete; +- NonCopyable( NonCopyable && ) = delete; +- NonCopyable& operator = ( NonCopyable const& ) = delete; +- NonCopyable& operator = ( NonCopyable && ) = delete; +- +- protected: +- NonCopyable(); +- virtual ~NonCopyable(); +- }; +- +- struct SourceLineInfo { +- +- SourceLineInfo() = delete; +- SourceLineInfo( char const* _file, std::size_t _line ) noexcept +- : file( _file ), +- line( _line ) +- {} +- +- SourceLineInfo( SourceLineInfo const& other ) = default; +- SourceLineInfo& operator = ( SourceLineInfo const& ) = default; +- SourceLineInfo( SourceLineInfo&& ) noexcept = default; +- SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default; +- +- bool empty() const noexcept; +- bool operator == ( SourceLineInfo const& other ) const noexcept; +- bool operator < ( SourceLineInfo const& other ) const noexcept; +- +- char const* file; +- std::size_t line; +- }; +- +- std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); +- +- // Bring in operator<< from global namespace into Catch namespace +- // This is necessary because the overload of operator<< above makes +- // lookup stop at namespace Catch +- using ::operator<<; +- +- // Use this in variadic streaming macros to allow +- // >> +StreamEndStop +- // as well as +- // >> stuff +StreamEndStop +- struct StreamEndStop { +- std::string operator+() const; +- }; +- template +- T const& operator + ( T const& value, StreamEndStop ) { +- return value; +- } +-} +- +-#define CATCH_INTERNAL_LINEINFO \ +- ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) +- +-// end catch_common.h +-namespace Catch { +- +- struct RegistrarForTagAliases { +- RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); +- }; +- +-} // end namespace Catch +- +-#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \ +- CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ +- namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \ +- CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS +- +-// end catch_tag_alias_autoregistrar.h +-// start catch_test_registry.h +- +-// start catch_interfaces_testcase.h +- +-#include +- +-namespace Catch { +- +- class TestSpec; +- +- struct ITestInvoker { +- virtual void invoke () const = 0; +- virtual ~ITestInvoker(); +- }; +- +- class TestCase; +- struct IConfig; +- +- struct ITestCaseRegistry { +- virtual ~ITestCaseRegistry(); +- virtual std::vector const& getAllTests() const = 0; +- virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0; +- }; +- +- bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ); +- std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ); +- std::vector const& getAllTestCasesSorted( IConfig const& config ); +- +-} +- +-// end catch_interfaces_testcase.h +-// start catch_stringref.h +- +-#include +-#include +-#include +- +-namespace Catch { +- +- /// A non-owning string class (similar to the forthcoming std::string_view) +- /// Note that, because a StringRef may be a substring of another string, +- /// it may not be null terminated. c_str() must return a null terminated +- /// string, however, and so the StringRef will internally take ownership +- /// (taking a copy), if necessary. In theory this ownership is not externally +- /// visible - but it does mean (substring) StringRefs should not be shared between +- /// threads. +- class StringRef { +- public: +- using size_type = std::size_t; +- +- private: +- friend struct StringRefTestAccess; +- +- char const* m_start; +- size_type m_size; +- +- char* m_data = nullptr; +- +- void takeOwnership(); +- +- static constexpr char const* const s_empty = ""; +- +- public: // construction/ assignment +- StringRef() noexcept +- : StringRef( s_empty, 0 ) +- {} +- +- StringRef( StringRef const& other ) noexcept +- : m_start( other.m_start ), +- m_size( other.m_size ) +- {} +- +- StringRef( StringRef&& other ) noexcept +- : m_start( other.m_start ), +- m_size( other.m_size ), +- m_data( other.m_data ) +- { +- other.m_data = nullptr; +- } +- +- StringRef( char const* rawChars ) noexcept; +- +- StringRef( char const* rawChars, size_type size ) noexcept +- : m_start( rawChars ), +- m_size( size ) +- {} +- +- StringRef( std::string const& stdString ) noexcept +- : m_start( stdString.c_str() ), +- m_size( stdString.size() ) +- {} +- +- ~StringRef() noexcept { +- delete[] m_data; +- } +- +- auto operator = ( StringRef const &other ) noexcept -> StringRef& { +- delete[] m_data; +- m_data = nullptr; +- m_start = other.m_start; +- m_size = other.m_size; +- return *this; +- } +- +- operator std::string() const; +- +- void swap( StringRef& other ) noexcept; +- +- public: // operators +- auto operator == ( StringRef const& other ) const noexcept -> bool; +- auto operator != ( StringRef const& other ) const noexcept -> bool; +- +- auto operator[] ( size_type index ) const noexcept -> char; +- +- public: // named queries +- auto empty() const noexcept -> bool { +- return m_size == 0; +- } +- auto size() const noexcept -> size_type { +- return m_size; +- } +- +- auto numberOfCharacters() const noexcept -> size_type; +- auto c_str() const -> char const*; +- +- public: // substrings and searches +- auto substr( size_type start, size_type size ) const noexcept -> StringRef; +- +- // Returns the current start pointer. +- // Note that the pointer can change when if the StringRef is a substring +- auto currentData() const noexcept -> char const*; +- +- private: // ownership queries - may not be consistent between calls +- auto isOwned() const noexcept -> bool; +- auto isSubstring() const noexcept -> bool; +- }; +- +- auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string; +- auto operator + ( StringRef const& lhs, char const* rhs ) -> std::string; +- auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string; +- +- auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&; +- auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&; +- +- inline auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef { +- return StringRef( rawChars, size ); +- } +- +-} // namespace Catch +- +-inline auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef { +- return Catch::StringRef( rawChars, size ); +-} +- +-// end catch_stringref.h +-// start catch_type_traits.hpp +- +- +-#include +- +-namespace Catch{ +- +-#ifdef CATCH_CPP17_OR_GREATER +- template +- inline constexpr auto is_unique = std::true_type{}; +- +- template +- inline constexpr auto is_unique = std::bool_constant< +- (!std::is_same_v && ...) && is_unique +- >{}; +-#else +- +-template +-struct is_unique : std::true_type{}; +- +-template +-struct is_unique : std::integral_constant +-::value +- && is_unique::value +- && is_unique::value +->{}; +- +-#endif +-} +- +-// end catch_type_traits.hpp +-// start catch_preprocessor.hpp +- +- +-#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__ +-#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__))) +-#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__))) +-#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__))) +-#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__))) +-#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__))) +- +-#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +-#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__ +-// MSVC needs more evaluations +-#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__))) +-#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__)) +-#else +-#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__) +-#endif +- +-#define CATCH_REC_END(...) +-#define CATCH_REC_OUT +- +-#define CATCH_EMPTY() +-#define CATCH_DEFER(id) id CATCH_EMPTY() +- +-#define CATCH_REC_GET_END2() 0, CATCH_REC_END +-#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2 +-#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1 +-#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT +-#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0) +-#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next) +- +-#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) +-#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ ) +-#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) +- +-#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) +-#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ ) +-#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ ) +- +-// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results, +-// and passes userdata as the first parameter to each invocation, +-// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c) +-#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) +- +-#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0)) +- +-#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param) +-#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__ +-#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__ +-#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF +-#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__) +-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +-#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__ +-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) +-#else +-// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF +-#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__) +-#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__ +-#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1) +-#endif +- +-#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__ +-#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name) +- +-#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__) +- +-#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR +-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper()) +-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)) +-#else +-#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper())) +-#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))) +-#endif +- +-#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\ +- CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__) +- +-#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0) +-#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1) +-#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2) +-#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3) +-#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4) +-#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5) +-#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _4, _5, _6) +-#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7) +-#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8) +-#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9) +-#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10) +- +-#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N +- +-#define INTERNAL_CATCH_TYPE_GEN\ +- template struct TypeList {};\ +- template\ +- constexpr auto get_wrapper() noexcept -> TypeList { return {}; }\ +- \ +- template class L1, typename...E1, template class L2, typename...E2> \ +- constexpr auto append(L1, L2) noexcept -> L1 { return {}; }\ +- template< template class L1, typename...E1, template class L2, typename...E2, typename...Rest>\ +- constexpr auto append(L1, L2, Rest...) noexcept -> decltype(append(L1{}, Rest{}...)) { return {}; }\ +- template< template class L1, typename...E1, typename...Rest>\ +- constexpr auto append(L1, TypeList, Rest...) noexcept -> L1 { return {}; }\ +- \ +- template< template class Container, template class List, typename...elems>\ +- constexpr auto rewrap(List) noexcept -> TypeList> { return {}; }\ +- template< template class Container, template class List, class...Elems, typename...Elements>\ +- constexpr auto rewrap(List,Elements...) noexcept -> decltype(append(TypeList>{}, rewrap(Elements{}...))) { return {}; }\ +- \ +- template