1 //
2 // Copyright 2019 The Abseil Authors.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // https://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15
16 #include "absl/flags/internal/usage.h"
17
18 #include <stdint.h>
19
20 #include <sstream>
21 #include <string>
22
23 #include "gtest/gtest.h"
24 #include "absl/flags/flag.h"
25 #include "absl/flags/internal/parse.h"
26 #include "absl/flags/internal/path_util.h"
27 #include "absl/flags/internal/program_name.h"
28 #include "absl/flags/reflection.h"
29 #include "absl/flags/usage.h"
30 #include "absl/flags/usage_config.h"
31 #include "absl/strings/match.h"
32 #include "absl/strings/string_view.h"
33
34 ABSL_FLAG(int, usage_reporting_test_flag_01, 101,
35 "usage_reporting_test_flag_01 help message");
36 ABSL_FLAG(bool, usage_reporting_test_flag_02, false,
37 "usage_reporting_test_flag_02 help message");
38 ABSL_FLAG(double, usage_reporting_test_flag_03, 1.03,
39 "usage_reporting_test_flag_03 help message");
40 ABSL_FLAG(int64_t, usage_reporting_test_flag_04, 1000000000000004L,
41 "usage_reporting_test_flag_04 help message");
42
43 static const char kTestUsageMessage[] = "Custom usage message";
44
45 struct UDT {
46 UDT() = default;
47 UDT(const UDT&) = default;
48 };
AbslParseFlag(absl::string_view,UDT *,std::string *)49 bool AbslParseFlag(absl::string_view, UDT*, std::string*) { return true; }
AbslUnparseFlag(const UDT &)50 std::string AbslUnparseFlag(const UDT&) { return "UDT{}"; }
51
52 ABSL_FLAG(UDT, usage_reporting_test_flag_05, {},
53 "usage_reporting_test_flag_05 help message");
54
55 ABSL_FLAG(
56 std::string, usage_reporting_test_flag_06, {},
57 "usage_reporting_test_flag_06 help message.\n"
58 "\n"
59 "Some more help.\n"
60 "Even more long long long long long long long long long long long long "
61 "help message.");
62
63 namespace {
64
65 namespace flags = absl::flags_internal;
66
NormalizeFileName(absl::string_view fname)67 static std::string NormalizeFileName(absl::string_view fname) {
68 #ifdef _WIN32
69 std::string normalized(fname);
70 std::replace(normalized.begin(), normalized.end(), '\\', '/');
71 fname = normalized;
72 #endif
73
74 auto absl_pos = fname.rfind("absl/");
75 if (absl_pos != absl::string_view::npos) {
76 fname = fname.substr(absl_pos);
77 }
78 return std::string(fname);
79 }
80
81 class UsageReportingTest : public testing::Test {
82 protected:
UsageReportingTest()83 UsageReportingTest() {
84 // Install default config for the use on this unit test.
85 // Binary may install a custom config before tests are run.
86 absl::FlagsUsageConfig default_config;
87 default_config.normalize_filename = &NormalizeFileName;
88 absl::SetFlagsUsageConfig(default_config);
89 }
90
91 private:
92 absl::FlagSaver flag_saver_;
93 };
94
95 // --------------------------------------------------------------------
96
97 using UsageReportingDeathTest = UsageReportingTest;
98
TEST_F(UsageReportingDeathTest,TestSetProgramUsageMessage)99 TEST_F(UsageReportingDeathTest, TestSetProgramUsageMessage) {
100 EXPECT_EQ(absl::ProgramUsageMessage(), kTestUsageMessage);
101
102 #ifndef _WIN32
103 // TODO(rogeeff): figure out why this does not work on Windows.
104 EXPECT_DEATH_IF_SUPPORTED(
105 absl::SetProgramUsageMessage("custom usage message"),
106 ".*SetProgramUsageMessage\\(\\) called twice.*");
107 #endif
108 }
109
110 // --------------------------------------------------------------------
111
TEST_F(UsageReportingTest,TestFlagHelpHRF_on_flag_01)112 TEST_F(UsageReportingTest, TestFlagHelpHRF_on_flag_01) {
113 const auto* flag = absl::FindCommandLineFlag("usage_reporting_test_flag_01");
114 std::stringstream test_buf;
115
116 flags::FlagHelp(test_buf, *flag, flags::HelpFormat::kHumanReadable);
117 EXPECT_EQ(
118 test_buf.str(),
119 R"( --usage_reporting_test_flag_01 (usage_reporting_test_flag_01 help message);
120 default: 101;
121 )");
122 }
123
TEST_F(UsageReportingTest,TestFlagHelpHRF_on_flag_02)124 TEST_F(UsageReportingTest, TestFlagHelpHRF_on_flag_02) {
125 const auto* flag = absl::FindCommandLineFlag("usage_reporting_test_flag_02");
126 std::stringstream test_buf;
127
128 flags::FlagHelp(test_buf, *flag, flags::HelpFormat::kHumanReadable);
129 EXPECT_EQ(
130 test_buf.str(),
131 R"( --usage_reporting_test_flag_02 (usage_reporting_test_flag_02 help message);
132 default: false;
133 )");
134 }
135
TEST_F(UsageReportingTest,TestFlagHelpHRF_on_flag_03)136 TEST_F(UsageReportingTest, TestFlagHelpHRF_on_flag_03) {
137 const auto* flag = absl::FindCommandLineFlag("usage_reporting_test_flag_03");
138 std::stringstream test_buf;
139
140 flags::FlagHelp(test_buf, *flag, flags::HelpFormat::kHumanReadable);
141 EXPECT_EQ(
142 test_buf.str(),
143 R"( --usage_reporting_test_flag_03 (usage_reporting_test_flag_03 help message);
144 default: 1.03;
145 )");
146 }
147
TEST_F(UsageReportingTest,TestFlagHelpHRF_on_flag_04)148 TEST_F(UsageReportingTest, TestFlagHelpHRF_on_flag_04) {
149 const auto* flag = absl::FindCommandLineFlag("usage_reporting_test_flag_04");
150 std::stringstream test_buf;
151
152 flags::FlagHelp(test_buf, *flag, flags::HelpFormat::kHumanReadable);
153 EXPECT_EQ(
154 test_buf.str(),
155 R"( --usage_reporting_test_flag_04 (usage_reporting_test_flag_04 help message);
156 default: 1000000000000004;
157 )");
158 }
159
TEST_F(UsageReportingTest,TestFlagHelpHRF_on_flag_05)160 TEST_F(UsageReportingTest, TestFlagHelpHRF_on_flag_05) {
161 const auto* flag = absl::FindCommandLineFlag("usage_reporting_test_flag_05");
162 std::stringstream test_buf;
163
164 flags::FlagHelp(test_buf, *flag, flags::HelpFormat::kHumanReadable);
165 EXPECT_EQ(
166 test_buf.str(),
167 R"( --usage_reporting_test_flag_05 (usage_reporting_test_flag_05 help message);
168 default: UDT{};
169 )");
170 }
171
172 // --------------------------------------------------------------------
173
TEST_F(UsageReportingTest,TestFlagsHelpHRF)174 TEST_F(UsageReportingTest, TestFlagsHelpHRF) {
175 std::string usage_test_flags_out =
176 R"(usage_test: Custom usage message
177
178 Flags from absl/flags/internal/usage_test.cc:
179 --usage_reporting_test_flag_01 (usage_reporting_test_flag_01 help message);
180 default: 101;
181 --usage_reporting_test_flag_02 (usage_reporting_test_flag_02 help message);
182 default: false;
183 --usage_reporting_test_flag_03 (usage_reporting_test_flag_03 help message);
184 default: 1.03;
185 --usage_reporting_test_flag_04 (usage_reporting_test_flag_04 help message);
186 default: 1000000000000004;
187 --usage_reporting_test_flag_05 (usage_reporting_test_flag_05 help message);
188 default: UDT{};
189 --usage_reporting_test_flag_06 (usage_reporting_test_flag_06 help message.
190
191 Some more help.
192 Even more long long long long long long long long long long long long help
193 message.); default: "";
194 )";
195
196 std::stringstream test_buf_01;
197 flags::FlagsHelp(test_buf_01, "usage_test.cc",
198 flags::HelpFormat::kHumanReadable, kTestUsageMessage);
199 EXPECT_EQ(test_buf_01.str(), usage_test_flags_out);
200
201 std::stringstream test_buf_02;
202 flags::FlagsHelp(test_buf_02, "flags/internal/usage_test.cc",
203 flags::HelpFormat::kHumanReadable, kTestUsageMessage);
204 EXPECT_EQ(test_buf_02.str(), usage_test_flags_out);
205
206 std::stringstream test_buf_03;
207 flags::FlagsHelp(test_buf_03, "usage_test", flags::HelpFormat::kHumanReadable,
208 kTestUsageMessage);
209 EXPECT_EQ(test_buf_03.str(), usage_test_flags_out);
210
211 std::stringstream test_buf_04;
212 flags::FlagsHelp(test_buf_04, "flags/invalid_file_name.cc",
213 flags::HelpFormat::kHumanReadable, kTestUsageMessage);
214 EXPECT_EQ(test_buf_04.str(),
215 R"(usage_test: Custom usage message
216
217 No modules matched: use -helpfull
218 )");
219
220 std::stringstream test_buf_05;
221 flags::FlagsHelp(test_buf_05, "", flags::HelpFormat::kHumanReadable,
222 kTestUsageMessage);
223 std::string test_out = test_buf_05.str();
224 absl::string_view test_out_str(test_out);
225 EXPECT_TRUE(
226 absl::StartsWith(test_out_str, "usage_test: Custom usage message"));
227 EXPECT_TRUE(absl::StrContains(
228 test_out_str, "Flags from absl/flags/internal/usage_test.cc:"));
229 EXPECT_TRUE(absl::StrContains(test_out_str,
230 "Flags from absl/flags/internal/usage.cc:"));
231 EXPECT_TRUE(
232 absl::StrContains(test_out_str, "-usage_reporting_test_flag_01 "));
233 EXPECT_TRUE(absl::StrContains(test_out_str, "-help (show help"))
234 << test_out_str;
235 }
236
237 // --------------------------------------------------------------------
238
TEST_F(UsageReportingTest,TestNoUsageFlags)239 TEST_F(UsageReportingTest, TestNoUsageFlags) {
240 std::stringstream test_buf;
241 EXPECT_EQ(flags::HandleUsageFlags(test_buf, kTestUsageMessage), -1);
242 }
243
244 // --------------------------------------------------------------------
245
TEST_F(UsageReportingTest,TestUsageFlag_helpshort)246 TEST_F(UsageReportingTest, TestUsageFlag_helpshort) {
247 absl::SetFlag(&FLAGS_helpshort, true);
248
249 std::stringstream test_buf;
250 EXPECT_EQ(flags::HandleUsageFlags(test_buf, kTestUsageMessage), 1);
251 EXPECT_EQ(test_buf.str(),
252 R"(usage_test: Custom usage message
253
254 Flags from absl/flags/internal/usage_test.cc:
255 --usage_reporting_test_flag_01 (usage_reporting_test_flag_01 help message);
256 default: 101;
257 --usage_reporting_test_flag_02 (usage_reporting_test_flag_02 help message);
258 default: false;
259 --usage_reporting_test_flag_03 (usage_reporting_test_flag_03 help message);
260 default: 1.03;
261 --usage_reporting_test_flag_04 (usage_reporting_test_flag_04 help message);
262 default: 1000000000000004;
263 --usage_reporting_test_flag_05 (usage_reporting_test_flag_05 help message);
264 default: UDT{};
265 --usage_reporting_test_flag_06 (usage_reporting_test_flag_06 help message.
266
267 Some more help.
268 Even more long long long long long long long long long long long long help
269 message.); default: "";
270 )");
271 }
272
273 // --------------------------------------------------------------------
274
TEST_F(UsageReportingTest,TestUsageFlag_help)275 TEST_F(UsageReportingTest, TestUsageFlag_help) {
276 absl::SetFlag(&FLAGS_help, true);
277
278 std::stringstream test_buf;
279 EXPECT_EQ(flags::HandleUsageFlags(test_buf, kTestUsageMessage), 1);
280 EXPECT_EQ(test_buf.str(),
281 R"(usage_test: Custom usage message
282
283 Flags from absl/flags/internal/usage_test.cc:
284 --usage_reporting_test_flag_01 (usage_reporting_test_flag_01 help message);
285 default: 101;
286 --usage_reporting_test_flag_02 (usage_reporting_test_flag_02 help message);
287 default: false;
288 --usage_reporting_test_flag_03 (usage_reporting_test_flag_03 help message);
289 default: 1.03;
290 --usage_reporting_test_flag_04 (usage_reporting_test_flag_04 help message);
291 default: 1000000000000004;
292 --usage_reporting_test_flag_05 (usage_reporting_test_flag_05 help message);
293 default: UDT{};
294 --usage_reporting_test_flag_06 (usage_reporting_test_flag_06 help message.
295
296 Some more help.
297 Even more long long long long long long long long long long long long help
298 message.); default: "";
299
300 Try --helpfull to get a list of all flags.
301 )");
302 }
303
304 // --------------------------------------------------------------------
305
TEST_F(UsageReportingTest,TestUsageFlag_helppackage)306 TEST_F(UsageReportingTest, TestUsageFlag_helppackage) {
307 absl::SetFlag(&FLAGS_helppackage, true);
308
309 std::stringstream test_buf;
310 EXPECT_EQ(flags::HandleUsageFlags(test_buf, kTestUsageMessage), 1);
311 EXPECT_EQ(test_buf.str(),
312 R"(usage_test: Custom usage message
313
314 Flags from absl/flags/internal/usage_test.cc:
315 --usage_reporting_test_flag_01 (usage_reporting_test_flag_01 help message);
316 default: 101;
317 --usage_reporting_test_flag_02 (usage_reporting_test_flag_02 help message);
318 default: false;
319 --usage_reporting_test_flag_03 (usage_reporting_test_flag_03 help message);
320 default: 1.03;
321 --usage_reporting_test_flag_04 (usage_reporting_test_flag_04 help message);
322 default: 1000000000000004;
323 --usage_reporting_test_flag_05 (usage_reporting_test_flag_05 help message);
324 default: UDT{};
325 --usage_reporting_test_flag_06 (usage_reporting_test_flag_06 help message.
326
327 Some more help.
328 Even more long long long long long long long long long long long long help
329 message.); default: "";
330
331 Try --helpfull to get a list of all flags.
332 )");
333 }
334
335 // --------------------------------------------------------------------
336
TEST_F(UsageReportingTest,TestUsageFlag_version)337 TEST_F(UsageReportingTest, TestUsageFlag_version) {
338 absl::SetFlag(&FLAGS_version, true);
339
340 std::stringstream test_buf;
341 EXPECT_EQ(flags::HandleUsageFlags(test_buf, kTestUsageMessage), 0);
342 #ifndef NDEBUG
343 EXPECT_EQ(test_buf.str(), "usage_test\nDebug build (NDEBUG not #defined)\n");
344 #else
345 EXPECT_EQ(test_buf.str(), "usage_test\n");
346 #endif
347 }
348
349 // --------------------------------------------------------------------
350
TEST_F(UsageReportingTest,TestUsageFlag_only_check_args)351 TEST_F(UsageReportingTest, TestUsageFlag_only_check_args) {
352 absl::SetFlag(&FLAGS_only_check_args, true);
353
354 std::stringstream test_buf;
355 EXPECT_EQ(flags::HandleUsageFlags(test_buf, kTestUsageMessage), 0);
356 EXPECT_EQ(test_buf.str(), "");
357 }
358
359 // --------------------------------------------------------------------
360
TEST_F(UsageReportingTest,TestUsageFlag_helpon)361 TEST_F(UsageReportingTest, TestUsageFlag_helpon) {
362 absl::SetFlag(&FLAGS_helpon, "bla-bla");
363
364 std::stringstream test_buf_01;
365 EXPECT_EQ(flags::HandleUsageFlags(test_buf_01, kTestUsageMessage), 1);
366 EXPECT_EQ(test_buf_01.str(),
367 R"(usage_test: Custom usage message
368
369 No modules matched: use -helpfull
370 )");
371
372 absl::SetFlag(&FLAGS_helpon, "usage_test");
373
374 std::stringstream test_buf_02;
375 EXPECT_EQ(flags::HandleUsageFlags(test_buf_02, kTestUsageMessage), 1);
376 EXPECT_EQ(test_buf_02.str(),
377 R"(usage_test: Custom usage message
378
379 Flags from absl/flags/internal/usage_test.cc:
380 --usage_reporting_test_flag_01 (usage_reporting_test_flag_01 help message);
381 default: 101;
382 --usage_reporting_test_flag_02 (usage_reporting_test_flag_02 help message);
383 default: false;
384 --usage_reporting_test_flag_03 (usage_reporting_test_flag_03 help message);
385 default: 1.03;
386 --usage_reporting_test_flag_04 (usage_reporting_test_flag_04 help message);
387 default: 1000000000000004;
388 --usage_reporting_test_flag_05 (usage_reporting_test_flag_05 help message);
389 default: UDT{};
390 --usage_reporting_test_flag_06 (usage_reporting_test_flag_06 help message.
391
392 Some more help.
393 Even more long long long long long long long long long long long long help
394 message.); default: "";
395 )");
396 }
397
398 // --------------------------------------------------------------------
399
400 } // namespace
401
main(int argc,char * argv[])402 int main(int argc, char* argv[]) {
403 (void)absl::GetFlag(FLAGS_undefok); // Force linking of parse.cc
404 flags::SetProgramInvocationName("usage_test");
405 absl::SetProgramUsageMessage(kTestUsageMessage);
406 ::testing::InitGoogleTest(&argc, argv);
407
408 return RUN_ALL_TESTS();
409 }
410