SerializeFlag => SerializeFlags
This is a straightforward refactoring to remove the SerializeFlag enum.
They are combined into one class because SerializeFlag is the old
negative bitfields and is confusing. SerializeFlags will contain
positive bitfields.
Bug: 110711640
Test: libvintf_test
Change-Id: I46070db674955add4971b0dc5736a43436f54ddf
diff --git a/AssembleVintf.cpp b/AssembleVintf.cpp
index b54b971..07d8604 100644
--- a/AssembleVintf.cpp
+++ b/AssembleVintf.cpp
@@ -668,19 +668,19 @@
bool setHalsOnly() override {
if (mSerializeFlags) return false;
- mSerializeFlags |= SerializeFlag::HALS_ONLY;
+ mSerializeFlags |= SerializeFlags::HALS_ONLY;
return true;
}
bool setNoHals() override {
if (mSerializeFlags) return false;
- mSerializeFlags |= SerializeFlag::NO_HALS;
+ mSerializeFlags |= SerializeFlags::NO_HALS;
return true;
}
bool setNoKernelRequirements() override {
- mSerializeFlags |= SerializeFlag::NO_KERNEL_CONFIGS;
- mSerializeFlags |= SerializeFlag::NO_KERNEL_MINOR_REVISION;
+ mSerializeFlags |= SerializeFlags::NO_KERNEL_CONFIGS;
+ mSerializeFlags |= SerializeFlags::NO_KERNEL_MINOR_REVISION;
return true;
}
@@ -689,7 +689,7 @@
Ostream mOutRef;
Istream mCheckFile;
bool mOutputMatrix = false;
- SerializeFlags mSerializeFlags = SerializeFlag::EVERYTHING;
+ SerializeFlags mSerializeFlags = SerializeFlags::EVERYTHING;
std::map<KernelVersion, std::vector<NamedIstream>> mKernels;
std::map<std::string, std::string> mFakeEnv;
};
diff --git a/SerializeFlags.cpp b/SerializeFlags.cpp
index ea4efb0..c801027 100644
--- a/SerializeFlags.cpp
+++ b/SerializeFlags.cpp
@@ -23,16 +23,16 @@
SerializeFlags::SerializeFlags(const SerializeFlags& other) : mValue(other.mValue) {}
-SerializeFlags SerializeFlags::operator|(SerializeFlag other) const {
- return SerializeFlags(legacyValue() | other);
+SerializeFlags SerializeFlags::operator|(SerializeFlags other) const {
+ return SerializeFlags(legacyValue() | other.legacyValue());
}
-SerializeFlags SerializeFlags::operator&(SerializeFlag other) const {
- return SerializeFlags(legacyValue() & other);
+SerializeFlags SerializeFlags::operator&(SerializeFlags other) const {
+ return SerializeFlags(legacyValue() & other.legacyValue());
}
-SerializeFlags& SerializeFlags::operator|=(SerializeFlag other) {
- *this = (*this | SerializeFlags(other));
+SerializeFlags& SerializeFlags::operator|=(SerializeFlags other) {
+ *this = (*this | other);
return *this;
}
@@ -68,5 +68,28 @@
VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(KernelConfigs, 8)
VINTF_SERIALIZE_FLAGS_FIELD_DEFINE(KernelMinorRevision, 9)
+const SerializeFlags SerializeFlags::EVERYTHING = SerializeFlags(0);
+const SerializeFlags SerializeFlags::NO_HALS = EVERYTHING.disableHals();
+const SerializeFlags SerializeFlags::NO_AVB = EVERYTHING.disableAvb();
+const SerializeFlags SerializeFlags::NO_SEPOLICY = EVERYTHING.disableSepolicy();
+const SerializeFlags SerializeFlags::NO_VNDK = EVERYTHING.disableVndk();
+const SerializeFlags SerializeFlags::NO_KERNEL = EVERYTHING.disableKernel();
+const SerializeFlags SerializeFlags::NO_XMLFILES = EVERYTHING.disableXmlFiles();
+const SerializeFlags SerializeFlags::NO_SSDK = EVERYTHING.disableSsdk();
+const SerializeFlags SerializeFlags::NO_FQNAME = EVERYTHING.disableFqname();
+const SerializeFlags SerializeFlags::NO_KERNEL_CONFIGS = EVERYTHING.disableKernelConfigs();
+const SerializeFlags SerializeFlags::NO_KERNEL_MINOR_REVISION =
+ EVERYTHING.disableKernelMinorRevision();
+
+const SerializeFlags SerializeFlags::NO_TAGS = SerializeFlags(~0);
+const SerializeFlags SerializeFlags::HALS_ONLY =
+ NO_TAGS.enableHals().enableFqname(); // <hal> with <fqname>
+const SerializeFlags SerializeFlags::XMLFILES_ONLY = NO_TAGS.enableXmlFiles();
+const SerializeFlags SerializeFlags::SEPOLICY_ONLY = NO_TAGS.enableSepolicy();
+const SerializeFlags SerializeFlags::VNDK_ONLY = NO_TAGS.enableVndk();
+const SerializeFlags SerializeFlags::HALS_NO_FQNAME =
+ NO_TAGS.enableHals(); // <hal> without <fqname>
+const SerializeFlags SerializeFlags::SSDK_ONLY = NO_TAGS.enableSsdk();
+
} // namespace vintf
} // namespace android
diff --git a/include/vintf/SerializeFlags.h b/include/vintf/SerializeFlags.h
index 99643d8..9715d18 100644
--- a/include/vintf/SerializeFlags.h
+++ b/include/vintf/SerializeFlags.h
@@ -22,28 +22,6 @@
namespace android {
namespace vintf {
-// legacy single SerializeFlag values. Use SerializeFlags class instead.
-enum SerializeFlag : uint32_t {
- NO_HALS = 1 << 0,
- NO_AVB = 1 << 1,
- NO_SEPOLICY = 1 << 2,
- NO_VNDK = 1 << 3,
- NO_KERNEL = 1 << 4,
- NO_XMLFILES = 1 << 5,
- NO_SSDK = 1 << 6,
- NO_FQNAME = 1 << 7,
- NO_KERNEL_CONFIGS = 1 << 8,
- NO_KERNEL_MINOR_REVISION = 1 << 9,
-
- EVERYTHING = 0,
- HALS_ONLY = ~(NO_HALS | NO_FQNAME), // <hal> with <fqname>
- XMLFILES_ONLY = ~NO_XMLFILES,
- SEPOLICY_ONLY = ~NO_SEPOLICY,
- VNDK_ONLY = ~NO_VNDK,
- HALS_NO_FQNAME = ~NO_HALS, // <hal> without <fqname>
- SSDK_ONLY = ~NO_SSDK,
-};
-
class SerializeFlags {
public:
SerializeFlags(const SerializeFlags& other);
@@ -66,18 +44,38 @@
#undef VINTF_SERIALIZE_FLAGS_FIELD_DECLARE
+ static const SerializeFlags NO_HALS;
+ static const SerializeFlags NO_AVB;
+ static const SerializeFlags NO_SEPOLICY;
+ static const SerializeFlags NO_VNDK;
+ static const SerializeFlags NO_KERNEL;
+ static const SerializeFlags NO_XMLFILES;
+ static const SerializeFlags NO_SSDK;
+ static const SerializeFlags NO_FQNAME;
+ static const SerializeFlags NO_KERNEL_CONFIGS;
+ static const SerializeFlags NO_KERNEL_MINOR_REVISION;
+
+ static const SerializeFlags EVERYTHING;
+ static const SerializeFlags NO_TAGS;
+ static const SerializeFlags HALS_ONLY;
+ static const SerializeFlags XMLFILES_ONLY;
+ static const SerializeFlags SEPOLICY_ONLY;
+ static const SerializeFlags VNDK_ONLY;
+ static const SerializeFlags HALS_NO_FQNAME;
+ static const SerializeFlags SSDK_ONLY;
+
private:
uint32_t mValue;
- // Legacy APIs to be compatible with old SerializeFlag usage.
+ // Legacy APIs to be compatible with old SerializeFlags usage.
public:
- SerializeFlags(uint32_t legacyValue);
- SerializeFlags operator|(SerializeFlag other) const;
- SerializeFlags operator&(SerializeFlag other) const;
- SerializeFlags& operator|=(SerializeFlag other);
+ SerializeFlags operator|(SerializeFlags other) const;
+ SerializeFlags operator&(SerializeFlags other) const;
+ SerializeFlags& operator|=(SerializeFlags other);
operator bool() const;
private:
+ SerializeFlags(uint32_t legacyValue);
uint32_t legacyValue() const;
};
diff --git a/include/vintf/parse_xml.h b/include/vintf/parse_xml.h
index 9c467c1..b24c3b2 100644
--- a/include/vintf/parse_xml.h
+++ b/include/vintf/parse_xml.h
@@ -32,10 +32,12 @@
virtual const std::string &lastError() const = 0;
// deprecated. Use operator() instead.
- virtual std::string serialize(const Object& o, SerializeFlags flags = EVERYTHING) const = 0;
+ virtual std::string serialize(const Object& o,
+ SerializeFlags flags = SerializeFlags::EVERYTHING) const = 0;
// Serialize an object to XML.
- virtual std::string operator()(const Object& o, SerializeFlags flags = EVERYTHING) const = 0;
+ virtual std::string operator()(const Object& o,
+ SerializeFlags flags = SerializeFlags::EVERYTHING) const = 0;
// deprecated. Use operator() instead. These APIs sets lastError(). Kept for testing.
virtual bool deserialize(Object* o, const std::string& xml) = 0;
diff --git a/main.cpp b/main.cpp
index c501bf7..d7f6630 100644
--- a/main.cpp
+++ b/main.cpp
@@ -266,10 +266,10 @@
std::cout << std::endl;
}
- SerializeFlags flags = SerializeFlag::EVERYTHING;
+ SerializeFlags flags = SerializeFlags::EVERYTHING;
if (!options.verbose) {
- flags |= SerializeFlag::NO_HALS;
- flags |= SerializeFlag::NO_KERNEL;
+ flags |= SerializeFlags::NO_HALS;
+ flags |= SerializeFlags::NO_KERNEL;
}
std::cout << "======== Device HAL Manifest =========" << std::endl;
if (vm != nullptr) std::cout << gHalManifestConverter(*vm, flags);
diff --git a/parse_xml.cpp b/parse_xml.cpp
index 7947fc3..fba8dfd 100644
--- a/parse_xml.cpp
+++ b/parse_xml.cpp
@@ -150,7 +150,7 @@
// convenience methods for user
inline const std::string& lastError() const override { return mLastError; }
inline NodeType* serialize(const Object& o, DocType* d,
- SerializeFlags flags = EVERYTHING) const {
+ SerializeFlags flags = SerializeFlags::EVERYTHING) const {
NodeType *root = createNode(this->elementName(), d);
this->mutateNode(o, root, d, flags);
return root;
@@ -234,7 +234,7 @@
template <typename T, typename Array>
inline void appendChildren(NodeType* parent, const XmlNodeConverter<T>& conv,
const Array& array, DocType* d,
- SerializeFlags flags = SerializeFlag::EVERYTHING) const {
+ SerializeFlags flags = SerializeFlags::EVERYTHING) const {
for (const T &t : array) {
appendChild(parent, conv.serialize(t, d, flags));
}
@@ -602,12 +602,12 @@
struct MatrixKernelConverter : public XmlNodeConverter<MatrixKernel> {
std::string elementName() const override { return "kernel"; }
void mutateNode(const MatrixKernel& kernel, NodeType* root, DocType* d) const override {
- mutateNode(kernel, root, d, SerializeFlag::EVERYTHING);
+ mutateNode(kernel, root, d, SerializeFlags::EVERYTHING);
}
void mutateNode(const MatrixKernel& kernel, NodeType* root, DocType* d,
SerializeFlags flags) const override {
KernelVersion kv = kernel.mMinLts;
- if (flags & SerializeFlag::NO_KERNEL_MINOR_REVISION) {
+ if (flags & SerializeFlags::NO_KERNEL_MINOR_REVISION) {
kv.minorRev = 0u;
}
appendAttr(root, "version", kv);
@@ -615,7 +615,7 @@
if (!kernel.mConditions.empty()) {
appendChild(root, matrixKernelConditionsConverter(kernel.mConditions, d));
}
- if (!(flags & SerializeFlag::NO_KERNEL_CONFIGS)) {
+ if (!(flags & SerializeFlags::NO_KERNEL_CONFIGS)) {
appendChildren(root, kernelConfigConverter, kernel.mConfigs, d);
}
}
@@ -637,7 +637,7 @@
struct ManifestHalConverter : public XmlNodeConverter<ManifestHal> {
std::string elementName() const override { return "hal"; }
void mutateNode(const ManifestHal& m, NodeType* root, DocType* d) const override {
- mutateNode(m, root, d, SerializeFlag::EVERYTHING);
+ mutateNode(m, root, d, SerializeFlags::EVERYTHING);
}
void mutateNode(const ManifestHal& hal, NodeType* root, DocType* d,
SerializeFlags flags) const override {
@@ -650,7 +650,7 @@
appendAttr(root, "override", hal.isOverride());
}
- if (!(flags & SerializeFlag::NO_FQNAME)) {
+ if (!(flags & SerializeFlags::NO_FQNAME)) {
std::set<FqInstance> fqInstances;
hal.forEachInstance([&fqInstances](const auto& manifestInstance) {
fqInstances.emplace(manifestInstance.getFqInstanceNoPackage());
@@ -861,25 +861,25 @@
struct HalManifestConverter : public XmlNodeConverter<HalManifest> {
std::string elementName() const override { return "manifest"; }
void mutateNode(const HalManifest &m, NodeType *root, DocType *d) const override {
- mutateNode(m, root, d, SerializeFlag::EVERYTHING);
+ mutateNode(m, root, d, SerializeFlags::EVERYTHING);
}
void mutateNode(const HalManifest& m, NodeType* root, DocType* d,
SerializeFlags flags) const override {
appendAttr(root, "version", m.getMetaVersion());
appendAttr(root, "type", m.mType);
- if (!(flags & SerializeFlag::NO_HALS)) {
+ if (!(flags & SerializeFlags::NO_HALS)) {
appendChildren(root, manifestHalConverter, m.getHals(), d, flags);
}
if (m.mType == SchemaType::DEVICE) {
- if (!(flags & SerializeFlag::NO_SEPOLICY)) {
+ if (!(flags & SerializeFlags::NO_SEPOLICY)) {
appendChild(root, halManifestSepolicyConverter(m.device.mSepolicyVersion, d));
}
if (m.mLevel != Level::UNSPECIFIED) {
this->appendAttr(root, "target-level", m.mLevel);
}
} else if (m.mType == SchemaType::FRAMEWORK) {
- if (!(flags & SerializeFlag::NO_VNDK)) {
+ if (!(flags & SerializeFlags::NO_VNDK)) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
appendChildren(root, vndkConverter, m.framework.mVndks, d);
@@ -887,14 +887,14 @@
appendChildren(root, vendorNdkConverter, m.framework.mVendorNdks, d);
}
- if (!(flags & SerializeFlag::NO_SSDK)) {
+ if (!(flags & SerializeFlags::NO_SSDK)) {
if (!m.framework.mSystemSdk.empty()) {
appendChild(root, systemSdkConverter(m.framework.mSystemSdk, d));
}
}
}
- if (!(flags & SerializeFlag::NO_XMLFILES)) {
+ if (!(flags & SerializeFlags::NO_XMLFILES)) {
appendChildren(root, manifestXmlFileConverter, m.getXmlFiles(), d);
}
}
@@ -1022,26 +1022,26 @@
struct CompatibilityMatrixConverter : public XmlNodeConverter<CompatibilityMatrix> {
std::string elementName() const override { return "compatibility-matrix"; }
void mutateNode(const CompatibilityMatrix &m, NodeType *root, DocType *d) const override {
- mutateNode(m, root, d, SerializeFlag::EVERYTHING);
+ mutateNode(m, root, d, SerializeFlags::EVERYTHING);
}
void mutateNode(const CompatibilityMatrix& m, NodeType* root, DocType* d,
SerializeFlags flags) const override {
appendAttr(root, "version", m.getMinimumMetaVersion());
appendAttr(root, "type", m.mType);
- if (!(flags & SerializeFlag::NO_HALS)) {
+ if (!(flags & SerializeFlags::NO_HALS)) {
appendChildren(root, matrixHalConverter, iterateValues(m.mHals), d);
}
if (m.mType == SchemaType::FRAMEWORK) {
- if (!(flags & SerializeFlag::NO_KERNEL)) {
+ if (!(flags & SerializeFlags::NO_KERNEL)) {
appendChildren(root, matrixKernelConverter, m.framework.mKernels, d, flags);
}
- if (!(flags & SerializeFlag::NO_SEPOLICY)) {
+ if (!(flags & SerializeFlags::NO_SEPOLICY)) {
if (!(m.framework.mSepolicy == Sepolicy{})) {
appendChild(root, sepolicyConverter(m.framework.mSepolicy, d));
}
}
- if (!(flags & SerializeFlag::NO_AVB)) {
+ if (!(flags & SerializeFlags::NO_AVB)) {
if (!(m.framework.mAvbMetaVersion == Version{})) {
appendChild(root, avbConverter(m.framework.mAvbMetaVersion, d));
}
@@ -1050,7 +1050,7 @@
this->appendAttr(root, "level", m.mLevel);
}
} else if (m.mType == SchemaType::DEVICE) {
- if (!(flags & SerializeFlag::NO_VNDK)) {
+ if (!(flags & SerializeFlags::NO_VNDK)) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
if (!(m.device.mVndk == Vndk{})) {
@@ -1063,14 +1063,14 @@
}
}
- if (!(flags & SerializeFlag::NO_SSDK)) {
+ if (!(flags & SerializeFlags::NO_SSDK)) {
if (!m.device.mSystemSdk.empty()) {
appendChild(root, systemSdkConverter(m.device.mSystemSdk, d));
}
}
}
- if (!(flags & SerializeFlag::NO_XMLFILES)) {
+ if (!(flags & SerializeFlags::NO_XMLFILES)) {
appendChildren(root, matrixXmlFileConverter, m.getXmlFiles(), d);
}
}
diff --git a/test/LibVintfTest.cpp b/test/LibVintfTest.cpp
index b67d5ed..7f6ce78 100644
--- a/test/LibVintfTest.cpp
+++ b/test/LibVintfTest.cpp
@@ -260,7 +260,7 @@
TEST_F(LibVintfTest, HalManifestConverter) {
HalManifest vm = testDeviceManifest();
std::string xml =
- gHalManifestConverter(vm, SerializeFlag::HALS_NO_FQNAME & SerializeFlag::SEPOLICY_ONLY);
+ gHalManifestConverter(vm, SerializeFlags::HALS_NO_FQNAME & SerializeFlags::SEPOLICY_ONLY);
EXPECT_EQ(xml,
"<manifest version=\"1.0\" type=\"device\">\n"
" <hal format=\"hidl\">\n"
@@ -298,7 +298,7 @@
TEST_F(LibVintfTest, HalManifestConverterFramework) {
HalManifest vm = testFrameworkManfiest();
std::string xml =
- gHalManifestConverter(vm, SerializeFlag::HALS_NO_FQNAME & SerializeFlag::VNDK_ONLY);
+ gHalManifestConverter(vm, SerializeFlags::HALS_NO_FQNAME & SerializeFlags::VNDK_ONLY);
EXPECT_EQ(xml,
"<manifest version=\"1.0\" type=\"framework\">\n"
" <hal format=\"hidl\">\n"
@@ -1286,8 +1286,8 @@
TEST_F(LibVintfTest, HalManifestConverterXmlFile) {
HalManifest vm = testDeviceManifestWithXmlFile();
std::string xml =
- gHalManifestConverter(vm, SerializeFlag::HALS_NO_FQNAME & SerializeFlag::SEPOLICY_ONLY &
- SerializeFlag::XMLFILES_ONLY);
+ gHalManifestConverter(vm, SerializeFlags::HALS_NO_FQNAME & SerializeFlags::SEPOLICY_ONLY &
+ SerializeFlags::XMLFILES_ONLY);
EXPECT_EQ(xml,
"<manifest version=\"1.0\" type=\"device\">\n"
" <hal format=\"hidl\">\n"
@@ -1329,7 +1329,7 @@
TEST_F(LibVintfTest, CompatibilityMatrixConverterXmlFile) {
CompatibilityMatrix cm;
addXmlFile(cm, "media_profile", {1, 0});
- std::string xml = gCompatibilityMatrixConverter(cm, SerializeFlag::XMLFILES_ONLY);
+ std::string xml = gCompatibilityMatrixConverter(cm, SerializeFlags::XMLFILES_ONLY);
EXPECT_EQ(xml,
"<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
" <xmlfile format=\"dtd\" optional=\"true\">\n"
@@ -2112,7 +2112,7 @@
<< gCompatibilityMatrixConverter.lastError();
EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
- xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
+ xml = gCompatibilityMatrixConverter(cm1, SerializeFlags::HALS_ONLY);
EXPECT_EQ(xml,
"<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
" <hal format=\"hidl\" optional=\"true\">\n"
@@ -2161,7 +2161,7 @@
<< gCompatibilityMatrixConverter.lastError();
EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
- xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
+ xml = gCompatibilityMatrixConverter(cm1, SerializeFlags::HALS_ONLY);
EXPECT_EQ(xml,
"<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
" <hal format=\"hidl\" optional=\"false\">\n"
@@ -2211,7 +2211,7 @@
<< gCompatibilityMatrixConverter.lastError();
EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
- xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
+ xml = gCompatibilityMatrixConverter(cm1, SerializeFlags::HALS_ONLY);
EXPECT_EQ(xml,
"<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
" <hal format=\"hidl\" optional=\"false\">\n"
@@ -2261,7 +2261,7 @@
<< gCompatibilityMatrixConverter.lastError();
EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
- xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
+ xml = gCompatibilityMatrixConverter(cm1, SerializeFlags::HALS_ONLY);
EXPECT_EQ(xml,
"<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
" <hal format=\"hidl\" optional=\"false\">\n"
@@ -2323,7 +2323,7 @@
EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
- xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
+ xml = gCompatibilityMatrixConverter(cm1, SerializeFlags::HALS_ONLY);
EXPECT_EQ(xml,
"<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
" <hal format=\"hidl\" optional=\"false\">\n"
@@ -2366,7 +2366,7 @@
EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
- xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
+ xml = gCompatibilityMatrixConverter(cm1, SerializeFlags::HALS_ONLY);
EXPECT_EQ(xml,
"<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
" <hal format=\"hidl\" optional=\"false\">\n"
@@ -2449,7 +2449,7 @@
<< gCompatibilityMatrixConverter.lastError();
EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
- xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
+ xml = gCompatibilityMatrixConverter(cm1, SerializeFlags::HALS_ONLY);
EXPECT_EQ(
"<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
" <hal format=\"hidl\" optional=\"false\">\n"
@@ -2509,7 +2509,7 @@
<< gCompatibilityMatrixConverter.lastError();
EXPECT_TRUE(addAllXmlFilesAsOptional(&cm1, &cm2, &error)) << error;
- xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::XMLFILES_ONLY);
+ xml = gCompatibilityMatrixConverter(cm1, SerializeFlags::XMLFILES_ONLY);
EXPECT_EQ(xml,
"<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
" <xmlfile format=\"xsd\" optional=\"true\">\n"
@@ -2696,7 +2696,7 @@
EXPECT_TRUE(gHalManifestConverter(&newManifest, xml)) << gHalManifestConverter.lastError();
manifest.addAllHals(&newManifest);
- EXPECT_EQ(xml, gHalManifestConverter(manifest, SerializeFlag::HALS_NO_FQNAME));
+ EXPECT_EQ(xml, gHalManifestConverter(manifest, SerializeFlags::HALS_NO_FQNAME));
}
TEST_F(LibVintfTest, ManifestAddOverrideHalSimpleOverride) {
@@ -2727,7 +2727,7 @@
EXPECT_TRUE(gHalManifestConverter(&newManifest, xml)) << gHalManifestConverter.lastError();
manifest.addAllHals(&newManifest);
- EXPECT_EQ(xml, gHalManifestConverter(manifest, SerializeFlag::HALS_NO_FQNAME));
+ EXPECT_EQ(xml, gHalManifestConverter(manifest, SerializeFlags::HALS_NO_FQNAME));
}
// Existing major versions should be removed.
@@ -2797,7 +2797,7 @@
" </interface>\n"
" </hal>\n"
"</manifest>\n",
- gHalManifestConverter(manifest, SerializeFlag::HALS_NO_FQNAME));
+ gHalManifestConverter(manifest, SerializeFlags::HALS_NO_FQNAME));
}
TEST_F(LibVintfTest, ManifestAddOverrideHalMultiVersion2) {
@@ -2834,7 +2834,7 @@
EXPECT_TRUE(gHalManifestConverter(&newManifest, xml)) << gHalManifestConverter.lastError();
manifest.addAllHals(&newManifest);
- EXPECT_EQ(xml, gHalManifestConverter(manifest, SerializeFlag::HALS_NO_FQNAME));
+ EXPECT_EQ(xml, gHalManifestConverter(manifest, SerializeFlags::HALS_NO_FQNAME));
}
// if no <versions>, remove all existing <hal> with given <name>.
@@ -2893,7 +2893,7 @@
" <transport>hwbinder</transport>\n"
" </hal>\n"
"</manifest>\n",
- gHalManifestConverter(manifest, SerializeFlag::HALS_ONLY));
+ gHalManifestConverter(manifest, SerializeFlags::HALS_ONLY));
}
// Make sure missing tags in old VINTF files does not cause incompatibilities.
@@ -2927,7 +2927,7 @@
"</compatibility-matrix>\n";
EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
<< gCompatibilityMatrixConverter.lastError();
- EXPECT_EQ(xml, gCompatibilityMatrixConverter(cm, ~SerializeFlag::NO_SSDK));
+ EXPECT_EQ(xml, gCompatibilityMatrixConverter(cm, SerializeFlags::SSDK_ONLY));
{
HalManifest manifest;
@@ -2939,7 +2939,7 @@
" </system-sdk>\n"
"</manifest>\n";
EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
- EXPECT_EQ(xml, gHalManifestConverter(manifest, ~SerializeFlag::NO_SSDK));
+ EXPECT_EQ(xml, gHalManifestConverter(manifest, SerializeFlags::SSDK_ONLY));
EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
}