c8e226610c
Clients don't need to know about statsd metadata. Extract out metadata from statslog.h/cpp into atoms_info.h/cpp which is only used by statsd. Generated atoms_info.h: https://paste.googleplex.com/6303016724463616 Generated atoms_info.cpp: https://paste.googleplex.com/5717940978581504 Test: m -j Test: old metadata in statslog matches the metadata in atoms_info Test: Flashes successfully Test: adb logcat "*:S statsd:*" Change-Id: I56ef3cc4ea1fbd2cd0130d4e9576b242efb9f627
271 lines
8.2 KiB
C++
271 lines
8.2 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 "statslog.h"
|
|
#include "../metrics/metrics_test_helper.h"
|
|
|
|
#ifdef __ANDROID__
|
|
|
|
namespace android {
|
|
namespace os {
|
|
namespace statsd {
|
|
|
|
using namespace testing;
|
|
using std::make_shared;
|
|
using std::shared_ptr;
|
|
using std::vector;
|
|
using testing::Contains;
|
|
/*
|
|
* Test merge isolated and host uid
|
|
*/
|
|
|
|
int uidAtomTagId = android::util::CPU_CLUSTER_TIME;
|
|
int nonUidAtomTagId = android::util::SYSTEM_UPTIME;
|
|
int timestamp = 1234;
|
|
int isolatedUid = 30;
|
|
int isolatedAdditiveData = 31;
|
|
int isolatedNonAdditiveData = 32;
|
|
int hostUid = 20;
|
|
int hostAdditiveData = 21;
|
|
int hostNonAdditiveData = 22;
|
|
|
|
void extractIntoVector(vector<shared_ptr<LogEvent>> events,
|
|
vector<vector<int>>& ret) {
|
|
ret.clear();
|
|
status_t err;
|
|
for (const auto& event : events) {
|
|
vector<int> vec;
|
|
vec.push_back(event->GetInt(1, &err));
|
|
vec.push_back(event->GetInt(2, &err));
|
|
vec.push_back(event->GetInt(3, &err));
|
|
ret.push_back(vec);
|
|
}
|
|
}
|
|
|
|
TEST(puller_util, MergeNoDimension) {
|
|
vector<shared_ptr<LogEvent>> inputData;
|
|
shared_ptr<LogEvent> event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
// 30->22->31
|
|
event->write(isolatedUid);
|
|
event->write(hostNonAdditiveData);
|
|
event->write(isolatedAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
// 20->22->21
|
|
event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
event->write(hostUid);
|
|
event->write(hostNonAdditiveData);
|
|
event->write(hostAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
|
|
EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid))
|
|
.WillRepeatedly(Return(hostUid));
|
|
EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid)))
|
|
.WillRepeatedly(ReturnArg<0>());
|
|
mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId);
|
|
|
|
vector<vector<int>> actual;
|
|
extractIntoVector(inputData, actual);
|
|
vector<int> expectedV1 = {20, 22, 52};
|
|
EXPECT_EQ(1, (int)actual.size());
|
|
EXPECT_THAT(actual, Contains(expectedV1));
|
|
}
|
|
|
|
TEST(puller_util, MergeWithDimension) {
|
|
vector<shared_ptr<LogEvent>> inputData;
|
|
shared_ptr<LogEvent> event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
// 30->32->31
|
|
event->write(isolatedUid);
|
|
event->write(isolatedNonAdditiveData);
|
|
event->write(isolatedAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
// 20->32->21
|
|
event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
event->write(hostUid);
|
|
event->write(isolatedNonAdditiveData);
|
|
event->write(hostAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
// 20->22->21
|
|
event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
event->write(hostUid);
|
|
event->write(hostNonAdditiveData);
|
|
event->write(hostAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
|
|
EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid))
|
|
.WillRepeatedly(Return(hostUid));
|
|
EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid)))
|
|
.WillRepeatedly(ReturnArg<0>());
|
|
mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId);
|
|
|
|
vector<vector<int>> actual;
|
|
extractIntoVector(inputData, actual);
|
|
vector<int> expectedV1 = {20, 22, 21};
|
|
vector<int> expectedV2 = {20, 32, 52};
|
|
EXPECT_EQ(2, (int)actual.size());
|
|
EXPECT_THAT(actual, Contains(expectedV1));
|
|
EXPECT_THAT(actual, Contains(expectedV2));
|
|
}
|
|
|
|
TEST(puller_util, NoMergeHostUidOnly) {
|
|
vector<shared_ptr<LogEvent>> inputData;
|
|
shared_ptr<LogEvent> event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
// 20->32->31
|
|
event->write(hostUid);
|
|
event->write(isolatedNonAdditiveData);
|
|
event->write(isolatedAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
// 20->22->21
|
|
event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
event->write(hostUid);
|
|
event->write(hostNonAdditiveData);
|
|
event->write(hostAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
|
|
EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid))
|
|
.WillRepeatedly(Return(hostUid));
|
|
EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid)))
|
|
.WillRepeatedly(ReturnArg<0>());
|
|
mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId);
|
|
|
|
// 20->32->31
|
|
// 20->22->21
|
|
vector<vector<int>> actual;
|
|
extractIntoVector(inputData, actual);
|
|
vector<int> expectedV1 = {20, 32, 31};
|
|
vector<int> expectedV2 = {20, 22, 21};
|
|
EXPECT_EQ(2, (int)actual.size());
|
|
EXPECT_THAT(actual, Contains(expectedV1));
|
|
EXPECT_THAT(actual, Contains(expectedV2));
|
|
}
|
|
|
|
TEST(puller_util, IsolatedUidOnly) {
|
|
vector<shared_ptr<LogEvent>> inputData;
|
|
shared_ptr<LogEvent> event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
// 30->32->31
|
|
event->write(hostUid);
|
|
event->write(isolatedNonAdditiveData);
|
|
event->write(isolatedAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
// 30->22->21
|
|
event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
event->write(hostUid);
|
|
event->write(hostNonAdditiveData);
|
|
event->write(hostAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
|
|
EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid))
|
|
.WillRepeatedly(Return(hostUid));
|
|
EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid)))
|
|
.WillRepeatedly(ReturnArg<0>());
|
|
mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId);
|
|
|
|
// 20->32->31
|
|
// 20->22->21
|
|
vector<vector<int>> actual;
|
|
extractIntoVector(inputData, actual);
|
|
vector<int> expectedV1 = {20, 32, 31};
|
|
vector<int> expectedV2 = {20, 22, 21};
|
|
EXPECT_EQ(2, (int)actual.size());
|
|
EXPECT_THAT(actual, Contains(expectedV1));
|
|
EXPECT_THAT(actual, Contains(expectedV2));
|
|
}
|
|
|
|
TEST(puller_util, MultipleIsolatedUidToOneHostUid) {
|
|
vector<shared_ptr<LogEvent>> inputData;
|
|
shared_ptr<LogEvent> event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
// 30->32->31
|
|
event->write(isolatedUid);
|
|
event->write(isolatedNonAdditiveData);
|
|
event->write(isolatedAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
// 31->32->21
|
|
event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
event->write(isolatedUid + 1);
|
|
event->write(isolatedNonAdditiveData);
|
|
event->write(hostAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
// 20->32->21
|
|
event = make_shared<LogEvent>(uidAtomTagId, timestamp);
|
|
event->write(hostUid);
|
|
event->write(isolatedNonAdditiveData);
|
|
event->write(hostAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
|
|
EXPECT_CALL(*uidMap, getHostUidOrSelf(_)).WillRepeatedly(Return(hostUid));
|
|
mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId);
|
|
|
|
vector<vector<int>> actual;
|
|
extractIntoVector(inputData, actual);
|
|
vector<int> expectedV1 = {20, 32, 73};
|
|
EXPECT_EQ(1, (int)actual.size());
|
|
EXPECT_THAT(actual, Contains(expectedV1));
|
|
}
|
|
|
|
TEST(puller_util, NoNeedToMerge) {
|
|
vector<shared_ptr<LogEvent>> inputData;
|
|
shared_ptr<LogEvent> event =
|
|
make_shared<LogEvent>(nonUidAtomTagId, timestamp);
|
|
// 32
|
|
event->write(isolatedNonAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
event = make_shared<LogEvent>(nonUidAtomTagId, timestamp);
|
|
// 22
|
|
event->write(hostNonAdditiveData);
|
|
event->init();
|
|
inputData.push_back(event);
|
|
|
|
sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
|
|
mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, nonUidAtomTagId);
|
|
|
|
EXPECT_EQ(2, (int)inputData.size());
|
|
}
|
|
|
|
} // namespace statsd
|
|
} // namespace os
|
|
} // namespace android
|
|
#else
|
|
GTEST_LOG_(INFO) << "This test does nothing.\n";
|
|
#endif
|