| /* |
| * Copyright (C) 2015 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 "link/ManifestFixer.h" |
| |
| #include "test/Test.h" |
| |
| using ::android::StringPiece; |
| using ::testing::IsNull; |
| using ::testing::NotNull; |
| using ::testing::StrEq; |
| |
| namespace aapt { |
| |
| struct ManifestFixerTest : public ::testing::Test { |
| std::unique_ptr<IAaptContext> mContext; |
| |
| void SetUp() override { |
| mContext = |
| test::ContextBuilder() |
| .SetCompilationPackage("android") |
| .SetPackageId(0x01) |
| .SetNameManglerPolicy(NameManglerPolicy{"android"}) |
| .AddSymbolSource( |
| test::StaticSymbolSourceBuilder() |
| .AddSymbol( |
| "android:attr/package", ResourceId(0x01010000), |
| test::AttributeBuilder() |
| .SetTypeMask(android::ResTable_map::TYPE_STRING) |
| .Build()) |
| .AddSymbol( |
| "android:attr/minSdkVersion", ResourceId(0x01010001), |
| test::AttributeBuilder() |
| .SetTypeMask(android::ResTable_map::TYPE_STRING | |
| android::ResTable_map::TYPE_INTEGER) |
| .Build()) |
| .AddSymbol( |
| "android:attr/targetSdkVersion", ResourceId(0x01010002), |
| test::AttributeBuilder() |
| .SetTypeMask(android::ResTable_map::TYPE_STRING | |
| android::ResTable_map::TYPE_INTEGER) |
| .Build()) |
| .AddSymbol("android:string/str", ResourceId(0x01060000)) |
| .Build()) |
| .Build(); |
| } |
| |
| std::unique_ptr<xml::XmlResource> Verify(const StringPiece& str) { |
| return VerifyWithOptions(str, {}); |
| } |
| |
| std::unique_ptr<xml::XmlResource> VerifyWithOptions( |
| const StringPiece& str, const ManifestFixerOptions& options) { |
| std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(str); |
| ManifestFixer fixer(options); |
| if (fixer.Consume(mContext.get(), doc.get())) { |
| return doc; |
| } |
| return {}; |
| } |
| }; |
| |
| TEST_F(ManifestFixerTest, EnsureManifestIsRootTag) { |
| EXPECT_EQ(nullptr, Verify("<other-tag />")); |
| EXPECT_EQ(nullptr, Verify("<ns:manifest xmlns:ns=\"com\" />")); |
| EXPECT_NE(nullptr, Verify("<manifest package=\"android\"></manifest>")); |
| } |
| |
| TEST_F(ManifestFixerTest, EnsureManifestHasPackage) { |
| EXPECT_NE(nullptr, Verify("<manifest package=\"android\" />")); |
| EXPECT_NE(nullptr, Verify("<manifest package=\"com.android\" />")); |
| EXPECT_NE(nullptr, Verify("<manifest package=\"com.android.google\" />")); |
| EXPECT_EQ(nullptr, |
| Verify("<manifest package=\"com.android.google.Class$1\" />")); |
| EXPECT_EQ(nullptr, Verify("<manifest " |
| "xmlns:android=\"http://schemas.android.com/apk/" |
| "res/android\" " |
| "android:package=\"com.android\" />")); |
| EXPECT_EQ(nullptr, Verify("<manifest package=\"@string/str\" />")); |
| } |
| |
| TEST_F(ManifestFixerTest, AllowMetaData) { |
| auto doc = Verify(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <meta-data /> |
| <application> |
| <meta-data /> |
| <activity android:name=".Hi"><meta-data /></activity> |
| <activity-alias android:name=".Ho"><meta-data /></activity-alias> |
| <receiver android:name=".OffTo"><meta-data /></receiver> |
| <provider android:name=".Work"><meta-data /></provider> |
| <service android:name=".We"><meta-data /></service> |
| </application> |
| <instrumentation android:name=".Go"><meta-data /></instrumentation> |
| </manifest>)EOF"); |
| ASSERT_NE(nullptr, doc); |
| } |
| |
| TEST_F(ManifestFixerTest, UseDefaultSdkVersionsIfNonePresent) { |
| ManifestFixerOptions options; |
| options.min_sdk_version_default = std::string("8"); |
| options.target_sdk_version_default = std::string("22"); |
| |
| std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <uses-sdk android:minSdkVersion="7" android:targetSdkVersion="21" /> |
| </manifest>)EOF", |
| options); |
| ASSERT_NE(nullptr, doc); |
| |
| xml::Element* el; |
| xml::Attribute* attr; |
| |
| el = doc->root.get(); |
| ASSERT_NE(nullptr, el); |
| el = el->FindChild({}, "uses-sdk"); |
| ASSERT_NE(nullptr, el); |
| attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ("7", attr->value); |
| attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ("21", attr->value); |
| |
| doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <uses-sdk android:targetSdkVersion="21" /> |
| </manifest>)EOF", |
| options); |
| ASSERT_NE(nullptr, doc); |
| |
| el = doc->root.get(); |
| ASSERT_NE(nullptr, el); |
| el = el->FindChild({}, "uses-sdk"); |
| ASSERT_NE(nullptr, el); |
| attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ("8", attr->value); |
| attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ("21", attr->value); |
| |
| doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <uses-sdk /> |
| </manifest>)EOF", |
| options); |
| ASSERT_NE(nullptr, doc); |
| |
| el = doc->root.get(); |
| ASSERT_NE(nullptr, el); |
| el = el->FindChild({}, "uses-sdk"); |
| ASSERT_NE(nullptr, el); |
| attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ("8", attr->value); |
| attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ("22", attr->value); |
| |
| doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android" />)EOF", |
| options); |
| ASSERT_NE(nullptr, doc); |
| |
| el = doc->root.get(); |
| ASSERT_NE(nullptr, el); |
| el = el->FindChild({}, "uses-sdk"); |
| ASSERT_NE(nullptr, el); |
| attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ("8", attr->value); |
| attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ("22", attr->value); |
| } |
| |
| TEST_F(ManifestFixerTest, UsesSdkMustComeBeforeApplication) { |
| ManifestFixerOptions options; |
| options.min_sdk_version_default = std::string("8"); |
| options.target_sdk_version_default = std::string("22"); |
| std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <application android:name=".MainApplication" /> |
| </manifest>)EOF", |
| options); |
| ASSERT_NE(nullptr, doc); |
| |
| xml::Element* manifest_el = doc->root.get(); |
| ASSERT_NE(nullptr, manifest_el); |
| ASSERT_EQ("manifest", manifest_el->name); |
| |
| xml::Element* application_el = manifest_el->FindChild("", "application"); |
| ASSERT_NE(nullptr, application_el); |
| |
| xml::Element* uses_sdk_el = manifest_el->FindChild("", "uses-sdk"); |
| ASSERT_NE(nullptr, uses_sdk_el); |
| |
| // Check that the uses_sdk_el comes before application_el in the children |
| // vector. |
| // Since there are no namespaces here, these children are direct descendants |
| // of manifest. |
| auto uses_sdk_iter = |
| std::find_if(manifest_el->children.begin(), manifest_el->children.end(), |
| [&](const std::unique_ptr<xml::Node>& child) { |
| return child.get() == uses_sdk_el; |
| }); |
| |
| auto application_iter = |
| std::find_if(manifest_el->children.begin(), manifest_el->children.end(), |
| [&](const std::unique_ptr<xml::Node>& child) { |
| return child.get() == application_el; |
| }); |
| |
| ASSERT_NE(manifest_el->children.end(), uses_sdk_iter); |
| ASSERT_NE(manifest_el->children.end(), application_iter); |
| |
| // The distance should be positive, meaning uses_sdk_iter comes before |
| // application_iter. |
| EXPECT_GT(std::distance(uses_sdk_iter, application_iter), 0); |
| } |
| |
| TEST_F(ManifestFixerTest, RenameManifestPackageAndFullyQualifyClasses) { |
| ManifestFixerOptions options; |
| options.rename_manifest_package = std::string("com.android"); |
| |
| std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <application android:name=".MainApplication" text="hello"> |
| <activity android:name=".activity.Start" /> |
| <receiver android:name="com.google.android.Receiver" /> |
| </application> |
| </manifest>)EOF", |
| options); |
| ASSERT_NE(nullptr, doc); |
| |
| xml::Element* manifestEl = doc->root.get(); |
| ASSERT_NE(nullptr, manifestEl); |
| |
| xml::Attribute* attr = nullptr; |
| |
| attr = manifestEl->FindAttribute({}, "package"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ(std::string("com.android"), attr->value); |
| |
| xml::Element* applicationEl = manifestEl->FindChild({}, "application"); |
| ASSERT_NE(nullptr, applicationEl); |
| |
| attr = applicationEl->FindAttribute(xml::kSchemaAndroid, "name"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ(std::string("android.MainApplication"), attr->value); |
| |
| attr = applicationEl->FindAttribute({}, "text"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ(std::string("hello"), attr->value); |
| |
| xml::Element* el; |
| el = applicationEl->FindChild({}, "activity"); |
| ASSERT_NE(nullptr, el); |
| |
| attr = el->FindAttribute(xml::kSchemaAndroid, "name"); |
| ASSERT_NE(nullptr, el); |
| EXPECT_EQ(std::string("android.activity.Start"), attr->value); |
| |
| el = applicationEl->FindChild({}, "receiver"); |
| ASSERT_NE(nullptr, el); |
| |
| attr = el->FindAttribute(xml::kSchemaAndroid, "name"); |
| ASSERT_NE(nullptr, el); |
| EXPECT_EQ(std::string("com.google.android.Receiver"), attr->value); |
| } |
| |
| TEST_F(ManifestFixerTest, |
| RenameManifestInstrumentationPackageAndFullyQualifyTarget) { |
| ManifestFixerOptions options; |
| options.rename_instrumentation_target_package = std::string("com.android"); |
| |
| std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <instrumentation android:name=".TestRunner" android:targetPackage="android" /> |
| </manifest>)EOF", |
| options); |
| ASSERT_NE(nullptr, doc); |
| |
| xml::Element* manifest_el = doc->root.get(); |
| ASSERT_NE(nullptr, manifest_el); |
| |
| xml::Element* instrumentation_el = |
| manifest_el->FindChild({}, "instrumentation"); |
| ASSERT_NE(nullptr, instrumentation_el); |
| |
| xml::Attribute* attr = |
| instrumentation_el->FindAttribute(xml::kSchemaAndroid, "targetPackage"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ(std::string("com.android"), attr->value); |
| } |
| |
| TEST_F(ManifestFixerTest, UseDefaultVersionNameAndCode) { |
| ManifestFixerOptions options; |
| options.version_name_default = std::string("Beta"); |
| options.version_code_default = std::string("0x10000000"); |
| |
| std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android" />)EOF", |
| options); |
| ASSERT_NE(nullptr, doc); |
| |
| xml::Element* manifest_el = doc->root.get(); |
| ASSERT_NE(nullptr, manifest_el); |
| |
| xml::Attribute* attr = |
| manifest_el->FindAttribute(xml::kSchemaAndroid, "versionName"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ(std::string("Beta"), attr->value); |
| |
| attr = manifest_el->FindAttribute(xml::kSchemaAndroid, "versionCode"); |
| ASSERT_NE(nullptr, attr); |
| EXPECT_EQ(std::string("0x10000000"), attr->value); |
| } |
| |
| TEST_F(ManifestFixerTest, DontUseDefaultVersionNameAndCode) { |
| ManifestFixerOptions options; |
| options.version_name_default = std::string("Beta"); |
| options.version_code_default = std::string("0x10000000"); |
| |
| std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android" |
| android:versionCode="0x20000000" |
| android:versionName="Alpha" />)EOF", |
| options); |
| ASSERT_THAT(doc, NotNull()); |
| |
| xml::Element* manifest_el = doc->root.get(); |
| ASSERT_THAT(manifest_el, NotNull()); |
| |
| xml::Attribute* attr = |
| manifest_el->FindAttribute(xml::kSchemaAndroid, "versionName"); |
| ASSERT_THAT(attr, NotNull()); |
| EXPECT_THAT(attr->value, StrEq("Alpha")); |
| |
| attr = manifest_el->FindAttribute(xml::kSchemaAndroid, "versionCode"); |
| ASSERT_THAT(attr, NotNull()); |
| EXPECT_THAT(attr->value, StrEq("0x20000000")); |
| } |
| |
| TEST_F(ManifestFixerTest, ReplaceVersionNameAndCode) { |
| ManifestFixerOptions options; |
| options.replace_version = true; |
| options.version_name_default = std::string("Beta"); |
| options.version_code_default = std::string("0x10000000"); |
| |
| std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android" |
| android:versionCode="0x20000000" |
| android:versionName="Alpha" />)EOF", |
| options); |
| ASSERT_THAT(doc, NotNull()); |
| |
| xml::Element* manifest_el = doc->root.get(); |
| ASSERT_THAT(manifest_el, NotNull()); |
| |
| xml::Attribute* attr = |
| manifest_el->FindAttribute(xml::kSchemaAndroid, "versionName"); |
| ASSERT_THAT(attr, NotNull()); |
| EXPECT_THAT(attr->value, StrEq("Beta")); |
| |
| attr = manifest_el->FindAttribute(xml::kSchemaAndroid, "versionCode"); |
| ASSERT_THAT(attr, NotNull()); |
| EXPECT_THAT(attr->value, StrEq("0x10000000")); |
| } |
| |
| TEST_F(ManifestFixerTest, ReplaceVersionName) { |
| ManifestFixerOptions options; |
| options.replace_version = true; |
| options.version_name_default = std::string("Beta"); |
| |
| std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android" |
| android:versionCode="0x20000000" |
| android:versionName="Alpha" />)EOF", |
| options); |
| ASSERT_THAT(doc, NotNull()); |
| |
| xml::Element* manifest_el = doc->root.get(); |
| ASSERT_THAT(manifest_el, NotNull()); |
| |
| xml::Attribute* attr = |
| manifest_el->FindAttribute(xml::kSchemaAndroid, "versionName"); |
| ASSERT_THAT(attr, NotNull()); |
| EXPECT_THAT(attr->value, StrEq("Beta")); |
| |
| attr = manifest_el->FindAttribute(xml::kSchemaAndroid, "versionCode"); |
| ASSERT_THAT(attr, NotNull()); |
| EXPECT_THAT(attr->value, StrEq("0x20000000")); |
| } |
| |
| TEST_F(ManifestFixerTest, ReplaceVersionCode) { |
| ManifestFixerOptions options; |
| options.replace_version = true; |
| options.version_code_default = std::string("0x10000000"); |
| |
| std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android" |
| android:versionCode="0x20000000" |
| android:versionName="Alpha" />)EOF", |
| options); |
| ASSERT_THAT(doc, NotNull()); |
| |
| xml::Element* manifest_el = doc->root.get(); |
| ASSERT_THAT(manifest_el, NotNull()); |
| |
| xml::Attribute* attr = |
| manifest_el->FindAttribute(xml::kSchemaAndroid, "versionName"); |
| ASSERT_THAT(attr, NotNull()); |
| EXPECT_THAT(attr->value, StrEq("Alpha")); |
| |
| attr = manifest_el->FindAttribute(xml::kSchemaAndroid, "versionCode"); |
| ASSERT_THAT(attr, NotNull()); |
| EXPECT_THAT(attr->value, StrEq("0x10000000")); |
| } |
| |
| TEST_F(ManifestFixerTest, DontReplaceVersionNameOrCode) { |
| ManifestFixerOptions options; |
| options.replace_version = true; |
| |
| std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android" |
| android:versionCode="0x20000000" |
| android:versionName="Alpha" />)EOF", |
| options); |
| ASSERT_THAT(doc, NotNull()); |
| |
| xml::Element* manifest_el = doc->root.get(); |
| ASSERT_THAT(manifest_el, NotNull()); |
| |
| xml::Attribute* attr = |
| manifest_el->FindAttribute(xml::kSchemaAndroid, "versionName"); |
| ASSERT_THAT(attr, NotNull()); |
| EXPECT_THAT(attr->value, StrEq("Alpha")); |
| |
| attr = manifest_el->FindAttribute(xml::kSchemaAndroid, "versionCode"); |
| ASSERT_THAT(attr, NotNull()); |
| EXPECT_THAT(attr->value, StrEq("0x20000000")); |
| } |
| |
| TEST_F(ManifestFixerTest, EnsureManifestAttributesAreTyped) { |
| EXPECT_EQ(nullptr, |
| Verify("<manifest package=\"android\" coreApp=\"hello\" />")); |
| EXPECT_EQ(nullptr, |
| Verify("<manifest package=\"android\" coreApp=\"1dp\" />")); |
| |
| std::unique_ptr<xml::XmlResource> doc = |
| Verify("<manifest package=\"android\" coreApp=\"true\" />"); |
| ASSERT_NE(nullptr, doc); |
| |
| xml::Element* el = doc->root.get(); |
| ASSERT_NE(nullptr, el); |
| |
| EXPECT_EQ("manifest", el->name); |
| |
| xml::Attribute* attr = el->FindAttribute("", "coreApp"); |
| ASSERT_NE(nullptr, attr); |
| |
| EXPECT_NE(nullptr, attr->compiled_value); |
| EXPECT_NE(nullptr, ValueCast<BinaryPrimitive>(attr->compiled_value.get())); |
| } |
| |
| TEST_F(ManifestFixerTest, UsesFeatureMustHaveNameOrGlEsVersion) { |
| std::string input = R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <uses-feature android:name="feature" /> |
| <uses-feature android:glEsVersion="1" /> |
| <feature-group /> |
| <feature-group> |
| <uses-feature android:name="feature_in_group" /> |
| <uses-feature android:glEsVersion="2" /> |
| </feature-group> |
| </manifest>)EOF"; |
| EXPECT_NE(nullptr, Verify(input)); |
| |
| input = R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <uses-feature android:name="feature" android:glEsVersion="1" /> |
| </manifest>)EOF"; |
| EXPECT_EQ(nullptr, Verify(input)); |
| |
| input = R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <uses-feature /> |
| </manifest>)EOF"; |
| EXPECT_EQ(nullptr, Verify(input)); |
| |
| input = R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <feature-group> |
| <uses-feature android:name="feature" android:glEsVersion="1" /> |
| </feature-group> |
| </manifest>)EOF"; |
| EXPECT_EQ(nullptr, Verify(input)); |
| |
| input = R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <feature-group> |
| <uses-feature /> |
| </feature-group> |
| </manifest>)EOF"; |
| EXPECT_EQ(nullptr, Verify(input)); |
| } |
| |
| TEST_F(ManifestFixerTest, IgnoreNamespacedElements) { |
| std::string input = R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <special:tag whoo="true" xmlns:special="http://google.com" /> |
| </manifest>)EOF"; |
| EXPECT_NE(nullptr, Verify(input)); |
| } |
| |
| TEST_F(ManifestFixerTest, DoNotIgnoreNonNamespacedElements) { |
| std::string input = R"EOF( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <tag whoo="true" /> |
| </manifest>)EOF"; |
| EXPECT_EQ(nullptr, Verify(input)); |
| } |
| |
| TEST_F(ManifestFixerTest, SupportKeySets) { |
| std::string input = R"( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <key-sets> |
| <key-set android:name="old-set"> |
| <public-key android:name="old-key" android:value="some+old+key" /> |
| </key-set> |
| <key-set android:name="new-set"> |
| <public-key android:name="new-key" android:value="some+new+key" /> |
| </key-set> |
| <upgrade-key-set android:name="old-set" /> |
| <upgrade-key-set android:name="new-set" /> |
| </key-sets> |
| </manifest>)"; |
| EXPECT_THAT(Verify(input), NotNull()); |
| } |
| |
| TEST_F(ManifestFixerTest, UnexpectedElementsInManifest) { |
| std::string input = R"( |
| <manifest xmlns:android="http://schemas.android.com/apk/res/android" |
| package="android"> |
| <beep/> |
| </manifest>)"; |
| ManifestFixerOptions options; |
| options.warn_validation = true; |
| |
| // Unexpected element should result in a warning if the flag is set to 'true'. |
| std::unique_ptr<xml::XmlResource> manifest = VerifyWithOptions(input, options); |
| ASSERT_THAT(manifest, NotNull()); |
| |
| // Unexpected element should result in an error if the flag is set to 'false'. |
| options.warn_validation = false; |
| manifest = VerifyWithOptions(input, options); |
| ASSERT_THAT(manifest, IsNull()); |
| |
| // By default the flag should be set to 'false'. |
| manifest = Verify(input); |
| ASSERT_THAT(manifest, IsNull()); |
| } |
| |
| } // namespace aapt |