blob: 0dc5c3ca23728686bc4b5dd5fe78de1fbaf06f8b [file] [log] [blame]
/*
* Copyright (C) 2022, 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 <aidl/android/frameworks/stats/VendorAtom.h>
#include <gtest/gtest.h>
#include <test_vendor_atoms.h>
#include <limits>
#include "frameworks/proto_logging/stats/stats_log_api_gen/test_vendor_atoms.pb.h"
namespace android {
namespace api_gen_vendor_tests {
using namespace android::VendorAtoms;
using namespace aidl::android::frameworks::stats;
using std::string;
using std::vector;
namespace {
static const int32_t kTestIntValue = 100;
static const int32_t kTestUidValue = 1000;
static const int32_t kTestPidValue = 3000;
static const int64_t kTestLongValue = std::numeric_limits<int64_t>::max() - kTestIntValue;
static const float kTestFloatValue = (float)kTestIntValue / kTestLongValue;
static const bool kTestBoolValue = true;
static const char* kTestStringValue = "test_string";
static const char* kTestStringValue2 = "test_string2";
} // namespace
/**
* Tests native auto generated code for specific vendor atom contains proper ids
*/
TEST(ApiGenVendorAtomTest, AtomIdConstantsTest) {
EXPECT_EQ(VENDOR_ATOM1, 105501);
EXPECT_EQ(VENDOR_ATOM2, 105502);
EXPECT_EQ(VENDOR_ATOM4, 105504);
}
/**
* Tests native auto generated code for specific vendor atom contains proper enums
*/
TEST(ApiGenVendorAtomTest, AtomEnumTest) {
EXPECT_EQ(VendorAtom1::TYPE_UNKNOWN, 0);
EXPECT_EQ(VendorAtom1::TYPE_1, 1);
EXPECT_EQ(VendorAtom1::TYPE_2, 2);
EXPECT_EQ(VendorAtom1::TYPE_3, 3);
EXPECT_EQ(VendorAtom1::ANOTHER_TYPE_UNKNOWN, 0);
EXPECT_EQ(VendorAtom1::ANOTHER_TYPE_1, 1);
EXPECT_EQ(VendorAtom1::ANOTHER_TYPE_2, 2);
EXPECT_EQ(VendorAtom1::ANOTHER_TYPE_3, 3);
EXPECT_EQ(VendorAtom2::TYPE_UNKNOWN, 0);
EXPECT_EQ(VendorAtom2::TYPE_1, 1);
EXPECT_EQ(VendorAtom2::TYPE_2, 2);
EXPECT_EQ(VendorAtom2::TYPE_3, 3);
EXPECT_EQ(VendorAtom2::ANOTHER_TYPE_UNKNOWN, 0);
EXPECT_EQ(VendorAtom2::ANOTHER_TYPE_1, 1);
EXPECT_EQ(VendorAtom2::ANOTHER_TYPE_2, 2);
EXPECT_EQ(VendorAtom2::ANOTHER_TYPE_3, 3);
EXPECT_EQ(VendorAtom4::TYPE_UNKNOWN, 0);
EXPECT_EQ(VendorAtom4::TYPE_1, 1);
typedef void (*Atom1FuncWithEnum)(VendorAtom1::EnumType arg);
typedef void (*Atom1FuncWithEnum2)(VendorAtom1::EnumType2 arg);
typedef void (*Atom2FuncWithEnum)(VendorAtom2::EnumType arg);
typedef void (*Atom2FuncWithEnum2)(VendorAtom2::EnumType2 arg);
Atom1FuncWithEnum f1 = nullptr;
Atom1FuncWithEnum2 f2 = nullptr;
Atom2FuncWithEnum f3 = nullptr;
Atom2FuncWithEnum2 f4 = nullptr;
EXPECT_EQ(f1, nullptr);
EXPECT_EQ(f2, nullptr);
EXPECT_EQ(f3, nullptr);
EXPECT_EQ(f4, nullptr);
}
TEST(ApiGenVendorAtomTest, buildVendorAtom1ApiTest) {
typedef VendorAtom (*VendorAtom1BuildFunc)(
int32_t code, char const* reverse_domain_name, int32_t enumField1, int32_t enumField2,
int32_t int_value32, int64_t int_value64, float float_value, bool bool_value,
int32_t enumField3, int32_t enumField4);
VendorAtom1BuildFunc func = &createVendorAtom;
EXPECT_NE(func, nullptr);
VendorAtom atom = func(VENDOR_ATOM1, kTestStringValue, VendorAtom1::TYPE_1, VendorAtom1::TYPE_2,
kTestIntValue, kTestLongValue, kTestFloatValue, kTestBoolValue,
VendorAtom1::ANOTHER_TYPE_2, VendorAtom1::ANOTHER_TYPE_3);
EXPECT_EQ(atom.atomId, VENDOR_ATOM1);
EXPECT_EQ(atom.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom.values.size(), static_cast<size_t>(8));
EXPECT_EQ(atom.values[0].get<VendorAtomValue::intValue>(), VendorAtom1::TYPE_1);
EXPECT_EQ(atom.values[1].get<VendorAtomValue::intValue>(), VendorAtom1::TYPE_2);
EXPECT_EQ(atom.values[2].get<VendorAtomValue::intValue>(), kTestIntValue);
EXPECT_EQ(atom.values[3].get<VendorAtomValue::longValue>(), kTestLongValue);
EXPECT_EQ(atom.values[4].get<VendorAtomValue::floatValue>(), kTestFloatValue);
EXPECT_EQ(atom.values[5].get<VendorAtomValue::boolValue>(), kTestBoolValue);
EXPECT_EQ(atom.values[6].get<VendorAtomValue::intValue>(), VendorAtom1::ANOTHER_TYPE_2);
EXPECT_EQ(atom.values[7].get<VendorAtomValue::intValue>(), VendorAtom1::ANOTHER_TYPE_3);
EXPECT_EQ(atom.atomAnnotations, std::nullopt);
}
TEST(ApiGenVendorAtomTest, buildVendorAtom3ApiTest) {
typedef VendorAtom (*VendorAtom3BuildFunc)(int32_t code, char const* arg1, int32_t arg2);
VendorAtom3BuildFunc func = &createVendorAtom;
EXPECT_NE(func, nullptr);
VendorAtom atom = func(VENDOR_ATOM3, kTestStringValue, kTestIntValue);
EXPECT_EQ(atom.atomId, VENDOR_ATOM3);
EXPECT_EQ(atom.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom.values.size(), static_cast<size_t>(1));
EXPECT_EQ(atom.values[0].get<VendorAtomValue::intValue>(), kTestIntValue);
EXPECT_EQ(atom.atomAnnotations, std::nullopt);
}
TEST(ApiGenVendorAtomTest, buildVendorAtom4ApiTest) {
typedef VendorAtom (*VendorAtom4BuildFunc)(
int32_t code, char const* arg1, float arg2, int32_t arg3, int64_t arg4, bool arg5,
int32_t arg6, const vector<bool>& arg7, const vector<float>& arg8,
const vector<int32_t>& arg9, const vector<int64_t>& arg10,
const vector<char const*>& arg11, const vector<int32_t>& arg12);
VendorAtom4BuildFunc func = &createVendorAtom;
EXPECT_NE(func, nullptr);
const vector<bool> repeatedBool{true, false, true};
const vector<float> repeatedFloat{kTestFloatValue, kTestFloatValue + 1.f,
kTestFloatValue + 2.f};
const vector<int32_t> repeatedInt{kTestIntValue, kTestIntValue + 1, kTestIntValue + 2};
const vector<int64_t> repeatedLong{kTestLongValue, kTestLongValue + 1, kTestLongValue + 2};
const vector<const char*> repeatedString{kTestStringValue, kTestStringValue2, kTestStringValue};
const vector<int32_t> repeatedEnum{VendorAtom4::TYPE_1, VendorAtom4::TYPE_UNKNOWN,
VendorAtom4::TYPE_1};
VendorAtom atom = func(VENDOR_ATOM4, kTestStringValue, kTestFloatValue, kTestIntValue,
kTestLongValue, kTestBoolValue, VendorAtom4::TYPE_1, repeatedBool,
repeatedFloat, repeatedInt, repeatedLong, repeatedString, repeatedEnum);
EXPECT_EQ(atom.atomId, VENDOR_ATOM4);
EXPECT_EQ(atom.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom.values.size(), static_cast<size_t>(11));
EXPECT_EQ(atom.values[0].get<VendorAtomValue::floatValue>(), kTestFloatValue);
EXPECT_EQ(atom.values[1].get<VendorAtomValue::intValue>(), kTestIntValue);
EXPECT_EQ(atom.values[2].get<VendorAtomValue::longValue>(), kTestLongValue);
EXPECT_EQ(atom.values[3].get<VendorAtomValue::boolValue>(), kTestBoolValue);
EXPECT_EQ(atom.values[4].get<VendorAtomValue::intValue>(), VendorAtom4::TYPE_1);
EXPECT_EQ(atom.values[5].get<VendorAtomValue::repeatedBoolValue>(), repeatedBool);
EXPECT_EQ(atom.values[6].get<VendorAtomValue::repeatedFloatValue>(), repeatedFloat);
EXPECT_EQ(atom.values[7].get<VendorAtomValue::repeatedIntValue>(), repeatedInt);
EXPECT_EQ(atom.values[8].get<VendorAtomValue::repeatedLongValue>(), repeatedLong);
EXPECT_TRUE(atom.values[9].get<VendorAtomValue::repeatedStringValue>().has_value());
EXPECT_EQ(atom.values[9].get<VendorAtomValue::repeatedStringValue>()->size(),
repeatedString.size());
const auto& repeatedStringValue = *atom.values[9].get<VendorAtomValue::repeatedStringValue>();
for (size_t i = 0; i < repeatedString.size(); i++) {
EXPECT_EQ(repeatedString[i], *repeatedStringValue[i]);
}
EXPECT_EQ(atom.values[10].get<VendorAtomValue::repeatedIntValue>(), repeatedEnum);
EXPECT_EQ(atom.atomAnnotations, std::nullopt);
}
TEST(ApiGenVendorAtomTest, buildVendorAtom5ApiTest) {
typedef VendorAtom (*VendorAtom5BuildFunc)(int32_t code, char const* arg1, float arg2,
int32_t arg3, int64_t arg4,
const vector<uint8_t>& arg5);
VendorAtom5BuildFunc func = &createVendorAtom;
EXPECT_NE(func, nullptr);
::android::stats_log_api_gen::TestNestedMessage nestedMessage;
nestedMessage.set_float_field(kTestFloatValue);
nestedMessage.set_int_field(kTestIntValue);
nestedMessage.set_long_field(kTestLongValue);
string nestedMessageString;
nestedMessage.SerializeToString(&nestedMessageString);
vector<uint8_t> nestedMessageBytes(nestedMessageString.begin(), nestedMessageString.end());
VendorAtom atom = func(VENDOR_ATOM5, kTestStringValue, kTestFloatValue, kTestIntValue,
kTestLongValue, nestedMessageBytes);
EXPECT_EQ(atom.atomId, VENDOR_ATOM5);
EXPECT_EQ(atom.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom.values.size(), static_cast<size_t>(4));
EXPECT_EQ(atom.values[0].get<VendorAtomValue::floatValue>(), kTestFloatValue);
EXPECT_EQ(atom.values[1].get<VendorAtomValue::intValue>(), kTestIntValue);
EXPECT_EQ(atom.values[2].get<VendorAtomValue::longValue>(), kTestLongValue);
EXPECT_EQ(atom.values[3].get<VendorAtomValue::byteArrayValue>(), nestedMessageBytes);
EXPECT_EQ(atom.atomAnnotations, std::nullopt);
string nestedMessageStringResult(atom.values[3].get<VendorAtomValue::byteArrayValue>()->begin(),
atom.values[3].get<VendorAtomValue::byteArrayValue>()->end());
EXPECT_EQ(nestedMessageStringResult, nestedMessageString);
::android::stats_log_api_gen::TestNestedMessage nestedMessageResult;
nestedMessageResult.ParseFromString(nestedMessageStringResult);
EXPECT_EQ(nestedMessageResult.float_field(), kTestFloatValue);
EXPECT_EQ(nestedMessageResult.int_field(), kTestIntValue);
EXPECT_EQ(nestedMessageResult.long_field(), kTestLongValue);
}
TEST(ApiGenVendorAtomTest, buildAtomWithTruncateTimestampTest) {
/**
* Expected signature equal to VendorAtomWithTrancateTimestampCreateFunc to log
* 3 different atoms with truncate_timestamp
* VendorAtomWithTruncateTimestamp truncateTimestampAtom1 = 105510 [
* (android.os.statsd.truncate_timestamp) = true
* ];
* VendorAtomWithTruncateTimestamp2 truncateTimestampAtom2 = 105511 [
* (android.os.statsd.truncate_timestamp) = true
* ];
* VendorAtomWithTruncateTimestamp3 truncateTimestampAtom3 = 105512 [
* (android.os.statsd.truncate_timestamp) = true
* ];
*
*/
typedef VendorAtom (*VendorAtomWithTrancateTimestampCreateFunc)(
int32_t code, char const* reverse_domain_name, int32_t state);
VendorAtomWithTrancateTimestampCreateFunc func = &createVendorAtom;
EXPECT_NE(func, nullptr);
VendorAtom atom1 = func(TRUNCATE_TIMESTAMP_ATOM1, kTestStringValue,
VendorAtomWithTruncateTimestamp::TEST_STATE_1);
EXPECT_EQ(atom1.atomId, TRUNCATE_TIMESTAMP_ATOM1);
EXPECT_EQ(atom1.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom1.values.size(), static_cast<size_t>(1));
EXPECT_EQ(atom1.values[0].get<VendorAtomValue::intValue>(),
VendorAtomWithTruncateTimestamp::TEST_STATE_1);
EXPECT_NE(atom1.atomAnnotations, std::nullopt);
EXPECT_EQ(atom1.atomAnnotations->size(), static_cast<size_t>(1));
EXPECT_NE(atom1.atomAnnotations.value()[0], std::nullopt);
EXPECT_EQ(atom1.atomAnnotations.value()[0]->annotationId, AnnotationId::TRUNCATE_TIMESTAMP);
EXPECT_TRUE(atom1.atomAnnotations.value()[0]->value.get<AnnotationValue::boolValue>());
VendorAtom atom2 = func(TRUNCATE_TIMESTAMP_ATOM2, kTestStringValue,
VendorAtomWithTruncateTimestamp2::TEST_STATE_2);
EXPECT_EQ(atom2.atomId, TRUNCATE_TIMESTAMP_ATOM2);
EXPECT_EQ(atom2.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom2.values.size(), static_cast<size_t>(1));
EXPECT_EQ(atom2.values[0].get<VendorAtomValue::intValue>(),
VendorAtomWithTruncateTimestamp2::TEST_STATE_2);
EXPECT_NE(atom2.atomAnnotations, std::nullopt);
EXPECT_EQ(atom2.atomAnnotations->size(), static_cast<size_t>(1));
EXPECT_NE(atom2.atomAnnotations.value()[0], std::nullopt);
EXPECT_EQ(atom2.atomAnnotations.value()[0]->annotationId, AnnotationId::TRUNCATE_TIMESTAMP);
EXPECT_TRUE(atom2.atomAnnotations.value()[0]->value.get<AnnotationValue::boolValue>());
VendorAtom atom3 = func(TRUNCATE_TIMESTAMP_ATOM2, kTestStringValue, kTestIntValue);
EXPECT_EQ(atom3.atomId, TRUNCATE_TIMESTAMP_ATOM2);
EXPECT_EQ(atom3.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom3.values.size(), static_cast<size_t>(1));
EXPECT_EQ(atom3.values[0].get<VendorAtomValue::intValue>(), kTestIntValue);
EXPECT_NE(atom3.atomAnnotations, std::nullopt);
EXPECT_EQ(atom3.atomAnnotations->size(), static_cast<size_t>(1));
EXPECT_NE(atom3.atomAnnotations.value()[0], std::nullopt);
EXPECT_EQ(atom3.atomAnnotations.value()[0]->annotationId, AnnotationId::TRUNCATE_TIMESTAMP);
EXPECT_TRUE(atom3.atomAnnotations.value()[0]->value.get<AnnotationValue::boolValue>());
}
TEST(ApiGenVendorAtomTest, buildAtomWithExclusiveStateAnnotationTest) {
/* Expected signature equal to VendorAtomWithStateCreateFunc to log
* atoms with similar definitions:
* VendorAtomWithState3 stateAtom3 = 105508
*/
typedef VendorAtom (*VendorAtomWithStateCreateFunc)(
int32_t code, char const* reverse_domain_name, int32_t state);
VendorAtomWithStateCreateFunc func = &createVendorAtom;
EXPECT_NE(func, nullptr);
VendorAtom atom = func(STATE_ATOM3, kTestStringValue, VendorAtomWithState3::TEST_STATE_3);
EXPECT_EQ(atom.atomId, STATE_ATOM3);
EXPECT_EQ(atom.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom.values.size(), static_cast<size_t>(1));
EXPECT_EQ(atom.values[0].get<VendorAtomValue::intValue>(), VendorAtomWithState3::TEST_STATE_3);
EXPECT_NE(atom.valuesAnnotations, std::nullopt);
EXPECT_EQ(atom.valuesAnnotations->size(), static_cast<size_t>(1));
EXPECT_NE(atom.valuesAnnotations.value()[0], std::nullopt);
EXPECT_EQ(atom.valuesAnnotations.value()[0]->valueIndex, 0);
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations.size(), static_cast<size_t>(1));
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations[0].annotationId,
AnnotationId::EXCLUSIVE_STATE);
EXPECT_TRUE(atom.valuesAnnotations.value()[0]
->annotations[0]
.value.get<AnnotationValue::boolValue>());
EXPECT_EQ(atom.atomAnnotations, std::nullopt);
}
TEST(ApiGenVendorAtomTest, buildAtomWithExclusiveStateAndPrimaryFieldAnnotationTest) {
/**
* Expected signature equal to VendorAtomWithStateCreateFunc to log atom
* VendorAtomWithState stateAtom1 = 105506
* which has 1 primary_field & 1 exclusive_state annotations associated with 2 fields
*/
typedef VendorAtom (*VendorAtomWithStateCreateFunc)(
int32_t code, char const* reverse_domain_name, int32_t uid, int32_t state);
VendorAtomWithStateCreateFunc func = &createVendorAtom;
EXPECT_NE(func, nullptr);
VendorAtom atom =
func(STATE_ATOM1, kTestStringValue, kTestUidValue, VendorAtomWithState::TEST_STATE_3);
EXPECT_EQ(atom.atomId, STATE_ATOM1);
EXPECT_EQ(atom.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom.values.size(), static_cast<size_t>(2));
EXPECT_EQ(atom.values[0].get<VendorAtomValue::intValue>(), kTestUidValue);
EXPECT_EQ(atom.values[1].get<VendorAtomValue::intValue>(), VendorAtomWithState::TEST_STATE_3);
EXPECT_NE(atom.valuesAnnotations, std::nullopt);
EXPECT_EQ(atom.valuesAnnotations->size(), static_cast<size_t>(2));
EXPECT_NE(atom.valuesAnnotations.value()[0], std::nullopt);
EXPECT_EQ(atom.valuesAnnotations.value()[0]->valueIndex, 0);
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations.size(), static_cast<size_t>(1));
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations[0].annotationId,
AnnotationId::PRIMARY_FIELD);
EXPECT_TRUE(atom.valuesAnnotations.value()[0]
->annotations[0]
.value.get<AnnotationValue::boolValue>());
EXPECT_NE(atom.valuesAnnotations.value()[1], std::nullopt);
EXPECT_EQ(atom.valuesAnnotations.value()[1]->valueIndex, 1);
EXPECT_EQ(atom.valuesAnnotations.value()[1]->annotations.size(), static_cast<size_t>(1));
EXPECT_EQ(atom.valuesAnnotations.value()[1]->annotations[0].annotationId,
AnnotationId::EXCLUSIVE_STATE);
EXPECT_TRUE(atom.valuesAnnotations.value()[1]
->annotations[0]
.value.get<AnnotationValue::boolValue>());
EXPECT_EQ(atom.atomAnnotations, std::nullopt);
}
TEST(ApiGenVendorAtomTest, buildAtomWithExclusiveStateAndTwoPrimaryFieldAnnotationTest) {
/**
* Expected signature equal to VendorAtomWithStateCreateFunc to log atom
* VendorAtomWithState2 stateAtom2 = 105507
* which has 2 primary_field & 1 exclusive_state annotations associated with 3 fields
*/
typedef VendorAtom (*VendorAtomWithStateCreateFunc)(
int32_t code, char const* reverse_domain_name, int32_t uid, int32_t pid, int32_t state);
VendorAtomWithStateCreateFunc func = &createVendorAtom;
EXPECT_NE(func, nullptr);
VendorAtom atom = func(STATE_ATOM2, kTestStringValue, kTestUidValue, kTestPidValue,
VendorAtomWithState2::TEST_STATE_2);
EXPECT_EQ(atom.atomId, STATE_ATOM2);
EXPECT_EQ(atom.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom.values.size(), static_cast<size_t>(3));
EXPECT_EQ(atom.values[0].get<VendorAtomValue::intValue>(), kTestUidValue);
EXPECT_EQ(atom.values[1].get<VendorAtomValue::intValue>(), kTestPidValue);
EXPECT_EQ(atom.values[2].get<VendorAtomValue::intValue>(), VendorAtomWithState2::TEST_STATE_2);
EXPECT_NE(atom.valuesAnnotations, std::nullopt);
EXPECT_EQ(atom.valuesAnnotations->size(), static_cast<size_t>(3));
EXPECT_NE(atom.valuesAnnotations.value()[0], std::nullopt);
EXPECT_EQ(atom.valuesAnnotations.value()[0]->valueIndex, 0);
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations.size(), static_cast<size_t>(1));
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations[0].annotationId,
AnnotationId::PRIMARY_FIELD);
EXPECT_TRUE(atom.valuesAnnotations.value()[0]
->annotations[0]
.value.get<AnnotationValue::boolValue>());
EXPECT_NE(atom.valuesAnnotations.value()[1], std::nullopt);
EXPECT_EQ(atom.valuesAnnotations.value()[1]->valueIndex, 1);
EXPECT_EQ(atom.valuesAnnotations.value()[1]->annotations.size(), static_cast<size_t>(1));
EXPECT_EQ(atom.valuesAnnotations.value()[1]->annotations[0].annotationId,
AnnotationId::PRIMARY_FIELD);
EXPECT_TRUE(atom.valuesAnnotations.value()[1]
->annotations[0]
.value.get<AnnotationValue::boolValue>());
EXPECT_NE(atom.valuesAnnotations.value()[2], std::nullopt);
EXPECT_EQ(atom.valuesAnnotations.value()[2]->valueIndex, 2);
EXPECT_EQ(atom.valuesAnnotations.value()[2]->annotations.size(), static_cast<size_t>(1));
EXPECT_EQ(atom.valuesAnnotations.value()[2]->annotations[0].annotationId,
AnnotationId::EXCLUSIVE_STATE);
EXPECT_TRUE(atom.valuesAnnotations.value()[2]
->annotations[0]
.value.get<AnnotationValue::boolValue>());
EXPECT_EQ(atom.atomAnnotations, std::nullopt);
}
TEST(ApiGenVendorAtomTest, buildAtomWithMultipleAnnotationsPerValueTest) {
/**
* Expected signature equal to VendorAtomWithStateCreateFunc to log atom
* VendorAtomWithState4 stateAtom4 = 105509
* which has 4 state annotations associated with single value field (index 0)
* testing that TRIGGER_STATE_RESET not be added
*/
typedef VendorAtom (*VendorAtomWithStateCreateFunc)(
int32_t code, char const* reverse_domain_name, int32_t state, bool someFlag);
VendorAtomWithStateCreateFunc func = &createVendorAtom;
EXPECT_NE(func, nullptr);
VendorAtom atom = func(STATE_ATOM4, kTestStringValue, VendorAtomWithState4::ON, kTestBoolValue);
EXPECT_EQ(atom.atomId, STATE_ATOM4);
EXPECT_EQ(atom.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom.values.size(), static_cast<size_t>(2));
EXPECT_EQ(atom.values[0].get<VendorAtomValue::intValue>(), VendorAtomWithState4::ON);
EXPECT_EQ(atom.values[1].get<VendorAtomValue::boolValue>(), kTestBoolValue);
EXPECT_NE(atom.valuesAnnotations, std::nullopt);
EXPECT_EQ(atom.valuesAnnotations->size(), static_cast<size_t>(2));
EXPECT_NE(atom.valuesAnnotations.value()[0], std::nullopt);
EXPECT_EQ(atom.valuesAnnotations.value()[0]->valueIndex, 0);
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations.size(), static_cast<size_t>(2));
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations[0].annotationId,
AnnotationId::EXCLUSIVE_STATE);
EXPECT_TRUE(atom.valuesAnnotations.value()[0]
->annotations[0]
.value.get<AnnotationValue::boolValue>());
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations[1].annotationId,
AnnotationId::STATE_NESTED);
EXPECT_TRUE(atom.valuesAnnotations.value()[0]
->annotations[1]
.value.get<AnnotationValue::boolValue>());
EXPECT_NE(atom.valuesAnnotations.value()[1], std::nullopt);
EXPECT_EQ(atom.valuesAnnotations.value()[1]->valueIndex, 1);
EXPECT_EQ(atom.valuesAnnotations.value()[1]->annotations.size(), static_cast<size_t>(1));
EXPECT_EQ(atom.valuesAnnotations.value()[1]->annotations[0].annotationId,
AnnotationId::PRIMARY_FIELD);
EXPECT_EQ(atom.atomAnnotations, std::nullopt);
}
TEST(ApiGenVendorAtomTest, buildAtomWithTriggerResetAnnotationTest) {
/**
* Expected signature equal to CreateStateAtom4ApiWrapper to log atom
* VendorAtomWithState4 stateAtom4 = 105509
* which has 4 state annotations associated with single value field (index 0)
* testing that TRIGGER_STATE_RESET will be added
*/
typedef VendorAtom (*VendorAtomWithStateCreateFunc)(
int32_t code, char const* reverse_domain_name, int32_t state, bool someFlag);
VendorAtomWithStateCreateFunc func = &createVendorAtom;
EXPECT_NE(func, nullptr);
const int kDefaultStateValue = VendorAtomWithState4::OFF;
VendorAtom atom =
func(STATE_ATOM4, kTestStringValue, VendorAtomWithState4::RESET, kTestBoolValue);
EXPECT_EQ(atom.atomId, STATE_ATOM4);
EXPECT_EQ(atom.reverseDomainName, kTestStringValue);
EXPECT_EQ(atom.values.size(), static_cast<size_t>(2));
EXPECT_EQ(atom.values[0].get<VendorAtomValue::intValue>(), VendorAtomWithState4::RESET);
EXPECT_EQ(atom.values[1].get<VendorAtomValue::boolValue>(), kTestBoolValue);
EXPECT_NE(atom.valuesAnnotations, std::nullopt);
EXPECT_EQ(atom.valuesAnnotations->size(), static_cast<size_t>(2));
EXPECT_NE(atom.valuesAnnotations.value()[0], std::nullopt);
EXPECT_EQ(atom.valuesAnnotations.value()[0]->valueIndex, 0);
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations.size(), static_cast<size_t>(3));
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations[0].annotationId,
AnnotationId::EXCLUSIVE_STATE);
EXPECT_TRUE(atom.valuesAnnotations.value()[0]
->annotations[0]
.value.get<AnnotationValue::boolValue>());
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations[1].annotationId,
AnnotationId::STATE_NESTED);
EXPECT_TRUE(atom.valuesAnnotations.value()[0]
->annotations[1]
.value.get<AnnotationValue::boolValue>());
EXPECT_EQ(atom.valuesAnnotations.value()[0]->annotations[2].annotationId,
AnnotationId::TRIGGER_STATE_RESET);
EXPECT_EQ(atom.valuesAnnotations.value()[0]
->annotations[2]
.value.get<AnnotationValue::intValue>(),
kDefaultStateValue);
EXPECT_NE(atom.valuesAnnotations.value()[1], std::nullopt);
EXPECT_EQ(atom.valuesAnnotations.value()[1]->valueIndex, 1);
EXPECT_EQ(atom.valuesAnnotations.value()[1]->annotations.size(), static_cast<size_t>(1));
EXPECT_EQ(atom.valuesAnnotations.value()[1]->annotations[0].annotationId,
AnnotationId::PRIMARY_FIELD);
EXPECT_EQ(atom.atomAnnotations, std::nullopt);
}
} // namespace api_gen_vendor_tests
} // namespace android