| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <gtest/gtest.h> |
| |
| #include <errno.h> |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <sys/wait.h> |
| #include <time.h> |
| #include <unistd.h> |
| |
| #include <string> |
| #include <tuple> |
| #include <utility> |
| #include <vector> |
| |
| namespace testing { |
| namespace internal { |
| |
| // Reuse of testing::internal::ColoredPrintf in gtest. |
| enum GTestColor { |
| COLOR_DEFAULT, |
| COLOR_RED, |
| COLOR_GREEN, |
| COLOR_YELLOW |
| }; |
| |
| void ColoredPrintf(GTestColor color, const char* fmt, ...); |
| |
| } // namespace internal |
| } // namespace testing |
| |
| using testing::internal::GTestColor; |
| using testing::internal::COLOR_DEFAULT; |
| using testing::internal::COLOR_RED; |
| using testing::internal::COLOR_GREEN; |
| using testing::internal::COLOR_YELLOW; |
| using testing::internal::ColoredPrintf; |
| |
| constexpr int DEFAULT_GLOBAL_TEST_RUN_DEADLINE_IN_MS = 60000; |
| constexpr int DEFAULT_GLOBAL_TEST_RUN_WARNLINE_IN_MS = 2000; |
| |
| // The time each test can run before killed for the reason of timeout. |
| // It takes effect only with --isolate option. |
| static int global_test_run_deadline_in_ms = DEFAULT_GLOBAL_TEST_RUN_DEADLINE_IN_MS; |
| |
| // The time each test can run before be warned for too much running time. |
| // It takes effect only with --isolate option. |
| static int global_test_run_warnline_in_ms = DEFAULT_GLOBAL_TEST_RUN_WARNLINE_IN_MS; |
| |
| // Return deadline duration for a test, in ms. |
| static int GetDeadlineInfo(const std::string& /*test_name*/) { |
| return global_test_run_deadline_in_ms; |
| } |
| |
| // Return warnline duration for a test, in ms. |
| static int GetWarnlineInfo(const std::string& /*test_name*/) { |
| return global_test_run_warnline_in_ms; |
| } |
| |
| enum TestResult { |
| TEST_SUCCESS = 0, |
| TEST_FAILED, |
| TEST_TIMEOUT |
| }; |
| |
| class TestCase { |
| public: |
| TestCase() {} // For std::vector<TestCase>. |
| explicit TestCase(const char* name) : name_(name) {} |
| |
| const std::string& GetName() const { return name_; } |
| |
| void AppendTest(const std::string& test_name) { |
| test_list_.push_back(std::make_tuple(test_name, TEST_FAILED, 0LL)); |
| } |
| |
| int NumTests() const { return test_list_.size(); } |
| |
| std::string GetTestName(int test_id) const { |
| VerifyTestId(test_id); |
| return name_ + "." + std::get<0>(test_list_[test_id]); |
| } |
| |
| void SetTestResult(int test_id, TestResult result) { |
| VerifyTestId(test_id); |
| std::get<1>(test_list_[test_id]) = result; |
| } |
| |
| TestResult GetTestResult(int test_id) const { |
| VerifyTestId(test_id); |
| return std::get<1>(test_list_[test_id]); |
| } |
| |
| void SetTestTime(int test_id, int64_t elapsed_time) { |
| VerifyTestId(test_id); |
| std::get<2>(test_list_[test_id]) = elapsed_time; |
| } |
| |
| int64_t GetTestTime(int test_id) const { |
| VerifyTestId(test_id); |
| return std::get<2>(test_list_[test_id]); |
| } |
| |
| private: |
| void VerifyTestId(int test_id) const { |
| if(test_id < 0 || test_id >= static_cast<int>(test_list_.size())) { |
| fprintf(stderr, "test_id %d out of range [0, %zu)\n", test_id, test_list_.size()); |
| exit(1); |
| } |
| } |
| |
| private: |
| const std::string name_; |
| std::vector<std::tuple<std::string, TestResult, int64_t> > test_list_; |
| }; |
| |
| // TestResultPrinter is copied from part of external/gtest/src/gtest.cc:PrettyUnitTestResultPrinter. |
| // The reason for copy is that PrettyUnitTestResultPrinter is defined and used in gtest.cc, which |
| // is hard to reuse. |
| // TestResultPrinter only print information for a single test, which is used in child process. |
| // The information of test_iteration/environment/testcase is left for parent process to print. |
| class TestResultPrinter : public testing::EmptyTestEventListener { |
| public: |
| TestResultPrinter() : pinfo_(NULL) {} |
| virtual void OnTestStart(const testing::TestInfo& test_info) { |
| pinfo_ = &test_info; // Record test_info for use in OnTestPartResult. |
| } |
| virtual void OnTestPartResult(const testing::TestPartResult& result); |
| virtual void OnTestEnd(const testing::TestInfo& test_info); |
| |
| private: |
| const testing::TestInfo* pinfo_; |
| }; |
| |
| // Called after an assertion failure. |
| void TestResultPrinter::OnTestPartResult(const testing::TestPartResult& result) { |
| // If the test part succeeded, we don't need to do anything. |
| if (result.type() == testing::TestPartResult::kSuccess) |
| return; |
| |
| // Print failure message from the assertion (e.g. expected this and got that). |
| char buf[1024]; |
| snprintf(buf, sizeof(buf), "%s:(%d) Failure in test %s.%s\n%s\n", result.file_name(), |
| result.line_number(), |
| pinfo_->test_case_name(), |
| pinfo_->name(), |
| result.message()); |
| |
| // Use write() to skip line buffer of printf, thus can avoid getting interleaved when |
| // several processes are printing at the same time. |
| int towrite = strlen(buf); |
| char* p = buf; |
| while (towrite > 0) { |
| ssize_t num_write = write(fileno(stdout), p, towrite); |
| if (num_write == -1) { |
| if (errno != EINTR) { |
| fprintf(stderr, "write, errno = %d\n", errno); |
| break; |
| } |
| } else { |
| towrite -= num_write; |
| p += num_write; |
| } |
| } |
| } |
| |
| void TestResultPrinter::OnTestEnd(const testing::TestInfo& test_info) { |
| if (test_info.result()->Passed()) { |
| ColoredPrintf(COLOR_GREEN, "[ OK ] "); |
| } else { |
| ColoredPrintf(COLOR_RED, "[ FAILED ] "); |
| } |
| printf("%s.%s", test_info.test_case_name(), test_info.name()); |
| if (test_info.result()->Failed()) { |
| const char* const type_param = test_info.type_param(); |
| const char* const value_param = test_info.value_param(); |
| if (type_param != NULL || value_param != NULL) { |
| printf(", where "); |
| if (type_param != NULL) { |
| printf("TypeParam = %s", type_param); |
| if (value_param != NULL) { |
| printf(" and "); |
| } |
| } |
| if (value_param != NULL) { |
| printf("GetParam() = %s", value_param); |
| } |
| } |
| } |
| |
| if (testing::GTEST_FLAG(print_time)) { |
| printf(" (%lld ms)\n", test_info.result()->elapsed_time()); |
| } else { |
| printf("\n"); |
| } |
| fflush(stdout); |
| } |
| |
| static int64_t NanoTime() { |
| struct timespec t; |
| t.tv_sec = t.tv_nsec = 0; |
| clock_gettime(CLOCK_MONOTONIC, &t); |
| return static_cast<int64_t>(t.tv_sec) * 1000000000LL + t.tv_nsec; |
| } |
| |
| static bool EnumerateTests(int argc, char** argv, std::vector<TestCase>& testcase_list) { |
| std::string command; |
| for (int i = 0; i < argc; ++i) { |
| command += argv[i]; |
| command += " "; |
| } |
| command += "--gtest_list_tests"; |
| FILE* fp = popen(command.c_str(), "r"); |
| if (fp == NULL) { |
| perror("popen"); |
| return false; |
| } |
| |
| char buf[200]; |
| while (fgets(buf, sizeof(buf), fp) != NULL) { |
| char* p = buf; |
| |
| while (*p != '\0' && isspace(*p)) { |
| ++p; |
| } |
| if (*p == '\0') continue; |
| char* start = p; |
| while (*p != '\0' && !isspace(*p)) { |
| ++p; |
| } |
| char* end = p; |
| while (*p != '\0' && isspace(*p)) { |
| ++p; |
| } |
| if (*p != '\0') { |
| // This is not we want, gtest must meet with some error when parsing the arguments. |
| fprintf(stderr, "argument error, check with --help\n"); |
| return false; |
| } |
| *end = '\0'; |
| if (*(end - 1) == '.') { |
| *(end - 1) = '\0'; |
| testcase_list.push_back(TestCase(start)); |
| } else { |
| testcase_list.back().AppendTest(start); |
| } |
| } |
| int result = pclose(fp); |
| return (result != -1 && WEXITSTATUS(result) == 0); |
| } |
| |
| static void PrintHelpInfo() { |
| printf("Bionic Unit Test Options:\n" |
| " --isolate\n" |
| " Use isolation mode, Run each test in a separate process.\n" |
| " --deadline=[TIME_IN_MS]\n" |
| " Run each test in no longer than [TIME_IN_MS] time.\n" |
| " It takes effect only in isolation mode. Deafult deadline is 60000 ms.\n" |
| " --warnline=[TIME_IN_MS]\n" |
| " Test running longer than [TIME_IN_MS] will be warned.\n" |
| " It takes effect only in isolation mode. Default warnline is 2000 ms.\n" |
| " -j [JOB_NUM]\n" |
| " Run up to JOB_NUM tests in parallel.\n" |
| " Use isolation mode, Run each test in a separate process.\n" |
| " If JOB_NUM is not given, it is set to the number of cpus available.\n" |
| "\n"); |
| } |
| |
| // Part of the following *Print functions are copied from external/gtest/src/gtest.cc: |
| // PrettyUnitTestResultPrinter. The reason for copy is that PrettyUnitTestResultPrinter |
| // is defined and used in gtest.cc, which is hard to reuse. |
| static void OnTestIterationStartPrint(const std::vector<TestCase>& testcase_list, int iteration, |
| int num_iterations) { |
| if (num_iterations > 1) { |
| printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration); |
| } |
| ColoredPrintf(COLOR_GREEN, "[==========] "); |
| |
| int num_testcases = testcase_list.size(); |
| int num_tests = 0; |
| for (const auto& testcase : testcase_list) { |
| num_tests += testcase.NumTests(); |
| } |
| |
| printf("Running %d %s from %d %s.\n", |
| num_tests, (num_tests == 1) ? "test" : "tests", |
| num_testcases, (num_testcases == 1) ? "test case" : "test cases"); |
| fflush(stdout); |
| } |
| |
| static void OnTestTimeoutPrint(const TestCase& testcase, int test_id) { |
| ColoredPrintf(COLOR_RED, "[ TIMEOUT ] "); |
| printf("%s (killed by timeout at %lld ms)\n", testcase.GetTestName(test_id).c_str(), |
| testcase.GetTestTime(test_id) / 1000000LL); |
| fflush(stdout); |
| } |
| |
| static void TestcaseTimePrint(const TestCase& testcase) { |
| int64_t testcase_time = 0; |
| for (int i = 0; i < testcase.NumTests(); ++i) { |
| testcase_time += testcase.GetTestTime(i); |
| } |
| printf("%d %s from %s (%lld ms total)\n", testcase.NumTests(), |
| (testcase.NumTests() == 1) ? "test" : "tests", |
| testcase.GetName().c_str(), |
| testcase_time / 1000000LL); |
| fflush(stdout); |
| } |
| |
| static void OnTestIterationEndPrint(const std::vector<TestCase>& testcase_list, int /*iteration*/, |
| int64_t elapsed_time) { |
| |
| std::vector<std::string> fail_test_name_list; |
| std::vector<std::pair<std::string, int64_t>> timeout_test_list; |
| |
| // For tests run exceed warnline but not timeout. |
| std::vector<std::tuple<std::string, int64_t, int>> timewarn_test_list; |
| int num_testcases = testcase_list.size(); |
| int num_tests = 0; |
| int num_success_tests = 0; |
| |
| for (const auto& testcase : testcase_list) { |
| num_tests += testcase.NumTests(); |
| for (int i = 0; i < testcase.NumTests(); ++i) { |
| TestResult result = testcase.GetTestResult(i); |
| if (result == TEST_SUCCESS) { |
| ++num_success_tests; |
| } else if (result == TEST_FAILED) { |
| fail_test_name_list.push_back(testcase.GetTestName(i)); |
| } else if (result == TEST_TIMEOUT) { |
| timeout_test_list.push_back(std::make_pair(testcase.GetTestName(i), |
| testcase.GetTestTime(i))); |
| } |
| if (result != TEST_TIMEOUT && |
| testcase.GetTestTime(i) / 1000000 >= GetWarnlineInfo(testcase.GetTestName(i))) { |
| timewarn_test_list.push_back(std::make_tuple(testcase.GetTestName(i), |
| testcase.GetTestTime(i), |
| GetWarnlineInfo(testcase.GetTestName(i)))); |
| } |
| } |
| } |
| |
| for (auto const& testcase : testcase_list) { |
| TestcaseTimePrint(testcase); |
| } |
| |
| ColoredPrintf(COLOR_GREEN, "[==========] "); |
| printf("%d %s from %d %s ran.", num_tests, (num_tests == 1) ? "test" : "tests", |
| num_testcases, (num_testcases == 1) ? "test case" : "test cases"); |
| if (testing::GTEST_FLAG(print_time)) { |
| printf(" (%lld ms total)", elapsed_time / 1000000LL); |
| } |
| printf("\n"); |
| ColoredPrintf(COLOR_GREEN, "[ PASSED ] "); |
| printf("%d %s.\n", num_success_tests, (num_success_tests == 1) ? "test" : "tests"); |
| |
| // Print tests failed. |
| int num_fail_tests = fail_test_name_list.size(); |
| if (num_fail_tests > 0) { |
| ColoredPrintf(COLOR_RED, "[ FAILED ] "); |
| printf("%d %s, listed below:\n", num_fail_tests, (num_fail_tests == 1) ? "test" : "tests"); |
| for (const auto& name : fail_test_name_list) { |
| ColoredPrintf(COLOR_RED, "[ FAILED ] "); |
| printf("%s\n", name.c_str()); |
| } |
| } |
| |
| // Print tests run timeout. |
| int num_timeout_tests = timeout_test_list.size(); |
| if (num_timeout_tests > 0) { |
| ColoredPrintf(COLOR_RED, "[ TIMEOUT ] "); |
| printf("%d %s, listed below:\n", num_timeout_tests, (num_timeout_tests == 1) ? "test" : "tests"); |
| for (const auto& timeout_pair : timeout_test_list) { |
| ColoredPrintf(COLOR_RED, "[ TIMEOUT ] "); |
| printf("%s (stopped at %lld ms)\n", timeout_pair.first.c_str(), |
| timeout_pair.second / 1000000LL); |
| } |
| } |
| |
| // Print tests run exceed warnline. |
| int num_timewarn_tests = timewarn_test_list.size(); |
| if (num_timewarn_tests > 0) { |
| ColoredPrintf(COLOR_YELLOW, "[ TIMEWARN ] "); |
| printf("%d %s, listed below:\n", num_timewarn_tests, (num_timewarn_tests == 1) ? "test" : "tests"); |
| for (const auto& timewarn_tuple : timewarn_test_list) { |
| ColoredPrintf(COLOR_YELLOW, "[ TIMEWARN ] "); |
| printf("%s (%lld ms, exceed warnline %d ms)\n", std::get<0>(timewarn_tuple).c_str(), |
| std::get<1>(timewarn_tuple) / 1000000LL, |
| std::get<2>(timewarn_tuple)); |
| } |
| } |
| |
| if (num_fail_tests > 0) { |
| printf("\n%2d FAILED %s\n", num_fail_tests, (num_fail_tests == 1) ? "TEST" : "TESTS"); |
| } |
| if (num_timeout_tests > 0) { |
| printf("%2d TIMEOUT %s\n", num_timeout_tests, (num_timeout_tests == 1) ? "TEST" : "TESTS"); |
| } |
| if (num_timewarn_tests > 0) { |
| printf("%2d TIMEWARN %s\n", num_timewarn_tests, (num_timewarn_tests == 1) ? "TEST" : "TESTS"); |
| } |
| fflush(stdout); |
| } |
| |
| // Forked Child process, run the single test. |
| static void ChildProcessFn(int argc, char** argv, const std::string& test_name) { |
| char** new_argv = new char*[argc + 1]; |
| memcpy(new_argv, argv, sizeof(char*) * argc); |
| |
| char* filter_arg = new char [test_name.size() + 20]; |
| strcpy(filter_arg, "--gtest_filter="); |
| strcat(filter_arg, test_name.c_str()); |
| new_argv[argc] = filter_arg; |
| |
| int new_argc = argc + 1; |
| testing::InitGoogleTest(&new_argc, new_argv); |
| int result = RUN_ALL_TESTS(); |
| exit(result); |
| } |
| |
| struct ChildProcInfo { |
| pid_t pid; |
| int64_t start_time; |
| int64_t deadline_time; |
| int testcase_id, test_id; |
| bool done_flag; |
| TestResult test_result; |
| ChildProcInfo() : pid(0) {} |
| }; |
| |
| static void WaitChildProcs(std::vector<ChildProcInfo>& child_proc_list) { |
| pid_t result; |
| int exit_status; |
| bool loop_flag = true; |
| |
| while (true) { |
| while ((result = waitpid(-1, &exit_status, WNOHANG)) == -1) { |
| if (errno != EINTR) { |
| break; |
| } |
| } |
| |
| if (result == -1) { |
| perror("waitpid"); |
| exit(1); |
| } else if (result == 0) { |
| // Check child timeout. |
| int64_t current_time = NanoTime(); |
| for (size_t i = 0; i < child_proc_list.size(); ++i) { |
| if (child_proc_list[i].deadline_time <= current_time) { |
| child_proc_list[i].done_flag = true; |
| child_proc_list[i].test_result = TEST_TIMEOUT; |
| loop_flag = false; |
| } |
| } |
| } else { |
| // Check child finish. |
| for (size_t i = 0; i < child_proc_list.size(); ++i) { |
| if (child_proc_list[i].pid == result) { |
| child_proc_list[i].done_flag = true; |
| child_proc_list[i].test_result = (WEXITSTATUS(exit_status) == 0) ? TEST_SUCCESS : |
| TEST_FAILED; |
| loop_flag = false; |
| break; |
| } |
| } |
| } |
| |
| if (!loop_flag) break; |
| // sleep 1 ms to avoid busy looping. |
| timespec sleep_time; |
| sleep_time.tv_sec = 0; |
| sleep_time.tv_nsec = 1000000; |
| nanosleep(&sleep_time, NULL); |
| } |
| } |
| |
| static TestResult WaitChildProc(pid_t pid) { |
| pid_t result; |
| int exit_status; |
| |
| while ((result = waitpid(pid, &exit_status, 0)) == -1) { |
| if (errno != EINTR) { |
| break; |
| } |
| } |
| |
| TestResult test_result = TEST_SUCCESS; |
| if (result != pid || WEXITSTATUS(exit_status) != 0) { |
| test_result = TEST_FAILED; |
| } |
| return test_result; |
| } |
| |
| // We choose to use multi-fork and multi-wait here instead of multi-thread, because it always |
| // makes deadlock to use fork in multi-thread. |
| static void RunTestInSeparateProc(int argc, char** argv, std::vector<TestCase>& testcase_list, |
| int num_iterations, int num_jobs) { |
| // Stop default result printer to avoid environment setup/teardown information for each test. |
| testing::UnitTest::GetInstance()->listeners().Release( |
| testing::UnitTest::GetInstance()->listeners().default_result_printer()); |
| testing::UnitTest::GetInstance()->listeners().Append(new TestResultPrinter); |
| |
| for (int iteration = 1; iteration <= num_iterations; ++iteration) { |
| OnTestIterationStartPrint(testcase_list, iteration, num_iterations); |
| int64_t iteration_start_time = NanoTime(); |
| |
| std::vector<ChildProcInfo> child_proc_list(num_jobs); |
| int assign_testcase = 0, assign_test = 0; |
| std::vector<int> finish_test_num_list(testcase_list.size(), 0); |
| int num_finish_testcases = 0; |
| |
| while (num_finish_testcases < static_cast<int>(testcase_list.size())) { |
| // Fork child process up to num_jobs. |
| for (auto& child_proc : child_proc_list) { |
| if (child_proc.pid == 0 && assign_testcase < static_cast<int>(testcase_list.size())) { |
| std::string test_name = testcase_list[assign_testcase].GetTestName(assign_test); |
| pid_t pid = fork(); |
| if (pid == -1) { |
| perror("fork in RunTestInSeparateProc"); |
| exit(1); |
| } else if (pid == 0) { |
| // Run child process test, never return. |
| ChildProcessFn(argc, argv, test_name); |
| } |
| // Parent process |
| child_proc.pid = pid; |
| child_proc.start_time = NanoTime(); |
| child_proc.deadline_time = child_proc.start_time + GetDeadlineInfo(test_name) * 1000000LL; |
| child_proc.testcase_id = assign_testcase; |
| child_proc.test_id = assign_test; |
| child_proc.done_flag = false; |
| if (++assign_test == testcase_list[assign_testcase].NumTests()) { |
| assign_test = 0; |
| ++assign_testcase; |
| } |
| } |
| } |
| |
| // Wait for any child proc finish or timeout. |
| WaitChildProcs(child_proc_list); |
| |
| // Collect result. |
| for (auto& child_proc : child_proc_list) { |
| if (child_proc.pid != 0 && child_proc.done_flag == true) { |
| int testcase_id = child_proc.testcase_id; |
| int test_id = child_proc.test_id; |
| TestResult test_result = child_proc.test_result; |
| if (test_result == TEST_TIMEOUT) { |
| // Kill and wait the child process. |
| kill(child_proc.pid, SIGKILL); |
| WaitChildProc(child_proc.pid); |
| } |
| TestCase& testcase = testcase_list[testcase_id]; |
| testcase.SetTestResult(test_id, test_result); |
| testcase.SetTestTime(test_id, NanoTime() - child_proc.start_time); |
| if (test_result == TEST_TIMEOUT) { |
| OnTestTimeoutPrint(testcase, test_id); |
| } |
| if (++finish_test_num_list[testcase_id] == testcase.NumTests()) { |
| ++num_finish_testcases; |
| } |
| child_proc.pid = 0; |
| child_proc.done_flag = false; |
| } |
| } |
| } |
| |
| OnTestIterationEndPrint(testcase_list, iteration, NanoTime() - iteration_start_time); |
| } |
| } |
| |
| static int GetCpuNumber() { |
| FILE* fp = popen("cat /proc/cpuinfo | grep processor | wc -l", "r"); |
| int result = 1; // Return 1 if we can't get the exact cpu number. |
| if (fp != NULL) { |
| fscanf(fp, "%d", &result); |
| if (result < 1) { |
| result = 1; |
| } |
| pclose(fp); |
| } |
| return result; |
| } |
| |
| // Pick options not for gtest; Return false if run error. |
| // Use exit_flag to indicate whether we need to run gtest flow after PickOptions. |
| static bool PickOptions(int* pargc, char*** pargv, bool* exit_flag) { |
| int argc = *pargc; |
| char** argv = *pargv; |
| *exit_flag = false; |
| for (int i = 0; i < argc; ++i) { |
| if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) { |
| PrintHelpInfo(); |
| return true; |
| } |
| } |
| |
| // Move --gtest_filter option to last, and add "-bionic_gtest*" to disable self test. |
| int gtest_filter_option_pos = 0; |
| for (int i = argc - 1; i >= 1; --i) { |
| if (strncmp(argv[i], "--gtest_filter=", sizeof("--gtest_filter=") - 1) == 0) { |
| gtest_filter_option_pos = i; |
| break; |
| } |
| } |
| if (gtest_filter_option_pos != 0) { |
| char* gtest_filter_arg = argv[gtest_filter_option_pos]; |
| for (int i = gtest_filter_option_pos; i < argc - 1; ++i) { |
| argv[i] = argv[i + 1]; |
| } |
| char* new_arg = new char[strlen(gtest_filter_arg) + sizeof(":-bionic_gtest*")]; |
| strcpy(new_arg, gtest_filter_arg); |
| strcat(new_arg, ":-bionic_gtest*"); |
| argv[argc - 1] = new_arg; |
| } else { |
| char** new_argv = new char* [argc + 1]; |
| for (int i = 0; i < argc; ++i) { |
| new_argv[i] = argv[i]; |
| } |
| new_argv[argc++] = const_cast<char*>("--gtest_filter=-bionic_gtest*"); |
| *pargv = argv = new_argv; |
| } |
| |
| // Parse bionic_gtest specific options. |
| bool isolate_option = false; |
| int job_num_option = 1; |
| |
| int deadline_option_len = sizeof("--deadline=") - 1; |
| int warnline_option_len = sizeof("--warnline=") - 1; |
| int gtest_color_option_len = sizeof("--gtest_color=") - 1; |
| |
| for (int i = 1; i < argc; ++i) { |
| int remove_arg_num = 0; |
| |
| // If running in isolation mode, main process doesn't call testing::InitGoogleTest(&argc, argv). |
| // So we should parse gtest options for printing here. |
| if (strncmp(argv[i], "--gtest_color=", gtest_color_option_len) == 0) { |
| testing::GTEST_FLAG(color) = argv[i] + gtest_color_option_len; |
| |
| } else if (strcmp(argv[i], "--gtest_print_time=0") == 0) { |
| testing::GTEST_FLAG(print_time) = false; |
| |
| } else if (strcmp(argv[i], "--isolate") == 0) { |
| isolate_option = true; |
| remove_arg_num = 1; |
| |
| } else if (strncmp(argv[i], "--deadline=", deadline_option_len) == 0) { |
| global_test_run_deadline_in_ms = atoi(argv[i] + deadline_option_len); |
| if (global_test_run_deadline_in_ms <= 0) { |
| fprintf(stderr, "value for --deadline option should be positive: %s\n", |
| argv[i] + deadline_option_len); |
| exit(1); |
| } |
| remove_arg_num = 1; |
| |
| } else if (strncmp(argv[i], "--warnline=", warnline_option_len) == 0) { |
| global_test_run_warnline_in_ms = atoi(argv[i] + warnline_option_len); |
| if (global_test_run_warnline_in_ms <= 0) { |
| fprintf(stderr, "value for --warnline option should be positive: %s\n", |
| argv[i] + warnline_option_len); |
| exit(1); |
| } |
| remove_arg_num = 1; |
| |
| } else if (strcmp(argv[i], "--bionic_gtest") == 0) { |
| // Enable "bionic_gtest*" for self test. |
| // Don't remove this option from argument list. |
| argv[argc - 1] = const_cast<char*>("--gtest_filter=bionic_gtest*"); |
| |
| } else if (strcmp(argv[i], "-j") == 0) { |
| isolate_option = true; // Enable isolation mode when -j is used. |
| if (i + 1 < argc && (job_num_option = atoi(argv[i + 1])) > 0) { |
| remove_arg_num = 2; |
| } else { |
| job_num_option = GetCpuNumber(); |
| remove_arg_num = 1; |
| } |
| } |
| |
| if (remove_arg_num != 0) { |
| for (int j = i; j < argc - remove_arg_num; ++j) { |
| argv[j] = argv[j + remove_arg_num]; |
| } |
| argc -= remove_arg_num; |
| --i; |
| } |
| } |
| |
| // Handle --gtest_repeat=[COUNT] option if we are in isolation mode. |
| // We should check and remove this option to avoid child process running single test for several |
| // iterations. |
| int gtest_repeat_num = 1; |
| if (isolate_option == true) { |
| int len = sizeof("--gtest_repeat=") - 1; |
| for (int i = 1; i < argc; ++i) { |
| if (strncmp(argv[i], "--gtest_repeat=", len) == 0) { |
| gtest_repeat_num = atoi(argv[i] + len); |
| if (gtest_repeat_num < 0) { |
| fprintf(stderr, "error count for option --gtest_repeat=[COUNT]\n"); |
| return false; |
| } |
| for (int j = i; j < argc - 1; ++j) { |
| argv[j] = argv[j + 1]; |
| } |
| --argc; |
| break; |
| } |
| } |
| } |
| |
| *pargc = argc; |
| |
| // Run tests in isolation mode. |
| if (isolate_option) { |
| *exit_flag = true; |
| |
| std::vector<TestCase> testcase_list; |
| if (EnumerateTests(argc, argv, testcase_list) == false) { |
| return false; |
| } |
| RunTestInSeparateProc(argc, argv, testcase_list, gtest_repeat_num, job_num_option); |
| return true; |
| } |
| return true; |
| } |
| |
| int main(int argc, char** argv) { |
| bool exit_flag; |
| int return_result = 0; |
| |
| if (PickOptions(&argc, &argv, &exit_flag) == false) { |
| return_result = 1; |
| } else if (!exit_flag) { |
| testing::InitGoogleTest(&argc, argv); |
| return_result = RUN_ALL_TESTS(); |
| } |
| return return_result; |
| } |
| |
| //################################################################################ |
| // Bionic Gtest self test, run this by --bionic_gtest --isolate option. |
| |
| TEST(bionic_gtest, test_success) { |
| ASSERT_EQ(1, 1); |
| } |
| |
| TEST(bionic_gtest, test_fail) { |
| ASSERT_EQ(0, 1); |
| } |
| |
| TEST(bionic_gtest, test_time_warn) { |
| sleep(4); |
| } |
| |
| TEST(bionic_gtest, test_timeout) { |
| while (1) {} |
| } |