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: 40 void ClearChildArgs() { 41 for (auto arg : child_args_) { 42 free(arg); 43 } 44 child_args_.clear(); 45 } 46 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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