Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

AAPT2: Clean up tests a bit

Browse Source 
Since the latest gtest has fixed support for
explicit bool operators, remvoe AAPT_ASSERT_* and AAPT_EXPECT_*.

Also switch to use NotNull() matchers, which are more legible.

Test: make aapt2_tests
Change-Id: Idce199ca9d567d70f7aae275fee15e04bb914c9e
This commit is contained in:
Adam Lesinski
2017-05-30 15:19:02 -07:00
parent 594fda3161
commit a45893a5c5
17 changed files with 619 additions and 772 deletions
Download Patch File Download Diff File Expand all files Collapse all files

753
tools/aapt2/ResourceParser_test.cpp
View File

File diff suppressed because it is too large Load Diff

27
tools/aapt2/ResourceTable_test.cpp
View File

@@ -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());

138
tools/aapt2/ResourceUtils_test.cpp
View File

@@ -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

12
tools/aapt2/compile/IdAssigner_test.cpp
View File

@@ -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);

32
tools/aapt2/flatten/TableFlattener_test.cpp
View File

@@ -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"));

85
tools/aapt2/link/AutoVersioner_test.cpp
View File

@@ -19,43 +19,34 @@
#include "ConfigDescription.h"
#include "test/Test.h"
using ::testing::NotNull;
namespace aapt {
TEST(AutoVersionerTest, GenerateVersionedResources) {
const ConfigDescription land_config = test::ParseConfigOrDie("land");
const ConfigDescription sw600dp_land_config =
test::ParseConfigOrDie("sw600dp-land");
const ConfigDescription sw600dp_land_config = test::ParseConfigOrDie("sw600dp-land");
ResourceEntry entry("foo");
entry.values.push_back(util::make_unique<ResourceConfigValue>(
ConfigDescription::DefaultConfig(), ""));
entry.values.push_back(
util::make_unique<ResourceConfigValue>(land_config, ""));
entry.values.push_back(
util::make_unique<ResourceConfigValue>(sw600dp_land_config, ""));
entry.values.push_back(util::make_unique<ResourceConfigValue>(ConfigDescription::DefaultConfig(), ""));
entry.values.push_back(util::make_unique<ResourceConfigValue>(land_config, ""));
entry.values.push_back(util::make_unique<ResourceConfigValue>(sw600dp_land_config, ""));
EXPECT_TRUE(ShouldGenerateVersionedResource(
&entry, ConfigDescription::DefaultConfig(), 17));
EXPECT_TRUE(ShouldGenerateVersionedResource(&entry, ConfigDescription::DefaultConfig(), 17));
EXPECT_TRUE(ShouldGenerateVersionedResource(&entry, land_config, 17));
}
TEST(AutoVersionerTest, GenerateVersionedResourceWhenHigherVersionExists) {
const ConfigDescription sw600dp_v13_config =
test::ParseConfigOrDie("sw600dp-v13");
const ConfigDescription sw600dp_v13_config = test::ParseConfigOrDie("sw600dp-v13");
const ConfigDescription v21_config = test::ParseConfigOrDie("v21");
ResourceEntry entry("foo");
entry.values.push_back(util::make_unique<ResourceConfigValue>(
ConfigDescription::DefaultConfig(), ""));
entry.values.push_back(
util::make_unique<ResourceConfigValue>(sw600dp_v13_config, ""));
entry.values.push_back(
util::make_unique<ResourceConfigValue>(v21_config, ""));
entry.values.push_back(util::make_unique<ResourceConfigValue>(ConfigDescription::DefaultConfig(), ""));
entry.values.push_back(util::make_unique<ResourceConfigValue>(sw600dp_v13_config, ""));
entry.values.push_back(util::make_unique<ResourceConfigValue>(v21_config, ""));
EXPECT_TRUE(ShouldGenerateVersionedResource(
&entry, ConfigDescription::DefaultConfig(), 17));
EXPECT_FALSE(ShouldGenerateVersionedResource(
&entry, ConfigDescription::DefaultConfig(), 22));
EXPECT_TRUE(ShouldGenerateVersionedResource(&entry, ConfigDescription::DefaultConfig(), 17));
EXPECT_FALSE(ShouldGenerateVersionedResource(&entry, ConfigDescription::DefaultConfig(), 22));
}
TEST(AutoVersionerTest, VersionStylesForTable) {
@@ -92,46 +83,28 @@ TEST(AutoVersionerTest, VersionStylesForTable) {
AutoVersioner versioner;
ASSERT_TRUE(versioner.Consume(context.get(), table.get()));
Style* style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
test::ParseConfigOrDie("v4"));
ASSERT_NE(style, nullptr);
Style* style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v4"));
ASSERT_THAT(style, NotNull());
ASSERT_EQ(style->entries.size(), 1u);
AAPT_ASSERT_TRUE(style->entries.front().key.name);
EXPECT_EQ(style->entries.front().key.name.value(),
test::ParseNameOrDie("android:attr/onClick"));
EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/onClick")), style->entries.front().key.name);
style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
test::ParseConfigOrDie("v13"));
ASSERT_NE(style, nullptr);
style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v13"));
ASSERT_THAT(style, NotNull());
ASSERT_EQ(style->entries.size(), 2u);
AAPT_ASSERT_TRUE(style->entries[0].key.name);
EXPECT_EQ(style->entries[0].key.name.value(),
test::ParseNameOrDie("android:attr/onClick"));
AAPT_ASSERT_TRUE(style->entries[1].key.name);
EXPECT_EQ(style->entries[1].key.name.value(),
test::ParseNameOrDie("android:attr/requiresSmallestWidthDp"));
EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/onClick")),style->entries[0].key.name);
EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/requiresSmallestWidthDp")), style->entries[1].key.name);
style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
test::ParseConfigOrDie("v17"));
ASSERT_NE(style, nullptr);
style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v17"));
ASSERT_THAT(style, NotNull());
ASSERT_EQ(style->entries.size(), 3u);
AAPT_ASSERT_TRUE(style->entries[0].key.name);
EXPECT_EQ(style->entries[0].key.name.value(),
test::ParseNameOrDie("android:attr/onClick"));
AAPT_ASSERT_TRUE(style->entries[1].key.name);
EXPECT_EQ(style->entries[1].key.name.value(),
test::ParseNameOrDie("android:attr/requiresSmallestWidthDp"));
AAPT_ASSERT_TRUE(style->entries[2].key.name);
EXPECT_EQ(style->entries[2].key.name.value(),
test::ParseNameOrDie("android:attr/paddingStart"));
EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/onClick")), style->entries[0].key.name);
EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/requiresSmallestWidthDp")), style->entries[1].key.name);
EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/paddingStart")), style->entries[2].key.name);
style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
test::ParseConfigOrDie("v21"));
ASSERT_NE(style, nullptr);
ASSERT_EQ(style->entries.size(), 1u);
AAPT_ASSERT_TRUE(style->entries.front().key.name);
EXPECT_EQ(style->entries.front().key.name.value(),
test::ParseNameOrDie("android:attr/paddingEnd"));
style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo", test::ParseConfigOrDie("v21"));
ASSERT_THAT(style, NotNull());
ASSERT_EQ(1u, style->entries.size());
EXPECT_EQ(make_value(test::ParseNameOrDie("android:attr/paddingEnd")), style->entries.front().key.name);
}
} // namespace aapt

