1/* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "ResourceParser.h" 18#include "ResourceTable.h" 19#include "ResourceUtils.h" 20#include "ResourceValues.h" 21#include "test/Context.h" 22#include "xml/XmlPullParser.h" 23 24#include <gtest/gtest.h> 25#include <sstream> 26#include <string> 27 28namespace aapt { 29 30constexpr const char* kXmlPreamble = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"; 31 32TEST(ResourceParserSingleTest, FailToParseWithNoRootResourcesElement) { 33 std::unique_ptr<IAaptContext> context = test::ContextBuilder().build(); 34 std::stringstream input(kXmlPreamble); 35 input << "<attr name=\"foo\"/>" << std::endl; 36 ResourceTable table; 37 ResourceParser parser(context->getDiagnostics(), &table, Source{ "test" }, {}); 38 xml::XmlPullParser xmlParser(input); 39 ASSERT_FALSE(parser.parse(&xmlParser)); 40} 41 42struct ResourceParserTest : public ::testing::Test { 43 ResourceTable mTable; 44 std::unique_ptr<IAaptContext> mContext; 45 46 void SetUp() override { 47 mContext = test::ContextBuilder().build(); 48 } 49 50 ::testing::AssertionResult testParse(const StringPiece& str) { 51 return testParse(str, ConfigDescription{}); 52 } 53 54 ::testing::AssertionResult testParse(const StringPiece& str, const ConfigDescription& config) { 55 std::stringstream input(kXmlPreamble); 56 input << "<resources>\n" << str << "\n</resources>" << std::endl; 57 ResourceParserOptions parserOptions; 58 ResourceParser parser(mContext->getDiagnostics(), &mTable, Source{ "test" }, config, 59 parserOptions); 60 xml::XmlPullParser xmlParser(input); 61 if (parser.parse(&xmlParser)) { 62 return ::testing::AssertionSuccess(); 63 } 64 return ::testing::AssertionFailure(); 65 } 66}; 67 68TEST_F(ResourceParserTest, ParseQuotedString) { 69 std::string input = "<string name=\"foo\"> \" hey there \" </string>"; 70 ASSERT_TRUE(testParse(input)); 71 72 String* str = test::getValue<String>(&mTable, u"@string/foo"); 73 ASSERT_NE(nullptr, str); 74 EXPECT_EQ(std::u16string(u" hey there "), *str->value); 75} 76 77TEST_F(ResourceParserTest, ParseEscapedString) { 78 std::string input = "<string name=\"foo\">\\?123</string>"; 79 ASSERT_TRUE(testParse(input)); 80 81 String* str = test::getValue<String>(&mTable, u"@string/foo"); 82 ASSERT_NE(nullptr, str); 83 EXPECT_EQ(std::u16string(u"?123"), *str->value); 84} 85 86TEST_F(ResourceParserTest, ParseFormattedString) { 87 std::string input = "<string name=\"foo\">%d %s</string>"; 88 ASSERT_FALSE(testParse(input)); 89 90 input = "<string name=\"foo\">%1$d %2$s</string>"; 91 ASSERT_TRUE(testParse(input)); 92} 93 94TEST_F(ResourceParserTest, IgnoreXliffTags) { 95 std::string input = "<string name=\"foo\" \n" 96 " xmlns:xliff=\"urn:oasis:names:tc:xliff:document:1.2\">\n" 97 " There are <xliff:g id=\"count\">%1$d</xliff:g> apples</string>"; 98 ASSERT_TRUE(testParse(input)); 99 100 String* str = test::getValue<String>(&mTable, u"@string/foo"); 101 ASSERT_NE(nullptr, str); 102 EXPECT_EQ(StringPiece16(u"There are %1$d apples"), StringPiece16(*str->value)); 103} 104 105TEST_F(ResourceParserTest, ParseNull) { 106 std::string input = "<integer name=\"foo\">@null</integer>"; 107 ASSERT_TRUE(testParse(input)); 108 109 // The Android runtime treats a value of android::Res_value::TYPE_NULL as 110 // a non-existing value, and this causes problems in styles when trying to resolve 111 // an attribute. Null values must be encoded as android::Res_value::TYPE_REFERENCE 112 // with a data value of 0. 113 BinaryPrimitive* integer = test::getValue<BinaryPrimitive>(&mTable, u"@integer/foo"); 114 ASSERT_NE(nullptr, integer); 115 EXPECT_EQ(uint16_t(android::Res_value::TYPE_REFERENCE), integer->value.dataType); 116 EXPECT_EQ(0u, integer->value.data); 117} 118 119TEST_F(ResourceParserTest, ParseEmpty) { 120 std::string input = "<integer name=\"foo\">@empty</integer>"; 121 ASSERT_TRUE(testParse(input)); 122 123 BinaryPrimitive* integer = test::getValue<BinaryPrimitive>(&mTable, u"@integer/foo"); 124 ASSERT_NE(nullptr, integer); 125 EXPECT_EQ(uint16_t(android::Res_value::TYPE_NULL), integer->value.dataType); 126 EXPECT_EQ(uint32_t(android::Res_value::DATA_NULL_EMPTY), integer->value.data); 127} 128 129TEST_F(ResourceParserTest, ParseAttr) { 130 std::string input = "<attr name=\"foo\" format=\"string\"/>\n" 131 "<attr name=\"bar\"/>"; 132 ASSERT_TRUE(testParse(input)); 133 134 Attribute* attr = test::getValue<Attribute>(&mTable, u"@attr/foo"); 135 ASSERT_NE(nullptr, attr); 136 EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask); 137 138 attr = test::getValue<Attribute>(&mTable, u"@attr/bar"); 139 ASSERT_NE(nullptr, attr); 140 EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_ANY), attr->typeMask); 141} 142 143// Old AAPT allowed attributes to be defined under different configurations, but ultimately 144// stored them with the default configuration. Check that we have the same behavior. 145TEST_F(ResourceParserTest, ParseAttrAndDeclareStyleableUnderConfigButRecordAsNoConfig) { 146 const ConfigDescription watchConfig = test::parseConfigOrDie("watch"); 147 std::string input = R"EOF( 148 <attr name="foo" /> 149 <declare-styleable name="bar"> 150 <attr name="baz" /> 151 </declare-styleable>)EOF"; 152 ASSERT_TRUE(testParse(input, watchConfig)); 153 154 EXPECT_EQ(nullptr, test::getValueForConfig<Attribute>(&mTable, u"@attr/foo", watchConfig)); 155 EXPECT_EQ(nullptr, test::getValueForConfig<Attribute>(&mTable, u"@attr/baz", watchConfig)); 156 EXPECT_EQ(nullptr, test::getValueForConfig<Styleable>(&mTable, u"@styleable/bar", watchConfig)); 157 158 EXPECT_NE(nullptr, test::getValue<Attribute>(&mTable, u"@attr/foo")); 159 EXPECT_NE(nullptr, test::getValue<Attribute>(&mTable, u"@attr/baz")); 160 EXPECT_NE(nullptr, test::getValue<Styleable>(&mTable, u"@styleable/bar")); 161} 162 163TEST_F(ResourceParserTest, ParseAttrWithMinMax) { 164 std::string input = "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"integer\"/>"; 165 ASSERT_TRUE(testParse(input)); 166 167 Attribute* attr = test::getValue<Attribute>(&mTable, u"@attr/foo"); 168 ASSERT_NE(nullptr, attr); 169 EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_INTEGER), attr->typeMask); 170 EXPECT_EQ(10, attr->minInt); 171 EXPECT_EQ(23, attr->maxInt); 172} 173 174TEST_F(ResourceParserTest, FailParseAttrWithMinMaxButNotInteger) { 175 std::string input = "<attr name=\"foo\" min=\"10\" max=\"23\" format=\"string\"/>"; 176 ASSERT_FALSE(testParse(input)); 177} 178 179TEST_F(ResourceParserTest, ParseUseAndDeclOfAttr) { 180 std::string input = "<declare-styleable name=\"Styleable\">\n" 181 " <attr name=\"foo\" />\n" 182 "</declare-styleable>\n" 183 "<attr name=\"foo\" format=\"string\"/>"; 184 ASSERT_TRUE(testParse(input)); 185 186 Attribute* attr = test::getValue<Attribute>(&mTable, u"@attr/foo"); 187 ASSERT_NE(nullptr, attr); 188 EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask); 189} 190 191TEST_F(ResourceParserTest, ParseDoubleUseOfAttr) { 192 std::string input = "<declare-styleable name=\"Theme\">" 193 " <attr name=\"foo\" />\n" 194 "</declare-styleable>\n" 195 "<declare-styleable name=\"Window\">\n" 196 " <attr name=\"foo\" format=\"boolean\"/>\n" 197 "</declare-styleable>"; 198 ASSERT_TRUE(testParse(input)); 199 200 Attribute* attr = test::getValue<Attribute>(&mTable, u"@attr/foo"); 201 ASSERT_NE(nullptr, attr); 202 EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_BOOLEAN), attr->typeMask); 203} 204 205TEST_F(ResourceParserTest, ParseEnumAttr) { 206 std::string input = "<attr name=\"foo\">\n" 207 " <enum name=\"bar\" value=\"0\"/>\n" 208 " <enum name=\"bat\" value=\"1\"/>\n" 209 " <enum name=\"baz\" value=\"2\"/>\n" 210 "</attr>"; 211 ASSERT_TRUE(testParse(input)); 212 213 Attribute* enumAttr = test::getValue<Attribute>(&mTable, u"@attr/foo"); 214 ASSERT_NE(enumAttr, nullptr); 215 EXPECT_EQ(enumAttr->typeMask, android::ResTable_map::TYPE_ENUM); 216 ASSERT_EQ(enumAttr->symbols.size(), 3u); 217 218 AAPT_ASSERT_TRUE(enumAttr->symbols[0].symbol.name); 219 EXPECT_EQ(enumAttr->symbols[0].symbol.name.value().entry, u"bar"); 220 EXPECT_EQ(enumAttr->symbols[0].value, 0u); 221 222 AAPT_ASSERT_TRUE(enumAttr->symbols[1].symbol.name); 223 EXPECT_EQ(enumAttr->symbols[1].symbol.name.value().entry, u"bat"); 224 EXPECT_EQ(enumAttr->symbols[1].value, 1u); 225 226 AAPT_ASSERT_TRUE(enumAttr->symbols[2].symbol.name); 227 EXPECT_EQ(enumAttr->symbols[2].symbol.name.value().entry, u"baz"); 228 EXPECT_EQ(enumAttr->symbols[2].value, 2u); 229} 230 231TEST_F(ResourceParserTest, ParseFlagAttr) { 232 std::string input = "<attr name=\"foo\">\n" 233 " <flag name=\"bar\" value=\"0\"/>\n" 234 " <flag name=\"bat\" value=\"1\"/>\n" 235 " <flag name=\"baz\" value=\"2\"/>\n" 236 "</attr>"; 237 ASSERT_TRUE(testParse(input)); 238 239 Attribute* flagAttr = test::getValue<Attribute>(&mTable, u"@attr/foo"); 240 ASSERT_NE(nullptr, flagAttr); 241 EXPECT_EQ(flagAttr->typeMask, android::ResTable_map::TYPE_FLAGS); 242 ASSERT_EQ(flagAttr->symbols.size(), 3u); 243 244 AAPT_ASSERT_TRUE(flagAttr->symbols[0].symbol.name); 245 EXPECT_EQ(flagAttr->symbols[0].symbol.name.value().entry, u"bar"); 246 EXPECT_EQ(flagAttr->symbols[0].value, 0u); 247 248 AAPT_ASSERT_TRUE(flagAttr->symbols[1].symbol.name); 249 EXPECT_EQ(flagAttr->symbols[1].symbol.name.value().entry, u"bat"); 250 EXPECT_EQ(flagAttr->symbols[1].value, 1u); 251 252 AAPT_ASSERT_TRUE(flagAttr->symbols[2].symbol.name); 253 EXPECT_EQ(flagAttr->symbols[2].symbol.name.value().entry, u"baz"); 254 EXPECT_EQ(flagAttr->symbols[2].value, 2u); 255 256 std::unique_ptr<BinaryPrimitive> flagValue = ResourceUtils::tryParseFlagSymbol(flagAttr, 257 u"baz|bat"); 258 ASSERT_NE(nullptr, flagValue); 259 EXPECT_EQ(flagValue->value.data, 1u | 2u); 260} 261 262TEST_F(ResourceParserTest, FailToParseEnumAttrWithNonUniqueKeys) { 263 std::string input = "<attr name=\"foo\">\n" 264 " <enum name=\"bar\" value=\"0\"/>\n" 265 " <enum name=\"bat\" value=\"1\"/>\n" 266 " <enum name=\"bat\" value=\"2\"/>\n" 267 "</attr>"; 268 ASSERT_FALSE(testParse(input)); 269} 270 271TEST_F(ResourceParserTest, ParseStyle) { 272 std::string input = "<style name=\"foo\" parent=\"@style/fu\">\n" 273 " <item name=\"bar\">#ffffffff</item>\n" 274 " <item name=\"bat\">@string/hey</item>\n" 275 " <item name=\"baz\"><b>hey</b></item>\n" 276 "</style>"; 277 ASSERT_TRUE(testParse(input)); 278 279 Style* style = test::getValue<Style>(&mTable, u"@style/foo"); 280 ASSERT_NE(nullptr, style); 281 AAPT_ASSERT_TRUE(style->parent); 282 AAPT_ASSERT_TRUE(style->parent.value().name); 283 EXPECT_EQ(test::parseNameOrDie(u"@style/fu"), style->parent.value().name.value()); 284 ASSERT_EQ(3u, style->entries.size()); 285 286 AAPT_ASSERT_TRUE(style->entries[0].key.name); 287 EXPECT_EQ(test::parseNameOrDie(u"@attr/bar"), style->entries[0].key.name.value()); 288 289 AAPT_ASSERT_TRUE(style->entries[1].key.name); 290 EXPECT_EQ(test::parseNameOrDie(u"@attr/bat"), style->entries[1].key.name.value()); 291 292 AAPT_ASSERT_TRUE(style->entries[2].key.name); 293 EXPECT_EQ(test::parseNameOrDie(u"@attr/baz"), style->entries[2].key.name.value()); 294} 295 296TEST_F(ResourceParserTest, ParseStyleWithShorthandParent) { 297 std::string input = "<style name=\"foo\" parent=\"com.app:Theme\"/>"; 298 ASSERT_TRUE(testParse(input)); 299 300 Style* style = test::getValue<Style>(&mTable, u"@style/foo"); 301 ASSERT_NE(nullptr, style); 302 AAPT_ASSERT_TRUE(style->parent); 303 AAPT_ASSERT_TRUE(style->parent.value().name); 304 EXPECT_EQ(test::parseNameOrDie(u"@com.app:style/Theme"), style->parent.value().name.value()); 305} 306 307TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedParent) { 308 std::string input = "<style xmlns:app=\"http://schemas.android.com/apk/res/android\"\n" 309 " name=\"foo\" parent=\"app:Theme\"/>"; 310 ASSERT_TRUE(testParse(input)); 311 312 Style* style = test::getValue<Style>(&mTable, u"@style/foo"); 313 ASSERT_NE(nullptr, style); 314 AAPT_ASSERT_TRUE(style->parent); 315 AAPT_ASSERT_TRUE(style->parent.value().name); 316 EXPECT_EQ(test::parseNameOrDie(u"@android:style/Theme"), style->parent.value().name.value()); 317} 318 319TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedItems) { 320 std::string input = 321 "<style xmlns:app=\"http://schemas.android.com/apk/res/android\" name=\"foo\">\n" 322 " <item name=\"app:bar\">0</item>\n" 323 "</style>"; 324 ASSERT_TRUE(testParse(input)); 325 326 Style* style = test::getValue<Style>(&mTable, u"@style/foo"); 327 ASSERT_NE(nullptr, style); 328 ASSERT_EQ(1u, style->entries.size()); 329 EXPECT_EQ(test::parseNameOrDie(u"@android:attr/bar"), style->entries[0].key.name.value()); 330} 331 332TEST_F(ResourceParserTest, ParseStyleWithInferredParent) { 333 std::string input = "<style name=\"foo.bar\"/>"; 334 ASSERT_TRUE(testParse(input)); 335 336 Style* style = test::getValue<Style>(&mTable, u"@style/foo.bar"); 337 ASSERT_NE(nullptr, style); 338 AAPT_ASSERT_TRUE(style->parent); 339 AAPT_ASSERT_TRUE(style->parent.value().name); 340 EXPECT_EQ(style->parent.value().name.value(), test::parseNameOrDie(u"@style/foo")); 341 EXPECT_TRUE(style->parentInferred); 342} 343 344TEST_F(ResourceParserTest, ParseStyleWithInferredParentOverridenByEmptyParentAttribute) { 345 std::string input = "<style name=\"foo.bar\" parent=\"\"/>"; 346 ASSERT_TRUE(testParse(input)); 347 348 Style* style = test::getValue<Style>(&mTable, u"@style/foo.bar"); 349 ASSERT_NE(nullptr, style); 350 AAPT_EXPECT_FALSE(style->parent); 351 EXPECT_FALSE(style->parentInferred); 352} 353 354TEST_F(ResourceParserTest, ParseStyleWithPrivateParentReference) { 355 std::string input = R"EOF(<style name="foo" parent="*android:style/bar" />)EOF"; 356 ASSERT_TRUE(testParse(input)); 357 358 Style* style = test::getValue<Style>(&mTable, u"@style/foo"); 359 ASSERT_NE(nullptr, style); 360 AAPT_ASSERT_TRUE(style->parent); 361 EXPECT_TRUE(style->parent.value().privateReference); 362} 363 364TEST_F(ResourceParserTest, ParseAutoGeneratedIdReference) { 365 std::string input = "<string name=\"foo\">@+id/bar</string>"; 366 ASSERT_TRUE(testParse(input)); 367 368 Id* id = test::getValue<Id>(&mTable, u"@id/bar"); 369 ASSERT_NE(id, nullptr); 370} 371 372TEST_F(ResourceParserTest, ParseAttributesDeclareStyleable) { 373 std::string input = "<declare-styleable name=\"foo\">\n" 374 " <attr name=\"bar\" />\n" 375 " <attr name=\"bat\" format=\"string|reference\"/>\n" 376 " <attr name=\"baz\">\n" 377 " <enum name=\"foo\" value=\"1\"/>\n" 378 " </attr>\n" 379 "</declare-styleable>"; 380 ASSERT_TRUE(testParse(input)); 381 382 Maybe<ResourceTable::SearchResult> result = 383 mTable.findResource(test::parseNameOrDie(u"@styleable/foo")); 384 AAPT_ASSERT_TRUE(result); 385 EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbolStatus.state); 386 387 Attribute* attr = test::getValue<Attribute>(&mTable, u"@attr/bar"); 388 ASSERT_NE(attr, nullptr); 389 EXPECT_TRUE(attr->isWeak()); 390 391 attr = test::getValue<Attribute>(&mTable, u"@attr/bat"); 392 ASSERT_NE(attr, nullptr); 393 EXPECT_TRUE(attr->isWeak()); 394 395 attr = test::getValue<Attribute>(&mTable, u"@attr/baz"); 396 ASSERT_NE(attr, nullptr); 397 EXPECT_TRUE(attr->isWeak()); 398 EXPECT_EQ(1u, attr->symbols.size()); 399 400 EXPECT_NE(nullptr, test::getValue<Id>(&mTable, u"@id/foo")); 401 402 Styleable* styleable = test::getValue<Styleable>(&mTable, u"@styleable/foo"); 403 ASSERT_NE(styleable, nullptr); 404 ASSERT_EQ(3u, styleable->entries.size()); 405 406 EXPECT_EQ(test::parseNameOrDie(u"@attr/bar"), styleable->entries[0].name.value()); 407 EXPECT_EQ(test::parseNameOrDie(u"@attr/bat"), styleable->entries[1].name.value()); 408} 409 410TEST_F(ResourceParserTest, ParsePrivateAttributesDeclareStyleable) { 411 std::string input = "<declare-styleable name=\"foo\" xmlns:privAndroid=\"http://schemas.android.com/apk/prv/res/android\">\n" 412 " <attr name=\"*android:bar\" />\n" 413 " <attr name=\"privAndroid:bat\" />\n" 414 "</declare-styleable>"; 415 ASSERT_TRUE(testParse(input)); 416 Styleable* styleable = test::getValue<Styleable>(&mTable, u"@styleable/foo"); 417 ASSERT_NE(nullptr, styleable); 418 ASSERT_EQ(2u, styleable->entries.size()); 419 420 EXPECT_TRUE(styleable->entries[0].privateReference); 421 AAPT_ASSERT_TRUE(styleable->entries[0].name); 422 EXPECT_EQ(std::u16string(u"android"), styleable->entries[0].name.value().package); 423 424 EXPECT_TRUE(styleable->entries[1].privateReference); 425 AAPT_ASSERT_TRUE(styleable->entries[1].name); 426 EXPECT_EQ(std::u16string(u"android"), styleable->entries[1].name.value().package); 427} 428 429TEST_F(ResourceParserTest, ParseArray) { 430 std::string input = "<array name=\"foo\">\n" 431 " <item>@string/ref</item>\n" 432 " <item>hey</item>\n" 433 " <item>23</item>\n" 434 "</array>"; 435 ASSERT_TRUE(testParse(input)); 436 437 Array* array = test::getValue<Array>(&mTable, u"@array/foo"); 438 ASSERT_NE(array, nullptr); 439 ASSERT_EQ(3u, array->items.size()); 440 441 EXPECT_NE(nullptr, valueCast<Reference>(array->items[0].get())); 442 EXPECT_NE(nullptr, valueCast<String>(array->items[1].get())); 443 EXPECT_NE(nullptr, valueCast<BinaryPrimitive>(array->items[2].get())); 444} 445 446TEST_F(ResourceParserTest, ParseStringArray) { 447 std::string input = "<string-array name=\"foo\">\n" 448 " <item>\"Werk\"</item>\n" 449 "</string-array>\n"; 450 ASSERT_TRUE(testParse(input)); 451 EXPECT_NE(nullptr, test::getValue<Array>(&mTable, u"@array/foo")); 452} 453 454TEST_F(ResourceParserTest, ParsePlural) { 455 std::string input = "<plurals name=\"foo\">\n" 456 " <item quantity=\"other\">apples</item>\n" 457 " <item quantity=\"one\">apple</item>\n" 458 "</plurals>"; 459 ASSERT_TRUE(testParse(input)); 460} 461 462TEST_F(ResourceParserTest, ParseCommentsWithResource) { 463 std::string input = "<!--This is a comment-->\n" 464 "<string name=\"foo\">Hi</string>"; 465 ASSERT_TRUE(testParse(input)); 466 467 String* value = test::getValue<String>(&mTable, u"@string/foo"); 468 ASSERT_NE(nullptr, value); 469 EXPECT_EQ(value->getComment(), u"This is a comment"); 470} 471 472TEST_F(ResourceParserTest, DoNotCombineMultipleComments) { 473 std::string input = "<!--One-->\n" 474 "<!--Two-->\n" 475 "<string name=\"foo\">Hi</string>"; 476 477 ASSERT_TRUE(testParse(input)); 478 479 String* value = test::getValue<String>(&mTable, u"@string/foo"); 480 ASSERT_NE(nullptr, value); 481 EXPECT_EQ(value->getComment(), u"Two"); 482} 483 484TEST_F(ResourceParserTest, IgnoreCommentBeforeEndTag) { 485 std::string input = "<!--One-->\n" 486 "<string name=\"foo\">\n" 487 " Hi\n" 488 "<!--Two-->\n" 489 "</string>"; 490 491 ASSERT_TRUE(testParse(input)); 492 493 String* value = test::getValue<String>(&mTable, u"@string/foo"); 494 ASSERT_NE(nullptr, value); 495 EXPECT_EQ(value->getComment(), u"One"); 496} 497 498TEST_F(ResourceParserTest, ParseNestedComments) { 499 // We only care about declare-styleable and enum/flag attributes because comments 500 // from those end up in R.java 501 std::string input = R"EOF( 502 <declare-styleable name="foo"> 503 <!-- The name of the bar --> 504 <attr name="barName" format="string|reference" /> 505 </declare-styleable> 506 507 <attr name="foo"> 508 <!-- The very first --> 509 <enum name="one" value="1" /> 510 </attr>)EOF"; 511 ASSERT_TRUE(testParse(input)); 512 513 Styleable* styleable = test::getValue<Styleable>(&mTable, u"@styleable/foo"); 514 ASSERT_NE(nullptr, styleable); 515 ASSERT_EQ(1u, styleable->entries.size()); 516 517 EXPECT_EQ(StringPiece16(u"The name of the bar"), styleable->entries.front().getComment()); 518 519 Attribute* attr = test::getValue<Attribute>(&mTable, u"@attr/foo"); 520 ASSERT_NE(nullptr, attr); 521 ASSERT_EQ(1u, attr->symbols.size()); 522 523 EXPECT_EQ(StringPiece16(u"The very first"), attr->symbols.front().symbol.getComment()); 524} 525 526/* 527 * Declaring an ID as public should not require a separate definition 528 * (as an ID has no value). 529 */ 530TEST_F(ResourceParserTest, ParsePublicIdAsDefinition) { 531 std::string input = "<public type=\"id\" name=\"foo\"/>"; 532 ASSERT_TRUE(testParse(input)); 533 534 Id* id = test::getValue<Id>(&mTable, u"@id/foo"); 535 ASSERT_NE(nullptr, id); 536} 537 538TEST_F(ResourceParserTest, KeepAllProducts) { 539 std::string input = R"EOF( 540 <string name="foo" product="phone">hi</string> 541 <string name="foo" product="no-sdcard">ho</string> 542 <string name="bar" product="">wee</string> 543 <string name="baz">woo</string> 544 <string name="bit" product="phablet">hoot</string> 545 <string name="bot" product="default">yes</string> 546 )EOF"; 547 ASSERT_TRUE(testParse(input)); 548 549 EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, u"@string/foo", 550 ConfigDescription::defaultConfig(), 551 "phone")); 552 EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, u"@string/foo", 553 ConfigDescription::defaultConfig(), 554 "no-sdcard")); 555 EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, u"@string/bar", 556 ConfigDescription::defaultConfig(), 557 "")); 558 EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, u"@string/baz", 559 ConfigDescription::defaultConfig(), 560 "")); 561 EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, u"@string/bit", 562 ConfigDescription::defaultConfig(), 563 "phablet")); 564 EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(&mTable, u"@string/bot", 565 ConfigDescription::defaultConfig(), 566 "default")); 567} 568 569TEST_F(ResourceParserTest, AutoIncrementIdsInPublicGroup) { 570 std::string input = R"EOF( 571 <public-group type="attr" first-id="0x01010040"> 572 <public name="foo" /> 573 <public name="bar" /> 574 </public-group>)EOF"; 575 ASSERT_TRUE(testParse(input)); 576 577 Maybe<ResourceTable::SearchResult> result = mTable.findResource( 578 test::parseNameOrDie(u"@attr/foo")); 579 AAPT_ASSERT_TRUE(result); 580 581 AAPT_ASSERT_TRUE(result.value().package->id); 582 AAPT_ASSERT_TRUE(result.value().type->id); 583 AAPT_ASSERT_TRUE(result.value().entry->id); 584 ResourceId actualId(result.value().package->id.value(), 585 result.value().type->id.value(), 586 result.value().entry->id.value()); 587 EXPECT_EQ(ResourceId(0x01010040), actualId); 588 589 result = mTable.findResource(test::parseNameOrDie(u"@attr/bar")); 590 AAPT_ASSERT_TRUE(result); 591 592 AAPT_ASSERT_TRUE(result.value().package->id); 593 AAPT_ASSERT_TRUE(result.value().type->id); 594 AAPT_ASSERT_TRUE(result.value().entry->id); 595 actualId = ResourceId(result.value().package->id.value(), 596 result.value().type->id.value(), 597 result.value().entry->id.value()); 598 EXPECT_EQ(ResourceId(0x01010041), actualId); 599} 600 601TEST_F(ResourceParserTest, ExternalTypesShouldOnlyBeReferences) { 602 std::string input = R"EOF(<item type="layout" name="foo">@layout/bar</item>)EOF"; 603 ASSERT_TRUE(testParse(input)); 604 605 input = R"EOF(<item type="layout" name="bar">"this is a string"</item>)EOF"; 606 ASSERT_FALSE(testParse(input)); 607} 608 609TEST_F(ResourceParserTest, AddResourcesElementShouldAddEntryWithUndefinedSymbol) { 610 std::string input = R"EOF(<add-resource name="bar" type="string" />)EOF"; 611 ASSERT_TRUE(testParse(input)); 612 613 Maybe<ResourceTable::SearchResult> result = mTable.findResource( 614 test::parseNameOrDie(u"@string/bar")); 615 AAPT_ASSERT_TRUE(result); 616 const ResourceEntry* entry = result.value().entry; 617 ASSERT_NE(nullptr, entry); 618 EXPECT_EQ(SymbolState::kUndefined, entry->symbolStatus.state); 619} 620 621TEST_F(ResourceParserTest, ParseItemElementWithFormat) { 622 std::string input = R"EOF(<item name="foo" type="integer" format="float">0.3</item>)EOF"; 623 ASSERT_TRUE(testParse(input)); 624 625 BinaryPrimitive* val = test::getValue<BinaryPrimitive>(&mTable, u"@integer/foo"); 626 ASSERT_NE(nullptr, val); 627 628 EXPECT_EQ(uint32_t(android::Res_value::TYPE_FLOAT), val->value.dataType); 629} 630 631} // namespace aapt 632