drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
android_frameworks_base/cmds/statsd/tests/LogEntryMatcher_test.cpp
Yao Chen d50f2ae487 rename neq_all_string to neq_any_string in statsd_config 
Bug: 73897465
Test: statsd_test
Change-Id: I1d020de873fc26fbb502f0b3487b85fdb3896753
2018-03-23 11:10:13 -07:00

755 lines
29 KiB
C++
Raw Blame History

// Copyright (C) 2017 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 "frameworks/base/cmds/statsd/src/statsd_config.pb.h"
#include "matchers/matcher_util.h"
#include "stats_log_util.h"
#include "stats_util.h"
#include <gtest/gtest.h>
#include <log/log_event_list.h>
#include <log/log_read.h>
#include <log/logprint.h>
#include <stdio.h>
using namespace android::os::statsd;
using std::unordered_map;
using std::vector;
const int32_t TAG_ID = 123;
const int FIELD_ID_1 = 1;
const int FIELD_ID_2 = 2;
const int FIELD_ID_3 = 2;
const int ATTRIBUTION_UID_FIELD_ID = 1;
const int ATTRIBUTION_TAG_FIELD_ID = 2;
#ifdef __ANDROID__
TEST(AtomMatcherTest, TestSimpleMatcher) {
UidMap uidMap;
// Set up the matcher
AtomMatcher matcher;
auto simpleMatcher = matcher.mutable_simple_atom_matcher();
simpleMatcher->set_atom_id(TAG_ID);
LogEvent event(TAG_ID, 0);
EXPECT_TRUE(event.write(11));
event.init();
// Test
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
// Wrong tag id.
simpleMatcher->set_atom_id(TAG_ID + 1);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
}
TEST(AtomMatcherTest, TestAttributionMatcher) {
UidMap uidMap;
AttributionNodeInternal attribution_node1;
attribution_node1.set_uid(1111);
attribution_node1.set_tag("location1");
AttributionNodeInternal attribution_node2;
attribution_node2.set_uid(2222);
attribution_node2.set_tag("location2");
AttributionNodeInternal attribution_node3;
attribution_node3.set_uid(3333);
attribution_node3.set_tag("location3");
std::vector<AttributionNodeInternal> attribution_nodes = {attribution_node1, attribution_node2,
attribution_node3};
// Set up the event
LogEvent event(TAG_ID, 0);
event.write(attribution_nodes);
event.write("some value");
// Convert to a LogEvent
event.init();
// Set up the matcher
AtomMatcher matcher;
auto simpleMatcher = matcher.mutable_simple_atom_matcher();
simpleMatcher->set_atom_id(TAG_ID);
// Match first node.
auto attributionMatcher = simpleMatcher->add_field_value_matcher();
attributionMatcher->set_field(FIELD_ID_1);
attributionMatcher->set_position(Position::FIRST);
attributionMatcher->mutable_matches_tuple()->add_field_value_matcher()->set_field(
ATTRIBUTION_TAG_FIELD_ID);
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)->set_eq_string("tag");
auto fieldMatcher = simpleMatcher->add_field_value_matcher();
fieldMatcher->set_field(FIELD_ID_2);
fieldMatcher->set_eq_string("some value");
// Tag not matched.
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("location3");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("location1");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
// Match last node.
attributionMatcher->set_position(Position::LAST);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("location3");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
// Match any node.
attributionMatcher->set_position(Position::ANY);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("location1");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("location2");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("location3");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("location4");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
// Attribution match but primitive field not match.
attributionMatcher->set_position(Position::ANY);
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("location2");
fieldMatcher->set_eq_string("wrong value");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
fieldMatcher->set_eq_string("some value");
// Uid match.
attributionMatcher->set_position(Position::ANY);
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)->set_field(
ATTRIBUTION_UID_FIELD_ID);
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)->set_eq_string("pkg0");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
uidMap.updateMap({1111, 1111, 2222, 3333, 3333} /* uid list */,
{1, 1, 2, 1, 2} /* version list */,
{android::String16("pkg0"), android::String16("pkg1"),
android::String16("pkg1"), android::String16("Pkg2"),
android::String16("PkG3")} /* package name list */);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg3");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg2");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg1");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg0");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->set_position(Position::FIRST);
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg0");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg3");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg2");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg1");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->set_position(Position::LAST);
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg0");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg3");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg2");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg1");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
// Uid + tag.
attributionMatcher->set_position(Position::ANY);
attributionMatcher->mutable_matches_tuple()->add_field_value_matcher()->set_field(
ATTRIBUTION_TAG_FIELD_ID);
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg0");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location1");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg1");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location1");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg1");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location2");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg2");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location3");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg3");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location3");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg3");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location1");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->set_position(Position::FIRST);
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg0");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location1");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg1");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location1");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg1");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location2");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg2");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location3");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg3");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location3");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg3");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location1");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->set_position(Position::LAST);
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg0");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location1");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg1");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location1");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg1");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location2");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg2");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location3");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg3");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location3");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(0)
->set_eq_string("pkg3");
attributionMatcher->mutable_matches_tuple()->mutable_field_value_matcher(1)
->set_eq_string("location1");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
}
TEST(AtomMatcherTest, TestNeqAnyStringMatcher) {
UidMap uidMap;
uidMap.updateMap(
{1111, 1111, 2222, 3333, 3333} /* uid list */, {1, 1, 2, 1, 2} /* version list */,
{android::String16("pkg0"), android::String16("pkg1"), android::String16("pkg1"),
android::String16("Pkg2"), android::String16("PkG3")} /* package name list */);
AttributionNodeInternal attribution_node1;
attribution_node1.set_uid(1111);
attribution_node1.set_tag("location1");
AttributionNodeInternal attribution_node2;
attribution_node2.set_uid(2222);
attribution_node2.set_tag("location2");
AttributionNodeInternal attribution_node3;
attribution_node3.set_uid(3333);
attribution_node3.set_tag("location3");
AttributionNodeInternal attribution_node4;
attribution_node4.set_uid(1066);
attribution_node4.set_tag("location3");
std::vector<AttributionNodeInternal> attribution_nodes = {attribution_node1, attribution_node2,
attribution_node3, attribution_node4};
// Set up the event
LogEvent event(TAG_ID, 0);
event.write(attribution_nodes);
event.write("some value");
// Convert to a LogEvent
event.init();
// Set up the matcher
AtomMatcher matcher;
auto simpleMatcher = matcher.mutable_simple_atom_matcher();
simpleMatcher->set_atom_id(TAG_ID);
// Match first node.
auto attributionMatcher = simpleMatcher->add_field_value_matcher();
attributionMatcher->set_field(FIELD_ID_1);
attributionMatcher->set_position(Position::FIRST);
attributionMatcher->mutable_matches_tuple()->add_field_value_matcher()->set_field(
ATTRIBUTION_UID_FIELD_ID);
auto neqStringList = attributionMatcher->mutable_matches_tuple()
->mutable_field_value_matcher(0)
->mutable_neq_any_string();
neqStringList->add_str_value("pkg2");
neqStringList->add_str_value("pkg3");
auto fieldMatcher = simpleMatcher->add_field_value_matcher();
fieldMatcher->set_field(FIELD_ID_2);
fieldMatcher->set_eq_string("some value");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
neqStringList->Clear();
neqStringList->add_str_value("pkg1");
neqStringList->add_str_value("pkg3");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->set_position(Position::ANY);
neqStringList->Clear();
neqStringList->add_str_value("maps.com");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
neqStringList->Clear();
neqStringList->add_str_value("PkG3");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->set_position(Position::LAST);
neqStringList->Clear();
neqStringList->add_str_value("AID_STATSD");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
}
TEST(AtomMatcherTest, TestEqAnyStringMatcher) {
UidMap uidMap;
uidMap.updateMap(
{1111, 1111, 2222, 3333, 3333} /* uid list */, {1, 1, 2, 1, 2} /* version list */,
{android::String16("pkg0"), android::String16("pkg1"), android::String16("pkg1"),
android::String16("Pkg2"), android::String16("PkG3")} /* package name list */);
AttributionNodeInternal attribution_node1;
attribution_node1.set_uid(1067);
attribution_node1.set_tag("location1");
AttributionNodeInternal attribution_node2;
attribution_node2.set_uid(2222);
attribution_node2.set_tag("location2");
AttributionNodeInternal attribution_node3;
attribution_node3.set_uid(3333);
attribution_node3.set_tag("location3");
AttributionNodeInternal attribution_node4;
attribution_node4.set_uid(1066);
attribution_node4.set_tag("location3");
std::vector<AttributionNodeInternal> attribution_nodes = {attribution_node1, attribution_node2,
attribution_node3, attribution_node4};
// Set up the event
LogEvent event(TAG_ID, 0);
event.write(attribution_nodes);
event.write("some value");
// Convert to a LogEvent
event.init();
// Set up the matcher
AtomMatcher matcher;
auto simpleMatcher = matcher.mutable_simple_atom_matcher();
simpleMatcher->set_atom_id(TAG_ID);
// Match first node.
auto attributionMatcher = simpleMatcher->add_field_value_matcher();
attributionMatcher->set_field(FIELD_ID_1);
attributionMatcher->set_position(Position::FIRST);
attributionMatcher->mutable_matches_tuple()->add_field_value_matcher()->set_field(
ATTRIBUTION_UID_FIELD_ID);
auto eqStringList = attributionMatcher->mutable_matches_tuple()
->mutable_field_value_matcher(0)
->mutable_eq_any_string();
eqStringList->add_str_value("AID_ROOT");
eqStringList->add_str_value("AID_INCIDENTD");
auto fieldMatcher = simpleMatcher->add_field_value_matcher();
fieldMatcher->set_field(FIELD_ID_2);
fieldMatcher->set_eq_string("some value");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
attributionMatcher->set_position(Position::ANY);
eqStringList->Clear();
eqStringList->add_str_value("AID_STATSD");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
eqStringList->Clear();
eqStringList->add_str_value("pkg1");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
auto normalStringField = fieldMatcher->mutable_eq_any_string();
normalStringField->add_str_value("some value123");
normalStringField->add_str_value("some value");
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
normalStringField->Clear();
normalStringField->add_str_value("AID_STATSD");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
eqStringList->Clear();
eqStringList->add_str_value("maps.com");
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
}
TEST(AtomMatcherTest, TestBoolMatcher) {
UidMap uidMap;
// Set up the matcher
AtomMatcher matcher;
auto simpleMatcher = matcher.mutable_simple_atom_matcher();
simpleMatcher->set_atom_id(TAG_ID);
auto keyValue1 = simpleMatcher->add_field_value_matcher();
keyValue1->set_field(FIELD_ID_1);
auto keyValue2 = simpleMatcher->add_field_value_matcher();
keyValue2->set_field(FIELD_ID_2);
// Set up the event
LogEvent event(TAG_ID, 0);
EXPECT_TRUE(event.write(true));
EXPECT_TRUE(event.write(false));
// Convert to a LogEvent
event.init();
// Test
keyValue1->set_eq_bool(true);
keyValue2->set_eq_bool(false);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue1->set_eq_bool(false);
keyValue2->set_eq_bool(false);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue1->set_eq_bool(false);
keyValue2->set_eq_bool(true);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue1->set_eq_bool(true);
keyValue2->set_eq_bool(true);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
}
TEST(AtomMatcherTest, TestStringMatcher) {
UidMap uidMap;
// Set up the matcher
AtomMatcher matcher;
auto simpleMatcher = matcher.mutable_simple_atom_matcher();
simpleMatcher->set_atom_id(TAG_ID);
auto keyValue = simpleMatcher->add_field_value_matcher();
keyValue->set_field(FIELD_ID_1);
keyValue->set_eq_string("some value");
// Set up the event
LogEvent event(TAG_ID, 0);
event.write("some value");
// Convert to a LogEvent
event.init();
// Test
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
}
TEST(AtomMatcherTest, TestMultiFieldsMatcher) {
UidMap uidMap;
// Set up the matcher
AtomMatcher matcher;
auto simpleMatcher = matcher.mutable_simple_atom_matcher();
simpleMatcher->set_atom_id(TAG_ID);
auto keyValue1 = simpleMatcher->add_field_value_matcher();
keyValue1->set_field(FIELD_ID_1);
auto keyValue2 = simpleMatcher->add_field_value_matcher();
keyValue2->set_field(FIELD_ID_2);
// Set up the event
LogEvent event(TAG_ID, 0);
event.write(2);
event.write(3);
// Convert to a LogEvent
event.init();
// Test
keyValue1->set_eq_int(2);
keyValue2->set_eq_int(3);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue1->set_eq_int(2);
keyValue2->set_eq_int(4);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue1->set_eq_int(4);
keyValue2->set_eq_int(3);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
}
TEST(AtomMatcherTest, TestIntComparisonMatcher) {
UidMap uidMap;
// Set up the matcher
AtomMatcher matcher;
auto simpleMatcher = matcher.mutable_simple_atom_matcher();
simpleMatcher->set_atom_id(TAG_ID);
auto keyValue = simpleMatcher->add_field_value_matcher();
keyValue->set_field(FIELD_ID_1);
// Set up the event
LogEvent event(TAG_ID, 0);
event.write(11);
event.init();
// Test
// eq_int
keyValue->set_eq_int(10);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue->set_eq_int(11);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue->set_eq_int(12);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
// lt_int
keyValue->set_lt_int(10);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue->set_lt_int(11);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue->set_lt_int(12);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
// lte_int
keyValue->set_lte_int(10);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue->set_lte_int(11);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue->set_lte_int(12);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
// gt_int
keyValue->set_gt_int(10);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue->set_gt_int(11);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue->set_gt_int(12);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
// gte_int
keyValue->set_gte_int(10);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue->set_gte_int(11);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event));
keyValue->set_gte_int(12);
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event));
}
TEST(AtomMatcherTest, TestFloatComparisonMatcher) {
UidMap uidMap;
// Set up the matcher
AtomMatcher matcher;
auto simpleMatcher = matcher.mutable_simple_atom_matcher();
simpleMatcher->set_atom_id(TAG_ID);
auto keyValue = simpleMatcher->add_field_value_matcher();
keyValue->set_field(FIELD_ID_1);
LogEvent event1(TAG_ID, 0);
keyValue->set_lt_float(10.0);
event1.write(10.1f);
event1.init();
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event1));
LogEvent event2(TAG_ID, 0);
event2.write(9.9f);
event2.init();
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event2));
LogEvent event3(TAG_ID, 0);
event3.write(10.1f);
event3.init();
keyValue->set_gt_float(10.0);
EXPECT_TRUE(matchesSimple(uidMap, *simpleMatcher, event3));
LogEvent event4(TAG_ID, 0);
event4.write(9.9f);
event4.init();
EXPECT_FALSE(matchesSimple(uidMap, *simpleMatcher, event4));
}
// Helper for the composite matchers.
void addSimpleMatcher(SimpleAtomMatcher* simpleMatcher, int tag, int key, int val) {
simpleMatcher->set_atom_id(tag);
auto keyValue = simpleMatcher->add_field_value_matcher();
keyValue->set_field(key);
keyValue->set_eq_int(val);
}
TEST(AtomMatcherTest, TestAndMatcher) {
// Set up the matcher
LogicalOperation operation = LogicalOperation::AND;
vector<int> children;
children.push_back(0);
children.push_back(1);
children.push_back(2);
vector<MatchingState> matcherResults;
matcherResults.push_back(MatchingState::kMatched);
matcherResults.push_back(MatchingState::kNotMatched);
matcherResults.push_back(MatchingState::kMatched);
EXPECT_FALSE(combinationMatch(children, operation, matcherResults));
matcherResults.clear();
matcherResults.push_back(MatchingState::kMatched);
matcherResults.push_back(MatchingState::kMatched);
matcherResults.push_back(MatchingState::kMatched);
EXPECT_TRUE(combinationMatch(children, operation, matcherResults));
}
TEST(AtomMatcherTest, TestOrMatcher) {
// Set up the matcher
LogicalOperation operation = LogicalOperation::OR;
vector<int> children;
children.push_back(0);
children.push_back(1);
children.push_back(2);
vector<MatchingState> matcherResults;
matcherResults.push_back(MatchingState::kMatched);
matcherResults.push_back(MatchingState::kNotMatched);
matcherResults.push_back(MatchingState::kMatched);
EXPECT_TRUE(combinationMatch(children, operation, matcherResults));
matcherResults.clear();
matcherResults.push_back(MatchingState::kNotMatched);
matcherResults.push_back(MatchingState::kNotMatched);
matcherResults.push_back(MatchingState::kNotMatched);
EXPECT_FALSE(combinationMatch(children, operation, matcherResults));
}
TEST(AtomMatcherTest, TestNotMatcher) {
// Set up the matcher
LogicalOperation operation = LogicalOperation::NOT;
vector<int> children;
children.push_back(0);
vector<MatchingState> matcherResults;
matcherResults.push_back(MatchingState::kMatched);
EXPECT_FALSE(combinationMatch(children, operation, matcherResults));
matcherResults.clear();
matcherResults.push_back(MatchingState::kNotMatched);
EXPECT_TRUE(combinationMatch(children, operation, matcherResults));
}
TEST(AtomMatcherTest, TestNandMatcher) {
// Set up the matcher
LogicalOperation operation = LogicalOperation::NAND;
vector<int> children;
children.push_back(0);
children.push_back(1);
vector<MatchingState> matcherResults;
matcherResults.push_back(MatchingState::kMatched);
matcherResults.push_back(MatchingState::kNotMatched);
EXPECT_TRUE(combinationMatch(children, operation, matcherResults));
matcherResults.clear();
matcherResults.push_back(MatchingState::kNotMatched);
matcherResults.push_back(MatchingState::kNotMatched);
EXPECT_TRUE(combinationMatch(children, operation, matcherResults));
matcherResults.clear();
matcherResults.push_back(MatchingState::kMatched);
matcherResults.push_back(MatchingState::kMatched);
EXPECT_FALSE(combinationMatch(children, operation, matcherResults));
}
TEST(AtomMatcherTest, TestNorMatcher) {
// Set up the matcher
LogicalOperation operation = LogicalOperation::NOR;
vector<int> children;
children.push_back(0);
children.push_back(1);
vector<MatchingState> matcherResults;
matcherResults.push_back(MatchingState::kMatched);
matcherResults.push_back(MatchingState::kNotMatched);
EXPECT_FALSE(combinationMatch(children, operation, matcherResults));
matcherResults.clear();
matcherResults.push_back(MatchingState::kNotMatched);
matcherResults.push_back(MatchingState::kNotMatched);
EXPECT_TRUE(combinationMatch(children, operation, matcherResults));
matcherResults.clear();
matcherResults.push_back(MatchingState::kMatched);
matcherResults.push_back(MatchingState::kMatched);
EXPECT_FALSE(combinationMatch(children, operation, matcherResults));
}
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
Reference in New Issue View Git Blame Copy Permalink