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
19 #include <sstream>
20 #include <string>
21
22 #include "ResourceTable.h"
23 #include "ResourceUtils.h"
24 #include "ResourceValues.h"
25 #include "io/StringStream.h"
26 #include "test/Test.h"
27 #include "xml/XmlPullParser.h"
28
29 using ::aapt::io::StringInputStream;
30 using ::aapt::test::StrValueEq;
31 using ::aapt::test::ValueEq;
32 using ::android::ConfigDescription;
33 using ::android::Res_value;
34 using ::android::ResTable_map;
35 using ::android::StringPiece;
36 using ::testing::Eq;
37 using ::testing::IsEmpty;
38 using ::testing::IsNull;
39 using ::testing::NotNull;
40 using ::testing::Pointee;
41 using ::testing::SizeIs;
42 using ::testing::StrEq;
43
44 using PolicyFlags = android::ResTable_overlayable_policy_header::PolicyFlags;
45
46 namespace aapt {
47
48 constexpr const char* kXmlPreamble = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
49
TEST(ResourceParserSingleTest,FailToParseWithNoRootResourcesElement)50 TEST(ResourceParserSingleTest, FailToParseWithNoRootResourcesElement) {
51 std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
52 ResourceTable table;
53 ResourceParser parser(context->GetDiagnostics(), &table, Source{"test"}, {});
54
55 std::string input = kXmlPreamble;
56 input += R"(<attr name="foo"/>)";
57 StringInputStream in(input);
58 xml::XmlPullParser xml_parser(&in);
59 ASSERT_FALSE(parser.Parse(&xml_parser));
60 }
61
62 class ResourceParserTest : public ::testing::Test {
63 public:
SetUp()64 void SetUp() override {
65 context_ = test::ContextBuilder().Build();
66 }
67
TestParse(const StringPiece & str)68 ::testing::AssertionResult TestParse(const StringPiece& str) {
69 return TestParse(str, ConfigDescription{});
70 }
71
TestParse(const StringPiece & str,const ConfigDescription & config)72 ::testing::AssertionResult TestParse(const StringPiece& str, const ConfigDescription& config) {
73 ResourceParserOptions parserOptions;
74 ResourceParser parser(context_->GetDiagnostics(), &table_, Source{"test"}, config,
75 parserOptions);
76
77 std::string input = kXmlPreamble;
78 input += "<resources>\n";
79 input.append(str.data(), str.size());
80 input += "\n</resources>";
81 StringInputStream in(input);
82 xml::XmlPullParser xmlParser(&in);
83 if (parser.Parse(&xmlParser)) {
84 return ::testing::AssertionSuccess();
85 }
86 return ::testing::AssertionFailure();
87 }
88
89 protected:
90 ResourceTable table_;
91 std::unique_ptr<IAaptContext> context_;
92 };
93
TEST_F(ResourceParserTest,ParseQuotedString)94 TEST_F(ResourceParserTest, ParseQuotedString) {
95 ASSERT_TRUE(TestParse(R"(<string name="foo"> " hey there " </string>)"));
96
97 String* str = test::GetValue<String>(&table_, "string/foo");
98 ASSERT_THAT(str, NotNull());
99 EXPECT_THAT(*str, StrValueEq(" hey there "));
100 EXPECT_THAT(str->untranslatable_sections, IsEmpty());
101
102 ASSERT_TRUE(TestParse(R"(<string name="bar">Isn\'t it cool?</string>)"));
103 str = test::GetValue<String>(&table_, "string/bar");
104 ASSERT_THAT(str, NotNull());
105 EXPECT_THAT(*str, StrValueEq("Isn't it cool?"));
106
107 ASSERT_TRUE(TestParse(R"(<string name="baz">"Isn't it cool?"</string>)"));
108 str = test::GetValue<String>(&table_, "string/baz");
109 ASSERT_THAT(str, NotNull());
110 EXPECT_THAT(*str, StrValueEq("Isn't it cool?"));
111 }
112
113 TEST_F(ResourceParserTest, ParseEscapedString) {
114 ASSERT_TRUE(TestParse(R"(<string name="foo">\?123</string>)"));
115
116 String* str = test::GetValue<String>(&table_, "string/foo");
117 ASSERT_THAT(str, NotNull());
118 EXPECT_THAT(*str, StrValueEq("?123"));
119 EXPECT_THAT(str->untranslatable_sections, IsEmpty());
120
121 ASSERT_TRUE(TestParse(R"(<string name="bar">This isn\’t a bad string</string>)"));
122 str = test::GetValue<String>(&table_, "string/bar");
123 ASSERT_THAT(str, NotNull());
124 EXPECT_THAT(*str, StrValueEq("This isn’t a bad string"));
125 }
126
127 TEST_F(ResourceParserTest, ParseFormattedString) {
128 ASSERT_FALSE(TestParse(R"(<string name="foo">%d %s</string>)"));
129 ASSERT_TRUE(TestParse(R"(<string name="foo">%1$d %2$s</string>)"));
130 }
131
132 TEST_F(ResourceParserTest, ParseStyledString) {
133 // Use a surrogate pair unicode point so that we can verify that the span
134 // indices use UTF-16 length and not UTF-8 length.
135 std::string input =
136 "<string name=\"foo\">This is my aunt\u2019s <b>fickle <small>string</small></b></string>";
137 ASSERT_TRUE(TestParse(input));
138
139 StyledString* str = test::GetValue<StyledString>(&table_, "string/foo");
140 ASSERT_THAT(str, NotNull());
141
142 EXPECT_THAT(str->value->value, StrEq("This is my aunt\u2019s fickle string"));
143 EXPECT_THAT(str->value->spans, SizeIs(2));
144 EXPECT_THAT(str->untranslatable_sections, IsEmpty());
145
146 EXPECT_THAT(*str->value->spans[0].name, StrEq("b"));
147 EXPECT_THAT(str->value->spans[0].first_char, Eq(18u));
148 EXPECT_THAT(str->value->spans[0].last_char, Eq(30u));
149
150 EXPECT_THAT(*str->value->spans[1].name, StrEq("small"));
151 EXPECT_THAT(str->value->spans[1].first_char, Eq(25u));
152 EXPECT_THAT(str->value->spans[1].last_char, Eq(30u));
153 }
154
TEST_F(ResourceParserTest,ParseStringWithWhitespace)155 TEST_F(ResourceParserTest, ParseStringWithWhitespace) {
156 ASSERT_TRUE(TestParse(R"(<string name="foo"> This is what I think </string>)"));
157
158 String* str = test::GetValue<String>(&table_, "string/foo");
159 ASSERT_THAT(str, NotNull());
160 EXPECT_THAT(*str->value, StrEq("This is what I think"));
161 EXPECT_THAT(str->untranslatable_sections, IsEmpty());
162
163 ASSERT_TRUE(TestParse(R"(<string name="foo2">" This is what I think "</string>)"));
164
165 str = test::GetValue<String>(&table_, "string/foo2");
166 ASSERT_THAT(str, NotNull());
167 EXPECT_THAT(*str, StrValueEq(" This is what I think "));
168 }
169
TEST_F(ResourceParserTest,ParseStringTruncateASCII)170 TEST_F(ResourceParserTest, ParseStringTruncateASCII) {
171 // Tuncate leading and trailing whitespace
172 EXPECT_TRUE(TestParse(R"(<string name="foo"> Hello </string>)"));
173
174 String* str = test::GetValue<String>(&table_, "string/foo");
175 ASSERT_THAT(str, NotNull());
176 EXPECT_THAT(*str->value, StrEq("Hello"));
177 EXPECT_THAT(str->untranslatable_sections, IsEmpty());
178
179 // AAPT does not truncate unicode whitespace
180 EXPECT_TRUE(TestParse(R"(<string name="foo2">\u0020\Hello\u0020</string>)"));
181
182 str = test::GetValue<String>(&table_, "string/foo2");
183 ASSERT_THAT(str, NotNull());
184 EXPECT_THAT(*str->value, StrEq(" Hello "));
185 EXPECT_THAT(str->untranslatable_sections, IsEmpty());
186
187 // Preserve non-ASCII whitespace including extended ASCII characters
188 EXPECT_TRUE(TestParse(R"(<string name="foo3"> Hello World </string>)"));
189
190 str = test::GetValue<String>(&table_, "string/foo3");
191 ASSERT_THAT(str, NotNull());
192 EXPECT_THAT(*str->value, StrEq("\xC2\xA0Hello\xE2\x80\xAFWorld\xC2\xA0"));
193 EXPECT_THAT(str->untranslatable_sections, IsEmpty());
194
195 EXPECT_TRUE(TestParse(R"(<string name="foo4">2005年6月1日</string>)"));
196
197 str = test::GetValue<String>(&table_, "string/foo4");
198 ASSERT_THAT(str, NotNull());
199 EXPECT_THAT(*str->value, StrEq("2005年6月1日"));
200 EXPECT_THAT(str->untranslatable_sections, IsEmpty());
201 }
202
TEST_F(ResourceParserTest,ParseStyledStringWithWhitespace)203 TEST_F(ResourceParserTest, ParseStyledStringWithWhitespace) {
204 std::string input = R"(<string name="foo"> <b> My <i> favorite</i> string </b> </string>)";
205 ASSERT_TRUE(TestParse(input));
206
207 StyledString* str = test::GetValue<StyledString>(&table_, "string/foo");
208 ASSERT_THAT(str, NotNull());
209 EXPECT_THAT(str->value->value, StrEq(" My favorite string "));
210 EXPECT_THAT(str->untranslatable_sections, IsEmpty());
211
212 ASSERT_THAT(str->value->spans, SizeIs(2u));
213 EXPECT_THAT(*str->value->spans[0].name, StrEq("b"));
214 EXPECT_THAT(str->value->spans[0].first_char, Eq(1u));
215 EXPECT_THAT(str->value->spans[0].last_char, Eq(21u));
216
217 EXPECT_THAT(*str->value->spans[1].name, StrEq("i"));
218 EXPECT_THAT(str->value->spans[1].first_char, Eq(5u));
219 EXPECT_THAT(str->value->spans[1].last_char, Eq(13u));
220 }
221
TEST_F(ResourceParserTest,ParseStringTranslatableAttribute)222 TEST_F(ResourceParserTest, ParseStringTranslatableAttribute) {
223 // If there is no translate attribute the default is 'true'
224 EXPECT_TRUE(TestParse(R"(<string name="foo1">Translate</string>)"));
225 String* str = test::GetValue<String>(&table_, "string/foo1");
226 ASSERT_THAT(str, NotNull());
227 ASSERT_TRUE(str->IsTranslatable());
228
229 // Explicit 'true' translate attribute
230 EXPECT_TRUE(TestParse(R"(<string name="foo2" translatable="true">Translate</string>)"));
231 str = test::GetValue<String>(&table_, "string/foo2");
232 ASSERT_THAT(str, NotNull());
233 ASSERT_TRUE(str->IsTranslatable());
234
235 // Explicit 'false' translate attribute
236 EXPECT_TRUE(TestParse(R"(<string name="foo3" translatable="false">Do not translate</string>)"));
237 str = test::GetValue<String>(&table_, "string/foo3");
238 ASSERT_THAT(str, NotNull());
239 ASSERT_FALSE(str->IsTranslatable());
240
241 // Invalid value for the translate attribute, should be boolean ('true' or 'false')
242 EXPECT_FALSE(TestParse(R"(<string name="foo4" translatable="yes">Translate</string>)"));
243 }
244
TEST_F(ResourceParserTest,IgnoreXliffTagsOtherThanG)245 TEST_F(ResourceParserTest, IgnoreXliffTagsOtherThanG) {
246 std::string input = R"(
247 <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
248 There are <xliff:source>no</xliff:source> apples</string>)";
249 ASSERT_TRUE(TestParse(input));
250
251 String* str = test::GetValue<String>(&table_, "string/foo");
252 ASSERT_THAT(str, NotNull());
253 EXPECT_THAT(*str, StrValueEq("There are no apples"));
254 EXPECT_THAT(str->untranslatable_sections, IsEmpty());
255 }
256
TEST_F(ResourceParserTest,NestedXliffGTagsAreIllegal)257 TEST_F(ResourceParserTest, NestedXliffGTagsAreIllegal) {
258 std::string input = R"(
259 <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
260 Do not <xliff:g>translate <xliff:g>this</xliff:g></xliff:g></string>)";
261 EXPECT_FALSE(TestParse(input));
262 }
263
TEST_F(ResourceParserTest,RecordUntranslateableXliffSectionsInString)264 TEST_F(ResourceParserTest, RecordUntranslateableXliffSectionsInString) {
265 std::string input = R"(
266 <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
267 There are <xliff:g id="count">%1$d</xliff:g> apples</string>)";
268 ASSERT_TRUE(TestParse(input));
269
270 String* str = test::GetValue<String>(&table_, "string/foo");
271 ASSERT_THAT(str, NotNull());
272 EXPECT_THAT(*str, StrValueEq("There are %1$d apples"));
273
274 ASSERT_THAT(str->untranslatable_sections, SizeIs(1));
275 EXPECT_THAT(str->untranslatable_sections[0].start, Eq(10u));
276 EXPECT_THAT(str->untranslatable_sections[0].end, Eq(14u));
277 }
278
TEST_F(ResourceParserTest,RecordUntranslateableXliffSectionsInStyledString)279 TEST_F(ResourceParserTest, RecordUntranslateableXliffSectionsInStyledString) {
280 std::string input = R"(
281 <string name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
282 There are <b><xliff:g id="count">%1$d</xliff:g></b> apples</string>)";
283 ASSERT_TRUE(TestParse(input));
284
285 StyledString* str = test::GetValue<StyledString>(&table_, "string/foo");
286 ASSERT_THAT(str, NotNull());
287 EXPECT_THAT(str->value->value, Eq(" There are %1$d apples"));
288
289 ASSERT_THAT(str->untranslatable_sections, SizeIs(1));
290 EXPECT_THAT(str->untranslatable_sections[0].start, Eq(11u));
291 EXPECT_THAT(str->untranslatable_sections[0].end, Eq(15u));
292
293 ASSERT_THAT(str->value->spans, SizeIs(1u));
294 EXPECT_THAT(*str->value->spans[0].name, StrEq("b"));
295 EXPECT_THAT(str->value->spans[0].first_char, Eq(11u));
296 EXPECT_THAT(str->value->spans[0].last_char, Eq(14u));
297 }
298
TEST_F(ResourceParserTest,ParseNull)299 TEST_F(ResourceParserTest, ParseNull) {
300 std::string input = R"(<integer name="foo">@null</integer>)";
301 ASSERT_TRUE(TestParse(input));
302
303 // The Android runtime treats a value of android::Res_value::TYPE_NULL as
304 // a non-existing value, and this causes problems in styles when trying to
305 // resolve an attribute. Null values must be encoded as android::Res_value::TYPE_REFERENCE
306 // with a data value of 0.
307 Reference* null_ref = test::GetValue<Reference>(&table_, "integer/foo");
308 ASSERT_THAT(null_ref, NotNull());
309 EXPECT_FALSE(null_ref->name);
310 EXPECT_FALSE(null_ref->id);
311 EXPECT_THAT(null_ref->reference_type, Eq(Reference::Type::kResource));
312 }
313
TEST_F(ResourceParserTest,ParseEmpty)314 TEST_F(ResourceParserTest, ParseEmpty) {
315 std::string input = R"(<integer name="foo">@empty</integer>)";
316 ASSERT_TRUE(TestParse(input));
317
318 BinaryPrimitive* integer = test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
319 ASSERT_THAT(integer, NotNull());
320 EXPECT_THAT(integer->value.dataType, Eq(Res_value::TYPE_NULL));
321 EXPECT_THAT(integer->value.data, Eq(Res_value::DATA_NULL_EMPTY));
322 }
323
TEST_F(ResourceParserTest,ParseAttr)324 TEST_F(ResourceParserTest, ParseAttr) {
325 std::string input = R"(
326 <attr name="foo" format="string"/>
327 <attr name="bar"/>)";
328 ASSERT_TRUE(TestParse(input));
329
330 Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
331 ASSERT_THAT(attr, NotNull());
332 EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_STRING));
333
334 attr = test::GetValue<Attribute>(&table_, "attr/bar");
335 ASSERT_THAT(attr, NotNull());
336 EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_ANY));
337 }
338
TEST_F(ResourceParserTest,ParseMacro)339 TEST_F(ResourceParserTest, ParseMacro) {
340 std::string input = R"(<macro name="foo">12345</macro>)";
341 ASSERT_TRUE(TestParse(input));
342
343 Macro* macro = test::GetValue<Macro>(&table_, "macro/foo");
344 ASSERT_THAT(macro, NotNull());
345 EXPECT_THAT(macro->raw_value, Eq("12345"));
346 EXPECT_THAT(macro->style_string.str, Eq("12345"));
347 EXPECT_THAT(macro->style_string.spans, IsEmpty());
348 EXPECT_THAT(macro->untranslatable_sections, IsEmpty());
349 EXPECT_THAT(macro->alias_namespaces, IsEmpty());
350 }
351
TEST_F(ResourceParserTest,ParseMacroUntranslatableSection)352 TEST_F(ResourceParserTest, ParseMacroUntranslatableSection) {
353 std::string input = R"(<macro name="foo" xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
354 This being <b><xliff:g>human</xliff:g></b> is a guest house.</macro>)";
355 ASSERT_TRUE(TestParse(input));
356
357 Macro* macro = test::GetValue<Macro>(&table_, "macro/foo");
358 ASSERT_THAT(macro, NotNull());
359 EXPECT_THAT(macro->raw_value, Eq("\nThis being human is a guest house."));
360 EXPECT_THAT(macro->style_string.str, Eq(" This being human is a guest house."));
361 EXPECT_THAT(macro->style_string.spans.size(), Eq(1));
362 EXPECT_THAT(macro->style_string.spans[0].name, Eq("b"));
363 EXPECT_THAT(macro->style_string.spans[0].first_char, Eq(12));
364 EXPECT_THAT(macro->style_string.spans[0].last_char, Eq(16));
365 ASSERT_THAT(macro->untranslatable_sections.size(), Eq(1));
366 EXPECT_THAT(macro->untranslatable_sections[0].start, Eq(12));
367 EXPECT_THAT(macro->untranslatable_sections[0].end, Eq(17));
368 EXPECT_THAT(macro->alias_namespaces, IsEmpty());
369 }
370
TEST_F(ResourceParserTest,ParseMacroNamespaces)371 TEST_F(ResourceParserTest, ParseMacroNamespaces) {
372 std::string input = R"(<macro name="foo" xmlns:app="http://schemas.android.com/apk/res/android">
373 @app:string/foo</macro>)";
374 ASSERT_TRUE(TestParse(input));
375
376 Macro* macro = test::GetValue<Macro>(&table_, "macro/foo");
377 ASSERT_THAT(macro, NotNull());
378 EXPECT_THAT(macro->raw_value, Eq("\n@app:string/foo"));
379 EXPECT_THAT(macro->style_string.str, Eq("@app:string/foo"));
380 EXPECT_THAT(macro->style_string.spans, IsEmpty());
381 EXPECT_THAT(macro->untranslatable_sections, IsEmpty());
382 EXPECT_THAT(macro->alias_namespaces.size(), Eq(1));
383 EXPECT_THAT(macro->alias_namespaces[0].alias, Eq("app"));
384 EXPECT_THAT(macro->alias_namespaces[0].package_name, Eq("android"));
385 EXPECT_THAT(macro->alias_namespaces[0].is_private, Eq(false));
386 }
387
388 TEST_F(ResourceParserTest, ParseMacroReference) {
389 std::string input = R"(<string name="res_string">@macro/foo</string>)";
390 ASSERT_TRUE(TestParse(input));
391
392 Reference* macro = test::GetValue<Reference>(&table_, "string/res_string");
393 ASSERT_THAT(macro, NotNull());
394 EXPECT_THAT(macro->type_flags, Eq(ResTable_map::TYPE_STRING));
395 EXPECT_THAT(macro->allow_raw, Eq(false));
396
397 input = R"(<style name="foo">
398 <item name="bar">@macro/foo</item>
399 </style>)";
400
401 ASSERT_TRUE(TestParse(input));
402 Style* style = test::GetValue<Style>(&table_, "style/foo");
403 ASSERT_THAT(style, NotNull());
404 EXPECT_THAT(style->entries.size(), Eq(1));
405
406 macro = ValueCast<Reference>(style->entries[0].value.get());
407 ASSERT_THAT(macro, NotNull());
408 EXPECT_THAT(macro->type_flags, Eq(0U));
409 EXPECT_THAT(macro->allow_raw, Eq(true));
410 }
411
412 TEST_F(ResourceParserTest, ParseMacroNoNameFail) {
413 std::string input = R"(<macro>12345</macro>)";
414 ASSERT_FALSE(TestParse(input));
415 }
416
417 TEST_F(ResourceParserTest, ParseMacroNonDefaultConfigurationFail) {
418 const ConfigDescription watch_config = test::ParseConfigOrDie("watch");
419 std::string input = R"(<macro name="foo">12345</macro>)";
420 ASSERT_FALSE(TestParse(input, watch_config));
421 }
422
423 // Old AAPT allowed attributes to be defined under different configurations, but ultimately
424 // stored them with the default configuration. Check that we have the same behavior.
425 TEST_F(ResourceParserTest, ParseAttrAndDeclareStyleableUnderConfigButRecordAsNoConfig) {
426 const ConfigDescription watch_config = test::ParseConfigOrDie("watch");
427 std::string input = R"(
428 <attr name="foo" />
429 <declare-styleable name="bar">
430 <attr name="baz" format="reference"/>
431 </declare-styleable>)";
432 ASSERT_TRUE(TestParse(input, watch_config));
433
434 EXPECT_THAT(test::GetValueForConfig<Attribute>(&table_, "attr/foo", watch_config), IsNull());
435 EXPECT_THAT(test::GetValueForConfig<Attribute>(&table_, "attr/baz", watch_config), IsNull());
436 EXPECT_THAT(test::GetValueForConfig<Styleable>(&table_, "styleable/bar", watch_config), IsNull());
437
438 EXPECT_THAT(test::GetValue<Attribute>(&table_, "attr/foo"), NotNull());
439 EXPECT_THAT(test::GetValue<Attribute>(&table_, "attr/baz"), NotNull());
440 EXPECT_THAT(test::GetValue<Styleable>(&table_, "styleable/bar"), NotNull());
441 }
442
443 TEST_F(ResourceParserTest, ParseAttrWithMinMax) {
444 std::string input = R"(<attr name="foo" min="10" max="23" format="integer"/>)";
445 ASSERT_TRUE(TestParse(input));
446
447 Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
448 ASSERT_THAT(attr, NotNull());
449 EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_INTEGER));
450 EXPECT_THAT(attr->min_int, Eq(10));
451 EXPECT_THAT(attr->max_int, Eq(23));
452 }
453
454 TEST_F(ResourceParserTest, FailParseAttrWithMinMaxButNotInteger) {
455 ASSERT_FALSE(TestParse(R"(<attr name="foo" min="10" max="23" format="string"/>)"));
456 }
457
458 TEST_F(ResourceParserTest, ParseUseAndDeclOfAttr) {
459 std::string input = R"(
460 <declare-styleable name="Styleable">
461 <attr name="foo" />
462 </declare-styleable>
463 <attr name="foo" format="string"/>)";
464 ASSERT_TRUE(TestParse(input));
465
466 Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
467 ASSERT_THAT(attr, NotNull());
468 EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_STRING));
469 }
470
471 TEST_F(ResourceParserTest, ParseDoubleUseOfAttr) {
472 std::string input = R"(
473 <declare-styleable name="Theme">
474 <attr name="foo" />
475 </declare-styleable>
476 <declare-styleable name="Window">
477 <attr name="foo" format="boolean"/>
478 </declare-styleable>)";
479 ASSERT_TRUE(TestParse(input));
480
481 Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
482 ASSERT_THAT(attr, NotNull());
483 EXPECT_THAT(attr->type_mask, Eq(ResTable_map::TYPE_BOOLEAN));
484 }
485
486 TEST_F(ResourceParserTest, ParseEnumAttr) {
487 std::string input = R"(
488 <attr name="foo">
489 <enum name="bar" value="0"/>
490 <enum name="bat" value="0x1"/>
491 <enum name="baz" value="2"/>
492 </attr>)";
493 ASSERT_TRUE(TestParse(input));
494
495 Attribute* enum_attr = test::GetValue<Attribute>(&table_, "attr/foo");
496 ASSERT_THAT(enum_attr, NotNull());
497 EXPECT_THAT(enum_attr->type_mask, Eq(ResTable_map::TYPE_ENUM));
498 ASSERT_THAT(enum_attr->symbols, SizeIs(3));
499
500 ASSERT_TRUE(enum_attr->symbols[0].symbol.name);
501 EXPECT_THAT(enum_attr->symbols[0].symbol.name.value().entry, Eq("bar"));
502 EXPECT_THAT(enum_attr->symbols[0].value, Eq(0u));
503 EXPECT_THAT(enum_attr->symbols[0].type, Eq(Res_value::TYPE_INT_DEC));
504
505 ASSERT_TRUE(enum_attr->symbols[1].symbol.name);
506 EXPECT_THAT(enum_attr->symbols[1].symbol.name.value().entry, Eq("bat"));
507 EXPECT_THAT(enum_attr->symbols[1].value, Eq(1u));
508 EXPECT_THAT(enum_attr->symbols[1].type, Eq(Res_value::TYPE_INT_HEX));
509
510 ASSERT_TRUE(enum_attr->symbols[2].symbol.name);
511 EXPECT_THAT(enum_attr->symbols[2].symbol.name.value().entry, Eq("baz"));
512 EXPECT_THAT(enum_attr->symbols[2].value, Eq(2u));
513 EXPECT_THAT(enum_attr->symbols[2].type, Eq(Res_value::TYPE_INT_DEC));
514 }
515
516 TEST_F(ResourceParserTest, ParseFlagAttr) {
517 std::string input = R"(
518 <attr name="foo">
519 <flag name="bar" value="0"/>
520 <flag name="bat" value="1"/>
521 <flag name="baz" value="2"/>
522 </attr>)";
523 ASSERT_TRUE(TestParse(input));
524
525 Attribute* flag_attr = test::GetValue<Attribute>(&table_, "attr/foo");
526 ASSERT_THAT(flag_attr, NotNull());
527 EXPECT_THAT(flag_attr->type_mask, Eq(ResTable_map::TYPE_FLAGS));
528 ASSERT_THAT(flag_attr->symbols, SizeIs(3));
529
530 ASSERT_TRUE(flag_attr->symbols[0].symbol.name);
531 EXPECT_THAT(flag_attr->symbols[0].symbol.name.value().entry, Eq("bar"));
532 EXPECT_THAT(flag_attr->symbols[0].value, Eq(0u));
533
534 ASSERT_TRUE(flag_attr->symbols[1].symbol.name);
535 EXPECT_THAT(flag_attr->symbols[1].symbol.name.value().entry, Eq("bat"));
536 EXPECT_THAT(flag_attr->symbols[1].value, Eq(1u));
537
538 ASSERT_TRUE(flag_attr->symbols[2].symbol.name);
539 EXPECT_THAT(flag_attr->symbols[2].symbol.name.value().entry, Eq("baz"));
540 EXPECT_THAT(flag_attr->symbols[2].value, Eq(2u));
541
542 std::unique_ptr<BinaryPrimitive> flag_value =
543 ResourceUtils::TryParseFlagSymbol(flag_attr, "baz|bat");
544 ASSERT_THAT(flag_value, NotNull());
545 EXPECT_THAT(flag_value->value.data, Eq(1u | 2u));
546 }
547
548 TEST_F(ResourceParserTest, FailToParseEnumAttrWithNonUniqueKeys) {
549 std::string input = R"(
550 <attr name="foo">
551 <enum name="bar" value="0"/>
552 <enum name="bat" value="1"/>
553 <enum name="bat" value="2"/>
554 </attr>)";
555 ASSERT_FALSE(TestParse(input));
556 }
557
558 TEST_F(ResourceParserTest, ParseStyle) {
559 std::string input = R"(
560 <style name="foo" parent="@style/fu">
561 <item name="bar">#ffffffff</item>
562 <item name="bat">@string/hey</item>
563 <item name="baz"><b>hey</b></item>
564 </style>)";
565 ASSERT_TRUE(TestParse(input));
566
567 Style* style = test::GetValue<Style>(&table_, "style/foo");
568 ASSERT_THAT(style, NotNull());
569 ASSERT_TRUE(style->parent);
570 EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("style/fu"))));
571 ASSERT_THAT(style->entries, SizeIs(3));
572
573 EXPECT_THAT(style->entries[0].key.name, Eq(make_value(test::ParseNameOrDie("attr/bar"))));
574 EXPECT_THAT(style->entries[1].key.name, Eq(make_value(test::ParseNameOrDie("attr/bat"))));
575 EXPECT_THAT(style->entries[2].key.name, Eq(make_value(test::ParseNameOrDie("attr/baz"))));
576 }
577
578 TEST_F(ResourceParserTest, ParseStyleWithShorthandParent) {
579 ASSERT_TRUE(TestParse(R"(<style name="foo" parent="com.app:Theme"/>)"));
580
581 Style* style = test::GetValue<Style>(&table_, "style/foo");
582 ASSERT_THAT(style, NotNull());
583 ASSERT_TRUE(style->parent);
584 EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("com.app:style/Theme"))));
585 }
586
587 TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedParent) {
588 std::string input = R"(
589 <style xmlns:app="http://schemas.android.com/apk/res/android"
590 name="foo" parent="app:Theme"/>)";
591 ASSERT_TRUE(TestParse(input));
592
593 Style* style = test::GetValue<Style>(&table_, "style/foo");
594 ASSERT_THAT(style, NotNull());
595 ASSERT_TRUE(style->parent);
596 ASSERT_TRUE(style->parent.value().name);
597 EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("android:style/Theme"))));
598 }
599
600 TEST_F(ResourceParserTest, ParseStyleWithPackageAliasedItems) {
601 std::string input = R"(
602 <style xmlns:app="http://schemas.android.com/apk/res/android" name="foo">
603 <item name="app:bar">0</item>
604 </style>)";
605 ASSERT_TRUE(TestParse(input));
606
607 Style* style = test::GetValue<Style>(&table_, "style/foo");
608 ASSERT_THAT(style, NotNull());
609 ASSERT_THAT(style->entries, SizeIs(1));
610 EXPECT_THAT(style->entries[0].key.name, Eq(make_value(test::ParseNameOrDie("android:attr/bar"))));
611 }
612
613 TEST_F(ResourceParserTest, ParseStyleWithRawStringItem) {
614 std::string input = R"(
615 <style name="foo">
616 <item name="bar">
617 com.helloworld.AppClass
618 </item>
619 </style>)";
620 ASSERT_TRUE(TestParse(input));
621
622 Style* style = test::GetValue<Style>(&table_, "style/foo");
623 ASSERT_THAT(style, NotNull());
624 EXPECT_THAT(style->entries[0].value, NotNull());
625 RawString* value = ValueCast<RawString>(style->entries[0].value.get());
626 EXPECT_THAT(value, NotNull());
627 EXPECT_THAT(*value->value, StrEq(R"(com.helloworld.AppClass)"));
628 }
629
630
631 TEST_F(ResourceParserTest, ParseStyleWithInferredParent) {
632 ASSERT_TRUE(TestParse(R"(<style name="foo.bar"/>)"));
633
634 Style* style = test::GetValue<Style>(&table_, "style/foo.bar");
635 ASSERT_THAT(style, NotNull());
636 ASSERT_TRUE(style->parent);
637 EXPECT_THAT(style->parent.value().name, Eq(make_value(test::ParseNameOrDie("style/foo"))));
638 EXPECT_TRUE(style->parent_inferred);
639 }
640
641 TEST_F(ResourceParserTest, ParseStyleWithInferredParentOverridenByEmptyParentAttribute) {
642 ASSERT_TRUE(TestParse(R"(<style name="foo.bar" parent=""/>)"));
643
644 Style* style = test::GetValue<Style>(&table_, "style/foo.bar");
645 ASSERT_THAT(style, NotNull());
646 EXPECT_FALSE(style->parent);
647 EXPECT_FALSE(style->parent_inferred);
648 }
649
650 TEST_F(ResourceParserTest, ParseStyleWithPrivateParentReference) {
651 ASSERT_TRUE(TestParse(R"(<style name="foo" parent="*android:style/bar" />)"));
652
653 Style* style = test::GetValue<Style>(&table_, "style/foo");
654 ASSERT_THAT(style, NotNull());
655 ASSERT_TRUE(style->parent);
656 EXPECT_TRUE(style->parent.value().private_reference);
657 }
658
659 TEST_F(ResourceParserTest, ParseAutoGeneratedIdReference) {
660 ASSERT_TRUE(TestParse(R"(<string name="foo">@+id/bar</string>)"));
661 ASSERT_THAT(test::GetValue<Id>(&table_, "id/bar"), NotNull());
662 }
663
664 TEST_F(ResourceParserTest, ParseAttributesDeclareStyleable) {
665 std::string input = R"(
666 <declare-styleable name="foo">
667 <attr name="bar" />
668 <attr name="bat" format="string|reference"/>
669 <attr name="baz">
670 <enum name="foo" value="1"/>
671 </attr>
672 </declare-styleable>)";
673 ASSERT_TRUE(TestParse(input));
674
675 Maybe<ResourceTable::SearchResult> result =
676 table_.FindResource(test::ParseNameOrDie("styleable/foo"));
677 ASSERT_TRUE(result);
678 EXPECT_THAT(result.value().entry->visibility.level, Eq(Visibility::Level::kPublic));
679
680 Attribute* attr = test::GetValue<Attribute>(&table_, "attr/bar");
681 ASSERT_THAT(attr, IsNull());
682
683 attr = test::GetValue<Attribute>(&table_, "attr/bat");
684 ASSERT_THAT(attr, NotNull());
685 EXPECT_TRUE(attr->IsWeak());
686
687 attr = test::GetValue<Attribute>(&table_, "attr/baz");
688 ASSERT_THAT(attr, NotNull());
689 EXPECT_TRUE(attr->IsWeak());
690 EXPECT_THAT(attr->symbols, SizeIs(1));
691
692 EXPECT_THAT(test::GetValue<Id>(&table_, "id/foo"), NotNull());
693
694 Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo");
695 ASSERT_THAT(styleable, NotNull());
696 ASSERT_THAT(styleable->entries, SizeIs(3));
697
698 EXPECT_THAT(styleable->entries[0].name, Eq(make_value(test::ParseNameOrDie("attr/bar"))));
699 EXPECT_THAT(styleable->entries[1].name, Eq(make_value(test::ParseNameOrDie("attr/bat"))));
700 EXPECT_THAT(styleable->entries[2].name, Eq(make_value(test::ParseNameOrDie("attr/baz"))));
701 }
702
703 TEST_F(ResourceParserTest, ParseDeclareStyleablePreservingVisibility) {
704 StringInputStream input(R"(
705 <resources>
706 <declare-styleable name="foo">
707 <attr name="myattr" />
708 </declare-styleable>
709 <declare-styleable name="bar">
710 <attr name="myattr" />
711 </declare-styleable>
712 <public type="styleable" name="bar" />
713 </resources>)");
714 ResourceParser parser(context_->GetDiagnostics(), &table_, Source{"test"},
715 ConfigDescription::DefaultConfig(),
716 ResourceParserOptions{.preserve_visibility_of_styleables = true});
717
718 xml::XmlPullParser xml_parser(&input);
719 ASSERT_TRUE(parser.Parse(&xml_parser));
720
721 EXPECT_EQ(
722 table_.FindResource(test::ParseNameOrDie("styleable/foo")).value().entry->visibility.level,
723 Visibility::Level::kUndefined);
724 EXPECT_EQ(
725 table_.FindResource(test::ParseNameOrDie("styleable/bar")).value().entry->visibility.level,
726 Visibility::Level::kPublic);
727 }
728
729 TEST_F(ResourceParserTest, ParsePrivateAttributesDeclareStyleable) {
730 std::string input = R"(
731 <declare-styleable xmlns:privAndroid="http://schemas.android.com/apk/prv/res/android"
732 name="foo">
733 <attr name="*android:bar" />
734 <attr name="privAndroid:bat" />
735 </declare-styleable>)";
736 ASSERT_TRUE(TestParse(input));
737 Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo");
738 ASSERT_THAT(styleable, NotNull());
739 ASSERT_THAT(styleable->entries, SizeIs(2));
740
741 EXPECT_TRUE(styleable->entries[0].private_reference);
742 ASSERT_TRUE(styleable->entries[0].name);
743 EXPECT_THAT(styleable->entries[0].name.value().package, Eq("android"));
744
745 EXPECT_TRUE(styleable->entries[1].private_reference);
746 ASSERT_TRUE(styleable->entries[1].name);
747 EXPECT_THAT(styleable->entries[1].name.value().package, Eq("android"));
748 }
749
750 TEST_F(ResourceParserTest, ParseArray) {
751 std::string input = R"(
752 <array name="foo">
753 <item>@string/ref</item>
754 <item>hey</item>
755 <item>23</item>
756 </array>)";
757 ASSERT_TRUE(TestParse(input));
758
759 Array* array = test::GetValue<Array>(&table_, "array/foo");
760 ASSERT_THAT(array, NotNull());
761 ASSERT_THAT(array->elements, SizeIs(3));
762
763 EXPECT_THAT(ValueCast<Reference>(array->elements[0].get()), NotNull());
764 EXPECT_THAT(ValueCast<String>(array->elements[1].get()), NotNull());
765 EXPECT_THAT(ValueCast<BinaryPrimitive>(array->elements[2].get()), NotNull());
766 }
767
768 TEST_F(ResourceParserTest, ParseStringArray) {
769 std::string input = R"(
770 <string-array name="foo">
771 <item>"Werk"</item>"
772 </string-array>)";
773 ASSERT_TRUE(TestParse(input));
774 EXPECT_THAT(test::GetValue<Array>(&table_, "array/foo"), NotNull());
775 }
776
TEST_F(ResourceParserTest,ParseArrayWithFormat)777 TEST_F(ResourceParserTest, ParseArrayWithFormat) {
778 std::string input = R"(
779 <array name="foo" format="string">
780 <item>100</item>
781 </array>)";
782 ASSERT_TRUE(TestParse(input));
783
784 Array* array = test::GetValue<Array>(&table_, "array/foo");
785 ASSERT_THAT(array, NotNull());
786 ASSERT_THAT(array->elements, SizeIs(1));
787
788 String* str = ValueCast<String>(array->elements[0].get());
789 ASSERT_THAT(str, NotNull());
790 EXPECT_THAT(*str, StrValueEq("100"));
791 }
792
TEST_F(ResourceParserTest,ParseArrayWithBadFormat)793 TEST_F(ResourceParserTest, ParseArrayWithBadFormat) {
794 std::string input = R"(
795 <array name="foo" format="integer">
796 <item>Hi</item>
797 </array>)";
798 ASSERT_FALSE(TestParse(input));
799 }
800
TEST_F(ResourceParserTest,ParsePlural)801 TEST_F(ResourceParserTest, ParsePlural) {
802 std::string input = R"(
803 <plurals name="foo">
804 <item quantity="other">apples</item>
805 <item quantity="one">apple</item>
806 </plurals>)";
807 ASSERT_TRUE(TestParse(input));
808
809 Plural* plural = test::GetValue<Plural>(&table_, "plurals/foo");
810 ASSERT_THAT(plural, NotNull());
811 EXPECT_THAT(plural->values[Plural::Zero], IsNull());
812 EXPECT_THAT(plural->values[Plural::Two], IsNull());
813 EXPECT_THAT(plural->values[Plural::Few], IsNull());
814 EXPECT_THAT(plural->values[Plural::Many], IsNull());
815
816 EXPECT_THAT(plural->values[Plural::One], NotNull());
817 EXPECT_THAT(plural->values[Plural::Other], NotNull());
818 }
819
TEST_F(ResourceParserTest,ParseCommentsWithResource)820 TEST_F(ResourceParserTest, ParseCommentsWithResource) {
821 std::string input = R"(
822 <!--This is a comment-->
823 <string name="foo">Hi</string>)";
824 ASSERT_TRUE(TestParse(input));
825
826 String* value = test::GetValue<String>(&table_, "string/foo");
827 ASSERT_THAT(value, NotNull());
828 EXPECT_THAT(value->GetComment(), Eq("This is a comment"));
829 }
830
TEST_F(ResourceParserTest,DoNotCombineMultipleComments)831 TEST_F(ResourceParserTest, DoNotCombineMultipleComments) {
832 std::string input = R"(
833 <!--One-->
834 <!--Two-->
835 <string name="foo">Hi</string>)";
836
837 ASSERT_TRUE(TestParse(input));
838
839 String* value = test::GetValue<String>(&table_, "string/foo");
840 ASSERT_THAT(value, NotNull());
841 EXPECT_THAT(value->GetComment(), Eq("Two"));
842 }
843
TEST_F(ResourceParserTest,IgnoreCommentBeforeEndTag)844 TEST_F(ResourceParserTest, IgnoreCommentBeforeEndTag) {
845 std::string input = R"(
846 <!--One-->
847 <string name="foo">
848 Hi
849 <!--Two-->
850 </string>)";
851 ASSERT_TRUE(TestParse(input));
852
853 String* value = test::GetValue<String>(&table_, "string/foo");
854 ASSERT_THAT(value, NotNull());
855 EXPECT_THAT(value->GetComment(), Eq("One"));
856 }
857
TEST_F(ResourceParserTest,ParseNestedComments)858 TEST_F(ResourceParserTest, ParseNestedComments) {
859 // We only care about declare-styleable and enum/flag attributes because
860 // comments from those end up in R.java
861 std::string input = R"(
862 <declare-styleable name="foo">
863 <!-- The name of the bar -->
864 <attr name="barName" format="string|reference" />
865 </declare-styleable>
866
867 <attr name="foo">
868 <!-- The very first -->
869 <enum name="one" value="1" />
870 </attr>)";
871 ASSERT_TRUE(TestParse(input));
872
873 Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo");
874 ASSERT_THAT(styleable, NotNull());
875 ASSERT_THAT(styleable->entries, SizeIs(1));
876 EXPECT_THAT(styleable->entries[0].GetComment(), Eq("The name of the bar"));
877
878 Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
879 ASSERT_THAT(attr, NotNull());
880 ASSERT_THAT(attr->symbols, SizeIs(1));
881 EXPECT_THAT(attr->symbols[0].symbol.GetComment(), Eq("The very first"));
882 }
883
884 // Declaring an ID as public should not require a separate definition (as an ID has no value).
TEST_F(ResourceParserTest,ParsePublicIdAsDefinition)885 TEST_F(ResourceParserTest, ParsePublicIdAsDefinition) {
886 ASSERT_TRUE(TestParse(R"(<public type="id" name="foo"/>)"));
887 ASSERT_THAT(test::GetValue<Id>(&table_, "id/foo"), NotNull());
888 }
889
TEST_F(ResourceParserTest,KeepAllProducts)890 TEST_F(ResourceParserTest, KeepAllProducts) {
891 std::string input = R"(
892 <string name="foo" product="phone">hi</string>
893 <string name="foo" product="no-sdcard">ho</string>
894 <string name="bar" product="">wee</string>
895 <string name="baz">woo</string>
896 <string name="bit" product="phablet">hoot</string>
897 <string name="bot" product="default">yes</string>)";
898 ASSERT_TRUE(TestParse(input));
899
900 ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/foo", ConfigDescription::DefaultConfig(), "phone"), NotNull());
901 ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/foo",ConfigDescription::DefaultConfig(), "no-sdcard"), NotNull());
902 ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/bar", ConfigDescription::DefaultConfig(), ""), NotNull());
903 ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/baz", ConfigDescription::DefaultConfig(), ""), NotNull());
904 ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/bit", ConfigDescription::DefaultConfig(), "phablet"), NotNull());
905 ASSERT_THAT(test::GetValueForConfigAndProduct<String>(&table_, "string/bot", ConfigDescription::DefaultConfig(), "default"), NotNull());
906 }
907
TEST_F(ResourceParserTest,AutoIncrementIdsInPublicGroup)908 TEST_F(ResourceParserTest, AutoIncrementIdsInPublicGroup) {
909 std::string input = R"(
910 <public-group type="attr" first-id="0x01010040">
911 <public name="foo" />
912 <public name="bar" />
913 </public-group>)";
914 ASSERT_TRUE(TestParse(input));
915
916 Maybe<ResourceTable::SearchResult> result = table_.FindResource(test::ParseNameOrDie("attr/foo"));
917 ASSERT_TRUE(result);
918 ASSERT_TRUE(result.value().entry->id);
919 EXPECT_THAT(result.value().entry->id.value(), Eq(ResourceId(0x01010040)));
920
921 result = table_.FindResource(test::ParseNameOrDie("attr/bar"));
922 ASSERT_TRUE(result);
923 ASSERT_TRUE(result.value().entry->id);
924 EXPECT_THAT(result.value().entry->id.value(), Eq(ResourceId(0x01010041)));
925 }
926
TEST_F(ResourceParserTest,StagingPublicGroup)927 TEST_F(ResourceParserTest, StagingPublicGroup) {
928 std::string input = R"(
929 <staging-public-group type="attr" first-id="0x01ff0049">
930 <public name="foo" />
931 <public name="bar" />
932 </staging-public-group>)";
933 ASSERT_TRUE(TestParse(input));
934
935 Maybe<ResourceTable::SearchResult> result = table_.FindResource(test::ParseNameOrDie("attr/foo"));
936 ASSERT_TRUE(result);
937
938 ASSERT_TRUE(result.value().entry->id);
939 EXPECT_THAT(result.value().entry->id.value(), Eq(ResourceId(0x01ff0049)));
940 EXPECT_THAT(result.value().entry->visibility.level, Eq(Visibility::Level::kPublic));
941 EXPECT_TRUE(result.value().entry->visibility.staged_api);
942
943 result = table_.FindResource(test::ParseNameOrDie("attr/bar"));
944 ASSERT_TRUE(result);
945
946 ASSERT_TRUE(result.value().entry->id);
947 EXPECT_THAT(result.value().entry->id.value(), Eq(ResourceId(0x01ff004a)));
948 EXPECT_THAT(result.value().entry->visibility.level, Eq(Visibility::Level::kPublic));
949 EXPECT_TRUE(result.value().entry->visibility.staged_api);
950 }
951
TEST_F(ResourceParserTest,StrongestSymbolVisibilityWins)952 TEST_F(ResourceParserTest, StrongestSymbolVisibilityWins) {
953 std::string input = R"(
954 <!-- private -->
955 <java-symbol type="string" name="foo" />
956 <!-- public -->
957 <public type="string" name="foo" id="0x01020000" />
958 <!-- private2 -->
959 <java-symbol type="string" name="foo" />)";
960 ASSERT_TRUE(TestParse(input));
961
962 Maybe<ResourceTable::SearchResult> result =
963 table_.FindResource(test::ParseNameOrDie("string/foo"));
964 ASSERT_TRUE(result);
965
966 ResourceEntry* entry = result.value().entry;
967 ASSERT_THAT(entry, NotNull());
968 EXPECT_THAT(entry->visibility.level, Eq(Visibility::Level::kPublic));
969 EXPECT_THAT(entry->visibility.comment, StrEq("public"));
970 }
971
TEST_F(ResourceParserTest,ExternalTypesShouldOnlyBeReferences)972 TEST_F(ResourceParserTest, ExternalTypesShouldOnlyBeReferences) {
973 ASSERT_TRUE(TestParse(R"(<item type="layout" name="foo">@layout/bar</item>)"));
974 ASSERT_FALSE(TestParse(R"(<item type="layout" name="bar">"this is a string"</item>)"));
975 }
976
TEST_F(ResourceParserTest,AddResourcesElementShouldAddEntryWithUndefinedSymbol)977 TEST_F(ResourceParserTest, AddResourcesElementShouldAddEntryWithUndefinedSymbol) {
978 ASSERT_TRUE(TestParse(R"(<add-resource name="bar" type="string" />)"));
979
980 Maybe<ResourceTable::SearchResult> result =
981 table_.FindResource(test::ParseNameOrDie("string/bar"));
982 ASSERT_TRUE(result);
983 const ResourceEntry* entry = result.value().entry;
984 ASSERT_THAT(entry, NotNull());
985 EXPECT_THAT(entry->visibility.level, Eq(Visibility::Level::kUndefined));
986 EXPECT_TRUE(entry->allow_new);
987 }
988
TEST_F(ResourceParserTest,ParseItemElementWithFormat)989 TEST_F(ResourceParserTest, ParseItemElementWithFormat) {
990 ASSERT_TRUE(TestParse(R"(<item name="foo" type="integer" format="float">0.3</item>)"));
991
992 BinaryPrimitive* val = test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
993 ASSERT_THAT(val, NotNull());
994 EXPECT_THAT(val->value.dataType, Eq(Res_value::TYPE_FLOAT));
995
996 ASSERT_FALSE(TestParse(R"(<item name="bar" type="integer" format="fraction">100</item>)"));
997 }
998
999 // An <item> without a format specifier accepts all types of values.
TEST_F(ResourceParserTest,ParseItemElementWithoutFormat)1000 TEST_F(ResourceParserTest, ParseItemElementWithoutFormat) {
1001 ASSERT_TRUE(TestParse(R"(<item name="foo" type="integer">100%p</item>)"));
1002
1003 BinaryPrimitive* val = test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
1004 ASSERT_THAT(val, NotNull());
1005 EXPECT_THAT(val->value.dataType, Eq(Res_value::TYPE_FRACTION));
1006 }
1007
TEST_F(ResourceParserTest,ParseConfigVaryingItem)1008 TEST_F(ResourceParserTest, ParseConfigVaryingItem) {
1009 ASSERT_TRUE(TestParse(R"(<item name="foo" type="configVarying">Hey</item>)"));
1010 ASSERT_THAT(test::GetValue<String>(&table_, "configVarying/foo"), NotNull());
1011 }
1012
TEST_F(ResourceParserTest,ParseBagElement)1013 TEST_F(ResourceParserTest, ParseBagElement) {
1014 std::string input = R"(
1015 <bag name="bag" type="configVarying">
1016 <item name="test">Hello!</item>
1017 </bag>)";
1018 ASSERT_TRUE(TestParse(input));
1019
1020 Style* val = test::GetValue<Style>(&table_, "configVarying/bag");
1021 ASSERT_THAT(val, NotNull());
1022 ASSERT_THAT(val->entries, SizeIs(1));
1023
1024 EXPECT_THAT(val->entries[0].key, Eq(Reference(test::ParseNameOrDie("attr/test"))));
1025 EXPECT_THAT(ValueCast<RawString>(val->entries[0].value.get()), NotNull());
1026 }
1027
TEST_F(ResourceParserTest,ParseElementWithNoValue)1028 TEST_F(ResourceParserTest, ParseElementWithNoValue) {
1029 std::string input = R"(
1030 <item type="drawable" format="reference" name="foo" />
1031 <string name="foo" />)";
1032 ASSERT_TRUE(TestParse(input));
1033 ASSERT_THAT(test::GetValue(&table_, "drawable/foo"), Pointee(ValueEq(Reference())));
1034
1035 String* str = test::GetValue<String>(&table_, "string/foo");
1036 ASSERT_THAT(str, NotNull());
1037 EXPECT_THAT(*str, StrValueEq(""));
1038 }
1039
TEST_F(ResourceParserTest,ParsePlatformIndependentNewline)1040 TEST_F(ResourceParserTest, ParsePlatformIndependentNewline) {
1041 ASSERT_TRUE(TestParse(R"(<string name="foo">%1$s %n %2$s</string>)"));
1042 }
1043
TEST_F(ResourceParserTest,ParseOverlayable)1044 TEST_F(ResourceParserTest, ParseOverlayable) {
1045 std::string input = R"(
1046 <overlayable name="Name" actor="overlay://theme">
1047 <policy type="signature">
1048 <item type="string" name="foo" />
1049 <item type="drawable" name="bar" />
1050 </policy>
1051 </overlayable>)";
1052 ASSERT_TRUE(TestParse(input));
1053
1054 auto search_result = table_.FindResource(test::ParseNameOrDie("string/foo"));
1055 ASSERT_TRUE(search_result);
1056 ASSERT_THAT(search_result.value().entry, NotNull());
1057 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1058 OverlayableItem& result_overlayable_item = search_result.value().entry->overlayable_item.value();
1059 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1060 EXPECT_THAT(result_overlayable_item.overlayable->actor, Eq("overlay://theme"));
1061 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::SIGNATURE));
1062
1063 search_result = table_.FindResource(test::ParseNameOrDie("drawable/bar"));
1064 ASSERT_TRUE(search_result);
1065 ASSERT_THAT(search_result.value().entry, NotNull());
1066 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1067 result_overlayable_item = search_result.value().entry->overlayable_item.value();
1068 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1069 EXPECT_THAT(result_overlayable_item.overlayable->actor, Eq("overlay://theme"));
1070 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::SIGNATURE));
1071 }
1072
TEST_F(ResourceParserTest,ParseOverlayableRequiresName)1073 TEST_F(ResourceParserTest, ParseOverlayableRequiresName) {
1074 EXPECT_FALSE(TestParse(R"(<overlayable actor="overlay://theme" />)"));
1075 EXPECT_TRUE(TestParse(R"(<overlayable name="Name" />)"));
1076 EXPECT_TRUE(TestParse(R"(<overlayable name="Name" actor="overlay://theme" />)"));
1077 }
1078
TEST_F(ResourceParserTest,ParseOverlayableBadActorFail)1079 TEST_F(ResourceParserTest, ParseOverlayableBadActorFail) {
1080 EXPECT_FALSE(TestParse(R"(<overlayable name="Name" actor="overley://theme" />)"));
1081 }
1082
TEST_F(ResourceParserTest,ParseOverlayablePolicy)1083 TEST_F(ResourceParserTest, ParseOverlayablePolicy) {
1084 std::string input = R"(
1085 <overlayable name="Name">
1086 <policy type="product">
1087 <item type="string" name="bar" />
1088 </policy>
1089 <policy type="system">
1090 <item type="string" name="fiz" />
1091 </policy>
1092 <policy type="vendor">
1093 <item type="string" name="fuz" />
1094 </policy>
1095 <policy type="public">
1096 <item type="string" name="faz" />
1097 </policy>
1098 <policy type="signature">
1099 <item type="string" name="foz" />
1100 </policy>
1101 <policy type="odm">
1102 <item type="string" name="biz" />
1103 </policy>
1104 <policy type="oem">
1105 <item type="string" name="buz" />
1106 </policy>
1107 <policy type="actor">
1108 <item type="string" name="actor" />
1109 </policy>
1110 </overlayable>)";
1111 ASSERT_TRUE(TestParse(input));
1112
1113 auto search_result = table_.FindResource(test::ParseNameOrDie("string/bar"));
1114 ASSERT_TRUE(search_result);
1115 ASSERT_THAT(search_result.value().entry, NotNull());
1116 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1117 OverlayableItem result_overlayable_item = search_result.value().entry->overlayable_item.value();
1118 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1119 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::PRODUCT_PARTITION));
1120
1121 search_result = table_.FindResource(test::ParseNameOrDie("string/fiz"));
1122 ASSERT_TRUE(search_result);
1123 ASSERT_THAT(search_result.value().entry, NotNull());
1124 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1125 result_overlayable_item = search_result.value().entry->overlayable_item.value();
1126 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1127 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::SYSTEM_PARTITION));
1128
1129 search_result = table_.FindResource(test::ParseNameOrDie("string/fuz"));
1130 ASSERT_TRUE(search_result);
1131 ASSERT_THAT(search_result.value().entry, NotNull());
1132 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1133 result_overlayable_item = search_result.value().entry->overlayable_item.value();
1134 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1135 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::VENDOR_PARTITION));
1136
1137 search_result = table_.FindResource(test::ParseNameOrDie("string/faz"));
1138 ASSERT_TRUE(search_result);
1139 ASSERT_THAT(search_result.value().entry, NotNull());
1140 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1141 result_overlayable_item = search_result.value().entry->overlayable_item.value();
1142 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1143 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::PUBLIC));
1144
1145 search_result = table_.FindResource(test::ParseNameOrDie("string/foz"));
1146 ASSERT_TRUE(search_result);
1147 ASSERT_THAT(search_result.value().entry, NotNull());
1148 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1149 result_overlayable_item = search_result.value().entry->overlayable_item.value();
1150 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1151 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::SIGNATURE));
1152
1153 search_result = table_.FindResource(test::ParseNameOrDie("string/biz"));
1154 ASSERT_TRUE(search_result);
1155 ASSERT_THAT(search_result.value().entry, NotNull());
1156 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1157 result_overlayable_item = search_result.value().entry->overlayable_item.value();
1158 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1159 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::ODM_PARTITION));
1160
1161 search_result = table_.FindResource(test::ParseNameOrDie("string/buz"));
1162 ASSERT_TRUE(search_result);
1163 ASSERT_THAT(search_result.value().entry, NotNull());
1164 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1165 result_overlayable_item = search_result.value().entry->overlayable_item.value();
1166 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1167 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::OEM_PARTITION));
1168
1169 search_result = table_.FindResource(test::ParseNameOrDie("string/actor"));
1170 ASSERT_TRUE(search_result);
1171 ASSERT_THAT(search_result.value().entry, NotNull());
1172 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1173 result_overlayable_item = search_result.value().entry->overlayable_item.value();
1174 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1175 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::ACTOR_SIGNATURE));
1176 }
1177
TEST_F(ResourceParserTest,ParseOverlayableNoPolicyError)1178 TEST_F(ResourceParserTest, ParseOverlayableNoPolicyError) {
1179 std::string input = R"(
1180 <overlayable name="Name">
1181 <item type="string" name="foo" />
1182 </overlayable>)";
1183 EXPECT_FALSE(TestParse(input));
1184
1185 input = R"(
1186 <overlayable name="Name">
1187 <policy>
1188 <item name="foo" />
1189 </policy>
1190 </overlayable>)";
1191 EXPECT_FALSE(TestParse(input));
1192 }
1193
TEST_F(ResourceParserTest,ParseOverlayableBadPolicyError)1194 TEST_F(ResourceParserTest, ParseOverlayableBadPolicyError) {
1195 std::string input = R"(
1196 <overlayable name="Name">
1197 <policy type="illegal_policy">
1198 <item type="string" name="foo" />
1199 </policy>
1200 </overlayable>)";
1201 EXPECT_FALSE(TestParse(input));
1202
1203 input = R"(
1204 <overlayable name="Name">
1205 <policy type="product">
1206 <item name="foo" />
1207 </policy>
1208 </overlayable>)";
1209 EXPECT_FALSE(TestParse(input));
1210
1211 input = R"(
1212 <overlayable name="Name">
1213 <policy type="vendor">
1214 <item type="string" />
1215 </policy>
1216 </overlayable>)";
1217 EXPECT_FALSE(TestParse(input));
1218 }
1219
TEST_F(ResourceParserTest,ParseOverlayableMultiplePolicy)1220 TEST_F(ResourceParserTest, ParseOverlayableMultiplePolicy) {
1221 std::string input = R"(
1222 <overlayable name="Name">
1223 <policy type="vendor|public">
1224 <item type="string" name="foo" />
1225 </policy>
1226 <policy type="product|system">
1227 <item type="string" name="bar" />
1228 </policy>
1229 </overlayable>)";
1230 ASSERT_TRUE(TestParse(input));
1231
1232 auto search_result = table_.FindResource(test::ParseNameOrDie("string/foo"));
1233 ASSERT_TRUE(search_result);
1234 ASSERT_THAT(search_result.value().entry, NotNull());
1235 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1236 OverlayableItem result_overlayable_item = search_result.value().entry->overlayable_item.value();
1237 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1238 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::VENDOR_PARTITION
1239 | PolicyFlags::PUBLIC));
1240
1241 search_result = table_.FindResource(test::ParseNameOrDie("string/bar"));
1242 ASSERT_TRUE(search_result);
1243 ASSERT_THAT(search_result.value().entry, NotNull());
1244 ASSERT_TRUE(search_result.value().entry->overlayable_item);
1245 result_overlayable_item = search_result.value().entry->overlayable_item.value();
1246 EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1247 EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::PRODUCT_PARTITION
1248 | PolicyFlags::SYSTEM_PARTITION));
1249 }
1250
TEST_F(ResourceParserTest,DuplicateOverlayableIsError)1251 TEST_F(ResourceParserTest, DuplicateOverlayableIsError) {
1252 std::string input = R"(
1253 <overlayable name="Name">
1254 <item type="string" name="foo" />
1255 <item type="string" name="foo" />
1256 </overlayable>)";
1257 EXPECT_FALSE(TestParse(input));
1258
1259 input = R"(
1260 <overlayable name="Name">
1261 <item type="string" name="foo" />
1262 </overlayable>
1263 <overlayable name="Name">
1264 <item type="string" name="foo" />
1265 </overlayable>)";
1266 EXPECT_FALSE(TestParse(input));
1267
1268 input = R"(
1269 <overlayable name="Name">
1270 <item type="string" name="foo" />
1271 </overlayable>
1272 <overlayable name="Other">
1273 <item type="string" name="foo" />
1274 </overlayable>)";
1275 EXPECT_FALSE(TestParse(input));
1276
1277 input = R"(
1278 <overlayable name="Name" actor="overlay://my.actor.one">
1279 <item type="string" name="foo" />
1280 </overlayable>
1281 <overlayable name="Other" actor="overlay://my.actor.two">
1282 <item type="string" name="foo" />
1283 </overlayable>)";
1284 EXPECT_FALSE(TestParse(input));
1285
1286 input = R"(
1287 <overlayable name="Name">
1288 <policy type="product">
1289 <item type="string" name="foo" />
1290 <item type="string" name="foo" />
1291 </policy>
1292 </overlayable>)";
1293 EXPECT_FALSE(TestParse(input));
1294
1295 input = R"(
1296 <overlayable name="Name">
1297 <policy type="product">
1298 <item type="string" name="foo" />
1299 </policy>
1300 <item type="string" name="foo" />
1301 </overlayable>)";
1302 EXPECT_FALSE(TestParse(input));
1303
1304 input = R"(
1305 <overlayable name="Name">
1306 <policy type="product">
1307 <item type="string" name="foo" />
1308 </policy>
1309 <policy type="vendor">
1310 <item type="string" name="foo" />
1311 </policy>
1312 </overlayable>)";
1313 EXPECT_FALSE(TestParse(input));
1314
1315 input = R"(
1316 <overlayable name="Name">
1317 <policy type="product">
1318 <item type="string" name="foo" />
1319 </policy>
1320 </overlayable>
1321
1322 <overlayable name="Name">
1323 <policy type="product">
1324 <item type="string" name="foo" />
1325 </policy>
1326 </overlayable>)";
1327 EXPECT_FALSE(TestParse(input));
1328 }
1329
1330 TEST_F(ResourceParserTest, NestPolicyInOverlayableError) {
1331 std::string input = R"(
1332 <overlayable name="Name">
1333 <policy type="vendor|product">
1334 <policy type="public">
1335 <item type="string" name="foo" />
1336 </policy>
1337 </policy>
1338 </overlayable>)";
1339 EXPECT_FALSE(TestParse(input));
1340 }
1341
1342 TEST_F(ResourceParserTest, ParseIdItem) {
1343 std::string input = R"(
1344 <item name="foo" type="id">@id/bar</item>
1345 <item name="bar" type="id"/>
1346 <item name="baz" type="id"></item>)";
1347 ASSERT_TRUE(TestParse(input));
1348
1349 ASSERT_THAT(test::GetValue<Reference>(&table_, "id/foo"), NotNull());
1350 ASSERT_THAT(test::GetValue<Id>(&table_, "id/bar"), NotNull());
1351 ASSERT_THAT(test::GetValue<Id>(&table_, "id/baz"), NotNull());
1352
1353 input = R"(
1354 <id name="foo2">@id/bar</id>
1355 <id name="bar2"/>
1356 <id name="baz2"></id>)";
1357 ASSERT_TRUE(TestParse(input));
1358
1359 ASSERT_THAT(test::GetValue<Reference>(&table_, "id/foo2"), NotNull());
1360 ASSERT_THAT(test::GetValue<Id>(&table_, "id/bar2"), NotNull());
1361 ASSERT_THAT(test::GetValue<Id>(&table_, "id/baz2"), NotNull());
1362
1363 // Reject attribute references
1364 input = R"(<item name="foo3" type="id">?attr/bar"</item>)";
1365 ASSERT_FALSE(TestParse(input));
1366
1367 // Reject non-references
1368 input = R"(<item name="foo4" type="id">0x7f010001</item>)";
1369 ASSERT_FALSE(TestParse(input));
1370 input = R"(<item name="foo5" type="id">@drawable/my_image</item>)";
1371 ASSERT_FALSE(TestParse(input));
1372 input = R"(<item name="foo6" type="id"><string name="biz"></string></item>)";
1373 ASSERT_FALSE(TestParse(input));
1374
1375 // Ids that reference other resource ids cannot be public
1376 input = R"(<public name="foo7" type="id">@id/bar7</item>)";
1377 ASSERT_FALSE(TestParse(input));
1378 }
1379
TEST_F(ResourceParserTest,ParseCData)1380 TEST_F(ResourceParserTest, ParseCData) {
1381 // Double quotes should still change the state of whitespace processing
1382 std::string input = R"(<string name="foo">Hello<![CDATA[ "</string>' ]]> World</string>)";
1383 ASSERT_TRUE(TestParse(input));
1384 auto output = test::GetValue<String>(&table_, "string/foo");
1385 ASSERT_THAT(output, NotNull());
1386 EXPECT_THAT(*output, StrValueEq(std::string("Hello </string>' World").data()));
1387
1388 input = R"(<string name="foo2"><![CDATA[Hello
1389 World]]></string>)";
1390 ASSERT_TRUE(TestParse(input));
1391 output = test::GetValue<String>(&table_, "string/foo2");
1392 ASSERT_THAT(output, NotNull());
1393 EXPECT_THAT(*output, StrValueEq(std::string("Hello World").data()));
1394
1395 // Cdata blocks should have their whitespace trimmed
1396 input = R"(<string name="foo3"> <![CDATA[ text ]]> </string>)";
1397 ASSERT_TRUE(TestParse(input));
1398 output = test::GetValue<String>(&table_, "string/foo3");
1399 ASSERT_THAT(output, NotNull());
1400 EXPECT_THAT(*output, StrValueEq(std::string("text").data()));
1401
1402 input = R"(<string name="foo4"> <![CDATA[]]> </string>)";
1403 ASSERT_TRUE(TestParse(input));
1404 output = test::GetValue<String>(&table_, "string/foo4");
1405 ASSERT_THAT(output, NotNull());
1406 EXPECT_THAT(*output, StrValueEq(std::string("").data()));
1407
1408 input = R"(<string name="foo5"> <![CDATA[ ]]> </string>)";
1409 ASSERT_TRUE(TestParse(input));
1410 output = test::GetValue<String>(&table_, "string/foo5");
1411 ASSERT_THAT(output, NotNull());
1412 EXPECT_THAT(*output, StrValueEq(std::string("").data()));
1413
1414 // Single quotes must still be escaped
1415 input = R"(<string name="foo6"><![CDATA[some text and ' apostrophe]]></string>)";
1416 ASSERT_FALSE(TestParse(input));
1417 }
1418
1419 } // namespace aapt
1420