42
tools/aapt2/link/ReferenceLinker_test.cpp
View File

@@ -19,6 +19,7 @@
#include "test/Test.h"
using android::ResTable_map;
using ::testing::NotNull;
namespace aapt {
@@ -54,18 +55,18 @@ TEST(ReferenceLinkerTest, LinkSimpleReferences) {
ASSERT_TRUE(linker.Consume(context.get(), table.get()));
Reference* ref = test::GetValue<Reference>(table.get(), "com.app.test:string/foo");
ASSERT_NE(nullptr, ref);
AAPT_ASSERT_TRUE(ref->id);
ASSERT_THAT(ref, NotNull());
ASSERT_TRUE(ref->id);
EXPECT_EQ(ResourceId(0x7f020001), ref->id.value());
ref = test::GetValue<Reference>(table.get(), "com.app.test:string/bar");
ASSERT_NE(nullptr, ref);
AAPT_ASSERT_TRUE(ref->id);
ASSERT_THAT(ref, NotNull());
ASSERT_TRUE(ref->id);
EXPECT_EQ(ResourceId(0x7f020002), ref->id.value());
ref = test::GetValue<Reference>(table.get(), "com.app.test:string/baz");
ASSERT_NE(nullptr, ref);
AAPT_ASSERT_TRUE(ref->id);
ASSERT_THAT(ref, NotNull());
ASSERT_TRUE(ref->id);
EXPECT_EQ(ResourceId(0x01040034), ref->id.value());
}
@@ -84,10 +85,9 @@ TEST(ReferenceLinkerTest, LinkStyleAttributes) {
{
// We need to fill in the value for the attribute android:attr/bar after we
// build the
// table, because we need access to the string pool.
// build the table, because we need access to the string pool.
Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
ASSERT_NE(nullptr, style);
ASSERT_THAT(style, NotNull());
style->entries.back().value =
util::make_unique<RawString>(table->string_pool.MakeRef("one|two"));
}
@@ -118,20 +118,20 @@ TEST(ReferenceLinkerTest, LinkStyleAttributes) {
ASSERT_TRUE(linker.Consume(context.get(), table.get()));
Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
ASSERT_NE(nullptr, style);
AAPT_ASSERT_TRUE(style->parent);
AAPT_ASSERT_TRUE(style->parent.value().id);
ASSERT_THAT(style, NotNull());
ASSERT_TRUE(style->parent);
ASSERT_TRUE(style->parent.value().id);
EXPECT_EQ(ResourceId(0x01060000), style->parent.value().id.value());
ASSERT_EQ(2u, style->entries.size());
AAPT_ASSERT_TRUE(style->entries[0].key.id);
ASSERT_TRUE(style->entries[0].key.id);
EXPECT_EQ(ResourceId(0x01010001), style->entries[0].key.id.value());
ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(style->entries[0].value.get()));
ASSERT_THAT(ValueCast<BinaryPrimitive>(style->entries[0].value.get()), NotNull());
AAPT_ASSERT_TRUE(style->entries[1].key.id);
ASSERT_TRUE(style->entries[1].key.id);
EXPECT_EQ(ResourceId(0x01010002), style->entries[1].key.id.value());
ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(style->entries[1].value.get()));
ASSERT_THAT(ValueCast<BinaryPrimitive>(style->entries[1].value.get()), NotNull());
}
TEST(ReferenceLinkerTest, LinkMangledReferencesAndAttributes) {
@@ -165,9 +165,9 @@ TEST(ReferenceLinkerTest, LinkMangledReferencesAndAttributes) {
ASSERT_TRUE(linker.Consume(context.get(), table.get()));
Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
ASSERT_NE(nullptr, style);
ASSERT_THAT(style, NotNull());
ASSERT_EQ(1u, style->entries.size());
AAPT_ASSERT_TRUE(style->entries.front().key.id);
ASSERT_TRUE(style->entries.front().key.id);
EXPECT_EQ(ResourceId(0x7f010000), style->entries.front().key.id.value());
}
@@ -266,7 +266,7 @@ TEST(ReferenceLinkerTest, AppsWithSamePackageButDifferentIdAreVisibleNonPublic)
const CallSite call_site{ResourceNameRef("com.app.test", ResourceType::kString, "foo")};
const SymbolTable::Symbol* symbol = ReferenceLinker::ResolveSymbolCheckVisibility(
*test::BuildReference("com.app.test:string/foo"), call_site, &table, &error);
ASSERT_NE(nullptr, symbol);
ASSERT_THAT(symbol, NotNull());
EXPECT_TRUE(error.empty());
}
@@ -283,12 +283,12 @@ TEST(ReferenceLinkerTest, AppsWithDifferentPackageCanNotUseEachOthersAttribute)
std::string error;
const CallSite call_site{ResourceNameRef("com.app.ext", ResourceType::kLayout, "foo")};
AAPT_EXPECT_FALSE(ReferenceLinker::CompileXmlAttribute(
EXPECT_FALSE(ReferenceLinker::CompileXmlAttribute(
*test::BuildReference("com.app.test:attr/foo"), call_site, &table, &error));
EXPECT_FALSE(error.empty());
error = "";
AAPT_ASSERT_TRUE(ReferenceLinker::CompileXmlAttribute(
ASSERT_TRUE(ReferenceLinker::CompileXmlAttribute(
*test::BuildReference("com.app.test:attr/public_foo"), call_site, &table, &error));
EXPECT_TRUE(error.empty());
}

137
tools/aapt2/link/XmlReferenceLinker_test.cpp
View File

@@ -18,6 +18,9 @@
#include "test/Test.h"
using ::testing::IsNull;
using ::testing::NotNull;
namespace aapt {
class XmlReferenceLinkerTest : public ::testing::Test {
@@ -90,56 +93,48 @@ TEST_F(XmlReferenceLinkerTest, LinkBasicAttributes) {
ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
xml::Element* view_el = xml::FindRootElement(doc.get());
ASSERT_NE(nullptr, view_el);
ASSERT_THAT(view_el, NotNull());
xml::Attribute* xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "layout_width");
ASSERT_NE(nullptr, xml_attr);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
EXPECT_EQ(ResourceId(0x01010000), xml_attr->compiled_attribute.value().id.value());
ASSERT_NE(nullptr, xml_attr->compiled_value);
ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()));
ASSERT_THAT(xml_attr, NotNull());
ASSERT_TRUE(xml_attr->compiled_attribute);
EXPECT_EQ(make_value(ResourceId(0x01010000)), xml_attr->compiled_attribute.value().id);
EXPECT_THAT(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), NotNull());
xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "background");
ASSERT_NE(nullptr, xml_attr);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
EXPECT_EQ(ResourceId(0x01010001), xml_attr->compiled_attribute.value().id.value());
ASSERT_NE(nullptr, xml_attr->compiled_value);
ASSERT_THAT(xml_attr, NotNull());
ASSERT_TRUE(xml_attr->compiled_attribute);
EXPECT_EQ(make_value(ResourceId(0x01010001)), xml_attr->compiled_attribute.value().id);
Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
ASSERT_NE(nullptr, ref);
AAPT_ASSERT_TRUE(ref->name);
EXPECT_EQ(test::ParseNameOrDie("color/green"), ref->name.value()); // Make sure the name
// didn't change.
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ResourceId(0x7f020000), ref->id.value());
ASSERT_THAT(ref, NotNull());
EXPECT_EQ(make_value(test::ParseNameOrDie("color/green")), ref->name); // Make sure the name
// didn't change.
EXPECT_EQ(make_value(ResourceId(0x7f020000)), ref->id);
xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "text");
ASSERT_NE(nullptr, xml_attr);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
ASSERT_FALSE(xml_attr->compiled_value); // Strings don't get compiled for memory sake.
ASSERT_THAT(xml_attr, NotNull());
EXPECT_TRUE(xml_attr->compiled_attribute);
EXPECT_THAT(xml_attr->compiled_value, IsNull()); // Strings don't get compiled for memory sake.
xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "attr");
ASSERT_NE(nullptr, xml_attr);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
ASSERT_FALSE(xml_attr->compiled_value); // Should be a plain string.
ASSERT_THAT(xml_attr, NotNull());
EXPECT_TRUE(xml_attr->compiled_attribute);
EXPECT_THAT(xml_attr->compiled_value, IsNull()); // Should be a plain string.
xml_attr = view_el->FindAttribute("", "nonAaptAttr");
ASSERT_NE(nullptr, xml_attr);
AAPT_ASSERT_FALSE(xml_attr->compiled_attribute);
ASSERT_NE(nullptr, xml_attr->compiled_value);
ASSERT_NE(nullptr, ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()));
ASSERT_THAT(xml_attr, NotNull());
EXPECT_FALSE(xml_attr->compiled_attribute);
EXPECT_THAT(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), NotNull());
xml_attr = view_el->FindAttribute("", "nonAaptAttrRef");
ASSERT_NE(nullptr, xml_attr);
AAPT_ASSERT_FALSE(xml_attr->compiled_attribute);
ASSERT_NE(nullptr, xml_attr->compiled_value);
ASSERT_NE(nullptr, ValueCast<Reference>(xml_attr->compiled_value.get()));
ASSERT_THAT(xml_attr, NotNull());
EXPECT_FALSE(xml_attr->compiled_attribute);
EXPECT_THAT(ValueCast<Reference>(xml_attr->compiled_value.get()), NotNull());
xml_attr = view_el->FindAttribute("", "class");
ASSERT_NE(nullptr, xml_attr);
AAPT_ASSERT_FALSE(xml_attr->compiled_attribute);
ASSERT_EQ(nullptr, xml_attr->compiled_value);
ASSERT_THAT(xml_attr, NotNull());
EXPECT_FALSE(xml_attr->compiled_attribute);
EXPECT_THAT(xml_attr->compiled_value, IsNull());
}
TEST_F(XmlReferenceLinkerTest, PrivateSymbolsAreNotLinked) {
@@ -169,15 +164,14 @@ TEST_F(XmlReferenceLinkerTest, LinkMangledAttributes) {
ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
xml::Element* view_el = xml::FindRootElement(doc.get());
ASSERT_NE(view_el, nullptr);
ASSERT_THAT(view_el, NotNull());
xml::Attribute* xml_attr =
view_el->FindAttribute(xml::BuildPackageNamespace("com.android.support"), "colorAccent");
ASSERT_NE(xml_attr, nullptr);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010001));
ASSERT_NE(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), nullptr);
ASSERT_THAT(xml_attr, NotNull());
ASSERT_TRUE(xml_attr->compiled_attribute);
EXPECT_EQ(make_value(ResourceId(0x7f010001)), xml_attr->compiled_attribute.value().id);
EXPECT_THAT(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()), NotNull());
}
TEST_F(XmlReferenceLinkerTest, LinkAutoResReference) {
@@ -189,18 +183,16 @@ TEST_F(XmlReferenceLinkerTest, LinkAutoResReference) {
ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
xml::Element* view_el = xml::FindRootElement(doc.get());
ASSERT_NE(view_el, nullptr);
ASSERT_THAT(view_el, NotNull());
xml::Attribute* xml_attr = view_el->FindAttribute(xml::kSchemaAuto, "colorAccent");
ASSERT_NE(xml_attr, nullptr);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010000));
ASSERT_THAT(xml_attr, NotNull());
ASSERT_TRUE(xml_attr->compiled_attribute);
EXPECT_EQ(make_value(ResourceId(0x7f010000)), xml_attr->compiled_attribute.value().id);
Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->name);
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ref->id.value(), ResourceId(0x7f020001));
ASSERT_THAT(ref, NotNull());
ASSERT_TRUE(ref->name);
EXPECT_EQ(make_value(ResourceId(0x7f020001)), ref->id);
}
TEST_F(XmlReferenceLinkerTest, LinkViewWithShadowedPackageAlias) {
@@ -215,35 +207,31 @@ TEST_F(XmlReferenceLinkerTest, LinkViewWithShadowedPackageAlias) {
ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
xml::Element* view_el = xml::FindRootElement(doc.get());
ASSERT_NE(view_el, nullptr);
ASSERT_THAT(view_el, NotNull());
// All attributes and references in this element should be referring to
// "android" (0x01).
xml::Attribute* xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "attr");
ASSERT_NE(xml_attr, nullptr);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x01010002));
ASSERT_THAT(xml_attr, NotNull());
ASSERT_TRUE(xml_attr->compiled_attribute);
EXPECT_EQ(make_value(ResourceId(0x01010002)), xml_attr->compiled_attribute.value().id);
Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ref->id.value(), ResourceId(0x01030000));
ASSERT_THAT(ref, NotNull());
EXPECT_EQ(make_value(ResourceId(0x01030000)), ref->id);
ASSERT_FALSE(view_el->GetChildElements().empty());
view_el = view_el->GetChildElements().front();
ASSERT_NE(view_el, nullptr);
ASSERT_THAT(view_el, NotNull());
// All attributes and references in this element should be referring to
// "com.app.test" (0x7f).
xml_attr = view_el->FindAttribute(xml::BuildPackageNamespace("com.app.test"), "attr");
ASSERT_NE(xml_attr, nullptr);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010002));
ASSERT_THAT(xml_attr, NotNull());
ASSERT_TRUE(xml_attr->compiled_attribute);
EXPECT_EQ(make_value(ResourceId(0x7f010002)), xml_attr->compiled_attribute.value().id);
ref = ValueCast<Reference>(xml_attr->compiled_value.get());
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ref->id.value(), ResourceId(0x7f030000));
ASSERT_THAT(ref, NotNull());
EXPECT_EQ(make_value(ResourceId(0x7f030000)), ref->id);
}
TEST_F(XmlReferenceLinkerTest, LinkViewWithLocalPackageAndAliasOfTheSameName) {
@@ -255,20 +243,17 @@ TEST_F(XmlReferenceLinkerTest, LinkViewWithLocalPackageAndAliasOfTheSameName) {
ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
xml::Element* view_el = xml::FindRootElement(doc.get());
ASSERT_NE(view_el, nullptr);
ASSERT_THAT(view_el, NotNull());
// All attributes and references in this element should be referring to
// "com.app.test" (0x7f).
xml::Attribute* xml_attr =
view_el->FindAttribute(xml::BuildPackageNamespace("com.app.test"), "attr");
ASSERT_NE(xml_attr, nullptr);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(), ResourceId(0x7f010002));
xml::Attribute* xml_attr = view_el->FindAttribute(xml::BuildPackageNamespace("com.app.test"), "attr");
ASSERT_THAT(xml_attr, NotNull());
ASSERT_TRUE(xml_attr->compiled_attribute);
EXPECT_EQ(make_value(ResourceId(0x7f010002)), xml_attr->compiled_attribute.value().id);
Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ref->id.value(), ResourceId(0x7f030000));
ASSERT_THAT(ref, NotNull());
EXPECT_EQ(make_value(ResourceId(0x7f030000)), ref->id);
}
} // namespace aapt

