b635b3a2eb
- Remove unneeded dependency on atoms.proto
- Remove extractIntoVector function. Assert on actual output directly.
- Use a helper method for creating UidMap mock for all tests.
- Add AttributionChain variants of existing tests in puller_util_tests.
- Add tests in StatsLogProcessor_test to test mapIsolatedUidToHostUid()
in StatsLogProcessor.
Bug: 154285085
Test: bit statsd_test:*
Change-Id: I6d0822be9f0fbca23bd2f441dc63b97110567307
409 lines
17 KiB
C++
409 lines
17 KiB
C++
// Copyright (C) 2018 The Android Open Source Project
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "external/puller_util.h"
|
|
|
|
#include <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
#include <stdio.h>
|
|
|
|
#include <vector>
|
|
|
|
#include "../metrics/metrics_test_helper.h"
|
|
#include "FieldValue.h"
|
|
#include "annotations.h"
|
|
#include "stats_event.h"
|
|
#include "tests/statsd_test_util.h"
|
|
|
|
#ifdef __ANDROID__
|
|
|
|
namespace android {
|
|
namespace os {
|
|
namespace statsd {
|
|
|
|
using namespace testing;
|
|
using std::shared_ptr;
|
|
using std::vector;
|
|
/*
|
|
* Test merge isolated and host uid
|
|
*/
|
|
namespace {
|
|
const int uidAtomTagId = 100;
|
|
const vector<int> additiveFields = {3};
|
|
const int nonUidAtomTagId = 200;
|
|
const int timestamp = 1234;
|
|
const int isolatedUid1 = 30;
|
|
const int isolatedUid2 = 40;
|
|
const int isolatedNonAdditiveData = 32;
|
|
const int isolatedAdditiveData = 31;
|
|
const int hostUid = 20;
|
|
const int hostNonAdditiveData = 22;
|
|
const int hostAdditiveData = 21;
|
|
const int attributionAtomTagId = 300;
|
|
|
|
sp<MockUidMap> makeMockUidMap() {
|
|
return makeMockUidMapForOneHost(hostUid, {isolatedUid1, isolatedUid2});
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
TEST(PullerUtilTest, MergeNoDimension) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 30->22->31
|
|
makeUidLogEvent(uidAtomTagId, timestamp, isolatedUid1, hostNonAdditiveData,
|
|
isolatedAdditiveData),
|
|
|
|
// 20->22->21
|
|
makeUidLogEvent(uidAtomTagId, timestamp, hostUid, hostNonAdditiveData,
|
|
hostAdditiveData),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, uidAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(1, (int)data.size());
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(3, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(isolatedAdditiveData + hostAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
}
|
|
|
|
TEST(PullerUtilTest, MergeWithDimension) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 30->32->31
|
|
makeUidLogEvent(uidAtomTagId, timestamp, isolatedUid1, isolatedNonAdditiveData,
|
|
isolatedAdditiveData),
|
|
|
|
// 20->32->21
|
|
makeUidLogEvent(uidAtomTagId, timestamp, hostUid, isolatedNonAdditiveData,
|
|
hostAdditiveData),
|
|
|
|
// 20->22->21
|
|
makeUidLogEvent(uidAtomTagId, timestamp, hostUid, hostNonAdditiveData,
|
|
hostAdditiveData),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, uidAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(2, (int)data.size());
|
|
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(3, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
|
|
actualFieldValues = &data[1]->getValues();
|
|
ASSERT_EQ(3, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(isolatedNonAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData + isolatedAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
}
|
|
|
|
TEST(PullerUtilTest, NoMergeHostUidOnly) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 20->32->31
|
|
makeUidLogEvent(uidAtomTagId, timestamp, hostUid, isolatedNonAdditiveData,
|
|
isolatedAdditiveData),
|
|
|
|
// 20->22->21
|
|
makeUidLogEvent(uidAtomTagId, timestamp, hostUid, hostNonAdditiveData,
|
|
hostAdditiveData),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, uidAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(2, (int)data.size());
|
|
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(3, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
|
|
actualFieldValues = &data[1]->getValues();
|
|
ASSERT_EQ(3, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(isolatedNonAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(isolatedAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
}
|
|
|
|
TEST(PullerUtilTest, IsolatedUidOnly) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 30->32->31
|
|
makeUidLogEvent(uidAtomTagId, timestamp, isolatedUid1, isolatedNonAdditiveData,
|
|
isolatedAdditiveData),
|
|
|
|
// 30->22->21
|
|
makeUidLogEvent(uidAtomTagId, timestamp, isolatedUid1, hostNonAdditiveData,
|
|
hostAdditiveData),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, uidAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(2, (int)data.size());
|
|
|
|
// 20->32->31
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(3, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
|
|
// 20->22->21
|
|
actualFieldValues = &data[1]->getValues();
|
|
ASSERT_EQ(3, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(isolatedNonAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(isolatedAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
}
|
|
|
|
TEST(PullerUtilTest, MultipleIsolatedUidToOneHostUid) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 30->32->31
|
|
makeUidLogEvent(uidAtomTagId, timestamp, isolatedUid1, isolatedNonAdditiveData,
|
|
isolatedAdditiveData),
|
|
|
|
// 31->32->21
|
|
makeUidLogEvent(uidAtomTagId, timestamp, isolatedUid2, isolatedNonAdditiveData,
|
|
hostAdditiveData),
|
|
|
|
// 20->32->21
|
|
makeUidLogEvent(uidAtomTagId, timestamp, hostUid, isolatedNonAdditiveData,
|
|
hostAdditiveData),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, uidAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(1, (int)data.size());
|
|
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(3, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(isolatedNonAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(isolatedAdditiveData + hostAdditiveData + hostAdditiveData,
|
|
actualFieldValues->at(2).mValue.int_value);
|
|
}
|
|
|
|
TEST(PullerUtilTest, NoNeedToMerge) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 32->31
|
|
CreateTwoValueLogEvent(nonUidAtomTagId, timestamp, isolatedNonAdditiveData,
|
|
isolatedAdditiveData),
|
|
|
|
// 22->21
|
|
CreateTwoValueLogEvent(nonUidAtomTagId, timestamp, hostNonAdditiveData,
|
|
hostAdditiveData),
|
|
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, nonUidAtomTagId, {} /*no additive fields*/);
|
|
|
|
ASSERT_EQ(2, (int)data.size());
|
|
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(2, actualFieldValues->size());
|
|
EXPECT_EQ(isolatedNonAdditiveData, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(isolatedAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
|
|
actualFieldValues = &data[1]->getValues();
|
|
ASSERT_EQ(2, actualFieldValues->size());
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
}
|
|
|
|
TEST(PullerUtilTest, MergeNoDimensionAttributionChain) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 30->tag1->400->tag2->22->31
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {isolatedUid1, 400},
|
|
{"tag1", "tag2"}, hostNonAdditiveData, isolatedAdditiveData),
|
|
|
|
// 20->tag1->400->tag2->22->21
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {hostUid, 400},
|
|
{"tag1", "tag2"}, hostNonAdditiveData, hostAdditiveData),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, attributionAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(1, (int)data.size());
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);
|
|
EXPECT_EQ(400, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ("tag2", actualFieldValues->at(3).mValue.str_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(isolatedAdditiveData + hostAdditiveData, actualFieldValues->at(5).mValue.int_value);
|
|
}
|
|
|
|
TEST(PullerUtilTest, MergeWithDimensionAttributionChain) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 200->tag1->30->tag2->32->31
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {200, isolatedUid1},
|
|
{"tag1", "tag2"}, isolatedNonAdditiveData,
|
|
isolatedAdditiveData),
|
|
|
|
// 200->tag1->20->tag2->32->21
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {200, hostUid},
|
|
{"tag1", "tag2"}, isolatedNonAdditiveData, hostAdditiveData),
|
|
|
|
// 200->tag1->20->tag2->22->21
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {200, hostUid},
|
|
{"tag1", "tag2"}, hostNonAdditiveData, hostAdditiveData),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, attributionAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(2, (int)data.size());
|
|
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(200, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ("tag2", actualFieldValues->at(3).mValue.str_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(5).mValue.int_value);
|
|
|
|
actualFieldValues = &data[1]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(200, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ("tag2", actualFieldValues->at(3).mValue.str_value);
|
|
EXPECT_EQ(isolatedNonAdditiveData, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData + isolatedAdditiveData, actualFieldValues->at(5).mValue.int_value);
|
|
}
|
|
|
|
TEST(PullerUtilTest, NoMergeHostUidOnlyAttributionChain) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 20->tag1->400->tag2->32->31
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {hostUid, 400},
|
|
{"tag1", "tag2"}, isolatedNonAdditiveData,
|
|
isolatedAdditiveData),
|
|
|
|
// 20->tag1->400->tag2->22->21
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {hostUid, 400},
|
|
{"tag1", "tag2"}, hostNonAdditiveData, hostAdditiveData),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, attributionAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(2, (int)data.size());
|
|
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);
|
|
EXPECT_EQ(400, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ("tag2", actualFieldValues->at(3).mValue.str_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(5).mValue.int_value);
|
|
|
|
actualFieldValues = &data[1]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);
|
|
EXPECT_EQ(400, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ("tag2", actualFieldValues->at(3).mValue.str_value);
|
|
EXPECT_EQ(isolatedNonAdditiveData, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(isolatedAdditiveData, actualFieldValues->at(5).mValue.int_value);
|
|
}
|
|
|
|
TEST(PullerUtilTest, IsolatedUidOnlyAttributionChain) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 30->tag1->400->tag2->32->31
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {isolatedUid1, 400},
|
|
{"tag1", "tag2"}, isolatedNonAdditiveData,
|
|
isolatedAdditiveData),
|
|
|
|
// 30->tag1->400->tag2->22->21
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {isolatedUid1, 400},
|
|
{"tag1", "tag2"}, hostNonAdditiveData, hostAdditiveData),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, attributionAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(2, (int)data.size());
|
|
|
|
// 20->tag1->400->tag2->32->31
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);
|
|
EXPECT_EQ(400, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ("tag2", actualFieldValues->at(3).mValue.str_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(5).mValue.int_value);
|
|
|
|
// 20->tag1->400->tag2->22->21
|
|
actualFieldValues = &data[1]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);
|
|
EXPECT_EQ(400, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ("tag2", actualFieldValues->at(3).mValue.str_value);
|
|
EXPECT_EQ(isolatedNonAdditiveData, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(isolatedAdditiveData, actualFieldValues->at(5).mValue.int_value);
|
|
}
|
|
|
|
TEST(PullerUtilTest, MultipleIsolatedUidToOneHostUidAttributionChain) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 30->tag1->400->tag2->32->31
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {isolatedUid1, 400},
|
|
{"tag1", "tag2"}, isolatedNonAdditiveData,
|
|
isolatedAdditiveData),
|
|
|
|
// 31->tag1->400->tag2->32->21
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {isolatedUid2, 400},
|
|
{"tag1", "tag2"}, isolatedNonAdditiveData, hostAdditiveData),
|
|
|
|
// 20->tag1->400->tag2->32->21
|
|
makeAttributionLogEvent(attributionAtomTagId, timestamp, {hostUid, 400},
|
|
{"tag1", "tag2"}, isolatedNonAdditiveData, hostAdditiveData),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, attributionAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(1, (int)data.size());
|
|
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);
|
|
EXPECT_EQ(400, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ("tag2", actualFieldValues->at(3).mValue.str_value);
|
|
EXPECT_EQ(isolatedNonAdditiveData, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(isolatedAdditiveData + hostAdditiveData + hostAdditiveData,
|
|
actualFieldValues->at(5).mValue.int_value);
|
|
}
|
|
|
|
} // namespace statsd
|
|
} // namespace os
|
|
} // namespace android
|
|
#else
|
|
GTEST_LOG_(INFO) << "This test does nothing.\n";
|
|
#endif
|