diff options
Diffstat (limited to 'tests/gtest_main.cpp')
| -rw-r--r-- | tests/gtest_main.cpp | 774 |
1 files changed, 774 insertions, 0 deletions
diff --git a/tests/gtest_main.cpp b/tests/gtest_main.cpp new file mode 100644 index 0000000..4304d8c --- /dev/null +++ b/tests/gtest_main.cpp @@ -0,0 +1,774 @@ +/* + * 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) {} +} |