Merge "AAPT2: Clean up tests a bit" (24acdf8a) · Commits · e / os / android_frameworks_base

tools/aapt2/ResourceParser_test.cpp

+342 −413

File changed.

Preview size limit exceeded, changes collapsed.

tools/aapt2/ResourceTable_test.cpp

+12 −15

Original line number	Diff line number	Diff line
		@@ -24,6 +24,8 @@
		#include <ostream>
		#include <string>

		using ::testing::NotNull;

		namespace aapt {

		TEST(ResourceTableTest, FailToAddResourceWithBadName) {
		@@ -56,7 +58,7 @@ TEST(ResourceTableTest, AddOneResource) {
		test::ValueBuilder<Id>().SetSource("test/path/file.xml", 23u).Build(),
		test::GetDiagnostics()));

		ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/id"));
		EXPECT_THAT(test::GetValue<Id>(&table, "android:attr/id"), NotNull());
		}

		TEST(ResourceTableTest, AddMultipleResources) {
		@@ -88,11 +90,10 @@ TEST(ResourceTableTest, AddMultipleResources) {
		.Build(),
		test::GetDiagnostics()));

		ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/layout_width"));
		ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/id"));
		ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:string/ok"));
		ASSERT_NE(nullptr, test::GetValueForConfig<BinaryPrimitive>(
		&table, "android:string/ok", language_config));
		EXPECT_THAT(test::GetValue<Id>(&table, "android:attr/layout_width"), NotNull());
		EXPECT_THAT(test::GetValue<Id>(&table, "android:attr/id"), NotNull());
		EXPECT_THAT(test::GetValue<Id>(&table, "android:string/ok"), NotNull());
		EXPECT_THAT(test::GetValueForConfig<BinaryPrimitive>(&table, "android:string/ok", language_config), NotNull());
		}

		TEST(ResourceTableTest, OverrideWeakResourceValue) {
		@@ -103,7 +104,7 @@ TEST(ResourceTableTest, OverrideWeakResourceValue) {
		util::make_unique<Attribute>(true), test::GetDiagnostics()));

		Attribute* attr = test::GetValue<Attribute>(&table, "android:attr/foo");
		ASSERT_NE(nullptr, attr);
		ASSERT_THAT(attr, NotNull());
		EXPECT_TRUE(attr->IsWeak());

		ASSERT_TRUE(table.AddResource(
		@@ -111,7 +112,7 @@ TEST(ResourceTableTest, OverrideWeakResourceValue) {
		util::make_unique<Attribute>(false), test::GetDiagnostics()));

		attr = test::GetValue<Attribute>(&table, "android:attr/foo");
		ASSERT_NE(nullptr, attr);
		ASSERT_THAT(attr, NotNull());
		EXPECT_FALSE(attr->IsWeak());
		}

		@@ -127,16 +128,12 @@ TEST(ResourceTableTest, ProductVaryingValues) {
		util::make_unique<Id>(),
		test::GetDiagnostics()));

		EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
		&table, "android:string/foo",
		test::ParseConfigOrDie("land"), "tablet"));
		EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
		&table, "android:string/foo",
		test::ParseConfigOrDie("land"), "phone"));
		EXPECT_THAT(test::GetValueForConfigAndProduct<Id>(&table, "android:string/foo",test::ParseConfigOrDie("land"), "tablet"), NotNull());
		EXPECT_THAT(test::GetValueForConfigAndProduct<Id>(&table, "android:string/foo",test::ParseConfigOrDie("land"), "phone"), NotNull());

		Maybe<ResourceTable::SearchResult> sr =
		table.FindResource(test::ParseNameOrDie("android:string/foo"));
		AAPT_ASSERT_TRUE(sr);
		ASSERT_TRUE(sr);
		std::vector<ResourceConfigValue*> values =
		sr.value().entry->FindAllValues(test::ParseConfigOrDie("land"));
		ASSERT_EQ(2u, values.size());