32
tools/aapt2/proto/TableProtoSerializer_test.cpp
View File

@@ -20,6 +20,7 @@
#include "test/Test.h"
using ::google::protobuf::io::StringOutputStream;
using ::testing::NotNull;
namespace aapt {
@@ -46,8 +47,7 @@ TEST(TableProtoSerializer, SerializeSinglePackage) {
// Make a plural.
std::unique_ptr<Plural> plural = util::make_unique<Plural>();
plural->values[Plural::One] =
util::make_unique<String>(table->string_pool.MakeRef("one"));
plural->values[Plural::One] = util::make_unique<String>(table->string_pool.MakeRef("one"));
ASSERT_TRUE(table->AddResource(test::ParseNameOrDie("com.app.a:plurals/hey"),
ConfigDescription{}, {}, std::move(plural),
context->GetDiagnostics()));
@@ -77,19 +77,19 @@ TEST(TableProtoSerializer, SerializeSinglePackage) {
context->GetDiagnostics()));
std::unique_ptr<pb::ResourceTable> pb_table = SerializeTableToPb(table.get());
ASSERT_NE(nullptr, pb_table);
ASSERT_THAT(pb_table, NotNull());
std::unique_ptr<ResourceTable> new_table = DeserializeTableFromPb(
*pb_table, Source{"test"}, context->GetDiagnostics());
ASSERT_NE(nullptr, new_table);
ASSERT_THAT(new_table, NotNull());
Id* new_id = test::GetValue<Id>(new_table.get(), "com.app.a:id/foo");
ASSERT_NE(nullptr, new_id);
ASSERT_THAT(new_id, NotNull());
EXPECT_EQ(id->IsWeak(), new_id->IsWeak());
Maybe<ResourceTable::SearchResult> result =
new_table->FindResource(test::ParseNameOrDie("com.app.a:layout/main"));
AAPT_ASSERT_TRUE(result);
ASSERT_TRUE(result);
EXPECT_EQ(SymbolState::kPublic, result.value().type->symbol_status.state);
EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbol_status.state);
@@ -101,18 +101,18 @@ TEST(TableProtoSerializer, SerializeSinglePackage) {
// Find the product-dependent values
BinaryPrimitive* prim = test::GetValueForConfigAndProduct<BinaryPrimitive>(
new_table.get(), "com.app.a:integer/one", test::ParseConfigOrDie("land"), "");
ASSERT_NE(nullptr, prim);
ASSERT_THAT(prim, NotNull());
EXPECT_EQ(123u, prim->value.data);
prim = test::GetValueForConfigAndProduct<BinaryPrimitive>(
new_table.get(), "com.app.a:integer/one", test::ParseConfigOrDie("land"), "tablet");
ASSERT_NE(nullptr, prim);
ASSERT_THAT(prim, NotNull());
EXPECT_EQ(321u, prim->value.data);
Reference* actual_ref = test::GetValue<Reference>(new_table.get(), "com.app.a:layout/abc");
ASSERT_NE(nullptr, actual_ref);
AAPT_ASSERT_TRUE(actual_ref->name);
AAPT_ASSERT_TRUE(actual_ref->id);
ASSERT_THAT(actual_ref, NotNull());
ASSERT_TRUE(actual_ref->name);
ASSERT_TRUE(actual_ref->id);
EXPECT_EQ(expected_ref.name.value(), actual_ref->name.value());
EXPECT_EQ(expected_ref.id.value(), actual_ref->id.value());
}
@@ -159,7 +159,7 @@ TEST(TableProtoSerializer, SerializeFileHeader) {
std::unique_ptr<ResourceFile> file = DeserializeCompiledFileFromPb(
new_pb_file, Source("test"), context->GetDiagnostics());
ASSERT_NE(nullptr, file);
ASSERT_THAT(file, NotNull());
uint64_t offset, len;
ASSERT_TRUE(in_file_stream.ReadDataMetaData(&offset, &len));
@@ -171,16 +171,14 @@ TEST(TableProtoSerializer, SerializeFileHeader) {
EXPECT_EQ(0u, offset & 0x03);
ASSERT_EQ(1u, file->exported_symbols.size());
EXPECT_EQ(test::ParseNameOrDie("id/unchecked"),
file->exported_symbols[0].name);
EXPECT_EQ(test::ParseNameOrDie("id/unchecked"), file->exported_symbols[0].name);
// Read the second compiled file.
ASSERT_TRUE(in_file_stream.ReadCompiledFile(&new_pb_file));
file = DeserializeCompiledFileFromPb(new_pb_file, Source("test"),
context->GetDiagnostics());
ASSERT_NE(nullptr, file);
file = DeserializeCompiledFileFromPb(new_pb_file, Source("test"), context->GetDiagnostics());
ASSERT_THAT(file, NotNull());
ASSERT_TRUE(in_file_stream.ReadDataMetaData(&offset, &len));

7
tools/aapt2/test/Builders.h
View File

@@ -212,8 +212,7 @@ class StyleBuilder {
}
StyleBuilder& AddItem(const android::StringPiece& str, std::unique_ptr<Item> value) {
style_->entries.push_back(
Style::Entry{Reference(ParseNameOrDie(str)), std::move(value)});
style_->entries.push_back(Style::Entry{Reference(ParseNameOrDie(str)), std::move(value)});
return *this;
}
@@ -224,7 +223,9 @@ class StyleBuilder {
return *this;
}
std::unique_ptr<Style> Build() { return std::move(style_); }
std::unique_ptr<Style> Build() {
return std::move(style_);
}
private:
DISALLOW_COPY_AND_ASSIGN(StyleBuilder);

13
tools/aapt2/test/Common.h
View File

@@ -34,15 +34,6 @@
#include "io/File.h"
#include "process/IResourceTableConsumer.h"
//
// GTEST 1.7 doesn't explicitly cast to bool, which causes explicit operators to
// fail to compile.
//
#define AAPT_ASSERT_TRUE(v) ASSERT_TRUE(bool(v))
#define AAPT_ASSERT_FALSE(v) ASSERT_FALSE(bool(v))
#define AAPT_EXPECT_TRUE(v) EXPECT_TRUE(bool(v))
#define AAPT_EXPECT_FALSE(v) EXPECT_FALSE(bool(v))
namespace aapt {
namespace test {
@@ -150,6 +141,10 @@ MATCHER_P(ValueEq, a,
return arg.Equals(&a);
}
MATCHER_P(StrValueEq, a, std::string(negation ? "isn't" : "is") + " equal to " + ::testing::PrintToString(a)) {
return *(arg.value) == a;
}
} // namespace test
} // namespace aapt

16
tools/aapt2/util/BigBuffer_test.cpp
View File

@@ -18,12 +18,14 @@
#include "test/Test.h"
using ::testing::NotNull;
namespace aapt {
TEST(BigBufferTest, AllocateSingleBlock) {
BigBuffer buffer(4);
EXPECT_NE(nullptr, buffer.NextBlock<char>(2));
EXPECT_THAT(buffer.NextBlock<char>(2), NotNull());
EXPECT_EQ(2u, buffer.size());
}
@@ -31,10 +33,10 @@ TEST(BigBufferTest, ReturnSameBlockIfNextAllocationFits) {
BigBuffer buffer(16);
char* b1 = buffer.NextBlock<char>(8);
EXPECT_NE(nullptr, b1);
EXPECT_THAT(b1, NotNull());
char* b2 = buffer.NextBlock<char>(4);
EXPECT_NE(nullptr, b2);
EXPECT_THAT(b2, NotNull());
EXPECT_EQ(b1 + 8, b2);
}
@@ -42,7 +44,7 @@ TEST(BigBufferTest, ReturnSameBlockIfNextAllocationFits) {
TEST(BigBufferTest, AllocateExactSizeBlockIfLargerThanBlockSize) {
BigBuffer buffer(16);
EXPECT_NE(nullptr, buffer.NextBlock<char>(32));
EXPECT_THAT(buffer.NextBlock<char>(32), NotNull());
EXPECT_EQ(32u, buffer.size());
}
@@ -50,13 +52,13 @@ TEST(BigBufferTest, AppendAndMoveBlock) {
BigBuffer buffer(16);
uint32_t* b1 = buffer.NextBlock<uint32_t>();
ASSERT_NE(nullptr, b1);
ASSERT_THAT(b1, NotNull());
*b1 = 33;
{
BigBuffer buffer2(16);
b1 = buffer2.NextBlock<uint32_t>();
ASSERT_NE(nullptr, b1);
ASSERT_THAT(b1, NotNull());
*b1 = 44;
buffer.AppendBuffer(std::move(buffer2));
@@ -83,7 +85,7 @@ TEST(BigBufferTest, AppendAndMoveBlock) {
TEST(BigBufferTest, PadAndAlignProperly) {
BigBuffer buffer(16);
ASSERT_NE(buffer.NextBlock<char>(2), nullptr);
ASSERT_THAT(buffer.NextBlock<char>(2), NotNull());
ASSERT_EQ(2u, buffer.size());
buffer.Pad(2);
ASSERT_EQ(4u, buffer.size());

10
tools/aapt2/util/Maybe_test.cpp
View File

@@ -80,22 +80,22 @@ struct Dummy {
TEST(MaybeTest, MakeNothing) {
Maybe<int> val = make_nothing<int>();
AAPT_EXPECT_FALSE(val);
EXPECT_FALSE(val);
Maybe<std::string> val2 = make_nothing<std::string>();
AAPT_EXPECT_FALSE(val2);
EXPECT_FALSE(val2);
val2 = make_nothing<std::string>();
AAPT_EXPECT_FALSE(val2);
EXPECT_FALSE(val2);
}
TEST(MaybeTest, MakeSomething) {
Maybe<int> val = make_value(23);
AAPT_ASSERT_TRUE(val);
ASSERT_TRUE(val);
EXPECT_EQ(23, val.value());
Maybe<std::string> val2 = make_value(std::string("hey"));
AAPT_ASSERT_TRUE(val2);
ASSERT_TRUE(val2);
EXPECT_EQ(std::string("hey"), val2.value());
}

30
tools/aapt2/util/Util_test.cpp
View File

@@ -147,54 +147,48 @@ TEST(UtilTest, IsJavaPackageName) {
TEST(UtilTest, FullyQualifiedClassName) {
Maybe<std::string> res = util::GetFullyQualifiedClassName("android", ".asdf");
AAPT_ASSERT_TRUE(res);
ASSERT_TRUE(res);
EXPECT_EQ(res.value(), "android.asdf");
res = util::GetFullyQualifiedClassName("android", ".a.b");
AAPT_ASSERT_TRUE(res);
ASSERT_TRUE(res);
EXPECT_EQ(res.value(), "android.a.b");
res = util::GetFullyQualifiedClassName("android", "a.b");
AAPT_ASSERT_TRUE(res);
ASSERT_TRUE(res);
EXPECT_EQ(res.value(), "a.b");
res = util::GetFullyQualifiedClassName("", "a.b");
AAPT_ASSERT_TRUE(res);
ASSERT_TRUE(res);
EXPECT_EQ(res.value(), "a.b");
res = util::GetFullyQualifiedClassName("android", "Class");
AAPT_ASSERT_TRUE(res);
ASSERT_TRUE(res);
EXPECT_EQ(res.value(), "android.Class");
res = util::GetFullyQualifiedClassName("", "");
AAPT_ASSERT_FALSE(res);
ASSERT_FALSE(res);
res = util::GetFullyQualifiedClassName("android", "./Apple");
AAPT_ASSERT_FALSE(res);
ASSERT_FALSE(res);
}
TEST(UtilTest, ExtractResourcePathComponents) {
StringPiece prefix, entry, suffix;
ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.xml",
&prefix, &entry, &suffix));
ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.xml", &prefix, &entry, &suffix));
EXPECT_EQ(prefix, "res/xml-sw600dp/");
EXPECT_EQ(entry, "entry");
EXPECT_EQ(suffix, ".xml");
ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.9.png",
&prefix, &entry, &suffix));
ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.9.png", &prefix, &entry, &suffix));
EXPECT_EQ(prefix, "res/xml-sw600dp/");
EXPECT_EQ(entry, "entry");
EXPECT_EQ(suffix, ".9.png");
EXPECT_FALSE(util::ExtractResFilePathParts("AndroidManifest.xml", &prefix,
&entry, &suffix));
EXPECT_FALSE(
util::ExtractResFilePathParts("res/.xml", &prefix, &entry, &suffix));
EXPECT_FALSE(util::ExtractResFilePathParts("AndroidManifest.xml", &prefix, &entry, &suffix));
EXPECT_FALSE(util::ExtractResFilePathParts("res/.xml", &prefix, &entry, &suffix));
ASSERT_TRUE(
util::ExtractResFilePathParts("res//.", &prefix, &entry, &suffix));
ASSERT_TRUE(util::ExtractResFilePathParts("res//.", &prefix, &entry, &suffix));
EXPECT_EQ(prefix, "res//");
EXPECT_EQ(entry, "");
EXPECT_EQ(suffix, ".");

12
tools/aapt2/xml/XmlActionExecutor_test.cpp
View File

@@ -18,6 +18,8 @@
#include "test/Test.h"
using ::testing::NotNull;
namespace aapt {
namespace xml {
@@ -42,12 +44,11 @@ TEST(XmlActionExecutorTest, BuildsAccessibleNestedPattern) {
test::BuildXmlDom("<manifest><application /></manifest>");
StdErrDiagnostics diag;
ASSERT_TRUE(
executor.Execute(XmlActionExecutorPolicy::kNone, &diag, doc.get()));
ASSERT_NE(nullptr, manifest_el);
ASSERT_TRUE(executor.Execute(XmlActionExecutorPolicy::kNone, &diag, doc.get()));
ASSERT_THAT(manifest_el, NotNull());
EXPECT_EQ(std::string("manifest"), manifest_el->name);
ASSERT_NE(nullptr, application_el);
ASSERT_THAT(application_el, NotNull());
EXPECT_EQ(std::string("application"), application_el->name);
}
@@ -58,8 +59,7 @@ TEST(XmlActionExecutorTest, FailsWhenUndefinedHierarchyExists) {
std::unique_ptr<XmlResource> doc =
test::BuildXmlDom("<manifest><application /><activity /></manifest>");
StdErrDiagnostics diag;
ASSERT_FALSE(
executor.Execute(XmlActionExecutorPolicy::kWhitelist, &diag, doc.get()));
ASSERT_FALSE(executor.Execute(XmlActionExecutorPolicy::kWhitelist, &diag, doc.get()));
}
} // namespace xml

14
tools/aapt2/xml/XmlDom_test.cpp
View File

@@ -21,6 +21,8 @@
#include "test/Test.h"
using ::testing::NotNull;
namespace aapt {
constexpr const char* kXmlPreamble =
@@ -41,10 +43,10 @@ TEST(XmlDomTest, Inflate) {
const Source source = {"test.xml"};
StdErrDiagnostics diag;
std::unique_ptr<xml::XmlResource> doc = xml::Inflate(&in, &diag, source);
ASSERT_NE(doc, nullptr);
ASSERT_THAT(doc, NotNull());
xml::Namespace* ns = xml::NodeCast<xml::Namespace>(doc->root.get());
ASSERT_NE(ns, nullptr);
ASSERT_THAT(ns, NotNull());
EXPECT_EQ(ns->namespace_uri, xml::kSchemaAndroid);
EXPECT_EQ(ns->namespace_prefix, "android");
}
@@ -55,19 +57,19 @@ TEST(XmlDomTest, ForwardEscapes) {
<element value="\?hello" pattern="\\d{5}">\\d{5}</element>)EOF");
xml::Element* el = xml::FindRootElement(doc->root.get());
ASSERT_NE(nullptr, el);
ASSERT_THAT(el, NotNull());
xml::Attribute* attr = el->FindAttribute({}, "pattern");
ASSERT_NE(nullptr, attr);
ASSERT_THAT(attr, NotNull());
EXPECT_EQ("\\\\d{5}", attr->value);
attr = el->FindAttribute({}, "value");
ASSERT_NE(nullptr, attr);
ASSERT_THAT(attr, NotNull());
EXPECT_EQ("\\?hello", attr->value);
ASSERT_EQ(1u, el->children.size());
xml::Text* text = xml::NodeCast<xml::Text>(el->children[0].get());
ASSERT_NE(nullptr, text);
ASSERT_THAT(text, NotNull());
EXPECT_EQ("\\\\d{5}", text->text);
}

31
tools/aapt2/xml/XmlUtil_test.cpp
View File

@@ -21,37 +21,30 @@
namespace aapt {
TEST(XmlUtilTest, ExtractPackageFromNamespace) {
AAPT_ASSERT_FALSE(xml::ExtractPackageFromNamespace("com.android"));
AAPT_ASSERT_FALSE(
xml::ExtractPackageFromNamespace("http://schemas.android.com/apk"));
AAPT_ASSERT_FALSE(
xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res"));
AAPT_ASSERT_FALSE(
xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/"));
AAPT_ASSERT_FALSE(xml::ExtractPackageFromNamespace(
"http://schemas.android.com/apk/prv/res/"));
ASSERT_FALSE(xml::ExtractPackageFromNamespace("com.android"));
ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk"));
ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res"));
ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/"));
ASSERT_FALSE(xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/prv/res/"));
Maybe<xml::ExtractedPackage> p =
xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/a");
AAPT_ASSERT_TRUE(p);
ASSERT_TRUE(p);
EXPECT_EQ(std::string("a"), p.value().package);
EXPECT_FALSE(p.value().private_namespace);
p = xml::ExtractPackageFromNamespace(
"http://schemas.android.com/apk/prv/res/android");
AAPT_ASSERT_TRUE(p);
p = xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/prv/res/android");
ASSERT_TRUE(p);
EXPECT_EQ(std::string("android"), p.value().package);
EXPECT_TRUE(p.value().private_namespace);
p = xml::ExtractPackageFromNamespace(
"http://schemas.android.com/apk/prv/res/com.test");
AAPT_ASSERT_TRUE(p);
p = xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/prv/res/com.test");
ASSERT_TRUE(p);
EXPECT_EQ(std::string("com.test"), p.value().package);
EXPECT_TRUE(p.value().private_namespace);
p = xml::ExtractPackageFromNamespace(
"http://schemas.android.com/apk/res-auto");
AAPT_ASSERT_TRUE(p);
p = xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res-auto");
ASSERT_TRUE(p);
EXPECT_EQ(std::string(), p.value().package);
EXPECT_TRUE(p.value().private_namespace);
}