content/common/sandbox_mac_unittest_helper.mm

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/common/sandbox_mac_unittest_helper.h"
   6
   7 extern "C" {
   8 #include <sandbox.h>
   9 }
  10
  11 #include <map>
  12
  13 #include "base/files/file_path.h"
  14 #include "base/logging.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/process/kill.h"
  17 #include "content/common/sandbox_mac.h"
  18 #include "content/test/test_content_client.h"
  19 #include "testing/multiprocess_func_list.h"
  20
  21 namespace content {
  22 namespace {
  23
  24 const char* kSandboxTypeKey = "CHROMIUM_SANDBOX_SANDBOX_TYPE";
  25 const char* kSandboxTestNameKey = "CHROMIUM_SANDBOX_TEST_NAME";
  26 const char* kTestDataKey = "CHROMIUM_SANDBOX_USER_DATA";
  27
  28 }  // namespace
  29
  30 // Support infrastructure for REGISTER_SANDBOX_TEST_CASE macro.
  31 namespace internal {
  32
  33 typedef std::map<std::string,MacSandboxTestCase*> SandboxTestMap;
  34
  35 // A function that returns a common map from string -> test case class.
  36 SandboxTestMap& GetSandboxTestMap() {
  37   static SandboxTestMap test_map;
  38   return test_map;
  39 }
  40
  41 void AddSandboxTestCase(const char* test_name, MacSandboxTestCase* test_class) {
  42   SandboxTestMap& test_map = GetSandboxTestMap();
  43   if (test_map.find(test_name) != test_map.end()) {
  44     LOG(ERROR) << "Trying to register duplicate test" << test_name;
  45     NOTREACHED();
  46   }
  47   test_map[test_name] = test_class;
  48 }
  49
  50 }  // namespace internal
  51
  52 bool MacSandboxTest::RunTestInAllSandboxTypes(const char* test_name,
  53                                               const char* test_data) {
  54   // Go through all the sandbox types, and run the test case in each of them
  55   // if one fails, abort.
  56   for(int i = static_cast<int>(SANDBOX_TYPE_FIRST_TYPE);
  57       i < SANDBOX_TYPE_AFTER_LAST_TYPE;
  58       ++i) {
  59
  60     if (!RunTestInSandbox(static_cast<SandboxType>(i),
  61             test_name, test_data)) {
  62       LOG(ERROR) << "Sandboxed test (" << test_name << ")" <<
  63           "Failed in sandbox type " << i <<
  64           "user data: (" << test_data << ")";
  65       return false;
  66     }
  67   }
  68  return true;
  69 }
  70
  71 bool MacSandboxTest::RunTestInSandbox(SandboxType sandbox_type,
  72                                       const char* test_name,
  73                                       const char* test_data) {
  74   std::stringstream s;
  75   s << static_cast<int>(static_cast<int>(sandbox_type));
  76   setenv(kSandboxTypeKey, s.str().c_str(), 1);
  77   setenv(kSandboxTestNameKey, test_name, 1);
  78   if (test_data)
  79     setenv(kTestDataKey, test_data, 1);
  80
  81   base::ProcessHandle child_process = SpawnChild("mac_sandbox_test_runner");
  82   if (child_process == base::kNullProcessHandle) {
  83     LOG(WARNING) << "SpawnChild failed";
  84     return false;
  85   }
  86   int code = -1;
  87   if (!base::WaitForExitCode(child_process, &code)) {
  88     LOG(WARNING) << "base::WaitForExitCode failed";
  89     return false;
  90   }
  91   return code == 0;
  92 }
  93
  94 bool MacSandboxTestCase::BeforeSandboxInit() {
  95   return true;
  96 }
  97
  98 void MacSandboxTestCase::SetTestData(const char* test_data) {
  99   test_data_ = test_data;
 100 }
 101
 102 // Given a test name specified by |name| return that test case.
 103 // If no test case is found for the given name, return NULL.
 104 MacSandboxTestCase *SandboxTestForName(const char* name) {
 105   using internal::SandboxTestMap;
 106   using internal::GetSandboxTestMap;
 107
 108   SandboxTestMap all_tests = GetSandboxTestMap();
 109
 110   SandboxTestMap::iterator it = all_tests.find(name);
 111   if (it == all_tests.end()) {
 112     LOG(ERROR) << "Couldn't find sandbox test case(" << name << ")";
 113     return NULL;
 114   }
 115
 116   return it->second;
 117 }
 118
 119 // Main function for driver process that enables the sandbox and runs test
 120 // code.
 121 MULTIPROCESS_TEST_MAIN(mac_sandbox_test_runner) {
 122   TestContentClient content_client;
 123   SetContentClient(&content_client);
 124   // Extract parameters.
 125   char* sandbox_type_str = getenv(kSandboxTypeKey);
 126   if (!sandbox_type_str) {
 127     LOG(ERROR) << "Sandbox type not specified";
 128     return -1;
 129   }
 130   SandboxType sandbox_type = static_cast<SandboxType>(atoi(sandbox_type_str));
 131   char* sandbox_test_name = getenv(kSandboxTestNameKey);
 132   if (!sandbox_test_name) {
 133     LOG(ERROR) << "Sandbox test name not specified";
 134     return -1;
 135   }
 136
 137   const char* test_data = getenv(kTestDataKey);
 138
 139   // Find Test Function to run;
 140   scoped_ptr<MacSandboxTestCase>
 141       test_case(SandboxTestForName(sandbox_test_name));
 142   if (!test_case) {
 143     LOG(ERROR) << "Invalid sandbox test name (" << sandbox_test_name << ")";
 144     return -1;
 145   }
 146   if (test_data)
 147     test_case->SetTestData(test_data);
 148
 149   // Run Test.
 150   if (!test_case->BeforeSandboxInit()) {
 151     LOG(ERROR) << sandbox_test_name << "Failed test before sandbox init";
 152     return -1;
 153   }
 154
 155   Sandbox::SandboxWarmup(sandbox_type);
 156
 157   if (!Sandbox::EnableSandbox(sandbox_type, base::FilePath())) {
 158     LOG(ERROR) << "Failed to initialize sandbox " << sandbox_type;
 159     return -1;
 160   }
 161
 162   if (!test_case->SandboxedTest()) {
 163     LOG(ERROR) << sandbox_test_name << "Failed sandboxed test";
 164     return -1;
 165   }
 166
 167   return 0;
 168 }
 169
 170 }  // namespace content