2 * Copyright (C) 2017 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #define LOG_TAG "VtsOffloadControlV1_0TargetTest"
19 #include <VtsHalHidlTargetCallbackBase.h>
20 #include <VtsHalHidlTargetTestBase.h>
21 #include <android-base/stringprintf.h>
22 #include <android-base/unique_fd.h>
23 #include <android/hardware/tetheroffload/config/1.0/IOffloadConfig.h>
24 #include <android/hardware/tetheroffload/control/1.0/IOffloadControl.h>
25 #include <android/hardware/tetheroffload/control/1.0/types.h>
26 #include <linux/netfilter/nfnetlink.h>
27 #include <linux/netlink.h>
29 #include <sys/socket.h>
33 using android::base::StringPrintf;
34 using android::base::unique_fd;
35 using android::hardware::hidl_handle;
36 using android::hardware::hidl_string;
37 using android::hardware::hidl_vec;
38 using android::hardware::Return;
39 using android::hardware::tetheroffload::config::V1_0::IOffloadConfig;
40 using android::hardware::tetheroffload::control::V1_0::IOffloadControl;
41 using android::hardware::tetheroffload::control::V1_0::IPv4AddrPortPair;
42 using android::hardware::tetheroffload::control::V1_0::ITetheringOffloadCallback;
43 using android::hardware::tetheroffload::control::V1_0::OffloadCallbackEvent;
44 using android::hardware::tetheroffload::control::V1_0::NatTimeoutUpdate;
45 using android::hardware::tetheroffload::control::V1_0::NetworkProtocol;
46 using android::hardware::Void;
49 // We use #defines here so as to get local lamba captures and error message line numbers
50 #define ASSERT_TRUE_CALLBACK \
51 [&](bool success, std::string errMsg) { \
53 ALOGI("Error message: %s", errMsg.c_str()); \
55 ASSERT_TRUE(success); \
58 #define ASSERT_FALSE_CALLBACK \
59 [&](bool success, std::string errMsg) { \
61 ALOGI("Error message: %s", errMsg.c_str()); \
63 ASSERT_FALSE(success); \
66 #define ASSERT_ZERO_BYTES_CALLBACK \
67 [&](uint64_t rxBytes, uint64_t txBytes) { \
68 EXPECT_EQ(0ULL, rxBytes); \
69 EXPECT_EQ(0ULL, txBytes); \
72 inline const sockaddr* asSockaddr(const sockaddr_nl* nladdr) {
73 return reinterpret_cast<const sockaddr*>(nladdr);
76 int conntrackSocket(unsigned groups) {
77 unique_fd s(socket(AF_NETLINK, SOCK_DGRAM, NETLINK_NETFILTER));
82 const struct sockaddr_nl bind_addr = {
83 .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
85 if (::bind(s.get(), asSockaddr(&bind_addr), sizeof(bind_addr)) < 0) {
89 const struct sockaddr_nl kernel_addr = {
90 .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
92 if (connect(s.get(), asSockaddr(&kernel_addr), sizeof(kernel_addr)) != 0) {
99 constexpr char kCallbackOnEvent[] = "onEvent";
100 constexpr char kCallbackUpdateTimeout[] = "updateTimeout";
102 class TetheringOffloadCallbackArgs {
104 OffloadCallbackEvent last_event;
105 NatTimeoutUpdate last_params;
108 class OffloadControlHidlTestBase : public testing::VtsHalHidlTargetTestBase {
110 virtual void SetUp() override {
115 virtual void TearDown() override { stopOffload(false); }
117 // The IOffloadConfig HAL is tested more thoroughly elsewhere. He we just
118 // setup everything correctly and verify basic readiness.
119 void setupConfigHal() {
120 config = testing::VtsHalHidlTargetTestBase::getService<IOffloadConfig>();
121 ASSERT_NE(nullptr, config.get()) << "Could not get HIDL instance";
123 unique_fd fd1(conntrackSocket(NFNLGRP_CONNTRACK_NEW | NFNLGRP_CONNTRACK_DESTROY));
125 ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
128 native_handle_t* const nativeHandle1 = native_handle_create(1, 0);
129 nativeHandle1->data[0] = fd1.release();
130 hidl_handle h1 = hidl_handle(nativeHandle1);
132 unique_fd fd2(conntrackSocket(NFNLGRP_CONNTRACK_UPDATE | NFNLGRP_CONNTRACK_DESTROY));
134 ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
137 native_handle_t* const nativeHandle2 = native_handle_create(1, 0);
138 nativeHandle2->data[0] = fd2.release();
139 hidl_handle h2 = hidl_handle(nativeHandle2);
141 const Return<void> ret = config->setHandles(h1, h2, ASSERT_TRUE_CALLBACK);
142 ASSERT_TRUE(ret.isOk());
145 void prepareControlHal() {
146 control = testing::VtsHalHidlTargetTestBase::getService<IOffloadControl>();
147 ASSERT_NE(nullptr, control.get()) << "Could not get HIDL instance";
149 control_cb = new TetheringOffloadCallback();
150 ASSERT_NE(nullptr, control_cb.get()) << "Could not get get offload callback";
153 void initOffload(const bool expected_result) {
154 auto init_cb = [&](bool success, std::string errMsg) {
156 ALOGI("Error message: %s", errMsg.c_str());
158 ASSERT_EQ(expected_result, success);
160 const Return<void> ret = control->initOffload(control_cb, init_cb);
161 ASSERT_TRUE(ret.isOk());
164 void setupControlHal() {
169 void stopOffload(const bool expected_result) {
170 auto cb = [&](bool success, const hidl_string& errMsg) {
172 ALOGI("Error message: %s", errMsg.c_str());
174 ASSERT_EQ(expected_result, success);
176 const Return<void> ret = control->stopOffload(cb);
177 ASSERT_TRUE(ret.isOk());
180 // Callback class for both events and NAT timeout updates.
181 class TetheringOffloadCallback
182 : public testing::VtsHalHidlTargetCallbackBase<TetheringOffloadCallbackArgs>,
183 public ITetheringOffloadCallback {
185 TetheringOffloadCallback() = default;
186 virtual ~TetheringOffloadCallback() = default;
188 Return<void> onEvent(OffloadCallbackEvent event) override {
189 const TetheringOffloadCallbackArgs args{.last_event = event};
190 NotifyFromCallback(kCallbackOnEvent, args);
194 Return<void> updateTimeout(const NatTimeoutUpdate& params) override {
195 const TetheringOffloadCallbackArgs args{.last_params = params};
196 NotifyFromCallback(kCallbackUpdateTimeout, args);
201 sp<IOffloadConfig> config;
202 sp<IOffloadControl> control;
203 sp<TetheringOffloadCallback> control_cb;
206 // Call initOffload() multiple times. Check that non-first initOffload() calls return false.
207 TEST_F(OffloadControlHidlTestBase, AdditionalInitsWithoutStopReturnFalse) {
212 stopOffload(true); // balance out initOffload(true)
215 // Check that calling stopOffload() without first having called initOffload() returns false.
216 TEST_F(OffloadControlHidlTestBase, MultipleStopsWithoutInitReturnFalse) {
222 // Check that calling stopOffload() after a complete init/stop cycle returns false.
223 TEST_F(OffloadControlHidlTestBase, AdditionalStopsWithInitReturnFalse) {
225 stopOffload(true); // balance out initOffload(true)
230 // Check that calling setLocalPrefixes() without first having called initOffload() returns false.
231 TEST_F(OffloadControlHidlTestBase, SetLocalPrefixesWithoutInitReturnsFalse) {
232 const vector<hidl_string> prefixes{hidl_string("2001:db8::/64")};
233 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
234 EXPECT_TRUE(ret.isOk());
237 // Check that calling getForwardedStats() without first having called initOffload()
238 // returns zero bytes statistics.
239 TEST_F(OffloadControlHidlTestBase, GetForwardedStatsWithoutInitReturnsZeroValues) {
240 const hidl_string upstream("rmnet_data0");
241 const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
242 EXPECT_TRUE(ret.isOk());
245 // Check that calling setDataLimit() without first having called initOffload() returns false.
246 TEST_F(OffloadControlHidlTestBase, SetDataLimitWithoutInitReturnsFalse) {
247 const hidl_string upstream("rmnet_data0");
248 const uint64_t limit = 5000ULL;
249 const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_FALSE_CALLBACK);
250 EXPECT_TRUE(ret.isOk());
253 // Check that calling setUpstreamParameters() without first having called initOffload()
255 TEST_F(OffloadControlHidlTestBase, SetUpstreamParametersWithoutInitReturnsFalse) {
256 const hidl_string iface("rmnet_data0");
257 const hidl_string v4Addr("192.0.2.0/24");
258 const hidl_string v4Gw("192.0.2.1");
259 const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
260 const Return<void> ret =
261 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
262 EXPECT_TRUE(ret.isOk());
265 // Check that calling addDownstream() with an IPv4 prefix without first having called
266 // initOffload() returns false.
267 TEST_F(OffloadControlHidlTestBase, AddIPv4DownstreamWithoutInitReturnsFalse) {
268 const hidl_string iface("rmnet_data0");
269 const hidl_string prefix("192.0.2.0/24");
270 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
271 EXPECT_TRUE(ret.isOk());
274 // Check that calling addDownstream() with an IPv6 prefix without first having called
275 // initOffload() returns false.
276 TEST_F(OffloadControlHidlTestBase, AddIPv6DownstreamWithoutInitReturnsFalse) {
277 const hidl_string iface("rmnet_data0");
278 const hidl_string prefix("2001:db8::/64");
279 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
280 EXPECT_TRUE(ret.isOk());
283 // Check that calling removeDownstream() with an IPv4 prefix without first having called
284 // initOffload() returns false.
285 TEST_F(OffloadControlHidlTestBase, RemoveIPv4DownstreamWithoutInitReturnsFalse) {
286 const hidl_string iface("rmnet_data0");
287 const hidl_string prefix("192.0.2.0/24");
288 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
289 EXPECT_TRUE(ret.isOk());
292 // Check that calling removeDownstream() with an IPv6 prefix without first having called
293 // initOffload() returns false.
294 TEST_F(OffloadControlHidlTestBase, RemoveIPv6DownstreamWithoutInitReturnsFalse) {
295 const hidl_string iface("rmnet_data0");
296 const hidl_string prefix("2001:db8::/64");
297 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
298 EXPECT_TRUE(ret.isOk());
301 class OffloadControlHidlTest : public OffloadControlHidlTestBase {
303 virtual void SetUp() override {
308 virtual void TearDown() override { stopOffload(true); }
312 * Tests for IOffloadControl::setLocalPrefixes().
315 // Test setLocalPrefixes() accepts an IPv4 address.
316 TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv4AddressOk) {
317 const vector<hidl_string> prefixes{hidl_string("192.0.2.1")};
318 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
319 EXPECT_TRUE(ret.isOk());
322 // Test setLocalPrefixes() accepts an IPv6 address.
323 TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv6AddressOk) {
324 const vector<hidl_string> prefixes{hidl_string("fe80::1")};
325 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
326 EXPECT_TRUE(ret.isOk());
329 // Test setLocalPrefixes() accepts both IPv4 and IPv6 prefixes.
330 TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv4v6PrefixesOk) {
331 const vector<hidl_string> prefixes{hidl_string("192.0.2.0/24"), hidl_string("fe80::/64")};
332 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
333 EXPECT_TRUE(ret.isOk());
336 // Test that setLocalPrefixes() fails given empty input. There is always
337 // a non-empty set of local prefixes; when all networking interfaces are down
338 // we still apply {127.0.0.0/8, ::1/128, fe80::/64} here.
339 TEST_F(OffloadControlHidlTest, SetLocalPrefixesEmptyFails) {
340 const vector<hidl_string> prefixes{};
341 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
342 EXPECT_TRUE(ret.isOk());
345 // Test setLocalPrefixes() fails on incorrectly formed input strings.
346 TEST_F(OffloadControlHidlTest, SetLocalPrefixesInvalidFails) {
347 const vector<hidl_string> prefixes{hidl_string("192.0.2.0/24"), hidl_string("invalid")};
348 const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
349 EXPECT_TRUE(ret.isOk());
353 * Tests for IOffloadControl::getForwardedStats().
356 // Test that getForwardedStats() for a non-existent upstream yields zero bytes statistics.
357 TEST_F(OffloadControlHidlTest, GetForwardedStatsInvalidUpstreamIface) {
358 const hidl_string upstream("invalid");
359 const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
360 EXPECT_TRUE(ret.isOk());
363 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
364 // are ever actually caused to be forwarded.
365 TEST_F(OffloadControlHidlTest, GetForwardedStatsDummyIface) {
366 const hidl_string upstream("rmnet_data0");
367 const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
368 EXPECT_TRUE(ret.isOk());
372 * Tests for IOffloadControl::setDataLimit().
375 // Test that setDataLimit() for an empty interface name fails.
376 TEST_F(OffloadControlHidlTest, SetDataLimitEmptyUpstreamIfaceFails) {
377 const hidl_string upstream("");
378 const uint64_t limit = 5000ULL;
379 const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_FALSE_CALLBACK);
380 EXPECT_TRUE(ret.isOk());
383 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
384 // are ever actually caused to be forwarded.
385 TEST_F(OffloadControlHidlTest, SetDataLimitNonZeroOk) {
386 const hidl_string upstream("rmnet_data0");
387 const uint64_t limit = 5000ULL;
388 const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_TRUE_CALLBACK);
389 EXPECT_TRUE(ret.isOk());
392 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
393 // are ever actually caused to be forwarded.
394 TEST_F(OffloadControlHidlTest, SetDataLimitZeroOk) {
395 const hidl_string upstream("rmnet_data0");
396 const uint64_t limit = 0ULL;
397 const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_TRUE_CALLBACK);
398 EXPECT_TRUE(ret.isOk());
402 * Tests for IOffloadControl::setUpstreamParameters().
405 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
406 // are ever actually caused to be forwarded.
407 TEST_F(OffloadControlHidlTest, SetUpstreamParametersIPv6OnlyOk) {
408 const hidl_string iface("rmnet_data0");
409 const hidl_string v4Addr("");
410 const hidl_string v4Gw("");
411 const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1"), hidl_string("fe80::db8:2")};
412 const Return<void> ret =
413 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
414 EXPECT_TRUE(ret.isOk());
417 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
418 // are ever actually caused to be forwarded.
419 TEST_F(OffloadControlHidlTest, SetUpstreamParametersAlternateIPv6OnlyOk) {
420 const hidl_string iface("rmnet_data0");
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());
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());
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());
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());
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());
478 // Test that setUpstreamParameters() fails when given unparseable IPv4 addresses.
479 TEST_F(OffloadControlHidlTest, SetUpstreamParametersInvalidIPv4AddrFails) {
480 const hidl_string iface("rmnet_data0");
481 const hidl_string v4Gw("192.0.2.1");
482 const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
483 for (const auto& bogus : {"invalid", "192.0.2"}) {
484 SCOPED_TRACE(StringPrintf("v4addr='%s'", bogus));
485 const hidl_string v4Addr(bogus);
486 const Return<void> ret =
487 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
488 EXPECT_TRUE(ret.isOk());
492 // Test that setUpstreamParameters() fails when given unparseable IPv4 gateways.
493 TEST_F(OffloadControlHidlTest, SetUpstreamParametersInvalidIPv4GatewayFails) {
494 const hidl_string iface("rmnet_data0");
495 const hidl_string v4Addr("192.0.2.2");
496 const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
497 for (const auto& bogus : {"invalid", "192.0.2"}) {
498 SCOPED_TRACE(StringPrintf("v4gateway='%s'", bogus));
499 const hidl_string v4Gw(bogus);
500 const Return<void> ret =
501 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
502 EXPECT_TRUE(ret.isOk());
506 // Test that setUpstreamParameters() fails when given unparseable IPv6 gateways.
507 TEST_F(OffloadControlHidlTest, SetUpstreamParametersBadIPv6GatewaysFail) {
508 const hidl_string iface("rmnet_data0");
509 const hidl_string v4Addr("192.0.2.2");
510 const hidl_string v4Gw("192.0.2.1");
511 for (const auto& bogus : {"", "invalid", "fe80::bogus", "192.0.2.66"}) {
512 SCOPED_TRACE(StringPrintf("v6gateway='%s'", bogus));
513 const vector<hidl_string> v6Gws{hidl_string("fe80::1"), hidl_string(bogus)};
514 const Return<void> ret =
515 control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
516 EXPECT_TRUE(ret.isOk());
521 * Tests for IOffloadControl::addDownstream().
524 // Test addDownstream() works given an IPv4 prefix.
525 TEST_F(OffloadControlHidlTest, AddDownstreamIPv4) {
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);
529 EXPECT_TRUE(ret.isOk());
532 // Test addDownstream() works given an IPv6 prefix.
533 TEST_F(OffloadControlHidlTest, AddDownstreamIPv6) {
534 const hidl_string iface("dummy0");
535 const hidl_string prefix("2001:db8::/64");
536 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
537 EXPECT_TRUE(ret.isOk());
540 // Test addDownstream() fails given all empty parameters.
541 TEST_F(OffloadControlHidlTest, AddDownstreamEmptyFails) {
542 const hidl_string iface("");
543 const hidl_string prefix("");
544 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
545 EXPECT_TRUE(ret.isOk());
548 // Test addDownstream() fails given empty or non-existent interface names.
549 TEST_F(OffloadControlHidlTest, AddDownstreamInvalidIfaceFails) {
550 const hidl_string prefix("192.0.2.0/24");
551 for (const auto& bogus : {"", "invalid"}) {
552 SCOPED_TRACE(StringPrintf("iface='%s'", bogus));
553 const hidl_string iface(bogus);
554 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
555 EXPECT_TRUE(ret.isOk());
559 // Test addDownstream() fails given unparseable prefix arguments.
560 TEST_F(OffloadControlHidlTest, AddDownstreamBogusPrefixFails) {
561 const hidl_string iface("dummy0");
562 for (const auto& bogus : {"", "192.0.2/24", "2001:db8/64"}) {
563 SCOPED_TRACE(StringPrintf("prefix='%s'", bogus));
564 const hidl_string prefix(bogus);
565 const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
566 EXPECT_TRUE(ret.isOk());
571 * Tests for IOffloadControl::removeDownstream().
574 // Test removeDownstream() works given an IPv4 prefix.
575 TEST_F(OffloadControlHidlTest, RemoveDownstreamIPv4) {
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);
579 EXPECT_TRUE(ret.isOk());
582 // Test removeDownstream() works given an IPv6 prefix.
583 TEST_F(OffloadControlHidlTest, RemoveDownstreamIPv6) {
584 const hidl_string iface("dummy0");
585 const hidl_string prefix("2001:db8::/64");
586 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
587 EXPECT_TRUE(ret.isOk());
590 // Test removeDownstream() fails given all empty parameters.
591 TEST_F(OffloadControlHidlTest, RemoveDownstreamEmptyFails) {
592 const hidl_string iface("");
593 const hidl_string prefix("");
594 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
595 EXPECT_TRUE(ret.isOk());
598 // Test removeDownstream() fails given empty or non-existent interface names.
599 TEST_F(OffloadControlHidlTest, RemoveDownstreamBogusIfaceFails) {
600 const hidl_string prefix("192.0.2.0/24");
601 for (const auto& bogus : {"", "invalid"}) {
602 SCOPED_TRACE(StringPrintf("iface='%s'", bogus));
603 const hidl_string iface(bogus);
604 const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
605 EXPECT_TRUE(ret.isOk());
609 // Test removeDownstream() fails given unparseable prefix arguments.
610 TEST_F(OffloadControlHidlTest, RemoveDownstreamBogusPrefixFails) {
611 const hidl_string iface("dummy0");
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());
620 int main(int argc, char** argv) {
621 testing::InitGoogleTest(&argc, argv);
622 int status = RUN_ALL_TESTS();
623 ALOGE("Test result with status=%d", status);