fixed co-pilot comments

Author: daantimmer

compatibility/data-tables/data-tables.cpp

@@ -1,52 +1,39 @@
-#include "cucumber/messages/pickle_table_row.hpp"
+#include "cucumber/messages/pickle_table.hpp"
 #include "cucumber_cpp/CucumberCpp.hpp"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
 #include <cstddef>
 #include <gmock/gmock.h>
-#include <span>
+#include <gtest/gtest.h>
 #include <vector>
 
 STEP(R"(the following table is transposed:)")
 {
-    std::vector<cucumber::messages::pickle_table_row> transposedTable;
-    transposedTable.reserve(this->table->front().cells.size());
-    for (std::size_t colIdx = 0; colIdx < this->table->front().cells.size(); ++colIdx)
-        transposedTable.emplace_back().cells.resize(this->table->size());
+    auto transposedTable = context.Emplace<cucumber::messages::pickle_table>();
+    transposedTable->rows.reserve(this->dataTable->rows[0].cells.size());
+    for (std::size_t colIdx = 0; colIdx < this->dataTable->rows[0].cells.size(); ++colIdx)
+        transposedTable->rows.emplace_back().cells.resize(this->dataTable->rows.size());
 
-    for (std::size_t rowIdx = 0; rowIdx < this->table->size(); ++rowIdx)
-        for (std::size_t colIdx = 0; colIdx < this->table->begin()[rowIdx].cells.size(); ++colIdx)
-            transposedTable[colIdx].cells[rowIdx] = this->table->begin()[rowIdx].cells[colIdx];
-
-    context.Insert(transposedTable);
+    for (std::size_t rowIdx = 0; rowIdx < this->dataTable->rows.size(); ++rowIdx)
+        for (std::size_t colIdx = 0; colIdx < this->dataTable->rows[rowIdx].cells.size(); ++colIdx)
+            transposedTable->rows[colIdx].cells[rowIdx] = this->dataTable->rows[rowIdx].cells[colIdx];
 }
 
 STEP(R"(it should be:)")
 {
-    std::span<const cucumber::messages::pickle_table_row> expected = context.Get<std::vector<cucumber::messages::pickle_table_row>>();
-    const auto& actual = *table;
-    const auto rows = expected.size();
-    ASSERT_THAT(rows, testing::Eq(actual.size()));
+    const auto& actualTable = context.Get<cucumber::messages::pickle_table>();
+    const auto& expectedTalbe = dataTable;
+
+    const auto rows = actualTable.rows.size();
+    ASSERT_THAT(rows, testing::Eq(expectedTalbe->rows.size()));
+
     for (auto rowIdx = 0; rowIdx < rows; ++rowIdx)
     {
-        const auto columns = expected[rowIdx].cells.size();
-        ASSERT_THAT(columns, testing::Eq(actual[rowIdx].cells.size()));
+        const auto columns = expectedTalbe->rows[rowIdx].cells.size();
+        ASSERT_THAT(columns, testing::Eq(actualTable.rows[rowIdx].cells.size()));
         for (auto colIdx = 0; colIdx < columns; ++colIdx)
         {
-            const auto& expectedCell = expected[rowIdx].cells[colIdx];
-            const auto& actualCell = actual[rowIdx].cells[colIdx];
+            const auto& expectedCell = expectedTalbe->rows[rowIdx].cells[colIdx];
+            const auto& actualCell = actualTable.rows[rowIdx].cells[colIdx];
             EXPECT_THAT(expectedCell.value, testing::StrEq(actualCell.value)) << "at row " << rowIdx << " column " << colIdx;
         }
     }
 }
-
-// import assert from 'node:assert'
-// import { DataTable, When, Then } from '@cucumber/fake-cucumber'
-
-// When('the following table is transposed:', function (table: DataTable) {
-//   this.transposed = table.transpose()
-// })
-
-// Then('it should be:', function (expected: DataTable) {
-//   assert.deepStrictEqual(this.transposed.raw(), expected.raw())
-// }

cucumber_cpp/example/steps/Steps.cpp

@@ -3,7 +3,6 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstdint>
-#include <iostream>
 #include <string>
 
 GIVEN(R"(a background step)")
@@ -13,11 +12,11 @@ GIVEN(R"(a background step)")
 
 GIVEN(R"(a simple data table)")
 {
-    [[maybe_unused]] const auto row0col0 = table.value()[0].cells[0].value;
-    [[maybe_unused]] const auto row0col1 = table.value()[0].cells[1].value;
+    [[maybe_unused]] const auto row0col0 = dataTable->rows[0].cells[0].value;
+    [[maybe_unused]] const auto row0col1 = dataTable->rows[0].cells[1].value;
 
-    [[maybe_unused]] const auto row1col0 = table.value()[1].cells[0].value;
-    [[maybe_unused]] const auto row1col1 = table.value()[1].cells[1].value;
+    [[maybe_unused]] const auto row1col0 = dataTable->rows[1].cells[0].value;
+    [[maybe_unused]] const auto row1col1 = dataTable->rows[1].cells[1].value;
 }
 
 GIVEN(R"(there are {int} cucumbers)", (std::int32_t num))
@@ -99,7 +98,7 @@ STEP("this step should be skipped")
 
 STEP(R"(a step stores the value at row {int} and column {int} from the table:)", (std::int32_t row, std::int32_t column))
 {
-    context.EmplaceAt<std::string>("cell", table.value()[row].cells[column].value);
+    context.EmplaceAt<std::string>("cell", dataTable->rows[row].cells[column].value);
 }
 
 STEP(R"(the value should be {string})", (const std::string& expected_value))

cucumber_cpp/library/StepRegistry.hpp

