PPAPI: More test cleanup

ppapi/tests/test_udp_socket_private.cc

 // Copyright (c) 2012 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 <cstring>
 #include <vector>
 
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/private/net_address_private.h"
 #include "ppapi/cpp/private/tcp_socket_private.h"
@@ skipping 36 matching lines @@
 
   return tcp_socket_private_is_available &&
       udp_socket_private_is_available &&
       net_address_private_is_available &&
       init_host_port &&
       CheckTestingInterface() &&
       EnsureRunningOverHTTP();
 }
 
 void TestUDPSocketPrivate::RunTests(const std::string& filter) {
-  RUN_TEST_FORCEASYNC_AND_NOT(Connect, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(ConnectFailure, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(Broadcast, filter);
-  RUN_TEST_FORCEASYNC_AND_NOT(SetSocketFeatureErrors, filter);
+  RUN_CALLBACK_TEST(TestUDPSocketPrivate, Connect, filter);
+  RUN_CALLBACK_TEST(TestUDPSocketPrivate, ConnectFailure, filter);
+  RUN_CALLBACK_TEST(TestUDPSocketPrivate, Broadcast, filter);
+  RUN_CALLBACK_TEST(TestUDPSocketPrivate, SetSocketFeatureErrors, filter);
 }
 
 std::string TestUDPSocketPrivate::GetLocalAddress(
     PP_NetAddress_Private* address) {
   pp::TCPSocketPrivate socket(instance_);
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket.Connect(host_.c_str(), port_, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_TCPSocket_Private::Connect force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_OK)
-    return ReportError("PPB_TCPSocket_Private::Connect", rv);
-  if (!socket.GetLocalAddress(address))
-    return "PPB_TCPSocket_Private::GetLocalAddress: Failed";
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket.Connect(host_.c_str(), port_, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
+  ASSERT_TRUE(socket.GetLocalAddress(address));
   socket.Disconnect();
   PASS();
 }
 
 std::string TestUDPSocketPrivate::SetBroadcastOptions(
     pp::UDPSocketPrivate* socket) {
   int32_t rv = socket->SetSocketFeature(PP_UDPSOCKETFEATURE_ADDRESS_REUSE,
                                         pp::Var(true));
   if (rv != PP_OK)
     return ReportError("PPB_UDPSocket_Private::SetSocketFeature", rv);
 
   rv = socket->SetSocketFeature(PP_UDPSOCKETFEATURE_BROADCAST, pp::Var(true));
   if (rv != PP_OK)
     return ReportError("PPB_UDPSocket_Private::SetSocketFeature", rv);
 
   PASS();
 }
 
 std::string TestUDPSocketPrivate::BindUDPSocket(
     pp::UDPSocketPrivate* socket,
     PP_NetAddress_Private* address) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->Bind(address, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_UDPSocket_Private::Bind force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv != PP_OK)
-    return ReportError("PPB_UDPSocket_Private::Bind", rv);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(socket->Bind(address, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_EQ(PP_OK, callback.result());
   PASS();
 }
 
 std::string TestUDPSocketPrivate::LookupPortAndBindUDPSocket(
     pp::UDPSocketPrivate* socket,
     PP_NetAddress_Private *address) {
   PP_NetAddress_Private base_address;
   ASSERT_SUBTEST_SUCCESS(GetLocalAddress(&base_address));
 
   bool is_free_port_found = false;
   for (uint16_t port = kPortScanFrom; port < kPortScanTo; ++port) {
     if (!pp::NetAddressPrivate::ReplacePort(base_address, port, address))
       return "PPB_NetAddress_Private::ReplacePort: Failed";
     if (BindUDPSocket(socket, address).empty()) {
       is_free_port_found = true;
       break;
     }
   }
   if (!is_free_port_found)
     return "Can't find available port";
   if (!socket->GetBoundAddress(address))
     return "PPB_UDPSocket_Private::GetBoundAddress: Failed";
   PASS();
 }
 
 std::string TestUDPSocketPrivate::BindUDPSocketFailure(
     pp::UDPSocketPrivate* socket,
     PP_NetAddress_Private *address) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->Bind(address, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_UDPSocket_Private::Bind force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv == PP_OK)
-    return ReportError("PPB_UDPSocket_Private::Bind", rv);
-  if (socket->GetBoundAddress(address))
-      return "PPB_UDPSocket_Private::GetBoundAddress: Failed";
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(socket->Bind(address, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_NE(PP_OK, callback.result());
+  ASSERT_FALSE(socket->GetBoundAddress(address));
   PASS();
 }
 
 std::string TestUDPSocketPrivate::ReadSocket(pp::UDPSocketPrivate* socket,
                                              PP_NetAddress_Private* address,
                                              size_t size,
                                              std::string* message) {
   std::vector<char> buffer(size);
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
-  int32_t rv = socket->RecvFrom(&buffer[0], size, callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_UDPSocket_Private::RecvFrom force_async", rv);
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv < 0 || size != static_cast<size_t>(rv))
-    return ReportError("PPB_UDPSocket_Private::RecvFrom", rv);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
+  callback.WaitForResult(
+      socket->RecvFrom(&buffer[0], size, callback.GetCallback()));
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_FALSE(callback.result() < 0);
+  ASSERT_EQ(size, static_cast<size_t>(callback.result()));
   message->assign(buffer.begin(), buffer.end());
   PASS();
 }
 
 std::string TestUDPSocketPrivate::PassMessage(pp::UDPSocketPrivate* target,
                                               pp::UDPSocketPrivate* source,
                                               PP_NetAddress_Private* address,
                                               const std::string& message) {
-  TestCompletionCallback callback(instance_->pp_instance(), force_async_);
+  TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   int32_t rv = source->SendTo(message.c_str(), message.size(), address,
                               callback.GetCallback());
-  if (force_async_ && rv != PP_OK_COMPLETIONPENDING)
-    return ReportError("PPB_UDPSocket_Private::SendTo force_async", rv);
-
   std::string str;
   ASSERT_SUBTEST_SUCCESS(ReadSocket(target, address, message.size(), &str));
 
-  if (rv == PP_OK_COMPLETIONPENDING)
-    rv = callback.WaitForResult();
-  if (rv < 0 || message.size() != static_cast<size_t>(rv))
-    return ReportError("PPB_UDPSocket_Private::SendTo", rv);
-
+  callback.WaitForResult(rv);
+  CHECK_CALLBACK_BEHAVIOR(callback);
+  ASSERT_FALSE(callback.result() < 0);
+  ASSERT_EQ(message.size(), static_cast<size_t>(callback.result()));
   ASSERT_EQ(message, str);
   PASS();
 }
 
 std::string TestUDPSocketPrivate::TestConnect() {
   pp::UDPSocketPrivate server_socket(instance_), client_socket(instance_);
   PP_NetAddress_Private server_address, client_address;
 
   ASSERT_SUBTEST_SUCCESS(LookupPortAndBindUDPSocket(&server_socket,
                                                     &server_address));
@@ skipping 76 matching lines @@
   // Try to pass incorrect feature name.
   int32_t rv = socket.SetSocketFeature(PP_UDPSOCKETFEATURE_COUNT,
                                        pp::Var(true));
   ASSERT_EQ(PP_ERROR_BADARGUMENT, rv);
 
   // Try to pass incorrect feature value's type.
   rv = socket.SetSocketFeature(PP_UDPSOCKETFEATURE_ADDRESS_REUSE, pp::Var(1));
   ASSERT_EQ(PP_ERROR_BADARGUMENT, rv);
   PASS();
 }