1 /*
2 * Copyright (C) 2017 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 #define LOG_TAG "AssembleVintfTest"
18
19 #include <android-base/logging.h>
20 #include <android-base/stringprintf.h>
21 #include <gtest/gtest.h>
22
23 #include <aidl/metadata.h>
24 #include <vintf/AssembleVintf.h>
25 #include <vintf/parse_string.h>
26 #include "constants-private.h"
27 #include "test_constants.h"
28
29 using android::base::StringPrintf;
30
31 namespace android {
32 namespace vintf {
33
In(const std::string & sub,const std::string & str)34 static bool In(const std::string& sub, const std::string& str) {
35 return str.find(sub) != std::string::npos;
36 }
37 #define EXPECT_IN(sub, str) EXPECT_TRUE(In((sub), (str))) << (str);
38
39 class AssembleVintfTest : public ::testing::Test {
40 public:
SetUp()41 virtual void SetUp() override {
42 mInstance = AssembleVintf::newInstance();
43 auto s = makeStream("");
44 mOutputStream = s.get();
45 mInstance->setOutputStream(std::move(s));
46 s = makeStream("");
47 mErrorStream = s.get();
48 mInstance->setErrorStream(std::move(s));
49
50 getInstance()->setFakeEnv("PRODUCT_ENFORCE_VINTF_MANIFEST", "true");
51 }
TearDown()52 virtual void TearDown() override { mInstance = nullptr; }
53
getInstance()54 const std::unique_ptr<AssembleVintf>& getInstance() { return mInstance; }
55
getOutput()56 std::string getOutput() { return mOutputStream->str(); }
getError()57 std::string getError() { return mErrorStream->str(); }
58
resetOutput()59 void resetOutput() { mOutputStream->str(""); }
60
setFakeEnvs(const std::map<std::string,std::string> & envs)61 void setFakeEnvs(const std::map<std::string, std::string>& envs) {
62 for (const auto& pair : envs) {
63 getInstance()->setFakeEnv(pair.first, pair.second);
64 }
65 }
66
setFakeAidlMetadata(const std::vector<AidlInterfaceMetadata> & metadata)67 void setFakeAidlMetadata(const std::vector<AidlInterfaceMetadata>& metadata) {
68 getInstance()->setFakeAidlMetadata(metadata);
69 }
70
setFakeAidlUseUnfrozen(bool use)71 void setFakeAidlUseUnfrozen(bool use) { getInstance()->setFakeAidlUseUnfrozen(use); }
72
addInput(const std::string & name,const std::string & s)73 void addInput(const std::string& name, const std::string& s) {
74 getInstance()->addInputStream(name, makeStream(s));
75 }
76
makeStream(const std::string & s)77 std::unique_ptr<std::stringstream> makeStream(const std::string& s) {
78 return std::make_unique<std::stringstream>(s);
79 }
80
81 std::unique_ptr<AssembleVintf> mInstance;
82 // do not own this object.
83 std::stringstream* mOutputStream;
84 std::stringstream* mErrorStream;
85 };
86
87 // clang-format off
88
TEST_F(AssembleVintfTest,FrameworkMatrixEmpty)89 TEST_F(AssembleVintfTest, FrameworkMatrixEmpty) {
90 std::string xmlEmpty = "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" />";
91 std::string kernel318 = "CONFIG_FOO=y\n";
92 std::string kernel318_64 = "CONFIG_BAR=y\n";
93 std::string kernel44 = "# CONFIG_FOO is not set\n";
94 std::string kernel44_64 = "CONFIG_BAR=y\n";
95
96 addInput("compatibility_matrix.empty.xml", xmlEmpty);
97 setFakeEnvs({
98 {"POLICYVERS", "30"},
99 {"PLATFORM_SEPOLICY_VERSION", "202404"},
100 {"FRAMEWORK_VBMETA_VERSION", "1.0"},
101 });
102 getInstance()->addKernelConfigInputStream({3, 18, 0}, "android-base.config",
103 makeStream(kernel318));
104 getInstance()->addKernelConfigInputStream({3, 18, 0}, "android-base-arm64.config",
105 makeStream(kernel318_64));
106 getInstance()->addKernelConfigInputStream({4, 4, 0}, "android-base.config", makeStream(kernel44));
107 getInstance()->addKernelConfigInputStream({4, 4, 0}, "android-base-arm64.config",
108 makeStream(kernel44_64));
109
110 EXPECT_TRUE(getInstance()->assemble());
111
112 EXPECT_IN(
113 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
114 " <kernel version=\"3.18.0\">\n"
115 " <config>\n"
116 " <key>CONFIG_FOO</key>\n"
117 " <value type=\"tristate\">y</value>\n"
118 " </config>\n"
119 " </kernel>\n"
120 " <kernel version=\"3.18.0\">\n"
121 " <conditions>\n"
122 " <config>\n"
123 " <key>CONFIG_ARM64</key>\n"
124 " <value type=\"tristate\">y</value>\n"
125 " </config>\n"
126 " </conditions>\n"
127 " <config>\n"
128 " <key>CONFIG_BAR</key>\n"
129 " <value type=\"tristate\">y</value>\n"
130 " </config>\n"
131 " </kernel>\n"
132 " <kernel version=\"4.4.0\">\n"
133 " <config>\n"
134 " <key>CONFIG_FOO</key>\n"
135 " <value type=\"tristate\">n</value>\n"
136 " </config>\n"
137 " </kernel>\n"
138 " <kernel version=\"4.4.0\">\n"
139 " <conditions>\n"
140 " <config>\n"
141 " <key>CONFIG_ARM64</key>\n"
142 " <value type=\"tristate\">y</value>\n"
143 " </config>\n"
144 " </conditions>\n"
145 " <config>\n"
146 " <key>CONFIG_BAR</key>\n"
147 " <value type=\"tristate\">y</value>\n"
148 " </config>\n"
149 " </kernel>\n"
150 " <sepolicy>\n"
151 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
152 " <sepolicy-version>202404</sepolicy-version>\n"
153 " </sepolicy>\n"
154 " <avb>\n"
155 " <vbmeta-version>1.0</vbmeta-version>\n"
156 " </avb>\n"
157 "</compatibility-matrix>\n",
158 getOutput());
159 }
160
TEST_F(AssembleVintfTest,FrameworkMatrix)161 TEST_F(AssembleVintfTest, FrameworkMatrix) {
162 std::string tail =
163 " <config>\n"
164 " <key>CONFIG_FOO</key>\n"
165 " <value type=\"tristate\">y</value>\n"
166 " </config>\n"
167 " </kernel>\n"
168 " <sepolicy>\n"
169 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
170 " <sepolicy-version>202404</sepolicy-version>\n"
171 " </sepolicy>\n"
172 " <avb>\n"
173 " <vbmeta-version>1.0</vbmeta-version>\n"
174 " </avb>\n"
175 "</compatibility-matrix>\n";
176
177 std::string xmlEmpty =
178 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
179 " <kernel version=\"3.18.0\">\n" +
180 tail;
181
182 std::string xml1 =
183 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
184 " <hal format=\"hidl\">\n"
185 " <name>android.hardware.foo</name>\n"
186 " <version>1.0</version>\n"
187 " <interface>\n"
188 " <name>IFoo</name>\n"
189 " <instance>default</instance>\n"
190 " </interface>\n"
191 " </hal>\n"
192 "</compatibility-matrix>\n";
193
194 std::string xml2 =
195 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
196 " <hal format=\"hidl\">\n"
197 " <name>android.hardware.foo</name>\n"
198 " <version>1.0-1</version>\n"
199 " <interface>\n"
200 " <name>IFoo</name>\n"
201 " <instance>default</instance>\n"
202 " </interface>\n"
203 " </hal>\n"
204 "</compatibility-matrix>\n";
205
206 std::string xml3 =
207 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"3\">\n"
208 " <hal format=\"hidl\">\n"
209 " <name>android.hardware.foo</name>\n"
210 " <version>2.0</version>\n"
211 " <interface>\n"
212 " <name>IFoo</name>\n"
213 " <instance>default</instance>\n"
214 " </interface>\n"
215 " </hal>\n"
216 "</compatibility-matrix>\n";
217
218 auto manifest = [](size_t level) {
219 return "<manifest " +
220 kMetaVersionStr +
221 " type=\"device\"" +
222 " target-level=\"" + std::to_string(level) + "\">\n" +
223 " <hal format=\"hidl\">\n"
224 " <name>android.hardware.foo</name>\n"
225 " <version>1.1</version>\n"
226 " <transport>hwbinder</transport>\n"
227 " <interface>\n"
228 " <name>IFoo</name>\n"
229 " <instance>default</instance>\n"
230 " </interface>\n"
231 " </hal>\n"
232 " <hal format=\"hidl\">\n"
233 " <name>android.hardware.foo</name>\n"
234 " <version>2.0</version>\n"
235 " <transport>hwbinder</transport>\n"
236 " <interface>\n"
237 " <name>IFoo</name>\n"
238 " <instance>default</instance>\n"
239 " </interface>\n"
240 " </hal>\n"
241 " <sepolicy>\n"
242 " <version>202404</version>\n"
243 " </sepolicy>\n"
244 "</manifest>\n";
245 };
246
247 addInput("compatibility_matrix.1.xml", xml1);
248 addInput("compatibility_matrix.2.xml", xml2);
249 addInput("compatibility_matrix.3.xml", xml3);
250 addInput("compatibility_matrix.empty.xml", xmlEmpty);
251 getInstance()->setFakeEnv("PRODUCT_ENFORCE_VINTF_MANIFEST", "true");
252
253 resetOutput();
254 getInstance()->setCheckInputStream("check.xml", makeStream(manifest(1)));
255 EXPECT_TRUE(getInstance()->assemble());
256 EXPECT_IN(
257 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
258 " <hal format=\"hidl\">\n"
259 " <name>android.hardware.foo</name>\n"
260 " <version>1.0-1</version>\n"
261 " <version>2.0</version>\n"
262 " <interface>\n"
263 " <name>IFoo</name>\n"
264 " <instance>default</instance>\n"
265 " </interface>\n"
266 " </hal>\n"
267 " <kernel version=\"3.18.0\" level=\"1\">\n" +
268 tail,
269 getOutput());
270
271 resetOutput();
272 getInstance()->setCheckInputStream("check.xml", makeStream(manifest(2)));
273 EXPECT_TRUE(getInstance()->assemble());
274 EXPECT_IN(
275 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
276 " <hal format=\"hidl\">\n"
277 " <name>android.hardware.foo</name>\n"
278 " <version>1.0-1</version>\n"
279 " <version>2.0</version>\n"
280 " <interface>\n"
281 " <name>IFoo</name>\n"
282 " <instance>default</instance>\n"
283 " </interface>\n"
284 " </hal>\n"
285 " <kernel version=\"3.18.0\" level=\"2\">\n" +
286 tail,
287 getOutput());
288
289 resetOutput();
290 getInstance()->setCheckInputStream("check.xml", makeStream(manifest(3)));
291 EXPECT_TRUE(getInstance()->assemble());
292 EXPECT_IN(
293 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"3\">\n"
294 " <hal format=\"hidl\">\n"
295 " <name>android.hardware.foo</name>\n"
296 " <version>2.0</version>\n"
297 " <interface>\n"
298 " <name>IFoo</name>\n"
299 " <instance>default</instance>\n"
300 " </interface>\n"
301 " </hal>\n"
302 " <kernel version=\"3.18.0\" level=\"3\">\n" +
303 tail,
304 getOutput());
305 }
306
TEST_F(AssembleVintfTest,MatrixVendorNdk)307 TEST_F(AssembleVintfTest, MatrixVendorNdk) {
308 addInput("compatibility_matrix.xml",
309 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\"/>\n");
310 getInstance()->setFakeEnv("REQUIRED_VNDK_VERSION", "P");
311 EXPECT_TRUE(getInstance()->assemble());
312 EXPECT_IN(
313 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
314 " <vendor-ndk>\n"
315 " <version>P</version>\n"
316 " </vendor-ndk>\n"
317 "</compatibility-matrix>\n",
318 getOutput());
319 }
320
TEST_F(AssembleVintfTest,ManifestVendorNdk)321 TEST_F(AssembleVintfTest, ManifestVendorNdk) {
322 addInput("manifest.xml", "<manifest " + kMetaVersionStr + " type=\"framework\"/>\n");
323 getInstance()->setFakeEnv("PROVIDED_VNDK_VERSIONS", "P 26 27 ");
324 EXPECT_TRUE(getInstance()->assemble());
325 EXPECT_IN(
326 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
327 " <vendor-ndk>\n"
328 " <version>P</version>\n"
329 " </vendor-ndk>\n"
330 " <vendor-ndk>\n"
331 " <version>26</version>\n"
332 " </vendor-ndk>\n"
333 " <vendor-ndk>\n"
334 " <version>27</version>\n"
335 " </vendor-ndk>\n"
336 "</manifest>\n",
337 getOutput());
338 }
339
TEST_F(AssembleVintfTest,VendorNdkCheckEmpty)340 TEST_F(AssembleVintfTest, VendorNdkCheckEmpty) {
341 addInput("manifest.xml", "<manifest " + kMetaVersionStr + " type=\"framework\"/>\n");
342 getInstance()->setFakeEnv("PROVIDED_VNDK_VERSIONS", "P 26 27 ");
343
344 std::string matrix = "<compatibility-matrix " + kMetaVersionStr + " type=\"device\"/>\n";
345 getInstance()->setCheckInputStream("check.xml", makeStream(matrix));
346 EXPECT_TRUE(getInstance()->assemble());
347 }
348
TEST_F(AssembleVintfTest,VendorNdkCheckIncompat)349 TEST_F(AssembleVintfTest, VendorNdkCheckIncompat) {
350 addInput("manifest.xml", "<manifest " + kMetaVersionStr + " type=\"framework\"/>\n");
351 getInstance()->setFakeEnv("PROVIDED_VNDK_VERSIONS", "P 26 27 ");
352 std::string matrix =
353 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
354 " <vendor-ndk>\n"
355 " <version>O</version>\n"
356 " </vendor-ndk>\n"
357 "</compatibility-matrix>\n";
358 getInstance()->setCheckInputStream("check.xml", makeStream(matrix));
359 EXPECT_FALSE(getInstance()->assemble());
360 }
361
TEST_F(AssembleVintfTest,VendorNdkCheckCompat)362 TEST_F(AssembleVintfTest, VendorNdkCheckCompat) {
363 addInput("manifest.xml", "<manifest " + kMetaVersionStr + " type=\"framework\"/>\n");
364 getInstance()->setFakeEnv("PROVIDED_VNDK_VERSIONS", "P 26 27 ");
365 std::string matrix =
366 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
367 " <vendor-ndk>\n"
368 " <version>27</version>\n"
369 " </vendor-ndk>\n"
370 "</compatibility-matrix>\n";
371 getInstance()->setCheckInputStream("check.xml", makeStream(matrix));
372 EXPECT_TRUE(getInstance()->assemble());
373 }
374
TEST_F(AssembleVintfTest,MatrixSystemSdk)375 TEST_F(AssembleVintfTest, MatrixSystemSdk) {
376 addInput("compatibility_matrix.xml",
377 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\"/>\n");
378 getInstance()->setFakeEnv("BOARD_SYSTEMSDK_VERSIONS", "P 1 2 ");
379 EXPECT_TRUE(getInstance()->assemble());
380 EXPECT_IN(
381 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
382 " <system-sdk>\n"
383 " <version>1</version>\n"
384 " <version>2</version>\n"
385 " <version>P</version>\n"
386 " </system-sdk>\n"
387 "</compatibility-matrix>\n",
388 getOutput());
389 }
390
TEST_F(AssembleVintfTest,ManifestSystemSdk)391 TEST_F(AssembleVintfTest, ManifestSystemSdk) {
392 addInput("manifest.xml", "<manifest " + kMetaVersionStr + " type=\"framework\"/>\n");
393 getInstance()->setFakeEnv("PLATFORM_SYSTEMSDK_VERSIONS", "P 1 2 ");
394 EXPECT_TRUE(getInstance()->assemble());
395 EXPECT_IN(
396 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
397 " <system-sdk>\n"
398 " <version>1</version>\n"
399 " <version>2</version>\n"
400 " <version>P</version>\n"
401 " </system-sdk>\n"
402 "</manifest>\n",
403 getOutput());
404 }
405
406 const std::string gEmptyOutManifest =
407 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
408 " <sepolicy>\n"
409 " <version>202404</version>\n"
410 " </sepolicy>\n"
411 "</manifest>\n";
412
TEST_F(AssembleVintfTest,EmptyManifest)413 TEST_F(AssembleVintfTest, EmptyManifest) {
414 const std::string emptyManifest = "<manifest " + kMetaVersionStr + " type=\"device\" />";
415 setFakeEnvs({{"BOARD_SEPOLICY_VERS", "202404"}, {"IGNORE_TARGET_FCM_VERSION", "true"}});
416 addInput("manifest.empty.xml", emptyManifest);
417 EXPECT_TRUE(getInstance()->assemble());
418 EXPECT_IN(gEmptyOutManifest, getOutput());
419 }
420
TEST_F(AssembleVintfTest,DeviceFrameworkMatrixOptional)421 TEST_F(AssembleVintfTest, DeviceFrameworkMatrixOptional) {
422 setFakeEnvs({{"POLICYVERS", "30"},
423 {"PLATFORM_SEPOLICY_VERSION", "202404"},
424 {"PLATFORM_SEPOLICY_COMPAT_VERSIONS", "26.0 27.0"},
425 {"FRAMEWORK_VBMETA_VERSION", "1.0"},
426 {"PRODUCT_ENFORCE_VINTF_MANIFEST", "true"}});
427 getInstance()->setCheckInputStream("check.xml", makeStream(gEmptyOutManifest));
428
429 addInput("compatibility_matrix.empty.xml",
430 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
431 " <hal format=\"hidl\">\n"
432 " <name>vendor.foo.bar</name>\n"
433 " <version>1.0</version>\n"
434 " <interface>\n"
435 " <name>IFoo</name>\n"
436 " <instance>default</instance>\n"
437 " </interface>\n"
438 " </hal>\n"
439 "</compatibility-matrix>");
440
441 EXPECT_TRUE(getInstance()->assemble());
442 EXPECT_IN(
443 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
444 " <hal format=\"hidl\">\n"
445 " <name>vendor.foo.bar</name>\n"
446 " <version>1.0</version>\n"
447 " <interface>\n"
448 " <name>IFoo</name>\n"
449 " <instance>default</instance>\n"
450 " </interface>\n"
451 " </hal>\n"
452 " <sepolicy>\n"
453 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
454 " <sepolicy-version>26.0</sepolicy-version>\n"
455 " <sepolicy-version>27.0</sepolicy-version>\n"
456 " <sepolicy-version>202404</sepolicy-version>\n"
457 " </sepolicy>\n"
458 " <avb>\n"
459 " <vbmeta-version>1.0</vbmeta-version>\n"
460 " </avb>\n"
461 "</compatibility-matrix>",
462 getOutput());
463 }
464
TEST_F(AssembleVintfTest,DeviceFrameworkMatrixMultiple)465 TEST_F(AssembleVintfTest, DeviceFrameworkMatrixMultiple) {
466 setFakeEnvs({{"POLICYVERS", "30"},
467 {"PLATFORM_SEPOLICY_VERSION", "202404"},
468 {"PLATFORM_SEPOLICY_COMPAT_VERSIONS", "26.0 27.0"},
469 {"FRAMEWORK_VBMETA_VERSION", "1.0"},
470 {"PRODUCT_ENFORCE_VINTF_MANIFEST", "true"}});
471 getInstance()->setCheckInputStream("check.xml", makeStream(gEmptyOutManifest));
472
473 addInput("compatibility_matrix.foobar.xml",
474 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
475 " <hal format=\"hidl\">\n"
476 " <name>vendor.foo.bar</name>\n"
477 " <version>1.0</version>\n"
478 " <interface>\n"
479 " <name>IFoo</name>\n"
480 " <instance>default</instance>\n"
481 " </interface>\n"
482 " </hal>\n"
483 "</compatibility-matrix>");
484
485 addInput("compatibility_matrix.bazquux.xml",
486 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
487 " <hal format=\"hidl\">\n"
488 " <name>vendor.baz.quux</name>\n"
489 " <version>1.0</version>\n"
490 " <interface>\n"
491 " <name>IBaz</name>\n"
492 " <instance>default</instance>\n"
493 " </interface>\n"
494 " </hal>\n"
495 "</compatibility-matrix>");
496
497 EXPECT_TRUE(getInstance()->assemble());
498 EXPECT_IN(
499 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
500 " <hal format=\"hidl\">\n"
501 " <name>vendor.baz.quux</name>\n"
502 " <version>1.0</version>\n"
503 " <interface>\n"
504 " <name>IBaz</name>\n"
505 " <instance>default</instance>\n"
506 " </interface>\n"
507 " </hal>\n"
508 " <hal format=\"hidl\">\n"
509 " <name>vendor.foo.bar</name>\n"
510 " <version>1.0</version>\n"
511 " <interface>\n"
512 " <name>IFoo</name>\n"
513 " <instance>default</instance>\n"
514 " </interface>\n"
515 " </hal>\n"
516 " <sepolicy>\n"
517 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
518 " <sepolicy-version>26.0</sepolicy-version>\n"
519 " <sepolicy-version>27.0</sepolicy-version>\n"
520 " <sepolicy-version>202404</sepolicy-version>\n"
521 " </sepolicy>\n"
522 " <avb>\n"
523 " <vbmeta-version>1.0</vbmeta-version>\n"
524 " </avb>\n"
525 "</compatibility-matrix>",
526 getOutput());
527 }
528
TEST_F(AssembleVintfTest,OutputFileMatrixTest)529 TEST_F(AssembleVintfTest, OutputFileMatrixTest) {
530 const std::string kFile = "file_name_1.xml";
531 const std::string kMatrix =
532 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\"/>";
533 addInput(kFile, kMatrix);
534 EXPECT_TRUE(getInstance()->assemble());
535 EXPECT_IN(kFile, getOutput());
536 }
537
TEST_F(AssembleVintfTest,OutputFileManifestTest)538 TEST_F(AssembleVintfTest, OutputFileManifestTest) {
539 const std::string kFile = "file_name_1.xml";
540 std::string kManifest = "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"1\"/>";
541 addInput(kFile, kManifest);
542 EXPECT_TRUE(getInstance()->assemble());
543 EXPECT_IN(kFile, getOutput());
544 }
545
TEST_F(AssembleVintfTest,AidlAndHidlNames)546 TEST_F(AssembleVintfTest, AidlAndHidlNames) {
547 addInput("manifest1.xml",
548 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
549 " <hal format=\"aidl\">\n"
550 " <name>android.system.foo</name>\n"
551 " <fqname>IFoo/default</fqname>\n"
552 " </hal>\n"
553 "</manifest>\n");
554 addInput("manifest2.xml",
555 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
556 " <hal format=\"hidl\">\n"
557 " <name>android.system.foo</name>\n"
558 " <transport>hwbinder</transport>\n"
559 " <fqname>@1.0::IFoo/default</fqname>\n"
560 " </hal>\n"
561 "</manifest>\n");
562 std::vector<AidlInterfaceMetadata> aidl{
563 {.name = "android.system.foo",
564 .types = {"android.system.foo.IFoo"}}};
565 setFakeAidlMetadata(aidl);
566 EXPECT_TRUE(getInstance()->assemble());
567 EXPECT_IN(
568 " <hal format=\"aidl\">\n"
569 " <name>android.system.foo</name>\n"
570 " <fqname>IFoo/default</fqname>\n"
571 " </hal>\n",
572 getOutput());
573 EXPECT_IN(
574 " <hal format=\"hidl\">\n"
575 " <name>android.system.foo</name>\n"
576 " <transport>hwbinder</transport>\n"
577 " <fqname>@1.0::IFoo/default</fqname>\n"
578 " </hal>\n",
579 getOutput());
580 }
581
582 // Merge kernel FCM from manually written device manifest and <config> from
583 // parsing kernel prebuilt.
TEST_F(AssembleVintfTest,MergeKernelFcmAndConfigs)584 TEST_F(AssembleVintfTest, MergeKernelFcmAndConfigs) {
585 addInput("manifest.xml",
586 "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"1\">\n"
587 " <kernel target-level=\"2\"/>\n"
588 "</manifest>\n");
589 getInstance()->addKernelConfigInputStream({3, 18, 10}, "android-base.config",
590 makeStream("CONFIG_FOO=y"));
591 EXPECT_TRUE(getInstance()->assemble());
592 EXPECT_IN("<kernel version=\"3.18.10\" target-level=\"2\">", getOutput());
593 }
594
TEST_F(AssembleVintfTest,NoAutoSetKernelFcm)595 TEST_F(AssembleVintfTest, NoAutoSetKernelFcm) {
596 addInput("manifest.xml",
597 "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"1\">\n"
598 " <kernel version=\"3.18.10\"/>\n"
599 "</manifest>\n");
600 EXPECT_TRUE(getInstance()->assemble());
601 EXPECT_IN("<kernel version=\"3.18.10\"/>", getOutput());
602 }
603
TEST_F(AssembleVintfTest,NoAutoSetKernelFcmWithConfig)604 TEST_F(AssembleVintfTest, NoAutoSetKernelFcmWithConfig) {
605 addInput("manifest.xml",
606 "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"1\" />\n");
607 getInstance()->addKernelConfigInputStream({3, 18, 10}, "android-base.config",
608 makeStream("CONFIG_FOO=y"));
609 EXPECT_TRUE(getInstance()->assemble());
610 EXPECT_IN("<kernel version=\"3.18.10\">", getOutput());
611 }
612
TEST_F(AssembleVintfTest,NoKernelFcmT)613 TEST_F(AssembleVintfTest, NoKernelFcmT) {
614 addInput("manifest.xml",
615 StringPrintf(R"(<manifest %s type="device" target-level="%s">
616 <kernel target-level="8"/>
617 </manifest>)", kMetaVersionStr.c_str(),
618 to_string(details::kEnforceDeviceManifestNoKernelLevel).c_str()));
619 EXPECT_FALSE(getInstance()->assemble());
620 }
621
622 // Automatically add kernel FCM when parsing framework matrix for a single FCM version.
TEST_F(AssembleVintfTest,AutoSetMatrixKernelFcm)623 TEST_F(AssembleVintfTest, AutoSetMatrixKernelFcm) {
624 addInput("compatibility_matrix.xml",
625 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\"/>\n"
626 );
627 getInstance()->addKernelConfigInputStream({3, 18, 10}, "android-base.config",
628 makeStream(""));
629 EXPECT_TRUE(getInstance()->assemble());
630 EXPECT_IN("<kernel version=\"3.18.10\" level=\"1\"/>", getOutput());
631 }
632
633
TEST_F(AssembleVintfTest,WithKernelRequirements)634 TEST_F(AssembleVintfTest, WithKernelRequirements) {
635 setFakeEnvs({{"POLICYVERS", "30"},
636 {"PLATFORM_SEPOLICY_VERSION", "202404"},
637 {"PRODUCT_ENFORCE_VINTF_MANIFEST", "true"}});
638 addInput("compatibility_matrix.xml",
639 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
640 " <kernel version=\"3.18.1\" level=\"1\">\n"
641 " <config>\n"
642 " <key>CONFIG_FOO</key>\n"
643 " <value type=\"tristate\">y</value>\n"
644 " </config>\n"
645 " </kernel>\n"
646 "</compatibility-matrix>\n");
647 getInstance()->setCheckInputStream("check.xml", makeStream(
648 "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"1\">\n"
649 " <kernel target-level=\"1\" version=\"3.18.0\"/>\n"
650 " <sepolicy>\n"
651 " <version>202404</version>\n"
652 " </sepolicy>\n"
653 "</manifest>\n"));
654
655 EXPECT_FALSE(getInstance()->assemble());
656 }
657
TEST_F(AssembleVintfTest,NoKernelRequirements)658 TEST_F(AssembleVintfTest, NoKernelRequirements) {
659 setFakeEnvs({{"POLICYVERS", "30"},
660 {"PLATFORM_SEPOLICY_VERSION", "202404"},
661 {"PRODUCT_ENFORCE_VINTF_MANIFEST", "true"}});
662 addInput("compatibility_matrix.xml",
663 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
664 " <kernel version=\"3.18.0\" level=\"1\"/>\n"
665 "</compatibility-matrix>\n");
666 getInstance()->setCheckInputStream("check.xml", makeStream(
667 "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"1\">\n"
668 " <kernel target-level=\"1\"/>\n"
669 " <sepolicy>\n"
670 " <version>202404</version>\n"
671 " </sepolicy>\n"
672 "</manifest>\n"));
673
674 EXPECT_TRUE(getInstance()->setNoKernelRequirements());
675 EXPECT_TRUE(getInstance()->assemble());
676 }
677
678 // clang-format on
679
TEST_F(AssembleVintfTest,ManifestLevelConflictCorrectLocation)680 TEST_F(AssembleVintfTest, ManifestLevelConflictCorrectLocation) {
681 addInput("manifest.xml", "<manifest " + kMetaVersionStr + R"( type="device" />)");
682 addInput("manifest_1.xml",
683 "<manifest " + kMetaVersionStr + R"( type="device" target-level="1" />)");
684 addInput("manifest_2.xml",
685 "<manifest " + kMetaVersionStr + R"( type="device" target-level="2" />)");
686 EXPECT_FALSE(getInstance()->assemble());
687 EXPECT_IN("File 'manifest_1.xml' has level 1", getError());
688 EXPECT_IN("File 'manifest_2.xml' has level 2", getError());
689 }
690
TEST_F(AssembleVintfTest,PassMultipleManifestEntrySameModule)691 TEST_F(AssembleVintfTest, PassMultipleManifestEntrySameModule) {
692 setFakeEnvs({{"VINTF_IGNORE_TARGET_FCM_VERSION", "true"}});
693 std::vector<AidlInterfaceMetadata> aidl{
694 {.name = "android.system.foo",
695 .stability = "vintf",
696 .versions = {1, 2},
697 .types = {"android.system.foobar.IFoo", "android.system.foobar.IBar"}}};
698 setFakeAidlMetadata(aidl);
699 addInput("manifest1.xml", StringPrintf(
700 R"(
701 <manifest %s type="framework">
702 <hal format="aidl">
703 <name>android.system.foobar</name>\n"
704 <fqname>IFoo/default</fqname>\n"
705 <fqname>IBar/default</fqname>\n"
706 <version>3</version>\n"
707 </hal>
708 </manifest>)",
709 kMetaVersionStr.c_str()));
710 EXPECT_TRUE(getInstance()->assemble());
711 }
712
TEST_F(AssembleVintfTest,FailOnMultipleModulesInSameManifestEntry)713 TEST_F(AssembleVintfTest, FailOnMultipleModulesInSameManifestEntry) {
714 setFakeEnvs({{"VINTF_IGNORE_TARGET_FCM_VERSION", "true"}});
715 std::vector<AidlInterfaceMetadata> aidl{{.name = "android.system.foo",
716 .stability = "vintf",
717 .versions = {1, 2},
718 .types = {"android.system.foobar.IFoo"}},
719 {.name = "android.system.bar",
720 .stability = "vintf",
721 .versions = {1, 2},
722 .types = {"android.system.foobar.IBar"}}};
723 setFakeAidlMetadata(aidl);
724 addInput("manifest1.xml", StringPrintf(
725 R"(
726 <manifest %s type="framework">
727 <hal format="aidl">
728 <name>android.system.foobar</name>\n"
729 <fqname>IFoo/default</fqname>\n"
730 <fqname>IBar/default</fqname>\n"
731 <version>3</version>\n"
732 </hal>
733 </manifest>)",
734 kMetaVersionStr.c_str()));
735 EXPECT_FALSE(getInstance()->assemble());
736 EXPECT_IN("HAL manifest entries must only contain", getError());
737 EXPECT_IN("android.system.foobar.IFoo is in android.system.foo", getError());
738 }
739
TEST_F(AssembleVintfTest,ForceDowngradeVersion)740 TEST_F(AssembleVintfTest, ForceDowngradeVersion) {
741 setFakeEnvs({{"VINTF_IGNORE_TARGET_FCM_VERSION", "true"}});
742 std::vector<AidlInterfaceMetadata> aidl{
743 {.name = "foo_android.system.bar",
744 .stability = "vintf",
745 .types = {"android.system.bar.IFoo", "android.system.bar.MyFoo"},
746 .versions = {1, 2},
747 .has_development = true}};
748 setFakeAidlMetadata(aidl);
749 setFakeAidlUseUnfrozen(false);
750 addInput("manifest1.xml", StringPrintf(
751 R"(
752 <manifest %s type="framework">
753 <hal format="aidl">
754 <name>android.system.bar</name>\n"
755 <fqname>IFoo/default</fqname>\n"
756 <version>3</version>\n"
757 </hal>
758 </manifest>)",
759 kMetaVersionStr.c_str()));
760 EXPECT_TRUE(getInstance()->assemble());
761 EXPECT_IN("<version>2</version>", getOutput());
762 }
763
764 TEST_F(AssembleVintfTest, InfoDowngradeVersionTypo) {
765 setFakeEnvs({{"VINTF_IGNORE_TARGET_FCM_VERSION", "true"}});
766 std::vector<AidlInterfaceMetadata> aidl{
767 {.name = "foo_android.system.bar",
768 .stability = "vintf",
769 .types = {"android.system.bar.IFoo", "android.system.bar.MyFoo"},
770 .versions = {1, 2},
771 .has_development = true}};
772 setFakeAidlMetadata(aidl);
773 setFakeAidlUseUnfrozen(false);
774 addInput("manifest1.xml", StringPrintf(
775 R"(
776 <manifest %s type="framework">
777 <hal format="aidl">
778 <name>android.system.bar</name>\n"
779 <fqname>IFooooooooo/default</fqname>\n"
780 <version>3</version>\n"
781 </hal>
782 </manifest>)",
783 kMetaVersionStr.c_str()));
784 // It doesn't fail because there may be prebuilts, but make sure we do log it.
785 EXPECT_TRUE(getInstance()->assemble());
786 EXPECT_IN(
787 "INFO: Couldn't find AIDL metadata for: android.system.bar.IFooooooooo in file "
788 "manifest1.xml. "
789 "Check "
790 "spelling?",
791 getError());
792 }
793
TEST_F(AssembleVintfTest,AllowUnfrozenVersion)794 TEST_F(AssembleVintfTest, AllowUnfrozenVersion) {
795 setFakeEnvs({{"VINTF_IGNORE_TARGET_FCM_VERSION", "true"}});
796 std::vector<AidlInterfaceMetadata> aidl{
797 {.name = "foo_android.system.bar",
798 .stability = "vintf",
799 .types = {"android.system.bar.IFoo", "android.system.bar.MyFoo"},
800 .versions = {1, 2},
801 .has_development = true}};
802 setFakeAidlMetadata(aidl);
803 setFakeAidlUseUnfrozen(true);
804 addInput("manifest1.xml", StringPrintf(
805 R"(
806 <manifest %s type="framework">
807 <hal format="aidl">
808 <name>android.system.bar</name>\n"
809 <fqname>IFoo/default</fqname>\n"
810 <version>3</version>\n"
811 </hal>
812 </manifest>)",
813 kMetaVersionStr.c_str()));
814 EXPECT_TRUE(getInstance()->assemble());
815 EXPECT_IN("<version>3</version>", getOutput());
816 }
817
818 TEST_F(AssembleVintfTest, KeepFrozenVersion) {
819 setFakeEnvs({{"VINTF_IGNORE_TARGET_FCM_VERSION", "true"}});
820 // V3 is already frozen
821 std::vector<AidlInterfaceMetadata> aidl{
822 {.name = "foo_android.system.bar",
823 .stability = "vintf",
824 .types = {"android.system.bar.IFoo", "android.system.bar.MyFoo"},
825 .versions = {1, 2, 3},
826 .has_development = true}};
827 setFakeAidlMetadata(aidl);
828 setFakeAidlUseUnfrozen(false);
829 addInput("manifest1.xml", StringPrintf(
830 R"(
831 <manifest %s type="framework">
832 <hal format="aidl">
833 <name>android.system.bar</name>\n"
834 <fqname>IFoo/default</fqname>\n"
835 <version>3</version>\n"
836 </hal>
837 </manifest>)",
838 kMetaVersionStr.c_str()));
839 EXPECT_TRUE(getInstance()->assemble());
840 EXPECT_IN("<version>3</version>", getOutput());
841 }
842
843 } // namespace vintf
844 } // namespace android
845