1 /*
2  * Copyright (C) 2016 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 "format/proto/ProtoSerialize.h"
18 
19 #include "ResourceUtils.h"
20 #include "format/proto/ProtoDeserialize.h"
21 #include "test/Test.h"
22 
23 using ::android::ConfigDescription;
24 using ::android::StringPiece;
25 using ::testing::Eq;
26 using ::testing::IsEmpty;
27 using ::testing::IsNull;
28 using ::testing::NotNull;
29 using ::testing::SizeIs;
30 using ::testing::StrEq;
31 
32 using PolicyFlags = android::ResTable_overlayable_policy_header::PolicyFlags;
33 
34 namespace aapt {
35 
36 class MockFileCollection : public io::IFileCollection {
37  public:
38   MOCK_METHOD1(FindFile, io::IFile*(StringPiece path));
39   MOCK_METHOD0(Iterator, std::unique_ptr<io::IFileCollectionIterator>());
40   MOCK_METHOD0(GetDirSeparator, char());
41 };
42 
GetEntry(ResourceTable * table,const ResourceNameRef & res_name)43 ResourceEntry* GetEntry(ResourceTable* table, const ResourceNameRef& res_name) {
44   auto result = table->FindResource(res_name);
45   return (result) ? result.value().entry : nullptr;
46 }
47 
GetEntry(ResourceTable * table,const ResourceNameRef & res_name,ResourceId id)48 ResourceEntry* GetEntry(ResourceTable* table, const ResourceNameRef& res_name, ResourceId id) {
49   auto result = table->FindResource(res_name, id);
50   return (result) ? result.value().entry : nullptr;
51 }
52 
TEST(ProtoSerializeTest,SerializeVisibility)53 TEST(ProtoSerializeTest, SerializeVisibility) {
54   std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
55   std::unique_ptr<ResourceTable> table =
56       test::ResourceTableBuilder()
57           .Add(NewResourceBuilder("com.app.a:bool/foo")
58                    .SetVisibility({Visibility::Level::kUndefined})
59                    .Build())
60           .Add(NewResourceBuilder("com.app.a:bool/bar")
61                    .SetVisibility({Visibility::Level::kPrivate})
62                    .Build())
63           .Add(NewResourceBuilder("com.app.a:bool/baz")
64                    .SetVisibility({Visibility::Level::kPublic})
65                    .Build())
66           .Add(NewResourceBuilder("com.app.a:bool/fiz")
67                    .SetVisibility({.level = Visibility::Level::kPublic, .staged_api = true})
68                    .Build())
69           .Build();
70 
71   ResourceTable new_table;
72   pb::ResourceTable pb_table;
73   MockFileCollection files;
74   std::string error;
75   SerializeTableToPb(*table, &pb_table, context->GetDiagnostics());
76   ASSERT_TRUE(DeserializeTableFromPb(pb_table, &files, &new_table, &error));
77   EXPECT_THAT(error, IsEmpty());
78 
79   auto search_result = new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/foo"));
80   ASSERT_TRUE(search_result);
81   EXPECT_THAT(search_result.value().entry->visibility.level, Eq(Visibility::Level::kUndefined));
82   EXPECT_FALSE(search_result.value().entry->visibility.staged_api);
83 
84   search_result = new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/bar"));
85   ASSERT_TRUE(search_result);
86   EXPECT_THAT(search_result.value().entry->visibility.level, Eq(Visibility::Level::kPrivate));
87   EXPECT_FALSE(search_result.value().entry->visibility.staged_api);
88 
89   search_result = new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/baz"));
90   ASSERT_TRUE(search_result);
91   EXPECT_THAT(search_result.value().entry->visibility.level, Eq(Visibility::Level::kPublic));
92   EXPECT_FALSE(search_result.value().entry->visibility.staged_api);
93 
94   search_result = new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/fiz"));
95   ASSERT_TRUE(search_result);
96   EXPECT_THAT(search_result.value().entry->visibility.level, Eq(Visibility::Level::kPublic));
97   EXPECT_TRUE(search_result.value().entry->visibility.staged_api);
98 }
99 
TEST(ProtoSerializeTest,SerializeSinglePackage)100 TEST(ProtoSerializeTest, SerializeSinglePackage) {
101   std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
102   std::unique_ptr<ResourceTable> table =
103       test::ResourceTableBuilder()
104           .AddFileReference("com.app.a:layout/main", ResourceId(0x7f020000), "res/layout/main.xml")
105           .AddReference("com.app.a:layout/other", ResourceId(0x7f020001), "com.app.a:layout/main")
106           .AddString("com.app.a:string/text", {}, "hi")
107           .AddValue("com.app.a:id/foo", {}, util::make_unique<Id>())
108           .SetSymbolState("com.app.a:bool/foo", {}, Visibility::Level::kUndefined,
109                           true /*allow_new*/)
110           .Build();
111 
112   ASSERT_TRUE(table->AddResource(NewResourceBuilder(test::ParseNameOrDie("com.app.a:layout/main"))
113                                      .SetId(0x7f020000)
114                                      .SetVisibility({Visibility::Level::kPublic})
115                                      .Build(),
116                                  context->GetDiagnostics()));
117 
118   Id* id = test::GetValue<Id>(table.get(), "com.app.a:id/foo");
119   ASSERT_THAT(id, NotNull());
120 
121   // Make a plural.
122   std::unique_ptr<Plural> plural = util::make_unique<Plural>();
123   plural->values[Plural::One] = util::make_unique<String>(table->string_pool.MakeRef("one"));
124   ASSERT_TRUE(table->AddResource(NewResourceBuilder(test::ParseNameOrDie("com.app.a:plurals/hey"))
125                                      .SetValue(std::move(plural))
126                                      .Build(),
127                                  context->GetDiagnostics()));
128 
129   // Make a styled string.
130   android::StyleString style_string;
131   style_string.str = "hello";
132   style_string.spans.push_back(android::Span{"b", 0u, 4u});
133   ASSERT_TRUE(table->AddResource(
134       NewResourceBuilder(test::ParseNameOrDie("com.app.a:string/styled"))
135           .SetValue(util::make_unique<StyledString>(table->string_pool.MakeRef(style_string)))
136           .Build(),
137       context->GetDiagnostics()));
138 
139   // Make a resource with different products.
140   ASSERT_TRUE(
141       table->AddResource(NewResourceBuilder(test::ParseNameOrDie("com.app.a:integer/one"))
142                              .SetValue(test::BuildPrimitive(android::Res_value::TYPE_INT_DEC, 123u),
143                                        test::ParseConfigOrDie("land"))
144                              .Build(),
145                          context->GetDiagnostics()));
146 
147   ASSERT_TRUE(
148       table->AddResource(NewResourceBuilder(test::ParseNameOrDie("com.app.a:integer/one"))
149                              .SetValue(test::BuildPrimitive(android::Res_value::TYPE_INT_HEX, 321u),
150                                        test::ParseConfigOrDie("land"), "tablet")
151                              .Build(),
152                          context->GetDiagnostics()));
153 
154   // Make a reference with both resource name and resource ID.
155   // The reference should point to a resource outside of this table to test that both name and id
156   // get serialized.
157   Reference expected_ref;
158   expected_ref.name = test::ParseNameOrDie("android:layout/main");
159   expected_ref.id = ResourceId(0x01020000);
160   ASSERT_TRUE(table->AddResource(NewResourceBuilder(test::ParseNameOrDie("com.app.a:layout/abc"))
161                                      .SetValue(util::make_unique<Reference>(expected_ref))
162                                      .Build(),
163                                  context->GetDiagnostics()));
164 
165   // Make an overlayable resource.
166   OverlayableItem overlayable_item(std::make_shared<Overlayable>(
167       "OverlayableName", "overlay://theme", android::Source("res/values/overlayable.xml", 40)));
168   overlayable_item.source = android::Source("res/values/overlayable.xml", 42);
169   ASSERT_TRUE(
170       table->AddResource(NewResourceBuilder(test::ParseNameOrDie("com.app.a:integer/overlayable"))
171                              .SetOverlayable(overlayable_item)
172                              .Build(),
173                          context->GetDiagnostics()));
174 
175   pb::ResourceTable pb_table;
176   SerializeTableToPb(*table, &pb_table, context->GetDiagnostics());
177 
178   test::TestFile file_a("res/layout/main.xml");
179   MockFileCollection files;
180   EXPECT_CALL(files, FindFile(Eq("res/layout/main.xml")))
181       .WillRepeatedly(::testing::Return(&file_a));
182 
183   ResourceTable new_table;
184   std::string error;
185   ASSERT_TRUE(DeserializeTableFromPb(pb_table, &files, &new_table, &error)) << error;
186   EXPECT_THAT(error, IsEmpty());
187 
188   Id* new_id = test::GetValue<Id>(&new_table, "com.app.a:id/foo");
189   ASSERT_THAT(new_id, NotNull());
190   EXPECT_THAT(new_id->IsWeak(), Eq(id->IsWeak()));
191 
192   std::optional<ResourceTable::SearchResult> result =
193       new_table.FindResource(test::ParseNameOrDie("com.app.a:layout/main"));
194   ASSERT_TRUE(result);
195 
196   EXPECT_THAT(result.value().type->visibility_level, Eq(Visibility::Level::kPublic));
197   EXPECT_THAT(result.value().entry->visibility.level, Eq(Visibility::Level::kPublic));
198 
199   result = new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/foo"));
200   ASSERT_TRUE(result);
201   EXPECT_THAT(result.value().entry->visibility.level, Eq(Visibility::Level::kUndefined));
202   EXPECT_TRUE(result.value().entry->allow_new);
203 
204   // Find the product-dependent values
205   BinaryPrimitive* prim = test::GetValueForConfigAndProduct<BinaryPrimitive>(
206       &new_table, "com.app.a:integer/one", test::ParseConfigOrDie("land"), "");
207   ASSERT_THAT(prim, NotNull());
208   EXPECT_THAT(prim->value.data, Eq(123u));
209   EXPECT_THAT(prim->value.dataType, Eq(0x10));
210 
211   prim = test::GetValueForConfigAndProduct<BinaryPrimitive>(
212       &new_table, "com.app.a:integer/one", test::ParseConfigOrDie("land"), "tablet");
213   ASSERT_THAT(prim, NotNull());
214   EXPECT_THAT(prim->value.data, Eq(321u));
215   EXPECT_THAT(prim->value.dataType, Eq(0x11));
216 
217   Reference* actual_ref = test::GetValue<Reference>(&new_table, "com.app.a:layout/abc");
218   ASSERT_THAT(actual_ref, NotNull());
219   ASSERT_TRUE(actual_ref->name);
220   ASSERT_TRUE(actual_ref->id);
221   EXPECT_THAT(*actual_ref, Eq(expected_ref));
222 
223   FileReference* actual_file_ref =
224       test::GetValue<FileReference>(&new_table, "com.app.a:layout/main");
225   ASSERT_THAT(actual_file_ref, NotNull());
226   EXPECT_THAT(actual_file_ref->file, Eq(&file_a));
227 
228   StyledString* actual_styled_str =
229       test::GetValue<StyledString>(&new_table, "com.app.a:string/styled");
230   ASSERT_THAT(actual_styled_str, NotNull());
231   EXPECT_THAT(actual_styled_str->value->value, Eq("hello"));
232   ASSERT_THAT(actual_styled_str->value->spans, SizeIs(1u));
233   EXPECT_THAT(*actual_styled_str->value->spans[0].name, Eq("b"));
234   EXPECT_THAT(actual_styled_str->value->spans[0].first_char, Eq(0u));
235   EXPECT_THAT(actual_styled_str->value->spans[0].last_char, Eq(4u));
236 
237   std::optional<ResourceTable::SearchResult> search_result =
238       new_table.FindResource(test::ParseNameOrDie("com.app.a:integer/overlayable"));
239   ASSERT_TRUE(search_result);
240   ASSERT_THAT(search_result.value().entry, NotNull());
241   ASSERT_TRUE(search_result.value().entry->overlayable_item);
242   OverlayableItem& result_overlayable_item = search_result.value().entry->overlayable_item.value();
243   EXPECT_THAT(result_overlayable_item.overlayable->name, Eq("OverlayableName"));
244   EXPECT_THAT(result_overlayable_item.overlayable->actor, Eq("overlay://theme"));
245   EXPECT_THAT(result_overlayable_item.overlayable->source.path, Eq("res/values/overlayable.xml"));
246   EXPECT_THAT(result_overlayable_item.overlayable->source.line, Eq(40));
247   EXPECT_THAT(result_overlayable_item.policies, Eq(PolicyFlags::NONE));
248   EXPECT_THAT(result_overlayable_item.source.path, Eq("res/values/overlayable.xml"));
249   EXPECT_THAT(result_overlayable_item.source.line, Eq(42));
250 }
251 
TEST(ProtoSerializeTest,SerializeAndDeserializeXml)252 TEST(ProtoSerializeTest, SerializeAndDeserializeXml) {
253   xml::Element element;
254   element.line_number = 22;
255   element.column_number = 23;
256   element.name = "element";
257   element.namespace_uri = "uri://";
258 
259   xml::NamespaceDecl decl;
260   decl.prefix = "android";
261   decl.uri = xml::kSchemaAndroid;
262   decl.line_number = 21;
263   decl.column_number = 24;
264 
265   element.namespace_decls.push_back(decl);
266 
267   xml::Attribute attr;
268   attr.name = "name";
269   attr.namespace_uri = xml::kSchemaAndroid;
270   attr.value = "23dp";
271   attr.compiled_attribute = xml::AaptAttribute(Attribute{}, ResourceId(0x01010000));
272   attr.compiled_value =
273       ResourceUtils::TryParseItemForAttribute(attr.value, android::ResTable_map::TYPE_DIMENSION);
274   attr.compiled_value->SetSource(android::Source().WithLine(25));
275   element.attributes.push_back(std::move(attr));
276 
277   std::unique_ptr<xml::Text> text = util::make_unique<xml::Text>();
278   text->line_number = 25;
279   text->column_number = 3;
280   text->text = "hey there";
281   element.AppendChild(std::move(text));
282 
283   std::unique_ptr<xml::Element> child = util::make_unique<xml::Element>();
284   child->name = "child";
285 
286   text = util::make_unique<xml::Text>();
287   text->text = "woah there";
288   child->AppendChild(std::move(text));
289 
290   element.AppendChild(std::move(child));
291 
292   pb::XmlNode pb_xml;
293   SerializeXmlToPb(element, &pb_xml);
294 
295   android::StringPool pool;
296   xml::Element actual_el;
297   std::string error;
298   ASSERT_TRUE(DeserializeXmlFromPb(pb_xml, &actual_el, &pool, &error));
299   ASSERT_THAT(error, IsEmpty());
300 
301   EXPECT_THAT(actual_el.name, StrEq("element"));
302   EXPECT_THAT(actual_el.namespace_uri, StrEq("uri://"));
303   EXPECT_THAT(actual_el.line_number, Eq(22u));
304   EXPECT_THAT(actual_el.column_number, Eq(23u));
305 
306   ASSERT_THAT(actual_el.namespace_decls, SizeIs(1u));
307   const xml::NamespaceDecl& actual_decl = actual_el.namespace_decls[0];
308   EXPECT_THAT(actual_decl.prefix, StrEq("android"));
309   EXPECT_THAT(actual_decl.uri, StrEq(xml::kSchemaAndroid));
310   EXPECT_THAT(actual_decl.line_number, Eq(21u));
311   EXPECT_THAT(actual_decl.column_number, Eq(24u));
312 
313   ASSERT_THAT(actual_el.attributes, SizeIs(1u));
314   const xml::Attribute& actual_attr = actual_el.attributes[0];
315   EXPECT_THAT(actual_attr.name, StrEq("name"));
316   EXPECT_THAT(actual_attr.namespace_uri, StrEq(xml::kSchemaAndroid));
317   EXPECT_THAT(actual_attr.value, StrEq("23dp"));
318 
319   ASSERT_THAT(actual_attr.compiled_value, NotNull());
320   const BinaryPrimitive* prim = ValueCast<BinaryPrimitive>(actual_attr.compiled_value.get());
321   ASSERT_THAT(prim, NotNull());
322   EXPECT_THAT(prim->value.dataType, Eq(android::Res_value::TYPE_DIMENSION));
323 
324   ASSERT_TRUE(actual_attr.compiled_attribute);
325   ASSERT_TRUE(actual_attr.compiled_attribute.value().id);
326 
327   ASSERT_THAT(actual_el.children, SizeIs(2u));
328   const xml::Text* child_text = xml::NodeCast<xml::Text>(actual_el.children[0].get());
329   ASSERT_THAT(child_text, NotNull());
330   const xml::Element* child_el = xml::NodeCast<xml::Element>(actual_el.children[1].get());
331   ASSERT_THAT(child_el, NotNull());
332 
333   EXPECT_THAT(child_text->line_number, Eq(25u));
334   EXPECT_THAT(child_text->column_number, Eq(3u));
335   EXPECT_THAT(child_text->text, StrEq("hey there"));
336 
337   EXPECT_THAT(child_el->name, StrEq("child"));
338   ASSERT_THAT(child_el->children, SizeIs(1u));
339 
340   child_text = xml::NodeCast<xml::Text>(child_el->children[0].get());
341   ASSERT_THAT(child_text, NotNull());
342   EXPECT_THAT(child_text->text, StrEq("woah there"));
343 }
344 
TEST(ProtoSerializeTest,SerializeAndDeserializeXmlTrimEmptyWhitepsace)345 TEST(ProtoSerializeTest, SerializeAndDeserializeXmlTrimEmptyWhitepsace) {
346   xml::Element element;
347   element.line_number = 22;
348   element.column_number = 23;
349   element.name = "element";
350 
351   std::unique_ptr<xml::Text> trim_text = util::make_unique<xml::Text>();
352   trim_text->line_number = 25;
353   trim_text->column_number = 3;
354   trim_text->text = "  \n   ";
355   element.AppendChild(std::move(trim_text));
356 
357   std::unique_ptr<xml::Text> keep_text = util::make_unique<xml::Text>();
358   keep_text->line_number = 26;
359   keep_text->column_number = 3;
360   keep_text->text = "  hello   ";
361   element.AppendChild(std::move(keep_text));
362 
363   pb::XmlNode pb_xml;
364   SerializeXmlOptions options;
365   options.remove_empty_text_nodes = true;
366   SerializeXmlToPb(element, &pb_xml, options);
367 
368   android::StringPool pool;
369   xml::Element actual_el;
370   std::string error;
371   ASSERT_TRUE(DeserializeXmlFromPb(pb_xml, &actual_el, &pool, &error));
372   ASSERT_THAT(error, IsEmpty());
373 
374   // Only the child that does not consist of only whitespace should remain
375   ASSERT_THAT(actual_el.children, SizeIs(1u));
376   const xml::Text* child_text_keep = xml::NodeCast<xml::Text>(actual_el.children[0].get());
377   ASSERT_THAT(child_text_keep, NotNull());
378   EXPECT_THAT(child_text_keep->text, StrEq( "  hello   "));
379 }
380 
TEST(ProtoSerializeTest,SerializeAndDeserializePrimitives)381 TEST(ProtoSerializeTest, SerializeAndDeserializePrimitives) {
382   std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
383   std::unique_ptr<ResourceTable> table =
384       test::ResourceTableBuilder()
385           .AddValue("android:bool/boolean_true",
386                     test::BuildPrimitive(android::Res_value::TYPE_INT_BOOLEAN, true))
387           .AddValue("android:bool/boolean_false",
388                     test::BuildPrimitive(android::Res_value::TYPE_INT_BOOLEAN, false))
389           .AddValue("android:color/color_rgb8", ResourceUtils::TryParseColor("#AABBCC"))
390           .AddValue("android:color/color_argb8", ResourceUtils::TryParseColor("#11223344"))
391           .AddValue("android:color/color_rgb4", ResourceUtils::TryParseColor("#DEF"))
392           .AddValue("android:color/color_argb4", ResourceUtils::TryParseColor("#5678"))
393           .AddValue("android:integer/integer_444", ResourceUtils::TryParseInt("444"))
394           .AddValue("android:integer/integer_neg_333", ResourceUtils::TryParseInt("-333"))
395           .AddValue("android:integer/hex_int_abcd", ResourceUtils::TryParseInt("0xABCD"))
396           .AddValue("android:dimen/dimen_1.39mm", ResourceUtils::TryParseFloat("1.39mm"))
397           .AddValue("android:fraction/fraction_27", ResourceUtils::TryParseFloat("27%"))
398           .AddValue("android:dimen/neg_2.3in", ResourceUtils::TryParseFloat("-2.3in"))
399           .AddValue("android:integer/null", ResourceUtils::MakeEmpty())
400           .Build();
401 
402   pb::ResourceTable pb_table;
403   SerializeTableToPb(*table, &pb_table, context->GetDiagnostics());
404 
405   test::TestFile file_a("res/layout/main.xml");
406   MockFileCollection files;
407   EXPECT_CALL(files, FindFile(Eq("res/layout/main.xml")))
408       .WillRepeatedly(::testing::Return(&file_a));
409 
410   ResourceTable new_table;
411   std::string error;
412   ASSERT_TRUE(DeserializeTableFromPb(pb_table, &files, &new_table, &error));
413   EXPECT_THAT(error, IsEmpty());
414 
415   BinaryPrimitive* bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(
416       &new_table, "android:bool/boolean_true", ConfigDescription::DefaultConfig(), "");
417   ASSERT_THAT(bp, NotNull());
418   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_BOOLEAN));
419   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseBool("true")->value.data));
420 
421   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "android:bool/boolean_false",
422                                                           ConfigDescription::DefaultConfig(), "");
423   ASSERT_THAT(bp, NotNull());
424   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_BOOLEAN));
425   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseBool("false")->value.data));
426 
427   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "android:color/color_rgb8",
428                                                           ConfigDescription::DefaultConfig(), "");
429   ASSERT_THAT(bp, NotNull());
430   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_COLOR_RGB8));
431   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseColor("#AABBCC")->value.data));
432 
433   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "android:color/color_argb8",
434                                                           ConfigDescription::DefaultConfig(), "");
435   ASSERT_THAT(bp, NotNull());
436   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_COLOR_ARGB8));
437   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseColor("#11223344")->value.data));
438 
439   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "android:color/color_rgb4",
440                                                           ConfigDescription::DefaultConfig(), "");
441   ASSERT_THAT(bp, NotNull());
442   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_COLOR_RGB4));
443   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseColor("#DEF")->value.data));
444 
445   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "android:color/color_argb4",
446                                                           ConfigDescription::DefaultConfig(), "");
447   ASSERT_THAT(bp, NotNull());
448   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_COLOR_ARGB4));
449   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseColor("#5678")->value.data));
450 
451   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "android:integer/integer_444",
452                                                           ConfigDescription::DefaultConfig(), "");
453   ASSERT_THAT(bp, NotNull());
454   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_DEC));
455   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseInt("444")->value.data));
456 
457   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(
458       &new_table, "android:integer/integer_neg_333", ConfigDescription::DefaultConfig(), "");
459   ASSERT_THAT(bp, NotNull());
460   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_DEC));
461   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseInt("-333")->value.data));
462 
463   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(
464       &new_table, "android:integer/hex_int_abcd", ConfigDescription::DefaultConfig(), "");
465   ASSERT_THAT(bp, NotNull());
466   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_HEX));
467   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseInt("0xABCD")->value.data));
468 
469   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "android:dimen/dimen_1.39mm",
470                                                           ConfigDescription::DefaultConfig(), "");
471   ASSERT_THAT(bp, NotNull());
472   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_DIMENSION));
473   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseFloat("1.39mm")->value.data));
474 
475   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(
476       &new_table, "android:fraction/fraction_27", ConfigDescription::DefaultConfig(), "");
477   ASSERT_THAT(bp, NotNull());
478   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_FRACTION));
479   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseFloat("27%")->value.data));
480 
481   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "android:dimen/neg_2.3in",
482                                                           ConfigDescription::DefaultConfig(), "");
483   ASSERT_THAT(bp, NotNull());
484   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_DIMENSION));
485   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseFloat("-2.3in")->value.data));
486 
487   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "android:integer/null",
488                                                           ConfigDescription::DefaultConfig(), "");
489   ASSERT_THAT(bp, NotNull());
490   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_NULL));
491   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::MakeEmpty()->value.data));
492 }
493 
ExpectConfigSerializes(StringPiece config_str)494 static void ExpectConfigSerializes(StringPiece config_str) {
495   const ConfigDescription expected_config = test::ParseConfigOrDie(config_str);
496   pb::Configuration pb_config;
497   SerializeConfig(expected_config, &pb_config);
498 
499   ConfigDescription actual_config;
500   std::string error;
501   ASSERT_TRUE(DeserializeConfigFromPb(pb_config, &actual_config, &error));
502   ASSERT_THAT(error, IsEmpty());
503   EXPECT_EQ(expected_config, actual_config);
504 }
505 
TEST(ProtoSerializeTest,SerializeDeserializeConfiguration)506 TEST(ProtoSerializeTest, SerializeDeserializeConfiguration) {
507   ExpectConfigSerializes("");
508 
509   ExpectConfigSerializes("mcc123");
510 
511   ExpectConfigSerializes("mnc123");
512 
513   ExpectConfigSerializes("en");
514   ExpectConfigSerializes("en-rGB");
515   ExpectConfigSerializes("b+en+GB");
516 
517   ExpectConfigSerializes("ldltr");
518   ExpectConfigSerializes("ldrtl");
519 
520   ExpectConfigSerializes("sw3600dp");
521 
522   ExpectConfigSerializes("w300dp");
523 
524   ExpectConfigSerializes("h400dp");
525 
526   ExpectConfigSerializes("small");
527   ExpectConfigSerializes("normal");
528   ExpectConfigSerializes("large");
529   ExpectConfigSerializes("xlarge");
530 
531   ExpectConfigSerializes("long");
532   ExpectConfigSerializes("notlong");
533 
534   ExpectConfigSerializes("round");
535   ExpectConfigSerializes("notround");
536 
537   ExpectConfigSerializes("widecg");
538   ExpectConfigSerializes("nowidecg");
539 
540   ExpectConfigSerializes("highdr");
541   ExpectConfigSerializes("lowdr");
542 
543   ExpectConfigSerializes("port");
544   ExpectConfigSerializes("land");
545   ExpectConfigSerializes("square");
546 
547   ExpectConfigSerializes("desk");
548   ExpectConfigSerializes("car");
549   ExpectConfigSerializes("television");
550   ExpectConfigSerializes("appliance");
551   ExpectConfigSerializes("watch");
552   ExpectConfigSerializes("vrheadset");
553 
554   ExpectConfigSerializes("night");
555   ExpectConfigSerializes("notnight");
556 
557   ExpectConfigSerializes("300dpi");
558   ExpectConfigSerializes("hdpi");
559 
560   ExpectConfigSerializes("notouch");
561   ExpectConfigSerializes("stylus");
562   ExpectConfigSerializes("finger");
563 
564   ExpectConfigSerializes("keysexposed");
565   ExpectConfigSerializes("keyshidden");
566   ExpectConfigSerializes("keyssoft");
567 
568   ExpectConfigSerializes("nokeys");
569   ExpectConfigSerializes("qwerty");
570   ExpectConfigSerializes("12key");
571 
572   ExpectConfigSerializes("navhidden");
573   ExpectConfigSerializes("navexposed");
574 
575   ExpectConfigSerializes("nonav");
576   ExpectConfigSerializes("dpad");
577   ExpectConfigSerializes("trackball");
578   ExpectConfigSerializes("wheel");
579 
580   ExpectConfigSerializes("300x200");
581 
582   ExpectConfigSerializes("v8");
583 
584   ExpectConfigSerializes("en-feminine");
585   ExpectConfigSerializes("en-neuter-v34");
586   ExpectConfigSerializes("feminine-v34");
587 
588   ExpectConfigSerializes(
589       "mcc123-mnc456-b+en+GB-masculine-ldltr-sw300dp-w300dp-h400dp-large-long-round-widecg-highdr-"
590       "land-car-night-xhdpi-stylus-keysexposed-qwerty-navhidden-dpad-300x200-v23");
591 }
592 
TEST(ProtoSerializeTest,SerializeAndDeserializeOverlayable)593 TEST(ProtoSerializeTest, SerializeAndDeserializeOverlayable) {
594   OverlayableItem overlayable_item_foo(std::make_shared<Overlayable>(
595       "CustomizableResources", "overlay://customization"));
596   overlayable_item_foo.policies |= PolicyFlags::SYSTEM_PARTITION;
597   overlayable_item_foo.policies |= PolicyFlags::PRODUCT_PARTITION;
598 
599   OverlayableItem overlayable_item_bar(std::make_shared<Overlayable>(
600       "TaskBar", "overlay://theme"));
601   overlayable_item_bar.policies |= PolicyFlags::PUBLIC;
602   overlayable_item_bar.policies |= PolicyFlags::VENDOR_PARTITION;
603 
604   OverlayableItem overlayable_item_baz(std::make_shared<Overlayable>(
605       "FontPack", "overlay://theme"));
606   overlayable_item_baz.policies |= PolicyFlags::PUBLIC;
607 
608   OverlayableItem overlayable_item_boz(std::make_shared<Overlayable>(
609       "IconPack", "overlay://theme"));
610   overlayable_item_boz.policies |= PolicyFlags::SIGNATURE;
611   overlayable_item_boz.policies |= PolicyFlags::ODM_PARTITION;
612   overlayable_item_boz.policies |= PolicyFlags::OEM_PARTITION;
613 
614   OverlayableItem overlayable_item_actor_config(std::make_shared<Overlayable>(
615       "ActorConfig", "overlay://theme"));
616   overlayable_item_actor_config.policies |= PolicyFlags::SIGNATURE;
617   overlayable_item_actor_config.policies |= PolicyFlags::ACTOR_SIGNATURE;
618 
619   OverlayableItem overlayable_item_biz(std::make_shared<Overlayable>(
620       "Other", "overlay://customization"));
621   overlayable_item_biz.comment ="comment";
622 
623   std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
624   std::unique_ptr<ResourceTable> table =
625       test::ResourceTableBuilder()
626           .SetOverlayable("com.app.a:bool/foo", overlayable_item_foo)
627           .SetOverlayable("com.app.a:bool/bar", overlayable_item_bar)
628           .SetOverlayable("com.app.a:bool/baz", overlayable_item_baz)
629           .SetOverlayable("com.app.a:bool/boz", overlayable_item_boz)
630           .SetOverlayable("com.app.a:bool/biz", overlayable_item_biz)
631           .SetOverlayable("com.app.a:bool/actor_config", overlayable_item_actor_config)
632           .AddValue("com.app.a:bool/fiz", ResourceUtils::TryParseBool("true"))
633           .Build();
634 
635   pb::ResourceTable pb_table;
636   SerializeTableToPb(*table, &pb_table, context->GetDiagnostics());
637 
638   MockFileCollection files;
639   ResourceTable new_table;
640   std::string error;
641   ASSERT_TRUE(DeserializeTableFromPb(pb_table, &files, &new_table, &error));
642   EXPECT_THAT(error, IsEmpty());
643 
644   std::optional<ResourceTable::SearchResult> search_result =
645       new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/foo"));
646   ASSERT_TRUE(search_result);
647   ASSERT_TRUE(search_result.value().entry->overlayable_item);
648   OverlayableItem& overlayable_item = search_result.value().entry->overlayable_item.value();
649   EXPECT_THAT(overlayable_item.overlayable->name, Eq("CustomizableResources"));
650   EXPECT_THAT(overlayable_item.overlayable->actor, Eq("overlay://customization"));
651   EXPECT_THAT(overlayable_item.policies, Eq(PolicyFlags::SYSTEM_PARTITION
652                                               | PolicyFlags::PRODUCT_PARTITION));
653 
654   search_result = new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/bar"));
655   ASSERT_TRUE(search_result);
656   ASSERT_TRUE(search_result.value().entry->overlayable_item);
657   overlayable_item = search_result.value().entry->overlayable_item.value();
658   EXPECT_THAT(overlayable_item.overlayable->name, Eq("TaskBar"));
659   EXPECT_THAT(overlayable_item.overlayable->actor, Eq("overlay://theme"));
660   EXPECT_THAT(overlayable_item.policies, Eq(PolicyFlags::PUBLIC
661                                               | PolicyFlags::VENDOR_PARTITION));
662 
663   search_result = new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/baz"));
664   ASSERT_TRUE(search_result);
665   ASSERT_TRUE(search_result.value().entry->overlayable_item);
666   overlayable_item = search_result.value().entry->overlayable_item.value();
667   EXPECT_THAT(overlayable_item.overlayable->name, Eq("FontPack"));
668   EXPECT_THAT(overlayable_item.overlayable->actor, Eq("overlay://theme"));
669   EXPECT_THAT(overlayable_item.policies, Eq(PolicyFlags::PUBLIC));
670 
671   search_result = new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/boz"));
672   ASSERT_TRUE(search_result);
673   ASSERT_TRUE(search_result.value().entry->overlayable_item);
674   overlayable_item = search_result.value().entry->overlayable_item.value();
675   EXPECT_THAT(overlayable_item.overlayable->name, Eq("IconPack"));
676   EXPECT_THAT(overlayable_item.overlayable->actor, Eq("overlay://theme"));
677   EXPECT_THAT(overlayable_item.policies, Eq(PolicyFlags::SIGNATURE
678                                             | PolicyFlags::ODM_PARTITION
679                                             | PolicyFlags::OEM_PARTITION));
680 
681   search_result = new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/actor_config"));
682   ASSERT_TRUE(search_result);
683   ASSERT_TRUE(search_result.value().entry->overlayable_item);
684   overlayable_item = search_result.value().entry->overlayable_item.value();
685   EXPECT_THAT(overlayable_item.overlayable->name, Eq("ActorConfig"));
686   EXPECT_THAT(overlayable_item.overlayable->actor, Eq("overlay://theme"));
687   EXPECT_THAT(overlayable_item.policies, Eq(PolicyFlags::SIGNATURE
688                                             | PolicyFlags::ACTOR_SIGNATURE));
689 
690   search_result = new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/biz"));
691   ASSERT_TRUE(search_result);
692   ASSERT_TRUE(search_result.value().entry->overlayable_item);
693   overlayable_item = search_result.value().entry->overlayable_item.value();
694   EXPECT_THAT(overlayable_item.overlayable->name, Eq("Other"));
695   EXPECT_THAT(overlayable_item.policies, Eq(PolicyFlags::NONE));
696   EXPECT_THAT(overlayable_item.comment, Eq("comment"));
697 
698   search_result = new_table.FindResource(test::ParseNameOrDie("com.app.a:bool/fiz"));
699   ASSERT_TRUE(search_result);
700   ASSERT_FALSE(search_result.value().entry->overlayable_item);
701 }
702 
TEST(ProtoSerializeTest,SerializeAndDeserializeDynamicReference)703 TEST(ProtoSerializeTest, SerializeAndDeserializeDynamicReference) {
704   Reference ref(ResourceId(0x00010001));
705   ref.is_dynamic = true;
706 
707   pb::Item pb_item;
708   SerializeItemToPb(ref, &pb_item);
709 
710   ASSERT_TRUE(pb_item.has_ref());
711   EXPECT_EQ(pb_item.ref().id(), ref.id.value().id);
712   EXPECT_TRUE(pb_item.ref().is_dynamic().value());
713 
714   std::unique_ptr<Item> item = DeserializeItemFromPb(pb_item, android::ResStringPool(),
715                                                      android::ConfigDescription(), nullptr,
716                                                      nullptr, nullptr);
717   Reference* actual_ref = ValueCast<Reference>(item.get());
718   EXPECT_EQ(actual_ref->id.value().id, ref.id.value().id);
719   EXPECT_TRUE(actual_ref->is_dynamic);
720 }
721 
TEST(ProtoSerializeTest,SerializeAndDeserializeNonDynamicReference)722 TEST(ProtoSerializeTest, SerializeAndDeserializeNonDynamicReference) {
723   Reference ref(ResourceId(0x00010001));
724 
725   pb::Item pb_item;
726   SerializeItemToPb(ref, &pb_item);
727 
728   ASSERT_TRUE(pb_item.has_ref());
729   EXPECT_EQ(pb_item.ref().id(), ref.id.value().id);
730   EXPECT_FALSE(pb_item.ref().has_is_dynamic());
731 
732   std::unique_ptr<Item> item = DeserializeItemFromPb(pb_item, android::ResStringPool(),
733                                                      android::ConfigDescription(), nullptr,
734                                                      nullptr, nullptr);
735   Reference* actual_ref = ValueCast<Reference>(item.get());
736   EXPECT_EQ(actual_ref->id.value().id, ref.id.value().id);
737   EXPECT_FALSE(actual_ref->is_dynamic);
738 }
739 
TEST(ProtoSerializeTest,CollapsingResourceNamesNoNameCollapseExemptionsSucceeds)740 TEST(ProtoSerializeTest, CollapsingResourceNamesNoNameCollapseExemptionsSucceeds) {
741   const uint32_t id_one_id = 0x7f020000;
742   const uint32_t id_two_id = 0x7f020001;
743   const uint32_t id_three_id = 0x7f020002;
744   const uint32_t integer_three_id = 0x7f030000;
745   const uint32_t string_test_id = 0x7f040000;
746   const uint32_t layout_bar_id = 0x7f050000;
747   std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
748   std::unique_ptr<ResourceTable> table =
749       test::ResourceTableBuilder()
750           .AddSimple("com.app.test:id/one", ResourceId(id_one_id))
751           .AddSimple("com.app.test:id/two", ResourceId(id_two_id))
752           .AddValue("com.app.test:id/three", ResourceId(id_three_id),
753                     test::BuildReference("com.app.test:id/one", ResourceId(id_one_id)))
754           .AddValue("com.app.test:integer/one", ResourceId(integer_three_id),
755                     util::make_unique<BinaryPrimitive>(
756                         uint8_t(android::Res_value::TYPE_INT_DEC), 1u))
757           .AddValue("com.app.test:integer/one", test::ParseConfigOrDie("v1"),
758                     ResourceId(integer_three_id),
759                     util::make_unique<BinaryPrimitive>(
760                         uint8_t(android::Res_value::TYPE_INT_DEC), 2u))
761           .AddString("com.app.test:string/test", ResourceId(string_test_id), "foo")
762           .AddFileReference("com.app.test:layout/bar", ResourceId(layout_bar_id),
763                             "res/layout/bar.xml")
764           .Build();
765 
766   SerializeTableOptions options;
767   options.collapse_key_stringpool = true;
768 
769   pb::ResourceTable pb_table;
770 
771   SerializeTableToPb(*table, &pb_table, context->GetDiagnostics(), options);
772   test::TestFile file_a("res/layout/bar.xml");
773   MockFileCollection files;
774   EXPECT_CALL(files, FindFile(Eq("res/layout/bar.xml")))
775       .WillRepeatedly(::testing::Return(&file_a));
776   ResourceTable new_table;
777   std::string error;
778   ASSERT_TRUE(DeserializeTableFromPb(pb_table, &files, &new_table, &error)) << error;
779   EXPECT_THAT(error, IsEmpty());
780 
781   ResourceName real_id_resource(
782       "com.app.test", ResourceType::kId, "one");
783   EXPECT_THAT(GetEntry(&new_table, real_id_resource), IsNull());
784 
785   ResourceName obfuscated_id_resource(
786       "com.app.test", ResourceType::kId, "0_resource_name_obfuscated");
787 
788   EXPECT_THAT(GetEntry(&new_table, obfuscated_id_resource,
789                   id_one_id), NotNull());
790   EXPECT_THAT(GetEntry(&new_table, obfuscated_id_resource,
791                   id_two_id), NotNull());
792   ResourceEntry* entry = GetEntry(&new_table, obfuscated_id_resource, id_three_id);
793   EXPECT_THAT(entry, NotNull());
794   ResourceConfigValue* config_value = entry->FindValue({});
795   Reference* ref = ValueCast<Reference>(config_value->value.get());
796   EXPECT_THAT(ref->id.value(), Eq(id_one_id));
797 
798   ResourceName obfuscated_integer_resource(
799       "com.app.test", ResourceType::kInteger, "0_resource_name_obfuscated");
800   entry = GetEntry(&new_table, obfuscated_integer_resource, integer_three_id);
801   EXPECT_THAT(entry, NotNull());
802   config_value = entry->FindValue({});
803   BinaryPrimitive* bp = ValueCast<BinaryPrimitive>(config_value->value.get());
804   EXPECT_THAT(bp->value.data, Eq(1u));
805 
806   config_value = entry->FindValue(test::ParseConfigOrDie("v1"));
807   bp = ValueCast<BinaryPrimitive>(config_value->value.get());
808   EXPECT_THAT(bp->value.data, Eq(2u));
809 
810   ResourceName obfuscated_string_resource(
811       "com.app.test", ResourceType::kString, "0_resource_name_obfuscated");
812   entry = GetEntry(&new_table, obfuscated_string_resource, string_test_id);
813   EXPECT_THAT(entry, NotNull());
814   config_value = entry->FindValue({});
815   String* s = ValueCast<String>(config_value->value.get());
816   EXPECT_THAT(*(s->value), Eq("foo"));
817 
818   ResourceName obfuscated_layout_resource(
819       "com.app.test", ResourceType::kLayout, "0_resource_name_obfuscated");
820   entry = GetEntry(&new_table, obfuscated_layout_resource, layout_bar_id);
821   EXPECT_THAT(entry, NotNull());
822   config_value = entry->FindValue({});
823   FileReference* f = ValueCast<FileReference>(config_value->value.get());
824   EXPECT_THAT(*(f->path), Eq("res/layout/bar.xml"));
825 }
826 
TEST(ProtoSerializeTest,ObfuscatingResourceNamesWithNameCollapseExemptionsSucceeds)827 TEST(ProtoSerializeTest, ObfuscatingResourceNamesWithNameCollapseExemptionsSucceeds) {
828   const uint32_t id_one_id = 0x7f020000;
829   const uint32_t id_two_id = 0x7f020001;
830   const uint32_t id_three_id = 0x7f020002;
831   const uint32_t integer_three_id = 0x7f030000;
832   const uint32_t string_test_id = 0x7f040000;
833   std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
834   std::unique_ptr<ResourceTable> table =
835       test::ResourceTableBuilder()
836           .AddSimple("com.app.test:id/one", ResourceId(id_one_id))
837           .AddSimple("com.app.test:id/two", ResourceId(id_two_id))
838           .AddValue("com.app.test:id/three", ResourceId(id_three_id),
839                     test::BuildReference("com.app.test:id/one", ResourceId(id_one_id)))
840           .AddValue("com.app.test:integer/one", ResourceId(integer_three_id),
841                     util::make_unique<BinaryPrimitive>(
842                         uint8_t(android::Res_value::TYPE_INT_DEC), 1u))
843           .AddValue("com.app.test:integer/one", test::ParseConfigOrDie("v1"),
844                     ResourceId(integer_three_id),
845                     util::make_unique<BinaryPrimitive>(
846                         uint8_t(android::Res_value::TYPE_INT_DEC), 2u))
847           .AddString("com.app.test:string/test", ResourceId(string_test_id), "foo")
848           .Build();
849 
850   SerializeTableOptions options;
851   options.collapse_key_stringpool = true;
852   options.name_collapse_exemptions.insert(ResourceName({}, ResourceType::kId, "one"));
853   options.name_collapse_exemptions.insert(ResourceName({}, ResourceType::kString, "test"));
854   pb::ResourceTable pb_table;
855 
856   SerializeTableToPb(*table, &pb_table, context->GetDiagnostics(), options);
857   MockFileCollection files;
858   ResourceTable new_table;
859   std::string error;
860   ASSERT_TRUE(DeserializeTableFromPb(pb_table, &files, &new_table, &error)) << error;
861   EXPECT_THAT(error, IsEmpty());
862 
863   EXPECT_THAT(GetEntry(&new_table, ResourceName("com.app.test", ResourceType::kId, "one"),
864                        id_one_id), NotNull());
865   ResourceName obfuscated_id_resource(
866       "com.app.test", ResourceType::kId, "0_resource_name_obfuscated");
867   EXPECT_THAT(GetEntry(&new_table, obfuscated_id_resource, id_one_id), IsNull());
868 
869   ResourceName real_id_resource(
870       "com.app.test", ResourceType::kId, "two");
871   EXPECT_THAT(GetEntry(&new_table, real_id_resource, id_two_id), IsNull());
872   EXPECT_THAT(GetEntry(&new_table, obfuscated_id_resource, id_two_id), NotNull());
873 
874   ResourceEntry* entry = GetEntry(&new_table, obfuscated_id_resource, id_three_id);
875   EXPECT_THAT(entry, NotNull());
876   ResourceConfigValue* config_value = entry->FindValue({});
877   Reference* ref = ValueCast<Reference>(config_value->value.get());
878   EXPECT_THAT(ref->id.value(), Eq(id_one_id));
879 
880   // Note that this resource is also named "one", but it's a different type, so gets obfuscated.
881   ResourceName obfuscated_integer_resource(
882       "com.app.test", ResourceType::kInteger, "0_resource_name_obfuscated");
883   entry = GetEntry(&new_table, obfuscated_integer_resource, integer_three_id);
884   EXPECT_THAT(entry, NotNull());
885   config_value = entry->FindValue({});
886   BinaryPrimitive* bp = ValueCast<BinaryPrimitive>(config_value->value.get());
887   EXPECT_THAT(bp->value.data, Eq(1u));
888 
889   config_value = entry->FindValue(test::ParseConfigOrDie("v1"));
890   bp = ValueCast<BinaryPrimitive>(config_value->value.get());
891   EXPECT_THAT(bp->value.data, Eq(2u));
892 
893   entry = GetEntry(&new_table, ResourceName("com.app.test", ResourceType::kString, "test"),
894                    string_test_id);
895   EXPECT_THAT(entry, NotNull());
896   config_value = entry->FindValue({});
897   String* s = ValueCast<String>(config_value->value.get());
898   EXPECT_THAT(*(s->value), Eq("foo"));
899 }
900 
TEST(ProtoSerializeTest,SerializeMacro)901 TEST(ProtoSerializeTest, SerializeMacro) {
902   auto original = std::make_unique<Macro>();
903   original->raw_value = "\nThis being human is a guest house.";
904   original->style_string.str = " This being human is a guest house.";
905   original->style_string.spans.emplace_back(
906       android::Span{.name = "b", .first_char = 12, .last_char = 16});
907   original->untranslatable_sections.emplace_back(UntranslatableSection{.start = 12, .end = 17});
908   original->alias_namespaces.emplace_back(
909       Macro::Namespace{.alias = "prefix", .package_name = "package.name", .is_private = true});
910 
911   CloningValueTransformer cloner(nullptr);
912   std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
913   std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
914                                              .Add(NewResourceBuilder("com.app.a:macro/foo")
915                                                       .SetValue(original->Transform(cloner))
916                                                       .Build())
917                                              .Build();
918 
919   ResourceTable new_table;
920   pb::ResourceTable pb_table;
921   MockFileCollection files;
922   std::string error;
923   SerializeTableToPb(*table, &pb_table, context->GetDiagnostics());
924   ASSERT_TRUE(DeserializeTableFromPb(pb_table, &files, &new_table, &error));
925   EXPECT_THAT(error, IsEmpty());
926 
927   Macro* deserialized = test::GetValue<Macro>(&new_table, "com.app.a:macro/foo");
928   ASSERT_THAT(deserialized, NotNull());
929   EXPECT_THAT(deserialized->raw_value, Eq(original->raw_value));
930   EXPECT_THAT(deserialized->style_string.str, Eq(original->style_string.str));
931   EXPECT_THAT(deserialized->style_string.spans, Eq(original->style_string.spans));
932   EXPECT_THAT(deserialized->untranslatable_sections, Eq(original->untranslatable_sections));
933   EXPECT_THAT(deserialized->alias_namespaces, Eq(original->alias_namespaces));
934 }
935 
TEST(ProtoSerializeTest,StagedId)936 TEST(ProtoSerializeTest, StagedId) {
937   CloningValueTransformer cloner(nullptr);
938   std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
939   std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
940                                              .Add(NewResourceBuilder("com.app.a:string/foo")
941                                                       .SetStagedId(StagedId{.id = 0x01ff0001})
942                                                       .Build())
943                                              .Build();
944 
945   ResourceTable new_table;
946   pb::ResourceTable pb_table;
947   MockFileCollection files;
948   std::string error;
949   SerializeTableToPb(*table, &pb_table, context->GetDiagnostics());
950   ASSERT_TRUE(DeserializeTableFromPb(pb_table, &files, &new_table, &error));
951   EXPECT_THAT(error, IsEmpty());
952 
953   auto result = new_table.FindResource(test::ParseNameOrDie("com.app.a:string/foo"));
954   ASSERT_TRUE(result);
955   ASSERT_TRUE(result.value().entry->staged_id);
956   EXPECT_THAT(result.value().entry->staged_id.value().id, Eq(ResourceId(0x01ff0001)));
957 }
958 
TEST(ProtoSerializeTest,CustomResourceTypes)959 TEST(ProtoSerializeTest, CustomResourceTypes) {
960   const uint32_t id_one_id = 0x7f020000;
961   const uint32_t id_2_two_id = 0x7f030000;
962   const uint32_t integer_three_id = 0x7f030000;
963   const uint32_t integer_1_four_id = 0x7f030000;
964   const uint32_t layout_bar_id = 0x7f050000;
965   std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
966   std::unique_ptr<ResourceTable> table =
967       test::ResourceTableBuilder()
968           .AddSimple("com.app.test:id/one", ResourceId(id_one_id))
969           .AddSimple("com.app.test:id.2/two", ResourceId(id_2_two_id))
970           .AddValue(
971               "com.app.test:integer/one", ResourceId(integer_three_id),
972               util::make_unique<BinaryPrimitive>(uint8_t(android::Res_value::TYPE_INT_DEC), 10u))
973           .AddValue(
974               "com.app.test:integer.1/one", ResourceId(integer_1_four_id),
975               util::make_unique<BinaryPrimitive>(uint8_t(android::Res_value::TYPE_INT_DEC), 1u))
976           .AddValue(
977               "com.app.test:integer.1/one", test::ParseConfigOrDie("v1"),
978               ResourceId(integer_1_four_id),
979               util::make_unique<BinaryPrimitive>(uint8_t(android::Res_value::TYPE_INT_DEC), 2u))
980           .AddFileReference("com.app.test:layout.custom/bar", ResourceId(layout_bar_id),
981                             "res/layout/bar.xml")
982           .Build();
983 
984   test::TestFile file_a("res/layout/bar.xml");
985   MockFileCollection files;
986   EXPECT_CALL(files, FindFile(Eq("res/layout/bar.xml"))).WillRepeatedly(::testing::Return(&file_a));
987 
988   ResourceTable new_table;
989   pb::ResourceTable pb_table;
990   std::string error;
991   SerializeTableToPb(*table, &pb_table, context->GetDiagnostics());
992   DeserializeTableFromPb(pb_table, &files, &new_table, &error);
993   ASSERT_THAT(error, IsEmpty());
994 
995   auto bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(
996       &new_table, "com.app.test:integer.1/one", ConfigDescription::DefaultConfig(), "");
997   ASSERT_THAT(bp, NotNull());
998   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_DEC));
999   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseInt("1")->value.data));
1000 
1001   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "com.app.test:integer.1/one",
1002                                                           test::ParseConfigOrDie("v1"), "");
1003   ASSERT_THAT(bp, NotNull());
1004   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_DEC));
1005   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseInt("2")->value.data));
1006 
1007   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "com.app.test:integer/one",
1008                                                           ConfigDescription::DefaultConfig(), "");
1009   ASSERT_THAT(bp, NotNull());
1010   EXPECT_THAT(bp->value.dataType, Eq(android::Res_value::TYPE_INT_DEC));
1011   EXPECT_THAT(bp->value.data, Eq(ResourceUtils::TryParseInt("10")->value.data));
1012 
1013   bp = test::GetValueForConfigAndProduct<BinaryPrimitive>(&new_table, "com.app.test:integer/one",
1014                                                           test::ParseConfigOrDie("v1"), "");
1015   ASSERT_THAT(bp, IsNull());
1016 
1017   auto id = test::GetValueForConfigAndProduct<Id>(&new_table, "com.app.test:id/one",
1018                                                   ConfigDescription::DefaultConfig(), "");
1019   ASSERT_THAT(id, NotNull());
1020 
1021   id = test::GetValueForConfigAndProduct<Id>(&new_table, "com.app.test:id.2/two",
1022                                              ConfigDescription::DefaultConfig(), "");
1023   ASSERT_THAT(id, NotNull());
1024 
1025   auto custom_layout = test::GetValueForConfigAndProduct<FileReference>(
1026       &new_table, "com.app.test:layout.custom/bar", ConfigDescription::DefaultConfig(), "");
1027   ASSERT_THAT(custom_layout, NotNull());
1028   EXPECT_THAT(*(custom_layout->path), Eq("res/layout/bar.xml"));
1029 }
1030 
TEST(ProtoSerializeTest,SerializeDynamicRef)1031 TEST(ProtoSerializeTest, SerializeDynamicRef) {
1032   std::unique_ptr<IAaptContext> context =
1033       test::ContextBuilder().SetCompilationPackage("app").SetPackageId(0x7f).Build();
1034   std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder().Build();
1035   table->included_packages_.insert({20, "foobar"});
1036   table->included_packages_.insert({30, "barfoo"});
1037 
1038   ResourceTable new_table;
1039   pb::ResourceTable pb_table;
1040   MockFileCollection files;
1041   std::string error;
1042   SerializeTableToPb(*table, &pb_table, context->GetDiagnostics());
1043   ASSERT_TRUE(DeserializeTableFromPb(pb_table, &files, &new_table, &error));
1044   EXPECT_THAT(error, IsEmpty());
1045 
1046   int result = new_table.included_packages_.size();
1047   EXPECT_THAT(result, Eq(2));
1048   auto it = new_table.included_packages_.begin();
1049   EXPECT_THAT(it->first, Eq(20));
1050   EXPECT_THAT(it->second, Eq("foobar"));
1051   it++;
1052   EXPECT_THAT(it->first, Eq(30));
1053   EXPECT_THAT(it->second, Eq("barfoo"));
1054 }
1055 }  // namespace aapt
1056