Repository: cucumber/cucumber-cpp
Branch: main
Commit: fedcaeab5382
Files: 129
Total size: 244.6 KB

Directory structure:
gitextract_c6fituri/

├── .clang-format
├── .github/
│   ├── ISSUE_TEMPLATE.md
│   ├── PULL_REQUEST_TEMPLATE.md
│   └── workflows/
│       ├── format.yml
│       ├── linux-build.yml
│       ├── qt5.yml
│       ├── run-all.yml
│       ├── windows-build.yml
│       └── zizmor-analysis.yaml
├── .gitignore
├── CHANGELOG.md
├── CMakeLists.txt
├── CONTRIBUTING.md
├── Gemfile
├── LICENSE
├── README.md
├── cmake/
│   └── modules/
│       ├── FindAsio.cmake
│       ├── FindTCLAP.cmake
│       ├── FindValgrind.cmake
│       └── GitVersion.cmake
├── examples/
│   ├── CMakeLists.txt
│   ├── Calc/
│   │   ├── CMakeLists.txt
│   │   ├── README.txt
│   │   ├── features/
│   │   │   ├── addition.feature
│   │   │   ├── division.feature
│   │   │   └── step_definitions/
│   │   │       ├── BoostCalculatorSteps.cpp
│   │   │       ├── CalculatorSteps.cpp
│   │   │       ├── FuncArgsCalculatorSteps.cpp
│   │   │       ├── GTestCalculatorSteps.cpp
│   │   │       ├── QtTestCalculatorSteps.cpp
│   │   │       └── cucumber.wire
│   │   └── src/
│   │       ├── Calculator.cpp
│   │       └── Calculator.hpp
│   ├── CalcQt/
│   │   ├── CMakeLists.txt
│   │   ├── README.txt
│   │   ├── features/
│   │   │   ├── addition.feature
│   │   │   ├── behavior.feature
│   │   │   ├── initialization.feature
│   │   │   ├── step_definitions/
│   │   │   │   ├── BoostCalculatorQtSteps.cpp
│   │   │   │   ├── CalculatorQtSteps.cpp
│   │   │   │   ├── GTestCalculatorQtSteps.cpp
│   │   │   │   ├── QtTestCalculatorQtSteps.cpp
│   │   │   │   └── cucumber.wire
│   │   │   └── subtraction.feature
│   │   └── src/
│   │       ├── CalcQt.cpp
│   │       ├── Calculator.cpp
│   │       ├── Calculator.hpp
│   │       ├── CalculatorWidget.cpp
│   │       └── CalculatorWidget.hpp
│   └── FeatureShowcase/
│       ├── CMakeLists.txt
│       ├── README.txt
│       └── features/
│           ├── step_definitions/
│           │   ├── TableSteps.cpp
│           │   ├── TagSteps.cpp
│           │   └── cucumber.wire
│           ├── table.feature
│           └── tag.feature
├── include/
│   └── cucumber-cpp/
│       ├── autodetect.hpp
│       ├── defs.hpp
│       ├── generic.hpp
│       └── internal/
│           ├── ContextManager.hpp
│           ├── CukeCommands.hpp
│           ├── CukeEngine.hpp
│           ├── CukeEngineImpl.hpp
│           ├── Macros.hpp
│           ├── RegistrationMacros.hpp
│           ├── Scenario.hpp
│           ├── Table.hpp
│           ├── connectors/
│           │   └── wire/
│           │       ├── ProtocolHandler.hpp
│           │       ├── WireProtocol.hpp
│           │       ├── WireProtocolCommands.hpp
│           │       └── WireServer.hpp
│           ├── defs.hpp
│           ├── drivers/
│           │   ├── BoostDriver.hpp
│           │   ├── DriverSelector.hpp
│           │   ├── GTestDriver.hpp
│           │   ├── GenericDriver.hpp
│           │   └── QtTestDriver.hpp
│           ├── hook/
│           │   ├── HookMacros.hpp
│           │   ├── HookRegistrar.hpp
│           │   └── Tag.hpp
│           ├── step/
│           │   ├── StepMacros.hpp
│           │   └── StepManager.hpp
│           └── utils/
│               ├── IndexSequence.hpp
│               └── Regex.hpp
├── run-linux.sh
├── run-windows.ps1
├── src/
│   ├── CMakeLists.txt
│   ├── ContextManager.cpp
│   ├── CukeCommands.cpp
│   ├── CukeEngine.cpp
│   ├── CukeEngineImpl.cpp
│   ├── HookRegistrar.cpp
│   ├── Regex.cpp
│   ├── Scenario.cpp
│   ├── StepManager.cpp
│   ├── Table.cpp
│   ├── Tag.cpp
│   ├── connectors/
│   │   └── wire/
│   │       ├── WireProtocol.cpp
│   │       ├── WireProtocolCommands.cpp
│   │       └── WireServer.cpp
│   ├── drivers/
│   │   ├── BoostDriver.cpp
│   │   ├── GTestDriver.cpp
│   │   ├── GenericDriver.cpp
│   │   └── QtTestDriver.cpp
│   └── main.cpp
└── tests/
    ├── CMakeLists.txt
    ├── integration/
    │   ├── ContextHandlingTest.cpp
    │   ├── HookRegistrationTest.cpp
    │   ├── StepRegistrationTest.cpp
    │   ├── TaggedHookRegistrationTest.cpp
    │   ├── WireProtocolTest.cpp
    │   ├── WireServerTest.cpp
    │   └── drivers/
    │       ├── BoostDriverTest.cpp
    │       ├── GTestDriverTest.cpp
    │       ├── GenericDriverTest.cpp
    │       └── QtTestDriverTest.cpp
    ├── unit/
    │   ├── BasicStepTest.cpp
    │   ├── ContextManagerTest.cpp
    │   ├── CukeCommandsTest.cpp
    │   ├── RegexTest.cpp
    │   ├── StepCallChainTest.cpp
    │   ├── StepManagerTest.cpp
    │   ├── TableTest.cpp
    │   └── TagTest.cpp
    └── utils/
        ├── ContextManagerTestDouble.hpp
        ├── CukeCommandsFixture.hpp
        ├── DriverTestRunner.hpp
        ├── HookRegistrationFixture.hpp
        └── StepManagerTestDouble.hpp

================================================
FILE CONTENTS
================================================

================================================
FILE: .clang-format
================================================
---
Language: Cpp
AccessModifierOffset: -4
AlignAfterOpenBracket: BlockIndent
AlignEscapedNewlinesLeft: true
AllowShortEnumsOnASingleLine: false
AllowShortFunctionsOnASingleLine: None
AlwaysBreakTemplateDeclarations: true
BinPackArguments: false
BinPackParameters: false
BreakBeforeBinaryOperators: All
BreakBeforeBraces: Attach
BreakConstructorInitializers: AfterColon
ColumnLimit: 100
FixNamespaceComments: true
IncludeCategories: 
  # The autodetect header should always be included last
  - Regex:           '^<cucumber-cpp/autodetect\.hpp>$'
    Priority:        3
  - Regex:           '^["<]cucumber-cpp/'
    Priority:        1
  - Regex:           '.*'
    Priority:        2
IndentPPDirectives: BeforeHash
IndentWidth: 4
NamespaceIndentation: None
PackConstructorInitializers: Never
PenaltyBreakString: 1000
PenaltyExcessCharacter: 10000
PenaltyReturnTypeOnItsOwnLine: 1000
PointerAlignment: Left
ShortNamespaceLines: 200
SortIncludes: false
SpaceAfterTemplateKeyword: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeParens: ControlStatements
Standard: Cpp11
...



================================================
FILE: .github/ISSUE_TEMPLATE.md
================================================
<!-- These sections are meant as guidance for you, to help you give the kind of information we'll need to help with your issue. If a section  doesn't seem to fit, just skip it.

This is not a support or discussion forum. If you have a question, please ask it on [The Cukes Google Group](http://groups.google.com/group/cukes) or on [Gitter](https://gitter.im/cucumber/).

In general: Please provide as much information as you can to help us solving your problem -->

## Summary

<!--- Provide a general summary description of the issue -->

## Expected Behavior

<!--- If you're describing a bug, tell us what should happen -->
<!--- If you're suggesting a change/improvement, tell us how it should work -->
<!--- Feel free to use Given / When / Then if that helps, but please add some plain-language context too -->

## Current Behavior

<!--- If describing a bug, tell us what happens instead of the expected behavior -->
<!--- If suggesting a change/improvement, explain the difference from current behavior -->

<!--- If you have got some output place it in the code block below. Otherwise remove it. -->
~~~
~~~

## Possible Solution

<!--- Not obligatory, but suggest a fix/reason for the bug, -->
<!--- or ideas how to implement the addition or change -->

## Steps to Reproduce (for bugs)

<!--- Provide a link to a live example, or an unambiguous set of steps to -->
<!--- reproduce this bug. Include code to reproduce, if relevant -->
1.
2.
3.
4.

## Context & Motivation

<!--- How has this issue affected you? What are you trying to accomplish? -->
<!--- Providing context helps us come up with a solution that is most useful in the real world -->

## Your Environment

<!--- If you're reporting a bug, include as many relevant details about the environment you experienced the bug in -->
* Version used:
* Operating System and version:
* Link to your project:


================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
<!-- These sections are meant as guidance for you. If something doesn't fit, you can just skip it. -->

## Summary

<!--- Provide a general summary description of your changes -->

## Details

<!--- Describe your changes in detail -->

## Motivation and Context

<!--- Why is this change required? What problem does it solve? -->
<!--- If it fixes an open issue, please link to the issue here. -->

## How Has This Been Tested?

<!--- Please add tests for changes to the code, otherwise we probably won't merge it -->

<!--- Please describe in detail how you tested your changes. -->
<!--- Include details of your testing environment, tests ran to see how -->
<!--- your change affects other areas of the code, etc. -->

## Types of changes

<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->
- [ ] Bug fix (non-breaking change which fixes an issue).
- [ ] New feature (non-breaking change which adds functionality).
- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected).

## Checklist:

