summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorErik Kline2017-08-07 13:32:45 -0500
committerErik Kline2017-08-07 15:51:09 -0500
commit434b8d38d0c418158b68bcd450cc1af5b6c8c0d4 (patch)
tree7bc52449ce15f990091b6c2c7f391210c1f5a10b /tetheroffload
parent36678525469e9c92f5f1d603c57ab55845bc2b31 (diff)
downloadplatform-hardware-interfaces-434b8d38d0c418158b68bcd450cc1af5b6c8c0d4.tar.gz
platform-hardware-interfaces-434b8d38d0c418158b68bcd450cc1af5b6c8c0d4.tar.xz
platform-hardware-interfaces-434b8d38d0c418158b68bcd450cc1af5b6c8c0d4.zip
Refactor and expand tetheroffload Control and Config VTS
Test: as follows - built - flashed - booted - adb sync && adb shell ...$test Bug: 38220415 Change-Id: Iab715c45ad0457f3eea43ee408fa947ffc01c4aa
Diffstat (limited to 'tetheroffload')
-rw-r--r--tetheroffload/config/1.0/vts/functional/Android.bp15
-rw-r--r--tetheroffload/config/1.0/vts/functional/VtsHalTetheroffloadConfigV1_0TargetTest.cpp167
-rw-r--r--tetheroffload/control/1.0/vts/functional/Android.bp15
-rw-r--r--tetheroffload/control/1.0/vts/functional/VtsHalTetheroffloadControlV1_0TargetTest.cpp1057
4 files changed, 508 insertions, 746 deletions
diff --git a/tetheroffload/config/1.0/vts/functional/Android.bp b/tetheroffload/config/1.0/vts/functional/Android.bp
index ba6d809a..2e720c68 100644
--- a/tetheroffload/config/1.0/vts/functional/Android.bp
+++ b/tetheroffload/config/1.0/vts/functional/Android.bp
@@ -1,9 +1,24 @@
1// Copyright (C) 2017 The Android Open Source Project
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
1cc_test { 15cc_test {
2 name: "VtsHalTetheroffloadConfigV1_0TargetTest", 16 name: "VtsHalTetheroffloadConfigV1_0TargetTest",
3 defaults: ["hidl_defaults"], 17 defaults: ["hidl_defaults"],
4 srcs: ["VtsHalTetheroffloadConfigV1_0TargetTest.cpp"], 18 srcs: ["VtsHalTetheroffloadConfigV1_0TargetTest.cpp"],
5 shared_libs: [ 19 shared_libs: [
6 "android.hardware.tetheroffload.config@1.0", 20 "android.hardware.tetheroffload.config@1.0",
21 "libbase",
7 "libcutils", 22 "libcutils",
8 "libhidlbase", 23 "libhidlbase",
9 "libhidltransport", 24 "libhidltransport",
diff --git a/tetheroffload/config/1.0/vts/functional/VtsHalTetheroffloadConfigV1_0TargetTest.cpp b/tetheroffload/config/1.0/vts/functional/VtsHalTetheroffloadConfigV1_0TargetTest.cpp
index b0ded4f5..fc61e1c1 100644
--- a/tetheroffload/config/1.0/vts/functional/VtsHalTetheroffloadConfigV1_0TargetTest.cpp
+++ b/tetheroffload/config/1.0/vts/functional/VtsHalTetheroffloadConfigV1_0TargetTest.cpp
@@ -13,18 +13,23 @@
13 * See the License for the specific language governing permissions and 13 * See the License for the specific language governing permissions and
14 * limitations under the License. 14 * limitations under the License.
15 */ 15 */
16
16#define LOG_TAG "VtsOffloadConfigV1_0TargetTest" 17#define LOG_TAG "VtsOffloadConfigV1_0TargetTest"
17 18
19#include <VtsHalHidlTargetTestBase.h>
20#include <android-base/stringprintf.h>
18#include <android-base/unique_fd.h> 21#include <android-base/unique_fd.h>
19#include <android/hardware/tetheroffload/config/1.0/IOffloadConfig.h> 22#include <android/hardware/tetheroffload/config/1.0/IOffloadConfig.h>
20#include <linux/netfilter/nfnetlink.h> 23#include <linux/netfilter/nfnetlink.h>
21#include <linux/netlink.h> 24#include <linux/netlink.h>
25#include <linux/rtnetlink.h>
22#include <log/log.h> 26#include <log/log.h>
23#include <set>
24#include <sys/socket.h> 27#include <sys/socket.h>
25#include <unistd.h> 28#include <unistd.h>
26#include <VtsHalHidlTargetTestBase.h> 29#include <set>
27 30
31using android::base::StringPrintf;
32using android::base::unique_fd;
28using android::hardware::hidl_handle; 33using android::hardware::hidl_handle;
29using android::hardware::hidl_string; 34using android::hardware::hidl_string;
30using android::hardware::Return; 35using android::hardware::Return;
@@ -32,41 +37,48 @@ using android::hardware::tetheroffload::config::V1_0::IOffloadConfig;
32using android::hardware::Void; 37using android::hardware::Void;
33using android::sp; 38using android::sp;
34 39
35inline const sockaddr * asSockaddr(const sockaddr_nl *nladdr) { 40#define ASSERT_TRUE_CALLBACK \
36 return reinterpret_cast<const sockaddr *>(nladdr); 41 [&](bool success, const hidl_string& errMsg) { ASSERT_TRUE(success) << errMsg.c_str(); }
42
43#define ASSERT_FALSE_CALLBACK \
44 [&](bool success, const hidl_string& errMsg) { ASSERT_FALSE(success) << errMsg.c_str(); }
45
46const unsigned kFd1Groups = NFNLGRP_CONNTRACK_NEW | NFNLGRP_CONNTRACK_DESTROY;
47const unsigned kFd2Groups = NFNLGRP_CONNTRACK_UPDATE | NFNLGRP_CONNTRACK_DESTROY;
48
49inline const sockaddr* asSockaddr(const sockaddr_nl* nladdr) {
50 return reinterpret_cast<const sockaddr*>(nladdr);
37} 51}
38 52
39int conntrackSocket(unsigned groups) { 53int netlinkSocket(int protocol, unsigned groups) {
40 android::base::unique_fd s(socket(AF_NETLINK, SOCK_DGRAM, NETLINK_NETFILTER)); 54 unique_fd s(socket(AF_NETLINK, SOCK_DGRAM, protocol));
41 if (s.get() < 0) { 55 if (s.get() < 0) {
42 return -errno; 56 return -errno;
43 } 57 }
44 58
45 const struct sockaddr_nl bind_addr = { 59 const struct sockaddr_nl bind_addr = {
46 .nl_family = AF_NETLINK, 60 .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
47 .nl_pad = 0,
48 .nl_pid = 0,
49 .nl_groups = groups,
50 }; 61 };
51 if (::bind(s.get(), asSockaddr(&bind_addr), sizeof(bind_addr)) != 0) { 62 if (::bind(s.get(), asSockaddr(&bind_addr), sizeof(bind_addr)) != 0) {
52 return -errno; 63 return -errno;
53 } 64 }
54 65
55 const struct sockaddr_nl kernel_addr = { 66 const struct sockaddr_nl kernel_addr = {
56 .nl_family = AF_NETLINK, 67 .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
57 .nl_pad = 0,
58 .nl_pid = 0,
59 .nl_groups = groups,
60 }; 68 };
61 if (connect(s.get(), asSockaddr(&kernel_addr), sizeof(kernel_addr)) != 0) { 69 if (::connect(s.get(), asSockaddr(&kernel_addr), sizeof(kernel_addr)) != 0) {
62 return -errno; 70 return -errno;
63 } 71 }
64 72
65 return s.release(); 73 return s.release();
66} 74}
67 75
76int netlinkSocket(unsigned groups) {
77 return netlinkSocket(NETLINK_NETFILTER, groups);
78}
79
68class OffloadConfigHidlTest : public testing::VtsHalHidlTargetTestBase { 80class OffloadConfigHidlTest : public testing::VtsHalHidlTargetTestBase {
69public: 81 public:
70 virtual void SetUp() override { 82 virtual void SetUp() override {
71 config = testing::VtsHalHidlTargetTestBase::getService<IOffloadConfig>(); 83 config = testing::VtsHalHidlTargetTestBase::getService<IOffloadConfig>();
72 ASSERT_NE(nullptr, config.get()) << "Could not get HIDL instance"; 84 ASSERT_NE(nullptr, config.get()) << "Could not get HIDL instance";
@@ -77,104 +89,77 @@ public:
77 sp<IOffloadConfig> config; 89 sp<IOffloadConfig> config;
78}; 90};
79 91
80/** 92// Ensure handles can be set with correct socket options.
81 * Ensure handles can be set with correct socket options.
82 */
83TEST_F(OffloadConfigHidlTest, TestSetHandles) { 93TEST_F(OffloadConfigHidlTest, TestSetHandles) {
84 android::base::unique_fd 94 unique_fd fd1(netlinkSocket(kFd1Groups));
85 fd1(conntrackSocket(NFNLGRP_CONNTRACK_NEW | NFNLGRP_CONNTRACK_DESTROY)), 95 if (fd1.get() < 0) {
86 fd2(conntrackSocket(NFNLGRP_CONNTRACK_UPDATE | NFNLGRP_CONNTRACK_DESTROY));
87
88 if (fd1.get() < 0 || fd2.get() < 0) {
89 ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno)); 96 ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
90 return; 97 FAIL();
91 } 98 }
99 native_handle_t* const nativeHandle1 = native_handle_create(1, 0);
100 nativeHandle1->data[0] = fd1.release();
101 const hidl_handle h1 = hidl_handle(nativeHandle1);
92 102
93 native_handle_t* nativeHandle1 = native_handle_create(1, 0); 103 unique_fd fd2(netlinkSocket(kFd2Groups));
94 nativeHandle1->data[0] = fd1; 104 if (fd2.get() < 0) {
95 hidl_handle h1 = hidl_handle(nativeHandle1); 105 ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
96 106 FAIL();
97 native_handle_t* nativeHandle2 = native_handle_create(1, 0);
98 nativeHandle2->data[0] = fd2;
99 hidl_handle h2 = hidl_handle(nativeHandle2);
100
101 if(h1->numFds == 1 && h2->numFds == 1) {
102 ALOGE("Num FDs for both is 1");
103 } else {
104 ALOGE("num FDs not 1: %d %d", h1->numFds, h2->numFds);
105 } 107 }
108 native_handle_t* const nativeHandle2 = native_handle_create(1, 0);
109 nativeHandle2->data[0] = fd2.release();
110 const hidl_handle h2 = hidl_handle(nativeHandle2);
106 111
107 auto cb = [&](bool success, const hidl_string& errMsg) { 112 const Return<void> ret = config->setHandles(h1, h2, ASSERT_TRUE_CALLBACK);
108 ASSERT_TRUE(success) << errMsg.c_str();
109 };
110
111 Return<void> ret = config->setHandles(h1, h2, cb);
112 ASSERT_TRUE(ret.isOk()); 113 ASSERT_TRUE(ret.isOk());
113} 114}
114 115
115/** 116// Passing a handle without an associated file descriptor should return an error
116 * Negative testcase 117// (e.g. "Failed Input Checks"). Check that this occurs when both FDs are empty.
117 * Passing a handle without an associated FD should return an
118 * error (Failed Input Checks). Check that this occurs when
119 * neither handle has an associated FD.
120 */
121TEST_F(OffloadConfigHidlTest, TestSetHandleNone) { 118TEST_F(OffloadConfigHidlTest, TestSetHandleNone) {
122 native_handle_t* nativeHandle1 = native_handle_create(0, 0); 119 native_handle_t* const nativeHandle1 = native_handle_create(0, 0);
123 hidl_handle h1 = hidl_handle(nativeHandle1); 120 const hidl_handle h1 = hidl_handle(nativeHandle1);
124 native_handle_t* nativeHandle2 = native_handle_create(0, 0); 121 native_handle_t* const nativeHandle2 = native_handle_create(0, 0);
125 hidl_handle h2 = hidl_handle(nativeHandle2); 122 const hidl_handle h2 = hidl_handle(nativeHandle2);
126
127 auto cb = [&](bool success, const hidl_string& errMsg) {
128 ASSERT_FALSE(success) << errMsg.c_str();
129 };
130 123
131 Return<void> ret = config->setHandles(h1, h2, cb); 124 const Return<void> ret = config->setHandles(h1, h2, ASSERT_FALSE_CALLBACK);
132 ASSERT_TRUE(ret.isOk()); 125 ASSERT_TRUE(ret.isOk());
133} 126}
134 127
135/** 128// Passing a handle without an associated file descriptor should return an error
136 * Negative testcase 129// (e.g. "Failed Input Checks"). Check that this occurs when FD2 is empty.
137 * Passing a handle without an associated FD should return an
138 * error (Failed Input Checks). Check that this occurs with FD2.
139 */
140TEST_F(OffloadConfigHidlTest, TestSetHandle1Only) { 130TEST_F(OffloadConfigHidlTest, TestSetHandle1Only) {
141 android::base::unique_fd 131 unique_fd fd1(netlinkSocket(kFd1Groups));
142 fd1(conntrackSocket(NFNLGRP_CONNTRACK_NEW | NFNLGRP_CONNTRACK_DESTROY)); 132 if (fd1.get() < 0) {
143 133 ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
144 native_handle_t* nativeHandle1 = native_handle_create(1, 0); 134 FAIL();
145 nativeHandle1->data[0] = fd1; 135 }
146 hidl_handle h1 = hidl_handle(nativeHandle1); 136 native_handle_t* const nativeHandle1 = native_handle_create(1, 0);
147 native_handle_t* nativeHandle2 = native_handle_create(0, 0); 137 nativeHandle1->data[0] = fd1.release();
148 hidl_handle h2 = hidl_handle(nativeHandle2); 138 const hidl_handle h1 = hidl_handle(nativeHandle1);
149 139
150 auto cb = [&](bool success, const hidl_string& errMsg) { 140 native_handle_t* const nativeHandle2 = native_handle_create(0, 0);
151 ASSERT_FALSE(success) << errMsg.c_str(); 141 const hidl_handle h2 = hidl_handle(nativeHandle2);
152 };
153 142
154 Return<void> ret = config->setHandles(h1, h2, cb); 143 const Return<void> ret = config->setHandles(h1, h2, ASSERT_FALSE_CALLBACK);
155 ASSERT_TRUE(ret.isOk()); 144 ASSERT_TRUE(ret.isOk());
156} 145}
157 146
158/** 147// Passing a handle without an associated file descriptor should return an error
159 * Negative testcase 148// (e.g. "Failed Input Checks"). Check that this occurs when FD1 is empty.
160 * Passing a handle without an associated FD should return an
161 * error (Failed Input Checks). Check that this occurs with FD1.
162 */
163TEST_F(OffloadConfigHidlTest, TestSetHandle2OnlyNotOk) { 149TEST_F(OffloadConfigHidlTest, TestSetHandle2OnlyNotOk) {
164 android::base::unique_fd 150 native_handle_t* const nativeHandle1 = native_handle_create(0, 0);
165 fd2(conntrackSocket(NFNLGRP_CONNTRACK_UPDATE | NFNLGRP_CONNTRACK_DESTROY)); 151 const hidl_handle h1 = hidl_handle(nativeHandle1);
166
167 native_handle_t* nativeHandle1 = native_handle_create(0, 0);
168 hidl_handle h1 = hidl_handle(nativeHandle1);
169 native_handle_t* nativeHandle2 = native_handle_create(1, 0);
170 nativeHandle2->data[0] = fd2;
171 hidl_handle h2 = hidl_handle(nativeHandle2);
172 152
173 auto cb = [&](bool success, const hidl_string& errMsg) { 153 unique_fd fd2(netlinkSocket(kFd2Groups));
174 ASSERT_FALSE(success) << errMsg.c_str(); 154 if (fd2.get() < 0) {
175 }; 155 ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
156 FAIL();
157 }
158 native_handle_t* const nativeHandle2 = native_handle_create(1, 0);
159 nativeHandle2->data[0] = fd2.release();
160 const hidl_handle h2 = hidl_handle(nativeHandle2);
176 161
177 Return<void> ret = config->setHandles(h1, h2, cb); 162 const Return<void> ret = config->setHandles(h1, h2, ASSERT_FALSE_CALLBACK);
178 ASSERT_TRUE(ret.isOk()); 163 ASSERT_TRUE(ret.isOk());
179} 164}
180 165
diff --git a/tetheroffload/control/1.0/vts/functional/Android.bp b/tetheroffload/control/1.0/vts/functional/Android.bp
index 17c993de..69fac6e5 100644
--- a/tetheroffload/control/1.0/vts/functional/Android.bp
+++ b/tetheroffload/control/1.0/vts/functional/Android.bp
@@ -1,3 +1,17 @@
1// Copyright (C) 2017 The Android Open Source Project
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
1cc_test { 15cc_test {
2 name: "VtsHalTetheroffloadControlV1_0TargetTest", 16 name: "VtsHalTetheroffloadControlV1_0TargetTest",
3 defaults: ["hidl_defaults"], 17 defaults: ["hidl_defaults"],
@@ -5,6 +19,7 @@ cc_test {
5 shared_libs: [ 19 shared_libs: [
6 "android.hardware.tetheroffload.config@1.0", 20 "android.hardware.tetheroffload.config@1.0",
7 "android.hardware.tetheroffload.control@1.0", 21 "android.hardware.tetheroffload.control@1.0",
22 "libbase",
8 "libcutils", 23 "libcutils",
9 "libhidlbase", 24 "libhidlbase",
10 "libhidltransport", 25 "libhidltransport",
diff --git a/tetheroffload/control/1.0/vts/functional/VtsHalTetheroffloadControlV1_0TargetTest.cpp b/tetheroffload/control/1.0/vts/functional/VtsHalTetheroffloadControlV1_0TargetTest.cpp
index 638c3c80..3d5cc815 100644
--- a/tetheroffload/control/1.0/vts/functional/VtsHalTetheroffloadControlV1_0TargetTest.cpp
+++ b/tetheroffload/control/1.0/vts/functional/VtsHalTetheroffloadControlV1_0TargetTest.cpp
@@ -13,8 +13,12 @@
13 * See the License for the specific language governing permissions and 13 * See the License for the specific language governing permissions and
14 * limitations under the License. 14 * limitations under the License.
15 */ 15 */
16
16#define LOG_TAG "VtsOffloadControlV1_0TargetTest" 17#define LOG_TAG "VtsOffloadControlV1_0TargetTest"
17 18
19#include <VtsHalHidlTargetCallbackBase.h>
20#include <VtsHalHidlTargetTestBase.h>
21#include <android-base/stringprintf.h>
18#include <android-base/unique_fd.h> 22#include <android-base/unique_fd.h>
19#include <android/hardware/tetheroffload/config/1.0/IOffloadConfig.h> 23#include <android/hardware/tetheroffload/config/1.0/IOffloadConfig.h>
20#include <android/hardware/tetheroffload/control/1.0/IOffloadControl.h> 24#include <android/hardware/tetheroffload/control/1.0/IOffloadControl.h>
@@ -22,12 +26,12 @@
22#include <linux/netfilter/nfnetlink.h> 26#include <linux/netfilter/nfnetlink.h>
23#include <linux/netlink.h> 27#include <linux/netlink.h>
24#include <log/log.h> 28#include <log/log.h>
25#include <set>
26#include <sys/socket.h> 29#include <sys/socket.h>
27#include <unistd.h> 30#include <unistd.h>
28#include <VtsHalHidlTargetCallbackBase.h> 31#include <set>
29#include <VtsHalHidlTargetTestBase.h>
30 32
33using android::base::StringPrintf;
34using android::base::unique_fd;
31using android::hardware::hidl_handle; 35using android::hardware::hidl_handle;
32using android::hardware::hidl_string; 36using android::hardware::hidl_string;
33using android::hardware::hidl_vec; 37using android::hardware::hidl_vec;
@@ -42,31 +46,48 @@ using android::hardware::tetheroffload::control::V1_0::NetworkProtocol;
42using android::hardware::Void; 46using android::hardware::Void;
43using android::sp; 47using android::sp;
44 48
45inline const sockaddr * asSockaddr(const sockaddr_nl *nladdr) { 49// We use #defines here so as to get local lamba captures and error message line numbers
46 return reinterpret_cast<const sockaddr *>(nladdr); 50#define ASSERT_TRUE_CALLBACK \
51 [&](bool success, std::string errMsg) { \
52 if (!success) { \
53 ALOGI("Error message: %s", errMsg.c_str()); \
54 } \
55 ASSERT_TRUE(success); \
56 }
57
58#define ASSERT_FALSE_CALLBACK \
59 [&](bool success, std::string errMsg) { \
60 if (!success) { \
61 ALOGI("Error message: %s", errMsg.c_str()); \
62 } \
63 ASSERT_FALSE(success); \
64 }
65
66#define ASSERT_ZERO_BYTES_CALLBACK \
67 [&](uint64_t rxBytes, uint64_t txBytes) { \
68 EXPECT_EQ(0ULL, rxBytes); \
69 EXPECT_EQ(0ULL, txBytes); \
70 }
71
72inline const sockaddr* asSockaddr(const sockaddr_nl* nladdr) {
73 return reinterpret_cast<const sockaddr*>(nladdr);
47} 74}
48 75
49int conntrackSocket(unsigned groups) { 76int conntrackSocket(unsigned groups) {
50 android::base::unique_fd s(socket(AF_NETLINK, SOCK_DGRAM, NETLINK_NETFILTER)); 77 unique_fd s(socket(AF_NETLINK, SOCK_DGRAM, NETLINK_NETFILTER));
51 if (s.get() < 0) { 78 if (s.get() < 0) {
52 return -errno; 79 return -errno;
53 } 80 }
54 81
55 const struct sockaddr_nl bind_addr = { 82 const struct sockaddr_nl bind_addr = {
56 .nl_family = AF_NETLINK, 83 .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
57 .nl_pad = 0,
58 .nl_pid = 0,
59 .nl_groups = groups,
60 }; 84 };
61 if (::bind(s.get(), asSockaddr(&bind_addr), sizeof(bind_addr)) < 0) { 85 if (::bind(s.get(), asSockaddr(&bind_addr), sizeof(bind_addr)) < 0) {
62 return -errno; 86 return -errno;
63 } 87 }
64 88
65 const struct sockaddr_nl kernel_addr = { 89 const struct sockaddr_nl kernel_addr = {
66 .nl_family = AF_NETLINK, 90 .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
67 .nl_pad = 0,
68 .nl_pid = 0,
69 .nl_groups = groups,
70 }; 91 };
71 if (connect(s.get(), asSockaddr(&kernel_addr), sizeof(kernel_addr)) != 0) { 92 if (connect(s.get(), asSockaddr(&kernel_addr), sizeof(kernel_addr)) != 0) {
72 return -errno; 93 return -errno;
@@ -84,89 +105,94 @@ class TetheringOffloadCallbackArgs {
84 NatTimeoutUpdate last_params; 105 NatTimeoutUpdate last_params;
85}; 106};
86 107
87class OffloadControlHidlTest : public testing::VtsHalHidlTargetTestBase { 108class OffloadControlHidlTestBase : public testing::VtsHalHidlTargetTestBase {
88public: 109 public:
89 virtual void SetUp() override { 110 virtual void SetUp() override {
90 control = testing::VtsHalHidlTargetTestBase::getService<IOffloadControl>(); 111 setupConfigHal();
91 ASSERT_NE(nullptr, control.get()) << "Could not get HIDL instance"; 112 prepareControlHal();
113 }
92 114
93 control_cb = new TetheringOffloadCallback(); 115 virtual void TearDown() override { stopOffload(false); }
94 ASSERT_NE(nullptr, control.get()) << "Could not get get offload callback";
95 116
96 /* 117 // The IOffloadConfig HAL is tested more thoroughly elsewhere. He we just
97 * Config must be set with correct socket options in order for 118 // setup everything correctly and verify basic readiness.
98 * any control options to be set. 119 void setupConfigHal() {
99 */
100 config = testing::VtsHalHidlTargetTestBase::getService<IOffloadConfig>(); 120 config = testing::VtsHalHidlTargetTestBase::getService<IOffloadConfig>();
101 ASSERT_NE(nullptr, control.get()) << "Could not get HIDL instance"; 121 ASSERT_NE(nullptr, config.get()) << "Could not get HIDL instance";
102
103 android::base::unique_fd
104 fd1(conntrackSocket(NFNLGRP_CONNTRACK_NEW | NFNLGRP_CONNTRACK_DESTROY)),
105 fd2(conntrackSocket(NFNLGRP_CONNTRACK_UPDATE | NFNLGRP_CONNTRACK_DESTROY));
106 122
107 native_handle_t* nativeHandle1 = native_handle_create(1, 0); 123 unique_fd fd1(conntrackSocket(NFNLGRP_CONNTRACK_NEW | NFNLGRP_CONNTRACK_DESTROY));
108 nativeHandle1->data[0] = fd1; 124 if (fd1.get() < 0) {
125 ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
126 FAIL();
127 }
128 native_handle_t* const nativeHandle1 = native_handle_create(1, 0);
129 nativeHandle1->data[0] = fd1.release();
109 hidl_handle h1 = hidl_handle(nativeHandle1); 130 hidl_handle h1 = hidl_handle(nativeHandle1);
110 131
111 native_handle_t* nativeHandle2 = native_handle_create(1, 0); 132 unique_fd fd2(conntrackSocket(NFNLGRP_CONNTRACK_UPDATE | NFNLGRP_CONNTRACK_DESTROY));
112 nativeHandle2->data[0] = fd2; 133 if (fd2.get() < 0) {
134 ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
135 FAIL();
136 }
137 native_handle_t* const nativeHandle2 = native_handle_create(1, 0);
138 nativeHandle2->data[0] = fd2.release();
113 hidl_handle h2 = hidl_handle(nativeHandle2); 139 hidl_handle h2 = hidl_handle(nativeHandle2);
114 140
115 auto config_cb = [&](bool config_success, std::string errMsg) { 141 const Return<void> ret = config->setHandles(h1, h2, ASSERT_TRUE_CALLBACK);
116 if(!config_success) {
117 ALOGI("Config CB Error message: %s", errMsg.c_str());
118 }
119 ASSERT_TRUE(config_success);
120 };
121
122 Return<void> ret = config->setHandles(h1, h2, config_cb);
123 ASSERT_TRUE(ret.isOk()); 142 ASSERT_TRUE(ret.isOk());
143 }
144
145 void prepareControlHal() {
146 control = testing::VtsHalHidlTargetTestBase::getService<IOffloadControl>();
147 ASSERT_NE(nullptr, control.get()) << "Could not get HIDL instance";
148
149 control_cb = new TetheringOffloadCallback();
150 ASSERT_NE(nullptr, control_cb.get()) << "Could not get get offload callback";
151 }
124 152
153 void initOffload(const bool expected_result) {
125 auto init_cb = [&](bool success, std::string errMsg) { 154 auto init_cb = [&](bool success, std::string errMsg) {
126 if(!success) { 155 if (!success) {
127 ALOGI("Error message: %s", errMsg.c_str()); 156 ALOGI("Error message: %s", errMsg.c_str());
128 } 157 }
129 ASSERT_TRUE(success); 158 ASSERT_EQ(expected_result, success);
130 }; 159 };
131 ret = control->initOffload(control_cb, init_cb); 160 const Return<void> ret = control->initOffload(control_cb, init_cb);
132 ASSERT_TRUE(ret.isOk()); 161 ASSERT_TRUE(ret.isOk());
133 } 162 }
134 163
135 virtual void TearDown() override { 164 void setupControlHal() {
165 prepareControlHal();
166 initOffload(true);
167 }
168
169 void stopOffload(const bool expected_result) {
136 auto cb = [&](bool success, const hidl_string& errMsg) { 170 auto cb = [&](bool success, const hidl_string& errMsg) {
137 if(!success) { 171 if (!success) {
138 ALOGI("Error message: %s", errMsg.c_str()); 172 ALOGI("Error message: %s", errMsg.c_str());
139 } 173 }
140 ASSERT_TRUE(success); 174 ASSERT_EQ(expected_result, success);
141 }; 175 };
142 Return<void> ret = control->stopOffload(cb); 176 const Return<void> ret = control->stopOffload(cb);
143 ASSERT_TRUE(ret.isOk()); 177 ASSERT_TRUE(ret.isOk());
144
145 control_cb.clear();
146 } 178 }
147 179
148 /* Callback class for data & Event. */ 180 // Callback class for both events and NAT timeout updates.
149 class TetheringOffloadCallback 181 class TetheringOffloadCallback
150 : public testing::VtsHalHidlTargetCallbackBase<TetheringOffloadCallbackArgs>, 182 : public testing::VtsHalHidlTargetCallbackBase<TetheringOffloadCallbackArgs>,
151 public ITetheringOffloadCallback { 183 public ITetheringOffloadCallback {
152 public: 184 public:
153 TetheringOffloadCallback(){}; 185 TetheringOffloadCallback() = default;
154
155 virtual ~TetheringOffloadCallback() = default; 186 virtual ~TetheringOffloadCallback() = default;
156 187
157 /* onEvent callback function - Called when an asynchronous
158 * event is generated by the hardware management process.
159 **/
160 Return<void> onEvent(OffloadCallbackEvent event) override { 188 Return<void> onEvent(OffloadCallbackEvent event) override {
161 TetheringOffloadCallbackArgs args; 189 const TetheringOffloadCallbackArgs args{.last_event = event};
162 args.last_event = event;
163 NotifyFromCallback(kCallbackOnEvent, args); 190 NotifyFromCallback(kCallbackOnEvent, args);
164 return Void(); 191 return Void();
165 }; 192 };
166 193
167 Return<void> updateTimeout(const NatTimeoutUpdate &params) override { 194 Return<void> updateTimeout(const NatTimeoutUpdate& params) override {
168 TetheringOffloadCallbackArgs args; 195 const TetheringOffloadCallbackArgs args{.last_params = params};
169 args.last_params = params;
170 NotifyFromCallback(kCallbackUpdateTimeout, args); 196 NotifyFromCallback(kCallbackUpdateTimeout, args);
171 return Void(); 197 return Void();
172 }; 198 };
@@ -177,697 +203,418 @@ public:
177 sp<TetheringOffloadCallback> control_cb; 203 sp<TetheringOffloadCallback> control_cb;
178}; 204};
179 205
180/** 206// Call initOffload() multiple times. Check that non-first initOffload() calls return false.
181 * InitOffloadNotOk: 207TEST_F(OffloadControlHidlTestBase, AdditionalInitsWithoutStopReturnFalse) {
182 * Calls initOffload() again. Check that initOffload returns 208 initOffload(true);
183 * false, since it was already called from SetUp(). 209 initOffload(false);
184 */ 210 initOffload(false);
185TEST_F(OffloadControlHidlTest, InitOffloadNotOk) { 211 initOffload(false);
186 auto cb = [&](bool success, std::string errMsg) { 212 stopOffload(true); // balance out initOffload(true)
187 if(!success){
188 ALOGI("Error message: %s", errMsg.c_str());
189 }
190 ASSERT_FALSE(success);
191 };
192 Return<void> ret = control->initOffload(control_cb, cb);
193 EXPECT_TRUE(ret.isOk());
194} 213}
195 214
196/** 215// Check that calling stopOffload() without first having called initOffload() returns false.
197 * StopOffload: 216TEST_F(OffloadControlHidlTestBase, MultipleStopsWithoutInitReturnFalse) {
198 * Calls StopOffload() 217 stopOffload(false);
199 * Check that stopOffload after init is successful. 218 stopOffload(false);
200 */ 219 stopOffload(false);
201TEST_F(OffloadControlHidlTest, StopOffload) {
202 /* Empty function tested as part of tearDown */
203} 220}
204 221
205/** 222// Check that calling stopOffload() after a complete init/stop cycle returns false.
206 * SetLocalPrefixesIPv4: 223TEST_F(OffloadControlHidlTestBase, AdditionalStopsWithInitReturnFalse) {
207 * Calls setLocalPrefixes(). Test setting one ipv4 prefix 224 initOffload(true);
208 * returns true. 225 stopOffload(true); // balance out initOffload(true)
209 */ 226 stopOffload(false);
210TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv4) { 227 stopOffload(false);
211 auto cb = [&](bool success, std::string errMsg) {
212 if(!success) {
213 ALOGI("Error message: %s", errMsg.c_str());
214 }
215 ASSERT_TRUE(success);
216 };
217 vector<hidl_string> prefixes;
218 prefixes.push_back(hidl_string("192.0.2.1"));
219 Return<void> ret = control->setLocalPrefixes(prefixes, cb);
220 EXPECT_TRUE(ret.isOk());
221} 228}
222 229
223/** 230// Check that calling setLocalPrefixes() without first having called initOffload() returns false.
224 * SetLocalPrefixesIPv6: 231TEST_F(OffloadControlHidlTestBase, SetLocalPrefixesWithoutInitReturnsFalse) {
225 * Calls setLocalPrefixes(). Test setting one ipv6 prefix 232 const vector<hidl_string> prefixes{hidl_string("2001:db8::/64")};
226 * returns true. 233 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
227 */
228TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv6) {
229 auto cb = [&](bool success, std::string errMsg) {
230 if(!success) {
231 ALOGI("Error message: %s", errMsg.c_str());
232 }
233 ASSERT_TRUE(success);
234 };
235 vector<hidl_string> prefixes;
236 prefixes.push_back(hidl_string("fe80:0db8:0:0::1"));
237 Return<void> ret = control->setLocalPrefixes(prefixes, cb);
238 EXPECT_TRUE(ret.isOk()); 234 EXPECT_TRUE(ret.isOk());
239} 235}
240 236
241/** 237// Check that calling getForwardedStats() without first having called initOffload()
242 * SetLocalPrefixesIPv4v6: 238// returns zero bytes statistics.
243 * Calls setLocalPrefixes(). Test setting one ipv4 and one ipv6 239TEST_F(OffloadControlHidlTestBase, GetForwardedStatsWithoutInitReturnsZeroValues) {
244 * prefix returns true. 240 const hidl_string upstream("rmnet_data0");
245 */ 241 const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
246TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv4v6) {
247 auto cb = [&](bool success, std::string errMsg) {
248 if(!success) {
249 ALOGI("Error message: %s", errMsg.c_str());
250 }
251 ASSERT_TRUE(success);
252 };
253 vector<hidl_string> prefixes;
254 prefixes.push_back(hidl_string("192.0.2.1"));
255 prefixes.push_back(hidl_string("fe80:0db8:0:0::1"));
256 Return<void> ret = control->setLocalPrefixes(prefixes, cb);
257 EXPECT_TRUE(ret.isOk()); 242 EXPECT_TRUE(ret.isOk());
258} 243}
259 244
260/** 245// Check that calling setDataLimit() without first having called initOffload() returns false.
261 * Negative testcase 246TEST_F(OffloadControlHidlTestBase, SetDataLimitWithoutInitReturnsFalse) {
262 * SetLocalPrefixesEmptyNotOk: 247 const hidl_string upstream("rmnet_data0");
263 * Calls setLocalPrefixes(). Test that setting no prefixes 248 const uint64_t limit = 5000ULL;
264 * returns false. 249 const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_FALSE_CALLBACK);
265 */
266TEST_F(OffloadControlHidlTest, SetLocalPrefixesEmptyNotOk) {
267 auto cb = [&](bool success, std::string errMsg) {
268 if(!success) {
269 ALOGI("Error message: %s", errMsg.c_str());
270 }
271 ASSERT_FALSE(success);
272 };
273 vector<hidl_string> prefixes;
274 Return<void> ret = control->setLocalPrefixes(prefixes, cb);
275 EXPECT_TRUE(ret.isOk()); 250 EXPECT_TRUE(ret.isOk());
276} 251}
277 252
278/** 253// Check that calling setUpstreamParameters() without first having called initOffload()
279 * Negative testcase 254// returns false.
280 * SetLocalPrefixesInvalidNotOk: 255TEST_F(OffloadControlHidlTestBase, SetUpstreamParametersWithoutInitReturnsFalse) {
281 * Calls setLocalPrefixes(). Set the 2nd prefix of 2 to 256 const hidl_string iface("rmnet_data0");
282 * "invalid", this is expected to return false. 257 const hidl_string v4Addr("192.0.2.0/24");
283 */ 258 const hidl_string v4Gw("192.0.2.1");
284TEST_F(OffloadControlHidlTest, SetLocalPrefixesInvalidNotOk) { 259 const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
285 auto cb = [&](bool success, std::string errMsg) { 260 const Return<void> ret =
286 if(!success) { 261 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
287 ALOGI("Error message: %s", errMsg.c_str());
288 }
289 ASSERT_FALSE(success);
290 };
291 vector<hidl_string> prefixes;
292 prefixes.push_back(hidl_string("192.0.2.1"));
293 prefixes.push_back(hidl_string("invalid"));
294 Return<void> ret = control->setLocalPrefixes(prefixes, cb);
295 EXPECT_TRUE(ret.isOk()); 262 EXPECT_TRUE(ret.isOk());
296} 263}
297 264
298/** 265// Check that calling addDownstream() with an IPv4 prefix without first having called
299 * getForwardedStats: 266// initOffload() returns false.
300 * Calls getForwardedStats(). Stats should always be 0 267TEST_F(OffloadControlHidlTestBase, AddIPv4DownstreamWithoutInitReturnsFalse) {
301 * since there is no data traffic. 268 const hidl_string iface("rmnet_data0");
302 */ 269 const hidl_string prefix("192.0.2.0/24");
303TEST_F(OffloadControlHidlTest, GetForwardedStats) { 270 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
304 auto cb = [&](uint64_t rxBytes, uint64_t txBytes) {
305 EXPECT_EQ((uint64_t) 0, rxBytes);
306 EXPECT_EQ((uint64_t) 0, txBytes);
307 };
308
309 hidl_string upstream("invalid");
310 Return<void> ret = control->getForwardedStats(upstream, cb);
311 EXPECT_TRUE(ret.isOk()); 271 EXPECT_TRUE(ret.isOk());
312} 272}
313 273
314/** 274// Check that calling addDownstream() with an IPv6 prefix without first having called
315 * GetForwardedStatsDummyIface: 275// initOffload() returns false.
316 * Calls getForwardedStats(). Stats should always be 0 276TEST_F(OffloadControlHidlTestBase, AddIPv6DownstreamWithoutInitReturnsFalse) {
317 * since there is no data traffic. 277 const hidl_string iface("rmnet_data0");
318 */ 278 const hidl_string prefix("2001:db8::/64");
319TEST_F(OffloadControlHidlTest, GetForwardedStatsDummyIface) { 279 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
320 auto cb = [&](uint64_t rxBytes, uint64_t txBytes) {
321 EXPECT_EQ((uint64_t) 0, rxBytes);
322 EXPECT_EQ((uint64_t) 0, txBytes);
323 };
324
325 hidl_string upstream("dummy0");
326 Return<void> ret = control->getForwardedStats(upstream, cb);
327 EXPECT_TRUE(ret.isOk()); 280 EXPECT_TRUE(ret.isOk());
328} 281}
329 282
330/** 283// Check that calling removeDownstream() with an IPv4 prefix without first having called
331 * Negative testcase 284// initOffload() returns false.
332 * SetDataLimitEmptyNotOk: 285TEST_F(OffloadControlHidlTestBase, RemoveIPv4DownstreamWithoutInitReturnsFalse) {
333 * Calls setDataLimit(). Set data limit with an empty upstream 286 const hidl_string iface("rmnet_data0");
334 * parameter. Expectation is this returns false. 287 const hidl_string prefix("192.0.2.0/24");
335 */ 288 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
336TEST_F(OffloadControlHidlTest, SetDataLimitEmptyNotOk) {
337 auto cb = [&](bool success, std::string errMsg) {
338 if(!success) {
339 ALOGI("Error message: %s", errMsg.c_str());
340 }
341 EXPECT_FALSE(success);
342 };
343
344 hidl_string upstream("");
345 uint64_t limit = 5000;
346 Return<void> ret = control->setDataLimit(upstream, limit, cb);
347 EXPECT_TRUE(ret.isOk()); 289 EXPECT_TRUE(ret.isOk());
348} 290}
349 291
350/** 292// Check that calling removeDownstream() with an IPv6 prefix without first having called
351 * SetUpstreamParameters: 293// initOffload() returns false.
352 * Calls setUpstreamParameters(). Valid parameters should return 294TEST_F(OffloadControlHidlTestBase, RemoveIPv6DownstreamWithoutInitReturnsFalse) {
353 * true. 295 const hidl_string iface("rmnet_data0");
354 */ 296 const hidl_string prefix("2001:db8::/64");
355TEST_F(OffloadControlHidlTest, SetUpstreamParameters) { 297 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
356 auto cb = [&](bool success, std::string errMsg) {
357 if(!success) {
358 ALOGI("Error message: %s", errMsg.c_str());
359 }
360 EXPECT_TRUE(success);
361 };
362
363 hidl_string iface("dummy0");
364 hidl_string v4Addr("192.0.2.0/24");
365 hidl_string v4Gw("192.0.2.1");
366 vector<hidl_string> v6Gws;
367 v6Gws.push_back(hidl_string("fe80:0db8:0:0::1"));
368 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
369 EXPECT_TRUE(ret.isOk()); 298 EXPECT_TRUE(ret.isOk());
370} 299}
371 300
372/** 301class OffloadControlHidlTest : public OffloadControlHidlTestBase {
373 * Negative testcase 302 public:
374 * SetUpstreamParametersEmptyNotOk: 303 virtual void SetUp() override {
375 * Calls setUpstreamParameters(). Empty parameters should return false. 304 setupConfigHal();
376 */ 305 setupControlHal();
377TEST_F(OffloadControlHidlTest, SetUpstreamParametersEmptyNotOk) { 306 }
378 auto cb = [&](bool success, std::string errMsg) {
379 if(!success) {
380 ALOGI("Error message: %s", errMsg.c_str());
381 }
382 EXPECT_FALSE(success);
383 };
384 307
385 hidl_string iface(""); 308 virtual void TearDown() override { stopOffload(true); }
386 hidl_string v4Addr(""); 309};
387 hidl_string v4Gw("");
388 vector<hidl_string> v6Gws;
389 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
390 EXPECT_TRUE(ret.isOk());
391}
392 310
393/** 311/*
394 * Negative testcase 312 * Tests for IOffloadControl::setLocalPrefixes().
395 * SetUpstreamParametersIfaceInvalidNotOk:
396 * Calls setUpstreamParameters(). Invalid iface should return false.
397 */ 313 */
398TEST_F(OffloadControlHidlTest, SetUpstreamParametersIfaceInvalidNotOk) {
399 auto cb = [&](bool success, std::string errMsg) {
400 if(!success) {
401 ALOGI("Error message: %s", errMsg.c_str());
402 }
403 EXPECT_FALSE(success);
404 };
405 314
406 hidl_string iface("invalid"); 315// Test setLocalPrefixes() accepts an IPv4 address.
407 hidl_string v4Addr("192.0.2.0/24"); 316TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv4AddressOk) {
408 hidl_string v4Gw("192.0.2.1"); 317 const vector<hidl_string> prefixes{hidl_string("192.0.2.1")};
409 vector<hidl_string> v6Gws; 318 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
410 v6Gws.push_back(hidl_string("fe80:0db8:0:0::1"));
411 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
412 EXPECT_TRUE(ret.isOk()); 319 EXPECT_TRUE(ret.isOk());
413} 320}
414 321
415/** 322// Test setLocalPrefixes() accepts an IPv6 address.
416 * Negative testcase 323TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv6AddressOk) {
417 * SetUpstreamParametersIfaceEmptyNotOk: 324 const vector<hidl_string> prefixes{hidl_string("fe80::1")};
418 * Calls setUpstreamParameters(). Empty iface should return false. 325 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
419 */
420TEST_F(OffloadControlHidlTest, SetUpstreamParametersIfaceEmptyNotOk) {
421 auto cb = [&](bool success, std::string errMsg) {
422 if(!success) {
423 ALOGI("Error message: %s", errMsg.c_str());
424 }
425 EXPECT_FALSE(success);
426 };
427
428 hidl_string iface("");
429 hidl_string v4Addr("192.0.2.0/24");
430 hidl_string v4Gw("192.0.2.1");
431 vector<hidl_string> v6Gws;
432 v6Gws.push_back(hidl_string("fe80:0db8:0:0::1"));
433 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
434 EXPECT_TRUE(ret.isOk()); 326 EXPECT_TRUE(ret.isOk());
435} 327}
436 328
437/** 329// Test setLocalPrefixes() accepts both IPv4 and IPv6 prefixes.
438 * SetUpstreamParametersV4AddrEmpty: Calls 330TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv4v6PrefixesOk) {
439 * setUpstreamParameters(). Empty v4 address should return true, 331 const vector<hidl_string> prefixes{hidl_string("192.0.2.0/24"), hidl_string("fe80::/64")};
440 * v6 address will be added. 332 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
441 */
442TEST_F(OffloadControlHidlTest, SetUpstreamParametersV4AddrEmpty) {
443 auto cb = [&](bool success, std::string errMsg) {
444 if(!success) {
445 ALOGI("Error message: %s", errMsg.c_str());
446 }
447 EXPECT_TRUE(success);
448 };
449
450 hidl_string iface("dummy0");
451 hidl_string v4Addr("");
452 hidl_string v4Gw("192.0.2.1");
453 vector<hidl_string> v6Gws;
454 v6Gws.push_back(hidl_string("fe80:0db8:0:0::1"));
455 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
456 EXPECT_TRUE(ret.isOk()); 333 EXPECT_TRUE(ret.isOk());
457} 334}
458 335
459/** 336// Test that setLocalPrefixes() fails given empty input. There is always
460 * Negative testcase 337// a non-empty set of local prefixes; when all networking interfaces are down
461 * SetUpstreamParametersV4AddrInvalidNotOk: 338// we still apply {127.0.0.0/8, ::1/128, fe80::/64} here.
462 * Calls setUpstreamParameters(). Invalid v4 address should return false. 339TEST_F(OffloadControlHidlTest, SetLocalPrefixesEmptyFails) {
463 */ 340 const vector<hidl_string> prefixes{};
464TEST_F(OffloadControlHidlTest, SetUpstreamParametersV4AddrInvalidNotOk) { 341 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
465 auto cb = [&](bool success, std::string errMsg) {
466 if(!success) {
467 ALOGI("Error message: %s", errMsg.c_str());
468 }
469 EXPECT_FALSE(success);
470 };
471
472 hidl_string iface("dummy0");
473 hidl_string v4Addr("invalid");
474 hidl_string v4Gw("192.0.2.1");
475 vector<hidl_string> v6Gws;
476 v6Gws.push_back(hidl_string("fe80:0db8:0:0::1"));
477 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
478 EXPECT_TRUE(ret.isOk()); 342 EXPECT_TRUE(ret.isOk());
479} 343}
480 344
481/** 345// Test setLocalPrefixes() fails on incorrectly formed input strings.
482 * Negative testcase 346TEST_F(OffloadControlHidlTest, SetLocalPrefixesInvalidFails) {
483 * SetUpstreamParametersV4AddrInvalid2NotOk: 347 const vector<hidl_string> prefixes{hidl_string("192.0.2.0/24"), hidl_string("invalid")};
484 * Calls setUpstreamParameters(). Invalid v4 address (missing 1 octet) 348 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
485 * should return false.
486 */
487TEST_F(OffloadControlHidlTest, SetUpstreamParametersV4AddrInvalid2NotOk) {
488 auto cb = [&](bool success, std::string errMsg) {
489 if(!success) {
490 ALOGI("Error message: %s", errMsg.c_str());
491 }
492 EXPECT_FALSE(success);
493 };
494
495 hidl_string iface("dummy0");
496 hidl_string v4Addr("192.0.2");
497 hidl_string v4Gw("192.0.2.1");
498 vector<hidl_string> v6Gws;
499 v6Gws.push_back(hidl_string("fe80:0db8:0:0::1"));
500 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
501 EXPECT_TRUE(ret.isOk()); 349 EXPECT_TRUE(ret.isOk());
502} 350}
503 351
504/** 352/*
505 * SetUpstreamParametersV4GwEmpty: Calls 353 * Tests for IOffloadControl::getForwardedStats().
506 * setUpstreamParameters(). Empty ipv4 gateway should return
507 * true, v6 address will be added.
508 */ 354 */
509TEST_F(OffloadControlHidlTest, SetUpstreamParametersV4GwEmpty) {
510 auto cb = [&](bool success, std::string errMsg) {
511 if(!success) {
512 ALOGI("Error message: %s", errMsg.c_str());
513 }
514 EXPECT_TRUE(success);
515 };
516 355
517 hidl_string iface("dummy0"); 356// Test that getForwardedStats() for a non-existent upstream yields zero bytes statistics.
518 hidl_string v4Addr("192.0.2.0/24"); 357TEST_F(OffloadControlHidlTest, GetForwardedStatsInvalidUpstreamIface) {
519 hidl_string v4Gw(""); 358 const hidl_string upstream("invalid");
520 vector<hidl_string> v6Gws; 359 const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
521 v6Gws.push_back(hidl_string("fe80:0db8:0:0::1"));
522 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
523 EXPECT_TRUE(ret.isOk()); 360 EXPECT_TRUE(ret.isOk());
524} 361}
525 362
526/** 363// The "rmnet_data0" is presumed to exist on the device and be up. No packets
527 * Negative testcase 364// are ever actually caused to be forwarded.
528 * SetUpstreamParametersV4GwInvalidNotOk: 365TEST_F(OffloadControlHidlTest, GetForwardedStatsDummyIface) {
529 * Calls setUpstreamParameters(). Invalid ipv4 gateway should return false. 366 const hidl_string upstream("rmnet_data0");
530 */ 367 const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
531TEST_F(OffloadControlHidlTest, SetUpstreamParametersV4GwInvalidNotOk) {
532 auto cb = [&](bool success, std::string errMsg) {
533 if(!success) {
534 ALOGI("Error message: %s", errMsg.c_str());
535 }
536 EXPECT_FALSE(success);
537 };
538
539 hidl_string iface("dummy0");
540 hidl_string v4Addr("192.0.2.0/24");
541 hidl_string v4Gw("invalid");
542 vector<hidl_string> v6Gws;
543 v6Gws.push_back(hidl_string("fe80:0db8:0:0::1"));
544 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
545 EXPECT_TRUE(ret.isOk()); 368 EXPECT_TRUE(ret.isOk());
546} 369}
547 370
548/** 371/*
549 * Negative testcase 372 * Tests for IOffloadControl::setDataLimit().
550 * SetUpstreamParametersV4GwInvalid2NotOk:
551 * Calls setUpstreamParameters(). Invalid v4 gateway (missing 1 octet)
552 * should return false.
553 */ 373 */
554TEST_F(OffloadControlHidlTest, SetUpstreamParametersV4GwInvalid2NotOk) {
555 auto cb = [&](bool success, std::string errMsg) {
556 if(!success) {
557 ALOGI("Error message: %s", errMsg.c_str());
558 }
559 EXPECT_FALSE(success);
560 };
561 374
562 hidl_string iface("dummy0"); 375// Test that setDataLimit() for an empty interface name fails.
563 hidl_string v4Addr("192.0.2.0/24"); 376TEST_F(OffloadControlHidlTest, SetDataLimitEmptyUpstreamIfaceFails) {
564 hidl_string v4Gw("192.0.2"); 377 const hidl_string upstream("");
565 vector<hidl_string> v6Gws; 378 const uint64_t limit = 5000ULL;
566 v6Gws.push_back(hidl_string("fe80:0db8:0:0::1")); 379 const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_FALSE_CALLBACK);
567 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
568 EXPECT_TRUE(ret.isOk()); 380 EXPECT_TRUE(ret.isOk());
569} 381}
570 382
571/** 383// The "rmnet_data0" is presumed to exist on the device and be up. No packets
572 * Negative testcase 384// are ever actually caused to be forwarded.
573 * SetUpstreamParametersV6GwEmptyNotOk: 385TEST_F(OffloadControlHidlTest, SetDataLimitNonZeroOk) {
574 * Calls setUpstreamParameters(). Invalid IPv6 gateway should 386 const hidl_string upstream("rmnet_data0");
575 * return false. 387 const uint64_t limit = 5000ULL;
576 */ 388 const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_TRUE_CALLBACK);
577TEST_F(OffloadControlHidlTest, SetUpstreamParametersV6GwEmptyNotOk) {
578 auto cb = [&](bool success, std::string errMsg) {
579 if(!success) {
580 ALOGI("Error message: %s", errMsg.c_str());
581 }
582 EXPECT_FALSE(success);
583 };
584
585 hidl_string iface("dummy0");
586 hidl_string v4Addr("192.0.2.0/24");
587 hidl_string v4Gw("192.0.2.1");
588 vector<hidl_string> v6Gws;
589 v6Gws.push_back(hidl_string(""));
590 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
591 EXPECT_TRUE(ret.isOk()); 389 EXPECT_TRUE(ret.isOk());
592} 390}
593 391
594/** 392// The "rmnet_data0" is presumed to exist on the device and be up. No packets
595 * Negative testcase 393// are ever actually caused to be forwarded.
596 * SetUpstreamParametersV6GwInvalidNotOk: 394TEST_F(OffloadControlHidlTest, SetDataLimitZeroOk) {
597 * Calls setUpstreamParameters(). Invalid IPv6 gateway should return false. 395 const hidl_string upstream("rmnet_data0");
598 */ 396 const uint64_t limit = 0ULL;
599TEST_F(OffloadControlHidlTest, SetUpstreamParametersV6GwInvalidNotOk) { 397 const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_TRUE_CALLBACK);
600 auto cb = [&](bool success, std::string errMsg) {
601 if(!success) {
602 ALOGI("Error message: %s", errMsg.c_str());
603 }
604 EXPECT_FALSE(success);
605 };
606
607 hidl_string iface("dummy0");
608 hidl_string v4Addr("192.0.2.0/24");
609 hidl_string v4Gw("192.0.2.1");
610 vector<hidl_string> v6Gws;
611 v6Gws.push_back(hidl_string("invalid"));
612 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
613 EXPECT_TRUE(ret.isOk()); 398 EXPECT_TRUE(ret.isOk());
614} 399}
615 400
616/** 401/*
617 * Negative testcase 402 * Tests for IOffloadControl::setUpstreamParameters().
618 * SetUpstreamParametersV6GwInvalid2NotOk: 403 */
619 * Calls setUpstreamParameters(). Invalid IPv6 gateway (too 404
620 * short)should return false. 405// The "rmnet_data0" is presumed to exist on the device and be up. No packets
621 */ 406// are ever actually caused to be forwarded.
622TEST_F(OffloadControlHidlTest, SetUpstreamParametersV6GwInvalid2NotOk) { 407TEST_F(OffloadControlHidlTest, SetUpstreamParametersIPv6OnlyOk) {
623 auto cb = [&](bool success, std::string errMsg) { 408 const hidl_string iface("rmnet_data0");
624 if(!success) { 409 const hidl_string v4Addr("");
625 ALOGI("Error message: %s", errMsg.c_str()); 410 const hidl_string v4Gw("");
626 } 411 const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1"), hidl_string("fe80::db8:2")};
627 EXPECT_FALSE(success); 412 const Return<void> ret =
628 }; 413 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
629 414 EXPECT_TRUE(ret.isOk());
630 hidl_string iface("dummy0"); 415}
631 hidl_string v4Addr("192.0.2.0/24"); 416
632 hidl_string v4Gw("192.0.2.1"); 417// The "rmnet_data0" is presumed to exist on the device and be up. No packets
633 vector<hidl_string> v6Gws; 418// are ever actually caused to be forwarded.
634 v6Gws.push_back(hidl_string("fe80:0db8")); 419TEST_F(OffloadControlHidlTest, SetUpstreamParametersAlternateIPv6OnlyOk) {
635 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb); 420 const hidl_string iface("rmnet_data0");
636 EXPECT_TRUE(ret.isOk()); 421 const hidl_string v4Addr;
422 const hidl_string v4Gw;
423 const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1"), hidl_string("fe80::db8:3")};
424 const Return<void> ret =
425 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
426 EXPECT_TRUE(ret.isOk());
427}
428
429// The "rmnet_data0" is presumed to exist on the device and be up. No packets
430// are ever actually caused to be forwarded.
431TEST_F(OffloadControlHidlTest, SetUpstreamParametersIPv4OnlyOk) {
432 const hidl_string iface("rmnet_data0");
433 const hidl_string v4Addr("192.0.2.2");
434 const hidl_string v4Gw("192.0.2.1");
435 const vector<hidl_string> v6Gws{};
436 const Return<void> ret =
437 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
438 EXPECT_TRUE(ret.isOk());
439}
440
441// The "rmnet_data0" is presumed to exist on the device and be up. No packets
442// are ever actually caused to be forwarded.
443TEST_F(OffloadControlHidlTest, SetUpstreamParametersIPv4v6Ok) {
444 const hidl_string iface("rmnet_data0");
445 const hidl_string v4Addr("192.0.2.2");
446 const hidl_string v4Gw("192.0.2.1");
447 const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1"), hidl_string("fe80::db8::2")};
448 const Return<void> ret =
449 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
450 EXPECT_TRUE(ret.isOk());
451}
452
453// Test that setUpstreamParameters() fails when all parameters are empty.
454TEST_F(OffloadControlHidlTest, SetUpstreamParametersEmptyFails) {
455 const hidl_string iface("");
456 const hidl_string v4Addr("");
457 const hidl_string v4Gw("");
458 const vector<hidl_string> v6Gws{};
459 const Return<void> ret =
460 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
461 EXPECT_TRUE(ret.isOk());
462}
463
464// Test that setUpstreamParameters() fails when given empty or non-existent interface names.
465TEST_F(OffloadControlHidlTest, SetUpstreamParametersBogusIfaceFails) {
466 const hidl_string v4Addr("192.0.2.2");
467 const hidl_string v4Gw("192.0.2.1");
468 const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
469 for (const auto& bogus : {"", "invalid"}) {
470 SCOPED_TRACE(StringPrintf("iface='%s'", bogus));
471 const hidl_string iface(bogus);
472 const Return<void> ret =
473 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
474 EXPECT_TRUE(ret.isOk());
475 }
637} 476}
638 477
639/** 478// Test that setUpstreamParameters() fails when given unparseable IPv4 addresses.
640 * SetUpstreamParametersV4OnlyValid: 479TEST_F(OffloadControlHidlTest, SetUpstreamParametersInvalidIPv4AddrFails) {
641 * Calls setUpstreamParameters(). Invalid v6 gateway, should 480 const hidl_string iface("rmnet_data0");
642 * still pass since a valid v4 gateway is passed in. 481 const hidl_string v4Gw("192.0.2.1");
643 */ 482 const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
644TEST_F(OffloadControlHidlTest, SetUpstreamParametersV4Only) { 483 for (const auto& bogus : {"invalid", "192.0.2"}) {
645 auto cb = [&](bool success, std::string errMsg) { 484 SCOPED_TRACE(StringPrintf("v4addr='%s'", bogus));
646 if(!success) { 485 const hidl_string v4Addr(bogus);
647 ALOGI("Error message: %s", errMsg.c_str()); 486 const Return<void> ret =
648 } 487 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
649 EXPECT_TRUE(success); 488 EXPECT_TRUE(ret.isOk());
650 }; 489 }
651
652 hidl_string iface("dummy0");
653 hidl_string v4Addr("192.0.2.0/24");
654 hidl_string v4Gw("192.0.2.1");
655 vector<hidl_string> v6Gws;
656 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
657 EXPECT_TRUE(ret.isOk());
658} 490}
659 491
660/** 492// Test that setUpstreamParameters() fails when given unparseable IPv4 gateways.
661 * SetUpstreamParametersV6Only: 493TEST_F(OffloadControlHidlTest, SetUpstreamParametersInvalidIPv4GatewayFails) {
662 * Calls setUpstreamParameters(). Invalid v4 parameters, should 494 const hidl_string iface("rmnet_data0");
663 * still pass since a valid v6 gateway is passed in. 495 const hidl_string v4Addr("192.0.2.2");
664 */ 496 const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
665TEST_F(OffloadControlHidlTest, SetUpstreamParametersV6Only) { 497 for (const auto& bogus : {"invalid", "192.0.2"}) {
666 auto cb = [&](bool success, std::string errMsg) { 498 SCOPED_TRACE(StringPrintf("v4gateway='%s'", bogus));
667 if(!success) { 499 const hidl_string v4Gw(bogus);
668 ALOGI("Error message: %s", errMsg.c_str()); 500 const Return<void> ret =
669 } 501 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
670 EXPECT_TRUE(success); 502 EXPECT_TRUE(ret.isOk());
671 }; 503 }
672
673 hidl_string iface("dummy0");
674 hidl_string v4Addr;
675 hidl_string v4Gw;
676 vector<hidl_string> v6Gws;
677 v6Gws.push_back(hidl_string("fe80:0db8:0:0::1"));
678 Return<void> ret = control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, cb);
679 EXPECT_TRUE(ret.isOk());
680} 504}
681 505
682/** 506// Test that setUpstreamParameters() fails when given unparseable IPv6 gateways.
683 * AddDownstream: 507TEST_F(OffloadControlHidlTest, SetUpstreamParametersBadIPv6GatewaysFail) {
684 * Calls addDownstream(). Valid parameters should return true. 508 const hidl_string iface("rmnet_data0");
685 */ 509 const hidl_string v4Addr("192.0.2.2");
686TEST_F(OffloadControlHidlTest, AddDownstream) { 510 const hidl_string v4Gw("192.0.2.1");
687 auto cb = [&](bool success, std::string errMsg) { 511 for (const auto& bogus : {"", "invalid", "fe80::bogus", "192.0.2.66"}) {
688 if(!success) { 512 SCOPED_TRACE(StringPrintf("v6gateway='%s'", bogus));
689 ALOGI("Error message: %s", errMsg.c_str()); 513 const vector<hidl_string> v6Gws{hidl_string("fe80::1"), hidl_string(bogus)};
690 } 514 const Return<void> ret =
691 ASSERT_TRUE(success); 515 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
692 }; 516 EXPECT_TRUE(ret.isOk());
693 517 }
694 hidl_string iface("dummy0");
695 hidl_string prefix("192.0.2.0/24");
696 Return<void> ret = control->addDownstream(iface, prefix, cb);
697 EXPECT_TRUE(ret.isOk());
698} 518}
699 519
700/** 520/*
701 * Negative testcase 521 * Tests for IOffloadControl::addDownstream().
702 * AddDownstreamEmptyNotOk:
703 * Calls addDownstream(). Empty parameters should return false.
704 */ 522 */
705TEST_F(OffloadControlHidlTest, AddDownstreamEmptyNotOk) {
706 auto cb = [&](bool success, std::string errMsg) {
707 if(!success) {
708 ALOGI("Error message: %s", errMsg.c_str());
709 }
710 EXPECT_FALSE(success);
711 };
712 523
713 hidl_string iface(""); 524// Test addDownstream() works given an IPv4 prefix.
714 hidl_string prefix(""); 525TEST_F(OffloadControlHidlTest, AddDownstreamIPv4) {
715 Return<void> ret = control->addDownstream(iface, prefix, cb); 526 const hidl_string iface("dummy0");
527 const hidl_string prefix("192.0.2.0/24");
528 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
716 EXPECT_TRUE(ret.isOk()); 529 EXPECT_TRUE(ret.isOk());
717} 530}
718 531
719/** 532// Test addDownstream() works given an IPv6 prefix.
720 * Negative testcase 533TEST_F(OffloadControlHidlTest, AddDownstreamIPv6) {
721 * AddDownstreamPrefixEmptyNotOk: 534 const hidl_string iface("dummy0");
722 * Calls addDownstream(). Empty prefix should return false. 535 const hidl_string prefix("2001:db8::/64");
723 */ 536 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
724TEST_F(OffloadControlHidlTest, AddDownstreamPrefixEmptyNotOk) {
725 auto cb = [&](bool success, std::string errMsg) {
726 if(!success) {
727 ALOGI("Error message: %s", errMsg.c_str());
728 }
729 EXPECT_FALSE(success);
730 };
731
732 hidl_string iface("dummy0");
733 hidl_string prefix("");
734 Return<void> ret = control->addDownstream(iface, prefix, cb);
735 EXPECT_TRUE(ret.isOk()); 537 EXPECT_TRUE(ret.isOk());
736} 538}
737 539
738/** 540// Test addDownstream() fails given all empty parameters.
739 * Negative testcase 541TEST_F(OffloadControlHidlTest, AddDownstreamEmptyFails) {
740 * AddDownstreamInvalidNotOk: 542 const hidl_string iface("");
741 * Calls addDownstream(). Invalid parameters should return false. 543 const hidl_string prefix("");
742 */ 544 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
743TEST_F(OffloadControlHidlTest, AddDownstreamInvalidNotOk) {
744 auto cb = [&](bool success, std::string errMsg) {
745 if(!success) {
746 ALOGI("Error message: %s", errMsg.c_str());
747 }
748 EXPECT_FALSE(success);
749 };
750
751 hidl_string iface("invalid");
752 hidl_string prefix("192.0.2");
753 Return<void> ret = control->addDownstream(iface, prefix, cb);
754 EXPECT_TRUE(ret.isOk()); 545 EXPECT_TRUE(ret.isOk());
755} 546}
756 547
757/** 548// Test addDownstream() fails given empty or non-existent interface names.
758 * Negative testcase 549TEST_F(OffloadControlHidlTest, AddDownstreamInvalidIfaceFails) {
759 * AddDownstreamInvalid2NotOk: 550 const hidl_string prefix("192.0.2.0/24");
760 * Calls addDownstream(). Invalid parameters should return false. Prefix 551 for (const auto& bogus : {"", "invalid"}) {
761 * is too short, missing 1 octet. 552 SCOPED_TRACE(StringPrintf("iface='%s'", bogus));
762 */ 553 const hidl_string iface(bogus);
763TEST_F(OffloadControlHidlTest, AddDownstreamInvalid2NotOk) { 554 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
764 auto cb = [&](bool success, std::string errMsg) { 555 EXPECT_TRUE(ret.isOk());
765 if(!success) { 556 }
766 ALOGI("Error message: %s", errMsg.c_str());
767 }
768 EXPECT_FALSE(success);
769 };
770
771 hidl_string iface("dummy0");
772 hidl_string prefix("192.0.2");
773 Return<void> ret = control->addDownstream(iface, prefix, cb);
774 EXPECT_TRUE(ret.isOk());
775} 557}
776 558
777/** 559// Test addDownstream() fails given unparseable prefix arguments.
778 * RemoveDownstream: 560TEST_F(OffloadControlHidlTest, AddDownstreamBogusPrefixFails) {
779 * Calls removeDownstream(). Valid parameters should return true. 561 const hidl_string iface("dummy0");
780 */ 562 for (const auto& bogus : {"", "192.0.2/24", "2001:db8/64"}) {
781TEST_F(OffloadControlHidlTest, RemoveDownstream) { 563 SCOPED_TRACE(StringPrintf("prefix='%s'", bogus));
782 auto cb = [&](bool success, std::string errMsg) { 564 const hidl_string prefix(bogus);
783 if(!success) { 565 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
784 ALOGI("Error message: %s", errMsg.c_str()); 566 EXPECT_TRUE(ret.isOk());
785 } 567 }
786 ASSERT_TRUE(success);
787 };
788
789 hidl_string iface("dummy0");
790 hidl_string prefix("192.0.2.0/24");
791 Return<void> ret = control->removeDownstream(iface, prefix, cb);
792 EXPECT_TRUE(ret.isOk());
793} 568}
794 569
795/** 570/*
796 * Negative testcase 571 * Tests for IOffloadControl::removeDownstream().
797 * RemoveDownstreamEmptyNotOk:
798 * Calls removeDownstream(). Empty parameters should return false.
799 */ 572 */
800TEST_F(OffloadControlHidlTest, RemoveDownstreamEmptyNotOk) {
801 auto cb = [&](bool success, std::string errMsg) {
802 if(!success) {
803 ALOGI("Error message: %s", errMsg.c_str());
804 }
805 EXPECT_FALSE(success);
806 };
807 573
808 hidl_string iface(""); 574// Test removeDownstream() works given an IPv4 prefix.
809 hidl_string prefix(""); 575TEST_F(OffloadControlHidlTest, RemoveDownstreamIPv4) {
810 Return<void> ret = control->removeDownstream(iface, prefix, cb); 576 const hidl_string iface("dummy0");
577 const hidl_string prefix("192.0.2.0/24");
578 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
811 EXPECT_TRUE(ret.isOk()); 579 EXPECT_TRUE(ret.isOk());
812} 580}
813 581
814/** 582// Test removeDownstream() works given an IPv6 prefix.
815 * Negative testcase 583TEST_F(OffloadControlHidlTest, RemoveDownstreamIPv6) {
816 * RemoveDownstreamEmpty2NotOk: 584 const hidl_string iface("dummy0");
817 * Calls removeDownstream(). Empty prefix should return 585 const hidl_string prefix("2001:db8::/64");
818 * false. 586 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
819 */
820TEST_F(OffloadControlHidlTest, RemoveDownstreamEmpty2NotOk) {
821 auto cb = [&](bool success, std::string errMsg) {
822 if(!success) {
823 ALOGI("Error message: %s", errMsg.c_str());
824 }
825 EXPECT_FALSE(success);
826 };
827
828 hidl_string iface("dummy0");
829 hidl_string prefix("");
830 Return<void> ret = control->removeDownstream(iface, prefix, cb);
831 EXPECT_TRUE(ret.isOk()); 587 EXPECT_TRUE(ret.isOk());
832} 588}
833 589
834/** 590// Test removeDownstream() fails given all empty parameters.
835 * Negative testcase 591TEST_F(OffloadControlHidlTest, RemoveDownstreamEmptyFails) {
836 * RemoveDownstreamInvalidNotOk: 592 const hidl_string iface("");
837 * Calls removeDownstream(). Invalid parameters should return false. 593 const hidl_string prefix("");
838 */ 594 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
839TEST_F(OffloadControlHidlTest, RemoveDownstreamInvalidNotOk) {
840 auto cb = [&](bool success, std::string errMsg) {
841 if(!success) {
842 ALOGI("Error message: %s", errMsg.c_str());
843 }
844 EXPECT_FALSE(success);
845 };
846
847 hidl_string iface("invalid");
848 hidl_string prefix("192.0.2.1");
849 Return<void> ret = control->removeDownstream(iface, prefix, cb);
850 EXPECT_TRUE(ret.isOk()); 595 EXPECT_TRUE(ret.isOk());
851} 596}
852 597
853/** 598// Test removeDownstream() fails given empty or non-existent interface names.
854 * Negative testcase 599TEST_F(OffloadControlHidlTest, RemoveDownstreamBogusIfaceFails) {
855 * RemoveDownstreamInvalid2NotOk: 600 const hidl_string prefix("192.0.2.0/24");
856 * Calls removeDownstream(). Invalid parameters should return false. Prefix 601 for (const auto& bogus : {"", "invalid"}) {
857 * is too short, missing 1 octet. 602 SCOPED_TRACE(StringPrintf("iface='%s'", bogus));
858 */ 603 const hidl_string iface(bogus);
859TEST_F(OffloadControlHidlTest, RemoveDownstreamInvalid2NotOk) { 604 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
860 auto cb = [&](bool success, std::string errMsg) { 605 EXPECT_TRUE(ret.isOk());
861 if(!success) { 606 }
862 ALOGI("Error message: %s", errMsg.c_str()); 607}
863 }
864 EXPECT_FALSE(success);
865 };
866 608
867 hidl_string iface("dummy0"); 609// Test removeDownstream() fails given unparseable prefix arguments.
868 hidl_string prefix("192.0.2"); 610TEST_F(OffloadControlHidlTest, RemoveDownstreamBogusPrefixFails) {
869 Return<void> ret = control->removeDownstream(iface, prefix, cb); 611 const hidl_string iface("dummy0");
870 EXPECT_TRUE(ret.isOk()); 612 for (const auto& bogus : {"", "192.0.2/24", "2001:db8/64"}) {
613 SCOPED_TRACE(StringPrintf("prefix='%s'", bogus));
614 const hidl_string prefix(bogus);
615 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
616 EXPECT_TRUE(ret.isOk());
617 }
871} 618}
872 619
873int main(int argc, char** argv) { 620int main(int argc, char** argv) {