Skip to content

Commit 3144b2f

Browse files
daantimmerdaantimmer
committed
feat: add test suite for StdOutReport and improve debugging configurations
1 parent fe6e9ab commit 3144b2f

File tree

6 files changed

+306
-7
lines changed

6 files changed

+306
-7
lines changed

‎.vscode/launch.json‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,24 @@
2828
}
2929
],
3030
"configurations": [
31+
{
32+
"name": "Debug Test",
33+
"type": "cppdbg",
34+
"request": "launch",
35+
"program": "${command:cmake.launchTargetPath}",
36+
"stopAtEntry": false,
37+
"cwd": "${workspaceFolder}",
38+
"environment": [],
39+
"externalConsole": false,
40+
"MIMode": "gdb",
41+
"setupCommands": [
42+
{
43+
"description": "Enable pretty-printing for gdb",
44+
"text": "-enable-pretty-printing",
45+
"ignoreFailures": true
46+
}
47+
]
48+
},
3149
{
3250
"name": "(gdb) Launch",
3351
"type": "cppdbg",

‎cucumber_cpp/library/engine/test_helper/ContextManagerInstance.hpp‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -23,12 +23,12 @@ namespace cucumber_cpp::library::engine::test_helper
2323
struct ContextManagerInstance : private ContextManagerInstanceStorage
2424
, cucumber_cpp::library::engine::ContextManager
2525
{
26-
ContextManagerInstance(std::set<std::string, std::less<>> tags = {})
26+
explicit ContextManagerInstance(std::set<std::string, std::less<>> tags = {})
2727
: cucumber_cpp::library::engine::ContextManager{ contextStorageFactory }
28-
, feature{ tags, {}, {}, {}, {}, {} }
29-
, rule{ feature, {}, {}, {}, {}, {} }
30-
, scenario{ rule, tags, {}, {}, {}, {} }
31-
, step{ scenario, {}, {}, {}, {}, {} }
28+
, feature{ tags, "FeatureInfo", {}, {}, {}, {} }
29+
, rule{ feature, {}, "RuleInfo", {}, {}, {} }
30+
, scenario{ rule, tags, "ScenarioInfo", {}, {}, {} }
31+
, step{ scenario, "StepInfo", {}, {}, {}, {} }
3232
{
3333
}
3434

‎cucumber_cpp/library/report/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,5 +19,6 @@ target_link_libraries(cucumber_cpp.library.report PUBLIC
1919
)
2020

2121
if (CCR_BUILD_TESTS)
22+
add_subdirectory(test)
2223
add_subdirectory(test_helper)
2324
endif()

‎cucumber_cpp/library/report/StdOutReport.cpp‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -174,8 +174,7 @@ namespace cucumber_cpp::library::report
174174

175175
void StdOutReport::RuleStart(const engine::RuleInfo& ruleInfo)
176176
{
177-
std::cout << "\n"
178-
<< ruleInfo.Title();
177+
// not required
179178
}
180179

181180
void StdOutReport::RuleEnd(engine::Result result, const engine::RuleInfo& ruleInfo, TraceTime::Duration duration)

‎cucumber_cpp/library/report/test/CMakeLists.txt‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
add_executable(cucumber_cpp.library.report.test)
2+
add_test(NAME cucumber_cpp.library.report.test COMMAND cucumber_cpp.library.report.test)
3+
4+
target_link_libraries(cucumber_cpp.library.report.test PUBLIC
5+
GTest::gtest
6+
GTest::gmock
7+
GTest::gmock_main
8+
9+
cucumber_cpp.library.report
10+
)
11+
12+
target_sources(cucumber_cpp.library.report.test PRIVATE
13+
TestStdOutReport.cpp
14+
)

‎cucumber_cpp/library/report/test/TestStdOutReport.cpp‎

Lines changed: 267 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,267 @@
1+
#include "cucumber_cpp/library/TraceTime.hpp"
2+
#include "cucumber_cpp/library/engine/Result.hpp"
3+
#include "cucumber_cpp/library/engine/test_helper/ContextManagerInstance.hpp"
4+
#include "cucumber_cpp/library/report/StdOutReport.hpp"
5+
#include "gmock/gmock.h"
6+
#include "gtest/gtest.h"
7+
#include <chrono>
8+
#include <gtest/gtest.h>
9+
10+
namespace cucumber_cpp::library::report
11+
{
12+
struct TestStdOutReport : testing::Test
13+
{
14+
engine::test_helper::ContextManagerInstance contextManagerInstance;
15+
StdOutReport stdOutReport;
16+
};
17+
18+
TEST_F(TestStdOutReport, FeatureStartPrintNothing)
19+
{
20+
testing::internal::CaptureStdout();
21+
stdOutReport.FeatureStart(contextManagerInstance.FeatureContext().info);
22+
const auto stdout{ testing::internal::GetCapturedStdout() };
23+
EXPECT_THAT(stdout, testing::StrEq(""));
24+
}
25+
26+
TEST_F(TestStdOutReport, FeatureEndPrintNothing)
27+
{
28+
testing::internal::CaptureStdout();
29+
stdOutReport.FeatureEnd({}, contextManagerInstance.FeatureContext().info, {});
30+
const auto stdout{ testing::internal::GetCapturedStdout() };
31+
EXPECT_THAT(stdout, testing::StrEq(""));
32+
}
33+
34+
TEST_F(TestStdOutReport, RuleStart)
35+
{
36+
testing::internal::CaptureStdout();
37+
stdOutReport.RuleStart(contextManagerInstance.RuleContext().info);
38+
const auto stdout{ testing::internal::GetCapturedStdout() };
39+
EXPECT_THAT(stdout, testing::StrEq(""));
40+
}
41+
42+
TEST_F(TestStdOutReport, RuleEndPrintNothing)
43+
{
44+
testing::internal::CaptureStdout();
45+
stdOutReport.RuleEnd({}, contextManagerInstance.RuleContext().info, {});
46+
const auto stdout{ testing::internal::GetCapturedStdout() };
47+
EXPECT_THAT(stdout, testing::StrEq(""));
48+
}
49+
50+
TEST_F(TestStdOutReport, ScenarioStart)
51+
{
52+
testing::internal::CaptureStdout();
53+
stdOutReport.ScenarioStart(contextManagerInstance.ScenarioContext().info);
54+
const auto stdout{ testing::internal::GetCapturedStdout() };
55+
EXPECT_THAT(stdout, testing::StrEq("\nScenarioInfo"));
56+
}
57+
58+
TEST_F(TestStdOutReport, ScenarioEndPassed)
59+
{
60+
testing::internal::CaptureStdout();
61+
stdOutReport.ScenarioEnd(engine::Result::passed, contextManagerInstance.ScenarioContext().info, {});
62+
const auto stdout{ testing::internal::GetCapturedStdout() };
63+
EXPECT_THAT(stdout, testing::HasSubstr("\n\\->"));
64+
EXPECT_THAT(stdout, testing::HasSubstr("done (0ns)"));
65+
}
66+
67+
TEST_F(TestStdOutReport, ScenarioEndPassedTimeScale)
68+
{
69+
auto testDuration = [this](TraceTime::Duration duration, const char* time)
70+
{
71+
testing::internal::CaptureStdout();
72+
stdOutReport.ScenarioEnd(engine::Result::passed, contextManagerInstance.ScenarioContext().info, duration);
73+
const auto stdout{ testing::internal::GetCapturedStdout() };
74+
EXPECT_THAT(stdout, testing::HasSubstr(time));
75+
};
76+
77+
testDuration(std::chrono::nanoseconds{ 1 }, "1ns");
78+
testDuration(std::chrono::microseconds{ 2 }, "2us");
79+
testDuration(std::chrono::milliseconds{ 3 }, "3ms");
80+
testDuration(std::chrono::seconds{ 4 }, "4s");
81+
testDuration(std::chrono::minutes{ 5 }, "5m");
82+
testDuration(std::chrono::hours{ 6 }, "6h");
83+
}
84+
85+
TEST_F(TestStdOutReport, ScenarioEndSkipped)
86+
{
87+
testing::internal::CaptureStdout();
88+
stdOutReport.ScenarioEnd(engine::Result::skipped, contextManagerInstance.ScenarioContext().info, {});
89+
const auto stdout{ testing::internal::GetCapturedStdout() };
90+
EXPECT_THAT(stdout, testing::HasSubstr("\n\\->"));
91+
EXPECT_THAT(stdout, testing::HasSubstr("skipped (0ns)"));
92+
}
93+
94+
TEST_F(TestStdOutReport, ScenarioEndPending)
95+
{
96+
testing::internal::CaptureStdout();
97+
stdOutReport.ScenarioEnd(engine::Result::pending, contextManagerInstance.ScenarioContext().info, {});
98+
const auto stdout{ testing::internal::GetCapturedStdout() };
99+
EXPECT_THAT(stdout, testing::HasSubstr("\n\\->"));
100+
EXPECT_THAT(stdout, testing::HasSubstr("pending (0ns)"));
101+
}
102+
103+
TEST_F(TestStdOutReport, ScenarioEndUndefined)
104+
{
105+
testing::internal::CaptureStdout();
106+
stdOutReport.ScenarioEnd(engine::Result::undefined, contextManagerInstance.ScenarioContext().info, {});
107+
const auto stdout{ testing::internal::GetCapturedStdout() };
108+
EXPECT_THAT(stdout, testing::HasSubstr("\n\\->"));
109+
EXPECT_THAT(stdout, testing::HasSubstr("undefined (0ns)"));
110+
}
111+
112+
TEST_F(TestStdOutReport, ScenarioEndAmbiguous)
113+
{
114+
testing::internal::CaptureStdout();
115+
stdOutReport.ScenarioEnd(engine::Result::ambiguous, contextManagerInstance.ScenarioContext().info, {});
116+
const auto stdout{ testing::internal::GetCapturedStdout() };
117+
EXPECT_THAT(stdout, testing::HasSubstr("\n\\->"));
118+
EXPECT_THAT(stdout, testing::HasSubstr("ambiguous (0ns)"));
119+
}
120+
121+
TEST_F(TestStdOutReport, ScenarioEndFailed)
122+
{
123+
testing::internal::CaptureStdout();
124+
stdOutReport.ScenarioEnd(engine::Result::failed, contextManagerInstance.ScenarioContext().info, {});
125+
const auto stdout{ testing::internal::GetCapturedStdout() };
126+
EXPECT_THAT(stdout, testing::HasSubstr("\n\\->"));
127+
EXPECT_THAT(stdout, testing::HasSubstr("failed (0ns)"));
128+
}
129+
130+
TEST_F(TestStdOutReport, StepMissing)
131+
{
132+
testing::internal::CaptureStdout();
133+
stdOutReport.StepMissing("missing step text");
134+
const auto stdout{ testing::internal::GetCapturedStdout() };
135+
EXPECT_THAT(stdout, testing::HasSubstr("Step missing: \"missing step text\""));
136+
}
137+
138+
TEST_F(TestStdOutReport, StepAmbiguous)
139+
{
140+
testing::internal::CaptureStdout();
141+
// stdOutReport.StepAmbiguous();
142+
const auto stdout{ testing::internal::GetCapturedStdout() };
143+
EXPECT_THAT(stdout, testing::StrEq(""));
144+
}
145+
146+
TEST_F(TestStdOutReport, StepSkipped)
147+
{
148+
testing::internal::CaptureStdout();
149+
stdOutReport.StepSkipped(contextManagerInstance.StepContext().info);
150+
const auto stdout{ testing::internal::GetCapturedStdout() };
151+
EXPECT_THAT(stdout, testing::HasSubstr("\n| "));
152+
EXPECT_THAT(stdout, testing::HasSubstr("skipped Given StepInfo"));
153+
}
154+
155+
TEST_F(TestStdOutReport, StepStart)
156+
{
157+
testing::internal::CaptureStdout();
158+
stdOutReport.StepStart(contextManagerInstance.StepContext().info);
159+
const auto stdout{ testing::internal::GetCapturedStdout() };
160+
EXPECT_THAT(stdout, testing::StrEq("\n| Given StepInfo"));
161+
}
162+
163+
TEST_F(TestStdOutReport, NestedStepStart)
164+
{
165+
testing::internal::CaptureStdout();
166+
stdOutReport.StepStart(contextManagerInstance.StepContext().info);
167+
testing::internal::GetCapturedStdout();
168+
169+
testing::internal::CaptureStdout();
170+
stdOutReport.StepStart(contextManagerInstance.StepContext().info);
171+
const auto stdout{ testing::internal::GetCapturedStdout() };
172+
EXPECT_THAT(stdout, testing::StrEq("\n| | Given StepInfo"));
173+
}
174+
175+
TEST_F(TestStdOutReport, StepEnd)
176+
{
177+
testing::internal::CaptureStdout();
178+
stdOutReport.StepStart(contextManagerInstance.StepContext().info);
179+
testing::internal::GetCapturedStdout();
180+
181+
testing::internal::CaptureStdout();
182+
stdOutReport.StepEnd(engine::Result::passed, contextManagerInstance.StepContext().info, {});
183+
const auto stdout{ testing::internal::GetCapturedStdout() };
184+
EXPECT_THAT(stdout, testing::HasSubstr("\n| \\-> "));
185+
EXPECT_THAT(stdout, testing::HasSubstr("done (0ns)"));
186+
}
187+
188+
TEST_F(TestStdOutReport, StepEndNested)
189+
{
190+
testing::internal::CaptureStdout();
191+
stdOutReport.StepStart(contextManagerInstance.StepContext().info);
192+
stdOutReport.StepStart(contextManagerInstance.StepContext().info);
193+
testing::internal::GetCapturedStdout();
194+
195+
testing::internal::CaptureStdout();
196+
stdOutReport.StepEnd(engine::Result::passed, contextManagerInstance.StepContext().info, {});
197+
const auto stdout{ testing::internal::GetCapturedStdout() };
198+
EXPECT_THAT(stdout, testing::HasSubstr("\n| | \\-> "));
199+
EXPECT_THAT(stdout, testing::HasSubstr("done (0ns)"));
200+
}
201+
202+
TEST_F(TestStdOutReport, Failure)
203+
{
204+
testing::internal::CaptureStdout();
205+
stdOutReport.Failure("My Failure", "file.cpp", 1, 1);
206+
const auto stdout{ testing::internal::GetCapturedStdout() };
207+
EXPECT_THAT(stdout, testing::HasSubstr("\nFailure @ ./file.cpp:1:1:\nMy Failure"));
208+
}
209+
210+
TEST_F(TestStdOutReport, FailureWithoutColumn)
211+
{
212+
testing::internal::CaptureStdout();
213+
stdOutReport.Failure("My Failure", "file.cpp", 1);
214+
const auto stdout{ testing::internal::GetCapturedStdout() };
215+
EXPECT_THAT(stdout, testing::HasSubstr("\nFailure @ ./file.cpp:1:\nMy Failure"));
216+
}
217+
218+
TEST_F(TestStdOutReport, Error)
219+
{
220+
testing::internal::CaptureStdout();
221+
stdOutReport.Error("My Error", "file.cpp", 1, 1);
222+
const auto stdout{ testing::internal::GetCapturedStdout() };
223+
EXPECT_THAT(stdout, testing::HasSubstr("\nError @ ./file.cpp:1:1:\nMy Error"));
224+
}
225+
226+
TEST_F(TestStdOutReport, ErrorWithoutColumn)
227+
{
228+
testing::internal::CaptureStdout();
229+
stdOutReport.Error("My Error", "file.cpp", 1);
230+
const auto stdout{ testing::internal::GetCapturedStdout() };
231+
EXPECT_THAT(stdout, testing::HasSubstr("\nError @ ./file.cpp:1:\nMy Error"));
232+
}
233+
234+
TEST_F(TestStdOutReport, Trace)
235+
{
236+
testing::internal::CaptureStdout();
237+
stdOutReport.Trace("Traces a message without any formatting");
238+
const auto stdout{ testing::internal::GetCapturedStdout() };
239+
EXPECT_THAT(stdout, testing::StrEq("Traces a message without any formatting"));
240+
}
241+
242+
TEST_F(TestStdOutReport, Summary)
243+
{
244+
testing::internal::CaptureStdout();
245+
stdOutReport.ScenarioStart(contextManagerInstance.ScenarioContext().info);
246+
stdOutReport.ScenarioStart(contextManagerInstance.ScenarioContext().info);
247+
stdOutReport.ScenarioStart(contextManagerInstance.ScenarioContext().info);
248+
249+
stdOutReport.ScenarioEnd(engine::Result::passed, contextManagerInstance.ScenarioContext().info, {});
250+
stdOutReport.ScenarioEnd(engine::Result::skipped, contextManagerInstance.ScenarioContext().info, {});
251+
stdOutReport.ScenarioEnd(engine::Result::failed, contextManagerInstance.ScenarioContext().info, {});
252+
253+
testing::internal::GetCapturedStdout();
254+
255+
testing::internal::CaptureStdout();
256+
stdOutReport.Summary({});
257+
const auto stdout{ testing::internal::GetCapturedStdout() };
258+
EXPECT_THAT(stdout, testing::StrEq("\n====================summary===================="
259+
"\nduration: 0ns"
260+
"\ntests : 1/3 passed"
261+
"\n"
262+
"\nfailed tests:"
263+
"\n\"\":0:0 : \"ScenarioInfo\""
264+
"\n\"\":0:0 : \"ScenarioInfo\""));
265+
}
266+
267+
}

0 commit comments

Comments
 (0)