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

ppapi/tests/test_post_message.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/test_post_message.h"
 
 #include <algorithm>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/c/pp_var.h"
@@ skipping 88 matching lines @@
   success = success && AddEchoingListener("message_event.data");
   message_data_.clear();
   // Send a message that the first test will expect to receive. This is to
   // verify that we can send messages when the 'Instance::Init' function is on
   // the stack.
   instance_->PostMessage(pp::Var(kTestString));
 
   return success;
 }
 
-void TestPostMessage::RunTest() {
+void TestPostMessage::RunTests(const std::string& filter) {
   // Note: SendInInit must be first, because it expects to receive a message
   // that was sent in Init above.
-  RUN_TEST(SendInInit);
-  RUN_TEST(SendingData);
-  RUN_TEST(MessageEvent);
-  RUN_TEST(NoHandler);
-  RUN_TEST(ExtraParam);
+  RUN_TEST(SendInInit, filter);
+  RUN_TEST(SendingData, filter);
+  RUN_TEST(MessageEvent, filter);
+  RUN_TEST(NoHandler, filter);
+  RUN_TEST(ExtraParam, filter);
   if (testing_interface_->IsOutOfProcess())
-    RUN_TEST(NonMainThread);
+    RUN_TEST(NonMainThread, filter);
 }
 
 void TestPostMessage::HandleMessage(const pp::Var& message_data) {
   if (message_data.is_string() &&
       (message_data.AsString() == FINISHED_WAITING_MESSAGE))
     testing_interface_->QuitMessageLoop(instance_->pp_instance());
   else
     message_data_.push_back(message_data);
 }
 
@@ skipping 50 matching lines @@
 std::string TestPostMessage::TestSendInInit() {
   ASSERT_EQ(WaitForMessages(), 1);
   // This test assumes Init already sent a message.
   ASSERT_EQ(message_data_.size(), 1);
   ASSERT_TRUE(message_data_.back().is_string());
   ASSERT_EQ(message_data_.back().AsString(), kTestString);
   PASS();
 }
 
 std::string TestPostMessage::TestSendingData() {
+  // Clean up after previous tests. This also swallows the message sent by Init
+  // if we didn't run the 'SendInInit' test. All tests other than 'SendInInit'
+  // should start with these.
+  WaitForMessages();
+  ASSERT_TRUE(ClearListeners());
   // Set up the JavaScript message event listener to echo the data part of the
   // message event back to us.
-  ASSERT_TRUE(ClearListeners());
   ASSERT_TRUE(AddEchoingListener("message_event.data"));
 
   // Test sending a message to JavaScript for each supported type.  The JS sends
   // the data back to us, and we check that they match.
   message_data_.clear();
   instance_->PostMessage(pp::Var(kTestString));
   // PostMessage is asynchronous, so we should not receive a response yet.
   ASSERT_EQ(message_data_.size(), 0);
   ASSERT_EQ(WaitForMessages(), 1);
   ASSERT_TRUE(message_data_.back().is_string());
@@ skipping 35 matching lines @@
 
   ASSERT_TRUE(ClearListeners());
 
   PASS();
 }
 
 std::string TestPostMessage::TestMessageEvent() {
   // Set up the JavaScript message event listener to pass us some values from
   // the MessageEvent and make sure they match our expectations.
 
+  WaitForMessages();
+  ASSERT_TRUE(ClearListeners());
   // Have the listener pass back the type of message_event and make sure it's
   // "object".
-  ASSERT_TRUE(ClearListeners());
   ASSERT_TRUE(AddEchoingListener("typeof(message_event)"));
   message_data_.clear();
   instance_->PostMessage(pp::Var(kTestInt));
   ASSERT_EQ(message_data_.size(), 0);
   ASSERT_EQ(WaitForMessages(), 1);
   ASSERT_TRUE(message_data_.back().is_string());
   ASSERT_EQ(message_data_.back().AsString(), "object");
   ASSERT_TRUE(ClearListeners());
 
   // Make sure all the non-data properties have the expected values.
@@ skipping 32 matching lines @@
   std::vector<double> double_vec;
   for (; iter != the_end; ++iter) {
     ASSERT_TRUE(iter->is_number());
     double_vec.push_back(iter->AsDouble());
   }
   std::sort(double_vec.begin(), double_vec.end());
   ASSERT_DOUBLE_EQ(double_vec[0], 1.0);
   ASSERT_DOUBLE_EQ(double_vec[1], 2.0);
   ASSERT_DOUBLE_EQ(double_vec[2], 3.0);
 
-  ASSERT_TRUE(ClearListeners());
-
   PASS();
 }
 
 std::string TestPostMessage::TestNoHandler() {
-  // Delete any lingering event listeners.
+  // Delete any lingering messages and event listeners.
+  WaitForMessages();
   ASSERT_TRUE(ClearListeners());
 
   // Now send a message.  We shouldn't get a response.
   message_data_.clear();
   instance_->PostMessage(pp::Var());
   ASSERT_EQ(WaitForMessages(), 0);
   ASSERT_TRUE(message_data_.empty());
 
   PASS();
 }
 
 std::string TestPostMessage::TestExtraParam() {
-  // Delete any lingering event listeners.
+  // Delete any lingering messages and event listeners.
+  WaitForMessages();
   ASSERT_TRUE(ClearListeners());
   // Add a listener that will respond with 1 and an empty array (where the
   // message port array would appear if it was Worker postMessage).
   ASSERT_TRUE(AddEchoingListener("1, []"));
 
   // Now send a message.  We shouldn't get a response.
   message_data_.clear();
   instance_->PostMessage(pp::Var());
   ASSERT_EQ(WaitForMessages(), 0);
   ASSERT_TRUE(message_data_.empty());
 
   PASS();
 }
 
 std::string TestPostMessage::TestNonMainThread() {
+  WaitForMessages();
   ASSERT_TRUE(ClearListeners());
   ASSERT_TRUE(AddEchoingListener("message_event.data"));
   message_data_.clear();
 
   // Set up a thread for each integer from 0 to (kThreadsToRun - 1).  Make each
   // thread send the number that matches its index kMessagesToSendPerThread
   // times.  For good measure, call postMessage from the main thread
   // kMessagesToSendPerThread times. At the end, we make sure we got all the
   // values we expected.
   PP_ThreadType threads[kThreadsToRun];
@@ skipping 34 matching lines @@
     }
     ASSERT_TRUE(received_value >= 0);
     ASSERT_TRUE(received_value <= kThreadsToRun);
     ++received_counts[received_value];
   }
   ASSERT_EQ(received_counts, expected_counts);
 
   PASS();
 }