@@ -3,6 +3,7 @@
 
 #include "cucumber/gherkin/id_generator.hpp"
 #include "cucumber/messages/pickle_doc_string.hpp"
+#include "cucumber/messages/pickle_table.hpp"
 #include "cucumber/messages/pickle_table_row.hpp"
 #include "cucumber/messages/step_definition_pattern_type.hpp"
 #include "cucumber_cpp/library/Body.hpp"
@@ -34,12 +35,12 @@
 
 namespace cucumber_cpp::library
 {
-    using StepFactory = std::unique_ptr<Body> (&)(util::Broadcaster& broadCaster, Context&, engine::StepOrHookStarted stepOrHookStarted, std::optional<std::span<const cucumber::messages::pickle_table_row>>, const std::optional<cucumber::messages::pickle_doc_string>&);
+    using StepFactory = std::unique_ptr<Body> (&)(util::Broadcaster& broadCaster, Context&, engine::StepOrHookStarted stepOrHookStarted, const std::optional<cucumber::messages::pickle_table>&, const std::optional<cucumber::messages::pickle_doc_string>&);
 
     template<class T>
-    std::unique_ptr<Body> StepBodyFactory(util::Broadcaster& broadCaster, Context& context, engine::StepOrHookStarted stepOrHookStarted, std::optional<std::span<const cucumber::messages::pickle_table_row>> table, const std::optional<cucumber::messages::pickle_doc_string>& docString)
+    std::unique_ptr<Body> StepBodyFactory(util::Broadcaster& broadCaster, Context& context, engine::StepOrHookStarted stepOrHookStarted, const std::optional<cucumber::messages::pickle_table>& dataTable, const std::optional<cucumber::messages::pickle_doc_string>& docString)
     {
-        return std::make_unique<T>(broadCaster, context, stepOrHookStarted, table, docString);
+        return std::make_unique<T>(broadCaster, context, stepOrHookStarted, dataTable, docString);
     }
 
     struct StepMatch

cucumber_cpp/library/engine/CMakeLists.txt

@@ -24,6 +24,6 @@ target_link_libraries(cucumber_cpp.library.engine PUBLIC
 )
 
 if (CCR_BUILD_TESTS)
-    # add_subdirectory(test)
+    add_subdirectory(test)
     # add_subdirectory(test_helper)
 endif()

cucumber_cpp/library/engine/Step.cpp

@@ -12,9 +12,9 @@
 
 namespace cucumber_cpp::library::engine
 {
-    Step::Step(util::Broadcaster& broadCaster, Context& context, engine::StepOrHookStarted stepOrHookStarted, std::optional<std::span<const cucumber::messages::pickle_table_row>> table, const std::optional<cucumber::messages::pickle_doc_string>& docString)
+    Step::Step(util::Broadcaster& broadCaster, Context& context, engine::StepOrHookStarted stepOrHookStarted, const std::optional<cucumber::messages::pickle_table>& dataTable, const std::optional<cucumber::messages::pickle_doc_string>& docString)
         : ExecutionContext{ broadCaster, context, stepOrHookStarted }
-        , table{ table }
+        , dataTable{ dataTable }
         , docString{ docString }
     {}
 

cucumber_cpp/library/engine/Step.hpp

@@ -5,6 +5,7 @@
 // IWYU pragma: friend cucumber_cpp/.*
 
 #include "cucumber/messages/pickle_doc_string.hpp"
+#include "cucumber/messages/pickle_table.hpp"
 #include "cucumber/messages/pickle_table_row.hpp"
 #include "cucumber_cpp/library/Context.hpp"
 #include "cucumber_cpp/library/engine/ExecutionContext.hpp"
@@ -20,7 +21,7 @@ namespace cucumber_cpp::library::engine
 {
     struct Step : ExecutionContext
     {
-        Step(util::Broadcaster& broadCaster, Context& context, engine::StepOrHookStarted stepOrHookStarted, std::optional<std::span<const cucumber::messages::pickle_table_row>> table, const std::optional<cucumber::messages::pickle_doc_string>& docString);
+        Step(util::Broadcaster& broadCaster, Context& context, engine::StepOrHookStarted stepOrHookStarted, const std::optional<cucumber::messages::pickle_table>& dataTable, const std::optional<cucumber::messages::pickle_doc_string>& docString);
         virtual ~Step() = default;
 
         virtual void SetUp()
@@ -38,7 +39,7 @@ namespace cucumber_cpp::library::engine
         void When(const std::string& step) const;
         void Then(const std::string& step) const;
 
-        std::optional<std::span<const cucumber::messages::pickle_table_row>> table;
+        const std::optional<cucumber::messages::pickle_table>& dataTable;
         const std::optional<cucumber::messages::pickle_doc_string>& docString;
     };
 }

cucumber_cpp/library/engine/test/CMakeLists.txt

@@ -4,16 +4,11 @@ add_test(NAME cucumber_cpp.library.engine.test COMMAND cucumber_cpp.library.engi
 target_link_libraries(cucumber_cpp.library.engine.test PUBLIC
     cucumber_cpp.library.engine
     gmock_main
-    cucumber_cpp.library.engine.test_helper
-    cucumber_cpp.library.engine.test_helper.steps
+    # cucumber_cpp.library.engine.test_helper
+    # cucumber_cpp.library.engine.test_helper.steps
 )
 
 target_sources(cucumber_cpp.library.engine.test PRIVATE
-    TestContextManager.cpp
-    TestFailureHandler.cpp
-    TestFeatureFactory.cpp
-    TestHookExecutor.cpp
-    TestHookExecutorHooks.cpp
     TestStep.cpp
     TestStringTo.cpp
 )