Snap for 4565898 from 281358e7139a4978ca552a79a35d234944039d7c to pi-release

Change-Id: I761e3c7e1cbcbf64740707c7eb4989c86aff1625

12 files changed, 435 insertions, 31 deletions

diff --git a/AssembleVintf.cpp b/AssembleVintf.cpp
index d17f1c5..8951471 100644
--- a/AssembleVintf.cpp
+++ b/AssembleVintf.cpp
@@ -108,7 +108,7 @@ class AssembleVintfImpl : public AssembleVintf {
      * Set *out to environment variable if *out is not a dummy value (i.e. default constructed).
      */
     template <typename T>
-    bool getFlagIfUnset(const std::string& envKey, T* out) const {
+    bool getFlagIfUnset(const std::string& envKey, T* out, bool log = true) const {
         bool hasExistingValue = !(*out == T{});
 
         bool hasEnvValue = false;
@@ -116,22 +116,26 @@ class AssembleVintfImpl : public AssembleVintf {
         std::string envStrValue = getEnv(envKey);
         if (!envStrValue.empty()) {
             if (!parse(envStrValue, &envValue)) {
-                std::cerr << "Cannot parse " << envValue << "." << std::endl;
+                if (log) {
+                    std::cerr << "Cannot parse " << envValue << "." << std::endl;
+                }
                 return false;
             }
             hasEnvValue = true;
         }
 
         if (hasExistingValue) {
-            if (hasEnvValue) {
+            if (hasEnvValue && log) {
                 std::cerr << "Warning: cannot override existing value " << *out << " with "
                           << envKey << " (which is " << envValue << ")." << std::endl;
             }
             return false;
         }
         if (!hasEnvValue) {
-            std::cerr << "Warning: " << envKey << " is not specified. Default to " << T{} << "."
-                      << std::endl;
+            if (log) {
+                std::cerr << "Warning: " << envKey << " is not specified. Default to " << T{} << "."
+                          << std::endl;
+            }
             return false;
         }
         *out = envValue;
@@ -353,8 +357,7 @@ class AssembleVintfImpl : public AssembleVintf {
                 return false;
             }
             for (ConditionedConfig& conditionedConfig : conditionedConfigs) {
-                MatrixKernel kernel(KernelVersion{pair.first.majorVer, pair.first.minorVer, 0u},
-                                    std::move(conditionedConfig.second));
+                MatrixKernel kernel(KernelVersion{pair.first}, std::move(conditionedConfig.second));
                 if (conditionedConfig.first != nullptr)
                     kernel.mConditions.push_back(std::move(*conditionedConfig.first));
                 matrix->framework.mKernels.push_back(std::move(kernel));
@@ -473,12 +476,15 @@ class AssembleVintfImpl : public AssembleVintf {
                 &matrix->framework.mSepolicy.mSepolicyVersionRanges;
             VersionRange sepolicyVr;
             if (!sepolicyVrs->empty()) sepolicyVr = sepolicyVrs->front();
-            if (getFlagIfUnset("BOARD_SEPOLICY_VERS", &sepolicyVr)) {
+            if (getFlagIfUnset("BOARD_SEPOLICY_VERS", &sepolicyVr,
+                               deviceLevel == Level::UNSPECIFIED /* log */)) {
                 *sepolicyVrs = {{sepolicyVr}};
             }
 
-            getFlagIfUnset("POLICYVERS", &matrix->framework.mSepolicy.mKernelSepolicyVersion);
-            getFlagIfUnset("FRAMEWORK_VBMETA_VERSION", &matrix->framework.mAvbMetaVersion);
+            getFlagIfUnset("POLICYVERS", &matrix->framework.mSepolicy.mKernelSepolicyVersion,
+                           deviceLevel == Level::UNSPECIFIED /* log */);
+            getFlagIfUnset("FRAMEWORK_VBMETA_VERSION", &matrix->framework.mAvbMetaVersion,
+                           deviceLevel == Level::UNSPECIFIED /* log */);
 
             out() << "<!--" << std::endl;
             out() << "    Input:" << std::endl;
@@ -576,12 +582,12 @@ class AssembleVintfImpl : public AssembleVintf {
         return *mCheckFile;
     }
 
-    bool hasKernelVersion(const Version& kernelVer) const override {
+    bool hasKernelVersion(const KernelVersion& kernelVer) const override {
         return mKernels.find(kernelVer) != mKernels.end();
     }
 
-    std::istream& addKernelConfigInputStream(const Version& kernelVer, const std::string& name,
-                                             Istream&& in) override {
+    std::istream& addKernelConfigInputStream(const KernelVersion& kernelVer,
+                                             const std::string& name, Istream&& in) override {
         auto&& kernel = mKernels[kernelVer];
         auto it = kernel.emplace(kernel.end(), name, std::move(in));
         return it->stream();
@@ -614,7 +620,7 @@ class AssembleVintfImpl : public AssembleVintf {
     Istream mCheckFile;
     bool mOutputMatrix = false;
     SerializeFlags mSerializeFlags = SerializeFlag::EVERYTHING;
-    std::map<Version, std::vector<NamedIstream>> mKernels;
+    std::map<KernelVersion, std::vector<NamedIstream>> mKernels;
     std::map<std::string, std::string> mFakeEnv;
 };
 
@@ -639,7 +645,7 @@ bool AssembleVintf::addKernel(const std::string& kernelArg) {
         std::cerr << "Unrecognized --kernel option '" << kernelArg << "'" << std::endl;
         return false;
     }
-    Version kernelVer;
+    KernelVersion kernelVer;
     if (!parse(tokens.front(), &kernelVer)) {
         std::cerr << "Unrecognized kernel version '" << tokens.front() << "'" << std::endl;
         return false;
diff --git a/CompatibilityMatrix.cpp b/CompatibilityMatrix.cpp
index d3c4ebf..00e4d14 100644
--- a/CompatibilityMatrix.cpp
+++ b/CompatibilityMatrix.cpp
@@ -96,6 +96,10 @@ std::pair<MatrixHal*, VersionRange*> CompatibilityMatrix::getHalWithMajorVersion
     }
     return {nullptr, nullptr};
 }
+std::pair<const MatrixHal*, const VersionRange*> CompatibilityMatrix::getHalWithMajorVersion(
+    const std::string& name, size_t majorVer) const {
+    return const_cast<CompatibilityMatrix*>(this)->getHalWithMajorVersion(name, majorVer);
+}
 
 bool CompatibilityMatrix::addAllHalsAsOptional(CompatibilityMatrix* other, std::string* error) {
     if (other == nullptr || other->level() <= level()) {
@@ -290,6 +294,22 @@ CompatibilityMatrix* CompatibilityMatrix::combine(Level deviceLevel,
         }
     }
 
+    for (auto& e : *matrices) {
+        if (&e.object != matrix && e.object.level() == deviceLevel &&
+            e.object.type() == SchemaType::FRAMEWORK) {
+            for (MatrixKernel& kernel : e.object.framework.mKernels) {
+                KernelVersion ver = kernel.minLts();
+                if (!matrix->add(std::move(kernel))) {
+                    if (error) {
+                        *error = "Cannot add kernel version " + to_string(ver) +
+                                 " from FCM version " + to_string(deviceLevel);
+                    }
+                    return nullptr;
+                }
+            }
+        }
+    }
+
     return matrix;
 }
 
diff --git a/VintfObject.cpp b/VintfObject.cpp
index 90b446d..7c55181 100644
--- a/VintfObject.cpp
+++ b/VintfObject.cpp
@@ -17,6 +17,7 @@
 #include "VintfObject.h"
 
 #include "CompatibilityMatrix.h"
+#include "parse_string.h"
 #include "parse_xml.h"
 #include "utils.h"
 
@@ -567,6 +568,144 @@ int32_t VintfObject::CheckCompatibility(const std::vector<std::string>& xmls, st
                                        disabledChecks);
 }
 
+bool VintfObject::isHalDeprecated(const MatrixHal& oldMatrixHal,
+                                  const CompatibilityMatrix& targetMatrix,
+                                  const IsInstanceInUse& isInstanceInUse, std::string* error) {
+    for (const VersionRange& range : oldMatrixHal.versionRanges) {
+        for (const HalInterface& interface : iterateValues(oldMatrixHal.interfaces)) {
+            for (const std::string& instance : interface.instances) {
+                if (isInstanceDeprecated(oldMatrixHal.name, range.minVer(), interface.name,
+                                         instance, targetMatrix, isInstanceInUse, error)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+// If isInstanceInUse(package@x.y::interface/instance), return true iff:
+// 1. package@x.?::interface/instance is not in targetMatrix; OR
+// 2. package@x.z::interface/instance is in targetMatrix but
+// !isInstanceInUse(package@x.z::interface/instance)
+bool VintfObject::isInstanceDeprecated(const std::string& package, Version version,
+                                       const std::string& interface, const std::string& instance,
+                                       const CompatibilityMatrix& targetMatrix,
+                                       const IsInstanceInUse& isInstanceInUse,
+                                       std::string* error) {
+    bool oldVersionIsServed;
+    Version servedVersion;
+    std::tie(oldVersionIsServed, servedVersion) =
+        isInstanceInUse(package, version, interface, instance);
+    if (oldVersionIsServed) {
+        // Find any package@x.? in target matrix, and check if instance is in target matrix.
+        const MatrixHal* targetMatrixHal;
+        const VersionRange* targetMatrixRange;
+        std::tie(targetMatrixHal, targetMatrixRange) =
+            targetMatrix.getHalWithMajorVersion(package, version.majorVer);
+        if (targetMatrixHal == nullptr || targetMatrixRange == nullptr) {
+            if (error) {
+                *error = package + "@" + to_string(servedVersion) +
+                         "is deprecated in compatibility matrix at FCM Version " +
+                         to_string(targetMatrix.level()) + "; it should not be served.";
+            }
+            return true;
+        }
+
+        const auto& targetMatrixInstances = targetMatrixHal->getInstances(interface);
+        if (targetMatrixInstances.find(instance) == targetMatrixInstances.end()) {
+            if (error) {
+                *error += package + "@" + to_string(servedVersion) + "::" + interface + "/" +
+                          instance + " is deprecated at FCM version " +
+                          to_string(targetMatrix.level()) + "; it should be not be served.\n";
+            }
+            return true;
+        }
+
+        // Assuming that targetMatrix requires @x.u-v, require that at least @x.u is served.
+        bool targetVersionServed;
+        std::tie(targetVersionServed, std::ignore) =
+            isInstanceInUse(package, targetMatrixRange->minVer(), interface, instance);
+
+        if (!targetVersionServed) {
+            if (error) {
+                *error += package + "@" + to_string(servedVersion) + " is deprecated; " +
+                          "require at least " + to_string(targetMatrixRange->minVer()) + "\n";
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+int32_t VintfObject::CheckDeprecation(const IsInstanceInUse& isInstanceInUse,
+                                      std::string* error) {
+    auto matrixFragments = GetAllFrameworkMatrixLevels(error);
+    if (matrixFragments.empty()) {
+        if (error && error->empty())
+            *error = "Cannot get framework matrix for each FCM version for unknown error.";
+        return NAME_NOT_FOUND;
+    }
+    auto deviceManifest = GetDeviceHalManifest();
+    if (deviceManifest == nullptr) {
+        if (error) *error = "No device manifest.";
+        return NAME_NOT_FOUND;
+    }
+    Level deviceLevel = deviceManifest->level();
+    if (deviceLevel == Level::UNSPECIFIED) {
+        if (error) *error = "Device manifest does not specify Shipping FCM Version.";
+        return BAD_VALUE;
+    }
+
+    const CompatibilityMatrix* targetMatrix = nullptr;
+    for (const auto& namedMatrix : matrixFragments) {
+        if (namedMatrix.object.level() == deviceLevel) {
+            targetMatrix = &namedMatrix.object;
+        }
+    }
+    if (targetMatrix == nullptr) {
+        if (error)
+            *error = "Cannot find framework matrix at FCM version " + to_string(deviceLevel) + ".";
+        return NAME_NOT_FOUND;
+    }
+
+    bool hasDeprecatedHals = false;
+    for (const auto& namedMatrix : matrixFragments) {
+        if (namedMatrix.object.level() == Level::UNSPECIFIED) continue;
+        if (namedMatrix.object.level() >= deviceLevel) continue;
+
+        const auto& oldMatrix = namedMatrix.object;
+        for (const MatrixHal& hal : oldMatrix.getHals()) {
+            hasDeprecatedHals |= isHalDeprecated(hal, *targetMatrix, isInstanceInUse, error);
+        }
+    }
+
+    return hasDeprecatedHals ? DEPRECATED : NO_DEPRECATED_HALS;
+}
+
+int32_t VintfObject::CheckDeprecation(std::string* error) {
+    auto deviceManifest = GetDeviceHalManifest();
+    IsInstanceInUse inManifest = [&deviceManifest](const std::string& package, Version version,
+                                                    const std::string& interface,
+                                                    const std::string& instance) {
+        const ManifestHal* hal = deviceManifest->getHal(package, version);
+        if (hal == nullptr) {
+            return std::make_pair(false, Version{});
+        }
+        const auto& instances = hal->getInstances(interface);
+        if (instances.find(instance) == instances.end()) {
+            return std::make_pair(false, Version{});
+        }
+
+        for (Version v : hal->versions) {
+            if (v.minorAtLeast(version)) {
+                return std::make_pair(true, v);
+            }
+        }
+        return std::make_pair(false, Version{});
+    };
+    return CheckDeprecation(inManifest, error);
+}
 
 } // namespace vintf
 } // namespace android
diff --git a/include-test/vintf/AssembleVintf.h b/include-test/vintf/AssembleVintf.h
index 1b457eb..ac6d2af 100644
--- a/include-test/vintf/AssembleVintf.h
+++ b/include-test/vintf/AssembleVintf.h
@@ -49,12 +49,12 @@ class AssembleVintf {
     virtual std::ostream& setOutputStream(Ostream&&) = 0;
     virtual std::istream& addInputStream(const std::string& name, Istream&&) = 0;
     virtual std::istream& setCheckInputStream(Istream&&) = 0;
-    virtual std::istream& addKernelConfigInputStream(const Version& kernelVer,
+    virtual std::istream& addKernelConfigInputStream(const KernelVersion& kernelVer,
                                                      const std::string& name, Istream&& in) = 0;
     virtual void setFakeEnv(const std::string& key, const std::string& value) = 0;
 
    protected:
-    virtual bool hasKernelVersion(const Version&) const = 0;
+    virtual bool hasKernelVersion(const KernelVersion&) const = 0;
     virtual std::string getEnv(const std::string& key) const = 0;
 };
 
diff --git a/include/vintf/CompatibilityMatrix.h b/include/vintf/CompatibilityMatrix.h
index 696a0bf..1b35d2d 100644
--- a/include/vintf/CompatibilityMatrix.h
+++ b/include/vintf/CompatibilityMatrix.h
@@ -71,6 +71,8 @@ struct CompatibilityMatrix : public HalGroup<MatrixHal>, public XmlFileGroup<Mat
     // Return nullptr if none is found.
     std::pair<MatrixHal*, VersionRange*> getHalWithMajorVersion(const std::string& name,
                                                                 size_t majorVer);
+    std::pair<const MatrixHal*, const VersionRange*> getHalWithMajorVersion(const std::string& name,
+                                                                            size_t majorVer) const;
     // Similar to addAllHalsAsOptional but on <xmlfile> entries.
     bool addAllXmlFilesAsOptional(CompatibilityMatrix* other, std::string* error);
 
diff --git a/include/vintf/Version.h b/include/vintf/Version.h
index 0f38391..5fab0fa 100644
--- a/include/vintf/Version.h
+++ b/include/vintf/Version.h
@@ -82,6 +82,14 @@ struct KernelVersion {
     inline bool operator!=(const KernelVersion &other) const {
         return !((*this) == other);
     }
+
+    inline bool operator<(const KernelVersion& other) const {
+        if (version < other.version) return true;
+        if (version > other.version) return false;
+        if (majorRev < other.majorRev) return true;
+        if (majorRev > other.majorRev) return false;
+        return minorRev < other.minorRev;
+    }
 };
 
 } // namespace vintf
diff --git a/include/vintf/VintfObject.h b/include/vintf/VintfObject.h
index 06ccd00..656b2b8 100644
--- a/include/vintf/VintfObject.h
+++ b/include/vintf/VintfObject.h
@@ -112,6 +112,34 @@ public:
                                       std::string* error = nullptr,
                                       DisabledChecks disabledChecks = ENABLE_ALL_CHECKS);
 
+    using IsInstanceInUse = std::function<std::pair<bool, Version>(
+        const std::string& package, Version version, const std::string& interface,
+        const std::string& instance)>;
+    /**
+     * Check deprecation on framework matrices with a provided predicate.
+     *
+     * @param isInstanceInUse predicate that takes parameter in this format:
+     *        android.hardware.foo@1.0::IFoo/instance
+     *        and returns {true, version} if HAL is in use, where version =
+     *        first version in interfaceChain where package + major version matches.
+     *
+     * @return = 0 if success (no deprecated HALs)
+     *         > 0 if there is at least one deprecated HAL
+     *         < 0 if any error (mount partition fails, illformed XML, etc.)
+     */
+    static int32_t CheckDeprecation(const IsInstanceInUse& isInstanceInUse,
+                                    std::string* error = nullptr);
+
+    /**
+     * Check deprecation on existing VINTF metadata. Use Device Manifest as the
+     * predicate to check if a HAL is in use.
+     *
+     * @return = 0 if success (no deprecated HALs)
+     *         > 0 if there is at least one deprecated HAL
+     *         < 0 if any error (mount partition fails, illformed XML, etc.)
+     */
+    static int32_t CheckDeprecation(std::string* error = nullptr);
+
    private:
     static status_t GetCombinedFrameworkMatrix(
         const std::shared_ptr<const HalManifest>& deviceManifest, CompatibilityMatrix* out,
@@ -123,11 +151,22 @@ public:
     static status_t FetchOdmHalManifest(HalManifest* out, std::string* error = nullptr);
     static status_t FetchOneHalManifest(const std::string& path, HalManifest* out,
                                         std::string* error = nullptr);
+
+    static bool isHalDeprecated(const MatrixHal& oldMatrixHal,
+                                const CompatibilityMatrix& targetMatrix,
+                                const IsInstanceInUse& isInstanceInUse, std::string* error);
+    static bool isInstanceDeprecated(const std::string& package, Version version,
+                                     const std::string& interface, const std::string& instance,
+                                     const CompatibilityMatrix& targetMatrix,
+                                     const IsInstanceInUse& isInstanceInUse, std::string* error);
 };
 
 enum : int32_t {
     COMPATIBLE = 0,
     INCOMPATIBLE = 1,
+
+    NO_DEPRECATED_HALS = 0,
+    DEPRECATED = 1,
 };
 
 // exposed for testing and VintfObjectRecovery.
diff --git a/parse_xml.cpp b/parse_xml.cpp
index 74ba880..5900f27 100644
--- a/parse_xml.cpp
+++ b/parse_xml.cpp
@@ -954,10 +954,14 @@ struct CompatibilityMatrixConverter : public XmlNodeConverter<CompatibilityMatri
                 appendChildren(root, matrixKernelConverter, m.framework.mKernels, d);
             }
             if (!(flags & SerializeFlag::NO_SEPOLICY)) {
-                appendChild(root, sepolicyConverter(m.framework.mSepolicy, d));
+                if (!(m.framework.mSepolicy == Sepolicy{})) {
+                    appendChild(root, sepolicyConverter(m.framework.mSepolicy, d));
+                }
             }
             if (!(flags & SerializeFlag::NO_AVB)) {
-                appendChild(root, avbConverter(m.framework.mAvbMetaVersion, d));
+                if (!(m.framework.mAvbMetaVersion == Version{})) {
+                    appendChild(root, avbConverter(m.framework.mAvbMetaVersion, d));
+                }
             }
         } else if (m.mType == SchemaType::DEVICE) {
             if (!(flags & SerializeFlag::NO_VNDK)) {
diff --git a/test/Android.bp b/test/Android.bp
index 540298a..d2121c6 100644
--- a/test/Android.bp
+++ b/test/Android.bp
@@ -63,6 +63,7 @@ cc_test {
     static_libs: [
         "libgtest",
         "libgmock",
+        "libhidl-gen-utils",
         "libvintftest",
     ],
     cflags: [
diff --git a/test/AssembleVintfTest.cpp b/test/AssembleVintfTest.cpp
index 912a11d..64dfc3e 100644
--- a/test/AssembleVintfTest.cpp
+++ b/test/AssembleVintfTest.cpp
@@ -77,11 +77,12 @@ TEST_F(AssembleVintfTest, FrameworkMatrixEmpty) {
         {"BOARD_SEPOLICY_VERS", "10000.0"},
         {"FRAMEWORK_VBMETA_VERSION", "1.0"},
     });
-    getInstance()->addKernelConfigInputStream({3, 18}, "android-base.cfg", makeStream(kernel318));
-    getInstance()->addKernelConfigInputStream({3, 18}, "android-base-arm64.cfg",
+    getInstance()->addKernelConfigInputStream({3, 18, 0}, "android-base.cfg",
+                                              makeStream(kernel318));
+    getInstance()->addKernelConfigInputStream({3, 18, 0}, "android-base-arm64.cfg",
                                               makeStream(kernel318_64));
-    getInstance()->addKernelConfigInputStream({4, 4}, "android-base.cfg", makeStream(kernel44));
-    getInstance()->addKernelConfigInputStream({4, 4}, "android-base-arm64.cfg",
+    getInstance()->addKernelConfigInputStream({4, 4, 0}, "android-base.cfg", makeStream(kernel44));
+    getInstance()->addKernelConfigInputStream({4, 4, 0}, "android-base-arm64.cfg",
                                               makeStream(kernel44_64));
 
     EXPECT_TRUE(getInstance()->assemble());
diff --git a/test/LibVintfTest.cpp b/test/LibVintfTest.cpp
index d705243..e7a609a 100644
--- a/test/LibVintfTest.cpp
+++ b/test/LibVintfTest.cpp
@@ -1355,15 +1355,9 @@ TEST_F(LibVintfTest, HalManifestConverterXmlFile) {
 TEST_F(LibVintfTest, CompatibilityMatrixConverterXmlFile) {
     CompatibilityMatrix cm;
     addXmlFile(cm, "media_profile", {1, 0});
-    std::string xml = gCompatibilityMatrixConverter(cm);
+    std::string xml = gCompatibilityMatrixConverter(cm, SerializeFlag::XMLFILES_ONLY);
     EXPECT_EQ(xml,
               "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
-              "    <sepolicy>\n"
-              "        <kernel-sepolicy-version>0</kernel-sepolicy-version>\n"
-              "    </sepolicy>\n"
-              "    <avb>\n"
-              "        <vbmeta-version>0.0</vbmeta-version>\n"
-              "    </avb>\n"
               "    <xmlfile format=\"dtd\" optional=\"true\">\n"
               "        <name>media_profile</name>\n"
               "        <version>1.0</version>\n"
diff --git a/test/vintf_object_tests.cpp b/test/vintf_object_tests.cpp
index f75baa3..659bd2b 100644
--- a/test/vintf_object_tests.cpp
+++ b/test/vintf_object_tests.cpp
@@ -25,13 +25,19 @@
 #include <android-base/properties.h>
 #endif
 
+#include <android-base/strings.h>
+#include <vintf/VintfObject.h>
+#include <vintf/parse_string.h>
 #include "utils-fake.h"
-#include "vintf/VintfObject.h"
+
+#include <hidl-util/FQName.h>
 
 using namespace ::testing;
 using namespace ::android::vintf;
 using namespace ::android::vintf::details;
 
+using android::FQName;
+
 //
 // Set of Xml1 metadata compatible with each other.
 //
@@ -167,6 +173,59 @@ const std::string vendorManifestXml2 =
     "    </sepolicy>\n"
     "</manifest>";
 
+//
+// Set of framework matrices of different FCM version.
+//
+
+const std::string systemMatrixLevel1 =
+    "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
+    "    <hal format=\"hidl\" optional=\"true\">\n"
+    "        <name>android.hardware.major</name>\n"
+    "        <version>1.0</version>\n"
+    "        <interface>\n"
+    "            <name>IMajor</name>\n"
+    "            <instance>default</instance>\n"
+    "        </interface>\n"
+    "    </hal>\n"
+    "    <hal format=\"hidl\" optional=\"true\">\n"
+    "        <name>android.hardware.removed</name>\n"
+    "        <version>1.0</version>\n"
+    "        <interface>\n"
+    "            <name>IRemoved</name>\n"
+    "            <instance>default</instance>\n"
+    "        </interface>\n"
+    "    </hal>\n"
+    "    <hal format=\"hidl\" optional=\"true\">\n"
+    "        <name>android.hardware.minor</name>\n"
+    "        <version>1.0</version>\n"
+    "        <interface>\n"
+    "            <name>IMinor</name>\n"
+    "            <instance>default</instance>\n"
+    "            <instance>legacy</instance>\n"
+    "        </interface>\n"
+    "    </hal>\n"
+    "</compatibility-matrix>\n";
+
+const std::string systemMatrixLevel2 =
+    "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"2\">\n"
+    "    <hal format=\"hidl\" optional=\"true\">\n"
+    "        <name>android.hardware.major</name>\n"
+    "        <version>2.0</version>\n"
+    "        <interface>\n"
+    "            <name>IMajor</name>\n"
+    "            <instance>default</instance>\n"
+    "        </interface>\n"
+    "    </hal>\n"
+    "    <hal format=\"hidl\" optional=\"true\">\n"
+    "        <name>android.hardware.minor</name>\n"
+    "        <version>1.1</version>\n"
+    "        <interface>\n"
+    "            <name>IMinor</name>\n"
+    "            <instance>default</instance>\n"
+    "        </interface>\n"
+    "    </hal>\n"
+    "</compatibility-matrix>\n";
+
 // Setup the MockFileFetcher used by the fetchAllInformation template
 // so it returns the given metadata info instead of fetching from device.
 void setupMockFetcher(const std::string& vendorManifestXml, const std::string& systemMatrixXml,
@@ -776,6 +835,137 @@ TEST_F(OdmManifestTest, OdmLegacyManifest) {
     EXPECT_TRUE(containsOdmManifest(p));
 }
 
+struct FQInstance {
+    FQName fqName;
+    std::string instance;
+
+    FQInstance(const char* s) : FQInstance(std::string(s)) {}
+    FQInstance(const std::string& s) {
+        auto tokens = android::base::Split(s, "/");
+        CHECK(2u == tokens.size());
+        fqName = FQName(tokens[0]);
+        CHECK(fqName.isValid());
+        instance = tokens[1];
+    }
+
+    Version getVersion() const {
+        return Version{fqName.getPackageMajorVersion(), fqName.getPackageMinorVersion()};
+    }
+};
+
+class DeprecateTest : public VintfObjectTestBase {
+   protected:
+    virtual void SetUp() override {
+        EXPECT_CALL(fetcher(), listFiles(StrEq(kSystemVintfDir), _, _))
+            .WillRepeatedly(Invoke([](const auto&, auto* out, auto*) {
+                *out = {
+                    "compatibility_matrix.1.xml",
+                    "compatibility_matrix.2.xml",
+                };
+                return ::android::OK;
+            }));
+        expectFetch(kSystemVintfDir + "compatibility_matrix.1.xml", systemMatrixLevel1);
+        expectFetch(kSystemVintfDir + "compatibility_matrix.2.xml", systemMatrixLevel2);
+        expectSystemMatrix(0);
+
+        expectFetch(kVendorManifest,
+                    "<manifest version=\"1.0\" type=\"device\" target-level=\"2\"/>");
+        expectFileNotExist(StartsWith("/odm/"));
+
+        // Update the device manifest cache because CheckDeprecate does not fetch
+        // device manifest again if cache exist.
+        VintfObject::GetDeviceHalManifest(true /* skipCache */);
+    }
+
+    VintfObject::IsInstanceInUse getPredicate(const std::vector<FQInstance>& instances) {
+        return [instances](const std::string& package, Version version,
+                           const std::string& interface, const std::string& instance) {
+            for (auto&& existing : instances) {
+                if (existing.fqName.package() == package &&
+                    existing.getVersion().minorAtLeast(version) &&
+                    existing.fqName.name() == interface && existing.instance == instance) {
+                    return std::make_pair(true, existing.getVersion());
+                }
+            }
+
+            return std::make_pair(false, Version{});
+        };
+    }
+};
+
+TEST_F(DeprecateTest, CheckNoDeprecate) {
+    auto pred = getPredicate({
+        "android.hardware.minor@1.1::IMinor/default",
+        "android.hardware.major@2.0::IMajor/default",
+    });
+    std::string error;
+    EXPECT_EQ(NO_DEPRECATED_HALS, VintfObject::CheckDeprecation(pred, &error)) << error;
+}
+
+TEST_F(DeprecateTest, CheckRemoved) {
+    auto pred = getPredicate({
+        "android.hardware.removed@1.0::IRemoved/default",
+        "android.hardware.minor@1.1::IMinor/default",
+        "android.hardware.major@2.0::IMajor/default",
+    });
+    std::string error;
+    EXPECT_EQ(DEPRECATED, VintfObject::CheckDeprecation(pred, &error))
+        << "removed@1.0 should be deprecated. " << error;
+}
+
+TEST_F(DeprecateTest, CheckMinor) {
+    auto pred = getPredicate({
+        "android.hardware.minor@1.0::IMinor/default",
+        "android.hardware.major@2.0::IMajor/default",
+    });
+    std::string error;
+    EXPECT_EQ(DEPRECATED, VintfObject::CheckDeprecation(pred, &error))
+        << "minor@1.0 should be deprecated. " << error;
+}
+
+TEST_F(DeprecateTest, CheckMinorDeprecatedInstance1) {
+    auto pred = getPredicate({
+        "android.hardware.minor@1.0::IMinor/legacy",
+        "android.hardware.minor@1.1::IMinor/default",
+        "android.hardware.major@2.0::IMajor/default",
+    });
+    std::string error;
+    EXPECT_EQ(DEPRECATED, VintfObject::CheckDeprecation(pred, &error))
+        << "minor@1.0::IMinor/legacy should be deprecated. " << error;
+}
+
+TEST_F(DeprecateTest, CheckMinorDeprecatedInstance2) {
+    auto pred = getPredicate({
+        "android.hardware.minor@1.1::IMinor/default",
+        "android.hardware.minor@1.1::IMinor/legacy",
+        "android.hardware.major@2.0::IMajor/default",
+    });
+    std::string error;
+    EXPECT_EQ(DEPRECATED, VintfObject::CheckDeprecation(pred, &error))
+        << "minor@1.1::IMinor/legacy should be deprecated. " << error;
+}
+
+TEST_F(DeprecateTest, CheckMajor1) {
+    auto pred = getPredicate({
+        "android.hardware.minor@1.1::IMinor/default",
+        "android.hardware.major@1.0::IMajor/default",
+        "android.hardware.major@2.0::IMajor/default",
+    });
+    std::string error;
+    EXPECT_EQ(DEPRECATED, VintfObject::CheckDeprecation(pred, &error))
+        << "major@1.0 should be deprecated. " << error;
+}
+
+TEST_F(DeprecateTest, CheckMajor2) {
+    auto pred = getPredicate({
+        "android.hardware.minor@1.1::IMinor/default",
+        "android.hardware.major@1.0::IMajor/default",
+    });
+    std::string error;
+    EXPECT_EQ(DEPRECATED, VintfObject::CheckDeprecation(pred, &error))
+        << "major@1.0 should be deprecated. " << error;
+}
+
 int main(int argc, char** argv) {
     ::testing::InitGoogleMock(&argc, argv);