Home | History | Annotate | Download | only in tests
      1 // Copyright 2013 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 "ppapi/tests/test_host_resolver.h"
      6 
      7 #include "ppapi/cpp/host_resolver.h"
      8 #include "ppapi/cpp/net_address.h"
      9 #include "ppapi/cpp/tcp_socket.h"
     10 #include "ppapi/cpp/var.h"
     11 #include "ppapi/tests/test_utils.h"
     12 #include "ppapi/tests/testing_instance.h"
     13 
     14 REGISTER_TEST_CASE(HostResolver);
     15 
     16 TestHostResolver::TestHostResolver(TestingInstance* instance)
     17     : TestCase(instance) {
     18 }
     19 
     20 bool TestHostResolver::Init() {
     21   bool host_resolver_is_available = pp::HostResolver::IsAvailable();
     22   if (!host_resolver_is_available)
     23     instance_->AppendError("PPB_HostResolver interface not available");
     24 
     25   bool tcp_socket_is_available = pp::TCPSocket::IsAvailable();
     26   if (!tcp_socket_is_available)
     27     instance_->AppendError("PPB_TCPSocket interface not available");
     28 
     29   bool init_host_port =
     30       GetLocalHostPort(instance_->pp_instance(), &host_, &port_);
     31   if (!init_host_port)
     32     instance_->AppendError("Can't init host and port");
     33 
     34   return host_resolver_is_available &&
     35       tcp_socket_is_available &&
     36       init_host_port &&
     37       CheckTestingInterface() &&
     38       EnsureRunningOverHTTP();
     39 }
     40 
     41 void TestHostResolver::RunTests(const std::string& filter) {
     42   RUN_TEST(Empty, filter);
     43   RUN_CALLBACK_TEST(TestHostResolver, Resolve, filter);
     44   RUN_CALLBACK_TEST(TestHostResolver, ResolveIPv4, filter);
     45 }
     46 
     47 std::string TestHostResolver::SyncConnect(
     48     pp::TCPSocket* socket,
     49     const pp::NetAddress& address) {
     50   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
     51   callback.WaitForResult(socket->Connect(address, callback.GetCallback()));
     52   CHECK_CALLBACK_BEHAVIOR(callback);
     53   ASSERT_EQ(PP_OK, callback.result());
     54   PASS();
     55 }
     56 
     57 std::string TestHostResolver::SyncRead(pp::TCPSocket* socket,
     58                                        char* buffer,
     59                                        int32_t num_bytes,
     60                                        int32_t* bytes_read) {
     61   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
     62   callback.WaitForResult(
     63       socket->Read(buffer, num_bytes, callback.GetCallback()));
     64   CHECK_CALLBACK_BEHAVIOR(callback);
     65   ASSERT_EQ(num_bytes, callback.result());
     66   *bytes_read = callback.result();
     67   PASS();
     68 }
     69 
     70 std::string TestHostResolver::SyncWrite(pp::TCPSocket* socket,
     71                                         const char* buffer,
     72                                         int32_t num_bytes,
     73                                         int32_t* bytes_written) {
     74   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
     75   callback.WaitForResult(
     76       socket->Write(buffer, num_bytes, callback.GetCallback()));
     77   CHECK_CALLBACK_BEHAVIOR(callback);
     78   ASSERT_EQ(num_bytes, callback.result());
     79   *bytes_written = callback.result();
     80   PASS();
     81 }
     82 
     83 std::string TestHostResolver::CheckHTTPResponse(pp::TCPSocket* socket,
     84                                                 const std::string& request,
     85                                                 const std::string& response) {
     86   int32_t rv = 0;
     87   ASSERT_SUBTEST_SUCCESS(
     88       SyncWrite(socket, request.c_str(), request.size(), &rv));
     89   std::vector<char> response_buffer(response.size());
     90   ASSERT_SUBTEST_SUCCESS(
     91       SyncRead(socket, &response_buffer[0], response.size(), &rv));
     92   std::string actual_response(&response_buffer[0], rv);
     93   if (response != actual_response) {
     94     return "CheckHTTPResponse failed, expected: " + response +
     95         ", actual: " + actual_response;
     96   }
     97   PASS();
     98 }
     99 
    100 std::string TestHostResolver::SyncResolve(
    101     pp::HostResolver* host_resolver,
    102     const std::string& host,
    103     uint16_t port,
    104     const PP_HostResolver_Hint& hint) {
    105   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
    106   callback.WaitForResult(
    107       host_resolver->Resolve(host.c_str(), port, hint, callback.GetCallback()));
    108   CHECK_CALLBACK_BEHAVIOR(callback);
    109   ASSERT_EQ(PP_OK, callback.result());
    110   PASS();
    111 }
    112 
    113 std::string TestHostResolver::ParameterizedTestResolve(
    114     const PP_HostResolver_Hint& hint) {
    115   pp::HostResolver host_resolver(instance_);
    116 
    117   ASSERT_SUBTEST_SUCCESS(SyncResolve(&host_resolver, host_, port_, hint));
    118 
    119   size_t size = host_resolver.GetNetAddressCount();
    120   ASSERT_TRUE(size >= 1);
    121 
    122   pp::NetAddress address;
    123   for (size_t i = 0; i < size; ++i) {
    124     address = host_resolver.GetNetAddress(i);
    125     ASSERT_NE(0, address.pp_resource());
    126 
    127     pp::TCPSocket socket(instance_);
    128     ASSERT_SUBTEST_SUCCESS(SyncConnect(&socket, address));
    129     ASSERT_SUBTEST_SUCCESS(CheckHTTPResponse(&socket,
    130                                              "GET / HTTP/1.0\r\n\r\n",
    131                                              "HTTP"));
    132     socket.Close();
    133   }
    134 
    135   address = host_resolver.GetNetAddress(size);
    136   ASSERT_EQ(0, address.pp_resource());
    137   pp::Var canonical_name = host_resolver.GetCanonicalName();
    138   ASSERT_TRUE(canonical_name.is_string());
    139 
    140   ASSERT_SUBTEST_SUCCESS(SyncResolve(&host_resolver, canonical_name.AsString(),
    141                                      port_, hint));
    142   size = host_resolver.GetNetAddressCount();
    143   ASSERT_TRUE(size >= 1);
    144 
    145   PASS();
    146 }
    147 
    148 std::string TestHostResolver::TestEmpty() {
    149   pp::HostResolver host_resolver(instance_);
    150   ASSERT_EQ(0, host_resolver.GetNetAddressCount());
    151   pp::NetAddress address = host_resolver.GetNetAddress(0);
    152   ASSERT_EQ(0, address.pp_resource());
    153 
    154   PASS();
    155 }
    156 
    157 std::string TestHostResolver::TestResolve() {
    158   PP_HostResolver_Hint hint;
    159   hint.family = PP_NETADDRESS_FAMILY_UNSPECIFIED;
    160   hint.flags = PP_HOSTRESOLVER_FLAG_CANONNAME;
    161   return ParameterizedTestResolve(hint);
    162 }
    163 
    164 std::string TestHostResolver::TestResolveIPv4() {
    165   PP_HostResolver_Hint hint;
    166   hint.family = PP_NETADDRESS_FAMILY_IPV4;
    167   hint.flags = PP_HOSTRESOLVER_FLAG_CANONNAME;
    168   return ParameterizedTestResolve(hint);
    169 }
    170