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

ppapi/tests/test_case.h

 // 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.
 
 #ifndef PPAPI_TESTS_TEST_CASE_H_
 #define PPAPI_TESTS_TEST_CASE_H_
 
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 19 matching lines @@
 // Individual classes of tests derive from this generic test case.
 class TestCase {
  public:
   explicit TestCase(TestingInstance* instance);
   virtual ~TestCase();
 
   // Optionally override to do testcase specific initialization.
   // Default implementation just returns true.
   virtual bool Init();
 
-  // Override to implement the test. It will be called after the plugin is
-  // first displayed.
-  virtual void RunTest() = 0;
+  // Override to implement the test case. It will be called after the plugin is
+  // first displayed, passing a string. If the string is empty, the
+  // should run all tests for this test case. Otherwise, it should run the test
+  // whose name matches test_filter exactly (if there is one). This should
+  // generally be implemented using the RUN_TEST* macros.
+  virtual void RunTests(const std::string& test_filter) = 0;
 
   static std::string MakeFailureMessage(const char* file, int line,
                                         const char* cmd);
 
 #if !(defined __native_client__)
   // Returns the scriptable test object for the current test, if any.
   // Internally, this uses CreateTestObject which each test overrides.
   pp::VarPrivate GetTestObject();
 #endif
 
@@ skipping 23 matching lines @@
   // caller. Return NULL if there is no supported test object (the default).
   virtual pp::deprecated::ScriptableObject* CreateTestObject();
 #endif
 
   // Initializes the testing interface.
   bool InitTestingInterface();
 
   // Makes sure the test is run over HTTP.
   bool EnsureRunningOverHTTP();
 
+  // Return true if the given test name matches the filter. This is true if
+  // (a) filter is empty or (b) test_name and filter match exactly.
+  bool MatchesFilter(const std::string& test_name, const std::string& filter);
+
   // Pointer to the instance that owns us.
   TestingInstance* instance_;
 
   // NULL unless InitTestingInterface is called.
   const PPB_Testing_Dev* testing_interface_;
 
   // Force asynchronous completion of any operation taking a callback.
   bool force_async_;
 
  private:
@@ skipping 37 matching lines @@
   static TestCase* Test##name##_FactoryMethod(TestingInstance* instance) {  \
     return new Test##name(instance);                                        \
   }                                                                         \
   static TestCaseFactory g_Test##name_factory(                              \
     #name, &Test##name##_FactoryMethod                                      \
   )
 
 // Helper macro for calling functions implementing specific tests in the
 // RunTest function. This assumes the function name is TestFoo where Foo is the
 // test |name|.
-#define RUN_TEST(name) \
-  do { \
+#define RUN_TEST(name, test_filter) \
+  if (MatchesFilter(#name, test_filter)) { \
     force_async_ = false; \
     instance_->LogTest(#name, Test##name()); \
-  } while (false)
+  }
 
 // Like RUN_TEST above but forces functions taking callbacks to complete
 // asynchronously on success or error.
-#define RUN_TEST_FORCEASYNC(name) \
-  do { \
+#define RUN_TEST_FORCEASYNC(name, test_filter) \
+  if (MatchesFilter(#name"ForceAsync", test_filter)) { \
     force_async_ = true; \
     instance_->LogTest(#name"ForceAsync", Test##name()); \
-  } while (false)
+  }
 
-#define RUN_TEST_FORCEASYNC_AND_NOT(name) \
+#define RUN_TEST_FORCEASYNC_AND_NOT(name, test_filter) \
   do { \
-    RUN_TEST_FORCEASYNC(name); \
-    RUN_TEST(name); \
+    RUN_TEST_FORCEASYNC(name, test_filter); \
+    RUN_TEST(name, test_filter); \
   } while (false)
 
 
 // Helper macros for checking values in tests, and returning a location
 // description of the test fails.
 #define ASSERT_TRUE(cmd) \
   if (!(cmd)) { \
     return MakeFailureMessage(__FILE__, __LINE__, #cmd); \
   }
 #define ASSERT_FALSE(cmd) ASSERT_TRUE(!(cmd))
 #define ASSERT_EQ(a, b) ASSERT_TRUE((a) == (b))
 #define ASSERT_NE(a, b) ASSERT_TRUE((a) != (b))
 
 #define ASSERT_DOUBLE_EQ(a, b) ASSERT_TRUE( \
     std::fabs((a)-(b)) <= std::numeric_limits<double>::epsilon())
 
 #define PASS() return std::string()
 
 #endif  // PPAPI_TESTS_TEST_CASE_H_