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, android::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(StringPiece str)68   ::testing::AssertionResult TestParse(StringPiece str) {
69     return TestParse(str, ConfigDescription{});
70   }
71 
TestParse(StringPiece str,const ConfigDescription & config)72   ::testing::AssertionResult TestParse(StringPiece str, const ConfigDescription& config) {
73     ResourceParserOptions parserOptions;
74     ResourceParser parser(context_->GetDiagnostics(), &table_, android::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">&#32;Hello&#32;</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">&#160;Hello&#x202F;World&#160;</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(test::ParseNameOrDie("style/fu")));
571   ASSERT_THAT(style->entries, SizeIs(3));
572 
573   EXPECT_THAT(style->entries[0].key.name, Eq(test::ParseNameOrDie("attr/bar")));
574   EXPECT_THAT(style->entries[1].key.name, Eq(test::ParseNameOrDie("attr/bat")));
575   EXPECT_THAT(style->entries[2].key.name, Eq(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(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(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(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(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   std::optional<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(test::ParseNameOrDie("attr/bar")));
699   EXPECT_THAT(styleable->entries[1].name, Eq(test::ParseNameOrDie("attr/bat")));
700   EXPECT_THAT(styleable->entries[2].name, Eq(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_, android::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   std::optional<ResourceTable::SearchResult> result =
917       table_.FindResource(test::ParseNameOrDie("attr/foo"));
918   ASSERT_TRUE(result);
919   ASSERT_TRUE(result.value().entry->id);
920   EXPECT_THAT(result.value().entry->id.value(), Eq(ResourceId(0x01010040)));
921 
922   result = table_.FindResource(test::ParseNameOrDie("attr/bar"));
923   ASSERT_TRUE(result);
924   ASSERT_TRUE(result.value().entry->id);
925   EXPECT_THAT(result.value().entry->id.value(), Eq(ResourceId(0x01010041)));
926 }
927 
TEST_F(ResourceParserTest,StagingPublicGroup)928 TEST_F(ResourceParserTest, StagingPublicGroup) {
929   std::string input = R"(
930       <staging-public-group type="attr" first-id="0x01ff0049">
931         <public name="foo" />
932         <public name="bar" />
933       </staging-public-group>)";
934   ASSERT_TRUE(TestParse(input));
935 
936   std::optional<ResourceTable::SearchResult> result =
937       table_.FindResource(test::ParseNameOrDie("attr/foo"));
938   ASSERT_TRUE(result);
939 
940   ASSERT_TRUE(result.value().entry->id);
941   EXPECT_THAT(result.value().entry->id.value(), Eq(ResourceId(0x01ff0049)));
942   EXPECT_THAT(result.value().entry->visibility.level, Eq(Visibility::Level::kPublic));
943   EXPECT_TRUE(result.value().entry->visibility.staged_api);
944 
945   result = table_.FindResource(test::ParseNameOrDie("attr/bar"));
946   ASSERT_TRUE(result);
947 
948   ASSERT_TRUE(result.value().entry->id);
949   EXPECT_THAT(result.value().entry->id.value(), Eq(ResourceId(0x01ff004a)));
950   EXPECT_THAT(result.value().entry->visibility.level, Eq(Visibility::Level::kPublic));
951   EXPECT_TRUE(result.value().entry->visibility.staged_api);
952 }
953 
TEST_F(ResourceParserTest,StrongestSymbolVisibilityWins)954 TEST_F(ResourceParserTest, StrongestSymbolVisibilityWins) {
955   std::string input = R"(
956       <!-- private -->
957       <java-symbol type="string" name="foo" />
958       <!-- public -->
959       <public type="string" name="foo" id="0x01020000" />
960       <!-- private2 -->
961       <java-symbol type="string" name="foo" />)";
962   ASSERT_TRUE(TestParse(input));
963 
964   std::optional<ResourceTable::SearchResult> result =
965       table_.FindResource(test::ParseNameOrDie("string/foo"));
966   ASSERT_TRUE(result);
967 
968   ResourceEntry* entry = result.value().entry;
969   ASSERT_THAT(entry, NotNull());
970   EXPECT_THAT(entry->visibility.level, Eq(Visibility::Level::kPublic));
971   EXPECT_THAT(entry->visibility.comment, StrEq("public"));
972 }
973 
TEST_F(ResourceParserTest,ExternalTypesShouldOnlyBeReferences)974 TEST_F(ResourceParserTest, ExternalTypesShouldOnlyBeReferences) {
975   ASSERT_TRUE(TestParse(R"(<item type="layout" name="foo">@layout/bar</item>)"));
976   ASSERT_FALSE(TestParse(R"(<item type="layout" name="bar">"this is a string"</item>)"));
977 }
978 
TEST_F(ResourceParserTest,AddResourcesElementShouldAddEntryWithUndefinedSymbol)979 TEST_F(ResourceParserTest, AddResourcesElementShouldAddEntryWithUndefinedSymbol) {
980   ASSERT_TRUE(TestParse(R"(<add-resource name="bar" type="string" />)"));
981 
982   std::optional<ResourceTable::SearchResult> result =
983       table_.FindResource(test::ParseNameOrDie("string/bar"));
984   ASSERT_TRUE(result);
985   const ResourceEntry* entry = result.value().entry;
986   ASSERT_THAT(entry, NotNull());
987   EXPECT_THAT(entry->visibility.level, Eq(Visibility::Level::kUndefined));
988   EXPECT_TRUE(entry->allow_new);
989 }
990 
TEST_F(ResourceParserTest,ParseItemElementWithFormat)991 TEST_F(ResourceParserTest, ParseItemElementWithFormat) {
992   ASSERT_TRUE(TestParse(R"(<item name="foo" type="integer" format="float">0.3</item>)"));
993 
994   BinaryPrimitive* val = test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
995   ASSERT_THAT(val, NotNull());
996   EXPECT_THAT(val->value.dataType, Eq(Res_value::TYPE_FLOAT));
997 
998   ASSERT_FALSE(TestParse(R"(<item name="bar" type="integer" format="fraction">100</item>)"));
999 }
1000 
1001 // An <item> without a format specifier accepts all types of values.
TEST_F(ResourceParserTest,ParseItemElementWithoutFormat)1002 TEST_F(ResourceParserTest, ParseItemElementWithoutFormat) {
1003   ASSERT_TRUE(TestParse(R"(<item name="foo" type="integer">100%p</item>)"));
1004 
1005   BinaryPrimitive* val = test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
1006   ASSERT_THAT(val, NotNull());
1007   EXPECT_THAT(val->value.dataType, Eq(Res_value::TYPE_FRACTION));
1008 }
1009 
TEST_F(ResourceParserTest,ParseConfigVaryingItem)1010 TEST_F(ResourceParserTest, ParseConfigVaryingItem) {
1011   ASSERT_TRUE(TestParse(R"(<item name="foo" type="configVarying">Hey</item>)"));
1012   ASSERT_THAT(test::GetValue<String>(&table_, "configVarying/foo"), NotNull());
1013 }
1014 
TEST_F(ResourceParserTest,ParseBagElement)1015 TEST_F(ResourceParserTest, ParseBagElement) {
1016   std::string input = R"(
1017       <bag name="bag" type="configVarying">
1018         <item name="test">Hello!</item>
1019       </bag>)";
1020   ASSERT_TRUE(TestParse(input));
1021 
1022   Style* val = test::GetValue<Style>(&table_, "configVarying/bag");
1023   ASSERT_THAT(val, NotNull());
1024   ASSERT_THAT(val->entries, SizeIs(1));
1025 
1026   EXPECT_THAT(val->entries[0].key, Eq(Reference(test::ParseNameOrDie("attr/test"))));
1027   EXPECT_THAT(ValueCast<RawString>(val->entries[0].value.get()), NotNull());
1028 }
1029 
TEST_F(ResourceParserTest,ParseElementWithNoValue)1030 TEST_F(ResourceParserTest, ParseElementWithNoValue) {
1031   std::string input = R"(
1032       <item type="drawable" format="reference" name="foo" />
1033       <string name="foo" />)";
1034   ASSERT_TRUE(TestParse(input));
1035   ASSERT_THAT(test::GetValue(&table_, "drawable/foo"), Pointee(ValueEq(Reference())));
1036 
1037   String* str = test::GetValue<String>(&table_, "string/foo");
1038   ASSERT_THAT(str, NotNull());
1039   EXPECT_THAT(*str, StrValueEq(""));
1040 }
1041 
TEST_F(ResourceParserTest,ParsePlatformIndependentNewline)1042 TEST_F(ResourceParserTest, ParsePlatformIndependentNewline) {
1043   ASSERT_TRUE(TestParse(R"(<string name="foo">%1$s %n %2$s</string>)"));
1044 }
1045 
TEST_F(ResourceParserTest,ParseOverlayable)1046 TEST_F(ResourceParserTest, ParseOverlayable) {
1047   std::string input = R"(
1048       <overlayable name="Name" actor="overlay://theme">
1049           <policy type="signature">
1050             <item type="string" name="foo" />
1051             <item type="drawable" name="bar" />
1052           </policy>
1053       </overlayable>)";
1054   ASSERT_TRUE(TestParse(input));
1055 
1056   auto search_result = table_.FindResource(test::ParseNameOrDie("string/foo"));
1057   ASSERT_TRUE(search_result);
1058   ASSERT_THAT(search_result.value().entry, NotNull());
1059   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1060   OverlayableItem& result_overlayable_item = search_result.value().entry->overlayable_item.value();
1061   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1062   EXPECT_THAT(result_overlayable_item.overlayable->actor, Eq("overlay://theme"));
1063   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::SIGNATURE));
1064 
1065   search_result = table_.FindResource(test::ParseNameOrDie("drawable/bar"));
1066   ASSERT_TRUE(search_result);
1067   ASSERT_THAT(search_result.value().entry, NotNull());
1068   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1069   result_overlayable_item = search_result.value().entry->overlayable_item.value();
1070   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1071   EXPECT_THAT(result_overlayable_item.overlayable->actor, Eq("overlay://theme"));
1072   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::SIGNATURE));
1073 }
1074 
TEST_F(ResourceParserTest,ParseOverlayableRequiresName)1075 TEST_F(ResourceParserTest, ParseOverlayableRequiresName) {
1076   EXPECT_FALSE(TestParse(R"(<overlayable actor="overlay://theme" />)"));
1077   EXPECT_TRUE(TestParse(R"(<overlayable name="Name" />)"));
1078   EXPECT_TRUE(TestParse(R"(<overlayable name="Name" actor="overlay://theme" />)"));
1079 }
1080 
TEST_F(ResourceParserTest,ParseOverlayableBadActorFail)1081 TEST_F(ResourceParserTest, ParseOverlayableBadActorFail) {
1082   EXPECT_FALSE(TestParse(R"(<overlayable name="Name" actor="overley://theme" />)"));
1083 }
1084 
TEST_F(ResourceParserTest,ParseOverlayablePolicy)1085 TEST_F(ResourceParserTest, ParseOverlayablePolicy) {
1086   std::string input = R"(
1087       <overlayable name="Name">
1088         <policy type="product">
1089           <item type="string" name="bar" />
1090         </policy>
1091         <policy type="system">
1092           <item type="string" name="fiz" />
1093         </policy>
1094         <policy type="vendor">
1095           <item type="string" name="fuz" />
1096         </policy>
1097         <policy type="public">
1098           <item type="string" name="faz" />
1099         </policy>
1100         <policy type="signature">
1101           <item type="string" name="foz" />
1102         </policy>
1103         <policy type="odm">
1104           <item type="string" name="biz" />
1105         </policy>
1106         <policy type="oem">
1107           <item type="string" name="buz" />
1108         </policy>
1109         <policy type="actor">
1110           <item type="string" name="actor" />
1111         </policy>
1112       </overlayable>)";
1113   ASSERT_TRUE(TestParse(input));
1114 
1115   auto search_result = table_.FindResource(test::ParseNameOrDie("string/bar"));
1116   ASSERT_TRUE(search_result);
1117   ASSERT_THAT(search_result.value().entry, NotNull());
1118   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1119   OverlayableItem result_overlayable_item = search_result.value().entry->overlayable_item.value();
1120   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1121   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::PRODUCT_PARTITION));
1122 
1123   search_result = table_.FindResource(test::ParseNameOrDie("string/fiz"));
1124   ASSERT_TRUE(search_result);
1125   ASSERT_THAT(search_result.value().entry, NotNull());
1126   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1127   result_overlayable_item = search_result.value().entry->overlayable_item.value();
1128   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1129   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::SYSTEM_PARTITION));
1130 
1131   search_result = table_.FindResource(test::ParseNameOrDie("string/fuz"));
1132   ASSERT_TRUE(search_result);
1133   ASSERT_THAT(search_result.value().entry, NotNull());
1134   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1135   result_overlayable_item = search_result.value().entry->overlayable_item.value();
1136   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1137   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::VENDOR_PARTITION));
1138 
1139   search_result = table_.FindResource(test::ParseNameOrDie("string/faz"));
1140   ASSERT_TRUE(search_result);
1141   ASSERT_THAT(search_result.value().entry, NotNull());
1142   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1143   result_overlayable_item = search_result.value().entry->overlayable_item.value();
1144   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1145   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::PUBLIC));
1146 
1147   search_result = table_.FindResource(test::ParseNameOrDie("string/foz"));
1148   ASSERT_TRUE(search_result);
1149   ASSERT_THAT(search_result.value().entry, NotNull());
1150   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1151   result_overlayable_item = search_result.value().entry->overlayable_item.value();
1152   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1153   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::SIGNATURE));
1154 
1155   search_result = table_.FindResource(test::ParseNameOrDie("string/biz"));
1156   ASSERT_TRUE(search_result);
1157   ASSERT_THAT(search_result.value().entry, NotNull());
1158   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1159   result_overlayable_item = search_result.value().entry->overlayable_item.value();
1160   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1161   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::ODM_PARTITION));
1162 
1163   search_result = table_.FindResource(test::ParseNameOrDie("string/buz"));
1164   ASSERT_TRUE(search_result);
1165   ASSERT_THAT(search_result.value().entry, NotNull());
1166   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1167   result_overlayable_item = search_result.value().entry->overlayable_item.value();
1168   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1169   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::OEM_PARTITION));
1170 
1171   search_result = table_.FindResource(test::ParseNameOrDie("string/actor"));
1172   ASSERT_TRUE(search_result);
1173   ASSERT_THAT(search_result.value().entry, NotNull());
1174   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1175   result_overlayable_item = search_result.value().entry->overlayable_item.value();
1176   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1177   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::ACTOR_SIGNATURE));
1178 }
1179 
TEST_F(ResourceParserTest,ParseOverlayableNoPolicyError)1180 TEST_F(ResourceParserTest, ParseOverlayableNoPolicyError) {
1181   std::string input = R"(
1182       <overlayable name="Name">
1183         <item type="string" name="foo" />
1184       </overlayable>)";
1185   EXPECT_FALSE(TestParse(input));
1186 
1187   input = R"(
1188       <overlayable name="Name">
1189         <policy>
1190           <item name="foo" />
1191         </policy>
1192       </overlayable>)";
1193   EXPECT_FALSE(TestParse(input));
1194 }
1195 
TEST_F(ResourceParserTest,ParseOverlayableBadPolicyError)1196 TEST_F(ResourceParserTest, ParseOverlayableBadPolicyError) {
1197   std::string input = R"(
1198       <overlayable name="Name">
1199         <policy type="illegal_policy">
1200           <item type="string" name="foo" />
1201         </policy>
1202       </overlayable>)";
1203   EXPECT_FALSE(TestParse(input));
1204 
1205   input = R"(
1206       <overlayable name="Name">
1207         <policy type="product">
1208           <item name="foo" />
1209         </policy>
1210       </overlayable>)";
1211   EXPECT_FALSE(TestParse(input));
1212 
1213   input = R"(
1214       <overlayable name="Name">
1215         <policy type="vendor">
1216           <item type="string" />
1217         </policy>
1218       </overlayable>)";
1219   EXPECT_FALSE(TestParse(input));
1220 }
1221 
TEST_F(ResourceParserTest,ParseOverlayableMultiplePolicy)1222 TEST_F(ResourceParserTest, ParseOverlayableMultiplePolicy) {
1223   std::string input = R"(
1224       <overlayable name="Name">
1225         <policy type="vendor|public">
1226           <item type="string" name="foo" />
1227         </policy>
1228         <policy type="product|system">
1229           <item type="string" name="bar" />
1230         </policy>
1231       </overlayable>)";
1232   ASSERT_TRUE(TestParse(input));
1233 
1234   auto search_result = table_.FindResource(test::ParseNameOrDie("string/foo"));
1235   ASSERT_TRUE(search_result);
1236   ASSERT_THAT(search_result.value().entry, NotNull());
1237   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1238   OverlayableItem result_overlayable_item = search_result.value().entry->overlayable_item.value();
1239   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1240   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::VENDOR_PARTITION
1241                                                    | PolicyFlags::PUBLIC));
1242 
1243   search_result = table_.FindResource(test::ParseNameOrDie("string/bar"));
1244   ASSERT_TRUE(search_result);
1245   ASSERT_THAT(search_result.value().entry, NotNull());
1246   ASSERT_TRUE(search_result.value().entry->overlayable_item);
1247   result_overlayable_item = search_result.value().entry->overlayable_item.value();
1248   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("Name"));
1249   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::PRODUCT_PARTITION
1250                                                    | PolicyFlags::SYSTEM_PARTITION));
1251 }
1252 
TEST_F(ResourceParserTest,DuplicateOverlayableIsError)1253 TEST_F(ResourceParserTest, DuplicateOverlayableIsError) {
1254   std::string input = R"(
1255       <overlayable name="Name">
1256         <item type="string" name="foo" />
1257         <item type="string" name="foo" />
1258       </overlayable>)";
1259   EXPECT_FALSE(TestParse(input));
1260 
1261   input = R"(
1262       <overlayable name="Name">
1263         <item type="string" name="foo" />
1264       </overlayable>
1265       <overlayable name="Name">
1266         <item type="string" name="foo" />
1267       </overlayable>)";
1268   EXPECT_FALSE(TestParse(input));
1269 
1270   input = R"(
1271       <overlayable name="Name">
1272         <item type="string" name="foo" />
1273       </overlayable>
1274       <overlayable name="Other">
1275         <item type="string" name="foo" />
1276       </overlayable>)";
1277   EXPECT_FALSE(TestParse(input));
1278 
1279   input = R"(
1280       <overlayable name="Name" actor="overlay://my.actor.one">
1281         <item type="string" name="foo" />
1282       </overlayable>
1283       <overlayable name="Other" actor="overlay://my.actor.two">
1284         <item type="string" name="foo" />
1285       </overlayable>)";
1286   EXPECT_FALSE(TestParse(input));
1287 
1288   input = R"(
1289       <overlayable name="Name">
1290         <policy type="product">
1291           <item type="string" name="foo" />
1292           <item type="string" name="foo" />
1293         </policy>
1294       </overlayable>)";
1295   EXPECT_FALSE(TestParse(input));
1296 
1297   input = R"(
1298       <overlayable name="Name">
1299         <policy type="product">
1300           <item type="string" name="foo" />
1301         </policy>
1302         <item type="string" name="foo" />
1303       </overlayable>)";
1304   EXPECT_FALSE(TestParse(input));
1305 
1306   input = R"(
1307       <overlayable name="Name">
1308         <policy type="product">
1309           <item type="string" name="foo" />
1310         </policy>
1311         <policy type="vendor">
1312           <item type="string" name="foo" />
1313         </policy>
1314       </overlayable>)";
1315   EXPECT_FALSE(TestParse(input));
1316 
1317   input = R"(
1318       <overlayable name="Name">
1319         <policy type="product">
1320           <item type="string" name="foo" />
1321         </policy>
1322       </overlayable>
1323 
1324       <overlayable name="Name">
1325         <policy type="product">
1326           <item type="string" name="foo" />
1327         </policy>
1328       </overlayable>)";
1329   EXPECT_FALSE(TestParse(input));
1330 }
1331 
1332 TEST_F(ResourceParserTest, NestPolicyInOverlayableError) {
1333   std::string input = R"(
1334       <overlayable name="Name">
1335         <policy type="vendor|product">
1336           <policy type="public">
1337             <item type="string" name="foo" />
1338           </policy>
1339         </policy>
1340       </overlayable>)";
1341   EXPECT_FALSE(TestParse(input));
1342 }
1343 
1344 TEST_F(ResourceParserTest, ParseIdItem) {
1345   std::string input = R"(
1346     <item name="foo" type="id">@id/bar</item>
1347     <item name="bar" type="id"/>
1348     <item name="baz" type="id"></item>)";
1349   ASSERT_TRUE(TestParse(input));
1350 
1351   ASSERT_THAT(test::GetValue<Reference>(&table_, "id/foo"), NotNull());
1352   ASSERT_THAT(test::GetValue<Id>(&table_, "id/bar"), NotNull());
1353   ASSERT_THAT(test::GetValue<Id>(&table_, "id/baz"), NotNull());
1354 
1355   input = R"(
1356     <id name="foo2">@id/bar</id>
1357     <id name="bar2"/>
1358     <id name="baz2"></id>)";
1359   ASSERT_TRUE(TestParse(input));
1360 
1361   ASSERT_THAT(test::GetValue<Reference>(&table_, "id/foo2"), NotNull());
1362   ASSERT_THAT(test::GetValue<Id>(&table_, "id/bar2"), NotNull());
1363   ASSERT_THAT(test::GetValue<Id>(&table_, "id/baz2"), NotNull());
1364 
1365   // Reject attribute references
1366   input = R"(<item name="foo3" type="id">?attr/bar"</item>)";
1367   ASSERT_FALSE(TestParse(input));
1368 
1369   // Reject non-references
1370   input = R"(<item name="foo4" type="id">0x7f010001</item>)";
1371   ASSERT_FALSE(TestParse(input));
1372   input = R"(<item name="foo5" type="id">@drawable/my_image</item>)";
1373   ASSERT_FALSE(TestParse(input));
1374   input = R"(<item name="foo6" type="id"><string name="biz"></string></item>)";
1375   ASSERT_FALSE(TestParse(input));
1376 
1377   // Ids that reference other resource ids cannot be public
1378   input = R"(<public name="foo7" type="id">@id/bar7</item>)";
1379   ASSERT_FALSE(TestParse(input));
1380 }
1381 
TEST_F(ResourceParserTest,ParseCData)1382 TEST_F(ResourceParserTest, ParseCData) {
1383   // Double quotes should still change the state of whitespace processing
1384   std::string input = R"(<string name="foo">Hello<![CDATA[ "</string>' ]]>      World</string>)";
1385   ASSERT_TRUE(TestParse(input));
1386   auto output = test::GetValue<String>(&table_, "string/foo");
1387   ASSERT_THAT(output, NotNull());
1388   EXPECT_THAT(*output, StrValueEq(std::string("Hello </string>'       World").data()));
1389 
1390   input = R"(<string name="foo2"><![CDATA[Hello
1391                                           World]]></string>)";
1392   ASSERT_TRUE(TestParse(input));
1393   output = test::GetValue<String>(&table_, "string/foo2");
1394   ASSERT_THAT(output, NotNull());
1395   EXPECT_THAT(*output, StrValueEq(std::string("Hello World").data()));
1396 
1397   // Cdata blocks should have their whitespace trimmed
1398   input = R"(<string name="foo3">     <![CDATA[ text ]]>     </string>)";
1399   ASSERT_TRUE(TestParse(input));
1400   output = test::GetValue<String>(&table_, "string/foo3");
1401   ASSERT_THAT(output, NotNull());
1402   EXPECT_THAT(*output, StrValueEq(std::string("text").data()));
1403 
1404   input = R"(<string name="foo4">     <![CDATA[]]>     </string>)";
1405   ASSERT_TRUE(TestParse(input));
1406   output = test::GetValue<String>(&table_, "string/foo4");
1407   ASSERT_THAT(output, NotNull());
1408   EXPECT_THAT(*output, StrValueEq(std::string("").data()));
1409 
1410   input = R"(<string name="foo5">     <![CDATA[    ]]>     </string>)";
1411   ASSERT_TRUE(TestParse(input));
1412   output = test::GetValue<String>(&table_, "string/foo5");
1413   ASSERT_THAT(output, NotNull());
1414   EXPECT_THAT(*output, StrValueEq(std::string("").data()));
1415 
1416   // Single quotes must still be escaped
1417   input = R"(<string name="foo6"><![CDATA[some text and ' apostrophe]]></string>)";
1418   ASSERT_FALSE(TestParse(input));
1419 }
1420 
1421 }  // namespace aapt
1422