diff options
author | Erik Kline | 2017-08-07 13:32:45 -0500 |
---|---|---|
committer | Erik Kline | 2017-08-07 15:51:09 -0500 |
commit | 434b8d38d0c418158b68bcd450cc1af5b6c8c0d4 (patch) | |
tree | 7bc52449ce15f990091b6c2c7f391210c1f5a10b /tetheroffload | |
parent | 36678525469e9c92f5f1d603c57ab55845bc2b31 (diff) | |
download | platform-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')
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 | |||
1 | cc_test { | 15 | cc_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 | ||
31 | using android::base::StringPrintf; | ||
32 | using android::base::unique_fd; | ||
28 | using android::hardware::hidl_handle; | 33 | using android::hardware::hidl_handle; |
29 | using android::hardware::hidl_string; | 34 | using android::hardware::hidl_string; |
30 | using android::hardware::Return; | 35 | using android::hardware::Return; |
@@ -32,41 +37,48 @@ using android::hardware::tetheroffload::config::V1_0::IOffloadConfig; | |||
32 | using android::hardware::Void; | 37 | using android::hardware::Void; |
33 | using android::sp; | 38 | using android::sp; |
34 | 39 | ||
35 | inline 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 | |||
46 | const unsigned kFd1Groups = NFNLGRP_CONNTRACK_NEW | NFNLGRP_CONNTRACK_DESTROY; | ||
47 | const unsigned kFd2Groups = NFNLGRP_CONNTRACK_UPDATE | NFNLGRP_CONNTRACK_DESTROY; | ||
48 | |||
49 | inline const sockaddr* asSockaddr(const sockaddr_nl* nladdr) { | ||
50 | return reinterpret_cast<const sockaddr*>(nladdr); | ||
37 | } | 51 | } |
38 | 52 | ||
39 | int conntrackSocket(unsigned groups) { | 53 | int 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 | ||
76 | int netlinkSocket(unsigned groups) { | ||
77 | return netlinkSocket(NETLINK_NETFILTER, groups); | ||
78 | } | ||
79 | |||
68 | class OffloadConfigHidlTest : public testing::VtsHalHidlTargetTestBase { | 80 | class OffloadConfigHidlTest : public testing::VtsHalHidlTargetTestBase { |
69 | public: | 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 | */ | ||
83 | TEST_F(OffloadConfigHidlTest, TestSetHandles) { | 93 | TEST_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 | */ | ||
121 | TEST_F(OffloadConfigHidlTest, TestSetHandleNone) { | 118 | TEST_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 | */ | ||
140 | TEST_F(OffloadConfigHidlTest, TestSetHandle1Only) { | 130 | TEST_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 | */ | ||
163 | TEST_F(OffloadConfigHidlTest, TestSetHandle2OnlyNotOk) { | 149 | TEST_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 | |||
1 | cc_test { | 15 | cc_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 | ||
33 | using android::base::StringPrintf; | ||
34 | using android::base::unique_fd; | ||
31 | using android::hardware::hidl_handle; | 35 | using android::hardware::hidl_handle; |
32 | using android::hardware::hidl_string; | 36 | using android::hardware::hidl_string; |
33 | using android::hardware::hidl_vec; | 37 | using android::hardware::hidl_vec; |
@@ -42,31 +46,48 @@ using android::hardware::tetheroffload::control::V1_0::NetworkProtocol; | |||
42 | using android::hardware::Void; | 46 | using android::hardware::Void; |
43 | using android::sp; | 47 | using android::sp; |
44 | 48 | ||
45 | inline 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 | |||
72 | inline const sockaddr* asSockaddr(const sockaddr_nl* nladdr) { | ||
73 | return reinterpret_cast<const sockaddr*>(nladdr); | ||
47 | } | 74 | } |
48 | 75 | ||
49 | int conntrackSocket(unsigned groups) { | 76 | int 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 | ||
87 | class OffloadControlHidlTest : public testing::VtsHalHidlTargetTestBase { | 108 | class OffloadControlHidlTestBase : public testing::VtsHalHidlTargetTestBase { |
88 | public: | 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 ¶ms) 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: | 207 | TEST_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); |
185 | TEST_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: | 216 | TEST_F(OffloadControlHidlTestBase, MultipleStopsWithoutInitReturnFalse) { |
198 | * Calls StopOffload() | 217 | stopOffload(false); |
199 | * Check that stopOffload after init is successful. | 218 | stopOffload(false); |
200 | */ | 219 | stopOffload(false); |
201 | TEST_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: | 223 | TEST_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); |
210 | TEST_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: | 231 | TEST_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 | */ | ||
228 | TEST_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 | 239 | TEST_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); |
246 | TEST_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 | 246 | TEST_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 | */ | ||
266 | TEST_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: | 255 | TEST_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"); |
284 | TEST_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 | 267 | TEST_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"); |
303 | TEST_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 | 276 | TEST_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"); |
319 | TEST_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: | 285 | TEST_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); |
336 | TEST_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 | 294 | TEST_F(OffloadControlHidlTestBase, RemoveIPv6DownstreamWithoutInitReturnsFalse) { |
353 | * true. | 295 | const hidl_string iface("rmnet_data0"); |
354 | */ | 296 | const hidl_string prefix("2001:db8::/64"); |
355 | TEST_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 | /** | 301 | class 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(); |
377 | TEST_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 | */ |
398 | TEST_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"); | 316 | TEST_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 | 323 | TEST_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 | */ | ||
420 | TEST_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 | 330 | TEST_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 | */ | ||
442 | TEST_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. | 339 | TEST_F(OffloadControlHidlTest, SetLocalPrefixesEmptyFails) { |
463 | */ | 340 | const vector<hidl_string> prefixes{}; |
464 | TEST_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 | 346 | TEST_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 | */ | ||
487 | TEST_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 | */ |
509 | TEST_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"); | 357 | TEST_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: | 365 | TEST_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); |
531 | TEST_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 | */ |
554 | TEST_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"); | 376 | TEST_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: | 385 | TEST_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); |
577 | TEST_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: | 394 | TEST_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; |
599 | TEST_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. |
622 | TEST_F(OffloadControlHidlTest, SetUpstreamParametersV6GwInvalid2NotOk) { | 407 | TEST_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")); | 419 | TEST_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. | ||
431 | TEST_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. | ||
443 | TEST_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. | ||
454 | TEST_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. | ||
465 | TEST_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: | 479 | TEST_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")}; |
644 | TEST_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: | 493 | TEST_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")}; |
665 | TEST_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: | 507 | TEST_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"); |
686 | TEST_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 | */ |
705 | TEST_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(""); | 525 | TEST_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 | 533 | TEST_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); |
724 | TEST_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 | 541 | TEST_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); |
743 | TEST_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 | 549 | TEST_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); |
763 | TEST_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: | 560 | TEST_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"}) { |
781 | TEST_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 | */ |
800 | TEST_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(""); | 575 | TEST_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 | 583 | TEST_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 | */ | ||
820 | TEST_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 | 591 | TEST_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); |
839 | TEST_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 | 599 | TEST_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); |
859 | TEST_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"); | 610 | TEST_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 | ||
873 | int main(int argc, char** argv) { | 620 | int main(int argc, char** argv) { |