650 lines
29 KiB
C++
650 lines
29 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;
|
|
const int hostUid2 = 2000;
|
|
const int isolatedUid3 = 3000;
|
|
const int isolatedUid4 = 4000;
|
|
|
|
sp<MockUidMap> makeMockUidMap() {
|
|
return makeMockUidMapForHosts(
|
|
{{hostUid, {isolatedUid1, isolatedUid2}}, {hostUid2, {isolatedUid3, isolatedUid4}}});
|
|
}
|
|
|
|
} // 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),
|
|
|
|
// 40->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, TwoIsolatedUidsOneAtom) {
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
makeExtraUidsLogEvent(uidAtomTagId, timestamp, isolatedUid1, isolatedNonAdditiveData,
|
|
isolatedAdditiveData, {isolatedUid3}),
|
|
|
|
makeExtraUidsLogEvent(uidAtomTagId, timestamp, isolatedUid2, isolatedNonAdditiveData,
|
|
hostAdditiveData, {isolatedUid4}),
|
|
|
|
makeExtraUidsLogEvent(uidAtomTagId, timestamp, hostUid, isolatedNonAdditiveData,
|
|
hostAdditiveData, {hostUid2}),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, uidAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(1, (int)data.size());
|
|
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(4, 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);
|
|
EXPECT_EQ(hostUid2, actualFieldValues->at(3).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);
|
|
}
|
|
|
|
// Test that repeated fields are treated as non-additive fields even when marked as additive.
|
|
TEST(PullerUtilTest, RepeatedAdditiveField) {
|
|
vector<int> int32Array1 = {3, 6};
|
|
vector<int> int32Array2 = {6, 9};
|
|
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// 30->22->{3,6}
|
|
makeUidLogEvent(uidAtomTagId, timestamp, isolatedUid1, hostNonAdditiveData,
|
|
int32Array1),
|
|
|
|
// 30->22->{6,9}
|
|
makeUidLogEvent(uidAtomTagId, timestamp, isolatedUid1, hostNonAdditiveData,
|
|
int32Array2),
|
|
|
|
// 20->22->{3,6}
|
|
makeUidLogEvent(uidAtomTagId, timestamp, hostUid, hostNonAdditiveData, int32Array1),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, uidAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(2, (int)data.size());
|
|
// Events 1 and 3 are merged - non-additive fields, including the repeated additive field, are
|
|
// equal.
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(4, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(3, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ(6, actualFieldValues->at(3).mValue.int_value);
|
|
|
|
// Event 2 isn't merged - repeated additive field is not equal.
|
|
actualFieldValues = &data[1]->getValues();
|
|
ASSERT_EQ(4, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(6, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ(9, actualFieldValues->at(3).mValue.int_value);
|
|
}
|
|
|
|
// Test that repeated uid events are sorted and merged correctly.
|
|
TEST(PullerUtilTest, RepeatedUidField) {
|
|
vector<int> uidArray1 = {isolatedUid1, hostUid};
|
|
vector<int> uidArray2 = {isolatedUid1, isolatedUid3};
|
|
vector<int> uidArray3 = {isolatedUid1, hostUid, isolatedUid2};
|
|
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// {30, 20}->22->21
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray1, hostNonAdditiveData,
|
|
hostAdditiveData),
|
|
|
|
// {30, 3000}->22->21 (different uid, not merged)
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray2, hostNonAdditiveData,
|
|
hostAdditiveData),
|
|
|
|
// {30, 20}->22->31 (different additive field, merged)
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray1, hostNonAdditiveData,
|
|
isolatedAdditiveData),
|
|
|
|
// {30, 20}->32->21 (different non-additive field, not merged)
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray1, isolatedNonAdditiveData,
|
|
hostAdditiveData),
|
|
|
|
// {30, 20, 40}->22->21 (different repeated uid length, not merged)
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray3, hostNonAdditiveData,
|
|
hostAdditiveData),
|
|
|
|
// {30, 20}->22->21 (same as first event, merged)
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray1, hostNonAdditiveData,
|
|
hostAdditiveData),
|
|
};
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, uidAtomTagId, additiveFields);
|
|
|
|
ASSERT_EQ(4, (int)data.size());
|
|
// Events 1 and 3 and 6 are merged.
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(4, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData + isolatedAdditiveData + hostAdditiveData,
|
|
actualFieldValues->at(3).mValue.int_value);
|
|
|
|
// Event 4 isn't merged - different non-additive data.
|
|
actualFieldValues = &data[1]->getValues();
|
|
ASSERT_EQ(4, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(isolatedNonAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(3).mValue.int_value);
|
|
|
|
// Event 2 isn't merged - different uid.
|
|
actualFieldValues = &data[2]->getValues();
|
|
ASSERT_EQ(4, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostUid2, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(3).mValue.int_value);
|
|
|
|
// Event 5 isn't merged - different repeated uid length.
|
|
actualFieldValues = &data[3]->getValues();
|
|
ASSERT_EQ(5, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ(hostNonAdditiveData, actualFieldValues->at(3).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(4).mValue.int_value);
|
|
}
|
|
|
|
// Test that repeated uid events with multiple repeated non-additive fields are sorted and merged
|
|
// correctly.
|
|
TEST(PullerUtilTest, MultipleRepeatedFields) {
|
|
vector<int> uidArray1 = {isolatedUid1, hostUid};
|
|
vector<int> uidArray2 = {isolatedUid1, isolatedUid3};
|
|
vector<int> uidArray3 = {isolatedUid1, hostUid, isolatedUid2};
|
|
|
|
vector<int> nonAdditiveArray1 = {1, 2, 3};
|
|
vector<int> nonAdditiveArray2 = {1, 5, 3};
|
|
vector<int> nonAdditiveArray3 = {1, 2};
|
|
|
|
const vector<int> secondAdditiveField = {2};
|
|
|
|
vector<shared_ptr<LogEvent>> data = {
|
|
// TODO: Once b/224880904 is fixed, can use different additive data without
|
|
// having the sort order messed up.
|
|
|
|
// Event 1 {30, 20}->21->{1, 2, 3} (merged with event 4)
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray1, hostAdditiveData,
|
|
nonAdditiveArray1),
|
|
|
|
// Event 2 {30, 3000}->21->{1, 2, 3} (different uid, not merged)
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray2, hostAdditiveData,
|
|
nonAdditiveArray1),
|
|
|
|
// Event 3 {30, 20, 40}->21->{1, 2} (different repeated fields with total length equal
|
|
// to event 1, merged with event 6)
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray3, hostAdditiveData,
|
|
nonAdditiveArray3),
|
|
|
|
// Event 4 {30, 20}->21->{1, 2, 3} (merged with event 1)
|
|
// TODO: once sorting bug is fixed, can change this additive field
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray1, hostAdditiveData,
|
|
nonAdditiveArray1),
|
|
|
|
// Event 5 {30, 20}->21->{1, 5, 3} (different repeated field, not merged)
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray1, hostAdditiveData,
|
|
nonAdditiveArray2),
|
|
|
|
// Event 6 {30, 20, 40}->22->{1, 2} (different repeated fields with total length equal
|
|
// to event 1, merged with event 3)
|
|
makeRepeatedUidLogEvent(uidAtomTagId, timestamp, uidArray3, isolatedAdditiveData,
|
|
nonAdditiveArray3),
|
|
};
|
|
|
|
// Expected event ordering after the sort:
|
|
// Event 3 {30, 20, 40}->21->{1, 2} (total size equal to event 1, merged with event 6)
|
|
// Event 6 {30, 20, 40}->22->{1, 2} (total size equal to event 1, merged with event 3)
|
|
// Event 1 {30, 20}->21->{1, 2, 3}
|
|
// Event 4 {30, 20}->21->{1, 2, 3} (merged with event 1)
|
|
// Event 5 {30, 20}->21->{1, 5, 3} (different repeated field, not merged)
|
|
// Event 2 {30, 3000}->21->{1, 2, 3} (different uid, not merged)
|
|
|
|
sp<MockUidMap> uidMap = makeMockUidMap();
|
|
mapAndMergeIsolatedUidsToHostUid(data, uidMap, uidAtomTagId, secondAdditiveField);
|
|
|
|
ASSERT_EQ(4, (int)data.size());
|
|
|
|
// Events 3 and 6 are merged. Not merged with event 1 because different repeated uids and
|
|
// fields, though length is same.
|
|
const vector<FieldValue>* actualFieldValues = &data[0]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData + isolatedAdditiveData, actualFieldValues->at(3).mValue.int_value);
|
|
EXPECT_EQ(1, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(2, actualFieldValues->at(5).mValue.int_value);
|
|
|
|
// Events 1 and 4 are merged.
|
|
actualFieldValues = &data[1]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData + hostAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ(1, actualFieldValues->at(3).mValue.int_value);
|
|
EXPECT_EQ(2, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(3, actualFieldValues->at(5).mValue.int_value);
|
|
|
|
// Event 5 isn't merged - different repeated field.
|
|
actualFieldValues = &data[2]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ(1, actualFieldValues->at(3).mValue.int_value);
|
|
EXPECT_EQ(5, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(3, actualFieldValues->at(5).mValue.int_value);
|
|
|
|
// Event 2 isn't merged - different uid.
|
|
actualFieldValues = &data[3]->getValues();
|
|
ASSERT_EQ(6, actualFieldValues->size());
|
|
EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
|
|
EXPECT_EQ(hostUid2, actualFieldValues->at(1).mValue.int_value);
|
|
EXPECT_EQ(hostAdditiveData, actualFieldValues->at(2).mValue.int_value);
|
|
EXPECT_EQ(1, actualFieldValues->at(3).mValue.int_value);
|
|
EXPECT_EQ(2, actualFieldValues->at(4).mValue.int_value);
|
|
EXPECT_EQ(3, actualFieldValues->at(5).mValue.int_value);
|
|
}
|
|
|
|
} // namespace statsd
|
|
} // namespace os
|
|
} // namespace android
|
|
#else
|
|
GTEST_LOG_(INFO) << "This test does nothing.\n";
|
|
#endif
|