| // 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 |