feat!: rewrite to use cucumber messages

.github/workflows/static-analysis.yml

@@ -44,7 +44,7 @@ jobs:
 
       - name: Run acceptance tests
         run: |
-          bats --formatter junit cucumber_cpp/acceptance_test/coverage.bats | tee test-report.xml
+          bats --formatter junit cucumber_cpp/acceptance_test/test.bats | tee test-report.xml
 
       - name: Collect coverage
         run: |

.gitignore

@@ -3,3 +3,10 @@
 .xwin-cache
 .vs/
 megalinter-reports/
+
+# compatibility generated files
+actual.ndjson
+expected.ndjson
+
+# bats task generated files
+test-report.xml

.ls-lint.yml

@@ -12,3 +12,4 @@ ignore:
   - external
   - megalinter-reports
   - testdata
+  - compatibility

.vscode/launch.json

@@ -15,7 +15,13 @@
                 "@result:UNDEFINED",
                 "@result:FAILED",
                 "@result:OK",
-                "@fail_feature"
+                "@fail_feature",
+                "@ex:2",
+                "@substep",
+                "@table_argument",
+                "@thishasarule",
+                "@nested_steps",
+                "@rules"
             ]
         },
         {
@@ -24,7 +30,10 @@
             "type": "pickString",
             "options": [
                 "cucumber_cpp/example/features",
-                "cucumber_cpp/acceptance_test/features"
+                "cucumber_cpp/example/features/rule.feature",
+                "cucumber_cpp/example/features/substep.feature",
+                "cucumber_cpp/acceptance_test/features",
+                "cucumber_cpp/devkit/empty/features"
             ]
         }
     ],
@@ -35,17 +44,77 @@
             "request": "launch",
             "program": "${command:cmake.launchTargetPath}",
             "args": [
-                "run",
-                "--feature",
-                "${input:features}",
-                "--report",
-                "console",
-                "junit-xml",
-                // "--com",
-                // "COMx",
-                // "--nordic",
-                "--tag",
-                "${input:tag}"
+                "--format",
+                "pretty",
+                "summary",
+                "--retry",
+                "1",
+                "--tags",
+                "${input:tag}",
+                "--",
+                "${input:features}"
+            ],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [
+                {
+                    "name": "ASAN_OPTIONS",
+                    "value": "detect_leaks=0"
+                }
+            ],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        },
+        {
+            "name": "(gdb) Launch dry run",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${command:cmake.launchTargetPath}",
+            "args": [
+                "--format",
+                "usage",
+                "--dry-run",
+                "--",
+                "${input:features}"
+            ],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [
+                {
+                    "name": "ASAN_OPTIONS",
+                    "value": "detect_leaks=0"
+                }
+            ],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        },
+        {
+            "name": "(gdb) Launch - no tags",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${command:cmake.launchTargetPath}",
+            "args": [
+                "--com",
+                "COMx",
+                "--nordic",
+                "--format",
+                "summary",
+                "--",
+                "${input:features}"
             ],
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}",

.vscode/settings.json

@@ -1,6 +1,7 @@
 {
   "cmake.useCMakePresets": "always",
   "cucumberautocomplete.steps": [
+    "compatibility/*/*.cpp",
     "cucumber_cpp/example/steps/*.cpp",
     "cucumber_cpp/acceptance_test/steps/*.cpp"
   ],

.vscode/tasks.json

@@ -6,7 +6,7 @@
         {
             "label": "bats",
             "type": "shell",
-            "command": "bats --formatter junit cucumber_cpp/acceptance_test/test.bats | tee test-report.xml",
+            "command": "bats --formatter junit cucumber_cpp/acceptance_test/test.bats",
             "problemMatcher": []
         }
     ]

CMakeLists.txt

@@ -11,20 +11,26 @@ endif()
 
 if (CCR_STANDALONE)
     set(CCR_DEFAULTOPT On)
-else()
-    set(CCR_DEFAULTOPT Off)
-endif()
-
-if (CCR_STANDALONE)
     set(CCR_EXCLUDE_FROM_ALL "")
