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 namespace { |
| 18 |
| 19 struct CallbackData { |
| 20 explicit CallbackData(PP_Instance instance) |
| 21 : call_counter(0), |
| 22 completion_callback(instance), |
| 23 list_resource(0) { |
| 24 } |
| 25 ~CallbackData() { |
| 26 if (list_resource) |
| 27 pp::Module::Get()->core()->ReleaseResource(list_resource); |
| 28 } |
| 29 int call_counter; |
| 30 TestCompletionCallback completion_callback; |
| 31 PP_Resource list_resource; |
| 32 }; |
| 33 |
| 34 void TestCallback(void* user_data, PP_Resource network_list) { |
| 35 CallbackData* data = static_cast<CallbackData*>(user_data); |
| 36 data->call_counter++; |
| 37 |
| 38 if (data->list_resource) |
| 39 pp::Module::Get()->core()->ReleaseResource(data->list_resource); |
| 40 data->list_resource = network_list; |
| 41 |
| 42 // Invoke completion callback only for the first change notification. |
| 43 if (data->call_counter == 1) |
| 44 static_cast<pp::CompletionCallback>(data->completion_callback).Run(PP_OK); |
| 45 } |
| 46 |
| 47 } // namespace |
| 48 |
| 49 TestNetworkMonitorPrivate::TestNetworkMonitorPrivate(TestingInstance* instance) |
| 50 : TestCase(instance) { |
| 51 } |
| 52 |
| 53 bool TestNetworkMonitorPrivate::Init() { |
| 54 if (!pp::NetworkMonitorPrivate::IsAvailable()) |
| 55 return false; |
| 56 |
| 57 return true; |
| 58 } |
| 59 |
| 60 void TestNetworkMonitorPrivate::RunTests(const std::string& filter) { |
| 61 RUN_TEST_FORCEASYNC_AND_NOT(Basic, filter); |
| 62 RUN_TEST_FORCEASYNC_AND_NOT(2Monitors, filter); |
| 63 } |
| 64 |
| 65 std::string TestNetworkMonitorPrivate::VerifyNetworkList( |
| 66 PP_Resource network_resource) { |
| 67 pp::NetworkListPrivate network_list(network_resource); |
| 68 |
| 69 // Verify that there is at least one network interface. |
| 70 size_t count = network_list.GetCount(); |
| 71 ASSERT_TRUE(count >= 1U); |
| 72 |
| 73 // Iterate over all interfaces and verify their properties. |
| 74 for (size_t iface = 0; iface < count; ++iface) { |
| 75 // Verify that the first interface has at least one address. |
| 76 std::vector<PP_NetAddress_Private> addresses; |
| 77 network_list.GetIpAddresses(iface, &addresses); |
| 78 ASSERT_TRUE(addresses.size() >= 1U); |
| 79 // Verify that the addresses are valid. |
| 80 for (size_t i = 0; i < addresses.size(); ++i) { |
| 81 ASSERT_TRUE(addresses[i].size == 4 || addresses[i].size == 16); |
| 82 |
| 83 // Verify that the address is not zero. |
| 84 size_t j; |
| 85 for (j = 0; j < addresses[i].size; ++j) { |
| 86 if (addresses[i].data[j] != 0) |
| 87 break; |
| 88 } |
| 89 ASSERT_TRUE(j != addresses[i].size); |
| 90 } |
| 91 |
| 92 // Verify that each interface has a unique name and a display name. |
| 93 ASSERT_FALSE(network_list.GetName(iface).empty()); |
| 94 ASSERT_FALSE(network_list.GetDisplayName(iface).empty()); |
| 95 |
| 96 PP_NetworkListType_Private type = network_list.GetType(iface); |
| 97 ASSERT_TRUE(type >= PP_NETWORKLIST_UNKNOWN); |
| 98 ASSERT_TRUE(type <= PP_NETWORKLIST_CELLULAR); |
| 99 |
| 100 PP_NetworkListState_Private state = network_list.GetState(iface); |
| 101 ASSERT_TRUE(state >= PP_NETWORKLIST_DOWN); |
| 102 ASSERT_TRUE(state <= PP_NETWORKLIST_UP); |
| 103 } |
| 104 |
| 105 // Try to call GetIpAddresses() without C++ wrapper and verify that |
| 106 // it always returns correct value. |
| 107 const PPB_NetworkList_Private* interface = |
| 108 static_cast<const PPB_NetworkList_Private*>( |
| 109 pp::Module::Get()->GetBrowserInterface( |
| 110 PPB_NETWORKLIST_PRIVATE_INTERFACE)); |
| 111 ASSERT_TRUE(interface); |
| 112 std::vector<PP_NetAddress_Private> addresses; |
| 113 network_list.GetIpAddresses(0, &addresses); |
| 114 size_t address_count = addresses.size(); |
| 115 addresses.resize(addresses.size() + 3); |
| 116 for (size_t i = 0; i < addresses.size(); ++i) { |
| 117 const char kFillValue = 123; |
| 118 memset(&addresses.front(), kFillValue, |
| 119 addresses.size() * sizeof(PP_NetAddress_Private)); |
| 120 int result = interface->GetIpAddresses(network_resource, 0, |
| 121 &addresses.front(), i); |
| 122 ASSERT_EQ(result, static_cast<int>(address_count)); |
| 123 |
| 124 // Verify that nothing outside the buffer was touched. |
| 125 for (char* pos = reinterpret_cast<char*>(&addresses[result]); |
| 126 pos != reinterpret_cast<char*>(&addresses[0] + addresses.size()); |
| 127 ++pos) { |
| 128 ASSERT_TRUE(*pos == kFillValue); |
| 129 } |
| 130 } |
| 131 |
| 132 PASS(); |
| 133 } |
| 134 |
| 135 std::string TestNetworkMonitorPrivate::TestBasic() { |
| 136 CallbackData callback_data(instance_->pp_instance()); |
| 137 |
| 138 pp::NetworkMonitorPrivate network_monitor( |
| 139 instance_, &TestCallback, reinterpret_cast<void*>(&callback_data)); |
| 140 ASSERT_EQ(callback_data.completion_callback.WaitForResult(), PP_OK); |
| 141 ASSERT_EQ(callback_data.call_counter, 1); |
| 142 |
| 143 ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data.list_resource)); |
| 144 |
| 145 PASS(); |
| 146 } |
| 147 |
| 148 std::string TestNetworkMonitorPrivate::Test2Monitors() { |
| 149 CallbackData callback_data(instance_->pp_instance()); |
| 150 |
| 151 pp::NetworkMonitorPrivate network_monitor( |
| 152 instance_, &TestCallback, reinterpret_cast<void*>(&callback_data)); |
| 153 ASSERT_EQ(callback_data.completion_callback.WaitForResult(), PP_OK); |
| 154 ASSERT_EQ(callback_data.call_counter, 1); |
| 155 |
| 156 ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data.list_resource)); |
| 157 |
| 158 CallbackData callback_data_2(instance_->pp_instance()); |
| 159 |
| 160 pp::NetworkMonitorPrivate network_monitor_2( |
| 161 instance_, &TestCallback, reinterpret_cast<void*>(&callback_data_2)); |
| 162 ASSERT_EQ(callback_data_2.completion_callback.WaitForResult(), PP_OK); |
| 163 ASSERT_EQ(callback_data_2.call_counter, 1); |
| 164 |
| 165 ASSERT_SUBTEST_SUCCESS(VerifyNetworkList(callback_data_2.list_resource)); |
| 166 |
| 167 PASS(); |
| 168 } |
OLD | NEW |