diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index d8a6be34..dc622506 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -2,53 +2,122 @@ name: C/C++ CI on: push: - branches: [ master ] + branches: [master, refactoring, 'refactor-to-c\+\+23'] pull_request: - branches: [ master ] - + branches: [master, refactoring, 'refactor-to-c\+\+23'] defaults: run: shell: bash -el {0} - jobs: build: - - runs-on: ubuntu-latest + name: Build and test (${{ matrix.name }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - name: GCC 14 release + os: ubuntu-24.04 + compiler: gcc + configure_debug: --disable-debug + - name: GCC 14 debug + os: ubuntu-24.04 + compiler: gcc + configure_debug: --enable-debug + - name: Apple Clang release + os: macos-15 + compiler: apple-clang + configure_debug: --disable-debug steps: + - name: Check out sources + uses: actions/checkout@v4 + + - name: Set up conda environment + uses: conda-incubator/setup-miniconda@v4 + with: + miniconda-version: latest + environment-file: conda-build-env.yml + activate-environment: intarna-build-env + + - name: Install and select GCC 14 + if: matrix.compiler == 'gcc' + run: | + sudo apt-get update + sudo apt-get install --yes gcc-14 g++-14 + echo "CC=gcc-14" >> "$GITHUB_ENV" + echo "CXX=g++-14" >> "$GITHUB_ENV" + echo "LDFLAGS=-L${CONDA_PREFIX}/lib -Wl,-rpath,${CONDA_PREFIX}/lib" >> "$GITHUB_ENV" + + - name: Verify GCC 14 + if: matrix.compiler == 'gcc' + run: | + "$CC" --version + "$CXX" --version + test "$("$CC" -dumpfullversion | cut -d. -f1)" = 14 + test "$("$CXX" -dumpfullversion | cut -d. -f1)" = 14 + + - name: Set up Apple Clang with OpenMP + if: matrix.compiler == 'apple-clang' + run: | + brew install libomp + libomp_prefix="$(brew --prefix libomp)" + echo "CC=/usr/bin/clang" >> "$GITHUB_ENV" + echo "CXX=/usr/bin/clang++" >> "$GITHUB_ENV" + echo "CPPFLAGS=-I${libomp_prefix}/include" >> "$GITHUB_ENV" + echo "CXXFLAGS=-Xpreprocessor -fopenmp" >> "$GITHUB_ENV" + echo "LDFLAGS=-L${libomp_prefix}/lib -Wl,-rpath,${libomp_prefix}/lib -L${CONDA_PREFIX}/lib -Wl,-rpath,${CONDA_PREFIX}/lib" >> "$GITHUB_ENV" + echo "LIBS=-lomp" >> "$GITHUB_ENV" + vrna_libs="$(pkg-config --libs RNAlib2)" + vrna_libs="${vrna_libs//-Wl,-fno-lto/}" + echo "VRNA_LIBS=${vrna_libs}" >> "$GITHUB_ENV" + + - name: Verify Apple Clang + if: matrix.compiler == 'apple-clang' + run: | + "$CC" --version + "$CXX" --version + "$CXX" --version | grep -q "Apple clang" + + - name: Bootstrap and configure + run: | + bash autotools-init.sh + ./configure \ + --prefix="$RUNNER_TEMP/intarna-install" \ + --with-vrna="$CONDA_PREFIX" \ + --with-boost="$CONDA_PREFIX" \ + --with-boost-libdir="$CONDA_PREFIX/lib" \ + --with-zlib="$CONDA_PREFIX" \ + ${{ matrix.configure_debug }} + grep -Eq '^CXX = .* -std=c\+\+23([[:space:]]|$)' Makefile + grep -q '^#define INTARNA_MULITHREADING 1' src/config.h + + - name: Build, install, and run full test suite + run: | + make -j 2 + make install + make tests -j 2 + "$RUNNER_TEMP/intarna-install/bin/IntaRNA" -h + + - name: Compile every installed public header independently + run: | + header_probe="$RUNNER_TEMP/intarna-header-probe.cpp" + for header in "$RUNNER_TEMP/intarna-install/include/IntaRNA/"*.h; do + printf '#include \nint main() { return 0; }\n' "$(basename "$header")" > "$header_probe" + "$CXX" -std=c++23 ${CPPFLAGS:-} ${CXXFLAGS:-} \ + -I"$RUNNER_TEMP/intarna-install/include" \ + -I"$CONDA_PREFIX/include" \ + -fsyntax-only "$header_probe" + done - - name: Check out sources from github - uses: actions/checkout@v2 - - - name: Setup conda environment - uses: conda-incubator/setup-miniconda@v2 - with: - miniconda-version: "latest" - environment-file: conda-build-env.yml - activate-environment: conda-build-env - - - name: Build and test IntaRNA - run: | - ##### start IntaRNA build ##### - pwd - # generate autotools's files - bash autotools-init.sh - # run configure (without boost checks) - ENVPREFIX=`conda info --base`/envs/conda-build-env - export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ENVPREFIX/lib - ./configure \ - --prefix=$HOME/IntaRNA \ - --with-vrna=$ENVPREFIX \ - --with-boost=$ENVPREFIX \ - --with-boost-libdir=$ENVPREFIX/lib \ - --with-zlib=$ENVPREFIX - # compile documentation - # - make doxygen-doc - # compile, test and install IntaRNA - make -j 2 && make install - make tests -j 2 - ##### check IntaRNA build ##### - # run installed IntaRNA with help output - $HOME/IntaRNA/bin/IntaRNA -h + - name: Compile and link an installed pkg-config consumer + run: | + consumer="$RUNNER_TEMP/intarna-consumer.cpp" + printf '#include \nint main() { IntaRNA::RnaSequence rna("test", "ACGU"); return rna.size() == 4 ? 0 : 1; }\n' > "$consumer" + export PKG_CONFIG_PATH="$RUNNER_TEMP/intarna-install/lib/pkgconfig" + "$CXX" -std=c++23 ${CPPFLAGS:-} ${CXXFLAGS:-} "$consumer" \ + ${LDFLAGS:-} $(pkg-config --cflags --libs IntaRNA) \ + -o "$RUNNER_TEMP/intarna-consumer" + "$RUNNER_TEMP/intarna-consumer" diff --git a/IntaRNA.pc.in b/IntaRNA.pc.in index 0474424b..db398781 100644 --- a/IntaRNA.pc.in +++ b/IntaRNA.pc.in @@ -1,10 +1,10 @@ -prefix=@PREFIX_PATH@ -exec_prefix=${prefix}/bin -libdir=${prefix}/lib -includedir=${prefix}/include - -Name: IntaRNA -Description: RNA-RNA interaction prediction C++ library -Version: @VERSION@ -Libs: @LIBS@ -Cflags: +prefix=@prefix@ +exec_prefix=${prefix} +libdir=${prefix}/lib +includedir=${prefix}/include + +Name: IntaRNA +Description: RNA-RNA interaction prediction C++ library +Version: @VERSION@ +Libs: -L${libdir} -lIntaRNA @LIBS@ +Cflags: -I${includedir} @BOOST_CPPFLAGS@ @VRNA_CFLAGS@ diff --git a/README.md b/README.md index b07795d5..878190a3 100644 --- a/README.md +++ b/README.md @@ -180,7 +180,7 @@ you with an encapsulated IntaRNA installation. If you are going to compile IntaRNA from source, ensure you meet the following dependencies: -- compiler supporting C++11 standard and OpenMP +- compiler supporting C++23 and OpenMP (GCC 14 or Apple Clang) - [boost C++ library](http://www.boost.org/) version >= 1.50.0 (ensure the following libraries are installed for development (not just runtime libraries!); or install all e.g. in Ubuntu via package `libboost-all-dev`) - libboost_regex @@ -312,57 +312,34 @@ directory to your [`Path` System variable](http://www.computerhope.com/issues/ch

-## OS X installation with homebrew (thanks to Lars Barquist) +## macOS installation with Homebrew -If you do not want to or can use the pre-compiled binaries for OS X available from -[bioconda](https://anaconda.org/bioconda/intarna), you can compile `IntaRNA` -locally. +The [Bioconda package](https://anaconda.org/bioconda/intarna) is the simplest +installation route. To build locally with the system Apple Clang compiler, +install the dependencies and the OpenMP runtime: -The following wraps up how to build `IntaRNA-2.0.2` under OS X (Sierra 10.12.4) using homebrew. - -First, install homebrew! :) - -```[bash] -brew install gcc --without-multilib -``` - -`--without-multilib` is necessary for OpenMP multithreading support -- note -OS X default `gcc`/`clang` doesn't support OpenMP, so we need to install standard -`gcc`/`g++` - -```[bash] -brew install boost --cc=gcc-6 -``` - -`--cc=gcc-6` is necessary to build `boost` with standard `gcc`, rather than the -default bottle which appears to have been built with the system `clang`. -Brew installs `gcc`/`g++` as `/usr/local/bin/gcc-VERSION` by default to avoid -clashing with the system's `gcc`/`clang`. `6` is the current version as of -writing, but may change. - -```[bash] -brew install viennarna -brew install doxygen -``` - -Download and extract the IntaRNA source code package (e.g. `intaRNA-2.0.2.tar.gz`) from the [release page](https://github.com/BackofenLab/IntaRNA/releases/latest). - -```[bash] -./configure CC=gcc-6 CXX=g++-6 +```bash +brew install autoconf automake boost libtool libomp pkg-config viennarna ``` -This sets up makefiles to use standard `gcc`/`g++` from brew, which will -need an update to the appropriate compiler version if not still `6`. -You might also want to -set `--prefix=INSTALLPATH` if you dont want to install IntaRNA globally. - +Apple Clang needs the Homebrew `libomp` headers, library and preprocessing flag. +The following keeps the normal optimized, multithreaded build: -```[bash] -make -make tests +```bash +LIBOMP_PREFIX="$(brew --prefix libomp)" +CPPFLAGS="-I${LIBOMP_PREFIX}/include" \ +CXXFLAGS="-Xpreprocessor -fopenmp" \ +LDFLAGS="-L${LIBOMP_PREFIX}/lib -Wl,-rpath,${LIBOMP_PREFIX}/lib" \ +LIBS="-lomp" \ +./configure CC=clang CXX=clang++ +make -j2 +make tests -j2 make install ``` +Use `--prefix=INSTALLPATH` with `./configure` when a system-wide installation +is not desired. + [![up](doc/figures/icon-up.28.png) back to overview](#overview) @@ -2255,5 +2232,3 @@ flags are used within the IntaRNA configuration: [![up](doc/figures/icon-up.38.png)](https://www.freepik.com/free-vector/colored-arrows_794372.htm) Designed by Freepik - - diff --git a/conda-build-env.yml b/conda-build-env.yml index 5c949728..381a798b 100644 --- a/conda-build-env.yml +++ b/conda-build-env.yml @@ -1,4 +1,3 @@ - name: intarna-build-env channels: @@ -7,10 +6,10 @@ channels: - defaults dependencies: - - gcc_linux-64 - - gxx_linux-64 + - autoconf + - automake + - libtool - pkgconfig - zlib - - boost-cpp + - boost-cpp - viennarna>=2.4.14 - \ No newline at end of file diff --git a/configure.ac b/configure.ac index 01404a0c..43bb01fe 100644 --- a/configure.ac +++ b/configure.ac @@ -1,5 +1,5 @@ -AC_PREREQ([2.65]) +AC_PREREQ([2.69]) # 5 argument version only available with aclocal >= 2.64 AC_INIT([IntaRNA], [3.4.1], [], [intaRNA], [http://www.bioinf.uni-freiburg.de] ) @@ -54,8 +54,8 @@ AM_INIT_AUTOMAKE([1.11]) # use the C++ compiler for the following checks AC_LANG([C++]) -# ensure we are using c11 C++ standard -AX_CXX_COMPILE_STDCXX([11], [noext], [mandatory]) +# ensure we are using the C++23 standard +AX_CXX_COMPILE_STDCXX([23], [noext], [mandatory]) # check if python is available AM_PATH_PYTHON([$PYTHON_REQUIRED_VERSION],, [:]) @@ -197,7 +197,7 @@ AS_IF([test x"$enable_multiprecision" = x"yes"], [ # Vienna RNA package library path support, if not installed in usual directories ############################################################################### AC_ARG_WITH([vrna], - [AC_HELP_STRING( + [AS_HELP_STRING( [--with-vrna=PREFIX], [alternative prefix path to Vienna RNA library] )], @@ -306,10 +306,6 @@ AX_CHECK_ZLIB([], []) # Checks for typedefs, structures, and compiler characteristics. AC_TYPE_SIZE_T -# Checks for header files. -AC_HEADER_STDC - - ########################################################################## # check boost test results ########################################################################## diff --git a/doc/refactor/2-c++23.md b/doc/refactor/2-c++23.md new file mode 100644 index 00000000..a1069a37 --- /dev/null +++ b/doc/refactor/2-c++23.md @@ -0,0 +1,406 @@ +# Phase 2: C++23 migration and performance roadmap + +This document implements the scope of phase 2 in +[discussion #232](https://github.com/BackofenLab/IntaRNA/discussions/232). +C++23 is a compilation baseline here, not a reason to rewrite working +scientific code. The migration must retain the architecture and modularity +described in `1-current-state.md`, preserve every successful phase-1 test, and +run with both GCC 14 on Linux and the Apple Clang toolchain used for macOS +Bioconda builds. + +The performance-candidate section is a roadmap. The reproducible three-reference +baseline is complete below; each optimization is implemented later on its own +phase-3 branch and measured independently against its scientific parent. + +## Exact scope + +Phase 2 requires: + +1. Work on `refactor-to-c++23`, branched from `refactoring`, and maintain + this file as the change and decision record. +2. Adapt the build and source to strict C++23 using only facilities supported + by GCC 14/libstdc++ and the relevant Apple Clang/libc++ combination. +3. Keep the existing library families and extension points intact, and keep + the CLI/binary-program interface and output schema stable. This is not a + promise of C++ ABI compatibility across different compilers or standard + libraries. +4. Preserve all tests that pass on `refactoring`; a standard-independent bug + found during migration belongs on `refactoring` with a regression first, + then is merged forward. +5. Analyse performance opportunities, distinguish architecture-preserving + from architecture-breaking work, prioritize the preserving work, and define + its benchmark gates. +6. Commit the test-stable migration and open its pull request against + `refactoring`. + +This phase does not change recurrences, energy models, coordinate conventions, +CLI behavior, output schemas, or partition definitions. It also does not +import implementation code from alternate IntaRNA trees; they may be consulted +only as independent lookup material. + +## Baseline and final phase-2 evidence + +The migration originally branched from `refactoring` at `70920c6`, whose last +source fix was `a975c4d`. Standard-independent defects found subsequently were +fixed with regressions on `refactoring` and merged forward. Consequently, the +final phase-1 scientific reference is `ba5f9eb41229b5aa47339b6ee954858ee3d6b93b`, +and the final phase-2 executable source tree is +`8bd1676d1e38ec6461c60e1b832ff3ace9ff77bc`. A later documentation-only commit +does not change that benchmarked executable. + +| Gate | Result | +| --- | --- | +| Initial API suite at `70920c6` | 3,895 assertions in 31 test cases passed | +| Final GCC 14 API suite | 4,275 assertions in 36 test cases passed | +| Command-line golden suite | all 20 cases passed | +| Configured language floor | C++11, strict `noext` mode | +| Final language contract | mandatory strict C++23, `noext` mode | +| GCC 14 strict-C++23 build and tests | passed: GCC 14.2 release and debug on Ubuntu 24.04 | +| Apple Clang strict-C++23 build and tests | passed: Apple Clang 17.0/libomp release on macOS 15 ARM64 | +| Cross-toolchain output comparison | passed through the same API and 20-case CLI golden suites | +| Phase-2 performance benchmark | complete at benchmark commit `565fc8617184565d3a33e7c02df63f750f4d26ea` | + +The bundled `m4/m4-ax_cxx_compile_stdcxx.m4` at the branch point recognizes +only C++11, C++14 and C++17. The existing Linux CI is a single +`ubuntu-latest` Conda build and does not establish either required phase-2 +compiler. These are build-contract gaps, not source-performance findings. + +## Minimal C++23 migration contract + +### Build contract + +- Replace the C++11 configure requirement with a mandatory strict C++23 + feature check equivalent to + `AX_CXX_COMPILE_STDCXX([23], [noext], [mandatory])`. +- Update or replace the vendored Autoconf probe so it understands C++23 and + the compiler spellings it tests; prefer a maintained upstream probe over an + ad-hoc local feature list. Merely adding `-std=c++23` to a Makefile is + insufficient because configure must fail clearly on an unsupported compiler. +- Regenerate the repository's Autotools outputs and verify a fresh-clone + `autotools-init.sh -> configure -> make -> make tests -> make install` + path. +- Compile in `-std=c++23`, not `gnu++23`. Source that accidentally relies + on GNU language extensions must be corrected or isolated behind an existing + platform boundary. +- Treat GCC 14 with libstdc++ and Apple Clang with libc++ as separate targets. + Compiler acceptance alone is not enough; included Boost and ViennaRNA + headers must compile and link with the same C++ runtime. +- Keep OpenMP feature detection. The required default multithreaded build is + tested with GCC/libgomp and Apple Clang/libomp. A + `--disable-multithreading` build remains a useful supplemental check, not a + second phase-2 compatibility target. +- GNU quadmath remains an optional GCC-only configuration. It is not a + requirement for the Apple Clang gate; the common scientific baseline uses + `Z_type=double`. + +### Source adaptation rules + +1. Make the build accept C++23 first, with no algorithmic change in the same + patch. +2. Apply the smallest compatibility fixes for removed or newly diagnosed + constructs. Keep any required compatibility edits to bundled Catch or + easylogging code isolated from IntaRNA changes. +3. Add explicit standard headers where the old build relied on transitive + includes. Do not combine this with renaming or broad formatting. +4. Preserve public class signatures and ownership semantics. Local RAII is + welcome where it removes a proven lifetime hazard, but a factory-wide + ownership redesign is not part of the migration. +5. Use a C++23 library facility only when both required standard libraries + support it and it makes the code or measured hot path better. Modules, + header units, `std::print`, `std::mdspan`, parallel standard algorithms + and other unevenly implemented facilities are not migration dependencies. +6. Do not replace Boost components solely to advertise newer C++. Replacing a + dependency is separate work with its own compatibility and performance + evidence. +7. Do not enable `-ffast-math`, reassociation, native-only instruction flags, + or other options that relax floating-point or portability semantics. + +The result may still look much like the phase-1 code. That is intentional: +language migration and performance experiments must remain independently +reviewable and benchmarkable. + +## Scientific and numerical neutrality + +The following contracts are unchanged by C++23. + +| Area | Invariant | Required evidence | +| --- | --- | --- | +| Coordinates | sequence ranges are closed and zero-based internally; reversed-query coordinates remain bijective | existing range/offset tests plus exact interaction coordinates in CLI output | +| MFE arithmetic | `E_type` remains integer centi-kcal/mol; `E_INF/E_MAX` retain headroom and are never used as ordinary energies | exact API assertions and exact MFE/output energy fields | +| Ensemble arithmetic | independent Boltzmann factors multiply and alternative structures add exactly once | ensemble, noLP, filter and seed-extension regressions | +| Floating-point evaluation | recurrence traversal and addition/multiplication order remain unchanged during migration | same-toolchain before/after partition comparison using existing `Z_equal`; every textual difference reported | +| Accessibility | `ED=-RT log(Pu)`, threshold comparison is inclusive, and inaccessible positions never enter returned ranges | accessibility, `outMinPu`, range split and ViennaRNA tests | +| ViennaRNA model | temperature, parameter set, constraints and maximum base-pair span reach the same ViennaRNA calls | ViennaRNA accessibility/ES tests and golden outputs | +| Seeds and tracebacks | seed feasibility, noLP rules, lexicographic tie-breaking and reported base pairs are unchanged | seed-handler, seed-ordering and predictor traceback tests | +| Predictor lifecycle | repeated prediction cannot reuse stale MFE, partition or boundary state | phase-1 seed-extension reuse regression and any new per-family reuse tests | +| Filters and output | `noGUend`, `maxED`, overlap, top-k, tracker and CLI-column behavior remain consistent | API filter tests and all CLI golden cases | +| Parallel execution | thread count may change scheduling, not the accepted scientific result | single-thread versus multithread differential corpus | + +For one compiler and dependency set, deterministic integer, coordinate, +structure, ordering and formatted-output fields must be identical before and +after migration. Cross-platform math libraries can differ in final +floating-point bits; such differences must be parsed, quantified and reported, +not hidden by normalizing the whole output. The in-memory API gate retains the +project's current `Z_equal` contract. A changed interaction set, rank, MFE, +seed, boundary probability, infinity state or filter decision is a failure +even if a scalar partition difference is small. + +No recurrence should be reordered to make a compiler warning disappear. If a +C++23 diagnostic exposes undefined behavior in scientific code, first add a +focused regression and fix the behavior on `refactoring`. + +## Portability validation + +Every job must record the OS and architecture, compiler and standard-library +versions, Boost and ViennaRNA versions, configure arguments, OpenMP runtime, +commit hash, and whether multiprecision is enabled. + +| Environment | Configuration | Required checks | Status | +| --- | --- | --- | --- | +| Ubuntu 24.04, GCC 14.2/libstdc++ | optimized, default OpenMP, strict C++23 | fresh configure, build, complete API/CLI suites, install and consumer checks | passed | +| Ubuntu 24.04, GCC 14.2/libstdc++ | debug, default OpenMP, strict C++23 | build, complete API/CLI suites, install and consumer checks | passed | +| macOS 15 ARM64, Apple Clang 17.0/libc++ and libomp | optimized, default multithreading, strict C++23 | configure, build, complete API/CLI suites, install and consumer checks | passed | + +The Apple Clang version is the C++23-capable version in the Bioconda target +environment and must be recorded rather than inferred from the unversioned +`clang++` name. Both macOS architectures should be covered when Bioconda +publishes both; otherwise the current supported target is the mandatory gate. + +Warnings from IntaRNA sources should be reviewed under both compilers, but +`-Werror` over vendored headers is not a portability criterion. Sanitizer +runs are useful supplementary evidence; they do not replace either required +compiler job. + +## Performance classification + +An optimization is architecture-preserving when the current sequence, +accessibility, energy, seed/helix, predictor, tracker and output boundaries +remain recognizable and extensible; public behavior and recurrence mathematics +do not change. Private storage and loop-local implementation may change. + +An optimization is architecture-breaking when it changes recurrence +ownership, public library interfaces, aggregation semantics, execution +topology, or the way predictor and energy modules compose. Architecture +breaking does not authorize a CLI change: phase 4 still requires the binary +interface to remain stable. + +### Architecture-preserving candidates + +| Priority | Candidate | Expected effect | Main scientific gate | +| --- | --- | --- | --- | +| AP-1 | Hoist loop invariants and cache repeated energy, ED, complementarity, size and offset lookups inside existing DP loops | fewer virtual calls and duplicate table accesses in the dominant nested loops | identical traversal, arithmetic order, MFE/traceback and partition output | +| AP-2 | Reuse and reserve predictor workspaces within one predictor/window configuration; clear only the active matrix bands | fewer allocations, initializations and cache misses | exhaustive reuse tests, because phase 1 found stale seed-extension partition state | +| AP-3 | Replace private general-purpose matrices with contiguous banded/flat storage one predictor at a time | lower memory, better locality and simpler bounds in hot cells | cell-by-cell small-instance differential and unchanged traceback | +| AP-4 | Precompute immutable pair feasibility, reversed-index mappings and decomposed accessibility ranges once per applicable sequence/configuration | removes repeated work and parser-owned mutation; enables safe read sharing | asymmetric target/query, offset, constraint and multi-pair tests | +| AP-5 | Accumulate top-k candidates in thread/window-local buffers and merge deterministically | shorter OpenMP critical sections and better scaling on output-heavy runs | exact ordering/tie behavior and one-thread versus many-thread equality; do not merge overlapping `Zall` domains | +| AP-6 | Trial ViennaRNA window APIs or narrower ES work only where requested ranges permit it | may reduce ViennaRNA preprocessing time and memory | full ED/ES table differential across constraints, span and temperature; discard if ViennaRNA algorithms change results | +| AP-7 | Replace measured Boost/string-conversion or allocation hotspots with portable standard facilities | lower dependency or conversion overhead if profiling proves it material | byte-stable parsing/formatting and both standard libraries | + +AP-1 is intentionally first: it is local, cheap to test and targets the +repeated calls identified in phase 1. Static inspection suggests AP-2 and AP-3 +could address substantial predictor costs, but profiling must establish their +priority; both require stronger lifecycle and traceback gates. AP-4 and +AP-5 prepare safe parallel scaling without redefining the algorithms. AP-6 and +AP-7 are experiments, not assumed improvements. + +`std::ranges`, smart pointers, `constexpr`, `noexcept`, `std::span` or +other modern constructs are not performance work by themselves. They belong +in an optimization branch only when they enable a measured change or remove a +specific correctness/lifetime risk. + +### Architecture-breaking candidates + +| Candidate | Why it breaks the current architecture | Potential benefit | +| --- | --- | --- | +| Stream or factor exact-ensemble boundary ownership instead of retaining all four-boundary values | changes when the recurrence finalizes and exposes boundary partitions | removes the practical `O(n1^2*n2^2)` memory growth | +| Use a private sparse keyed container while retaining every boundary value | may remain preserving if ownership, values and iteration semantics are unchanged; otherwise it is staged here | reduces memory only when the valid boundary set is sparse | +| Introduce scaled or log-domain partition accumulation | changes the numeric representation and algebra used by ensemble recurrences | prevents release-build overflow and extends the usable sequence/energy range | +| Define disjoint ownership for multiple regions and overlapping windows | changes global partition/tracker aggregation semantics | permits scientifically valid global `Zall/Eall` with windowing | +| Introduce an immutable run configuration and task graph for target/query/window work | moves mutable factory state and parallel ownership across CLI/library boundaries | coarse task parallelism, less contention and safer caching | +| Specialize predictor/energy kernels rather than dispatching through virtual interfaces in inner loops | changes the principal modular composition mechanism | inlining, vectorization and removal of repeated virtual dispatch | +| Build a shared tiled/wavefront recurrence engine or accelerator backend | reorganizes DP storage, scheduling and traceback ownership | better locality and possible SIMD/GPU execution | + +These belong after the preserving roadmap and benchmark infrastructure. Any +selected design must still make it straightforward to add predictors, output +handlers, input types and energy/accessibility models. + +## Benchmark gate + +Before the first optimization, create and commit the separate private +repository `BackofenLab/IntaRNA-refactor-benchmark` required by discussion +#232. It must contain the runner, a versioned and extensible/prunable corpus +manifest, schemas, raw JSON artifacts and the generated Markdown comparison. +A GitHub Action must validate and regenerate the report whenever benchmark +JSON is added or changed. The first batch establishes comparable results for +the last commits on `master`, `refactoring` and `refactor-to-c++23`. + +Before AP-1, phase 2 adds small exhaustive/reference oracles for exact MFE, +exact partition enumeration and seeded prediction. They cover LP/noLP, +terminal GU, direct `maxED` partition filtering, bulged and overlapping seeds, +predictor reuse, reversed offsets and exact traceback coordinates. Together +with the phase-1 regressions and the benchmark's one-/many-thread cases, these +form the scientific gate for optimization work. + +The committed corpus is small enough for routine use and is stratified across: + +- short exact MFE and ensemble cases with independently checkable outputs; +- default heuristic seed-extension workloads; +- noLP, terminal-GU, `maxED`, seed-free and constrained cases; +- disabled, base-pair, stream and ViennaRNA accessibility; +- single pair, many target/query pairs, explicit regions and windowing; +- one and multiple threads; and +- output-light prediction, top-k output and tracker-heavy output. + +The initial routine corpus uses independently checkable tiny inputs, individual +biological sRNA/target pairs, a deterministic stratified 64-target throughput +subset and the complete 4,319-target scaling case. Timed cases use one warm-up +and three to seven fresh-process repetitions according to cost, fixed release +flags, explicit thread counts and GNU `time` wall/user/system/maximum-RSS +measurements. Candidate branches add the smallest counter or stage timer needed +to attribute their claimed improvement; the baseline harness does not require +instrumenting the scientific executable. + +For every case the JSON must contain the exact commit and environment metadata, +arguments, raw repetitions, summary statistics with dispersion, peak resident +memory, exit status, raw and canonical output hashes, and a semantic divergence +report. The corpus and build inputs are checksum-pinned. The aggregation action +produces the Markdown comparison requested in the discussion. + +An optimization branch passes only when: + +1. the full compiler/test portability gate remains green; +2. MFE, coordinates, structures, ordering, error behavior and categorical + fields are identical; +3. every floating or ensemble difference satisfies the predeclared + relative/ULP/induced-`Eall` case bounds and leaves ranks, filters, + structures and infinity states unchanged; +4. repeated timing improvement is larger than observed run-to-run noise on a + relevant workload, using the same machine, dependencies and thread count; +5. peak memory does not regress without a documented and worthwhile speed + tradeoff; and +6. results are stored for the exact branch commit. + +Output identity is judged against the branch's scientific parent. Differences +from `master` to `refactoring` caused by the documented phase-1 bug fixes are +expected but remain visible and classified; they are not optimization +regressions. No fixed percentage is declared before measuring the benchmark +noise. A change that merely moves cost between corpus cases is reported as a +tradeoff, not as a general speedup. + +The required private repository is +[BackofenLab/IntaRNA-refactor-benchmark](https://github.com/BackofenLab/IntaRNA-refactor-benchmark). +Evidence commit `565fc8617184565d3a33e7c02df63f750f4d26ea` contains the +checksum-pinned corpus, runner, strict result schema, deterministic aggregator, +GitHub workflows, 23 passing harness tests, raw compressed outputs and the +[generated report](https://github.com/BackofenLab/IntaRNA-refactor-benchmark/blob/master/REPORT.md). +The recorded source references are `master` at +`3b14bc09a7387d85faf7829d31a5839db5ca721c`, `refactoring` at +`ba5f9eb41229b5aa47339b6ee954858ee3d6b93b` and `refactor-to-c++23` at +`8bd1676d1e38ec6461c60e1b832ff3ace9ff77bc`. + +The same-host batch used GCC 14.4.0, Boost 1.85.0 and ViennaRNA 2.7.2 with +environment fingerprint +`52fb1f3e9e0f6e3806593ed89ca02aea5ea8fa2f2fa9544e9dfd53f07bdbd68e`. +Wall times are means plus/minus sample standard deviation; RSS entries are the +three mean peak values for master/refactoring/C++23 in KiB. The three tiny +scientific-oracle cases round to 0.000000 seconds and remain output-hash gates, +so they are omitted from this timing table. + +| Case | master wall (s) | refactoring wall (s) | C++23 wall (s) | mean peak RSS: master/refactoring/C++23 (KiB) | +| --- | ---: | ---: | ---: | ---: | +| `gcvb-phob-exact` | 1.043333 +/- 0.005774 | 1.040000 +/- 0.017321 | 1.050000 +/- 0.026458 | 15,862.7 / 15,920.0 / 15,904.0 | +| `gcvb-st-ilve-seed-exact` | 0.680000 +/- 0.000000 | 0.666667 +/- 0.020817 | 0.703333 +/- 0.061101 | 15,894.7 / 15,584.0 / 15,726.7 | +| `nc000913-stratified64-t1` | 6.000000 +/- 0.085440 | 6.136667 +/- 0.005774 | 6.243333 +/- 0.020817 | 12,944.0 / 12,844.0 / 13,034.7 | +| `nc000913-stratified64-t4` | 1.860000 +/- 0.010000 | 1.883333 +/- 0.015275 | 1.886667 +/- 0.041633 | 25,165.3 / 25,113.3 / 25,154.7 | +| `oxys-fhla-default` | 0.034000 +/- 0.005477 | 0.032000 +/- 0.004472 | 0.030000 +/- 0.000000 | 10,609.6 / 10,638.4 / 10,716.0 | + +The migration deliberately contains no algorithmic optimization, and the +measurements do not establish one: changes are within a few percent and/or the +observed dispersion and timer granularity. The peak-memory envelope is stable. +All deterministic C++23 raw and canonical outputs are identical to +`refactoring`. The four-thread throughput case has schedule-dependent raw row +order (two hashes for `refactoring`, three for C++23), while every run has the +same canonical SHA-256 +`4950ee7d9eb2f9291fc66921b475972717d5bf86cde980404309e3145d5b8624`. +The only differences from `master` are the two expected phase-1 scientific +fixes: heuristic noLP ensemble direct-continuation de-duplication and seed-free +`outMinPu` accessible-range retention. C++23 is identical to `refactoring` for +both corrected cases. + +## Prioritized implementation sequence + +### Executed phase-2 migration + +1. Froze `70920c6` test outputs and environment metadata. +2. Committed the C++23 Autoconf/build requirement and regenerated build + artifacts separately from source adaptations. +3. Committed minimal project and vendored-test compatibility fixes without + changing scientific algorithms. +4. Ran the GCC 14 release and debug matrix with the default OpenMP build. +5. Ran the Apple Clang/libc++ release build with libomp. +6. Compared all API, CLI and installed-binary outputs with the phase-1 + reference; fixed standard-independent defects on `refactoring` first and + merged them forward. +7. Recorded the exact toolchains, tests and same-host benchmark results and + opened the pull request to `refactoring`. + +Items 2 and 3 may be split further when a compatibility fix is independently +testable. No performance candidate is folded into those commits. + +### Phase-3 preserving work + +Subject to profiling, the provisional order is AP-1 inner-loop lookup removal, +AP-2 workspace reuse, AP-3 private matrix layout, AP-4 immutable preprocessing, +AP-5 deterministic local aggregation, then the AP-6/AP-7 experiments. Each +candidate gets its own branch rooted at `refactor-to-c++23`, or a documented +subbranch when it depends on a preceding level, and its own benchmark JSON. + +The order is deliberately revisable after the first profiles: measured runtime +and memory decide which hotspot is next. Architecture-breaking candidates are +deferred to phase 4 and must be staged so their scientific and benchmark impact +remains attributable. + +## Verification and change record + +C++23-specific migration changes are intentionally mechanical: + +- `configure.ac` now requests mandatory strict C++23 and uses non-obsolete + Autoconf forms; the vendored compiler probe is pinned to Autoconf Archive + serial 25 at upstream commit + `ce7e1be1c4b114ba5eb6dfa8b8253f5ca8522c65`; +- the test-only Catch 1.5.7 header is replaced by official Catch2 2.13.10, + whose pinned header SHA-256 is + `3725c0f0a75f376a5005dde31ead0feb8f7da7507644c201b814443de8355170`; +- project sources receive only direct standard-library includes and a portable + literal debug-mode macro; +- installed pkg-config metadata now supplies its actual prefix, IntaRNA + library and the configured Boost/ViennaRNA public-header paths; and +- CI defines GCC 14 release/debug and Apple Clang/libomp release jobs, each + with build, install, full tests, CLI smoke, isolated installed-header + compilation and an external pkg-config consumer. + +Two independent exhaustive test oracles were added before optimization work: +the exact unseeded oracle at `1ee6aa0` contributes 227 assertions and the +seeded oracle at `3a83472` contributes 114. +Late standard-independent fixes were regression-tested on `refactoring` and +merged forward: `8fb6304` carries the heuristic-cell state, noLP continuation +and bulged-loop corrections, while `8bd1676` carries the +`OutputHandlerHub::add` signature and maximum-reported-count corrections. + +`autotools-init.sh` completes without obsolete-macro warnings. The final +[compiler matrix](https://github.com/BackofenLab/IntaRNA/actions/runs/31863660953) +passes with GCC 14.2.0 on Ubuntu 24.04 in release and debug configurations and +with Apple Clang 17.0.0 on macOS 15 ARM64 in a release/libomp configuration. +All three jobs passed build, installation, both API/CLI test programs, 65 +standalone installed-header probes and the installed pkg-config consumer. The +shared CLI golden suite supplies a byte-stable cross-toolchain output gate. + +A supplemental +GCC 13.3 run using the provisional strict `-std=c++23` flag passed all 3,895 +API assertions in 31 cases and all 20 CLI cases, but GCC 13 advertises a +pre-final C++23 dialect and is not counted as the required gate. Production +translation units also pass a strict-C++23 syntax scan with GCC 16.1. After the +two exhaustive oracles and forward-merged phase-1 regressions, the final GCC 14 +API gate passes 4,275 assertions in 36 cases; all 20 CLI golden cases pass. +The benchmark above supplies the separate same-host timing, memory and output +evidence; no performance result is inferred from compiler CI. diff --git a/m4/m4-ax_cxx_compile_stdcxx.m4 b/m4/m4-ax_cxx_compile_stdcxx.m4 index f87d2209..fe6ae17e 100644 --- a/m4/m4-ax_cxx_compile_stdcxx.m4 +++ b/m4/m4-ax_cxx_compile_stdcxx.m4 @@ -10,13 +10,13 @@ # # Check for baseline language coverage in the compiler for the specified # version of the C++ standard. If necessary, add switches to CXX and -# CXXCPP to enable support. VERSION may be '11' (for the C++11 standard) -# or '14' (for the C++14 standard). +# CXXCPP to enable support. VERSION may be '11', '14', '17', '20', or +# '23' for the respective C++ standard version. # # The second argument, if specified, indicates whether you insist on an # extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g. # -std=c++11). If neither is specified, you get whatever works, with -# preference for an extended mode. +# preference for no added switch, and then for an extended mode. # # The third argument, if specified 'mandatory' or if left unspecified, # indicates that baseline support for the specified C++ standard is @@ -33,23 +33,28 @@ # Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov # Copyright (c) 2015 Paul Norman # Copyright (c) 2015 Moritz Klammler -# Copyright (c) 2016 Krzesimir Nowak +# Copyright (c) 2016, 2018 Krzesimir Nowak +# Copyright (c) 2019 Enji Cooper +# Copyright (c) 2020 Jason Merrill +# Copyright (c) 2021, 2024 Jörn Heusipp +# Copyright (c) 2015, 2022, 2023, 2024 Olly Betts # # Copying and distribution of this file, with or without modification, are # permitted in any medium without royalty provided the copyright notice # and this notice are preserved. This file is offered as-is, without any # warranty. -#serial 7 +#serial 25 dnl This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro dnl (serial version number 13). -dnl AX_REQUIRE_DEFINED([AC_MSG_WARN]) AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"], [$1], [14], [ax_cxx_compile_alternatives="14 1y"], [$1], [17], [ax_cxx_compile_alternatives="17 1z"], + [$1], [20], [ax_cxx_compile_alternatives="20"], + [$1], [23], [ax_cxx_compile_alternatives="23"], [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl m4_if([$2], [], [], [$2], [ext], [], @@ -61,14 +66,16 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])]) AC_LANG_PUSH([C++])dnl ac_success=no - AC_CACHE_CHECK(whether $CXX supports C++$1 features by default, - ax_cv_cxx_compile_cxx$1, - [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], - [ax_cv_cxx_compile_cxx$1=yes], - [ax_cv_cxx_compile_cxx$1=no])]) - if test x$ax_cv_cxx_compile_cxx$1 = xyes; then - ac_success=yes - fi + + m4_if([$2], [], [dnl + AC_CACHE_CHECK(whether $CXX supports C++$1 features by default, + ax_cv_cxx_compile_cxx$1, + [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [ax_cv_cxx_compile_cxx$1=yes], + [ax_cv_cxx_compile_cxx$1=no])]) + if test x$ax_cv_cxx_compile_cxx$1 = xyes; then + ac_success=yes + fi]) m4_if([$2], [noext], [], [dnl if test x$ac_success = xno; then @@ -99,9 +106,18 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl dnl HP's aCC needs +std=c++11 according to: dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf dnl Cray's crayCC needs "-h std=c++11" + dnl MSVC needs -std:c++NN for C++17 and later (default is C++14) for alternative in ${ax_cxx_compile_alternatives}; do - for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do - cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}" MSVC; do + if test x"$switch" = xMSVC; then + dnl AS_TR_SH maps both `:` and `=` to `_` so -std:c++17 would collide + dnl with -std=c++17. We suffix the cache variable name with _MSVC to + dnl avoid this. + switch=-std:c++${alternative} + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_${switch}_MSVC]) + else + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + fi AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, $cachevar, [ac_save_CXX="$CXX" @@ -139,30 +155,50 @@ AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl [define if the compiler supports basic C++$1 syntax]) fi AC_SUBST(HAVE_CXX$1) - m4_if([$1], [17], [AC_MSG_WARN([C++17 is not yet standardized, so the checks may change in incompatible ways anytime])]) ]) dnl Test body for checking C++11 support m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11], - _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + [_AX_CXX_COMPILE_STDCXX_testbody_new_in_11] ) - dnl Test body for checking C++14 support m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14], - _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 - _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + [_AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14] ) +dnl Test body for checking C++17 support + m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17], - _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 - _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 - _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 + [_AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_17] +) + +dnl Test body for checking C++20 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_20], + [_AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_20] +) + +dnl Test body for checking C++23 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_23], + [_AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_20 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_23] ) + dnl Tests for new features in C++11 m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ @@ -174,7 +210,21 @@ m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ #error "This is not a C++ compiler" -#elif __cplusplus < 201103L +// MSVC always sets __cplusplus to 199711L in older versions; newer versions +// only set it correctly if /Zc:__cplusplus is specified as well as a +// /std:c++NN switch: +// +// https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/ +// +// The value __cplusplus ought to have is available in _MSVC_LANG since +// Visual Studio 2015 Update 3: +// +// https://learn.microsoft.com/en-us/cpp/preprocessor/predefined-macros +// +// This was also the first MSVC version to support C++14 so we can't use the +// value of either __cplusplus or _MSVC_LANG to quickly rule out MSVC having +// C++11 or C++14 support, but we can check _MSVC_LANG for C++17 and later. +#elif __cplusplus < 201103L && !defined _MSC_VER #error "This is not a C++11 compiler" @@ -199,11 +249,13 @@ namespace cxx11 struct Base { + virtual ~Base() {} virtual void f() {} }; struct Derived : public Base { + virtual ~Derived() override {} virtual void f() override {} }; @@ -463,7 +515,7 @@ m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[ #error "This is not a C++ compiler" -#elif __cplusplus < 201402L +#elif __cplusplus < 201402L && !defined _MSC_VER #error "This is not a C++14 compiler" @@ -587,20 +639,12 @@ m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[ #error "This is not a C++ compiler" -#elif __cplusplus <= 201402L +#elif (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 201703L #error "This is not a C++17 compiler" #else -#if defined(__clang__) - #define REALLY_CLANG -#else - #if defined(__GNUC__) - #define REALLY_GCC - #endif -#endif - #include #include #include @@ -608,16 +652,12 @@ m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[ namespace cxx17 { -#if !defined(REALLY_CLANG) namespace test_constexpr_lambdas { - // TODO: test it with clang++ from git - constexpr int foo = [](){return 42;}(); } -#endif // !defined(REALLY_CLANG) namespace test::nested_namespace::definitions { @@ -852,12 +892,9 @@ namespace cxx17 } -#if !defined(REALLY_CLANG) namespace test_template_argument_deduction_for_class_templates { - // TODO: test it with clang++ from git - template struct pair { @@ -876,7 +913,6 @@ namespace cxx17 } } -#endif // !defined(REALLY_CLANG) namespace test_non_type_auto_template_parameters { @@ -890,12 +926,9 @@ namespace cxx17 } -#if !defined(REALLY_CLANG) namespace test_structured_bindings { - // TODO: test it with clang++ from git - int arr[2] = { 1, 2 }; std::pair pr = { 1, 2 }; @@ -927,14 +960,10 @@ namespace cxx17 const auto [ x3, y3 ] = f3(); } -#endif // !defined(REALLY_CLANG) -#if !defined(REALLY_CLANG) namespace test_exception_spec_type_system { - // TODO: test it with clang++ from git - struct Good {}; struct Bad {}; @@ -952,7 +981,6 @@ namespace cxx17 static_assert (std::is_same_v); } -#endif // !defined(REALLY_CLANG) namespace test_inline_variables { @@ -977,6 +1005,66 @@ namespace cxx17 } // namespace cxx17 -#endif // __cplusplus <= 201402L +#endif // (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 201703L + +]]) + + +dnl Tests for new features in C++20 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_20], [[ + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 202002L + +#error "This is not a C++20 compiler" + +#else + +#include + +namespace cxx20 +{ + +// As C++20 supports feature test macros in the standard, there is no +// immediate need to actually test for feature availability on the +// Autoconf side. + +} // namespace cxx20 + +#endif // (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 202002L + +]]) + + +dnl Tests for new features in C++23 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_23], [[ + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 202302L + +#error "This is not a C++23 compiler" + +#else + +#include + +namespace cxx23 +{ + +// As C++23 supports feature test macros in the standard, there is no +// immediate need to actually test for feature availability on the +// Autoconf side. + +} // namespace cxx23 + +#endif // (defined _MSVC_LANG ? _MSVC_LANG : __cplusplus) < 202302L ]]) diff --git a/src/IntaRNA/HelixHandlerUnpaired.h b/src/IntaRNA/HelixHandlerUnpaired.h index aec2f879..88f7f1eb 100644 --- a/src/IntaRNA/HelixHandlerUnpaired.h +++ b/src/IntaRNA/HelixHandlerUnpaired.h @@ -10,6 +10,8 @@ #include +#include + namespace IntaRNA { /** diff --git a/src/IntaRNA/Interaction.h b/src/IntaRNA/Interaction.h index 6ef98063..127c17a9 100644 --- a/src/IntaRNA/Interaction.h +++ b/src/IntaRNA/Interaction.h @@ -2,9 +2,11 @@ #ifndef INTARNA_INTERACTION_H_ #define INTARNA_INTERACTION_H_ -#include +#include +#include #include #include +#include #include diff --git a/src/IntaRNA/OutputHandlerCsv.h b/src/IntaRNA/OutputHandlerCsv.h index b91d17d7..a8a76e52 100644 --- a/src/IntaRNA/OutputHandlerCsv.h +++ b/src/IntaRNA/OutputHandlerCsv.h @@ -8,9 +8,11 @@ #include "IntaRNA/OutputHandler.h" #include "IntaRNA/InteractionEnergy.h" +#include #include #include #include +#include #include diff --git a/src/IntaRNA/general.cpp b/src/IntaRNA/general.cpp index b036c785..9c82953b 100644 --- a/src/IntaRNA/general.cpp +++ b/src/IntaRNA/general.cpp @@ -2,6 +2,7 @@ #include "IntaRNA/general.h" #include +#include #include #include diff --git a/src/IntaRNA/general.h b/src/IntaRNA/general.h index 83547b06..ab9dfdcc 100644 --- a/src/IntaRNA/general.h +++ b/src/IntaRNA/general.h @@ -11,10 +11,15 @@ #include "IntaRNA/intarna_config.h" +#include #include //! central flag whether or not debug mode is enabled -#define INTARNA_IN_DEBUG_MODE ((defined(_DEBUG)) || (!defined (NDEBUG))) +#if defined(_DEBUG) || !defined(NDEBUG) + #define INTARNA_IN_DEBUG_MODE 1 +#else + #define INTARNA_IN_DEBUG_MODE 0 +#endif //////////////// CENTRAL LOGGING LIB ////////////////// diff --git a/src/bin/CommandLineParsing.h b/src/bin/CommandLineParsing.h index 594c101b..0818ead7 100644 --- a/src/bin/CommandLineParsing.h +++ b/src/bin/CommandLineParsing.h @@ -11,8 +11,9 @@ #include #include -#include #include +#include +#include #include "IntaRNA/Accessibility.h" #include "IntaRNA/InteractionEnergy.h" diff --git a/src/bin/IntaRNA.cpp b/src/bin/IntaRNA.cpp index 529e6f78..446f739b 100644 --- a/src/bin/IntaRNA.cpp +++ b/src/bin/IntaRNA.cpp @@ -6,6 +6,7 @@ INITIALIZE_EASYLOGGINGPP #include #include +#include #if INTARNA_MULITHREADING #include diff --git a/tests/Makefile.am b/tests/Makefile.am index 30e84189..3bc74a69 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -48,6 +48,8 @@ runApiTests_SOURCES = \ PredictorMfe2dHelixBlockHeuristicSeed_test.cpp \ PredictorMfeHeuristicCellState_test.cpp \ PredictorMfeEnsRegression_test.cpp \ + PredictorTinyOracle_test.cpp \ + PredictorSeedOracle_test.cpp \ NussinovHandler_test.cpp \ RnaSequence_test.cpp \ OutputStreamHandlerSortedCsv_test.cpp \ diff --git a/tests/PredictorSeedOracle_test.cpp b/tests/PredictorSeedOracle_test.cpp new file mode 100644 index 00000000..61e9e3ad --- /dev/null +++ b/tests/PredictorSeedOracle_test.cpp @@ -0,0 +1,667 @@ +#include "catch.hpp" + +#undef NDEBUG + +#include "IntaRNA/AccessibilityDisabled.h" +#include "IntaRNA/InteractionEnergyBasePair.h" +#include "IntaRNA/OutputHandler.h" +#include "IntaRNA/OutputHandlerInteractionList.h" +#include "IntaRNA/PredictorMfe2dSeed.h" +#include "IntaRNA/PredictorMfe2dSeedExtension.h" +#include "IntaRNA/PredictorMfeEns2dSeedExtension.h" +#include "IntaRNA/PredictorMfeEnsSeedOnly.h" +#include "IntaRNA/PredictorMfeSeedOnly.h" +#include "IntaRNA/ReverseAccessibility.h" +#include "IntaRNA/RnaSequence.h" +#include "IntaRNA/SeedConstraint.h" +#include "IntaRNA/SeedHandlerMfe.h" + +#include +#include +#include +#include +#include +#include +#include + +using namespace IntaRNA; + +namespace { + +struct SeedOraclePair { + size_t i1; + size_t i2; + + bool operator==(const SeedOraclePair &) const = default; +}; + +using SeedOracleChain = std::vector; + +struct SeedOccurrence { + size_t firstPair; + size_t lastPair; + E_type hybridEnergy; + E_type totalEnergy; +}; + +struct SeededOracleInteraction { + SeedOracleChain chain; + std::vector seeds; + E_type energy; +}; + +struct SeedOnlyOracleInteraction { + SeedOracleChain chain; + E_type energy; +}; + +struct SeedOracleResult { + std::vector interactions; + std::vector seedOnlyInteractions; + E_type mfe = E_INF; + Z_type unionPartition = 0.0; +}; + +struct SeedOnlySummary { + std::vector optimalInteractions; + E_type mfe = E_INF; + Z_type partition = 0.0; +}; + +class SeedRecordingOutput final : public OutputHandler { +public: + explicit SeedRecordingOutput(const OutputConstraint & constraint) + : OutputHandler(constraint) + {} + + void add(const Interaction & interaction) override { + calls.push_back(std::make_unique(interaction)); + ++reportedInteractions; + } + + const Interaction & last() const { + return *calls.back(); + } + + std::vector > calls; +}; + +size_t seedOracleLast(const IndexRange & range, const size_t sequenceSize) { + return range.to == RnaSequence::lastPos ? sequenceSize-1 : range.to; +} + +bool isStacked(const SeedOraclePair & left, const SeedOraclePair & right) { + return left.i1+1 == right.i1 && left.i2+1 == right.i2; +} + +bool hasNoLonelyPairs(const SeedOracleChain & chain, const size_t first, + const size_t last) +{ + for (size_t i = first; i <= last; ++i) { + const bool stackedLeft = i > first && isStacked(chain[i-1], chain[i]); + const bool stackedRight = i < last && isStacked(chain[i], chain[i+1]); + if (!stackedLeft && !stackedRight) { + return false; + } + } + return first <= last; +} + +bool isAllowedSeedPair(const InteractionEnergy & energy, + const SeedConstraint & constraint, const SeedOraclePair & pair, + const bool atSeedEnd) +{ + return energy.areComplementary(pair.i1, pair.i2) + && energy.getED1(pair.i1, pair.i1) <= constraint.getMaxED() + && energy.getED2(pair.i2, pair.i2) <= constraint.getMaxED() + && (constraint.isGUallowed() || !energy.isGU(pair.i1, pair.i2)) + && (!atSeedEnd || constraint.isGUendAllowed() + || !energy.isGU(pair.i1, pair.i2)) + && (constraint.getRanges1().empty() + || constraint.getRanges1().covers(pair.i1)) + && (constraint.getRanges2().empty() + || constraint.getRanges2().covers(pair.i2)); +} + +bool evaluateSeed(const InteractionEnergy & energy, + const SeedConstraint & constraint, const SeedOracleChain & chain, + const size_t first, SeedOccurrence & seed) +{ + const size_t seedBP = constraint.getBasePairs(); + if (first+seedBP > chain.size()) { + return false; + } + const size_t last = first+seedBP-1; + const SeedOraclePair & left = chain[first]; + const SeedOraclePair & right = chain[last]; + const size_t unpaired1 = right.i1-left.i1+1-seedBP; + const size_t unpaired2 = right.i2-left.i2+1-seedBP; + if (unpaired1 > constraint.getMaxUnpaired1() + || unpaired2 > constraint.getMaxUnpaired2() + || unpaired1+unpaired2 > constraint.getMaxUnpairedOverall()) + { + return false; + } + if (!constraint.isLpAllowed() && !hasNoLonelyPairs(chain, first, last)) { + return false; + } + for (size_t i = first; i <= last; ++i) { + if (!isAllowedSeedPair(energy, constraint, chain[i], + i == first || i == last)) + { + return false; + } + } + + E_type hybridEnergy = energy.getE_init(); + for (size_t i = first+1; i <= last; ++i) { + const E_type loopEnergy = energy.getE_interLeft(chain[i-1].i1, + chain[i].i1, chain[i-1].i2, chain[i].i2); + if (E_isINF(loopEnergy)) { + return false; + } + hybridEnergy += loopEnergy; + } + if (hybridEnergy > constraint.getMaxEhybrid()) { + return false; + } + // SeedHandlerMfe treats the interval ED limit as exclusive. + if (energy.getED1(left.i1, right.i1) >= constraint.getMaxED() + || energy.getED2(left.i2, right.i2) >= constraint.getMaxED()) + { + return false; + } + const E_type totalEnergy = energy.getE(left.i1, right.i1, + left.i2, right.i2, hybridEnergy); + if (E_isINF(totalEnergy) || totalEnergy > constraint.getMaxE()) { + return false; + } + + seed = SeedOccurrence{first, last, hybridEnergy, totalEnergy}; + return true; +} + +std::vector findSeeds(const InteractionEnergy & energy, + const SeedConstraint & constraint, const SeedOracleChain & chain) +{ + std::vector seeds; + if (constraint.getExplicitSeeds().size() != 0) { + throw std::logic_error( + "the computed-seed oracle does not interpret explicit seed strings"); + } + for (size_t first = 0; first+constraint.getBasePairs() <= chain.size(); + ++first) + { + SeedOccurrence seed{}; + if (evaluateSeed(energy, constraint, chain, first, seed)) { + seeds.push_back(seed); + } + } + return seeds; +} + +bool passesOutputConstraint(const InteractionEnergy & energy, + const OutputConstraint & constraint, const SeedOracleChain & chain) +{ + if (constraint.noLP && !hasNoLonelyPairs(chain, 0, chain.size()-1)) { + return false; + } + const SeedOraclePair & left = chain.front(); + const SeedOraclePair & right = chain.back(); + if (constraint.noGUend + && (energy.isGU(left.i1, left.i2) + || energy.isGU(right.i1, right.i2))) + { + return false; + } + return energy.getED1(left.i1, right.i1) <= constraint.maxED + && energy.getED2(left.i2, right.i2) <= constraint.maxED; +} + +void recordSeedOracleChain(const InteractionEnergy & energy, + const SeedConstraint & seedConstraint, + const OutputConstraint & outputConstraint, + const SeedOracleChain & chain, const E_type hybridEnergy, + SeedOracleResult & result) +{ + const std::vector seeds = findSeeds(energy, + seedConstraint, chain); + if (chain.size() == seedConstraint.getBasePairs() && seeds.size() == 1 + && passesOutputConstraint(energy, outputConstraint, chain)) + { + result.seedOnlyInteractions.push_back( + SeedOnlyOracleInteraction{chain, seeds.front().totalEnergy}); + } + if (seeds.empty() || !passesOutputConstraint(energy, outputConstraint, chain)) { + return; + } + const SeedOraclePair & left = chain.front(); + const SeedOraclePair & right = chain.back(); + const E_type totalEnergy = energy.getE(left.i1, right.i1, + left.i2, right.i2, hybridEnergy); + if (E_isINF(totalEnergy)) { + return; + } + result.interactions.push_back(SeededOracleInteraction{ + chain, seeds, totalEnergy}); + result.mfe = std::min(result.mfe, totalEnergy); + // A chain belongs to the seeded ensemble once, irrespective of how many + // overlapping seed witnesses it contains. + result.unionPartition += energy.getBoltzmannWeight(totalEnergy); +} + +void enumerateSeedOracleExtensions(const InteractionEnergy & energy, + const SeedConstraint & seedConstraint, + const OutputConstraint & outputConstraint, const size_t to1, + const size_t to2, SeedOracleChain & chain, const E_type hybridEnergy, + SeedOracleResult & result) +{ + recordSeedOracleChain(energy, seedConstraint, outputConstraint, chain, + hybridEnergy, result); + const SeedOraclePair previous = chain.back(); + for (size_t next1 = previous.i1+1; next1 <= to1; ++next1) { + for (size_t next2 = previous.i2+1; next2 <= to2; ++next2) { + if (!energy.areComplementary(next1, next2)) { + continue; + } + const E_type loopEnergy = energy.getE_interLeft(previous.i1, + next1, previous.i2, next2); + if (E_isINF(loopEnergy)) { + continue; + } + chain.push_back(SeedOraclePair{next1, next2}); + enumerateSeedOracleExtensions(energy, seedConstraint, + outputConstraint, to1, to2, chain, + hybridEnergy+loopEnergy, result); + chain.pop_back(); + } + } +} + +/** + * Exhaustive reference calculation for tiny inputs. It enumerates physical + * base-pair chains directly and checks their seed witnesses afterwards; it + * has no predictor matrix, seed-handler state, or dynamic-programming + * recurrence. + */ +SeedOracleResult enumerateSeededInteractions(const InteractionEnergy & energy, + const SeedConstraint & seedConstraint, + const OutputConstraint & outputConstraint, const IndexRange & range1, + const IndexRange & range2) +{ + SeedOracleResult result; + const size_t to1 = seedOracleLast(range1, energy.size1()); + const size_t to2 = seedOracleLast(range2, energy.size2()); + for (size_t i1 = range1.from; i1 <= to1; ++i1) { + for (size_t i2 = range2.from; i2 <= to2; ++i2) { + if (!energy.areComplementary(i1, i2)) { + continue; + } + SeedOracleChain chain(1, SeedOraclePair{i1, i2}); + enumerateSeedOracleExtensions(energy, seedConstraint, + outputConstraint, to1, to2, chain, energy.getE_init(), + result); + } + } + return result; +} + +SeedOnlySummary summarizeMfeSeedPerStart(const InteractionEnergy & energy, + const SeedOracleResult & oracle) +{ + using Start = std::pair; + std::map bestByStart; + for (const SeedOnlyOracleInteraction & seed : oracle.seedOnlyInteractions) { + const Start start(seed.chain.front().i1, seed.chain.front().i2); + auto entry = bestByStart.find(start); + if (entry == bestByStart.end() || seed.energy < entry->second) { + bestByStart[start] = seed.energy; + } + } + + SeedOnlySummary summary; + for (const auto & entry : bestByStart) { + summary.partition += energy.getBoltzmannWeight(entry.second); + summary.mfe = std::min(summary.mfe, entry.second); + } + for (const SeedOnlyOracleInteraction & seed : oracle.seedOnlyInteractions) { + const Start start(seed.chain.front().i1, seed.chain.front().i2); + if (seed.energy == bestByStart.at(start) && seed.energy == summary.mfe) { + summary.optimalInteractions.push_back(seed); + } + } + return summary; +} + +Interaction::PairingVec seedOracleBasePairs(const InteractionEnergy & energy, + const SeedOracleChain & chain) +{ + Interaction::PairingVec basePairs; + basePairs.reserve(chain.size()); + for (const SeedOraclePair & pair : chain) { + basePairs.push_back(energy.getBasePair(pair.i1, pair.i2)); + } + return basePairs; +} + +const SeededOracleInteraction * findOptimalTrace( + const InteractionEnergy & energy, const SeedOracleResult & oracle, + const Interaction & interaction) +{ + for (const SeededOracleInteraction & candidate : oracle.interactions) { + if (candidate.energy == oracle.mfe + && seedOracleBasePairs(energy, candidate.chain) + == interaction.basePairs) + { + return &candidate; + } + } + return nullptr; +} + +bool matchesSeed(const Interaction::Seed & reported, + const InteractionEnergy & energy, const SeedOracleChain & chain, + const SeedOccurrence & expected) +{ + return reported.bp_i == energy.getBasePair(chain[expected.firstPair].i1, + chain[expected.firstPair].i2) + && reported.bp_j == energy.getBasePair(chain[expected.lastPair].i1, + chain[expected.lastPair].i2) + && E_equal(reported.energy, expected.totalEnergy); +} + +void requireValidSeededMfe(const InteractionEnergy & energy, + const SeedOracleResult & oracle, const Interaction & interaction) +{ + REQUIRE_FALSE(interaction.isEmpty()); + REQUIRE(interaction.energy == oracle.mfe); + const SeededOracleInteraction * trace = findOptimalTrace(energy, oracle, + interaction); + REQUIRE(trace != nullptr); + REQUIRE(interaction.seed != nullptr); + REQUIRE(interaction.seed->size() == trace->seeds.size()); + for (const SeedOccurrence & expected : trace->seeds) { + const auto reported = std::find_if(interaction.seed->begin(), + interaction.seed->end(), [&](const Interaction::Seed & seed) { + return matchesSeed(seed, energy, trace->chain, expected); + }); + REQUIRE(reported != interaction.seed->end()); + } +} + +void compareExactSeededMfePredictors(const InteractionEnergy & energy, + const SeedConstraint & seedConstraint, + const OutputConstraint & outputConstraint, const IndexRange & range1, + const IndexRange & range2, const SeedOracleResult & oracle) +{ + REQUIRE_FALSE(oracle.interactions.empty()); + + OutputHandlerInteractionList directOutput(outputConstraint, 1); + PredictorMfe2dSeed direct(energy, directOutput, nullptr, + new SeedHandlerMfe(energy, seedConstraint)); + direct.predict(range1, range2); + REQUIRE_FALSE(directOutput.empty()); + requireValidSeededMfe(energy, oracle, **directOutput.begin()); + + OutputHandlerInteractionList extensionOutput(outputConstraint, 1); + PredictorMfe2dSeedExtension extension(energy, extensionOutput, nullptr, + new SeedHandlerMfe(energy, seedConstraint)); + extension.predict(range1, range2); + REQUIRE_FALSE(extensionOutput.empty()); + requireValidSeededMfe(energy, oracle, **extensionOutput.begin()); +} + +void compareSeedOnlyPredictors(const InteractionEnergy & energy, + const SeedConstraint & seedConstraint, + const OutputConstraint & outputConstraint, const IndexRange & range1, + const IndexRange & range2, const SeedOracleResult & oracle) +{ + const SeedOnlySummary expected = summarizeMfeSeedPerStart(energy, oracle); + REQUIRE_FALSE(expected.optimalInteractions.empty()); + + OutputHandlerInteractionList mfeOutput(outputConstraint, 1); + PredictorMfeSeedOnly mfe(energy, mfeOutput, nullptr, + new SeedHandlerMfe(energy, seedConstraint)); + mfe.predict(range1, range2); + REQUIRE_FALSE(mfeOutput.empty()); + const Interaction & mfeInteraction = **mfeOutput.begin(); + REQUIRE(mfeInteraction.energy == expected.mfe); + REQUIRE(std::any_of(expected.optimalInteractions.begin(), + expected.optimalInteractions.end(), + [&](const SeedOnlyOracleInteraction & candidate) { + return seedOracleBasePairs(energy, candidate.chain) + == mfeInteraction.basePairs; + })); + REQUIRE(mfeInteraction.seed != nullptr); + REQUIRE_FALSE(mfeInteraction.seed->empty()); + + OutputHandlerInteractionList ensembleOutput(outputConstraint, 1); + PredictorMfeEnsSeedOnly ensemble(energy, ensembleOutput, nullptr, + new SeedHandlerMfe(energy, seedConstraint)); + ensemble.predict(range1, range2); + REQUIRE(ensemble.getZall() + == Approx(expected.partition).epsilon(1e-12)); +} + +SeedConstraint makeSeedConstraint(const size_t basePairs, + const size_t maxUnpairedOverall, const size_t maxUnpaired1, + const size_t maxUnpaired2, const bool noLP) +{ + return SeedConstraint(basePairs, maxUnpairedOverall, maxUnpaired1, + maxUnpaired2, E_INF, Accessibility::ED_UPPER_BOUND, E_INF, + IndexRangeList(), IndexRangeList(), "", false, false, noLP); +} + +OutputConstraint makeOutputConstraint(const bool noLP) { + return OutputConstraint(1, OutputConstraint::OVERLAP_BOTH, + E_INF, E_INF, false, noLP, false, true, true); +} + +void requireUniqueAnchorEnsemblePartition(const InteractionEnergy & energy, + const SeedConstraint & seedConstraint, + const OutputConstraint & outputConstraint, const IndexRange & range1, + const IndexRange & range2, const SeedOracleResult & oracle) +{ + // Seed-extension Z accounting is only asserted in this proved-trivial + // domain. General multi-anchor X-mode Z is not an exact-oracle contract. + REQUIRE(oracle.interactions.size() == 1); + REQUIRE(oracle.interactions.front().seeds.size() == 1); + OutputHandlerInteractionList output(outputConstraint, 1); + PredictorMfeEns2dSeedExtension predictor(energy, output, nullptr, + new SeedHandlerMfe(energy, seedConstraint)); + predictor.predict(range1, range2); + REQUIRE(predictor.getZall() + == Approx(oracle.unionPartition).epsilon(1e-12)); +} + +} // namespace + +TEST_CASE("tiny exhaustive seed oracle for exact predictor families", + "[PredictorSeedOracle]") +{ + #include "testEasyLoggingSetup.icc" + + SECTION("a unique bulged LP seed is required and traced") { + RnaSequence target("target", "GAGG"); + RnaSequence query("query", "CCC"); + AccessibilityDisabled targetAcc(target, 0, nullptr); + AccessibilityDisabled queryAcc(query, 0, nullptr); + ReverseAccessibility reverseQueryAcc(queryAcc); + InteractionEnergyBasePair energy(targetAcc, reverseQueryAcc, 2, 2); + const SeedConstraint seedConstraint = makeSeedConstraint(3, 1, 1, 0, + false); + const OutputConstraint outputConstraint = makeOutputConstraint(false); + const IndexRange targetRange(0, 3); + const IndexRange queryRange(0, 2); + const SeedOracleResult oracle = enumerateSeededInteractions(energy, + seedConstraint, outputConstraint, targetRange, queryRange); + + REQUIRE(oracle.interactions.size() == 1); + REQUIRE(oracle.interactions.front().seeds.size() == 1); + const SeedOccurrence & seed = oracle.interactions.front().seeds.front(); + REQUIRE(oracle.interactions.front().chain[seed.lastPair].i1 + -oracle.interactions.front().chain[seed.firstPair].i1+1 + -seedConstraint.getBasePairs() == 1); + compareExactSeededMfePredictors(energy, seedConstraint, + outputConstraint, targetRange, queryRange, oracle); + compareSeedOnlyPredictors(energy, seedConstraint, outputConstraint, + targetRange, queryRange, oracle); + requireUniqueAnchorEnsemblePartition(energy, seedConstraint, + outputConstraint, targetRange, queryRange, oracle); + } + + SECTION("a noLP bulged seed is two stacked blocks") { + RnaSequence target("target", "GGAGG"); + RnaSequence query("query", "CCCC"); + AccessibilityDisabled targetAcc(target, 0, nullptr); + AccessibilityDisabled queryAcc(query, 0, nullptr); + ReverseAccessibility reverseQueryAcc(queryAcc); + InteractionEnergyBasePair energy(targetAcc, reverseQueryAcc, 2, 2); + const SeedConstraint seedConstraint = makeSeedConstraint(4, 1, 1, 0, + true); + const OutputConstraint outputConstraint = makeOutputConstraint(true); + const IndexRange targetRange(0, 4); + const IndexRange queryRange(0, 3); + const SeedOracleResult oracle = enumerateSeededInteractions(energy, + seedConstraint, outputConstraint, targetRange, queryRange); + + REQUIRE(oracle.interactions.size() == 1); + REQUIRE(hasNoLonelyPairs(oracle.interactions.front().chain, 0, 3)); + REQUIRE_FALSE(isStacked(oracle.interactions.front().chain[1], + oracle.interactions.front().chain[2])); + compareExactSeededMfePredictors(energy, seedConstraint, + outputConstraint, targetRange, queryRange, oracle); + compareSeedOnlyPredictors(energy, seedConstraint, outputConstraint, + targetRange, queryRange, oracle); + requireUniqueAnchorEnsemblePartition(energy, seedConstraint, + outputConstraint, targetRange, queryRange, oracle); + } + + SECTION("overlapping equal-energy seeds preserve every witness") { + RnaSequence target("target", "GGGGG"); + RnaSequence query("query", "CCCCC"); + AccessibilityDisabled targetAcc(target, 0, nullptr); + AccessibilityDisabled queryAcc(query, 0, nullptr); + ReverseAccessibility reverseQueryAcc(queryAcc); + InteractionEnergyBasePair energy(targetAcc, reverseQueryAcc, 2, 2); + const SeedConstraint seedConstraint = makeSeedConstraint(3, 0, 0, 0, + false); + const OutputConstraint outputConstraint = makeOutputConstraint(false); + const IndexRange full(0, 4); + const SeedOracleResult oracle = enumerateSeededInteractions(energy, + seedConstraint, outputConstraint, full, full); + + const auto optimum = std::find_if(oracle.interactions.begin(), + oracle.interactions.end(), [&](const SeededOracleInteraction & i) { + return i.energy == oracle.mfe && i.chain.size() == 5; + }); + REQUIRE(optimum != oracle.interactions.end()); + REQUIRE(optimum->seeds.size() == 3); + REQUIRE(std::all_of(optimum->seeds.begin(), optimum->seeds.end(), + [&](const SeedOccurrence & seed) { + return seed.totalEnergy == optimum->seeds.front().totalEnergy; + })); + + Z_type naivePerSeedPartition = 0.0; + for (const SeededOracleInteraction & interaction : oracle.interactions) { + naivePerSeedPartition += interaction.seeds.size() + * energy.getBoltzmannWeight(interaction.energy); + } + REQUIRE(naivePerSeedPartition > oracle.unionPartition); + + compareExactSeededMfePredictors(energy, seedConstraint, + outputConstraint, full, full, oracle); + compareSeedOnlyPredictors(energy, seedConstraint, outputConstraint, + full, full, oracle); + } + + SECTION("interactions without a valid seed are not reported") { + RnaSequence target("target", "GGGG"); + RnaSequence query("query", "CCCC"); + AccessibilityDisabled targetAcc(target, 0, nullptr); + AccessibilityDisabled queryAcc(query, 0, nullptr); + ReverseAccessibility reverseQueryAcc(queryAcc); + InteractionEnergyBasePair energy(targetAcc, reverseQueryAcc, 2, 2); + const SeedConstraint seedConstraint = makeSeedConstraint(5, 0, 0, 0, + false); + const OutputConstraint outputConstraint = makeOutputConstraint(false); + const IndexRange full(0, 3); + const SeedOracleResult oracle = enumerateSeededInteractions(energy, + seedConstraint, outputConstraint, full, full); + + REQUIRE(oracle.interactions.empty()); + REQUIRE(oracle.seedOnlyInteractions.empty()); + REQUIRE(oracle.unionPartition == 0.0); + + OutputHandlerInteractionList directOutput(outputConstraint, 1); + PredictorMfe2dSeed direct(energy, directOutput, nullptr, + new SeedHandlerMfe(energy, seedConstraint)); + direct.predict(full, full); + REQUIRE(directOutput.empty()); + + OutputHandlerInteractionList extensionOutput(outputConstraint, 1); + PredictorMfe2dSeedExtension extension(energy, extensionOutput, nullptr, + new SeedHandlerMfe(energy, seedConstraint)); + extension.predict(full, full); + REQUIRE(extensionOutput.empty()); + + OutputHandlerInteractionList seedOnlyOutput(outputConstraint, 1); + PredictorMfeEnsSeedOnly seedOnly(energy, seedOnlyOutput, nullptr, + new SeedHandlerMfe(energy, seedConstraint)); + seedOnly.predict(full, full); + REQUIRE(seedOnlyOutput.empty()); + REQUIRE(seedOnly.getZall() == 0.0); + } + + SECTION("exact seeded predictors can be reused on offset subranges") { + RnaSequence target("target", "GGGGGG"); + RnaSequence query("query", "CCCCCC"); + AccessibilityDisabled targetAcc(target, 0, nullptr); + AccessibilityDisabled queryAcc(query, 0, nullptr); + ReverseAccessibility reverseQueryAcc(queryAcc); + InteractionEnergyBasePair energy(targetAcc, reverseQueryAcc, 2, 2); + const SeedConstraint seedConstraint = makeSeedConstraint(3, 0, 0, 0, + false); + const OutputConstraint outputConstraint = makeOutputConstraint(false); + const IndexRange full(0, 5); + const IndexRange sub1(1, 4); + const IndexRange sub2(2, 5); + const SeedOracleResult oracle = enumerateSeededInteractions(energy, + seedConstraint, outputConstraint, sub1, sub2); + REQUIRE_FALSE(oracle.interactions.empty()); + + SeedRecordingOutput directOutput(outputConstraint); + PredictorMfe2dSeed direct(energy, directOutput, nullptr, + new SeedHandlerMfe(energy, seedConstraint)); + direct.predict(full, full); + direct.predict(sub1, sub2); + REQUIRE(directOutput.calls.size() == 2); + requireValidSeededMfe(energy, oracle, directOutput.last()); + + SeedRecordingOutput extensionOutput(outputConstraint); + PredictorMfe2dSeedExtension extension(energy, extensionOutput, nullptr, + new SeedHandlerMfe(energy, seedConstraint)); + extension.predict(full, full); + extension.predict(sub1, sub2); + REQUIRE(extensionOutput.calls.size() == 2); + requireValidSeededMfe(energy, oracle, extensionOutput.last()); + + const SeedOnlySummary seedOnlyExpected = summarizeMfeSeedPerStart(energy, + oracle); + SeedRecordingOutput seedOnlyOutput(outputConstraint); + PredictorMfeEnsSeedOnly seedOnly(energy, seedOnlyOutput, nullptr, + new SeedHandlerMfe(energy, seedConstraint)); + seedOnly.predict(full, full); + seedOnly.predict(sub1, sub2); + REQUIRE(seedOnlyOutput.calls.size() == 2); + REQUIRE(seedOnlyOutput.last().energy == seedOnlyExpected.mfe); + REQUIRE(std::any_of(seedOnlyExpected.optimalInteractions.begin(), + seedOnlyExpected.optimalInteractions.end(), + [&](const SeedOnlyOracleInteraction & candidate) { + return seedOracleBasePairs(energy, candidate.chain) + == seedOnlyOutput.last().basePairs; + })); + REQUIRE(seedOnly.getZall() + == Approx(seedOnlyExpected.partition).epsilon(1e-12)); + } +} diff --git a/tests/PredictorTinyOracle_test.cpp b/tests/PredictorTinyOracle_test.cpp new file mode 100644 index 00000000..1610f838 --- /dev/null +++ b/tests/PredictorTinyOracle_test.cpp @@ -0,0 +1,377 @@ +#include "catch.hpp" + +#undef NDEBUG + +#include "IntaRNA/AccessibilityConstraint.h" +#include "IntaRNA/AccessibilityDisabled.h" +#include "IntaRNA/InteractionEnergyBasePair.h" +#include "IntaRNA/OutputHandlerInteractionList.h" +#include "IntaRNA/PredictorMfe2d.h" +#include "IntaRNA/PredictorMfeEns2d.h" +#include "IntaRNA/ReverseAccessibility.h" +#include "IntaRNA/RnaSequence.h" + +#include +#include +#include +#include +#include + +using namespace IntaRNA; + +namespace { + +/** + * A deliberately simple accessibility model for testing site-width and ED + * filters. It is independent of the interaction predictors: an accessible + * interval of width w has ED = w * edPerNt. + */ +class WidthAccessibility final : public Accessibility { +public: + WidthAccessibility(const RnaSequence & sequence, const size_t maxLength, + const E_type edPerNt) + : Accessibility(sequence, maxLength, NULL) + , edPerNt(edPerNt) + {} + + E_type getED(const size_t from, const size_t to) const override { + checkIndices(from, to); + if (to-from+1 > getMaxLength() + || !getAccConstraint().isAccessible(from) + || !getAccConstraint().isAccessible(to)) + { + return ED_UPPER_BOUND; + } + return static_cast((to-from+1) * edPerNt); + } + +private: + const E_type edPerNt; +}; + +struct OraclePair { + size_t i1; + size_t i2; +}; + +using OracleChain = std::vector; + +struct OracleInteraction { + OracleChain chain; + E_type energy; +}; + +struct OracleResult { + std::vector interactions; + E_type mfe = E_INF; + Z_type partition = 0.0; +}; + +size_t lastIndex(const IndexRange & range, const size_t sequenceSize) { + return range.to == RnaSequence::lastPos ? sequenceSize-1 : range.to; +} + +bool hasNoLonelyPairs(const OracleChain & chain) { + for (size_t i = 0; i < chain.size(); ++i) { + const bool stackedLeft = i > 0 + && chain[i-1].i1+1 == chain[i].i1 + && chain[i-1].i2+1 == chain[i].i2; + const bool stackedRight = i+1 < chain.size() + && chain[i].i1+1 == chain[i+1].i1 + && chain[i].i2+1 == chain[i+1].i2; + if (!stackedLeft && !stackedRight) { + return false; + } + } + return !chain.empty(); +} + +void recordChain(const InteractionEnergy & energy, + const OutputConstraint & constraint, const OracleChain & chain, + const E_type hybridEnergy, OracleResult & result) +{ + if (constraint.noLP && !hasNoLonelyPairs(chain)) { + return; + } + + const OraclePair & left = chain.front(); + const OraclePair & right = chain.back(); + if (constraint.noGUend + && (energy.isGU(left.i1, left.i2) + || energy.isGU(right.i1, right.i2))) + { + return; + } + + const E_type ed1 = energy.getED1(left.i1, right.i1); + const E_type ed2 = energy.getED2(left.i2, right.i2); + if (ed1 > constraint.maxED || ed2 > constraint.maxED) { + return; + } + + const E_type totalEnergy = energy.getE(left.i1, right.i1, + left.i2, right.i2, hybridEnergy); + if (E_isINF(totalEnergy)) { + return; + } + + result.interactions.push_back(OracleInteraction{chain, totalEnergy}); + result.mfe = std::min(result.mfe, totalEnergy); + result.partition += energy.getBoltzmannWeight(totalEnergy); +} + +void enumerateExtensions(const InteractionEnergy & energy, + const OutputConstraint & constraint, const size_t to1, const size_t to2, + OracleChain & chain, const E_type hybridEnergy, OracleResult & result) +{ + recordChain(energy, constraint, chain, hybridEnergy, result); + + const OraclePair previous = chain.back(); + for (size_t next1 = previous.i1+1; next1 <= to1; ++next1) { + for (size_t next2 = previous.i2+1; next2 <= to2; ++next2) { + if (!energy.areComplementary(next1, next2)) { + continue; + } + const E_type loopEnergy = energy.getE_interLeft(previous.i1, + next1, previous.i2, next2); + if (E_isINF(loopEnergy)) { + continue; + } + chain.push_back(OraclePair{next1, next2}); + enumerateExtensions(energy, constraint, to1, to2, chain, + hybridEnergy+loopEnergy, result); + chain.pop_back(); + } + } +} + +/** + * Exhaustive reference calculation. Unlike PredictorMfe2d and + * PredictorMfeEns2d, this has no dynamic-programming state or recurrence: it + * visits every strictly increasing pair chain and evaluates it once. + */ +OracleResult enumerateInteractions(const InteractionEnergy & energy, + const OutputConstraint & constraint, const IndexRange & range1, + const IndexRange & range2) +{ + OracleResult result; + const size_t to1 = lastIndex(range1, energy.size1()); + const size_t to2 = lastIndex(range2, energy.size2()); + for (size_t i1 = range1.from; i1 <= to1; ++i1) { + for (size_t i2 = range2.from; i2 <= to2; ++i2) { + if (!energy.areComplementary(i1, i2)) { + continue; + } + OracleChain chain(1, OraclePair{i1, i2}); + enumerateExtensions(energy, constraint, to1, to2, chain, + energy.getE_init(), result); + } + } + return result; +} + +Interaction::PairingVec toBasePairs(const InteractionEnergy & energy, + const OracleChain & chain) +{ + Interaction::PairingVec basePairs; + basePairs.reserve(chain.size()); + for (const OraclePair & pair : chain) { + basePairs.push_back(energy.getBasePair(pair.i1, pair.i2)); + } + return basePairs; +} + +bool isOptimalOracleTrace(const InteractionEnergy & energy, + const OracleResult & oracle, const Interaction & interaction) +{ + for (const OracleInteraction & candidate : oracle.interactions) { + if (candidate.energy == oracle.mfe + && toBasePairs(energy, candidate.chain) == interaction.basePairs) + { + return true; + } + } + return false; +} + +void compareExactPredictors(const InteractionEnergy & energy, + const OutputConstraint & constraint, const IndexRange & range1, + const IndexRange & range2) +{ + const OracleResult oracle = enumerateInteractions(energy, constraint, + range1, range2); + REQUIRE_FALSE(oracle.interactions.empty()); + + OutputHandlerInteractionList mfeOutput(constraint, 1); + PredictorMfe2d mfePredictor(energy, mfeOutput, NULL); + mfePredictor.predict(range1, range2); + REQUIRE_FALSE(mfeOutput.empty()); + const Interaction & mfe = **mfeOutput.begin(); + REQUIRE(mfe.energy == oracle.mfe); + REQUIRE(isOptimalOracleTrace(energy, oracle, mfe)); + + OutputHandlerInteractionList ensembleOutput(constraint, 1); + PredictorMfeEns2d ensemblePredictor(energy, ensembleOutput, NULL); + ensemblePredictor.predict(range1, range2); + REQUIRE(ensemblePredictor.getZall() + == Approx(oracle.partition).epsilon(1e-12)); +} + +class RecordingOutput final : public OutputHandler { +public: + explicit RecordingOutput(const OutputConstraint & constraint) + : OutputHandler(constraint) + {} + + void add(const Interaction & interaction) override { + calls.push_back(std::make_unique(interaction)); + ++reportedInteractions; + } + + const Interaction & last() const { + return *calls.back(); + } + + std::vector > calls; +}; + +std::string reversed(const std::string & sequence) { + return std::string(sequence.rbegin(), sequence.rend()); +} + +} // namespace + +TEST_CASE("tiny exhaustive oracle for exact predictors", "[PredictorTinyOracle]") { + + #include "testEasyLoggingSetup.icc" + + SECTION("LP chains with internal loops") { + RnaSequence target("target", "GGAGG"); + RnaSequence query("query", reversed("CCUCC")); + AccessibilityDisabled targetAcc(target, 0, NULL); + AccessibilityDisabled queryAcc(query, 0, NULL); + ReverseAccessibility reverseQueryAcc(queryAcc); + InteractionEnergyBasePair energy(targetAcc, reverseQueryAcc, 2, 2); + OutputConstraint constraint(1, OutputConstraint::OVERLAP_BOTH, + E_INF, E_INF, false, false, false, true, true); + + compareExactPredictors(energy, constraint, IndexRange(0, 4), + IndexRange(0, 4)); + } + + SECTION("noLP chains are unions of stacked blocks") { + RnaSequence target("target", "GGGGG"); + RnaSequence query("query", "CCCCC"); + AccessibilityDisabled targetAcc(target, 0, NULL); + AccessibilityDisabled queryAcc(query, 0, NULL); + ReverseAccessibility reverseQueryAcc(queryAcc); + InteractionEnergyBasePair energy(targetAcc, reverseQueryAcc, 2, 2); + OutputConstraint constraint(1, OutputConstraint::OVERLAP_BOTH, + E_INF, E_INF, false, true, false, true, true); + + compareExactPredictors(energy, constraint, IndexRange(0, 4), + IndexRange(0, 4)); + } + + SECTION("GU ends are included or excluded at site level") { + RnaSequence target("target", "GGGG"); + RnaSequence query("query", reversed("UCCU")); + AccessibilityDisabled targetAcc(target, 0, NULL); + AccessibilityDisabled queryAcc(query, 0, NULL); + ReverseAccessibility reverseQueryAcc(queryAcc); + InteractionEnergyBasePair energy(targetAcc, reverseQueryAcc, 2, 2); + + OutputConstraint allowGU(1, OutputConstraint::OVERLAP_BOTH, + E_INF, E_INF, false, false, false, true, true); + OutputConstraint noGUend(1, OutputConstraint::OVERLAP_BOTH, + E_INF, E_INF, false, false, true, true, true); + const OracleResult allowed = enumerateInteractions(energy, allowGU, + IndexRange(0, 3), IndexRange(0, 3)); + const OracleResult filtered = enumerateInteractions(energy, noGUend, + IndexRange(0, 3), IndexRange(0, 3)); + REQUIRE(filtered.partition < allowed.partition); + + compareExactPredictors(energy, allowGU, IndexRange(0, 3), + IndexRange(0, 3)); + compareExactPredictors(energy, noGUend, IndexRange(0, 3), + IndexRange(0, 3)); + } + + SECTION("loop limits, maximum interaction length, and maxED") { + RnaSequence target("target", "GGGGG"); + RnaSequence query("query", "CCCCC"); + WidthAccessibility targetAcc(target, 3, Ekcal_2_E(0.10)); + WidthAccessibility queryAcc(query, 4, Ekcal_2_E(0.15)); + ReverseAccessibility reverseQueryAcc(queryAcc); + InteractionEnergyBasePair energy(targetAcc, reverseQueryAcc, 0, 1); + OutputConstraint constraint(1, OutputConstraint::OVERLAP_BOTH, + E_INF, E_INF, false, false, false, true, true, + Ekcal_2_E(0.45)); + + compareExactPredictors(energy, constraint, IndexRange(0, 4), + IndexRange(0, 4)); + } + + SECTION("offset subranges retain reversed query coordinates") { + RnaSequence target("target", "AAGGGAA"); + RnaSequence query("query", reversed("ACCCUAA")); + AccessibilityConstraint targetConstraint(target, "...b...", 0, + "", "", ""); + AccessibilityDisabled targetAcc(target, 0, &targetConstraint); + AccessibilityDisabled queryAcc(query, 0, NULL); + ReverseAccessibility reverseQueryAcc(queryAcc); + InteractionEnergyBasePair energy(targetAcc, reverseQueryAcc, 2, 2); + OutputConstraint constraint(1, OutputConstraint::OVERLAP_BOTH, + E_INF, E_INF, false, false, false, true, true); + + const IndexRange range1(2, 5); + const IndexRange range2(1, 4); + compareExactPredictors(energy, constraint, range1, range2); + + const OracleResult oracle = enumerateInteractions(energy, constraint, + range1, range2); + for (const OracleInteraction & interaction : oracle.interactions) { + REQUIRE(std::none_of(interaction.chain.begin(), interaction.chain.end(), + [](const OraclePair & pair) { return pair.i1 == 3; })); + for (const Interaction::BasePair & pair + : toBasePairs(energy, interaction.chain)) + { + REQUIRE(pair.first >= range1.from); + REQUIRE(pair.first <= range1.to); + REQUIRE(pair.second >= query.size()-1-range2.to); + REQUIRE(pair.second <= query.size()-1-range2.from); + } + } + } + + SECTION("non-seed exact predictors can be reused with new offsets") { + RnaSequence target("target", "GGGGGG"); + RnaSequence query("query", "CCCCCC"); + AccessibilityDisabled targetAcc(target, 0, NULL); + AccessibilityDisabled queryAcc(query, 0, NULL); + ReverseAccessibility reverseQueryAcc(queryAcc); + InteractionEnergyBasePair energy(targetAcc, reverseQueryAcc, 2, 2); + OutputConstraint constraint(1, OutputConstraint::OVERLAP_BOTH, + E_INF, E_INF, false, false, false, true, true); + const IndexRange full(0, 5); + const IndexRange sub1(1, 4); + const IndexRange sub2(2, 5); + + RecordingOutput mfeOutput(constraint); + PredictorMfe2d mfePredictor(energy, mfeOutput, NULL); + mfePredictor.predict(full, full); + mfePredictor.predict(sub1, sub2); + const OracleResult oracle = enumerateInteractions(energy, constraint, + sub1, sub2); + REQUIRE(mfeOutput.calls.size() == 2); + REQUIRE(mfeOutput.last().energy == oracle.mfe); + REQUIRE(isOptimalOracleTrace(energy, oracle, mfeOutput.last())); + + RecordingOutput ensembleOutput(constraint); + PredictorMfeEns2d ensemblePredictor(energy, ensembleOutput, NULL); + ensemblePredictor.predict(full, full); + ensemblePredictor.predict(sub1, sub2); + REQUIRE(ensemblePredictor.getZall() + == Approx(oracle.partition).epsilon(1e-12)); + } +} diff --git a/tests/catch.hpp b/tests/catch.hpp index a11ecce3..9b309bdd 100644 --- a/tests/catch.hpp +++ b/tests/catch.hpp @@ -1,17 +1,21 @@ /* - * Catch v1.5.7 - * Generated: 2016-09-27 10:45:46.824849 + * Catch v2.13.10 + * Generated: 2022-10-16 11:01:23.452308 * ---------------------------------------------------------- * 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) 2022 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 TWOBLUECUBES_CATCH_HPP_INCLUDED + +#define CATCH_VERSION_MAJOR 2 +#define CATCH_VERSION_MINOR 13 +#define CATCH_VERSION_PATCH 10 #ifdef __clang__ # pragma clang system_header @@ -19,34 +23,69 @@ # pragma GCC system_header #endif -// #included from: internal/catch_suppress_warnings.h +// 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 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" + // 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 + +// See e.g.: +// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html +#ifdef __APPLE__ +# include +# if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \ + (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1) +# define CATCH_PLATFORM_MAC +# elif (defined(TARGET_OS_IPHONE) && 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 @@ -54,270 +93,395 @@ # endif #endif -// #included from: internal/catch_notimplemented_exception.h -#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED +// start catch_user_interfaces.h -// #included from: catch_common.h -#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED - -#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line -#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) -#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 +namespace Catch { + unsigned int rngSeed(); +} -#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr -#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr ) +// end catch_user_interfaces.h +// start catch_tag_alias_autoregistrar.h -#include -#include -#include +// start catch_common.h -// #included from: catch_compiler_capabilities.h -#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED +// start catch_compiler_capabilities.h -// Detect a number of compiler features - mostly C++11/14 conformance - by compiler +// 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_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 // **************** // 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 they // can be combined, en-mass, with the _NO_ forms later. -// All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11 - #ifdef __cplusplus -# if __cplusplus >= 201103L -# define CATCH_CPP11_OR_GREATER +# if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L) +# define CATCH_CPP14_OR_GREATER # endif -# if __cplusplus >= 201402L -# define CATCH_CPP14_OR_GREATER +# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) +# define CATCH_CPP17_OR_GREATER # endif #endif -#ifdef __clang__ +// Only GCC compiler should be used in this block, so other compilers trying to +// mask themselves as GCC should be ignored. +#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" ) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" ) -# 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 + +#if defined(__clang__) -# if __has_feature(cxx_noexcept) -# define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" ) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic pop" ) + +// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug +// which results in calls to destructors being emitted for each temporary, +// without a matching initialization. In practice, this can result in something +// 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" == "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 -# if defined(CATCH_CPP11_OR_GREATER) -# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS _Pragma( "clang diagnostic ignored \"-Wparentheses\"" ) -# 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-arguments\"" ) + +# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \ + _Pragma( "clang diagnostic ignored \"-Wunused-template\"" ) #endif // __clang__ //////////////////////////////////////////////////////////////////////////////// -// Borland -#ifdef __BORLANDC__ - -#endif // __BORLANDC__ +// Assume that non-Windows platforms support posix signals by default +#if !defined(CATCH_PLATFORM_WINDOWS) + #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS +#endif //////////////////////////////////////////////////////////////////////////////// -// EDG -#ifdef __EDG_VERSION__ +// 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 -#endif // __EDG_VERSION__ +#ifdef __OS400__ +# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS +# define CATCH_CONFIG_COLOUR_NONE +#endif //////////////////////////////////////////////////////////////////////////////// -// Digital Mars -#ifdef __DMC__ +// 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 -#endif // __DMC__ +//////////////////////////////////////////////////////////////////////////////// +// Not all Windows environments support SEH properly +#if defined(__MINGW32__) +# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH +#endif //////////////////////////////////////////////////////////////////////////////// -// GCC -#ifdef __GNUC__ +// PS4 +#if defined(__ORBIS__) +# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE +#endif -# if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) -# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR -# endif +//////////////////////////////////////////////////////////////////////////////// +// Cygwin +#ifdef __CYGWIN__ -# if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) && defined(CATCH_CPP11_OR_GREATER) -# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" ) -# endif +// 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)) -// - otherwise more recent versions define __cplusplus >= 201103L -// and will get picked up below +# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING -#endif // __GNUC__ +# endif +#endif // __CYGWIN__ //////////////////////////////////////////////////////////////////////////////// // Visual C++ -#ifdef _MSC_VER +#if defined(_MSC_VER) -#if (_MSC_VER >= 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 == WINAPI_FAMILY_APP) +# define CATCH_CONFIG_COLOUR_NONE +# else +# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH +# endif -#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015)) -#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT -#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS -#endif +# if !defined(__clang__) // Handle Clang masquerading for msvc + +// 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 // MSVC_TRADITIONAL + +// Only do this if we're not using clang on Windows, which uses `diagnostic push` & `diagnostic pop` +# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) ) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop) ) +# endif // __clang__ + +#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__ -// Use variadic macros if the compiler supports them -#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \ - ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \ - ( defined __GNUC__ && __GNUC__ >= 3 ) || \ - ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L ) +//////////////////////////////////////////////////////////////////////////////// +// Embarcadero C++Build +#if defined(__BORLANDC__) + #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN +#endif -#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS +//////////////////////////////////////////////////////////////////////////////// +// 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 -// Use __COUNTER__ if the compiler supports it -#if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \ - ( defined __GNUC__ && __GNUC__ >= 4 && __GNUC_MINOR__ >= 3 ) || \ - ( defined __clang__ && __clang_major__ >= 3 ) +//////////////////////////////////////////////////////////////////////////////// -#define CATCH_INTERNAL_CONFIG_COUNTER +// 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 +#if !defined(_GLIBCXX_USE_C99_MATH_TR1) +#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER #endif -//////////////////////////////////////////////////////////////////////////////// -// C++ language feature support +// 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/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 // defined(__has_include) -// catch all support for C++11 -#if defined(CATCH_CPP11_OR_GREATER) +#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_CPP11_NULLPTR) -# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR -# 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 -# ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT -# define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT -# 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 -# ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS -# define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS -# 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 -# ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM -# define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM -# 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 -# ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE -# define CATCH_INTERNAL_CONFIG_CPP11_TUPLE -# endif +#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE) +# define CATCH_CONFIG_CPP17_BYTE +#endif -# ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS -# define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS -# endif +#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT) +# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE +#endif -# if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) -# define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG -# 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_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_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) +# define CATCH_CONFIG_DISABLE_EXCEPTIONS +#endif -#endif // __cplusplus >= 201103L +#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN) +# define CATCH_CONFIG_POLYFILL_ISNAN +#endif -// Now set the actual defines based on the above + anything the user has configured -#if defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NO_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_NO_CPP11) -# define CATCH_CONFIG_CPP11_NULLPTR +#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC) +# define CATCH_CONFIG_USE_ASYNC #endif -#if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_NO_CPP11) -# define CATCH_CONFIG_CPP11_NOEXCEPT + +#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE) +# define CATCH_CONFIG_ANDROID_LOGWRITE #endif -#if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11) -# define CATCH_CONFIG_CPP11_GENERATED_METHODS + +#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER) +# define CATCH_CONFIG_GLOBAL_NEXTAFTER #endif -#if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_NO_CPP11) -# define CATCH_CONFIG_CPP11_IS_ENUM + +// 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_TUPLE) && !defined(CATCH_CONFIG_CPP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_NO_CPP11) -# define CATCH_CONFIG_CPP11_TUPLE +#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION) +# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION #endif -#if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONFIG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS) -# define CATCH_CONFIG_VARIADIC_MACROS +#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS #endif -#if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_CPP11) -# define CATCH_CONFIG_CPP11_LONG_LONG +#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS #endif -#if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_CPP11) -# define CATCH_CONFIG_CPP11_OVERRIDE +#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS #endif -#if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11) -# define CATCH_CONFIG_CPP11_UNIQUE_PTR +#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS #endif -#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) -# define CATCH_CONFIG_COUNTER + +// 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 -#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) -# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS +#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10) +# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS +#elif defined(__clang__) && (__clang_major__ < 5) +# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS #endif -// noexcept support: -#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT) -# define CATCH_NOEXCEPT noexcept -# define CATCH_NOEXCEPT_IS(x) noexcept(x) -#else -# define CATCH_NOEXCEPT throw() -# define CATCH_NOEXCEPT_IS(x) +#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS #endif -// nullptr support -#ifdef CATCH_CONFIG_CPP11_NULLPTR -# define CATCH_NULL nullptr +#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_NULL NULL +#define CATCH_TRY try +#define CATCH_CATCH_ALL catch (...) +#define CATCH_CATCH_ANON(type) catch (type) #endif -// override support -#ifdef CATCH_CONFIG_CPP11_OVERRIDE -# define CATCH_OVERRIDE override -#else -# define CATCH_OVERRIDE +#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 -// unique_ptr support -#ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR -# define CATCH_AUTO_PTR( T ) std::unique_ptr +// 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 CATCH_AUTO_PTR( T ) std::auto_ptr +# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ ) #endif -namespace Catch { +#include +#include +#include - struct IConfig; +// 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, @@ -325,102 +489,50 @@ namespace Catch { }; }; class NonCopyable { -#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS NonCopyable( NonCopyable const& ) = delete; NonCopyable( NonCopyable && ) = delete; NonCopyable& operator = ( NonCopyable const& ) = delete; NonCopyable& operator = ( NonCopyable && ) = delete; -#else - NonCopyable( NonCopyable const& info ); - NonCopyable& operator = ( NonCopyable const& ); -#endif protected: - NonCopyable() {} + NonCopyable(); virtual ~NonCopyable(); }; - class SafeBool { - public: - typedef void (SafeBool::*type)() const; - - static type makeSafe( bool value ) { - return value ? &SafeBool::trueValue : 0; - } - private: - void trueValue() const {} - }; - - template - inline void deleteAll( ContainerT& container ) { - typename ContainerT::const_iterator it = container.begin(); - typename ContainerT::const_iterator itEnd = container.end(); - for(; it != itEnd; ++it ) - delete *it; - } - template - inline void deleteAllValues( AssociativeContainerT& container ) { - typename AssociativeContainerT::const_iterator it = container.begin(); - typename AssociativeContainerT::const_iterator itEnd = container.end(); - for(; it != itEnd; ++it ) - delete it->second; - } - - bool startsWith( std::string const& s, std::string const& prefix ); - bool endsWith( std::string const& s, std::string const& suffix ); - bool contains( std::string const& s, std::string const& infix ); - void toLowerInPlace( std::string& s ); - std::string toLower( std::string const& s ); - std::string trim( std::string const& str ); - bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ); - - struct pluralise { - pluralise( std::size_t count, std::string const& label ); - - friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ); + struct SourceLineInfo { - std::size_t m_count; - std::string m_label; - }; + SourceLineInfo() = delete; + SourceLineInfo( char const* _file, std::size_t _line ) noexcept + : file( _file ), + line( _line ) + {} - struct SourceLineInfo { + SourceLineInfo( SourceLineInfo const& other ) = default; + SourceLineInfo& operator = ( SourceLineInfo const& ) = default; + SourceLineInfo( SourceLineInfo&& ) noexcept = default; + SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default; - SourceLineInfo(); - SourceLineInfo( char const* _file, std::size_t _line ); - SourceLineInfo( SourceLineInfo const& other ); -# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS - SourceLineInfo( SourceLineInfo && ) = default; - SourceLineInfo& operator = ( SourceLineInfo const& ) = default; - SourceLineInfo& operator = ( SourceLineInfo && ) = default; -# endif - bool empty() const; - bool operator == ( SourceLineInfo const& other ) const; - bool operator < ( SourceLineInfo const& other ) const; + bool empty() const noexcept { return file[0] == '\0'; } + bool operator == ( SourceLineInfo const& other ) const noexcept; + bool operator < ( SourceLineInfo const& other ) const noexcept; - std::string file; + char const* file; std::size_t line; }; std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ); - // This is just here to avoid compiler warnings with macro constants and boolean literals - inline bool isTrue( bool value ){ return value; } - inline bool alwaysTrue() { return true; } - inline bool alwaysFalse() { return false; } - - void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ); - - void seedRng( IConfig const& config ); - unsigned int rngSeed(); + // 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+() { - return std::string(); - } + std::string operator+() const; }; template T const& operator + ( T const& value, StreamEndStop ) { @@ -428,353 +540,812 @@ namespace Catch { } } -#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) -#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO ); - -#include +#define CATCH_INTERNAL_LINEINFO \ + ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) +// end catch_common.h namespace Catch { - class NotImplementedException : public std::exception - { - public: - NotImplementedException( SourceLineInfo const& lineInfo ); - NotImplementedException( NotImplementedException const& ) {} - - virtual ~NotImplementedException() CATCH_NOEXCEPT {} - - virtual const char* what() const CATCH_NOEXCEPT; - - private: - std::string m_what; - SourceLineInfo m_lineInfo; + struct RegistrarForTagAliases { + RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); }; } // end namespace Catch -/////////////////////////////////////////////////////////////////////////////// -#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 -// #included from: internal/catch_context.h -#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED +// end catch_tag_alias_autoregistrar.h +// start catch_test_registry.h -// #included from: catch_interfaces_generators.h -#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED +// start catch_interfaces_testcase.h -#include +#include namespace Catch { - struct IGeneratorInfo { - virtual ~IGeneratorInfo(); - virtual bool moveNext() = 0; - virtual std::size_t getCurrentIndex() const = 0; + class TestSpec; + + struct ITestInvoker { + virtual void invoke () const = 0; + virtual ~ITestInvoker(); }; - struct IGeneratorsForTest { - virtual ~IGeneratorsForTest(); + class TestCase; + struct IConfig; - virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0; - virtual bool moveNext() = 0; + struct ITestCaseRegistry { + virtual ~ITestCaseRegistry(); + virtual std::vector const& getAllTests() const = 0; + virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0; }; - IGeneratorsForTest* createGeneratorsForTest(); + bool isThrowSafe( TestCase const& testCase, IConfig const& config ); + 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 namespace Catch +} -// #included from: catch_ptr.hpp -#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED +// end catch_interfaces_testcase.h +// start catch_stringref.h -#ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wpadded" -#endif +#include +#include +#include +#include namespace Catch { - // 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 string, + /// 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(); + using size_type = std::size_t; + using const_iterator = const char*; + + private: + static constexpr char const* const s_empty = ""; + + char const* m_start = s_empty; + size_type m_size = 0; + + public: // construction + constexpr StringRef() noexcept = default; + + StringRef( char const* rawChars ) noexcept; + + constexpr 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() ) + {} + + explicit operator std::string() const { + return std::string(m_start, m_size); } - ~Ptr(){ - if( m_p ) - m_p->release(); + + public: // operators + auto operator == ( StringRef const& other ) const noexcept -> bool; + auto operator != (StringRef const& other) const noexcept -> bool { + return !(*this == other); } - void reset() { - if( m_p ) - m_p->release(); - m_p = CATCH_NULL; + + auto operator[] ( size_type index ) const noexcept -> char { + assert(index < m_size); + return m_start[index]; } - Ptr& operator = ( T* p ){ - Ptr temp( p ); - swap( temp ); - return *this; + + public: // named queries + constexpr auto empty() const noexcept -> bool { + return m_size == 0; } - Ptr& operator = ( Ptr const& other ){ - Ptr temp( other ); - swap( temp ); - return *this; + constexpr auto size() const noexcept -> size_type { + return m_size; } - void swap( Ptr& other ) { std::swap( m_p, other.m_p ); } - T* get() const{ return m_p; } - T& operator*() const { return *m_p; } - T* operator->() const { return m_p; } - bool operator !() const { return m_p == CATCH_NULL; } - operator SafeBool::type() const { return SafeBool::makeSafe( m_p != CATCH_NULL ); } - - private: - T* m_p; - }; - struct IShared : NonCopyable { - virtual ~IShared(); - virtual void addRef() const = 0; - virtual void release() const = 0; - }; + // Returns the current start pointer. If the StringRef is not + // null-terminated, throws std::domain_exception + auto c_str() const -> char const*; - template - struct SharedImpl : T { + 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; - SharedImpl() : m_rc( 0 ){} + // Returns the current start pointer. May not be null-terminated. + auto data() const noexcept -> char const*; - virtual void addRef() const { - ++m_rc; - } - virtual void release() const { - if( --m_rc == 0 ) - delete this; + constexpr auto isNullTerminated() const noexcept -> bool { + return m_start[m_size] == '\0'; } - mutable unsigned int m_rc; + public: // iterators + constexpr const_iterator begin() const { return m_start; } + constexpr const_iterator end() const { return m_start + m_size; } }; -} // end namespace Catch + auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&; + auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&; -#ifdef __clang__ -#pragma clang diagnostic pop -#endif + constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef { + return StringRef( rawChars, size ); + } +} // namespace Catch -#include -#include -#include +constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef { + return Catch::StringRef( rawChars, size ); +} -namespace Catch { +// end catch_stringref.h +// start catch_preprocessor.hpp - class TestCase; - class Stream; - struct IResultCapture; - struct IRunner; - struct IGeneratorsForTest; - struct IConfig; - struct IContext - { - virtual ~IContext(); +#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__))) - virtual IResultCapture* getResultCapture() = 0; - virtual IRunner* getRunner() = 0; - virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0; - virtual bool advanceGeneratorsForCurrentTest() = 0; - virtual Ptr getConfig() const = 0; - }; +#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 - struct IMutableContext : IContext - { - virtual ~IMutableContext(); - virtual void setResultCapture( IResultCapture* resultCapture ) = 0; - virtual void setRunner( IRunner* runner ) = 0; - virtual void setConfig( Ptr const& config ) = 0; - }; +#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 - IContext& getCurrentContext(); - IMutableContext& getCurrentMutableContext(); - void cleanUpContext(); - Stream createStream( std::string const& streamName ); +#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__) -// #included from: internal/catch_test_registry.hpp -#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED +#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 -// #included from: catch_interfaces_testcase.h -#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED +#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, _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_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...> struct TemplateTypeList{};\ + template class...Cs>\ + constexpr auto get_wrapper() noexcept -> TemplateTypeList { return {}; }\ + template\ + struct append;\ + template\ + struct rewrap;\ + template class, typename...>\ + struct create;\ + template class, typename>\ + struct convert;\ + \ + template \ + struct append { using type = T; };\ + template< template class L1, typename...E1, template class L2, typename...E2, typename...Rest>\ + struct append, L2, Rest...> { using type = typename append, Rest...>::type; };\ + template< template class L1, typename...E1, typename...Rest>\ + struct append, TypeList, Rest...> { using type = L1; };\ + \ + template< template class Container, template class List, typename...elems>\ + struct rewrap, List> { using type = TypeList>; };\ + template< template class Container, template class List, class...Elems, typename...Elements>\ + struct rewrap, List, Elements...> { using type = typename append>, typename rewrap, Elements...>::type>::type; };\ + \ + template