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