Home | History | Annotate | Download | only in server 
      1 /*
      2  * Copyright 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  * TrafficControllerTest.cpp - unit tests for TrafficController.cpp
     17  */
     18 
     19 #include <string>
     20 #include <vector>
     21 
     22 #include <fcntl.h>
     23 #include <inttypes.h>
     24 #include <linux/inet_diag.h>
     25 #include <linux/sock_diag.h>
     26 #include <sys/socket.h>
     27 #include <sys/types.h>
     28 #include <unistd.h>
     29 
     30 #include <gtest/gtest.h>
     31 
     32 #include <android-base/stringprintf.h>
     33 #include <android-base/strings.h>
     34 
     35 #include <netdutils/MockSyscalls.h>
     36 #include "netdutils/Status.h"
     37 #include "netdutils/StatusOr.h"
     38 
     39 #include "FirewallController.h"
     40 #include "TrafficController.h"
     41 #include "bpf/BpfUtils.h"
     42 
     43 using namespace android::bpf;
     44 
     45 using ::testing::_;
     46 using ::testing::ByMove;
     47 using ::testing::Invoke;
     48 using ::testing::Return;
     49 using ::testing::StrictMock;
     50 using ::testing::Test;
     51 
     52 namespace android {
     53 namespace net {
     54 
     55 using base::unique_fd;
     56 using netdutils::isOk;
     57 using netdutils::Status;
     58 using netdutils::status::ok;
     59 using netdutils::StatusOr;
     60 
     61 constexpr int TEST_MAP_SIZE = 10;
     62 constexpr uid_t TEST_UID = 10086;
     63 constexpr uid_t TEST_UID2 = 54321;
     64 constexpr uid_t TEST_UID3 = 98765;
     65 constexpr uint32_t TEST_TAG = 42;
     66 constexpr uint32_t TEST_COUNTERSET = 1;
     67 constexpr uint32_t DEFAULT_COUNTERSET = 0;
     68 
     69 class TrafficControllerTest : public ::testing::Test {
     70   protected:
     71     TrafficControllerTest() {}
     72     TrafficController mTc;
     73     BpfMap<uint64_t, UidTag> mFakeCookieTagMap;
     74     BpfMap<uint32_t, uint8_t> mFakeUidCounterSetMap;
     75     BpfMap<uint32_t, StatsValue> mFakeAppUidStatsMap;
     76     BpfMap<StatsKey, StatsValue> mFakeUidStatsMap;
     77     BpfMap<StatsKey, StatsValue> mFakeTagStatsMap;
     78     BpfMap<uint32_t, uint8_t> mFakeDozableUidMap;
     79     BpfMap<uint32_t, uint8_t> mFakeStandbyUidMap;
     80     BpfMap<uint32_t, uint8_t> mFakePowerSaveUidMap;
     81 
     82     void SetUp() {
     83         std::lock_guard<std::mutex> ownerGuard(mTc.mOwnerMatchMutex);
     84         SKIP_IF_BPF_NOT_SUPPORTED;
     85 
     86         mFakeCookieTagMap.reset(createMap(BPF_MAP_TYPE_HASH, sizeof(uint64_t),
     87                                           sizeof(struct UidTag), TEST_MAP_SIZE, 0));
     88         ASSERT_LE(0, mFakeCookieTagMap.getMap());
     89 
     90         mFakeUidCounterSetMap.reset(
     91             createMap(BPF_MAP_TYPE_HASH, sizeof(uint32_t), sizeof(uint8_t), TEST_MAP_SIZE, 0));
     92         ASSERT_LE(0, mFakeUidCounterSetMap.getMap());
     93 
     94         mFakeAppUidStatsMap.reset(createMap(BPF_MAP_TYPE_HASH, sizeof(uint32_t),
     95                                             sizeof(struct StatsValue), TEST_MAP_SIZE, 0));
     96         ASSERT_LE(0, mFakeAppUidStatsMap.getMap());
     97 
     98         mFakeUidStatsMap.reset(createMap(BPF_MAP_TYPE_HASH, sizeof(struct StatsKey),
     99                                          sizeof(struct StatsValue), TEST_MAP_SIZE, 0));
    100         ASSERT_LE(0, mFakeUidStatsMap.getMap());
    101 
    102         mFakeTagStatsMap.reset(createMap(BPF_MAP_TYPE_HASH, sizeof(struct StatsKey),
    103                                          sizeof(struct StatsValue), TEST_MAP_SIZE, 0));
    104         ASSERT_LE(0, mFakeTagStatsMap.getMap());
    105 
    106         mFakeDozableUidMap.reset(
    107             createMap(BPF_MAP_TYPE_HASH, sizeof(uint32_t), sizeof(uint8_t), TEST_MAP_SIZE, 0));
    108         ASSERT_LE(0, mFakeDozableUidMap.getMap());
    109 
    110         mFakeStandbyUidMap.reset(
    111             createMap(BPF_MAP_TYPE_HASH, sizeof(uint32_t), sizeof(uint8_t), TEST_MAP_SIZE, 0));
    112         ASSERT_LE(0, mFakeStandbyUidMap.getMap());
    113 
    114         mFakePowerSaveUidMap.reset(
    115             createMap(BPF_MAP_TYPE_HASH, sizeof(uint32_t), sizeof(uint8_t), TEST_MAP_SIZE, 0));
    116         ASSERT_LE(0, mFakePowerSaveUidMap.getMap());
    117         // Make sure trafficController use the eBPF code path.
    118         mTc.ebpfSupported = true;
    119 
    120         mTc.mCookieTagMap.reset(mFakeCookieTagMap.getMap());
    121         mTc.mUidCounterSetMap.reset(mFakeUidCounterSetMap.getMap());
    122         mTc.mAppUidStatsMap.reset(mFakeAppUidStatsMap.getMap());
    123         mTc.mUidStatsMap.reset(mFakeUidStatsMap.getMap());
    124         mTc.mTagStatsMap.reset(mFakeTagStatsMap.getMap());
    125         mTc.mDozableUidMap.reset(mFakeDozableUidMap.getMap());
    126         mTc.mStandbyUidMap.reset(mFakeStandbyUidMap.getMap());
    127         mTc.mPowerSaveUidMap.reset(mFakePowerSaveUidMap.getMap());
    128     }
    129 
    130     int setUpSocketAndTag(int protocol, uint64_t* cookie, uint32_t tag, uid_t uid) {
    131         int sock = socket(protocol, SOCK_STREAM, 0);
    132         EXPECT_LE(0, sock);
    133         *cookie = getSocketCookie(sock);
    134         EXPECT_NE(NONEXISTENT_COOKIE, *cookie);
    135         EXPECT_EQ(0, mTc.tagSocket(sock, tag, uid));
    136         return sock;
    137     }
    138 
    139     void expectUidTag(uint64_t cookie, uid_t uid, uint32_t tag) {
    140         StatusOr<UidTag> tagResult = mFakeCookieTagMap.readValue(cookie);
    141         EXPECT_TRUE(isOk(tagResult));
    142         EXPECT_EQ(uid, tagResult.value().uid);
    143         EXPECT_EQ(tag, tagResult.value().tag);
    144     }
    145 
    146     void expectNoTag(uint64_t cookie) { EXPECT_FALSE(isOk(mFakeCookieTagMap.readValue(cookie))); }
    147 
    148     void expectTagMapEmpty() { EXPECT_FALSE(isOk(mFakeCookieTagMap.getFirstKey())); }
    149 
    150     void populateFakeStats(uint64_t cookie, uint32_t uid, uint32_t tag, StatsKey* key) {
    151         UidTag cookieMapkey = {.uid = (uint32_t)uid, .tag = tag};
    152         EXPECT_TRUE(isOk(mFakeCookieTagMap.writeValue(cookie, cookieMapkey, BPF_ANY)));
    153         *key = {.uid = uid, .tag = tag, .counterSet = TEST_COUNTERSET, .ifaceIndex = 1};
    154         StatsValue statsMapValue = {.rxPackets = 1, .rxBytes = 100};
    155         uint8_t counterSet = TEST_COUNTERSET;
    156         EXPECT_TRUE(isOk(mFakeUidCounterSetMap.writeValue(uid, counterSet, BPF_ANY)));
    157         EXPECT_TRUE(isOk(mFakeTagStatsMap.writeValue(*key, statsMapValue, BPF_ANY)));
    158         key->tag = 0;
    159         EXPECT_TRUE(isOk(mFakeUidStatsMap.writeValue(*key, statsMapValue, BPF_ANY)));
    160         EXPECT_TRUE(isOk(mFakeAppUidStatsMap.writeValue(uid, statsMapValue, BPF_ANY)));
    161         // put tag information back to statsKey
    162         key->tag = tag;
    163     }
    164 
    165     void checkUidOwnerRuleForChain(ChildChain chain, BpfMap<uint32_t, uint8_t>& targetMap) {
    166         uint32_t uid = TEST_UID;
    167         EXPECT_EQ(0, mTc.changeUidOwnerRule(chain, uid, DENY, BLACKLIST));
    168         StatusOr<uint8_t> value = targetMap.readValue(uid);
    169         EXPECT_TRUE(isOk(value));
    170         EXPECT_EQ(BPF_DROP, value.value());
    171 
    172         uid = TEST_UID2;
    173         EXPECT_EQ(0, mTc.changeUidOwnerRule(chain, uid, ALLOW, WHITELIST));
    174         value = targetMap.readValue(uid);
    175         EXPECT_TRUE(isOk(value));
    176         EXPECT_EQ(BPF_PASS, value.value());
    177 
    178         EXPECT_EQ(0, mTc.changeUidOwnerRule(chain, uid, DENY, WHITELIST));
    179         value = targetMap.readValue(uid);
    180         EXPECT_FALSE(isOk(value));
    181         EXPECT_EQ(ENOENT, value.status().code());
    182 
    183         uid = TEST_UID;
    184         EXPECT_EQ(0, mTc.changeUidOwnerRule(chain, uid, ALLOW, BLACKLIST));
    185         value = targetMap.readValue(uid);
    186         EXPECT_FALSE(isOk(value));
    187         EXPECT_EQ(ENOENT, value.status().code());
    188 
    189         uid = TEST_UID3;
    190         EXPECT_EQ(-ENOENT, mTc.changeUidOwnerRule(chain, uid, ALLOW, BLACKLIST));
    191         value = targetMap.readValue(uid);
    192         EXPECT_FALSE(isOk(value));
    193         EXPECT_EQ(ENOENT, value.status().code());
    194     }
    195 
    196     void checkEachUidValue(const std::vector<int32_t>& uids, const uint8_t expectValue,
    197                            BpfMap<uint32_t, uint8_t>& targetMap) {
    198         for (uint32_t uid : uids) {
    199             StatusOr<uint8_t> value = targetMap.readValue(uid);
    200             EXPECT_TRUE(isOk(value));
    201             EXPECT_EQ(expectValue, value.value());
    202         }
    203         std::set<uint32_t> uidSet(uids.begin(), uids.end());
    204         const auto checkNoOtherUid = [&uidSet](const int32_t& key,
    205                                                const BpfMap<uint32_t, uint8_t>&) {
    206             EXPECT_NE(uidSet.end(), uidSet.find(key));
    207             return netdutils::status::ok;
    208         };
    209         EXPECT_TRUE(isOk(targetMap.iterate(checkNoOtherUid)));
    210     }
    211 
    212     void checkUidMapReplace(const std::string& name, const std::vector<int32_t>& uids,
    213                             BpfMap<uint32_t, uint8_t>& targetMap) {
    214         bool isWhitelist = true;
    215         EXPECT_EQ(0, mTc.replaceUidOwnerMap(name, isWhitelist, uids));
    216         checkEachUidValue(uids, BPF_PASS, targetMap);
    217 
    218         isWhitelist = false;
    219         EXPECT_EQ(0, mTc.replaceUidOwnerMap(name, isWhitelist, uids));
    220         checkEachUidValue(uids, BPF_DROP, targetMap);
    221     }
    222 
    223     void TearDown() {
    224         std::lock_guard<std::mutex> ownerGuard(mTc.mOwnerMatchMutex);
    225         mFakeCookieTagMap.reset();
    226         mFakeUidCounterSetMap.reset();
    227         mFakeAppUidStatsMap.reset();
    228         mFakeUidStatsMap.reset();
    229         mFakeTagStatsMap.reset();
    230         mTc.mDozableUidMap.reset();
    231         mTc.mStandbyUidMap.reset();
    232         mTc.mPowerSaveUidMap.reset();
    233     }
    234 };
    235 
    236 TEST_F(TrafficControllerTest, TestTagSocketV4) {
    237     SKIP_IF_BPF_NOT_SUPPORTED;
    238 
    239     uint64_t sockCookie;
    240     int v4socket = setUpSocketAndTag(AF_INET, &sockCookie, TEST_TAG, TEST_UID);
    241     expectUidTag(sockCookie, TEST_UID, TEST_TAG);
    242     ASSERT_EQ(0, mTc.untagSocket(v4socket));
    243     expectNoTag(sockCookie);
    244     expectTagMapEmpty();
    245 }
    246 
    247 TEST_F(TrafficControllerTest, TestReTagSocket) {
    248     SKIP_IF_BPF_NOT_SUPPORTED;
    249 
    250     uint64_t sockCookie;
    251     int v4socket = setUpSocketAndTag(AF_INET, &sockCookie, TEST_TAG, TEST_UID);
    252     expectUidTag(sockCookie, TEST_UID, TEST_TAG);
    253     ASSERT_EQ(0, mTc.tagSocket(v4socket, TEST_TAG + 1, TEST_UID + 1));
    254     expectUidTag(sockCookie, TEST_UID + 1, TEST_TAG + 1);
    255 }
    256 
    257 TEST_F(TrafficControllerTest, TestTagTwoSockets) {
    258     SKIP_IF_BPF_NOT_SUPPORTED;
    259 
    260     uint64_t sockCookie1;
    261     uint64_t sockCookie2;
    262     int v4socket1 = setUpSocketAndTag(AF_INET, &sockCookie1, TEST_TAG, TEST_UID);
    263     setUpSocketAndTag(AF_INET, &sockCookie2, TEST_TAG, TEST_UID);
    264     expectUidTag(sockCookie1, TEST_UID, TEST_TAG);
    265     expectUidTag(sockCookie2, TEST_UID, TEST_TAG);
    266     ASSERT_EQ(0, mTc.untagSocket(v4socket1));
    267     expectNoTag(sockCookie1);
    268     expectUidTag(sockCookie2, TEST_UID, TEST_TAG);
    269     ASSERT_FALSE(isOk(mFakeCookieTagMap.getNextKey(sockCookie2)));
    270 }
    271 
    272 TEST_F(TrafficControllerTest, TestTagSocketV6) {
    273     SKIP_IF_BPF_NOT_SUPPORTED;
    274 
    275     uint64_t sockCookie;
    276     int v6socket = setUpSocketAndTag(AF_INET6, &sockCookie, TEST_TAG, TEST_UID);
    277     expectUidTag(sockCookie, TEST_UID, TEST_TAG);
    278     ASSERT_EQ(0, mTc.untagSocket(v6socket));
    279     expectNoTag(sockCookie);
    280     expectTagMapEmpty();
    281 }
    282 
    283 TEST_F(TrafficControllerTest, TestTagInvalidSocket) {
    284     SKIP_IF_BPF_NOT_SUPPORTED;
    285 
    286     int invalidSocket = -1;
    287     ASSERT_GT(0, mTc.tagSocket(invalidSocket, TEST_TAG, TEST_UID));
    288     expectTagMapEmpty();
    289 }
    290 
    291 TEST_F(TrafficControllerTest, TestUntagInvalidSocket) {
    292     SKIP_IF_BPF_NOT_SUPPORTED;
    293 
    294     int invalidSocket = -1;
    295     ASSERT_GT(0, mTc.untagSocket(invalidSocket));
    296     int v4socket = socket(AF_INET, SOCK_STREAM, 0);
    297     ASSERT_GT(0, mTc.untagSocket(v4socket));
    298     expectTagMapEmpty();
    299 }
    300 
    301 TEST_F(TrafficControllerTest, TestSetCounterSet) {
    302     SKIP_IF_BPF_NOT_SUPPORTED;
    303 
    304     ASSERT_EQ(0, mTc.setCounterSet(TEST_COUNTERSET, TEST_UID));
    305     uid_t uid = TEST_UID;
    306     StatusOr<uint8_t> counterSetResult = mFakeUidCounterSetMap.readValue(uid);
    307     ASSERT_TRUE(isOk(counterSetResult));
    308     ASSERT_EQ(TEST_COUNTERSET, counterSetResult.value());
    309     ASSERT_EQ(0, mTc.setCounterSet(DEFAULT_COUNTERSET, TEST_UID));
    310     ASSERT_FALSE(isOk(mFakeUidCounterSetMap.readValue(uid)));
    311     ASSERT_FALSE(isOk(mFakeUidCounterSetMap.getFirstKey()));
    312 }
    313 
    314 TEST_F(TrafficControllerTest, TestSetInvalidCounterSet) {
    315     SKIP_IF_BPF_NOT_SUPPORTED;
    316 
    317     ASSERT_GT(0, mTc.setCounterSet(OVERFLOW_COUNTERSET, TEST_UID));
    318     uid_t uid = TEST_UID;
    319     ASSERT_FALSE(isOk(mFakeUidCounterSetMap.readValue(uid)));
    320     ASSERT_FALSE(isOk(mFakeUidCounterSetMap.getFirstKey()));
    321 }
    322 
    323 TEST_F(TrafficControllerTest, TestDeleteTagData) {
    324     SKIP_IF_BPF_NOT_SUPPORTED;
    325 
    326     uint64_t cookie = 1;
    327     uid_t uid = TEST_UID;
    328     uint32_t tag = TEST_TAG;
    329     StatsKey tagStatsMapKey;
    330     populateFakeStats(cookie, uid, tag, &tagStatsMapKey);
    331     ASSERT_EQ(0, mTc.deleteTagData(TEST_TAG, TEST_UID));
    332     ASSERT_FALSE(isOk(mFakeCookieTagMap.readValue(cookie)));
    333     StatusOr<uint8_t> counterSetResult = mFakeUidCounterSetMap.readValue(uid);
    334     ASSERT_TRUE(isOk(counterSetResult));
    335     ASSERT_EQ(TEST_COUNTERSET, counterSetResult.value());
    336     ASSERT_FALSE(isOk(mFakeTagStatsMap.readValue(tagStatsMapKey)));
    337     tagStatsMapKey.tag = 0;
    338     StatusOr<StatsValue> statsMapResult = mFakeUidStatsMap.readValue(tagStatsMapKey);
    339     ASSERT_TRUE(isOk(statsMapResult));
    340     ASSERT_EQ((uint64_t)1, statsMapResult.value().rxPackets);
    341     ASSERT_EQ((uint64_t)100, statsMapResult.value().rxBytes);
    342     auto appStatsResult = mFakeAppUidStatsMap.readValue(TEST_UID);
    343     ASSERT_TRUE(isOk(appStatsResult));
    344     ASSERT_EQ((uint64_t)1, appStatsResult.value().rxPackets);
    345     ASSERT_EQ((uint64_t)100, appStatsResult.value().rxBytes);
    346 }
    347 
    348 TEST_F(TrafficControllerTest, TestDeleteAllUidData) {
    349     SKIP_IF_BPF_NOT_SUPPORTED;
    350 
    351     uint64_t cookie = 1;
    352     uid_t uid = TEST_UID;
    353     uint32_t tag = TEST_TAG;
    354     StatsKey tagStatsMapKey;
    355     populateFakeStats(cookie, uid, tag, &tagStatsMapKey);
    356     ASSERT_EQ(0, mTc.deleteTagData(0, TEST_UID));
    357     ASSERT_FALSE(isOk(mFakeCookieTagMap.readValue(cookie)));
    358     ASSERT_FALSE(isOk(mFakeUidCounterSetMap.readValue(uid)));
    359     ASSERT_FALSE(isOk(mFakeTagStatsMap.readValue(tagStatsMapKey)));
    360     tagStatsMapKey.tag = 0;
    361     ASSERT_FALSE(isOk(mFakeUidStatsMap.readValue(tagStatsMapKey)));
    362     ASSERT_FALSE(isOk(mFakeAppUidStatsMap.readValue(TEST_UID)));
    363 }
    364 
    365 TEST_F(TrafficControllerTest, TestDeleteDataWithTwoTags) {
    366     SKIP_IF_BPF_NOT_SUPPORTED;
    367 
    368     uint64_t cookie1 = 1;
    369     uint64_t cookie2 = 2;
    370     uid_t uid = TEST_UID;
    371     uint32_t tag1 = TEST_TAG;
    372     uint32_t tag2 = TEST_TAG + 1;
    373     StatsKey tagStatsMapKey1;
    374     StatsKey tagStatsMapKey2;
    375     populateFakeStats(cookie1, uid, tag1, &tagStatsMapKey1);
    376     populateFakeStats(cookie2, uid, tag2, &tagStatsMapKey2);
    377     ASSERT_EQ(0, mTc.deleteTagData(TEST_TAG, TEST_UID));
    378     ASSERT_FALSE(isOk(mFakeCookieTagMap.readValue(cookie1)));
    379     StatusOr<UidTag> cookieMapResult = mFakeCookieTagMap.readValue(cookie2);
    380     ASSERT_TRUE(isOk(cookieMapResult));
    381     ASSERT_EQ(TEST_UID, cookieMapResult.value().uid);
    382     ASSERT_EQ(TEST_TAG + 1, cookieMapResult.value().tag);
    383     StatusOr<uint8_t> counterSetResult = mFakeUidCounterSetMap.readValue(uid);
    384     ASSERT_TRUE(isOk(counterSetResult));
    385     ASSERT_EQ(TEST_COUNTERSET, counterSetResult.value());
    386     ASSERT_FALSE(isOk(mFakeTagStatsMap.readValue(tagStatsMapKey1)));
    387     StatusOr<StatsValue> statsMapResult = mFakeTagStatsMap.readValue(tagStatsMapKey2);
    388     ASSERT_TRUE(isOk(statsMapResult));
    389     ASSERT_EQ((uint64_t)1, statsMapResult.value().rxPackets);
    390     ASSERT_EQ((uint64_t)100, statsMapResult.value().rxBytes);
    391 }
    392 
    393 TEST_F(TrafficControllerTest, TestDeleteDataWithTwoUids) {
    394     SKIP_IF_BPF_NOT_SUPPORTED;
    395 
    396     uint64_t cookie1 = 1;
    397     uint64_t cookie2 = 2;
    398     uid_t uid1 = TEST_UID;
    399     uid_t uid2 = TEST_UID + 1;
    400     uint32_t tag = TEST_TAG;
    401     StatsKey tagStatsMapKey1;
    402     StatsKey tagStatsMapKey2;
    403     populateFakeStats(cookie1, uid1, tag, &tagStatsMapKey1);
    404     populateFakeStats(cookie2, uid2, tag, &tagStatsMapKey2);
    405 
    406     // Delete the stats of one of the uid. Check if it is properly collected by
    407     // removedStats.
    408     ASSERT_EQ(0, mTc.deleteTagData(0, uid2));
    409     ASSERT_FALSE(isOk(mFakeCookieTagMap.readValue(cookie2)));
    410     StatusOr<uint8_t> counterSetResult = mFakeUidCounterSetMap.readValue(uid1);
    411     ASSERT_TRUE(isOk(counterSetResult));
    412     ASSERT_EQ(TEST_COUNTERSET, counterSetResult.value());
    413     ASSERT_FALSE(isOk(mFakeUidCounterSetMap.readValue(uid2)));
    414     ASSERT_FALSE(isOk(mFakeTagStatsMap.readValue(tagStatsMapKey2)));
    415     tagStatsMapKey2.tag = 0;
    416     ASSERT_FALSE(isOk(mFakeUidStatsMap.readValue(tagStatsMapKey2)));
    417     ASSERT_FALSE(isOk(mFakeAppUidStatsMap.readValue(uid2)));
    418     tagStatsMapKey1.tag = 0;
    419     StatusOr<StatsValue> statsMapResult = mFakeUidStatsMap.readValue(tagStatsMapKey1);
    420     ASSERT_TRUE(isOk(statsMapResult));
    421     ASSERT_EQ((uint64_t)1, statsMapResult.value().rxPackets);
    422     ASSERT_EQ((uint64_t)100, statsMapResult.value().rxBytes);
    423     auto appStatsResult = mFakeAppUidStatsMap.readValue(uid1);
    424     ASSERT_TRUE(isOk(appStatsResult));
    425     ASSERT_EQ((uint64_t)1, appStatsResult.value().rxPackets);
    426     ASSERT_EQ((uint64_t)100, appStatsResult.value().rxBytes);
    427 
    428     // Delete the stats of the other uid.
    429     ASSERT_EQ(0, mTc.deleteTagData(0, uid1));
    430     ASSERT_FALSE(isOk(mFakeUidStatsMap.readValue(tagStatsMapKey1)));
    431     ASSERT_FALSE(isOk(mFakeAppUidStatsMap.readValue(uid1)));
    432 }
    433 
    434 TEST_F(TrafficControllerTest, TestUpdateOwnerMapEntry) {
    435     SKIP_IF_BPF_NOT_SUPPORTED;
    436 
    437     uint32_t uid = TEST_UID;
    438     ASSERT_TRUE(isOk(mTc.updateOwnerMapEntry(mFakeDozableUidMap, uid, DENY, BLACKLIST)));
    439     StatusOr<uint8_t> value = mFakeDozableUidMap.readValue(uid);
    440     ASSERT_TRUE(isOk(value));
    441     ASSERT_EQ(BPF_DROP, value.value());
    442 
    443     uid = TEST_UID2;
    444     ASSERT_TRUE(isOk(mTc.updateOwnerMapEntry(mFakeDozableUidMap, uid, ALLOW, WHITELIST)));
    445     value = mFakeDozableUidMap.readValue(uid);
    446     ASSERT_TRUE(isOk(value));
    447     ASSERT_EQ(BPF_PASS, value.value());
    448 
    449     ASSERT_TRUE(isOk(mTc.updateOwnerMapEntry(mFakeDozableUidMap, uid, DENY, WHITELIST)));
    450     ASSERT_FALSE(isOk(mFakeDozableUidMap.readValue(uid)));
    451 
    452     uid = TEST_UID;
    453     ASSERT_TRUE(isOk(mTc.updateOwnerMapEntry(mFakeDozableUidMap, uid, ALLOW, BLACKLIST)));
    454     ASSERT_FALSE(isOk(mFakeDozableUidMap.readValue(uid)));
    455 
    456     uid = TEST_UID3;
    457     ASSERT_FALSE(isOk(mTc.updateOwnerMapEntry(mFakeDozableUidMap, uid, ALLOW, BLACKLIST)));
    458     ASSERT_FALSE(isOk(mFakeDozableUidMap.readValue(uid)));
    459 }
    460 
    461 TEST_F(TrafficControllerTest, TestChangeUidOwnerRule) {
    462     SKIP_IF_BPF_NOT_SUPPORTED;
    463 
    464     checkUidOwnerRuleForChain(DOZABLE, mFakeDozableUidMap);
    465     checkUidOwnerRuleForChain(STANDBY, mFakeStandbyUidMap);
    466     checkUidOwnerRuleForChain(POWERSAVE, mFakePowerSaveUidMap);
    467     ASSERT_EQ(-EINVAL, mTc.changeUidOwnerRule(NONE, TEST_UID, ALLOW, WHITELIST));
    468     ASSERT_EQ(-EINVAL, mTc.changeUidOwnerRule(INVALID_CHAIN, TEST_UID, ALLOW, WHITELIST));
    469 }
    470 
    471 TEST_F(TrafficControllerTest, TestReplaceUidOwnerMap) {
    472     SKIP_IF_BPF_NOT_SUPPORTED;
    473 
    474     std::vector<int32_t> uids = {TEST_UID, TEST_UID2, TEST_UID3};
    475     checkUidMapReplace("fw_dozable", uids, mFakeDozableUidMap);
    476     checkUidMapReplace("fw_standby", uids, mFakeStandbyUidMap);
    477     checkUidMapReplace("fw_powersave", uids, mFakePowerSaveUidMap);
    478     ASSERT_EQ(-EINVAL, mTc.replaceUidOwnerMap("unknow", true, uids));
    479 }
    480 
    481 }  // namespace net
    482 }  // namespace android
    483