1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31 // This file contains a program for running the test suite in a separate
32 // process. The other alternative is to run the suite in-process. See
33 // conformance.proto for pros/cons of these two options.
34 //
35 // This program will fork the process under test and communicate with it over
36 // its stdin/stdout:
37 //
38 // +--------+ pipe +----------+
39 // | tester | <------> | testee |
40 // | | | |
41 // | C++ | | any lang |
42 // +--------+ +----------+
43 //
44 // The tester contains all of the test cases and their expected output.
45 // The testee is a simple program written in the target language that reads
46 // each test case and attempts to produce acceptable output for it.
47 //
48 // Every test consists of a ConformanceRequest/ConformanceResponse
49 // request/reply pair. The protocol on the pipe is simply:
50 //
51 // 1. tester sends 4-byte length N (little endian)
52 // 2. tester sends N bytes representing a ConformanceRequest proto
53 // 3. testee sends 4-byte length M (little endian)
54 // 4. testee sends M bytes representing a ConformanceResponse proto
55
56 #include <algorithm>
57 #include <errno.h>
58 #include <fstream>
59 #include <sys/types.h>
60 #include <sys/wait.h>
61 #include <unistd.h>
62 #include <vector>
63
64 #include <google/protobuf/stubs/stringprintf.h>
65
66 #include "conformance.pb.h"
67 #include "conformance_test.h"
68
69 using conformance::ConformanceResponse;
70 using google::protobuf::StringAppendF;
71 using google::protobuf::ConformanceTestSuite;
72 using std::string;
73 using std::vector;
74
75 #define STRINGIFY(x) #x
76 #define TOSTRING(x) STRINGIFY(x)
77 #define CHECK_SYSCALL(call) \
78 if (call < 0) { \
79 perror(#call " " __FILE__ ":" TOSTRING(__LINE__)); \
80 exit(1); \
81 }
82
83 namespace google {
84 namespace protobuf {
85
ParseFailureList(const char * filename,conformance::FailureSet * failure_list)86 void ParseFailureList(const char *filename,
87 conformance::FailureSet *failure_list) {
88 std::ifstream infile(filename);
89
90 if (!infile.is_open()) {
91 fprintf(stderr, "Couldn't open failure list file: %s\n", filename);
92 exit(1);
93 }
94
95 for (string line; getline(infile, line);) {
96 // Remove whitespace.
97 line.erase(std::remove_if(line.begin(), line.end(), ::isspace),
98 line.end());
99
100 // Remove comments.
101 line = line.substr(0, line.find("#"));
102
103 if (!line.empty()) {
104 failure_list->add_failure(line);
105 }
106 }
107 }
108
UsageError()109 void UsageError() {
110 fprintf(stderr,
111 "Usage: conformance-test-runner [options] <test-program>\n");
112 fprintf(stderr, "\n");
113 fprintf(stderr, "Options:\n");
114 fprintf(stderr,
115 " --failure_list <filename> Use to specify list of tests\n");
116 fprintf(stderr,
117 " that are expected to fail. File\n");
118 fprintf(stderr,
119 " should contain one test name per\n");
120 fprintf(stderr,
121 " line. Use '#' for comments.\n");
122 fprintf(stderr,
123 " --text_format_failure_list <filename> Use to specify list \n");
124 fprintf(stderr,
125 " of tests that are expected to \n");
126 fprintf(stderr,
127 " fail in the \n");
128 fprintf(stderr,
129 " text_format_conformance_suite. \n");
130 fprintf(stderr,
131 " File should contain one test name \n");
132 fprintf(stderr,
133 " per line. Use '#' for comments.\n");
134
135 fprintf(stderr,
136 " --enforce_recommended Enforce that recommended test\n");
137 fprintf(stderr,
138 " cases are also passing. Specify\n");
139 fprintf(stderr,
140 " this flag if you want to be\n");
141 fprintf(stderr,
142 " strictly conforming to protobuf\n");
143 fprintf(stderr,
144 " spec.\n");
145 exit(1);
146 }
147
RunTest(const std::string & test_name,const std::string & request,std::string * response)148 void ForkPipeRunner::RunTest(
149 const std::string& test_name,
150 const std::string& request,
151 std::string* response) {
152 if (child_pid_ < 0) {
153 SpawnTestProgram();
154 }
155
156 current_test_name_ = test_name;
157
158 uint32_t len = request.size();
159 CheckedWrite(write_fd_, &len, sizeof(uint32_t));
160 CheckedWrite(write_fd_, request.c_str(), request.size());
161
162 if (!TryRead(read_fd_, &len, sizeof(uint32_t))) {
163 // We failed to read from the child, assume a crash and try to reap.
164 GOOGLE_LOG(INFO) << "Trying to reap child, pid=" << child_pid_;
165
166 int status;
167 waitpid(child_pid_, &status, WEXITED);
168
169 string error_msg;
170 if (WIFEXITED(status)) {
171 StringAppendF(&error_msg,
172 "child exited, status=%d", WEXITSTATUS(status));
173 } else if (WIFSIGNALED(status)) {
174 StringAppendF(&error_msg,
175 "child killed by signal %d", WTERMSIG(status));
176 }
177 GOOGLE_LOG(INFO) << error_msg;
178 child_pid_ = -1;
179
180 conformance::ConformanceResponse response_obj;
181 response_obj.set_runtime_error(error_msg);
182 response_obj.SerializeToString(response);
183 return;
184 }
185
186 response->resize(len);
187 CheckedRead(read_fd_, (void*)response->c_str(), len);
188 }
189
Run(int argc,char * argv[],const std::vector<ConformanceTestSuite * > & suites)190 int ForkPipeRunner::Run(
191 int argc, char *argv[], const std::vector<ConformanceTestSuite*>& suites) {
192 if (suites.empty()) {
193 fprintf(stderr, "No test suites found.\n");
194 return EXIT_FAILURE;
195 }
196 bool all_ok = true;
197 for (ConformanceTestSuite* suite : suites) {
198 char *program;
199 string failure_list_filename;
200 conformance::FailureSet failure_list;
201
202 for (int arg = 1; arg < argc; ++arg) {
203 if (strcmp(argv[arg], suite->GetFailureListFlagName().c_str()) == 0) {
204 if (++arg == argc) UsageError();
205 failure_list_filename = argv[arg];
206 ParseFailureList(argv[arg], &failure_list);
207 } else if (strcmp(argv[arg], "--verbose") == 0) {
208 suite->SetVerbose(true);
209 } else if (strcmp(argv[arg], "--enforce_recommended") == 0) {
210 suite->SetEnforceRecommended(true);
211 } else if (argv[arg][0] == '-') {
212 bool recognized_flag = false;
213 for (ConformanceTestSuite* suite : suites) {
214 if (strcmp(argv[arg], suite->GetFailureListFlagName().c_str()) == 0) {
215 if (++arg == argc) UsageError();
216 recognized_flag = true;
217 }
218 }
219 if (!recognized_flag) {
220 fprintf(stderr, "Unknown option: %s\n", argv[arg]);
221 UsageError();
222 }
223 } else {
224 if (arg != argc - 1) {
225 fprintf(stderr, "Too many arguments.\n");
226 UsageError();
227 }
228 program = argv[arg];
229 }
230 }
231
232 ForkPipeRunner runner(program);
233
234 std::string output;
235 all_ok = all_ok &&
236 suite->RunSuite(&runner, &output, failure_list_filename, &failure_list);
237
238 fwrite(output.c_str(), 1, output.size(), stderr);
239 }
240 return all_ok ? EXIT_SUCCESS : EXIT_FAILURE;
241 }
242
243 // TODO(haberman): make this work on Windows, instead of using these
244 // UNIX-specific APIs.
245 //
246 // There is a platform-agnostic API in
247 // src/google/protobuf/compiler/subprocess.h
248 //
249 // However that API only supports sending a single message to the subprocess.
250 // We really want to be able to send messages and receive responses one at a
251 // time:
252 //
253 // 1. Spawning a new process for each test would take way too long for thousands
254 // of tests and subprocesses like java that can take 100ms or more to start
255 // up.
256 //
257 // 2. Sending all the tests in one big message and receiving all results in one
258 // big message would take away our visibility about which test(s) caused a
259 // crash or other fatal error. It would also give us only a single failure
260 // instead of all of them.
SpawnTestProgram()261 void ForkPipeRunner::SpawnTestProgram() {
262 int toproc_pipe_fd[2];
263 int fromproc_pipe_fd[2];
264 if (pipe(toproc_pipe_fd) < 0 || pipe(fromproc_pipe_fd) < 0) {
265 perror("pipe");
266 exit(1);
267 }
268
269 pid_t pid = fork();
270 if (pid < 0) {
271 perror("fork");
272 exit(1);
273 }
274
275 if (pid) {
276 // Parent.
277 CHECK_SYSCALL(close(toproc_pipe_fd[0]));
278 CHECK_SYSCALL(close(fromproc_pipe_fd[1]));
279 write_fd_ = toproc_pipe_fd[1];
280 read_fd_ = fromproc_pipe_fd[0];
281 child_pid_ = pid;
282 } else {
283 // Child.
284 CHECK_SYSCALL(close(STDIN_FILENO));
285 CHECK_SYSCALL(close(STDOUT_FILENO));
286 CHECK_SYSCALL(dup2(toproc_pipe_fd[0], STDIN_FILENO));
287 CHECK_SYSCALL(dup2(fromproc_pipe_fd[1], STDOUT_FILENO));
288
289 CHECK_SYSCALL(close(toproc_pipe_fd[0]));
290 CHECK_SYSCALL(close(fromproc_pipe_fd[1]));
291 CHECK_SYSCALL(close(toproc_pipe_fd[1]));
292 CHECK_SYSCALL(close(fromproc_pipe_fd[0]));
293
294 std::unique_ptr<char[]> executable(new char[executable_.size() + 1]);
295 memcpy(executable.get(), executable_.c_str(), executable_.size());
296 executable[executable_.size()] = '\0';
297
298 char *const argv[] = {executable.get(), NULL};
299 CHECK_SYSCALL(execv(executable.get(), argv)); // Never returns.
300 }
301 }
302
CheckedWrite(int fd,const void * buf,size_t len)303 void ForkPipeRunner::CheckedWrite(int fd, const void *buf, size_t len) {
304 if (write(fd, buf, len) != len) {
305 GOOGLE_LOG(FATAL) << current_test_name_
306 << ": error writing to test program: "
307 << strerror(errno);
308 }
309 }
310
TryRead(int fd,void * buf,size_t len)311 bool ForkPipeRunner::TryRead(int fd, void *buf, size_t len) {
312 size_t ofs = 0;
313 while (len > 0) {
314 ssize_t bytes_read = read(fd, (char*)buf + ofs, len);
315
316 if (bytes_read == 0) {
317 GOOGLE_LOG(ERROR) << current_test_name_
318 << ": unexpected EOF from test program";
319 return false;
320 } else if (bytes_read < 0) {
321 GOOGLE_LOG(ERROR) << current_test_name_
322 << ": error reading from test program: "
323 << strerror(errno);
324 return false;
325 }
326
327 len -= bytes_read;
328 ofs += bytes_read;
329 }
330
331 return true;
332 }
333
CheckedRead(int fd,void * buf,size_t len)334 void ForkPipeRunner::CheckedRead(int fd, void *buf, size_t len) {
335 if (!TryRead(fd, buf, len)) {
336 GOOGLE_LOG(FATAL) << current_test_name_
337 << ": error reading from test program: "
338 << strerror(errno);
339 }
340 }
341
342 } // namespace protobuf
343 } // namespace google
344