add tests

Author: daantimmer

cucumber_cpp/library/Application.cpp

@@ -117,7 +117,7 @@ namespace cucumber_cpp::library
         runCommand->add_option("--outputfolder", options.outputfolder, "Specifies the output folder for generated report files")->group("report generation");
         runCommand->add_option("--reportfile", options.reportfile, "Specifies the output name for generated report files")->group("report generation");
         runCommand->add_flag("--dry", options.dryrun, "Generate report without running tests");
-        runCommand->add_flag("--unused", options.printStepsNotUsed, "Show step definitions that were not used")->default_val(false);
+        runCommand->add_flag("--unused", options.printStepsNotUsed, "Show step definitions that were not used");
 
         reporters.Add("console", std::make_unique<report::StdOutReport>());
         reporters.Add("junit-xml", std::make_unique<report::JunitReport>(options.outputfolder, options.reportfile));
@@ -217,26 +217,31 @@ namespace cucumber_cpp::library
         testRunner.Run(GetFeatureTree(featureTreeFactory, tagExpression));
 
         if (options.printStepsNotUsed)
-        {
-            auto isUsed = [](const StepRegistry::EntryView& entry)
-            {
-                return entry.used > 0;
-            };
-            auto unusedSteps = stepRegistry.List() | std::views::filter(std::not_fn(isUsed));
-            if (std::ranges::begin(unusedSteps) == std::ranges::end(unusedSteps))
-                std::cout << "\nAll steps have been used.";
-            else
-            {
-                std::cout << "\nThe following steps have not been used:";
-                for (const auto& entry : unusedSteps)
-                    std::cout << "\n - " << std::visit(cucumber_expression::PatternVisitor{}, entry.stepRegex);
-            }
-        }
+            PrintStepsNotUsed(stepRegistry);
 
         std::cout << '\n'
                   << std::flush;
     }
 
+    void Application::PrintStepsNotUsed(StepRegistry& stepRegistry)
+    {
+        auto isUnused = [](const StepRegistry::EntryView& entry)
+        {
+            return entry.used == 0;
+        };
+
+        auto unusedSteps = stepRegistry.List() | std::views::filter(isUnused);
+
+        if (std::ranges::empty(unusedSteps))
+            std::cout << "\nAll steps have been used.";
+        else
+        {
+            std::cout << "\nThe following steps have not been used:";
+            for (const auto& entry : unusedSteps)
+                std::cout << "\n - " << std::visit(cucumber_expression::SourceVisitor{}, entry.stepRegex);
+        }
+    }
+
     std::vector<std::unique_ptr<engine::FeatureInfo>> Application::GetFeatureTree(const engine::FeatureTreeFactory& featureTreeFactory, std::string_view tagExpression)
     {
 

cucumber_cpp/library/Application.hpp

@@ -6,6 +6,7 @@
 
 #include "cucumber/gherkin/app.hpp"
 #include "cucumber_cpp/library/Context.hpp"
+#include "cucumber_cpp/library/StepRegistry.hpp"
 #include "cucumber_cpp/library/cucumber_expression/ParameterRegistry.hpp"
 #include "cucumber_cpp/library/engine/ContextManager.hpp"
 #include "cucumber_cpp/library/engine/FeatureFactory.hpp"
@@ -54,12 +55,14 @@ namespace cucumber_cpp::library
         void AddReportHandler(const std::string& name, std::unique_ptr<report::ReportHandlerV2>&& reporter);
 
     private:
-        [[nodiscard]] int GetExitCode() const;
-        [[nodiscard]] int GetExitCode(engine::Result result) const;
         void DryRunFeatures();
         void RunFeatures();
-        [[nodiscard]] std::vector<std::unique_ptr<engine::FeatureInfo>> GetFeatureTree(const engine::FeatureTreeFactory& featureTreeFactory, std::string_view tagExpression);
         [[nodiscard]] engine::Result RunFeature(const std::filesystem::path& path, std::string_view tagExpression, report::ReportHandlerV2& reportHandler);
+        void PrintStepsNotUsed(StepRegistry& stepRegistry);
+        [[nodiscard]] std::vector<std::unique_ptr<engine::FeatureInfo>> GetFeatureTree(const engine::FeatureTreeFactory& featureTreeFactory, std::string_view tagExpression);
+
+        [[nodiscard]] int GetExitCode() const;
+        [[nodiscard]] int GetExitCode(engine::Result result) const;
 
         Options options;
         CLI::App cli;

cucumber_cpp/library/test/TestApplication.cpp

@@ -1,6 +1,7 @@
 #include "cucumber_cpp/CucumberCpp.hpp"
 #include "cucumber_cpp/library/Application.hpp"
 #include "cucumber_cpp/library/engine/test_helper/TemporaryFile.hpp"
+#include "gmock/gmock.h"
 #include <CLI/Error.hpp>
 #include <array>
 #include <cstddef>
@@ -110,4 +111,33 @@ namespace cucumber_cpp::library
     {
         EXPECT_THAT(&Application{}.ParameterRegistration(), testing::NotNull());
     }
+
+    TEST_F(TestApplication, UnusedParameters)
+    {
+        auto tmp = engine::test_helper::TemporaryFile{ "tmpfile.feature" };
+        const auto path = tmp.Path().string();
+
+        tmp << "Feature: Test feature\n"
+               "  Rule: Test rule\n"
+               "    Scenario: Test scenario1\n"
+               "      Given 5 and 5 are equal\n"
+               "      And This is a GIVEN step\n"
+               "      And This is a WHEN step\n"
+               "      And This is a THEN step\n"
+               "      And This is a STEP step\n";
+
+        const std::array args{ "application", "run", "--feature", path.c_str(), "--report", "console", "--unused" };
+
+        std::string stdoutString = RunWithArgs(args, static_cast<std::underlying_type_t<CLI::ExitCodes>>(CLI::ExitCodes::Success));
+
+        EXPECT_THAT(stdoutString, testing::HasSubstr("The following steps have not been used:"));
+        EXPECT_THAT(stdoutString, testing::HasSubstr("^This is a step with a ([0-9]+)s delay$"));
+        EXPECT_THAT(stdoutString, testing::HasSubstr("Step with cucumber expression syntax {float} {string} {int}"));
+
+        EXPECT_THAT(stdoutString, testing::Not(testing::HasSubstr("{int} and {int} are equal")));
+        EXPECT_THAT(stdoutString, testing::Not(testing::HasSubstr("And This is a GIVEN step")));
+        EXPECT_THAT(stdoutString, testing::Not(testing::HasSubstr("And This is a WHEN step")));
+        EXPECT_THAT(stdoutString, testing::Not(testing::HasSubstr("And This is a THEN step")));
+        EXPECT_THAT(stdoutString, testing::Not(testing::HasSubstr("And This is a STEP step")));
+    }
 }