tools/aapt2/ResourceUtils_test.cpp

+58 −80

Original line number	Diff line number	Diff line
		@@ -20,96 +20,88 @@
		#include "test/Test.h"

		using ::aapt::test::ValueEq;
		using ::android::Res_value;
		using ::android::ResTable_map;
		using ::testing::Eq;
		using ::testing::NotNull;
		using ::testing::Pointee;

		namespace aapt {

		TEST(ResourceUtilsTest, ParseBool) {
		EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("true"));
		EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("TRUE"));
		EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("True"));
		EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("false"));
		EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("FALSE"));
		EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("False"));
		EXPECT_THAT(ResourceUtils::ParseBool("true"), Eq(Maybe<bool>(true)));
		EXPECT_THAT(ResourceUtils::ParseBool("TRUE"), Eq(Maybe<bool>(true)));
		EXPECT_THAT(ResourceUtils::ParseBool("True"), Eq(Maybe<bool>(true)));

		EXPECT_THAT(ResourceUtils::ParseBool("false"), Eq(Maybe<bool>(false)));
		EXPECT_THAT(ResourceUtils::ParseBool("FALSE"), Eq(Maybe<bool>(false)));
		EXPECT_THAT(ResourceUtils::ParseBool("False"), Eq(Maybe<bool>(false)));
		}

		TEST(ResourceUtilsTest, ParseResourceName) {
		ResourceNameRef actual;
		bool actual_priv = false;
		EXPECT_TRUE(ResourceUtils::ParseResourceName("android:color/foo", &actual,
		&actual_priv));
		EXPECT_EQ(ResourceNameRef("android", ResourceType::kColor, "foo"), actual);
		EXPECT_TRUE(ResourceUtils::ParseResourceName("android:color/foo", &actual, &actual_priv));
		EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo")));
		EXPECT_FALSE(actual_priv);

		EXPECT_TRUE(
		ResourceUtils::ParseResourceName("color/foo", &actual, &actual_priv));
		EXPECT_EQ(ResourceNameRef({}, ResourceType::kColor, "foo"), actual);
		EXPECT_TRUE(ResourceUtils::ParseResourceName("color/foo", &actual, &actual_priv));
		EXPECT_THAT(actual, Eq(ResourceNameRef({}, ResourceType::kColor, "foo")));
		EXPECT_FALSE(actual_priv);

		EXPECT_TRUE(ResourceUtils::ParseResourceName("*android:color/foo", &actual,
		&actual_priv));
		EXPECT_EQ(ResourceNameRef("android", ResourceType::kColor, "foo"), actual);
		EXPECT_TRUE(ResourceUtils::ParseResourceName("*android:color/foo", &actual, &actual_priv));
		EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo")));
		EXPECT_TRUE(actual_priv);

		EXPECT_FALSE(ResourceUtils::ParseResourceName(android::StringPiece(), &actual, &actual_priv));
		}

		TEST(ResourceUtilsTest, ParseReferenceWithNoPackage) {
		ResourceNameRef expected({}, ResourceType::kColor, "foo");
		ResourceNameRef actual;
		bool create = false;
		bool private_ref = false;
		EXPECT_TRUE(ResourceUtils::ParseReference("@color/foo", &actual, &create,
		&private_ref));
		EXPECT_EQ(expected, actual);
		EXPECT_TRUE(ResourceUtils::ParseReference("@color/foo", &actual, &create, &private_ref));
		EXPECT_THAT(actual, Eq(ResourceNameRef({}, ResourceType::kColor, "foo")));
		EXPECT_FALSE(create);
		EXPECT_FALSE(private_ref);
		}

		TEST(ResourceUtilsTest, ParseReferenceWithPackage) {
		ResourceNameRef expected("android", ResourceType::kColor, "foo");
		ResourceNameRef actual;
		bool create = false;
		bool private_ref = false;
		EXPECT_TRUE(ResourceUtils::ParseReference("@android:color/foo", &actual,
		&create, &private_ref));
		EXPECT_EQ(expected, actual);
		EXPECT_TRUE(ResourceUtils::ParseReference("@android:color/foo", &actual, &create, &private_ref));
		EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo")));
		EXPECT_FALSE(create);
		EXPECT_FALSE(private_ref);
		}

		TEST(ResourceUtilsTest, ParseReferenceWithSurroundingWhitespace) {
		ResourceNameRef expected("android", ResourceType::kColor, "foo");
		ResourceNameRef actual;
		bool create = false;
		bool private_ref = false;
		EXPECT_TRUE(ResourceUtils::ParseReference("\t @android:color/foo\n \n\t",
		&actual, &create, &private_ref));
		EXPECT_EQ(expected, actual);
		EXPECT_TRUE(ResourceUtils::ParseReference("\t @android:color/foo\n \n\t", &actual, &create, &private_ref));
		EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kColor, "foo")));
		EXPECT_FALSE(create);
		EXPECT_FALSE(private_ref);
		}

		TEST(ResourceUtilsTest, ParseAutoCreateIdReference) {
		ResourceNameRef expected("android", ResourceType::kId, "foo");
		ResourceNameRef actual;
		bool create = false;
		bool private_ref = false;
		EXPECT_TRUE(ResourceUtils::ParseReference("@+android:id/foo", &actual,
		&create, &private_ref));
		EXPECT_EQ(expected, actual);
		EXPECT_TRUE(ResourceUtils::ParseReference("@+android:id/foo", &actual, &create, &private_ref));
		EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kId, "foo")));
		EXPECT_TRUE(create);
		EXPECT_FALSE(private_ref);
		}

		TEST(ResourceUtilsTest, ParsePrivateReference) {
		ResourceNameRef expected("android", ResourceType::kId, "foo");
		ResourceNameRef actual;
		bool create = false;
		bool private_ref = false;
		EXPECT_TRUE(ResourceUtils::ParseReference("@*android:id/foo", &actual,
		&create, &private_ref));
		EXPECT_EQ(expected, actual);
		EXPECT_TRUE(ResourceUtils::ParseReference("@*android:id/foo", &actual, &create, &private_ref));
		EXPECT_THAT(actual, Eq(ResourceNameRef("android", ResourceType::kId, "foo")));
		EXPECT_FALSE(create);
		EXPECT_TRUE(private_ref);
		}
		@@ -118,8 +110,7 @@ TEST(ResourceUtilsTest, FailToParseAutoCreateNonIdReference) {
		bool create = false;
		bool private_ref = false;
		ResourceNameRef actual;
		EXPECT_FALSE(ResourceUtils::ParseReference("@+android:color/foo", &actual,
		&create, &private_ref));
		EXPECT_FALSE(ResourceUtils::ParseReference("@+android:color/foo", &actual, &create, &private_ref));
		}

		TEST(ResourceUtilsTest, ParseAttributeReferences) {
		@@ -143,82 +134,69 @@ TEST(ResourceUtilsTest, FailParseIncompleteReference) {
		}

		TEST(ResourceUtilsTest, ParseStyleParentReference) {
		const ResourceName kAndroidStyleFooName("android", ResourceType::kStyle,
		"foo");
		const ResourceName kAndroidStyleFooName("android", ResourceType::kStyle, "foo");
		const ResourceName kStyleFooName({}, ResourceType::kStyle, "foo");

		std::string err_str;
		Maybe<Reference> ref =
		ResourceUtils::ParseStyleParentReference("@android:style/foo", &err_str);
		AAPT_ASSERT_TRUE(ref);
		EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
		Maybe<Reference> ref = ResourceUtils::ParseStyleParentReference("@android:style/foo", &err_str);
		ASSERT_TRUE(ref);
		EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));

		ref = ResourceUtils::ParseStyleParentReference("@style/foo", &err_str);
		AAPT_ASSERT_TRUE(ref);
		EXPECT_EQ(ref.value().name.value(), kStyleFooName);
		ASSERT_TRUE(ref);
		EXPECT_THAT(ref.value().name, Eq(make_value(kStyleFooName)));

		ref =
		ResourceUtils::ParseStyleParentReference("?android:style/foo", &err_str);
		AAPT_ASSERT_TRUE(ref);
		EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
		ref = ResourceUtils::ParseStyleParentReference("?android:style/foo", &err_str);
		ASSERT_TRUE(ref);
		EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));

		ref = ResourceUtils::ParseStyleParentReference("?style/foo", &err_str);
		AAPT_ASSERT_TRUE(ref);
		EXPECT_EQ(ref.value().name.value(), kStyleFooName);
		ASSERT_TRUE(ref);
		EXPECT_THAT(ref.value().name, Eq(make_value(kStyleFooName)));

		ref = ResourceUtils::ParseStyleParentReference("android:style/foo", &err_str);
		AAPT_ASSERT_TRUE(ref);
		EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
		ASSERT_TRUE(ref);
		EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));

		ref = ResourceUtils::ParseStyleParentReference("android:foo", &err_str);
		AAPT_ASSERT_TRUE(ref);
		EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
		ASSERT_TRUE(ref);
		EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));

		ref = ResourceUtils::ParseStyleParentReference("@android:foo", &err_str);
		AAPT_ASSERT_TRUE(ref);
		EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
		ASSERT_TRUE(ref);
		EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));

		ref = ResourceUtils::ParseStyleParentReference("foo", &err_str);
		AAPT_ASSERT_TRUE(ref);
		EXPECT_EQ(ref.value().name.value(), kStyleFooName);
		ASSERT_TRUE(ref);
		EXPECT_THAT(ref.value().name, Eq(make_value(kStyleFooName)));

		ref =
		ResourceUtils::ParseStyleParentReference("*android:style/foo", &err_str);
		AAPT_ASSERT_TRUE(ref);
		EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
		ref = ResourceUtils::ParseStyleParentReference("*android:style/foo", &err_str);
		ASSERT_TRUE(ref);
		EXPECT_THAT(ref.value().name, Eq(make_value(kAndroidStyleFooName)));
		EXPECT_TRUE(ref.value().private_reference);
		}

		TEST(ResourceUtilsTest, ParseEmptyFlag) {
		std::unique_ptr<Attribute> attr =
		test::AttributeBuilder(false)
		.SetTypeMask(android::ResTable_map::TYPE_FLAGS)
		.SetTypeMask(ResTable_map::TYPE_FLAGS)
		.AddItem("one", 0x01)
		.AddItem("two", 0x02)
		.Build();

		std::unique_ptr<BinaryPrimitive> result =
		ResourceUtils::TryParseFlagSymbol(attr.get(), "");
		ASSERT_NE(nullptr, result);
		EXPECT_EQ(0u, result->value.data);
		std::unique_ptr<BinaryPrimitive> result = ResourceUtils::TryParseFlagSymbol(attr.get(), "");
		ASSERT_THAT(result, NotNull());
		EXPECT_THAT(result->value.data, Eq(0u));
		}

		TEST(ResourceUtilsTest, NullIsEmptyReference) {
		auto null_value = ResourceUtils::MakeNull();
		ASSERT_THAT(null_value, Pointee(ValueEq(Reference())));

		auto value = ResourceUtils::TryParseNullOrEmpty("@null");
		ASSERT_THAT(value, Pointee(ValueEq(Reference())));
		ASSERT_THAT(ResourceUtils::MakeNull(), Pointee(ValueEq(Reference())));
		ASSERT_THAT(ResourceUtils::TryParseNullOrEmpty("@null"), Pointee(ValueEq(Reference())));
		}

		TEST(ResourceUtilsTest, EmptyIsBinaryPrimitive) {
		auto empty_value = ResourceUtils::MakeEmpty();
		ASSERT_THAT(empty_value, Pointee(ValueEq(BinaryPrimitive(android::Res_value::TYPE_NULL,
		android::Res_value::DATA_NULL_EMPTY))));

		auto value = ResourceUtils::TryParseNullOrEmpty("@empty");
		ASSERT_THAT(value, Pointee(ValueEq(BinaryPrimitive(android::Res_value::TYPE_NULL,
		android::Res_value::DATA_NULL_EMPTY))));
		ASSERT_THAT(ResourceUtils::MakeEmpty(), Pointee(ValueEq(BinaryPrimitive(Res_value::TYPE_NULL, Res_value::DATA_NULL_EMPTY))));
		ASSERT_THAT(ResourceUtils::TryParseNullOrEmpty("@empty"), Pointee(ValueEq(BinaryPrimitive(Res_value::TYPE_NULL, Res_value::DATA_NULL_EMPTY))));
		}

		} // namespace aapt

