1// Copyright (c) 2012 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_net_address_private_untrusted.h"
6
7#include <limits>
8#include <sstream>
9
10#include "ppapi/c/pp_errors.h"
11#include "ppapi/cpp/private/net_address_private.h"
12#include "ppapi/tests/test_utils.h"
13#include "ppapi/tests/testing_instance.h"
14
15REGISTER_TEST_CASE(NetAddressPrivateUntrusted);
16
17using pp::NetAddressPrivate;
18using pp::TCPSocketPrivate;
19
20TestNetAddressPrivateUntrusted::TestNetAddressPrivateUntrusted(
21    TestingInstance* instance) : TestCase(instance), port_(0) {
22}
23
24bool TestNetAddressPrivateUntrusted::Init() {
25  bool net_address_private_is_available = NetAddressPrivate::IsAvailable();
26  if (!net_address_private_is_available)
27    instance_->AppendError("PPB_NetAddress_Private interface not available");
28
29  bool tcp_socket_private_is_available = TCPSocketPrivate::IsAvailable();
30  if (!tcp_socket_private_is_available)
31    instance_->AppendError("PPB_TCPSocket_Private interface not available");
32
33  bool init_host_port =
34      GetLocalHostPort(instance_->pp_instance(), &host_, &port_);
35  if (!init_host_port)
36    instance_->AppendError("Can't init host and port");
37
38  return net_address_private_is_available &&
39      tcp_socket_private_is_available &&
40      init_host_port &&
41      CheckTestingInterface();
42}
43
44void TestNetAddressPrivateUntrusted::RunTests(const std::string& filter) {
45  RUN_TEST(AreEqual, filter);
46  RUN_TEST(AreHostsEqual, filter);
47  RUN_TEST(Describe, filter);
48  RUN_TEST(ReplacePort, filter);
49  RUN_TEST(GetAnyAddress, filter);
50  RUN_TEST(GetFamily, filter);
51  RUN_TEST(GetPort, filter);
52  RUN_TEST(GetAddress, filter);
53}
54
55int32_t TestNetAddressPrivateUntrusted::Connect(TCPSocketPrivate* socket,
56                                                const std::string& host,
57                                                uint16_t port) {
58  TestCompletionCallback callback(instance_->pp_instance(), false);
59
60  callback.WaitForResult(
61      socket->Connect(host.c_str(), port, callback.GetCallback()));
62  return callback.result();
63}
64
65std::string TestNetAddressPrivateUntrusted::TestAreEqual() {
66  pp::TCPSocketPrivate socket(instance_);
67  int32_t rv = Connect(&socket, host_, port_);
68  if (rv != PP_OK)
69    return ReportError("pp::TCPSocketPrivate::Connect", rv);
70
71  PP_NetAddress_Private local_address, remote_address;
72  ASSERT_TRUE(socket.GetLocalAddress(&local_address));
73  ASSERT_TRUE(socket.GetRemoteAddress(&remote_address));
74
75  ASSERT_TRUE(NetAddressPrivate::AreEqual(local_address, local_address));
76  ASSERT_FALSE(NetAddressPrivate::AreEqual(local_address, remote_address));
77
78  socket.Disconnect();
79  PASS();
80}
81
82std::string TestNetAddressPrivateUntrusted::TestAreHostsEqual() {
83  pp::TCPSocketPrivate socket(instance_);
84  int32_t rv = Connect(&socket, host_, port_);
85  if (rv != PP_OK)
86    return ReportError("pp::TCPSocketPrivate::Connect", rv);
87
88  PP_NetAddress_Private local_address, remote_address;
89  ASSERT_TRUE(socket.GetLocalAddress(&local_address));
90  ASSERT_TRUE(socket.GetRemoteAddress(&remote_address));
91
92  ASSERT_TRUE(NetAddressPrivate::AreHostsEqual(local_address, local_address));
93  ASSERT_TRUE(NetAddressPrivate::AreHostsEqual(local_address, remote_address));
94
95  socket.Disconnect();
96  PASS();
97}
98
99std::string TestNetAddressPrivateUntrusted::TestDescribe() {
100  pp::TCPSocketPrivate socket(instance_);
101  int32_t rv = Connect(&socket, host_, port_);
102  if (rv != PP_OK)
103    return ReportError("pp::TCPSocketPrivate::Connect", rv);
104
105  PP_NetAddress_Private remote_address;
106  ASSERT_TRUE(socket.GetRemoteAddress(&remote_address));
107
108  std::ostringstream os;
109
110  os << host_;
111  ASSERT_EQ(os.str(), NetAddressPrivate::Describe(remote_address, false));
112
113  os << ':' << port_;
114  ASSERT_EQ(os.str(), NetAddressPrivate::Describe(remote_address, true));
115
116  socket.Disconnect();
117  PASS();
118}
119
120std::string TestNetAddressPrivateUntrusted::TestReplacePort() {
121  pp::TCPSocketPrivate socket(instance_);
122  int32_t rv = Connect(&socket, host_, port_);
123  if (rv != PP_OK)
124    return ReportError("pp::TCPSocketPrivate::Connect", rv);
125
126  PP_NetAddress_Private src_addr, dst_addr;
127  ASSERT_TRUE(socket.GetRemoteAddress(&src_addr));
128
129  uint16_t nport = port_;
130  if (nport == std::numeric_limits<uint16_t>::max())
131    --nport;
132  else
133    ++nport;
134  ASSERT_TRUE(NetAddressPrivate::ReplacePort(src_addr, nport, &dst_addr));
135
136  std::ostringstream os;
137  os << host_ << ':' << nport;
138
139  ASSERT_EQ(os.str(), NetAddressPrivate::Describe(dst_addr, true));
140
141  socket.Disconnect();
142  PASS();
143}
144
145std::string TestNetAddressPrivateUntrusted::TestGetAnyAddress() {
146  PP_NetAddress_Private address;
147
148  NetAddressPrivate::GetAnyAddress(false, &address);
149  ASSERT_TRUE(NetAddressPrivate::AreEqual(address, address));
150
151  NetAddressPrivate::GetAnyAddress(true, &address);
152  ASSERT_TRUE(NetAddressPrivate::AreEqual(address, address));
153
154  PASS();
155}
156
157std::string TestNetAddressPrivateUntrusted::TestGetFamily() {
158  pp::TCPSocketPrivate socket(instance_);
159  int32_t rv = Connect(&socket, host_, port_);
160  if (rv != PP_OK)
161    return ReportError("pp::TCPSocketPrivate::Connect", rv);
162
163  PP_NetAddress_Private remote_address;
164  ASSERT_TRUE(socket.GetRemoteAddress(&remote_address));
165
166  ASSERT_EQ(NetAddressPrivate::GetFamily(remote_address),
167            NetAddressPrivate::GetFamily(remote_address));
168
169  socket.Disconnect();
170  PASS();
171}
172
173std::string TestNetAddressPrivateUntrusted::TestGetPort() {
174  pp::TCPSocketPrivate socket(instance_);
175  int32_t rv = Connect(&socket, host_, port_);
176  if (rv != PP_OK)
177    return ReportError("pp::TCPSocketPrivate::Connect", rv);
178
179  PP_NetAddress_Private remote_address;
180  ASSERT_TRUE(socket.GetRemoteAddress(&remote_address));
181
182  ASSERT_EQ(NetAddressPrivate::GetPort(remote_address), port_);
183
184  socket.Disconnect();
185  PASS();
186}
187
188std::string TestNetAddressPrivateUntrusted::TestGetAddress() {
189  pp::TCPSocketPrivate socket(instance_);
190  int32_t rv = Connect(&socket, host_, port_);
191  if (rv != PP_OK)
192    return ReportError("pp::TCPSocketPrivate::Connect", rv);
193
194  PP_NetAddress_Private remote_address;
195  ASSERT_TRUE(socket.GetRemoteAddress(&remote_address));
196
197  static const uint16_t buffer_size = sizeof(remote_address.data);
198  char buffer[buffer_size];
199  ASSERT_TRUE(NetAddressPrivate::GetAddress(remote_address, buffer,
200                                            buffer_size));
201
202  socket.Disconnect();
203  PASS();
204}
205