<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
<!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
- [ ] It is my own work, its copyright is implicitly assigned to the project and no substantial part of it has been copied from other sources (including [Stack Overflow](https://stackoverflow.com/)). In rare occasions this is acceptable, like in CMake modules where the original copyright information should be kept.
- [ ] I'm using the same code standards as the existing code (indentation, spacing, variable naming, ...).
- [ ] I've added tests for my code.
- [ ] I have verified whether my change requires changes to the documentation
- [ ] My change either requires no documentation change or I've updated the documentation accordingly.
- [ ] My branch has been rebased to main, keeping only relevant commits.


================================================
FILE: .github/workflows/format.yml
================================================
name: check format

permissions: {}

on:
  pull_request:
    branches: [ main ]
  workflow_dispatch:
  push:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
  cancel-in-progress: true

jobs:
  build:
    runs-on: ubuntu-22.04

    steps:
    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      with:
        persist-credentials: false

    - name: setup environment
      run: |
        sudo apt-get install --no-install-recommends \
        clang-format-15

    - name: check code format
      run: |
        clang-format-15 --style=file --Werror --dry-run --verbose `find . -type d \( -name '3rdparty' \) -prune -o -regex '.*\.\(cpp\|hpp\)' -print`


================================================
FILE: .github/workflows/linux-build.yml
================================================
name: Linux build

permissions: {}

on:
  pull_request:
    branches: [ main ]
  workflow_dispatch:
  push:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
  cancel-in-progress: true


jobs:
  build:
    strategy:
      matrix:
        cpp-compiler:
          - g++
          - clang++-15
        cpp-standard:
          - 17
          - 20

    runs-on: ubuntu-22.04

    steps:
    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      with:
        persist-credentials: false

    - name: setup environment
      run: |
        sudo apt-get install --no-install-recommends \
          clang-15 \
          cmake \
          g++ \
          git \
          libasio-dev \
          libboost-test-dev \
          libgl1-mesa-dev \
          libtclap-dev \
          ninja-build \
          nlohmann-json3-dev \
          qt6-base-dev

    - name: install gtest
      run: |
        git clone https://github.com/google/googletest.git
        cd googletest
        mkdir build
        cd build
        cmake \
          ..
        cmake --build . --parallel
        sudo cmake --install .

    - name: build
      run: |
        cmake -E make_directory build
        cmake -E chdir build cmake \
          -DCMAKE_CXX_COMPILER=${{ matrix.cpp-compiler }} \
          -DCMAKE_CXX_STANDARD=${{ matrix.cpp-standard }} \
          -G Ninja \
          -DCUKE_STRICT=on \
          -DCUKE_ENABLE_BOOST_TEST=on \
          -DCUKE_ENABLE_GTEST=on \
          -DCUKE_ENABLE_QT_6=on \
          -DCUKE_ENABLE_EXAMPLES=on \
          -DCUKE_TESTS_UNIT=on \
          ..
        cmake --build build --parallel --verbose

    - name: unit tests
      run: |
        cmake --build build --target test


================================================
FILE: .github/workflows/qt5.yml
================================================
name: build and test with Qt5

permissions: {}

on:
  pull_request:
    branches: [ main ]
  workflow_dispatch:
  push:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
  cancel-in-progress: true

jobs:
  build:
    runs-on: ubuntu-22.04

    steps:
    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      with:
        persist-credentials: false

    - name: setup environment
      run: |
        sudo apt-get install --no-install-recommends \
          cmake \
          g++ \
          git \
          libasio-dev \
          libboost-test-dev \
          libtclap-dev \
          ninja-build \
          nlohmann-json3-dev \
          qtbase5-dev \
          ruby \
          ruby-dev

    - name: install ruby tools
      run: |
        sudo gem install bundler
        sudo bundle install

    - name: install gtest
      run: |
        git clone https://github.com/google/googletest.git
        cd googletest
        mkdir build
        cd build
        cmake ../
        cmake --build . --parallel
        sudo cmake --install .

    - name: build
      run: |
        cmake -E make_directory build
        cmake -E chdir build cmake \
          -G Ninja \
          -DCUKE_STRICT=on \
          -DCUKE_ENABLE_BOOST_TEST=on \
          -DCUKE_ENABLE_GTEST=on \
          -DCUKE_ENABLE_QT_5=on \
          -DCUKE_ENABLE_EXAMPLES=on \
          -DCUKE_TESTS_UNIT=on \
          ..
        cmake --build build --parallel --verbose

    - name: unit tests
      run: |
        cmake --build build --target test

    - name: QtCalc examples
      run: |
        for TEST in \
          build/examples/CalcQt/GTestCalculatorQtSteps \
          build/examples/CalcQt/QtTestCalculatorQtSteps \
          build/examples/CalcQt/BoostCalculatorQtSteps \
        ; do
          "${TEST}" 2> /dev/null &
          sleep 1
          (cd examples/CalcQt; cucumber)
          wait %
        done


================================================
FILE: .github/workflows/run-all.yml
================================================
name: run all

permissions: {}

on:
  pull_request:
    branches: [ main ]
  workflow_dispatch:
  push:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
  cancel-in-progress: true

jobs:
  build-linux:
    runs-on: ubuntu-22.04

    steps:
    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      with:
        persist-credentials: false

    - name: update package index
      run: sudo apt-get -y update

    - name: setup environment
      run: |
        sudo apt-get install --no-install-recommends \
          cmake \
          g++ \
          gcovr \
          git \
          libasio-dev \
          libboost-test-dev \
          libgl1-mesa-dev \
          libtclap-dev \
          ninja-build \
          nlohmann-json3-dev \
          qt6-base-dev \
          ruby \
          ruby-dev

    - name: install ruby tools
      run: |
        sudo gem install bundler
        sudo bundle install

    - name: install gtest
      run: |
        git clone https://github.com/google/googletest.git
        cd googletest
        mkdir build
        cd build
        cmake ../
        cmake --build . --parallel
        sudo cmake --install .

    - name: build and run
      run: |
        ./run-linux.sh

    - name: code coverage summary report
      uses: irongut/CodeCoverageSummary@51cc3a756ddcd398d447c044c02cb6aa83fdae95 #v1.3.0
      with:
        filename: coverage/cobertura.xml
        indicators: false
        hide_complexity: true
        format: markdown
        output: file

    - name: publish code coverage summary
      run: |
        echo '# Code Coverage Report' >> $GITHUB_STEP_SUMMARY
        cat code-coverage-results.md >> $GITHUB_STEP_SUMMARY


================================================
FILE: .github/workflows/windows-build.yml
================================================
name: Windows build

permissions: {}

on:
  pull_request:
    branches: [ main ]
  workflow_dispatch:
  push:
    branches:
      - main

concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
  cancel-in-progress: true

jobs:
  build:
    strategy:
      matrix:
        cpp-standard:
          - 17
          - 20
    # You can find specific tool versions for Windows builds in the Runner specification:
    # https://github.com/actions/runner-images/blob/main/images/windows/Windows2022-Readme.md
    # In particular, this build uses:
    # cmake: 3.27.9
    # VSCode: 2022 Enterprise Edition (corresponding C++ version: https://blog.knatten.org/2022/08/26/microsoft-c-versions-explained/)
    # Ruby: 3.0.6p216
    # boost: 1.82.0
    runs-on: windows-2022
    env:
      BOOST_VERSION: 1.82.0
      NLOHMANN_CLONE_DIR: nlohmann
      NLOHMANN_TAG: v3.11.3
      ASIO_CLONE_DIR: asio
      ASIO_TAG: asio-1-29-0
      TCLAP_CLONE_DIR: tclap
      TCLAP_TAG: v1.2.5

    steps:
    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      with:
        persist-credentials: false

    - name: install ruby tools
      run: |
        gem install bundler
        bundle install

    # - name: Install Google Test
    #   uses: MarkusJx/googletest-installer@v1.1

    - name: Restore cached boost dependencies
      id: cache-boost-deps
      uses: actions/cache@6f8efc29b200d32929f49075959781ed54ec270c #v3.5.0
      with:
        path: |
          boost_1_82_0
        key: ${{ runner.os }}-boost-1820

    - name: install boost
      if: steps.cache-boost-deps.outputs.cache-hit != 'true'
      run: |
        $boost_version_str = ${Env:BOOST_VERSION}.Replace(".","_")
        $boost_url = "https://archives.boost.io/release/${Env:BOOST_VERSION}/source/boost_${boost_version_str}.zip"
        $ProgressPreference = 'SilentlyContinue'
        Write-Host "Downloading Boost from $boost_url"
        Invoke-WebRequest -Uri $boost_url -OutFile boost_${boost_version_str}.zip
        7z x boost_${boost_version_str}.zip
        Write-Host "Unzipped directory content:"
        Get-ChildItem -Directory
        cd boost_${boost_version_str}
        cmd /C bootstrap
        ./b2.exe --build-type=complete toolset=msvc --with-regex --with-program_options --with-system --with-test

    - name: Get and build nlohmann-json
      run: |
        Start-Process "git" -ArgumentList "clone https://github.com/nlohmann/json.git $Env:NLOHMANN_CLONE_DIR --depth 1 --branch $Env:NLOHMANN_TAG" -PassThru -NoNewWindow -Wait
        cd $Env:NLOHMANN_CLONE_DIR
        cmake -B build -S .
        cd ..

    - name: Get ASIO
      run: Start-Process "git" -ArgumentList "clone https://github.com/chriskohlhoff/asio.git $Env:ASIO_CLONE_DIR --depth 1 --branch $Env:ASIO_TAG" -PassThru -NoNewWindow -Wait

    - name: Get TCLAP
      run: Start-Process "git" -ArgumentList "clone https://github.com/mirror/tclap.git $Env:TCLAP_CLONE_DIR --depth 1 --branch $Env:TCLAP_TAG" -PassThru -NoNewWindow -Wait

    - name: build and run
      run: |
        $current_script_dir = Get-Location | Select-Object -Expand "Path"
        $Env:nlohmann_json_DIR = "${current_script_dir}/$Env:NLOHMANN_CLONE_DIR/build"
        $Env:Asio_ROOT = "${current_script_dir}/$Env:ASIO_CLONE_DIR/asio"
        $Env:TCLAP_ROOT = "${current_script_dir}/$Env:TCLAP_CLONE_DIR"
        $Env:cpp_standard = ${{ matrix.cpp-standard }}
        ./run-windows.ps1


================================================
FILE: .github/workflows/zizmor-analysis.yaml
================================================
name: GitHub Actions Security Analysis

on:
  push:
    branches:
      - main
      - 'releases/**'
    paths:
      - '.github/**'
  pull_request:
    paths:
      - '.github/**'

permissions: {}

jobs:
  zizmor:
    name: Run Zizmor
    runs-on: ubuntu-latest
    permissions:
      security-events: write
    steps:
      - name: Checkout repository
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          persist-credentials: false

      - name: Run Zizmor
        uses: zizmorcore/zizmor-action@71321a20a9ded102f6e9ce5718a2fcec2c4f70d8 # v0.5.2


================================================
FILE: .gitignore
================================================
# Bundler
/Gemfile.lock

# rvm
/.ruby-version
/.ruby-gemset

# Build artifacts
/build/
/coverage/
/.local/

# vim swap files
*.swp

# CLion
/.idea
/cmake-build-*/

# Qt Creator
/CMakeLists.txt.user

# build folder
build


================================================
FILE: CHANGELOG.md
================================================
Please see [CONTRIBUTING.md](https://github.com/cucumber/cucumber/blob/main/CONTRIBUTING.md) on how to contribute to Cucumber.

## [0.8.0](https://github.com/cucumber/cucumber-cpp/compare/v0.7.0...v0.8.0) (07 January 2026)

### Added

* Qt6 support ([#283](https://github.com/cucumber/cucumber-cpp/pull/283) Urs Fässler)
* Windows CI support ([#288](https://github.com/cucumber/cucumber-cpp/pull/288) Christoph Wellm)
* Test compilation with different compilers and language standards on Linux ([#282](https://github.com/cucumber/cucumber-cpp/pull/282) Urs Fässler)
* Test to fail the build for deprecated asio features ([72e5fa9](https://github.com/cucumber/cucumber-cpp/commit/72e5fa9ff643d90a513bff57f7322606ecaf4270) Shirzart Enwer)

### Changed

* Only enable minimal set of CMake options by default ([#281](https://github.com/cucumber/cucumber-cpp/pull/281) Urs Fässler)
* Use CMake option for strict checks ([#310](https://github.com/cucumber/cucumber-cpp/pull/310) Joerg Kreuzberger)
* Only treat compilation warnings as error in CI ([#301](https://github.com/cucumber/cucumber-cpp/pull/301) Joerg Kreuzberger)
* Remove support for Qt4 ([#283](https://github.com/cucumber/cucumber-cpp/pull/283) Urs Fässler)
* CalcQt example improvements ([#283](https://github.com/cucumber/cucumber-cpp/pull/283) Urs Fässler)
* Update README with explanation how it works ([#291](https://github.com/cucumber/cucumber-cpp/pull/291) erichstuder)
* Adjust links and information regarding where to get help ([#306](https://github.com/cucumber/cucumber-cpp/pull/306) Joerg Kreuzberger)
* Use https for all links in README ([0911bd2](https://github.com/cucumber/cucumber-cpp/commit/0911bd265bf0b484d5661f4163074714868cc77b) Joerg Kreuzberger)

### Fixed

* Support asio 1.33 ([#308](https://github.com/cucumber/cucumber-cpp/pull/308) Shirzart Enwer)
* Boost download source fixed ([#309](https://github.com/cucumber/cucumber-cpp/pull/309) Shirzart Enwer)
* Windows QtTestDriver ([#305](https://github.com/cucumber/cucumber-cpp/pull/305) Joerg Kreuzberger)
* Flaky QtTestDriver test ([#296](https://github.com/cucumber/cucumber-cpp/pull/296) Joerg Kreuzberger)
* Links to website and discussion group in README ([#299](https://github.com/cucumber/cucumber-cpp/pull/299) Joerg Kreuzberger)
* Compile error with C++20 ([ea089a6](https://github.com/cucumber/cucumber-cpp/commit/ea089a6369641445dc52099298779cef6affdb8f) Urs Fässler)

## [0.7.0](https://github.com/cucumber/cucumber-cpp/compare/v0.6...v0.7.0) (30 December 2023)

### Added

* add version info to cucumber-cpp-main ([8a0d16b8](https://github.com/cucumber/cucumber-cpp/pull/275/commits/8a0d16b8f59dd1c9d75045aa016d9ce235257311) Urs Fässler)
* Remove dependency to Boost ([#275](https://github.com/cucumber/cucumber-cpp/pull/275) Urs Fässler)
* List headers in cmake ([#274](https://github.com/cucumber/cucumber-cpp/pull/274) Urs Fässler)
* Check code format on PR and main branch ([#268](https://github.com/cucumber/cucumber-cpp/pull/268) Urs Fässler)

### Changed

* use semantic versioning ([#280](https://github.com/cucumber/cucumber-cpp/pull/280) Urs Fässler)
* No googletest auto-download ([#279](https://github.com/cucumber/cucumber-cpp/pull/279) Urs Fässler)
* Remove dependency to Boost ([#275](https://github.com/cucumber/cucumber-cpp/pull/275) Urs Fässler)
  * use asio without boost  ([d131ae39](https://github.com/cucumber/cucumber-cpp/pull/275/commits/d131ae3951b9aeb03dd787bf6fee4a06a81c1f04))
  * use TCLAP to parse program options ([b688cf41](https://github.com/cucumber/cucumber-cpp/pull/275/commits/b688cf41647803daa8a7656595b0d1bcbabf2310))
* use nlohmann/json library ([#273](https://github.com/cucumber/cucumber-cpp/pull/273) Urs Fässler)
* remove boost::multi_array ([#269](https://github.com/cucumber/cucumber-cpp/pull/269) Urs Fässler)
* Modernize overloading ([#267](https://github.com/cucumber/cucumber-cpp/pull/267) Urs Fässler)
* refactoring: use stl regex instead of boost::regex ([#266](https://github.com/cucumber/cucumber-cpp/pull/266) Urs Fässler)

### Fixed

* mention CI scripts for details about dependency installation ([#278](https://github.com/cucumber/cucumber-cpp/pull/278) Urs Fässler)
* remove broken E2E tests ([#272](https://github.com/cucumber/cucumber-cpp/pull/272) Urs Fässler)
* remove broken AppVeyor build ([#271](https://github.com/cucumber/cucumber-cpp/pull/271) Urs Fässler)

## [0.6](https://github.com/cucumber/cucumber-cpp/compare/v0.5...v0.6) (17 December 2023)

### Added

### Changed

* Using C++ standard library where possible instead of boost ([#264](https://github.com/cucumber/cucumber-cpp/pull/264) Urs Fässler)

### Fixed

* Statically linking `boost_system` ([#197](https://github.com/cucumber/cucumber-cpp/pull/197) Matthieu Longo)
* Unable to `add_subdirectory(cucumber-cpp)` ([#211](https://github.com/cucumber/cucumber-cpp/pull/211) Sergey Bon)
* Warning C4265 on Visual Studio ([#195](https://github.com/cucumber/cucumber-cpp/pull/195) Matthieu Longo)
* Fix handling of optional regex captures ([#221](https://github.com/cucumber/cucumber-cpp/pull/221) Alain Martin)
* Fix compilation with Boost 1.70.0 ([#225](https://github.com/cucumber/cucumber-cpp/pull/225) Krystian Młynarczyk)
* Support step definitions with multi-byte characters ([#224](https://github.com/cucumber/cucumber-cpp/pull/224) Spencer Rudnick)
* Supress warning about deprecated QSignalMapper ([#228](https://github.com/cucumber/cucumber-cpp/pull/228) Lukas Woodtli)
* Remove CACHE FORCE arguments from CMAKE_CXX_FLAG on colored terminal output ([#232](https://github.com/cucumber/cucumber-cpp/pull/232)  Alex Cani)
* Enable compiling with clang's -Wsuggest-override ([#244](https://github.com/cucumber/cucumber-cpp/pull/244) Tobias Hahn)
* Add posibility to build with sanitizers enabled ([#247](https://github.com/cucumber/cucumber-cpp/pull/247) Lukas Woodtli)
* Add support for latest GoogleTest and Boost ([#249](https://github.com/cucumber/cucumber-cpp/pull/249) Canmor Lam)
* add file extensions to adhere to policy CMP0115 ([#250](https://github.com/cucumber/cucumber-cpp/pull/250) Urs Fässler)
* Support latest Qt and test on Ubuntu 22.04 ([#253](https://github.com/cucumber/cucumber-cpp/pull/253) Urs Fässler)
* Update table.feature ([#258](https://github.com/cucumber/cucumber-cpp/pull/258) mbed101)

## [0.5](https://github.com/cucumber/cucumber-cpp/compare/v0.4...v0.5) (2 July 2018)

### Added

* QtTest based test driver for cucumber-cpp ([#165](https://github.com/cucumber/cucumber-cpp/pull/165) Kamil Strzempowicz)
* Listen on localhost by default to avoid firewall warnings ([#158](https://github.com/cucumber/cucumber-cpp/pull/158) Nik Reiman)
* Better integrate Qt into buildsystem, it can now be disabled, and test it in CI ([#160](https://github.com/cucumber/cucumber-cpp/pull/160) Kamil Strzempowicz & Giel van Schijndel)
* Support taking regex captures as arguments to the step definition's function ([#159](https://github.com/cucumber/cucumber-cpp/pull/159) Giel van Schijndel)
* Support building as shared library on Windows and hide internal symbols on all platforms ([#147](https://github.com/cucumber/cucumber-cpp/pull/147) [Nik Reiman](https://github.com/nre-ableton))
* Support installing library targets along with headers ([#182](https://github.com/cucumber/cucumber-cpp/pull/182) [Matthieu](https://github.com/matlo607))

### Changed

* Renamed HISTORY.md to CHANGELOG.md and updated to bring inline with [cucumber/cucumber #251](https://github.com/cucumber/cucumber/issues/251) ([#166](https://github.com/cucumber/cucumber-cpp/pull/166) [jaysonesmith](https://github.com/jaysonesmith))

### Fixed

* Fix compiler warning ([#192](https://github.com/cucumber/cucumber-cpp/issues/192) [Giel van Schijndel](https://github.com/muggenhor)), ([#184](https://github.com/cucumber/cucumber-cpp/pull/184) [Kamil Strzempowicz](https://github.com/konserw))
* Add missing virtual destructor in base class SocketServer used by TCPSocketServer and UnixSocketServer ([#183](https://github.com/cucumber/cucumber-cpp/pull/183) Matthieu Longo)
* Fix breaking changes in API of boost-1.66.0 ([#180](https://github.com/cucumber/cucumber-cpp/pull/180)  Matthieu Longo)
* Fix conflicting "using std" declaration with "using boost::thread" ([#181](https://github.com/cucumber/cucumber-cpp/pull/181)  Matthieu Longo)
* Fix building with boost > 1.64 by adding 2 new methods to BoostLogInterceptor ([#175](https://github.com/cucumber/cucumber-cpp/pull/175) Kamil Strzempowicz)
* Fixing Visual Studio 2013 error: no appropriate default constructor available ([#188](https://github.com/cucumber/cucumber-cpp/pull/188) Antoine Allard)
* Fix issue #81 by intercepting messages from BOOST_*_MESSAGE macros ([#164](https://github.com/cucumber/cucumber-cpp/pull/164) Kamil Strzempowicz)
* Allow running all GTest cases without filter separation ([#144](https://github.com/cucumber/cucumber-cpp/pull/144) Giel van Schijndel)
* Fix QNX build by depending on standard C++ instead of specific implementation ([#156](https://github.com/cucumber/cucumber-cpp/issues/156) Giel van Schijndel)
* Ensure CMake 3.1+ is available, 2.8.12 wasn't enough for quite a while ([#152](https://github.com/cucumber/cucumber-cpp/pull/152) Giel van Schijndel)
* Fix crash during termination of the CalcQt example's step definitions ([#62](https://github.com/cucumber/cucumber-cpp/issues/62) Giel van Schijndel)

## [0.4](https://github.com/cucumber/cucumber-cpp/compare/v0.3.1...v0.4) (31 March 2017)

### New Features

* Support for MinGW build ([#130](https://github.com/cucumber/cucumber-cpp/pull/130) Michel Estermann)
* Add support for Unix sockets ([#126](https://github.com/cucumber/cucumber-cpp/pull/126) Giel van Schijndel)
* Add support for using ephemeral ports ([#131](https://github.com/cucumber/cucumber-cpp/pull/131) Giel van Schijndel)
* Removed CppSpec support ([#118](https://github.com/cucumber/cucumber-cpp/pull/118) Paolo Ambrosio)
* Support for GoogleTest 1.8 ([#120](https://github.com/cucumber/cucumber-cpp/pull/120) Kamil Strzempowicz)
* Disable Nagle on TCP socket ([#125](https://github.com/cucumber/cucumber-cpp/pull/125) Giel van Schijndel)

### Bugfixes

* Fixed suggested step definition when step sentence contains double quote ([#116](https://github.com/cucumber/cucumber-cpp/issues/116) Kamil Strzempowicz, [fbc49a3](https://github.com/cucumber/cucumber-cpp/commit/fbc49a34e12a0b9b2a6e121d97ba1ad8f46dce8f) Paolo Ambrosio)
* Fixed `defs.hpp` deprecation warning on MSVC ([#124](https://github.com/cucumber/cucumber-cpp/pull/124) Antoine Allard)
* Fixed parallel build ([#135](https://github.com/cucumber/cucumber-cpp/pull/135) Giel van Schijndel)
* Fixed memory leaks and better memory management ([#134](https://github.com/cucumber/cucumber-cpp/pull/134) Giel van Schijndel)
* Fixed clang warning about bad `typeid` usage ([#138](https://github.com/cucumber/cucumber-cpp/pull/138) Kamil Strzempowicz)

## [0.3.1](https://github.com/cucumber/cucumber-cpp/compare/v0.3...v0.3.1) (11 April 2016)

### New Features

* Support for Boost 1.60 ([#101](https://github.com/cucumber/cucumber-cpp/pull/101) Kai Unger)
* Support for CMake inclusion in other projects ([#76](https://github.com/cucumber/cucumber-cpp/pull/76) Eric Brayet)
* Added Qt5 support in CalcQt example ([#98](https://github.com/cucumber/cucumber-cpp/pull/98) Kamil Strzempowicz)
* Improved Generic Driver to write steps without testing framework ([#99](https://github.com/cucumber/cucumber-cpp/pull/99) Kamil Strzempowicz)

### Bugfixes

None

## [0.3](https://github.com/cucumber/cucumber-cpp/compare/v0.2...v0.3) (22 December 2013)

### New Features

* Added BEFORE_ALL and AFTER_ALL macros ([#65](https://github.com/cucumber/cucumber-cpp/pull/65) Larry Price)
* Added CalcQt example ([#58](https://github.com/cucumber/cucumber-cpp/pull/58) Gianni Ambrosio)
* Replaced USING_CONTEXT with ScenarioScope<T> ([27256e9](https://github.com/cucumber/cucumber-cpp/commit/27256e932c75e9d4d57d4839042317e6a04cfe46) Paolo Ambrosio)
* Changed include name from core.hpp to defs.hpp ([5bbac06](https://github.com/cucumber/cucumber-cpp/commit/5bbac062e19dcf9de2761f4ded115aa7212c14d7) Paolo Ambrosio)
* Project rename from CukeBins to Cucumber-Cpp ([efecfd0](https://github.com/cucumber/cucumber-cpp/commit/efecfd0813efa1b6d406c2fd0cd03d8a84bed3ff) Paolo Ambrosio)

### Bugfixes

* Fixed socket server bug in VS2012 forcing Boost 1.51 ([#57](https://github.com/cucumber/cucumber-cpp/pull/57) Jared Szechy, [e41a9b7](https://github.com/cucumber/cucumber-cpp/commit/e681c5028a756d8f711574a86e84ca8b98333d5c) Paolo Ambrosio)
* Fixed crashes on some architectures ([#52](https://github.com/cucumber/cucumber-cpp/pull/52) Sabst)
* Fixed AFTER hook ordering issue ([#43](https://github.com/cucumber/cucumber-cpp/pull/43) Greg Williams)
* Added default empty constructor to work with less permissive gcc 4.6 settings ([#38](https://github.com/cucumber/cucumber-cpp/pull/38) Hugo Ferreira)


## [0.2](https://github.com/cucumber/cucumber-cpp/compare/v0.1...v0.2) (25 June 2011)

TODO


## [0.1](https://github.com/cucumber/cucumber-cpp/commits/v0.1) (03 May 2010)

* Initial implementation



================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.16)

cmake_policy(SET CMP0063 NEW)

# CMP0077: option() honors normal variables
# https://cmake.org/cmake/help/latest/policy/CMP0077.html
cmake_policy(SET CMP0077 NEW)

# CMP0074: find_package() makes use of <PackageName>_ROOT variables
# https://cmake.org/cmake/help/latest/policy/CMP0074.html
cmake_policy(SET CMP0074 NEW)

project(Cucumber-Cpp)

option(CUKE_ENABLE_BOOST_TEST   "Enable Boost.Test framework" OFF)
option(CUKE_ENABLE_GTEST        "Enable Google Test framework" OFF)
option(CUKE_ENABLE_QT_5         "Enable Qt5 framework" OFF)
option(CUKE_ENABLE_QT_6         "Enable Qt6 framework" OFF)

option(CUKE_ENABLE_EXAMPLES     "Build examples" OFF)
option(CUKE_TESTS_UNIT          "Enable unit tests" OFF)

option(BUILD_SHARED_LIBS        "Generate shared libraries" OFF)
option(CUKE_CODE_COVERAGE       "Enable instrumentation for code coverage" OFF)
set(CUKE_ENABLE_SANITIZER       "OFF" CACHE STRING "Sanitizer to use for checking")
set_property(CACHE CUKE_ENABLE_SANITIZER PROPERTY STRINGS OFF "address" "thread" "undefined")
option(CUKE_TESTS_VALGRIND      "Enable tests within Valgrind" OFF)
option(CUKE_STRICT              "Additional and more strict checks" OFF)

if(NOT DEFINED CMAKE_CXX_STANDARD)
    set(CMAKE_CXX_STANDARD 17)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
    set(CMAKE_CXX_EXTENSIONS OFF)
elseif(CMAKE_CXX_STANDARD LESS 17)
    message(FATAL_ERROR "C++17 (above) is required")
endif()

if(CUKE_CODE_COVERAGE)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage")
endif()

if(CUKE_STRICT)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DASIO_NO_DEPRECATED")
endif()

set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake/modules)

#
# Option deprecation: if deprecated option is defined
# then print a warning and use its value instead
#

function(option_depr_message old prefer)
    message (DEPRECATION "${old} is deprecated in favor of ${prefer}")
endfunction()

function(option_depr old prefer)
    if(DEFINED ${old})
        option_depr_message(${old} ${prefer})
        set (${prefer} ${${old}} CACHE BOOL "Set from deprecated ${old}" FORCE)
    endif()
endfunction()

function(option_depr_invert old prefer)
    if(DEFINED ${old})
        option_depr_message(${old} ${prefer})
        set (${prefer} $<NOT:${${old}}> CACHE BOOL "Set from deprecated ${old}" FORCE)
    endif()
endfunction()


option_depr_invert (CUKE_DISABLE_BOOST_TEST   CUKE_ENABLE_BOOST_TEST)
option_depr_invert (CUKE_DISABLE_GTEST        CUKE_ENABLE_GTEST)
option_depr_invert (CUKE_DISABLE_QT_5         CUKE_ENABLE_QT_5)
option_depr_invert (CUKE_DISABLE_QT_6         CUKE_ENABLE_QT_6)
option_depr_invert (CUKE_DISABLE_UNIT_TESTS   CUKE_TESTS_UNIT)
option_depr        (VALGRIND_TESTS            CUKE_TESTS_VALGRIND)

#
# Check that at least one test framework is enabled
#

set(CUKE_TEST_FRAMEWORKS
    CUKE_ENABLE_BOOST_TEST
    CUKE_ENABLE_GTEST
    CUKE_ENABLE_QT_5
    CUKE_ENABLE_QT_6
)

set(TEST_FRAMEWORK_FOUND FALSE)
foreach(test_framework ${CUKE_TEST_FRAMEWORKS})
    if(${test_framework})
        set(TEST_FRAMEWORK_FOUND TRUE)
    endif()
endforeach()

if(NOT TEST_FRAMEWORK_FOUND)
    message(WARNING "No test framework enabled. At least one should be enabled. Options are: ${CUKE_TEST_FRAMEWORKS}.")
endif()

#
# Generic Compiler Flags
#

if(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_INIT} -Wall -Wextra -Wsuggest-override ${CMAKE_CXX_FLAGS}")
    # TODO: A better fix should handle ld's --as-needed flag
    if(UNIX AND NOT APPLE)
        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Xlinker '--no-as-needed'")
    endif()
elseif(MSVC)
    set(CMAKE_CXX_FLAGS "-DNOMINMAX ${CMAKE_CXX_FLAGS}") # exclude M$ min/max macros
    set(CMAKE_CXX_FLAGS "/wd4996 ${CMAKE_CXX_FLAGS}") # don't warn about use of plain C functions without (non-portable) "_s" suffix
    #set(CMAKE_CXX_FLAGS_DEBUG "/analyze ${CMAKE_CXX_FLAGS_DEBUG}")
endif()

#
# Colored Terminal Output
#

if(UNIX AND (
       (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    OR (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9))
    AND CMAKE_GENERATOR STREQUAL "Ninja")
  # These compilers generate coloured output, but by default only when their output channel is a
  # terminal (TTY/PTY). Ninja however captures all output in a pipe (per-subprocess), disabling
  # coloured compiler diagnostics. We forcefully enable it because Ninja, since 1.0.0
  # (ninja-build/ninja#198) takes care to strip VT100 CSI control sequences from the output if Ninja
  # itself is writing to a pipe instead of a terminal. As a result this should give us the best of
  # both worlds: coloured output when we're running in a terminal, plain output for editors, IDEs,
  # etc.
  set(CMAKE_CXX_FLAGS "-fdiagnostics-color=always ${CMAKE_CXX_FLAGS}")
endif()

#
# Boost
#

set(Boost_USE_STATIC_RUNTIME OFF)
if(CUKE_ENABLE_BOOST_TEST)
    # "An external test runner utility is required to link with dynamic library" (Boost User's Guide)
    set(CMAKE_CXX_FLAGS "-DBOOST_TEST_DYN_LINK ${CMAKE_CXX_FLAGS}")
    find_package(Boost 1.70 COMPONENTS unit_test_framework REQUIRED)
endif()

#
# GTest
#

if(CUKE_ENABLE_GTEST)
    find_package(GTest 1.11.0 REQUIRED)
endif()

#
# Qt
#

if(CUKE_ENABLE_QT_5 AND CUKE_ENABLE_QT_6)
    message(FATAL_ERROR "Qt version 5 and 6 enabled, please select at most one")
endif()


if(CUKE_ENABLE_QT_5)
    find_package(Qt5 REQUIRED COMPONENTS
        Core
        Gui
        Widgets
        Test
    )

    message(STATUS "Found Qt version: ${Qt5Core_VERSION_STRING}")
    if(Qt5Core_VERSION_STRING VERSION_LESS 5.15.0)
        add_library(Qt::Core    INTERFACE IMPORTED)
        add_library(Qt::Gui     INTERFACE IMPORTED)
        add_library(Qt::Widgets INTERFACE IMPORTED)
        add_library(Qt::Test    INTERFACE IMPORTED)
        set_target_properties(Qt::Core    PROPERTIES INTERFACE_LINK_LIBRARIES Qt5::Core   )
        set_target_properties(Qt::Gui     PROPERTIES INTERFACE_LINK_LIBRARIES Qt5::Gui    )
        set_target_properties(Qt::Widgets PROPERTIES INTERFACE_LINK_LIBRARIES Qt5::Widgets)
        set_target_properties(Qt::Test    PROPERTIES INTERFACE_LINK_LIBRARIES Qt5::Test   )
    endif()
endif()

if(CUKE_ENABLE_QT_6)
    find_package(Qt6 REQUIRED COMPONENTS
        Core
        Gui
        Widgets
        Test
    )

    message(STATUS "Found Qt version: ${Qt6Core_VERSION}")
endif()


#
# Sanitizers
#

if(CUKE_ENABLE_SANITIZER AND NOT ${CUKE_ENABLE_SANITIZER} EQUAL "OFF")
    message("Disabling valgrind when a sanitizer is enabled")
    set(CUKE_TESTS_VALGRIND OFF)

    if (WIN32)
        message(WARNING "The use of the sanatizers on Windows is not tested")
    endif()

    add_compile_options("-fsanitize=${CUKE_ENABLE_SANITIZER}")
    add_link_options("-fsanitize=${CUKE_ENABLE_SANITIZER}")
endif()



#
# Valgrind
#

if(CUKE_TESTS_VALGRIND)
    find_package(Valgrind REQUIRED)
    set(VALGRIND_ARGS --error-exitcode=2 --leak-check=full --undef-value-errors=no)
    if(NOT VALGRIND_VERSION_STRING VERSION_LESS 3.9)
        # Valgrind 3.9 no longer shows all leaks unless asked to
        list(APPEND VALGRIND_ARGS --show-leak-kinds=all)
    endif()
    function(add_test name)
        if(NOT name STREQUAL "NAME")
            _add_test(${VALGRIND_EXECUTABLE} ${VALGRIND_ARGS} ${ARGV})
            return()
        endif()

        set(TEST_ARGS ${ARGV})
        list(FIND TEST_ARGS COMMAND COMMAND_IDX)
        if(COMMAND_IDX EQUAL -1)
            message(AUTHOR_WARNING "Weird command-line given to add_test(), not injecting valgrind")
            _add_test(${ARGV})
            return()
        endif()

        # We want to operate on the COMMAND, not the 'COMMAND' keyword preceding it
        math(EXPR COMMAND_IDX "${COMMAND_IDX} + 1")

        # Keep add_test() behaviour of replacing COMMANDs, when executable targets, with their output files
        list(GET TEST_ARGS ${COMMAND_IDX} COMMAND)
        if(TARGET ${COMMAND})
            get_target_property(COMMAND_TYPE ${COMMAND} TYPE)
            if(COMMAND_TYPE STREQUAL "EXECUTABLE")
                # Inserting first, removing the original only after that, because inserting to the end of the list doesn't work
                math(EXPR ORIG_COMMAND_IDX "${COMMAND_IDX} + 1")
                list(INSERT TEST_ARGS ${COMMAND_IDX} "$<TARGET_FILE:${COMMAND}>")
                list(REMOVE_AT TEST_ARGS ${ORIG_COMMAND_IDX})
            endif()
        endif()

        # Insert the valgrind command line, before the command to execute
        list(INSERT TEST_ARGS ${COMMAND_IDX} ${VALGRIND_EXECUTABLE} ${VALGRIND_ARGS})

        _add_test(${TEST_ARGS})
    endfunction()
endif()

#
# Cucumber-Cpp
#

set(CUKE_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
add_subdirectory(src)

#
# Tests
#

if(CUKE_TESTS_UNIT)
    enable_testing()
    add_subdirectory(tests)
else()
    message(STATUS "Skipping unit tests")
endif()

#
# Examples
#

if(CUKE_ENABLE_EXAMPLES)
    add_subdirectory(examples)
endif()


================================================
FILE: CONTRIBUTING.md
================================================
## About to create a new Github Issue?

We appreciate that. But before you do, please learn our basic rules:

* Do you have a feature request? Then don't expect it to be implemented unless you or someone else sends a [pull request](https://help.github.com/articles/using-pull-requests).
* Reporting a bug? We need to know what compiler, operating system and architecture (32 or 64 bit) you are using, including versions of all libraries. Bugs with [pull requests](https://help.github.com/articles/using-pull-requests) get fixed quicker. Some bugs may never be fixed.
* You have to tell us how to reproduce a bug. Bonus point for a [pull request](https://help.github.com/articles/using-pull-requests) with a failing test that reproduces the bug.
* Want to paste some code or output? Put \`\`\` on a line above and below your code/output. See [GFM](https://help.github.com/articles/github-flavored-markdown)'s *Fenced Code Blocks* for details.
* We love [pull requests](https://help.github.com/articles/using-pull-requests), but if you don't have a test to go with it we probably won't merge it.

## Contributing

Before you can contribute, you have to be able to build the source and run tests.

### The Github Process

The process for using git/github is similar to the [Github-Flow](http://scottchacon.com/2011/08/31/github-flow.html)

* **Anything** in the main branch is good enough to release
* Working on nontrivial features
    + Create a descriptively named branch off of main
    + Commit to that branch locally and regularly
    + Push your work to the same named branch on the server
    + Regularly rebase this branch from main to keep it up to date
* Open a pull request
    + When you need feedback or help
    + You think the branch is ready for merging (you can use the [hub](https://github.com/defunkt/hub#git-pull-request) command-line tool)
* For any nontrivial change, even if you have the rights to merge the pull request yourself, wait before someone else has reviewed and agreed on the change

Here is an [Example](https://github.com/cucumber/bool/pull/12) of this process in action

#### Tips for good commits

1. Read up on [Github Flavored Markdown](https://help.github.com/articles/github-flavored-markdown)
    + Especially links and syntax highlighting. GFM can be used in tickets as well as commit messages (e.g. put "#4" somewhere in a commit message to link ticket 4 to that commit
2. Close tickets with commits if you can
    + Add "Closes #5, #9" somewhere in the commit message to both link and close. See [Issues 2.0 the Next Generation](https://github.com/blog/831-issues-2-0-the-next-generation) for details.
    + Use [this script](https://gist.github.com/aslakhellesoy/4754009) to compile and view GFM locally
3. Subscribe to ticket feeds so you stay in the loop and get a chance to provide feedback on tickets
4. The code standard is the existing code
    + Use the same indentation, spacing, line ending, ASCII for source code, UTF-8 everywhere else
5. Use git diff (or git diff --cached if you have staged) before every commit
    + This helps you avoid committing changes you didn't mean to

## Maintainers' guide

### Merge a PR

- Verify that:
  - All checks have passed
  - At least one maintainer has approved any non-trivial change, and a
    discussion has occurred for any breaking change
  - The branch does not need rebasing or squashing of commits
- To merge:
  - Follow the command line instructions on GitHub
  - If it is either a new feature or a bugfix, specify the `--no-commit`
    flag when merging and add a line to `CHANGELOG.md` following the
    current convention. Add this file to the changes to be committed and
    commit the merge.
  - Commit message should follow the current convention:
    `Merge #42 'Description of the change usually from the PR description'`

### Do a release

- Release commit (e.g. [fdf8a5c](https://github.com/cucumber/cucumber-cpp/commit/fdf8a5c4ef4c51dfa7ea82077f706414a4c6322d)):
  - Change `CHANGELOG.md` renaming the "In Git" section with the release number and date
  - Commit with message `Update changelog for the X.Y.Z release`
  - Create an annotated tag for this commit named `vX.Y.Z`
- New development branch commit (e.g. [da60995](https://github.com/cucumber/cucumber-cpp/commit/da609956fcd42046e5182c6226acd7e53dd7754e)):
  - Add new "In Git" section to `CHANGELOG.md`
  - Commit with message `Preparing history file for next development release`
- Push commits and tags to main


================================================
FILE: Gemfile
================================================
source 'https://rubygems.org'

group :test do
  gem 'cucumber', "=7.1.0"
  gem 'cucumber-wire', "=6.2.1"
end



================================================
FILE: LICENSE
================================================
MIT License

Copyright (c) 2010 Paolo Ambrosio

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
# Cucumber-CPP

## Overview

Cucumber-Cpp allows Cucumber to support step definitions written in C++.

* [Cucumber-Cpp Website](https://github.com/cucumber/cucumber-cpp)
* [Cucumber-Cpp Documentation](https://github.com/cucumber/cucumber-cpp/wiki/)
* [Cucumber Website](https://cucumber.io/)
* [Get in touch](https://cucumber.io/docs/community/get-in-touch/)

If you need to ask a question, post on the [Cucumber discussion group](https://github.com/orgs/cucumber/discussions).

If you want to contribute code to the project, guidelines are in [CONTRIBUTING.md](CONTRIBUTING.md).

## Dependencies

It relies on a few executables:

* [cmake](https://cmake.org/download/) 3.16 or later.
  Required to setup environment and build software

It relies on a few libraries:

* [Asio](https://think-async.com/Asio/) 1.18.1 or later.
* [Boost.Test](https://www.boost.org/) 1.70. Optional for the Boost Test driver.
* [GTest](https://github.com/google/googletest) 1.11.0 or later. Optional for the GTest driver.
* [GMock](https://github.com/google/googletest) 1.11.0 or later. Optional for the internal test suite.
* [nlohmann-json](https://github.com/nlohmann/json) 3.10.5 or later.
* [Qt6 or Qt5](https://qt-project.org/). Optional for the CalcQt example and QtTest driver.
* [TCLAP](https://tclap.sourceforge.net/) 1.2.5 or later.

It might work with earlier versions of the libraries, but it was not tested with them.
See the [CI scripts](.github/workflows/run-all.yml) for details about dependency installation.

Cucumber-Cpp uses the wire protocol at the moment, so you will need
Cucumber-Ruby installed and available on the path. It is also needed
to run the functional test suite.

Please mind that Cucumber-Cpp is not compatible with Cucumber-Ruby 3.x
due to a [bug in its wire protocol](https://github.com/cucumber/cucumber-ruby/issues/1183)
implementation.

To install the Ruby prerequisites:

```
gem install bundler // For windows: gem install bundle
bundle install
```

### Windows vs. Linux

To get an inspiration on how to set up the dependencies on your specific system (Windows or Linux), you may want to have a look at the
workflow files [for Windows](.github/workflows/windows-build.yml) and [for Linux](.github/workflows/linux-build.yml).


## Build

Building Cucumber-Cpp with tests and samples:

```
# Create build directory
cmake -E make_directory build

# Generate Makefiles
cmake -E chdir build cmake \
    -DCUKE_ENABLE_BOOST_TEST=on \
    -DCUKE_ENABLE_GTEST=on \
    -DCUKE_ENABLE_QT_6=on \
    -DCUKE_TESTS_UNIT=on \
    -DCUKE_ENABLE_EXAMPLES=on \
    ..

# Build cucumber-cpp
cmake --build build

# Run unit tests
cmake --build build --target test

# Run install
cmake --install build
```

Running the Calc example on Unix:

```
build/examples/Calc/BoostCalculatorSteps >/dev/null &
(cd examples/Calc; cucumber)
```

Running the Calc example on Windows (NMake):

```
start build\examples\Calc\BoostCalculatorSteps.exe
cucumber examples\Calc
```

## The way it works
(This is a great explanation by [paoloambrosio](https://github.com/paoloambrosio) copied from [stackoverflow](https://stackoverflow.com/questions/50760865/cucumber-cpp-required-software-for-running-example))

The way Cucumber-CPP currently works is by having Cucumber-Ruby connecting to a TCP port where the C++ implementation is listening. When the wire protocol is defined in the cucumber.wire file, with host and port where your C++ wire protocol server is listening, Cucumber-Ruby will try and run them with Cucumber-CPP.

C++ is a compiled language, so step definitions must be compiled first. The examples provided use CMake, as described in the README. Cucumber-CPP needs to be linked to the step definitions and to everything that they use (usually the application under test), creating an executable file that will listen to the wire protocol port (defaults to localhost:3902) for Cucumber-Ruby to connect to (and exiting when it disconnects).

```
                    +------------------------------------------+
                    |                                          |
+----------+        | +----------+  +----------+  +----------+ |
|          |        | |          |  |          |  |          | |
| Cucumber |        | | Cucumber |  | C++ Step |  | Your     | |
| Ruby     |--------->| CPP Wire |--| Defs     |--| CPP App  | |
|          |        | | Server   |  |          |  |          | |
|          |        | |          |  |          |  |          | |
+----------+        | +----------+  +----------+  +----------+ |
                    |                                          |
                    +------------------------------------------+
```

## Getting started

Here is a basic example on how to get started with *cucumber-cpp*. First you need to create the basic feature structure:

```
cucumber --init
```

Then create a *cucumber.wire* file in the *features/step_definitions* folder with the following content:

```
host: localhost
port: 3902
```

Create your first feature (an example is available [here](examples/Calc/features/addition.feature)).

Then create your step definition runner (an example is available [here](examples/Calc/features/step_definitions/BoostCalculatorSteps.cpp)). In order to compile the step definition runner, make sure to add [cucumber include directory](include/cucumber-cpp) to the include path and link with *libcucumber-cpp.a* and additional testing libraries (boost unit test).

Run the step definition runner in the background and then cucumber, like in the Calc example in the previous section. The step definition runner should exit after the feature is run and cucumber exits.


================================================
FILE: cmake/modules/FindAsio.cmake
================================================
find_path(ASIO_INCLUDE_DIR asio.hpp)

if (ASIO_INCLUDE_DIR)
    set(ASIO_FOUND TRUE)
else ()
    set(ASIO_FOUND FALSE)
endif ()

include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(Asio REQUIRED_VARS ASIO_INCLUDE_DIR)


================================================
FILE: cmake/modules/FindTCLAP.cmake
================================================
find_path(TCLAP_INCLUDE_DIR tclap/CmdLine.h)

if (TCLAP_INCLUDE_DIR)
    set(TCLAP_FOUND TRUE)
else ()
    set(TCLAP_FOUND FALSE)
endif ()

include(FindPackageHandleStandardArgs)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(TCLAP REQUIRED_VARS TCLAP_INCLUDE_DIR)


================================================
FILE: cmake/modules/FindValgrind.cmake
================================================
#.rst:
# FindValgrind
# -------
#
# The module defines the following variables:
#
# ``VALGRIND_EXECUTABLE``
#   Path to Valgrind command-line client.
# ``Valgrind_FOUND``
#   True if the Valgrind command-line client was found.
# ``VALGRIND_VERSION_STRING``
#   The version of Valgrind found.
#
# Example usage:
#
# .. code-block:: cmake
#
#    find_package(Valgrind)
#    if(Valgrind_FOUND)
#      message("Valgrind found: ${VALGRIND_EXECUTABLE}")
#    endif()

#=============================================================================
# Copyright (c) 2017 Giel van Schijndel
#
# CMake - Cross Platform Makefile Generator
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
#   notice, this list of conditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright
#   notice, this list of conditions and the following disclaimer in the
#   documentation and/or other materials provided with the distribution.
#
# * Neither the names of Kitware, Inc., the Insight Software Consortium,
#   nor the names of their contributors may be used to endorse or promote
#   products derived from this software without specific prior written
#   permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# ------------------------------------------------------------------------------
#
# The above copyright and license notice applies to distributions of
# CMake in source and binary form.  Some source files contain additional
# notices of original copyright by their contributors; see each source
# for details.  Third-party software packages supplied with CMake under
# compatible licenses provide their own copyright notices documented in
# corresponding subdirectories.
#
# ------------------------------------------------------------------------------
#
# CMake was initially developed by Kitware with the following sponsorship:
#
#  * National Library of Medicine at the National Institutes of Health
#    as part of the Insight Segmentation and Registration Toolkit (ITK).
#
#  * US National Labs (Los Alamos, Livermore, Sandia) ASC Parallel
#    Visualization Initiative.
#
#  * National Alliance for Medical Image Computing (NAMIC) is funded by the
#    National Institutes of Health through the NIH Roadmap for Medical Research,
#    Grant U54 EB005149.
#
#  * Kitware, Inc.
#=============================================================================

find_program(VALGRIND_EXECUTABLE
  NAMES valgrind
  DOC "Valgrind command line executable"
)
mark_as_advanced(VALGRIND_EXECUTABLE)

if(VALGRIND_EXECUTABLE)
    execute_process(COMMAND ${VALGRIND_EXECUTABLE} --version
                    OUTPUT_VARIABLE VALGRIND_VERSION_STRING
                    ERROR_QUIET
                    OUTPUT_STRIP_TRAILING_WHITESPACE)
    if (VALGRIND_VERSION_STRING MATCHES "^valgrind-[0-9]")
        string(REPLACE "valgrind-" "" VALGRIND_VERSION_STRING "${VALGRIND_VERSION_STRING}")
    endif()
endif()

include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Valgrind
                                  REQUIRED_VARS VALGRIND_EXECUTABLE
                                  VERSION_VAR VALGRIND_VERSION_STRING)


================================================
FILE: cmake/modules/GitVersion.cmake
================================================
function(git_get_version VERSION_VARIABLE)
    find_program(GIT_EXECUTABLE git)

    if(NOT GIT_EXECUTABLE)
        message(FATAL_ERROR "Git not found. Please install Git and make sure it is in your system's PATH.")
    endif()

    execute_process(
        COMMAND ${GIT_EXECUTABLE} describe --always --dirty
        OUTPUT_VARIABLE VERSION_STRING
        OUTPUT_STRIP_TRAILING_WHITESPACE
        WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
        ERROR_VARIABLE GIT_DESCRIBE_ERROR
        RESULT_VARIABLE GIT_DESCRIBE_RESULT
    )

    if(NOT GIT_DESCRIBE_RESULT EQUAL 0)
        message(FATAL_ERROR "Error running 'git describe': ${GIT_DESCRIBE_ERROR}")
    endif()

    string(LENGTH "${VERSION_STRING}" VERSION_STRING_LENGTH)
    string(SUBSTRING "${VERSION_STRING}" 0 1 FIRST_CHARACTER)

    if("${FIRST_CHARACTER}" STREQUAL "v")
        string(SUBSTRING "${VERSION_STRING}" 1 ${VERSION_STRING_LENGTH} VERSION_STRING)
    endif()

    set(${VERSION_VARIABLE} ${VERSION_STRING} PARENT_SCOPE)
endfunction()


================================================
FILE: examples/CMakeLists.txt
================================================
add_subdirectory(Calc)
add_subdirectory(CalcQt)
add_subdirectory(FeatureShowcase)


================================================
FILE: examples/Calc/CMakeLists.txt
================================================
project(Calc)

add_library(Calc STATIC src/Calculator.cpp)
target_include_directories(Calc INTERFACE src)

if(TARGET GTest::gtest)
    add_executable(GTestCalculatorSteps features/step_definitions/GTestCalculatorSteps.cpp)
    target_link_libraries(GTestCalculatorSteps PRIVATE Calc cucumber-cpp GTest::gtest)

    add_executable(FuncArgsCalculatorSteps features/step_definitions/FuncArgsCalculatorSteps.cpp)
    target_link_libraries(FuncArgsCalculatorSteps PRIVATE Calc cucumber-cpp GTest::gtest)
endif()

if(TARGET Boost::unit_test_framework)
    add_executable(BoostCalculatorSteps features/step_definitions/BoostCalculatorSteps.cpp)
    target_link_libraries(BoostCalculatorSteps PRIVATE Calc cucumber-cpp Boost::unit_test_framework)
endif()

if(TARGET Qt::Test)
    add_executable(QtTestCalculatorSteps features/step_definitions/QtTestCalculatorSteps.cpp)
    target_link_libraries(QtTestCalculatorSteps Calc Qt::Test cucumber-cpp)
endif()


================================================
FILE: examples/Calc/README.txt
================================================
This was inspired by Cuke4Nuke Calc sample



================================================
FILE: examples/Calc/features/addition.feature
================================================
# language: en
Feature: Addition
  In order to avoid silly mistakes
  As a math idiot 
  I want to be told the sum of two numbers

  Scenario Outline: Add two numbers
    Given I have entered <input_1> into the calculator
    And I have entered <input_2> into the calculator
    When I press <button>
    Then the result should be <output> on the screen

  Examples:
    | input_1 | input_2 | button | output |
    | 20      | 30      | add    | 50     |
    | 2       | 5       | add    | 7      |
    | 0       | 40      | add    | 40     |


================================================
FILE: examples/Calc/features/division.feature
================================================
# language: en
Feature: Division
  In order to avoid silly mistakes
  Cashiers must be able to calculate a fraction

  Scenario: Regular numbers
    Given I have entered 3 into the calculator
    And I have entered 2 into the calculator
    When I press divide
    Then the result should be 1.5 on the screen


================================================
FILE: examples/Calc/features/step_definitions/BoostCalculatorSteps.cpp
================================================
#include <boost/test/unit_test.hpp>
// Pretend to be GTest
#define EXPECT_EQ BOOST_CHECK_EQUAL
#include "CalculatorSteps.cpp"


================================================
FILE: examples/Calc/features/step_definitions/CalculatorSteps.cpp
================================================
#include <cucumber-cpp/autodetect.hpp>

#include <Calculator.hpp>

using cucumber::ScenarioScope;

struct CalcCtx {
    Calculator calc;
    double result;
};

GIVEN("^I have entered (\\d+) into the calculator$") {
    REGEX_PARAM(double, n);
    ScenarioScope<CalcCtx> context;

    context->calc.push(n);
}

WHEN("^I press add") {
    ScenarioScope<CalcCtx> context;

    context->result = context->calc.add();
}

WHEN("^I press divide") {
    ScenarioScope<CalcCtx> context;

    context->result = context->calc.divide();
}

THEN("^the result should be (.*) on the screen$") {
    REGEX_PARAM(double, expected);
    ScenarioScope<CalcCtx> context;

    EXPECT_EQ(expected, context->result);
}


================================================
FILE: examples/Calc/features/step_definitions/FuncArgsCalculatorSteps.cpp
================================================
#include <gtest/gtest.h>
#include <cucumber-cpp/autodetect.hpp>

#include <Calculator.hpp>

using cucumber::ScenarioScope;

struct CalcCtx {
    Calculator calc;
    double result;
};

GIVEN("^I have entered (\\d+) into the calculator$", (const double n)) {
    ScenarioScope<CalcCtx> context;

    context->calc.push(n);
}

WHEN("^I press add") {
    ScenarioScope<CalcCtx> context;

    context->result = context->calc.add();
}

WHEN("^I press divide") {
    ScenarioScope<CalcCtx> context;

    context->result = context->calc.divide();
}

THEN("^the result should be (.*) on the screen$", (const double expected)) {
    ScenarioScope<CalcCtx> context;

    EXPECT_EQ(expected, context->result);
}


================================================
FILE: examples/Calc/features/step_definitions/GTestCalculatorSteps.cpp
================================================
#include <gtest/gtest.h>
#include "CalculatorSteps.cpp"


================================================
FILE: examples/Calc/features/step_definitions/QtTestCalculatorSteps.cpp
================================================
#include <QTest>
// Pretend to be GTest
#define EXPECT_EQ QCOMPARE
#include "CalculatorSteps.cpp"


================================================
FILE: examples/Calc/features/step_definitions/cucumber.wire
================================================
host: localhost
port: 3902


================================================
FILE: examples/Calc/src/Calculator.cpp
================================================
#include <limits>
#include "Calculator.hpp"

void Calculator::push(double n) {
    values.push_back(n);
}

double Calculator::add() {
    double result = 0;
    for (std::list<double>::const_iterator i = values.begin(); i != values.end(); ++i) {
        result += *i;
    }
    return result;
}

double Calculator::divide() {
    double result = std::numeric_limits<double>::quiet_NaN();
    for (std::list<double>::const_iterator i = values.begin(); i != values.end(); ++i) {
        if (i == values.begin()) {
            result = *i;
        } else {
            result /= *i;
        }
    }
    return result;
}


================================================
FILE: examples/Calc/src/Calculator.hpp
================================================
#pragma once

#include <list>

class Calculator {
private:
    std::list<double> values;

public:
    void push(double);
    double add();
    double divide();
};


================================================
FILE: examples/CalcQt/CMakeLists.txt
================================================
project(CalcQt)

if(TARGET Qt::Core AND TARGET Qt::Gui AND TARGET Qt::Widgets AND TARGET Qt::Test)
    set(CMAKE_AUTOMOC ON)

    add_library(libcalcqt STATIC src/Calculator.cpp src/Calculator.hpp)
    target_include_directories(libcalcqt INTERFACE src)
    target_link_libraries(libcalcqt
        PUBLIC
            Qt::Core
    )

    add_executable(calcqt
        src/CalcQt.cpp
        src/CalculatorWidget.cpp
        src/CalculatorWidget.hpp
    )
    target_link_libraries(calcqt
        PRIVATE
            libcalcqt
            Qt::Core
            Qt::Gui
            Qt::Widgets
    )

    add_executable(QtTestCalculatorQtSteps features/step_definitions/QtTestCalculatorQtSteps.cpp)
    target_link_libraries(QtTestCalculatorQtSteps PRIVATE libcalcqt Qt::Test cucumber-cpp)

    if(TARGET Boost::unit_test_framework)
        add_executable(BoostCalculatorQtSteps features/step_definitions/BoostCalculatorQtSteps.cpp)
        target_link_libraries(BoostCalculatorQtSteps PRIVATE libcalcqt Boost::unit_test_framework cucumber-cpp)
    endif()

    if(TARGET GTest::gtest)
        add_executable(GTestCalculatorQtSteps features/step_definitions/GTestCalculatorQtSteps.cpp)
        target_link_libraries(GTestCalculatorQtSteps PRIVATE libcalcqt GTest::gtest cucumber-cpp)
    endif()

endif()


================================================
FILE: examples/CalcQt/README.txt
================================================
This sample shows how to test a QT GUI. The environment variable
CALCQT_STEP_DELAY allows to introduce delays in the step execution for
demo purposes (i.e. CALCQT_STEP_DELAY=100 ./BoostCalculatorQtSteps)



================================================
FILE: examples/CalcQt/features/addition.feature
================================================
# language: en
Feature: Addition
  In order to avoid silly mistakes
  As a math idiot 
  I want to be told the sum of two numbers

  Scenario Outline: Add two numbers
    Given I just turned on the calculator
    When I press <button1>
    And I press add
    And I press <button2>
    And I press calculate
    Then the display should show <result>

  Examples:
    | button1 | button2 | result |
    | 2       | 3       | 5      |
    | 7       | 5       | 12     |
    | 9       | 1       | 10     |


================================================
FILE: examples/CalcQt/features/behavior.feature
================================================
# language: en
Feature: GUI behavior
  tests for buttons

  Scenario Outline: Digit buttons
    Given I just turned on the calculator
    When I press <button>
    Then the display should show <output>

  Examples:
    | button | output |
    | 0      | 0      |
    | 1      | 1      |
    | 2      | 2      |
    | 3      | 3      |
    | 4      | 4      |
    | 5      | 5      |
    | 6      | 6      |
    | 7      | 7      |
    | 8      | 8      |
    | 9      | 9      |

  Scenario: Clear button
    Given I just turned on the calculator
    When I press 2
    And I press clear
    Then the display should be empty

  Scenario: Addition button
    Given I just turned on the calculator
    When I press add
    Then the display should show +

  Scenario: Subtraction button
    Given I just turned on the calculator
    When I press subtract
    Then the display should show -

  Scenario Outline: Digit sequence
    Given I just turned on the calculator
    When I press <button1>
    And I press <button2>
    Then the display should show <output>

  Examples:
    | button1 | button2 | output |
    | 2       | 2       | 22     |
    | 7       | 4       | 74     |
    | 3       | 8       | 38     |

  Scenario Outline: Addition operation
    Given I just turned on the calculator
    When I press <button1>
	 And I press add
    And I press <button2>
    Then the display should show <output>

  Examples:
    | button1 | button2 | output |
    | 2       | 2       | 2+2    |
    | 7       | 4       | 7+4    |
    | 3       | 8       | 3+8    |


  Scenario Outline: Subtraction operation
    Given I just turned on the calculator
    When I press <button1>
	 And I press subtract
    And I press <button2>
    Then the display should show <output>

  Examples:
    | button1 | button2 | output |
    | 2       | 2       | 2-2    |
    | 7       | 4       | 7-4    |
    | 3       | 8       | 3-8    |



================================================
FILE: examples/CalcQt/features/initialization.feature
================================================
# language: en
Feature: GUI initalization
  test the initial status of the calculator

  Scenario: Initialization
    Given I just turned on the calculator
    Then the display should be empty



================================================
FILE: examples/CalcQt/features/step_definitions/BoostCalculatorQtSteps.cpp
================================================
#include <boost/test/unit_test.hpp>
// Pretend to be GTest
#define EXPECT_EQ BOOST_CHECK_EQUAL
#define ASSERT_TRUE BOOST_REQUIRE
#include "CalculatorQtSteps.cpp"


================================================
FILE: examples/CalcQt/features/step_definitions/CalculatorQtSteps.cpp
================================================
#include <cucumber-cpp/autodetect.hpp>

#include "Calculator.hpp"

class CalculatorCtx {
public:
    CalculatorCtx() {
        QObject::connect(&calculator, &Calculator::updateDisplay, [this](QString value) {
            display = value;
        });
    }

    Calculator calculator{};
    QString display{};
};

std::istream& operator>>(std::istream& in, QString& val) {
    std::string s;
    in >> s;
    val = s.c_str();
    return in;
}
std::ostream& operator<<(std::ostream& out, const QString& val) {
    out << val.toLatin1().data();
    return out;
}

GIVEN("^I just turned on the calculator$") {
    cucumber::ScenarioScope<CalculatorCtx> ctx;
}

WHEN("^I press (\\d+)$") {
    REGEX_PARAM(unsigned int, n);
    cucumber::ScenarioScope<CalculatorCtx> ctx;
    ctx->calculator.number(n);
}

WHEN("^I press add") {
    cucumber::ScenarioScope<CalculatorCtx> ctx;
    ctx->calculator.add();
}

WHEN("^I press calculate") {
    cucumber::ScenarioScope<CalculatorCtx> ctx;
    ctx->calculator.calculate();
}

WHEN("^I press clear") {
    cucumber::ScenarioScope<CalculatorCtx> ctx;
    ctx->calculator.clear();
}

WHEN("^I press subtract") {
    cucumber::ScenarioScope<CalculatorCtx> ctx;
    ctx->calculator.subtract();
}

THEN("^the display should be empty$") {
    cucumber::ScenarioScope<CalculatorCtx> ctx;
    EXPECT_EQ(QString{}, ctx->display);
}

THEN("^the display should show (.*)$") {
    REGEX_PARAM(QString, expected);
    cucumber::ScenarioScope<CalculatorCtx> ctx;
    EXPECT_EQ(expected, ctx->display);
}


================================================
FILE: examples/CalcQt/features/step_definitions/GTestCalculatorQtSteps.cpp
================================================
#include <gtest/gtest.h>
#include "CalculatorQtSteps.cpp"


================================================
FILE: examples/CalcQt/features/step_definitions/QtTestCalculatorQtSteps.cpp
================================================
#include <QTest>
// Pretend to be GTest
#define EXPECT_EQ QCOMPARE
#define ASSERT_TRUE QVERIFY
#include "CalculatorQtSteps.cpp"


================================================
FILE: examples/CalcQt/features/step_definitions/cucumber.wire
================================================
host: localhost
port: 3902


================================================
FILE: examples/CalcQt/features/subtraction.feature
================================================
# language: en
Feature: Subtraction
  In order to avoid silly mistakes
  As a math idiot 
  I want to be told the difference of two numbers

  Scenario Outline: Subtract two numbers
    Given I just turned on the calculator
    When I press <button1>
    And I press subtract
    And I press <button2>
    And I press calculate
    Then the display should show <result>

  Examples:
    | button1 | button2 | result |
    | 2       | 3       | -1     |
    | 7       | 5       | 2      |
    | 9       | 1       | 8      |


================================================
FILE: examples/CalcQt/src/CalcQt.cpp
================================================
#include <QApplication>

#include "Calculator.hpp"
#include "CalculatorWidget.hpp"

int main(int argc, char* argv[]) {
    QApplication app(argc, argv);
    app.setApplicationName("Qt Calculator");
    Calculator calculator{};
    CalculatorWidget widget{&calculator};
    widget.show();
    return app.exec();
}


================================================
FILE: examples/CalcQt/src/Calculator.cpp
================================================
#include "Calculator.hpp"

#include <QRegularExpression>

QString Calculator::calculate(const QString& expression) const {
    int result = 0;
    char operation = '+';
    const QRegularExpression regexp("(\\d+)");
    QRegularExpressionMatchIterator matches = regexp.globalMatch(expression);

    while (matches.hasNext()) {
        const auto match = matches.next();
        const int value = match.captured(1).toInt();

        switch (operation) {
        case '+':
            result += value;
            break;
        case '-':
            result -= value;
            break;
        }

        const int pos = match.capturedEnd();
        if (pos < expression.length()) {
            operation = expression.at(pos).toLatin1();
        }
    }

    return QString::number(result);
}

void Calculator::number(quint8 number) {
    expression += QString::number(number);
    emit updateDisplay(expression);
}

void Calculator::add() {
    expression += "+";
    emit updateDisplay(expression);
}

void Calculator::subtract() {
    expression += "-";
    emit updateDisplay(expression);
}

void Calculator::calculate() {
    expression = calculate(expression);
    emit updateDisplay(expression);
}

void Calculator::clear() {
    expression.clear();
    emit updateDisplay(expression);
}


================================================
FILE: examples/CalcQt/src/Calculator.hpp
================================================
#pragma once

#include <QObject>

class Calculator : public QObject {
    Q_OBJECT

public:
    using QObject::QObject;

public slots:
    void number(quint8);
    void add();
    void subtract();
    void calculate();
    void clear();

signals:
    void updateDisplay(QString);

private:
    QString expression{};
    QString calculate(const QString& expression) const;
};


================================================
FILE: examples/CalcQt/src/CalculatorWidget.cpp
================================================
#include "CalculatorWidget.hpp"

#include "Calculator.hpp"
#include <QGridLayout>
#include <QKeyEvent>
#include <QLabel>
#include <QPushButton>

CalculatorWidget::CalculatorWidget(Calculator* calculator, QWidget* parent) :
    QWidget(parent) {
    QGridLayout* layout = new QGridLayout(this);
    layout->setSizeConstraint(QLayout::SetFixedSize);
    setLayout(layout);

    QSizePolicy policy = sizePolicy();

    displayLabel = new QLabel(this);
    layout->addWidget(displayLabel, 0, 0, 1, 3);
    displayLabel->setAutoFillBackground(true);
    displayLabel->setBackgroundRole(QPalette::Base);
    displayLabel->setAlignment(Qt::AlignRight);
    policy = displayLabel->sizePolicy();
    policy.setVerticalPolicy(QSizePolicy::Fixed);
    displayLabel->setSizePolicy(policy);
    QObject::connect(calculator, &Calculator::updateDisplay, displayLabel, &QLabel::setText);

    QPushButton* button = new QPushButton(QString::number(0), this);
    QObject::connect(button, &QPushButton::clicked, calculator, [calculator] {
        calculator->number(0);
    });
    layout->addWidget(button, 4, 1);
    digitButtons.push_back(button);
    for (unsigned int i = 1; i < 10; ++i) {
        QPushButton* button = new QPushButton(QString::number(i), this);
        QObject::connect(button, &QPushButton::clicked, calculator, [i, calculator] {
            calculator->number(i);
        });
        layout->addWidget(button, 1 + (9 - i) / 3, (i - 1) % 3);
        digitButtons.push_back(button);
    }

    clearButton = new QPushButton("C", this);
    layout->addWidget(clearButton, 1, 4);
    QObject::connect(clearButton, &QPushButton::clicked, calculator, [calculator] {
        calculator->clear();
    });

    additionButton = new QPushButton("+", this);
    layout->addWidget(additionButton, 2, 4);
    QObject::connect(additionButton, &QPushButton::clicked, calculator, [calculator] {
        calculator->add();
    });

    subtractionButton = new QPushButton("-", this);
    layout->addWidget(subtractionButton, 3, 4);
    QObject::connect(subtractionButton, &QPushButton::clicked, calculator, [calculator] {
        calculator->subtract();
    });

    calculateButton = new QPushButton("=", this);
    layout->addWidget(calculateButton, 4, 4);
    QObject::connect(calculateButton, &QPushButton::clicked, calculator, [calculator] {
        calculator->calculate();
    });
}

void CalculatorWidget::keyPressEvent(QKeyEvent* event) {
    keyclickedButton = nullptr;
    int key = event->key();
    if (key >= Qt::Key_0 && key <= Qt::Key_9) {
        keyclickedButton = digitButtons[key - Qt::Key_0];
    } else {
        switch (key) {
        case Qt::Key_Plus:
            keyclickedButton = additionButton;
            break;
        case Qt::Key_Minus:
            keyclickedButton = subtractionButton;
            break;
        case Qt::Key_Return:
        case Qt::Key_Enter:
        case Qt::Key_Equal:
            keyclickedButton = calculateButton;
            break;
        case Qt::Key_Escape:
            keyclickedButton = clearButton;
            break;
        }
    }
    if (keyclickedButton) {
        keyclickedButton->click();
        keyclickedButton->setDown(true);
    }
}

void CalculatorWidget::keyReleaseEvent(QKeyEvent* event) {
    Q_UNUSED(event)
    if (keyclickedButton) {
        keyclickedButton->setDown(false);
        keyclickedButton = nullptr;
    }
}

void CalculatorWidget::updateDisplay(QString text) {
    displayLabel->setText(text);
}


================================================
FILE: examples/CalcQt/src/CalculatorWidget.hpp
================================================
#pragma once

class QLabel;
class QPushButton;
class Calculator;

#include <QString>
#include <QWidget>

class CalculatorWidget : public QWidget {
    Q_OBJECT

public:
    CalculatorWidget(Calculator* calculator, QWidget* parent = 0);

protected:
    void keyPressEvent(QKeyEvent* event) override;
    void keyReleaseEvent(QKeyEvent* event) override;

private:
    QLabel* displayLabel;
    QVector<QPushButton*> digitButtons;
    QPushButton* additionButton;
    QPushButton* calculateButton;
    QPushButton* clearButton;
    QPushButton* subtractionButton;

    QPushButton* keyclickedButton{};

private Q_SLOTS:
    void updateDisplay(QString);
};


================================================
FILE: examples/FeatureShowcase/CMakeLists.txt
================================================
project(FeatureShowcase)

if(TARGET GTest::gtest)
    function(add_cucumber_executable)
        add_executable(FeatureShowcaseSteps ${ARGV})
        target_link_libraries(FeatureShowcaseSteps PRIVATE cucumber-cpp GTest::gtest)
        foreach(_arg ${ARGN})
            get_filename_component(OBJECT_PREFIX ${_arg} NAME_WE)
            set_source_files_properties(${_arg} PROPERTIES COMPILE_FLAGS "-DCUKE_OBJECT_PREFIX=${OBJECT_PREFIX}")
        endforeach(_arg)
    endfunction()

    add_cucumber_executable(
        features/step_definitions/TagSteps.cpp
        features/step_definitions/TableSteps.cpp
    )
endif()



================================================
FILE: examples/FeatureShowcase/README.txt
================================================
This sample shows a few advanced features: tags and table arguments.



================================================
FILE: examples/FeatureShowcase/features/step_definitions/TableSteps.cpp
================================================
#include <gtest/gtest.h>
#include <cucumber-cpp/autodetect.hpp>

#include <string>
#include <map>

using cucumber::ScenarioScope;

class ActiveActors {
public:
    typedef std::string actor_name_type;
    typedef unsigned short actor_year_type;

private:
    typedef std::map<actor_name_type, actor_year_type> actors_type;

    actors_type actors;

public:
    void addActor(const actor_name_type name, const actor_year_type year) {
        actors[name] = year;
    }

    void retireActor(const actor_name_type name) {
        actors.erase(actors.find(name));
    }

    actor_name_type getOldestActor() {
        actors_type::iterator it = actors.begin();
        actor_name_type name = it->first;
        actor_year_type year = it->second;
        while (++it != actors.end()) {
            actor_year_type currentYear = it->second;
            if (year > currentYear) {
                name = it->first;
            }
        }
        return name;
    }
};

GIVEN("^the following actors are still active") {
    TABLE_PARAM(actorsParam);
    ScenarioScope<ActiveActors> context;

    const table_hashes_type& actors = actorsParam.hashes();
    for (table_hashes_type::const_iterator ait = actors.begin(); ait != actors.end(); ++ait) {
        std::string name(ait->at("name"));
        std::string yearString(ait->at("born"));
        const ActiveActors::actor_year_type year
            = ::cucumber::internal::fromString<ActiveActors::actor_year_type>(yearString);
        context->addActor(name, year);
    }
}

WHEN("^(.+) retires") {
    REGEX_PARAM(std::string, retiringActor);
    ScenarioScope<ActiveActors> context;

    context->retireActor(retiringActor);
}

THEN("^the oldest actor should be (.+)$") {
    REGEX_PARAM(std::string, oldestActor);
    ScenarioScope<ActiveActors> context;

    ASSERT_EQ(oldestActor, context->getOldestActor());
}


================================================
FILE: examples/FeatureShowcase/features/step_definitions/TagSteps.cpp
================================================
#include <gtest/gtest.h>
#include <cucumber-cpp/autodetect.hpp>

#include <iostream>

using std::cout;
using std::endl;
using std::string;

BEFORE_ALL() {
    cout << "-------------------- (Before all scenarios)" << endl;
}

AFTER_ALL() {
    cout << "-------------------- (After all scenarios)" << endl;
}

BEFORE() {
    cout << "-------------------- (Before any scenario)" << endl;
}

BEFORE("@foo,@bar", "@baz") {
    cout << "Before scenario (\"@foo,@baz\",\"@bar\")" << endl;
}

AROUND_STEP("@baz") {
    cout << "Around step (\"@baz\") ...before" << endl;
    step->call();
    cout << "Around step (\"@baz\") ..after" << endl;
}

AFTER_STEP("@bar") {
    cout << "After step (\"@bar\")" << endl;
}

AFTER("@foo") {
    cout << "After scenario (\"@foo\")" << endl;
}

AFTER("@gherkin") {
    cout << "After scenario (\"@gherkin\")" << endl;
}

/*
 * CUKE_STEP_ is used just because the feature does not convey any
 * business value. It should NEVER be used in real step definitions!
 */

CUKE_STEP_("^I'm running a step from a scenario not tagged$") {
    cout << "Running step from scenario without tags" << endl;
    EXPECT_TRUE(true); // To fix a problem at link time
}

CUKE_STEP_("^I'm running a step from a scenario tagged with (.*)$") {
    REGEX_PARAM(string, tags);
    cout << "Running step from scenario with tags: " << tags << endl;
    EXPECT_TRUE(true); // To fix a problem at link time
}


================================================
FILE: examples/FeatureShowcase/features/step_definitions/cucumber.wire
================================================
host: localhost
port: 3902


================================================
FILE: examples/FeatureShowcase/features/table.feature
================================================
# language: en
Feature: Table
  In order to explain how to use tables
  I have to make this silly example

  Scenario: No tag
    Given the following actors are still active:
      | name           | born |
      | Al Pacino      | 1940 |
      | Robert De Niro | 1943 |
      | George Clooney | 1961 |
      | Morgan Freeman | 1937 |
    When Morgan Freeman retires
    Then the oldest actor should be Al Pacino


================================================
FILE: examples/FeatureShowcase/features/tag.feature
================================================
# language: en
Feature: Tags
  In order to explain how to use tags
  I have to make this silly example

  Scenario: No tag
    Given I'm running a step from a scenario not tagged
    When I'm running a step from a scenario not tagged
    Then I'm running a step from a scenario not tagged

  @foo
  Scenario: Foo
    Given I'm running a step from a scenario tagged with @foo
    When I'm running a step from a scenario tagged with @foo
    Then I'm running a step from a scenario tagged with @foo

  @bar
  Scenario: Bar
    Given I'm running a step from a scenario tagged with @bar
    When I'm running a step from a scenario tagged with @bar
    Then I'm running a step from a scenario tagged with @bar

  @baz
  Scenario: Baz
    Given I'm running a step from a scenario tagged with @baz
    When I'm running a step from a scenario tagged with @baz
    Then I'm running a step from a scenario tagged with @baz

  @bar @foo
  Scenario: Bar and Foo
    Given I'm running a step from a scenario tagged with @bar,@foo
    When I'm running a step from a scenario tagged with @bar,@foo
    Then I'm running a step from a scenario tagged with @bar,@foo

  @pickle
  Scenario: Pickle
    Given I'm running a step from a scenario tagged with @pickle
    When I'm running a step from a scenario tagged with @pickle
    Then I'm running a step from a scenario tagged with @pickle


================================================
FILE: include/cucumber-cpp/autodetect.hpp
================================================
#include "internal/defs.hpp"
#ifndef STEP_INHERITANCE
    #error No test framework found: please include a testing framework before autodetect.hpp or include generic.hpp
#endif


================================================
FILE: include/cucumber-cpp/defs.hpp
================================================
#ifdef __GNUC__
    #warning "Use of defs.hpp is deprecated, please use either autodetect.hpp or generic.hpp"
#else
    #pragma message(                                                                     \
        "Use of defs.hpp is deprecated, please use either autodetect.hpp or generic.hpp" \
    )
#endif
#include "internal/defs.hpp"
#ifndef STEP_INHERITANCE
    #include "internal/drivers/GenericDriver.hpp"
#endif


================================================
FILE: include/cucumber-cpp/generic.hpp
================================================
#include "internal/defs.hpp"
#ifdef STEP_INHERITANCE
    #error Test framework found: please include autodetect.hpp or remove the test framework includes
#else
    #include "internal/drivers/GenericDriver.hpp"
#endif


================================================
FILE: include/cucumber-cpp/internal/ContextManager.hpp
================================================
#ifndef CUKE_CONTEXTMANAGER_HPP_
#define CUKE_CONTEXTMANAGER_HPP_

#include <cucumber-cpp/internal/CukeExport.hpp>

#include <vector>

#include <memory>

namespace cucumber {

namespace internal {

typedef std::vector<std::shared_ptr<void>> contexts_type;

class CUCUMBER_CPP_EXPORT ContextManager {
public:
    void purgeContexts();
    template<class T>
    std::weak_ptr<T> addContext();

protected:
    static contexts_type contexts;
};

template<class T>
std::weak_ptr<T> ContextManager::addContext() {
    std::shared_ptr<T> shared(std::make_shared<T>());
    contexts.push_back(shared);
    return std::weak_ptr<T>(shared);
}

}

template<class T>
class ScenarioScope {
public:
    ScenarioScope();

    T& operator*();
    T* operator->();
    T* get();

private:
    internal::ContextManager contextManager;
    std::shared_ptr<T> context;
    static std::weak_ptr<T> contextReference;
};

template<class T>
std::weak_ptr<T> ScenarioScope<T>::contextReference;

template<class T>
ScenarioScope<T>::ScenarioScope() {
    if (contextReference.expired()) {
        contextReference = contextManager.addContext<T>();
    }
    context = contextReference.lock();
}

template<class T>
T& ScenarioScope<T>::operator*() {
    return *(context.get());
}

template<class T>
T* ScenarioScope<T>::operator->() {
    return (context.get());
}

template<class T>
T* ScenarioScope<T>::get() {
    return context.get();
}

}

#endif /* CUKE_CONTEXTMANAGER_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/CukeCommands.hpp
================================================
#ifndef CUKE_CUKECOMMANDS_HPP_
#define CUKE_CUKECOMMANDS_HPP_

#include "ContextManager.hpp"
#include <cucumber-cpp/internal/CukeExport.hpp>
#include "Scenario.hpp"
#include "Table.hpp"
#include "step/StepManager.hpp"

#include <map>
#include <string>
#include <sstream>

#include <memory>

namespace cucumber {
namespace internal {

/**
 * Legacy class to be removed when feature #31 is complete, substituted by CukeEngineImpl.
 */
class CUCUMBER_CPP_EXPORT CukeCommands {
public:
    CukeCommands();
    virtual ~CukeCommands();

    void beginScenario(const TagExpression::tag_list& tags = TagExpression::tag_list());
    void endScenario();
    const std::string snippetText(const std::string stepKeyword, const std::string stepName) const;
    MatchResult stepMatches(const std::string description) const;
    InvokeResult invoke(step_id_type id, const InvokeArgs* pArgs);

protected:
    const std::string escapeRegex(const std::string regex) const;
    const std::string escapeCString(const std::string str) const;

private:
    ContextManager contextManager;
    bool hasStarted;

private:
    static std::shared_ptr<Scenario> currentScenario;
};

}
}

#endif /* CUKE_CUKECOMMANDS_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/CukeEngine.hpp
================================================
#ifndef CUKE_CUKEENGINE_HPP_
#define CUKE_CUKEENGINE_HPP_

#include <cstddef>
#include <string>
#include <vector>

#include <cucumber-cpp/internal/CukeExport.hpp>

namespace cucumber {
namespace internal {

class CUCUMBER_CPP_EXPORT StepMatchArg {
public:
    std::string value;
    std::ptrdiff_t position;
};

class CUCUMBER_CPP_EXPORT StepMatch {
public:
    std::string id;
    std::vector<StepMatchArg> args;
    std::string source;
    std::string regexp;
};

class CUCUMBER_CPP_EXPORT InvokeException {
private:
    const std::string message;

public:
    InvokeException(const std::string& message);
    InvokeException(const InvokeException& rhs);

    const std::string getMessage() const;

    virtual ~InvokeException() = default;
};

class CUCUMBER_CPP_EXPORT InvokeFailureException : public InvokeException {
private:
    const std::string exceptionType;

public:
    InvokeFailureException(const std::string& message, const std::string& exceptionType);
    InvokeFailureException(const InvokeFailureException& rhs);

    const std::string getExceptionType() const;
};

class CUCUMBER_CPP_EXPORT PendingStepException : public InvokeException {
public:
    PendingStepException(const std::string& message);
    PendingStepException(const PendingStepException& rhs);
};

/**
 * The entry point to Cucumber.
 *
 * It uses standard types (as much as possible) to be easier to call.
 * Returns standard types if possible.
 */
class CukeEngine {
private:
    typedef std::vector<std::string> string_array;
    typedef std::vector<std::vector<std::string>> string_2d_array;

public:
    typedef string_array tags_type;
    typedef string_array invoke_args_type;
    typedef string_2d_array invoke_table_type;

    /**
     * Finds steps whose regexp match some text.
     */
    virtual std::vector<StepMatch> stepMatches(const std::string& name) const = 0;

    /**
     * Starts a scenario.
     */
    virtual void beginScenario(const tags_type& tags) = 0;

    /**
     * Invokes a step passing arguments to it.
     *
     * @throws InvokeException if the test fails or it is pending
     */
    virtual void invokeStep(
        const std::string& id, const invoke_args_type& args, const invoke_table_type& tableArg
    ) = 0;

    /**
     * Ends a scenario.
     */
    virtual void endScenario(const tags_type& tags) = 0;

    /**
     * Returns the step definition for a pending step.
     */
    virtual std::string snippetText(
        const std::string& keyword, const std::string& name, const std::string& multilineArgClass
    ) const
        = 0;

    CUCUMBER_CPP_EXPORT CukeEngine();
    CUCUMBER_CPP_EXPORT virtual ~CukeEngine() = default;
};

}
}

#endif /* CUKE_CUKEENGINE_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/CukeEngineImpl.hpp
================================================
#ifndef CUKE_CUKEENGINE_IMPL_HPP_
#define CUKE_CUKEENGINE_IMPL_HPP_

#include "CukeEngine.hpp"
#include <cucumber-cpp/internal/CukeExport.hpp>
#include "CukeCommands.hpp"

namespace cucumber {
namespace internal {

/**
 * Default Engine Implementation
 *
 * Currently it is a wrapper around CukeCommands. It will have its own
 * implementation when feature #31 is complete.
 */
class CUCUMBER_CPP_EXPORT CukeEngineImpl : public CukeEngine {
private:
    CukeCommands cukeCommands;

public:
    std::vector<StepMatch> stepMatches(const std::string& name) const override;
    void beginScenario(const tags_type& tags) override;
    void invokeStep(
        const std::string& id, const invoke_args_type& args, const invoke_table_type& tableArg
    ) override;
    void endScenario(const tags_type& tags) override;
    std::string snippetText(
        const std::string& keyword, const std::string& name, const std::string& multilineArgClass
    ) const override;
};

}
}

#endif /* CUKE_CUKEENGINE_IMPL_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/Macros.hpp
================================================
#ifndef CUKE_MACROS_HPP_
#define CUKE_MACROS_HPP_

#include "RegistrationMacros.hpp"
#include "step/StepMacros.hpp"
#include "hook/HookMacros.hpp"

#endif /* CUKE_MACROS_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/RegistrationMacros.hpp
================================================
#ifndef CUKE_REGISTRATIONMACROS_HPP_
#define CUKE_REGISTRATIONMACROS_HPP_

// ************************************************************************** //
// **************            OBJECT NAMING MACROS              ************** //
// ************************************************************************** //

// from https://www.boost.org/doc/libs/1_84_0/boost/config/helper_macros.hpp
#define CUKE_JOIN(X, Y) CUKE_DO_JOIN(X, Y)
#define CUKE_DO_JOIN(X, Y) CUKE_DO_JOIN2(X, Y)
#define CUKE_DO_JOIN2(X, Y) X##Y

#ifndef CUKE_OBJECT_PREFIX
    #define CUKE_OBJECT_PREFIX CukeObject
#endif

#ifdef __COUNTER__
    #define CUKE_GEN_OBJECT_NAME_ CUKE_JOIN(CUKE_OBJECT_PREFIX, __COUNTER__)
#else
    // Use a counter to be incremented every time cucumber-cpp is included
    // in case this does not suffice (possible with multiple files only)
    #define CUKE_GEN_OBJECT_NAME_ CUKE_JOIN(CUKE_OBJECT_PREFIX, __LINE__)
#endif

// ************************************************************************** //
// **************                 CUKE OBJECTS                 ************** //
// ************************************************************************** //

#define CUKE_OBJECT_(class_name, parent_class, registration_fn, args)                     \
    class class_name : public parent_class {                                              \
    public:                                                                               \
        void body() override { return invokeWithArgs(*this, &class_name::bodyWithArgs); } \
        void bodyWithArgs args;                                                           \
                                                                                          \
    private:                                                                              \
        static const int cukeRegId;                                                       \
    };                                                                                    \
    const int class_name ::cukeRegId = registration_fn;                                   \
    void class_name ::bodyWithArgs args /**/

#endif /* CUKE_REGISTRATIONMACROS_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/Scenario.hpp
================================================
#ifndef CUKE_SCENARIO_HPP_
#define CUKE_SCENARIO_HPP_

#include "hook/Tag.hpp"

namespace cucumber {
namespace internal {

class Scenario {
public:
    Scenario(const TagExpression::tag_list& tags = TagExpression::tag_list());

    const TagExpression::tag_list& getTags();

private:
    const TagExpression::tag_list tags;
};

}
}

#endif /* CUKE_SCENARIO_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/Table.hpp
================================================
#ifndef CUKE_TABLE_HPP_
#define CUKE_TABLE_HPP_

#include <cucumber-cpp/internal/CukeExport.hpp>

#include <vector>
#include <map>
#include <string>
#include <stdexcept>

namespace cucumber {
namespace internal {

class CUCUMBER_CPP_EXPORT Table {
private:
    typedef std::vector<std::string> basic_type;

public:
    typedef std::map<std::string, std::string> hash_row_type;
    typedef basic_type columns_type;
    typedef basic_type row_type;
    typedef std::vector<hash_row_type> hashes_type;

    /**
     * @brief addColumn
     * @param column
     *
     * @throws std::runtime_error
     */
    void addColumn(const std::string column);

    /**
     * @brief addRow
     * @param row
     *
     * @throws std::range_error
     * @throws std::runtime_error
     */
    void addRow(const row_type& row);
    const hashes_type& hashes() const;

private:
    hash_row_type buildHashRow(const row_type& row);

    columns_type columns;
    hashes_type rows;
};

}
}

#endif /* CUKE_TABLE_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/connectors/wire/ProtocolHandler.hpp
================================================
#ifndef CUKE_PROTOCOLHANDLER_HPP_
#define CUKE_PROTOCOLHANDLER_HPP_

#include <string>

namespace cucumber {
namespace internal {

/**
 * Protocol that reads one command for each input line.
 */
class ProtocolHandler {
public:
    virtual std::string handle(const std::string& request) const = 0;
    virtual ~ProtocolHandler() = default;
};

}
}

#endif /* CUKE_PROTOCOLHANDLER_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/connectors/wire/WireProtocol.hpp
================================================
#ifndef CUKE_WIREPROTOCOL_HPP_
#define CUKE_WIREPROTOCOL_HPP_

#include <cucumber-cpp/internal/CukeExport.hpp>
#include "ProtocolHandler.hpp"
#include "../../CukeEngine.hpp"

#include <memory>

namespace cucumber {
namespace internal {

/*
 * Response messages
 */

class WireResponseVisitor;

class CUCUMBER_CPP_EXPORT WireResponse {
public:
    WireResponse(){};

    virtual void accept(WireResponseVisitor& visitor) const = 0;

    virtual ~WireResponse() = default;
};

class CUCUMBER_CPP_EXPORT SuccessResponse : public WireResponse {
public:
    void accept(WireResponseVisitor& visitor) const override;
};

class CUCUMBER_CPP_EXPORT FailureResponse : public WireResponse {
private:
    const std::string message, exceptionType;

public:
    FailureResponse(const std::string& message = "", const std::string& exceptionType = "");

    const std::string getMessage() const;
    const std::string getExceptionType() const;

    void accept(WireResponseVisitor& visitor) const override;
};

class CUCUMBER_CPP_EXPORT PendingResponse : public WireResponse {
private:
    const std::string message;

public:
    PendingResponse(const std::string& message);

    const std::string getMessage() const;

    void accept(WireResponseVisitor& visitor) const override;
};

class CUCUMBER_CPP_EXPORT StepMatchesResponse : public WireResponse {
private:
    const std::vector<StepMatch> matchingSteps;

public:
    StepMatchesResponse(const std::vector<StepMatch>& matchingSteps);
    const std::vector<StepMatch>& getMatchingSteps() const;

    void accept(WireResponseVisitor& visitor) const override;
};

class CUCUMBER_CPP_EXPORT SnippetTextResponse : public WireResponse {
private:
    const std::string stepSnippet;

public:
    SnippetTextResponse(const std::string& stepSnippet);

    const std::string getStepSnippet() const;

    void accept(WireResponseVisitor& visitor) const override;
};

class CUCUMBER_CPP_EXPORT WireResponseVisitor {
public:
    virtual void visit(const SuccessResponse& response) = 0;
    virtual void visit(const FailureResponse& response) = 0;
    virtual void visit(const PendingResponse& response) = 0;
    virtual void visit(const StepMatchesResponse& response) = 0;
    virtual void visit(const SnippetTextResponse& response) = 0;

    virtual ~WireResponseVisitor() = default;
};

/**
 * Wire protocol request command.
 */
class CUCUMBER_CPP_EXPORT WireCommand {
public:
    /**
     * Runs the command on the provided engine
     *
     * @param The engine
     *
     * @return The command response (ownership passed to the caller)
     */
    virtual std::shared_ptr<WireResponse> run(CukeEngine& engine) const = 0;

    virtual ~WireCommand() = default;
};

class CUCUMBER_CPP_EXPORT WireMessageCodecException : public std::exception {
private:
    const char* description;

public:
    WireMessageCodecException(const char* description) :
        description(description) {
    }

    const char* what() const throw() override {
        return description;
    }
};

/**
 * Transforms wire messages into commands and responses to messages.
 */
class CUCUMBER_CPP_EXPORT WireMessageCodec {
public:
    /**
     * Decodes a wire message into a command.
     *
     * @param One single message to decode
     *
     * @return The decoded command (ownership passed to the caller)
     *
     * @throws WireMessageCodecException
     */
    virtual std::shared_ptr<WireCommand> decode(const std::string& request) const = 0;

    /**
     * Encodes a response to wire format.
     *
     * @param Response to encode
     *
     * @return The encoded string
     */
    virtual const std::string encode(const WireResponse& response) const = 0;

    virtual ~WireMessageCodec() = default;
};

/**
 * WireMessageCodec implementation with Json.
 */
class CUCUMBER_CPP_EXPORT JsonWireMessageCodec : public WireMessageCodec {
public:
    JsonWireMessageCodec() = default;
    std::shared_ptr<WireCommand> decode(const std::string& request) const override;
    const std::string encode(const WireResponse& response) const override;
};

/**
 * Wire protocol handler, delegating JSON encoding and decoding to a
 * codec object and running commands on a provided engine instance.
 */
class CUCUMBER_CPP_EXPORT WireProtocolHandler : public ProtocolHandler {
private:
    const WireMessageCodec& codec;
    CukeEngine& engine;

public:
    WireProtocolHandler(const WireMessageCodec& codec, CukeEngine& engine);

    std::string handle(const std::string& request) const override;
};

}
}

#endif /* CUKE_WIREPROTOCOL_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/connectors/wire/WireProtocolCommands.hpp
================================================
#ifndef CUKE_WIREPROTOCOL_COMMANDS_HPP_
#define CUKE_WIREPROTOCOL_COMMANDS_HPP_

#include "WireProtocol.hpp"
#include <memory>

namespace cucumber {
namespace internal {

class ScenarioCommand : public WireCommand {
protected:
    const CukeEngine::tags_type tags;

    ScenarioCommand(const CukeEngine::tags_type& tags);
};

class BeginScenarioCommand : public ScenarioCommand {
public:
    BeginScenarioCommand(const CukeEngine::tags_type& tags);

    std::shared_ptr<WireResponse> run(CukeEngine& engine) const override;
};

class EndScenarioCommand : public ScenarioCommand {
public:
    EndScenarioCommand(const CukeEngine::tags_type& tags);

    std::shared_ptr<WireResponse> run(CukeEngine& engine) const override;
};

class StepMatchesCommand : public WireCommand {
private:
    const std::string stepName;

public:
    StepMatchesCommand(const std::string& stepName);

    std::shared_ptr<WireResponse> run(CukeEngine& engine) const override;
};

class InvokeCommand : public WireCommand {
private:
    const std::string stepId;
    const CukeEngine::invoke_args_type args;
    const CukeEngine::invoke_table_type tableArg;

public:
    InvokeCommand(
        const std::string& stepId,
        const CukeEngine::invoke_args_type& args,
        const CukeEngine::invoke_table_type& tableArg
    );

    std::shared_ptr<WireResponse> run(CukeEngine& engine) const override;
};

class SnippetTextCommand : public WireCommand {
private:
    std::string keyword, name, multilineArgClass;

public:
    SnippetTextCommand(
        const std::string& keyword, const std::string& name, const std::string& multilineArgClass
    );

    std::shared_ptr<WireResponse> run(CukeEngine& engine) const override;
};

class FailingCommand : public WireCommand {
public:
    std::shared_ptr<WireResponse> run(CukeEngine& engine) const override;
};

}
}

#endif /* CUKE_WIREPROTOCOL_COMMANDS_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/connectors/wire/WireServer.hpp
================================================
#ifndef CUKE_WIRESERVER_HPP_
#define CUKE_WIRESERVER_HPP_

#include <cucumber-cpp/internal/CukeExport.hpp>
#include "ProtocolHandler.hpp"

#include <string>

#include <asio.hpp>

namespace cucumber {
namespace internal {

/**
 * Socket server that calls a protocol handler line by line
 */
class CUCUMBER_CPP_EXPORT SocketServer {
public:
    /**
     * Constructor for DI
     */
    SocketServer(const ProtocolHandler* protocolHandler);
    virtual ~SocketServer() = default;

    /**
     * Accept one connection
     */
    virtual void acceptOnce() = 0;

protected:
    const ProtocolHandler* protocolHandler;
    asio::io_context ios;

    template<typename Protocol>
    void doListen(
        asio::basic_socket_acceptor<Protocol>& acceptor, const typename Protocol::endpoint& endpoint
    );
    template<typename Protocol>
    void doAcceptOnce(asio::basic_socket_acceptor<Protocol>& acceptor);
    void processStream(std::iostream& stream);
};

/**
 * Socket server that calls a protocol handler line by line
 */
class CUCUMBER_CPP_EXPORT TCPSocketServer : public SocketServer {
public:
    /**
     * Type definition for TCP port
     */
    typedef unsigned short port_type;

    /**
     * Constructor for DI
     */
    TCPSocketServer(const ProtocolHandler* protocolHandler);

    /**
     * Bind and listen to a TCP port
     */
    void listen(const port_type port);

    /**
     * Bind and listen to a TCP port on the given endpoint
     */
    void listen(const asio::ip::tcp::endpoint endpoint);

    /**
     * Endpoint (IP address and port number) that this server is currently
     * listening on.
     *
     * @throw std::system_error when not listening on any socket or
     *        the endpoint cannot be determined.
     */
    asio::ip::tcp::endpoint listenEndpoint() const;

    void acceptOnce() override;

private:
    asio::ip::tcp::acceptor acceptor;
};

#if defined(ASIO_HAS_LOCAL_SOCKETS)
/**
 * Socket server that calls a protocol handler line by line
 */
class CUCUMBER_CPP_EXPORT UnixSocketServer : public SocketServer {
public:
    /**
     * Constructor for DI
     */
    UnixSocketServer(const ProtocolHandler* protocolHandler);

    /**
     * Bind and listen on a local stream socket
     */
    void listen(const std::string& unixPath);

    /**
     * Port number that this server is currently listening on.
     *
     * @throw std::system_error when not listening on any socket or
     *        the endpoint cannot be determined.
     */
    asio::local::stream_protocol::endpoint listenEndpoint() const;

    void acceptOnce() override;

    ~UnixSocketServer() override;

private:
    asio::local::stream_protocol::acceptor acceptor;
};
#endif

}
}

#endif /* CUKE_WIRESERVER_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/defs.hpp
================================================
#include "step/StepManager.hpp"
#include "hook/HookRegistrar.hpp"
#include "ContextManager.hpp"
#include "Macros.hpp"
#include "drivers/DriverSelector.hpp"


================================================
FILE: include/cucumber-cpp/internal/drivers/BoostDriver.hpp
================================================
#ifndef CUKE_BOOSTDRIVER_HPP_
#define CUKE_BOOSTDRIVER_HPP_

#include "../step/StepManager.hpp"
#include <cucumber-cpp/internal/CukeExport.hpp>

namespace cucumber {
namespace internal {

class CukeBoostLogInterceptor;

class CUCUMBER_CPP_EXPORT BoostStep : public BasicStep {
protected:
    const InvokeResult invokeStepBody() override;

private:
    static void initBoostTest();
    void runWithMasterSuite();
};

#define STEP_INHERITANCE(step_name) ::cucumber::internal::BoostStep

}
}

#endif /* CUKE_BOOSTDRIVER_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/drivers/DriverSelector.hpp
================================================
#if defined(GTEST_INCLUDE_GTEST_GTEST_H_) || defined(GOOGLETEST_INCLUDE_GTEST_GTEST_H_)
    #include "GTestDriver.hpp"
#elif defined(BOOST_TEST_CASE)
    #include "BoostDriver.hpp"
#elif defined(QTEST_H)
    #include "QtTestDriver.hpp"
#endif


================================================
FILE: include/cucumber-cpp/internal/drivers/GTestDriver.hpp
================================================
#ifndef CUKE_GTESTDRIVER_HPP_
#define CUKE_GTESTDRIVER_HPP_

#include <cucumber-cpp/internal/CukeExport.hpp>
#include "../step/StepManager.hpp"

#include <iostream>

namespace cucumber {
namespace internal {

class CUCUMBER_CPP_EXPORT GTestStep : public BasicStep {
protected:
    const InvokeResult invokeStepBody() override;

private:
    void initGTest();
    void initFlags();

protected:
    static bool initialized;
};

#define STEP_INHERITANCE(step_name) ::cucumber::internal::GTestStep

}
}

#endif /* CUKE_GTESTDRIVER_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/drivers/GenericDriver.hpp
================================================
#ifndef CUKE_GENERICDRIVER_HPP_
#define CUKE_GENERICDRIVER_HPP_

#include "../step/StepManager.hpp"
#include <cucumber-cpp/internal/CukeExport.hpp>

namespace cucumber {
namespace internal {

class CUCUMBER_CPP_EXPORT GenericStep : public BasicStep {
protected:
    const InvokeResult invokeStepBody() override;
};

#define STEP_INHERITANCE(step_name) virtual ::cucumber::internal::GenericStep

}
}

#endif /* CUKE_GENERICDRIVER_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/drivers/QtTestDriver.hpp
================================================
#ifndef CUKE_QTTESTDRIVER_HPP_
#define CUKE_QTTESTDRIVER_HPP_

#include "../step/StepManager.hpp"
#include <cucumber-cpp/internal/CukeExport.hpp>
#include <QObject>

namespace cucumber {
namespace internal {

class CUCUMBER_CPP_EXPORT QtTestStep : public BasicStep {
    friend class QtTestObject;

public:
    QtTestStep() :
        BasicStep() {
    }

protected:
    const InvokeResult invokeStepBody() override;
};

#define STEP_INHERITANCE(step_name) ::cucumber::internal::QtTestStep

class QtTestObject : public QObject {
    Q_OBJECT
public:
    QtTestObject(QtTestStep* qtTestStep) :
        step(qtTestStep) {
    }

protected:
    QtTestStep* step;

private slots:
    void test() const {
        step->body();
    }
};

}
}

#endif /* CUKE_QTTESTDRIVER_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/hook/HookMacros.hpp
================================================
#ifndef CUKE_HOOKMACROS_HPP_
#define CUKE_HOOKMACROS_HPP_

#include "../RegistrationMacros.hpp"

// ************************************************************************** //
// **************                 BEFORE HOOK                  ************** //
// ************************************************************************** //

#define BEFORE(...)                                           \
    BEFORE_WITH_NAME_(CUKE_GEN_OBJECT_NAME_, "" #__VA_ARGS__) \
    /**/

#define BEFORE_WITH_NAME_(step_name, tag_expression)          \
    CUKE_OBJECT_(                                             \
        step_name,                                            \
        ::cucumber::internal::BeforeHook,                     \
        BEFORE_HOOK_REGISTRATION_(step_name, tag_expression), \
        ()                                                    \
    )                                                         \
    /**/

#define BEFORE_HOOK_REGISTRATION_(step_name, tag_expression) \
    ::cucumber::internal::registerBeforeHook<step_name>(tag_expression) /**/

// ************************************************************************** //
// **************              AROUND_STEP HOOK                ************** //
// ************************************************************************** //

#define AROUND_STEP(...)                                           \
    AROUND_STEP_WITH_NAME_(CUKE_GEN_OBJECT_NAME_, "" #__VA_ARGS__) \
    /**/

#define AROUND_STEP_WITH_NAME_(step_name, tag_expression)          \
    CUKE_OBJECT_(                                                  \
        step_name,                                                 \
        ::cucumber::internal::AroundStepHook,                      \
        AROUND_STEP_HOOK_REGISTRATION_(step_name, tag_expression), \
        ()                                                         \
    )                                                              \
    /**/

#define AROUND_STEP_HOOK_REGISTRATION_(step_name, tag_expression) \
    ::cucumber::internal::registerAroundStepHook<step_name>(tag_expression) /**/

// ************************************************************************** //
// **************               AFTER_STEP HOOK                ************** //
// ************************************************************************** //

#define AFTER_STEP(...)                                           \
    AFTER_STEP_WITH_NAME_(CUKE_GEN_OBJECT_NAME_, "" #__VA_ARGS__) \
    /**/

#define AFTER_STEP_WITH_NAME_(step_name, tag_expression)          \
    CUKE_OBJECT_(                                                 \
        step_name,                                                \
        ::cucumber::internal::AfterStepHook,                      \
        AFTER_STEP_HOOK_REGISTRATION_(step_name, tag_expression), \
        ()                                                        \
    )                                                             \
    /**/

#define AFTER_STEP_HOOK_REGISTRATION_(step_name, tag_expression) \
    ::cucumber::internal::registerAfterStepHook<step_name>(tag_expression) /**/

// ************************************************************************** //
// **************                  AFTER HOOK                  ************** //
// ************************************************************************** //

#define AFTER(...)                                           \
    AFTER_WITH_NAME_(CUKE_GEN_OBJECT_NAME_, "" #__VA_ARGS__) \
    /**/

#define AFTER_WITH_NAME_(step_name, tag_expression)          \
    CUKE_OBJECT_(                                            \
        step_name,                                           \
        ::cucumber::internal::AfterHook,                     \
        AFTER_HOOK_REGISTRATION_(step_name, tag_expression), \
        ()                                                   \
    )                                                        \
    /**/

#define AFTER_HOOK_REGISTRATION_(step_name, tag_expression) \
    ::cucumber::internal::registerAfterHook<step_name>(tag_expression) /**/

// ************************************************************************** //
// **************                BEFORE_ALL HOOK               ************** //
// ************************************************************************** //

#define BEFORE_ALL()                             \
    BEFORE_ALL_WITH_NAME_(CUKE_GEN_OBJECT_NAME_) \
    /**/

#define BEFORE_ALL_WITH_NAME_(step_name)          \
    CUKE_OBJECT_(                                 \
        step_name,                                \
        ::cucumber::internal::BeforeAllHook,      \
        BEFORE_ALL_HOOK_REGISTRATION_(step_name), \
        ()                                        \
    )                                             \
    /**/

#define BEFORE_ALL_HOOK_REGISTRATION_(step_name) \
    ::cucumber::internal::registerBeforeAllHook<step_name>() /**/

// ************************************************************************** //
// **************                 AFTER_ALL HOOK               ************** //
// ************************************************************************** //

#define AFTER_ALL()                             \
    AFTER_ALL_WITH_NAME_(CUKE_GEN_OBJECT_NAME_) \
    /**/

#define AFTER_ALL_WITH_NAME_(step_name)                                                            \
    CUKE_OBJECT_(                                                                                  \
        step_name, ::cucumber::internal::AfterAllHook, AFTER_ALL_HOOK_REGISTRATION_(step_name), () \
    )                                                                                              \
    /**/

#define AFTER_ALL_HOOK_REGISTRATION_(step_name) \
    ::cucumber::internal::registerAfterAllHook<step_name>() /**/

#endif /* CUKE_HOOKMACROS_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/hook/HookRegistrar.hpp
================================================
#ifndef CUKE_HOOKREGISTRAR_HPP_
#define CUKE_HOOKREGISTRAR_HPP_

#include <cucumber-cpp/internal/CukeExport.hpp>
#include "Tag.hpp"
#include "../Scenario.hpp"
#include "../step/StepManager.hpp"

#include <memory>
#include <list>

namespace cucumber {
namespace internal {

class CUCUMBER_CPP_EXPORT CallableStep {
public:
    virtual void call() = 0;
};

class CUCUMBER_CPP_EXPORT Hook {
public:
    virtual ~Hook() = default;

    void setTags(const std::string& csvTagNotation);
    virtual void invokeHook(Scenario* scenario, CallableStep* step);
    virtual void skipHook();
    virtual void body() = 0;

protected:
    bool tagsMatch(Scenario* scenario);

    template<typename Derived, typename R>
    static R invokeWithArgs(Derived& that, R (Derived::*f)()) {
        return (that.*f)();
    }

private:
    AndTagExpression tagExpression;
};

class CUCUMBER_CPP_EXPORT BeforeHook : public Hook {};

class CUCUMBER_CPP_EXPORT AroundStepHook : public Hook {
public:
    void invokeHook(Scenario* scenario, CallableStep* step) override;
    void skipHook() override;

protected:
    CallableStep* step;
};

class CUCUMBER_CPP_EXPORT AfterStepHook : public Hook {};

class CUCUMBER_CPP_EXPORT AfterHook : public Hook {};

class CUCUMBER_CPP_EXPORT UnconditionalHook : public Hook {
public:
    void invokeHook(Scenario* scenario, CallableStep* step) override;
};

class CUCUMBER_CPP_EXPORT BeforeAllHook : public UnconditionalHook {};

class CUCUMBER_CPP_EXPORT AfterAllHook : public UnconditionalHook {};

class CUCUMBER_CPP_EXPORT HookRegistrar {
public:
    typedef std::list<std::shared_ptr<Hook>> hook_list_type;
    typedef std::list<std::shared_ptr<AroundStepHook>> aroundhook_list_type;

    static void addBeforeHook(std::shared_ptr<BeforeHook> afterHook);
    static void execBeforeHooks(Scenario* scenario);

    static void addAroundStepHook(std::shared_ptr<AroundStepHook> aroundStepHook);
    static InvokeResult execStepChain(
        Scenario* scenario, const StepInfo* stepInfo, const InvokeArgs* pArgs
    );

    static void addAfterStepHook(std::shared_ptr<AfterStepHook> afterStepHook);
    static void execAfterStepHooks(Scenario* scenario);

    static void addAfterHook(std::shared_ptr<AfterHook> afterHook);
    static void execAfterHooks(Scenario* scenario);

    static void addBeforeAllHook(std::shared_ptr<BeforeAllHook> beforeAllHook);
    static void execBeforeAllHooks();

    static void addAfterAllHook(std::shared_ptr<AfterAllHook> afterAllHook);
    static void execAfterAllHooks();

private:
    static void execHooks(HookRegistrar::hook_list_type& hookList, Scenario* scenario);

protected:
    static hook_list_type& beforeAllHooks();
    static hook_list_type& beforeHooks();
    static aroundhook_list_type& aroundStepHooks();
    static hook_list_type& afterStepHooks();
    static hook_list_type& afterHooks();
    static hook_list_type& afterAllHooks();

private:
    // We're a singleton so don't allow instances
    HookRegistrar() = delete;
};

class CUCUMBER_CPP_EXPORT StepCallChain {
public:
    StepCallChain(
        Scenario* scenario,
        const StepInfo* stepInfo,
        const InvokeArgs* pStepArgs,
        HookRegistrar::aroundhook_list_type& aroundHooks
    );
    InvokeResult exec();
    void execNext();

private:
    void execStep();

    Scenario* scenario;
    const StepInfo* stepInfo;
    const InvokeArgs* pStepArgs;

    HookRegistrar::aroundhook_list_type::iterator nextHook;
    HookRegistrar::aroundhook_list_type::iterator hookEnd;
    InvokeResult result;
};

class CUCUMBER_CPP_EXPORT CallableStepChain : public CallableStep {
public:
    CallableStepChain(StepCallChain* scc);
    void call() override;

private:
    StepCallChain* scc;
};

template<class T>
static int registerBeforeHook(const std::string& csvTagNotation) {
    std::shared_ptr<T> hook(std::make_shared<T>());
    hook->setTags(csvTagNotation);
    HookRegistrar::addBeforeHook(hook);
    return 0; // We are not interested in the ID at this time
}

template<class T>
static int registerAroundStepHook(const std::string& csvTagNotation) {
    std::shared_ptr<T> hook(std::make_shared<T>());
    hook->setTags(csvTagNotation);
    HookRegistrar::addAroundStepHook(hook);
    return 0;
}

template<class T>
static int registerAfterStepHook(const std::string& csvTagNotation) {
    std::shared_ptr<T> hook(std::make_shared<T>());
    hook->setTags(csvTagNotation);
    HookRegistrar::addAfterStepHook(hook);
    return 0;
}

template<class T>
static int registerAfterHook(const std::string& csvTagNotation) {
    std::shared_ptr<T> hook(std::make_shared<T>());
    hook->setTags(csvTagNotation);
    HookRegistrar::addAfterHook(hook);
    return 0;
}

template<class T>
static int registerBeforeAllHook() {
    HookRegistrar::addBeforeAllHook(std::make_shared<T>());
    return 0;
}

template<class T>
static int registerAfterAllHook() {
    HookRegistrar::addAfterAllHook(std::make_shared<T>());
    return 0;
}

}
}

#endif /* CUKE_HOOKREGISTRAR_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/hook/Tag.hpp
================================================
#ifndef CUKE_TAG_HPP_
#define CUKE_TAG_HPP_

#include <string>
#include <vector>

#include <cucumber-cpp/internal/CukeExport.hpp>
#include "../utils/Regex.hpp"

namespace cucumber {
namespace internal {

class CUCUMBER_CPP_EXPORT TagExpression {
public:
    typedef std::vector<std::string> tag_list;

    virtual ~TagExpression() = default;
    virtual bool matches(const tag_list& tags) const = 0;
};

class CUCUMBER_CPP_EXPORT OrTagExpression : public TagExpression {
public:
    OrTagExpression(const std::string& csvTagNotation);
    bool matches(const tag_list& tags) const override;

private:
    bool orTagMatchesTagList(const std::string& currentOrTag, const tag_list& tags) const;

    tag_list orTags;

    static Regex& csvTagNotationRegex();
};

class CUCUMBER_CPP_EXPORT AndTagExpression : public TagExpression {
public:
    AndTagExpression() = default;
    AndTagExpression(const std::string& csvTagNotation);
    bool matches(const tag_list& tags) const override;

private:
    typedef std::vector<OrTagExpression> or_expressions_type;
    or_expressions_type orExpressions;

    static Regex& csvTagNotationRegex();
};

}
}

#endif /* CUKE_TAG_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/step/StepMacros.hpp
================================================
#ifndef CUKE_STEPMACROS_HPP_
#define CUKE_STEPMACROS_HPP_

#include "../RegistrationMacros.hpp"

// ************************************************************************** //
// **************                     STEP                     ************** //
// ************************************************************************** //

#define CUKE_STEP_GET_MATCHER_(step_matcher, ...) step_matcher
#define CUKE_STEP_GET_ARGS_(step_matcher, args, ...) args

#define CUKE_STEP_(...)                          \
    CUKE_STEP_WITH_NAME_(                        \
        CUKE_GEN_OBJECT_NAME_,                   \
        CUKE_STEP_GET_MATCHER_(__VA_ARGS__, ()), \
        CUKE_STEP_GET_ARGS_(__VA_ARGS__, (), ()) \
    )                                            \
    /**/

#define CUKE_STEP_WITH_NAME_(step_name, step_matcher, args) \
    CUKE_OBJECT_(                                           \
        step_name,                                          \
        STEP_INHERITANCE(step_name),                        \
        CUKE_STEP_REGISTRATION_(step_name, step_matcher),   \
        args                                                \
    )                                                       \
    /**/

#define CUKE_STEP_REGISTRATION_(step_name, step_matcher) \
    ::cucumber::internal::registerStep<step_name>(step_matcher, __FILE__, __LINE__) /**/

// ************************************************************************** //
// **************               GIVEN/WHEN/THEN                ************** //
// ************************************************************************** //

#define GIVEN CUKE_STEP_
#define WHEN CUKE_STEP_
#define THEN CUKE_STEP_

// ************************************************************************** //
// **************                 REGEX_PARAM                  ************** //
// ************************************************************************** //

#define REGEX_PARAM(type, name) const type name(getInvokeArg<type>())
#define TABLE_PARAM(name) const ::cucumber::internal::Table& name = getArgs()->getTableArg()

#endif /* CUKE_STEPMACROS_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/step/StepManager.hpp
================================================
#ifndef CUKE_STEPMANAGER_HPP_
#define CUKE_STEPMANAGER_HPP_

#include <map>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
#include <memory>
#include <type_traits>

#include <cucumber-cpp/internal/CukeExport.hpp>
#include "../Table.hpp"
#include "../utils/IndexSequence.hpp"
#include "../utils/Regex.hpp"

namespace cucumber {
namespace internal {

typedef unsigned int step_id_type;

class StepInfo;

class CUCUMBER_CPP_EXPORT SingleStepMatch {
public:
    typedef RegexMatch::submatches_type submatches_type;

    operator const void*() const;

    std::shared_ptr<const StepInfo> stepInfo;
    submatches_type submatches;
};

class CUCUMBER_CPP_EXPORT MatchResult {
public:
    typedef std::vector<SingleStepMatch> match_results_type;

    const match_results_type& getResultSet();
    void addMatch(SingleStepMatch match);

    explicit operator bool() const;

private:
    match_results_type resultSet;
};

class CUCUMBER_CPP_EXPORT InvokeArgs {
    typedef std::vector<std::string> args_type;

public:
    typedef args_type::size_type size_type;

    InvokeArgs() = default;

    void addArg(const std::string arg);
    Table& getVariableTableArg();

    template<class T>
    T getInvokeArg(size_type i) const;
    const Table& getTableArg() const;

private:
    Table tableArg;
    args_type args;
};

enum InvokeResultType {
    SUCCESS,
    FAILURE,
    PENDING
};

class CUCUMBER_CPP_EXPORT InvokeResult {
private:
    InvokeResultType type;
    std::string description;

    InvokeResult(const InvokeResultType type, const char* description);

public:
    InvokeResult();
    InvokeResult(const InvokeResult& ir);
    InvokeResult& operator=(const InvokeResult& rhs);

    static InvokeResult success();
    static InvokeResult failure(const char* description);
    static InvokeResult failure(const std::string& description);
    static InvokeResult pending(const char* description);

    bool isSuccess() const;
    bool isPending() const;
    InvokeResultType getType() const;
    const std::string& getDescription() const;
};

class CUCUMBER_CPP_EXPORT StepInfo : public std::enable_shared_from_this<StepInfo> {
public:
    StepInfo(const std::string& stepMatcher, const std::string source);

    virtual ~StepInfo() = default;

    SingleStepMatch matches(const std::string& stepDescription) const;
    virtual InvokeResult invokeStep(const InvokeArgs* pArgs) const = 0;

    step_id_type id;
    Regex regex;
    const std::string source;

private:
    // Shut up MSVC warning C4512: assignment operator could not be generated
    StepInfo& operator=(const StepInfo& other);
};

class CUCUMBER_CPP_EXPORT BasicStep {
public:
    virtual ~BasicStep() = default;

    InvokeResult invoke(const InvokeArgs* pArgs);

protected:
    typedef const Table table_type;
    typedef const Table::hashes_type table_hashes_type;

    virtual const InvokeResult invokeStepBody() = 0;
    virtual void body() = 0;

    void pending(const char* description);
    void pending();

    template<class T>
    const T getInvokeArg();
    const InvokeArgs* getArgs();

    template<typename Derived, typename R, typename... Args, std::size_t... N>
    static R invokeWithIndexedArgs(Derived& that, R (Derived::*f)(Args...), index_sequence<N...>) {
        return (that.*f)(that.pArgs->template getInvokeArg<typename std::decay<Args>::type>(N)...);
    }

    template<typename Derived, typename R, typename... Args>
    static R invokeWithArgs(Derived& that, R (Derived::*f)(Args...)) {
        that.currentArgIndex = sizeof...(Args);
        return invokeWithIndexedArgs(that, f, index_sequence_for<Args...>{});
    }

private:
    // FIXME: awful hack because of Boost::Test
    InvokeResult currentResult;

    const InvokeArgs* pArgs;
    InvokeArgs::size_type currentArgIndex;
};

template<class T>
class StepInvoker : public StepInfo {
public:
    StepInvoker(const std::string& stepMatcher, const std::string source);

    InvokeResult invokeStep(const InvokeArgs* args) const override;
};

class CUCUMBER_CPP_EXPORT StepManager {
protected:
    typedef std::map<step_id_type, std::shared_ptr<const StepInfo>> steps_type;

public:
    static step_id_type addStep(std::shared_ptr<StepInfo> stepInfo);
    static MatchResult stepMatches(const std::string& stepDescription);
    static const StepInfo* getStep(step_id_type id);

protected:
    static steps_type& steps();

private:
    // We're a singleton so don't allow instances
    StepManager() = delete;
};

static inline std::string toSourceString(const char* filePath, const int line) {
    using namespace std;
    stringstream s;
    string file(filePath);
    string::size_type pos = file.find_last_of("/\\");
    if (pos == string::npos) {
        s << file;
    } else {
        s << file.substr(++pos);
    }
    s << ":" << line;
    return s.str();
}

template<class T>
static int registerStep(const std::string& stepMatcher, const char* file, const int line) {
    return StepManager::addStep(
        std::make_shared<StepInvoker<T>>(stepMatcher, toSourceString(file, line))
    );
}

template<typename T>
T fromString(const std::string& s) {
    std::istringstream stream(s);
    T t;
    stream >> t;
    if (stream.fail()) {
        throw std::invalid_argument("Cannot convert parameter");
    }
    return t;
}

template<>
inline std::string fromString(const std::string& s) {
    return s;
}

template<typename T>
std::string toString(T arg) {
    std::stringstream s;
    s << arg;
    return s.str();
}

template<typename T>
T InvokeArgs::getInvokeArg(size_type i) const {
    if (i >= args.size()) {
        throw std::invalid_argument("Parameter not found");
    }
    return fromString<T>(args.at(i));
}

template<typename T>
const T BasicStep::getInvokeArg() {
    return pArgs->getInvokeArg<T>(currentArgIndex++);
}

template<class T>
StepInvoker<T>::StepInvoker(const std::string& stepMatcher, const std::string source) :
    StepInfo(stepMatcher, source) {
}

template<class T>
InvokeResult StepInvoker<T>::invokeStep(const InvokeArgs* pArgs) const {
    T t;
    return t.invoke(pArgs);
}

}
}

#endif /* CUKE_STEPMANAGER_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/utils/IndexSequence.hpp
================================================
#ifndef CUKE_INDEXSEQ_HPP_
#define CUKE_INDEXSEQ_HPP_

#include <utility>

namespace cucumber {
namespace internal {

using ::std::index_sequence;
using ::std::index_sequence_for;

}
}

#endif /* CUKE_INDEXSEQ_HPP_ */


================================================
FILE: include/cucumber-cpp/internal/utils/Regex.hpp
================================================
#ifndef CUKE_REGEX_HPP_
#define CUKE_REGEX_HPP_

#include <cstddef>
#include <vector>

#include <regex>

namespace cucumber {
namespace internal {

struct RegexSubmatch {
    std::string value;
    std::ptrdiff_t position;
};

class RegexMatch {
public:
    typedef std::vector<RegexSubmatch> submatches_type;

    virtual ~RegexMatch() = default;

    bool matches();
    const submatches_type& getSubmatches();

protected:
    bool regexMatched;
    submatches_type submatches;
};

class FindRegexMatch : public RegexMatch {
public:
    FindRegexMatch(const std::regex& regexImpl, const std::string& expression);
};

class FindAllRegexMatch : public RegexMatch {
public:
    FindAllRegexMatch(const std::regex& regexImpl, const std::string& expression);
};

class Regex {
private:
    std::regex regexImpl;
    const std::string regexString;

public:
    Regex(std::string expr);

    std::shared_ptr<RegexMatch> find(const std::string& expression) const;
    std::shared_ptr<RegexMatch> findAll(const std::string& expression) const;

    std::string str() const;
};

}
}

#endif /* CUKE_REGEX_HPP_ */


================================================
FILE: run-linux.sh
================================================
#!/bin/sh
set -e #break script on non-zero exitcode from any command
set -x #display command being executed

CTEST_OUTPUT_ON_FAILURE=ON
export CTEST_OUTPUT_ON_FAILURE

cmake -E make_directory build
cmake -E chdir build cmake \
    -G Ninja \
    -DCUKE_STRICT=on \
    -DCUKE_ENABLE_BOOST_TEST=on \
    -DCUKE_ENABLE_GTEST=on \
    -DCUKE_ENABLE_QT_6=on \
    -DCUKE_ENABLE_EXAMPLES=on \
    -DCUKE_TESTS_UNIT=on \
    -DCUKE_CODE_COVERAGE=on \
    ..
cmake --build build --parallel --verbose

#
# Run tests
#

cmake --build build --target test

#
# Execute Calc examples
#

for TEST in \
    build/examples/Calc/GTestCalculatorSteps \
    build/examples/Calc/QtTestCalculatorSteps \
    build/examples/Calc/BoostCalculatorSteps \
    build/examples/Calc/FuncArgsCalculatorSteps \
; do
    "${TEST}" > /dev/null &
    sleep 1
    (cd examples/Calc; cucumber)
    wait %
done

#
# Execute QtCalc examples
#

for TEST in \
    build/examples/CalcQt/GTestCalculatorQtSteps \
    build/examples/CalcQt/QtTestCalculatorQtSteps \
    build/examples/CalcQt/BoostCalculatorQtSteps \
; do
    "${TEST}" 2> /dev/null &
    sleep 1
    (cd examples/CalcQt; cucumber)
    wait %
done

#
# Execute feature showcase on Unix socket
#

SOCK=`pwd`/cucumber.wire.sock
TEST=build/examples/FeatureShowcase/FeatureShowcaseSteps
echo "unix: ${SOCK}" > examples/FeatureShowcase/features/step_definitions/cucumber.wire
"${TEST}" --unix "${SOCK}" > /dev/null &
(cd examples/FeatureShowcase; cucumber)
wait %

mkdir -p coverage
gcovr build/ --html-details --output coverage/index.html --xml coverage/cobertura.xml

sudo cmake --install build


================================================
FILE: run-windows.ps1
================================================
# --- Function definitions ---
function Invoke-CMake {
    param (
        $Arguments
    )
    $process = Start-Process "cmake" -ArgumentList "$Arguments" -NoNewWindow -Wait -PassThru
    If ($process.ExitCode -ne 0) {
        Write-Host "Abort script execution due to CMake error."
        Exit(42)
    }
}

function Get-VariableOrEnv {
    param (
        [string]$Name
    )

    $envValue = [Environment]::GetEnvironmentVariable($Name)
    if ($envValue -ne $null) {
        return $envValue
    }

    if (Get-Variable -Name $Name -ErrorAction SilentlyContinue) {
        return (Get-Variable -Name $Name).Value
    }

    return $null
}

# --- Variable definitions ---
$cpp_standard = Get-VariableOrEnv -Name "cpp_standard"

$nlohmann_json_DIR = Get-VariableOrEnv -Name "nlohmann_json_DIR"
$Asio_ROOT = Get-VariableOrEnv -Name "Asio_ROOT"
$TCLAP_ROOT = Get-VariableOrEnv -Name "TCLAP_ROOT"
$Env:BOOST_ROOT = "boost_${Env:BOOST_VERSION}".Replace(".","_")

$Env:CTEST_OUTPUT_ON_FAILURE="ON"


# --- Script ---

Invoke-CMake "-E","make_directory","build"

$cmake_params = "-E chdir build cmake",
    "-DBUILD_SHARED_LIBS=`"${BUILD_SHARED_LIBS}`"",
    "-DCMAKE_INSTALL_PREFIX=${HOME}/.local"

$cmake_params += "-DCMAKE_CXX_STANDARD=${cpp_standard}"

$cmake_params += "-DCUKE_ENABLE_BOOST_TEST=OFF"
$cmake_params += "-DCUKE_ENABLE_GTEST=OFF"
$cmake_params += "-DCUKE_ENABLE_QT_6=OFF"
$cmake_params += "-DCUKE_ENABLE_EXAMPLES=OFF"
$cmake_params += "-DCUKE_TESTS_UNIT=OFF"
$cmake_params += "-DCUKE_CODE_COVERAGE=OFF"

$cmake_params += "-Dnlohmann_json_DIR=${nlohmann_json_DIR}"
$cmake_params += "-DAsio_ROOT=${Asio_ROOT}"
$cmake_params += "-DTCLAP_ROOT=${TCLAP_ROOT}"

$cmake_params += ".."


Invoke-CMake "$cmake_params"
Invoke-CMake "--build","build" #,"--parallel"


================================================
FILE: src/CMakeLists.txt
================================================
include(GenerateExportHeader)

find_package(nlohmann_json 3.10.5 REQUIRED)
find_package(Asio REQUIRED)
find_package(TCLAP REQUIRED)
include(../cmake/modules/GitVersion.cmake)

set(CUKE_SOURCES
    drivers/GenericDriver.cpp
    ContextManager.cpp
    CukeCommands.cpp
    CukeEngine.cpp
    CukeEngineImpl.cpp
    StepManager.cpp
    HookRegistrar.cpp
    Regex.cpp
    Scenario.cpp
    Table.cpp
    Tag.cpp
    connectors/wire/WireServer.cpp
    connectors/wire/WireProtocol.cpp
    connectors/wire/WireProtocolCommands.cpp
    )

if(TARGET GTest::gtest)
    list(APPEND CUKE_EXTRA_PRIVATE_LIBRARIES GTest::gtest)
    list(APPEND CUKE_SOURCES drivers/GTestDriver.cpp)
endif()

if(TARGET Boost::unit_test_framework)
    list(APPEND CUKE_EXTRA_PRIVATE_LIBRARIES Boost::unit_test_framework)
    list(APPEND CUKE_SOURCES drivers/BoostDriver.cpp)
    list(APPEND CUKE_DEP_LIBRARIES ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
endif()

if(TARGET Qt::Test)
    qt_wrap_cpp(MOC_FILE ../include/cucumber-cpp/internal/drivers/QtTestDriver.hpp)
    list(APPEND CUKE_SOURCES ${MOC_FILE})
    list(APPEND CUKE_SOURCES drivers/QtTestDriver.cpp)
    list(APPEND CUKE_EXTRA_PRIVATE_LIBRARIES Qt::Test)
endif()

message(STATUS "Adding header files to project")
set(CUKE_HEADERS
    ../include/cucumber-cpp/autodetect.hpp
    ../include/cucumber-cpp/defs.hpp
    ../include/cucumber-cpp/generic.hpp
    ../include/cucumber-cpp/internal/ContextManager.hpp
    ../include/cucumber-cpp/internal/CukeCommands.hpp
    ../include/cucumber-cpp/internal/CukeEngine.hpp
    ../include/cucumber-cpp/internal/CukeEngineImpl.hpp
    ../include/cucumber-cpp/internal/Macros.hpp
    ../include/cucumber-cpp/internal/RegistrationMacros.hpp
    ../include/cucumber-cpp/internal/Scenario.hpp
    ../include/cucumber-cpp/internal/Table.hpp
    ../include/cucumber-cpp/internal/connectors/wire/ProtocolHandler.hpp
    ../include/cucumber-cpp/internal/connectors/wire/WireProtocol.hpp
    ../include/cucumber-cpp/internal/connectors/wire/WireProtocolCommands.hpp
    ../include/cucumber-cpp/internal/connectors/wire/WireServer.hpp
    ../include/cucumber-cpp/internal/defs.hpp
    ../include/cucumber-cpp/internal/drivers/BoostDriver.hpp
    ../include/cucumber-cpp/internal/drivers/DriverSelector.hpp
    ../include/cucumber-cpp/internal/drivers/GTestDriver.hpp
    ../include/cucumber-cpp/internal/drivers/GenericDriver.hpp
    ../include/cucumber-cpp/internal/drivers/QtTestDriver.hpp
    ../include/cucumber-cpp/internal/hook/HookMacros.hpp
    ../include/cucumber-cpp/internal/hook/HookRegistrar.hpp
    ../include/cucumber-cpp/internal/hook/Tag.hpp
    ../include/cucumber-cpp/internal/step/StepMacros.hpp
    ../include/cucumber-cpp/internal/step/StepManager.hpp
    ../include/cucumber-cpp/internal/utils/IndexSequence.hpp
    ../include/cucumber-cpp/internal/utils/Regex.hpp
)
if(MSVC_IDE)
    source_group("Header Files" FILES ${CUKE_HEADERS})
endif()
list(APPEND CUKE_SOURCES ${CUKE_HEADERS})

# Library for unit tests relying on internals
add_library(cucumber-cpp-internal STATIC ${CUKE_SOURCES})

add_library(cucumber-cpp-nomain ${CUKE_SOURCES})
add_library(cucumber-cpp ${CUKE_SOURCES} main.cpp)

set_target_properties(
    cucumber-cpp-internal
    cucumber-cpp
    cucumber-cpp-nomain
    PROPERTIES
        DEFINE_SYMBOL cucumber_cpp_EXPORTS
        CXX_VISIBILITY_PRESET hidden
        VISIBILITY_INLINES_HIDDEN ON
)

generate_export_header(cucumber-cpp
    EXPORT_FILE_NAME "cucumber-cpp/internal/CukeExport.hpp"
)

foreach(TARGET
        cucumber-cpp-internal
        cucumber-cpp-nomain
        cucumber-cpp
)
    target_include_directories(${TARGET}
        PUBLIC
            $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
            $<BUILD_INTERFACE:${CUKE_INCLUDE_DIR}>
            $<BUILD_INTERFACE:${ASIO_INCLUDE_DIR}>
            $<BUILD_INTERFACE:${TCLAP_INCLUDE_DIR}>
            $<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>
    )
    target_link_libraries(${TARGET}
        PRIVATE
            ${CUKE_EXTRA_PRIVATE_LIBRARIES}
            nlohmann_json::nlohmann_json
    )
    # Don't export or import symbols for statically linked libraries
    get_property(type TARGET ${TARGET} PROPERTY TYPE)
    if(NOT "${type}" MATCHES "^(SHARED|MODULE)_LIBRARY$")
        target_compile_definitions(${TARGET} PUBLIC CUCUMBER_CPP_STATIC_DEFINE)
    endif()
    if(MINGW)
        target_link_libraries(${TARGET}
            PRIVATE
                ws2_32
        )
    endif(MINGW)
endforeach()

git_get_version(CUKE_VERSION)
message(STATUS "Version: ${CUKE_VERSION}")
target_compile_definitions(cucumber-cpp PRIVATE
    CUKE_VERSION="${CUKE_VERSION}"
)

include(GNUInstallDirs)
install(DIRECTORY ${CUKE_INCLUDE_DIR}/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
install(
    FILES
        "${CMAKE_CURRENT_BINARY_DIR}/cucumber-cpp/internal/CukeExport.hpp"
    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/cucumber-cpp/internal"
)
install(
    TARGETS
        cucumber-cpp-nomain
        cucumber-cpp
    EXPORT   CucumberCpp
    ARCHIVE  DESTINATION ${CMAKE_INSTALL_LIBDIR}
    LIBRARY  DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME  DESTINATION ${CMAKE_INSTALL_BINDIR}
)
install(
    EXPORT      CucumberCpp
    NAMESPACE   CucumberCpp::
    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake
    FILE        CucumberCppConfig.cmake
)


================================================
FILE: src/ContextManager.cpp
================================================
#include "cucumber-cpp/internal/ContextManager.hpp"

namespace cucumber {
namespace internal {

contexts_type ContextManager::contexts;

void ContextManager::purgeContexts() {
    contexts.clear();
}

}
}


================================================
FILE: src/CukeCommands.cpp
================================================
#include "cucumber-cpp/internal/CukeCommands.hpp"
#include "cucumber-cpp/internal/hook/HookRegistrar.hpp"

#include <sstream>

namespace cucumber {
namespace internal {

std::shared_ptr<Scenario> CukeCommands::currentScenario;

CukeCommands::CukeCommands() :
    hasStarted(false) {
}

CukeCommands::~CukeCommands() {
    if (hasStarted) {
        HookRegistrar::execAfterAllHooks();
    }
}

void CukeCommands::beginScenario(const TagExpression::tag_list& tags) {
    if (!hasStarted) {
        hasStarted = true;
        HookRegistrar::execBeforeAllHooks();
    }

    currentScenario = std::make_shared<Scenario>(tags);
    HookRegistrar::execBeforeHooks(currentScenario.get());
}

void CukeCommands::endScenario() {
    HookRegistrar::execAfterHooks(currentScenario.get());
    contextManager.purgeContexts();
    currentScenario.reset();
}

const std::string CukeCommands::snippetText(
    const std::string stepKeyword, const std::string stepName
) const {
    std::stringstream text;
    std::string stepKeywordUpperCase;
    std::transform(
        stepKeyword.begin(), stepKeyword.end(), std::back_inserter(stepKeywordUpperCase), ::toupper
    );
    text << stepKeywordUpperCase << "(\"" << escapeCString("^" + escapeRegex(stepName) + "$")
         << "\") {\n"
         << "    pending();\n"
         << "}\n";
    return text.str();
}

const std::string CukeCommands::escapeRegex(const std::string reg) const {
    return regex_replace(
        reg,
        std::regex("[\\|\\(\\)\\[\\]\\{\\}\\^\\$\\*\\+\\?\\.\\\\]"),
        "\\\\&",
        std::regex_constants::match_default | std::regex_constants::format_sed
    );
}

const std::string CukeCommands::escapeCString(const std::string str) const {
    return regex_replace(
        str,
        std::regex("[\"\\\\]"),
        "\\\\&",
        std::regex_constants::match_default | std::regex_constants::format_sed
    );
}

MatchResult CukeCommands::stepMatches(const std::string description) const {
    return StepManager::stepMatches(description);
}

InvokeResult CukeCommands::invoke(step_id_type id, const InvokeArgs* pArgs) {
    const StepInfo* const stepInfo = StepManager::getStep(id);
    InvokeResult result = HookRegistrar::execStepChain(currentScenario.get(), stepInfo, pArgs);
    HookRegistrar::execAfterStepHooks(currentScenario.get());
    return result;
}

}
}


================================================
FILE: src/CukeEngine.cpp
================================================
#include "cucumber-cpp/internal/CukeEngine.hpp"

namespace cucumber {
namespace internal {

InvokeException::InvokeException(const std::string& message) :
    message(message) {
}

InvokeException::InvokeException(const InvokeException& rhs) :
    message(rhs.message) {
}

const std::string InvokeException::getMessage() const {
    return message;
}

InvokeFailureException::InvokeFailureException(
    const std::string& message, const std::string& exceptionType
) :
    InvokeException(message),
    exceptionType(exceptionType) {
}

InvokeFailureException::InvokeFailureException(const InvokeFailureException& rhs) :
    InvokeException(rhs),
    exceptionType(rhs.exceptionType) {
}

const std::string InvokeFailureException::getExceptionType() const {
    return exceptionType;
}

PendingStepException::PendingStepException(const std::string& message) :
    InvokeException(message) {
}

PendingStepException::PendingStepException(const PendingStepException& rhs) :
    InvokeException(rhs) {
}

CukeEngine::CukeEngine() {
}

}
}


================================================
FILE: src/CukeEngineImpl.cpp
================================================
#include "cucumber-cpp/internal/CukeEngineImpl.hpp"

namespace cucumber {
namespace internal {

namespace {

std::string convertId(step_id_type id) {
    std::stringstream ss;
    ss << id;
    return ss.str();
}

step_id_type convertId(const std::string& stringid) {
    std::stringstream ss(stringid);
    step_id_type id;
    ss >> id;
    return id;
}
}

std::vector<StepMatch> CukeEngineImpl::stepMatches(const std::string& name) const {
    std::vector<StepMatch> engineResult;
    MatchResult commandResult = cukeCommands.stepMatches(name);
    for (const SingleStepMatch& commandMatch : commandResult.getResultSet()) {
        StepMatch engineMatch;
        engineMatch.id = convertId(commandMatch.stepInfo->id);
        engineMatch.source = commandMatch.stepInfo->source;
        engineMatch.regexp = commandMatch.stepInfo->regex.str();
        for (const RegexSubmatch& commandMatchArg : commandMatch.submatches) {
            StepMatchArg engineMatchArg;
            engineMatchArg.value = commandMatchArg.value;
            engineMatchArg.position = commandMatchArg.position;
            engineMatch.args.push_back(engineMatchArg);
        }
        engineResult.push_back(engineMatch);
    }
    return engineResult;
}

void CukeEngineImpl::beginScenario(const tags_type& tags) {
    cukeCommands.beginScenario(tags);
}

void CukeEngineImpl::invokeStep(
    const std::string& id, const invoke_args_type& args, const invoke_table_type& tableArg
) {
    InvokeArgs commandArgs;
    try {
        for (const std::string& a : args) {
            commandArgs.addArg(a);
        }

        if (!tableArg.empty() && !tableArg.front().empty()) {
            Table& commandTableArg = commandArgs.getVariableTableArg();
            for (const auto& arg : tableArg[0]) {
                commandTableArg.addColumn(arg);
            }

            for (std::size_t i = 1; i < tableArg.size(); ++i) {
                Table::row_type row;
                for (const auto& arg : tableArg[i]) {
                    row.push_back(arg);
                }
                commandTableArg.addRow(row);
            }
        }
    } catch (...) {
        throw InvokeException("Unable to decode arguments");
    }

    InvokeResult commandResult;
    try {
        commandResult = cukeCommands.invoke(convertId(id), &commandArgs);
    } catch (...) {
        throw InvokeException("Uncatched exception");
    }
    switch (commandResult.getType()) {
    case SUCCESS:
        return;
    case FAILURE:
        throw InvokeFailureException(commandResult.getDescription(), "");
    case PENDING:
        throw PendingStepException(commandResult.getDescription());
    }
}

void CukeEngineImpl::endScenario(const tags_type& /*tags*/) {
    cukeCommands.endScenario();
}

std::string CukeEngineImpl::snippetText(
    const std::string& keyword, const std::string& name, const std::string& /*multilineArgClass*/
) const {
    return cukeCommands.snippetText(keyword, name);
}

}
}


================================================
FILE: src/HookRegistrar.cpp
================================================
#include <cucumber-cpp/internal/hook/HookRegistrar.hpp>
#include <cucumber-cpp/internal/CukeCommands.hpp>

namespace cucumber {
namespace internal {

void Hook::invokeHook(Scenario* scenario, CallableStep*) {
    if (tagsMatch(scenario)) {
        body();
    } else {
        skipHook();
    }
}

void Hook::skipHook() {
}

void Hook::setTags(const std::string& csvTagNotation) {
    tagExpression = AndTagExpression(csvTagNotation);
}

bool Hook::tagsMatch(Scenario* scenario) {
    return !scenario || tagExpression.matches(scenario->getTags());
}

void AroundStepHook::invokeHook(Scenario* scenario, CallableStep* step) {
    this->step = step;
    Hook::invokeHook(scenario, NULL);
}

void AroundStepHook::skipHook() {
    step->call();
}

void UnconditionalHook::invokeHook(Scenario*, CallableStep*) {
    body();
}

void HookRegistrar::addBeforeHook(std::shared_ptr<BeforeHook> beforeHook) {
    beforeHooks().push_back(beforeHook);
}

HookRegistrar::hook_list_type& HookRegistrar::beforeHooks() {
    static hook_list_type beforeHooks;
    return beforeHooks;
}

void HookRegistrar::execBeforeHooks(Scenario* scenario) {
    execHooks(beforeHooks(), scenario);
}

void HookRegistrar::addAroundStepHook(std::shared_ptr<AroundStepHook> aroundStepHook) {
    aroundStepHooks().push_front(aroundStepHook);
}

HookRegistrar::aroundhook_list_type& HookRegistrar::aroundStepHooks() {
    static aroundhook_list_type aroundStepHooks;
    return aroundStepHooks;
}

InvokeResult HookRegistrar::execStepChain(
    Scenario* scenario, const StepInfo* const stepInfo, const InvokeArgs* pArgs
) {
    StepCallChain scc(scenario, stepInfo, pArgs, aroundStepHooks());
    return scc.exec();
}

void HookRegistrar::addAfterStepHook(std::shared_ptr<AfterStepHook> afterStepHook) {
    afterStepHooks().push_front(afterStepHook);
}

HookRegistrar::hook_list_type& HookRegistrar::afterStepHooks() {
    static hook_list_type afterStepHooks;
    return afterStepHooks;
}

void HookRegistrar::execAfterStepHooks(Scenario* scenario) {
    execHooks(afterStepHooks(), scenario);
}

void HookRegistrar::addAfterHook(std::shared_ptr<AfterHook> afterHook) {
    afterHooks().push_front(afterHook);
}

HookRegistrar::hook_list_type& HookRegistrar::afterHooks() {
    static hook_list_type afterHooks;
    return afterHooks;
}

void HookRegistrar::execAfterHooks(Scenario* scenario) {
    execHooks(afterHooks(), scenario);
}

void HookRegistrar::execHooks(HookRegistrar::hook_list_type& hookList, Scenario* scenario) {
    for (HookRegistrar::hook_list_type::iterator hook = hookList.begin(); hook != hookList.end();
         ++hook) {
        (*hook)->invokeHook(scenario, NULL);
    }
}

HookRegistrar::hook_list_type& HookRegistrar::beforeAllHooks() {
    static hook_list_type beforeAllHooks;
    return beforeAllHooks;
}

void HookRegistrar::addBeforeAllHook(std::shared_ptr<BeforeAllHook> beforeAllHook) {
    beforeAllHooks().push_back(beforeAllHook);
}

void HookRegistrar::execBeforeAllHooks() {
    execHooks(beforeAllHooks(), NULL);
}

HookRegistrar::hook_list_type& HookRegistrar::afterAllHooks() {
    static hook_list_type afterAllHooks;
    return afterAllHooks;
}

void HookRegistrar::addAfterAllHook(std::shared_ptr<AfterAllHook> afterAllHook) {
    afterAllHooks().push_back(afterAllHook);
}

void HookRegistrar::execAfterAllHooks() {
    execHooks(afterAllHooks(), NULL);
}

StepCallChain::StepCallChain(
    Scenario* scenario,
    const StepInfo* const stepInfo,
    const InvokeArgs* pStepArgs,
    HookRegistrar::aroundhook_list_type& aroundHooks
) :
    scenario(scenario),
    stepInfo(stepInfo),
    pStepArgs(pStepArgs) {
    nextHook = aroundHooks.begin();
    hookEnd = aroundHooks.end();
}

InvokeResult StepCallChain::exec() {
    execNext();
    return result;
}

void StepCallChain::execNext() {
    if (nextHook == hookEnd) {
        execStep();
    } else {
        HookRegistrar::aroundhook_list_type::iterator currentHook = nextHook++;
        CallableStepChain callableStepChain(this);
        (*currentHook)->invokeHook(scenario, &callableStepChain);
    }
}

void StepCallChain::execStep() {
    if (stepInfo) {
        result = stepInfo->invokeStep(pStepArgs);
    }
}

CallableStepChain::CallableStepChain(StepCallChain* scc) :
    scc(scc) {
}

void CallableStepChain::call() {
    scc->execNext();
}

}
}


================================================
FILE: src/Regex.cpp
================================================
#include <cucumber-cpp/internal/utils/Regex.hpp>

#include <algorithm>

namespace cucumber {
namespace internal {

Regex::Regex(std::string regularExpression) :
    regexImpl(regularExpression),
    regexString(regularExpression) {
}

bool RegexMatch::matches() {
    return regexMatched;
}

const RegexMatch::submatches_type& RegexMatch::getSubmatches() {
    return submatches;
}

std::string Regex::str() const {
    return regexString;
}

std::shared_ptr<RegexMatch> Regex::find(const std::string& expression) const {
    return std::make_shared<FindRegexMatch>(regexImpl, expression);
}

namespace {
bool isUtf8CodeUnitStartOfCodepoint(unsigned int i) {
    return (i & 0xc0) != 0x80;
}

std::ptrdiff_t utf8CodepointOffset(
    const std::string& expression, const std::string::const_iterator& it
) {
    return count_if(expression.begin(), it, &isUtf8CodeUnitStartOfCodepoint);
}
} // namespace

FindRegexMatch::FindRegexMatch(const std::regex& regexImpl, const std::string& expression) {
    std::smatch matchResults;
    regexMatched = std::regex_search(expression, matchResults, regexImpl);
    if (regexMatched) {
        std::smatch::const_iterator i = matchResults.begin();
        if (i != matchResults.end())
            // Skip capture group 0 which is the whole match, not a user marked sub-expression
            ++i;
        for (; i != matchResults.end(); ++i) {
            if (i->matched) {
                RegexSubmatch s = {*i, utf8CodepointOffset(expression, i->first)};
                submatches.push_back(s);
            } else {
                submatches.push_back(RegexSubmatch());
            }
        }
    }
}

std::shared_ptr<RegexMatch> Regex::findAll(const std::string& expression) const {
    return std::make_shared<FindAllRegexMatch>(regexImpl, expression);
}

FindAllRegexMatch::FindAllRegexMatch(const std::regex& regexImpl, const std::string& expression) {
    std::sregex_token_iterator i(
        expression.begin(), expression.end(), regexImpl, 1, std::regex_constants::match_continuous
    );
    const std::sregex_token_iterator end;
    for (; i != end; ++i) {
        RegexSubmatch s = {*i, -1};
        submatches.push_back(s);
    }
    regexMatched = !submatches.empty();
}

}
}


================================================
FILE: src/Scenario.cpp
================================================
#include <cucumber-cpp/internal/Scenario.hpp>

namespace cucumber {
namespace internal {

Scenario::Scenario(const TagExpression::tag_list& tags) :
    tags(tags) {
}

const TagExpression::tag_list& Scenario::getTags() {
    return tags;
}

}
}


================================================
FILE: src/StepManager.cpp
================================================
#include "cucumber-cpp/internal/step/StepManager.hpp"

namespace cucumber {
namespace internal {

StepInfo::StepInfo(const std::string& stepMatcher, const std::string source) :
    regex(stepMatcher),
    source(source) {
    static step_id_type currentId = 0;
    id = ++currentId;
}

SingleStepMatch StepInfo::matches(const std::string& stepDescription) const {
    SingleStepMatch stepMatch;
    std::shared_ptr<RegexMatch> regexMatch(regex.find(stepDescription));
    if (regexMatch->matches()) {
        stepMatch.stepInfo = shared_from_this();
        stepMatch.submatches = regexMatch->getSubmatches();
    }
    return stepMatch;
}

SingleStepMatch::operator const void*() const {
    return stepInfo.get();
}

MatchResult::operator bool() const {
    return !resultSet.empty();
}

const MatchResult::match_results_type& MatchResult::getResultSet() {
    return resultSet;
}

void MatchResult::addMatch(SingleStepMatch match) {
    resultSet.push_back(match);
}

void InvokeArgs::addArg(const std::string arg) {
    args.push_back(arg);
}

const Table& InvokeArgs::getTableArg() const {
    return tableArg;
}

Table& InvokeArgs::getVariableTableArg() {
    return tableArg;
}

InvokeResult::InvokeResult(const InvokeResultType type, const char* description) :
    type(type) {
    if (description) {
        this->description = description;
    };
}

InvokeResult::InvokeResult() :
    type(FAILURE) {
}

InvokeResult::InvokeResult(const InvokeResult& ir) :
    type(ir.type),
    description(ir.description) {
}

InvokeResult& InvokeResult::operator=(const InvokeResult& rhs) {
    this->type = rhs.type;
    this->description = rhs.description;
    return *this;
}

InvokeResult InvokeResult::success() {
    return InvokeResult(SUCCESS, 0);
}

InvokeResult InvokeResult::failure(const char* description) {
    return InvokeResult(FAILURE, description);
}

InvokeResult InvokeResult::failure(const std::string& description) {
    return InvokeResult(FAILURE, description.c_str());
}

InvokeResult InvokeResult::pending(const char* description) {
    return InvokeResult(PENDING, description);
}

bool InvokeResult::isSuccess() const {
    return (type == SUCCESS);
}

bool InvokeResult::isPending() const {
    return (type == PENDING);
}

InvokeResultType InvokeResult::getType() const {
    return type;
}

const std::string& InvokeResult::getDescription() const {
    return description;
}

step_id_type StepManager::addStep(std::shared_ptr<StepInfo> stepInfo) {
    return steps().insert(std::make_pair(stepInfo->id, stepInfo)).first->first;
}

MatchResult StepManager::stepMatches(const std::string& stepDescription) {
    MatchResult matchResult;
    for (steps_type::iterator iter = steps().begin(); iter != steps().end(); ++iter) {
        const std::shared_ptr<const StepInfo>& stepInfo = iter->second;
        SingleStepMatch currentMatch = stepInfo->matches(stepDescription);
        if (currentMatch) {
            matchResult.addMatch(currentMatch);
        }
    }
    return matchResult;
}

const StepInfo* StepManager::getStep(step_id_type id) {
    const steps_type::const_iterator step = steps().find(id);
    if (step == steps().end()) {
        return NULL;
    }
    return step->second.get();
}

/**
 * Needed to fix the "static initialization order fiasco"
 * http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.12
 */
StepManager::steps_type& StepManager::steps() {
    static steps_type steps;
    return steps;
}

InvokeResult BasicStep::invoke(const InvokeArgs* pArgs) {
    this->pArgs = pArgs;
    currentArgIndex = 0;
    currentResult = InvokeResult::success();
    try {
        InvokeResult returnedResult = invokeStepBody();
        if (currentResult.isPending()) {
            return currentResult;
        } else {
            return returnedResult;
        }
    } catch (const std::exception& ex) {
        return InvokeResult::failure(ex.what());
    } catch (const std::string& ex) {
        return InvokeResult::failure(ex);
    } catch (const char* ex) {
        return InvokeResult::failure(ex);
    } catch (...) {
        // Cucumber needs a description here
        return InvokeResult::failure("Unknown exception");
    }
}

void BasicStep::pending() {
    pending(0);
}

void BasicStep::pending(const char* description) {
    currentResult = InvokeResult::pending(description);
}

const InvokeArgs* BasicStep::getArgs() {
    return pArgs;
}

}
}


================================================
FILE: src/Table.cpp
================================================
#include <cucumber-cpp/internal/Table.hpp>

namespace cucumber {
namespace internal {

void Table::addColumn(const std::string column) {
    if (rows.empty()) {
        columns.push_back(column);
    } else {
        throw std::runtime_error("Cannot alter columns after rows have been added");
    }
}

void Table::addRow(const row_type& row) {
    const basic_type::size_type colSize = columns.size();
    if (colSize == 0) {
        throw std::runtime_error("No column defined yet");
    } else if (colSize != row.size()) {
        throw std::range_error("Row size does not match the table column size");
    } else {
        rows.push_back(buildHashRow(row));
    }
}

Table::hash_row_type Table::buildHashRow(const row_type& row) {
    hash_row_type hashRow;
    for (columns_type::size_type i = 0; i < columns.size(); ++i) {
        hashRow[columns[i]] = row[i];
    }
    return hashRow;
}

const Table::hashes_type& Table::hashes() const {
    return rows;
}

}
}


================================================
FILE: src/Tag.cpp
================================================
#include <cucumber-cpp/internal/hook/Tag.hpp>
#include <memory>

namespace cucumber {
namespace internal {

Regex& AndTagExpression::csvTagNotationRegex() {
    static Regex r("\\s*\"([^\"]+)\"\\s*(?:,|$)");
    return r;
}

AndTagExpression::AndTagExpression(const std::string& csvTagNotation) {
    const std::shared_ptr<RegexMatch> match(csvTagNotationRegex().findAll(csvTagNotation));
    const RegexMatch::submatches_type submatches = match->getSubmatches();
    orExpressions.reserve(submatches.size());
    for (RegexMatch::submatches_type::const_iterator i = submatches.begin(); i != submatches.end();
         ++i) {
        const std::string orCsvTagNotation = i->value;
        orExpressions.push_back(OrTagExpression(orCsvTagNotation));
    }
}

bool AndTagExpression::matches(const tag_list& tags) const {
    bool match = true;
    for (or_expressions_type::const_iterator i = orExpressions.begin();
         i != orExpressions.end() && match;
         ++i) {
        match &= i->matches(tags);
    }
    return match;
}

Regex& OrTagExpression::csvTagNotationRegex() {
    static Regex r("\\s*@(\\w+)\\s*(?:,|$)");
    return r;
}

OrTagExpression::OrTagExpression(const std::string& csvTagNotation) {
    const std::shared_ptr<RegexMatch> match(csvTagNotationRegex().findAll(csvTagNotation));
    const RegexMatch::submatches_type submatches = match->getSubmatches();
    orTags.reserve(submatches.size());
    for (RegexMatch::submatches_type::const_iterator i = submatches.begin(); i != submatches.end();
         ++i) {
        orTags.push_back(i->value);
    }
}

bool OrTagExpression::matches(const tag_list& tags) const {
    for (tag_list::const_iterator i = orTags.begin(); i != orTags.end(); ++i) {
        if (orTagMatchesTagList(*i, tags))
            return true;
    }
    return false;
}

bool OrTagExpression::orTagMatchesTagList(const std::string& currentOrTag, const tag_list& tags)
    const {
    for (tag_list::const_iterator i = tags.begin(); i != tags.end(); ++i) {
        if (*i == currentOrTag)
            return true;
    }
    return false;
}

}
}


================================================
FILE: src/connectors/wire/WireProtocol.cpp
================================================
#include <cucumber-cpp/internal/connectors/wire/WireProtocol.hpp>
#include <cucumber-cpp/internal/connectors/wire/WireProtocolCommands.hpp>

#include <nlohmann/json.hpp>

#include <iostream>
#include <string>
#include <sstream>

using json = nlohmann::json;

namespace cucumber {
namespace internal {

/*
 * Responses
 */

void SuccessResponse::accept(WireResponseVisitor& visitor) const {
    visitor.visit(*this);
}

FailureResponse::FailureResponse(const std::string& message, const std::string& exceptionType) :
    message(message),
    exceptionType(exceptionType) {
}

const std::string FailureResponse::getMessage() const {
    return message;
}

const std::string FailureResponse::getExceptionType() const {
    return exceptionType;
}

void FailureResponse::accept(WireResponseVisitor& visitor) const {
    visitor.visit(*this);
}

PendingResponse::PendingResponse(const std::string& message) :
    message(message) {
}

const std::string PendingResponse::getMessage() const {
    return message;
}

void PendingResponse::accept(WireResponseVisitor& visitor) const {
    visitor.visit(*this);
}

StepMatchesResponse::StepMatchesResponse(const std::vector<StepMatch>& matchingSteps) :
    matchingSteps(matchingSteps) {
}

const std::vector<StepMatch>& StepMatchesResponse::getMatchingSteps() const {
    return matchingSteps;
}

void StepMatchesResponse::accept(WireResponseVisitor& visitor) const {
    visitor.visit(*this);
}

SnippetTextResponse::SnippetTextResponse(const std::string& stepSnippet) :
    stepSnippet(stepSnippet) {
}

const std::string SnippetTextResponse::getStepSnippet() const {
    return stepSnippet;
}

void SnippetTextResponse::accept(WireResponseVisitor& visitor) const {
    visitor.visit(*this);
}

/*
 * Command decoders
 */

namespace {
typedef std::shared_ptr<WireCommand> (*CommandDecoder)(const json& jsonArgs);

CukeEngine::tags_type getScenarioTags(const json& jsonArgs) {
    CukeEngine::tags_type tags;
    if (!jsonArgs.is_null()) {
        const auto& jsonTags = jsonArgs.at("tags");
        for (const auto& tag : jsonTags) {
            tags.push_back(tag.get<std::string>());
        }
    }
    return tags;
}

std::shared_ptr<WireCommand> BeginScenarioDecoder(const json& jsonArgs) {
    return std::make_shared<BeginScenarioCommand>(getScenarioTags(jsonArgs));
}

std::shared_ptr<WireCommand> EndScenarioDecoder(const json& jsonArgs) {
    return std::make_shared<EndScenarioCommand>(getScenarioTags(jsonArgs));
}

std::shared_ptr<WireCommand> StepMatchesDecoder(const json& jsonArgs) {
    const std::string& nameToMatch = jsonArgs.at("name_to_match");
    return std::make_shared<StepMatchesCommand>(nameToMatch);
}

void fillTableArg(const json& jsonTableArg, CukeEngine::invoke_table_type& tableArg) {
    const std::size_t rows = jsonTableArg.size();
    if (rows > 0) {
        const std::size_t columns = jsonTableArg[0].get<std::vector<std::string>>().size();
        tableArg.resize(rows);
        for (std::size_t i = 0; i < rows; ++i) {
            const auto& jsonRow(jsonTableArg[i].get<std::vector<std::string>>());
            if (jsonRow.size() == columns) {
                for (std::size_t j = 0; j < columns; ++j) {
                    tableArg[i].push_back(jsonRow[j]);
                }
            } else {
                // TODO: Invalid row
            }
        }
    } else {
        // TODO: Invalid table (no column specified)
    }
}

void fillInvokeArgs(
    const json& invokeParams,
    CukeEngine::invoke_args_type& args,
    CukeEngine::invoke_table_type& tableArg
) {
    const auto& jsonArgs = invokeParams.at("args");
    for (const auto& arg : jsonArgs) {
        if (arg.is_string()) {
            args.push_back(arg.get<std::string>());
        } else if (arg.is_array()) {
            fillTableArg(arg, tableArg);
        }
    }
}

std::shared_ptr<WireCommand> InvokeDecoder(const json& jsonArgs) {
    const auto& invokeParams = jsonArgs.get<json::object_t>();

    CukeEngine::invoke_args_type args;
    CukeEngine::invoke_table_type tableArg;
    const std::string& id = invokeParams.at("id");
    fillInvokeArgs(invokeParams, args, tableArg);
    return std::make_shared<InvokeCommand>(id, args, tableArg);
}

std::shared_ptr<WireCommand> SnippetTextDecoder(const json& jsonArgs) {
    const auto& snippetTextArgs = jsonArgs.get<json::object_t>();
    const std::string& stepKeyword = snippetTextArgs.at("step_keyword");
    const std::string& stepName = snippetTextArgs.at("step_name");
    const std::string& multilineArgClass = snippetTextArgs.at("multiline_arg_class");
    return std::make_shared<SnippetTextCommand>(stepKeyword, stepName, multilineArgClass);
}
}

static const std::map<std::string, CommandDecoder> commandDecodersMap = {
    {"begin_scenario", BeginScenarioDecoder},
    {"end_scenario", EndScenarioDecoder},
    {"step_matches", StepMatchesDecoder},
    {"invoke", InvokeDecoder},
    {"snippet_text", SnippetTextDecoder},
};

std::shared_ptr<WireCommand> JsonWireMessageCodec::decode(const std::string& request) const {
    try {
        json jsonRequest = json::parse(request);
        const auto& jsonCommand = jsonRequest.at(0);

        const auto& commandDecoder = commandDecodersMap.find(jsonCommand.get<std::string>());
        if (commandDecoder != commandDecodersMap.end() && commandDecoder->second) {
            json jsonArgs;
            if (jsonRequest.size() > 1) {
                jsonArgs = jsonRequest.at(1);
            }
            return commandDecoder->second(jsonArgs);
        }
    } catch (...) {
        // LOG Error decoding wire protocol command
    }
    return std::make_shared<FailingCommand>();
}

namespace {

class WireResponseEncoder : public WireResponseVisitor {
private:
    json jsonOutput = json::array();

    void success(const json* detail = nullptr) {
        output("success", detail);
    }

    void fail(const json* detail = nullptr) {
        output("fail", detail);
    }

    void output(const std::string& responseType, const json* detail = nullptr) {
        jsonOutput.push_back(responseType);
        if (detail == nullptr || detail->is_null()) {
            return;
        }
        jsonOutput.push_back(*detail);
    }

public:
    std::string encode(const WireResponse& response) {
        jsonOutput.clear();
        response.accept(*this);
        return jsonOutput.dump();
    }

    void visit(const SuccessResponse& /*response*/) override {
        success();
    }

    void visit(const FailureResponse& response) override {
        json detailObject;
        if (!response.getMessage().empty()) {
            detailObject["message"] = response.getMessage();
        }
        if (!response.getExceptionType().empty()) {
            detailObject["exception"] = response.getExceptionType();
        }
        if (detailObject.empty()) {
            fail();
        } else {
            const json detail(detailObject);
            fail(&detail);
        }
    }

    void visit(const PendingResponse& response) override {
        json jsonReponse(response.getMessage());
        output("pending", &jsonReponse);
    }

    void visit(const StepMatchesResponse& response) override {
        json jsonMatches = json::array();
        for (const StepMatch& m : response.getMatchingSteps()) {
            json jsonM;
            jsonM["id"] = m.id;
            json jsonArgs = json::array();
            for (const StepMatchArg& ma : m.args) {
                json jsonMa;
                jsonMa["val"] = ma.value;
                jsonMa["pos"] = static_cast<int64_t>(ma.position);
                jsonArgs.push_back(jsonMa);
            }
            jsonM["args"] = jsonArgs;
            if (!m.source.empty()) {
                jsonM["source"] = m.source;
            }
            if (!m.regexp.empty()) {
                jsonM["regexp"] = m.regexp;
            }
            jsonMatches.push_back(jsonM);
        }
        json jsonReponse(jsonMatches);
        output("success", &jsonReponse);
    }

    void visit(const SnippetTextResponse& response) override {
        json jsonReponse(response.getStepSnippet());
        success(&jsonReponse);
    }
};

}

const std::string JsonWireMessageCodec::encode(const WireResponse& response) const {
    try {
        WireResponseEncoder encoder;
        return encoder.encode(response);
    } catch (...) {
        throw WireMessageCodecException("Error decoding wire protocol response");
    }
}

WireProtocolHandler::WireProtocolHandler(const WireMessageCodec& codec, CukeEngine& engine) :
    codec(codec),
    engine(engine) {
}

std::string WireProtocolHandler::handle(const std::string& request) const {
    std::string response;
    // LOG request
    try {
        std::shared_ptr<const WireCommand> command = codec.decode(request);
        std::shared_ptr<const WireResponse> wireResponse = command->run(engine);
        response = codec.encode(*wireResponse);
    } catch (...) {
        response = "[\"fail\"]";
    }
    // LOG response
    return response;
}

} // namespace internal
} // namespace cucumber


================================================
FILE: src/connectors/wire/WireProtocolCommands.cpp
================================================
#include <cucumber-cpp/internal/connectors/wire/WireProtocolCommands.hpp>

namespace cucumber {
namespace internal {

ScenarioCommand::ScenarioCommand(const CukeEngine::tags_type& tags) :
    tags(tags) {
}

BeginScenarioCommand::BeginScenarioCommand(const CukeEngine::tags_type& tags) :
    ScenarioCommand(tags) {
}

std::shared_ptr<WireResponse> BeginScenarioCommand::run(CukeEngine& engine) const {
    engine.beginScenario(tags);
    return std::make_shared<SuccessResponse>();
}

EndScenarioCommand::EndScenarioCommand(const CukeEngine::tags_type& tags) :
    ScenarioCommand(tags) {
}

std::shared_ptr<WireResponse> EndScenarioCommand::run(CukeEngine& engine) const {
    engine.endScenario(tags);
    return std::make_shared<SuccessResponse>();
}

StepMatchesCommand::StepMatchesCommand(const std::string& stepName) :
    stepName(stepName) {
}

std::shared_ptr<WireResponse> StepMatchesCommand::run(CukeEngine& engine) const {
    std::vector<StepMatch> matchingSteps = engine.stepMatches(stepName);
    return std::make_shared<StepMatchesResponse>(matchingSteps);
}

InvokeCommand::InvokeCommand(
    const std::string& stepId,
    const CukeEngine::invoke_args_type& args,
    const CukeEngine::invoke_table_type& tableArg
) :
    stepId(stepId),
    args(args),
    tableArg(tableArg) {
}

std::shared_ptr<WireResponse> InvokeCommand::run(CukeEngine& engine) const {
    try {
        engine.invokeStep(stepId, args, tableArg);
        return std::make_shared<SuccessResponse>();
    } catch (const InvokeFailureException& e) {
        return std::make_shared<FailureResponse>(e.getMessage(), e.getExceptionType());
    } catch (const PendingStepException& e) {
        return std::make_shared<PendingResponse>(e.getMessage());
    } catch (...) {
        return std::make_shared<FailureResponse>();
    }
}

SnippetTextCommand::SnippetTextCommand(
    const std::string& keyword, const std::string& name, const std::string& multilineArgClass
) :
    keyword(keyword),
    name(name),
    multilineArgClass(multilineArgClass) {
}

std::shared_ptr<WireResponse> SnippetTextCommand::run(CukeEngine& engine) const {
    return std::make_shared<SnippetTextResponse>(
        engine.snippetText(keyword, name, multilineArgClass)
    );
}

std::shared_ptr<WireResponse> FailingCommand::run(CukeEngine& /*engine*/) const {
    return std::make_shared<FailureResponse>();
}

}
}


================================================
FILE: src/connectors/wire/WireServer.cpp
================================================
#include <cucumber-cpp/internal/connectors/wire/WireServer.hpp>
#include <filesystem>

namespace cucumber {
namespace internal {

SocketServer::SocketServer(const ProtocolHandler* protocolHandler) :
    protocolHandler(protocolHandler),
    ios() {
}

template<typename Protocol>
void SocketServer::doListen(
    asio::basic_socket_acceptor<Protocol>& acceptor, const typename Protocol::endpoint& endpoint
) {
    if (acceptor.is_open())
        throw std::system_error(asio::error::already_open);
    acceptor.open(endpoint.protocol());
    acceptor.set_option(typename Protocol::acceptor::reuse_address(true));
    acceptor.bind(endpoint);
    acceptor.listen(1);
}

template<typename Protocol>
void SocketServer::doAcceptOnce(asio::basic_socket_acceptor<Protocol>& acceptor) {
    typename Protocol::socket socket(ios);
    acceptor.accept(socket);
    typename Protocol::iostream stream(std::move(socket));
    processStream(stream);
}

void SocketServer::processStream(std::iostream& stream) {
    std::string request;
    while (getline(stream, request)) {
        stream << protocolHandler->handle(request) << std::endl << std::flush;
    }
}

TCPSocketServer::TCPSocketServer(const ProtocolHandler* protocolHandler) :
    SocketServer(protocolHandler),
    acceptor(ios) {
}

void TCPSocketServer::listen(const port_type port) {
    listen(asio::ip::tcp::endpoint(asio::ip::tcp::v4(), port));
}

void TCPSocketServer::listen(const asio::ip::tcp::endpoint endpoint) {
    doListen(acceptor, endpoint);
    acceptor.set_option(asio::ip::tcp::no_delay(true));
}

asio::ip::tcp::endpoint TCPSocketServer::listenEndpoint() const {
    return acceptor.local_endpoint();
}

void TCPSocketServer::acceptOnce() {
    doAcceptOnce(acceptor);
}

#if defined(ASIO_HAS_LOCAL_SOCKETS)
UnixSocketServer::UnixSocketServer(const ProtocolHandler* protocolHandler) :
    SocketServer(protocolHandler),
    acceptor(ios) {
}

void UnixSocketServer::listen(const std::string& unixPath) {
    if (std::filesystem::status(unixPath).type() == std::filesystem::file_type::socket)
        std::filesystem::remove(unixPath);

    doListen(acceptor, asio::local::stream_protocol::endpoint(unixPath));
}

asio::local::stream_protocol::endpoint UnixSocketServer::listenEndpoint() const {
    return acceptor.local_endpoint();
}

void UnixSocketServer::acceptOnce() {
    doAcceptOnce(acceptor);
}

UnixSocketServer::~UnixSocketServer() {
    if (!acceptor.is_open())
        return;
    std::string path = acceptor.local_endpoint().path();
    // NOTE: this will fail if this path got deleted manually or represents an abstract-namespace
    // socket
    std::filesystem::remove(path);
}
#endif

}
}


================================================
FILE: src/drivers/BoostDriver.cpp
================================================
#include <cucumber-cpp/internal/drivers/BoostDriver.hpp>

#include <sstream>

#include <boost/function.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/test/unit_test_log_formatter.hpp>
#include <mutex>
#include <boost/version.hpp>

using namespace ::boost::unit_test;
using ::boost::execution_exception;

namespace cucumber {
namespace internal {

namespace {

test_case* testCase = 0;
boost::function<void()> currentTestBody;

void exec_test_body() {
    if (currentTestBody) {
        currentTestBody();
    }
}

bool boost_test_init() {
    testCase = BOOST_TEST_CASE(&exec_test_body);
    framework::master_test_suite().add(testCase);

    return true;
}

// Freed by Boost's unit test framework on exit
static CukeBoostLogInterceptor* logInterceptor = 0;

}

class CukeBoostLogInterceptor : public ::boost::unit_test::unit_test_log_formatter {
public:
    const InvokeResult getResult() const;
    void reset();

    // Formatter
    void log_start(std::ostream&, counter_t /*test_cases_amount*/) override{};
    void log_finish(std::ostream&) override{};
    void log_build_info(std::ostream&, bool /*log_build_info*/) override{};

    void test_unit_start(std::ostream&, test_unit const& /*tu*/) override{};
    void test_unit_finish(std::ostream&, test_unit const& /*tu*/, unsigned long /*elapsed*/)
        override{};
    void test_unit_skipped(std::ostream&, test_unit const& /*tu*/) override{};

    void log_exception_start(std::ostream&, log_checkpoint_data const&, execution_exception const&)
        override{};
    void log_exception_finish(std::ostream&) override{};

    void log_entry_start(std::ostream&, log_entry_data const&, log_entry_types /*let*/) override{};
    void log_entry_value(std::ostream&, const_string value) override;
    void log_entry_value(std::ostream&, lazy_ostream const& value) override;
    void log_entry_finish(std::ostream&) override{};

    void entry_context_start(std::ostream&, log_level /*l*/) override {
    }
    void log_entry_context(std::ostream&, log_level /*l*/, const_string /*value*/) override {
    }
    void entry_context_finish(std::ostream&, log_level /*l*/) override {
    }

private:
    std::stringstream description;
};

void CukeBoostLogInterceptor::reset() {
    description.str("");
}

/*
 * Threshold level set to log_all_errors, so we should be fine logging everything
 */
void CukeBoostLogInterceptor::log_entry_value(std::ostream&, const_string value) {
    description << value;
}

void CukeBoostLogInterceptor::log_entry_value(std::ostream&, lazy_ostream const& value) {
    description << value;
}

const InvokeResult CukeBoostLogInterceptor::getResult() const {
    std::string d = description.str();
    if (d.empty()) {
        return InvokeResult::success();
    } else {
        return InvokeResult::failure(description.str());
    }
}

const InvokeResult BoostStep::invokeStepBody() {
    static std::once_flag initialized;
    std::call_once(initialized, BoostStep::initBoostTest);

    logInterceptor->reset();
    runWithMasterSuite();
    return logInterceptor->getResult();
}

void BoostStep::initBoostTest() {
    int argc = 1;
    char dummyArg[] = "dummy";
    char* argv[] = {dummyArg};
    framework::init(&boost_test_init, argc, argv);
    framework::finalize_setup_phase();

    logInterceptor = new CukeBoostLogInterceptor;
    ::boost::unit_test::unit_test_log.set_formatter(logInterceptor);
    ::boost::unit_test::unit_test_log.set_threshold_level(log_all_errors);
}

void BoostStep::runWithMasterSuite() {
    currentTestBody = std::bind(&BoostStep::body, this);

    ::boost::unit_test::framework::run(testCase, false);

    currentTestBody.clear();
}

}
}


================================================
FILE: src/drivers/GTestDriver.cpp
================================================
#include <cucumber-cpp/internal/drivers/GTestDriver.hpp>

#include <gtest/gtest.h>

namespace cucumber {
namespace internal {

bool GTestStep::initialized(false);

const InvokeResult GTestStep::invokeStepBody() {
    if (!initialized) {
        initGTest();
        initFlags();
    }
    try {
        body();
        return InvokeResult::success();
    } catch (const ::std::runtime_error& e) {
        // ::testing::GoogleTestFailureException inherits from ::std::runtime_error
        return InvokeResult::failure(e.what());
    }
}

void GTestStep::initGTest() {
    int fake_argc = 1;
    char* fake_argv[1];
    fake_argv[0] = (char*)"cucumber-cpp";
    ::testing::InitGoogleTest(&fake_argc, fake_argv);
    initialized = true;
}

void GTestStep::initFlags() {
    ::testing::GTEST_FLAG(throw_on_failure) = true;  // let cucumber-cpp drive
    ::testing::GTEST_FLAG(break_on_failure) = false; // turn off debugger breakpoints
    ::testing::GTEST_FLAG(catch_exceptions) = true;
}

}
}


================================================
FILE: src/drivers/GenericDriver.cpp
================================================
#include "cucumber-cpp/internal/drivers/GenericDriver.hpp"

namespace cucumber {
namespace internal {

const InvokeResult GenericStep::invokeStepBody() {
    // No try/catch block to throw the original exceptions to the testing framework
    body();
    return InvokeResult::success();
}

}
}


================================================
FILE: src/drivers/QtTestDriver.cpp
================================================
#include "cucumber-cpp/internal/drivers/QtTestDriver.hpp"

#include <QTest>
#include <QTemporaryFile>
#include <QTextStream>

namespace cucumber {
namespace internal {

/**
 * Wraps the QTemporaryFile for Windows.
 *
 * On Windows. the file can not be written as long as QTemporaryFile keeps it open.
 */
class TemporaryFileWrapper {
public:
    ~TemporaryFileWrapper() {
        QFile::remove(filename);
    }

    bool exists() const {
        return !filename.isEmpty();
    }

    QString name() const {
        return filename;
    }

    QString read() const {
        QFile file{filename};
        if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
            return QString();
        QTextStream in(&file);
        return in.readAll();
    }

private:
    const QString filename{getTmpFileName()};

    static QString getTmpFileName() {
        QTemporaryFile tempFile{};
        if (!tempFile.open()) {
            return {};
        }
        return tempFile.fileName() + ".txt";
    }
};

const InvokeResult QtTestStep::invokeStepBody() {
    const TemporaryFileWrapper file{};
    if (!file.exists()) {
        return InvokeResult::failure("Unable to open temporary file needed for this test");
    }

    QtTestObject testObject{this};
    const QStringList args{"test", "-o", file.name() + ",tap"};
    const int returnValue = QTest::qExec(&testObject, args);

    if (returnValue == 0) {
        return InvokeResult::success();
    } else {
        return InvokeResult::failure(file.read().toLocal8Bit());
    }
}

}
}


================================================
FILE: src/main.cpp
================================================
#include <cucumber-cpp/internal/CukeEngineImpl.hpp>
#include <cucumber-cpp/internal/CukeExport.hpp>
#include <cucumber-cpp/internal/connectors/wire/WireServer.hpp>
#include <cucumber-cpp/internal/connectors/wire/WireProtocol.hpp>
#include <iostream>
#include <memory>
#include <tclap/CmdLine.h>

namespace {

void acceptWireProtocol(
    const std::string& host, int port, const std::string& unixPath, bool verbose
) {
    using namespace ::cucumber::internal;
    CukeEngineImpl cukeEngine;
    JsonWireMessageCodec wireCodec;
    WireProtocolHandler protocolHandler(wireCodec, cukeEngine);
    std::unique_ptr<SocketServer> server;
#if defined(ASIO_HAS_LOCAL_SOCKETS)
    if (!unixPath.empty()) {
        UnixSocketServer* const unixServer = new UnixSocketServer(&protocolHandler);
        server.reset(unixServer);
        unixServer->listen(unixPath);
        if (verbose)
            std::clog << "Listening on socket " << unixServer->listenEndpoint() << std::endl;
    } else
#else
    // Prevent warning about unused parameter
    static_cast<void>(unixPath);
#endif
    {
        TCPSocketServer* const tcpServer = new TCPSocketServer(&protocolHandler);
        server.reset(tcpServer);
        tcpServer->listen(asio::ip::tcp::endpoint(asio::ip::make_address(host), port));
        if (verbose)
            std::clog << "Listening on " << tcpServer->listenEndpoint() << std::endl;
    }
    server->acceptOnce();
}

}

int CUCUMBER_CPP_EXPORT main(int argc, char** argv) {
    TCLAP::CmdLine cmd("C++ Cucumber wireserver", ' ', CUKE_VERSION);

    TCLAP::SwitchArg verboseArg("v", "verbose", "Verbose output", cmd, false);
    TCLAP::ValueArg<std::string> listenArg(
        "l", "listen", "Listening address of wireserver", false, "127.0.0.1", "string"
    );
    cmd.add(listenArg);
    TCLAP::ValueArg<int> portArg(
        "p",
        "port",
        "Listening port of wireserver, use '0' (zero) to select an ephemeral port",
        false,
        3902,
        "int"
    );
    cmd.add(portArg);

#if defined(ASIO_HAS_LOCAL_SOCKETS)
    TCLAP::ValueArg<std::string> unixArg(
        "u",
        "unix",
        "Listening unix socket of wireserver (disables listening on port)",
        false,
        "",
        "string"
    );
    cmd.add(unixArg);
#endif

    cmd.parse(argc, argv);

    std::string unixPath;
    std::string listenHost = listenArg.getValue();
    int port = portArg.getValue();
#if defined(ASIO_HAS_LOCAL_SOCKETS)
    unixPath = unixArg.getValue();
#endif

    bool verbose = verboseArg.getValue();

    try {
        acceptWireProtocol(listenHost, port, unixPath, verbose);
    } catch (std::exception& e) {
        std::cerr << e.what() << std::endl;
        exit(1);
    }
    return 0;
}


================================================
FILE: tests/CMakeLists.txt
================================================
find_package(GTest REQUIRED)

add_library(utils INTERFACE
    utils/HookRegistrationFixture.hpp
    utils/ContextManagerTestDouble.hpp
    utils/DriverTestRunner.hpp
    utils/CukeCommandsFixture.hpp
    utils/StepManagerTestDouble.hpp
)
target_include_directories(utils INTERFACE
    .
)

function(cuke_add_driver_test TEST_FILE)
    get_filename_component(TEST_NAME ${TEST_FILE} NAME)
    message(STATUS "Adding " ${TEST_NAME})
    add_executable(${TEST_NAME} ${TEST_FILE}.cpp)
    target_link_libraries(${TEST_NAME} PRIVATE cucumber-cpp-internal utils ${ARGN})
    add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME})
endfunction()

if(TARGET GTest::gmock_main)
    function(cuke_add_test TEST_FILE)
        get_filename_component(TEST_NAME ${TEST_FILE} NAME)
        message(STATUS "Adding " ${TEST_NAME})
        add_executable(${TEST_NAME} ${TEST_FILE}.cpp)
        target_link_libraries(${TEST_NAME} PRIVATE cucumber-cpp-internal utils ${ARGN} GTest::gmock_main)
        gtest_add_tests(${TEST_NAME} "" ${TEST_FILE}.cpp)
        # Run all tests in executable at once too. This ensures that the used fixtures get tested
        # properly too. Additionally gather the output in jUnit compatible output for CI.
        add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME} "--gtest_output=xml:TEST-${TEST_NAME}.xml")
    endfunction()

    # TODO Compile tests with the least possible code, not with the entire library
    cuke_add_test(integration/ContextHandlingTest)
    cuke_add_test(integration/HookRegistrationTest)
    cuke_add_test(integration/StepRegistrationTest)
    cuke_add_test(integration/TaggedHookRegistrationTest)
    if(NOT WIN32)
        cuke_add_test(integration/WireServerTest)
    endif()
    cuke_add_test(integration/WireProtocolTest)
    cuke_add_test(unit/BasicStepTest)
    cuke_add_test(unit/ContextManagerTest)
    cuke_add_test(unit/CukeCommandsTest)
    cuke_add_test(unit/RegexTest)
    cuke_add_test(unit/StepCallChainTest)
    cuke_add_test(unit/StepManagerTest)
    cuke_add_test(unit/TableTest)
    cuke_add_test(unit/TagTest)
endif()

if(TARGET GTest::gtest_main)
    cuke_add_driver_test(integration/drivers/GTestDriverTest GTest::gtest_main)
endif()

if(TARGET Boost::unit_test_framework)
    cuke_add_driver_test(integration/drivers/BoostDriverTest Boost::unit_test_framework)
endif()

if((TARGET Qt::Test)
    # FIXME: not including this in the test suite due to memory leak #190
    AND (NOT VALGRIND_TESTS)
    )
    cuke_add_driver_test(integration/drivers/QtTestDriverTest Qt::Test)
endif()

cuke_add_driver_test(integration/drivers/GenericDriverTest)


================================================
FILE: tests/integration/ContextHandlingTest.cpp
================================================
#include <gtest/gtest.h>

#include "utils/ContextManagerTestDouble.hpp"

using namespace std;
using namespace cucumber::internal;

class ContextHandlingTest : public ::testing::Test {
public:
    ContextHandlingTest() :
        contextManager() {
    }

protected:
    ContextManagerTestDouble contextManager;

private:
    void TearDown() override {
        contextManager.purgeContexts();
    }
};

struct Context1 {
    int i;
};
struct Context2 {};

TEST_F(ContextHandlingTest, contextsAreCreatedWhenNeeded) {
    ASSERT_EQ(0, contextManager.countContexts());
    ::cucumber::ScenarioScope<Context1> context1;
    ASSERT_EQ(1, contextManager.countContexts());
    ::cucumber::ScenarioScope<Context2> context2;
    ASSERT_EQ(2, contextManager.countContexts());
}

TEST_F(ContextHandlingTest, sameContextTypesShareTheSamePointer) {
    ::cucumber::ScenarioScope<Context1> context1_a;
    ::cucumber::ScenarioScope<Context1> context1_b;
    context1_a->i = 42;
    ASSERT_EQ(context1_a->i, context1_b->i);
}

TEST_F(ContextHandlingTest, theSameContextIsNotCreatedTwice) {
    ASSERT_EQ(0, contextManager.countContexts());
    ::cucumber::ScenarioScope<Context1> context1_a;
    ASSERT_EQ(1, contextManager.countContexts());
    ::cucumber::ScenarioScope<Context1> context1_b;
    ASSERT_EQ(1, contextManager.countContexts());
}

TEST_F(ContextHandlingTest, contextsArePurgedExplicitlyOnly) {
    ASSERT_EQ(0, contextManager.countContexts());
    ::cucumber::ScenarioScope<Context1> context1_a;
    ASSERT_EQ(1, contextManager.countContexts());
    ::cucumber::ScenarioScope<Context2>* context1_b = new ::cucumber::ScenarioScope<Context2>();
    ASSERT_EQ(2, contextManager.countContexts());
    delete context1_b;
    ASSERT_EQ(2, contextManager.countContexts());
    contextManager.purgeContexts();
    ASSERT_EQ(0, contextManager.countContexts());
}


================================================
FILE: tests/integration/HookRegistrationTest.cpp
================================================
#include <gtest/gtest.h>

#include "utils/HookRegistrationFixture.hpp"

#include <cucumber-cpp/internal/hook/HookMacros.hpp>

#define BEFORE_ALL_MARKER_1 "A"
#define BEFORE_ALL_MARKER_2 "B"
#define BEFORE_ALL_MARKER_3 "C"
BEFORE_ALL() {
    beforeAllHookCallMarker << BEFORE_ALL_MARKER_1;
}
BEFORE_ALL() {
    beforeAllHookCallMarker << BEFORE_ALL_MARKER_2;
}
BEFORE_ALL() {
    beforeAllHookCallMarker << BEFORE_ALL_MARKER_3;
}

#define BEFORE_MARKER_1 "D"
#define BEFORE_MARKER_2 "E"
#define BEFORE_MARKER_3 "F"
BEFORE() {
    beforeHookCallMarker << BEFORE_MARKER_1;
}
BEFORE() {
    beforeHookCallMarker << BEFORE_MARKER_2;
}
BEFORE() {
    beforeHookCallMarker << BEFORE_MARKER_3;
}

#define AROUND_STEP_MARKER_BEFORE_1 "G"
#define AROUND_STEP_MARKER_BEFORE_2 "H"
#define AROUND_STEP_MARKER_BEFORE_3 "I"
#define AROUND_STEP_MARKER_AFTER_3 "g"
#define AROUND_STEP_MARKER_AFTER_2 "h"
#define AROUND_STEP_MARKER_AFTER_1 "i"
AROUND_STEP() {
    beforeAroundStepHookCallMarker << AROUND_STEP_MARKER_BEFORE_1;
    globalStepHookCallMarker << AROUND_STEP_MARKER_BEFORE_1;
    step->call();
    globalStepHookCallMarker << AROUND_STEP_MARKER_AFTER_1;
    afterAroundStepHookCallMarker << AROUND_STEP_MARKER_AFTER_1;
}
AROUND_STEP() {
    beforeAroundStepHookCallMarker << AROUND_STEP_MARKER_BEFORE_2;
    globalStepHookCallMarker << AROUND_STEP_MARKER_BEFORE_2;
    step->call();
    globalStepHookCallMarker << AROUND_STEP_MARKER_AFTER_2;
    afterAroundStepHookCallMarker << AROUND_STEP_MARKER_AFTER_2;
}
AROUND_STEP() {
    beforeAroundStepHookCallMarker << AROUND_STEP_MARKER_BEFORE_3;
    globalStepHookCallMarker << AROUND_STEP_MARKER_BEFORE_3;
    step->call();
    globalStepHookCallMarker << AROUND_STEP_MARKER_AFTER_3;
    afterAroundStepHookCallMarker << AROUND_STEP_MARKER_AFTER_3;
}

#define AFTER_STEP_MARKER_1 "J"
#define AFTER_STEP_MARKER_2 "K"
#define AFTER_STEP_MARKER_3 "L"
AFTER_STEP() {
    afterStepHookCallMarker << AFTER_STEP_MARKER_1;
    globalStepHookCallMarker << AFTER_STEP_MARKER_1;
}
AFTER_STEP() {
    afterStepHookCallMarker << AFTER_STEP_MARKER_2;
    globalStepHookCallMarker << AFTER_STEP_MARKER_2;
}
AFTER_STEP() {
    afterStepHookCallMarker << AFTER_STEP_MARKER_3;
    globalStepHookCallMarker << AFTER_STEP_MARKER_3;
}

#define AFTER_MARKER_1 "M"
#define AFTER_MARKER_2 "N"
#define AFTER_MARKER_3 "O"
AFTER() {
    afterHookCallMarker << AFTER_MARKER_1;
}
AFTER() {
    afterHookCallMarker << AFTER_MARKER_2;
}
AFTER() {
    afterHookCallMarker << AFTER_MARKER_3;
}

#define AFTER_ALL_MARKER_1 "P"
#define AFTER_ALL_MARKER_2 "Q"
#define AFTER_ALL_MARKER_3 "R"
AFTER_ALL() {
    afterAllHookCallMarker << AFTER_ALL_MARKER_1;
}
AFTER_ALL() {
    afterAllHookCallMarker << AFTER_ALL_MARKER_2;
}
AFTER_ALL() {
    afterAllHookCallMarker << AFTER_ALL_MARKER_3;
}

#define CONTEXT_MARKER "X"
BEFORE() {
    cucumber::ScenarioScope<std::string> context;
    *context = CONTEXT_MARKER;
}
AFTER() {
    cucumber::ScenarioScope<std::string> context;
    contextContents = *context;
}

const std::string correctBeforeOrder(BEFORE_MARKER_1 BEFORE_MARKER_2 BEFORE_MARKER_3);
const std::string correctBeforeAroundStepOrder(
    AROUND_STEP_MARKER_BEFORE_1 AROUND_STEP_MARKER_BEFORE_2 AROUND_STEP_MARKER_BEFORE_3
);
const std::string correctAfterAroundStepOrder(AROUND_STEP_MARKER_AFTER_3 AROUND_STEP_MARKER_AFTER_2
                                                  AROUND_STEP_MARKER_AFTER_1);
const std::string correctAfterStepOrder(AFTER_STEP_MARKER_1 AFTER_STEP_MARKER_2 AFTER_STEP_MARKER_3
);
const std::string correctAfterOrder(AFTER_MARKER_1 AFTER_MARKER_2 AFTER_MARKER_3);
const std::string correctBeforeAllOrder(BEFORE_ALL_MARKER_1 BEFORE_ALL_MARKER_2 BEFORE_ALL_MARKER_3
);
const std::string correctAfterAllOrder(AFTER_ALL_MARKER_1 AFTER_ALL_MARKER_2 AFTER_ALL_MARKER_3);

TEST_F(HookRegistrationTest, hooksAreRegisteredByTheMacros) {
    beginScenario();
    EXPECT_EQ(correctBeforeOrder, sort(beforeHookOrder()));
    EXPECT_EQ(correctBeforeAroundStepOrder, sort(aroundStepHookOrder()));
    EXPECT_EQ(correctAfterStepOrder, sort(afterStepHookOrder()));
    EXPECT_EQ(correctAfterOrder, sort(afterHookOrder()));
    endScenario();
}

TEST_F(HookRegistrationTest, beforeHooksAreInvokedInAnyOrder) {
    EXPECT_EQ("", beforeHookCallMarker.str());
    beginScenario();
    EXPECT_EQ(correctBeforeOrder, sort(beforeHookCallMarker.str()));
    invokeStep();
    endScenario();
    EXPECT_EQ(correctBeforeOrder, sort(beforeHookCallMarker.str()));
}

TEST_F(HookRegistrationTest, aroundStepHooksAreInvokedInAnyOrderButNested) {
    beginScenario();
    EXPECT_EQ("", beforeAroundStepHookCallMarker.str());
    invokeStep();
    EXPECT_EQ(correctBeforeAroundStepOrder, sort(beforeAroundStepHookCallMarker.str()));
    EXPECT_EQ(correctAfterAroundStepOrder, sort(afterAroundStepHookCallMarker.str()));
    endScenario();
    EXPECT_EQ(correctBeforeAroundStepOrder, sort(beforeAroundStepHookCallMarker.str()));
    EXPECT_EQ(correctAfterAroundStepOrder, sort(afterAroundStepHookCallMarker.str()));
}

TEST_F(HookRegistrationTest, afterStepHooksAreInvokedInAnyOrder) {
    beginScenario();
    EXPECT_EQ("", afterStepHookCallMarker.str());
    invokeStep();
    EXPECT_EQ(correctAfterStepOrder, sort(afterStepHookCallMarker.str()));
    endScenario();
    EXPECT_EQ(correctAfterStepOrder, sort(afterStepHookCallMarker.str()));
}

TEST_F(HookRegistrationTest, afterHooksAreInvokedInAnyOrder) {
    beginScenario();
    invokeStep();
    invokeStep();
    EXPECT_EQ("", sort(afterHookCallMarker.str()));
    endScenario();
    EXPECT_EQ(correctAfterOrder, sort(afterHookCallMarker.str()));
}

TEST_F(HookRegistrationTest, contextIsAccessibleInAfterHooks) {
    beginScenario();
    endScenario();
    EXPECT_EQ(CONTEXT_MARKER, contextContents);
}

TEST_F(HookRegistrationTest, afterStepHooksAreInvokedAfterAroundStepHooks) {
    beginScenario();
    EXPECT_EQ("", globalStepHookCallMarker.str());
    invokeStep();
    EXPECT_EQ(
        beforeAroundStepHookCallMarker.str() + afterAroundStepHookCallMarker.str()
            + afterStepHookCallMarker.str(),
        globalStepHookCallMarker.str()
    );
    endScenario();
}

TEST_F(HookRegistrationTest, beforeAllHooksAreInvokedInAnyOrderDuringFirstScenarioOnly) {
    EXPECT_EQ("", afterAllHookCallMarker.str());
    beginScenario();
    EXPECT_EQ(correctBeforeAllOrder, sort(beforeAllHookCallMarker.str()));

    clearHookCallMarkers();
    invokeStep();
    endScenario();
    EXPECT_EQ("", sort(beforeAllHookCallMarker.str()));
    beginScenario();
    invokeStep();
    endScenario();
    EXPECT_EQ("", sort(beforeAllHookCallMarker.str()));
}

TEST_F(HookRegistrationTest, beforeAllHooksAreNotInvokedIfNoScenariosRun) {
    clearHookCallMarkers();
    CukeCommands* cukeCommands = new CukeCommands();
    EXPECT_EQ("", afterAllHookCallMarker.str());

    delete cukeCommands;
    cukeCommands = NULL;

    EXPECT_EQ("", beforeAllHookCallMarker.str());
}

TEST_F(HookRegistrationTest, afterAllHooksAreNotInvokedIfNoScenariosRun) {
    clearHookCallMarkers();
    CukeCommands* cukeCommands = new CukeCommands();
    EXPECT_EQ("", afterAllHookCallMarker.str());

    delete cukeCommands;
    cukeCommands = NULL;

    EXPECT_EQ("", afterAllHookCallMarker.str());
}

TEST_F(HookRegistrationTest, afterAllHooksAreInvokedOnceDuringDestructionOnly) {
    clearHookCallMarkers();
    CukeCommands* cukeCommands = new CukeCommands();

    EXPECT_EQ("", afterAllHookCallMarker.str());
    cukeCommands->beginScenario();
    cukeCommands->endScenario();
    EXPECT_EQ("", afterAllHookCallMarker.str());
    cukeCommands->beginScenario();
    cukeCommands->endScenario();
    EXPECT_EQ("", afterAllHookCallMarker.str());

    delete cukeCommands;
    cukeCommands = NULL;

    EXPECT_EQ(correctAfterAllOrder, sort(afterAllHookCallMarker.str()));
}


================================================
FILE: tests/integration/StepRegistrationTest.cpp
================================================
#include <gtest/gtest.h>

#include <cucumber-cpp/internal/step/StepManager.hpp>
#include <cucumber-cpp/internal/step/StepMacros.hpp>
#include <cucumber-cpp/internal/drivers/GenericDriver.hpp>

using namespace cucumber::internal;

#define MANUAL_STEP_MATCHER "manual step"

class ManualStep : public GenericStep {
public:
    void body() override{};
    // private:
    static const int cukeRegId;
};
const int ManualStep::cukeRegId = ::cucumber::internal::registerStep<ManualStep>(
    MANUAL_STEP_MATCHER, "C:\\Path\\With/Barward/And\\Forward/Slashes.cpp", 42
);

TEST(StepRegistrationTest, manualRegistration) {
    // static_cast is necessary for GTest <= 1.7 and C++ >= 2011 because it
    // doesn't support contextually-convertible-to-bool
    EXPECT_TRUE(static_cast<bool>(StepManager::stepMatches(MANUAL_STEP_MATCHER)));
    EXPECT_EQ("Slashes.cpp:42", StepManager::getStep(ManualStep::cukeRegId)->source);
}

#define GIVEN_MATCHER "given matcher"
#define WHEN_MATCHER "when matcher"
#define THEN_MATCHER "then matcher"

GIVEN(GIVEN_MATCHER) {
}
WHEN(WHEN_MATCHER) {
}
THEN(THEN_MATCHER) {
}

TEST(StepRegistrationTest, macroRegistration) {
    EXPECT_TRUE(static_cast<bool>(StepManager::stepMatches(GIVEN_MATCHER)));
    EXPECT_TRUE(static_cast<bool>(StepManager::stepMatches(WHEN_MATCHER)));
    EXPECT_TRUE(static_cast<bool>(StepManager::stepMatches(THEN_MATCHER)));
}


================================================
FILE: tests/integration/TaggedHookRegistrationTest.cpp
================================================
#include <gtest/gtest.h>

#include "utils/HookRegistrationFixture.hpp"
#include <cucumber-cpp/internal/hook/HookMacros.hpp>

BEFORE("@a") {
    beforeHookCallMarker << "A";
}
BEFORE("@a", "@b") {
    beforeHookCallMarker << "B";
}
BEFORE("@a,@b") {
    beforeHookCallMarker << "C";
}

AROUND_STEP("@a") {
    afterAroundStepHookCallMarker << "D";
    step->call();
}
AROUND_STEP("@a", "@b") {
    afterAroundStepHookCallMarker << "E";
    step->call();
}
AROUND_STEP("@a,@b") {
    afterAroundStepHookCallMarker << "F";
    step->call();
}

AFTER_STEP("@a") {
    afterStepHookCallMarker << "G";
}
AFTER_STEP("@a", "@b") {
    afterStepHookCallMarker << "H";
}
AFTER_STEP("@a,@b") {
    afterStepHookCallMarker << "I";
}

AFTER("@a") {
    afterHookCallMarker << "J";
}
AFTER("@a", "@b") {
    afterHookCallMarker << "K";
}
AFTER("@a,@b") {
    afterHookCallMarker << "L";
}

TEST_F(HookRegistrationTest, noTaggedHooksAreInvokedIfNoScenarioTag) {
    beginScenario();
    invokeStep();
    endScenario();
    EXPECT_EQ("", sort(beforeHookCallMarker.str()));
    EXPECT_EQ("", sort(afterAroundStepHookCallMarker.str()));
    EXPECT_EQ("", sort(afterStepHookCallMarker.str()));
    EXPECT_EQ("", sort(afterHookCallMarker.str()));
}

TEST_F(HookRegistrationTest, orTagsAreEnforced) {
    const TagExpression::tag_list tags = {"b"};
    beginScenario(tags);
    invokeStep();
    endScenario();
    EXPECT_EQ("C", sort(beforeHookCallMarker.str()));
    EXPECT_EQ("F", sort(afterAroundStepHookCallMarker.str()));
    EXPECT_EQ("I", sort(afterStepHookCallMarker.str()));
    EXPECT_EQ("L", sort(afterHookCallMarker.str()));
}

TEST_F(HookRegistrationTest, andTagsAreEnforced) {
    const TagExpression::tag_list tags = {"a", "b"};
    beginScenario(tags);
    invokeStep();
    endScenario();
    EXPECT_EQ("ABC", sort(beforeHookCallMarker.str()));
    EXPECT_EQ("DEF", sort(afterAroundStepHookCallMarker.str()));
    EXPECT_EQ("GHI", sort(afterStepHookCallMarker.str()));
    EXPECT_EQ("JKL", sort(afterHookCallMarker.str()));
}


================================================
FILE: tests/integration/WireProtocolTest.cpp
================================================
#include <cucumber-cpp/internal/connectors/wire/WireProtocol.hpp>
#include <cucumber-cpp/internal/connectors/wire/WireProtocolCommands.hpp>

#include <gmock/gmock.h>

#include <typeinfo>

using namespace cucumber::internal;
using namespace std;
using namespace testing;

class MockCukeEngine : public CukeEngine {
public:
    MOCK_METHOD(std::vector<StepMatch>, stepMatches, (const std::string& name), (const, override));
    MOCK_METHOD(void, endScenario, (const tags_type& tags), (override));
    MOCK_METHOD(
        void,
        invokeStep,
        (const std::string& id, const invoke_args_type& args, const invoke_table_type& tableArg),
        (override)
    );
    MOCK_METHOD(void, beginScenario, (const tags_type& tags), (override));
    MOCK_METHOD(
        std::string,
        snippetText,
        (const std::string& keyword, const std::string& name, const std::string& multilineArgClass),
        (const, override)
    );
};

#define EXPECT_PTRTYPE(classname, expression) \
    EXPECT_NE(dynamic_cast<const classname*>(expression), (void*)NULL)

class WireMessageCodecTest : public Test {
protected:
    std::shared_ptr<WireCommand> commandAutoPtr;

    WireCommand& decode(const char* jsonStr) {
        commandAutoPtr = codec.decode(jsonStr);
        return *commandAutoPtr;
    }

    std::string encode(const WireResponse& response) const {
        return codec.encode(response);
    }

protected:
    const JsonWireMessageCodec codec;
};

/*
 * Request decoding
 */

TEST_F(WireMessageCodecTest, decodesUnknownOrMalformedMessage) {
    MockCukeEngine engine;

    EXPECT_EQ(encode(*decode("[\"unknown_command\"]").run(engine)), "[\"fail\"]");
    EXPECT_EQ(encode(*decode("").run(engine)), "[\"fail\"]");
    EXPECT_EQ(encode(*decode("rubbish").run(engine)), "[\"fail\"]");
    EXPECT_EQ(encode(*decode("{\"malformed_command\"}").run(engine)), "[\"fail\"]");
    EXPECT_EQ(encode(*decode("[42]").run(engine)), "[\"fail\"]");
}

TEST_F(WireMessageCodecTest, handlesStepMatchesMessage) {
    MockCukeEngine engine;
    EXPECT_CALL(engine, stepMatches("name to match"))
        .Times(1)
        .WillRepeatedly(Return(std::vector<StepMatch>(0)));

    decode(R"json([
        "step_matches", {
            "name_to_match": "name to match"
        }
    ])json")
        .run(engine);
}

TEST_F(WireMessageCodecTest, handlesBeginScenarioMessageWithoutArgument) {
    MockCukeEngine engine;
    EXPECT_CALL(engine, beginScenario(ElementsAre())).Times(1);

    decode(R"json([
        "begin_scenario"
    ])json")
        .run(engine);
}

TEST_F(WireMessageCodecTest, handlesBeginScenarioMessageWithTagsArgument) {
    MockCukeEngine engine;
    EXPECT_CALL(engine, beginScenario(ElementsAre("bar", "baz", "foo"))).Times(1);

    decode(R"json([
        "begin_scenario", {
            "tags": ["bar", "baz", "foo"]
        }
    ])json")
        .run(engine);
}

TEST_F(WireMessageCodecTest, handlesBeginScenarioMessageWithNullArgument) {
    MockCukeEngine engine;
    EXPECT_CALL(engine, beginScenario(ElementsAre())).Times(1);

    decode(R"json([
        "begin_scenario",
        null
    ])json")
        .run(engine);
}

TEST_F(WireMessageCodecTest, handlesInvokeMessageWithNoArgs) {
    MockCukeEngine engine;
    EXPECT_CALL(engine, invokeStep("42", ElementsAre(), ElementsAre())).Times(1);

    decode(R"json([
        "invoke", {
            "id": "42",
            "args": []
        }
    ])json")
        .run(engine);
}

TEST_F(WireMessageCodecTest, handlesInvokeMessageWithoutTableArgs) {
    MockCukeEngine engine;
    EXPECT_CALL(engine, invokeStep("42", ElementsAre("p1", "p2", "p3"), ElementsAre())).Times(1);

    decode(R"json([
        "invoke", {
            "id": "42",
            "args": ["p1", "p2", "p3"]
        }
    ])json")
        .run(engine);
}

TEST_F(WireMessageCodecTest, handlesInvokeMessageWithTableArgs) {
    MockCukeEngine engine;
    EXPECT_CALL(
        engine,
        invokeStep(
            "42",
            ElementsAre("p1"),
            ElementsAre(
                ElementsAre("col1", "col2"),
                ElementsAre("r1c1", "r1c2"),
                ElementsAre("r2c1", "r2c2"),
                ElementsAre("r3c1", "r3c2")
            )
        )
    )
        .Times(1);

    decode(R"json([
        "invoke", {
            "id": "42",
            "args": [
                "p1",
                [
                    ["col1", "col2"],
                    ["r1c1", "r1c2"],
                    ["r2c1", "r2c2"],
                    ["r3c1", "r3c2"]
                ]
            ]
        }
    ])json")
        .run(engine);
}

TEST_F(WireMessageCodecTest, handlesInvokeMessageWithNullArg) {
    MockCukeEngine engine;
    EXPECT_CALL(engine, invokeStep("42", ElementsAre(), ElementsAre())).Times(1);

    decode(R"json([
        "invoke", {
            "id": "42",
            "args": [null]
        }
    ])json")
        .run(engine);
}

TEST_F(WireMessageCodecTest, handlesEndScenarioMessageWithoutArgument) {
    MockCukeEngine engine;
    EXPECT_CALL(engine, endScenario(ElementsAre())).Times(1);

    decode(R"json([
        "end_scenario"
    ])json")
        .run(engine);
}

TEST_F(WireMessageCodecTest, handlesEndScenarioMessageWithNullArgument) {
    MockCukeEngine engine;
    EXPECT_CALL(engine, endScenario(ElementsAre())).Times(1);

    decode(R"json([
        "end_scenario",
        null
    ])json")
        .run(engine);
}

TEST_F(WireMessageCodecTest, handlesEndScenarioMessageWithTagsArgument) {
    MockCukeEngine engine;
    EXPECT_CALL(engine, endScenario(ElementsAre("cu", "cum", "ber"))).Times(1);

    decode(R"json([
        "end_scenario", {
            "tags": [
                "cu",
                "cum",
                "ber"
            ]
        }
    ])json")
        .run(engine);
}

TEST_F(WireMessageCodecTest, handlesSnippetTextMessage) {
    MockCukeEngine engine;
    EXPECT_CALL(engine, snippetText("Keyword", "step description", "Some::Class")).Times(1);

    decode(R"json([
        "snippet_text", {
            "step_keyword": "Keyword",
            "multiline_arg_class": "Some::Class",
            "step_name": "step description"
        }
    ])json")
        .run(engine);
}

/*
 * Response encoding
 */

TEST_F(WireMessageCodecTest, handlesSuccessResponse) {
    SuccessResponse response;
    EXPECT_THAT(codec.encode(response), StrEq("[\"success\"]"));
}

TEST_F(WireMessageCodecTest, handlesSimpleFailureResponse) {
    FailureResponse response;
    EXPECT_THAT(codec.encode(response), StrEq("[\"fail\"]"));
}

TEST_F(WireMessageCodecTest, handlesDetailedFailureResponse) {
    FailureResponse response("My message", "ExceptionClassName");
    EXPECT_THAT(
        codec.encode(response),
        StrEq("[\"fail\",{"
              "\"exception\":\"ExceptionClassName\","
              "\"message\":\"My message\""
              "}]")
    );
}

TEST_F(WireMessageCodecTest, handlesPendingResponse) {
    PendingResponse response("I'm lazy!");
    EXPECT_THAT(codec.encode(response), StrEq("[\"pending\",\"I'm lazy!\"]"));
}

TEST_F(WireMessageCodecTest, handlesEmptyStepMatchesResponse) {
    StepMatchesResponse response(std::vector<StepMatch>(0));
    EXPECT_THAT(codec.encode(response), StrEq("[\"success\",[]]"));
}

TEST_F(WireMessageCodecTest, handlesStepMatchesResponse) {
    std::vector<StepMatch> matches;
    StepMatch sm1;
    sm1.id = "1234";
    sm1.source = "MyClass.cpp:56";
    sm1.regexp = "Some (.*) regexp";
    matches.push_back(sm1);
    StepMatch sm2;
    sm2.id = "9876";
    StepMatchArg sm2arg1;
    sm2arg1.value = "odd";
    sm2arg1.position = 5;
    sm2.args.push_back(sm2arg1);
    matches.push_back(sm2);
    StepMatchesResponse response(matches);

    // clang-format off
    EXPECT_THAT(codec.encode(response), StrEq(
        "[\"success\",[{"
            "\"args\":[],"
            "\"id\":\"1234\","
            "\"regexp\":\"Some (.*) regexp\","
            "\"source\":\"MyClass.cpp:56\""
        "},{"
            "\"args\":[{"
                "\"pos\":5,"
                "\"val\":\"odd\""
            "}],"
            "\"id\":\"9876\""
        "}]]")
    );
    // clang-format on
}

TEST_F(WireMessageCodecTest, handlesSnippetTextResponse) {
    SnippetTextResponse response("GIVEN(...)");
    EXPECT_THAT(codec.encode(response), StrEq("[\"success\",\"GIVEN(...)\"]"));
}

TEST_F(WireMessageCodecTest, encodesResponseUsingRawUtf8) {
    std::vector<StepMatch> matches;
    StepMatch sm1;
    sm1.id = "1234";
    sm1.regexp = "Some (.+) regexp (.+)";
    StepMatchArg sm1arg1;
    sm1arg1.value = "カラオケ機";
    sm1arg1.position = 5;
    sm1.args.push_back(sm1arg1);
    StepMatchArg sm1arg2;
    sm1arg2.value = "ASCII";
    sm1arg2.position = 18;
    sm1.args.push_back(sm1arg2);
    matches.push_back(sm1);
    StepMatchesResponse response(matches);

    // clang-format off
    EXPECT_THAT(codec.encode(response), StrEq(
        "[\"success\",[{"
            "\"args\":[{"
                "\"pos\":5,"
                "\"val\":\"カラオケ機\""
            "},{"
                "\"pos\":18,"
                "\"val\":\"ASCII\""
            "}],"
            "\"id\":\"1234\","
            "\"regexp\":\"Some (.+) regexp (.+)\""
        "}]]"));
    // clang-format on
}

/*
 * Command response
 */

TEST(WireCommandsTest, succesfulInvokeReturnsSuccess) {
    MockCukeEngine engine;
    InvokeCommand invokeCommand(
        "x", CukeEngine::invoke_args_type(), CukeEngine::invoke_table_type()
    );
    EXPECT_CALL(engine, invokeStep(_, _, _)).Times(1);

    std::shared_ptr<const WireResponse> response(invokeCommand.run(engine));
    EXPECT_PTRTYPE(SuccessResponse, response.get());
}

TEST(WireCommandsTest, throwingFailureInvokeReturnsFailure) {
    MockCukeEngine engine;
    InvokeCommand invokeCommand(
        "x", CukeEngine::invoke_args_type(), CukeEngine::invoke_table_type()
    );
    EXPECT_CALL(engine, invokeStep(_, _, _))
        .Times(1)
        .WillOnce(Throw(InvokeFailureException("A", "B")));

    std::shared_ptr<const WireResponse> response(invokeCommand.run(engine));
    EXPECT_PTRTYPE(FailureResponse, response.get());
    // TODO Test A and B
}

TEST(WireCommandsTest, throwingPendingStepReturnsPending) {
    MockCukeEngine engine;
    InvokeCommand invokeCommand(
        "x", CukeEngine::invoke_args_type(), CukeEngine::invoke_table_type()
    );
    EXPECT_CALL(engine, invokeStep(_, _, _)).Times(1).WillOnce(Throw(PendingStepException("S")));

    std::shared_ptr<const WireResponse> response(invokeCommand.run(engine));
    EXPECT_PTRTYPE(PendingResponse, response.get());
    // TODO Test S
}

TEST(WireCommandsTest, throwingAnythingInvokeReturnsFailure) {
    MockCukeEngine engine;
    InvokeCommand invokeCommand(
        "x", CukeEngine::invoke_args_type(), CukeEngine::invoke_table_type()
    );
    EXPECT_CALL(engine, invokeStep(_, _, _)).Times(1).WillOnce(Throw(string("something")));

    std::shared_ptr<const WireResponse> response(invokeCommand.run(engine));
    EXPECT_PTRTYPE(FailureResponse, response.get());
    // TODO Test empty
}


================================================
FILE: tests/integration/WireServerTest.cpp
================================================
#include <cucumber-cpp/internal/connectors/wire/WireServer.hpp>

#include <gmock/gmock.h>

#include <filesystem>
#include <memory>
#include <random>
#include <thread>
#include <chrono>

#include <stdlib.h>
#include <sstream>

using namespace cucumber::internal;
using namespace testing;

static const auto THREAD_TEST_TIMEOUT = std::chrono::milliseconds(4000);

MATCHER(IsConnected, std::string(negation ? "is not" : "is") + " connected") {
    return arg.good();
}

MATCHER(HasTerminated, "") {
    return !arg.joinable();
}

MATCHER(EventuallyTerminates, "") {
    const std::future_status status = arg.wait_for(THREAD_TEST_TIMEOUT);
    return status == std::future_status::ready;
}

MATCHER_P(EventuallyReceives, value, "") {
    std::basic_iostream<char>* stream
        = const_cast<std::basic_iostream<char>*>(static_cast<const std::basic_iostream<char>*>(&arg)
        );
    std::string output;
    // FIXME It should not block
    (*stream) >> output;
    //    boost::timer timer;
    //    double timeout = THREAD_TEST_TIMEOUT.total_milliseconds() / 1000.0;
    //    while (timer.elapsed() < timeout) {
    //        if (stream->rdbuf()->available() > 0) { // it is zero even if it doesn't block!
    //            (*stream) >> output;
    //            break;
    //        }
    //        boost::this_thread::yield();
    //    }
    return (output == value);
}

class MockProtocolHandler : public ProtocolHandler {
public:
    MOCK_METHOD(std::string, handle, (const std::string& request), (const, override));
};

class SocketServerTest : public Test {

protected:
    StrictMock<MockProtocolHandler> protocolHandler;
    std::future<void> serverThread{};

    void SetUp() override {
        SocketServer* server = createListeningServer();
        serverThread = std::async(std::launch::async, &SocketServer::acceptOnce, server);
    }

    void TearDown() override {
        serverThread.wait_for(THREAD_TEST_TIMEOUT);
        destroyListeningServer();
    }

    virtual SocketServer* createListeningServer() = 0;
    virtual void destroyListeningServer() = 0;
};

class TCPSocketServerTest : public SocketServerTest {
protected:
    std::unique_ptr<TCPSocketServer> server;

    SocketServer* createListeningServer() override {
        server.reset(new TCPSocketServer(&protocolHandler));
        server->listen(0);
        return server.get();
    }

    void destroyListeningServer() override {
        server.reset();
    }
};

TEST_F(TCPSocketServerTest, exitsOnFirstConnectionClosed) {
    // given
    asio::ip::tcp::iostream client(server->listenEndpoint());
    ASSERT_THAT(client, IsConnected());
    ASSERT_THAT(server->listenEndpoint().address().to_string(), std::string("0.0.0.0"));

    // when
    client.close();

    // then
    EXPECT_THAT(serverThread, EventuallyTerminates());
}

TEST_F(TCPSocketServerTest, moreThanOneClientCanConnect) {
    // given
    asio::ip::tcp::iostream client1(server->listenEndpoint());
    ASSERT_THAT(client1, IsConnected());

    // when
    asio::ip::tcp::iostream client2(server->listenEndpoint());

    // then
    ASSERT_THAT(client2, IsConnected());
}

TEST_F(TCPSocketServerTest, receiveAndSendsSingleLineMassages) {
    {
        InSequence s;
        EXPECT_CALL(protocolHandler, handle("12")).WillRepeatedly(Return("A"));
        EXPECT_CALL(protocolHandler, handle("3")).WillRepeatedly(Return("B"));
        EXPECT_CALL(protocolHandler, handle("4")).WillRepeatedly(Return("C"));
    }

    // given
    asio::ip::tcp::iostream client(server->listenEndpoint());
    ASSERT_THAT(client, IsConnected());

    // when
    client << "1" << std::flush << "2" << std::endl << std::flush;
    client << "3" << std::endl << "4" << std::endl << std::flush;

    // then
    EXPECT_THAT(client, EventuallyReceives("A"));
    EXPECT_THAT(client, EventuallyReceives("B"));
    EXPECT_THAT(client, EventuallyReceives("C"));
}

class TCPSocketServerLocalhostTest : public SocketServerTest {
protected:
    std::unique_ptr<TCPSocketServer> server;

    SocketServer* createListeningServer() override {
        server.reset(new TCPSocketServer(&protocolHandler));
        server->listen(asio::ip::tcp::endpoint(asio::ip::make_address("127.0.0.1"), 0));
        return server.get();
    }

    void destroyListeningServer() override {
        server.reset();
    }
};

TEST_F(TCPSocketServerLocalhostTest, listensOnLocalhost) {
    // given
    asio::ip::tcp::iostream client(server->listenEndpoint());
    ASSERT_THAT(client, IsConnected());
    ASSERT_THAT(server->listenEndpoint().address().to_string(), std::string("127.0.0.1"));

    // when
    client.close();

    // then
    EXPECT_THAT(serverThread, EventuallyTerminates());
}

#if defined(ASIO_HAS_LOCAL_SOCKETS)
class UnixSocketServerTest : public SocketServerTest {
protected:
    std::unique_ptr<UnixSocketServer> server;

    SocketServer* createListeningServer() override {
        const std::string filename = std::filesystem::temp_directory_path() / randomString();
        server.reset(new UnixSocketServer(&protocolHandler));
        server->listen(filename);
        return server.get();
    }

    void destroyListeningServer() override {
        server.reset();
    }

private:
    std::random_device rd{};
    std::mt19937 gen{rd()};
    std::uniform_int_distribution<> distrib{0, 15};

    std::string randomString() {
        std::stringstream out{};
        for (std::size_t i = 0; i < 16; i++)
            out << std::hex << distrib(gen);
        return out.str();
    }
};

/*
 * Tests are flickering on OSX when testing without traffic flowing.
 *
 * This full lifecycle test is not optimal but it should be enough
 * given that the main difference between Unix and TCP is the socket
 * created at startup and removed on shutdown.
 */
TEST_F(UnixSocketServerTest, fullLifecycle) {
    asio::local::stream_protocol::endpoint socketName = server->listenEndpoint();
    EXPECT_CALL(protocolHandler, handle("X")).WillRepeatedly(Return("Y"));

    // socket created at startup
    ASSERT_TRUE(std::filesystem::exists(socketName.path()));

    // traffic flows
    asio::local::stream_protocol::iostream client(socketName);
    client << "X" << std::endl << std::flush;
    EXPECT_THAT(client, EventuallyReceives("Y"));

    // client disconnection terminates server
    client.close();
    EXPECT_THAT(serverThread, EventuallyTerminates());

    // socket removed by destructor
    TearDown();
    EXPECT_FALSE(std::filesystem::exists(socketName.path()));
}
#endif


================================================
FILE: tests/integration/drivers/BoostDriverTest.cpp
================================================
#include <boost/version.hpp>
#include <boost/test/unit_test.hpp>
#include <cucumber-cpp/autodetect.hpp>

#include "utils/DriverTestRunner.hpp"

using namespace cucumber;

THEN(SUCCEED_MATCHER) {
    ScenarioScope<SomeContext> ctx;
    BOOST_CHECK(true);
}

THEN(FAIL_MATCHER) {
    ScenarioScope<SomeContext> ctx;
    BOOST_CHECK(false);
}

THEN(PENDING_MATCHER_1) {
    pending();
}

THEN(PENDING_MATCHER_2) {
    pending(PENDING_DESCRIPTION);
}

using namespace cucumber::internal;

namespace boost {
namespace unit_test {
namespace framework {
bool is_initialized() {
    return boost::unit_test::framework::master_test_suite().argc > 0;
}
}
}
}

class BoostStepDouble : public BoostStep {
public:
    const InvokeResult invokeStepBody() override {
        return BoostStep::invokeStepBody();
    };

    void body() override{};
};

class BoostDriverTest : public DriverTest {
public:
    void runAllTests() override {
        stepInvocationInitsBoostTest();
        DriverTest::runAllTests();
    }

private:
    void stepInvocationInitsBoostTest() {
        std::cout << "= Init =" << std::endl;
        using namespace boost::unit_test;
        BoostStepDouble step;
        expectFalse(
            "Framework is not initialized before the first test", framework::is_initialized()
        );
        step.invokeStepBody();
        expectTrue("Framework is initialized after the first test", framework::is_initialized());
    }
};

int main() {
    BoostDriverTest test;
    return test.run();
}


================================================
FILE: tests/integration/drivers/GTestDriverTest.cpp
================================================
#include <gtest/gtest.h>
#include <cucumber-cpp/autodetect.hpp>

#include "utils/DriverTestRunner.hpp"

using namespace cucumber;

THEN(SUCCEED_MATCHER) {
    ScenarioScope<SomeContext> ctx;
    ASSERT_TRUE(true);
}

THEN(FAIL_MATCHER) {
    ScenarioScope<SomeContext> ctx;
    ASSERT_TRUE(false);
}

THEN(PENDING_MATCHER_1) {
    pending();
}

THEN(PENDING_MATCHER_2) {
    pending(PENDING_DESCRIPTION);
}

using namespace cucumber::internal;

class GTestStepDouble : public GTestStep {
public:
    bool isInitialized() {
        return GTestStep::initialized;
    }

    const InvokeResult invokeStepBody() override {
        return GTestStep::invokeStepBody();
    };

    void body() override{};
};

class GTestDriverTest : public DriverTest {
public:
    void runAllTests() override {
        stepInvocationInitsGTest();
        DriverTest::runAllTests();
    }

private:
    void stepInvocationInitsGTest() {
        std::cout << "= Init =" << std::endl;
        GTestStepDouble framework;
        expectFalse(
            "Framework is not initialized before the first test", framework.isInitialized()
        );
        framework.invokeStepBody();
        expectTrue("Framework is initialized after the first test", framework.isInitialized());
    }
};

int main() {
    GTestDriverTest test;
    return test.run();
}


================================================
FILE: tests/integration/drivers/GenericDriverTest.cpp
================================================
#include <cucumber-cpp/generic.hpp>

#include "utils/DriverTestRunner.hpp"

using namespace cucumber;

THEN(SUCCEED_MATCHER) {
    ScenarioScope<SomeContext> ctx;
    // Do not throw for successes
}

THEN(FAIL_MATCHER) {
    ScenarioScope<SomeContext> ctx;
    throw std::runtime_error("Failure description");
}

THEN(PENDING_MATCHER_1) {
    pending();
}

THEN(PENDING_MATCHER_2) {
    pending(PENDING_DESCRIPTION);
}

using namespace cucumber::internal;

int main() {
    return DriverTest().run();
}


================================================
FILE: tests/integration/drivers/QtTestDriverTest.cpp
================================================
#include <QtTest>
#include <cucumber-cpp/autodetect.hpp>

#include "utils/DriverTestRunner.hpp"

using namespace cucumber;

THEN(SUCCEED_MATCHER) {
    ScenarioScope<SomeContext> ctx;
    QVERIFY(true);
}

THEN(FAIL_MATCHER) {
    ScenarioScope<SomeContext> ctx;
    QVERIFY(false);
}

THEN(PENDING_MATCHER_1) {
    pending();
}

THEN(PENDING_MATCHER_2) {
    pending(PENDING_DESCRIPTION);
}

using namespace cucumber::internal;

class QtTestStepDouble : public QtTestStep {
public:
    QtTestStepDouble() :
        QtTestStep(),
        testRun(false) {
    }

    const InvokeResult invokeStepBody() override {
        return QtTestStep::invokeStepBody();
    }

    void body() override {
        testRun = true;
    }

    bool testRun;
};

class QtTestDriverTest : public DriverTest {
public:
    void runAllTests() override {
        stepInvocationRunsStepBody();
        DriverTest::runAllTests();
    }

private:
    void stepInvocationRunsStepBody() {
        QtTestStepDouble framework;
        expectFalse("The test body has not been run", framework.testRun);
        framework.invokeStepBody();
        expectTrue("The test body has been run", framework.testRun);
    }
};

int main() {
    QtTestDriverTest test;
    return test.run();
}


================================================
FILE: tests/unit/BasicStepTest.cpp
================================================
#include <gtest/gtest.h>

#include <cucumber-cpp/internal/drivers/GenericDriver.hpp>

using namespace cucumber::internal;

#define PENDING_STEP_DESCRIPTION "A description"

class PendingStep : public GenericStep {
    void body() override {
        pending();
    }
};

class PendingStepWithDescription : public GenericStep {
    void body() override {
        pending(PENDING_STEP_DESCRIPTION);
    }
};

static const InvokeArgs NO_INVOKE_ARGS;

TEST(BasicStepTest, handlesPendingSteps) {
    PendingStep pendingStep;
    PendingStepWithDescription pendingStepWithDescription;
    InvokeResult result;

    result = pendingStep.invoke(&NO_INVOKE_ARGS);
    ASSERT_TRUE(result.isPending());
    ASSERT_STREQ("", result.getDescription().c_str());

    result = pendingStepWithDescription.invoke(&NO_INVOKE_ARGS);
    ASSERT_TRUE(result.isPending());
    ASSERT_STREQ(PENDING_STEP_DESCRIPTION, result.getDescription().c_str());
}


================================================
FILE: tests/unit/ContextManagerTest.cpp
================================================
#include <gtest/gtest.h>

#include "utils/ContextManagerTestDouble.hpp"

#include <memory>

using namespace cucumber::internal;

class ContextManagerTest : public ::testing::Test {
public:
    ContextManagerTestDouble contextManager;

    ContextManagerTest() :
        contextManager() {
    }

protected:
private:
    void TearDown() override {
        contextManager.purgeContexts();
    }
};

class Context1 {};
class Context2 {};

TEST_F(ContextManagerTest, createsValidContextPointers) {
    std::weak_ptr<Context1> ctx1 = contextManager.addContext<Context1>();
    ASSERT_EQ(1, contextManager.countContexts());
    ASSERT_FALSE(ctx1.expired());
    std::weak_ptr<Context2> ctx2 = contextManager.addContext<Context2>();
    ASSERT_EQ(2, contextManager.countContexts());
    ASSERT_FALSE(ctx2.expired());
}

TEST_F(ContextManagerTest, allowsCreatingTheSameContextTypeTwice) {
    std::weak_ptr<Context1> ctx1 = contextManager.addContext<Context1>();
    ASSERT_EQ(1, contextManager.countContexts());
    ASSERT_FALSE(ctx1.expired());
    std::weak_ptr<Context1> ctx2 = contextManager.addContext<Context1>();
    ASSERT_EQ(2, contextManager.countContexts());
    ASSERT_FALSE(ctx2.expired());
    ASSERT_NE(ctx1.lock(), ctx2.lock());
}

TEST_F(ContextManagerTest, purgesContexts) {
    std::weak_ptr<Context1> ctx1 = contextManager.addContext<Context1>();
    ASSERT_EQ(1, contextManager.countContexts());
    ASSERT_FALSE(ctx1.expired());
    contextManager.purgeContexts();
    ASSERT_EQ(0, contextManager.countContexts());
    ASSERT_TRUE(ctx1.expired());
}


================================================
FILE: tests/unit/CukeCommandsTest.cpp
================================================
#include <gtest/gtest.h>

#include <cucumber-cpp/internal/step/StepMacros.hpp>
#include "utils/CukeCommandsFixture.hpp"

using namespace cucumber::internal;

using std::string;

class CukeCommandsTest : public CukeCommandsFixture {
protected:
    void addStepWithMatcher(const std::string& matcher) {
        addStepToManager<EmptyStep>(matcher);
    }
};

class CheckAllParameters : public GenericStep {
protected:
    static const int arg_0_int;
    static const double arg_1_double;
    static const string arg_2_string;
    static const string arg_3_string_with_spaces;

public:
    static InvokeArgs buildInvokeArgs() {
        InvokeArgs mixedArgs;
        mixedArgs.addArg(toString(arg_0_int));
        mixedArgs.addArg(toString(arg_1_double));
        mixedArgs.addArg(toString(arg_2_string));
        mixedArgs.addArg(toString(arg_3_string_with_spaces));
        return mixedArgs;
    }
};

const int CheckAllParameters::arg_0_int(42);
const double CheckAllParameters::arg_1_double(4.2);
const string CheckAllParameters::arg_2_string("fortytwo");
const string CheckAllParameters::arg_3_string_with_spaces("forty two");

class CheckAllParametersWithoutMacro : public CheckAllParameters {
public:
    void body() override {
        EXPECT_EQ(arg_0_int, getArgs()->getInvokeArg<int>(0));
        EXPECT_EQ((double)arg_0_int, getArgs()->getInvokeArg<double>(0));
        EXPECT_NO_THROW(getArgs()->getInvokeArg<string>(0));

        EXPECT_EQ((int)arg_1_double, getArgs()->getInvokeArg<int>(1));
        EXPECT_EQ(arg_1_double, getArgs()->getInvokeArg<double>(1));
        EXPECT_NO_THROW(getArgs()->getInvokeArg<string>(1));

        EXPECT_THROW(getArgs()->getInvokeArg<int>(2), std::invalid_argument);
        EXPECT_THROW(getArgs()->getInvokeArg<double>(2), std::invalid_argument);
        EXPECT_EQ(arg_2_string, getArgs()->getInvokeArg<string>(2));

        EXPECT_THROW(getArgs()->getInvokeArg<int>(3), std::invalid_argument);
        EXPECT_THROW(getArgs()->getInvokeArg<double>(3), std::invalid_argument);
        EXPECT_EQ(arg_3_string_with_spaces, getArgs()->getInvokeArg<string>(3));
    }
};

class CheckAllParametersWithMacro : public CheckAllParameters {
public:
    void body() override {
        REGEX_PARAM(int, got_arg_0_int);
        EXPECT_EQ(arg_0_int, got_arg_0_int);

        REGEX_PARAM(double, got_arg_1_double);
        EXPECT_EQ(arg_1_double, got_arg_1_double);

        REGEX_PARAM(string, got_arg_2_string);
        EXPECT_EQ(arg_2_string, got_arg_2_string);

        REGEX_PARAM(string, got_arg_3_string_with_spaces);
        EXPECT_EQ(arg_3_string_with_spaces, got_arg_3_string_with_spaces);
    }
};

class CheckAllParametersWithFuncArgs : public CheckAllParameters {
public:
    void bodyWithArgs(
        const int got_arg_0_int,
        const double got_arg_1_double,
        const std::string got_arg_2_string,
        const std::string& got_arg_3_string_with_spaces
    ) {
        EXPECT_EQ(arg_0_int, got_arg_0_int);
        EXPECT_EQ(arg_1_double, got_arg_1_double);
        EXPECT_EQ(arg_2_string, got_arg_2_string);
        EXPECT_EQ(arg_3_string_with_spaces, got_arg_3_string_with_spaces);
    }

    void body() override {
        return invokeWithArgs(*this, &CheckAllParametersWithFuncArgs::bodyWithArgs);
    }
};

TEST_F(CukeCommandsTest, invokeHandlesParametersWithFuncArgs) {
    // The real test is in TestClass::body()
    runStepBodyTest<CheckAllParametersWithFuncArgs>();
}

TEST_F(CukeCommandsTest, matchesCorrectly) {
    addStepWithMatcher(STATIC_MATCHER);
    MatchResult result = stepMatches(STATIC_MATCHER);
    EXPECT_EQ(stepId, result.getResultSet().at(0).stepInfo->id);
}

TEST_F(CukeCommandsTest, invokeHandlesParametersWithoutMacro) {
    // The real test is in TestClass::body()
    runStepBodyTest<CheckAllParametersWithoutMacro>();
}

TEST_F(CukeCommandsTest, invokeHandlesParametersWithMacro) {
    // The real test is in TestClass::body()
    runStepBodyTest<CheckAllParametersWithMacro>();
}

TEST_F(CukeCommandsTest, producesSnippetsEscapingTitle) {
    EXPECT_EQ(
        "THEN(\"^x\\\\|y\\\"z$\") {\n"
        "    pending();\n"
        "}\n",
        snippetText("then", "x|y\"z")
    );
}

TEST_F(CukeCommandsTest, escapesCaractersInRegexes) {
    //  abc|()[]{}^$*+?.\def  <=  abc\|\(\)\[\]\{\}\^\$\*\+\?\.\\def
    EXPECT_EQ(
        "abc\\|\\(\\)\\[\\]\\{\\}\\^\\$\\*\\+\\?\\.\\\\def", escapeRegex("abc|()[]{}^$*+?.\\def")
    );
}

TEST_F(CukeCommandsTest, escapesCharactersInCStrings) {
    //  abc\"def\\ghi  <=  abc"def\ghi
    EXPECT_EQ("abc\\\"def\\\\ghi", escapeCString("abc\"def\\ghi"));
}


================================================
FILE: tests/unit/RegexTest.cpp
================================================
#include <gtest/gtest.h>

#include <cucumber-cpp/internal/utils/Regex.hpp>
using namespace cucumber::internal;

#include <memory>

TEST(RegexTest, matchesSimpleRegex) {
    Regex exact("^cde$");

    std::shared_ptr<RegexMatch> match(exact.find("cde"));
    EXPECT_TRUE(match->matches());
    EXPECT_TRUE(match->getSubmatches().empty());

    match = std::shared_ptr<RegexMatch>(exact.find("abcdefg"));
    EXPECT_FALSE(match->matches());
    EXPECT_TRUE(match->getSubmatches().empty());
}

TEST(RegexTest, matchesRegexWithoutSubmatches) {
    Regex variable("x\\d+x");

    std::shared_ptr<RegexMatch> match(variable.find("xxxx123xxx"));
    EXPECT_TRUE(match->matches());

    match = std::shared_ptr<RegexMatch>(variable.find("xxx"));
    EXPECT_FALSE(match->matches());
}

TEST(RegexTest, matchesRegexWithSubmatches) {
    Regex sum("^(\\d+)\\+\\d+=(\\d+)$");

    std::shared_ptr<RegexMatch> match(sum.find("1+2=3 "));
    EXPECT_FALSE(match->matches());
    EXPECT_TRUE(match->getSubmatches().empty());

    match = std::shared_ptr<RegexMatch>(sum.find("42+27=69"));
    EXPECT_TRUE(match->matches());
    ASSERT_EQ(2, match->getSubmatches().size());
    EXPECT_EQ("42", match->getSubmatches()[0].value);
    EXPECT_EQ("69", match->getSubmatches()[1].value);
}

TEST(RegexTest, matchesRegexWithOptionalSubmatches) {
    Regex sum("^(\\d+)\\+(\\d+)(?:\\+(\\d+))?=(\\d+)$");

    std::shared_ptr<RegexMatch> match(sum.find("1+2+3=6"));
    EXPECT_TRUE(match->matches());
    ASSERT_EQ(4, match->getSubmatches().size());

    match = std::shared_ptr<RegexMatch>(sum.find("42+27=69"));
    EXPECT_TRUE(match->matches());
    ASSERT_EQ(4, match->getSubmatches().size());
    EXPECT_EQ("42", match->getSubmatches()[0].value);
    EXPECT_EQ("27", match->getSubmatches()[1].value);
    EXPECT_EQ("", match->getSubmatches()[2].value);
    EXPECT_EQ("69", match->getSubmatches()[3].value);
}

TEST(RegexTest, findAllDoesNotMatchIfNoTokens) {
    Regex sum("([^,]+)(?:,|$)");
    std::shared_ptr<RegexMatch> match(sum.findAll(""));

    EXPECT_FALSE(match->matches());
    EXPECT_EQ(0, match->getSubmatches().size());
}

TEST(RegexTest, findReportsCodepointPositions) {
    Regex twoArgs("Some (.+) regexp (.+)");
    std::shared_ptr<RegexMatch> match(twoArgs.find("Some カラオケ機 regexp ASCII"));

    EXPECT_TRUE(match->matches());
    ASSERT_EQ(2, match->getSubmatches().size());
    EXPECT_EQ(5, match->getSubmatches()[0].position);
    EXPECT_EQ(18, match->getSubmatches()[1].position);
}

TEST(RegexTest, findAllExtractsTheFirstGroupOfEveryToken) {
    Regex sum("([^,]+)(?:,|$)");
    std::shared_ptr<RegexMatch> match(sum.findAll("a,b,cc"));

    EXPECT_TRUE(match->matches());
    EXPECT_EQ(3, match->getSubmatches().size());
    // EXPECT_THAT(match.getSubmatches(), ElementsAre("a", "b", "cc"));
}

/*
TEST(RegexTest, findAllHasToMatchTheEntireInput) {
    Regex sum("([^,]+)(?:,|$)");
    std::shared_ptr<RegexMatch> match(sum.findAll("1 a,b,cc"));

    EXPECT_FALSE(match->matches());
    EXPECT_EQ(0, match->getSubmatches().size());
}
*/


================================================
FILE: tests/unit/StepCallChainTest.cpp
================================================
#include <gtest/gtest.h>

#include <cucumber-cpp/internal/hook/HookRegistrar.hpp>

using namespace cucumber::internal;

class FakeStepInfo : public StepInfo {
public:
    FakeStepInfo(std::stringstream* markersPtr, const InvokeResult& result) :
        StepInfo("FAKE", ""),
        latestArgsPtr(0),
        markersPtr(markersPtr),
        result(result) {
    }

    InvokeResult invokeStep(const InvokeArgs* pArgs) const override {
        latestArgsPtr = pArgs;
        (*markersPtr) << "S";
        return result;
    }

    const InvokeArgs* getLatestArgsPassed() const {
        return latestArgsPtr;
    }

private:
    mutable const InvokeArgs* latestArgsPtr;
    std::stringstream* markersPtr;
    const InvokeResult result;
};

class MarkingAroundStepHook : public AroundStepHook {
public:
    MarkingAroundStepHook(std::string id, std::stringstream* markersPtr) :
        id(id),
        markersPtr(markersPtr){};

    MarkingAroundStepHook() :
        id(""),
        markersPtr(0){};

    void body() override {
        if (markersPtr) {
            (*markersPtr) << "B" << id;
        }
        doCall();
        if (markersPtr) {
            (*markersPtr) << "A" << id;
        }
    }

protected:
    virtual void doCall() {
        step->call();
    }

private:
    std::string id;
    std::stringstream* markersPtr;
};

class BlockingAroundStepHook : public MarkingAroundStepHook {
public:
    BlockingAroundStepHook(std::string id, std::stringstream* markersPtr) :
        MarkingAroundStepHook(id, markersPtr){};

protected:
    void doCall() override {
    }
};

static const InvokeArgs NO_INVOKE_ARGS;

class StepCallChainTest : public ::testing::Test {
protected:
    HookRegistrar::aroundhook_list_type aroundHooks;
    std::stringstream markers;

    InvokeResult execStep(const InvokeResult& result) {
        const FakeStepInfo step(&markers, result);
        StepCallChain scc(0, &step, &NO_INVOKE_ARGS, aroundHooks);
        return scc.exec();
    }

    void execStepAndCheckSuccess() {
        InvokeResult result;
        result = execStep(InvokeResult::success());
        EXPECT_TRUE(result.isSuccess());
        result = execStep(InvokeResult::failure("Failed"));
        EXPECT_FALSE(result.isSuccess());
    }
};

TEST_F(StepCallChainTest, failsIfNoStep) {
    StepCallChain scc(0, NULL, &NO_INVOKE_ARGS, aroundHooks);
    EXPECT_FALSE(scc.exec().isSuccess());
    EXPECT_EQ("", markers.str());
}

TEST_F(StepCallChainTest, stepExecutionReturnsTheExpectedResult) {
    std::shared_ptr<MarkingAroundStepHook> hook(std::make_shared<MarkingAroundStepHook>());

    execStepAndCheckSuccess();

    aroundHooks.push_back(hook);

    execStepAndCheckSuccess();

    aroundHooks.push_back(hook);
    aroundHooks.push_back(hook);

    execStepAndCheckSuccess();
}

TEST_F(StepCallChainTest, aroundHooksAreInvokedInTheCorrectOrder) {
    std::shared_ptr<MarkingAroundStepHook> hook1(
        std::make_shared<MarkingAroundStepHook>("1", &markers)
    ),
        hook2(std::make_shared<MarkingAroundStepHook>("2", &markers)),
        hook3(std::make_shared<MarkingAroundStepHook>("3", &markers));

    aroundHooks.push_back(hook1);
    aroundHooks.push_back(hook2);
    aroundHooks.push_back(hook3);

    execStep(InvokeResult::success());

    EXPECT_EQ("B1B2B3SA3A2A1", markers.str());
}

TEST_F(StepCallChainTest, argsArePassedToTheStep) {
    const FakeStepInfo step(&markers, InvokeResult::success());
    StepCallChain scc(0, &step, &NO_INVOKE_ARGS, aroundHooks);

    EXPECT_NE(&NO_INVOKE_ARGS, step.getLatestArgsPassed());
    scc.exec();
    EXPECT_EQ(&NO_INVOKE_ARGS, step.getLatestArgsPassed());
}

TEST_F(StepCallChainTest, aroundHooksCanStopTheCallChain) {
    std::shared_ptr<MarkingAroundStepHook> hook1(
        std::make_shared<MarkingAroundStepHook>("1", &markers)
    ),
        hook2(std::make_shared<BlockingAroundStepHook>("2", &markers)),
        hook3(std::make_shared<MarkingAroundStepHook>("3", &markers));

    aroundHooks.push_back(hook1);
    aroundHooks.push_back(hook2);
    aroundHooks.push_back(hook3);

    execStep(InvokeResult::success());

    EXPECT_EQ("B1B2A2A1", markers.str());
}


================================================
FILE: tests/unit/StepManagerTest.cpp
================================================
#include <gtest/gtest.h>

#include "utils/StepManagerTestDouble.hpp"

#include <map>

using namespace std;
using namespace cucumber::internal;

class StepManagerTest : public ::testing::Test {
public:
    typedef StepManagerTestDouble StepManager;

protected:
    StepManagerTest() {
    }
    const static char* a_matcher;
    const static char* another_matcher;
    const static char* no_match;
    const static char* a_third_matcher;
    const map<std::ptrdiff_t, string> no_params;

    int getUniqueMatchIdOrZeroFor(const string& stepMatch) {
        MatchResult::match_results_type resultSet = getResultSetFor(stepMatch);
        if (resultSet.size() != 1) {
            return 0;
        } else {
            return resultSet.begin()->stepInfo->id;
        }
    }

    size_t countMatches(const string& stepMatch) {
        return getResultSetFor(stepMatch).size();
    }

    bool matchesOnce(const string& stepMatch) {
        return (countMatches(stepMatch) == 1);
    }

    bool matchesAtLeastOnce(const string& stepMatch) {
        return (countMatches(stepMatch) > 0);
    }

    bool extractedParamsAre(const string stepMatch, map<std::ptrdiff_t, string> params) {
        MatchResult::match_results_type resultSet = getResultSetFor(stepMatch);
        if (resultSet.size() != 1) {
            return false; // more than one match
        }
        SingleStepMatch match = resultSet.front();
        if (params.size() != match.submatches.size()) {
            return false;
        }
        SingleStepMatch::submatches_type::const_iterator rsi;
        for (rsi = match.submatches.begin(); rsi != match.submatches.end(); ++rsi) {
            if (params.find(rsi->position) == params.end())
                return false;
            if (rsi->value != params[rsi->position]) {
                return false;
            }
        }
        return true;
    }

private:
    MatchResult::match_results_type getResultSetFor(const string& stepMatch) {
        return StepManager::stepMatches(stepMatch).getResultSet();
    }
    void TearDown() override {
        StepManager::clearSteps();
    }
};

const char* StepManagerTest::a_matcher = "a matcher";
const char* StepManagerTest::another_matcher = "another matcher";
const char* StepManagerTest::a_third_matcher = "a third matcher";
const char* StepManagerTest::no_match = "no match";

TEST_F(StepManagerTest, holdsNonConflictingSteps) {
    ASSERT_EQ(0, StepManager::count());
    StepManager::addStepDefinition(a_matcher);
    StepManager::addStepDefinition(another_matcher);
    StepManager::addStepDefinition(a_third_matcher);
    ASSERT_EQ(3, StepManager::count());
}

TEST_F(StepManagerTest, holdsConflictingSteps) {
    ASSERT_EQ(0, StepManager::count());
    StepManager::addStepDefinition(a_matcher);
    StepManager::addStepDefinition(a_matcher);
    StepManager::addStepDefinition(a_matcher);
    ASSERT_EQ(3, StepManager::count());
}

TEST_F(StepManagerTest, matchesStepsWithNonRegExMatchers) {
    EXPECT_FALSE(matchesAtLeastOnce(no_match));
    step_id_type aMatcherIndex = StepManager::addStepDefinition(a_matcher);
    EXPECT_EQ(aMatcherIndex, getUniqueMatchIdOrZeroFor(a_matcher));
    step_id_type anotherMatcherIndex = StepManager::addStepDefinition(another_matcher);
    EXPECT_EQ(anotherMatcherIndex, getUniqueMatchIdOrZeroFor(another_matcher));
    EXPECT_EQ(aMatcherIndex, getUniqueMatchIdOrZeroFor(a_matcher));
}

TEST_F(StepManagerTest, matchesStepsWithRegExMatchers) {
    StepManager::addStepDefinition("match the number (\\d+)");
    EXPECT_TRUE(matchesOnce("match the number 42"));
    EXPECT_FALSE(matchesOnce("match the number (\\d+)"));
    EXPECT_FALSE(matchesOnce("match the number one"));
}

TEST_F(StepManagerTest, extractsParamsFromRegExMatchers) {
    StepManager::addStepDefinition("match no params");
    EXPECT_TRUE(extractedParamsAre("match no params", no_params));
    StepManager::addStepDefinition("match the (\\w+) param");
    EXPECT_TRUE(extractedParamsAre("match the first param", {{10, "first"}}));
    StepManager::addStepDefinition("match a (.+)$");
    EXPECT_TRUE(
        extractedParamsAre("match a  string  with  spaces  ", {{8, " string  with  spaces  "}})
    );
    StepManager::addStepDefinition("match params (\\w+), (\\w+) and (\\w+)");
    EXPECT_TRUE(extractedParamsAre("match params A, B and C", {{13, "A"}, {16, "B"}, {22, "C"}}));
}

TEST_F(StepManagerTest, handlesMultipleMatches) {
    StepManager::addStepDefinition(a_matcher);
    StepManager::addStepDefinition(another_matcher);
    StepManager::addStepDefinition(a_matcher);
    EXPECT_EQ(2, countMatches(a_matcher));
}

TEST_F(StepManagerTest, matchesStepsWithNonAsciiMatchers) {
    step_id_type aMatcherIndex = StepManager::addStepDefinition("خيار");
    EXPECT_EQ(aMatcherIndex, getUniqueMatchIdOrZeroFor("خيار"));
    EXPECT_FALSE(matchesAtLeastOnce("cetriolo"));
    EXPECT_FALSE(matchesAtLeastOnce("огурец"));
    EXPECT_FALSE(matchesAtLeastOnce("黄瓜"));
}


================================================
FILE: tests/unit/TableTest.cpp
================================================
#include <gtest/gtest.h>

#include <cucumber-cpp/internal/Table.hpp>
using namespace cucumber::internal;

TEST(TableTest, forbidsRowsNotMatchingTableColumnsSize) {
    Table t;
    t.addColumn("C1");

    EXPECT_THROW(
        {
            Table::row_type row;
            t.addRow(row);
        },
        std::range_error
    );

    EXPECT_NO_THROW({ t.addRow({"R1"}); });

    EXPECT_THROW({ t.addRow({"R1", "R2"}); }, std::range_error);
}

TEST(TableTest, rowsCannotBeAddedBeforeColumnsAreSet) {
    Table t;

    EXPECT_THROW(
        {
            Table::row_type row;
            t.addRow(row);
        },
        std::runtime_error
    );
}

TEST(TableTest, columnsCannotBeChangesAfterRowsAreAdded) {
    Table t;
    t.addColumn("C1");
    t.addRow({"R1"});

    EXPECT_THROW({ t.addColumn("C2"); }, std::runtime_error);
}

TEST(TableTest, addedRowsMatchColumnDefinition) {
    Table t;
    t.addColumn("C1");
    t.addColumn("C2");
    t.addColumn("C3");

    ASSERT_EQ(0, t.hashes().size());

    t.addRow({"R11", "R12", "R13"});
    Table::hashes_type hashes = t.hashes();
    ASSERT_EQ(1, hashes.size());
    EXPECT_EQ("R11", hashes[0]["C1"]);
    EXPECT_EQ("R12", hashes[0]["C2"]);
    EXPECT_EQ("R13", hashes[0]["C3"]);

    t.addRow({"R21", "R22", "R23"});
    t.addRow({"R31", "R32", "R33"});
    t.addRow({"R41", "R42", "R43"});
    hashes = t.hashes();
    ASSERT_EQ(4, hashes.size());
    EXPECT_EQ("R21", hashes[1]["C1"]);
    EXPECT_EQ("R32", hashes[2]["C2"]);
    EXPECT_EQ("R43", hashes[3]["C3"]);
}


================================================
FILE: tests/unit/TagTest.cpp
================================================
#include <gtest/gtest.h>

#include <cucumber-cpp/internal/hook/Tag.hpp>

using namespace cucumber::internal;

TEST(TagTest, emptyOrExpressionMatchesNoTag) {
    OrTagExpression tagExpr("");
    EXPECT_FALSE(tagExpr.matches({"x"}));
    EXPECT_FALSE(tagExpr.matches({"a", "b"}));
}

TEST(TagTest, orExpressionsMatchTheTagSpecified) {
    OrTagExpression tagExpr("@a");
    EXPECT_TRUE(tagExpr.matches({"a"}));
    EXPECT_FALSE(tagExpr.matches({"x"}));
}

TEST(TagTest, orExpressionsMatchAnyTagSpecified) {
    OrTagExpression tagExpr("@a,@b,@c");
    EXPECT_TRUE(tagExpr.matches({"a"}));
    EXPECT_TRUE(tagExpr.matches({"b"}));
    EXPECT_TRUE(tagExpr.matches({"a", "b"}));
    EXPECT_TRUE(tagExpr.matches({"a", "b", "c"}));
    EXPECT_TRUE(tagExpr.matches({"x", "a", "b"}));
    EXPECT_TRUE(tagExpr.matches({"a", "y"}));
    EXPECT_TRUE(tagExpr.matches({"x", "b"}));
    EXPECT_FALSE(tagExpr.matches({"x", "y", "z"}));
}

TEST(TagTest, orExpressionsAllowSpaces) {
    OrTagExpression tagExpr("@a, @b,@c");
    EXPECT_TRUE(tagExpr.matches({"b"}));
    EXPECT_FALSE(tagExpr.matches({"x"}));
}

TEST(TagTest, emptyAndExpressionMatchesAnyTag) {
    AndTagExpression tagExpr("");
    EXPECT_TRUE(tagExpr.matches({"x"}));
    EXPECT_TRUE(tagExpr.matches({"a", "b"}));
}

TEST(TagTest, singleAndExpressionMatchesTheTagSpecified) {
    AndTagExpression tagExpr("\"@a\"");
    EXPECT_TRUE(tagExpr.matches({"a"}));
    EXPECT_FALSE(tagExpr.matches({"x"}));
}

TEST(TagTest, andExpressionsMatchEveryTagSpecified) {
    AndTagExpression tagExpr("\"@a\",\"@b\"");
    EXPECT_TRUE(tagExpr.matches({"a", "b"}));
    EXPECT_TRUE(tagExpr.matches({"x", "a", "b"}));
    EXPECT_FALSE(tagExpr.matches({"a"}));
    EXPECT_FALSE(tagExpr.matches({"b"}));
    EXPECT_FALSE(tagExpr.matches({"a", "y"}));
    EXPECT_FALSE(tagExpr.matches({"x", "b"}));
    EXPECT_FALSE(tagExpr.matches({"x", "y"}));
}

TEST(TagTest, andExpressionsAllowSpaces) {
    AndTagExpression tagExpr(" \"@a\" , \"@b\" ");
    EXPECT_TRUE(tagExpr.matches({"a", "b"}));
    EXPECT_FALSE(tagExpr.matches({"a"}));
}

TEST(TagTest, compositeTagExpressionsAreHandled) {
    AndTagExpression tagExpr("\"@a,@b\", \"@c\", \"@d,@e,@f\"");
    EXPECT_TRUE(tagExpr.matches({"a", "c", "d"}));
    EXPECT_FALSE(tagExpr.matches({"x", "c", "f"}));
}


================================================
FILE: tests/utils/ContextManagerTestDouble.hpp
================================================
#ifndef CUKE_CONTEXTMANAGERTESTDOUBLE_HPP_
#define CUKE_CONTEXTMANAGERTESTDOUBLE_HPP_

#include <cucumber-cpp/internal/ContextManager.hpp>

namespace cucumber {
namespace internal {

class ContextManagerTestDouble : public ContextManager {
public:
    contexts_type::size_type countContexts() {
        return ContextManager::contexts.size();
    }
};

}
}

#endif /* CUKE_CONTEXTMANAGERTESTDOUBLE_HPP_ */


================================================
FILE: tests/utils/CukeCommandsFixture.hpp
================================================
#ifndef CUKE_CUKECOMMANDSFIXTURE_HPP_
#define CUKE_CUKECOMMANDSFIXTURE_HPP_

#include <cucumber-cpp/internal/CukeCommands.hpp>
#include <cucumber-cpp/internal/drivers/GenericDriver.hpp>
#include "StepManagerTestDouble.hpp"

#include <gtest/gtest.h>
#include <memory>

using namespace cucumber::internal;

class EmptyStep : public GenericStep {
    void body() override {
    }
};

class CukeCommandsFixture : public ::testing::Test, public CukeCommands {
    typedef StepManagerTestDouble StepManager;

public:
    const static std::string STATIC_MATCHER;

protected:
    step_id_type stepId;

    template<class T>
    void runStepBodyTest() {
        addStepToManager<T>(STATIC_MATCHER);
        const InvokeArgs spArgs(T::buildInvokeArgs());
        invoke(stepId, &spArgs);
    }

    template<class T>
    void addStepToManager(const std::string& matcher) {
        stepId = StepManager::addStep(std::make_shared<StepInvoker<T>>(matcher, ""));
    }

    void TearDown() override {
        StepManager::clearSteps();
    }
};

const std::string CukeCommandsFixture::STATIC_MATCHER("MATCHER");

#endif /* CUKE_CUKECOMMANDSFIXTURE_HPP_ */


================================================
FILE: tests/utils/DriverTestRunner.hpp
================================================
#ifndef CUKE_DRIVERTESTRUNNER_HPP_
#define CUKE_DRIVERTESTRUNNER_HPP_

#include "StepManagerTestDouble.hpp"
#include <cucumber-cpp/internal/CukeCommands.hpp>

#include <cstring>
#include <iostream>
#include <string>

class ContextListener {
private:
    static int createdContexts;
    static int destroyedContexts;

public:
    int getCreatedContexts() {
        return createdContexts;
    }
    int getDestroyedContexts() {
        return destroyedContexts;
    }
    void notifyCreation() {
        ++createdContexts;
    }
    void notifyDestruction() {
        ++destroyedContexts;
    }
    void reset() {
        createdContexts = 0;
        destroyedContexts = 0;
    }
};

int ContextListener::createdContexts = 0;
int ContextListener::destroyedContexts = 0;

class SomeContext {
private:
    ContextListener listener;

public:
    SomeContext() {
        listener.notifyCreation();
    }
    ~SomeContext() {
        listener.notifyDestruction();
    }
};

namespace cucumber {
namespace internal {

static const InvokeArgs NO_INVOKE_ARGS;

#define SUCCEED_MATCHER "Succeeding step"
#define FAIL_MATCHER "Failing step"
#define PENDING_MATCHER_1 "Pending step without description"
#define PENDING_MATCHER_2 "Pending step with description"

#define PENDING_DESCRIPTION "Describe me!"

class DriverTest {
public:
    int run() {
        runAllTests();
        return failedTests;
    }

    DriverTest() {
        failedTests = 0;
    }

    virtual ~DriverTest() = default;

protected:
    void expectTrue(const char* description, bool condition) {
        updateState(description, condition);
    }

    void expectFalse(const char* description, bool condition) {
        updateState(description, !condition);
    }

    template<typename T>
    void expectEqual(const char* description, T val1, T val2) {
        updateState(description, val1 == val2);
    }

    void expectStrEqual(const char* description, const char* val1, const char* val2) {
        updateState(description, strcmp(val1, val2) == 0);
    }

    virtual void runAllTests() {
        invokeRunsTests();
        contextConstructorAndDesctructorGetCalled();
        failureDescriptionIsResetOnEachRun();
    }

    CukeCommands cukeCommands;

private:
    typedef StepManagerTestDouble StepManager;
    ContextListener listener;

    int failedTests;

    void updateState(const char* description, bool testSuccessState) {
        std::cout << (testSuccessState ? "SUCCESS" : "FAILURE") << " (" << description << ")"
                  << std::endl;
        failedTests += testSuccessState ? 0 : 1;
    }

    step_id_type getStepIdFromMatcher(const std::string& stepMatcher) {
        return StepManager::getStepId(stepMatcher);
    }

    void invokeRunsTests() {
        std::cout << "= Step invocation =" << std::endl;

        InvokeResult result;

        cukeCommands.beginScenario();

        result = cukeCommands.invoke(getStepIdFromMatcher(SUCCEED_MATCHER), &NO_INVOKE_ARGS);
        expectTrue("Succeeding step", result.isSuccess());

        result = cukeCommands.invoke(getStepIdFromMatcher(FAIL_MATCHER), &NO_INVOKE_ARGS);
        expectFalse("Failing step", result.isSuccess() || result.isPending());
        expectFalse("Failing step has a message", result.getDescription().empty());

        result = cukeCommands.invoke(getStepIdFromMatcher(PENDING_MATCHER_1), &NO_INVOKE_ARGS);
        expectTrue("Pending step with no description - result", result.isPending());
        expectStrEqual(
            "Pending step with no description - description", "", result.getDescription().c_str()
        );

        result = cukeCommands.invoke(getStepIdFromMatcher(PENDING_MATCHER_2), &NO_INVOKE_ARGS);
        expectTrue("Pending step with description - result", result.isPending());
        expectStrEqual(
            "Pending step with description - description",
            PENDING_DESCRIPTION,
            result.getDescription().c_str()
        );

        result = cukeCommands.invoke(42, &NO_INVOKE_ARGS);
        expectFalse("Inexistent step", result.isSuccess());

        cukeCommands.endScenario();
    }

    void contextConstructorAndDesctructorGetCalled() {
        std::cout << "= Constructors and destructors =" << std::endl;
        contextConstructorAndDesctructorGetCalledOn(SUCCEED_MATCHER);
        contextConstructorAndDesctructorGetCalledOn(FAIL_MATCHER);
    }

    void contextConstructorAndDesctructorGetCalledOn(const std::string stepMatcher) {
        std::cout << "== " << stepMatcher << " ==" << std::endl;
        listener.reset();
        cukeCommands.beginScenario();
        cukeCommands.invoke(getStepIdFromMatcher(stepMatcher), &NO_INVOKE_ARGS);
        expectEqual("Contexts created after invoke", 1, listener.getCreatedContexts());
        expectEqual("Contexts destroyed after invoke", 0, listener.getDestroyedContexts());
        cukeCommands.endScenario();
        expectEqual("Contexts created after end scenario", 1, listener.getCreatedContexts());
        expectEqual("Contexts destroyed after end scenario", 1, listener.getDestroyedContexts());
    }

    void failureDescriptionIsResetOnEachRun() {
        std::cout << "= Step failure description is reset =" << std::endl;
        InvokeResult result;
        cukeCommands.beginScenario();

        result = cukeCommands.invoke(getStepIdFromMatcher(FAIL_MATCHER), &NO_INVOKE_ARGS);
        std::string failureMessage = result.getDescription();

        expectFalse("Failing step description is set", failureMessage.empty());

        result = cukeCommands.invoke(getStepIdFromMatcher(FAIL_MATCHER), &NO_INVOKE_ARGS);

        expectEqual(
            "Failing step description is the same", failureMessage, result.getDescription()
        );
    }
};

}
}

#endif /* CUKE_DRIVERTESTRUNNER_HPP_ */


================================================
FILE: tests/utils/HookRegistrationFixture.hpp
================================================
#ifndef CUKE_HOOKREGISTRATIONFIXTURE_HPP_
#define CUKE_HOOKREGISTRATIONFIXTURE_HPP_

#include <cucumber-cpp/internal/hook/HookRegistrar.hpp>

#include "CukeCommandsFixture.hpp"

#include <memory>
#include <sstream>

using namespace cucumber::internal;

namespace {

std::stringstream beforeHookCallMarker;
std::stringstream aroundStepHookCallMarker;
std::stringstream beforeAroundStepHookCallMarker;
std::stringstream afterAroundStepHookCallMarker;
std::stringstream afterStepHookCallMarker;
std::stringstream afterHookCallMarker;
std::stringstream globalStepHookCallMarker;
std::stringstream beforeAllHookCallMarker;
std::stringstream afterAllHookCallMarker;
std::string contextContents;

void clearHookCallMarkers() {
    beforeHookCallMarker.str("");
    beforeAroundStepHookCallMarker.str("");
    afterAroundStepHookCallMarker.str("");
    afterStepHookCallMarker.str("");
    afterHookCallMarker.str("");
    globalStepHookCallMarker.str("");
    beforeAllHookCallMarker.str("");
    afterAllHookCallMarker.str("");
    contextContents.clear();
}

std::string getHookCallMarkers() {
    return beforeAllHookCallMarker.str() + beforeHookCallMarker.str()
           + beforeAroundStepHookCallMarker.str() + afterStepHookCallMarker.str()
           + afterHookCallMarker.str() + afterAllHookCallMarker.str();
}

class EmptyCallableStep : public CallableStep {
public:
    void call() override{};
};

class HookRegistrarDouble : public HookRegistrar {
public:
    static void execAroundStepHooks(Scenario* scenario) {
        EmptyCallableStep emptyStep;
        aroundhook_list_type& ash = aroundStepHooks();
        for (HookRegistrar::aroundhook_list_type::const_iterator h = ash.begin(); h != ash.end();
             ++h) {
            (*h)->invokeHook(scenario, &emptyStep);
        }
    }
};

static const InvokeArgs NO_INVOKE_ARGS;

class HookRegistrationTest : public CukeCommandsFixture {
protected:
    std::shared_ptr<Scenario> emptyScenario;

    HookRegistrationTest() {
        emptyScenario = std::make_shared<Scenario>();
    }

    Scenario* getEmptyScenario() {
        return emptyScenario.get();
    }

    std::string beforeHookOrder() {
        clearHookCallMarkers();
        HookRegistrarDouble::execBeforeHooks(getEmptyScenario());
        return getHookCallMarkers();
    }

    std::string aroundStepHookOrder() {
        clearHookCallMarkers();
        HookRegistrarDouble::execAroundStepHooks(getEmptyScenario());
        return getHookCallMarkers();
    }

    std::string afterStepHookOrder() {
        clearHookCallMarkers();
        HookRegistrarDouble::execAfterStepHooks(getEmptyScenario());
        return getHookCallMarkers();
    }

    std::string afterHookOrder() {
        clearHookCallMarkers();
        HookRegistrarDouble::execAfterHooks(getEmptyScenario());
        return getHookCallMarkers();
    }

    void beginScenario(const TagExpression::tag_list& tags = TagExpression::tag_list()) {
        CukeCommandsFixture::beginScenario(tags);
    }

    void invokeStep() {
        invoke(stepId, &NO_INVOKE_ARGS);
    }

    void endScenario() {
        CukeCommandsFixture::endScenario();
    }

    std::string sort(std::string str) {
        std::sort(str.begin(), str.end());
        return str;
    }

    void SetUp() override {
        CukeCommandsFixture::SetUp();
        clearHookCallMarkers();
        addStepToManager<EmptyStep>(STATIC_MATCHER);
    }
};

}

#endif /* CUKE_HOOKREGISTRATIONFIXTURE_HPP_ */


================================================
FILE: tests/utils/StepManagerTestDouble.hpp
================================================
#ifndef CUKE_STEPMANAGERTESTDOUBLE_HPP_
#define CUKE_STEPMANAGERTESTDOUBLE_HPP_

#include <cucumber-cpp/internal/step/StepManager.hpp>

namespace cucumber {
namespace internal {

class StepInfoNoOp : public StepInfo {
public:
    StepInfoNoOp(const std::string& stepMatcher, const std::string source) :
        StepInfo(stepMatcher, source) {
    }
    InvokeResult invokeStep(const InvokeArgs*) const override {
        return InvokeResult::success();
    }
};

class StepInfoPending : public StepInfo {
private:
    const char* description;

public:
    StepInfoPending(const std::string& stepMatcher, const char* description) :
        StepInfo(stepMatcher, ""),
        description(description) {
    }

    InvokeResult invokeStep(const InvokeArgs*) const override {
        return InvokeResult::pending(description);
    }
};

/*
 * FIXME This should be a mock testing it receives a table argument
 */
class StepInfoWithTableArg : public StepInfo {
    const unsigned short expectedSize;

public:
    StepInfoWithTableArg(const std::string& stepMatcher, const unsigned short expectedSize) :
        StepInfo(stepMatcher, ""),
        expectedSize(expectedSize) {
    }

    InvokeResult invokeStep(const InvokeArgs* pArgs) const override {
        if (pArgs->getTableArg().hashes().size() == expectedSize) {
            return InvokeResult::success();
        } else {
            return InvokeResult::failure("Failed");
        }
    }
};

class StepManagerTestDouble : public StepManager {
public:
    static void clearSteps() {
        steps().clear();
    }

    static steps_type::size_type count() {
        return steps().size();
    }

    static step_id_type addStepDefinition(const std::string& stepMatcher) {
        return addStep(std::make_shared<StepInfoNoOp>(stepMatcher, ""));
    }

    static step_id_type addStepDefinitionWithId(
        step_id_type desiredId, const std::string& stepMatcher
    ) {
        return addStepDefinitionWithId(desiredId, stepMatcher, "");
    }

    static step_id_type addStepDefinitionWithId(
        step_id_type desiredId, const std::string& stepMatcher, const std::string source
    ) {
        std::shared_ptr<StepInfo> stepInfo(std::make_shared<StepInfoNoOp>(stepMatcher, source));
        stepInfo->id = desiredId;
        return addStep(stepInfo);
    }

    static step_id_type addPendingStepDefinitionWithId(
        step_id_type desiredId, const std::string& stepMatcher
    ) {
        return addPendingStepDefinitionWithId(desiredId, stepMatcher, 0);
    }

    static step_id_type addPendingStepDefinitionWithId(
        step_id_type desiredId, const std::string& stepMatcher, const char* description
    ) {
        std::shared_ptr<StepInfo> stepInfo(
            std::make_shared<StepInfoPending>(stepMatcher, description)
        );
        stepInfo->id = desiredId;
        return addStep(stepInfo);
    }

    static step_id_type addTableStepDefinitionWithId(
        step_id_type desiredId, const std::string& stepMatcher, const unsigned short expectedSize
    ) {
        std::shared_ptr<StepInfo> stepInfo(
            std::make_shared<StepInfoWithTableArg>(stepMatcher, expectedSize)
        );
        stepInfo->id = desiredId;
        return addStep(stepInfo);
    }

    static step_id_type getStepId(const std::string& stepMatcher) {
        step_id_type id = 0;
        for (steps_type::const_iterator i = steps().begin(); i != steps().end(); ++i) {
            const StepInfo& stepInfo = *i->second;
            if (stepInfo.regex.str() == stepMatcher) {
                id = stepInfo.id;
                break;
            }
        }
        return id;
    }
};

}
}

#endif /* CUKE_STEPMANAGERTESTDOUBLE_HPP_ */