1 /*
2 * Copyright (C) 2017 The Android Open Source Project
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 * http://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
17 #include <errno.h>
18 #include <stdio.h>
19 #include <string.h>
20 #include <unistd.h>
21
22 #include <string>
23 #include <vector>
24
25 #include <android-base/file.h>
26 #include <android-base/test_utils.h>
27 #include <gmock/gmock.h>
28 #include <gtest/gtest.h>
29
30 #include "Options.h"
31
32 using ::testing::ElementsAre;
33 using ::testing::StrEq;
34
35 namespace android {
36 namespace gtest_extras {
37
38 class OptionsTest : public ::testing::Test {
39 protected:
ClearChildArgs()40 void ClearChildArgs() {
41 for (auto arg : child_args_) {
42 free(arg);
43 }
44 child_args_.clear();
45 }
46
TearDown()47 void TearDown() { ClearChildArgs(); }
48
49 void CheckIncompatible(const std::string arg);
50 void CheckIncompatibleFromEnv(const std::string env_var);
51
52 std::vector<char*> child_args_;
53 };
54
TEST_F(OptionsTest,unknown_arg)55 TEST_F(OptionsTest, unknown_arg) {
56 CapturedStdout capture;
57 std::vector<const char*> cur_args{"ignore", "--unknown_arg"};
58 Options options;
59 bool parsed = options.Process(cur_args, &child_args_);
60 capture.Stop();
61 ASSERT_FALSE(parsed) << "Process did not fail properly.";
62 EXPECT_EQ("Unknown argument: --unknown_arg\n", capture.str());
63 }
64
TEST_F(OptionsTest,unknown_arg_single_dash)65 TEST_F(OptionsTest, unknown_arg_single_dash) {
66 CapturedStdout capture;
67 std::vector<const char*> cur_args{"ignore", "-unknown_arg"};
68 Options options;
69 bool parsed = options.Process(cur_args, &child_args_);
70 capture.Stop();
71 ASSERT_FALSE(parsed) << "Process did not fail properly.";
72 EXPECT_EQ("Unknown argument: -unknown_arg\n", capture.str());
73 }
74
TEST_F(OptionsTest,extra_arg)75 TEST_F(OptionsTest, extra_arg) {
76 CapturedStdout capture;
77 std::vector<const char*> cur_args{"ignore", "extra"};
78 Options options;
79 bool parsed = options.Process(cur_args, &child_args_);
80 capture.Stop();
81 ASSERT_FALSE(parsed) << "Process did not fail properly.";
82 EXPECT_EQ("Unexpected argument 'extra'\n", capture.str());
83 }
84
TEST_F(OptionsTest,check_defaults)85 TEST_F(OptionsTest, check_defaults) {
86 std::vector<const char*> cur_args{"ignore"};
87 Options options;
88 ASSERT_TRUE(options.Process(cur_args, &child_args_));
89 EXPECT_LT(0U, options.job_count());
90 EXPECT_EQ(90000ULL, options.deadline_threshold_ms());
91 EXPECT_EQ(2000ULL, options.slow_threshold_ms());
92 EXPECT_EQ(0ULL, options.shard_index());
93 EXPECT_EQ(0ULL, options.total_shards());
94 EXPECT_EQ("auto", options.color());
95 EXPECT_EQ("", options.xml_file());
96 EXPECT_EQ("", options.filter());
97 EXPECT_EQ(1, options.num_iterations());
98 EXPECT_TRUE(options.print_time());
99 EXPECT_FALSE(options.allow_disabled_tests());
100 EXPECT_FALSE(options.list_tests());
101 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
102 }
103
TEST_F(OptionsTest,gtest_list_tests)104 TEST_F(OptionsTest, gtest_list_tests) {
105 std::vector<const char*> cur_args{"ignore", "--gtest_list_tests"};
106 Options options;
107 ASSERT_TRUE(options.Process(cur_args, &child_args_));
108 EXPECT_TRUE(options.list_tests());
109 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
110 }
111
TEST_F(OptionsTest,gtest_list_tests_error_argument)112 TEST_F(OptionsTest, gtest_list_tests_error_argument) {
113 CapturedStdout capture;
114 std::vector<const char*> cur_args{"ignore", "--gtest_list_tests=nothing"};
115 Options options;
116 bool parsed = options.Process(cur_args, &child_args_);
117 capture.Stop();
118 ASSERT_FALSE(parsed) << "Process did not fail properly.";
119 EXPECT_EQ("--gtest_list_tests does not take an argument.\n", capture.str());
120 }
121
TEST_F(OptionsTest,job_count_single_arg)122 TEST_F(OptionsTest, job_count_single_arg) {
123 std::vector<const char*> cur_args{"ignore", "-j11"};
124 Options options;
125 ASSERT_TRUE(options.Process(cur_args, &child_args_));
126 EXPECT_EQ(11U, options.job_count());
127 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
128 }
129
TEST_F(OptionsTest,job_count_second_arg)130 TEST_F(OptionsTest, job_count_second_arg) {
131 std::vector<const char*> cur_args{"ignore", "-j", "23"};
132 Options options;
133 ASSERT_TRUE(options.Process(cur_args, &child_args_));
134 EXPECT_EQ(23U, options.job_count());
135 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
136 }
137
TEST_F(OptionsTest,job_count_error_single_arg)138 TEST_F(OptionsTest, job_count_error_single_arg) {
139 CapturedStdout capture;
140 std::vector<const char*> cur_args{"ignore", "-j0bad"};
141 Options options;
142 bool parsed = options.Process(cur_args, &child_args_);
143 capture.Stop();
144 ASSERT_FALSE(parsed) << "Process did not fail properly.";
145 EXPECT_EQ("-j value is not formatted as a numeric value (0bad)\n", capture.str());
146 }
147
TEST_F(OptionsTest,job_count_error_second_arg)148 TEST_F(OptionsTest, job_count_error_second_arg) {
149 CapturedStdout capture;
150 std::vector<const char*> cur_args{"ignore", "-j", "34b"};
151 Options options;
152 bool parsed = options.Process(cur_args, &child_args_);
153 capture.Stop();
154 ASSERT_FALSE(parsed) << "Process did not fail properly.";
155 EXPECT_EQ("-j value is not formatted as a numeric value (34b)\n", capture.str());
156 }
157
TEST_F(OptionsTest,job_count_error_no_arg)158 TEST_F(OptionsTest, job_count_error_no_arg) {
159 CapturedStdout capture;
160 std::vector<const char*> cur_args{"ignore", "-j"};
161 Options options;
162 bool parsed = options.Process(cur_args, &child_args_);
163 capture.Stop();
164 ASSERT_FALSE(parsed) << "Process did not fail properly.";
165 EXPECT_EQ("-j requires an argument.\n", capture.str());
166 }
167
TEST_F(OptionsTest,deadline_threshold_ms)168 TEST_F(OptionsTest, deadline_threshold_ms) {
169 std::vector<const char*> cur_args{"ignore", "--deadline_threshold_ms=3200"};
170 Options options;
171 ASSERT_TRUE(options.Process(cur_args, &child_args_));
172 EXPECT_EQ(3200ULL, options.deadline_threshold_ms());
173 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
174 }
175
TEST_F(OptionsTest,deadline_threshold_ms_error_no_value)176 TEST_F(OptionsTest, deadline_threshold_ms_error_no_value) {
177 CapturedStdout capture;
178 std::vector<const char*> cur_args{"ignore", "--deadline_threshold_ms"};
179 Options options;
180 bool parsed = options.Process(cur_args, &child_args_);
181 capture.Stop();
182 ASSERT_FALSE(parsed) << "Process did not fail properly.";
183 EXPECT_EQ("--deadline_threshold_ms requires an argument.\n", capture.str());
184 }
185
TEST_F(OptionsTest,deadline_threshold_ms_error_not_a_number)186 TEST_F(OptionsTest, deadline_threshold_ms_error_not_a_number) {
187 CapturedStdout capture;
188 std::vector<const char*> cur_args{"ignore", "--deadline_threshold_ms=bad"};
189 Options options;
190 bool parsed = options.Process(cur_args, &child_args_);
191 capture.Stop();
192 ASSERT_FALSE(parsed) << "Process did not fail properly.";
193 EXPECT_EQ("--deadline_threshold_ms value is not formatted as a numeric value (bad)\n",
194 capture.str());
195 }
196
TEST_F(OptionsTest,deadline_threshold_ms_error_illegal_value)197 TEST_F(OptionsTest, deadline_threshold_ms_error_illegal_value) {
198 CapturedStdout capture;
199 std::vector<const char*> cur_args{"ignore", "--deadline_threshold_ms=0"};
200 Options options;
201 bool parsed = options.Process(cur_args, &child_args_);
202 capture.Stop();
203 ASSERT_FALSE(parsed) << "Process did not fail properly.";
204 EXPECT_EQ("--deadline_threshold_ms requires a number greater than zero.\n", capture.str());
205 }
206
TEST_F(OptionsTest,slow_threshold_ms)207 TEST_F(OptionsTest, slow_threshold_ms) {
208 std::vector<const char*> cur_args{"ignore", "--slow_threshold_ms=4580"};
209 Options options;
210 ASSERT_TRUE(options.Process(cur_args, &child_args_));
211 EXPECT_EQ(4580ULL, options.slow_threshold_ms());
212 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
213 }
214
TEST_F(OptionsTest,slow_threshold_ms_error_no_value)215 TEST_F(OptionsTest, slow_threshold_ms_error_no_value) {
216 CapturedStdout capture;
217 std::vector<const char*> cur_args{"ignore", "--slow_threshold_ms"};
218 Options options;
219 bool parsed = options.Process(cur_args, &child_args_);
220 capture.Stop();
221 ASSERT_FALSE(parsed) << "Process did not fail properly.";
222 EXPECT_EQ("--slow_threshold_ms requires an argument.\n", capture.str());
223 }
224
TEST_F(OptionsTest,slow_threshold_ms_error_not_a_number)225 TEST_F(OptionsTest, slow_threshold_ms_error_not_a_number) {
226 CapturedStdout capture;
227 Options options;
228 std::vector<const char*> cur_args{"ignore", "--slow_threshold_ms=not"};
229 bool parsed = options.Process(cur_args, &child_args_);
230 capture.Stop();
231 ASSERT_FALSE(parsed) << "Process did not fail properly.";
232 EXPECT_EQ("--slow_threshold_ms value is not formatted as a numeric value (not)\n", capture.str());
233 }
234
TEST_F(OptionsTest,slow_threshold_ms_error_illegal_value)235 TEST_F(OptionsTest, slow_threshold_ms_error_illegal_value) {
236 CapturedStdout capture;
237 std::vector<const char*> cur_args{"ignore", "--slow_threshold_ms=0"};
238 Options options;
239 bool parsed = options.Process(cur_args, &child_args_);
240 capture.Stop();
241 ASSERT_FALSE(parsed) << "Process did not fail properly.";
242 EXPECT_EQ("--slow_threshold_ms requires a number greater than zero.\n", capture.str());
243 }
244
TEST_F(OptionsTest,shard_index)245 TEST_F(OptionsTest, shard_index) {
246 ASSERT_NE(-1, setenv("GTEST_SHARD_INDEX", "100", 1));
247
248 std::vector<const char*> cur_args{"ignore"};
249 Options options;
250 ASSERT_TRUE(options.Process(cur_args, &child_args_));
251 EXPECT_EQ(100ULL, options.shard_index());
252 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
253
254 ClearChildArgs();
255 ASSERT_NE(-1, setenv("GTEST_SHARD_INDEX", "0", 1));
256 ASSERT_TRUE(options.Process(cur_args, &child_args_));
257 EXPECT_EQ(0ULL, options.shard_index());
258 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
259
260 ASSERT_NE(-1, unsetenv("GTEST_SHARD_INDEX"));
261 }
262
TEST_F(OptionsTest,shard_index_error_no_value)263 TEST_F(OptionsTest, shard_index_error_no_value) {
264 ASSERT_NE(-1, setenv("GTEST_SHARD_INDEX", "", 1));
265
266 CapturedStdout capture;
267 std::vector<const char*> cur_args{"ignore"};
268 Options options;
269 bool parsed = options.Process(cur_args, &child_args_);
270 capture.Stop();
271 ASSERT_FALSE(parsed) << "Process did not fail properly.";
272 EXPECT_EQ("env[GTEST_SHARD_INDEX] requires an argument.\n", capture.str());
273
274 ASSERT_NE(-1, unsetenv("GTEST_SHARD_INDEX"));
275 }
276
TEST_F(OptionsTest,shard_index_error_not_a_number)277 TEST_F(OptionsTest, shard_index_error_not_a_number) {
278 ASSERT_NE(-1, setenv("GTEST_SHARD_INDEX", "bad", 1));
279
280 CapturedStdout capture;
281 std::vector<const char*> cur_args{"ignore"};
282 Options options;
283 bool parsed = options.Process(cur_args, &child_args_);
284 capture.Stop();
285 ASSERT_FALSE(parsed) << "Process did not fail properly.";
286 EXPECT_EQ("env[GTEST_SHARD_INDEX] value is not formatted as a numeric value (bad)\n",
287 capture.str());
288
289 ASSERT_NE(-1, unsetenv("GTEST_SHARD_INDEX"));
290 }
291
TEST_F(OptionsTest,shard_index_error_not_from_env)292 TEST_F(OptionsTest, shard_index_error_not_from_env) {
293 CapturedStdout capture;
294 std::vector<const char*> cur_args{"ignore", "--gtest_shard_index=100"};
295 Options options;
296 bool parsed = options.Process(cur_args, &child_args_);
297 capture.Stop();
298 ASSERT_FALSE(parsed) << "Process did not fail properly.";
299 EXPECT_EQ("--gtest_shard_index is only supported as an environment variable.\n", capture.str());
300 }
301
TEST_F(OptionsTest,total_shards)302 TEST_F(OptionsTest, total_shards) {
303 ASSERT_NE(-1, setenv("GTEST_TOTAL_SHARDS", "500", 1));
304
305 std::vector<const char*> cur_args{"ignore"};
306 Options options;
307 ASSERT_TRUE(options.Process(cur_args, &child_args_));
308 EXPECT_EQ(500ULL, options.total_shards());
309 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
310
311 ClearChildArgs();
312 ASSERT_NE(-1, setenv("GTEST_TOTAL_SHARDS", "0", 1));
313 ASSERT_TRUE(options.Process(cur_args, &child_args_));
314 EXPECT_EQ(0ULL, options.total_shards());
315 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
316
317 ASSERT_NE(-1, unsetenv("GTEST_TOTAL_SHARDS"));
318 }
319
TEST_F(OptionsTest,total_shards_error_no_value)320 TEST_F(OptionsTest, total_shards_error_no_value) {
321 ASSERT_NE(-1, setenv("GTEST_TOTAL_SHARDS", "", 1));
322
323 CapturedStdout capture;
324 std::vector<const char*> cur_args{"ignore"};
325 Options options;
326 bool parsed = options.Process(cur_args, &child_args_);
327 capture.Stop();
328 ASSERT_FALSE(parsed) << "Process did not fail properly.";
329 EXPECT_EQ("env[GTEST_TOTAL_SHARDS] requires an argument.\n", capture.str());
330
331 ASSERT_NE(-1, unsetenv("GTEST_TOTAL_SHARDS"));
332 }
333
TEST_F(OptionsTest,total_shards_error_not_a_number)334 TEST_F(OptionsTest, total_shards_error_not_a_number) {
335 ASSERT_NE(-1, setenv("GTEST_TOTAL_SHARDS", "bad", 1));
336
337 CapturedStdout capture;
338 std::vector<const char*> cur_args{"ignore"};
339 Options options;
340 bool parsed = options.Process(cur_args, &child_args_);
341 capture.Stop();
342 ASSERT_FALSE(parsed) << "Process did not fail properly.";
343 EXPECT_EQ("env[GTEST_TOTAL_SHARDS] value is not formatted as a numeric value (bad)\n",
344 capture.str());
345
346 ASSERT_NE(-1, unsetenv("GTEST_TOTAL_SHARDS"));
347 }
348
TEST_F(OptionsTest,total_shards_error_not_from_env)349 TEST_F(OptionsTest, total_shards_error_not_from_env) {
350 CapturedStdout capture;
351 std::vector<const char*> cur_args{"ignore", "--gtest_total_shards=100"};
352 Options options;
353 bool parsed = options.Process(cur_args, &child_args_);
354 capture.Stop();
355 ASSERT_FALSE(parsed) << "Process did not fail properly.";
356 EXPECT_EQ("--gtest_total_shards is only supported as an environment variable.\n", capture.str());
357 }
358
TEST_F(OptionsTest,gtest_color)359 TEST_F(OptionsTest, gtest_color) {
360 std::vector<const char*> cur_args{"ignore", "--gtest_color=yes"};
361 Options options;
362 ASSERT_TRUE(options.Process(cur_args, &child_args_));
363 EXPECT_EQ("yes", options.color());
364 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore"), StrEq("--gtest_color=yes")));
365 }
366
TEST_F(OptionsTest,gtest_color_error_no_value)367 TEST_F(OptionsTest, gtest_color_error_no_value) {
368 CapturedStdout capture;
369 std::vector<const char*> cur_args{"ignore", "--gtest_color="};
370 Options options;
371 bool parsed = options.Process(cur_args, &child_args_);
372 capture.Stop();
373 ASSERT_FALSE(parsed) << "Process did not fail properly.";
374 EXPECT_EQ("--gtest_color requires an argument.\n", capture.str());
375 }
376
TEST_F(OptionsTest,gtest_filter)377 TEST_F(OptionsTest, gtest_filter) {
378 std::vector<const char*> cur_args{"ignore", "--gtest_filter=filter"};
379 Options options;
380 ASSERT_TRUE(options.Process(cur_args, &child_args_));
381 EXPECT_EQ("filter", options.filter());
382 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
383 }
384
TEST_F(OptionsTest,gtest_filter_error_no_value)385 TEST_F(OptionsTest, gtest_filter_error_no_value) {
386 CapturedStdout capture;
387 std::vector<const char*> cur_args{"ignore", "--gtest_filter"};
388 Options options;
389 bool parsed = options.Process(cur_args, &child_args_);
390 capture.Stop();
391 ASSERT_FALSE(parsed) << "Process did not fail properly.";
392 EXPECT_EQ("--gtest_filter requires an argument.\n", capture.str());
393 }
394
TEST_F(OptionsTest,gtest_also_run_disabled_tests)395 TEST_F(OptionsTest, gtest_also_run_disabled_tests) {
396 std::vector<const char*> cur_args{"ignore", "--gtest_also_run_disabled_tests"};
397 Options options;
398 ASSERT_TRUE(options.Process(cur_args, &child_args_));
399 EXPECT_TRUE(options.allow_disabled_tests());
400 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore"), StrEq("--gtest_also_run_disabled_tests")));
401 }
402
TEST_F(OptionsTest,gtest_also_run_disabled_tests_error_argument)403 TEST_F(OptionsTest, gtest_also_run_disabled_tests_error_argument) {
404 CapturedStdout capture;
405 std::vector<const char*> cur_args{"ignore", "--gtest_also_run_disabled_tests=nothing"};
406 Options options;
407 bool parsed = options.Process(cur_args, &child_args_);
408 capture.Stop();
409 ASSERT_FALSE(parsed) << "Process did not fail properly.";
410 EXPECT_EQ("--gtest_also_run_disabled_tests does not take an argument.\n", capture.str());
411 }
412
TEST_F(OptionsTest,gtest_repeat)413 TEST_F(OptionsTest, gtest_repeat) {
414 std::vector<const char*> cur_args{"ignore", "--gtest_repeat=10"};
415 Options options;
416 ASSERT_TRUE(options.Process(cur_args, &child_args_));
417 EXPECT_EQ(10, options.num_iterations());
418 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
419
420 ClearChildArgs();
421 cur_args = std::vector<const char*>{"ignore", "--gtest_repeat=-1"};
422 ASSERT_TRUE(options.Process(cur_args, &child_args_));
423 EXPECT_EQ(-1, options.num_iterations());
424 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
425 }
426
TEST_F(OptionsTest,gtest_repeat_error_no_value)427 TEST_F(OptionsTest, gtest_repeat_error_no_value) {
428 CapturedStdout capture;
429 std::vector<const char*> cur_args{"ignore", "--gtest_repeat"};
430 Options options;
431 bool parsed = options.Process(cur_args, &child_args_);
432 capture.Stop();
433 ASSERT_FALSE(parsed) << "Process did not fail properly.";
434 EXPECT_EQ("--gtest_repeat requires an argument.\n", capture.str());
435 }
436
TEST_F(OptionsTest,gtest_repeat_error_overflow)437 TEST_F(OptionsTest, gtest_repeat_error_overflow) {
438 CapturedStdout capture;
439 std::vector<const char*> cur_args{"ignore", "--gtest_repeat=2147483747"};
440 Options options;
441 bool parsed = options.Process(cur_args, &child_args_);
442 capture.Stop();
443 ASSERT_FALSE(parsed) << "Process did not fail properly.";
444 EXPECT_EQ("--gtest_repeat value overflows (2147483747)\n", capture.str());
445
446 ClearChildArgs();
447 capture.Reset();
448 capture.Start();
449 cur_args = std::vector<const char*>{"ignore", "--gtest_repeat=-2147483747"};
450 parsed = options.Process(cur_args, &child_args_);
451 capture.Stop();
452 ASSERT_FALSE(parsed) << "Process did not fail properly.";
453 EXPECT_EQ("--gtest_repeat value overflows (-2147483747)\n", capture.str());
454 }
455
TEST_F(OptionsTest,gtest_print_time)456 TEST_F(OptionsTest, gtest_print_time) {
457 std::vector<const char*> cur_args{"ignore", "--gtest_print_time"};
458 Options options;
459 ASSERT_TRUE(options.Process(cur_args, &child_args_));
460 EXPECT_TRUE(options.print_time());
461 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
462
463 ClearChildArgs();
464 cur_args = std::vector<const char*>{"ignore", "--gtest_print_time=0"};
465 ASSERT_TRUE(options.Process(cur_args, &child_args_));
466 EXPECT_FALSE(options.print_time());
467 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
468
469 ClearChildArgs();
470 cur_args = std::vector<const char*>{"ignore", "--gtest_print_time=1"};
471 ASSERT_TRUE(options.Process(cur_args, &child_args_));
472 EXPECT_TRUE(options.print_time());
473 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
474 }
475
TEST_F(OptionsTest,gtest_output)476 TEST_F(OptionsTest, gtest_output) {
477 std::vector<const char*> cur_args{"ignore", "--gtest_output=xml:/file.xml"};
478 Options options;
479 ASSERT_TRUE(options.Process(cur_args, &child_args_));
480 EXPECT_EQ("/file.xml", options.xml_file());
481 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
482
483 ClearChildArgs();
484 cur_args = std::vector<const char*>{"ignore", "--gtest_output=xml:/directory/"};
485 ASSERT_TRUE(options.Process(cur_args, &child_args_));
486 EXPECT_EQ("/directory/test_details.xml", options.xml_file());
487 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
488
489 ClearChildArgs();
490 cur_args = std::vector<const char*>{"ignore", "--gtest_output=xml:cwd.xml"};
491 ASSERT_TRUE(options.Process(cur_args, &child_args_));
492 char* cwd = getcwd(nullptr, 0);
493 std::string expected_file(cwd);
494 expected_file += "/cwd.xml";
495 free(cwd);
496 EXPECT_EQ(expected_file, options.xml_file());
497 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
498 }
499
TEST_F(OptionsTest,gtest_output_error_no_value)500 TEST_F(OptionsTest, gtest_output_error_no_value) {
501 CapturedStdout capture;
502 std::vector<const char*> cur_args{"ignore", "--gtest_output"};
503 Options options;
504 bool parsed = options.Process(cur_args, &child_args_);
505 capture.Stop();
506 ASSERT_FALSE(parsed) << "Process did not fail properly.";
507 EXPECT_EQ("--gtest_output requires an argument.\n", capture.str());
508 }
509
TEST_F(OptionsTest,gtest_output_error_no_xml)510 TEST_F(OptionsTest, gtest_output_error_no_xml) {
511 CapturedStdout capture;
512 std::vector<const char*> cur_args{"ignore", "--gtest_output=xml:"};
513 Options options;
514 bool parsed = options.Process(cur_args, &child_args_);
515 capture.Stop();
516 ASSERT_FALSE(parsed) << "Process did not fail properly.";
517 EXPECT_EQ("--gtest_output requires a file name after xml:\n", capture.str());
518
519 ClearChildArgs();
520 capture.Reset();
521 capture.Start();
522 cur_args = std::vector<const char*>{"ignore", "--gtest_output=not_xml"};
523 parsed = options.Process(cur_args, &child_args_);
524 capture.Stop();
525 ASSERT_FALSE(parsed) << "Process did not fail properly.";
526 EXPECT_EQ("--gtest_output only supports an xml output file.\n", capture.str());
527 }
528
TEST_F(OptionsTest,gtest_death_test_style)529 TEST_F(OptionsTest, gtest_death_test_style) {
530 std::vector<const char*> cur_args{"ignore", "--gtest_death_test_style=something"};
531 Options options;
532 ASSERT_TRUE(options.Process(cur_args, &child_args_));
533 EXPECT_THAT(child_args_,
534 ElementsAre(StrEq("ignore"), StrEq("--gtest_death_test_style=something")));
535 }
536
TEST_F(OptionsTest,gtest_death_test_style_error_no_value)537 TEST_F(OptionsTest, gtest_death_test_style_error_no_value) {
538 CapturedStdout capture;
539 std::vector<const char*> cur_args{"ignore", "--gtest_death_test_style"};
540 Options options;
541 bool parsed = options.Process(cur_args, &child_args_);
542 capture.Stop();
543 ASSERT_FALSE(parsed) << "Process did not fail properly.";
544 EXPECT_EQ("--gtest_death_test_style requires an argument.\n", capture.str());
545 }
546
TEST_F(OptionsTest,gtest_flagfile)547 TEST_F(OptionsTest, gtest_flagfile) {
548 TemporaryFile tf;
549 ASSERT_TRUE(
550 android::base::WriteStringToFile("--gtest_color=no\n"
551 "\n"
552 "--gtest_print_time=0\n"
553 "--gtest_repeat=10\n",
554 tf.path));
555
556 std::string flag("--gtest_flagfile=");
557 flag += tf.path;
558 std::vector<const char*> cur_args{"ignore", flag.c_str()};
559 Options options;
560 ASSERT_TRUE(options.Process(cur_args, &child_args_));
561 EXPECT_EQ("no", options.color());
562 EXPECT_FALSE(options.print_time());
563 EXPECT_EQ(10U, options.num_iterations());
564 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore"), StrEq("--gtest_color=no")));
565 }
566
TEST_F(OptionsTest,gtest_flagfile_no_newline)567 TEST_F(OptionsTest, gtest_flagfile_no_newline) {
568 TemporaryFile tf;
569 ASSERT_TRUE(android::base::WriteStringToFile("--gtest_color=no", tf.path));
570
571 std::string flag("--gtest_flagfile=");
572 flag += tf.path;
573 std::vector<const char*> cur_args{"ignore", flag.c_str()};
574 Options options;
575 ASSERT_TRUE(options.Process(cur_args, &child_args_));
576 EXPECT_EQ("no", options.color());
577 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore"), StrEq("--gtest_color=no")));
578 }
579
TEST_F(OptionsTest,gtest_flagfile_empty_file)580 TEST_F(OptionsTest, gtest_flagfile_empty_file) {
581 TemporaryFile tf;
582
583 std::string flag("--gtest_flagfile=");
584 flag += tf.path;
585 std::vector<const char*> cur_args{"ignore", flag.c_str()};
586 Options options;
587 ASSERT_TRUE(options.Process(cur_args, &child_args_));
588 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
589 }
590
TEST_F(OptionsTest,gtest_flagfile_disallow_j_option)591 TEST_F(OptionsTest, gtest_flagfile_disallow_j_option) {
592 TemporaryFile tf;
593 ASSERT_TRUE(android::base::WriteStringToFile("-j1\n", tf.path));
594
595 CapturedStdout capture;
596 std::string flag("--gtest_flagfile=");
597 flag += tf.path;
598 std::vector<const char*> cur_args{"ignore", flag.c_str()};
599 Options options;
600 bool parsed = options.Process(cur_args, &child_args_);
601 capture.Stop();
602 ASSERT_FALSE(parsed) << "Process did not fail properly.";
603 EXPECT_EQ("Unknown argument: -j1\n", capture.str());
604 }
605
TEST_F(OptionsTest,gtest_flagfile_disallow_gtest_flagfile_option_in_file)606 TEST_F(OptionsTest, gtest_flagfile_disallow_gtest_flagfile_option_in_file) {
607 TemporaryFile tf;
608 ASSERT_TRUE(android::base::WriteStringToFile("--gtest_flagfile=nothing\n", tf.path));
609
610 CapturedStdout capture;
611 std::string flag("--gtest_flagfile=");
612 flag += tf.path;
613 std::vector<const char*> cur_args{"ignore", flag.c_str()};
614 Options options;
615 bool parsed = options.Process(cur_args, &child_args_);
616 capture.Stop();
617 ASSERT_FALSE(parsed) << "Process did not fail properly.";
618 EXPECT_EQ("Argument: --gtest_flagfile=nothing is not allowed in flag file.\n", capture.str());
619 }
620
TEST_F(OptionsTest,gtest_flagfile_does_not_exist)621 TEST_F(OptionsTest, gtest_flagfile_does_not_exist) {
622 CapturedStdout capture;
623 std::vector<const char*> cur_args{"ignore", "--gtest_flagfile=/this/does/not/exist"};
624 Options options;
625 bool parsed = options.Process(cur_args, &child_args_);
626 capture.Stop();
627 ASSERT_FALSE(parsed) << "Process did not fail properly.";
628 EXPECT_EQ("Unable to read data from file /this/does/not/exist\n", capture.str());
629 }
630
CheckIncompatible(const std::string arg)631 void OptionsTest::CheckIncompatible(const std::string arg) {
632 CapturedStdout capture;
633 std::vector<const char*> cur_args{"ignore", arg.c_str()};
634 Options options;
635 bool parsed = options.Process(cur_args, &child_args_);
636 capture.Stop();
637 ASSERT_FALSE(parsed) << "Process did not fail properly for arg " + arg;
638 EXPECT_EQ(arg + " is not compatible with isolation runs.\n", capture.str());
639 }
640
TEST_F(OptionsTest,incompatible)641 TEST_F(OptionsTest, incompatible) {
642 ASSERT_NO_FATAL_FAILURE(CheckIncompatible("--gtest_break_on_failure"));
643 ASSERT_NO_FATAL_FAILURE(CheckIncompatible("--gtest_catch_exceptions"));
644 ASSERT_NO_FATAL_FAILURE(CheckIncompatible("--gtest_random_seed"));
645 ASSERT_NO_FATAL_FAILURE(CheckIncompatible("--gtest_shuffle"));
646 ASSERT_NO_FATAL_FAILURE(CheckIncompatible("--gtest_stream_result_to"));
647 ASSERT_NO_FATAL_FAILURE(CheckIncompatible("--gtest_throw_on_failure"));
648 }
649
TEST_F(OptionsTest,verify_non_env_variables)650 TEST_F(OptionsTest, verify_non_env_variables) {
651 EXPECT_NE(-1, setenv("DEADLINE_THRESHOLD_MS", "VALUE", 1));
652 EXPECT_NE(-1, setenv("SLOW_THRESHOLD_MS", "VALUE", 1));
653 EXPECT_NE(-1, setenv("GTEST_FORMAT", "VALUE", 1));
654 EXPECT_NE(-1, setenv("GTEST_LIST_TESTS", "VALUE", 1));
655
656 std::vector<const char*> cur_args{"ignore"};
657 Options options;
658 EXPECT_TRUE(options.Process(cur_args, &child_args_));
659 EXPECT_LT(0U, options.job_count());
660 EXPECT_EQ(90000ULL, options.deadline_threshold_ms());
661 EXPECT_EQ(2000ULL, options.slow_threshold_ms());
662 EXPECT_EQ("auto", options.color());
663 EXPECT_EQ("", options.xml_file());
664 EXPECT_EQ("", options.filter());
665 EXPECT_EQ(1, options.num_iterations());
666 EXPECT_TRUE(options.print_time());
667 EXPECT_FALSE(options.allow_disabled_tests());
668 EXPECT_FALSE(options.list_tests());
669 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
670
671 EXPECT_NE(-1, unsetenv("DEADLINE_THRESHOLD_MS"));
672 EXPECT_NE(-1, unsetenv("SLOW_THRESHOLD_MS"));
673 EXPECT_NE(-1, unsetenv("GTEST_FORMAT"));
674 EXPECT_NE(-1, unsetenv("GTEST_LIST_TESTS"));
675 }
676
TEST_F(OptionsTest,gtest_filter_from_env)677 TEST_F(OptionsTest, gtest_filter_from_env) {
678 ASSERT_NE(-1, setenv("GTEST_FILTER", "filter_value", 1));
679
680 std::vector<const char*> cur_args{"ignore"};
681 Options options;
682 EXPECT_TRUE(options.Process(cur_args, &child_args_));
683 EXPECT_EQ("filter_value", options.filter());
684 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
685
686 ASSERT_NE(-1, unsetenv("GTEST_FILTER"));
687 }
688
TEST_F(OptionsTest,gtest_filter_error_no_value_from_env)689 TEST_F(OptionsTest, gtest_filter_error_no_value_from_env) {
690 ASSERT_NE(-1, setenv("GTEST_FILTER", "", 1));
691
692 CapturedStdout capture;
693 std::vector<const char*> cur_args{"ignore"};
694 Options options;
695 bool parsed = options.Process(cur_args, &child_args_);
696 capture.Stop();
697 ASSERT_FALSE(parsed) << "Process did not fail properly.";
698 EXPECT_EQ("env[GTEST_FILTER] requires an argument.\n", capture.str());
699
700 ASSERT_NE(-1, unsetenv("GTEST_FILTER"));
701 }
702
TEST_F(OptionsTest,gtest_also_run_disabled_tests_from_env)703 TEST_F(OptionsTest, gtest_also_run_disabled_tests_from_env) {
704 ASSERT_NE(-1, setenv("GTEST_ALSO_RUN_DISABLED_TESTS", "", 1));
705
706 std::vector<const char*> cur_args{"ignore"};
707 Options options;
708 ASSERT_TRUE(options.Process(cur_args, &child_args_));
709 EXPECT_TRUE(options.allow_disabled_tests());
710 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
711
712 ASSERT_NE(-1, unsetenv("GTEST_ALSO_RUN_DISABLED_TESTS"));
713 }
714
TEST_F(OptionsTest,gtest_also_run_disabled_tests_error_argument_from_env)715 TEST_F(OptionsTest, gtest_also_run_disabled_tests_error_argument_from_env) {
716 ASSERT_NE(-1, setenv("GTEST_ALSO_RUN_DISABLED_TESTS", "one", 1));
717
718 CapturedStdout capture;
719 std::vector<const char*> cur_args{"ignore"};
720 Options options;
721 bool parsed = options.Process(cur_args, &child_args_);
722 capture.Stop();
723 ASSERT_FALSE(parsed) << "Process did not fail properly.";
724 EXPECT_EQ("env[GTEST_ALSO_RUN_DISABLED_TESTS] does not take an argument.\n", capture.str());
725
726 ASSERT_NE(-1, unsetenv("GTEST_ALSO_RUN_DISABLED_TESTS"));
727 }
728
TEST_F(OptionsTest,gtest_repeat_from_env)729 TEST_F(OptionsTest, gtest_repeat_from_env) {
730 ASSERT_NE(-1, setenv("GTEST_REPEAT", "34", 1));
731
732 std::vector<const char*> cur_args{"ignore"};
733 Options options;
734 ASSERT_TRUE(options.Process(cur_args, &child_args_));
735 EXPECT_EQ(34, options.num_iterations());
736 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
737
738 ASSERT_NE(-1, unsetenv("GTEST_REPEAT"));
739 }
740
TEST_F(OptionsTest,gtest_repeat_error_no_value_from_env)741 TEST_F(OptionsTest, gtest_repeat_error_no_value_from_env) {
742 ASSERT_NE(-1, setenv("GTEST_REPEAT", "", 1));
743
744 CapturedStdout capture;
745 std::vector<const char*> cur_args{"ignore"};
746 Options options;
747 bool parsed = options.Process(cur_args, &child_args_);
748 capture.Stop();
749 ASSERT_FALSE(parsed) << "Process did not fail properly.";
750 EXPECT_EQ("env[GTEST_REPEAT] requires an argument.\n", capture.str());
751
752 ASSERT_NE(-1, unsetenv("GTEST_REPEAT"));
753 }
754
TEST_F(OptionsTest,gtest_repeat_error_overflow_from_env)755 TEST_F(OptionsTest, gtest_repeat_error_overflow_from_env) {
756 ASSERT_NE(-1, setenv("GTEST_REPEAT", "2147483747", 1));
757
758 CapturedStdout capture;
759 std::vector<const char*> cur_args{"ignore"};
760 Options options;
761 bool parsed = options.Process(cur_args, &child_args_);
762 capture.Stop();
763 ASSERT_FALSE(parsed) << "Process did not fail properly.";
764 EXPECT_EQ("env[GTEST_REPEAT] value overflows (2147483747)\n", capture.str());
765
766 ASSERT_NE(-1, setenv("GTEST_REPEAT", "-2147483747", 1));
767
768 ClearChildArgs();
769 capture.Reset();
770 capture.Start();
771 parsed = options.Process(cur_args, &child_args_);
772 capture.Stop();
773 ASSERT_FALSE(parsed) << "Process did not fail properly.";
774 EXPECT_EQ("env[GTEST_REPEAT] value overflows (-2147483747)\n", capture.str());
775
776 ASSERT_NE(-1, unsetenv("GTEST_REPEAT"));
777 }
778
TEST_F(OptionsTest,gtest_color_from_env)779 TEST_F(OptionsTest, gtest_color_from_env) {
780 ASSERT_NE(-1, setenv("GTEST_COLOR", "yes", 1));
781
782 std::vector<const char*> cur_args{"ignore"};
783 std::vector<const char*> child_args;
784 Options options;
785 ASSERT_TRUE(options.Process(cur_args, &child_args_));
786 EXPECT_EQ("yes", options.color());
787 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
788
789 ASSERT_NE(-1, unsetenv("GTEST_COLOR"));
790 }
791
TEST_F(OptionsTest,gtest_color_error_no_value_from_env)792 TEST_F(OptionsTest, gtest_color_error_no_value_from_env) {
793 ASSERT_NE(-1, setenv("GTEST_COLOR", "", 1));
794
795 CapturedStdout capture;
796 std::vector<const char*> cur_args{"ignore"};
797 Options options;
798 bool parsed = options.Process(cur_args, &child_args_);
799 ASSERT_FALSE(parsed) << "Process did not fail properly.";
800 EXPECT_EQ("env[GTEST_COLOR] requires an argument.\n", capture.str());
801
802 ASSERT_NE(-1, unsetenv("GTEST_COLOR"));
803 }
804
TEST_F(OptionsTest,gtest_print_time_from_env)805 TEST_F(OptionsTest, gtest_print_time_from_env) {
806 ASSERT_NE(-1, setenv("GTEST_PRINT_TIME", "0", 1));
807
808 std::vector<const char*> cur_args{"ignore"};
809 Options options;
810 ASSERT_TRUE(options.Process(cur_args, &child_args_));
811 EXPECT_FALSE(options.print_time());
812 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
813
814 ASSERT_NE(-1, unsetenv("GTEST_PRINT_TIME"));
815 }
816
TEST_F(OptionsTest,gtest_print_time_no_value_from_env)817 TEST_F(OptionsTest, gtest_print_time_no_value_from_env) {
818 ASSERT_NE(-1, setenv("GTEST_PRINT_TIME", "", 1));
819
820 std::vector<const char*> cur_args{"ignore"};
821 Options options;
822 ASSERT_TRUE(options.Process(cur_args, &child_args_));
823 EXPECT_TRUE(options.print_time());
824 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
825
826 ASSERT_NE(-1, unsetenv("GTEST_PRINT_TIME"));
827 }
828
TEST_F(OptionsTest,gtest_output_from_env)829 TEST_F(OptionsTest, gtest_output_from_env) {
830 ASSERT_NE(-1, setenv("GTEST_OUTPUT", "xml:/file.xml", 1));
831
832 std::vector<const char*> cur_args{"ignore"};
833 Options options;
834 ASSERT_TRUE(options.Process(cur_args, &child_args_));
835 EXPECT_EQ("/file.xml", options.xml_file());
836 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
837
838 ASSERT_NE(-1, unsetenv("GTEST_PRINT_TIME"));
839 }
840
TEST_F(OptionsTest,gtest_output_error_no_value_from_env)841 TEST_F(OptionsTest, gtest_output_error_no_value_from_env) {
842 ASSERT_NE(-1, setenv("GTEST_OUTPUT", "", 1));
843
844 CapturedStdout capture;
845 std::vector<const char*> cur_args{"ignore"};
846 Options options;
847 bool parsed = options.Process(cur_args, &child_args_);
848 capture.Stop();
849 ASSERT_FALSE(parsed) << "Process did not fail properly.";
850 EXPECT_EQ("env[GTEST_OUTPUT] requires an argument.\n", capture.str());
851
852 ASSERT_NE(-1, unsetenv("GTEST_OUTPUT"));
853 }
854
TEST_F(OptionsTest,gtest_output_error_no_xml_from_env)855 TEST_F(OptionsTest, gtest_output_error_no_xml_from_env) {
856 ASSERT_NE(-1, setenv("GTEST_OUTPUT", "xml:", 1));
857
858 CapturedStdout capture;
859 std::vector<const char*> cur_args{"ignore"};
860 Options options;
861 bool parsed = options.Process(cur_args, &child_args_);
862 capture.Stop();
863 ASSERT_FALSE(parsed) << "Process did not fail properly.";
864 EXPECT_EQ("env[GTEST_OUTPUT] requires a file name after xml:\n", capture.str());
865
866 ASSERT_NE(-1, setenv("GTEST_OUTPUT", "not_xml", 1));
867
868 ClearChildArgs();
869 capture.Reset();
870 capture.Start();
871 parsed = options.Process(cur_args, &child_args_);
872 capture.Stop();
873 ASSERT_FALSE(parsed) << "Process did not fail properly.";
874 EXPECT_EQ("env[GTEST_OUTPUT] only supports an xml output file.\n", capture.str());
875
876 ASSERT_NE(-1, unsetenv("GTEST_OUTPUT"));
877 }
878
TEST_F(OptionsTest,gtest_death_test_style_from_env)879 TEST_F(OptionsTest, gtest_death_test_style_from_env) {
880 ASSERT_NE(-1, setenv("GTEST_DEATH_TEST_STYLE", "fast", 1));
881
882 std::vector<const char*> cur_args{"ignore"};
883 Options options;
884 ASSERT_TRUE(options.Process(cur_args, &child_args_));
885 EXPECT_THAT(child_args_, ElementsAre(StrEq("ignore")));
886
887 ASSERT_NE(-1, unsetenv("GTEST_DEATH_TEST_STYLE"));
888 }
889
TEST_F(OptionsTest,gtest_death_test_style_error_no_value_from_env)890 TEST_F(OptionsTest, gtest_death_test_style_error_no_value_from_env) {
891 ASSERT_NE(-1, setenv("GTEST_DEATH_TEST_STYLE", "", 1));
892
893 CapturedStdout capture;
894 std::vector<const char*> cur_args{"ignore"};
895 Options options;
896 bool parsed = options.Process(cur_args, &child_args_);
897 capture.Stop();
898 ASSERT_FALSE(parsed) << "Process did not fail properly.";
899 EXPECT_EQ("env[GTEST_DEATH_TEST_STYLE] requires an argument.\n", capture.str());
900
901 ASSERT_NE(-1, unsetenv("GTEST_DEATH_TEST_STYLE"));
902 }
903
CheckIncompatibleFromEnv(const std::string env_var)904 void OptionsTest::CheckIncompatibleFromEnv(const std::string env_var) {
905 ASSERT_NE(-1, setenv(env_var.c_str(), "", 1));
906
907 CapturedStdout capture;
908 Options options;
909 std::vector<const char*> cur_args{"ignore"};
910 bool parsed = options.Process(cur_args, &child_args_);
911 capture.Stop();
912 ASSERT_FALSE(parsed) << "Process did not fail properly for env var " + env_var;
913 EXPECT_EQ("env[" + env_var + "] is not compatible with isolation runs.\n", capture.str());
914
915 ASSERT_NE(-1, setenv(env_var.c_str(), "not_empty", 1));
916
917 ClearChildArgs();
918 capture.Reset();
919 capture.Start();
920 parsed = options.Process(cur_args, &child_args_);
921 capture.Stop();
922 ASSERT_FALSE(parsed) << "Process did not fail properly for env var " + env_var;
923 EXPECT_EQ("env[" + env_var + "] is not compatible with isolation runs.\n", capture.str());
924
925 ASSERT_NE(-1, unsetenv(env_var.c_str()));
926 }
927
TEST_F(OptionsTest,incompatible_from_env)928 TEST_F(OptionsTest, incompatible_from_env) {
929 ASSERT_NO_FATAL_FAILURE(CheckIncompatibleFromEnv("GTEST_BREAK_ON_FAILURE"));
930 ASSERT_NO_FATAL_FAILURE(CheckIncompatibleFromEnv("GTEST_CATCH_EXCEPTIONS"));
931 ASSERT_NO_FATAL_FAILURE(CheckIncompatibleFromEnv("GTEST_RANDOM_SEED"));
932 ASSERT_NO_FATAL_FAILURE(CheckIncompatibleFromEnv("GTEST_SHUFFLE"));
933 ASSERT_NO_FATAL_FAILURE(CheckIncompatibleFromEnv("GTEST_STREAM_RESULT_TO"));
934 ASSERT_NO_FATAL_FAILURE(CheckIncompatibleFromEnv("GTEST_THROW_ON_FAILURE"));
935 }
936
937 } // namespace gtest_extras
938 } // namespace android
939