tools/aapt2/link/FlaggedResources_test.cpp - platform/frameworks/base - Git at Google

 /*
  * 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 <regex>
 #include <string>

 #include "LoadedApk.h"
 #include "cmd/Dump.h"
 #include "io/StringStream.h"
 #include "test/Common.h"
 #include "test/Test.h"
 #include "text/Printer.h"

 using ::aapt::io::StringOutputStream;
 using ::aapt::text::Printer;
 using testing::Eq;
 using testing::Ne;

 namespace aapt {

 using FlaggedResourcesTest = CommandTestFixture;

 static android::NoOpDiagnostics noop_diag;

 void DumpStringPoolToString(LoadedApk* loaded_apk, std::string* output) {
   StringOutputStream output_stream(output);
   Printer printer(&output_stream);

   DumpStringsCommand command(&printer, &noop_diag);
   ASSERT_EQ(command.Dump(loaded_apk), 0);
   output_stream.Flush();
 }

 void DumpResourceTableToString(LoadedApk* loaded_apk, std::string* output) {
   StringOutputStream output_stream(output);
   Printer printer(&output_stream);

   DumpTableCommand command(&printer, &noop_diag);
   ASSERT_EQ(command.Dump(loaded_apk), 0);
   output_stream.Flush();
 }

 void DumpChunksToString(LoadedApk* loaded_apk, std::string* output) {
   StringOutputStream output_stream(output);
   Printer printer(&output_stream);

   DumpChunks command(&printer, &noop_diag);
   ASSERT_EQ(command.Dump(loaded_apk), 0);
   output_stream.Flush();
 }

 void DumpXmlTreeToString(LoadedApk* loaded_apk, std::string file, std::string* output) {
   StringOutputStream output_stream(output);
   Printer printer(&output_stream);

   auto xml = loaded_apk->LoadXml(file, &noop_diag);
   ASSERT_NE(xml, nullptr);
   Debug::DumpXml(*xml, &printer);
   output_stream.Flush();
 }

 TEST_F(FlaggedResourcesTest, DisabledStringRemovedFromPool) {
   auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
   auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

   std::string output;
   DumpStringPoolToString(loaded_apk.get(), &output);

   std::string excluded = "DONTFIND";
   ASSERT_EQ(output.find(excluded), std::string::npos);
 }

 TEST_F(FlaggedResourcesTest, DisabledResourcesRemovedFromTable) {
   auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
   auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

   std::string output;
   DumpResourceTableToString(loaded_apk.get(), &output);
   ASSERT_EQ(output.find("bool4"), std::string::npos);
   ASSERT_EQ(output.find("str1"), std::string::npos);
   ASSERT_EQ(output.find("layout2"), std::string::npos);
   ASSERT_EQ(output.find("removedpng"), std::string::npos);
 }

 TEST_F(FlaggedResourcesTest, DisabledResourcesRemovedFromTableChunks) {
   auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
   auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

   std::string output;
   DumpChunksToString(loaded_apk.get(), &output);

   ASSERT_EQ(output.find("bool4"), std::string::npos);
   ASSERT_EQ(output.find("str1"), std::string::npos);
   ASSERT_EQ(output.find("layout2"), std::string::npos);
   ASSERT_EQ(output.find("removedpng"), std::string::npos);
 }

 TEST_F(FlaggedResourcesTest, DisabledResourcesInRJava) {
   auto r_path = file::BuildPath({android::base::GetExecutableDirectory(), "resource-flagging-java",
                                  "com", "android", "intenal", "flaggedresources", "R.java"});
   std::string r_contents;
   ::android::base::ReadFileToString(r_path, &r_contents);

   ASSERT_NE(r_contents.find("public static final int bool4"), std::string::npos);
   ASSERT_NE(r_contents.find("public static final int str1"), std::string::npos);
 }

 TEST_F(FlaggedResourcesTest, TwoValuesSameDisabledFlag) {
   test::TestDiagnosticsImpl diag;
   const std::string compiled_files_dir = GetTestPath("compiled");
   ASSERT_FALSE(CompileFile(
       GetTestPath("res/values/values.xml"),
       R"(<resources xmlns:android="http://schemas.android.com/apk/res/android">
            <bool name="bool1" android:featureFlag="test.package.falseFlag">false</bool>
            <bool name="bool1" android:featureFlag="test.package.falseFlag">true</bool>
          </resources>)",
       compiled_files_dir, &diag,
       {"--feature-flags", "test.package.falseFlag:ro=false,test.package.trueFlag:ro=true"}));
   ASSERT_TRUE(
       diag.GetLog().contains("duplicate flag disabled value for resource 'bool/bool1' with config "
                              "'' and flag 'test.package.falseFlag'"));
 }

 TEST_F(FlaggedResourcesTest, TwoValuesSameDisabledFlagDifferentFiles) {
   test::TestDiagnosticsImpl diag;
   const std::string compiled_files_dir = GetTestPath("compiled");
   ASSERT_TRUE(CompileFile(
       GetTestPath("res/values/values1.xml"),
       R"(<resources xmlns:android="http://schemas.android.com/apk/res/android">
            <bool name="bool1" android:featureFlag="test.package.falseFlag">false</bool>
          </resources>)",
       compiled_files_dir, &diag,
       {"--feature-flags", "test.package.falseFlag:ro=false,test.package.trueFlag:ro=true"}));
   ASSERT_TRUE(CompileFile(
       GetTestPath("res/values/values2.xml"),
       R"(<resources xmlns:android="http://schemas.android.com/apk/res/android">
            <bool name="bool1" android:featureFlag="test.package.falseFlag">true</bool>
          </resources>)",
       compiled_files_dir, &diag,
       {"--feature-flags", "test.package.falseFlag:ro=false,test.package.trueFlag:ro=true"}));
   const std::string out_apk = GetTestPath("out.apk");
   std::vector<std::string> link_args = {
       "--manifest",
       GetDefaultManifest(),
       "-o",
       out_apk,
   };

   ASSERT_FALSE(Link(link_args, compiled_files_dir, &diag));
   ASSERT_TRUE(
       diag.GetLog().contains("duplicate flag_disabled_values value for resource 'bool/bool1' with "
                              "config '' and flag 'test.package.falseFlag'"));
 }

 TEST_F(FlaggedResourcesTest, EnabledXmlElementAttributeRemoved) {
   auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
   auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

   std::string output;
   DumpXmlTreeToString(loaded_apk.get(), "res/layout-v36.1/layout1.xml", &output);
   ASSERT_TRUE(output.contains("FIND_ME"));
 }

 TEST_F(FlaggedResourcesTest, ReadWriteFlagInXmlGetsFlagged) {
   auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
   auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

   std::string output;
   DumpChunksToString(loaded_apk.get(), &output);

   // The actual line looks something like:
   // [ResTable_entry] id: 0x0000 name: layout1 keyIndex: 14 size: 8 flags: 0x0010
   //
   // This regex matches that line and captures the name and the flag value for checking.
   std::regex regex("[0-9a-zA-Z:_\\]\\[ ]+name: ([0-9a-zA-Z]+)[0-9a-zA-Z: ]+flags: (0x\\d{4})");
   std::smatch match;

   std::stringstream ss(output);
   std::string line;
   bool found = false;
   int fields_flagged = 0;
   while (std::getline(ss, line)) {
     bool first_line = false;
     if (line.contains("config: v36")) {
       std::getline(ss, line);
       first_line = true;
     }
     if (!line.contains("flags")) {
       continue;
     }
     if (std::regex_search(line, match, regex) && (match.size() == 3)) {
       unsigned int hex_value;
       std::stringstream hex_ss;
       hex_ss << std::hex << match[2];
       hex_ss >> hex_value;
       if (hex_value & android::ResTable_entry::FLAG_USES_FEATURE_FLAGS) {
         fields_flagged++;
         if (first_line && match[1] == "layout1") {
           found = true;
         }
       }
     }
   }

   ASSERT_TRUE(found) << "No entry for layout1 at v36 with FLAG_USES_FEATURE_FLAGS bit set";
   // There should only be 2 entry that has the FLAG_USES_FEATURE_FLAGS bit of flags set to 1, the
   // three versions of the layout file that has flags
   ASSERT_EQ(fields_flagged, 3);
 }

 TEST_F(FlaggedResourcesTest, FlagInXmlNotRecognized) {
   const std::string compiled_files_dir = GetTestPath("compiled");
   ASSERT_TRUE(
       CompileFile(GetTestPath("res/layout/mylayout.xml"),
                   R"(<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android">
                                       <TextView android:featureFlag="test.package.myFlag"/>
                                       </LinearLayout>)",
                   compiled_files_dir, &noop_diag, {}));
   const std::string manifest_file = GetTestPath("AndroidManifest.xml");
   WriteFile(manifest_file, R"(
     <manifest xmlns:android="http://schemas.android.com/apk/res/android"
         package="com.aapt.command.test">
       <overlay android:targetPackage="com.example.target" />
     </manifest>)");
   const std::string out_apk = GetTestPath("out.apk");
   std::vector<std::string> link_args = {
       "--manifest",
       manifest_file,
       "-o",
       out_apk,
   };

   test::TestDiagnosticsImpl diag;
   ASSERT_FALSE(Link(link_args, compiled_files_dir, &diag));
   ASSERT_TRUE(
       diag.GetLog().contains("res/layout/mylayout.xml:2: error: element 'TextView' has "
                              "flag 'test.package.myFlag' not found in flags from --feature_flags "
                              "parameter"));
 }

 TEST_F(FlaggedResourcesTest, ReadWriteFlagChunk) {
   const std::string compiled_files_dir = GetTestPath("compiled");
   ASSERT_TRUE(CompileFile(GetTestPath("res/values/strings.xml"),
                           R"(<resources  xmlns:android="http://schemas.android.com/apk/res/android">
 <string name="text1" android:featureFlag="test.package.rwFlag">foobar</string>
 <string name="text2">foobar</string>
 <string name="text3" android:featureFlag="test.package.rwFlag">@string/text2</string>
                               </resources>)",
                           compiled_files_dir, &noop_diag,
                           {"--feature-flags", "test.package.rwFlag"}));
   const std::string out_apk = GetTestPath("out.apk");
   std::vector<std::string> link_args = {
       "--manifest",
       GetDefaultManifest(),
       "-o",
       out_apk,
   };

   ASSERT_TRUE(Link(link_args, compiled_files_dir, &noop_diag));

   auto loaded_apk = LoadedApk::LoadApkFromPath(out_apk, &noop_diag);

   std::string output;
   DumpChunksToString(loaded_apk.get(), &output);
   SCOPED_TRACE(output);

   std::string expected1 =
       R"OUT_END(  [RES_TABLE_FLAG_LIST] chunkSize: 12 headerSize: 8 count: 1
     [0] flag name: 1 'test.package.rwFlag')OUT_END";
   ASSERT_TRUE(output.contains(expected1));

   std::string expected2 =
       R"OUT_END([RES_TABLE_FLAGGED] chunkSize: 144 headerSize: 16 name: test.package.rwFlag negated: false
       [ResTable_type] chunkSize: 128 headerSize: 84 id: 0x01 name: string flags: 0x00 (DENSE) entryCount: 3 entryStart: 96 config:
         [ResTable_entry] id: 0x0000 name: text1 keyIndex: 0 size: 8 flags: 0x0010
           [Res_value] size: 8 dataType: 0x03 (string) data: 0x00000000 ("foobar")
         [ResTable_entry] id: 0x0002 name: text3 keyIndex: 2 size: 8 flags: 0x0010
           [Res_value] size: 8 dataType: 0x01 (reference) data: 0x7f010001 (@0x7f010001))OUT_END";
   ASSERT_TRUE(output.contains(expected2));
 }

 TEST_F(FlaggedResourcesTest, ReadWriteFlagsOnOverlaySucceeds) {
   const std::string compiled_files_dir = GetTestPath("compiled");
   ASSERT_TRUE(CompileFile(GetTestPath("res/values/strings.xml"),
                           R"(<resources  xmlns:android="http://schemas.android.com/apk/res/android">
 <string name="text1" android:featureFlag="test.package.rwFlag">foobar</string>
                               </resources>)",
                           compiled_files_dir, &noop_diag,
                           {"--feature-flags", "test.package.rwFlag"}));
   const std::string manifest_file = GetTestPath("AndroidManifest.xml");
   WriteFile(manifest_file, R"(
     <manifest xmlns:android="http://schemas.android.com/apk/res/android"
         package="com.aapt.command.test">
       <overlay android:targetPackage="com.example.target" />
     </manifest>)");
   const std::string out_apk = GetTestPath("out.apk");
   std::vector<std::string> link_args = {
       "--manifest",
       manifest_file,
       "-o",
       out_apk,
   };

   test::TestDiagnosticsImpl diag;
   ASSERT_TRUE(Link(link_args, compiled_files_dir, &diag));
 }

 TEST_F(FlaggedResourcesTest, RODisabledManifestElementRemoved) {
   auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
   auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

   std::string output;
   DumpXmlTreeToString(loaded_apk.get(), "AndroidManifest.xml", &output);
   SCOPED_TRACE(output);
   ASSERT_FALSE(output.contains("CAMERA"));
 }

 }  // namespace aapt
	/*
	* 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 <regex>
	#include <string>

	#include "LoadedApk.h"
	#include "cmd/Dump.h"
	#include "io/StringStream.h"
	#include "test/Common.h"
	#include "test/Test.h"
	#include "text/Printer.h"

	using ::aapt::io::StringOutputStream;
	using ::aapt::text::Printer;
	using testing::Eq;
	using testing::Ne;

	namespace aapt {

	using FlaggedResourcesTest = CommandTestFixture;

	static android::NoOpDiagnostics noop_diag;

	void DumpStringPoolToString(LoadedApk* loaded_apk, std::string* output) {
	StringOutputStream output_stream(output);
	Printer printer(&output_stream);

	DumpStringsCommand command(&printer, &noop_diag);
	ASSERT_EQ(command.Dump(loaded_apk), 0);
	output_stream.Flush();
	}

	void DumpResourceTableToString(LoadedApk* loaded_apk, std::string* output) {
	StringOutputStream output_stream(output);
	Printer printer(&output_stream);

	DumpTableCommand command(&printer, &noop_diag);
	ASSERT_EQ(command.Dump(loaded_apk), 0);
	output_stream.Flush();
	}

	void DumpChunksToString(LoadedApk* loaded_apk, std::string* output) {
	StringOutputStream output_stream(output);
	Printer printer(&output_stream);

	DumpChunks command(&printer, &noop_diag);
	ASSERT_EQ(command.Dump(loaded_apk), 0);
	output_stream.Flush();
	}

	void DumpXmlTreeToString(LoadedApk* loaded_apk, std::string file, std::string* output) {
	StringOutputStream output_stream(output);
	Printer printer(&output_stream);

	auto xml = loaded_apk->LoadXml(file, &noop_diag);
	ASSERT_NE(xml, nullptr);
	Debug::DumpXml(*xml, &printer);
	output_stream.Flush();
	}

	TEST_F(FlaggedResourcesTest, DisabledStringRemovedFromPool) {
	auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
	auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

	std::string output;
	DumpStringPoolToString(loaded_apk.get(), &output);

	std::string excluded = "DONTFIND";
	ASSERT_EQ(output.find(excluded), std::string::npos);
	}

	TEST_F(FlaggedResourcesTest, DisabledResourcesRemovedFromTable) {
	auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
	auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

	std::string output;
	DumpResourceTableToString(loaded_apk.get(), &output);
	ASSERT_EQ(output.find("bool4"), std::string::npos);
	ASSERT_EQ(output.find("str1"), std::string::npos);
	ASSERT_EQ(output.find("layout2"), std::string::npos);
	ASSERT_EQ(output.find("removedpng"), std::string::npos);
	}

	TEST_F(FlaggedResourcesTest, DisabledResourcesRemovedFromTableChunks) {
	auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
	auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

	std::string output;
	DumpChunksToString(loaded_apk.get(), &output);

	ASSERT_EQ(output.find("bool4"), std::string::npos);
	ASSERT_EQ(output.find("str1"), std::string::npos);
	ASSERT_EQ(output.find("layout2"), std::string::npos);
	ASSERT_EQ(output.find("removedpng"), std::string::npos);
	}

	TEST_F(FlaggedResourcesTest, DisabledResourcesInRJava) {
	auto r_path = file::BuildPath({android::base::GetExecutableDirectory(), "resource-flagging-java",
	"com", "android", "intenal", "flaggedresources", "R.java"});
	std::string r_contents;
	::android::base::ReadFileToString(r_path, &r_contents);

	ASSERT_NE(r_contents.find("public static final int bool4"), std::string::npos);
	ASSERT_NE(r_contents.find("public static final int str1"), std::string::npos);
	}

	TEST_F(FlaggedResourcesTest, TwoValuesSameDisabledFlag) {
	test::TestDiagnosticsImpl diag;
	const std::string compiled_files_dir = GetTestPath("compiled");
	ASSERT_FALSE(CompileFile(
	GetTestPath("res/values/values.xml"),
	R"(<resources xmlns:android="http://schemas.android.com/apk/res/android">
	<bool name="bool1" android:featureFlag="test.package.falseFlag">false</bool>
	<bool name="bool1" android:featureFlag="test.package.falseFlag">true</bool>
	</resources>)",
	compiled_files_dir, &diag,
	{"--feature-flags", "test.package.falseFlag:ro=false,test.package.trueFlag:ro=true"}));
	ASSERT_TRUE(
	diag.GetLog().contains("duplicate flag disabled value for resource 'bool/bool1' with config "
	"'' and flag 'test.package.falseFlag'"));
	}

	TEST_F(FlaggedResourcesTest, TwoValuesSameDisabledFlagDifferentFiles) {
	test::TestDiagnosticsImpl diag;
	const std::string compiled_files_dir = GetTestPath("compiled");
	ASSERT_TRUE(CompileFile(
	GetTestPath("res/values/values1.xml"),
	R"(<resources xmlns:android="http://schemas.android.com/apk/res/android">
	<bool name="bool1" android:featureFlag="test.package.falseFlag">false</bool>
	</resources>)",
	compiled_files_dir, &diag,
	{"--feature-flags", "test.package.falseFlag:ro=false,test.package.trueFlag:ro=true"}));
	ASSERT_TRUE(CompileFile(
	GetTestPath("res/values/values2.xml"),
	R"(<resources xmlns:android="http://schemas.android.com/apk/res/android">
	<bool name="bool1" android:featureFlag="test.package.falseFlag">true</bool>
	</resources>)",
	compiled_files_dir, &diag,
	{"--feature-flags", "test.package.falseFlag:ro=false,test.package.trueFlag:ro=true"}));
	const std::string out_apk = GetTestPath("out.apk");
	std::vector<std::string> link_args = {
	"--manifest",
	GetDefaultManifest(),
	"-o",
	out_apk,
	};

	ASSERT_FALSE(Link(link_args, compiled_files_dir, &diag));
	ASSERT_TRUE(
	diag.GetLog().contains("duplicate flag_disabled_values value for resource 'bool/bool1' with "
	"config '' and flag 'test.package.falseFlag'"));
	}

	TEST_F(FlaggedResourcesTest, EnabledXmlElementAttributeRemoved) {
	auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
	auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

	std::string output;
	DumpXmlTreeToString(loaded_apk.get(), "res/layout-v36.1/layout1.xml", &output);
	ASSERT_TRUE(output.contains("FIND_ME"));
	}

	TEST_F(FlaggedResourcesTest, ReadWriteFlagInXmlGetsFlagged) {
	auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
	auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

	std::string output;
	DumpChunksToString(loaded_apk.get(), &output);

	// The actual line looks something like:
	// [ResTable_entry] id: 0x0000 name: layout1 keyIndex: 14 size: 8 flags: 0x0010
	//
	// This regex matches that line and captures the name and the flag value for checking.
	std::regex regex("[0-9a-zA-Z:_\\]\\[ ]+name: ([0-9a-zA-Z]+)[0-9a-zA-Z: ]+flags: (0x\\d{4})");
	std::smatch match;

	std::stringstream ss(output);
	std::string line;
	bool found = false;
	int fields_flagged = 0;
	while (std::getline(ss, line)) {
	bool first_line = false;
	if (line.contains("config: v36")) {
	std::getline(ss, line);
	first_line = true;
	}
	if (!line.contains("flags")) {
	continue;
	}
	if (std::regex_search(line, match, regex) && (match.size() == 3)) {
	unsigned int hex_value;
	std::stringstream hex_ss;
	hex_ss << std::hex << match[2];
	hex_ss >> hex_value;
	if (hex_value & android::ResTable_entry::FLAG_USES_FEATURE_FLAGS) {
	fields_flagged++;
	if (first_line && match[1] == "layout1") {
	found = true;
	}
	}
	}
	}

	ASSERT_TRUE(found) << "No entry for layout1 at v36 with FLAG_USES_FEATURE_FLAGS bit set";
	// There should only be 2 entry that has the FLAG_USES_FEATURE_FLAGS bit of flags set to 1, the
	// three versions of the layout file that has flags
	ASSERT_EQ(fields_flagged, 3);
	}

	TEST_F(FlaggedResourcesTest, FlagInXmlNotRecognized) {
	const std::string compiled_files_dir = GetTestPath("compiled");
	ASSERT_TRUE(
	CompileFile(GetTestPath("res/layout/mylayout.xml"),
	R"(<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android">
	<TextView android:featureFlag="test.package.myFlag"/>
	</LinearLayout>)",
	compiled_files_dir, &noop_diag, {}));
	const std::string manifest_file = GetTestPath("AndroidManifest.xml");
	WriteFile(manifest_file, R"(
	<manifest xmlns:android="http://schemas.android.com/apk/res/android"
	package="com.aapt.command.test">
	<overlay android:targetPackage="com.example.target" />
	</manifest>)");
	const std::string out_apk = GetTestPath("out.apk");
	std::vector<std::string> link_args = {
	"--manifest",
	manifest_file,
	"-o",
	out_apk,
	};

	test::TestDiagnosticsImpl diag;
	ASSERT_FALSE(Link(link_args, compiled_files_dir, &diag));
	ASSERT_TRUE(
	diag.GetLog().contains("res/layout/mylayout.xml:2: error: element 'TextView' has "
	"flag 'test.package.myFlag' not found in flags from --feature_flags "
	"parameter"));
	}

	TEST_F(FlaggedResourcesTest, ReadWriteFlagChunk) {
	const std::string compiled_files_dir = GetTestPath("compiled");
	ASSERT_TRUE(CompileFile(GetTestPath("res/values/strings.xml"),
	R"(<resources xmlns:android="http://schemas.android.com/apk/res/android">
	<string name="text1" android:featureFlag="test.package.rwFlag">foobar</string>
	<string name="text2">foobar</string>
	<string name="text3" android:featureFlag="test.package.rwFlag">@string/text2</string>
	</resources>)",
	compiled_files_dir, &noop_diag,
	{"--feature-flags", "test.package.rwFlag"}));
	const std::string out_apk = GetTestPath("out.apk");
	std::vector<std::string> link_args = {
	"--manifest",
	GetDefaultManifest(),
	"-o",
	out_apk,
	};

	ASSERT_TRUE(Link(link_args, compiled_files_dir, &noop_diag));

	auto loaded_apk = LoadedApk::LoadApkFromPath(out_apk, &noop_diag);

	std::string output;
	DumpChunksToString(loaded_apk.get(), &output);
	SCOPED_TRACE(output);

	std::string expected1 =
	R"OUT_END( [RES_TABLE_FLAG_LIST] chunkSize: 12 headerSize: 8 count: 1
	[0] flag name: 1 'test.package.rwFlag')OUT_END";
	ASSERT_TRUE(output.contains(expected1));

	std::string expected2 =
	R"OUT_END([RES_TABLE_FLAGGED] chunkSize: 144 headerSize: 16 name: test.package.rwFlag negated: false
	[ResTable_type] chunkSize: 128 headerSize: 84 id: 0x01 name: string flags: 0x00 (DENSE) entryCount: 3 entryStart: 96 config:
	[ResTable_entry] id: 0x0000 name: text1 keyIndex: 0 size: 8 flags: 0x0010
	[Res_value] size: 8 dataType: 0x03 (string) data: 0x00000000 ("foobar")
	[ResTable_entry] id: 0x0002 name: text3 keyIndex: 2 size: 8 flags: 0x0010
	[Res_value] size: 8 dataType: 0x01 (reference) data: 0x7f010001 (@0x7f010001))OUT_END";
	ASSERT_TRUE(output.contains(expected2));
	}

	TEST_F(FlaggedResourcesTest, ReadWriteFlagsOnOverlaySucceeds) {
	const std::string compiled_files_dir = GetTestPath("compiled");
	ASSERT_TRUE(CompileFile(GetTestPath("res/values/strings.xml"),
	R"(<resources xmlns:android="http://schemas.android.com/apk/res/android">
	<string name="text1" android:featureFlag="test.package.rwFlag">foobar</string>
	</resources>)",
	compiled_files_dir, &noop_diag,
	{"--feature-flags", "test.package.rwFlag"}));
	const std::string manifest_file = GetTestPath("AndroidManifest.xml");
	WriteFile(manifest_file, R"(
	<manifest xmlns:android="http://schemas.android.com/apk/res/android"
	package="com.aapt.command.test">
	<overlay android:targetPackage="com.example.target" />
	</manifest>)");
	const std::string out_apk = GetTestPath("out.apk");
	std::vector<std::string> link_args = {
	"--manifest",
	manifest_file,
	"-o",
	out_apk,
	};

	test::TestDiagnosticsImpl diag;
	ASSERT_TRUE(Link(link_args, compiled_files_dir, &diag));
	}

	TEST_F(FlaggedResourcesTest, RODisabledManifestElementRemoved) {
	auto apk_path = file::BuildPath({android::base::GetExecutableDirectory(), "resapp.apk"});
	auto loaded_apk = LoadedApk::LoadApkFromPath(apk_path, &noop_diag);

	std::string output;
	DumpXmlTreeToString(loaded_apk.get(), "AndroidManifest.xml", &output);
	SCOPED_TRACE(output);
	ASSERT_FALSE(output.contains("CAMERA"));
	}

	} // namespace aapt