tools/aapt2/compile/IdAssigner_test.cpp

+6 −6

Original line number	Diff line number	Diff line
		@@ -64,12 +64,12 @@ TEST(IdAssignerTest, AssignIdsWithReservedIds) {
		// Expect to fill in the gaps between 0x0101XXXX and 0x0104XXXX.

		maybe_result = table->FindResource(test::ParseNameOrDie("android:dimen/two"));
		AAPT_ASSERT_TRUE(maybe_result);
		ASSERT_TRUE(maybe_result);
		EXPECT_EQ(make_value<uint8_t>(2), maybe_result.value().type->id);

		maybe_result =
		table->FindResource(test::ParseNameOrDie("android:integer/three"));
		AAPT_ASSERT_TRUE(maybe_result);
		ASSERT_TRUE(maybe_result);
		EXPECT_EQ(make_value<uint8_t>(3), maybe_result.value().type->id);

		// Expect to bypass the reserved 0x0104XXXX IDs and use the next 0x0105XXXX
		@@ -77,17 +77,17 @@ TEST(IdAssignerTest, AssignIdsWithReservedIds) {

		maybe_result =
		table->FindResource(test::ParseNameOrDie("android:string/five"));
		AAPT_ASSERT_TRUE(maybe_result);
		ASSERT_TRUE(maybe_result);
		EXPECT_EQ(make_value<uint8_t>(5), maybe_result.value().type->id);

		// Expect to fill in the gaps between 0x01040000 and 0x01040006.

		maybe_result = table->FindResource(test::ParseNameOrDie("android:attr/bar"));
		AAPT_ASSERT_TRUE(maybe_result);
		ASSERT_TRUE(maybe_result);
		EXPECT_EQ(make_value<uint16_t>(1), maybe_result.value().entry->id);

		maybe_result = table->FindResource(test::ParseNameOrDie("android:attr/baz"));
		AAPT_ASSERT_TRUE(maybe_result);
		ASSERT_TRUE(maybe_result);
		EXPECT_EQ(make_value<uint16_t>(2), maybe_result.value().entry->id);
		}

		@@ -121,7 +121,7 @@ TEST(IdAssignerTest, AssignIdsWithIdMap) {
		ASSERT_TRUE(VerifyIds(table.get()));
		Maybe<ResourceTable::SearchResult> result =
		table->FindResource(test::ParseNameOrDie("android:attr/foo"));
		AAPT_ASSERT_TRUE(result);
		ASSERT_TRUE(result);

		const ResourceTable::SearchResult& search_result = result.value();
		EXPECT_EQ(make_value<uint8_t>(0x01), search_result.package->id);

tools/aapt2/flatten/TableFlattener_test.cpp

+16 −16

Original line number	Diff line number	Diff line
		@@ -26,6 +26,9 @@

		using namespace android;

		using ::testing::IsNull;
		using ::testing::NotNull;

		namespace aapt {

		class TableFlattenerTest : public ::testing::Test {
		@@ -235,13 +238,12 @@ TEST_F(TableFlattenerTest, FlattenMinMaxAttributes) {
		ResourceTable result;
		ASSERT_TRUE(Flatten(context_.get(), {}, table.get(), &result));

		Attribute* actualAttr =
		test::GetValue<Attribute>(&result, "android:attr/foo");
		ASSERT_NE(nullptr, actualAttr);
		EXPECT_EQ(attr.IsWeak(), actualAttr->IsWeak());
		EXPECT_EQ(attr.type_mask, actualAttr->type_mask);
		EXPECT_EQ(attr.min_int, actualAttr->min_int);
		EXPECT_EQ(attr.max_int, actualAttr->max_int);
		Attribute* actual_attr = test::GetValue<Attribute>(&result, "android:attr/foo");
		ASSERT_THAT(actual_attr, NotNull());
		EXPECT_EQ(attr.IsWeak(), actual_attr->IsWeak());
		EXPECT_EQ(attr.type_mask, actual_attr->type_mask);
		EXPECT_EQ(attr.min_int, actual_attr->min_int);
		EXPECT_EQ(attr.max_int, actual_attr->max_int);
		}

		static std::unique_ptr<ResourceTable> BuildTableWithSparseEntries(
		@@ -303,15 +305,13 @@ TEST_F(TableFlattenerTest, FlattenSparseEntryWithMinSdkO) {

		auto value = test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_0",
		sparse_config);
		ASSERT_NE(nullptr, value);
		ASSERT_THAT(value, NotNull());
		EXPECT_EQ(0u, value->value.data);

		ASSERT_EQ(nullptr, test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_1",
		sparse_config));
		ASSERT_THAT(test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_1", sparse_config), IsNull());

		value = test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_4",
		sparse_config);
		ASSERT_NE(nullptr, value);
		value = test::GetValueForConfig<BinaryPrimitive>(&sparse_table, "android:string/foo_4", sparse_config);
		ASSERT_THAT(value, NotNull());
		EXPECT_EQ(4u, value->value.data);
		}

		@@ -372,7 +372,7 @@ TEST_F(TableFlattenerTest, FlattenSharedLibrary) {

		Maybe<ResourceTable::SearchResult> search_result =
		result.FindResource(test::ParseNameOrDie("lib:id/foo"));
		AAPT_ASSERT_TRUE(search_result);
		ASSERT_TRUE(search_result);
		EXPECT_EQ(0x00u, search_result.value().package->id.value());

		auto iter = result.included_packages_.find(0x00);
		@@ -398,7 +398,7 @@ TEST_F(TableFlattenerTest, FlattenTableReferencingSharedLibraries) {
		ASSERT_TRUE(Flatten(context.get(), {}, table.get(), &result));

		const DynamicRefTable* dynamic_ref_table = result.getDynamicRefTableForCookie(1);
		ASSERT_NE(nullptr, dynamic_ref_table);
		ASSERT_THAT(dynamic_ref_table, NotNull());

		const KeyedVector<String16, uint8_t>& entries = dynamic_ref_table->entries();

		@@ -423,7 +423,7 @@ TEST_F(TableFlattenerTest, PackageWithNonStandardIdHasDynamicRefTable) {
		ASSERT_TRUE(Flatten(context.get(), {}, table.get(), &result));

		const DynamicRefTable* dynamic_ref_table = result.getDynamicRefTableForCookie(1);
		ASSERT_NE(nullptr, dynamic_ref_table);
		ASSERT_THAT(dynamic_ref_table, NotNull());

		const KeyedVector<String16, uint8_t>& entries = dynamic_ref_table->entries();
		ssize_t idx = entries.indexOfKey(android::String16("app"));