tetheroffload/control/1.0/vts/functional/VtsHalTetheroffloadControlV1_0TargetTest.cpp

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   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
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #define LOG_TAG "VtsOffloadControlV1_0TargetTest"
  18
  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>
  28 #include <log/log.h>
  29 #include <sys/socket.h>
  30 #include <unistd.h>
  31 #include <set>
  32
  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;
  47 using android::sp;
  48
  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) {             \
  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);
  74 }
  75
  76 int conntrackSocket(unsigned groups) {
  77     unique_fd s(socket(AF_NETLINK, SOCK_DGRAM, NETLINK_NETFILTER));
  78     if (s.get() < 0) {
  79         return -errno;
  80     }
  81
  82     const struct sockaddr_nl bind_addr = {
  83         .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
  84     };
  85     if (::bind(s.get(), asSockaddr(&bind_addr), sizeof(bind_addr)) < 0) {
  86         return -errno;
  87     }
  88
  89     const struct sockaddr_nl kernel_addr = {
  90         .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
  91     };
  92     if (connect(s.get(), asSockaddr(&kernel_addr), sizeof(kernel_addr)) != 0) {
  93         return -errno;
  94     }
  95
  96     return s.release();
  97 }
  98
  99 constexpr char kCallbackOnEvent[] = "onEvent";
 100 constexpr char kCallbackUpdateTimeout[] = "updateTimeout";
 101
 102 class TetheringOffloadCallbackArgs {
 103    public:
 104     OffloadCallbackEvent last_event;
 105     NatTimeoutUpdate last_params;
 106 };
 107
 108 class OffloadControlHidlTestBase : public testing::VtsHalHidlTargetTestBase {
 109    public:
 110     virtual void SetUp() override {
 111         setupConfigHal();
 112         prepareControlHal();
 113     }
 114
 115     virtual void TearDown() override { stopOffload(false); }
 116
 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";
 122
 123         unique_fd fd1(conntrackSocket(NFNLGRP_CONNTRACK_NEW | NFNLGRP_CONNTRACK_DESTROY));
 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();
 130         hidl_handle h1 = hidl_handle(nativeHandle1);
 131
 132         unique_fd fd2(conntrackSocket(NFNLGRP_CONNTRACK_UPDATE | NFNLGRP_CONNTRACK_DESTROY));
 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();
 139         hidl_handle h2 = hidl_handle(nativeHandle2);
 140
 141         const Return<void> ret = config->setHandles(h1, h2, ASSERT_TRUE_CALLBACK);
 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     }
 152
 153     void initOffload(const bool expected_result) {
 154         auto init_cb = [&](bool success, std::string errMsg) {
 155             if (!success) {
 156                 ALOGI("Error message: %s", errMsg.c_str());
 157             }
 158             ASSERT_EQ(expected_result, success);
 159         };
 160         const Return<void> ret = control->initOffload(control_cb, init_cb);
 161         ASSERT_TRUE(ret.isOk());
 162     }
 163
 164     void setupControlHal() {
 165         prepareControlHal();
 166         initOffload(true);
 167     }
 168
 169     void stopOffload(const bool expected_result) {
 170         auto cb = [&](bool success, const hidl_string& errMsg) {
 171             if (!success) {
 172                 ALOGI("Error message: %s", errMsg.c_str());
 173             }
 174             ASSERT_EQ(expected_result, success);
 175         };
 176         const Return<void> ret = control->stopOffload(cb);
 177         ASSERT_TRUE(ret.isOk());
 178     }
 179
 180     // Callback class for both events and NAT timeout updates.
 181     class TetheringOffloadCallback
 182         : public testing::VtsHalHidlTargetCallbackBase<TetheringOffloadCallbackArgs>,
 183           public ITetheringOffloadCallback {
 184        public:
 185         TetheringOffloadCallback() = default;
 186         virtual ~TetheringOffloadCallback() = default;
 187
 188         Return<void> onEvent(OffloadCallbackEvent event) override {
 189             const TetheringOffloadCallbackArgs args{.last_event = event};
 190             NotifyFromCallback(kCallbackOnEvent, args);
 191             return Void();
 192         };
 193
 194         Return<void> updateTimeout(const NatTimeoutUpdate& params) override {
 195             const TetheringOffloadCallbackArgs args{.last_params = params};
 196             NotifyFromCallback(kCallbackUpdateTimeout, args);
 197             return Void();
 198         };
 199     };
 200
 201     sp<IOffloadConfig> config;
 202     sp<IOffloadControl> control;
 203     sp<TetheringOffloadCallback> control_cb;
 204 };
 205
 206 // Call initOffload() multiple times. Check that non-first initOffload() calls return false.
 207 TEST_F(OffloadControlHidlTestBase, AdditionalInitsWithoutStopReturnFalse) {
 208     initOffload(true);
 209     initOffload(false);
 210     initOffload(false);
 211     initOffload(false);
 212     stopOffload(true);  // balance out initOffload(true)
 213 }
 214
 215 // Check that calling stopOffload() without first having called initOffload() returns false.
 216 TEST_F(OffloadControlHidlTestBase, MultipleStopsWithoutInitReturnFalse) {
 217     stopOffload(false);
 218     stopOffload(false);
 219     stopOffload(false);
 220 }
 221
 222 // Check that calling stopOffload() after a complete init/stop cycle returns false.
 223 TEST_F(OffloadControlHidlTestBase, AdditionalStopsWithInitReturnFalse) {
 224     initOffload(true);
 225     stopOffload(true);  // balance out initOffload(true)
 226     stopOffload(false);
 227     stopOffload(false);
 228 }
 229
 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());
 235 }
 236
 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());
 243 }
 244
 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());
 251 }
 252
 253 // Check that calling setUpstreamParameters() without first having called initOffload()
 254 // returns false.
 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());
 263 }
 264
 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());
 272 }
 273
 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());
 281 }
 282
 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());
 290 }
 291
 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());
 299 }
 300
 301 class OffloadControlHidlTest : public OffloadControlHidlTestBase {
 302    public:
 303     virtual void SetUp() override {
 304         setupConfigHal();
 305         setupControlHal();
 306     }
 307
 308     virtual void TearDown() override { stopOffload(true); }
 309 };
 310
 311 /*
 312  * Tests for IOffloadControl::setLocalPrefixes().
 313  */
 314
 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());
 320 }
 321
 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());
 327 }
 328
 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());
 334 }
 335
 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());
 343 }
 344
 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());
 350 }
 351
 352 /*
 353  * Tests for IOffloadControl::getForwardedStats().
 354  */
 355
 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());
 361 }
 362
 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());
 369 }
 370
 371 /*
 372  * Tests for IOffloadControl::setDataLimit().
 373  */
 374
 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());
 381 }
 382
 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());
 390 }
 391
 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());
 399 }
 400
 401 /*
 402  * Tests for IOffloadControl::setUpstreamParameters().
 403  */
 404
 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());
 415 }
 416
 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());
 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     }
 476 }
 477
 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());
 489     }
 490 }
 491
 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());
 503     }
 504 }
 505
 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());
 517     }
 518 }
 519
 520 /*
 521  * Tests for IOffloadControl::addDownstream().
 522  */
 523
 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());
 530 }
 531
 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());
 538 }
 539
 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());
 546 }
 547
 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());
 556     }
 557 }
 558
 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());
 567     }
 568 }
 569
 570 /*
 571  * Tests for IOffloadControl::removeDownstream().
 572  */
 573
 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());
 580 }
 581
 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());
 588 }
 589
 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());
 596 }
 597
 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());
 606     }
 607 }
 608
 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());
 617     }
 618 }
 619
 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);
 624     return status;
 625 }