OLD | NEW |
---|---|
(Empty) | |
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_network_monitor_private.h" | |
6 | |
7 #include <string.h> | |
8 | |
9 #include "ppapi/cpp/private/network_list_private.h" | |
10 #include "ppapi/cpp/private/network_monitor_private.h" | |
11 #include "ppapi/tests/testing_instance.h" | |
12 #include "ppapi/tests/test_utils.h" | |
13 #include "ppapi/cpp/module.h" | |
14 | |
15 REGISTER_TEST_CASE(NetworkMonitorPrivate); | |
16 | |
17 #define ASSERT_SUCCESS(error_message) \ | |
dmichael (off chromium)
2012/03/05 19:22:00
Please comment to explain what "SUCCESS" means her
Sergey Ulanov
2012/03/06 02:11:06
That was actually copied from the TCPServerSocket
dmichael (off chromium)
2012/03/06 16:11:28
Sure, we can do that since there are several uses.
Sergey Ulanov
2012/03/06 23:38:08
Done. I sent you a separate CL for that change.
| |
18 if (!(error_message).empty()) \ | |
19 return (error_message); | |
dmichael (off chromium)
2012/03/05 19:22:00
Maybe worth putting in a "do {...} while (false)"
Sergey Ulanov
2012/03/06 02:11:06
Done, but see my comment about RUN_SUBTEST() above
| |
20 | |
21 namespace { | |
22 | |
23 struct CallbackData { | |
24 explicit CallbackData(PP_Instance instance) | |
25 : call_counter(0), | |
26 completion_callback(instance), | |
27 list_resource(0) { | |
28 } | |
29 ~CallbackData() { | |
30 if (list_resource) | |
31 pp::Module::Get()->core()->ReleaseResource(list_resource); | |
32 } | |
33 int call_counter; | |
34 TestCompletionCallback completion_callback; | |
35 PP_Resource list_resource; | |
36 }; | |
37 | |
38 void TestCallback(void* user_data, PP_Resource network_list) { | |
39 CallbackData* data = static_cast<CallbackData*>(user_data); | |
40 data->call_counter++; | |
41 | |
42 if (data->list_resource) | |
43 pp::Module::Get()->core()->ReleaseResource(data->list_resource); | |
44 data->list_resource = network_list; | |
45 | |
46 // Invoke completion callback only for the first change notification. | |
47 if (data->call_counter == 1) | |
48 static_cast<pp::CompletionCallback>(data->completion_callback).Run(PP_OK); | |
49 } | |
50 | |
51 } // namespace | |
52 | |
53 TestNetworkMonitorPrivate::TestNetworkMonitorPrivate(TestingInstance* instance) | |
54 : TestCase(instance) { | |
55 } | |
56 | |
57 bool TestNetworkMonitorPrivate::Init() { | |
58 if (!pp::NetworkMonitorPrivate::IsAvailable()) | |
59 return false; | |
60 | |
61 return true; | |
62 } | |
63 | |
64 void TestNetworkMonitorPrivate::RunTests(const std::string& filter) { | |
65 RUN_TEST_FORCEASYNC_AND_NOT(Basic, filter); | |
66 RUN_TEST_FORCEASYNC_AND_NOT(2Monitors, filter); | |
67 } | |
68 | |
69 std::string TestNetworkMonitorPrivate::VerifyNetworkList( | |
70 PP_Resource network_resource) { | |
71 pp::NetworkListPrivate network_list(network_resource); | |
72 | |
73 // Verify that there is at least one interface | |
dmichael (off chromium)
2012/03/05 19:22:00
nit: might be clearer to say "network interface" o
Sergey Ulanov
2012/03/06 02:11:06
Done.
| |
74 size_t count = network_list.GetCount(); | |
75 ASSERT_TRUE(count >= 1U); | |
76 | |
77 // Iterate over all interface and verify their properties. | |
dmichael (off chromium)
2012/03/05 19:22:00
nit: interface->interfaces
Sergey Ulanov
2012/03/06 02:11:06
Done.
| |
78 for (size_t iface = 0; iface < count; ++iface) { | |
79 | |
dmichael (off chromium)
2012/03/05 19:22:00
style nit: extra carriage return
Sergey Ulanov
2012/03/06 02:11:06
Done.
| |
80 // Verify that the first interface has at least one address. | |
81 std::vector<PP_NetAddress_Private> addresses; | |
82 network_list.GetIpAddresses(iface, &addresses); | |
83 ASSERT_TRUE(addresses.size() >= 1U); | |
84 // Verify that the addresses are valid. | |
85 for (size_t i = 0; i < addresses.size(); ++i) { | |
86 ASSERT_TRUE(addresses[i].size == 4 || addresses[i].size == 16); | |
87 | |
88 size_t j; | |
89 for (j = 0; j < addresses[i].size; ++j) { | |
90 if (addresses[i].data[j] != 0) | |
91 break; | |
92 } | |
93 ASSERT_TRUE(j != addresses[i].size); | |
dmichael (off chromium)
2012/03/05 19:22:00
A quick comment above this loop saying "Make sure
Sergey Ulanov
2012/03/06 02:11:06
Done.
| |
94 } | |
95 | |
96 // Verify that each interface has a unique name and a display name. | |
97 ASSERT_TRUE(!network_list.GetName(iface).empty()); | |
98 ASSERT_TRUE(!network_list.GetDisplayName(iface).empty()); | |
dmichael (off chromium)
2012/03/05 19:22:00
why not use ASSERT_FALSE?
Sergey Ulanov
2012/03/06 02:11:06
Done.
| |
99 | |
100 PP_NetworkListType_Private type = network_list.GetType(iface); | |
101 ASSERT_TRUE(type >= PP_NETWORKLIST_UNKNOWN); | |
102 ASSERT_TRUE(type <= PP_NETWORKLIST_CELLULAR); | |
103 | |
104 PP_NetworkListState_Private state = network_list.GetState(iface); | |
105 ASSERT_TRUE(state >= PP_NETWORKLIST_DOWN); | |
106 ASSERT_TRUE(state <= PP_NETWORKLIST_UP); | |
107 } | |
108 | |
109 // Try to call GetIpAddresses() without C++ wrapper and verify that | |
110 // it always returns correct value. | |
111 const PPB_NetworkList_Private* interface = | |
112 static_cast<const PPB_NetworkList_Private*>( | |
113 pp::Module::Get()->GetBrowserInterface( | |
114 PPB_NETWORKLIST_PRIVATE_INTERFACE)); | |
115 ASSERT_TRUE(interface); | |
116 std::vector<PP_NetAddress_Private> addresses; | |
117 network_list.GetIpAddresses(0, &addresses); | |
118 size_t address_count = addresses.size(); | |
119 addresses.resize(addresses.size() + 3); | |
120 for (size_t i = 0; i < addresses.size(); ++i) { | |
121 const char kFillValue = 123; | |
122 memset(&addresses.front(), kFillValue, | |
123 addresses.size() * sizeof(PP_NetAddress_Private)); | |
124 int result = interface->GetIpAddresses(network_resource, 0, | |
125 &addresses.front(), i); | |
126 ASSERT_EQ(result, static_cast<int>(address_count)); | |
127 | |
128 // Verify that nothing outside the buffer was touched. | |
129 for (char* pos = reinterpret_cast<char*>(&addresses[result]); | |
130 pos != reinterpret_cast<char*>(&*addresses.end()); ++pos) { | |
dmichael (off chromium)
2012/03/05 19:22:00
I think dereferencing end() is technically undefin
Sergey Ulanov
2012/03/06 02:11:06
Done.
| |
131 ASSERT_TRUE(*pos == kFillValue); | |
132 } | |
133 } | |
134 | |
135 PASS(); | |
136 } | |
137 | |
138 std::string TestNetworkMonitorPrivate::TestBasic() { | |
139 CallbackData callback_data(instance_->pp_instance()); | |
140 | |
141 pp::NetworkMonitorPrivate network_monitor( | |
142 instance_, &TestCallback, reinterpret_cast<void*>(&callback_data)); | |
143 ASSERT_EQ(callback_data.completion_callback.WaitForResult(), PP_OK); | |
144 ASSERT_EQ(callback_data.call_counter, 1); | |
145 | |
146 std::string list_result = VerifyNetworkList(callback_data.list_resource); | |
147 ASSERT_SUCCESS(list_result); | |
148 | |
149 PASS(); | |
150 } | |
151 | |
152 std::string TestNetworkMonitorPrivate::Test2Monitors() { | |
153 CallbackData callback_data(instance_->pp_instance()); | |
154 | |
155 pp::NetworkMonitorPrivate network_monitor( | |
156 instance_, &TestCallback, reinterpret_cast<void*>(&callback_data)); | |
157 ASSERT_EQ(callback_data.completion_callback.WaitForResult(), PP_OK); | |
158 ASSERT_EQ(callback_data.call_counter, 1); | |
159 | |
160 std::string list_result = VerifyNetworkList(callback_data.list_resource); | |
161 ASSERT_SUCCESS(list_result); | |
162 | |
163 CallbackData callback_data_2(instance_->pp_instance()); | |
164 | |
165 pp::NetworkMonitorPrivate network_monitor_2( | |
166 instance_, &TestCallback, reinterpret_cast<void*>(&callback_data_2)); | |
167 ASSERT_EQ(callback_data_2.completion_callback.WaitForResult(), PP_OK); | |
168 ASSERT_EQ(callback_data_2.call_counter, 1); | |
169 | |
170 list_result = VerifyNetworkList(callback_data_2.list_resource); | |
171 ASSERT_SUCCESS(list_result); | |
172 | |
173 PASS(); | |
174 } | |
OLD | NEW |