From 17f4fc44f4b13a620d008603f31c6dee108c2044 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9my=20Chibois?= Date: Thu, 1 Jun 2023 10:25:10 +0200 Subject: [PATCH] Feature/cpp (#152) * chore: initial cpp structure and implementation * chore: compile ok * chore: cleaned library name, install interface * chore: add message files * chore: missing include * chore: missing include * chore: de-virtualized messages, cleaned CMakeLists * chore: fixed enum * chore: removed inheritance * chore: added nlohmann json library * chore: json serialization * chore: json serialization * chore: missing source file * chore: serialization fixes * chore: made non required properties optional * chore: added convenience global header * chore: removed CMake 3.23+ dependency * fix: installed include directories * chore: fixing json serialization for enums * chore: externalized nlohmann::json dependency, lowered C++ standard to 17 * chore: initial license and Dockerfile * chore: with-dependencies stage build ok * chore: added basic README * chore: added cpp to bake targets * chore: adding C++ workflow * chore: added cpp to languages --------- Co-authored-by: Remy Chibois Co-authored-by: Remy Chibois --- .github/workflows/test-cpp.yml | 33 ++++ CHANGELOG.md | 2 + Makefile | 4 +- README.md | 1 + cpp/.gitignore | 5 + cpp/CMakeLists.txt | 35 ++++ cpp/Dockerfile | 38 ++++ cpp/LICENSE | 21 +++ cpp/Makefile | 73 ++++++++ cpp/README.md | 25 +++ cpp/cmake/toolchains/ext.cmake | 18 ++ cpp/deps.txt | 1 + cpp/include/cucumber/messages/all.hpp | 56 ++++++ cpp/include/cucumber/messages/attachment.hpp | 55 ++++++ .../messages/attachment_content_encoding.hpp | 19 ++ cpp/include/cucumber/messages/background.hpp | 41 +++++ cpp/include/cucumber/messages/ci.hpp | 40 ++++ cpp/include/cucumber/messages/comment.hpp | 38 ++++ cpp/include/cucumber/messages/data_table.hpp | 37 ++++ cpp/include/cucumber/messages/doc_string.hpp | 38 ++++ cpp/include/cucumber/messages/duration.hpp | 37 ++++ cpp/include/cucumber/messages/envelope.hpp | 74 ++++++++ cpp/include/cucumber/messages/examples.hpp | 45 +++++ cpp/include/cucumber/messages/exception.hpp | 36 ++++ cpp/include/cucumber/messages/feature.hpp | 43 +++++ .../cucumber/messages/feature_child.hpp | 41 +++++ .../cucumber/messages/gherkin_document.hpp | 45 +++++ cpp/include/cucumber/messages/git.hpp | 39 ++++ cpp/include/cucumber/messages/group.hpp | 37 ++++ cpp/include/cucumber/messages/hook.hpp | 38 ++++ cpp/include/cucumber/messages/java_method.hpp | 35 ++++ .../messages/java_stack_trace_element.hpp | 35 ++++ cpp/include/cucumber/messages/location.hpp | 36 ++++ cpp/include/cucumber/messages/meta.hpp | 47 +++++ .../cucumber/messages/parameter_type.hpp | 40 ++++ cpp/include/cucumber/messages/parse_error.hpp | 36 ++++ cpp/include/cucumber/messages/pickle.hpp | 55 ++++++ .../cucumber/messages/pickle_doc_string.hpp | 34 ++++ cpp/include/cucumber/messages/pickle_step.hpp | 42 +++++ .../messages/pickle_step_argument.hpp | 39 ++++ .../cucumber/messages/pickle_step_type.hpp | 21 +++ .../cucumber/messages/pickle_table.hpp | 35 ++++ .../cucumber/messages/pickle_table_cell.hpp | 33 ++++ .../cucumber/messages/pickle_table_row.hpp | 35 ++++ cpp/include/cucumber/messages/pickle_tag.hpp | 36 ++++ cpp/include/cucumber/messages/product.hpp | 36 ++++ cpp/include/cucumber/messages/rule.hpp | 43 +++++ cpp/include/cucumber/messages/rule_child.hpp | 39 ++++ cpp/include/cucumber/messages/scenario.hpp | 45 +++++ cpp/include/cucumber/messages/source.hpp | 41 +++++ .../cucumber/messages/source_media_type.hpp | 19 ++ .../cucumber/messages/source_reference.hpp | 43 +++++ cpp/include/cucumber/messages/step.hpp | 46 +++++ .../cucumber/messages/step_definition.hpp | 38 ++++ .../messages/step_definition_pattern.hpp | 36 ++++ .../messages/step_definition_pattern_type.hpp | 19 ++ .../cucumber/messages/step_keyword_type.hpp | 22 +++ .../cucumber/messages/step_match_argument.hpp | 43 +++++ .../messages/step_match_arguments_list.hpp | 35 ++++ cpp/include/cucumber/messages/table_cell.hpp | 38 ++++ cpp/include/cucumber/messages/table_row.hpp | 40 ++++ cpp/include/cucumber/messages/tag.hpp | 39 ++++ cpp/include/cucumber/messages/test_case.hpp | 41 +++++ .../cucumber/messages/test_case_finished.hpp | 37 ++++ .../cucumber/messages/test_case_started.hpp | 39 ++++ .../cucumber/messages/test_run_finished.hpp | 39 ++++ .../cucumber/messages/test_run_started.hpp | 35 ++++ cpp/include/cucumber/messages/test_step.hpp | 42 +++++ .../cucumber/messages/test_step_finished.hpp | 39 ++++ .../cucumber/messages/test_step_result.hpp | 40 ++++ .../messages/test_step_result_status.hpp | 24 +++ .../cucumber/messages/test_step_started.hpp | 37 ++++ cpp/include/cucumber/messages/timestamp.hpp | 34 ++++ .../messages/undefined_parameter_type.hpp | 34 ++++ cpp/scripts/build-ext | 122 +++++++++++++ cpp/scripts/build-externals | 172 ++++++++++++++++++ cpp/src/CMakeLists.txt | 1 + cpp/src/lib/CMakeLists.txt | 1 + cpp/src/lib/cucumber-messages/CMakeLists.txt | 36 ++++ .../cucumber/messages/attachment.cpp | 62 +++++++ .../messages/attachment_content_encoding.cpp | 28 +++ .../cucumber/messages/background.cpp | 58 ++++++ .../cucumber/messages/ci.cpp | 54 ++++++ .../cucumber/messages/comment.cpp | 50 +++++ .../cucumber/messages/data_table.cpp | 50 +++++ .../cucumber/messages/doc_string.cpp | 54 ++++++ .../cucumber/messages/duration.cpp | 50 +++++ .../cucumber/messages/envelope.cpp | 80 ++++++++ .../cucumber/messages/examples.cpp | 62 +++++++ .../cucumber/messages/exception.cpp | 50 +++++ .../cucumber/messages/feature.cpp | 60 ++++++ .../cucumber/messages/feature_child.cpp | 52 ++++++ .../cucumber/messages/gherkin_document.cpp | 52 ++++++ .../cucumber/messages/git.cpp | 54 ++++++ .../cucumber/messages/group.cpp | 52 ++++++ .../cucumber/messages/hook.cpp | 54 ++++++ .../cucumber/messages/java_method.cpp | 52 ++++++ .../messages/java_stack_trace_element.cpp | 52 ++++++ .../cucumber/messages/location.cpp | 50 +++++ .../cucumber/messages/meta.cpp | 58 ++++++ .../cucumber/messages/parameter_type.cpp | 58 ++++++ .../cucumber/messages/parse_error.cpp | 50 +++++ .../cucumber/messages/pickle.cpp | 60 ++++++ .../cucumber/messages/pickle_doc_string.cpp | 50 +++++ .../cucumber/messages/pickle_step.cpp | 56 ++++++ .../messages/pickle_step_argument.cpp | 50 +++++ .../cucumber/messages/pickle_step_type.cpp | 30 +++ .../cucumber/messages/pickle_table.cpp | 48 +++++ .../cucumber/messages/pickle_table_cell.cpp | 48 +++++ .../cucumber/messages/pickle_table_row.cpp | 48 +++++ .../cucumber/messages/pickle_tag.cpp | 50 +++++ .../cucumber/messages/product.cpp | 50 +++++ .../cucumber/messages/rule.cpp | 60 ++++++ .../cucumber/messages/rule_child.cpp | 50 +++++ .../cucumber/messages/scenario.cpp | 62 +++++++ .../cucumber/messages/source.cpp | 52 ++++++ .../cucumber/messages/source_media_type.cpp | 28 +++ .../cucumber/messages/source_reference.cpp | 54 ++++++ .../cucumber/messages/step.cpp | 60 ++++++ .../cucumber/messages/step_definition.cpp | 52 ++++++ .../messages/step_definition_pattern.cpp | 50 +++++ .../messages/step_definition_pattern_type.cpp | 28 +++ .../cucumber/messages/step_keyword_type.cpp | 31 ++++ .../cucumber/messages/step_match_argument.cpp | 50 +++++ .../messages/step_match_arguments_list.cpp | 48 +++++ .../cucumber/messages/table_cell.cpp | 50 +++++ .../cucumber/messages/table_row.cpp | 52 ++++++ .../cucumber/messages/tag.cpp | 52 ++++++ .../cucumber/messages/test_case.cpp | 52 ++++++ .../cucumber/messages/test_case_finished.cpp | 52 ++++++ .../cucumber/messages/test_case_started.cpp | 56 ++++++ .../cucumber/messages/test_run_finished.cpp | 54 ++++++ .../cucumber/messages/test_run_started.cpp | 48 +++++ .../cucumber/messages/test_step.cpp | 56 ++++++ .../cucumber/messages/test_step_finished.cpp | 54 ++++++ .../cucumber/messages/test_step_result.cpp | 54 ++++++ .../messages/test_step_result_status.cpp | 33 ++++ .../cucumber/messages/test_step_started.cpp | 52 ++++++ .../cucumber/messages/timestamp.cpp | 50 +++++ .../messages/undefined_parameter_type.cpp | 50 +++++ .../cucumber/messages/utils.cpp | 28 +++ .../cucumber/messages/utils.hpp | 109 +++++++++++ docker-bake.hcl | 19 ++ jsonschema/scripts/codegen.rb | 27 +++ jsonschema/scripts/templates/cpp.enum.hpp.erb | 54 ++++++ jsonschema/scripts/templates/cpp.hpp.erb | 147 +++++++++++++++ 146 files changed, 6473 insertions(+), 2 deletions(-) create mode 100644 .github/workflows/test-cpp.yml create mode 100644 cpp/.gitignore create mode 100644 cpp/CMakeLists.txt create mode 100644 cpp/Dockerfile create mode 100644 cpp/LICENSE create mode 100644 cpp/Makefile create mode 100644 cpp/README.md create mode 100644 cpp/cmake/toolchains/ext.cmake create mode 100644 cpp/deps.txt create mode 100644 cpp/include/cucumber/messages/all.hpp create mode 100644 cpp/include/cucumber/messages/attachment.hpp create mode 100644 cpp/include/cucumber/messages/attachment_content_encoding.hpp create mode 100644 cpp/include/cucumber/messages/background.hpp create mode 100644 cpp/include/cucumber/messages/ci.hpp create mode 100644 cpp/include/cucumber/messages/comment.hpp create mode 100644 cpp/include/cucumber/messages/data_table.hpp create mode 100644 cpp/include/cucumber/messages/doc_string.hpp create mode 100644 cpp/include/cucumber/messages/duration.hpp create mode 100644 cpp/include/cucumber/messages/envelope.hpp create mode 100644 cpp/include/cucumber/messages/examples.hpp create mode 100644 cpp/include/cucumber/messages/exception.hpp create mode 100644 cpp/include/cucumber/messages/feature.hpp create mode 100644 cpp/include/cucumber/messages/feature_child.hpp create mode 100644 cpp/include/cucumber/messages/gherkin_document.hpp create mode 100644 cpp/include/cucumber/messages/git.hpp create mode 100644 cpp/include/cucumber/messages/group.hpp create mode 100644 cpp/include/cucumber/messages/hook.hpp create mode 100644 cpp/include/cucumber/messages/java_method.hpp create mode 100644 cpp/include/cucumber/messages/java_stack_trace_element.hpp create mode 100644 cpp/include/cucumber/messages/location.hpp create mode 100644 cpp/include/cucumber/messages/meta.hpp create mode 100644 cpp/include/cucumber/messages/parameter_type.hpp create mode 100644 cpp/include/cucumber/messages/parse_error.hpp create mode 100644 cpp/include/cucumber/messages/pickle.hpp create mode 100644 cpp/include/cucumber/messages/pickle_doc_string.hpp create mode 100644 cpp/include/cucumber/messages/pickle_step.hpp create mode 100644 cpp/include/cucumber/messages/pickle_step_argument.hpp create mode 100644 cpp/include/cucumber/messages/pickle_step_type.hpp create mode 100644 cpp/include/cucumber/messages/pickle_table.hpp create mode 100644 cpp/include/cucumber/messages/pickle_table_cell.hpp create mode 100644 cpp/include/cucumber/messages/pickle_table_row.hpp create mode 100644 cpp/include/cucumber/messages/pickle_tag.hpp create mode 100644 cpp/include/cucumber/messages/product.hpp create mode 100644 cpp/include/cucumber/messages/rule.hpp create mode 100644 cpp/include/cucumber/messages/rule_child.hpp create mode 100644 cpp/include/cucumber/messages/scenario.hpp create mode 100644 cpp/include/cucumber/messages/source.hpp create mode 100644 cpp/include/cucumber/messages/source_media_type.hpp create mode 100644 cpp/include/cucumber/messages/source_reference.hpp create mode 100644 cpp/include/cucumber/messages/step.hpp create mode 100644 cpp/include/cucumber/messages/step_definition.hpp create mode 100644 cpp/include/cucumber/messages/step_definition_pattern.hpp create mode 100644 cpp/include/cucumber/messages/step_definition_pattern_type.hpp create mode 100644 cpp/include/cucumber/messages/step_keyword_type.hpp create mode 100644 cpp/include/cucumber/messages/step_match_argument.hpp create mode 100644 cpp/include/cucumber/messages/step_match_arguments_list.hpp create mode 100644 cpp/include/cucumber/messages/table_cell.hpp create mode 100644 cpp/include/cucumber/messages/table_row.hpp create mode 100644 cpp/include/cucumber/messages/tag.hpp create mode 100644 cpp/include/cucumber/messages/test_case.hpp create mode 100644 cpp/include/cucumber/messages/test_case_finished.hpp create mode 100644 cpp/include/cucumber/messages/test_case_started.hpp create mode 100644 cpp/include/cucumber/messages/test_run_finished.hpp create mode 100644 cpp/include/cucumber/messages/test_run_started.hpp create mode 100644 cpp/include/cucumber/messages/test_step.hpp create mode 100644 cpp/include/cucumber/messages/test_step_finished.hpp create mode 100644 cpp/include/cucumber/messages/test_step_result.hpp create mode 100644 cpp/include/cucumber/messages/test_step_result_status.hpp create mode 100644 cpp/include/cucumber/messages/test_step_started.hpp create mode 100644 cpp/include/cucumber/messages/timestamp.hpp create mode 100644 cpp/include/cucumber/messages/undefined_parameter_type.hpp create mode 100755 cpp/scripts/build-ext create mode 100755 cpp/scripts/build-externals create mode 100644 cpp/src/CMakeLists.txt create mode 100644 cpp/src/lib/CMakeLists.txt create mode 100644 cpp/src/lib/cucumber-messages/CMakeLists.txt create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/attachment.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/attachment_content_encoding.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/background.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/ci.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/comment.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/data_table.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/doc_string.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/duration.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/envelope.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/examples.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/exception.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/feature.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/feature_child.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/gherkin_document.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/git.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/group.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/hook.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/java_method.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/java_stack_trace_element.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/location.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/meta.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/parameter_type.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/parse_error.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/pickle.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/pickle_doc_string.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step_argument.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step_type.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table_cell.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table_row.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/pickle_tag.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/product.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/rule.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/rule_child.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/scenario.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/source.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/source_media_type.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/source_reference.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/step.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/step_definition.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/step_definition_pattern.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/step_definition_pattern_type.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/step_keyword_type.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/step_match_argument.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/step_match_arguments_list.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/table_cell.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/table_row.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/tag.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/test_case.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/test_case_finished.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/test_case_started.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/test_run_finished.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/test_run_started.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/test_step.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/test_step_finished.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/test_step_result.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/test_step_result_status.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/test_step_started.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/timestamp.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/undefined_parameter_type.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/utils.cpp create mode 100644 cpp/src/lib/cucumber-messages/cucumber/messages/utils.hpp create mode 100644 jsonschema/scripts/templates/cpp.enum.hpp.erb create mode 100644 jsonschema/scripts/templates/cpp.hpp.erb diff --git a/.github/workflows/test-cpp.yml b/.github/workflows/test-cpp.yml new file mode 100644 index 00000000..809449eb --- /dev/null +++ b/.github/workflows/test-cpp.yml @@ -0,0 +1,33 @@ +name: test-cpp + +on: + push: + branches: + - main + - renovate/** + pull_request: + branches: + - main + workflow_call: + +jobs: + test-cpp: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + + - name: install cmake and libraries + run: | + sudo apt-get update + sudo apt-get install ninja-build cmake + sudo apt-get install nlohmann-json3-dev + ninja --version + cmake --version + gcc --version + + - name: configure and build + run: | + cmake -S . -B build + cmake --build build + working-directory: cpp diff --git a/CHANGELOG.md b/CHANGELOG.md index 3d3308ee..52bcdd99 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/). ## [Unreleased] +### Added +- Added C++ implementation ([#152](https://github.com/cucumber/messages/pull/152)) ## [22.0.0] - 2023-04-06 ### Added diff --git a/Makefile b/Makefile index 7c8c61d0..11a201dd 100644 --- a/Makefile +++ b/Makefile @@ -24,7 +24,7 @@ schemas = \ ./jsonschema/UndefinedParameterType.json \ ./jsonschema/Envelope.json -languages = go java javascript perl php ruby +languages = cpp go java javascript perl php ruby .DEFAULT_GOAL = help @@ -63,4 +63,4 @@ generate-%: % clean-%: % cd $< && make clean -.PHONY: clean-% \ No newline at end of file +.PHONY: clean-% diff --git a/README.md b/README.md index 7e526eb2..88904605 100644 --- a/README.md +++ b/README.md @@ -32,6 +32,7 @@ Each message in a message stream is of type [Envelope](messages.md#envelope). Each subdirectory defines language-specific implementations of these messages, generated from the JSON schemas. The current implementation are: - .Net +- C++ - Elixir - Go - Java diff --git a/cpp/.gitignore b/cpp/.gitignore new file mode 100644 index 00000000..c99592be --- /dev/null +++ b/cpp/.gitignore @@ -0,0 +1,5 @@ +.configured +.built +build/ +ext/ +stage/ diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt new file mode 100644 index 00000000..30290aa5 --- /dev/null +++ b/cpp/CMakeLists.txt @@ -0,0 +1,35 @@ +cmake_minimum_required(VERSION 3.12 FATAL_ERROR) + +project(cucumber-messages VERSION 1.0.0 LANGUAGES CXX) + +include(GNUInstallDirs) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_CXX_EXTENSIONS OFF) +set(CMAKE_POSITION_INDEPENDENT_CODE ON) + +find_package(nlohmann_json CONFIG REQUIRED) + +add_subdirectory(src) + +install( + TARGETS + cucumber-messages + EXPORT cucumber-messages-config + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} +) + +install( + DIRECTORY "${CMAKE_SOURCE_DIR}/include/" + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/cucumber +) + +install( + EXPORT cucumber-messages-config + FILE cucumber-messages-config.cmake + NAMESPACE cucumber:: + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/cucumber-messages +) diff --git a/cpp/Dockerfile b/cpp/Dockerfile new file mode 100644 index 00000000..39f12155 --- /dev/null +++ b/cpp/Dockerfile @@ -0,0 +1,38 @@ +#syntax=docker/dockerfile:1.4 + +# Base image +FROM debian:bullseye-slim AS cpp + +RUN <\n\nWhere is one of:\n"} /^[$$()% a-zA-Z_-]+:.*?##/ { printf " \033[36m%-15s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST) + +generate: require .generate-messages ## Generate C++ code based on the schemas found in ../jsonschema and using the scripts in ../jsonschema/scripts for the generation + +require: ## Check requirements for the code generation (ruby, csplit and tail are required) + @ruby --version >/dev/null 2>&1 || (echo "ERROR: ruby is required."; exit 1) + @csplit --version >/dev/null 2>&1 || (echo "ERROR: csplit is required."; exit 1) + @tail --version >/dev/null 2>&1 || (echo "ERROR: tail is required."; exit 1) + +clean: ## Remove automatically generated files and related artifacts + rm -rf build .configured + +.generate-messages: $(schemas) ../jsonschema/scripts/codegen.rb ../jsonschema/scripts/templates/cpp.hpp.erb ../jsonschema/scripts/templates/cpp.enum.hpp.erb + ruby ../jsonschema/scripts/codegen.rb Cpp ../jsonschema cpp.hpp.erb > Generated.hpp.tmp + ruby ../jsonschema/scripts/codegen.rb Cpp ../jsonschema cpp.enum.hpp.erb >> Generated.hpp.tmp + csplit --quiet --prefix=Generated --suffix-format=%02d.hpp.tmp --elide-empty-files Generated.hpp.tmp /^[A-Za-z_.]*[.][ch]pp/ {*} + rm Generated.hpp.tmp + + for file in Generated**; do \ + F=$$(head -n 1 $$file | tr -d '\r\n'); \ + if [ -n "$$F" ]; then \ + tail -n +2 $$file > $(INC_DIR)/$$F; \ + fi; \ + rm $$file; \ + done + + mv $(INC_DIR)/*.cpp $(LIB_DIR)/ || true + +clean-build: + rm -rf build .configured .built + +clean-deps: + rm -rf ext build/src build/root + +install-deps: + ./scripts/build-externals deps.txt + +.configured: $(CMAKELISTS) + mkdir -p build + cmake \ + -DCMAKE_PREFIX_PATH=$(CMAKE_BUILDROOT) \ + -DCMAKE_INSTALL_PREFIX=$(HERE)/stage \ + -S . \ + -B build \ + --toolchain cmake/toolchains/ext.cmake \ + && touch $@ + +clean-configure: + rm -f .configured + +reconfigure: clean-configure .configured + +rebuild: reconfigure .built + +.built: .configured $(SOURCES) + cmake --build build --parallel && touch $@ + cmake --install build diff --git a/cpp/README.md b/cpp/README.md new file mode 100644 index 00000000..139eeb6c --- /dev/null +++ b/cpp/README.md @@ -0,0 +1,25 @@ +# Cucumber Messages for C++ (JSON schema) + +## Requirements + +This library requires: +- A C++ 17 compiler (tested with GCC 10, 12) +- [JSON for Modern C++](https://json.nlohmann.me/) + +## Installing from Git repository + +```shell +$ git clone https://github.com/cucumber/messages +$ cd messages/cpp +$ cmake -S . -B build +$ cmake --build build +$ cmake --install build +``` + +## CMake integration + +```cmake +find_package(cucumber-messages CONFIG REQUIRED) + +target_link_libraries(mylib PRIVATE cucumber::cucumber-messages) +``` diff --git a/cpp/cmake/toolchains/ext.cmake b/cpp/cmake/toolchains/ext.cmake new file mode 100644 index 00000000..192b99b9 --- /dev/null +++ b/cpp/cmake/toolchains/ext.cmake @@ -0,0 +1,18 @@ +# +# CMake toolchain to be used when building external libraries +# + +# use, i.e. don't skip the full RPATH for the build tree +set(CMAKE_SKIP_BUILD_RPATH FALSE) + +find_program(CCACHE ccache) + +if(CCACHE) + set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE}") + set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE}") +endif() + +if(DEFINED ENV{GHERKIN_DEBUG}) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fsanitize=address") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -fsanitize=address") +endif() diff --git a/cpp/deps.txt b/cpp/deps.txt new file mode 100644 index 00000000..81debec6 --- /dev/null +++ b/cpp/deps.txt @@ -0,0 +1 @@ +https://github.com/nlohmann/json/archive/refs/tags/v3.11.2.zip -DJSON_BuildTests=OFF diff --git a/cpp/include/cucumber/messages/all.hpp b/cpp/include/cucumber/messages/all.hpp new file mode 100644 index 00000000..4b4dc10c --- /dev/null +++ b/cpp/include/cucumber/messages/all.hpp @@ -0,0 +1,56 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + diff --git a/cpp/include/cucumber/messages/attachment.hpp b/cpp/include/cucumber/messages/attachment.hpp new file mode 100644 index 00000000..25fcef3f --- /dev/null +++ b/cpp/include/cucumber/messages/attachment.hpp @@ -0,0 +1,55 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Attachment message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// //// Attachments (parse errors, execution errors, screenshots, links...) +// +// An attachment represents any kind of data associated with a line in a +// [Source](#io.cucumber.messages.Source) file. It can be used for: +// +// * Syntax errors during parse time +// * Screenshots captured and attached during execution +// * Logs captured and attached during execution +// +// It is not to be used for runtime errors raised/thrown during execution. This +// is captured in `TestResult`. +// +// Generated code + +struct attachment +{ + std::string body; + cucumber::messages::attachment_content_encoding content_encoding; + std::optional file_name; + std::string media_type; + std::optional source; + std::optional test_case_started_id; + std::optional test_step_id; + std::optional url; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const attachment& msg); + +void to_json(json& j, const attachment& m); + +} diff --git a/cpp/include/cucumber/messages/attachment_content_encoding.hpp b/cpp/include/cucumber/messages/attachment_content_encoding.hpp new file mode 100644 index 00000000..36f54140 --- /dev/null +++ b/cpp/include/cucumber/messages/attachment_content_encoding.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include + +namespace cucumber::messages { + +enum class attachment_content_encoding +{ + IDENTITY, + BASE64 +}; + +std::string_view +to_string(attachment_content_encoding v); + +std::ostream& +operator<<(std::ostream& os, attachment_content_encoding v); + +} diff --git a/cpp/include/cucumber/messages/background.hpp b/cpp/include/cucumber/messages/background.hpp new file mode 100644 index 00000000..e5d8cf9f --- /dev/null +++ b/cpp/include/cucumber/messages/background.hpp @@ -0,0 +1,41 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Background message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct background +{ + cucumber::messages::location location; + std::string keyword; + std::string name; + std::string description; + std::vector steps; + std::string id; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const background& msg); + +void to_json(json& j, const background& m); + +} diff --git a/cpp/include/cucumber/messages/ci.hpp b/cpp/include/cucumber/messages/ci.hpp new file mode 100644 index 00000000..05f59324 --- /dev/null +++ b/cpp/include/cucumber/messages/ci.hpp @@ -0,0 +1,40 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Ci message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// CI environment +// +// Generated code + +struct ci +{ + std::string name; + std::optional url; + std::optional build_number; + std::optional git; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const ci& msg); + +void to_json(json& j, const ci& m); + +} diff --git a/cpp/include/cucumber/messages/comment.hpp b/cpp/include/cucumber/messages/comment.hpp new file mode 100644 index 00000000..76876514 --- /dev/null +++ b/cpp/include/cucumber/messages/comment.hpp @@ -0,0 +1,38 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Comment message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// A comment in a Gherkin document +// +// Generated code + +struct comment +{ + cucumber::messages::location location; + std::string text; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const comment& msg); + +void to_json(json& j, const comment& m); + +} diff --git a/cpp/include/cucumber/messages/data_table.hpp b/cpp/include/cucumber/messages/data_table.hpp new file mode 100644 index 00000000..ec3ce1d7 --- /dev/null +++ b/cpp/include/cucumber/messages/data_table.hpp @@ -0,0 +1,37 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the DataTable message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct data_table +{ + cucumber::messages::location location; + std::vector rows; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const data_table& msg); + +void to_json(json& j, const data_table& m); + +} diff --git a/cpp/include/cucumber/messages/doc_string.hpp b/cpp/include/cucumber/messages/doc_string.hpp new file mode 100644 index 00000000..bd29a765 --- /dev/null +++ b/cpp/include/cucumber/messages/doc_string.hpp @@ -0,0 +1,38 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the DocString message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct doc_string +{ + cucumber::messages::location location; + std::optional media_type; + std::string content; + std::string delimiter; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const doc_string& msg); + +void to_json(json& j, const doc_string& m); + +} diff --git a/cpp/include/cucumber/messages/duration.hpp b/cpp/include/cucumber/messages/duration.hpp new file mode 100644 index 00000000..aebdcaa1 --- /dev/null +++ b/cpp/include/cucumber/messages/duration.hpp @@ -0,0 +1,37 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Duration message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// The structure is pretty close of the Timestamp one. For clarity, a second type +// of message is used. +// +// Generated code + +struct duration +{ + std::size_t seconds; + std::size_t nanos; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const duration& msg); + +void to_json(json& j, const duration& m); + +} diff --git a/cpp/include/cucumber/messages/envelope.hpp b/cpp/include/cucumber/messages/envelope.hpp new file mode 100644 index 00000000..4fc8e258 --- /dev/null +++ b/cpp/include/cucumber/messages/envelope.hpp @@ -0,0 +1,74 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Envelope message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// When removing a field, replace it with reserved, rather than deleting the line. +// When adding a field, add it to the end and increment the number by one. +// See https://developers.google.com/protocol-buffers/docs/proto#updating for details +// +// All the messages that are passed between different components/processes are Envelope +// messages. +// +// Generated code + +struct envelope +{ + std::optional attachment; + std::optional gherkin_document; + std::optional hook; + std::optional meta; + std::optional parameter_type; + std::optional parse_error; + std::optional pickle; + std::optional source; + std::optional step_definition; + std::optional test_case; + std::optional test_case_finished; + std::optional test_case_started; + std::optional test_run_finished; + std::optional test_run_started; + std::optional test_step_finished; + std::optional test_step_started; + std::optional undefined_parameter_type; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const envelope& msg); + +void to_json(json& j, const envelope& m); + +} diff --git a/cpp/include/cucumber/messages/examples.hpp b/cpp/include/cucumber/messages/examples.hpp new file mode 100644 index 00000000..bc23086a --- /dev/null +++ b/cpp/include/cucumber/messages/examples.hpp @@ -0,0 +1,45 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Examples message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct examples +{ + cucumber::messages::location location; + std::vector tags; + std::string keyword; + std::string name; + std::string description; + std::optional table_header; + std::vector table_body; + std::string id; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const examples& msg); + +void to_json(json& j, const examples& m); + +} diff --git a/cpp/include/cucumber/messages/exception.hpp b/cpp/include/cucumber/messages/exception.hpp new file mode 100644 index 00000000..c7712676 --- /dev/null +++ b/cpp/include/cucumber/messages/exception.hpp @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Exception message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// A simplified representation of an exception +// +// Generated code + +struct exception +{ + std::string type; + std::optional message; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const exception& msg); + +void to_json(json& j, const exception& m); + +} diff --git a/cpp/include/cucumber/messages/feature.hpp b/cpp/include/cucumber/messages/feature.hpp new file mode 100644 index 00000000..85fb7a73 --- /dev/null +++ b/cpp/include/cucumber/messages/feature.hpp @@ -0,0 +1,43 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Feature message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct feature +{ + cucumber::messages::location location; + std::vector tags; + std::string language; + std::string keyword; + std::string name; + std::string description; + std::vector children; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const feature& msg); + +void to_json(json& j, const feature& m); + +} diff --git a/cpp/include/cucumber/messages/feature_child.hpp b/cpp/include/cucumber/messages/feature_child.hpp new file mode 100644 index 00000000..6dace2f3 --- /dev/null +++ b/cpp/include/cucumber/messages/feature_child.hpp @@ -0,0 +1,41 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the FeatureChild message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// A child node of a `Feature` node +// +// Generated code + +struct feature_child +{ + std::optional rule; + std::optional background; + std::optional scenario; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const feature_child& msg); + +void to_json(json& j, const feature_child& m); + +} diff --git a/cpp/include/cucumber/messages/gherkin_document.hpp b/cpp/include/cucumber/messages/gherkin_document.hpp new file mode 100644 index 00000000..9dd49305 --- /dev/null +++ b/cpp/include/cucumber/messages/gherkin_document.hpp @@ -0,0 +1,45 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the GherkinDocument message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// The [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) of a Gherkin document. +// Cucumber implementations should *not* depend on `GherkinDocument` or any of its +// children for execution - use [Pickle](#io.cucumber.messages.Pickle) instead. +// +// The only consumers of `GherkinDocument` should only be formatters that produce +// "rich" output, resembling the original Gherkin document. +// +// Generated code + +struct gherkin_document +{ + std::optional uri; + std::optional feature; + std::vector comments; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const gherkin_document& msg); + +void to_json(json& j, const gherkin_document& m); + +} diff --git a/cpp/include/cucumber/messages/git.hpp b/cpp/include/cucumber/messages/git.hpp new file mode 100644 index 00000000..751b2795 --- /dev/null +++ b/cpp/include/cucumber/messages/git.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Git message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Information about Git, provided by the Build/CI server as environment +// variables. +// +// Generated code + +struct git +{ + std::string remote; + std::string revision; + std::optional branch; + std::optional tag; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const git& msg); + +void to_json(json& j, const git& m); + +} diff --git a/cpp/include/cucumber/messages/group.hpp b/cpp/include/cucumber/messages/group.hpp new file mode 100644 index 00000000..a1af3681 --- /dev/null +++ b/cpp/include/cucumber/messages/group.hpp @@ -0,0 +1,37 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Group message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct group +{ + std::vector children; + std::optional start; + std::optional value; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const group& msg); + +void to_json(json& j, const group& m); + +} diff --git a/cpp/include/cucumber/messages/hook.hpp b/cpp/include/cucumber/messages/hook.hpp new file mode 100644 index 00000000..ee645659 --- /dev/null +++ b/cpp/include/cucumber/messages/hook.hpp @@ -0,0 +1,38 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Hook message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct hook +{ + std::string id; + std::optional name; + cucumber::messages::source_reference source_reference; + std::optional tag_expression; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const hook& msg); + +void to_json(json& j, const hook& m); + +} diff --git a/cpp/include/cucumber/messages/java_method.hpp b/cpp/include/cucumber/messages/java_method.hpp new file mode 100644 index 00000000..9f3d14a4 --- /dev/null +++ b/cpp/include/cucumber/messages/java_method.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the JavaMethod message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct java_method +{ + std::string class_name; + std::string method_name; + std::vector method_parameter_types; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const java_method& msg); + +void to_json(json& j, const java_method& m); + +} diff --git a/cpp/include/cucumber/messages/java_stack_trace_element.hpp b/cpp/include/cucumber/messages/java_stack_trace_element.hpp new file mode 100644 index 00000000..fc2ecc39 --- /dev/null +++ b/cpp/include/cucumber/messages/java_stack_trace_element.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the JavaStackTraceElement message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct java_stack_trace_element +{ + std::string class_name; + std::string file_name; + std::string method_name; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const java_stack_trace_element& msg); + +void to_json(json& j, const java_stack_trace_element& m); + +} diff --git a/cpp/include/cucumber/messages/location.hpp b/cpp/include/cucumber/messages/location.hpp new file mode 100644 index 00000000..f09a54e2 --- /dev/null +++ b/cpp/include/cucumber/messages/location.hpp @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Location message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Points to a line and a column in a text file +// +// Generated code + +struct location +{ + std::size_t line; + std::optional column; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const location& msg); + +void to_json(json& j, const location& m); + +} diff --git a/cpp/include/cucumber/messages/meta.hpp b/cpp/include/cucumber/messages/meta.hpp new file mode 100644 index 00000000..77ec0b3a --- /dev/null +++ b/cpp/include/cucumber/messages/meta.hpp @@ -0,0 +1,47 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Meta message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// This message contains meta information about the environment. Consumers can use +// this for various purposes. +// +// Generated code + +struct meta +{ + std::string protocol_version; + cucumber::messages::product implementation; + cucumber::messages::product runtime; + cucumber::messages::product os; + cucumber::messages::product cpu; + std::optional ci; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const meta& msg); + +void to_json(json& j, const meta& m); + +} diff --git a/cpp/include/cucumber/messages/parameter_type.hpp b/cpp/include/cucumber/messages/parameter_type.hpp new file mode 100644 index 00000000..1f084db7 --- /dev/null +++ b/cpp/include/cucumber/messages/parameter_type.hpp @@ -0,0 +1,40 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the ParameterType message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct parameter_type +{ + std::string name; + std::vector regular_expressions; + bool prefer_for_regular_expression_match; + bool use_for_snippets; + std::string id; + std::optional source_reference; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const parameter_type& msg); + +void to_json(json& j, const parameter_type& m); + +} diff --git a/cpp/include/cucumber/messages/parse_error.hpp b/cpp/include/cucumber/messages/parse_error.hpp new file mode 100644 index 00000000..9ac5464e --- /dev/null +++ b/cpp/include/cucumber/messages/parse_error.hpp @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the ParseError message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct parse_error +{ + cucumber::messages::source_reference source; + std::string message; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const parse_error& msg); + +void to_json(json& j, const parse_error& m); + +} diff --git a/cpp/include/cucumber/messages/pickle.hpp b/cpp/include/cucumber/messages/pickle.hpp new file mode 100644 index 00000000..dc01fb47 --- /dev/null +++ b/cpp/include/cucumber/messages/pickle.hpp @@ -0,0 +1,55 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Pickle message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// //// Pickles +// +// A `Pickle` represents a template for a `TestCase`. It is typically derived +// from another format, such as [GherkinDocument](#io.cucumber.messages.GherkinDocument). +// In the future a `Pickle` may be derived from other formats such as Markdown or +// Excel files. +// +// By making `Pickle` the main data structure Cucumber uses for execution, the +// implementation of Cucumber itself becomes simpler, as it doesn't have to deal +// with the complex structure of a [GherkinDocument](#io.cucumber.messages.GherkinDocument). +// +// Each `PickleStep` of a `Pickle` is matched with a `StepDefinition` to create a `TestCase` +// +// Generated code + +struct pickle +{ + std::string id; + std::string uri; + std::string name; + std::string language; + std::vector steps; + std::vector tags; + std::vector ast_node_ids; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const pickle& msg); + +void to_json(json& j, const pickle& m); + +} diff --git a/cpp/include/cucumber/messages/pickle_doc_string.hpp b/cpp/include/cucumber/messages/pickle_doc_string.hpp new file mode 100644 index 00000000..6171bb95 --- /dev/null +++ b/cpp/include/cucumber/messages/pickle_doc_string.hpp @@ -0,0 +1,34 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the PickleDocString message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct pickle_doc_string +{ + std::optional media_type; + std::string content; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const pickle_doc_string& msg); + +void to_json(json& j, const pickle_doc_string& m); + +} diff --git a/cpp/include/cucumber/messages/pickle_step.hpp b/cpp/include/cucumber/messages/pickle_step.hpp new file mode 100644 index 00000000..dbf8ddcd --- /dev/null +++ b/cpp/include/cucumber/messages/pickle_step.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the PickleStep message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// An executable step +// +// Generated code + +struct pickle_step +{ + std::optional argument; + std::vector ast_node_ids; + std::string id; + std::optional type; + std::string text; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const pickle_step& msg); + +void to_json(json& j, const pickle_step& m); + +} diff --git a/cpp/include/cucumber/messages/pickle_step_argument.hpp b/cpp/include/cucumber/messages/pickle_step_argument.hpp new file mode 100644 index 00000000..d701c01d --- /dev/null +++ b/cpp/include/cucumber/messages/pickle_step_argument.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the PickleStepArgument message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// An optional argument +// +// Generated code + +struct pickle_step_argument +{ + std::optional doc_string; + std::optional data_table; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const pickle_step_argument& msg); + +void to_json(json& j, const pickle_step_argument& m); + +} diff --git a/cpp/include/cucumber/messages/pickle_step_type.hpp b/cpp/include/cucumber/messages/pickle_step_type.hpp new file mode 100644 index 00000000..40a7f083 --- /dev/null +++ b/cpp/include/cucumber/messages/pickle_step_type.hpp @@ -0,0 +1,21 @@ +#pragma once + +#include + +namespace cucumber::messages { + +enum class pickle_step_type +{ + UNKNOWN, + CONTEXT, + ACTION, + OUTCOME +}; + +std::string_view +to_string(pickle_step_type v); + +std::ostream& +operator<<(std::ostream& os, pickle_step_type v); + +} diff --git a/cpp/include/cucumber/messages/pickle_table.hpp b/cpp/include/cucumber/messages/pickle_table.hpp new file mode 100644 index 00000000..270e0ccc --- /dev/null +++ b/cpp/include/cucumber/messages/pickle_table.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the PickleTable message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct pickle_table +{ + std::vector rows; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const pickle_table& msg); + +void to_json(json& j, const pickle_table& m); + +} diff --git a/cpp/include/cucumber/messages/pickle_table_cell.hpp b/cpp/include/cucumber/messages/pickle_table_cell.hpp new file mode 100644 index 00000000..0dffa30d --- /dev/null +++ b/cpp/include/cucumber/messages/pickle_table_cell.hpp @@ -0,0 +1,33 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the PickleTableCell message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct pickle_table_cell +{ + std::string value; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const pickle_table_cell& msg); + +void to_json(json& j, const pickle_table_cell& m); + +} diff --git a/cpp/include/cucumber/messages/pickle_table_row.hpp b/cpp/include/cucumber/messages/pickle_table_row.hpp new file mode 100644 index 00000000..a894e774 --- /dev/null +++ b/cpp/include/cucumber/messages/pickle_table_row.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the PickleTableRow message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct pickle_table_row +{ + std::vector cells; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const pickle_table_row& msg); + +void to_json(json& j, const pickle_table_row& m); + +} diff --git a/cpp/include/cucumber/messages/pickle_tag.hpp b/cpp/include/cucumber/messages/pickle_tag.hpp new file mode 100644 index 00000000..9937e1b2 --- /dev/null +++ b/cpp/include/cucumber/messages/pickle_tag.hpp @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the PickleTag message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// A tag +// +// Generated code + +struct pickle_tag +{ + std::string name; + std::string ast_node_id; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const pickle_tag& msg); + +void to_json(json& j, const pickle_tag& m); + +} diff --git a/cpp/include/cucumber/messages/product.hpp b/cpp/include/cucumber/messages/product.hpp new file mode 100644 index 00000000..130fbf0b --- /dev/null +++ b/cpp/include/cucumber/messages/product.hpp @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Product message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Used to describe various properties of Meta +// +// Generated code + +struct product +{ + std::string name; + std::optional version; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const product& msg); + +void to_json(json& j, const product& m); + +} diff --git a/cpp/include/cucumber/messages/rule.hpp b/cpp/include/cucumber/messages/rule.hpp new file mode 100644 index 00000000..401af218 --- /dev/null +++ b/cpp/include/cucumber/messages/rule.hpp @@ -0,0 +1,43 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Rule message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct rule +{ + cucumber::messages::location location; + std::vector tags; + std::string keyword; + std::string name; + std::string description; + std::vector children; + std::string id; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const rule& msg); + +void to_json(json& j, const rule& m); + +} diff --git a/cpp/include/cucumber/messages/rule_child.hpp b/cpp/include/cucumber/messages/rule_child.hpp new file mode 100644 index 00000000..82407a67 --- /dev/null +++ b/cpp/include/cucumber/messages/rule_child.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the RuleChild message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// A child node of a `Rule` node +// +// Generated code + +struct rule_child +{ + std::optional background; + std::optional scenario; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const rule_child& msg); + +void to_json(json& j, const rule_child& m); + +} diff --git a/cpp/include/cucumber/messages/scenario.hpp b/cpp/include/cucumber/messages/scenario.hpp new file mode 100644 index 00000000..18c2d06a --- /dev/null +++ b/cpp/include/cucumber/messages/scenario.hpp @@ -0,0 +1,45 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Scenario message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct scenario +{ + cucumber::messages::location location; + std::vector tags; + std::string keyword; + std::string name; + std::string description; + std::vector steps; + std::vector examples; + std::string id; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const scenario& msg); + +void to_json(json& j, const scenario& m); + +} diff --git a/cpp/include/cucumber/messages/source.hpp b/cpp/include/cucumber/messages/source.hpp new file mode 100644 index 00000000..bb3fc881 --- /dev/null +++ b/cpp/include/cucumber/messages/source.hpp @@ -0,0 +1,41 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Source message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// //// Source +// +// A source file, typically a Gherkin document or Java/Ruby/JavaScript source code +// +// Generated code + +struct source +{ + std::string uri; + std::string data; + cucumber::messages::source_media_type media_type; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const source& msg); + +void to_json(json& j, const source& m); + +} diff --git a/cpp/include/cucumber/messages/source_media_type.hpp b/cpp/include/cucumber/messages/source_media_type.hpp new file mode 100644 index 00000000..9c2f01f2 --- /dev/null +++ b/cpp/include/cucumber/messages/source_media_type.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include + +namespace cucumber::messages { + +enum class source_media_type +{ + TEXT_X_CUCUMBER_GHERKIN_PLAIN, + TEXT_X_CUCUMBER_GHERKIN_MARKDOWN +}; + +std::string_view +to_string(source_media_type v); + +std::ostream& +operator<<(std::ostream& os, source_media_type v); + +} diff --git a/cpp/include/cucumber/messages/source_reference.hpp b/cpp/include/cucumber/messages/source_reference.hpp new file mode 100644 index 00000000..2d1a5300 --- /dev/null +++ b/cpp/include/cucumber/messages/source_reference.hpp @@ -0,0 +1,43 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the SourceReference message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Points to a [Source](#io.cucumber.messages.Source) identified by `uri` and a +// [Location](#io.cucumber.messages.Location) within that file. +// +// Generated code + +struct source_reference +{ + std::optional uri; + std::optional java_method; + std::optional java_stack_trace_element; + std::optional location; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const source_reference& msg); + +void to_json(json& j, const source_reference& m); + +} diff --git a/cpp/include/cucumber/messages/step.hpp b/cpp/include/cucumber/messages/step.hpp new file mode 100644 index 00000000..e07b3b00 --- /dev/null +++ b/cpp/include/cucumber/messages/step.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Step message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// A step +// +// Generated code + +struct step +{ + cucumber::messages::location location; + std::string keyword; + std::optional keyword_type; + std::string text; + std::optional doc_string; + std::optional data_table; + std::string id; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const step& msg); + +void to_json(json& j, const step& m); + +} diff --git a/cpp/include/cucumber/messages/step_definition.hpp b/cpp/include/cucumber/messages/step_definition.hpp new file mode 100644 index 00000000..b13b1663 --- /dev/null +++ b/cpp/include/cucumber/messages/step_definition.hpp @@ -0,0 +1,38 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the StepDefinition message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct step_definition +{ + std::string id; + cucumber::messages::step_definition_pattern pattern; + cucumber::messages::source_reference source_reference; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const step_definition& msg); + +void to_json(json& j, const step_definition& m); + +} diff --git a/cpp/include/cucumber/messages/step_definition_pattern.hpp b/cpp/include/cucumber/messages/step_definition_pattern.hpp new file mode 100644 index 00000000..5a33dd43 --- /dev/null +++ b/cpp/include/cucumber/messages/step_definition_pattern.hpp @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the StepDefinitionPattern message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct step_definition_pattern +{ + std::string source; + cucumber::messages::step_definition_pattern_type type; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const step_definition_pattern& msg); + +void to_json(json& j, const step_definition_pattern& m); + +} diff --git a/cpp/include/cucumber/messages/step_definition_pattern_type.hpp b/cpp/include/cucumber/messages/step_definition_pattern_type.hpp new file mode 100644 index 00000000..38ac5d52 --- /dev/null +++ b/cpp/include/cucumber/messages/step_definition_pattern_type.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include + +namespace cucumber::messages { + +enum class step_definition_pattern_type +{ + CUCUMBER_EXPRESSION, + REGULAR_EXPRESSION +}; + +std::string_view +to_string(step_definition_pattern_type v); + +std::ostream& +operator<<(std::ostream& os, step_definition_pattern_type v); + +} diff --git a/cpp/include/cucumber/messages/step_keyword_type.hpp b/cpp/include/cucumber/messages/step_keyword_type.hpp new file mode 100644 index 00000000..3ad19c66 --- /dev/null +++ b/cpp/include/cucumber/messages/step_keyword_type.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include + +namespace cucumber::messages { + +enum class step_keyword_type +{ + UNKNOWN, + CONTEXT, + ACTION, + OUTCOME, + CONJUNCTION +}; + +std::string_view +to_string(step_keyword_type v); + +std::ostream& +operator<<(std::ostream& os, step_keyword_type v); + +} diff --git a/cpp/include/cucumber/messages/step_match_argument.hpp b/cpp/include/cucumber/messages/step_match_argument.hpp new file mode 100644 index 00000000..c6667395 --- /dev/null +++ b/cpp/include/cucumber/messages/step_match_argument.hpp @@ -0,0 +1,43 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the StepMatchArgument message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Represents a single argument extracted from a step match and passed to a step definition. +// This is used for the following purposes: +// - Construct an argument to pass to a step definition (possibly through a parameter type transform) +// - Highlight the matched parameter in rich formatters such as the HTML formatter +// +// This message closely matches the `Argument` class in the `cucumber-expressions` library. +// +// Generated code + +struct step_match_argument +{ + cucumber::messages::group group; + std::optional parameter_type_name; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const step_match_argument& msg); + +void to_json(json& j, const step_match_argument& m); + +} diff --git a/cpp/include/cucumber/messages/step_match_arguments_list.hpp b/cpp/include/cucumber/messages/step_match_arguments_list.hpp new file mode 100644 index 00000000..d004a88b --- /dev/null +++ b/cpp/include/cucumber/messages/step_match_arguments_list.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the StepMatchArgumentsList message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct step_match_arguments_list +{ + std::vector step_match_arguments; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const step_match_arguments_list& msg); + +void to_json(json& j, const step_match_arguments_list& m); + +} diff --git a/cpp/include/cucumber/messages/table_cell.hpp b/cpp/include/cucumber/messages/table_cell.hpp new file mode 100644 index 00000000..8e0bf6c1 --- /dev/null +++ b/cpp/include/cucumber/messages/table_cell.hpp @@ -0,0 +1,38 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the TableCell message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// A cell in a `TableRow` +// +// Generated code + +struct table_cell +{ + cucumber::messages::location location; + std::string value; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const table_cell& msg); + +void to_json(json& j, const table_cell& m); + +} diff --git a/cpp/include/cucumber/messages/table_row.hpp b/cpp/include/cucumber/messages/table_row.hpp new file mode 100644 index 00000000..33ac0ef3 --- /dev/null +++ b/cpp/include/cucumber/messages/table_row.hpp @@ -0,0 +1,40 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the TableRow message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// A row in a table +// +// Generated code + +struct table_row +{ + cucumber::messages::location location; + std::vector cells; + std::string id; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const table_row& msg); + +void to_json(json& j, const table_row& m); + +} diff --git a/cpp/include/cucumber/messages/tag.hpp b/cpp/include/cucumber/messages/tag.hpp new file mode 100644 index 00000000..4dfc54d0 --- /dev/null +++ b/cpp/include/cucumber/messages/tag.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Tag message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// A tag +// +// Generated code + +struct tag +{ + cucumber::messages::location location; + std::string name; + std::string id; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const tag& msg); + +void to_json(json& j, const tag& m); + +} diff --git a/cpp/include/cucumber/messages/test_case.hpp b/cpp/include/cucumber/messages/test_case.hpp new file mode 100644 index 00000000..56a578ff --- /dev/null +++ b/cpp/include/cucumber/messages/test_case.hpp @@ -0,0 +1,41 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the TestCase message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// //// TestCases +// +// A `TestCase` contains a sequence of `TestStep`s. +// +// Generated code + +struct test_case +{ + std::string id; + std::string pickle_id; + std::vector test_steps; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const test_case& msg); + +void to_json(json& j, const test_case& m); + +} diff --git a/cpp/include/cucumber/messages/test_case_finished.hpp b/cpp/include/cucumber/messages/test_case_finished.hpp new file mode 100644 index 00000000..e92815dd --- /dev/null +++ b/cpp/include/cucumber/messages/test_case_finished.hpp @@ -0,0 +1,37 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the TestCaseFinished message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct test_case_finished +{ + std::string test_case_started_id; + cucumber::messages::timestamp timestamp; + bool will_be_retried; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const test_case_finished& msg); + +void to_json(json& j, const test_case_finished& m); + +} diff --git a/cpp/include/cucumber/messages/test_case_started.hpp b/cpp/include/cucumber/messages/test_case_started.hpp new file mode 100644 index 00000000..1c4a70aa --- /dev/null +++ b/cpp/include/cucumber/messages/test_case_started.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the TestCaseStarted message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct test_case_started +{ + std::size_t attempt; + std::string id; + std::string test_case_id; + std::optional worker_id; + cucumber::messages::timestamp timestamp; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const test_case_started& msg); + +void to_json(json& j, const test_case_started& m); + +} diff --git a/cpp/include/cucumber/messages/test_run_finished.hpp b/cpp/include/cucumber/messages/test_run_finished.hpp new file mode 100644 index 00000000..973e4728 --- /dev/null +++ b/cpp/include/cucumber/messages/test_run_finished.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the TestRunFinished message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct test_run_finished +{ + std::optional message; + bool success; + cucumber::messages::timestamp timestamp; + std::optional exception; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const test_run_finished& msg); + +void to_json(json& j, const test_run_finished& m); + +} diff --git a/cpp/include/cucumber/messages/test_run_started.hpp b/cpp/include/cucumber/messages/test_run_started.hpp new file mode 100644 index 00000000..0ba29f48 --- /dev/null +++ b/cpp/include/cucumber/messages/test_run_started.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the TestRunStarted message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct test_run_started +{ + cucumber::messages::timestamp timestamp; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const test_run_started& msg); + +void to_json(json& j, const test_run_started& m); + +} diff --git a/cpp/include/cucumber/messages/test_step.hpp b/cpp/include/cucumber/messages/test_step.hpp new file mode 100644 index 00000000..58df22ac --- /dev/null +++ b/cpp/include/cucumber/messages/test_step.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the TestStep message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// A `TestStep` is derived from either a `PickleStep` +// combined with a `StepDefinition`, or from a `Hook`. +// +// Generated code + +struct test_step +{ + std::optional hook_id; + std::string id; + std::optional pickle_step_id; + std::optional> step_definition_ids; + std::optional> step_match_arguments_lists; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const test_step& msg); + +void to_json(json& j, const test_step& m); + +} diff --git a/cpp/include/cucumber/messages/test_step_finished.hpp b/cpp/include/cucumber/messages/test_step_finished.hpp new file mode 100644 index 00000000..80e34405 --- /dev/null +++ b/cpp/include/cucumber/messages/test_step_finished.hpp @@ -0,0 +1,39 @@ +#pragma once + +#include +#include + +#include + +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the TestStepFinished message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct test_step_finished +{ + std::string test_case_started_id; + std::string test_step_id; + cucumber::messages::test_step_result test_step_result; + cucumber::messages::timestamp timestamp; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const test_step_finished& msg); + +void to_json(json& j, const test_step_finished& m); + +} diff --git a/cpp/include/cucumber/messages/test_step_result.hpp b/cpp/include/cucumber/messages/test_step_result.hpp new file mode 100644 index 00000000..12d70c45 --- /dev/null +++ b/cpp/include/cucumber/messages/test_step_result.hpp @@ -0,0 +1,40 @@ +#pragma once + +#include +#include + +#include + +#include +#include +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the TestStepResult message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct test_step_result +{ + cucumber::messages::duration duration; + std::optional message; + cucumber::messages::test_step_result_status status; + std::optional exception; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const test_step_result& msg); + +void to_json(json& j, const test_step_result& m); + +} diff --git a/cpp/include/cucumber/messages/test_step_result_status.hpp b/cpp/include/cucumber/messages/test_step_result_status.hpp new file mode 100644 index 00000000..ee92d219 --- /dev/null +++ b/cpp/include/cucumber/messages/test_step_result_status.hpp @@ -0,0 +1,24 @@ +#pragma once + +#include + +namespace cucumber::messages { + +enum class test_step_result_status +{ + UNKNOWN, + PASSED, + SKIPPED, + PENDING, + UNDEFINED, + AMBIGUOUS, + FAILED +}; + +std::string_view +to_string(test_step_result_status v); + +std::ostream& +operator<<(std::ostream& os, test_step_result_status v); + +} diff --git a/cpp/include/cucumber/messages/test_step_started.hpp b/cpp/include/cucumber/messages/test_step_started.hpp new file mode 100644 index 00000000..bb29f967 --- /dev/null +++ b/cpp/include/cucumber/messages/test_step_started.hpp @@ -0,0 +1,37 @@ +#pragma once + +#include +#include + +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the TestStepStarted message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct test_step_started +{ + std::string test_case_started_id; + std::string test_step_id; + cucumber::messages::timestamp timestamp; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const test_step_started& msg); + +void to_json(json& j, const test_step_started& m); + +} diff --git a/cpp/include/cucumber/messages/timestamp.hpp b/cpp/include/cucumber/messages/timestamp.hpp new file mode 100644 index 00000000..33e14f76 --- /dev/null +++ b/cpp/include/cucumber/messages/timestamp.hpp @@ -0,0 +1,34 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the Timestamp message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct timestamp +{ + std::size_t seconds; + std::size_t nanos; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const timestamp& msg); + +void to_json(json& j, const timestamp& m); + +} diff --git a/cpp/include/cucumber/messages/undefined_parameter_type.hpp b/cpp/include/cucumber/messages/undefined_parameter_type.hpp new file mode 100644 index 00000000..4e0501fa --- /dev/null +++ b/cpp/include/cucumber/messages/undefined_parameter_type.hpp @@ -0,0 +1,34 @@ +#pragma once + +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the UndefinedParameterType message in Cucumber's message protocol +// @see Github - Cucumber - Messages +// +// Generated code + +struct undefined_parameter_type +{ + std::string expression; + std::string name; + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const undefined_parameter_type& msg); + +void to_json(json& j, const undefined_parameter_type& m); + +} diff --git a/cpp/scripts/build-ext b/cpp/scripts/build-ext new file mode 100755 index 00000000..b3595953 --- /dev/null +++ b/cpp/scripts/build-ext @@ -0,0 +1,122 @@ +#!/usr/bin/env bash + +set -e + +ME=$(basename $0) +MYDIR=$(cd $(dirname $0)/.. && pwd) + +############################################################################### +# +# Minimal checks +# +############################################################################### +[ -z "$1" ] && echo "$ME: missing directory" && exit 1 +[ ! -d "$1" ] && echo "$ME: invalid directory: $1" && exit 1 + +SRCDIR="$1" +shift + +while ((${#1})); do + case "$1" in + --src-dir=*) + SUBDIR="${1##--src-dir=}" + SRCDIR="$SRCDIR/$SUBDIR" + shift + ;; + *) + break + ;; + esac +done + +############################################################################### +# +# Compiler setup +# +############################################################################### +BUILDROOT=$MYDIR/build/root +CC= +CFLAGS= +CXX= +CXXFLAGS=$CFLAGS +CPATH=$BUILDROOT/include +LIBRARY_PATH=$BUILDROOT/lib +LD_LIBRARY_PATH=$BUILDROOT/lib +PKG_CONFIG_PATH=$LIBRARY_PATH/pkgconfig + +#CCACHE=$(which ccache || true) + +# if [ -n "$CCACHE" ]; then +# CC="$CCACHE $CC" +# CXX="$CCACHE $CXX" +# fi + +export CC CFLAGS CXX CXXFLAGS CPATH LIBRARY_PATH LD_LIBRARY_PATH + +############################################################################### +# +# Parallel compilation setup +# +############################################################################### +MAKEARGS= +CMAKEARGS= + +if [ -n "$NPROCS" ]; then + CMAKEARGS="--parallel $NPROCS" + MAKEARGS="-j$NPROCS" +else + CMAKEARGS="--parallel" +fi + +############################################################################### +# +# Project build +# +############################################################################### +PROJECT=$(basename $SRCDIR) +BUILDDIR=$MYDIR/build/$PROJECT + +mkdir -p $LIBRARY_PATH +rm -rf $BUILDDIR && mkdir -p $BUILDDIR + +if [ -f $SRCDIR/CMakeLists.txt ]; then + cmake \ + -DCMAKE_PREFIX_PATH=$BUILDROOT \ + -DCMAKE_INSTALL_PREFIX=$BUILDROOT \ + -DCMAKE_TOOLCHAIN_FILE=$MYDIR/cmake/toolchains/ext.cmake \ + -S $SRCDIR -B $BUILDDIR \ + "$@" + cmake --build $BUILDDIR $CMAKEARGS + cmake --install $BUILDDIR +elif [ -f $SRCDIR/meson.build ]; then + cd $BUILDDIR + meson \ + --prefix=$BUILDROOT \ + --pkg-config-path=$BUILDROOT \ + --cmake-prefix-path=$BUILDROOT \ + "$@" \ + . $SRCDIR + meson install +elif [ -x $SRCDIR/configure ]; then + cd $BUILDDIR + $SRCDIR/configure \ + --prefix=$BUILDROOT \ + --enable-shared \ + "$@" + make $MAKEARGS + make install +elif [ -x $SRCDIR/config ]; then + cd $BUILDDIR + $SRCDIR/config --prefix=$BUILDROOT "$@" + make $MAKEARGS + make install +elif [ -f $SRCDIR/Makefile ]; then + cd $SRCDIR + make $MAKEARGS + make prefix=$BUILDROOT install +else + echo "$ME: don't know how to build $SRCDIR" + exit 1 +fi + +rm -rf $BUILDDIR diff --git a/cpp/scripts/build-externals b/cpp/scripts/build-externals new file mode 100755 index 00000000..42ef6a78 --- /dev/null +++ b/cpp/scripts/build-externals @@ -0,0 +1,172 @@ +#!/usr/bin/env bash + +############################################################################### +# +# Barebones dependency installer +# +############################################################################### +set -e +trap "exit 1" TERM + +ME=$(basename $0) +MYDIR=$(cd $(dirname $0)/.. && pwd) +MYPID=$$ + +BUILDER=$MYDIR/scripts/build-ext + +EXTDIR=$MYDIR/ext +DLFILE=$EXTDIR/.downloaded +INSTFILE=$EXTDIR/.installed +TMPDIR=$EXTDIR/tmp +ARCDIR=$EXTDIR/archives + +function error() { + echo "$@" >&2 + kill -TERM $MYPID + exit 1 +} + +function clean_tmp() { + rm -rf $TMPDIR && mkdir -p $TMPDIR +} + +function get_unique() { + local WHERE=$1 + local TYPE=$2 + + local COUNT=$(find $WHERE -mindepth 1 -maxdepth 1 -type $TYPE | wc -l) + + [ "$COUNT" -ne "1" ] && error "no unique entry of type $TYPE in $WHERE" + + local ENTRY=$(find $WHERE -mindepth 1 -maxdepth 1 -type $TYPE) + + echo $ENTRY +} + +function get_md5() { + local WHAT=$1 + local MD5 + + case $(uname -s) in + Darwin) + MD5=$(md5 -qs "$WHAT") + ;; + *) + MD5=$(echo -n "$WHAT" | md5sum | cut -d ' ' -f 1) + ;; + esac + + echo $MD5 +} + +function download() { + local PKG=$1 + + local MD5=$(get_md5 "$PKG") + local ARCHIVE=$(grep $MD5 $DLFILE | cut -d ' ' -f 2) + + if [ -z "$ARCHIVE" ]; then + clean_tmp + + (cd $TMPDIR && curl -LJO $PKG) + + mkdir -p $ARCDIR + + ARCHIVE=$(get_unique $TMPDIR f) + + mv $ARCHIVE $ARCDIR + + ARCHIVE=$(basename $ARCHIVE) + echo "$MD5 $ARCHIVE" >> $DLFILE + fi + + echo $ARCHIVE +} + +function extract() { + local ARCHIVE=$1 + + local ARCFILE=$ARCDIR/$ARCHIVE + local TAROPTS + + case $(uname -s) in + Darwin) + TAROPTS=xf + ;; + *) + TAROPTS=xaf + ;; + esac + + clean_tmp + + if [[ "$ARCFILE" =~ \.zip$ ]]; then + (cd $TMPDIR && unzip -q $ARCFILE) + elif [[ "$ARCFILE" =~ \.tar\.(gz|bz2|xz)$ ]]; then + (cd $TMPDIR && tar $TAROPTS $ARCFILE) + else + error "unhandled archive format $ARCHIVE" + fi + + DIR=$(get_unique $TMPDIR d) + + echo $DIR +} + +function build() { + local URL=$1 + shift + + local ARCHIVE=$(download $URL) + local INSTALLED=$(grep $ARCHIVE $INSTFILE) + + if [ -z "$INSTALLED" ]; then + local DEPDIR=$(extract $ARCHIVE) + + echo "building from $URL" + + $BUILDER $DEPDIR "$@" + + echo $ARCHIVE >> $INSTFILE + else + echo "skipping already installed $ARCHIVE from $URL" + fi +} + +function build_list() { + local EXTFILE=$1 + local -a SPEC=() + + while read LINE; do + [[ "$LINE" =~ ^([[:space:]]*(#.*)?)?$ ]] && continue + + build $LINE + done < $EXTFILE +} + +mkdir -p $EXTDIR +touch $DLFILE $INSTFILE + +[ -z "$1" ] && echo "usage: $ME FILE|URL" && exit 1 + +WHAT=$1 +shift + +if [ -f $WHAT ]; then + # Assume a dependency list file + if [ -n "$1" ]; then + # Short keyword to easily select something in the list file + LINE=$(grep "$1" $WHAT) + + if [ -n "$LINE" ]; then + build $LINE + fi + else + build_list $WHAT + fi +else + # Assume a URL + build $WHAT "$@" +fi + +exit 0 diff --git a/cpp/src/CMakeLists.txt b/cpp/src/CMakeLists.txt new file mode 100644 index 00000000..3ea7a419 --- /dev/null +++ b/cpp/src/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(lib) diff --git a/cpp/src/lib/CMakeLists.txt b/cpp/src/lib/CMakeLists.txt new file mode 100644 index 00000000..63df6a2a --- /dev/null +++ b/cpp/src/lib/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(cucumber-messages) diff --git a/cpp/src/lib/cucumber-messages/CMakeLists.txt b/cpp/src/lib/cucumber-messages/CMakeLists.txt new file mode 100644 index 00000000..70193a89 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/CMakeLists.txt @@ -0,0 +1,36 @@ +add_library(cucumber-messages) +add_library(cucumber::messages ALIAS cucumber-messages) + +set(INC_DIR "${CMAKE_SOURCE_DIR}/include") + +# We prefer it that way... +file(GLOB_RECURSE CUCUMBER_MESSAGES_HEADERS ${INC_DIR}/*.[ch]pp) +file(GLOB_RECURSE CUCUMBER_MESSAGES_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.[ch]pp) + +target_sources( + cucumber-messages + PRIVATE + ${CUCUMBER_MESSAGES_HEADERS} + ${CUCUMBER_MESSAGES_SOURCES} +) + +target_include_directories( + cucumber-messages + PUBLIC + $ + $ + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR} +) + +target_link_libraries( + cucumber-messages + PUBLIC + nlohmann_json::nlohmann_json +) + +set_target_properties( + cucumber-messages + PROPERTIES + OUTPUT_NAME cucumber_messages +) diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/attachment.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/attachment.cpp new file mode 100644 index 00000000..d4661e0c --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/attachment.cpp @@ -0,0 +1,62 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +attachment::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "body=", body); + cucumber::messages::to_string(oss, ", content_encoding=", content_encoding); + cucumber::messages::to_string(oss, ", file_name=", file_name); + cucumber::messages::to_string(oss, ", media_type=", media_type); + cucumber::messages::to_string(oss, ", source=", source); + cucumber::messages::to_string(oss, ", test_case_started_id=", test_case_started_id); + cucumber::messages::to_string(oss, ", test_step_id=", test_step_id); + cucumber::messages::to_string(oss, ", url=", url); + + return oss.str(); +} + +void +attachment::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("body"), body); + cucumber::messages::to_json(j, camelize("content_encoding"), content_encoding); + cucumber::messages::to_json(j, camelize("file_name"), file_name); + cucumber::messages::to_json(j, camelize("media_type"), media_type); + cucumber::messages::to_json(j, camelize("source"), source); + cucumber::messages::to_json(j, camelize("test_case_started_id"), test_case_started_id); + cucumber::messages::to_json(j, camelize("test_step_id"), test_step_id); + cucumber::messages::to_json(j, camelize("url"), url); +} + +std::string +attachment::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const attachment& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const attachment& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/attachment_content_encoding.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/attachment_content_encoding.cpp new file mode 100644 index 00000000..22cde9f8 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/attachment_content_encoding.cpp @@ -0,0 +1,28 @@ +#include + +#include + +namespace cucumber::messages { + +std::string_view +to_string(attachment_content_encoding v) +{ + using map_type = std::unordered_map; + + static const map_type m = { + { attachment_content_encoding::IDENTITY, "IDENTITY" }, + { attachment_content_encoding::BASE64, "BASE64" } + }; + + return m.at(v); +} + +std::ostream& +operator<<(std::ostream& os, attachment_content_encoding v) +{ + os << to_string(v); + + return os; +} + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/background.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/background.cpp new file mode 100644 index 00000000..76184a20 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/background.cpp @@ -0,0 +1,58 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +background::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", keyword=", keyword); + cucumber::messages::to_string(oss, ", name=", name); + cucumber::messages::to_string(oss, ", description=", description); + cucumber::messages::to_string(oss, ", steps=", steps); + cucumber::messages::to_string(oss, ", id=", id); + + return oss.str(); +} + +void +background::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("keyword"), keyword); + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("description"), description); + cucumber::messages::to_json(j, camelize("steps"), steps); + cucumber::messages::to_json(j, camelize("id"), id); +} + +std::string +background::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const background& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const background& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/ci.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/ci.cpp new file mode 100644 index 00000000..12ef638a --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/ci.cpp @@ -0,0 +1,54 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +ci::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "name=", name); + cucumber::messages::to_string(oss, ", url=", url); + cucumber::messages::to_string(oss, ", build_number=", build_number); + cucumber::messages::to_string(oss, ", git=", git); + + return oss.str(); +} + +void +ci::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("url"), url); + cucumber::messages::to_json(j, camelize("build_number"), build_number); + cucumber::messages::to_json(j, camelize("git"), git); +} + +std::string +ci::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const ci& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const ci& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/comment.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/comment.cpp new file mode 100644 index 00000000..74ec901e --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/comment.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +comment::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", text=", text); + + return oss.str(); +} + +void +comment::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("text"), text); +} + +std::string +comment::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const comment& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const comment& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/data_table.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/data_table.cpp new file mode 100644 index 00000000..7895d594 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/data_table.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +data_table::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", rows=", rows); + + return oss.str(); +} + +void +data_table::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("rows"), rows); +} + +std::string +data_table::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const data_table& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const data_table& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/doc_string.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/doc_string.cpp new file mode 100644 index 00000000..9f27d714 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/doc_string.cpp @@ -0,0 +1,54 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +doc_string::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", media_type=", media_type); + cucumber::messages::to_string(oss, ", content=", content); + cucumber::messages::to_string(oss, ", delimiter=", delimiter); + + return oss.str(); +} + +void +doc_string::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("media_type"), media_type); + cucumber::messages::to_json(j, camelize("content"), content); + cucumber::messages::to_json(j, camelize("delimiter"), delimiter); +} + +std::string +doc_string::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const doc_string& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const doc_string& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/duration.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/duration.cpp new file mode 100644 index 00000000..1a08f1f0 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/duration.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +duration::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "seconds=", seconds); + cucumber::messages::to_string(oss, ", nanos=", nanos); + + return oss.str(); +} + +void +duration::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("seconds"), seconds); + cucumber::messages::to_json(j, camelize("nanos"), nanos); +} + +std::string +duration::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const duration& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const duration& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/envelope.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/envelope.cpp new file mode 100644 index 00000000..88e63702 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/envelope.cpp @@ -0,0 +1,80 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +envelope::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "attachment=", attachment); + cucumber::messages::to_string(oss, ", gherkin_document=", gherkin_document); + cucumber::messages::to_string(oss, ", hook=", hook); + cucumber::messages::to_string(oss, ", meta=", meta); + cucumber::messages::to_string(oss, ", parameter_type=", parameter_type); + cucumber::messages::to_string(oss, ", parse_error=", parse_error); + cucumber::messages::to_string(oss, ", pickle=", pickle); + cucumber::messages::to_string(oss, ", source=", source); + cucumber::messages::to_string(oss, ", step_definition=", step_definition); + cucumber::messages::to_string(oss, ", test_case=", test_case); + cucumber::messages::to_string(oss, ", test_case_finished=", test_case_finished); + cucumber::messages::to_string(oss, ", test_case_started=", test_case_started); + cucumber::messages::to_string(oss, ", test_run_finished=", test_run_finished); + cucumber::messages::to_string(oss, ", test_run_started=", test_run_started); + cucumber::messages::to_string(oss, ", test_step_finished=", test_step_finished); + cucumber::messages::to_string(oss, ", test_step_started=", test_step_started); + cucumber::messages::to_string(oss, ", undefined_parameter_type=", undefined_parameter_type); + + return oss.str(); +} + +void +envelope::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("attachment"), attachment); + cucumber::messages::to_json(j, camelize("gherkin_document"), gherkin_document); + cucumber::messages::to_json(j, camelize("hook"), hook); + cucumber::messages::to_json(j, camelize("meta"), meta); + cucumber::messages::to_json(j, camelize("parameter_type"), parameter_type); + cucumber::messages::to_json(j, camelize("parse_error"), parse_error); + cucumber::messages::to_json(j, camelize("pickle"), pickle); + cucumber::messages::to_json(j, camelize("source"), source); + cucumber::messages::to_json(j, camelize("step_definition"), step_definition); + cucumber::messages::to_json(j, camelize("test_case"), test_case); + cucumber::messages::to_json(j, camelize("test_case_finished"), test_case_finished); + cucumber::messages::to_json(j, camelize("test_case_started"), test_case_started); + cucumber::messages::to_json(j, camelize("test_run_finished"), test_run_finished); + cucumber::messages::to_json(j, camelize("test_run_started"), test_run_started); + cucumber::messages::to_json(j, camelize("test_step_finished"), test_step_finished); + cucumber::messages::to_json(j, camelize("test_step_started"), test_step_started); + cucumber::messages::to_json(j, camelize("undefined_parameter_type"), undefined_parameter_type); +} + +std::string +envelope::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const envelope& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const envelope& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/examples.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/examples.cpp new file mode 100644 index 00000000..f2fbca9d --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/examples.cpp @@ -0,0 +1,62 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +examples::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", tags=", tags); + cucumber::messages::to_string(oss, ", keyword=", keyword); + cucumber::messages::to_string(oss, ", name=", name); + cucumber::messages::to_string(oss, ", description=", description); + cucumber::messages::to_string(oss, ", table_header=", table_header); + cucumber::messages::to_string(oss, ", table_body=", table_body); + cucumber::messages::to_string(oss, ", id=", id); + + return oss.str(); +} + +void +examples::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("tags"), tags); + cucumber::messages::to_json(j, camelize("keyword"), keyword); + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("description"), description); + cucumber::messages::to_json(j, camelize("table_header"), table_header); + cucumber::messages::to_json(j, camelize("table_body"), table_body); + cucumber::messages::to_json(j, camelize("id"), id); +} + +std::string +examples::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const examples& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const examples& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/exception.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/exception.cpp new file mode 100644 index 00000000..c7a6a29c --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/exception.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +exception::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "type=", type); + cucumber::messages::to_string(oss, ", message=", message); + + return oss.str(); +} + +void +exception::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("type"), type); + cucumber::messages::to_json(j, camelize("message"), message); +} + +std::string +exception::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const exception& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const exception& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/feature.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/feature.cpp new file mode 100644 index 00000000..b2e5a586 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/feature.cpp @@ -0,0 +1,60 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +feature::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", tags=", tags); + cucumber::messages::to_string(oss, ", language=", language); + cucumber::messages::to_string(oss, ", keyword=", keyword); + cucumber::messages::to_string(oss, ", name=", name); + cucumber::messages::to_string(oss, ", description=", description); + cucumber::messages::to_string(oss, ", children=", children); + + return oss.str(); +} + +void +feature::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("tags"), tags); + cucumber::messages::to_json(j, camelize("language"), language); + cucumber::messages::to_json(j, camelize("keyword"), keyword); + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("description"), description); + cucumber::messages::to_json(j, camelize("children"), children); +} + +std::string +feature::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const feature& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const feature& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/feature_child.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/feature_child.cpp new file mode 100644 index 00000000..86f534b6 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/feature_child.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +feature_child::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "rule=", rule); + cucumber::messages::to_string(oss, ", background=", background); + cucumber::messages::to_string(oss, ", scenario=", scenario); + + return oss.str(); +} + +void +feature_child::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("rule"), rule); + cucumber::messages::to_json(j, camelize("background"), background); + cucumber::messages::to_json(j, camelize("scenario"), scenario); +} + +std::string +feature_child::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const feature_child& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const feature_child& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/gherkin_document.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/gherkin_document.cpp new file mode 100644 index 00000000..b5c0fa82 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/gherkin_document.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +gherkin_document::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "uri=", uri); + cucumber::messages::to_string(oss, ", feature=", feature); + cucumber::messages::to_string(oss, ", comments=", comments); + + return oss.str(); +} + +void +gherkin_document::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("uri"), uri); + cucumber::messages::to_json(j, camelize("feature"), feature); + cucumber::messages::to_json(j, camelize("comments"), comments); +} + +std::string +gherkin_document::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const gherkin_document& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const gherkin_document& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/git.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/git.cpp new file mode 100644 index 00000000..0411b163 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/git.cpp @@ -0,0 +1,54 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +git::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "remote=", remote); + cucumber::messages::to_string(oss, ", revision=", revision); + cucumber::messages::to_string(oss, ", branch=", branch); + cucumber::messages::to_string(oss, ", tag=", tag); + + return oss.str(); +} + +void +git::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("remote"), remote); + cucumber::messages::to_json(j, camelize("revision"), revision); + cucumber::messages::to_json(j, camelize("branch"), branch); + cucumber::messages::to_json(j, camelize("tag"), tag); +} + +std::string +git::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const git& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const git& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/group.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/group.cpp new file mode 100644 index 00000000..54cf4a2a --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/group.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +group::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "children=", children); + cucumber::messages::to_string(oss, ", start=", start); + cucumber::messages::to_string(oss, ", value=", value); + + return oss.str(); +} + +void +group::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("children"), children); + cucumber::messages::to_json(j, camelize("start"), start); + cucumber::messages::to_json(j, camelize("value"), value); +} + +std::string +group::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const group& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const group& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/hook.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/hook.cpp new file mode 100644 index 00000000..7566258a --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/hook.cpp @@ -0,0 +1,54 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +hook::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "id=", id); + cucumber::messages::to_string(oss, ", name=", name); + cucumber::messages::to_string(oss, ", source_reference=", source_reference); + cucumber::messages::to_string(oss, ", tag_expression=", tag_expression); + + return oss.str(); +} + +void +hook::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("id"), id); + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("source_reference"), source_reference); + cucumber::messages::to_json(j, camelize("tag_expression"), tag_expression); +} + +std::string +hook::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const hook& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const hook& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/java_method.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/java_method.cpp new file mode 100644 index 00000000..bcb6515e --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/java_method.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +java_method::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "class_name=", class_name); + cucumber::messages::to_string(oss, ", method_name=", method_name); + cucumber::messages::to_string(oss, ", method_parameter_types=", method_parameter_types); + + return oss.str(); +} + +void +java_method::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("class_name"), class_name); + cucumber::messages::to_json(j, camelize("method_name"), method_name); + cucumber::messages::to_json(j, camelize("method_parameter_types"), method_parameter_types); +} + +std::string +java_method::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const java_method& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const java_method& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/java_stack_trace_element.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/java_stack_trace_element.cpp new file mode 100644 index 00000000..011d1a9b --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/java_stack_trace_element.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +java_stack_trace_element::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "class_name=", class_name); + cucumber::messages::to_string(oss, ", file_name=", file_name); + cucumber::messages::to_string(oss, ", method_name=", method_name); + + return oss.str(); +} + +void +java_stack_trace_element::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("class_name"), class_name); + cucumber::messages::to_json(j, camelize("file_name"), file_name); + cucumber::messages::to_json(j, camelize("method_name"), method_name); +} + +std::string +java_stack_trace_element::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const java_stack_trace_element& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const java_stack_trace_element& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/location.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/location.cpp new file mode 100644 index 00000000..e2f5699e --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/location.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +location::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "line=", line); + cucumber::messages::to_string(oss, ", column=", column); + + return oss.str(); +} + +void +location::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("line"), line); + cucumber::messages::to_json(j, camelize("column"), column); +} + +std::string +location::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const location& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const location& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/meta.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/meta.cpp new file mode 100644 index 00000000..0297fec5 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/meta.cpp @@ -0,0 +1,58 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +meta::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "protocol_version=", protocol_version); + cucumber::messages::to_string(oss, ", implementation=", implementation); + cucumber::messages::to_string(oss, ", runtime=", runtime); + cucumber::messages::to_string(oss, ", os=", os); + cucumber::messages::to_string(oss, ", cpu=", cpu); + cucumber::messages::to_string(oss, ", ci=", ci); + + return oss.str(); +} + +void +meta::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("protocol_version"), protocol_version); + cucumber::messages::to_json(j, camelize("implementation"), implementation); + cucumber::messages::to_json(j, camelize("runtime"), runtime); + cucumber::messages::to_json(j, camelize("os"), os); + cucumber::messages::to_json(j, camelize("cpu"), cpu); + cucumber::messages::to_json(j, camelize("ci"), ci); +} + +std::string +meta::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const meta& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const meta& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/parameter_type.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/parameter_type.cpp new file mode 100644 index 00000000..52a6f1c0 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/parameter_type.cpp @@ -0,0 +1,58 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +parameter_type::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "name=", name); + cucumber::messages::to_string(oss, ", regular_expressions=", regular_expressions); + cucumber::messages::to_string(oss, ", prefer_for_regular_expression_match=", prefer_for_regular_expression_match); + cucumber::messages::to_string(oss, ", use_for_snippets=", use_for_snippets); + cucumber::messages::to_string(oss, ", id=", id); + cucumber::messages::to_string(oss, ", source_reference=", source_reference); + + return oss.str(); +} + +void +parameter_type::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("regular_expressions"), regular_expressions); + cucumber::messages::to_json(j, camelize("prefer_for_regular_expression_match"), prefer_for_regular_expression_match); + cucumber::messages::to_json(j, camelize("use_for_snippets"), use_for_snippets); + cucumber::messages::to_json(j, camelize("id"), id); + cucumber::messages::to_json(j, camelize("source_reference"), source_reference); +} + +std::string +parameter_type::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const parameter_type& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const parameter_type& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/parse_error.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/parse_error.cpp new file mode 100644 index 00000000..bef2eece --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/parse_error.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +parse_error::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "source=", source); + cucumber::messages::to_string(oss, ", message=", message); + + return oss.str(); +} + +void +parse_error::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("source"), source); + cucumber::messages::to_json(j, camelize("message"), message); +} + +std::string +parse_error::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const parse_error& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const parse_error& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/pickle.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle.cpp new file mode 100644 index 00000000..e8fd1896 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle.cpp @@ -0,0 +1,60 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +pickle::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "id=", id); + cucumber::messages::to_string(oss, ", uri=", uri); + cucumber::messages::to_string(oss, ", name=", name); + cucumber::messages::to_string(oss, ", language=", language); + cucumber::messages::to_string(oss, ", steps=", steps); + cucumber::messages::to_string(oss, ", tags=", tags); + cucumber::messages::to_string(oss, ", ast_node_ids=", ast_node_ids); + + return oss.str(); +} + +void +pickle::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("id"), id); + cucumber::messages::to_json(j, camelize("uri"), uri); + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("language"), language); + cucumber::messages::to_json(j, camelize("steps"), steps); + cucumber::messages::to_json(j, camelize("tags"), tags); + cucumber::messages::to_json(j, camelize("ast_node_ids"), ast_node_ids); +} + +std::string +pickle::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const pickle& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const pickle& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_doc_string.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_doc_string.cpp new file mode 100644 index 00000000..388d8b1c --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_doc_string.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +pickle_doc_string::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "media_type=", media_type); + cucumber::messages::to_string(oss, ", content=", content); + + return oss.str(); +} + +void +pickle_doc_string::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("media_type"), media_type); + cucumber::messages::to_json(j, camelize("content"), content); +} + +std::string +pickle_doc_string::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const pickle_doc_string& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const pickle_doc_string& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step.cpp new file mode 100644 index 00000000..5437dd07 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step.cpp @@ -0,0 +1,56 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +pickle_step::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "argument=", argument); + cucumber::messages::to_string(oss, ", ast_node_ids=", ast_node_ids); + cucumber::messages::to_string(oss, ", id=", id); + cucumber::messages::to_string(oss, ", type=", type); + cucumber::messages::to_string(oss, ", text=", text); + + return oss.str(); +} + +void +pickle_step::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("argument"), argument); + cucumber::messages::to_json(j, camelize("ast_node_ids"), ast_node_ids); + cucumber::messages::to_json(j, camelize("id"), id); + cucumber::messages::to_json(j, camelize("type"), type); + cucumber::messages::to_json(j, camelize("text"), text); +} + +std::string +pickle_step::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const pickle_step& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const pickle_step& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step_argument.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step_argument.cpp new file mode 100644 index 00000000..a28d56a0 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step_argument.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +pickle_step_argument::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "doc_string=", doc_string); + cucumber::messages::to_string(oss, ", data_table=", data_table); + + return oss.str(); +} + +void +pickle_step_argument::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("doc_string"), doc_string); + cucumber::messages::to_json(j, camelize("data_table"), data_table); +} + +std::string +pickle_step_argument::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const pickle_step_argument& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const pickle_step_argument& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step_type.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step_type.cpp new file mode 100644 index 00000000..897da3c4 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_step_type.cpp @@ -0,0 +1,30 @@ +#include + +#include + +namespace cucumber::messages { + +std::string_view +to_string(pickle_step_type v) +{ + using map_type = std::unordered_map; + + static const map_type m = { + { pickle_step_type::UNKNOWN, "Unknown" }, + { pickle_step_type::CONTEXT, "Context" }, + { pickle_step_type::ACTION, "Action" }, + { pickle_step_type::OUTCOME, "Outcome" } + }; + + return m.at(v); +} + +std::ostream& +operator<<(std::ostream& os, pickle_step_type v) +{ + os << to_string(v); + + return os; +} + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table.cpp new file mode 100644 index 00000000..d9fcd2cc --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table.cpp @@ -0,0 +1,48 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +pickle_table::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "rows=", rows); + + return oss.str(); +} + +void +pickle_table::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("rows"), rows); +} + +std::string +pickle_table::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const pickle_table& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const pickle_table& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table_cell.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table_cell.cpp new file mode 100644 index 00000000..b4ac5bdf --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table_cell.cpp @@ -0,0 +1,48 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +pickle_table_cell::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "value=", value); + + return oss.str(); +} + +void +pickle_table_cell::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("value"), value); +} + +std::string +pickle_table_cell::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const pickle_table_cell& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const pickle_table_cell& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table_row.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table_row.cpp new file mode 100644 index 00000000..13a09cca --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_table_row.cpp @@ -0,0 +1,48 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +pickle_table_row::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "cells=", cells); + + return oss.str(); +} + +void +pickle_table_row::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("cells"), cells); +} + +std::string +pickle_table_row::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const pickle_table_row& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const pickle_table_row& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_tag.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_tag.cpp new file mode 100644 index 00000000..0e194894 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/pickle_tag.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +pickle_tag::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "name=", name); + cucumber::messages::to_string(oss, ", ast_node_id=", ast_node_id); + + return oss.str(); +} + +void +pickle_tag::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("ast_node_id"), ast_node_id); +} + +std::string +pickle_tag::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const pickle_tag& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const pickle_tag& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/product.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/product.cpp new file mode 100644 index 00000000..92960bb4 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/product.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +product::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "name=", name); + cucumber::messages::to_string(oss, ", version=", version); + + return oss.str(); +} + +void +product::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("version"), version); +} + +std::string +product::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const product& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const product& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/rule.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/rule.cpp new file mode 100644 index 00000000..03d5a9ba --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/rule.cpp @@ -0,0 +1,60 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +rule::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", tags=", tags); + cucumber::messages::to_string(oss, ", keyword=", keyword); + cucumber::messages::to_string(oss, ", name=", name); + cucumber::messages::to_string(oss, ", description=", description); + cucumber::messages::to_string(oss, ", children=", children); + cucumber::messages::to_string(oss, ", id=", id); + + return oss.str(); +} + +void +rule::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("tags"), tags); + cucumber::messages::to_json(j, camelize("keyword"), keyword); + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("description"), description); + cucumber::messages::to_json(j, camelize("children"), children); + cucumber::messages::to_json(j, camelize("id"), id); +} + +std::string +rule::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const rule& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const rule& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/rule_child.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/rule_child.cpp new file mode 100644 index 00000000..ea1e83a8 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/rule_child.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +rule_child::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "background=", background); + cucumber::messages::to_string(oss, ", scenario=", scenario); + + return oss.str(); +} + +void +rule_child::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("background"), background); + cucumber::messages::to_json(j, camelize("scenario"), scenario); +} + +std::string +rule_child::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const rule_child& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const rule_child& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/scenario.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/scenario.cpp new file mode 100644 index 00000000..991abdcf --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/scenario.cpp @@ -0,0 +1,62 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +scenario::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", tags=", tags); + cucumber::messages::to_string(oss, ", keyword=", keyword); + cucumber::messages::to_string(oss, ", name=", name); + cucumber::messages::to_string(oss, ", description=", description); + cucumber::messages::to_string(oss, ", steps=", steps); + cucumber::messages::to_string(oss, ", examples=", examples); + cucumber::messages::to_string(oss, ", id=", id); + + return oss.str(); +} + +void +scenario::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("tags"), tags); + cucumber::messages::to_json(j, camelize("keyword"), keyword); + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("description"), description); + cucumber::messages::to_json(j, camelize("steps"), steps); + cucumber::messages::to_json(j, camelize("examples"), examples); + cucumber::messages::to_json(j, camelize("id"), id); +} + +std::string +scenario::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const scenario& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const scenario& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/source.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/source.cpp new file mode 100644 index 00000000..f647beb7 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/source.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +source::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "uri=", uri); + cucumber::messages::to_string(oss, ", data=", data); + cucumber::messages::to_string(oss, ", media_type=", media_type); + + return oss.str(); +} + +void +source::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("uri"), uri); + cucumber::messages::to_json(j, camelize("data"), data); + cucumber::messages::to_json(j, camelize("media_type"), media_type); +} + +std::string +source::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const source& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const source& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/source_media_type.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/source_media_type.cpp new file mode 100644 index 00000000..550ba295 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/source_media_type.cpp @@ -0,0 +1,28 @@ +#include + +#include + +namespace cucumber::messages { + +std::string_view +to_string(source_media_type v) +{ + using map_type = std::unordered_map; + + static const map_type m = { + { source_media_type::TEXT_X_CUCUMBER_GHERKIN_PLAIN, "text/x.cucumber.gherkin+plain" }, + { source_media_type::TEXT_X_CUCUMBER_GHERKIN_MARKDOWN, "text/x.cucumber.gherkin+markdown" } + }; + + return m.at(v); +} + +std::ostream& +operator<<(std::ostream& os, source_media_type v) +{ + os << to_string(v); + + return os; +} + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/source_reference.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/source_reference.cpp new file mode 100644 index 00000000..660a6dd1 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/source_reference.cpp @@ -0,0 +1,54 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +source_reference::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "uri=", uri); + cucumber::messages::to_string(oss, ", java_method=", java_method); + cucumber::messages::to_string(oss, ", java_stack_trace_element=", java_stack_trace_element); + cucumber::messages::to_string(oss, ", location=", location); + + return oss.str(); +} + +void +source_reference::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("uri"), uri); + cucumber::messages::to_json(j, camelize("java_method"), java_method); + cucumber::messages::to_json(j, camelize("java_stack_trace_element"), java_stack_trace_element); + cucumber::messages::to_json(j, camelize("location"), location); +} + +std::string +source_reference::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const source_reference& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const source_reference& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/step.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/step.cpp new file mode 100644 index 00000000..732f7029 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/step.cpp @@ -0,0 +1,60 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +step::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", keyword=", keyword); + cucumber::messages::to_string(oss, ", keyword_type=", keyword_type); + cucumber::messages::to_string(oss, ", text=", text); + cucumber::messages::to_string(oss, ", doc_string=", doc_string); + cucumber::messages::to_string(oss, ", data_table=", data_table); + cucumber::messages::to_string(oss, ", id=", id); + + return oss.str(); +} + +void +step::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("keyword"), keyword); + cucumber::messages::to_json(j, camelize("keyword_type"), keyword_type); + cucumber::messages::to_json(j, camelize("text"), text); + cucumber::messages::to_json(j, camelize("doc_string"), doc_string); + cucumber::messages::to_json(j, camelize("data_table"), data_table); + cucumber::messages::to_json(j, camelize("id"), id); +} + +std::string +step::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const step& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const step& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/step_definition.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/step_definition.cpp new file mode 100644 index 00000000..5e62dcfa --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/step_definition.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +step_definition::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "id=", id); + cucumber::messages::to_string(oss, ", pattern=", pattern); + cucumber::messages::to_string(oss, ", source_reference=", source_reference); + + return oss.str(); +} + +void +step_definition::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("id"), id); + cucumber::messages::to_json(j, camelize("pattern"), pattern); + cucumber::messages::to_json(j, camelize("source_reference"), source_reference); +} + +std::string +step_definition::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const step_definition& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const step_definition& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/step_definition_pattern.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/step_definition_pattern.cpp new file mode 100644 index 00000000..e76a4740 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/step_definition_pattern.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +step_definition_pattern::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "source=", source); + cucumber::messages::to_string(oss, ", type=", type); + + return oss.str(); +} + +void +step_definition_pattern::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("source"), source); + cucumber::messages::to_json(j, camelize("type"), type); +} + +std::string +step_definition_pattern::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const step_definition_pattern& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const step_definition_pattern& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/step_definition_pattern_type.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/step_definition_pattern_type.cpp new file mode 100644 index 00000000..101afeb7 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/step_definition_pattern_type.cpp @@ -0,0 +1,28 @@ +#include + +#include + +namespace cucumber::messages { + +std::string_view +to_string(step_definition_pattern_type v) +{ + using map_type = std::unordered_map; + + static const map_type m = { + { step_definition_pattern_type::CUCUMBER_EXPRESSION, "CUCUMBER_EXPRESSION" }, + { step_definition_pattern_type::REGULAR_EXPRESSION, "REGULAR_EXPRESSION" } + }; + + return m.at(v); +} + +std::ostream& +operator<<(std::ostream& os, step_definition_pattern_type v) +{ + os << to_string(v); + + return os; +} + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/step_keyword_type.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/step_keyword_type.cpp new file mode 100644 index 00000000..ff13059c --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/step_keyword_type.cpp @@ -0,0 +1,31 @@ +#include + +#include + +namespace cucumber::messages { + +std::string_view +to_string(step_keyword_type v) +{ + using map_type = std::unordered_map; + + static const map_type m = { + { step_keyword_type::UNKNOWN, "Unknown" }, + { step_keyword_type::CONTEXT, "Context" }, + { step_keyword_type::ACTION, "Action" }, + { step_keyword_type::OUTCOME, "Outcome" }, + { step_keyword_type::CONJUNCTION, "Conjunction" } + }; + + return m.at(v); +} + +std::ostream& +operator<<(std::ostream& os, step_keyword_type v) +{ + os << to_string(v); + + return os; +} + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/step_match_argument.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/step_match_argument.cpp new file mode 100644 index 00000000..9fd58691 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/step_match_argument.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +step_match_argument::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "group=", group); + cucumber::messages::to_string(oss, ", parameter_type_name=", parameter_type_name); + + return oss.str(); +} + +void +step_match_argument::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("group"), group); + cucumber::messages::to_json(j, camelize("parameter_type_name"), parameter_type_name); +} + +std::string +step_match_argument::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const step_match_argument& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const step_match_argument& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/step_match_arguments_list.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/step_match_arguments_list.cpp new file mode 100644 index 00000000..5a7ede42 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/step_match_arguments_list.cpp @@ -0,0 +1,48 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +step_match_arguments_list::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "step_match_arguments=", step_match_arguments); + + return oss.str(); +} + +void +step_match_arguments_list::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("step_match_arguments"), step_match_arguments); +} + +std::string +step_match_arguments_list::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const step_match_arguments_list& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const step_match_arguments_list& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/table_cell.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/table_cell.cpp new file mode 100644 index 00000000..5ec1aaa6 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/table_cell.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +table_cell::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", value=", value); + + return oss.str(); +} + +void +table_cell::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("value"), value); +} + +std::string +table_cell::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const table_cell& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const table_cell& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/table_row.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/table_row.cpp new file mode 100644 index 00000000..c1f9d94d --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/table_row.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +table_row::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", cells=", cells); + cucumber::messages::to_string(oss, ", id=", id); + + return oss.str(); +} + +void +table_row::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("cells"), cells); + cucumber::messages::to_json(j, camelize("id"), id); +} + +std::string +table_row::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const table_row& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const table_row& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/tag.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/tag.cpp new file mode 100644 index 00000000..becb0562 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/tag.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +tag::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "location=", location); + cucumber::messages::to_string(oss, ", name=", name); + cucumber::messages::to_string(oss, ", id=", id); + + return oss.str(); +} + +void +tag::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("location"), location); + cucumber::messages::to_json(j, camelize("name"), name); + cucumber::messages::to_json(j, camelize("id"), id); +} + +std::string +tag::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const tag& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const tag& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/test_case.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/test_case.cpp new file mode 100644 index 00000000..6a9070f3 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/test_case.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +test_case::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "id=", id); + cucumber::messages::to_string(oss, ", pickle_id=", pickle_id); + cucumber::messages::to_string(oss, ", test_steps=", test_steps); + + return oss.str(); +} + +void +test_case::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("id"), id); + cucumber::messages::to_json(j, camelize("pickle_id"), pickle_id); + cucumber::messages::to_json(j, camelize("test_steps"), test_steps); +} + +std::string +test_case::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const test_case& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const test_case& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/test_case_finished.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/test_case_finished.cpp new file mode 100644 index 00000000..3f313a4d --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/test_case_finished.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +test_case_finished::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "test_case_started_id=", test_case_started_id); + cucumber::messages::to_string(oss, ", timestamp=", timestamp); + cucumber::messages::to_string(oss, ", will_be_retried=", will_be_retried); + + return oss.str(); +} + +void +test_case_finished::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("test_case_started_id"), test_case_started_id); + cucumber::messages::to_json(j, camelize("timestamp"), timestamp); + cucumber::messages::to_json(j, camelize("will_be_retried"), will_be_retried); +} + +std::string +test_case_finished::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const test_case_finished& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const test_case_finished& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/test_case_started.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/test_case_started.cpp new file mode 100644 index 00000000..69d497b8 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/test_case_started.cpp @@ -0,0 +1,56 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +test_case_started::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "attempt=", attempt); + cucumber::messages::to_string(oss, ", id=", id); + cucumber::messages::to_string(oss, ", test_case_id=", test_case_id); + cucumber::messages::to_string(oss, ", worker_id=", worker_id); + cucumber::messages::to_string(oss, ", timestamp=", timestamp); + + return oss.str(); +} + +void +test_case_started::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("attempt"), attempt); + cucumber::messages::to_json(j, camelize("id"), id); + cucumber::messages::to_json(j, camelize("test_case_id"), test_case_id); + cucumber::messages::to_json(j, camelize("worker_id"), worker_id); + cucumber::messages::to_json(j, camelize("timestamp"), timestamp); +} + +std::string +test_case_started::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const test_case_started& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const test_case_started& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/test_run_finished.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/test_run_finished.cpp new file mode 100644 index 00000000..f2c179e8 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/test_run_finished.cpp @@ -0,0 +1,54 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +test_run_finished::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "message=", message); + cucumber::messages::to_string(oss, ", success=", success); + cucumber::messages::to_string(oss, ", timestamp=", timestamp); + cucumber::messages::to_string(oss, ", exception=", exception); + + return oss.str(); +} + +void +test_run_finished::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("message"), message); + cucumber::messages::to_json(j, camelize("success"), success); + cucumber::messages::to_json(j, camelize("timestamp"), timestamp); + cucumber::messages::to_json(j, camelize("exception"), exception); +} + +std::string +test_run_finished::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const test_run_finished& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const test_run_finished& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/test_run_started.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/test_run_started.cpp new file mode 100644 index 00000000..0ce5fdd9 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/test_run_started.cpp @@ -0,0 +1,48 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +test_run_started::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "timestamp=", timestamp); + + return oss.str(); +} + +void +test_run_started::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("timestamp"), timestamp); +} + +std::string +test_run_started::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const test_run_started& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const test_run_started& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/test_step.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/test_step.cpp new file mode 100644 index 00000000..0c5f0afb --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/test_step.cpp @@ -0,0 +1,56 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +test_step::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "hook_id=", hook_id); + cucumber::messages::to_string(oss, ", id=", id); + cucumber::messages::to_string(oss, ", pickle_step_id=", pickle_step_id); + cucumber::messages::to_string(oss, ", step_definition_ids=", step_definition_ids); + cucumber::messages::to_string(oss, ", step_match_arguments_lists=", step_match_arguments_lists); + + return oss.str(); +} + +void +test_step::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("hook_id"), hook_id); + cucumber::messages::to_json(j, camelize("id"), id); + cucumber::messages::to_json(j, camelize("pickle_step_id"), pickle_step_id); + cucumber::messages::to_json(j, camelize("step_definition_ids"), step_definition_ids); + cucumber::messages::to_json(j, camelize("step_match_arguments_lists"), step_match_arguments_lists); +} + +std::string +test_step::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const test_step& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const test_step& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_finished.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_finished.cpp new file mode 100644 index 00000000..5629a93c --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_finished.cpp @@ -0,0 +1,54 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +test_step_finished::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "test_case_started_id=", test_case_started_id); + cucumber::messages::to_string(oss, ", test_step_id=", test_step_id); + cucumber::messages::to_string(oss, ", test_step_result=", test_step_result); + cucumber::messages::to_string(oss, ", timestamp=", timestamp); + + return oss.str(); +} + +void +test_step_finished::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("test_case_started_id"), test_case_started_id); + cucumber::messages::to_json(j, camelize("test_step_id"), test_step_id); + cucumber::messages::to_json(j, camelize("test_step_result"), test_step_result); + cucumber::messages::to_json(j, camelize("timestamp"), timestamp); +} + +std::string +test_step_finished::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const test_step_finished& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const test_step_finished& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_result.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_result.cpp new file mode 100644 index 00000000..f99d601c --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_result.cpp @@ -0,0 +1,54 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +test_step_result::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "duration=", duration); + cucumber::messages::to_string(oss, ", message=", message); + cucumber::messages::to_string(oss, ", status=", status); + cucumber::messages::to_string(oss, ", exception=", exception); + + return oss.str(); +} + +void +test_step_result::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("duration"), duration); + cucumber::messages::to_json(j, camelize("message"), message); + cucumber::messages::to_json(j, camelize("status"), status); + cucumber::messages::to_json(j, camelize("exception"), exception); +} + +std::string +test_step_result::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const test_step_result& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const test_step_result& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_result_status.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_result_status.cpp new file mode 100644 index 00000000..f7ae9ccc --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_result_status.cpp @@ -0,0 +1,33 @@ +#include + +#include + +namespace cucumber::messages { + +std::string_view +to_string(test_step_result_status v) +{ + using map_type = std::unordered_map; + + static const map_type m = { + { test_step_result_status::UNKNOWN, "UNKNOWN" }, + { test_step_result_status::PASSED, "PASSED" }, + { test_step_result_status::SKIPPED, "SKIPPED" }, + { test_step_result_status::PENDING, "PENDING" }, + { test_step_result_status::UNDEFINED, "UNDEFINED" }, + { test_step_result_status::AMBIGUOUS, "AMBIGUOUS" }, + { test_step_result_status::FAILED, "FAILED" } + }; + + return m.at(v); +} + +std::ostream& +operator<<(std::ostream& os, test_step_result_status v) +{ + os << to_string(v); + + return os; +} + +} \ No newline at end of file diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_started.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_started.cpp new file mode 100644 index 00000000..56a1ced0 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/test_step_started.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +test_step_started::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "test_case_started_id=", test_case_started_id); + cucumber::messages::to_string(oss, ", test_step_id=", test_step_id); + cucumber::messages::to_string(oss, ", timestamp=", timestamp); + + return oss.str(); +} + +void +test_step_started::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("test_case_started_id"), test_case_started_id); + cucumber::messages::to_json(j, camelize("test_step_id"), test_step_id); + cucumber::messages::to_json(j, camelize("timestamp"), timestamp); +} + +std::string +test_step_started::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const test_step_started& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const test_step_started& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/timestamp.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/timestamp.cpp new file mode 100644 index 00000000..d9d86a05 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/timestamp.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +timestamp::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "seconds=", seconds); + cucumber::messages::to_string(oss, ", nanos=", nanos); + + return oss.str(); +} + +void +timestamp::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("seconds"), seconds); + cucumber::messages::to_json(j, camelize("nanos"), nanos); +} + +std::string +timestamp::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const timestamp& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const timestamp& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/undefined_parameter_type.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/undefined_parameter_type.cpp new file mode 100644 index 00000000..5ef07f83 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/undefined_parameter_type.cpp @@ -0,0 +1,50 @@ +#include + +#include +#include + +namespace cucumber::messages { + +std::string +undefined_parameter_type::to_string() const +{ + std::ostringstream oss; + + cucumber::messages::to_string(oss, "expression=", expression); + cucumber::messages::to_string(oss, ", name=", name); + + return oss.str(); +} + +void +undefined_parameter_type::to_json(json& j) const +{ + cucumber::messages::to_json(j, camelize("expression"), expression); + cucumber::messages::to_json(j, camelize("name"), name); +} + +std::string +undefined_parameter_type::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const undefined_parameter_type& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const undefined_parameter_type& m) +{ m.to_json(j); } + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/utils.cpp b/cpp/src/lib/cucumber-messages/cucumber/messages/utils.cpp new file mode 100644 index 00000000..63efca21 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/utils.cpp @@ -0,0 +1,28 @@ +#include + +namespace cucumber::messages { + +// https://codereview.stackexchange.com/questions/263749/codewars-kata-converting-snake-case-identifiers-to-camelcase-in-c +std::string +camelize(std::string s, bool initial_tail) +{ + std::size_t n = 0; + bool tail = initial_tail; + + for (unsigned char c : s) { + if (c == '-' || c == '_') { + tail = false; + } else if (tail) { + s[n++] = c; + } else { + tail = true; + s[n++] = std::toupper(c); + } + } + + s.resize(n); + + return s; +} + +} diff --git a/cpp/src/lib/cucumber-messages/cucumber/messages/utils.hpp b/cpp/src/lib/cucumber-messages/cucumber/messages/utils.hpp new file mode 100644 index 00000000..7d9312e2 --- /dev/null +++ b/cpp/src/lib/cucumber-messages/cucumber/messages/utils.hpp @@ -0,0 +1,109 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include + +namespace cucumber::messages { + +using json = nlohmann::json; + +namespace detail { + +template < + template class Container, + template class Other, + typename T +> +std::is_same, Other> +test_is_container(Other*); + +template < + template class Container, + typename T +> +std::false_type test_is_container(T*); + +} // namespace detail + +template < + template class C, + typename T +> +using is_container = decltype( + detail::test_is_container(static_cast(nullptr)) +); + +template < + template class C, + typename T +> +inline +constexpr bool is_container_v = is_container::value; + +template < + typename T, + typename Callable +> +void +apply_if(const T& v, Callable&& cb) +{ + if constexpr (is_container_v) { + if (v) { + cb(*v); + } + } else { + cb(v); + } +} + +std::string +camelize(std::string s, bool initial_tail = true); + +template +void +to_string(std::ostream& os, P&& prefix, T&& opt) +{ + apply_if( + opt, + [&](const auto& v) { + using vtype = std::decay_t; + + if constexpr (is_container_v) { + os << prefix << '['; + + for (std::size_t i = 0; i < v.size(); ++i) { + os << (i > 0 ? ", " : "") << v[i]; + } + + os << ']'; + } else { + os << prefix << v; + } + } + ); +} + +template +void +to_json(json& j, K&& key, T&& opt) +{ + apply_if( + opt, + [&](const auto& v) { + using vtype = std::decay_t; + + if constexpr (std::is_enum_v) { + j[key] = to_string(v); + } else { + j[key] = v; + } + } + ); +} + +} diff --git a/docker-bake.hcl b/docker-bake.hcl index a5600dc0..02e5d2ad 100644 --- a/docker-bake.hcl +++ b/docker-bake.hcl @@ -7,6 +7,7 @@ group "default" { group "codegen" { targets = [ + "cpp-codegen", "go-codegen", "java-codegen", "javascript-codegen", @@ -18,6 +19,7 @@ group "codegen" { group "test" { targets = [ + "cpp-test", "go-test", "java-test", "javascript-test", @@ -31,6 +33,23 @@ target "elixir-test" { target = "tested" } +target "cpp-codegen" { + context = "jsonschema" + target = "output" + args = { + LANGUAGE = "cpp", + } + output = ["cpp/"] +} + +target "cpp-test" { + context = "cpp" + target = "tested" + contexts = { + schema-codegen = "target:cpp-codegen", + } +} + target "go-codegen" { context = "jsonschema" target = "output" diff --git a/jsonschema/scripts/codegen.rb b/jsonschema/scripts/codegen.rb index bf144575..2b0c558c 100644 --- a/jsonschema/scripts/codegen.rb +++ b/jsonschema/scripts/codegen.rb @@ -160,6 +160,33 @@ def array_type_for(type_name) end end +class Cpp < Codegen + def initialize(paths) + language_type_by_schema_type = { + 'integer' => 'std::size_t', + 'string' => 'std::string', + 'boolean' => 'bool', + } + + super(paths, language_type_by_schema_type) + end + + def array_type_for(type_name) + "std::vector<#{type_name}>" + end + + def format_description(raw_description, indent_string: "") + return '' if raw_description.nil? + + raw_description + .split("\n") + .map { |line| line.strip() } + .filter { |line| line != '*' } + .map { |line| "// #{line}".rstrip() } + .join("\n#{indent_string}") + end +end + class Java < Codegen def initialize(paths) language_type_by_schema_type = { diff --git a/jsonschema/scripts/templates/cpp.enum.hpp.erb b/jsonschema/scripts/templates/cpp.enum.hpp.erb new file mode 100644 index 00000000..3cc4b2e0 --- /dev/null +++ b/jsonschema/scripts/templates/cpp.enum.hpp.erb @@ -0,0 +1,54 @@ +<% @enums.each do |enum| -%> +<% ename = underscore(enum[:name]) %> +<%= ename %>.hpp +#pragma once + +#include + +namespace cucumber::messages { + +enum class <%= ename %> +{ +<%- + vals = enum[:values].map { |v| enum_constant(v) } +-%> + <%= vals.join(",\n ") %> +}; + +std::string_view +to_string(<%= ename %> v); + +std::ostream& +operator<<(std::ostream& os, <%= ename %> v); + +} +<%= ename %>.cpp +#include + +#include .hpp> + +namespace cucumber::messages { + +std::string_view +to_string(<%= ename %> v) +{ + using map_type = std::unordered_map<<%= ename %>, std::string_view>; + + static const map_type m = { +<%- enum[:values].each_with_index do |value, index| -%> + { <%= ename %>::<%= enum_constant(value) %>, "<%= value %>" }<%= index < enum[:values].length-1 ? ',' : '' %> +<% end -%> + }; + + return m.at(v); +} + +std::ostream& +operator<<(std::ostream& os, <%= ename %> v) +{ + os << to_string(v); + + return os; +} + +}<%- end -%> diff --git a/jsonschema/scripts/templates/cpp.hpp.erb b/jsonschema/scripts/templates/cpp.hpp.erb new file mode 100644 index 00000000..f6a9e1aa --- /dev/null +++ b/jsonschema/scripts/templates/cpp.hpp.erb @@ -0,0 +1,147 @@ +all.hpp +<%- @schemas.each do |key, schema| -%> +<%- + myclass = underscore(class_name(key)) +-%> +#include .hpp> +<%- end -%> +<%- @schemas.each do |key, schema| -%> +<%- + myclass = underscore(class_name(key)) +%> +<%= myclass -%>.hpp +#pragma once + +#include +#include + +#include +<%- + incs = [] + schema['properties'].each do |property_name, property| + type = underscore(type_for(class_name(key), property_name, property)) + if m = /std::vector<(?.+)>/.match(type) + type = m['vtype'] + end + next if type.start_with?("std::") + next if type == "bool" + incs.append(type) + end + + if incs.length > 0 +-%> + + <%- incs.each do |type| -%> +#include .hpp> + <%- end -%> +<%- end -%> + +namespace cucumber::messages { + +using json = nlohmann::json; + +// +// Represents the <%= class_name(key) %> message in Cucumber's message protocol +// @see Github - Cucumber - Messages +<%- if not (schema['description'] || []).empty? -%> +// +<%= format_description(schema['description'], indent_string: '') %> +<%- end -%> +// +// Generated code + +struct <%= myclass %> +{ + <%- + schema['properties'].each do |property_name, property| + type = underscore(type_for(class_name(key), property_name, property)) + ptype = type + pname = underscore(property_name) + prequired = (schema['required'] || []).index(property_name) + if m = /std::vector<(?.+)>/.match(type) + if !m['vtype'].start_with?("std::") + ptype = "std::vector" + end + elsif !type.start_with?("std::") && type != "bool" + ptype = "cucumber::messages::" + type + end + if !prequired + ptype = "std::optional<" + ptype + ">" + end + -%> + <%= ptype %> <%= pname %>; + <%- end -%> + + std::string to_string() const; + + void to_json(json& j) const; + std::string to_json() const; +}; + +std::ostream& +operator<<(std::ostream& os, const <%= myclass %>& msg); + +void to_json(json& j, const <%= myclass %>& m); + +} +<%= myclass %>.cpp +#include + +#include +#include .hpp> + +namespace cucumber::messages { + +std::string +<%= myclass %>::to_string() const +{ + std::ostringstream oss; + + <%- + schema['properties'].each_with_index do |(property_name, property), index| + pname = underscore(property_name) + prefix = '"' + (index == 0 ? '' : ', ') + pname + '="' + -%> + cucumber::messages::to_string(oss, <%= prefix %>, <%= pname %>); + <%- end -%> + + return oss.str(); +} + +void +<%= myclass %>::to_json(json& j) const +{ + <%- + exprs = [] + schema['properties'].each_with_index do |(property_name, property), index| + pname = underscore(property_name) + -%> + cucumber::messages::to_json(j, camelize("<%= pname %>"), <%= pname %>); + <%- end -%> +} + +std::string +<%= myclass %>::to_json() const +{ + std::ostringstream oss; + json j; + + to_json(j); + + oss << j; + + return oss.str(); +} + +std::ostream& +operator<<(std::ostream& os, const <%= myclass %>& msg) +{ + os << msg.to_string(); + + return os; +} + +void to_json(json& j, const <%= myclass %>& m) +{ m.to_json(j); } + +}<%- end -%>