+    set(CMAKE_COMPILE_WARNING_AS_ERROR On)
 else()
+    set(CCR_DEFAULTOPT Off)
     set(CCR_EXCLUDE_FROM_ALL "EXCLUDE_FROM_ALL")
 endif()
 
-option(CCR_FETCH_DEPS "Fetch dependencies via FetchContent." On )
+option(CCR_FETCH_DEPS "Fetch dependencies via FetchContent." ${CCR_DEFAULTOPT} )
 option(CCR_BUILD_TESTS "Enable build of the tests" ${CCR_DEFAULTOPT})
 option(CCR_ENABLE_COVERAGE "Enable compiler flags for code coverage measurements" Off)
 
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+if (CCR_STANDALONE AND NOT CCR_ENABLE_COVERAGE)
+    if (NOT (CMAKE_CXX_COMPILER_ID MATCHES "MSVC" OR CMAKE_CXX_SIMULATE_ID MATCHES "MSVC"))
+        add_compile_options(-fsanitize=address -fsanitize=undefined)
+        add_link_options(-fsanitize=address -fsanitize=undefined)
+    endif()
+endif()
+
 if (CCR_BUILD_TESTS)
     ccr_enable_testing()
 endif()
@@ -53,7 +59,6 @@ set_directory_properties(PROPERTY USE_FOLDERS ON)
 include(FetchContent)
 include(GNUInstallDirs)
 include(CTest)
-include(GoogleTest)
 
 if (CCR_FETCH_DEPS)
     add_subdirectory(external)
@@ -64,7 +69,15 @@ else()
     find_package(pugixml REQUIRED)
     find_package(cucumber_messages REQUIRED)
     find_package(cucumber_gherkin REQUIRED)
-    find_package(yaml-cpp REQUIRED)
+    find_package(fmt REQUIRED)
+
+    if (CCR_BUILD_TESTS)
+        find_package(yaml-cpp REQUIRED)
+    endif()
 endif()
 
 add_subdirectory(cucumber_cpp)
+
+if (CCR_STANDALONE)
+    add_subdirectory(compatibility)
+endif()

CMakePresets.json

