Make it possible to enable/disable specific ppapi tests. Migrate PostMessage tests.

ppapi/tests/testing_instance.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/tests/testing_instance.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 #include <vector>
@@ skipping 38 matching lines @@
     }
     else if (std::strcmp(argn[i], "protocol") == 0)
       protocol_ = argv[i];
   }
   // Create the proper test case from the argument.
   for (uint32_t i = 0; i < argc; i++) {
     if (std::strcmp(argn[i], "testcase") == 0) {
       if (argv[i][0] == '\0')
         break;
       current_case_ = CaseForTestName(argv[i]);
+      test_filter_ = FilterForTestName(argv[i]);
       if (!current_case_)
         errors_.append(std::string("Unknown test case ") + argv[i]);
       else if (!current_case_->Init())
         errors_.append(" Test case could not initialize.");
       return true;
     }
   }
 
   // In DidChangeView, we'll dump out a list of all available tests.
   return true;
@@ skipping 68 matching lines @@
   PostMessage(pp::Var("TESTING_MESSAGE:ClearConsole"));
 
   if (!errors_.empty()) {
     // Catch initialization errors and output the current error string to
     // the console.
     LogError("Plugin initialization failed: " + errors_);
   } else if (!current_case_) {
     LogAvailableTests();
     errors_.append("FAIL: Only listed tests");
   } else {
-    current_case_->RunTest();
+    current_case_->RunTests(test_filter_);
     // Automated PyAuto tests rely on finding the exact strings below.
     LogHTML(errors_.empty() ?
             "<span class=\"pass\">[SHUTDOWN]</span> All tests passed." :
             "<span class=\"fail\">[SHUTDOWN]</span> Some tests failed.");
   }
 
   // Declare we're done by setting a cookie to either "PASS" or the errors.
   ReportProgress(errors_.empty() ? "PASS" : errors_);
   PostMessage(pp::Var("TESTING_MESSAGE:DidExecuteTests"));
 }
 
-TestCase* TestingInstance::CaseForTestName(const char* name) {
+TestCase* TestingInstance::CaseForTestName(const std::string& name) {
+  std::string case_name = name.substr(0, name.find_first_of('_'));
   TestCaseFactory* iter = TestCaseFactory::head_;
   while (iter != NULL) {
-    if (std::strcmp(name, iter->name_) == 0)
+    if (case_name == iter->name_)
       return iter->method_(this);
     iter = iter->next_;
   }
   return NULL;
 }
 
+std::string TestingInstance::FilterForTestName(const std::string& name) {

[darin (slow to review), 2011/11/07 23:33:11]

hmm... maybe calling this a filter is a bit too generic, when in reality it is
just the name of the test within the test group.  maybe it would help to just
have a good name for these two terms.  maybe look at what gtest calls them
(group == gtest file)?

+  size_t delim = name.find_first_of('_');
+  if (delim != std::string::npos)
+    return name.substr(delim+1);
+  return "";
+}
+
 void TestingInstance::LogAvailableTests() {
   // Print out a listing of all tests.
   std::vector<std::string> test_cases;
   TestCaseFactory* iter = TestCaseFactory::head_;
   while (iter != NULL) {
     test_cases.push_back(iter->name_);
     iter = iter->next_;
   }
   std::sort(test_cases.begin(), test_cases.end());
 
@@ skipping 55 matching lines @@
   }
 };
 
 namespace pp {
 
 Module* CreateModule() {
   return new ::Module();
 }
 
 }  // namespace pp