Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "(Part 3) Use new socket schema with statsd tests" into rvc-dev am: 4aa7af0a8f am: 0b03be06a9 am: ab3c482b45

Browse Source 
Change-Id: I666cc99dc941d198b78164c1c116050e37a2fa9c
This commit is contained in:
Christine Tsai
2020-03-24 21:18:16 +00:00
committed by Automerger Merge Worker
parent 9fddd2e1a0 ab3c482b45
commit 5b940bbb60
9 changed files with 2799 additions and 2683 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
cmds/statsd/src/atoms.proto
View File

@@ -78,7 +78,8 @@ message Atom {
// Pushed atoms start at 2. // Pushed atoms start at 2.
oneof pushed { oneof pushed {
// For StatsLog reasons, 1 is illegal and will not work. Must start at 2. // For StatsLog reasons, 1 is illegal and will not work. Must start at 2.
BleScanStateChanged ble_scan_state_changed = 2 [(module) = "bluetooth"]; BleScanStateChanged ble_scan_state_changed = 2
[(module) = "bluetooth", (module) = "statsdtest"];
ProcessStateChanged process_state_changed = 3 [(module) = "framework"]; ProcessStateChanged process_state_changed = 3 [(module) = "framework"];
BleScanResultReceived ble_scan_result_received = 4 [(module) = "bluetooth"]; BleScanResultReceived ble_scan_result_received = 4 [(module) = "bluetooth"];
SensorStateChanged sensor_state_changed = SensorStateChanged sensor_state_changed =
@@ -434,7 +435,7 @@ message Atom {
ProcessMemoryState process_memory_state = 10013 [(module) = "framework"]; ProcessMemoryState process_memory_state = 10013 [(module) = "framework"];
SystemElapsedRealtime system_elapsed_realtime = 10014 [(module) = "framework"]; SystemElapsedRealtime system_elapsed_realtime = 10014 [(module) = "framework"];
SystemUptime system_uptime = 10015 [(module) = "framework", (module) = "statsdtest"]; SystemUptime system_uptime = 10015 [(module) = "framework", (module) = "statsdtest"];
CpuActiveTime cpu_active_time = 10016 [(module) = "framework"]; CpuActiveTime cpu_active_time = 10016 [(module) = "framework", (module) = "statsdtest"];
CpuClusterTime cpu_cluster_time = 10017 [(module) = "framework", (module) = "statsdtest"]; CpuClusterTime cpu_cluster_time = 10017 [(module) = "framework", (module) = "statsdtest"];
DiskSpace disk_space = 10018 [deprecated=true, (module) = "statsdtest"]; DiskSpace disk_space = 10018 [deprecated=true, (module) = "statsdtest"];
RemainingBatteryCapacity remaining_battery_capacity = 10019 [(module) = "framework"]; RemainingBatteryCapacity remaining_battery_capacity = 10019 [(module) = "framework"];

329
cmds/statsd/tests/FieldValue_test.cpp
View File

@@ -14,13 +14,16 @@
* limitations under the License. * limitations under the License.
*/ */
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "frameworks/base/cmds/statsd/src/stats_log.pb.h" #include "frameworks/base/cmds/statsd/src/stats_log.pb.h"
#include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h"
#include "matchers/matcher_util.h" #include "matchers/matcher_util.h"
#include "src/logd/LogEvent.h" #include "src/logd/LogEvent.h"
#include "stats_event.h"
#include "stats_log_util.h" #include "stats_log_util.h"
#include "stats_util.h" #include "stats_util.h"
#include "subscriber/SubscriberReporter.h" #include "subscriber/SubscriberReporter.h"
#include "tests/statsd_test_util.h"
#ifdef __ANDROID__ #ifdef __ANDROID__
@@ -30,6 +33,58 @@ namespace android {
namespace os { namespace os {
namespace statsd { namespace statsd {
namespace {
void makeLogEvent(LogEvent* logEvent, const int32_t atomId, const int64_t timestamp,
const vector<int>& attributionUids, const vector<string>& attributionTags,
const string& name) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, atomId);
AStatsEvent_overwriteTimestamp(statsEvent, timestamp);
vector<const char*> cTags(attributionTags.size());
for (int i = 0; i < cTags.size(); i++) {
cTags[i] = attributionTags[i].c_str();
}
AStatsEvent_writeAttributionChain(statsEvent,
reinterpret_cast<const uint32_t*>(attributionUids.data()),
cTags.data(), attributionUids.size());
AStatsEvent_writeString(statsEvent, name.c_str());
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
}
void makeLogEvent(LogEvent* logEvent, const int32_t atomId, const int64_t timestamp,
const vector<int>& attributionUids, const vector<string>& attributionTags,
const int32_t value) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, atomId);
AStatsEvent_overwriteTimestamp(statsEvent, timestamp);
vector<const char*> cTags(attributionTags.size());
for (int i = 0; i < cTags.size(); i++) {
cTags[i] = attributionTags[i].c_str();
}
AStatsEvent_writeAttributionChain(statsEvent,
reinterpret_cast<const uint32_t*>(attributionUids.data()),
cTags.data(), attributionUids.size());
AStatsEvent_writeInt32(statsEvent, value);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
}
} // anonymous namespace
TEST(AtomMatcherTest, TestFieldTranslation) { TEST(AtomMatcherTest, TestFieldTranslation) {
FieldMatcher matcher1; FieldMatcher matcher1;
matcher1.set_field(10); matcher1.set_field(10);
@@ -72,66 +127,50 @@ TEST(AtomMatcherTest, TestFieldTranslation_ALL) {
EXPECT_EQ((int32_t)0xff7f7f7f, matcher12.mMask); EXPECT_EQ((int32_t)0xff7f7f7f, matcher12.mMask);
} }
// TODO(b/149590301): Update this test to use new socket schema. TEST(AtomMatcherTest, TestFilter_ALL) {
//TEST(AtomMatcherTest, TestFilter_ALL) { FieldMatcher matcher1;
// FieldMatcher matcher1; matcher1.set_field(10);
// matcher1.set_field(10); FieldMatcher* child = matcher1.add_child();
// FieldMatcher* child = matcher1.add_child(); child->set_field(1);
// child->set_field(1); child->set_position(Position::ALL);
// child->set_position(Position::ALL);
// child->add_child()->set_field(1);
// child->add_child()->set_field(1); child->add_child()->set_field(2);
// child->add_child()->set_field(2);
// child = matcher1.add_child();
// child = matcher1.add_child(); child->set_field(2);
// child->set_field(2);
// vector<Matcher> matchers;
// vector<Matcher> matchers; translateFieldMatcher(matcher1, &matchers);
// translateFieldMatcher(matcher1, &matchers);
// std::vector<int> attributionUids = {1111, 2222, 3333};
// AttributionNodeInternal attribution_node1; std::vector<string> attributionTags = {"location1", "location2", "location3"};
// attribution_node1.set_uid(1111);
// attribution_node1.set_tag("location1"); LogEvent event(/*uid=*/0, /*pid=*/0);
// makeLogEvent(&event, 10 /*atomId*/, 1012345, attributionUids, attributionTags, "some value");
// AttributionNodeInternal attribution_node2; HashableDimensionKey output;
// attribution_node2.set_uid(2222);
// attribution_node2.set_tag("location2"); filterValues(matchers, event.getValues(), &output);
//
// AttributionNodeInternal attribution_node3; EXPECT_EQ((size_t)7, output.getValues().size());
// attribution_node3.set_uid(3333); EXPECT_EQ((int32_t)0x02010101, output.getValues()[0].mField.getField());
// attribution_node3.set_tag("location3"); EXPECT_EQ((int32_t)1111, output.getValues()[0].mValue.int_value);
// std::vector<AttributionNodeInternal> attribution_nodes = {attribution_node1, attribution_node2, EXPECT_EQ((int32_t)0x02010102, output.getValues()[1].mField.getField());
// attribution_node3}; EXPECT_EQ("location1", output.getValues()[1].mValue.str_value);
//
// // Set up the event EXPECT_EQ((int32_t)0x02010201, output.getValues()[2].mField.getField());
// LogEvent event(10, 12345); EXPECT_EQ((int32_t)2222, output.getValues()[2].mValue.int_value);
// event.write(attribution_nodes); EXPECT_EQ((int32_t)0x02010202, output.getValues()[3].mField.getField());
// event.write("some value"); EXPECT_EQ("location2", output.getValues()[3].mValue.str_value);
// // Convert to a LogEvent
// event.init(); EXPECT_EQ((int32_t)0x02010301, output.getValues()[4].mField.getField());
// HashableDimensionKey output; EXPECT_EQ((int32_t)3333, output.getValues()[4].mValue.int_value);
// EXPECT_EQ((int32_t)0x02010302, output.getValues()[5].mField.getField());
// filterValues(matchers, event.getValues(), &output); EXPECT_EQ("location3", output.getValues()[5].mValue.str_value);
//
// EXPECT_EQ((size_t)7, output.getValues().size()); EXPECT_EQ((int32_t)0x00020000, output.getValues()[6].mField.getField());
// EXPECT_EQ((int32_t)0x02010101, output.getValues()[0].mField.getField()); EXPECT_EQ("some value", output.getValues()[6].mValue.str_value);
// EXPECT_EQ((int32_t)1111, output.getValues()[0].mValue.int_value); }
// EXPECT_EQ((int32_t)0x02010102, output.getValues()[1].mField.getField());
// EXPECT_EQ("location1", output.getValues()[1].mValue.str_value);
//
// EXPECT_EQ((int32_t)0x02010201, output.getValues()[2].mField.getField());
// EXPECT_EQ((int32_t)2222, output.getValues()[2].mValue.int_value);
// EXPECT_EQ((int32_t)0x02010202, output.getValues()[3].mField.getField());
// EXPECT_EQ("location2", output.getValues()[3].mValue.str_value);
//
// EXPECT_EQ((int32_t)0x02010301, output.getValues()[4].mField.getField());
// EXPECT_EQ((int32_t)3333, output.getValues()[4].mValue.int_value);
// EXPECT_EQ((int32_t)0x02010302, output.getValues()[5].mField.getField());
// EXPECT_EQ("location3", output.getValues()[5].mValue.str_value);
//
// EXPECT_EQ((int32_t)0x00020000, output.getValues()[6].mField.getField());
// EXPECT_EQ("some value", output.getValues()[6].mValue.str_value);
//}
TEST(AtomMatcherTest, TestSubDimension) { TEST(AtomMatcherTest, TestSubDimension) {
HashableDimensionKey dim; HashableDimensionKey dim;
@@ -174,61 +213,45 @@ TEST(AtomMatcherTest, TestSubDimension) {
EXPECT_TRUE(dim.contains(subDim4)); EXPECT_TRUE(dim.contains(subDim4));
} }
// TODO(b/149590301): Update this test to use new socket schema. TEST(AtomMatcherTest, TestMetric2ConditionLink) {
//TEST(AtomMatcherTest, TestMetric2ConditionLink) { std::vector<int> attributionUids = {1111, 2222, 3333};
// AttributionNodeInternal attribution_node1; std::vector<string> attributionTags = {"location1", "location2", "location3"};
// attribution_node1.set_uid(1111);
// attribution_node1.set_tag("location1"); LogEvent event(/*uid=*/0, /*pid=*/0);
// makeLogEvent(&event, 10 /*atomId*/, 12345, attributionUids, attributionTags, "some value");
// AttributionNodeInternal attribution_node2;
// attribution_node2.set_uid(2222); FieldMatcher whatMatcher;
// attribution_node2.set_tag("location2"); whatMatcher.set_field(10);
// FieldMatcher* child11 = whatMatcher.add_child();
// AttributionNodeInternal attribution_node3; child11->set_field(1);
// attribution_node3.set_uid(3333); child11->set_position(Position::ANY);
// attribution_node3.set_tag("location3"); child11 = child11->add_child();
// std::vector<AttributionNodeInternal> attribution_nodes = {attribution_node1, attribution_node2, child11->set_field(1);
// attribution_node3};
// FieldMatcher conditionMatcher;
// // Set up the event conditionMatcher.set_field(27);
// LogEvent event(10, 12345); FieldMatcher* child2 = conditionMatcher.add_child();
// event.write(attribution_nodes); child2->set_field(2);
// event.write("some value"); child2->set_position(Position::LAST);
// // Convert to a LogEvent
// event.init(); child2 = child2->add_child();
// child2->set_field(2);
// FieldMatcher whatMatcher;
// whatMatcher.set_field(10); Metric2Condition link;
// FieldMatcher* child11 = whatMatcher.add_child();
// child11->set_field(1); translateFieldMatcher(whatMatcher, &link.metricFields);
// child11->set_position(Position::ANY); translateFieldMatcher(conditionMatcher, &link.conditionFields);
// child11 = child11->add_child();
// child11->set_field(1); EXPECT_EQ((size_t)1, link.metricFields.size());
// EXPECT_EQ((int32_t)0x02010001, link.metricFields[0].mMatcher.getField());
// FieldMatcher conditionMatcher; EXPECT_EQ((int32_t)0xff7f007f, link.metricFields[0].mMask);
// conditionMatcher.set_field(27); EXPECT_EQ((int32_t)10, link.metricFields[0].mMatcher.getTag());
// FieldMatcher* child2 = conditionMatcher.add_child();
// child2->set_field(2); EXPECT_EQ((size_t)1, link.conditionFields.size());
// child2->set_position(Position::LAST); EXPECT_EQ((int32_t)0x02028002, link.conditionFields[0].mMatcher.getField());
// EXPECT_EQ((int32_t)0xff7f807f, link.conditionFields[0].mMask);
// child2 = child2->add_child(); EXPECT_EQ((int32_t)27, link.conditionFields[0].mMatcher.getTag());
// child2->set_field(2); }
//
// Metric2Condition link;
//
// translateFieldMatcher(whatMatcher, &link.metricFields);
// translateFieldMatcher(conditionMatcher, &link.conditionFields);
//
// EXPECT_EQ((size_t)1, link.metricFields.size());
// EXPECT_EQ((int32_t)0x02010001, link.metricFields[0].mMatcher.getField());
// EXPECT_EQ((int32_t)0xff7f007f, link.metricFields[0].mMask);
// EXPECT_EQ((int32_t)10, link.metricFields[0].mMatcher.getTag());
//
// EXPECT_EQ((size_t)1, link.conditionFields.size());
// EXPECT_EQ((int32_t)0x02028002, link.conditionFields[0].mMatcher.getField());
// EXPECT_EQ((int32_t)0xff7f807f, link.conditionFields[0].mMask);
// EXPECT_EQ((int32_t)27, link.conditionFields[0].mMatcher.getTag());
//}
TEST(AtomMatcherTest, TestWriteDimensionPath) { TEST(AtomMatcherTest, TestWriteDimensionPath) {
for (auto position : {Position::ANY, Position::ALL, Position::FIRST, Position::LAST}) { for (auto position : {Position::ANY, Position::ALL, Position::FIRST, Position::LAST}) {
@@ -439,50 +462,38 @@ TEST(AtomMatcherTest, TestWriteDimensionLeafNodesToProto) {
EXPECT_EQ(99999, dim4.value_long()); EXPECT_EQ(99999, dim4.value_long());
} }
// TODO(b/149590301): Update this test to use new socket schema. TEST(AtomMatcherTest, TestWriteAtomToProto) {
//TEST(AtomMatcherTest, TestWriteAtomToProto) { std::vector<int> attributionUids = {1111, 2222};
// AttributionNodeInternal attribution_node1; std::vector<string> attributionTags = {"location1", "location2"};
// attribution_node1.set_uid(1111);
// attribution_node1.set_tag("location1"); LogEvent event(/*uid=*/0, /*pid=*/0);
// makeLogEvent(&event, 4 /*atomId*/, 12345, attributionUids, attributionTags, 999);
// AttributionNodeInternal attribution_node2;
// attribution_node2.set_uid(2222); android::util::ProtoOutputStream protoOutput;
// attribution_node2.set_tag("location2"); writeFieldValueTreeToStream(event.GetTagId(), event.getValues(), &protoOutput);
//
// std::vector<AttributionNodeInternal> attribution_nodes = {attribution_node1, attribution_node2}; vector<uint8_t> outData;
// outData.resize(protoOutput.size());
// // Set up the event size_t pos = 0;
// LogEvent event(4, 12345); sp<ProtoReader> reader = protoOutput.data();
// event.write(attribution_nodes); while (reader->readBuffer() != NULL) {
// event.write((int32_t)999); size_t toRead = reader->currentToRead();
// // Convert to a LogEvent std::memcpy(&(outData[pos]), reader->readBuffer(), toRead);
// event.init(); pos += toRead;
// reader->move(toRead);
// android::util::ProtoOutputStream protoOutput; }
// writeFieldValueTreeToStream(event.GetTagId(), event.getValues(), &protoOutput);
// Atom result;
// vector<uint8_t> outData; EXPECT_EQ(true, result.ParseFromArray(&outData[0], outData.size()));
// outData.resize(protoOutput.size()); EXPECT_EQ(Atom::PushedCase::kBleScanResultReceived, result.pushed_case());
// size_t pos = 0; const auto& atom = result.ble_scan_result_received();
// sp<ProtoReader> reader = protoOutput.data(); EXPECT_EQ(2, atom.attribution_node_size());
// while (reader->readBuffer() != NULL) { EXPECT_EQ(1111, atom.attribution_node(0).uid());
// size_t toRead = reader->currentToRead(); EXPECT_EQ("location1", atom.attribution_node(0).tag());
// std::memcpy(&(outData[pos]), reader->readBuffer(), toRead); EXPECT_EQ(2222, atom.attribution_node(1).uid());
// pos += toRead; EXPECT_EQ("location2", atom.attribution_node(1).tag());
// reader->move(toRead); EXPECT_EQ(999, atom.num_results());
// } }
//
// Atom result;
// EXPECT_EQ(true, result.ParseFromArray(&outData[0], outData.size()));
// EXPECT_EQ(Atom::PushedCase::kBleScanResultReceived, result.pushed_case());
// const auto& atom = result.ble_scan_result_received();
// EXPECT_EQ(2, atom.attribution_node_size());
// EXPECT_EQ(1111, atom.attribution_node(0).uid());
// EXPECT_EQ("location1", atom.attribution_node(0).tag());
// EXPECT_EQ(2222, atom.attribution_node(1).uid());
// EXPECT_EQ("location2", atom.attribution_node(1).tag());
// EXPECT_EQ(999, atom.num_results());
//}
/* /*
* Test two Matchers is not a subset of one Matcher. * Test two Matchers is not a subset of one Matcher.

1338
cmds/statsd/tests/LogEntryMatcher_test.cpp
View File

File diff suppressed because it is too large Load Diff

2824
cmds/statsd/tests/StatsLogProcessor_test.cpp
View File

File diff suppressed because it is too large Load Diff

51
cmds/statsd/tests/UidMap_test.cpp
View File

@@ -39,35 +39,28 @@ using android::util::ProtoReader;
const string kApp1 = "app1.sharing.1"; const string kApp1 = "app1.sharing.1";
const string kApp2 = "app2.sharing.1"; const string kApp2 = "app2.sharing.1";
// TODO(b/149590301): Update this test to use new socket schema. TEST(UidMapTest, TestIsolatedUID) {
//TEST(UidMapTest, TestIsolatedUID) { sp<UidMap> m = new UidMap();
// sp<UidMap> m = new UidMap(); sp<StatsPullerManager> pullerManager = new StatsPullerManager();
// sp<StatsPullerManager> pullerManager = new StatsPullerManager(); sp<AlarmMonitor> anomalyAlarmMonitor;
// sp<AlarmMonitor> anomalyAlarmMonitor; sp<AlarmMonitor> subscriberAlarmMonitor;
// sp<AlarmMonitor> subscriberAlarmMonitor; // Construct the processor with a dummy sendBroadcast function that does nothing.
// // Construct the processor with a dummy sendBroadcast function that does nothing. StatsLogProcessor p(
// StatsLogProcessor p(m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0, m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
// [](const ConfigKey& key) { return true; }, [](const ConfigKey& key) { return true; },
// [](const int&, const vector<int64_t>&) {return true;}); [](const int&, const vector<int64_t>&) { return true; });
// LogEvent addEvent(util::ISOLATED_UID_CHANGED, 1);
// addEvent.write(100); // parent UID std::unique_ptr<LogEvent> addEvent = CreateIsolatedUidChangedEvent(
// addEvent.write(101); // isolated UID 1 /*timestamp*/, 100 /*hostUid*/, 101 /*isolatedUid*/, 1 /*is_create*/);
// addEvent.write(1); // Indicates creation. EXPECT_EQ(101, m->getHostUidOrSelf(101));
// addEvent.init(); p.OnLogEvent(addEvent.get());
// EXPECT_EQ(100, m->getHostUidOrSelf(101));
// EXPECT_EQ(101, m->getHostUidOrSelf(101));
// std::unique_ptr<LogEvent> removeEvent = CreateIsolatedUidChangedEvent(
// p.OnLogEvent(&addEvent); 1 /*timestamp*/, 100 /*hostUid*/, 101 /*isolatedUid*/, 0 /*is_create*/);
// EXPECT_EQ(100, m->getHostUidOrSelf(101)); p.OnLogEvent(removeEvent.get());
// EXPECT_EQ(101, m->getHostUidOrSelf(101));
// LogEvent removeEvent(util::ISOLATED_UID_CHANGED, 1); }
// removeEvent.write(100); // parent UID
// removeEvent.write(101); // isolated UID
// removeEvent.write(0); // Indicates removal.
// removeEvent.init();
// p.OnLogEvent(&removeEvent);
// EXPECT_EQ(101, m->getHostUidOrSelf(101));
//}
TEST(UidMapTest, TestMatching) { TEST(UidMapTest, TestMatching) {
UidMap m; UidMap m;

27
cmds/statsd/tests/shell/ShellSubscriber_test.cpp
View File

@@ -12,18 +12,20 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
#include <gtest/gtest.h> #include "src/shell/ShellSubscriber.h"
#include <gtest/gtest.h>
#include <stdio.h>
#include <unistd.h> #include <unistd.h>
#include <vector>
#include "frameworks/base/cmds/statsd/src/atoms.pb.h" #include "frameworks/base/cmds/statsd/src/atoms.pb.h"
#include "frameworks/base/cmds/statsd/src/shell/shell_config.pb.h" #include "frameworks/base/cmds/statsd/src/shell/shell_config.pb.h"
#include "frameworks/base/cmds/statsd/src/shell/shell_data.pb.h" #include "frameworks/base/cmds/statsd/src/shell/shell_data.pb.h"
#include "src/shell/ShellSubscriber.h"
#include "stats_event.h" #include "stats_event.h"
#include "tests/metrics/metrics_test_helper.h" #include "tests/metrics/metrics_test_helper.h"
#include "tests/statsd_test_util.h"
#include <stdio.h>
#include <vector>
using namespace android::os::statsd; using namespace android::os::statsd;
using android::sp; using android::sp;
@@ -118,18 +120,9 @@ TEST(ShellSubscriberTest, testPushedSubscription) {
vector<std::shared_ptr<LogEvent>> pushedList; vector<std::shared_ptr<LogEvent>> pushedList;
// Create the LogEvent from an AStatsEvent // Create the LogEvent from an AStatsEvent
AStatsEvent* statsEvent = AStatsEvent_obtain(); std::unique_ptr<LogEvent> logEvent = CreateScreenStateChangedEvent(
AStatsEvent_setAtomId(statsEvent, 29 /*screen_state_atom_id*/); 1000 /*timestamp*/, ::android::view::DisplayStateEnum::DISPLAY_STATE_ON);
AStatsEvent_overwriteTimestamp(statsEvent, 1000); pushedList.push_back(std::move(logEvent));
AStatsEvent_writeInt32(statsEvent, ::android::view::DisplayStateEnum::DISPLAY_STATE_ON);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buffer = AStatsEvent_getBuffer(statsEvent, &size);
std::shared_ptr<LogEvent> logEvent = std::make_shared<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buffer, size);
AStatsEvent_release(statsEvent);
pushedList.push_back(logEvent);
// create a simple config to get screen events // create a simple config to get screen events
ShellSubscription config; ShellSubscription config;

755
cmds/statsd/tests/state/StateTracker_test.cpp
View File

@@ -13,11 +13,13 @@
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*/ */
#include <gtest/gtest.h>
#include "state/StateManager.h"
#include "state/StateTracker.h" #include "state/StateTracker.h"
#include "state/StateListener.h"
#include <gtest/gtest.h>
#include "state/StateListener.h"
#include "state/StateManager.h"
#include "stats_event.h"
#include "tests/statsd_test_util.h" #include "tests/statsd_test_util.h"
#ifdef __ANDROID__ #ifdef __ANDROID__
@@ -26,6 +28,8 @@ namespace android {
namespace os { namespace os {
namespace statsd { namespace statsd {
const int32_t timestampNs = 1000;
/** /**
* Mock StateListener class for testing. * Mock StateListener class for testing.
* Stores primary key and state pairs. * Stores primary key and state pairs.
@@ -56,95 +60,49 @@ int getStateInt(StateManager& mgr, int atomId, const HashableDimensionKey& query
return output.mValue.int_value; return output.mValue.int_value;
} }
// TODO(b/149590301): Update these helpers to use new socket schema. // START: build event functions.
//// START: build event functions. // Incorrect event - missing fields
//// State with no primary fields - ScreenStateChanged std::shared_ptr<LogEvent> buildIncorrectOverlayEvent(int uid, const std::string& packageName,
//std::shared_ptr<LogEvent> buildScreenEvent(int state) { int state) {
// std::shared_ptr<LogEvent> event = AStatsEvent* statsEvent = AStatsEvent_obtain();
// std::make_shared<LogEvent>(util::SCREEN_STATE_CHANGED, 1000 /*timestamp*/); AStatsEvent_setAtomId(statsEvent, util::OVERLAY_STATE_CHANGED);
// event->write((int32_t)state); AStatsEvent_overwriteTimestamp(statsEvent, 1000);
// event->init();
// return event; AStatsEvent_writeInt32(statsEvent, uid);
//} AStatsEvent_writeString(statsEvent, packageName.c_str());
// // Missing field 3 - using_alert_window.
//// State with one primary field - UidProcessStateChanged AStatsEvent_writeInt32(statsEvent, state);
//std::shared_ptr<LogEvent> buildUidProcessEvent(int uid, int state) { AStatsEvent_build(statsEvent);
// std::shared_ptr<LogEvent> event =
// std::make_shared<LogEvent>(util::UID_PROCESS_STATE_CHANGED, 1000 /*timestamp*/); size_t size;
// event->write((int32_t)uid); uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
// event->write((int32_t)state);
// event->init(); std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
// return event; logEvent->parseBuffer(buf, size);
//} AStatsEvent_release(statsEvent);
// return logEvent;
//// State with first uid in attribution chain as primary field - WakelockStateChanged }
//std::shared_ptr<LogEvent> buildPartialWakelockEvent(int uid, const std::string& tag, bool acquire) {
// std::vector<AttributionNodeInternal> chain; // Incorrect event - exclusive state has wrong type
// chain.push_back(AttributionNodeInternal()); std::unique_ptr<LogEvent> buildOverlayEventBadStateType(int uid, const std::string& packageName) {
// AttributionNodeInternal& attr = chain.back(); AStatsEvent* statsEvent = AStatsEvent_obtain();
// attr.set_uid(uid); AStatsEvent_setAtomId(statsEvent, util::OVERLAY_STATE_CHANGED);
// AStatsEvent_overwriteTimestamp(statsEvent, 1000);
// std::shared_ptr<LogEvent> event =
// std::make_shared<LogEvent>(util::WAKELOCK_STATE_CHANGED, 1000 /* timestamp */); AStatsEvent_writeInt32(statsEvent, uid);
// event->write(chain); AStatsEvent_writeString(statsEvent, packageName.c_str());
// event->write((int32_t)1); // PARTIAL_WAKE_LOCK AStatsEvent_writeInt32(statsEvent, true); // using_alert_window
// event->write(tag); AStatsEvent_writeString(statsEvent, "string"); // exclusive state: string instead of int
// event->write(acquire ? 1 : 0); AStatsEvent_build(statsEvent);
// event->init();
// return event; size_t size;
//} uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
//
//// State with multiple primary fields - OverlayStateChanged std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
//std::shared_ptr<LogEvent> buildOverlayEvent(int uid, const std::string& packageName, int state) { logEvent->parseBuffer(buf, size);
// std::shared_ptr<LogEvent> event = AStatsEvent_release(statsEvent);
// std::make_shared<LogEvent>(util::OVERLAY_STATE_CHANGED, 1000 /*timestamp*/); return logEvent;
// event->write((int32_t)uid); }
// event->write(packageName);
// event->write(true); // using_alert_window
// event->write((int32_t)state);
// event->init();
// return event;
//}
//
//// Incorrect event - missing fields
//std::shared_ptr<LogEvent> buildIncorrectOverlayEvent(int uid, const std::string& packageName, int state) {
// std::shared_ptr<LogEvent> event =
// std::make_shared<LogEvent>(util::OVERLAY_STATE_CHANGED, 1000 /*timestamp*/);
// event->write((int32_t)uid);
// event->write(packageName);
// event->write((int32_t)state);
// event->init();
// return event;
//}
//
//// Incorrect event - exclusive state has wrong type
//std::shared_ptr<LogEvent> buildOverlayEventBadStateType(int uid, const std::string& packageName) {
// std::shared_ptr<LogEvent> event =
// std::make_shared<LogEvent>(util::OVERLAY_STATE_CHANGED, 1000 /*timestamp*/);
// event->write((int32_t)uid);
// event->write(packageName);
// event->write(true);
// event->write("string"); // exclusive state: string instead of int
// event->init();
// return event;
//}
//
//std::shared_ptr<LogEvent> buildBleScanEvent(int uid, bool acquire, bool reset) {
// std::vector<AttributionNodeInternal> chain;
// chain.push_back(AttributionNodeInternal());
// AttributionNodeInternal& attr = chain.back();
// attr.set_uid(uid);
//
// std::shared_ptr<LogEvent> event =
// std::make_shared<LogEvent>(util::BLE_SCAN_STATE_CHANGED, 1000);
// event->write(chain);
// event->write(reset ? 2 : acquire ? 1 : 0); // PARTIAL_WAKE_LOCK
// event->write(0); // filtered
// event->write(0); // first match
// event->write(0); // opportunistic
// event->init();
// return event;
//}
// END: build event functions. // END: build event functions.
// START: get primary key functions // START: get primary key functions
@@ -293,302 +251,323 @@ TEST(StateTrackerTest, TestUnregisterListener) {
EXPECT_EQ(0, mgr.getStateTrackersCount()); EXPECT_EQ(0, mgr.getStateTrackersCount());
EXPECT_EQ(-1, mgr.getListenersCount(util::SCREEN_STATE_CHANGED)); EXPECT_EQ(-1, mgr.getListenersCount(util::SCREEN_STATE_CHANGED));
} }
// TODO(b/149590301): Update these tests to use new socket schema.
///** /**
// * Test a binary state atom with nested counting. * Test a binary state atom with nested counting.
// * *
// * To go from an "ON" state to an "OFF" state with nested counting, we must see * To go from an "ON" state to an "OFF" state with nested counting, we must see
// * an equal number of "OFF" events as "ON" events. * an equal number of "OFF" events as "ON" events.
// * For example, ACQUIRE, ACQUIRE, RELEASE will still be in the ACQUIRE state. * For example, ACQUIRE, ACQUIRE, RELEASE will still be in the ACQUIRE state.
// * ACQUIRE, ACQUIRE, RELEASE, RELEASE will be in the RELEASE state. * ACQUIRE, ACQUIRE, RELEASE, RELEASE will be in the RELEASE state.
// */ */
//TEST(StateTrackerTest, TestStateChangeNested) { TEST(StateTrackerTest, TestStateChangeNested) {
// sp<TestStateListener> listener = new TestStateListener(); sp<TestStateListener> listener = new TestStateListener();
// StateManager mgr; StateManager mgr;
// mgr.registerListener(util::WAKELOCK_STATE_CHANGED, listener); mgr.registerListener(util::WAKELOCK_STATE_CHANGED, listener);
//
// std::shared_ptr<LogEvent> event1 = std::vector<int> attributionUids1 = {1000};
// buildPartialWakelockEvent(1000 /* uid */, "tag", true /*acquire*/); std::vector<string> attributionTags1 = {"tag"};
// mgr.onLogEvent(*event1);
// EXPECT_EQ(1, listener->updates.size()); std::unique_ptr<LogEvent> event1 = CreateAcquireWakelockEvent(timestampNs, attributionUids1,
// EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value); attributionTags1, "wakelockName");
// EXPECT_EQ(1, listener->updates[0].mState); mgr.onLogEvent(*event1);
// listener->updates.clear(); EXPECT_EQ(1, listener->updates.size());
// EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value);
// std::shared_ptr<LogEvent> event2 = EXPECT_EQ(1, listener->updates[0].mState);
// buildPartialWakelockEvent(1000 /* uid */, "tag", true /*acquire*/); listener->updates.clear();
// mgr.onLogEvent(*event2);
// EXPECT_EQ(0, listener->updates.size()); std::unique_ptr<LogEvent> event2 = CreateAcquireWakelockEvent(
// timestampNs + 1000, attributionUids1, attributionTags1, "wakelockName");
// std::shared_ptr<LogEvent> event3 = mgr.onLogEvent(*event2);
// buildPartialWakelockEvent(1000 /* uid */, "tag", false /*release*/); EXPECT_EQ(0, listener->updates.size());
// mgr.onLogEvent(*event3);
// EXPECT_EQ(0, listener->updates.size()); std::unique_ptr<LogEvent> event3 = CreateReleaseWakelockEvent(
// timestampNs + 2000, attributionUids1, attributionTags1, "wakelockName");
// std::shared_ptr<LogEvent> event4 = mgr.onLogEvent(*event3);
// buildPartialWakelockEvent(1000 /* uid */, "tag", false /*release*/); EXPECT_EQ(0, listener->updates.size());
// mgr.onLogEvent(*event4);
// EXPECT_EQ(1, listener->updates.size()); std::unique_ptr<LogEvent> event4 = CreateReleaseWakelockEvent(
// EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value); timestampNs + 3000, attributionUids1, attributionTags1, "wakelockName");
// EXPECT_EQ(0, listener->updates[0].mState); mgr.onLogEvent(*event4);
//} EXPECT_EQ(1, listener->updates.size());
// EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value);
///** EXPECT_EQ(0, listener->updates[0].mState);
// * Test a state atom with a reset state. }
// *
// * If the reset state value is seen, every state in the map is set to the default /**
// * state and every listener is notified. * Test a state atom with a reset state.
// */ *
//TEST(StateTrackerTest, TestStateChangeReset) { * If the reset state value is seen, every state in the map is set to the default
// sp<TestStateListener> listener = new TestStateListener(); * state and every listener is notified.
// StateManager mgr; */
// mgr.registerListener(util::BLE_SCAN_STATE_CHANGED, listener); TEST(StateTrackerTest, TestStateChangeReset) {
// sp<TestStateListener> listener = new TestStateListener();
// std::shared_ptr<LogEvent> event1 = StateManager mgr;
// buildBleScanEvent(1000 /* uid */, true /*acquire*/, false /*reset*/); mgr.registerListener(util::BLE_SCAN_STATE_CHANGED, listener);
// mgr.onLogEvent(*event1);
// EXPECT_EQ(1, listener->updates.size()); std::vector<int> attributionUids1 = {1000};
// EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value); std::vector<string> attributionTags1 = {"tag1"};
// EXPECT_EQ(BleScanStateChanged::ON, listener->updates[0].mState); std::vector<int> attributionUids2 = {2000};
// listener->updates.clear();
// std::unique_ptr<LogEvent> event1 =
// std::shared_ptr<LogEvent> event2 = CreateBleScanStateChangedEvent(timestampNs, attributionUids1, attributionTags1,
// buildBleScanEvent(2000 /* uid */, true /*acquire*/, false /*reset*/); BleScanStateChanged::ON, false, false, false);
// mgr.onLogEvent(*event2); mgr.onLogEvent(*event1);
// EXPECT_EQ(1, listener->updates.size()); EXPECT_EQ(1, listener->updates.size());
// EXPECT_EQ(2000, listener->updates[0].mKey.getValues()[0].mValue.int_value); EXPECT_EQ(1000, listener->updates[0].mKey.getValues()[0].mValue.int_value);
// EXPECT_EQ(BleScanStateChanged::ON, listener->updates[0].mState); EXPECT_EQ(BleScanStateChanged::ON, listener->updates[0].mState);
// listener->updates.clear(); listener->updates.clear();
//
// std::shared_ptr<LogEvent> event3 = std::unique_ptr<LogEvent> event2 =
// buildBleScanEvent(2000 /* uid */, false /*acquire*/, true /*reset*/); CreateBleScanStateChangedEvent(timestampNs + 1000, attributionUids2, attributionTags1,
// mgr.onLogEvent(*event3); BleScanStateChanged::ON, false, false, false);
// EXPECT_EQ(2, listener->updates.size()); mgr.onLogEvent(*event2);
// EXPECT_EQ(BleScanStateChanged::OFF, listener->updates[0].mState); EXPECT_EQ(1, listener->updates.size());
// EXPECT_EQ(BleScanStateChanged::OFF, listener->updates[1].mState); EXPECT_EQ(2000, listener->updates[0].mKey.getValues()[0].mValue.int_value);
//} EXPECT_EQ(BleScanStateChanged::ON, listener->updates[0].mState);
// listener->updates.clear();
///**
// * Test StateManager's onLogEvent and StateListener's onStateChanged correctly std::unique_ptr<LogEvent> event3 =
// * updates listener for states without primary keys. CreateBleScanStateChangedEvent(timestampNs + 2000, attributionUids2, attributionTags1,
// */ BleScanStateChanged::RESET, false, false, false);
//TEST(StateTrackerTest, TestStateChangeNoPrimaryFields) { mgr.onLogEvent(*event3);
// sp<TestStateListener> listener1 = new TestStateListener(); EXPECT_EQ(2, listener->updates.size());
// StateManager mgr; EXPECT_EQ(BleScanStateChanged::OFF, listener->updates[0].mState);
// mgr.registerListener(util::SCREEN_STATE_CHANGED, listener1); EXPECT_EQ(BleScanStateChanged::OFF, listener->updates[1].mState);
// }
// // log event
// std::shared_ptr<LogEvent> event = /**
// buildScreenEvent(android::view::DisplayStateEnum::DISPLAY_STATE_ON); * Test StateManager's onLogEvent and StateListener's onStateChanged correctly
// mgr.onLogEvent(*event); * updates listener for states without primary keys.
// */
// // check listener was updated TEST(StateTrackerTest, TestStateChangeNoPrimaryFields) {
// EXPECT_EQ(1, listener1->updates.size()); sp<TestStateListener> listener1 = new TestStateListener();
// EXPECT_EQ(DEFAULT_DIMENSION_KEY, listener1->updates[0].mKey); StateManager mgr;
// EXPECT_EQ(2, listener1->updates[0].mState); mgr.registerListener(util::SCREEN_STATE_CHANGED, listener1);
//
// // check StateTracker was updated by querying for state // log event
// HashableDimensionKey queryKey = DEFAULT_DIMENSION_KEY; std::unique_ptr<LogEvent> event = CreateScreenStateChangedEvent(
// EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON, timestampNs, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
// getStateInt(mgr, util::SCREEN_STATE_CHANGED, queryKey)); mgr.onLogEvent(*event);
//}
// // check listener was updated
///** EXPECT_EQ(1, listener1->updates.size());
// * Test StateManager's onLogEvent and StateListener's onStateChanged correctly EXPECT_EQ(DEFAULT_DIMENSION_KEY, listener1->updates[0].mKey);
// * updates listener for states with one primary key. EXPECT_EQ(2, listener1->updates[0].mState);
// */
//TEST(StateTrackerTest, TestStateChangeOnePrimaryField) { // check StateTracker was updated by querying for state
// sp<TestStateListener> listener1 = new TestStateListener(); HashableDimensionKey queryKey = DEFAULT_DIMENSION_KEY;
// StateManager mgr; EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON,
// mgr.registerListener(util::UID_PROCESS_STATE_CHANGED, listener1); getStateInt(mgr, util::SCREEN_STATE_CHANGED, queryKey));
// }
// // log event
// std::shared_ptr<LogEvent> event = /**
// buildUidProcessEvent(1000 /* uid */, android::app::ProcessStateEnum::PROCESS_STATE_TOP); * Test StateManager's onLogEvent and StateListener's onStateChanged correctly
// mgr.onLogEvent(*event); * updates listener for states with one primary key.
// */
// // check listener was updated TEST(StateTrackerTest, TestStateChangeOnePrimaryField) {
// EXPECT_EQ(1, listener1->updates.size()); sp<TestStateListener> listener1 = new TestStateListener();
// EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value); StateManager mgr;
// EXPECT_EQ(1002, listener1->updates[0].mState); mgr.registerListener(util::UID_PROCESS_STATE_CHANGED, listener1);
//
// // check StateTracker was updated by querying for state // log event
// HashableDimensionKey queryKey; std::unique_ptr<LogEvent> event = CreateUidProcessStateChangedEvent(
// getUidProcessKey(1000 /* uid */, &queryKey); timestampNs, 1000 /*uid*/, android::app::ProcessStateEnum::PROCESS_STATE_TOP);
// EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_TOP, mgr.onLogEvent(*event);
// getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED, queryKey));
//} // check listener was updated
// EXPECT_EQ(1, listener1->updates.size());
//TEST(StateTrackerTest, TestStateChangePrimaryFieldAttrChain) { EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value);
// sp<TestStateListener> listener1 = new TestStateListener(); EXPECT_EQ(1002, listener1->updates[0].mState);
// StateManager mgr;
// mgr.registerListener(util::WAKELOCK_STATE_CHANGED, listener1); // check StateTracker was updated by querying for state
// HashableDimensionKey queryKey;
// // Log event. getUidProcessKey(1000 /* uid */, &queryKey);
// std::shared_ptr<LogEvent> event = EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_TOP,
// buildPartialWakelockEvent(1001 /* uid */, "tag1", true /* acquire */); getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED, queryKey));
// mgr.onLogEvent(*event); }
//
// EXPECT_EQ(1, mgr.getStateTrackersCount()); TEST(StateTrackerTest, TestStateChangePrimaryFieldAttrChain) {
// EXPECT_EQ(1, mgr.getListenersCount(util::WAKELOCK_STATE_CHANGED)); sp<TestStateListener> listener1 = new TestStateListener();
// StateManager mgr;
// // Check listener was updated. mgr.registerListener(util::WAKELOCK_STATE_CHANGED, listener1);
// EXPECT_EQ(1, listener1->updates.size());
// EXPECT_EQ(3, listener1->updates[0].mKey.getValues().size()); // Log event.
// EXPECT_EQ(1001, listener1->updates[0].mKey.getValues()[0].mValue.int_value); std::vector<int> attributionUids = {1001};
// EXPECT_EQ(1, listener1->updates[0].mKey.getValues()[1].mValue.int_value); std::vector<string> attributionTags = {"tag1"};
// EXPECT_EQ("tag1", listener1->updates[0].mKey.getValues()[2].mValue.str_value);
// EXPECT_EQ(WakelockStateChanged::ACQUIRE, listener1->updates[0].mState); std::unique_ptr<LogEvent> event = CreateAcquireWakelockEvent(timestampNs, attributionUids,
// attributionTags, "wakelockName");
// // Check StateTracker was updated by querying for state. mgr.onLogEvent(*event);
// HashableDimensionKey queryKey; EXPECT_EQ(1, mgr.getStateTrackersCount());
// getPartialWakelockKey(1001 /* uid */, "tag1", &queryKey); EXPECT_EQ(1, mgr.getListenersCount(util::WAKELOCK_STATE_CHANGED));
// EXPECT_EQ(WakelockStateChanged::ACQUIRE,
// getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey)); // Check listener was updated.
// EXPECT_EQ(1, listener1->updates.size());
// // No state stored for this query key. EXPECT_EQ(3, listener1->updates[0].mKey.getValues().size());
// HashableDimensionKey queryKey2; EXPECT_EQ(1001, listener1->updates[0].mKey.getValues()[0].mValue.int_value);
// getPartialWakelockKey(1002 /* uid */, "tag1", &queryKey2); EXPECT_EQ(1, listener1->updates[0].mKey.getValues()[1].mValue.int_value);
// EXPECT_EQ(WakelockStateChanged::RELEASE, EXPECT_EQ("wakelockName", listener1->updates[0].mKey.getValues()[2].mValue.str_value);
// getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey2)); EXPECT_EQ(WakelockStateChanged::ACQUIRE, listener1->updates[0].mState);
//
// // Partial query fails. // Check StateTracker was updated by querying for state.
// HashableDimensionKey queryKey3; HashableDimensionKey queryKey;
// getPartialWakelockKey(1001 /* uid */, &queryKey3); getPartialWakelockKey(1001 /* uid */, "wakelockName", &queryKey);
// EXPECT_EQ(WakelockStateChanged::RELEASE, EXPECT_EQ(WakelockStateChanged::ACQUIRE,
// getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey3)); getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey));
//}
// // No state stored for this query key.
///** HashableDimensionKey queryKey2;
// * Test StateManager's onLogEvent and StateListener's onStateChanged correctly getPartialWakelockKey(1002 /* uid */, "tag1", &queryKey2);
// * updates listener for states with multiple primary keys. EXPECT_EQ(WakelockStateChanged::RELEASE,
// */ getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey2));
//TEST(StateTrackerTest, TestStateChangeMultiplePrimaryFields) {
// sp<TestStateListener> listener1 = new TestStateListener(); // Partial query fails.
// StateManager mgr; HashableDimensionKey queryKey3;
// mgr.registerListener(util::OVERLAY_STATE_CHANGED, listener1); getPartialWakelockKey(1001 /* uid */, &queryKey3);
// EXPECT_EQ(WakelockStateChanged::RELEASE,
// // log event getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey3));
// std::shared_ptr<LogEvent> event = }
// buildOverlayEvent(1000 /* uid */, "package1", 1); // state: ENTERED
// mgr.onLogEvent(*event); /**
// * Test StateManager's onLogEvent and StateListener's onStateChanged correctly
// // check listener was updated * updates listener for states with multiple primary keys.
// EXPECT_EQ(1, listener1->updates.size()); */
// EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value); TEST(StateTrackerTest, TestStateChangeMultiplePrimaryFields) {
// EXPECT_EQ(1, listener1->updates[0].mState); sp<TestStateListener> listener1 = new TestStateListener();
// StateManager mgr;
// // check StateTracker was updated by querying for state mgr.registerListener(util::OVERLAY_STATE_CHANGED, listener1);
// HashableDimensionKey queryKey;
// getOverlayKey(1000 /* uid */, "package1", &queryKey); // log event
// EXPECT_EQ(OverlayStateChanged::ENTERED, std::unique_ptr<LogEvent> event = CreateOverlayStateChangedEvent(
// getStateInt(mgr, util::OVERLAY_STATE_CHANGED, queryKey)); timestampNs, 1000 /* uid */, "package1", true /*using_alert_window*/,
//} OverlayStateChanged::ENTERED);
// mgr.onLogEvent(*event);
///**
// * Test StateManager's onLogEvent and StateListener's onStateChanged // check listener was updated
// * when there is an error extracting state from log event. Listener is not EXPECT_EQ(1, listener1->updates.size());
// * updated of state change. EXPECT_EQ(1000, listener1->updates[0].mKey.getValues()[0].mValue.int_value);
// */ EXPECT_EQ(1, listener1->updates[0].mState);
//TEST(StateTrackerTest, TestStateChangeEventError) {
// sp<TestStateListener> listener1 = new TestStateListener(); // check StateTracker was updated by querying for state
// StateManager mgr; HashableDimensionKey queryKey;
// mgr.registerListener(util::OVERLAY_STATE_CHANGED, listener1); getOverlayKey(1000 /* uid */, "package1", &queryKey);
// EXPECT_EQ(OverlayStateChanged::ENTERED,
// // log event getStateInt(mgr, util::OVERLAY_STATE_CHANGED, queryKey));
// std::shared_ptr<LogEvent> event1 = }
// buildIncorrectOverlayEvent(1000 /* uid */, "package1", 1 /* state */);
// std::shared_ptr<LogEvent> event2 = buildOverlayEventBadStateType(1001 /* uid */, "package2"); /**
// * Test StateManager's onLogEvent and StateListener's onStateChanged
// // check listener was updated * when there is an error extracting state from log event. Listener is not
// mgr.onLogEvent(*event1); * updated of state change.
// EXPECT_EQ(0, listener1->updates.size()); */
// mgr.onLogEvent(*event2); TEST(StateTrackerTest, TestStateChangeEventError) {
// EXPECT_EQ(0, listener1->updates.size()); sp<TestStateListener> listener1 = new TestStateListener();
//} StateManager mgr;
// mgr.registerListener(util::OVERLAY_STATE_CHANGED, listener1);
//TEST(StateTrackerTest, TestStateQuery) {
// sp<TestStateListener> listener1 = new TestStateListener(); // log event
// sp<TestStateListener> listener2 = new TestStateListener(); std::shared_ptr<LogEvent> event1 =
// sp<TestStateListener> listener3 = new TestStateListener(); buildIncorrectOverlayEvent(1000 /* uid */, "package1", 1 /* state */);
// sp<TestStateListener> listener4 = new TestStateListener(); std::shared_ptr<LogEvent> event2 = buildOverlayEventBadStateType(1001 /* uid */, "package2");
// StateManager mgr;
// mgr.registerListener(util::SCREEN_STATE_CHANGED, listener1); // check listener was updated
// mgr.registerListener(util::UID_PROCESS_STATE_CHANGED, listener2); mgr.onLogEvent(*event1);
// mgr.registerListener(util::OVERLAY_STATE_CHANGED, listener3); EXPECT_EQ(0, listener1->updates.size());
// mgr.registerListener(util::WAKELOCK_STATE_CHANGED, listener4); mgr.onLogEvent(*event2);
// EXPECT_EQ(0, listener1->updates.size());
// std::shared_ptr<LogEvent> event1 = buildUidProcessEvent( }
// 1000,
// android::app::ProcessStateEnum::PROCESS_STATE_TOP); // state value: 1002 TEST(StateTrackerTest, TestStateQuery) {
// std::shared_ptr<LogEvent> event2 = buildUidProcessEvent( sp<TestStateListener> listener1 = new TestStateListener();
// 1001, sp<TestStateListener> listener2 = new TestStateListener();
// android::app::ProcessStateEnum::PROCESS_STATE_FOREGROUND_SERVICE); // state value: sp<TestStateListener> listener3 = new TestStateListener();
// // 1003 sp<TestStateListener> listener4 = new TestStateListener();
// std::shared_ptr<LogEvent> event3 = buildUidProcessEvent( StateManager mgr;
// 1002, mgr.registerListener(util::SCREEN_STATE_CHANGED, listener1);
// android::app::ProcessStateEnum::PROCESS_STATE_PERSISTENT); // state value: 1000 mgr.registerListener(util::UID_PROCESS_STATE_CHANGED, listener2);
// std::shared_ptr<LogEvent> event4 = buildUidProcessEvent( mgr.registerListener(util::OVERLAY_STATE_CHANGED, listener3);
// 1001, mgr.registerListener(util::WAKELOCK_STATE_CHANGED, listener4);
// android::app::ProcessStateEnum::PROCESS_STATE_TOP); // state value: 1002
// std::shared_ptr<LogEvent> event5 = std::unique_ptr<LogEvent> event1 = CreateUidProcessStateChangedEvent(
// buildScreenEvent(android::view::DisplayStateEnum::DISPLAY_STATE_ON); timestampNs, 1000 /*uid*/,
// std::shared_ptr<LogEvent> event6 = android::app::ProcessStateEnum::PROCESS_STATE_TOP); // state value: 1002
// buildOverlayEvent(1000, "package1", OverlayStateChanged::ENTERED); std::unique_ptr<LogEvent> event2 = CreateUidProcessStateChangedEvent(
// std::shared_ptr<LogEvent> event7 = timestampNs + 1000, 1001 /*uid*/,
// buildOverlayEvent(1000, "package2", OverlayStateChanged::EXITED); android::app::ProcessStateEnum::PROCESS_STATE_FOREGROUND_SERVICE); // state value:
// std::shared_ptr<LogEvent> event8 = buildPartialWakelockEvent(1005, "tag1", true); // 1003
// std::shared_ptr<LogEvent> event9 = buildPartialWakelockEvent(1005, "tag2", false); std::unique_ptr<LogEvent> event3 = CreateUidProcessStateChangedEvent(
// timestampNs + 2000, 1002 /*uid*/,
// mgr.onLogEvent(*event1); android::app::ProcessStateEnum::PROCESS_STATE_PERSISTENT); // state value: 1000
// mgr.onLogEvent(*event2); std::unique_ptr<LogEvent> event4 = CreateUidProcessStateChangedEvent(
// mgr.onLogEvent(*event3); timestampNs + 3000, 1001 /*uid*/,
// mgr.onLogEvent(*event5); android::app::ProcessStateEnum::PROCESS_STATE_TOP); // state value: 1002
// mgr.onLogEvent(*event5); std::unique_ptr<LogEvent> event5 = CreateScreenStateChangedEvent(
// mgr.onLogEvent(*event6); timestampNs + 4000, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
// mgr.onLogEvent(*event7); std::unique_ptr<LogEvent> event6 = CreateOverlayStateChangedEvent(
// mgr.onLogEvent(*event8); timestampNs + 5000, 1000 /*uid*/, "package1", true /*using_alert_window*/,
// mgr.onLogEvent(*event9); OverlayStateChanged::ENTERED);
// std::unique_ptr<LogEvent> event7 = CreateOverlayStateChangedEvent(
// // Query for UidProcessState of uid 1001 timestampNs + 6000, 1000 /*uid*/, "package2", true /*using_alert_window*/,
// HashableDimensionKey queryKey1; OverlayStateChanged::EXITED);
// getUidProcessKey(1001, &queryKey1);
// EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_FOREGROUND_SERVICE, std::vector<int> attributionUids = {1005};
// getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED, queryKey1)); std::vector<string> attributionTags = {"tag"};
//
// // Query for UidProcessState of uid 1004 - not in state map std::unique_ptr<LogEvent> event8 = CreateAcquireWakelockEvent(
// HashableDimensionKey queryKey2; timestampNs + 7000, attributionUids, attributionTags, "wakelock1");
// getUidProcessKey(1004, &queryKey2); std::unique_ptr<LogEvent> event9 = CreateReleaseWakelockEvent(
// EXPECT_EQ(-1, getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED, timestampNs + 8000, attributionUids, attributionTags, "wakelock2");
// queryKey2)); // default state
// mgr.onLogEvent(*event1);
// // Query for UidProcessState of uid 1001 - after change in state mgr.onLogEvent(*event2);
// mgr.onLogEvent(*event4); mgr.onLogEvent(*event3);
// EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_TOP, mgr.onLogEvent(*event5);
// getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED, queryKey1)); mgr.onLogEvent(*event5);
// mgr.onLogEvent(*event6);
// // Query for ScreenState mgr.onLogEvent(*event7);
// EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON, mgr.onLogEvent(*event8);
// getStateInt(mgr, util::SCREEN_STATE_CHANGED, DEFAULT_DIMENSION_KEY)); mgr.onLogEvent(*event9);
//
// // Query for OverlayState of uid 1000, package name "package2" // Query for UidProcessState of uid 1001
// HashableDimensionKey queryKey3; HashableDimensionKey queryKey1;
// getOverlayKey(1000, "package2", &queryKey3); getUidProcessKey(1001, &queryKey1);
// EXPECT_EQ(OverlayStateChanged::EXITED, EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_FOREGROUND_SERVICE,
// getStateInt(mgr, util::OVERLAY_STATE_CHANGED, queryKey3)); getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED, queryKey1));
//
// // Query for WakelockState of uid 1005, tag 2 // Query for UidProcessState of uid 1004 - not in state map
// HashableDimensionKey queryKey4; HashableDimensionKey queryKey2;
// getPartialWakelockKey(1005, "tag2", &queryKey4); getUidProcessKey(1004, &queryKey2);
// EXPECT_EQ(WakelockStateChanged::RELEASE, EXPECT_EQ(-1, getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED,
// getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey4)); queryKey2)); // default state
//
// // Query for WakelockState of uid 1005, tag 1 // Query for UidProcessState of uid 1001 - after change in state
// HashableDimensionKey queryKey5; mgr.onLogEvent(*event4);
// getPartialWakelockKey(1005, "tag1", &queryKey5); EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_TOP,
// EXPECT_EQ(WakelockStateChanged::ACQUIRE, getStateInt(mgr, util::UID_PROCESS_STATE_CHANGED, queryKey1));
// getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey5));
//} // Query for ScreenState
EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON,
getStateInt(mgr, util::SCREEN_STATE_CHANGED, DEFAULT_DIMENSION_KEY));
// Query for OverlayState of uid 1000, package name "package2"
HashableDimensionKey queryKey3;
getOverlayKey(1000, "package2", &queryKey3);
EXPECT_EQ(OverlayStateChanged::EXITED,
getStateInt(mgr, util::OVERLAY_STATE_CHANGED, queryKey3));
// Query for WakelockState of uid 1005, tag 2
HashableDimensionKey queryKey4;
getPartialWakelockKey(1005, "wakelock2", &queryKey4);
EXPECT_EQ(WakelockStateChanged::RELEASE,
getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey4));
// Query for WakelockState of uid 1005, tag 1
HashableDimensionKey queryKey5;
getPartialWakelockKey(1005, "wakelock1", &queryKey5);
EXPECT_EQ(WakelockStateChanged::ACQUIRE,
getStateInt(mgr, util::WAKELOCK_STATE_CHANGED, queryKey5));
}
} // namespace statsd } // namespace statsd
} // namespace os } // namespace os

127
cmds/statsd/tests/statsd_test_util.cpp
View File

@@ -600,32 +600,51 @@ std::unique_ptr<LogEvent> CreateScreenBrightnessChangedEvent(uint64_t timestampN
return logEvent; return logEvent;
} }
//std::unique_ptr<LogEvent> CreateScheduledJobStateChangedEvent( std::unique_ptr<LogEvent> CreateScheduledJobStateChangedEvent(
// const std::vector<AttributionNodeInternal>& attributions, const string& jobName, const vector<int>& attributionUids, const vector<string>& attributionTags,
// const ScheduledJobStateChanged::State state, uint64_t timestampNs) { const string& jobName, const ScheduledJobStateChanged::State state, uint64_t timestampNs) {
// auto event = std::make_unique<LogEvent>(util::SCHEDULED_JOB_STATE_CHANGED, timestampNs); AStatsEvent* statsEvent = AStatsEvent_obtain();
// event->write(attributions); AStatsEvent_setAtomId(statsEvent, util::SCHEDULED_JOB_STATE_CHANGED);
// event->write(jobName); AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
// event->write(state);
// event->init(); vector<const char*> cTags(attributionTags.size());
// return event; for (int i = 0; i < cTags.size(); i++) {
//} cTags[i] = attributionTags[i].c_str();
// }
//std::unique_ptr<LogEvent> CreateStartScheduledJobEvent(
// const std::vector<AttributionNodeInternal>& attributions, AStatsEvent_writeAttributionChain(statsEvent,
// const string& name, uint64_t timestampNs) { reinterpret_cast<const uint32_t*>(attributionUids.data()),
// return CreateScheduledJobStateChangedEvent( cTags.data(), attributionUids.size());
// attributions, name, ScheduledJobStateChanged::STARTED, timestampNs); AStatsEvent_writeString(statsEvent, jobName.c_str());
//} AStatsEvent_writeInt32(statsEvent, state);
// AStatsEvent_build(statsEvent);
//// Create log event when scheduled job finishes.
//std::unique_ptr<LogEvent> CreateFinishScheduledJobEvent( size_t size;
// const std::vector<AttributionNodeInternal>& attributions, uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
// const string& name, uint64_t timestampNs) {
// return CreateScheduledJobStateChangedEvent( std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
// attributions, name, ScheduledJobStateChanged::FINISHED, timestampNs); logEvent->parseBuffer(buf, size);
//} AStatsEvent_release(statsEvent);
// return logEvent;
}
std::unique_ptr<LogEvent> CreateStartScheduledJobEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& jobName) {
return CreateScheduledJobStateChangedEvent(attributionUids, attributionTags, jobName,
ScheduledJobStateChanged::STARTED, timestampNs);
}
// Create log event when scheduled job finishes.
std::unique_ptr<LogEvent> CreateFinishScheduledJobEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& jobName) {
return CreateScheduledJobStateChangedEvent(attributionUids, attributionTags, jobName,
ScheduledJobStateChanged::FINISHED, timestampNs);
}
std::unique_ptr<LogEvent> CreateWakelockStateChangedEvent(uint64_t timestampNs, std::unique_ptr<LogEvent> CreateWakelockStateChangedEvent(uint64_t timestampNs,
const vector<int>& attributionUids, const vector<int>& attributionUids,
const vector<string>& attributionTags, const vector<string>& attributionTags,
@@ -833,6 +852,62 @@ std::unique_ptr<LogEvent> CreateUidProcessStateChangedEvent(
return logEvent; return logEvent;
} }
std::unique_ptr<LogEvent> CreateBleScanStateChangedEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const BleScanStateChanged::State state,
const bool filtered, const bool firstMatch,
const bool opportunistic) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, util::BLE_SCAN_STATE_CHANGED);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
vector<const char*> cTags(attributionTags.size());
for (int i = 0; i < cTags.size(); i++) {
cTags[i] = attributionTags[i].c_str();
}
AStatsEvent_writeAttributionChain(statsEvent,
reinterpret_cast<const uint32_t*>(attributionUids.data()),
cTags.data(), attributionUids.size());
AStatsEvent_writeInt32(statsEvent, state);
AStatsEvent_writeInt32(statsEvent, filtered); // filtered
AStatsEvent_writeInt32(statsEvent, firstMatch); // first match
AStatsEvent_writeInt32(statsEvent, opportunistic); // opportunistic
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
std::unique_ptr<LogEvent> CreateOverlayStateChangedEvent(int64_t timestampNs, const int32_t uid,
const string& packageName,
const bool usingAlertWindow,
const OverlayStateChanged::State state) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, util::OVERLAY_STATE_CHANGED);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
AStatsEvent_writeInt32(statsEvent, uid);
AStatsEvent_writeString(statsEvent, packageName.c_str());
AStatsEvent_writeInt32(statsEvent, usingAlertWindow);
AStatsEvent_writeInt32(statsEvent, state);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
sp<StatsLogProcessor> CreateStatsLogProcessor(const int64_t timeBaseNs, const int64_t currentTimeNs, sp<StatsLogProcessor> CreateStatsLogProcessor(const int64_t timeBaseNs, const int64_t currentTimeNs,
const StatsdConfig& config, const ConfigKey& key, const StatsdConfig& config, const ConfigKey& key,
const shared_ptr<IPullAtomCallback>& puller, const shared_ptr<IPullAtomCallback>& puller,

26
cmds/statsd/tests/statsd_test_util.h
View File

@@ -195,14 +195,16 @@ std::unique_ptr<LogEvent> CreateScreenStateChangedEvent(
std::unique_ptr<LogEvent> CreateScreenBrightnessChangedEvent(uint64_t timestampNs, int level); std::unique_ptr<LogEvent> CreateScreenBrightnessChangedEvent(uint64_t timestampNs, int level);
// Create log event when scheduled job starts. // Create log event when scheduled job starts.
std::unique_ptr<LogEvent> CreateStartScheduledJobEvent( std::unique_ptr<LogEvent> CreateStartScheduledJobEvent(uint64_t timestampNs,
const std::vector<AttributionNodeInternal>& attributions, const vector<int>& attributionUids,
const string& name, uint64_t timestampNs); const vector<string>& attributionTags,
const string& jobName);
// Create log event when scheduled job finishes. // Create log event when scheduled job finishes.
std::unique_ptr<LogEvent> CreateFinishScheduledJobEvent( std::unique_ptr<LogEvent> CreateFinishScheduledJobEvent(uint64_t timestampNs,
const std::vector<AttributionNodeInternal>& attributions, const vector<int>& attributionUids,
const string& name, uint64_t timestampNs); const vector<string>& attributionTags,
const string& jobName);
// Create log event when battery saver starts. // Create log event when battery saver starts.
std::unique_ptr<LogEvent> CreateBatterySaverOnEvent(uint64_t timestampNs); std::unique_ptr<LogEvent> CreateBatterySaverOnEvent(uint64_t timestampNs);
@@ -247,6 +249,18 @@ std::unique_ptr<LogEvent> CreateIsolatedUidChangedEvent(uint64_t timestampNs, in
std::unique_ptr<LogEvent> CreateUidProcessStateChangedEvent( std::unique_ptr<LogEvent> CreateUidProcessStateChangedEvent(
uint64_t timestampNs, int uid, const android::app::ProcessStateEnum state); uint64_t timestampNs, int uid, const android::app::ProcessStateEnum state);
std::unique_ptr<LogEvent> CreateBleScanStateChangedEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const BleScanStateChanged::State state,
const bool filtered, const bool firstMatch,
const bool opportunistic);
std::unique_ptr<LogEvent> CreateOverlayStateChangedEvent(int64_t timestampNs, const int32_t uid,
const string& packageName,
const bool usingAlertWindow,
const OverlayStateChanged::State state);
// Helper function to create an AttributionNodeInternal proto. // Helper function to create an AttributionNodeInternal proto.
AttributionNodeInternal CreateAttribution(const int& uid, const string& tag); AttributionNodeInternal CreateAttribution(const int& uid, const string& tag);