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 enum class ExpectBoolean {
  50     Ignored = -1,
  51     False = 0,
  52     True = 1,
  53 };
  54
  55 // We use #defines here so as to get local lamba captures and error message line numbers
  56 #define ASSERT_TRUE_CALLBACK                            \
  57     [&](bool success, std::string errMsg) {             \
  58         if (!success) {                                 \
  59             ALOGI("Error message: %s", errMsg.c_str()); \
  60         }                                               \
  61         ASSERT_TRUE(success);                           \
  62     }
  63
  64 #define ASSERT_FALSE_CALLBACK                           \
  65     [&](bool success, std::string errMsg) {             \
  66         if (!success) {                                 \
  67             ALOGI("Error message: %s", errMsg.c_str()); \
  68         }                                               \
  69         ASSERT_FALSE(success);                          \
  70     }
  71
  72 #define ASSERT_ZERO_BYTES_CALLBACK            \
  73     [&](uint64_t rxBytes, uint64_t txBytes) { \
  74         EXPECT_EQ(0ULL, rxBytes);             \
  75         EXPECT_EQ(0ULL, txBytes);             \
  76     }
  77
  78 inline const sockaddr* asSockaddr(const sockaddr_nl* nladdr) {
  79     return reinterpret_cast<const sockaddr*>(nladdr);
  80 }
  81
  82 int conntrackSocket(unsigned groups) {
  83     unique_fd s(socket(AF_NETLINK, SOCK_DGRAM, NETLINK_NETFILTER));
  84     if (s.get() < 0) {
  85         return -errno;
  86     }
  87
  88     const struct sockaddr_nl bind_addr = {
  89         .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
  90     };
  91     if (::bind(s.get(), asSockaddr(&bind_addr), sizeof(bind_addr)) < 0) {
  92         return -errno;
  93     }
  94
  95     const struct sockaddr_nl kernel_addr = {
  96         .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
  97     };
  98     if (connect(s.get(), asSockaddr(&kernel_addr), sizeof(kernel_addr)) != 0) {
  99         return -errno;
 100     }
 101
 102     return s.release();
 103 }
 104
 105 constexpr char kCallbackOnEvent[] = "onEvent";
 106 constexpr char kCallbackUpdateTimeout[] = "updateTimeout";
 107
 108 class TetheringOffloadCallbackArgs {
 109    public:
 110     OffloadCallbackEvent last_event;
 111     NatTimeoutUpdate last_params;
 112 };
 113
 114 class OffloadControlHidlTestBase : public testing::VtsHalHidlTargetTestBase {
 115    public:
 116     virtual void SetUp() override {
 117         setupConfigHal();
 118         prepareControlHal();
 119     }
 120
 121     virtual void TearDown() override {
 122         // For good measure, we should try stopOffload() once more. Since we
 123         // don't know where we are in HAL call test cycle we don't know what
 124         // return code to actually expect, so we just ignore it.
 125         stopOffload(ExpectBoolean::Ignored);
 126     }
 127
 128     // The IOffloadConfig HAL is tested more thoroughly elsewhere. He we just
 129     // setup everything correctly and verify basic readiness.
 130     void setupConfigHal() {
 131         config = testing::VtsHalHidlTargetTestBase::getService<IOffloadConfig>();
 132         ASSERT_NE(nullptr, config.get()) << "Could not get HIDL instance";
 133
 134         unique_fd fd1(conntrackSocket(NFNLGRP_CONNTRACK_NEW | NFNLGRP_CONNTRACK_DESTROY));
 135         if (fd1.get() < 0) {
 136             ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
 137             FAIL();
 138         }
 139         native_handle_t* const nativeHandle1 = native_handle_create(1, 0);
 140         nativeHandle1->data[0] = fd1.release();
 141         hidl_handle h1;
 142         h1.setTo(nativeHandle1, true);
 143
 144         unique_fd fd2(conntrackSocket(NFNLGRP_CONNTRACK_UPDATE | NFNLGRP_CONNTRACK_DESTROY));
 145         if (fd2.get() < 0) {
 146             ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
 147             FAIL();
 148         }
 149         native_handle_t* const nativeHandle2 = native_handle_create(1, 0);
 150         nativeHandle2->data[0] = fd2.release();
 151         hidl_handle h2;
 152         h2.setTo(nativeHandle2, true);
 153
 154         const Return<void> ret = config->setHandles(h1, h2, ASSERT_TRUE_CALLBACK);
 155         ASSERT_TRUE(ret.isOk());
 156     }
 157
 158     void prepareControlHal() {
 159         control = testing::VtsHalHidlTargetTestBase::getService<IOffloadControl>();
 160         ASSERT_NE(nullptr, control.get()) << "Could not get HIDL instance";
 161
 162         control_cb = new TetheringOffloadCallback();
 163         ASSERT_NE(nullptr, control_cb.get()) << "Could not get get offload callback";
 164     }
 165
 166     void initOffload(const bool expected_result) {
 167         auto init_cb = [&](bool success, std::string errMsg) {
 168             if (!success) {
 169                 ALOGI("Error message: %s", errMsg.c_str());
 170             }
 171             ASSERT_EQ(expected_result, success);
 172         };
 173         const Return<void> ret = control->initOffload(control_cb, init_cb);
 174         ASSERT_TRUE(ret.isOk());
 175     }
 176
 177     void setupControlHal() {
 178         prepareControlHal();
 179         initOffload(true);
 180     }
 181
 182     void stopOffload(const ExpectBoolean value) {
 183         auto cb = [&](bool success, const hidl_string& errMsg) {
 184             if (!success) {
 185                 ALOGI("Error message: %s", errMsg.c_str());
 186             }
 187             switch (value) {
 188                 case ExpectBoolean::False:
 189                     ASSERT_EQ(false, success);
 190                     break;
 191                 case ExpectBoolean::True:
 192                     ASSERT_EQ(true, success);
 193                     break;
 194                 case ExpectBoolean::Ignored:
 195                     break;
 196             }
 197         };
 198         const Return<void> ret = control->stopOffload(cb);
 199         ASSERT_TRUE(ret.isOk());
 200     }
 201
 202     // Callback class for both events and NAT timeout updates.
 203     class TetheringOffloadCallback
 204         : public testing::VtsHalHidlTargetCallbackBase<TetheringOffloadCallbackArgs>,
 205           public ITetheringOffloadCallback {
 206        public:
 207         TetheringOffloadCallback() = default;
 208         virtual ~TetheringOffloadCallback() = default;
 209
 210         Return<void> onEvent(OffloadCallbackEvent event) override {
 211             const TetheringOffloadCallbackArgs args{.last_event = event};
 212             NotifyFromCallback(kCallbackOnEvent, args);
 213             return Void();
 214         };
 215
 216         Return<void> updateTimeout(const NatTimeoutUpdate& params) override {
 217             const TetheringOffloadCallbackArgs args{.last_params = params};
 218             NotifyFromCallback(kCallbackUpdateTimeout, args);
 219             return Void();
 220         };
 221     };
 222
 223     sp<IOffloadConfig> config;
 224     sp<IOffloadControl> control;
 225     sp<TetheringOffloadCallback> control_cb;
 226 };
 227
 228 // Call initOffload() multiple times. Check that non-first initOffload() calls return false.
 229 TEST_F(OffloadControlHidlTestBase, AdditionalInitsWithoutStopReturnFalse) {
 230     initOffload(true);
 231     initOffload(false);
 232     initOffload(false);
 233     initOffload(false);
 234     stopOffload(ExpectBoolean::True);  // balance out initOffload(true)
 235 }
 236
 237 // Check that calling stopOffload() without first having called initOffload() returns false.
 238 TEST_F(OffloadControlHidlTestBase, MultipleStopsWithoutInitReturnFalse) {
 239     stopOffload(ExpectBoolean::False);
 240     stopOffload(ExpectBoolean::False);
 241     stopOffload(ExpectBoolean::False);
 242 }
 243
 244 // Check that calling stopOffload() after a complete init/stop cycle returns false.
 245 TEST_F(OffloadControlHidlTestBase, AdditionalStopsWithInitReturnFalse) {
 246     initOffload(true);
 247     stopOffload(ExpectBoolean::True);  // balance out initOffload(true)
 248     stopOffload(ExpectBoolean::False);
 249     stopOffload(ExpectBoolean::False);
 250 }
 251
 252 // Check that calling setLocalPrefixes() without first having called initOffload() returns false.
 253 TEST_F(OffloadControlHidlTestBase, SetLocalPrefixesWithoutInitReturnsFalse) {
 254     const vector<hidl_string> prefixes{hidl_string("2001:db8::/64")};
 255     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
 256     EXPECT_TRUE(ret.isOk());
 257 }
 258
 259 // Check that calling getForwardedStats() without first having called initOffload()
 260 // returns zero bytes statistics.
 261 TEST_F(OffloadControlHidlTestBase, GetForwardedStatsWithoutInitReturnsZeroValues) {
 262     const hidl_string upstream("rmnet_data0");
 263     const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
 264     EXPECT_TRUE(ret.isOk());
 265 }
 266
 267 // Check that calling setDataLimit() without first having called initOffload() returns false.
 268 TEST_F(OffloadControlHidlTestBase, SetDataLimitWithoutInitReturnsFalse) {
 269     const hidl_string upstream("rmnet_data0");
 270     const uint64_t limit = 5000ULL;
 271     const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_FALSE_CALLBACK);
 272     EXPECT_TRUE(ret.isOk());
 273 }
 274
 275 // Check that calling setUpstreamParameters() without first having called initOffload()
 276 // returns false.
 277 TEST_F(OffloadControlHidlTestBase, SetUpstreamParametersWithoutInitReturnsFalse) {
 278     const hidl_string iface("rmnet_data0");
 279     const hidl_string v4Addr("192.0.2.0/24");
 280     const hidl_string v4Gw("192.0.2.1");
 281     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
 282     const Return<void> ret =
 283         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 284     EXPECT_TRUE(ret.isOk());
 285 }
 286
 287 // Check that calling addDownstream() with an IPv4 prefix without first having called
 288 // initOffload() returns false.
 289 TEST_F(OffloadControlHidlTestBase, AddIPv4DownstreamWithoutInitReturnsFalse) {
 290     const hidl_string iface("rmnet_data0");
 291     const hidl_string prefix("192.0.2.0/24");
 292     const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 293     EXPECT_TRUE(ret.isOk());
 294 }
 295
 296 // Check that calling addDownstream() with an IPv6 prefix without first having called
 297 // initOffload() returns false.
 298 TEST_F(OffloadControlHidlTestBase, AddIPv6DownstreamWithoutInitReturnsFalse) {
 299     const hidl_string iface("rmnet_data0");
 300     const hidl_string prefix("2001:db8::/64");
 301     const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 302     EXPECT_TRUE(ret.isOk());
 303 }
 304
 305 // Check that calling removeDownstream() with an IPv4 prefix without first having called
 306 // initOffload() returns false.
 307 TEST_F(OffloadControlHidlTestBase, RemoveIPv4DownstreamWithoutInitReturnsFalse) {
 308     const hidl_string iface("rmnet_data0");
 309     const hidl_string prefix("192.0.2.0/24");
 310     const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 311     EXPECT_TRUE(ret.isOk());
 312 }
 313
 314 // Check that calling removeDownstream() with an IPv6 prefix without first having called
 315 // initOffload() returns false.
 316 TEST_F(OffloadControlHidlTestBase, RemoveIPv6DownstreamWithoutInitReturnsFalse) {
 317     const hidl_string iface("rmnet_data0");
 318     const hidl_string prefix("2001:db8::/64");
 319     const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 320     EXPECT_TRUE(ret.isOk());
 321 }
 322
 323 class OffloadControlHidlTest : public OffloadControlHidlTestBase {
 324    public:
 325     virtual void SetUp() override {
 326         setupConfigHal();
 327         setupControlHal();
 328     }
 329
 330     virtual void TearDown() override {
 331         // For good measure, we should try stopOffload() once more. Since we
 332         // don't know where we are in HAL call test cycle we don't know what
 333         // return code to actually expect, so we just ignore it.
 334         stopOffload(ExpectBoolean::Ignored);
 335     }
 336 };
 337
 338 /*
 339  * Tests for IOffloadControl::setLocalPrefixes().
 340  */
 341
 342 // Test setLocalPrefixes() accepts an IPv4 address.
 343 TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv4AddressOk) {
 344     const vector<hidl_string> prefixes{hidl_string("192.0.2.1")};
 345     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
 346     EXPECT_TRUE(ret.isOk());
 347 }
 348
 349 // Test setLocalPrefixes() accepts an IPv6 address.
 350 TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv6AddressOk) {
 351     const vector<hidl_string> prefixes{hidl_string("fe80::1")};
 352     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
 353     EXPECT_TRUE(ret.isOk());
 354 }
 355
 356 // Test setLocalPrefixes() accepts both IPv4 and IPv6 prefixes.
 357 TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv4v6PrefixesOk) {
 358     const vector<hidl_string> prefixes{hidl_string("192.0.2.0/24"), hidl_string("fe80::/64")};
 359     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
 360     EXPECT_TRUE(ret.isOk());
 361 }
 362
 363 // Test that setLocalPrefixes() fails given empty input. There is always
 364 // a non-empty set of local prefixes; when all networking interfaces are down
 365 // we still apply {127.0.0.0/8, ::1/128, fe80::/64} here.
 366 TEST_F(OffloadControlHidlTest, SetLocalPrefixesEmptyFails) {
 367     const vector<hidl_string> prefixes{};
 368     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
 369     EXPECT_TRUE(ret.isOk());
 370 }
 371
 372 // Test setLocalPrefixes() fails on incorrectly formed input strings.
 373 TEST_F(OffloadControlHidlTest, SetLocalPrefixesInvalidFails) {
 374     const vector<hidl_string> prefixes{hidl_string("192.0.2.0/24"), hidl_string("invalid")};
 375     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
 376     EXPECT_TRUE(ret.isOk());
 377 }
 378
 379 /*
 380  * Tests for IOffloadControl::getForwardedStats().
 381  */
 382
 383 // Test that getForwardedStats() for a non-existent upstream yields zero bytes statistics.
 384 TEST_F(OffloadControlHidlTest, GetForwardedStatsInvalidUpstreamIface) {
 385     const hidl_string upstream("invalid");
 386     const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
 387     EXPECT_TRUE(ret.isOk());
 388 }
 389
 390 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
 391 // are ever actually caused to be forwarded.
 392 TEST_F(OffloadControlHidlTest, GetForwardedStatsDummyIface) {
 393     const hidl_string upstream("rmnet_data0");
 394     const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
 395     EXPECT_TRUE(ret.isOk());
 396 }
 397
 398 /*
 399  * Tests for IOffloadControl::setDataLimit().
 400  */
 401
 402 // Test that setDataLimit() for an empty interface name fails.
 403 TEST_F(OffloadControlHidlTest, SetDataLimitEmptyUpstreamIfaceFails) {
 404     const hidl_string upstream("");
 405     const uint64_t limit = 5000ULL;
 406     const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_FALSE_CALLBACK);
 407     EXPECT_TRUE(ret.isOk());
 408 }
 409
 410 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
 411 // are ever actually caused to be forwarded.
 412 TEST_F(OffloadControlHidlTest, SetDataLimitNonZeroOk) {
 413     const hidl_string upstream("rmnet_data0");
 414     const uint64_t limit = 5000ULL;
 415     const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_TRUE_CALLBACK);
 416     EXPECT_TRUE(ret.isOk());
 417 }
 418
 419 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
 420 // are ever actually caused to be forwarded.
 421 TEST_F(OffloadControlHidlTest, SetDataLimitZeroOk) {
 422     const hidl_string upstream("rmnet_data0");
 423     const uint64_t limit = 0ULL;
 424     const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_TRUE_CALLBACK);
 425     EXPECT_TRUE(ret.isOk());
 426 }
 427
 428 /*
 429  * Tests for IOffloadControl::setUpstreamParameters().
 430  */
 431
 432 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
 433 // are ever actually caused to be forwarded.
 434 TEST_F(OffloadControlHidlTest, SetUpstreamParametersIPv6OnlyOk) {
 435     const hidl_string iface("rmnet_data0");
 436     const hidl_string v4Addr("");
 437     const hidl_string v4Gw("");
 438     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1"), hidl_string("fe80::db8:2")};
 439     const Return<void> ret =
 440         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
 441     EXPECT_TRUE(ret.isOk());
 442 }
 443
 444 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
 445 // are ever actually caused to be forwarded.
 446 TEST_F(OffloadControlHidlTest, SetUpstreamParametersAlternateIPv6OnlyOk) {
 447     const hidl_string iface("rmnet_data0");
 448     const hidl_string v4Addr;
 449     const hidl_string v4Gw;
 450     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1"), hidl_string("fe80::db8:3")};
 451     const Return<void> ret =
 452         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
 453     EXPECT_TRUE(ret.isOk());
 454 }
 455
 456 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
 457 // are ever actually caused to be forwarded.
 458 TEST_F(OffloadControlHidlTest, SetUpstreamParametersIPv4OnlyOk) {
 459     const hidl_string iface("rmnet_data0");
 460     const hidl_string v4Addr("192.0.2.2");
 461     const hidl_string v4Gw("192.0.2.1");
 462     const vector<hidl_string> v6Gws{};
 463     const Return<void> ret =
 464         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
 465     EXPECT_TRUE(ret.isOk());
 466 }
 467
 468 // The "rmnet_data0" is presumed to exist on the device and be up. No packets
 469 // are ever actually caused to be forwarded.
 470 TEST_F(OffloadControlHidlTest, SetUpstreamParametersIPv4v6Ok) {
 471     const hidl_string iface("rmnet_data0");
 472     const hidl_string v4Addr("192.0.2.2");
 473     const hidl_string v4Gw("192.0.2.1");
 474     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1"), hidl_string("fe80::db8:2")};
 475     const Return<void> ret =
 476         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
 477     EXPECT_TRUE(ret.isOk());
 478 }
 479
 480 // Test that setUpstreamParameters() fails when all parameters are empty.
 481 TEST_F(OffloadControlHidlTest, SetUpstreamParametersEmptyFails) {
 482     const hidl_string iface("");
 483     const hidl_string v4Addr("");
 484     const hidl_string v4Gw("");
 485     const vector<hidl_string> v6Gws{};
 486     const Return<void> ret =
 487         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 488     EXPECT_TRUE(ret.isOk());
 489 }
 490
 491 // Test that setUpstreamParameters() fails when given empty or non-existent interface names.
 492 TEST_F(OffloadControlHidlTest, SetUpstreamParametersBogusIfaceFails) {
 493     const hidl_string v4Addr("192.0.2.2");
 494     const hidl_string v4Gw("192.0.2.1");
 495     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
 496     for (const auto& bogus : {"", "invalid"}) {
 497         SCOPED_TRACE(StringPrintf("iface='%s'", bogus));
 498         const hidl_string iface(bogus);
 499         const Return<void> ret =
 500             control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 501         EXPECT_TRUE(ret.isOk());
 502     }
 503 }
 504
 505 // Test that setUpstreamParameters() fails when given unparseable IPv4 addresses.
 506 TEST_F(OffloadControlHidlTest, SetUpstreamParametersInvalidIPv4AddrFails) {
 507     const hidl_string iface("rmnet_data0");
 508     const hidl_string v4Gw("192.0.2.1");
 509     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
 510     for (const auto& bogus : {"invalid", "192.0.2"}) {
 511         SCOPED_TRACE(StringPrintf("v4addr='%s'", bogus));
 512         const hidl_string v4Addr(bogus);
 513         const Return<void> ret =
 514             control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 515         EXPECT_TRUE(ret.isOk());
 516     }
 517 }
 518
 519 // Test that setUpstreamParameters() fails when given unparseable IPv4 gateways.
 520 TEST_F(OffloadControlHidlTest, SetUpstreamParametersInvalidIPv4GatewayFails) {
 521     const hidl_string iface("rmnet_data0");
 522     const hidl_string v4Addr("192.0.2.2");
 523     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
 524     for (const auto& bogus : {"invalid", "192.0.2"}) {
 525         SCOPED_TRACE(StringPrintf("v4gateway='%s'", bogus));
 526         const hidl_string v4Gw(bogus);
 527         const Return<void> ret =
 528             control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 529         EXPECT_TRUE(ret.isOk());
 530     }
 531 }
 532
 533 // Test that setUpstreamParameters() fails when given unparseable IPv6 gateways.
 534 TEST_F(OffloadControlHidlTest, SetUpstreamParametersBadIPv6GatewaysFail) {
 535     const hidl_string iface("rmnet_data0");
 536     const hidl_string v4Addr("192.0.2.2");
 537     const hidl_string v4Gw("192.0.2.1");
 538     for (const auto& bogus : {"", "invalid", "fe80::bogus", "192.0.2.66"}) {
 539         SCOPED_TRACE(StringPrintf("v6gateway='%s'", bogus));
 540         const vector<hidl_string> v6Gws{hidl_string("fe80::1"), hidl_string(bogus)};
 541         const Return<void> ret =
 542             control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 543         EXPECT_TRUE(ret.isOk());
 544     }
 545 }
 546
 547 /*
 548  * Tests for IOffloadControl::addDownstream().
 549  */
 550
 551 // Test addDownstream() works given an IPv4 prefix.
 552 TEST_F(OffloadControlHidlTest, AddDownstreamIPv4) {
 553     const hidl_string iface("dummy0");
 554     const hidl_string prefix("192.0.2.0/24");
 555     const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 556     EXPECT_TRUE(ret.isOk());
 557 }
 558
 559 // Test addDownstream() works given an IPv6 prefix.
 560 TEST_F(OffloadControlHidlTest, AddDownstreamIPv6) {
 561     const hidl_string iface("dummy0");
 562     const hidl_string prefix("2001:db8::/64");
 563     const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 564     EXPECT_TRUE(ret.isOk());
 565 }
 566
 567 // Test addDownstream() fails given all empty parameters.
 568 TEST_F(OffloadControlHidlTest, AddDownstreamEmptyFails) {
 569     const hidl_string iface("");
 570     const hidl_string prefix("");
 571     const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 572     EXPECT_TRUE(ret.isOk());
 573 }
 574
 575 // Test addDownstream() fails given empty or non-existent interface names.
 576 TEST_F(OffloadControlHidlTest, AddDownstreamInvalidIfaceFails) {
 577     const hidl_string prefix("192.0.2.0/24");
 578     for (const auto& bogus : {"", "invalid"}) {
 579         SCOPED_TRACE(StringPrintf("iface='%s'", bogus));
 580         const hidl_string iface(bogus);
 581         const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 582         EXPECT_TRUE(ret.isOk());
 583     }
 584 }
 585
 586 // Test addDownstream() fails given unparseable prefix arguments.
 587 TEST_F(OffloadControlHidlTest, AddDownstreamBogusPrefixFails) {
 588     const hidl_string iface("dummy0");
 589     for (const auto& bogus : {"", "192.0.2/24", "2001:db8/64"}) {
 590         SCOPED_TRACE(StringPrintf("prefix='%s'", bogus));
 591         const hidl_string prefix(bogus);
 592         const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 593         EXPECT_TRUE(ret.isOk());
 594     }
 595 }
 596
 597 /*
 598  * Tests for IOffloadControl::removeDownstream().
 599  */
 600
 601 // Test removeDownstream() works given an IPv4 prefix.
 602 TEST_F(OffloadControlHidlTest, RemoveDownstreamIPv4) {
 603     const hidl_string iface("dummy0");
 604     const hidl_string prefix("192.0.2.0/24");
 605     // First add the downstream, otherwise removeDownstream logic can reasonably
 606     // return false for downstreams not previously added.
 607     const Return<void> add = control->addDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 608     EXPECT_TRUE(add.isOk());
 609     const Return<void> del = control->removeDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 610     EXPECT_TRUE(del.isOk());
 611 }
 612
 613 // Test removeDownstream() works given an IPv6 prefix.
 614 TEST_F(OffloadControlHidlTest, RemoveDownstreamIPv6) {
 615     const hidl_string iface("dummy0");
 616     const hidl_string prefix("2001:db8::/64");
 617     // First add the downstream, otherwise removeDownstream logic can reasonably
 618     // return false for downstreams not previously added.
 619     const Return<void> add = control->addDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 620     EXPECT_TRUE(add.isOk());
 621     const Return<void> del = control->removeDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 622     EXPECT_TRUE(del.isOk());
 623 }
 624
 625 // Test removeDownstream() fails given all empty parameters.
 626 TEST_F(OffloadControlHidlTest, RemoveDownstreamEmptyFails) {
 627     const hidl_string iface("");
 628     const hidl_string prefix("");
 629     const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 630     EXPECT_TRUE(ret.isOk());
 631 }
 632
 633 // Test removeDownstream() fails given empty or non-existent interface names.
 634 TEST_F(OffloadControlHidlTest, RemoveDownstreamBogusIfaceFails) {
 635     const hidl_string prefix("192.0.2.0/24");
 636     for (const auto& bogus : {"", "invalid"}) {
 637         SCOPED_TRACE(StringPrintf("iface='%s'", bogus));
 638         const hidl_string iface(bogus);
 639         const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 640         EXPECT_TRUE(ret.isOk());
 641     }
 642 }
 643
 644 // Test removeDownstream() fails given unparseable prefix arguments.
 645 TEST_F(OffloadControlHidlTest, RemoveDownstreamBogusPrefixFails) {
 646     const hidl_string iface("dummy0");
 647     for (const auto& bogus : {"", "192.0.2/24", "2001:db8/64"}) {
 648         SCOPED_TRACE(StringPrintf("prefix='%s'", bogus));
 649         const hidl_string prefix(bogus);
 650         const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 651         EXPECT_TRUE(ret.isOk());
 652     }
 653 }
 654
 655 int main(int argc, char** argv) {
 656     testing::InitGoogleTest(&argc, argv);
 657     int status = RUN_ALL_TESTS();
 658     ALOGE("Test result with status=%d", status);
 659     return status;
 660 }