| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. All rights reserved. |
| // |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file or at |
| // https://developers.google.com/open-source/licenses/bsd |
| |
| // This file contains a program for running the test suite in a separate |
| // process. The other alternative is to run the suite in-process. See |
| // conformance.proto for pros/cons of these two options. |
| // |
| // This program will fork the process under test and communicate with it over |
| // its stdin/stdout: |
| // |
| // +--------+ pipe +----------+ |
| // | tester | <------> | testee | |
| // | | | | |
| // | C++ | | any lang | |
| // +--------+ +----------+ |
| // |
| // The tester contains all of the test cases and their expected output. |
| // The testee is a simple program written in the target language that reads |
| // each test case and attempts to produce acceptable output for it. |
| // |
| // Every test consists of a ConformanceRequest/ConformanceResponse |
| // request/reply pair. The protocol on the pipe is simply: |
| // |
| // 1. tester sends 4-byte length N (little endian) |
| // 2. tester sends N bytes representing a ConformanceRequest proto |
| // 3. testee sends 4-byte length M (little endian) |
| // 4. testee sends M bytes representing a ConformanceResponse proto |
| |
| #include <errno.h> |
| #include <signal.h> |
| #include <sys/types.h> |
| #include <sys/wait.h> |
| #include <unistd.h> |
| |
| #include <algorithm> |
| #include <cstdio> |
| #include <cstdlib> |
| #include <cstring> |
| #include <fstream> |
| #include <future> |
| #include <vector> |
| |
| #include "absl/log/absl_log.h" |
| #include "absl/strings/str_cat.h" |
| #include "absl/strings/str_format.h" |
| #include "conformance/conformance.pb.h" |
| #include "conformance_test.h" |
| #include "google/protobuf/endian.h" |
| |
| using conformance::ConformanceResponse; |
| using google::protobuf::ConformanceTestSuite; |
| using std::string; |
| using std::vector; |
| |
| #define STRINGIFY(x) #x |
| #define TOSTRING(x) STRINGIFY(x) |
| #define CHECK_SYSCALL(call) \ |
| if (call < 0) { \ |
| perror(#call " " __FILE__ ":" TOSTRING(__LINE__)); \ |
| exit(1); \ |
| } |
| |
| namespace google { |
| namespace protobuf { |
| |
| void ParseFailureList(const char *filename, |
| conformance::FailureSet *failure_list) { |
| std::ifstream infile(filename); |
| |
| if (!infile.is_open()) { |
| fprintf(stderr, "Couldn't open failure list file: %s\n", filename); |
| exit(1); |
| } |
| |
| for (string line; getline(infile, line);) { |
| // Remove whitespace. |
| line.erase(std::remove_if(line.begin(), line.end(), ::isspace), line.end()); |
| |
| // Remove comments. |
| line = line.substr(0, line.find("#")); |
| |
| if (!line.empty()) { |
| failure_list->add_failure(line); |
| } |
| } |
| } |
| |
| void UsageError() { |
| fprintf(stderr, "Usage: conformance-test-runner [options] <test-program>\n"); |
| fprintf(stderr, "\n"); |
| fprintf(stderr, "Options:\n"); |
| fprintf(stderr, |
| " --failure_list <filename> Use to specify list of tests\n"); |
| fprintf(stderr, |
| " that are expected to fail. File\n"); |
| fprintf(stderr, |
| " should contain one test name per\n"); |
| fprintf(stderr, |
| " line. Use '#' for comments.\n"); |
| fprintf(stderr, |
| " --text_format_failure_list <filename> Use to specify list \n"); |
| fprintf(stderr, |
| " of tests that are expected to \n"); |
| fprintf(stderr, " fail in the \n"); |
| fprintf(stderr, |
| " text_format_conformance_suite. \n"); |
| fprintf(stderr, |
| " File should contain one test name \n"); |
| fprintf(stderr, |
| " per line. Use '#' for comments.\n"); |
| |
| fprintf(stderr, |
| " --enforce_recommended Enforce that recommended test\n"); |
| fprintf(stderr, |
| " cases are also passing. Specify\n"); |
| fprintf(stderr, |
| " this flag if you want to be\n"); |
| fprintf(stderr, |
| " strictly conforming to protobuf\n"); |
| fprintf(stderr, " spec.\n"); |
| fprintf(stderr, |
| " --maximum_edition <edition> Only run conformance tests up\n"); |
| fprintf(stderr, |
| " to and including the specified\n"); |
| fprintf(stderr, " edition.\n"); |
| fprintf(stderr, |
| " --output_dir <dirname> Directory to write\n" |
| " output files.\n"); |
| exit(1); |
| } |
| |
| void ForkPipeRunner::RunTest(const std::string &test_name, |
| const std::string &request, |
| std::string *response) { |
| if (child_pid_ < 0) { |
| SpawnTestProgram(); |
| } |
| current_test_name_ = test_name; |
| |
| uint32_t len = |
| internal::little_endian::FromHost(static_cast<uint32_t>(request.size())); |
| CheckedWrite(write_fd_, &len, sizeof(uint32_t)); |
| CheckedWrite(write_fd_, request.c_str(), request.size()); |
| |
| if (!TryRead(read_fd_, &len, sizeof(uint32_t))) { |
| // We failed to read from the child, assume a crash and try to reap. |
| ABSL_LOG(INFO) << "Trying to reap child, pid=" << child_pid_; |
| |
| int status = 0; |
| waitpid(child_pid_, &status, WEXITED); |
| |
| string error_msg; |
| conformance::ConformanceResponse response_obj; |
| if (WIFEXITED(status)) { |
| if (WEXITSTATUS(status) == 0) { |
| absl::StrAppendFormat(&error_msg, |
| "child timed out, killed by signal %d", |
| WTERMSIG(status)); |
| response_obj.set_timeout_error(error_msg); |
| } else { |
| absl::StrAppendFormat(&error_msg, "child exited, status=%d", |
| WEXITSTATUS(status)); |
| response_obj.set_runtime_error(error_msg); |
| } |
| } else if (WIFSIGNALED(status)) { |
| absl::StrAppendFormat(&error_msg, "child killed by signal %d", |
| WTERMSIG(status)); |
| } |
| ABSL_LOG(INFO) << error_msg; |
| child_pid_ = -1; |
| |
| response_obj.SerializeToString(response); |
| return; |
| } |
| |
| len = internal::little_endian::ToHost(len); |
| response->resize(len); |
| CheckedRead(read_fd_, (void *)response->c_str(), len); |
| } |
| |
| int ForkPipeRunner::Run(int argc, char *argv[], |
| const std::vector<ConformanceTestSuite *> &suites) { |
| if (suites.empty()) { |
| fprintf(stderr, "No test suites found.\n"); |
| return EXIT_FAILURE; |
| } |
| bool all_ok = true; |
| for (ConformanceTestSuite *suite : suites) { |
| string program; |
| std::vector<string> program_args; |
| string failure_list_filename; |
| conformance::FailureSet failure_list; |
| |
| bool performance = false; |
| for (int arg = 1; arg < argc; ++arg) { |
| if (strcmp(argv[arg], suite->GetFailureListFlagName().c_str()) == 0) { |
| if (++arg == argc) UsageError(); |
| failure_list_filename = argv[arg]; |
| ParseFailureList(argv[arg], &failure_list); |
| } else if (strcmp(argv[arg], "--performance") == 0) { |
| performance = true; |
| suite->SetPerformance(true); |
| } else if (strcmp(argv[arg], "--verbose") == 0) { |
| suite->SetVerbose(true); |
| } else if (strcmp(argv[arg], "--enforce_recommended") == 0) { |
| suite->SetEnforceRecommended(true); |
| } else if (strcmp(argv[arg], "--maximum_edition") == 0) { |
| if (++arg == argc) UsageError(); |
| Edition edition = EDITION_UNKNOWN; |
| if (!Edition_Parse(absl::StrCat("EDITION_", argv[arg]), &edition)) { |
| fprintf(stderr, "Unknown edition: %s\n", argv[arg]); |
| UsageError(); |
| } |
| suite->SetMaximumEdition(edition); |
| } else if (strcmp(argv[arg], "--output_dir") == 0) { |
| if (++arg == argc) UsageError(); |
| suite->SetOutputDir(argv[arg]); |
| } else if (argv[arg][0] == '-') { |
| bool recognized_flag = false; |
| for (ConformanceTestSuite *suite : suites) { |
| if (strcmp(argv[arg], suite->GetFailureListFlagName().c_str()) == 0) { |
| if (++arg == argc) UsageError(); |
| recognized_flag = true; |
| } |
| } |
| if (!recognized_flag) { |
| fprintf(stderr, "Unknown option: %s\n", argv[arg]); |
| UsageError(); |
| } |
| } else { |
| program += argv[arg++]; |
| while (arg < argc) { |
| program_args.push_back(argv[arg]); |
| arg++; |
| } |
| } |
| } |
| |
| ForkPipeRunner runner(program, program_args, performance); |
| |
| std::string output; |
| all_ok = all_ok && suite->RunSuite(&runner, &output, failure_list_filename, |
| &failure_list); |
| |
| fwrite(output.c_str(), 1, output.size(), stderr); |
| } |
| return all_ok ? EXIT_SUCCESS : EXIT_FAILURE; |
| } |
| |
| // TODO: make this work on Windows, instead of using these |
| // UNIX-specific APIs. |
| // |
| // There is a platform-agnostic API in |
| // src/google/protobuf/compiler/subprocess.h |
| // |
| // However that API only supports sending a single message to the subprocess. |
| // We really want to be able to send messages and receive responses one at a |
| // time: |
| // |
| // 1. Spawning a new process for each test would take way too long for thousands |
| // of tests and subprocesses like java that can take 100ms or more to start |
| // up. |
| // |
| // 2. Sending all the tests in one big message and receiving all results in one |
| // big message would take away our visibility about which test(s) caused a |
| // crash or other fatal error. It would also give us only a single failure |
| // instead of all of them. |
| void ForkPipeRunner::SpawnTestProgram() { |
| int toproc_pipe_fd[2]; |
| int fromproc_pipe_fd[2]; |
| if (pipe(toproc_pipe_fd) < 0 || pipe(fromproc_pipe_fd) < 0) { |
| perror("pipe"); |
| exit(1); |
| } |
| |
| pid_t pid = fork(); |
| if (pid < 0) { |
| perror("fork"); |
| exit(1); |
| } |
| |
| if (pid) { |
| // Parent. |
| CHECK_SYSCALL(close(toproc_pipe_fd[0])); |
| CHECK_SYSCALL(close(fromproc_pipe_fd[1])); |
| write_fd_ = toproc_pipe_fd[1]; |
| read_fd_ = fromproc_pipe_fd[0]; |
| child_pid_ = pid; |
| } else { |
| // Child. |
| CHECK_SYSCALL(close(STDIN_FILENO)); |
| CHECK_SYSCALL(close(STDOUT_FILENO)); |
| CHECK_SYSCALL(dup2(toproc_pipe_fd[0], STDIN_FILENO)); |
| CHECK_SYSCALL(dup2(fromproc_pipe_fd[1], STDOUT_FILENO)); |
| |
| CHECK_SYSCALL(close(toproc_pipe_fd[0])); |
| CHECK_SYSCALL(close(fromproc_pipe_fd[1])); |
| CHECK_SYSCALL(close(toproc_pipe_fd[1])); |
| CHECK_SYSCALL(close(fromproc_pipe_fd[0])); |
| |
| std::unique_ptr<char[]> executable(new char[executable_.size() + 1]); |
| memcpy(executable.get(), executable_.c_str(), executable_.size()); |
| executable[executable_.size()] = '\0'; |
| |
| std::vector<const char *> argv; |
| argv.push_back(executable.get()); |
| ABSL_LOG(INFO) << argv[0]; |
| for (size_t i = 0; i < executable_args_.size(); ++i) { |
| argv.push_back(executable_args_[i].c_str()); |
| ABSL_LOG(INFO) << executable_args_[i]; |
| } |
| argv.push_back(nullptr); |
| // Never returns. |
| CHECK_SYSCALL(execv(executable.get(), const_cast<char **>(argv.data()))); |
| } |
| } |
| |
| void ForkPipeRunner::CheckedWrite(int fd, const void *buf, size_t len) { |
| if (static_cast<size_t>(write(fd, buf, len)) != len) { |
| ABSL_LOG(FATAL) << current_test_name_ |
| << ": error writing to test program: " << strerror(errno); |
| } |
| } |
| |
| bool ForkPipeRunner::TryRead(int fd, void *buf, size_t len) { |
| size_t ofs = 0; |
| while (len > 0) { |
| std::future<ssize_t> future = std::async( |
| std::launch::async, |
| [](int fd, void *buf, size_t ofs, size_t len) { |
| return read(fd, (char *)buf + ofs, len); |
| }, |
| fd, buf, ofs, len); |
| std::future_status status; |
| if (performance_) { |
| status = future.wait_for(std::chrono::seconds(5)); |
| if (status == std::future_status::timeout) { |
| ABSL_LOG(ERROR) << current_test_name_ << ": timeout from test program"; |
| kill(child_pid_, SIGQUIT); |
| // TODO: Only log in flag-guarded mode, since reading output |
| // from SIGQUIT is slow and verbose. |
| std::vector<char> err; |
| err.resize(5000); |
| ssize_t err_bytes_read; |
| size_t err_ofs = 0; |
| do { |
| err_bytes_read = |
| read(fd, (void *)&err[err_ofs], err.size() - err_ofs); |
| err_ofs += err_bytes_read; |
| } while (err_bytes_read > 0 && err_ofs < err.size()); |
| ABSL_LOG(ERROR) << "child_pid_=" << child_pid_ << " SIGQUIT: \n" |
| << &err[0]; |
| return false; |
| } |
| } else { |
| future.wait(); |
| } |
| ssize_t bytes_read = future.get(); |
| if (bytes_read == 0) { |
| ABSL_LOG(ERROR) << current_test_name_ |
| << ": unexpected EOF from test program"; |
| return false; |
| } else if (bytes_read < 0) { |
| ABSL_LOG(ERROR) << current_test_name_ |
| << ": error reading from test program: " |
| << strerror(errno); |
| return false; |
| } |
| |
| len -= bytes_read; |
| ofs += bytes_read; |
| } |
| |
| return true; |
| } |
| |
| void ForkPipeRunner::CheckedRead(int fd, void *buf, size_t len) { |
| if (!TryRead(fd, buf, len)) { |
| ABSL_LOG(FATAL) << current_test_name_ |
| << ": error reading from test program: " << strerror(errno); |
| } |
| } |
| |
| } // namespace protobuf |
| } // namespace google |