test_host_resolver.cc 5.9 KB

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