| /* |
| * 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; |
| } |
| |
| static void PrintHelpInfo() { |
| printf("Bionic Unit Test Options:\n" |
| " -j [JOB_COUNT]\n" |
| " Run up to JOB_COUNT tests in parallel.\n" |
| " Use isolation mode, Run each test in a separate process.\n" |
| " If JOB_COUNT is not given, it is set to the count of available processors.\n" |
| " --no-isolate\n" |
| " Don't use isolation mode, run all tests in a single 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" |
| "\nDefault bionic unit test option is -j.\n" |
| "\n"); |
| } |
| |
| 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)); |
| } |
| |
| size_t TestCount() const { return test_list_.size(); } |
| |
| std::string GetTestName(size_t test_id) const { |
| VerifyTestId(test_id); |
| return name_ + "." + std::get<0>(test_list_[test_id]); |
| } |
| |
| void SetTestResult(size_t test_id, TestResult result) { |
| VerifyTestId(test_id); |
| std::get<1>(test_list_[test_id]) = result; |
| } |
| |
| TestResult GetTestResult(size_t test_id) const { |
| VerifyTestId(test_id); |
| return std::get<1>(test_list_[test_id]); |
| } |
| |
| void SetTestTime(size_t test_id, int64_t elapsed_time) { |
| VerifyTestId(test_id); |
| std::get<2>(test_list_[test_id]) = elapsed_time; |
| } |
| |
| int64_t GetTestTime(size_t test_id) const { |
| VerifyTestId(test_id); |
| return std::get<2>(test_list_[test_id]); |
| } |
| |
| private: |
| void VerifyTestId(size_t test_id) const { |
| if(test_id >= test_list_.size()) { |
| fprintf(stderr, "test_id %zu 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 write_count = write(fileno(stdout), p, towrite); |
| if (write_count == -1) { |
| if (errno != EINTR) { |
| fprintf(stderr, "write, errno = %d\n", errno); |
| break; |
| } |
| } else { |
| towrite -= write_count; |
| p += write_count; |
| } |
| } |
| } |
| |
| 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); |
| } |
| |
| // 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, size_t iteration, |
| size_t iteration_count) { |
| if (iteration_count > 1) { |
| printf("\nRepeating all tests (iteration %zu) . . .\n\n", iteration); |
| } |
| ColoredPrintf(COLOR_GREEN, "[==========] "); |
| |
| size_t testcase_count = testcase_list.size(); |
| size_t test_count = 0; |
| for (const auto& testcase : testcase_list) { |
| test_count += testcase.TestCount(); |
| } |
| |
| printf("Running %zu %s from %zu %s.\n", |
| test_count, (test_count == 1) ? "test" : "tests", |
| testcase_count, (testcase_count == 1) ? "test case" : "test cases"); |
| fflush(stdout); |
| } |
| |
| static void OnTestTerminatedPrint(const TestCase& testcase, size_t test_id, int sig) { |
| ColoredPrintf(COLOR_RED, "[ FAILED ] "); |
| printf("%s terminated by signal: %s\n", testcase.GetTestName(test_id).c_str(), |
| strsignal(sig)); |
| fflush(stdout); |
| } |
| |
| static void OnTestTimeoutPrint(const TestCase& testcase, size_t 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 (size_t i = 0; i < testcase.TestCount(); ++i) { |
| testcase_time += testcase.GetTestTime(i); |
| } |
| printf("%zu %s from %s (%lld ms total)\n", testcase.TestCount(), |
| (testcase.TestCount() == 1) ? "test" : "tests", |
| testcase.GetName().c_str(), |
| testcase_time / 1000000LL); |
| fflush(stdout); |
| } |
| |
| static void OnTestIterationEndPrint(const std::vector<TestCase>& testcase_list, size_t /*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; |
| size_t testcase_count = testcase_list.size(); |
| size_t test_count = 0; |
| size_t success_test_count = 0; |
| |
| for (const auto& testcase : testcase_list) { |
| test_count += testcase.TestCount(); |
| for (size_t i = 0; i < testcase.TestCount(); ++i) { |
| TestResult result = testcase.GetTestResult(i); |
| if (result == TEST_SUCCESS) { |
| ++success_test_count; |
| } 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("%zu %s from %zu %s ran.", test_count, (test_count == 1) ? "test" : "tests", |
| testcase_count, (testcase_count == 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("%zu %s.\n", success_test_count, (success_test_count == 1) ? "test" : "tests"); |
| |
| // Print tests failed. |
| size_t fail_test_count = fail_test_name_list.size(); |
| if (fail_test_count > 0) { |
| ColoredPrintf(COLOR_RED, "[ FAILED ] "); |
| printf("%zu %s, listed below:\n", fail_test_count, (fail_test_count == 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. |
| size_t timeout_test_count = timeout_test_list.size(); |
| if (timeout_test_count > 0) { |
| ColoredPrintf(COLOR_RED, "[ TIMEOUT ] "); |
| printf("%zu %s, listed below:\n", timeout_test_count, (timeout_test_count == 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. |
| size_t timewarn_test_count = timewarn_test_list.size(); |
| if (timewarn_test_count > 0) { |
| ColoredPrintf(COLOR_YELLOW, "[ TIMEWARN ] "); |
| printf("%zu %s, listed below:\n", timewarn_test_count, (timewarn_test_count == 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 (fail_test_count > 0) { |
| printf("\n%2zu FAILED %s\n", fail_test_count, (fail_test_count == 1) ? "TEST" : "TESTS"); |
| } |
| if (timeout_test_count > 0) { |
| printf("%2zu TIMEOUT %s\n", timeout_test_count, (timeout_test_count == 1) ? "TEST" : "TESTS"); |
| } |
| if (timewarn_test_count > 0) { |
| printf("%2zu TIMEWARN %s\n", timewarn_test_count, (timewarn_test_count == 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; |
| size_t testcase_id, test_id; |
| bool done_flag; |
| bool timeout_flag; |
| int exit_status; |
| ChildProcInfo() : pid(0) {} |
| }; |
| |
| static void WaitChildProcs(std::vector<ChildProcInfo>& child_proc_list) { |
| pid_t result; |
| int status; |
| bool loop_flag = true; |
| |
| while (true) { |
| while ((result = waitpid(-1, &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].timeout_flag = true; |
| 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].timeout_flag = false; |
| child_proc_list[i].exit_status = status; |
| 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, |
| size_t iteration_count, size_t job_count) { |
| // 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 (size_t iteration = 1; iteration <= iteration_count; ++iteration) { |
| OnTestIterationStartPrint(testcase_list, iteration, iteration_count); |
| int64_t iteration_start_time = NanoTime(); |
| |
| // Run up to job_count tests in parallel, each test in a child process. |
| std::vector<ChildProcInfo> child_proc_list(job_count); |
| |
| // Next test to run is [next_testcase_id:next_test_id]. |
| size_t next_testcase_id = 0; |
| size_t next_test_id = 0; |
| |
| // Record how many tests are finished. |
| std::vector<size_t> finished_test_count_list(testcase_list.size(), 0); |
| size_t finished_testcase_count = 0; |
| |
| while (finished_testcase_count < testcase_list.size()) { |
| // Fork up to job_count child processes. |
| for (auto& child_proc : child_proc_list) { |
| if (child_proc.pid == 0 && next_testcase_id < testcase_list.size()) { |
| std::string test_name = testcase_list[next_testcase_id].GetTestName(next_test_id); |
| 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 = next_testcase_id; |
| child_proc.test_id = next_test_id; |
| child_proc.done_flag = false; |
| if (++next_test_id == testcase_list[next_testcase_id].TestCount()) { |
| next_test_id = 0; |
| ++next_testcase_id; |
| } |
| } |
| } |
| |
| // 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) { |
| size_t testcase_id = child_proc.testcase_id; |
| size_t test_id = child_proc.test_id; |
| TestCase& testcase = testcase_list[testcase_id]; |
| testcase.SetTestTime(test_id, NanoTime() - child_proc.start_time); |
| |
| if (child_proc.timeout_flag) { |
| // Kill and wait the timeout child process. |
| kill(child_proc.pid, SIGKILL); |
| WaitChildProc(child_proc.pid); |
| testcase.SetTestResult(test_id, TEST_TIMEOUT); |
| OnTestTimeoutPrint(testcase, test_id); |
| |
| } else if (WIFSIGNALED(child_proc.exit_status)) { |
| // Record signal terminated test as failed. |
| testcase.SetTestResult(test_id, TEST_FAILED); |
| OnTestTerminatedPrint(testcase, test_id, WTERMSIG(child_proc.exit_status)); |
| |
| } else { |
| testcase.SetTestResult(test_id, WEXITSTATUS(child_proc.exit_status) == 0 ? |
| TEST_SUCCESS : TEST_FAILED); |
| // TestResultPrinter::OnTestEnd has already printed result for normal exit. |
| } |
| |
| if (++finished_test_count_list[testcase_id] == testcase.TestCount()) { |
| ++finished_testcase_count; |
| } |
| child_proc.pid = 0; |
| child_proc.done_flag = false; |
| } |
| } |
| } |
| |
| OnTestIterationEndPrint(testcase_list, iteration, NanoTime() - iteration_start_time); |
| } |
| } |
| |
| static size_t GetProcessorCount() { |
| return static_cast<size_t>(sysconf(_SC_NPROCESSORS_ONLN)); |
| } |
| |
| // Pick options not for gtest: There are two parts in argv, one part is handled by PickOptions() |
| // as described in PrintHelpInfo(), the other part is handled by testing::InitGoogleTest() in |
| // gtest. PickOptions() picks the first part of options and change them into flags and operations, |
| // lefting the second part in argv. |
| // Arguments: |
| // argv is used to pass in all command arguments, and pass out only the part of options for gtest. |
| // exit_flag is to indicate whether we need to run gtest workflow after PickOptions. |
| // Return false if run error. |
| static bool PickOptions(std::vector<char*>& argv, bool* exit_flag) { |
| *exit_flag = false; |
| for (size_t i = 1; i < argv.size() - 1; ++i) { |
| if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) { |
| PrintHelpInfo(); |
| return true; |
| } |
| } |
| |
| // Move --gtest_filter option to last, and add "-bionic_selftest*" to disable self test. |
| std::string gtest_filter_str = "--gtest_filter=-bionic_selftest*"; |
| for (size_t i = argv.size() - 2; i >= 1; --i) { |
| if (strncmp(argv[i], "--gtest_filter=", sizeof("--gtest_filter=") - 1) == 0) { |
| gtest_filter_str = std::string(argv[i]) + ":-bionic_selftest*"; |
| argv.erase(argv.begin() + i); |
| break; |
| } |
| } |
| argv.insert(argv.end() - 1, strdup(gtest_filter_str.c_str())); |
| |
| // Init default bionic_gtest option. |
| bool isolate_option = true; |
| size_t job_count_option = GetProcessorCount(); |
| |
| size_t deadline_option_len = strlen("--deadline="); |
| size_t warnline_option_len = strlen("--warnline="); |
| size_t gtest_color_option_len = strlen("--gtest_color="); |
| |
| // Parse bionic_gtest specific options in arguments. |
| for (size_t i = 1; i < argv.size() - 1; ++i) { |
| if (strcmp(argv[i], "-j") == 0) { |
| isolate_option = true; // Enable isolation mode when -j is used. |
| int tmp; |
| if (argv[i + 1] != NULL && (tmp = atoi(argv[i + 1])) > 0) { |
| job_count_option = tmp; |
| argv.erase(argv.begin() + i); |
| } else { |
| job_count_option = GetProcessorCount(); |
| } |
| argv.erase(argv.begin() + i); |
| --i; |
| |
| } else if (strcmp(argv[i], "--no-isolate") == 0) { |
| isolate_option = false; |
| argv.erase(argv.begin() + i); |
| --i; |
| |
| } 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); |
| } |
| argv.erase(argv.begin() + i); |
| --i; |
| |
| } 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); |
| } |
| argv.erase(argv.begin() + i); |
| --i; |
| |
| } else if (strncmp(argv[i], "--gtest_color=", gtest_color_option_len) == 0) { |
| // If running in isolation mode, main process doesn't call testing::InitGoogleTest(&argc, argv). |
| // So we should parse gtest options for printing by ourselves. |
| 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], "--gtest_list_tests") == 0) { |
| // Disable isolation mode in gtest_list_tests option. |
| isolate_option = false; |
| |
| } else if (strcmp(argv[i], "--bionic-selftest") == 0) { |
| // This option is to enable "bionic_selftest*" for self test, and not shown in help informantion. |
| // Don't remove this option from argument list. |
| argv[argv.size() - 2] = strdup("--gtest_filter=bionic_selftest*"); |
| } |
| } |
| |
| // 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. |
| size_t gtest_repeat_count = 1; |
| if (isolate_option == true) { |
| int len = sizeof("--gtest_repeat=") - 1; |
| for (size_t i = 1; i < argv.size() - 1; ++i) { |
| if (strncmp(argv[i], "--gtest_repeat=", len) == 0) { |
| int tmp = atoi(argv[i] + len); |
| if (tmp < 0) { |
| fprintf(stderr, "error count for option --gtest_repeat=[COUNT]\n"); |
| return false; |
| } |
| gtest_repeat_count = tmp; |
| argv.erase(argv.begin() + i); |
| break; |
| } |
| } |
| } |
| |
| // Add --no-isolate option in argv to suppress subprocess running in isolation mode again. |
| // As DeathTest will try to execve again, this option should always be set. |
| argv.insert(argv.begin() + 1, strdup("--no-isolate")); |
| |
| // Run tests in isolation mode. |
| if (isolate_option) { |
| *exit_flag = true; |
| |
| std::vector<TestCase> testcase_list; |
| int argc = static_cast<int>(argv.size()) - 1; |
| if (EnumerateTests(argc, argv.data(), testcase_list) == false) { |
| return false; |
| } |
| RunTestInSeparateProc(argc, argv.data(), testcase_list, gtest_repeat_count, job_count_option); |
| return true; |
| } |
| return true; |
| } |
| |
| int main(int argc, char** argv) { |
| std::vector<char*> arg_list; |
| for (int i = 0; i < argc; ++i) { |
| arg_list.push_back(argv[i]); |
| } |
| arg_list.push_back(NULL); |
| |
| bool exit_flag; |
| int return_result = 0; |
| |
| if (PickOptions(arg_list, &exit_flag) == false) { |
| return_result = 1; |
| } else if (!exit_flag) { |
| argc = static_cast<int>(arg_list.size()) - 1; |
| testing::InitGoogleTest(&argc, arg_list.data()); |
| return_result = RUN_ALL_TESTS(); |
| } |
| return return_result; |
| } |
| |
| //################################################################################ |
| // Bionic Gtest self test, run this by --bionic-selftest option. |
| |
| TEST(bionic_selftest, test_success) { |
| ASSERT_EQ(1, 1); |
| } |
| |
| TEST(bionic_selftest, test_fail) { |
| ASSERT_EQ(0, 1); |
| } |
| |
| TEST(bionic_selftest, test_time_warn) { |
| sleep(4); |
| } |
| |
| TEST(bionic_selftest, test_timeout) { |
| while (1) {} |
| } |
| |
| TEST(bionic_selftest, test_signal_SEGV_terminated) { |
| char* p = reinterpret_cast<char*>(static_cast<intptr_t>(atoi("0"))); |
| *p = 3; |
| } |