Update third_party/protobuf to protobuf-v3.0.0-beta-3

third_party/protobuf/conformance/conformance_test_runner.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 37 matching lines @@
 // 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 <algorithm>
 #include <errno.h>
+#include <fstream>
+#include <sys/types.h>
+#include <sys/wait.h>
 #include <unistd.h>
-#include <fstream>
 #include <vector>
 
+#include <google/protobuf/stubs/stringprintf.h>
+
 #include "conformance.pb.h"
 #include "conformance_test.h"
 
 using conformance::ConformanceRequest;
 using conformance::ConformanceResponse;
 using google::protobuf::internal::scoped_array;
+using google::protobuf::StringAppendF;
 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); \
   }
 
 // Test runner that spawns the process being tested and communicates with it
 // over a pipe.
 class ForkPipeRunner : public google::protobuf::ConformanceTestRunner {
  public:
   ForkPipeRunner(const std::string &executable)
-      : running_(false), executable_(executable) {}
+      : child_pid_(-1), executable_(executable) {}
 
   virtual ~ForkPipeRunner() {}
 
   void RunTest(const std::string& test_name,
                const std::string& request,
                std::string* response) {
-    if (!running_) {
+    if (child_pid_ < 0) {
       SpawnTestProgram();
     }
 
     current_test_name_ = test_name;
 
     uint32_t len = request.size();
     CheckedWrite(write_fd_, &len, sizeof(uint32_t));
     CheckedWrite(write_fd_, request.c_str(), request.size());
-    CheckedRead(read_fd_, &len, sizeof(uint32_t));
+
+    if (!TryRead(read_fd_, &len, sizeof(uint32_t))) {
+      // We failed to read from the child, assume a crash and try to reap.
+      GOOGLE_LOG(INFO) << "Trying to reap child, pid=" << child_pid_;
+
+      int status;
+      waitpid(child_pid_, &status, WEXITED);
+
+      string error_msg;
+      if (WIFEXITED(status)) {
+        StringAppendF(&error_msg,
+                      "child exited, status=%d", WEXITSTATUS(status));
+      } else if (WIFSIGNALED(status)) {
+        StringAppendF(&error_msg,
+                      "child killed by signal %d", WTERMSIG(status));
+      }
+      GOOGLE_LOG(INFO) << error_msg;
+      child_pid_ = -1;
+
+      conformance::ConformanceResponse response_obj;
+      response_obj.set_runtime_error(error_msg);
+      response_obj.SerializeToString(response);
+      return;
+    }
+
     response->resize(len);
     CheckedRead(read_fd_, (void*)response->c_str(), len);
   }
 
  private:
   // TODO(haberman): 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
@@ skipping 23 matching lines @@
       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];
-      running_ = true;
+      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]));
 
       scoped_array<char> executable(new char[executable_.size() + 1]);
       memcpy(executable.get(), executable_.c_str(), executable_.size());
       executable[executable_.size()] = '\0';
 
       char *const argv[] = {executable.get(), NULL};
       CHECK_SYSCALL(execv(executable.get(), argv));  // Never returns.
     }
   }
 
   void CheckedWrite(int fd, const void *buf, size_t len) {
     if (write(fd, buf, len) != len) {
       GOOGLE_LOG(FATAL) << current_test_name_
                         << ": error writing to test program: "
                         << strerror(errno);
     }
   }
 
-  void CheckedRead(int fd, void *buf, size_t len) {
+  bool TryRead(int fd, void *buf, size_t len) {
     size_t ofs = 0;
     while (len > 0) {
       ssize_t bytes_read = read(fd, (char*)buf + ofs, len);
 
       if (bytes_read == 0) {
-        GOOGLE_LOG(FATAL) << current_test_name_
+        GOOGLE_LOG(ERROR) << current_test_name_
                           << ": unexpected EOF from test program";
+        return false;
       } else if (bytes_read < 0) {
-        GOOGLE_LOG(FATAL) << current_test_name_
+        GOOGLE_LOG(ERROR) << current_test_name_
                           << ": error reading from test program: "
                           << strerror(errno);
+        return false;
       }
 
       len -= bytes_read;
       ofs += bytes_read;
     }
+
+    return true;
+  }
+
+  void CheckedRead(int fd, void *buf, size_t len) {
+    if (!TryRead(fd, buf, len)) {
+      GOOGLE_LOG(FATAL) << current_test_name_
+                        << ": error reading from test program: "
+                        << strerror(errno);
+    }
   }
 
   int write_fd_;
   int read_fd_;
-  bool running_;
+  pid_t child_pid_;
   std::string executable_;
   std::string current_test_name_;
 };
 
 void UsageError() {
   fprintf(stderr,
           "Usage: conformance-test-runner [options] <test-program>\n");
   fprintf(stderr, "\n");
   fprintf(stderr, "Options:\n");
   fprintf(stderr,
@@ skipping 26 matching lines @@
     if (!line.empty()) {
       failure_list->push_back(line);
     }
   }
 }
 
 int main(int argc, char *argv[]) {
   char *program;
   google::protobuf::ConformanceTestSuite suite;
 
+  vector<string> failure_list;
+
   for (int arg = 1; arg < argc; ++arg) {
     if (strcmp(argv[arg], "--failure_list") == 0) {
       if (++arg == argc) UsageError();
-      vector<string> failure_list;
       ParseFailureList(argv[arg], &failure_list);
-      suite.SetFailureList(failure_list);
     } else if (strcmp(argv[arg], "--verbose") == 0) {
       suite.SetVerbose(true);
     } else if (argv[arg][0] == '-') {
       fprintf(stderr, "Unknown option: %s\n", argv[arg]);
       UsageError();
     } else {
       if (arg != argc - 1) {
         fprintf(stderr, "Too many arguments.\n");
         UsageError();
       }
       program = argv[arg];
     }
   }
 
+  suite.SetFailureList(failure_list);
   ForkPipeRunner runner(program);
 
   std::string output;
   bool ok = suite.RunSuite(&runner, &output);
 
   fwrite(output.c_str(), 1, output.size(), stderr);
 
   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
 }