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