From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mp11.migadu.com ([2001:41d0:2:4a6f::]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)) by ms9.migadu.com with LMTPS id mL+xBdNbYmTD6QAASxT56A (envelope-from ) for ; Mon, 15 May 2023 18:20:35 +0200 Received: from aspmx1.migadu.com ([2001:41d0:2:4a6f::]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)) by mp11.migadu.com with LMTPS id YLemBdNbYmRcPAAA9RJhRA (envelope-from ) for ; Mon, 15 May 2023 18:20:35 +0200 Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by aspmx1.migadu.com (Postfix) with ESMTPS id BDEDB1250F for ; Mon, 15 May 2023 18:20:33 +0200 (CEST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1pyava-0005t4-WC; Mon, 15 May 2023 12:20:04 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1pyXeW-0002ft-9H for help-guix@gnu.org; Mon, 15 May 2023 08:50:19 -0400 Received: from cyberdimension.org ([2001:910:1314:ffff::1] helo=gnutoo.cyberdimension.org) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_CHACHA20_POLY1305:256) (Exim 4.90_1) (envelope-from ) id 1pyXeI-0006Ev-Pk for help-guix@gnu.org; Mon, 15 May 2023 08:50:08 -0400 Received: from gnutoo.cyberdimension.org (localhost [127.0.0.1]) by cyberdimension.org (OpenSMTPD) with ESMTP id e8804310; Mon, 15 May 2023 12:49:49 +0000 (UTC) Received: from primary_laptop (localhost [::1]) by gnutoo.cyberdimension.org (OpenSMTPD) with ESMTP id 7a545fa5; Mon, 15 May 2023 12:49:49 +0000 (UTC) Date: Mon, 15 May 2023 14:49:37 +0200 From: Denis 'GNUtoo' Carikli To: Vagrant Cascadian Cc: hub.lombard@free.fr, help-guix@gnu.org Subject: Re: 1 dependencies couldn't be built. cpp-mustache-4.1 Message-ID: <20230515144856.26b5d1e4@primary_laptop> In-Reply-To: <87o7mnlz8m.fsf@wireframe> References: <688696369.707372467.1684054546191.JavaMail.root@zimbra49-e8.priv.proxad.net> <87o7mnlz8m.fsf@wireframe> X-Mailer: Claws Mail 4.1.1 (GTK 3.24.37; x86_64-pc-linux-gnu) MIME-Version: 1.0 Content-Type: multipart/signed; boundary="Sig_/JmSiSlSwgaBPXi2R2F6_Ege"; protocol="application/pgp-signature"; micalg=pgp-sha256 Received-SPF: pass client-ip=2001:910:1314:ffff::1; envelope-from=GNUtoo@cyberdimension.org; helo=gnutoo.cyberdimension.org X-Spam_score_int: -18 X-Spam_score: -1.9 X-Spam_bar: - X-Spam_report: (-1.9 / 5.0 requ) BAYES_00=-1.9, SPF_HELO_PASS=-0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-Mailman-Approved-At: Mon, 15 May 2023 12:19:50 -0400 X-BeenThere: help-guix@gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: help-guix-bounces+larch=yhetil.org@gnu.org Sender: help-guix-bounces+larch=yhetil.org@gnu.org X-Migadu-Flow: FLOW_IN X-Migadu-Country: US ARC-Seal: i=1; s=key1; d=yhetil.org; t=1684167634; a=rsa-sha256; cv=none; b=gDaLZ0WiklnLT0udxZRX0iN8RDVJrojEzUEuYuynFZ/Vi4tkG0ssXKun2BqaPJIJBS4hcH mYQ7odMkJw7jEzdBCKI79TLNhvJgXwC1egW0sBBmg2daeOMLmTnI0o4lZ9idOTa1XWNcOy GYI1fpn15nWdgZBNFgbvXmKOgp75JERW/WBDpHpGi9WezEegO2yPC+Qkol/mg4R3KIBeeN JYnCwiqpAyoNjF/fWyWkRJIVIg/RQdzZIbS3b3g3wqdwGZxb3Cqu29yzbLELViDfrplIMl oN5/L+rBprEJ8/pvacIY+FjXJ3b2/bkvKrNPXHXrWQS9/wS8YKrihmlp6E2kjA== ARC-Authentication-Results: i=1; aspmx1.migadu.com; dkim=none; dmarc=none; spf=pass (aspmx1.migadu.com: domain of "help-guix-bounces+larch=yhetil.org@gnu.org" designates 209.51.188.17 as permitted sender) smtp.mailfrom="help-guix-bounces+larch=yhetil.org@gnu.org" ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=yhetil.org; s=key1; t=1684167634; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type:in-reply-to:in-reply-to: references:references:list-id:list-help:list-unsubscribe: list-subscribe:list-post; bh=1g6TdV0nHeh29qZ/z21U250M09uhPGSirpDUEtj1uoQ=; b=DTPF4AS1D5l6As5ljqwXzkpcXvitE4DTJCk7NS53845OtBQw27o+83pYWo3CR5XitTRE85 D9Fr2J+ocVxDh0aNSu2ZCwhthN0WMXir9sYqhg6VR1h8hzPVfXEldm61ux7MLKKZT/jhzo AmY1i5EJGlZrQ+P1Zz+t5llySWKnI8jsuIHKjytsBp8O4Yst2QQUWNJD4s7dfhROkSLt8x GQojqxuDaupPGa2VnOE086VroBhXM+4n914Y7uIbmueijycQySO4Ytrl5E5CwVMAhZLSi6 Njk9Bpz5WEcTf65GRAXLeHSqS1OBjYADVHHD2sT676IsdyGEnzSp8WIOfEe2Ig== X-Migadu-Scanner: scn1.migadu.com Authentication-Results: aspmx1.migadu.com; dkim=none; dmarc=none; spf=pass (aspmx1.migadu.com: domain of "help-guix-bounces+larch=yhetil.org@gnu.org" designates 209.51.188.17 as permitted sender) smtp.mailfrom="help-guix-bounces+larch=yhetil.org@gnu.org" X-Migadu-Spam-Score: -3.09 X-Spam-Score: -3.09 X-Migadu-Queue-Id: BDEDB1250F X-TUID: mOWanP/BI1iZ --Sig_/JmSiSlSwgaBPXi2R2F6_Ege Content-Type: multipart/mixed; boundary="MP_/3iK2SzGmyMn.cZRe=/pBDv9" --MP_/3iK2SzGmyMn.cZRe=/pBDv9 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Content-Disposition: inline Hi, On Sun, 14 May 2023 08:16:41 -0700 Vagrant Cascadian wrote: > On 2023-05-14, hub.lombard@free.fr wrote: > > I encounter an update's problem, 'guix package -u' does not finish > > correctly... > > > > Here's the history and an error log contain about 'cpp-mustache-4.1' > ... > > In file included from > > /gnu/store/gsjczqir1wbz8p770zndrpw4rnppmxi3-glibc-2.35/include/signal.h= :328, > > from /tmp/guix-build-cpp-mustache-4.1.drv-0/source/catch.hpp:6520, > > from /tmp/guix-build-cpp-mustache-4.1.drv-0/source/tests.cpp:32: > > /tmp/guix-build-cpp-mustache-4.1.drv-0/source/catch.hpp:6543:33: > > error: size of array =E2=80=98altStackMem=E2=80=99 is not an integral > > constant-expression 6543 | static char > > altStackMem[SIGSTKSZ]; | ^~~~~~~~ > > /tmp/guix-build-cpp-mustache-4.1.drv-0/source/catch.hpp:6594:45: > > error: size of array =E2=80=98altStackMem=E2=80=99 is not an integral > > constant-expression 6594 | char > > FatalConditionHandler::altStackMem[SIGSTKSZ] =3D {}; | > > [CMakeFiles/mustache.dir/build.make:79: > > CMakeFiles/mustache.dir/tests.cpp.o] Error 1 I had a similar failure. > A similar patch might work for cpp-mustache? There are several approaches here and I've patches for two of them if needed (I've attached them): (1) backport some upstream patches: - There are 2 catch2 updates, they can be squashed into 1 patch - We also need a patch for fixing unused variables. (2) Update cpp-mustache: There is an upstream commit (https://github.com/kainjow/Mustache/commit/4ed8c0b5a2a43d59394bd6900dc= 04e738dbf8c02) that change some version string. I've asked upstream if that was the 5.0.0 release but so far I got no answer. https://github.com/kainjow/Mustache/issues/65 (1) is 0001-gnu-cpp-mustache-fix-build-with-newer-glibc.patch (2) is 0001-bug-reported-upstream-for-release-info-gnu-cpp-musta.patch I didn't share the patches yet because I was waiting on upstream to clarify the situation with the lack of 5.0.0 tag. Denis. --MP_/3iK2SzGmyMn.cZRe=/pBDv9 Content-Type: text/x-patch Content-Transfer-Encoding: quoted-printable Content-Disposition: attachment; filename=0001-bug-reported-upstream-for-release-info-gnu-cpp-musta.patch =46rom 81945c18446c0bdb0c9125baf06c6bda8d1b90df Mon Sep 17 00:00:00 2001 From: Denis 'GNUtoo' Carikli Date: Mon, 8 May 2023 15:50:50 +0200 Subject: [PATCH] [bug reported upstream for release info] gnu: cpp-mustache: Update to 5.0 to fix build. * gnu/packages/cpp.scm (cpp-mustache): Update to 5.0. Signed-off-by: Denis 'GNUtoo' Carikli --- gnu/packages/cpp.scm | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/gnu/packages/cpp.scm b/gnu/packages/cpp.scm index 1a892d7b78..439e800d52 100644 --- a/gnu/packages/cpp.scm +++ b/gnu/packages/cpp.scm @@ -34,6 +34,7 @@ ;;; Copyright =C2=A9 2022 Maxim Cournoyer ;;; Copyright =C2=A9 2023 Sughosha ;;; Copyright =C2=A9 2023 Artyom V. Poptsov +;;; Copyright =C2=A9 2023 Denis 'GNUtoo' Carikli ;;; ;;; This file is part of GNU Guix. ;;; @@ -2015,29 +2016,35 @@ (define-public gulrak-filesystem (define-public cpp-mustache (package (name "cpp-mustache") - (version "4.1") + (version "5.0") (source (origin (method git-fetch) (uri (git-reference (url "https://github.com/kainjow/Mustache") - (commit (string-append "v" version)))) + (commit "4ed8c0b5a2a43d59394bd6900dc04e738dbf8c02"))) (file-name (git-file-name name version)) (sha256 (base32 - "0r9rbk6v1wpld2ismfsk2lkhbyv3dkf0p03hkjivbj05qkfhvlbb")))) + "0qwrg35gby851viwd6dgrc346712701a0gll8a0m4xs8invxavrh")))) (build-system cmake-build-system) (arguments - (list #:phases + (list #:configure-flags + #~(list + (string-append "-DCMAKE_CXX_FLAGS=3D-I" + #$(this-package-native-input "catch2") + "/include/catch2/")) + #:phases #~(modify-phases %standard-phases (replace 'check (lambda* (#:key tests? #:allow-other-keys) (when tests? - (invoke "./mustache")))) + (invoke "./tests/mustache-unit-tests")))) (replace 'install (lambda* (#:key outputs #:allow-other-keys) (install-file "../source/mustache.hpp" (string-append (assoc-ref outputs "out") "/include"))))))) + (native-inputs (list catch2)) (home-page "https://github.com/kainjow/Mustache") (synopsis "Mustache text templates for modern C++") (description "@code{cpp-mustache} is a Mustache implementation for C++= 11 --=20 2.40.1 --MP_/3iK2SzGmyMn.cZRe=/pBDv9 Content-Type: text/x-patch Content-Transfer-Encoding: quoted-printable Content-Disposition: attachment; filename=0001-gnu-cpp-mustache-fix-build-with-newer-glibc.patch =46rom a89fe1060bbaf68edba17520c36052d51f31d56b Mon Sep 17 00:00:00 2001 From: Denis 'GNUtoo' Carikli Date: Mon, 8 May 2023 15:04:48 +0200 Subject: [PATCH] gnu: cpp-mustache: fix build with newer glibc * gnu/packages/cpp.scm (cpp-mustache)[source]: Add patch. * gnu/packages/patches/cpp-mustache-update-catch2-library.patch: New file. * gnu/packages/patches/cpp-mustache-remove-unused-variables.patch: New file. * gnu/local.mk (dist_patch_DATA): Add patches. Signed-off-by: Denis 'GNUtoo' Carikli --- gnu/local.mk | 2 + gnu/packages/cpp.scm | 6 +- ...cpp-mustache-remove-unused-variables.patch | 37 + .../cpp-mustache-update-catch2-library.patch | 26903 ++++++++++++++++ 4 files changed, 26947 insertions(+), 1 deletion(-) create mode 100644 gnu/packages/patches/cpp-mustache-remove-unused-variabl= es.patch create mode 100644 gnu/packages/patches/cpp-mustache-update-catch2-library= .patch diff --git a/gnu/local.mk b/gnu/local.mk index dde0af9537..b8f6975dec 100644 --- a/gnu/local.mk +++ b/gnu/local.mk @@ -1018,6 +1018,8 @@ dist_patch_DATA =3D \ %D%/packages/patches/cool-retro-term-wctype.patch \ %D%/packages/patches/coreutils-gnulib-tests.patch \ %D%/packages/patches/coq-fix-envvars.patch \ + %D%/packages/patches/cpp-mustache-update-catch2-library.patch \ + %D%/packages/patches/cpp-mustache-remove-unused-variables.patch \ %D%/packages/patches/cppcheck-disable-char-signedness-test.patch \ %D%/packages/patches/cpuinfo-system-libraries.patch \ %D%/packages/patches/cpulimit-with-glib-2.32.patch \ diff --git a/gnu/packages/cpp.scm b/gnu/packages/cpp.scm index 023d1c0337..ab881c9748 100644 --- a/gnu/packages/cpp.scm +++ b/gnu/packages/cpp.scm @@ -2024,7 +2024,11 @@ (define-public cpp-mustache (file-name (git-file-name name version)) (sha256 (base32 - "0r9rbk6v1wpld2ismfsk2lkhbyv3dkf0p03hkjivbj05qkfhvlbb")))) + "0r9rbk6v1wpld2ismfsk2lkhbyv3dkf0p03hkjivbj05qkfhvlbb"))) + (patches + (search-patches + "cpp-mustache-update-catch2-library.patch" + "cpp-mustache-remove-unused-variables.patch"))) (build-system cmake-build-system) (arguments (list #:phases diff --git a/gnu/packages/patches/cpp-mustache-remove-unused-variables.patc= h b/gnu/packages/patches/cpp-mustache-remove-unused-variables.patch new file mode 100644 index 0000000000..1015f1f44c --- /dev/null +++ b/gnu/packages/patches/cpp-mustache-remove-unused-variables.patch @@ -0,0 +1,37 @@ +From: Kevin Wojniak +Subject: Remove unused variables. +Without that fix tests.cpp fail to build in Guix with the following errors: +error: unused variable =E2=80=98stream=E2=80=99 [-Werror=3Dunused-variable] +error: unused variable =E2=80=98root_children=E2=80=99 [-Werror=3Dunused-v= ariable] +Forwarded: not-needed +Origin: upstream, +https://github.com/kainjow/Mustache/commit/a790aae190f6744c3abe6a4c8325005= 377c2b72c +Applied-Upstream: https://github.com/kainjow/Mustache/commit/a790aae190f67= 44c3abe6a4c8325005377c2b72c +--- + tests.cpp | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +diff --git a/tests.cpp b/tests.cpp +index 84b4abe..e013d45 100644 +--- a/tests.cpp ++++ b/tests.cpp +@@ -1158,7 +1158,7 @@ TEST_CASE("custom_context") { + SECTION("basic") { + my_context ctx; + mustache tmpl("Hello {{what}}"); +- std::ostream& stream =3D tmpl.render(ctx, std::cout) << std::endl; ++ tmpl.render(ctx, std::cout) << std::endl; + CHECK(tmpl.is_valid()); + CHECK(tmpl.error_message() =3D=3D ""); + CHECK(tmpl.render(ctx) =3D=3D "Hello Steve"); +@@ -1218,7 +1218,6 @@ TEST_CASE("standalone_lines") { + context_internal context{ctx}; + parser{input, context, root_component, err= or_message}; + CHECK(error_message.empty()); +- const auto& root_children =3D root_component.children; + const std::vector text_components{"\n", "\= r\n", "\t", " ", "\n", "\n", "\r"}; + REQUIRE(root_component.children.size() =3D=3D 7); + REQUIRE(root_component.children.size() =3D=3D text_components.siz= e()); +--=20 +2.39.1 + diff --git a/gnu/packages/patches/cpp-mustache-update-catch2-library.patch = b/gnu/packages/patches/cpp-mustache-update-catch2-library.patch new file mode 100644 index 0000000000..3394522b84 --- /dev/null +++ b/gnu/packages/patches/cpp-mustache-update-catch2-library.patch @@ -0,0 +1,26903 @@ +From: Adrian Stratulat and Kevin Wojniak +Subject: Backport upstream patch to fix compilation with newer glibc. +I (Denis Carikli) made this patch was made by combining the +c54b11840371fe7deea2af9668a29c2d67129b3f and +a35c69ed5dba7bce7e91de7a0028da1e5258b759 patch to update the catch2 librar= y. +Forwarded: not-needed +Origin: upstream, +https://github.com/kainjow/Mustache/commit/c54b11840371fe7deea2af9668a29c2= d67129b3f, +https://github.com/kainjow/Mustache/commit/a35c69ed5dba7bce7e91de7a0028da1= e5258b759 +Bug: https://github.com/kainjow/Mustache/pull/58 +Applied-Upstream: https://github.com/kainjow/Mustache/commit/c54b11840371f= e7deea2af9668a29c2d67129b3f +--- + catch.hpp | 24312 +++++++++++++++++++++++++++++++++------------------- + tests.cpp | 2 +- + 2 files changed, 15292 insertions(+), 9022 deletions(-) + +diff --git a/catch.hpp b/catch.hpp +index fdb046f..7e706f9 100644 +--- a/catch.hpp ++++ b/catch.hpp +@@ -1,17 +1,21 @@ + /* +- * Catch v1.12.2 +- * Generated: 2018-05-14 15:10:01.112442 ++ * Catch v2.13.7 ++ * Generated: 2021-07-28 20:29:27.753164 + * ---------------------------------------------------------- + * This file has been merged from multiple headers. Please don't edit it= directly +- * Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. ++ * Copyright (c) 2021 Two Blue Cubes Ltd. All rights reserved. + * + * Distributed under the Boost Software License, Version 1.0. (See accom= panying + * 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 +=20 +-#define TWOBLUECUBES_CATCH_HPP_INCLUDED ++ ++#define CATCH_VERSION_MAJOR 2 ++#define CATCH_VERSION_MINOR 13 ++#define CATCH_VERSION_PATCH 7 +=20 + #ifdef __clang__ + # pragma clang system_header +@@ -19,36 +23,69 @@ + # pragma GCC system_header + #endif +=20 +-// #included from: internal/catch_suppress_warnings.h ++// start catch_suppress_warnings.h +=20 + #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 ignored "-Wparentheses" ++ // 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 +=20 + # 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 ++ ++// See e.g.: ++// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/T= argetConditionals.h.auto.html ++#ifdef __APPLE__ ++# include ++# if (defined(TARGET_OS_OSX) && TARGET_OS_OSX =3D=3D 1) || \ ++ (defined(TARGET_OS_MAC) && TARGET_OS_MAC =3D=3D 1) ++# define CATCH_PLATFORM_MAC ++# elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE =3D=3D 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 +=20 ++// end catch_platform.h ++ + #ifdef CATCH_IMPL + # ifndef CLARA_CONFIG_MAIN + # define CLARA_CONFIG_MAIN_NOT_DEFINED +@@ -56,93 +93,106 @@ + # endif + #endif +=20 +-// #included from: internal/catch_notimplemented_exception.h +-#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED ++// start catch_user_interfaces.h +=20 +-// #included from: catch_common.h +-#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED ++namespace Catch { ++ unsigned int rngSeed(); ++} ++ ++// end catch_user_interfaces.h ++// start catch_tag_alias_autoregistrar.h +=20 +-// #included from: catch_compiler_capabilities.h +-#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED ++// start catch_common.h +=20 +-// Detect a number of compiler features - mostly C++11/14 conformance - b= y compiler ++// start catch_compiler_capabilities.h ++ ++// Detect a number of compiler features - 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_SHUFFLE : is std::shuffle supported? +-// CATCH_CONFIG_CPP11_TYPE_TRAITS : are type_traits and enable_if support= ed? +- +-// CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported? +- +-// CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported? + // 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 + // **************** +=20 + // In general each macro has a _NO_ form +-// (e.g. CATCH_CONFIG_CPP11_NO_NULLPTR) which disables the feature. ++// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature. + // Many features, at point of detection, define an _INTERNAL_ macro, so t= hey + // can be combined, en-mass, with the _NO_ forms later. +=20 +-// All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11 +- + #ifdef __cplusplus +=20 +-# if __cplusplus >=3D 201103L +-# define CATCH_CPP11_OR_GREATER ++# if (__cplusplus >=3D 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= =3D 201402L) ++# define CATCH_CPP14_OR_GREATER + # endif +=20 +-# if __cplusplus >=3D 201402L +-# define CATCH_CPP14_OR_GREATER ++# if (__cplusplus >=3D 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= =3D 201703L) ++# define CATCH_CPP17_OR_GREATER + # endif +=20 + #endif +=20 +-#ifdef __clang__ ++// Only GCC compiler should be used in this block, so other compilers try= ing to ++// mask themselves as GCC should be ignored. ++#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defin= ed(__CUDACC__) && !defined(__LCC__) ++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagn= ostic push" ) ++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagn= ostic pop" ) +=20 +-# if __has_feature(cxx_nullptr) +-# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +-# endif ++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_= p(__VA_ARGS__) ++ ++#endif +=20 +-# if __has_feature(cxx_noexcept) +-# define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT ++#if defined(__clang__) ++ ++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang dia= gnostic push" ) ++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang dia= gnostic pop" ) ++ ++// As of this writing, IBM XL's implementation of __builtin_constant_p ha= s a bug ++// which results in calls to destructors being emitted for each temporary, ++// without a matching initialization. In practice, this can result in som= ething ++// like `std::string::~string` being called on an uninitialized value. ++// ++// For example, this code will likely segfault under IBM XL: ++// ``` ++// REQUIRE(std::string("12") + "34" =3D=3D "1234") ++// ``` ++// ++// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented. ++# if !defined(__ibmxl__) && !defined(__CUDACC__) ++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_= p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */ + # endif +=20 +-# if defined(CATCH_CPP11_OR_GREATER) +-# define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \ +- _Pragma( "clang diagnostic push" ) \ +- _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\= "" ) +-# define CATCH_INTERNAL_UNSUPPRESS_ETD_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" ) +-# endif ++# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ ++ _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" = ) \ ++ _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"") ++ ++# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ ++ _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) ++ ++# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \ ++ _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" ) ++ ++# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \ ++ _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-a= rguments\"" ) ++ ++# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \ ++ _Pragma( "clang diagnostic ignored \"-Wunused-template\"" ) +=20 + #endif // __clang__ +=20 + /////////////////////////////////////////////////////////////////////////= /////// +-// We know some environments not to support full POSIX signals +-#if defined(__CYGWIN__) || defined(__QNX__) +- +-# if !defined(CATCH_CONFIG_POSIX_SIGNALS) +-# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS +-# endif ++// Assume that non-Windows platforms support posix signals by default ++#if !defined(CATCH_PLATFORM_WINDOWS) ++ #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS ++#endif +=20 ++/////////////////////////////////////////////////////////////////////////= /////// ++// 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 +=20 + #ifdef __OS400__ +@@ -151,225 +201,268 @@ + #endif +=20 + /////////////////////////////////////////////////////////////////////////= /////// +-// Cygwin +-#ifdef __CYGWIN__ +- +-// Required for some versions of Cygwin to declare gettimeofday +-// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-decl= ared-in-this-scope-cygwin +-# define _BSD_SOURCE +- +-#endif // __CYGWIN__ +- +-/////////////////////////////////////////////////////////////////////////= /////// +-// Borland +-#ifdef __BORLANDC__ +- +-#endif // __BORLANDC__ ++// Android somehow still does not support std::to_string ++#if defined(__ANDROID__) ++# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING ++# define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE ++#endif +=20 + /////////////////////////////////////////////////////////////////////////= /////// +-// EDG +-#ifdef __EDG_VERSION__ +- +-#endif // __EDG_VERSION__ ++// Not all Windows environments support SEH properly ++#if defined(__MINGW32__) ++# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH ++#endif +=20 + /////////////////////////////////////////////////////////////////////////= /////// +-// Digital Mars +-#ifdef __DMC__ +- +-#endif // __DMC__ ++// PS4 ++#if defined(__ORBIS__) ++# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE ++#endif +=20 + /////////////////////////////////////////////////////////////////////////= /////// +-// GCC +-#ifdef __GNUC__ ++// Cygwin ++#ifdef __CYGWIN__ +=20 +-# if __GNUC__ =3D=3D 4 && __GNUC_MINOR__ >=3D 6 && defined(__GXX_EXPERI= MENTAL_CXX0X__) +-# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +-# endif ++// Required for some versions of Cygwin to declare gettimeofday ++// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-decl= ared-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.h= tml line 2812-2813 ++# if !((__cplusplus >=3D 201103L) && defined(_GLIBCXX_USE_C99) \ ++ && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF)) +=20 +-// - otherwise more recent versions define __cplusplus >=3D 201103L +-// and will get picked up below ++# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING +=20 +-#endif // __GNUC__ ++# endif ++#endif // __CYGWIN__ +=20 + /////////////////////////////////////////////////////////////////////////= /////// + // Visual C++ +-#ifdef _MSC_VER ++#if defined(_MSC_VER) +=20 +-#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH ++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(pus= h) ) ++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop= ) ) +=20 +-#if (_MSC_VER >=3D 1600) +-# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +-# define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR +-#endif ++// Universal Windows platform does not support SEH ++// Or console colours (or console at all...) ++# if defined(WINAPI_FAMILY) && (WINAPI_FAMILY =3D=3D WINAPI_FAMILY_APP) ++# define CATCH_CONFIG_COLOUR_NONE ++# else ++# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH ++# endif +=20 +-#if (_MSC_VER >=3D 1900 ) // (VC++ 13 (VS2015)) +-#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT +-#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +-#define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE +-#define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS +-#endif ++// MSVC traditional preprocessor needs some workaround for __VA_ARGS__ ++// _MSVC_TRADITIONAL =3D=3D 0 means new conformant preprocessor ++// _MSVC_TRADITIONAL =3D=3D 1 means old traditional non-conformant prepro= cessor ++# if !defined(__clang__) // Handle Clang masquerading for msvc ++# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MS= VC_TRADITIONAL) ++# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR ++# endif // MSVC_TRADITIONAL ++# endif // __clang__ +=20 + #endif // _MSC_VER +=20 +-/////////////////////////////////////////////////////////////////////////= /////// ++#if defined(_REENTRANT) || defined(_MSC_VER) ++// Enable async processing, as -pthread is specified or no additional lin= king is required ++# define CATCH_INTERNAL_CONFIG_USE_ASYNC ++#endif // _MSC_VER +=20 +-// 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__ >=3D 3 ) || \ +- ( !defined __cplusplus && __STDC_VERSION__ >=3D 199901L || __cplusplu= s >=3D 201103L ) ++/////////////////////////////////////////////////////////////////////////= /////// ++// Check if we are compiled with -fno-exceptions or equivalent ++#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNW= IND) ++# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED ++#endif +=20 +-#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS ++/////////////////////////////////////////////////////////////////////////= /////// ++// DJGPP ++#ifdef __DJGPP__ ++# define CATCH_INTERNAL_CONFIG_NO_WCHAR ++#endif // __DJGPP__ +=20 ++/////////////////////////////////////////////////////////////////////////= /////// ++// Embarcadero C++Build ++#if defined(__BORLANDC__) ++ #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN + #endif +=20 +-// Use __COUNTER__ if the compiler supports it +-#if ( defined _MSC_VER && _MSC_VER >=3D 1300 ) || \ +- ( defined __GNUC__ && ( __GNUC__ > 4 || (__GNUC__ =3D=3D 4 && __GNUC= _MINOR__ >=3D 3 )) ) || \ +- ( defined __clang__ && __clang_major__ >=3D 3 ) ++/////////////////////////////////////////////////////////////////////////= /////// +=20 +-// Use of __COUNTER__ is suppressed during code analysis in CLion/AppCode= 2017.2.x and former, +-// because __COUNTER__ is not properly handled by it. +-// This does not affect compilation +-#if ( !defined __JETBRAINS_IDE__ || __JETBRAINS_IDE__ >=3D 20170300L ) ++// 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__ >=3D 20170300L ) + #define CATCH_INTERNAL_CONFIG_COUNTER + #endif +=20 +-#endif +- + /////////////////////////////////////////////////////////////////////////= /////// +-// C++ language feature support +- +-// catch all support for C++11 +-#if defined(CATCH_CPP11_OR_GREATER) +=20 +-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) +-# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR +-# endif ++// RTX is a special version of Windows that is real time. ++// This means that it is detected as Windows, but does not provide ++// the same set of capabilities as real Windows does. ++#if defined(UNDER_RTSS) || defined(RTX64_BUILD) ++ #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH ++ #define CATCH_INTERNAL_CONFIG_NO_ASYNC ++ #define CATCH_CONFIG_COLOUR_NONE ++#endif +=20 +-# ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT +-# define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT +-# endif ++#if !defined(_GLIBCXX_USE_C99_MATH_TR1) ++#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER ++#endif +=20 +-# ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +-# define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +-# endif ++// Various stdlib support checks that require __has_include ++#if defined(__has_include) ++ // Check if string_view is available and usable ++ #if __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW ++ #endif ++ ++ // Check if optional is available and usable ++ # if __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL ++ # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ ++ // Check if byte is available and usable ++ # if __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ # include ++ # if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0) ++ # define CATCH_INTERNAL_CONFIG_CPP17_BYTE ++ # endif ++ # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ ++ // Check if variant is available and usable ++ # if __has_include() && defined(CATCH_CPP17_OR_GREATER) ++ # if defined(__clang__) && (__clang_major__ < 8) ++ // work around clang bug with libstdc++ https://bugs.llvm.org/sh= ow_bug.cgi?id=3D31852 ++ // fix should be in clang 8, workaround in libstdc++ 8.2 ++ # include ++ # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCX= X_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 // defined(__has_include) +=20 +-# ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM +-# define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM +-# endif ++#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_CO= UNTER) && !defined(CATCH_CONFIG_COUNTER) ++# define CATCH_CONFIG_COUNTER ++#endif ++#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_N= O_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTE= RNAL_CONFIG_NO_WINDOWS_SEH) ++# define CATCH_CONFIG_WINDOWS_SEH ++#endif ++// This is set by default, because we assume that unix compilers are posi= x-signal-compatible by default. ++#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERN= AL_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 +=20 +-# ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE +-# define CATCH_INTERNAL_CONFIG_CPP11_TUPLE +-# 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 +=20 +-# ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS +-# define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS +-# endif ++#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFI= G_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL) ++# define CATCH_CONFIG_CPP17_OPTIONAL ++#endif +=20 +-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) +-# define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG +-# endif ++#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CO= NFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW) ++# define CATCH_CONFIG_CPP17_STRING_VIEW ++#endif +=20 +-# 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 +-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) +-# define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE +-# endif +-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) +-# define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS +-# 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 +=20 +-#endif // __cplusplus >=3D 201103L ++#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO= _CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE) ++# define CATCH_CONFIG_CPP17_BYTE ++#endif +=20 +-// 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(CATC= H_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_NULLPTR ++#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT) ++# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFI= G_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(C= ATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_NOEXCEPT ++ ++#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL= _CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !define= d(CATCH_CONFIG_NEW_CAPTURE) ++# define CATCH_CONFIG_NEW_CAPTURE + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CA= TCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENER= ATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_GENERATED_METHODS ++ ++#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_= CONFIG_DISABLE_EXCEPTIONS) ++# define CATCH_CONFIG_DISABLE_EXCEPTIONS + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG= _CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATC= H_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_IS_ENUM ++ ++#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFI= G_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN) ++# define CATCH_CONFIG_POLYFILL_ISNAN + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_C= PP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONF= IG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_TUPLE ++ ++#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_= CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_C= ONFIG_USE_ASYNC) ++# define CATCH_CONFIG_USE_ASYNC + #endif +-#if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONF= IG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS) +-# define CATCH_CONFIG_VARIADIC_MACROS ++ ++#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CON= FIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE) ++# define CATCH_CONFIG_ANDROID_LOGWRITE + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONF= IG_CPP11_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !define= d(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_LONG_LONG ++ ++#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CON= FIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER) ++# define CATCH_CONFIG_GLOBAL_NEXTAFTER + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFI= G_CPP11_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(C= ATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_OVERRIDE ++ ++// Even if we do not think the compiler has that warning, we still have ++// to provide a macro that can be used by the code. ++#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION) ++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CON= FIG_CPP11_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !def= ined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_UNIQUE_PTR ++#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION) ++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION + #endif +-#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_CO= UNTER) && !defined(CATCH_CONFIG_COUNTER) +-# define CATCH_CONFIG_COUNTER ++#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) ++# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS + #endif +-#if defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG= _CPP11_NO_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_SHUFFLE) && !defined(CATC= H_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_SHUFFLE ++#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS) ++# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS + #endif +-# if defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_C= ONFIG_CPP11_NO_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) && = !defined(CATCH_CONFIG_NO_CPP11) +-# define CATCH_CONFIG_CPP11_TYPE_TRAITS +-# endif +-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_N= O_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) +-# define CATCH_CONFIG_WINDOWS_SEH ++#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS) ++# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS + #endif +-// This is set by default, because we assume that unix compilers are posi= x-signal-compatible by default. +-#if !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CO= NFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS) +-# define CATCH_CONFIG_POSIX_SIGNALS ++#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS) ++# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS + #endif +=20 +-#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_ETD_WARNINGS) +-# define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS +-# define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS ++// The goal of this macro is to avoid evaluation of the arguments, but ++// still have the compiler warn on problems inside... ++#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN) ++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) + #endif +=20 +-// 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) ++#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_ma= jor__ < 10) ++# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS ++#elif defined(__clang__) && (__clang_major__ < 5) ++# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS + #endif +=20 +-// nullptr support +-#ifdef CATCH_CONFIG_CPP11_NULLPTR +-# define CATCH_NULL nullptr +-#else +-# define CATCH_NULL NULL ++#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS) ++# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS + #endif +=20 +-// override support +-#ifdef CATCH_CONFIG_CPP11_OVERRIDE +-# define CATCH_OVERRIDE override ++#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_OVERRIDE ++#define CATCH_TRY try ++#define CATCH_CATCH_ALL catch (...) ++#define CATCH_CATCH_ANON(type) catch (type) + #endif +=20 +-// unique_ptr support +-#ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR +-# define CATCH_AUTO_PTR( T ) std::unique_ptr +-#else +-# define CATCH_AUTO_PTR( T ) std::auto_ptr ++#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defi= ned(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG= _TRADITIONAL_MSVC_PREPROCESSOR) ++#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR + #endif +=20 ++// 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_UNIQ= UE_NAME_LINE2( name, line ) + #ifdef CATCH_CONFIG_COUNTER +@@ -378,95 +471,48 @@ + # define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_L= INE( name, __LINE__ ) + #endif +=20 +-#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr +-#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr ) ++#include ++#include ++#include +=20 +-#include +-#include ++// We need a dummy global operator<< so we can bring it into Catch namesp= ace later ++struct Catch_global_namespace_dummy {}; ++std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy); +=20 + namespace Catch { +=20 +- struct IConfig; +- + struct CaseSensitive { enum Choice { + Yes, + No + }; }; +=20 + class NonCopyable { +-#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + NonCopyable( NonCopyable const& ) =3D delete; + NonCopyable( NonCopyable && ) =3D delete; + NonCopyable& operator =3D ( NonCopyable const& ) =3D delete; + NonCopyable& operator =3D ( NonCopyable && ) =3D delete; +-#else +- NonCopyable( NonCopyable const& info ); +- NonCopyable& operator =3D ( NonCopyable const& ); +-#endif +=20 + protected: +- NonCopyable() {} ++ NonCopyable(); + virtual ~NonCopyable(); + }; +=20 +- class SafeBool { +- public: +- typedef void (SafeBool::*type)() const; +- +- static type makeSafe( bool value ) { +- return value ? &SafeBool::trueValue : 0; +- } +- private: +- void trueValue() const {} +- }; +- +- template +- void deleteAll( ContainerT& container ) { +- typename ContainerT::const_iterator it =3D container.begin(); +- typename ContainerT::const_iterator itEnd =3D container.end(); +- for(; it !=3D itEnd; ++it ) +- delete *it; +- } +- template +- void deleteAllValues( AssociativeContainerT& container ) { +- typename AssociativeContainerT::const_iterator it =3D container.b= egin(); +- typename AssociativeContainerT::const_iterator itEnd =3D containe= r.end(); +- for(; it !=3D itEnd; ++it ) +- delete it->second; +- } +- +- bool startsWith( std::string const& s, std::string const& prefix ); +- bool startsWith( std::string const& s, char prefix ); +- bool endsWith( std::string const& s, std::string const& suffix ); +- bool endsWith( std::string const& s, char 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 co= nst& pluraliser ); ++ struct SourceLineInfo { +=20 +- std::size_t m_count; +- std::string m_label; +- }; ++ SourceLineInfo() =3D delete; ++ SourceLineInfo( char const* _file, std::size_t _line ) noexcept ++ : file( _file ), ++ line( _line ) ++ {} +=20 +- struct SourceLineInfo { ++ SourceLineInfo( SourceLineInfo const& other ) =3D defa= ult; ++ SourceLineInfo& operator =3D ( SourceLineInfo const& ) =3D de= fault; ++ SourceLineInfo( SourceLineInfo&& ) noexcept =3D defa= ult; ++ SourceLineInfo& operator =3D ( SourceLineInfo&& ) noexcept =3D de= fault; +=20 +- SourceLineInfo(); +- SourceLineInfo( char const* _file, std::size_t _line ); +-# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS +- SourceLineInfo(SourceLineInfo const& other) =3D default; +- SourceLineInfo( SourceLineInfo && ) =3D default; +- SourceLineInfo& operator =3D ( SourceLineInfo const& ) =3D defaul= t; +- SourceLineInfo& operator =3D ( SourceLineInfo && ) =3D defaul= t; +-# endif +- bool empty() const; +- bool operator =3D=3D ( SourceLineInfo const& other ) const; +- bool operator < ( SourceLineInfo const& other ) const; ++ bool empty() const noexcept { return file[0] =3D=3D '\0'; } ++ bool operator =3D=3D ( SourceLineInfo const& other ) const noexce= pt; ++ bool operator < ( SourceLineInfo const& other ) const noexcept; +=20 + char const* file; + std::size_t line; +@@ -474,24 +520,17 @@ namespace Catch { +=20 + std::ostream& operator << ( std::ostream& os, SourceLineInfo const& i= nfo ); +=20 +- // 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 cons= t& locationInfo ); +- +- void seedRng( IConfig const& config ); +- unsigned int rngSeed(); ++ // 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<<; +=20 + // Use this in variadic streaming macros to allow + // >> +StreamEndStop + // as well as + // >> stuff +StreamEndStop + struct StreamEndStop { +- std::string operator+() { +- return std::string(); +- } ++ std::string operator+() const; + }; + template + T const& operator + ( T const& value, StreamEndStop ) { +@@ -499,363 +538,812 @@ namespace Catch { + } + } +=20 +-#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static= _cast( __LINE__ ) ) +-#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_= INTERNAL_LINEINFO ); ++#define CATCH_INTERNAL_LINEINFO \ ++ ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__= ) ) +=20 ++// end catch_common.h + namespace Catch { +=20 +- class NotImplementedException : public std::exception +- { +- public: +- NotImplementedException( SourceLineInfo const& lineInfo ); +- +- virtual ~NotImplementedException() CATCH_NOEXCEPT {} +- +- virtual const char* what() const CATCH_NOEXCEPT; +- +- private: +- std::string m_what; +- SourceLineInfo m_lineInfo; ++ struct RegistrarForTagAliases { ++ RegistrarForTagAliases( char const* alias, char const* tag, Sourc= eLineInfo const& lineInfo ); + }; +=20 + } // end namespace Catch +=20 +-/////////////////////////////////////////////////////////////////////////= ////// +-#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH= _INTERNAL_LINEINFO ) ++#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \ ++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \ ++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \ ++ namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( = AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \ ++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION +=20 +-// #included from: internal/catch_context.h +-#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED ++// end catch_tag_alias_autoregistrar.h ++// start catch_test_registry.h +=20 +-// #included from: catch_interfaces_generators.h +-#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED ++// start catch_interfaces_testcase.h +=20 +-#include ++#include +=20 + namespace Catch { +=20 +- struct IGeneratorInfo { +- virtual ~IGeneratorInfo(); +- virtual bool moveNext() =3D 0; +- virtual std::size_t getCurrentIndex() const =3D 0; ++ class TestSpec; ++ ++ struct ITestInvoker { ++ virtual void invoke () const =3D 0; ++ virtual ~ITestInvoker(); + }; +=20 +- struct IGeneratorsForTest { +- virtual ~IGeneratorsForTest(); ++ class TestCase; ++ struct IConfig; +=20 +- virtual IGeneratorInfo& getGeneratorInfo( std::string const& file= Info, std::size_t size ) =3D 0; +- virtual bool moveNext() =3D 0; ++ struct ITestCaseRegistry { ++ virtual ~ITestCaseRegistry(); ++ virtual std::vector const& getAllTests() const =3D 0; ++ virtual std::vector const& getAllTestsSorted( IConfig c= onst& config ) const =3D 0; + }; +=20 +- IGeneratorsForTest* createGeneratorsForTest(); ++ bool isThrowSafe( TestCase const& testCase, IConfig const& config ); ++ bool matchTest( TestCase const& testCase, TestSpec const& testSpec, I= Config const& config ); ++ std::vector filterTests( std::vector const& testC= ases, TestSpec const& testSpec, IConfig const& config ); ++ std::vector const& getAllTestCasesSorted( IConfig const& co= nfig ); +=20 +-} // end namespace Catch ++} +=20 +-// #included from: catch_ptr.hpp +-#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED ++// end catch_interfaces_testcase.h ++// start catch_stringref.h +=20 +-#ifdef __clang__ +-#pragma clang diagnostic push +-#pragma clang diagnostic ignored "-Wpadded" +-#endif ++#include ++#include ++#include ++#include +=20 + namespace Catch { +=20 +- // An intrusive reference counting smart pointer. +- // T must implement addRef() and release() methods +- // typically implementing the IShared interface +- template +- class Ptr { ++ /// A non-owning string class (similar to the forthcoming std::string= _view) ++ /// Note that, because a StringRef may be a substring of another stri= ng, ++ /// it may not be null terminated. ++ class StringRef { + 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 =3D CATCH_NULL; +- } +- Ptr& operator =3D ( T* p ){ +- Ptr temp( p ); +- swap( temp ); +- return *this; +- } +- Ptr& operator =3D ( 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 =3D=3D CATCH_NULL; } +- operator SafeBool::type() const { return SafeBool::makeSafe( m_p = !=3D CATCH_NULL ); } ++ using size_type =3D std::size_t; ++ using const_iterator =3D const char*; +=20 + private: +- T* m_p; +- }; ++ static constexpr char const* const s_empty =3D ""; +=20 +- struct IShared : NonCopyable { +- virtual ~IShared(); +- virtual void addRef() const =3D 0; +- virtual void release() const =3D 0; +- }; ++ char const* m_start =3D s_empty; ++ size_type m_size =3D 0; +=20 +- template +- struct SharedImpl : T { ++ public: // construction ++ constexpr StringRef() noexcept =3D default; +=20 +- SharedImpl() : m_rc( 0 ){} ++ StringRef( char const* rawChars ) noexcept; ++ ++ constexpr StringRef( char const* rawChars, size_type size ) noexc= ept ++ : m_start( rawChars ), ++ m_size( size ) ++ {} ++ ++ StringRef( std::string const& stdString ) noexcept ++ : m_start( stdString.c_str() ), ++ m_size( stdString.size() ) ++ {} +=20 +- virtual void addRef() const { +- ++m_rc; ++ explicit operator std::string() const { ++ return std::string(m_start, m_size); + } +- virtual void release() const { +- if( --m_rc =3D=3D 0 ) +- delete this; ++ ++ public: // operators ++ auto operator =3D=3D ( StringRef const& other ) const noexcept ->= bool; ++ auto operator !=3D (StringRef const& other) const noexcept -> boo= l { ++ return !(*this =3D=3D other); + } +=20 +- mutable unsigned int m_rc; +- }; ++ auto operator[] ( size_type index ) const noexcept -> char { ++ assert(index < m_size); ++ return m_start[index]; ++ } +=20 +-} // end namespace Catch ++ public: // named queries ++ constexpr auto empty() const noexcept -> bool { ++ return m_size =3D=3D 0; ++ } ++ constexpr auto size() const noexcept -> size_type { ++ return m_size; ++ } +=20 +-#ifdef __clang__ +-#pragma clang diagnostic pop +-#endif ++ // Returns the current start pointer. If the StringRef is not ++ // null-terminated, throws std::domain_exception ++ auto c_str() const -> char const*; +=20 +-namespace Catch { ++ public: // substrings and searches ++ // Returns a substring of [start, start + length). ++ // If start + length > size(), then the substring is [start, size= ()). ++ // If start > size(), then the substring is empty. ++ auto substr( size_type start, size_type length ) const noexcept -= > StringRef; +=20 +- class TestCase; +- class Stream; +- struct IResultCapture; +- struct IRunner; +- struct IGeneratorsForTest; +- struct IConfig; ++ // Returns the current start pointer. May not be null-terminated. ++ auto data() const noexcept -> char const*; +=20 +- struct IContext +- { +- virtual ~IContext(); ++ constexpr auto isNullTerminated() const noexcept -> bool { ++ return m_start[m_size] =3D=3D '\0'; ++ } +=20 +- virtual IResultCapture* getResultCapture() =3D 0; +- virtual IRunner* getRunner() =3D 0; +- virtual size_t getGeneratorIndex( std::string const& fileInfo, si= ze_t totalSize ) =3D 0; +- virtual bool advanceGeneratorsForCurrentTest() =3D 0; +- virtual Ptr getConfig() const =3D 0; ++ public: // iterators ++ constexpr const_iterator begin() const { return m_start; } ++ constexpr const_iterator end() const { return m_start + m_size; } + }; +=20 +- struct IMutableContext : IContext +- { +- virtual ~IMutableContext(); +- virtual void setResultCapture( IResultCapture* resultCapture ) = =3D 0; +- virtual void setRunner( IRunner* runner ) =3D 0; +- virtual void setConfig( Ptr const& config ) =3D 0; +- }; ++ auto operator +=3D ( std::string& lhs, StringRef const& sr ) -> std::= string&; ++ auto operator << ( std::ostream& os, StringRef const& sr ) -> std::os= tream&; +=20 +- IContext& getCurrentContext(); +- IMutableContext& getCurrentMutableContext(); +- void cleanUpContext(); +- Stream createStream( std::string const& streamName ); ++ constexpr auto operator "" _sr( char const* rawChars, std::size_t siz= e ) noexcept -> StringRef { ++ return StringRef( rawChars, size ); ++ } ++} // namespace Catch +=20 ++constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t s= ize ) noexcept -> Catch::StringRef { ++ return Catch::StringRef( rawChars, size ); + } +=20 +-// #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 ++// end catch_stringref.h ++// start catch_preprocessor.hpp +=20 +-#include +=20 +-namespace Catch { ++#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__ ++#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSIO= N_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__))) ++#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSIO= N_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__))) ++#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSIO= N_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__))) ++#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSIO= N_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__))) ++#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSIO= N_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__))) +=20 +- class TestSpec; ++#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_RECURSIO= N_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 +=20 +- struct ITestCase : IShared { +- virtual void invoke () const =3D 0; +- protected: +- virtual ~ITestCase(); +- }; ++#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 ) ( tes= t, next, 0) ++#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END tes= t, next) ++ ++#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_N= EXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) ++#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_N= EXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ ) ++#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_N= EXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ ) ++ ++#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CA= TCH_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) CA= TCH_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) CA= TCH_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, in= serts 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_STR= INGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) ++#else ++// MSVC is adding extra space and needs another indirection to expand INT= ERNAL_CATCH_NOINTERNAL_CATCH_DEF ++#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARG= S__) ++#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__ ++#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_ST= RINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1) ++#endif +=20 +- class TestCase; +- struct IConfig; ++#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__ ++#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE= 2(name) +=20 +- struct ITestCaseRegistry { +- virtual ~ITestCaseRegistry(); +- virtual std::vector const& getAllTests() const =3D 0; +- virtual std::vector const& getAllTestsSorted( IConfig c= onst& config ) const =3D 0; ++#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(d= ecltype(get_wrapper())) ++#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(IN= TERNAL_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_PARE= NS(_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_REM= OVE_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_C= ATCH_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) INTERN= AL_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) IN= TERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, = _3, _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_PAR= ENS_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...> struct TemplateTypeList{};\ ++ template class...Cs>\ ++ constexpr auto get_wrapper() noexcept -> TemplateTypeList { re= turn {}; }\ ++ template\ ++ struct append;\ ++ template\ ++ struct rewrap;\ ++ template class, typename...>\ ++ struct create;\ ++ template class, typename>\ ++ struct convert;\ ++ \ ++ template \ ++ struct append { using type =3D T; };\ ++ template< template class L1, typename...E1, template class L2, typename...E2, typename...Rest>\ ++ struct append, L2, Rest...> { using type =3D typenam= e append, Rest...>::type; };\ ++ template< template class L1, typename...E1, typename...R= est>\ ++ struct append, TypeList, Rest...> { using type = =3D L1; };\ ++ \ ++ template< template class Container, template class List, typename...elems>\ ++ struct rewrap, List> { using ty= pe =3D TypeList>; };\ ++ template< template class Container, template class List, class...Elems, typename...Elements>\ ++ struct rewrap, List, Elements..= .> { using type =3D typename append>, typename= rewrap, Elements...>::type>::type; };\ ++ \ ++ template