@@ -13,7 +13,9 @@
             "installDir": "${sourceDir}/.install/${presetName}",
             "cacheVariables": {
                 "CMAKE_EXPORT_COMPILE_COMMANDS": "On",
-                "CMAKE_CONFIGURATION_TYPES": "Debug;RelWithDebInfo;Release"
+                "CMAKE_CONFIGURATION_TYPES": "Debug;RelWithDebInfo;Release",
+                "CMAKE_C_COMPILER_LAUNCHER": "ccache",
+                "CMAKE_CXX_COMPILER_LAUNCHER": "ccache"
             }
         },
         {

README.md

@@ -18,11 +18,148 @@ amp-cucumber-cpp-runner is known to build using:
 amp-cucumber-cpp-runner is not supposed to be used standalone. It is possible to add amp-cucumber-cpp-runner as a submodule to your own project or to use cmake's FetchContent to add amp-cucumber-cpp-runner as a cmake build dependency.
 
 En example project is provided which shows most features of amp-cucumber-cpp-runner and how to configure a cmake project to use amp-cucumber-cpp-runner. The simplest solution is to simply add a dependency on `cucumber-cpp-runner` like so:
-`cmake
-target_link_libraries(cucumber_cpp.example PRIVATE
+
+```cmake
+FetchContent_Declare(cucumber_cpp
+    GIT_REPOSITORY https://github.com/philips-software/amp-cucumber-cpp-runner.git
+    GIT_TAG main
+)
+
+FetchContent_MakeAvailable(cucumber_cpp)
+
+add_executable(my_test_runner)
+target_sources(my_test_runner PRIVATE
+    steps/mysteps.cpp
+    hooks/myhooks.cpp
+)
+
+target_link_libraries(my_test_runner PRIVATE
     cucumber_cpp.runner
 )
-`
+```
+
+## Writing step definitions
+
+Steps are written using the `GIVEN`, `WHEN`, `THEN` or `STEP` macro's. The syntax for step definitions is:
+
+```cpp
+// using cucumber expressions
+
+STEP("cucumber expression without captures"){
+    // body
+}
+
+STEP("cucumber expression with an {int}", (std::int32_t arg)){
+    // body
+}
+
+// or as a regular expression:
+
+STEP(R"(^a regular\?? expression without captures$)"){
+
+}
+
+STEP(R"(^a (regular|unregular) expression with ([1-2]) capture groups$)", (const std::string& type, const std::string& nrOfGroups)){
+
+}
+```
+
+### Builtin Parameter Types
+
+The argument list has to match with the cucumber expression type:
+
+| Cucumber Expression | Parsed as      | Notes                            |
+|---------------------|----------------|----------------------------------|
+| `{int}`             | `std::int32_t` |                                  |
+| `{float}`           | `float`        |                                  |
+| `{word}`            | `std::string`  | words without whitespace         |
+| `{string}`          | `std::string`  | "banana split" or 'banana split' |
+| `{}`                | `std::string`  |                                  |
+| `{bigdecimal}`      | `double`       | non-standard                     |
+| `{biginteger}`      | `std::int64_t` | non-standard                     |
+| `{byte}`            | `std::int8_t`  |                                  |
+| `{short}`           | `std::int16_t` |                                  |
+| `{long}`            | `std::int64_t` |                                  |
+| `{double}`          | `double`       |                                  |
+
+
+See the [Cucumber Expressions documentation](https://github.com/cucumber/cucumber-expressions#readme) for more details on supported types. amp-cucumber-cpp-runner has full support for cucumber expressions.
+
+> ℹ️ except for biginteger, but it's optional
+
+### Custom Parameter Types
+
+There is also support for custom parameter types. They are written and used like:
+
+```cpp
+struct Flight
+{
+    std::string from;
+    std::string to;
+};
+
+PARAMETER(Flight, "flight", "([A-Z]{3})-([A-Z]{3})", true)
+{
+    return { group.children[0].value.value(), group.children[1].value.value() };
+}
+
+STEP(R"({flight} has been delayed)", (const Flight& flight))
+{
+    EXPECT_THAT(flight.from, testing::StrEq("LHR"));
+    EXPECT_THAT(flight.to, testing::StrEq("CDG"));
+}
+```
+
+The `PARAMETER` macro API is as follows:
+```
+PARAMETER(<return type>, <name>, <regular expression>, <use for snippets>)
+```
+> ℹ️ \<use for snippets\> is not supported yet
+
+The `PARAMETER` function body receives an [`const cucumber::messages::group& group`](https://github.com/cucumber/messages/blob/37af3aa8c54ccaf4e61c7cd168d05e39a19c1959/cpp/include/messages/cucumber/messages/group.hpp#L21) as argument.
+
+### Custom step fixtures
+
+amp-cucumber-cpp-runner has support for custom base classes for step definitions using the `GIVEN_F`, `WHEN_F`, `THEN_F` or `STEP_F` macros. These give additional flexibility for re-using common patterns for steps. For example:
+
+```cpp
+struct LoadMeOnConstruction
+{
+    void Tadaa() const
+    {}
+};
+
+struct CustomFixture : cucumber_cpp::library::engine::Step
+{
+    using Step::Step;
+
+    const LoadMeOnConstruction& alwaysAvailable{ context.Get<LoadMeOnConstruction>() };
+};
+
+GIVEN_F(CustomFixture, R"(a custom fixture background step)")
+{
+    alwaysAvailable.Tadaa();
+}
+```
+
+### Assertion Framework
+
+amp-cucumber-cpp-runner uses GoogleTest and GoogleMock as the basis for the assertion framework. For example:
+```cpp
+STEP(R"(the value should be {string})", (const std::string& expected_value))
+{
+    const auto& actual = context.Get<std::string>("cell");
+
+    ASSERT_THAT(actual, testing::StrEq(expected_value));
+}
+```
+
+If asserting (or expecting) is not an option then it is also safe to throw exceptions.
+
+## Writing hook definitions
+
+\<\<todo>>
+
 
 ## How to test the software