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 // This needs to be on top of the file to work.
18 #include "gmock-logging-compat.h"
19
20 #include <stdio.h>
21 #include <optional>
22
23 #include <android-base/file.h>
24 #include <android-base/logging.h>
25 #include <android-base/result-gmock.h>
26 #include <android-base/stringprintf.h>
27 #include <android-base/strings.h>
28 #include <gtest/gtest.h>
29
30 #include <vintf/VintfObject.h>
31 #include <vintf/parse_string.h>
32 #include <vintf/parse_xml.h>
33 #include "constants-private.h"
34 #include "parse_xml_internal.h"
35 #include "test_constants.h"
36 #include "utils-fake.h"
37
38 using namespace ::testing;
39 using namespace std::literals;
40
41 using android::base::testing::HasError;
42 using android::base::testing::HasValue;
43 using android::base::testing::Ok;
44 using android::base::testing::WithCode;
45 using android::base::testing::WithMessage;
46 using android::vintf::FqInstance;
47
48 #define EXPECT_IN(sub, str) EXPECT_THAT(str, HasSubstr(sub))
49 #define EXPECT_NOT_IN(sub, str) EXPECT_THAT(str, Not(HasSubstr(sub)))
50
51 namespace android {
52 namespace vintf {
53 namespace testing {
54
55 using namespace ::android::vintf::details;
56
57 // clang-format off
58
59 //
60 // Set of Xml1 metadata compatible with each other.
61 //
62
63 const std::string systemMatrixXml1 =
64 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
65 " <hal format=\"hidl\" optional=\"false\">\n"
66 " <name>android.hardware.camera</name>\n"
67 " <version>2.0-5</version>\n"
68 " <version>3.4-16</version>\n"
69 " </hal>\n"
70 " <hal format=\"hidl\" optional=\"false\">\n"
71 " <name>android.hardware.nfc</name>\n"
72 " <version>1.0</version>\n"
73 " <version>2.0</version>\n"
74 " </hal>\n"
75 " <hal format=\"hidl\" optional=\"true\">\n"
76 " <name>android.hardware.foo</name>\n"
77 " <version>1.0</version>\n"
78 " </hal>\n"
79 " <kernel version=\"3.18.31\"></kernel>\n"
80 " <sepolicy>\n"
81 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
82 " <sepolicy-version>25.5</sepolicy-version>\n"
83 " <sepolicy-version>26.0-3</sepolicy-version>\n"
84 " </sepolicy>\n"
85 " <avb>\n"
86 " <vbmeta-version>0.0</vbmeta-version>\n"
87 " </avb>\n"
88 "</compatibility-matrix>\n";
89
90 const std::string vendorManifestXml1 =
91 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
92 " <hal format=\"hidl\">\n"
93 " <name>android.hardware.camera</name>\n"
94 " <transport>hwbinder</transport>\n"
95 " <version>3.5</version>\n"
96 " <interface>\n"
97 " <name>IBetterCamera</name>\n"
98 " <instance>camera</instance>\n"
99 " </interface>\n"
100 " <interface>\n"
101 " <name>ICamera</name>\n"
102 " <instance>default</instance>\n"
103 " <instance>legacy/0</instance>\n"
104 " </interface>\n"
105 " </hal>\n"
106 " <hal format=\"hidl\">\n"
107 " <name>android.hardware.nfc</name>\n"
108 " <transport>hwbinder</transport>\n"
109 " <version>1.0</version>\n"
110 " <interface>\n"
111 " <name>INfc</name>\n"
112 " <instance>nfc_nci</instance>\n"
113 " </interface>\n"
114 " </hal>\n"
115 " <hal format=\"hidl\">\n"
116 " <name>android.hardware.nfc</name>\n"
117 " <transport>hwbinder</transport>\n"
118 " <version>2.0</version>\n"
119 " <interface>\n"
120 " <name>INfc</name>\n"
121 " <instance>default</instance>\n"
122 " <instance>nfc_nci</instance>\n"
123 " </interface>\n"
124 " </hal>\n"
125 " <sepolicy>\n"
126 " <version>25.5</version>\n"
127 " </sepolicy>\n"
128 "</manifest>\n";
129
130 const std::string systemManifestXml1 =
131 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
132 " <hal format=\"hidl\">\n"
133 " <name>android.hidl.manager</name>\n"
134 " <transport>hwbinder</transport>\n"
135 " <version>1.0</version>\n"
136 " <interface>\n"
137 " <name>IServiceManager</name>\n"
138 " <instance>default</instance>\n"
139 " </interface>\n"
140 " </hal>\n"
141 " <vndk>\n"
142 " <version>25.0.5</version>\n"
143 " <library>libbase.so</library>\n"
144 " <library>libjpeg.so</library>\n"
145 " </vndk>\n"
146 "</manifest>\n";
147
148 const std::string vendorMatrixXml1 =
149 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
150 " <hal format=\"hidl\" optional=\"false\">\n"
151 " <name>android.hidl.manager</name>\n"
152 " <version>1.0</version>\n"
153 " </hal>\n"
154 " <vndk>\n"
155 " <version>25.0.1-5</version>\n"
156 " <library>libbase.so</library>\n"
157 " <library>libjpeg.so</library>\n"
158 " </vndk>\n"
159 "</compatibility-matrix>\n";
160
161 //
162 // Set of Xml2 metadata compatible with each other.
163 //
164
165 const std::string systemMatrixXml2 =
166 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
167 " <hal format=\"hidl\" optional=\"false\">\n"
168 " <name>android.hardware.foo</name>\n"
169 " <version>1.0</version>\n"
170 " </hal>\n"
171 " <kernel version=\"3.18.31\"></kernel>\n"
172 " <sepolicy>\n"
173 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
174 " <sepolicy-version>25.5</sepolicy-version>\n"
175 " <sepolicy-version>26.0-3</sepolicy-version>\n"
176 " </sepolicy>\n"
177 " <avb>\n"
178 " <vbmeta-version>0.0</vbmeta-version>\n"
179 " </avb>\n"
180 "</compatibility-matrix>\n";
181
182 const std::string vendorManifestXml2 =
183 "<manifest " + kMetaVersionStr + " type=\"device\">"
184 " <hal>"
185 " <name>android.hardware.foo</name>"
186 " <transport>hwbinder</transport>"
187 " <version>1.0</version>"
188 " </hal>"
189 " <sepolicy>\n"
190 " <version>25.5</version>\n"
191 " </sepolicy>\n"
192 "</manifest>";
193
194 //
195 // Set of framework matrices of different FCM version.
196 //
197
198 const std::string systemMatrixLevel1 =
199 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
200 " <hal format=\"hidl\" optional=\"true\">\n"
201 " <name>android.hardware.major</name>\n"
202 " <version>1.0</version>\n"
203 " <interface>\n"
204 " <name>IMajor</name>\n"
205 " <instance>default</instance>\n"
206 " </interface>\n"
207 " </hal>\n"
208 " <hal format=\"hidl\" optional=\"true\">\n"
209 " <name>android.hardware.removed</name>\n"
210 " <version>1.0</version>\n"
211 " <interface>\n"
212 " <name>IRemoved</name>\n"
213 " <instance>default</instance>\n"
214 " </interface>\n"
215 " </hal>\n"
216 " <hal format=\"hidl\" optional=\"true\">\n"
217 " <name>android.hardware.minor</name>\n"
218 " <version>1.0</version>\n"
219 " <interface>\n"
220 " <name>IMinor</name>\n"
221 " <instance>default</instance>\n"
222 " <instance>legacy</instance>\n"
223 " </interface>\n"
224 " </hal>\n"
225 " <hal format=\"aidl\" optional=\"true\">\n"
226 " <name>android.hardware.minor</name>\n"
227 " <version>101</version>\n"
228 " <interface>\n"
229 " <name>IMinor</name>\n"
230 " <instance>default</instance>\n"
231 " </interface>\n"
232 " </hal>\n"
233 " <hal format=\"aidl\" optional=\"true\">\n"
234 " <name>android.hardware.removed</name>\n"
235 " <version>101</version>\n"
236 " <interface>\n"
237 " <name>IRemoved</name>\n"
238 " <instance>default</instance>\n"
239 " </interface>\n"
240 " </hal>\n"
241 " <hal format=\"aidl\" exclusive-to=\"virtual-machine\">\n"
242 " <name>android.hardware.vm.removed</name>\n"
243 " <version>2</version>\n"
244 " <interface>\n"
245 " <name>IRemoved</name>\n"
246 " <instance>default</instance>\n"
247 " </interface>\n"
248 " </hal>\n"
249 "</compatibility-matrix>\n";
250
251 const std::string systemMatrixLevel2 =
252 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
253 " <hal format=\"hidl\" optional=\"true\">\n"
254 " <name>android.hardware.major</name>\n"
255 " <version>2.0</version>\n"
256 " <interface>\n"
257 " <name>IMajor</name>\n"
258 " <instance>default</instance>\n"
259 " </interface>\n"
260 " </hal>\n"
261 " <hal format=\"hidl\" optional=\"true\">\n"
262 " <name>android.hardware.minor</name>\n"
263 " <version>1.1</version>\n"
264 " <interface>\n"
265 " <name>IMinor</name>\n"
266 " <instance>default</instance>\n"
267 " </interface>\n"
268 " </hal>\n"
269 " <hal format=\"aidl\" optional=\"true\">\n"
270 " <name>android.hardware.minor</name>\n"
271 " <version>102</version>\n"
272 " <interface>\n"
273 " <name>IMinor</name>\n"
274 " <instance>default</instance>\n"
275 " </interface>\n"
276 " </hal>\n"
277 " <hal format=\"aidl\" exclusive-to=\"virtual-machine\">\n"
278 " <name>android.hardware.vm.removed</name>\n"
279 " <version>3</version>\n"
280 " <interface>\n"
281 " <name>IRemoved</name>\n"
282 " <instance>default</instance>\n"
283 " </interface>\n"
284 " </hal>\n"
285 "</compatibility-matrix>\n";
286
287 //
288 // Smaller product FCMs at different levels to test that framework and product
289 // FCMs are combined when checking deprecation.
290 //
291
292 const std::string productMatrixLevel1 =
293 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
294 " <hal format=\"hidl\" optional=\"true\">\n"
295 " <name>product.removed</name>\n"
296 " <version>1.0</version>\n"
297 " <interface>\n"
298 " <name>IRemoved</name>\n"
299 " <instance>default</instance>\n"
300 " </interface>\n"
301 " </hal>\n"
302 " <hal format=\"hidl\" optional=\"true\">\n"
303 " <name>product.minor</name>\n"
304 " <version>1.0</version>\n"
305 " <interface>\n"
306 " <name>IMinor</name>\n"
307 " <instance>default</instance>\n"
308 " </interface>\n"
309 " </hal>\n"
310 "</compatibility-matrix>\n";
311
312 const std::string productMatrixLevel2 =
313 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
314 " <hal format=\"hidl\" optional=\"true\">\n"
315 " <name>product.minor</name>\n"
316 " <version>1.1</version>\n"
317 " <interface>\n"
318 " <name>IMinor</name>\n"
319 " <instance>default</instance>\n"
320 " </interface>\n"
321 " </hal>\n"
322 "</compatibility-matrix>\n";
323
324 //
325 // Set of framework matrices of different FCM version with regex.
326 //
327
328 const static std::vector<std::string> systemMatrixRegexXmls = {
329 // 1.xml
330 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
331 " <hal format=\"hidl\" optional=\"false\">\n"
332 " <name>android.hardware.regex</name>\n"
333 " <version>1.0-1</version>\n"
334 " <interface>\n"
335 " <name>IRegex</name>\n"
336 " <instance>default</instance>\n"
337 " <instance>special/1.0</instance>\n"
338 " <regex-instance>regex/1.0/[0-9]+</regex-instance>\n"
339 " <regex-instance>regex_common/[0-9]+</regex-instance>\n"
340 " </interface>\n"
341 " </hal>\n"
342 "</compatibility-matrix>\n",
343 // 2.xml
344 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
345 " <hal format=\"hidl\" optional=\"false\">\n"
346 " <name>android.hardware.regex</name>\n"
347 " <version>1.1-2</version>\n"
348 " <interface>\n"
349 " <name>IRegex</name>\n"
350 " <instance>default</instance>\n"
351 " <instance>special/1.1</instance>\n"
352 " <regex-instance>regex/1.1/[0-9]+</regex-instance>\n"
353 " <regex-instance>[a-z]+_[a-z]+/[0-9]+</regex-instance>\n"
354 " </interface>\n"
355 " </hal>\n"
356 "</compatibility-matrix>\n",
357 // 3.xml
358 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"3\">\n"
359 " <hal format=\"hidl\" optional=\"false\">\n"
360 " <name>android.hardware.regex</name>\n"
361 " <version>2.0</version>\n"
362 " <interface>\n"
363 " <name>IRegex</name>\n"
364 " <instance>default</instance>\n"
365 " <instance>special/2.0</instance>\n"
366 " <regex-instance>regex/2.0/[0-9]+</regex-instance>\n"
367 " <regex-instance>regex_[a-z]+/[0-9]+</regex-instance>\n"
368 " </interface>\n"
369 " </hal>\n"
370 "</compatibility-matrix>\n"};
371
372 //
373 // Set of metadata at different FCM version that has requirements
374 //
375
376 const std::vector<std::string> systemMatrixRequire = {
377 // 1.xml
378 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
379 " <hal format=\"hidl\" optional=\"false\">\n"
380 " <name>android.hardware.foo</name>\n"
381 " <version>1.0</version>\n"
382 " <interface>\n"
383 " <name>IFoo</name>\n"
384 " <instance>default</instance>\n"
385 " </interface>\n"
386 " </hal>\n"
387 "</compatibility-matrix>\n",
388 // 2.xml
389 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
390 " <hal format=\"hidl\" optional=\"false\">\n"
391 " <name>android.hardware.bar</name>\n"
392 " <version>1.0</version>\n"
393 " <interface>\n"
394 " <name>IBar</name>\n"
395 " <instance>default</instance>\n"
396 " </interface>\n"
397 " </hal>\n"
398 "</compatibility-matrix>\n"};
399
400 const std::string vendorManifestRequire1 =
401 "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"1\">\n"
402 " <hal format=\"hidl\">\n"
403 " <name>android.hardware.foo</name>\n"
404 " <transport>hwbinder</transport>\n"
405 " <fqname>@1.0::IFoo/default</fqname>\n"
406 " </hal>\n"
407 "</manifest>\n";
408
409 const std::string vendorManifestRequire2 =
410 "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"2\">\n"
411 " <hal format=\"hidl\">\n"
412 " <name>android.hardware.bar</name>\n"
413 " <transport>hwbinder</transport>\n"
414 " <fqname>@1.0::IBar/default</fqname>\n"
415 " </hal>\n"
416 "</manifest>\n";
417
418 //
419 // Set of metadata for kernel requirements
420 //
421
422 const std::string vendorManifestKernel318 =
423 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
424 " <kernel version=\"3.18.999\" />\n"
425 " <sepolicy>\n"
426 " <version>25.5</version>\n"
427 " </sepolicy>\n"
428 "</manifest>\n";
429
430 const std::string systemMatrixKernel318 =
431 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
432 " <kernel version=\"3.18.999\"></kernel>\n"
433 " <sepolicy>\n"
434 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
435 " <sepolicy-version>25.5</sepolicy-version>\n"
436 " </sepolicy>\n"
437 "</compatibility-matrix>\n";
438
439 const std::string apexHalName = "android.hardware.apex.foo";
440 const std::string apexHalManifest =
441 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
442 " <hal format=\"aidl\">\n"
443 " <name>" + apexHalName + "</name>\n"
444 " <fqname>IApex/default</fqname>\n"
445 " </hal>\n"
446 "</manifest>\n";
447
448 class VintfObjectTestBase : public ::testing::Test {
449 protected:
fetcher()450 MockFileSystem& fetcher() {
451 return static_cast<MockFileSystem&>(*vintfObject->getFileSystem());
452 }
propertyFetcher()453 MockPropertyFetcher& propertyFetcher() {
454 return static_cast<MockPropertyFetcher&>(*vintfObject->getPropertyFetcher());
455 }
456
setCheckAidlFCM(bool check)457 void setCheckAidlFCM(bool check) { vintfObject->setFakeCheckAidlCompatMatrix(check); }
useEmptyFileSystem()458 void useEmptyFileSystem() {
459 // By default, no files exist in the file system.
460 // Use EXPECT_CALL because more specific expectation of fetch and listFiles will come along.
461 EXPECT_CALL(fetcher(), listFiles(_, _, _)).Times(AnyNumber())
462 .WillRepeatedly(Return(::android::NAME_NOT_FOUND));
463 EXPECT_CALL(fetcher(), fetch(_, _)).Times(AnyNumber())
464 .WillRepeatedly(Return(::android::NAME_NOT_FOUND));
465 }
466
467 // Setup the MockFileSystem used by the fetchAllInformation template
468 // so it returns the given metadata info instead of fetching from device.
setupMockFetcher(const std::string & vendorManifestXml,const std::string & systemMatrixXml,const std::string & systemManifestXml,const std::string & vendorMatrixXml)469 void setupMockFetcher(const std::string& vendorManifestXml, const std::string& systemMatrixXml,
470 const std::string& systemManifestXml, const std::string& vendorMatrixXml) {
471
472 useEmptyFileSystem();
473
474 ON_CALL(fetcher(), fetch(StrEq(kVendorLegacyManifest), _))
475 .WillByDefault(
476 Invoke([vendorManifestXml](const std::string& path, std::string& fetched) {
477 (void)path;
478 fetched = vendorManifestXml;
479 return 0;
480 }));
481 ON_CALL(fetcher(), fetch(StrEq(kSystemManifest), _))
482 .WillByDefault(
483 Invoke([systemManifestXml](const std::string& path, std::string& fetched) {
484 (void)path;
485 fetched = systemManifestXml;
486 return 0;
487 }));
488 ON_CALL(fetcher(), fetch(StrEq(kVendorLegacyMatrix), _))
489 .WillByDefault(Invoke([vendorMatrixXml](const std::string& path, std::string& fetched) {
490 (void)path;
491 fetched = vendorMatrixXml;
492 return 0;
493 }));
494 ON_CALL(fetcher(), fetch(StrEq(kSystemLegacyMatrix), _))
495 .WillByDefault(Invoke([systemMatrixXml](const std::string& path, std::string& fetched) {
496 (void)path;
497 fetched = systemMatrixXml;
498 return 0;
499 }));
500 }
SetUp()501 virtual void SetUp() {
502 vintfObject = VintfObject::Builder()
503 .setFileSystem(std::make_unique<NiceMock<MockFileSystem>>())
504 .setRuntimeInfoFactory(std::make_unique<NiceMock<MockRuntimeInfoFactory>>(
505 std::make_shared<NiceMock<MockRuntimeInfo>>()))
506 .setPropertyFetcher(std::make_unique<NiceMock<MockPropertyFetcher>>())
507 .build();
508
509 ON_CALL(propertyFetcher(), getBoolProperty("apex.all.ready", _))
510 .WillByDefault(Return(true));
511 }
TearDown()512 virtual void TearDown() {
513 Mock::VerifyAndClear(&fetcher());
514 }
515
expectVendorManifest(size_t times=1)516 void expectVendorManifest(size_t times = 1) {
517 EXPECT_CALL(fetcher(), fetch(StrEq(kVendorLegacyManifest), _)).Times(times);
518 }
519
expectSystemManifest(size_t times=1)520 void expectSystemManifest(size_t times = 1) {
521 EXPECT_CALL(fetcher(), fetch(StrEq(kSystemManifest), _)).Times(times);
522 }
523
expectVendorMatrix(size_t times=1)524 void expectVendorMatrix(size_t times = 1) {
525 EXPECT_CALL(fetcher(), fetch(StrEq(kVendorLegacyMatrix), _)).Times(times);
526 }
527
expectSystemMatrix(size_t times=1)528 void expectSystemMatrix(size_t times = 1) {
529 EXPECT_CALL(fetcher(), fetch(StrEq(kSystemLegacyMatrix), _)).Times(times);
530 }
531
532 // Expect that a file exist and should be fetched once.
expectFetch(const std::string & path,const std::string & content)533 void expectFetch(const std::string& path, const std::string& content) {
534 EXPECT_CALL(fetcher(), fetch(StrEq(path), _))
535 .WillOnce(Invoke([content](const auto&, auto& out) {
536 out = content;
537 return ::android::OK;
538 }));
539 }
540
541 // Expect that a file exist and can be fetched 0 or more times.
expectFetchRepeatedly(const std::string & path,const std::string & content)542 void expectFetchRepeatedly(const std::string& path, const std::string& content) {
543 EXPECT_CALL(fetcher(), fetch(StrEq(path), _))
544 .Times(AnyNumber())
545 .WillRepeatedly(Invoke([content](const auto&, auto& out) {
546 out = content;
547 return ::android::OK;
548 }));
549 }
550
551 // Expect that the file should never be fetched (whether it exists or not).
expectNeverFetch(const std::string & path)552 void expectNeverFetch(const std::string& path) {
553 EXPECT_CALL(fetcher(), fetch(StrEq(path), _)).Times(0);
554 }
555
556 // Expect that the file does not exist, and can be fetched 0 or more times.
557 template <typename Matcher>
expectFileNotExist(const Matcher & matcher)558 void expectFileNotExist(const Matcher& matcher) {
559 EXPECT_CALL(fetcher(), fetch(matcher, _))
560 .Times(AnyNumber())
561 .WillRepeatedly(Return(::android::NAME_NOT_FOUND));
562 }
563
564 // clang-format on
expectVendorManifest(Level level,const std::vector<std::string> & fqInstances,const std::vector<FqInstance> & aidlInstances={},ExclusiveTo exclusiveTo=ExclusiveTo::EMPTY)565 void expectVendorManifest(Level level, const std::vector<std::string>& fqInstances,
566 const std::vector<FqInstance>& aidlInstances = {},
567 ExclusiveTo exclusiveTo = ExclusiveTo::EMPTY) {
568 std::string xml =
569 android::base::StringPrintf(R"(<manifest %s type="device" target-level="%s">)",
570 kMetaVersionStr.c_str(), to_string(level).c_str());
571 for (const auto& fqInstanceString : fqInstances) {
572 auto fqInstance = FqInstance::from(fqInstanceString);
573 ASSERT_TRUE(fqInstance.has_value());
574 xml += android::base::StringPrintf(
575 R"(
576 <hal format="hidl">
577 <name>%s</name>
578 <transport>hwbinder</transport>
579 <fqname>%s</fqname>
580 </hal>
581 )",
582 fqInstance->getPackage().c_str(),
583 toFQNameString(fqInstance->getVersion(), fqInstance->getInterface(),
584 fqInstance->getInstance())
585 .c_str());
586 }
587 for (const auto& fqInstance : aidlInstances) {
588 xml += android::base::StringPrintf(
589 R"(
590 <hal format="aidl" exclusive-to="%s">
591 <name>%s</name>
592 <version>%zu</version>
593 <fqname>%s</fqname>
594 </hal>
595 )",
596 gExclusiveToStrings.at(static_cast<size_t>(exclusiveTo)),
597 fqInstance.getPackage().c_str(), fqInstance.getMinorVersion(),
598 toFQNameString(fqInstance.getInterface(), fqInstance.getInstance()).c_str());
599 }
600 xml += "</manifest>";
601 expectFetchRepeatedly(kVendorManifest, xml);
602 }
603 // clang-format off
604
runtimeInfoFactory()605 MockRuntimeInfoFactory& runtimeInfoFactory() {
606 return static_cast<MockRuntimeInfoFactory&>(*vintfObject->getRuntimeInfoFactory());
607 }
608
noApex()609 void noApex() {
610 expectFileNotExist(StartsWith("/apex/"));
611 }
612
613 std::unique_ptr<VintfObject> vintfObject;
614 };
615
616 // Test fixture that provides compatible metadata from the mock device.
617 class VintfObjectCompatibleTest : public VintfObjectTestBase {
618 protected:
SetUp()619 virtual void SetUp() {
620 VintfObjectTestBase::SetUp();
621 setupMockFetcher(vendorManifestXml1, systemMatrixXml1, systemManifestXml1, vendorMatrixXml1);
622 noApex();
623 }
624 };
625
626 // Tests that local info is checked.
TEST_F(VintfObjectCompatibleTest,TestDeviceCompatibility)627 TEST_F(VintfObjectCompatibleTest, TestDeviceCompatibility) {
628 std::string error;
629
630 expectVendorManifest();
631 expectSystemManifest();
632 expectVendorMatrix();
633 expectSystemMatrix();
634
635 int result = vintfObject->checkCompatibility(&error);
636
637 ASSERT_EQ(result, 0) << "Fail message:" << error.c_str();
638 // Check that nothing was ignored.
639 ASSERT_STREQ(error.c_str(), "");
640 }
641
642 // Test fixture that provides incompatible metadata from the mock device.
643 class VintfObjectIncompatibleTest : public VintfObjectTestBase {
644 protected:
SetUp()645 virtual void SetUp() {
646 VintfObjectTestBase::SetUp();
647 setupMockFetcher(vendorManifestXml1, systemMatrixXml2, systemManifestXml1, vendorMatrixXml1);
648 }
649 };
650
651 // Fetch all metadata from device and ensure that it fails.
TEST_F(VintfObjectIncompatibleTest,TestDeviceCompatibility)652 TEST_F(VintfObjectIncompatibleTest, TestDeviceCompatibility) {
653 std::string error;
654
655 expectVendorManifest();
656 expectSystemManifest();
657 expectVendorMatrix();
658 expectSystemMatrix();
659
660 int result = vintfObject->checkCompatibility(&error);
661
662 ASSERT_EQ(result, 1) << "Should have failed:" << error.c_str();
663 }
664
665 const std::string vendorManifestKernelFcm =
666 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
667 " <kernel version=\"3.18.999\" target-level=\"8\"/>\n"
668 "</manifest>\n";
669
670 // Test fixture that provides compatible metadata from the mock device.
671 class VintfObjectRuntimeInfoTest : public VintfObjectTestBase {
672 protected:
SetUp()673 virtual void SetUp() {
674 VintfObjectTestBase::SetUp();
675 }
TearDown()676 virtual void TearDown() {
677 Mock::VerifyAndClear(&runtimeInfoFactory());
678 Mock::VerifyAndClear(runtimeInfoFactory().getInfo().get());
679 }
680 };
681
TEST_F(VintfObjectRuntimeInfoTest,GetRuntimeInfo)682 TEST_F(VintfObjectRuntimeInfoTest, GetRuntimeInfo) {
683 setupMockFetcher(vendorManifestKernelFcm, "", "", "");
684 expectVendorManifest();
685 InSequence s;
686
687 EXPECT_CALL(*runtimeInfoFactory().getInfo(),
688 fetchAllInformation(RuntimeInfo::FetchFlag::CPU_VERSION));
689 EXPECT_CALL(*runtimeInfoFactory().getInfo(), fetchAllInformation(RuntimeInfo::FetchFlag::NONE));
690 EXPECT_CALL(
691 *runtimeInfoFactory().getInfo(),
692 fetchAllInformation(RuntimeInfo::FetchFlag::ALL & ~RuntimeInfo::FetchFlag::CPU_VERSION));
693 EXPECT_CALL(*runtimeInfoFactory().getInfo(), fetchAllInformation(RuntimeInfo::FetchFlag::NONE));
694
695 EXPECT_NE(nullptr, vintfObject->getRuntimeInfo(
696 RuntimeInfo::FetchFlag::CPU_VERSION));
697 EXPECT_NE(nullptr, vintfObject->getRuntimeInfo(
698 RuntimeInfo::FetchFlag::CPU_VERSION));
699 EXPECT_NE(nullptr, vintfObject->getRuntimeInfo(
700 RuntimeInfo::FetchFlag::ALL));
701 EXPECT_NE(nullptr, vintfObject->getRuntimeInfo(
702 RuntimeInfo::FetchFlag::ALL));
703 }
704
TEST_F(VintfObjectRuntimeInfoTest,GetRuntimeInfoHost)705 TEST_F(VintfObjectRuntimeInfoTest, GetRuntimeInfoHost) {
706 runtimeInfoFactory().getInfo()->failNextFetch();
707 EXPECT_EQ(nullptr, vintfObject->getRuntimeInfo(RuntimeInfo::FetchFlag::ALL));
708 }
709
710 class VintfObjectKernelFcmTest : public VintfObjectTestBase,
711 public WithParamInterface<std::tuple<bool, bool>> {
712 protected:
SetUp()713 virtual void SetUp() {
714 VintfObjectTestBase::SetUp();
715 auto [isHost, hasDeviceManifest] = GetParam();
716 if (hasDeviceManifest) {
717 setupMockFetcher(vendorManifestKernelFcm, "", "", "");
718 expectVendorManifest();
719 }
720
721 if (isHost) {
722 runtimeInfoFactory().getInfo()->failNextFetch();
723 } else {
724 runtimeInfoFactory().getInfo()->setNextFetchKernelLevel(Level{8});
725 }
726 }
727
expectedKernelFcm()728 Level expectedKernelFcm() {
729 auto [isHost, hasDeviceManifest] = GetParam();
730 return !isHost || hasDeviceManifest ? Level{8} : Level::UNSPECIFIED;
731 }
732 };
733
TEST_P(VintfObjectKernelFcmTest,GetKernelLevel)734 TEST_P(VintfObjectKernelFcmTest, GetKernelLevel) {
735 ASSERT_EQ(expectedKernelFcm(), vintfObject->getKernelLevel());
736 }
737
738 INSTANTIATE_TEST_SUITE_P(KernelFcm, VintfObjectKernelFcmTest,
739 ::testing::Combine(::testing::Bool(), ::testing::Bool()));
740
741 // Test fixture that provides incompatible metadata from the mock device.
742 class VintfObjectTest : public VintfObjectTestBase {
743 protected:
SetUp()744 virtual void SetUp() {
745 VintfObjectTestBase::SetUp();
746 useEmptyFileSystem();
747 }
748 };
749
750 // Test framework compatibility matrix is combined at runtime
TEST_F(VintfObjectTest,FrameworkCompatibilityMatrixCombine)751 TEST_F(VintfObjectTest, FrameworkCompatibilityMatrixCombine) {
752 EXPECT_CALL(fetcher(), listFiles(StrEq(kSystemVintfDir), _, _))
753 .WillOnce(Invoke([](const auto&, auto* out, auto*) {
754 *out = {
755 "compatibility_matrix.1.xml",
756 "compatibility_matrix.empty.xml",
757 };
758 return ::android::OK;
759 }));
760 expectFetch(kSystemVintfDir + "compatibility_matrix.1.xml"s,
761 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\"/>");
762 expectFetch(kSystemVintfDir + "compatibility_matrix.empty.xml"s,
763 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\"/>");
764 expectFileNotExist(StrEq(kProductMatrix));
765 expectFetch(kVendorManifest, "<manifest " + kMetaVersionStr + " type=\"device\" />\n");
766 expectNeverFetch(kSystemLegacyMatrix);
767
768 EXPECT_NE(nullptr, vintfObject->getFrameworkCompatibilityMatrix());
769 }
770
771 // Test product compatibility matrix is fetched
TEST_F(VintfObjectTest,ProductCompatibilityMatrix)772 TEST_F(VintfObjectTest, ProductCompatibilityMatrix) {
773 EXPECT_CALL(fetcher(), listFiles(StrEq(kSystemVintfDir), _, _))
774 .WillOnce(Invoke([](const auto&, auto* out, auto*) {
775 *out = {
776 "compatibility_matrix.1.xml",
777 "compatibility_matrix.empty.xml",
778 };
779 return ::android::OK;
780 }));
781 EXPECT_CALL(fetcher(), listFiles(StrEq(kProductVintfDir), _, _))
782 .WillRepeatedly(Invoke([](const auto&, auto* out, auto*) {
783 *out = {android::base::Basename(kProductMatrix)};
784 return ::android::OK;
785 }));
786 expectFetch(kSystemVintfDir + "compatibility_matrix.1.xml"s,
787 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\"/>");
788 expectFetch(kSystemVintfDir + "compatibility_matrix.empty.xml"s,
789 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\"/>");
790 expectFetch(kProductMatrix,
791 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
792 " <hal format=\"hidl\" optional=\"true\">\n"
793 " <name>android.hardware.foo</name>\n"
794 " <version>1.0</version>\n"
795 " <interface>\n"
796 " <name>IFoo</name>\n"
797 " <instance>default</instance>\n"
798 " </interface>\n"
799 " </hal>\n"
800 "</compatibility-matrix>\n");
801 expectFetch(kVendorManifest, "<manifest " + kMetaVersionStr + " type=\"device\" />\n");
802 expectNeverFetch(kSystemLegacyMatrix);
803
804 auto fcm = vintfObject->getFrameworkCompatibilityMatrix();
805 ASSERT_NE(nullptr, fcm);
806
807 FqInstance expectInstance;
808 EXPECT_TRUE(expectInstance.setTo("[email protected]::IFoo/default"));
809 bool found = false;
810 fcm->forEachHidlInstance([&found, &expectInstance](const auto& matrixInstance) {
811 found |= matrixInstance.isSatisfiedBy(expectInstance);
812 return !found; // continue if not found
813 });
814 EXPECT_TRUE(found) << "[email protected]::IFoo/default should be found in matrix:\n"
815 << toXml(*fcm);
816 }
817
818 const std::string vendorEtcManifest =
819 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
820 " <hal format=\"hidl\">\n"
821 " <name>android.hardware.foo</name>\n"
822 " <transport>hwbinder</transport>\n"
823 " <version>1.0</version>\n"
824 " <version>2.0</version>\n"
825 " <interface>\n"
826 " <name>IVendorEtc</name>\n"
827 " <instance>default</instance>\n"
828 " </interface>\n"
829 " </hal>\n"
830 "</manifest>\n";
831
832 const std::string vendorManifest =
833 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
834 " <hal format=\"hidl\">\n"
835 " <name>android.hardware.foo</name>\n"
836 " <transport>hwbinder</transport>\n"
837 " <version>1.0</version>\n"
838 " <interface>\n"
839 " <name>IVendor</name>\n"
840 " <instance>default</instance>\n"
841 " </interface>\n"
842 " </hal>\n"
843 "</manifest>\n";
844
845 const std::string odmProductManifest =
846 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
847 " <hal format=\"hidl\" override=\"true\">\n"
848 " <name>android.hardware.foo</name>\n"
849 " <transport>hwbinder</transport>\n"
850 " <version>1.1</version>\n"
851 " <interface>\n"
852 " <name>IOdmProduct</name>\n"
853 " <instance>default</instance>\n"
854 " </interface>\n"
855 " </hal>\n"
856 "</manifest>\n";
857
858 const std::string odmManifest =
859 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
860 " <hal format=\"hidl\" override=\"true\">\n"
861 " <name>android.hardware.foo</name>\n"
862 " <transport>hwbinder</transport>\n"
863 " <version>1.1</version>\n"
864 " <interface>\n"
865 " <name>IOdm</name>\n"
866 " <instance>default</instance>\n"
867 " </interface>\n"
868 " </hal>\n"
869 "</manifest>\n";
870
containsVendorManifest(const std::shared_ptr<const HalManifest> & p)871 bool containsVendorManifest(const std::shared_ptr<const HalManifest>& p) {
872 return !p->getHidlInstances("android.hardware.foo", {1, 0}, "IVendor").empty();
873 }
874
containsVendorEtcManifest(const std::shared_ptr<const HalManifest> & p)875 bool containsVendorEtcManifest(const std::shared_ptr<const HalManifest>& p) {
876 return !p->getHidlInstances("android.hardware.foo", {2, 0}, "IVendorEtc").empty();
877 }
878
vendorEtcManifestOverridden(const std::shared_ptr<const HalManifest> & p)879 bool vendorEtcManifestOverridden(const std::shared_ptr<const HalManifest>& p) {
880 return p->getHidlInstances("android.hardware.foo", {1, 0}, "IVendorEtc").empty();
881 }
882
containsOdmManifest(const std::shared_ptr<const HalManifest> & p)883 bool containsOdmManifest(const std::shared_ptr<const HalManifest>& p) {
884 return !p->getHidlInstances("android.hardware.foo", {1, 1}, "IOdm").empty();
885 }
886
containsOdmProductManifest(const std::shared_ptr<const HalManifest> & p)887 bool containsOdmProductManifest(const std::shared_ptr<const HalManifest>& p) {
888 return !p->getHidlInstances("android.hardware.foo", {1, 1}, "IOdmProduct").empty();
889 }
890
containsApexManifest(const std::shared_ptr<const HalManifest> & p)891 bool containsApexManifest(const std::shared_ptr<const HalManifest>& p) {
892 return !p->getAidlInstances(apexHalName, "IApex").empty();
893 }
894
895 class DeviceManifestTest : public VintfObjectTestBase {
896 protected:
expectApex(const std::string & halManifest=apexHalManifest)897 void expectApex(const std::string& halManifest = apexHalManifest) {
898 expectFetchRepeatedly(kApexInfoFile, R"(<apex-info-list>
899 <apex-info moduleName="com.test"
900 partition="VENDOR" isActive="true"/>
901 <apex-info moduleName="com.novintf"
902 partition="VENDOR" isActive="true"/>
903 </apex-info-list>)");
904 EXPECT_CALL(fetcher(), modifiedTime(kApexInfoFile, _, _))
905 .WillOnce(Invoke([](auto, timespec* out, auto){
906 *out = {};
907 return ::android::OK;
908 }))
909 // Update once, but no more.
910 .WillRepeatedly(Invoke([](auto, timespec* out, auto){
911 *out = {1,};
912 return ::android::OK;
913 }))
914 ;
915 ON_CALL(fetcher(), listFiles("/apex/com.test/etc/vintf/", _, _))
916 .WillByDefault(Invoke([](auto, std::vector<std::string>* out, auto){
917 *out = {"manifest.xml"};
918 return ::android::OK;
919 }));
920 expectFetchRepeatedly("/apex/com.test/etc/vintf/manifest.xml", halManifest);
921 }
922
923 // Expect that /vendor/etc/vintf/manifest.xml is fetched.
expectVendorManifest()924 void expectVendorManifest() {
925 expectFetchRepeatedly(kVendorManifest, vendorEtcManifest);
926 }
927 // /vendor/etc/vintf/manifest.xml does not exist.
noVendorManifest()928 void noVendorManifest() { expectFileNotExist(StrEq(kVendorManifest)); }
929 // Expect some ODM manifest is fetched.
expectOdmManifest()930 void expectOdmManifest() {
931 expectFetchRepeatedly(kOdmManifest, odmManifest);
932 }
noOdmManifest()933 void noOdmManifest() { expectFileNotExist(StartsWith("/odm/")); }
get()934 std::shared_ptr<const HalManifest> get() {
935 return vintfObject->getDeviceHalManifest();
936 }
937 };
938
939 // Test /vendor/etc/vintf/manifest.xml + ODM manifest
TEST_F(DeviceManifestTest,Combine1)940 TEST_F(DeviceManifestTest, Combine1) {
941 expectVendorManifest();
942 expectOdmManifest();
943 noApex();
944 auto p = get();
945 ASSERT_NE(nullptr, p);
946 EXPECT_TRUE(containsVendorEtcManifest(p));
947 EXPECT_TRUE(vendorEtcManifestOverridden(p));
948 EXPECT_TRUE(containsOdmManifest(p));
949 EXPECT_FALSE(containsVendorManifest(p));
950 }
951
952 // Test /vendor/etc/vintf/manifest.xml
TEST_F(DeviceManifestTest,Combine2)953 TEST_F(DeviceManifestTest, Combine2) {
954 expectVendorManifest();
955 noOdmManifest();
956 noApex();
957 auto p = get();
958 ASSERT_NE(nullptr, p);
959 EXPECT_TRUE(containsVendorEtcManifest(p));
960 EXPECT_FALSE(vendorEtcManifestOverridden(p));
961 EXPECT_FALSE(containsOdmManifest(p));
962 EXPECT_FALSE(containsVendorManifest(p));
963 }
964
965 // Test ODM manifest
TEST_F(DeviceManifestTest,Combine3)966 TEST_F(DeviceManifestTest, Combine3) {
967 noVendorManifest();
968 expectOdmManifest();
969 noApex();
970 auto p = get();
971 ASSERT_NE(nullptr, p);
972 EXPECT_FALSE(containsVendorEtcManifest(p));
973 EXPECT_TRUE(vendorEtcManifestOverridden(p));
974 EXPECT_TRUE(containsOdmManifest(p));
975 EXPECT_FALSE(containsVendorManifest(p));
976 }
977
978 // Test /vendor/manifest.xml
TEST_F(DeviceManifestTest,Combine4)979 TEST_F(DeviceManifestTest, Combine4) {
980 noVendorManifest();
981 noOdmManifest();
982 noApex();
983 expectFetch(kVendorLegacyManifest, vendorManifest);
984 auto p = get();
985 ASSERT_NE(nullptr, p);
986 EXPECT_FALSE(containsVendorEtcManifest(p));
987 EXPECT_TRUE(vendorEtcManifestOverridden(p));
988 EXPECT_FALSE(containsOdmManifest(p));
989 EXPECT_TRUE(containsVendorManifest(p));
990 }
991
992 // Run the same tests as above (Combine1,2,3,4) including APEX data.
993
994 // Test /vendor/etc/vintf/manifest.xml + ODM manifest + APEX
TEST_F(DeviceManifestTest,Combine5)995 TEST_F(DeviceManifestTest, Combine5) {
996 expectVendorManifest();
997 expectOdmManifest();
998 expectApex();
999 auto p = get();
1000 ASSERT_NE(nullptr, p);
1001 EXPECT_TRUE(containsVendorEtcManifest(p));
1002 EXPECT_TRUE(vendorEtcManifestOverridden(p));
1003 EXPECT_TRUE(containsOdmManifest(p));
1004 EXPECT_FALSE(containsVendorManifest(p));
1005 EXPECT_TRUE(containsApexManifest(p));
1006
1007 // Second call should create new maninfest containing APEX info.
1008 auto p2 = get();
1009 ASSERT_NE(nullptr, p2);
1010 ASSERT_NE(p, p2);
1011
1012 // Third call expect no update and no call to DeviceVintfDirs.
1013 auto p3 = get();
1014 ASSERT_EQ(p2,p3);
1015 }
1016
1017 // Tests for valid/invalid APEX defined HAL
1018 // For a HAL to be defined within an APEX it must not have
1019 // the update-via-apex attribute defined in the HAL manifest
1020
1021 // Valid APEX HAL definition
TEST_F(DeviceManifestTest,ValidApexHal)1022 TEST_F(DeviceManifestTest, ValidApexHal) {
1023 expectVendorManifest();
1024 noOdmManifest();
1025 expectApex();
1026 auto p = get();
1027 ASSERT_NE(nullptr, p);
1028 // HALs defined in APEX should set updatable-via-apex
1029 bool found = false;
1030 p->forEachInstance([&found](const ManifestInstance& instance){
1031 if (instance.package() == apexHalName) {
1032 std::optional<std::string> apexName = "com.test";
1033 EXPECT_EQ(apexName, instance.updatableViaApex());
1034 found = true;
1035 }
1036 return true;
1037 });
1038 ASSERT_TRUE(found) << "should found android.apex.foo";
1039 }
1040 // Invalid APEX HAL definition
TEST_F(DeviceManifestTest,InvalidApexHal)1041 TEST_F(DeviceManifestTest, InvalidApexHal) {
1042 const std::string apexInvalidManifest =
1043 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
1044 " <hal format=\"aidl\" updatable-via-apex=\"com.android.apex.foo\">\n"
1045 " <name>android.apex.foo</name>\n"
1046 " <fqname>IApex/default</fqname>\n"
1047 " </hal>\n"
1048 "</manifest>\n";
1049 expectVendorManifest();
1050 noOdmManifest();
1051 expectApex(apexInvalidManifest);
1052 auto p = get();
1053 ASSERT_EQ(nullptr, p);
1054 }
1055
1056 struct VendorApexTest : DeviceManifestTest {
SetUpandroid::vintf::testing::VendorApexTest1057 virtual void SetUp() override {
1058 // Use actual Apex implementation
1059 vintfObject = VintfObject::Builder()
1060 .setFileSystem(std::make_unique<NiceMock<MockFileSystem>>())
1061 .setRuntimeInfoFactory(std::make_unique<NiceMock<MockRuntimeInfoFactory>>(
1062 std::make_shared<NiceMock<MockRuntimeInfo>>()))
1063 .setPropertyFetcher(std::make_unique<NiceMock<MockPropertyFetcher>>())
1064 .build();
1065 expectVendorManifest();
1066 noOdmManifest();
1067
1068 EXPECT_CALL(fetcher(), listFiles(_, _, _))
1069 .WillRepeatedly(Invoke([](const auto&, auto*, auto*) {
1070 return ::android::OK;
1071 }));
1072 EXPECT_CALL(fetcher(), modifiedTime(_, _, _))
1073 .WillRepeatedly(Invoke([](const auto&, auto*, auto*) {
1074 return ::android::OK;
1075 }));
1076 }
1077 };
1078
TEST_F(VendorApexTest,ReadBootstrapApexBeforeApexReady)1079 TEST_F(VendorApexTest, ReadBootstrapApexBeforeApexReady) {
1080 // When APEXes are not ready,
1081 ON_CALL(propertyFetcher(), getBoolProperty("apex.all.ready", _))
1082 .WillByDefault(Return(false));
1083 // Should read bootstrap APEXes from /bootstrap-apex
1084 EXPECT_CALL(fetcher(), fetch(kBootstrapApexInfoFile, _))
1085 .WillOnce(Invoke([](const auto&, auto& out) {
1086 out = R"(<?xml version="1.0" encoding="utf-8"?>
1087 <apex-info-list>
1088 <apex-info moduleName="com.vendor.foo"
1089 partition="VENDOR"
1090 isActive="true" />
1091 </apex-info-list>)";
1092 return ::android::OK;
1093 }));
1094 // ... and read VINTF directory in it.
1095 EXPECT_CALL(fetcher(), listFiles("/bootstrap-apex/com.vendor.foo/etc/vintf/", _, _))
1096 .WillOnce(Invoke([](const auto&, auto*, auto*) {
1097 return ::android::OK;
1098 }));
1099 auto p = get();
1100 (void) p;
1101 }
1102
TEST_F(VendorApexTest,OkayIfBootstrapApexDirDoesntExist)1103 TEST_F(VendorApexTest, OkayIfBootstrapApexDirDoesntExist) {
1104 // When APEXes are not ready,
1105 ON_CALL(propertyFetcher(), getBoolProperty("apex.all.ready", _))
1106 .WillByDefault(Return(false));
1107 // Should try to read bootstrap APEXes from /bootstrap-apex
1108 EXPECT_CALL(fetcher(), fetch(kBootstrapApexInfoFile, _))
1109 .WillOnce(Invoke([](const auto&, auto&) {
1110 return NAME_NOT_FOUND;
1111 }));
1112 // Doesn't fallback to normal APEX if APEXes are not ready.
1113 EXPECT_CALL(fetcher(), fetch(kApexInfoFile, _)).Times(0);
1114 auto p = get();
1115 (void) p;
1116 }
1117
TEST_F(VendorApexTest,DoNotReadBootstrapApexWhenApexesAreReady)1118 TEST_F(VendorApexTest, DoNotReadBootstrapApexWhenApexesAreReady) {
1119 // When APEXes are ready,
1120 ON_CALL(propertyFetcher(), getBoolProperty("apex.all.ready", _))
1121 .WillByDefault(Return(true));
1122 // Should NOT read bootstrap APEXes
1123 EXPECT_CALL(fetcher(), fetch(kBootstrapApexInfoFile, _))
1124 .Times(0);
1125 // Instead, read /apex/apex-info-list.xml
1126 EXPECT_CALL(fetcher(), fetch(kApexInfoFile, _));
1127 auto p = get();
1128 (void) p;
1129 }
1130
1131 class OdmManifestTest : public VintfObjectTestBase,
1132 public ::testing::WithParamInterface<const char*> {
1133 protected:
SetUp()1134 virtual void SetUp() override {
1135 VintfObjectTestBase::SetUp();
1136 // Assume /vendor/etc/vintf/manifest.xml does not exist to simplify
1137 // testing logic.
1138 expectFileNotExist(StrEq(kVendorManifest));
1139 // Expect that the legacy /vendor/manifest.xml is never fetched.
1140 expectNeverFetch(kVendorLegacyManifest);
1141 // Assume no files exist under /odm/ unless otherwise specified.
1142 expectFileNotExist(StartsWith("/odm/"));
1143 noApex();
1144 // set SKU
1145 productModel = GetParam();
1146 ON_CALL(propertyFetcher(), getProperty("ro.boot.product.hardware.sku", _))
1147 .WillByDefault(Return(productModel));
1148 }
get()1149 std::shared_ptr<const HalManifest> get() {
1150 return vintfObject->getDeviceHalManifest();
1151 }
1152 std::string productModel;
1153 };
1154
TEST_P(OdmManifestTest,OdmProductManifest)1155 TEST_P(OdmManifestTest, OdmProductManifest) {
1156 if (productModel.empty()) return;
1157 expectFetch(kOdmVintfDir + "manifest_"s + productModel + ".xml", odmProductManifest);
1158 // /odm/etc/vintf/manifest.xml should not be fetched when the product variant exists.
1159 expectNeverFetch(kOdmManifest);
1160 auto p = get();
1161 ASSERT_NE(nullptr, p);
1162 EXPECT_TRUE(containsOdmProductManifest(p));
1163 }
1164
TEST_P(OdmManifestTest,OdmManifest)1165 TEST_P(OdmManifestTest, OdmManifest) {
1166 expectFetch(kOdmManifest, odmManifest);
1167 auto p = get();
1168 ASSERT_NE(nullptr, p);
1169 EXPECT_TRUE(containsOdmManifest(p));
1170 }
1171
TEST_P(OdmManifestTest,OdmLegacyProductManifest)1172 TEST_P(OdmManifestTest, OdmLegacyProductManifest) {
1173 if (productModel.empty()) return;
1174 expectFetch(kOdmLegacyVintfDir + "manifest_"s + productModel + ".xml", odmProductManifest);
1175 // /odm/manifest.xml should not be fetched when the product variant exists.
1176 expectNeverFetch(kOdmLegacyManifest);
1177 auto p = get();
1178 ASSERT_NE(nullptr, p);
1179 EXPECT_TRUE(containsOdmProductManifest(p));
1180 }
1181
TEST_P(OdmManifestTest,OdmLegacyManifest)1182 TEST_P(OdmManifestTest, OdmLegacyManifest) {
1183 expectFetch(kOdmLegacyManifest, odmManifest);
1184 auto p = get();
1185 ASSERT_NE(nullptr, p);
1186 EXPECT_TRUE(containsOdmManifest(p));
1187 }
1188
1189 INSTANTIATE_TEST_SUITE_P(OdmManifest, OdmManifestTest, ::testing::Values("", "fake_sku"));
1190
1191 struct ManifestOverrideTest : public VintfObjectTestBase {
1192 protected:
SetUpandroid::vintf::testing::ManifestOverrideTest1193 void SetUp() override {
1194 VintfObjectTestBase::SetUp();
1195 ON_CALL(fetcher(), fetch(_, _))
1196 .WillByDefault(Invoke([&](auto path, std::string& out) {
1197 auto dirIt = dirs_.find(base::Dirname(path) + "/");
1198 if (dirIt != dirs_.end()) {
1199 auto fileIt = dirIt->second.find(base::Basename(path));
1200 if (fileIt != dirIt->second.end()) {
1201 out = fileIt->second;
1202 return OK;
1203 }
1204 }
1205 return NAME_NOT_FOUND;
1206 }));
1207 ON_CALL(fetcher(), listFiles(_, _, _))
1208 .WillByDefault(Invoke([&](auto path, std::vector<std::string>* out, auto) {
1209 auto dirIt = dirs_.find(path);
1210 if (dirIt != dirs_.end()) {
1211 for (const auto& [f, _]: dirIt->second) {
1212 out->push_back(f);
1213 }
1214 return OK;
1215 }
1216 return NAME_NOT_FOUND;
1217 }));
1218 }
expectandroid::vintf::testing::ManifestOverrideTest1219 void expect(std::string path, std::string content) {
1220 dirs_[base::Dirname(path) + "/"][base::Basename(path)] = content;
1221 }
1222 private:
1223 std::map<std::string, std::map<std::string, std::string>> dirs_;
1224 };
1225
TEST_F(ManifestOverrideTest,NoOverrideForVendor)1226 TEST_F(ManifestOverrideTest, NoOverrideForVendor) {
1227 expect(kVendorManifest,
1228 "<manifest " + kMetaVersionStr + " type=\"device\">"
1229 " <hal format=\"aidl\">"
1230 " <name>android.hardware.foo</name>"
1231 " <fqname>IFoo/default</fqname>"
1232 " </hal>"
1233 "</manifest>");
1234 auto p = vintfObject->getDeviceHalManifest();
1235 ASSERT_NE(nullptr, p);
1236 ASSERT_EQ(p->getAidlInstances("android.hardware.foo", "IFoo"),
1237 std::set<std::string>({"default"}));
1238 }
1239
TEST_F(ManifestOverrideTest,OdmOverridesVendor)1240 TEST_F(ManifestOverrideTest, OdmOverridesVendor) {
1241 expect(kVendorManifest, "<manifest " + kMetaVersionStr + " type=\"device\">"
1242 " <hal format=\"aidl\">"
1243 " <name>android.hardware.foo</name>"
1244 " <fqname>IFoo/default</fqname>"
1245 " </hal>"
1246 "</manifest>");
1247 // ODM overrides(disables) HAL in Vendor
1248 expect(kOdmManifest, "<manifest " + kMetaVersionStr + " type=\"device\">"
1249 " <hal override=\"true\" format=\"aidl\">"
1250 " <name>android.hardware.foo</name>"
1251 " </hal>"
1252 "</manifest>");
1253 auto p = vintfObject->getDeviceHalManifest();
1254 ASSERT_NE(nullptr, p);
1255 ASSERT_EQ(p->getAidlInstances("android.hardware.foo", "IFoo"), std::set<std::string>({}));
1256 }
1257
TEST_F(ManifestOverrideTest,NoOverrideForVendorApex)1258 TEST_F(ManifestOverrideTest, NoOverrideForVendorApex) {
1259 expect(kVendorManifest,
1260 "<manifest " + kMetaVersionStr + " type=\"device\" />");
1261 expect(kApexInfoFile,
1262 R"(<apex-info-list>
1263 <apex-info
1264 moduleName="com.android.foo"
1265 partition="VENDOR"
1266 isActive="true"/>
1267 </apex-info-list>)");
1268 expect("/apex/com.android.foo/etc/vintf/foo.xml",
1269 "<manifest " + kMetaVersionStr + "type=\"device\">"
1270 " <hal format=\"aidl\">"
1271 " <name>android.hardware.foo</name>"
1272 " <fqname>IFoo/default</fqname>"
1273 " </hal>"
1274 "</manifest>");
1275 auto p = vintfObject->getDeviceHalManifest();
1276 ASSERT_NE(nullptr, p);
1277 ASSERT_EQ(p->getAidlInstances("android.hardware.foo", "IFoo"),
1278 std::set<std::string>({"default"}));
1279 }
1280
TEST_F(ManifestOverrideTest,OdmOverridesVendorApex)1281 TEST_F(ManifestOverrideTest, OdmOverridesVendorApex) {
1282 expect(kVendorManifest,
1283 "<manifest " + kMetaVersionStr + " type=\"device\" />");
1284 expect(kApexInfoFile,
1285 R"(<apex-info-list>
1286 <apex-info
1287 moduleName="com.android.foo"
1288 partition="VENDOR"
1289 isActive="true"/>
1290 </apex-info-list>)");
1291 expect("/apex/com.android.foo/etc/vintf/foo.xml",
1292 "<manifest " + kMetaVersionStr + "type=\"device\">"
1293 " <hal format=\"aidl\">"
1294 " <name>android.hardware.foo</name>"
1295 " <fqname>IFoo/default</fqname>"
1296 " </hal>"
1297 "</manifest>");
1298 // ODM overrides(disables) HAL in Vendor APEX
1299 expect(kOdmManifest, "<manifest " + kMetaVersionStr + " type=\"device\">"
1300 " <hal override=\"true\" format=\"aidl\">"
1301 " <name>android.hardware.foo</name>"
1302 " </hal>"
1303 "</manifest>");
1304 auto p = vintfObject->getDeviceHalManifest();
1305 ASSERT_NE(nullptr, p);
1306 ASSERT_EQ(p->getAidlInstances("android.hardware.foo", "IFoo"),
1307 std::set<std::string>({}));
1308 }
1309
1310 struct CheckedFqInstance : FqInstance {
CheckedFqInstanceandroid::vintf::testing::CheckedFqInstance1311 CheckedFqInstance(const char* s) : CheckedFqInstance(std::string(s)) {}
CheckedFqInstanceandroid::vintf::testing::CheckedFqInstance1312 CheckedFqInstance(const std::string& s) { CHECK(setTo(s)) << s; }
1313
getVersionandroid::vintf::testing::CheckedFqInstance1314 Version getVersion() const { return FqInstance::getVersion(); }
1315 };
1316
1317 class DeprecateTest : public VintfObjectTestBase {
1318 protected:
SetUp()1319 virtual void SetUp() override {
1320 VintfObjectTestBase::SetUp();
1321 useEmptyFileSystem();
1322 EXPECT_CALL(fetcher(), listFiles(StrEq(kSystemVintfDir), _, _))
1323 .WillRepeatedly(Invoke([](const auto&, auto* out, auto*) {
1324 *out = {
1325 "compatibility_matrix.1.xml",
1326 "compatibility_matrix.2.xml",
1327 };
1328 return ::android::OK;
1329 }));
1330 expectFetchRepeatedly(kSystemVintfDir + "compatibility_matrix.1.xml"s, systemMatrixLevel1);
1331 expectFetchRepeatedly(kSystemVintfDir + "compatibility_matrix.2.xml"s, systemMatrixLevel2);
1332 EXPECT_CALL(fetcher(), listFiles(StrEq(kProductVintfDir), _, _))
1333 .WillRepeatedly(Invoke([](const auto&, auto* out, auto*) {
1334 *out = {
1335 "compatibility_matrix.1.xml",
1336 "compatibility_matrix.2.xml",
1337 };
1338 return ::android::OK;
1339 }));
1340 expectFetchRepeatedly(kProductVintfDir + "compatibility_matrix.1.xml"s,
1341 productMatrixLevel1);
1342 expectFetchRepeatedly(kProductVintfDir + "compatibility_matrix.2.xml"s,
1343 productMatrixLevel2);
1344 expectFileNotExist(StrEq(kProductMatrix));
1345 expectNeverFetch(kSystemLegacyMatrix);
1346
1347 expectFileNotExist(StartsWith("/odm/"));
1348 }
1349 };
1350
1351 // clang-format on
1352
aidlFqInstance(const std::string & package,size_t version,const std::string & interface,const std::string & instance)1353 FqInstance aidlFqInstance(const std::string& package, size_t version, const std::string& interface,
1354 const std::string& instance) {
1355 auto ret = FqInstance::from(package, kFakeAidlMajorVersion, version, interface, instance);
1356 EXPECT_TRUE(ret.has_value());
1357 return ret.value_or(FqInstance());
1358 }
1359
1360 // clang-format off
1361
TEST_F(DeprecateTest,CheckNoDeprecate)1362 TEST_F(DeprecateTest, CheckNoDeprecate) {
1363 expectVendorManifest(Level{2}, {
1364 "[email protected]::IMinor/default",
1365 "[email protected]::IMajor/default",
1366 "[email protected]::IMinor/default",
1367 }, {
1368 aidlFqInstance("android.hardware.minor", 102, "IMinor", "default"),
1369 });
1370 std::string error;
1371 EXPECT_EQ(NO_DEPRECATED_HALS, vintfObject->checkDeprecation({}, &error)) << error;
1372 }
1373
TEST_F(DeprecateTest,CheckRemovedSystem)1374 TEST_F(DeprecateTest, CheckRemovedSystem) {
1375 expectVendorManifest(Level{2}, {
1376 "[email protected]::IRemoved/default",
1377 "[email protected]::IMinor/default",
1378 "[email protected]::IMajor/default",
1379 });
1380 std::string error;
1381 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1382 << "[email protected] should be deprecated. " << error;
1383 }
1384
TEST_F(DeprecateTest,CheckRemovedVersionAccess)1385 TEST_F(DeprecateTest, CheckRemovedVersionAccess) {
1386 expectVendorManifest(Level{2}, {}, {aidlFqInstance("android.hardware.vm.removed", 2, "IRemoved",
1387 "default")}, ExclusiveTo::VM);
1388 std::string error;
1389 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1390 << "removed@2 should be deprecated. " << error;
1391 EXPECT_IN("android.hardware.vm.removed", error);
1392 EXPECT_IN("is deprecated; requires at least", error);
1393 }
1394
TEST_F(DeprecateTest,CheckOkVersionSystemAccess)1395 TEST_F(DeprecateTest, CheckOkVersionSystemAccess) {
1396 expectVendorManifest(Level{2}, {}, {aidlFqInstance("android.hardware.vm.removed", 3, "IRemoved",
1397 "default")}, ExclusiveTo::VM);
1398 std::string error;
1399 EXPECT_EQ(NO_DEPRECATED_HALS, vintfObject->checkDeprecation({}, &error))
1400 << "V3 should be allowed at level 2" << error;
1401 }
1402
TEST_F(DeprecateTest,CheckRemovedSystemAccessWrong)1403 TEST_F(DeprecateTest, CheckRemovedSystemAccessWrong) {
1404 expectVendorManifest(Level{2}, {}, {aidlFqInstance("android.hardware.vm.removed", 2, "IRemoved",
1405 "default")}, ExclusiveTo::EMPTY);
1406 std::string error;
1407 EXPECT_EQ(NO_DEPRECATED_HALS, vintfObject->checkDeprecation({}, &error))
1408 << "There is no entry for this HAL with ExclusiveTo::EMPTY so it "
1409 << "should not show as deprecated." << error;
1410 }
1411
TEST_F(DeprecateTest,CheckRemovedSystemAidl)1412 TEST_F(DeprecateTest, CheckRemovedSystemAidl) {
1413 expectVendorManifest(Level{2}, {}, {
1414 aidlFqInstance("android.hardware.removed", 101, "IRemoved", "default"),
1415 });
1416 std::string error;
1417 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1418 << "removed@101 should be deprecated. " << error;
1419 }
1420
TEST_F(DeprecateTest,CheckRemovedProduct)1421 TEST_F(DeprecateTest, CheckRemovedProduct) {
1422 expectVendorManifest(Level{2}, {
1423 "[email protected]::IRemoved/default",
1424 "[email protected]::IMinor/default",
1425 });
1426 std::string error;
1427 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1428 << "[email protected] should be deprecated. " << error;
1429 }
1430
TEST_F(DeprecateTest,CheckMinorSystem)1431 TEST_F(DeprecateTest, CheckMinorSystem) {
1432 expectVendorManifest(Level{2}, {
1433 "[email protected]::IMinor/default",
1434 "[email protected]::IMajor/default",
1435 });
1436 std::string error;
1437 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1438 << "[email protected] should be deprecated. " << error;
1439 }
1440
TEST_F(DeprecateTest,CheckMinorSystemAidl)1441 TEST_F(DeprecateTest, CheckMinorSystemAidl) {
1442 expectVendorManifest(Level{2}, {}, {
1443 aidlFqInstance("android.hardware.minor", 101, "IMinor", "default"),
1444 });
1445 std::string error;
1446 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1447 << "minor@101 should be deprecated. " << error;
1448 }
1449
TEST_F(DeprecateTest,CheckMinorProduct)1450 TEST_F(DeprecateTest, CheckMinorProduct) {
1451 expectVendorManifest(Level{2}, {
1452 "[email protected]::IMinor/default",
1453 });
1454 std::string error;
1455 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1456 << "[email protected] should be deprecated. " << error;
1457 }
1458
TEST_F(DeprecateTest,CheckMinorDeprecatedInstance1)1459 TEST_F(DeprecateTest, CheckMinorDeprecatedInstance1) {
1460 expectVendorManifest(Level{2}, {
1461 "[email protected]::IMinor/legacy",
1462 "[email protected]::IMinor/default",
1463 "[email protected]::IMajor/default",
1464 });
1465 std::string error;
1466 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1467 << "[email protected]::IMinor/legacy should be deprecated. " << error;
1468 }
1469
TEST_F(DeprecateTest,CheckMinorDeprecatedInstance2)1470 TEST_F(DeprecateTest, CheckMinorDeprecatedInstance2) {
1471 expectVendorManifest(Level{2}, {
1472 "[email protected]::IMinor/default",
1473 "[email protected]::IMinor/legacy",
1474 "[email protected]::IMajor/default",
1475 });
1476 std::string error;
1477 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1478 << "[email protected]::IMinor/legacy should be deprecated. " << error;
1479 }
1480
TEST_F(DeprecateTest,CheckMajor1)1481 TEST_F(DeprecateTest, CheckMajor1) {
1482 expectVendorManifest(Level{2}, {
1483 "[email protected]::IMinor/default",
1484 "[email protected]::IMajor/default",
1485 "[email protected]::IMajor/default",
1486 });
1487 std::string error;
1488 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1489 << "[email protected] should be deprecated. " << error;
1490 }
1491
TEST_F(DeprecateTest,CheckMajor2)1492 TEST_F(DeprecateTest, CheckMajor2) {
1493 expectVendorManifest(Level{2}, {
1494 "[email protected]::IMinor/default",
1495 "[email protected]::IMajor/default",
1496 });
1497 std::string error;
1498 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1499 << "[email protected] should be deprecated. " << error;
1500 }
1501
TEST_F(DeprecateTest,HidlMetadataNotDeprecate)1502 TEST_F(DeprecateTest, HidlMetadataNotDeprecate) {
1503 expectVendorManifest(Level{2}, {
1504 "[email protected]::IMajor/default",
1505 "[email protected]::IMajor/default",
1506 });
1507 std::string error;
1508 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1509 << "[email protected] should be deprecated. " << error;
1510 std::vector<HidlInterfaceMetadata> hidlMetadata{
1511 {"[email protected]::IMajor", {"[email protected]::IMajor"}},
1512 };
1513 EXPECT_EQ(NO_DEPRECATED_HALS, vintfObject->checkDeprecation(hidlMetadata, &error))
1514 << "[email protected] should not be deprecated because it extends from 2.0: " << error;
1515 }
1516
TEST_F(DeprecateTest,HidlMetadataDeprecate)1517 TEST_F(DeprecateTest, HidlMetadataDeprecate) {
1518 expectVendorManifest(Level{2}, {
1519 "[email protected]::IMajor/default",
1520 });
1521 std::string error;
1522 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1523 << "[email protected] should be deprecated. " << error;
1524 std::vector<HidlInterfaceMetadata> hidlMetadata{
1525 {"[email protected]::IMajor", {"[email protected]::IMajor"}},
1526 };
1527 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation(hidlMetadata, &error))
1528 << "[email protected] should be deprecated. " << error;
1529 }
1530
1531 class RegexInstanceDeprecateTest : public VintfObjectTestBase {
1532 protected:
SetUp()1533 virtual void SetUp() override {
1534 VintfObjectTestBase::SetUp();
1535 useEmptyFileSystem();
1536 EXPECT_CALL(fetcher(), listFiles(StrEq(kSystemVintfDir), _, _))
1537 .WillRepeatedly(Invoke([](const auto&, auto* out, auto*) {
1538 *out = {
1539 "compatibility_matrix.1.xml",
1540 "compatibility_matrix.2.xml",
1541 };
1542 return ::android::OK;
1543 }));
1544 expectFetchRepeatedly(kSystemVintfDir + "compatibility_matrix.1.xml"s,
1545 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
1546 " <hal format=\"hidl\" optional=\"true\">\n"
1547 " <name>android.hardware.minor</name>\n"
1548 " <version>1.1</version>\n"
1549 " <interface>\n"
1550 " <name>IMinor</name>\n"
1551 " <regex-instance>instance.*</regex-instance>\n"
1552 " </interface>\n"
1553 " </hal>\n"
1554 " <hal format=\"aidl\" optional=\"true\">\n"
1555 " <name>android.hardware.minor</name>\n"
1556 " <version>101</version>\n"
1557 " <interface>\n"
1558 " <name>IMinor</name>\n"
1559 " <regex-instance>instance.*</regex-instance>\n"
1560 " </interface>\n"
1561 " </hal>\n"
1562 "</compatibility-matrix>\n"
1563 );
1564 expectFetchRepeatedly(kSystemVintfDir + "compatibility_matrix.2.xml"s,
1565 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
1566 " <hal format=\"hidl\" optional=\"true\">\n"
1567 " <name>android.hardware.minor</name>\n"
1568 " <version>1.2</version>\n"
1569 " <interface>\n"
1570 " <name>IMinor</name>\n"
1571 " <regex-instance>instance.*</regex-instance>\n"
1572 " </interface>\n"
1573 " </hal>\n"
1574 " <hal format=\"aidl\" optional=\"true\">\n"
1575 " <name>android.hardware.minor</name>\n"
1576 " <version>102</version>\n"
1577 " <interface>\n"
1578 " <name>IMinor</name>\n"
1579 " <regex-instance>instance.*</regex-instance>\n"
1580 " </interface>\n"
1581 " </hal>\n"
1582 "</compatibility-matrix>\n");
1583 expectFileNotExist(StrEq(kProductMatrix));
1584 expectNeverFetch(kSystemLegacyMatrix);
1585
1586 expectFileNotExist(StartsWith("/odm/"));
1587 }
1588 };
1589
TEST_F(RegexInstanceDeprecateTest,HidlNoDeprecate)1590 TEST_F(RegexInstanceDeprecateTest, HidlNoDeprecate) {
1591 expectVendorManifest(Level{2}, {
1592 "[email protected]::IMinor/instance1",
1593 }, {
1594 aidlFqInstance("android.hardware.minor", 102, "IMinor", "instance1"),
1595 });
1596 std::string error;
1597 EXPECT_EQ(NO_DEPRECATED_HALS, vintfObject->checkDeprecation({}, &error)) << error;
1598 }
1599
TEST_F(RegexInstanceDeprecateTest,HidlDeprecate)1600 TEST_F(RegexInstanceDeprecateTest, HidlDeprecate) {
1601 expectVendorManifest(Level{2}, {
1602 "[email protected]::IMinor/instance1",
1603 "[email protected]::IMinor/instance2",
1604 }, {});
1605 std::string error;
1606 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1607 << "[email protected]::IMinor/instance2 is deprecated";
1608 }
1609
TEST_F(RegexInstanceDeprecateTest,AidlDeprecate)1610 TEST_F(RegexInstanceDeprecateTest, AidlDeprecate) {
1611 expectVendorManifest(Level{2}, {}, {
1612 aidlFqInstance("android.hardware.minor", 102, "IMinor", "instance1"),
1613 aidlFqInstance("android.hardware.minor", 101, "IMinor", "instance2"),
1614 });
1615 std::string error;
1616 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1617 << "minor@101::IMinor/instance2 is deprecated";
1618 }
1619
1620 class MultiMatrixTest : public VintfObjectTestBase {
1621 protected:
SetUp()1622 void SetUp() override {
1623 VintfObjectTestBase::SetUp();
1624 useEmptyFileSystem();
1625 }
getFileName(size_t i)1626 static std::string getFileName(size_t i) {
1627 return "compatibility_matrix." + to_string(static_cast<Level>(i)) + ".xml";
1628 }
SetUpMockSystemMatrices(const std::vector<std::string> & xmls)1629 void SetUpMockSystemMatrices(const std::vector<std::string>& xmls) {
1630 SetUpMockMatrices(kSystemVintfDir, xmls);
1631 }
SetUpMockMatrices(const std::string & dir,const std::vector<std::string> & xmls)1632 void SetUpMockMatrices(const std::string& dir, const std::vector<std::string>& xmls) {
1633 EXPECT_CALL(fetcher(), listFiles(StrEq(dir), _, _))
1634 .WillRepeatedly(Invoke([=](const auto&, auto* out, auto*) {
1635 size_t i = 1;
1636 for (const auto& content : xmls) {
1637 (void)content;
1638 out->push_back(getFileName(i));
1639 ++i;
1640 }
1641 return ::android::OK;
1642 }));
1643 size_t i = 1;
1644 for (const auto& content : xmls) {
1645 expectFetchRepeatedly(dir + getFileName(i), content);
1646 ++i;
1647 }
1648 }
expectTargetFcmVersion(size_t level)1649 void expectTargetFcmVersion(size_t level) {
1650 expectVendorManifest(Level{level}, {});
1651 }
1652 };
1653
1654 class RegexTest : public MultiMatrixTest {
1655 protected:
SetUp()1656 virtual void SetUp() {
1657 MultiMatrixTest::SetUp();
1658 SetUpMockSystemMatrices(systemMatrixRegexXmls);
1659 }
1660 };
1661
TEST_F(RegexTest,CombineLevel1)1662 TEST_F(RegexTest, CombineLevel1) {
1663 expectTargetFcmVersion(1);
1664 auto matrix = vintfObject->getFrameworkCompatibilityMatrix();
1665 ASSERT_NE(nullptr, matrix);
1666 std::string xml = toXml(*matrix);
1667
1668 EXPECT_IN(
1669 " <hal format=\"hidl\" optional=\"false\">\n"
1670 " <name>android.hardware.regex</name>\n"
1671 " <version>1.0-2</version>\n"
1672 " <version>2.0</version>\n"
1673 " <interface>\n"
1674 " <name>IRegex</name>\n"
1675 " <instance>default</instance>\n"
1676 " </interface>\n"
1677 " </hal>\n",
1678 xml);
1679 EXPECT_IN(
1680 " <hal format=\"hidl\" optional=\"false\">\n"
1681 " <name>android.hardware.regex</name>\n"
1682 " <version>1.0-1</version>\n"
1683 " <interface>\n"
1684 " <name>IRegex</name>\n"
1685 " <instance>special/1.0</instance>\n"
1686 " <regex-instance>regex/1.0/[0-9]+</regex-instance>\n"
1687 " <regex-instance>regex_common/[0-9]+</regex-instance>\n"
1688 " </interface>\n"
1689 " </hal>\n",
1690 xml);
1691 EXPECT_IN(
1692 " <hal format=\"hidl\" optional=\"true\">\n"
1693 " <name>android.hardware.regex</name>\n"
1694 " <version>1.1-2</version>\n"
1695 " <interface>\n"
1696 " <name>IRegex</name>\n"
1697 " <instance>special/1.1</instance>\n"
1698 " <regex-instance>[a-z]+_[a-z]+/[0-9]+</regex-instance>\n"
1699 " <regex-instance>regex/1.1/[0-9]+</regex-instance>\n"
1700 " </interface>\n"
1701 " </hal>\n",
1702 xml);
1703 EXPECT_IN(
1704 " <hal format=\"hidl\" optional=\"true\">\n"
1705 " <name>android.hardware.regex</name>\n"
1706 " <version>2.0</version>\n"
1707 " <interface>\n"
1708 " <name>IRegex</name>\n"
1709 " <instance>special/2.0</instance>\n"
1710 " <regex-instance>regex/2.0/[0-9]+</regex-instance>\n"
1711 " <regex-instance>regex_[a-z]+/[0-9]+</regex-instance>\n"
1712 " </interface>\n"
1713 " </hal>\n",
1714 xml);
1715 }
1716
TEST_F(RegexTest,CombineLevel2)1717 TEST_F(RegexTest, CombineLevel2) {
1718 expectTargetFcmVersion(2);
1719 auto matrix = vintfObject->getFrameworkCompatibilityMatrix();
1720 ASSERT_NE(nullptr, matrix);
1721 std::string xml = toXml(*matrix);
1722
1723 EXPECT_IN(
1724 " <hal format=\"hidl\" optional=\"false\">\n"
1725 " <name>android.hardware.regex</name>\n"
1726 " <version>1.1-2</version>\n"
1727 " <version>2.0</version>\n"
1728 " <interface>\n"
1729 " <name>IRegex</name>\n"
1730 " <instance>default</instance>\n"
1731 " </interface>\n"
1732 " </hal>\n",
1733 xml);
1734 EXPECT_IN(
1735 " <hal format=\"hidl\" optional=\"false\">\n"
1736 " <name>android.hardware.regex</name>\n"
1737 " <version>1.1-2</version>\n"
1738 " <interface>\n"
1739 " <name>IRegex</name>\n"
1740 " <instance>special/1.1</instance>\n"
1741 " <regex-instance>[a-z]+_[a-z]+/[0-9]+</regex-instance>\n"
1742 " <regex-instance>regex/1.1/[0-9]+</regex-instance>\n"
1743 " </interface>\n"
1744 " </hal>\n",
1745 xml);
1746 EXPECT_IN(
1747 " <hal format=\"hidl\" optional=\"true\">\n"
1748 " <name>android.hardware.regex</name>\n"
1749 " <version>2.0</version>\n"
1750 " <interface>\n"
1751 " <name>IRegex</name>\n"
1752 " <instance>special/2.0</instance>\n"
1753 " <regex-instance>regex/2.0/[0-9]+</regex-instance>\n"
1754 " <regex-instance>regex_[a-z]+/[0-9]+</regex-instance>\n"
1755 " </interface>\n"
1756 " </hal>\n",
1757 xml);
1758 }
1759
1760 // clang-format on
1761
TEST_F(RegexTest,DeprecateLevel2)1762 TEST_F(RegexTest, DeprecateLevel2) {
1763 std::string error;
1764 expectVendorManifest(Level{2}, {
1765 "[email protected]::IRegex/default",
1766 "[email protected]::IRegex/special/1.1",
1767 "[email protected]::IRegex/regex/1.1/1",
1768 "[email protected]::IRegex/regex_common/0",
1769 "[email protected]::IRegex/default",
1770 });
1771 EXPECT_EQ(NO_DEPRECATED_HALS, vintfObject->checkDeprecation({}, &error)) << error;
1772 }
1773
1774 class RegexTestDeprecateLevel2P : public RegexTest, public WithParamInterface<const char*> {};
TEST_P(RegexTestDeprecateLevel2P,Test)1775 TEST_P(RegexTestDeprecateLevel2P, Test) {
1776 auto deprecated = GetParam();
1777 std::string error;
1778 // 2.0/default ensures compatibility.
1779 expectVendorManifest(Level{2}, {
1780 deprecated,
1781 "[email protected]::IRegex/default",
1782 });
1783 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1784 << deprecated << " should be deprecated. " << error;
1785 }
1786
1787 INSTANTIATE_TEST_SUITE_P(RegexTest, RegexTestDeprecateLevel2P,
1788 ::testing::Values("[email protected]::IRegex/default",
1789 "[email protected]::IRegex/special/1.0",
1790 "[email protected]::IRegex/regex/1.0/1",
1791 "[email protected]::IRegex/regex_common/0",
1792 "[email protected]::IRegex/special/1.0",
1793 "[email protected]::IRegex/regex/1.0/1"));
1794
TEST_F(RegexTest,DeprecateLevel3)1795 TEST_F(RegexTest, DeprecateLevel3) {
1796 std::string error;
1797 expectVendorManifest(Level{3}, {
1798 "[email protected]::IRegex/special/2.0",
1799 "[email protected]::IRegex/regex/2.0/1",
1800 "[email protected]::IRegex/default",
1801 });
1802 EXPECT_EQ(NO_DEPRECATED_HALS, vintfObject->checkDeprecation({}, &error)) << error;
1803 }
1804
1805 class RegexTestDeprecateLevel3P : public RegexTest, public WithParamInterface<const char*> {};
TEST_P(RegexTestDeprecateLevel3P,Test)1806 TEST_P(RegexTestDeprecateLevel3P, Test) {
1807 auto deprecated = GetParam();
1808 std::string error;
1809 // 2.0/default ensures compatibility.
1810 expectVendorManifest(Level{3}, {
1811 deprecated,
1812 "[email protected]::IRegex/default",
1813 });
1814 EXPECT_EQ(DEPRECATED, vintfObject->checkDeprecation({}, &error))
1815 << deprecated << " should be deprecated.";
1816 }
1817
1818 INSTANTIATE_TEST_SUITE_P(RegexTest, RegexTestDeprecateLevel3P,
1819 ::testing::Values("[email protected]::IRegex/default",
1820 "[email protected]::IRegex/special/1.0",
1821 "[email protected]::IRegex/regex/1.0/1",
1822 "[email protected]::IRegex/regex_common/0",
1823 "[email protected]::IRegex/special/1.0",
1824 "[email protected]::IRegex/regex/1.0/1",
1825 "[email protected]::IRegex/special/1.1",
1826 "[email protected]::IRegex/regex/1.1/1",
1827 "[email protected]::IRegex/regex_common/0"));
1828
1829 // clang-format off
1830
1831 //
1832 // Set of framework matrices of different FCM version with <kernel>.
1833 //
1834
1835 #define FAKE_KERNEL(__version__, __key__, __level__) \
1836 " <kernel version=\"" __version__ "\" level=\"" #__level__ "\">\n" \
1837 " <config>\n" \
1838 " <key>CONFIG_" __key__ "</key>\n" \
1839 " <value type=\"tristate\">y</value>\n" \
1840 " </config>\n" \
1841 " </kernel>\n"
1842
1843 const static std::vector<std::string> systemMatrixKernelXmls = {
1844 // 1.xml
1845 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
1846 FAKE_KERNEL("1.0.0", "A1", 1)
1847 FAKE_KERNEL("2.0.0", "B1", 1)
1848 "</compatibility-matrix>\n",
1849 // 2.xml
1850 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
1851 FAKE_KERNEL("2.0.0", "B2", 2)
1852 FAKE_KERNEL("3.0.0", "C2", 2)
1853 FAKE_KERNEL("4.0.0", "D2", 2)
1854 "</compatibility-matrix>\n",
1855 // 3.xml
1856 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"3\">\n"
1857 FAKE_KERNEL("4.0.0", "D3", 3)
1858 FAKE_KERNEL("5.0.0", "E3", 3)
1859 "</compatibility-matrix>\n",
1860 // 4.xml
1861 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"4\">\n"
1862 FAKE_KERNEL("5.0.0", "E4", 4)
1863 FAKE_KERNEL("6.0.0", "F4", 4)
1864 "</compatibility-matrix>\n",
1865 // 5.xml
1866 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"5\">\n"
1867 FAKE_KERNEL("6.0.0", "F5", 5)
1868 FAKE_KERNEL("7.0.0", "G5", 5)
1869 "</compatibility-matrix>\n",
1870 };
1871
1872 const static std::vector<std::string> systemMatrixKernelXmlsGki = {
1873 // 5.xml
1874 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"5\">\n"
1875 FAKE_KERNEL("4.14.0", "R_4_14", 5)
1876 FAKE_KERNEL("4.19.0", "R_4_19", 5)
1877 FAKE_KERNEL("5.4.0", "R_5_4", 5)
1878 "</compatibility-matrix>\n",
1879 // 6.xml
1880 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"6\">\n"
1881 FAKE_KERNEL("4.19.0", "S_4_19", 6)
1882 FAKE_KERNEL("5.4.0", "S_5_4", 6)
1883 FAKE_KERNEL("5.10.0", "S_5_10", 6)
1884 "</compatibility-matrix>\n",
1885 // 7.xml
1886 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"7\">\n"
1887 FAKE_KERNEL("5.10.0", "T_5_10", 7)
1888 FAKE_KERNEL("5.15.0", "T_5_15", 7)
1889 "</compatibility-matrix>\n",
1890 // 8.xml
1891 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"8\">\n"
1892 FAKE_KERNEL("5.15.0", "U_5_15", 8)
1893 FAKE_KERNEL("6.1.0", "U_6_1", 8)
1894 "</compatibility-matrix>\n",
1895 };
1896
1897 class KernelTest : public MultiMatrixTest {
1898 public:
expectKernelFcmVersion(size_t targetFcm,Level kernelFcm)1899 void expectKernelFcmVersion(size_t targetFcm, Level kernelFcm) {
1900 std::string xml = "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"" +
1901 to_string(static_cast<Level>(targetFcm)) + "\">\n";
1902 if (kernelFcm != Level::UNSPECIFIED) {
1903 xml += " <kernel target-level=\"" + to_string(kernelFcm) + "\"/>\n";
1904 }
1905 xml += "</manifest>";
1906 expectFetch(kVendorManifest, xml);
1907 }
1908 };
1909
1910 // Assume that we are developing level 2. Test that old <kernel> requirements should
1911 // not change and new <kernel> versions are added.
TEST_F(KernelTest,Level1AndLevel2)1912 TEST_F(KernelTest, Level1AndLevel2) {
1913 SetUpMockSystemMatrices({systemMatrixKernelXmls[0], systemMatrixKernelXmls[1]});
1914
1915 expectTargetFcmVersion(1);
1916 auto matrix = vintfObject->getFrameworkCompatibilityMatrix();
1917 ASSERT_NE(nullptr, matrix);
1918 std::string xml = toXml(*matrix);
1919
1920 EXPECT_IN(FAKE_KERNEL("1.0.0", "A1", 1), xml) << "\nOld requirements must not change.";
1921 EXPECT_IN(FAKE_KERNEL("2.0.0", "B1", 1), xml) << "\nOld requirements must not change.";
1922 EXPECT_IN(FAKE_KERNEL("3.0.0", "C2", 2), xml) << "\nShould see <kernel> from new matrices";
1923 EXPECT_IN(FAKE_KERNEL("4.0.0", "D2", 2), xml) << "\nShould see <kernel> from new matrices";
1924
1925 EXPECT_IN(FAKE_KERNEL("2.0.0", "B2", 2), xml) << "\nShould see <kernel> from new matrices";
1926 }
1927
1928 // Assume that we are developing level 3. Test that old <kernel> requirements should
1929 // not change and new <kernel> versions are added.
TEST_F(KernelTest,Level1AndMore)1930 TEST_F(KernelTest, Level1AndMore) {
1931 SetUpMockSystemMatrices({systemMatrixKernelXmls});
1932
1933 expectTargetFcmVersion(1);
1934 auto matrix = vintfObject->getFrameworkCompatibilityMatrix();
1935 ASSERT_NE(nullptr, matrix);
1936 std::string xml = toXml(*matrix);
1937
1938 EXPECT_IN(FAKE_KERNEL("1.0.0", "A1", 1), xml) << "\nOld requirements must not change.";
1939 EXPECT_IN(FAKE_KERNEL("2.0.0", "B1", 1), xml) << "\nOld requirements must not change.";
1940 EXPECT_IN(FAKE_KERNEL("3.0.0", "C2", 2), xml) << "\nOld requirements must not change.";
1941 EXPECT_IN(FAKE_KERNEL("4.0.0", "D2", 2), xml) << "\nOld requirements must not change.";
1942 EXPECT_IN(FAKE_KERNEL("5.0.0", "E3", 3), xml) << "\nShould see <kernel> from new matrices";
1943
1944 EXPECT_IN(FAKE_KERNEL("2.0.0", "B2", 2), xml) << "\nShould see <kernel> from new matrices";
1945 EXPECT_IN(FAKE_KERNEL("4.0.0", "D3", 3), xml) << "\nShould see <kernel> from new matrices";
1946 }
1947
MakeKernelInfo(const std::string & version,const std::string & key)1948 KernelInfo MakeKernelInfo(const std::string& version, const std::string& key) {
1949 KernelInfo info;
1950 CHECK(fromXml(&info,
1951 " <kernel version=\"" + version + "\">\n"
1952 " <config>\n"
1953 " <key>CONFIG_" + key + "</key>\n"
1954 " <value type=\"tristate\">y</value>\n"
1955 " </config>\n"
1956 " </kernel>\n"));
1957 return info;
1958 }
1959
TEST_F(KernelTest,Compatible)1960 TEST_F(KernelTest, Compatible) {
1961 setupMockFetcher(vendorManifestXml1, systemMatrixXml1, systemManifestXml1, vendorMatrixXml1);
1962
1963 SetUpMockSystemMatrices({
1964 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
1965 FAKE_KERNEL("1.0.0", "A1", 1)
1966 FAKE_KERNEL("2.0.0", "B1", 1)
1967 " <sepolicy>\n"
1968 " <kernel-sepolicy-version>0</kernel-sepolicy-version>\n"
1969 " <sepolicy-version>0</sepolicy-version>\n"
1970 " </sepolicy>\n"
1971 "</compatibility-matrix>\n"});
1972 expectKernelFcmVersion(1, Level{1});
1973 expectSystemManifest();
1974 expectVendorMatrix();
1975
1976 auto info = MakeKernelInfo("1.0.0", "A1");
1977 runtimeInfoFactory().getInfo()->setNextFetchKernelInfo(info.version(), info.configs());
1978 std::string error;
1979 ASSERT_EQ(COMPATIBLE, vintfObject->checkCompatibility(&error)) << error;
1980 }
1981
TEST_F(KernelTest,Level)1982 TEST_F(KernelTest, Level) {
1983 expectKernelFcmVersion(1, Level{8});
1984 EXPECT_EQ(Level{8}, vintfObject->getKernelLevel());
1985 }
1986
TEST_F(KernelTest,LevelUnspecified)1987 TEST_F(KernelTest, LevelUnspecified) {
1988 expectKernelFcmVersion(1, Level::UNSPECIFIED);
1989 EXPECT_EQ(Level::UNSPECIFIED, vintfObject->getKernelLevel());
1990 }
1991
1992 class KernelTestP : public KernelTest, public WithParamInterface<
1993 std::tuple<std::vector<std::string>, KernelInfo, Level, Level, bool>> {};
1994 // Assume that we are developing level 2. Test that old <kernel> requirements should
1995 // not change and new <kernel> versions are added.
TEST_P(KernelTestP,Test)1996 TEST_P(KernelTestP, Test) {
1997 auto&& [matrices, info, targetFcm, kernelFcm, pass] = GetParam();
1998
1999 SetUpMockSystemMatrices(matrices);
2000 expectKernelFcmVersion(static_cast<size_t>(targetFcm), kernelFcm);
2001 runtimeInfoFactory().getInfo()->setNextFetchKernelInfo(info.version(), info.configs());
2002 auto matrix = vintfObject->getFrameworkCompatibilityMatrix();
2003 auto runtime = vintfObject->getRuntimeInfo();
2004 ASSERT_NE(nullptr, matrix);
2005 ASSERT_NE(nullptr, runtime);
2006 std::string fallbackError = "Matrix is compatible with kernel info, but it shouldn't. Matrix:\n"
2007 + toXml(*matrix) + "\nKernelInfo:\n" + toXml(info);
2008 std::string error;
2009 ASSERT_EQ(pass, runtime->checkCompatibility(*matrix, &error))
2010 << (pass ? error : fallbackError);
2011 }
2012
2013
KernelTestParamValues()2014 std::vector<KernelTestP::ParamType> KernelTestParamValues() {
2015 std::vector<KernelTestP::ParamType> ret;
2016 std::vector<std::string> matrices = {systemMatrixKernelXmls[0], systemMatrixKernelXmls[1]};
2017 ret.emplace_back(matrices, MakeKernelInfo("1.0.0", "A1"), Level{1}, Level::UNSPECIFIED, true);
2018 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B1"), Level{1}, Level::UNSPECIFIED, true);
2019 ret.emplace_back(matrices, MakeKernelInfo("3.0.0", "C2"), Level{1}, Level::UNSPECIFIED, true);
2020 ret.emplace_back(matrices, MakeKernelInfo("4.0.0", "D2"), Level{1}, Level::UNSPECIFIED, true);
2021 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B2"), Level{1}, Level::UNSPECIFIED, false);
2022
2023 ret.emplace_back(matrices, MakeKernelInfo("1.0.0", "A1"), Level{1}, Level{1}, true);
2024 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B1"), Level{1}, Level{1}, true);
2025 ret.emplace_back(matrices, MakeKernelInfo("3.0.0", "C2"), Level{1}, Level{1}, false);
2026 ret.emplace_back(matrices, MakeKernelInfo("4.0.0", "D2"), Level{1}, Level{1}, false);
2027 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B2"), Level{1}, Level{1}, true);
2028
2029 // Kernel FCM lower than target FCM
2030 ret.emplace_back(matrices, MakeKernelInfo("1.0.0", "A1"), Level{2}, Level{1}, true);
2031 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B1"), Level{2}, Level{1}, true);
2032 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B2"), Level{2}, Level{1}, true);
2033
2034 matrices = systemMatrixKernelXmls;
2035 ret.emplace_back(matrices, MakeKernelInfo("1.0.0", "A1"), Level{1}, Level::UNSPECIFIED, true);
2036 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B1"), Level{1}, Level::UNSPECIFIED, true);
2037 ret.emplace_back(matrices, MakeKernelInfo("3.0.0", "C2"), Level{1}, Level::UNSPECIFIED, true);
2038 ret.emplace_back(matrices, MakeKernelInfo("4.0.0", "D2"), Level{1}, Level::UNSPECIFIED, true);
2039 ret.emplace_back(matrices, MakeKernelInfo("5.0.0", "E3"), Level{1}, Level::UNSPECIFIED, true);
2040 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{1}, Level::UNSPECIFIED, true);
2041 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B2"), Level{1}, Level::UNSPECIFIED, false);
2042 ret.emplace_back(matrices, MakeKernelInfo("4.0.0", "D3"), Level{1}, Level::UNSPECIFIED, false);
2043 ret.emplace_back(matrices, MakeKernelInfo("5.0.0", "E4"), Level{1}, Level::UNSPECIFIED, false);
2044 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F5"), Level{1}, Level::UNSPECIFIED, false);
2045
2046 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{2}, Level::UNSPECIFIED, true);
2047 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{3}, Level::UNSPECIFIED, true);
2048 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{4}, Level::UNSPECIFIED, true);
2049 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{5}, Level::UNSPECIFIED, false);
2050
2051 ret.emplace_back(matrices, MakeKernelInfo("1.0.0", "A1"), Level{1}, Level{1}, true);
2052 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B1"), Level{1}, Level{1}, true);
2053 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B2"), Level{1}, Level{1}, true);
2054 ret.emplace_back(matrices, MakeKernelInfo("3.0.0", "C2"), Level{1}, Level{1}, false);
2055 ret.emplace_back(matrices, MakeKernelInfo("3.0.0", "C3"), Level{1}, Level{1}, false);
2056 ret.emplace_back(matrices, MakeKernelInfo("4.0.0", "D2"), Level{1}, Level{1}, false);
2057 ret.emplace_back(matrices, MakeKernelInfo("4.0.0", "D3"), Level{1}, Level{1}, false);
2058 ret.emplace_back(matrices, MakeKernelInfo("5.0.0", "E3"), Level{1}, Level{1}, false);
2059 ret.emplace_back(matrices, MakeKernelInfo("5.0.0", "E4"), Level{1}, Level{1}, false);
2060 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{1}, Level{1}, false);
2061 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F5"), Level{1}, Level{1}, false);
2062 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{1}, Level{1}, false);
2063
2064 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{2}, Level{2}, false);
2065 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{3}, Level{3}, false);
2066 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{4}, Level{4}, true);
2067 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{5}, Level{5}, false);
2068
2069 // Kernel FCM lower than target FCM
2070 ret.emplace_back(matrices, MakeKernelInfo("1.0.0", "A1"), Level{2}, Level{1}, true);
2071 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B1"), Level{2}, Level{1}, true);
2072 ret.emplace_back(matrices, MakeKernelInfo("2.0.0", "B2"), Level{2}, Level{1}, true);
2073 ret.emplace_back(matrices, MakeKernelInfo("3.0.0", "C2"), Level{2}, Level{1}, false);
2074 ret.emplace_back(matrices, MakeKernelInfo("3.0.0", "C3"), Level{2}, Level{1}, false);
2075 ret.emplace_back(matrices, MakeKernelInfo("4.0.0", "D2"), Level{2}, Level{1}, false);
2076 ret.emplace_back(matrices, MakeKernelInfo("4.0.0", "D3"), Level{2}, Level{1}, false);
2077 ret.emplace_back(matrices, MakeKernelInfo("5.0.0", "E3"), Level{2}, Level{1}, false);
2078 ret.emplace_back(matrices, MakeKernelInfo("5.0.0", "E4"), Level{2}, Level{1}, false);
2079 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{2}, Level{1}, false);
2080 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F5"), Level{2}, Level{1}, false);
2081 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{2}, Level{1}, false);
2082
2083 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{3}, Level{2}, false);
2084 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{4}, Level{3}, false);
2085 ret.emplace_back(matrices, MakeKernelInfo("6.0.0", "F4"), Level{5}, Level{4}, true);
2086 // We don't have device FCM 6 in systemMatrixKernelXmls, skip
2087
2088 return ret;
2089 }
2090
RKernelTestParamValues()2091 std::vector<KernelTestP::ParamType> RKernelTestParamValues() {
2092 std::vector<KernelTestP::ParamType> ret;
2093 std::vector<std::string> matrices = systemMatrixKernelXmls;
2094
2095 // Devices launching O~Q: Must not use *-r+ kernels without specifying kernel FCM version
2096 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{1}, Level::UNSPECIFIED, false);
2097 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{2}, Level::UNSPECIFIED, false);
2098 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{3}, Level::UNSPECIFIED, false);
2099 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{4}, Level::UNSPECIFIED, false);
2100
2101 // Devices launching R: may use r kernel without specifying kernel FCM version because
2102 // assemble_vintf does not insert <kernel> tags to device manifest any more.
2103 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{5}, Level::UNSPECIFIED, true);
2104
2105 // May use *-r+ kernels with kernel FCM version
2106 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{1}, Level{5}, true);
2107 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{2}, Level{5}, true);
2108 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{3}, Level{5}, true);
2109 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{4}, Level{5}, true);
2110 ret.emplace_back(matrices, MakeKernelInfo("7.0.0", "G5"), Level{5}, Level{5}, true);
2111
2112 return ret;
2113 }
2114
PrintKernelTestParam(const TestParamInfo<KernelTestP::ParamType> & info)2115 std::string PrintKernelTestParam(const TestParamInfo<KernelTestP::ParamType>& info) {
2116 const auto& [matrices, kernelInfo, targetFcm, kernelFcm, pass] = info.param;
2117 return (matrices.size() == 2 ? "Level1AndLevel2_" : "Level1AndMore_") +
2118 android::base::StringReplace(to_string(kernelInfo.version()), ".", "_", true) + "_" +
2119 android::base::StringReplace(kernelInfo.configs().begin()->first, "CONFIG_", "", false) +
2120 "_TargetFcm" +
2121 (targetFcm == Level::UNSPECIFIED ? "Unspecified" : to_string(targetFcm)) +
2122 "_KernelFcm" +
2123 (kernelFcm == Level::UNSPECIFIED ? "Unspecified" : to_string(kernelFcm)) +
2124 "_Should" + (pass ? "Pass" : "Fail");
2125 }
2126
2127 INSTANTIATE_TEST_SUITE_P(KernelTest, KernelTestP, ValuesIn(KernelTestParamValues()),
2128 &PrintKernelTestParam);
2129 INSTANTIATE_TEST_SUITE_P(NoRKernelWithoutFcm, KernelTestP, ValuesIn(RKernelTestParamValues()),
2130 &PrintKernelTestParam);
2131
2132 // clang-format on
2133
GkiKernelTestParamValues()2134 std::vector<KernelTestP::ParamType> GkiKernelTestParamValues() {
2135 std::vector<KernelTestP::ParamType> ret;
2136 std::vector<std::string> matrices = systemMatrixKernelXmlsGki;
2137
2138 // Kernel FCM version R: may use 4.19-stable and android12-5.4
2139 ret.emplace_back(matrices, MakeKernelInfo("4.19.0", "R_4_19"), Level::R, Level::R, true);
2140 ret.emplace_back(matrices, MakeKernelInfo("4.19.0", "S_4_19"), Level::R, Level::R, true);
2141 ret.emplace_back(matrices, MakeKernelInfo("5.4.0", "R_5_4"), Level::R, Level::R, true);
2142 ret.emplace_back(matrices, MakeKernelInfo("5.4.0", "S_5_4"), Level::R, Level::R, true);
2143
2144 // Kernel FCM version S: may not use android13-5.10.
2145 ret.emplace_back(matrices, MakeKernelInfo("5.4.0", "S_5_4"), Level::S, Level::S, true);
2146 ret.emplace_back(matrices, MakeKernelInfo("5.10.0", "S_5_10"), Level::S, Level::S, true);
2147 ret.emplace_back(matrices, MakeKernelInfo("5.10.0", "T_5_10"), Level::S, Level::S, false);
2148
2149 // Kernel FCM version T: may not use android14-5.15.
2150 ret.emplace_back(matrices, MakeKernelInfo("5.10.0", "T_5_10"), Level::T, Level::T, true);
2151 ret.emplace_back(matrices, MakeKernelInfo("5.15.0", "T_5_15"), Level::T, Level::T, true);
2152 ret.emplace_back(matrices, MakeKernelInfo("5.15.0", "U_5_15"), Level::T, Level::T, false);
2153
2154 return ret;
2155 }
2156
GkiPrintKernelTestParam(const TestParamInfo<KernelTestP::ParamType> & info)2157 std::string GkiPrintKernelTestParam(const TestParamInfo<KernelTestP::ParamType>& info) {
2158 const auto& [matrices, kernelInfo, targetFcm, kernelFcm, pass] = info.param;
2159 std::string ret = kernelInfo.configs().begin()->first;
2160 ret += "_TargetFcm" + (targetFcm == Level::UNSPECIFIED ? "Unspecified" : to_string(targetFcm));
2161 ret += "_KernelFcm" + (kernelFcm == Level::UNSPECIFIED ? "Unspecified" : to_string(kernelFcm));
2162 ret += "_Should"s + (pass ? "Pass" : "Fail");
2163 return ret;
2164 }
2165
2166 INSTANTIATE_TEST_SUITE_P(GkiNoCheckFutureKmi, KernelTestP, ValuesIn(GkiKernelTestParamValues()),
2167 &GkiPrintKernelTestParam);
2168
2169 // clang-format off
2170
2171 class VintfObjectPartialUpdateTest : public MultiMatrixTest {
2172 protected:
SetUp()2173 void SetUp() override {
2174 MultiMatrixTest::SetUp();
2175 }
2176 };
2177
TEST_F(VintfObjectPartialUpdateTest,DeviceCompatibility)2178 TEST_F(VintfObjectPartialUpdateTest, DeviceCompatibility) {
2179 setupMockFetcher(vendorManifestRequire1, "", systemManifestXml1, vendorMatrixXml1);
2180 SetUpMockSystemMatrices(systemMatrixRequire);
2181
2182 expectSystemManifest();
2183 expectVendorMatrix();
2184 expectVendorManifest();
2185
2186 std::string error;
2187 EXPECT_TRUE(vintfObject->checkCompatibility(&error)) << error;
2188 }
2189
CreateFrameworkManifestFrag(const std::string & interface)2190 std::string CreateFrameworkManifestFrag(const std::string& interface) {
2191 return "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
2192 " <hal format=\"hidl\">\n"
2193 " <name>android.hardware.foo</name>\n"
2194 " <transport>hwbinder</transport>\n"
2195 " <fqname>@1.0::" + interface + "/default</fqname>\n"
2196 " </hal>\n"
2197 "</manifest>\n";
2198 }
2199
2200 using FrameworkManifestTestParam =
2201 std::tuple<bool /* Existence of /system/etc/vintf/manifest.xml */,
2202 bool /* Existence of /system/etc/vintf/manifest/fragment.xml */,
2203 bool /* Existence of /product/etc/vintf/manifest.xml */,
2204 bool /* Existence of /product/etc/vintf/manifest/fragment.xml */,
2205 bool /* Existence of /system_ext/etc/vintf/manifest.xml */,
2206 bool /* Existence of /system_ext/etc/vintf/manifest/fragment.xml */,
2207 bool /* Existence of /apex/com.system/etc/vintf/manifest.xml */>;
2208 class FrameworkManifestTest : public VintfObjectTestBase,
2209 public ::testing::WithParamInterface<FrameworkManifestTestParam> {
2210 protected:
2211 // Set the existence of |path|.
expectManifest(const std::string & path,const std::string & interface,bool exists)2212 void expectManifest(const std::string& path, const std::string& interface, bool exists) {
2213 if (exists) {
2214 expectFetchRepeatedly(path, CreateFrameworkManifestFrag(interface));
2215 } else {
2216 expectFileNotExist(StrEq(path));
2217 }
2218 }
2219
2220 // Set the existence of |path| as a fragment dir
expectFragment(const std::string & path,const std::string & interface,bool exists)2221 void expectFragment(const std::string& path, const std::string& interface, bool exists) {
2222 if (exists) {
2223 EXPECT_CALL(fetcher(), listFiles(StrEq(path), _, _))
2224 .Times(AnyNumber())
2225 .WillRepeatedly(Invoke([](const auto&, auto* out, auto*) {
2226 *out = {"fragment.xml"};
2227 return ::android::OK;
2228 }));
2229 expectFetchRepeatedly(path + "fragment.xml",
2230 CreateFrameworkManifestFrag(interface));
2231 } else {
2232 EXPECT_CALL(fetcher(), listFiles(StrEq(path), _, _))
2233 .Times(AnyNumber())
2234 .WillRepeatedly(Return(::android::OK));
2235 expectFileNotExist(path + "fragment.xml");
2236 }
2237 }
2238
expectContainsInterface(const std::string & interface,bool contains=true)2239 void expectContainsInterface(const std::string& interface, bool contains = true) {
2240 auto manifest = vintfObject->getFrameworkHalManifest();
2241 ASSERT_NE(nullptr, manifest);
2242 EXPECT_NE(manifest->getHidlInstances("android.hardware.foo", {1, 0}, interface).empty(),
2243 contains)
2244 << interface << " should " << (contains ? "" : "not ") << "exist.";
2245 }
2246
expectApex()2247 void expectApex() {
2248 expectFetchRepeatedly(kApexInfoFile, R"(
2249 <apex-info-list>
2250 <apex-info
2251 moduleName="com.system"
2252 partition="SYSTEM"
2253 isActive="true"/>
2254 </apex-info-list>)");
2255 EXPECT_CALL(fetcher(), modifiedTime(kApexInfoFile, _, _))
2256 .WillRepeatedly(Invoke([](auto, timespec* out, auto){
2257 *out = {};
2258 return ::android::OK;
2259 }))
2260 ;
2261 EXPECT_CALL(fetcher(), listFiles("/apex/com.system/etc/vintf/", _, _))
2262 .WillRepeatedly(Invoke([](auto, std::vector<std::string>* out, auto){
2263 *out = {"manifest.xml"};
2264 return ::android::OK;
2265 }));
2266 expectManifest("/apex/com.system/etc/vintf/manifest.xml", "ISystemApex", true);
2267 }
2268 };
2269
TEST_P(FrameworkManifestTest,Existence)2270 TEST_P(FrameworkManifestTest, Existence) {
2271 useEmptyFileSystem();
2272
2273 expectFileNotExist(StrEq(kSystemLegacyManifest));
2274
2275 expectManifest(kSystemManifest, "ISystemEtc", std::get<0>(GetParam()));
2276 expectFragment(kSystemManifestFragmentDir, "ISystemEtcFragment", std::get<1>(GetParam()));
2277 expectManifest(kProductManifest, "IProductEtc", std::get<2>(GetParam()));
2278 expectFragment(kProductManifestFragmentDir, "IProductEtcFragment", std::get<3>(GetParam()));
2279 expectManifest(kSystemExtManifest, "ISystemExtEtc", std::get<4>(GetParam()));
2280 expectFragment(kSystemExtManifestFragmentDir, "ISystemExtEtcFragment", std::get<5>(GetParam()));
2281 if (std::get<6>(GetParam())) {
2282 expectApex();
2283 }
2284
2285 if (!std::get<0>(GetParam())) {
2286 EXPECT_EQ(nullptr, vintfObject->getFrameworkHalManifest())
2287 << "getFrameworkHalManifest must return nullptr if " << kSystemManifest
2288 << " does not exist";
2289 } else {
2290 expectContainsInterface("ISystemEtc", std::get<0>(GetParam()));
2291 expectContainsInterface("ISystemEtcFragment", std::get<1>(GetParam()));
2292 expectContainsInterface("IProductEtc", std::get<2>(GetParam()));
2293 expectContainsInterface("IProductEtcFragment", std::get<3>(GetParam()));
2294 expectContainsInterface("ISystemExtEtc", std::get<4>(GetParam()));
2295 expectContainsInterface("ISystemExtEtcFragment", std::get<5>(GetParam()));
2296 expectContainsInterface("ISystemApex", std::get<6>(GetParam()));
2297 }
2298 }
2299 INSTANTIATE_TEST_SUITE_P(Vintf, FrameworkManifestTest,
2300 ::testing::Combine(Bool(), Bool(), Bool(), Bool(), Bool(), Bool(), Bool()));
2301
2302 // clang-format on
2303
2304 class FrameworkManifestLevelTest : public VintfObjectTestBase {
2305 protected:
SetUp()2306 void SetUp() override {
2307 VintfObjectTestBase::SetUp();
2308 useEmptyFileSystem();
2309
2310 auto head = "<manifest " + kMetaVersionStr + R"( type="framework">)";
2311 auto tail = "</manifest>";
2312
2313 auto systemManifest =
2314 head + getFragment(HalFormat::HIDL, Level::UNSPECIFIED, Level{6}, "@3.0::ISystemEtc") +
2315 getFragment(HalFormat::AIDL, Level{6}, Level{7}, "ISystemEtc4") + tail;
2316 expectFetch(kSystemManifest, systemManifest);
2317
2318 auto hidlFragment =
2319 head +
2320 getFragment(HalFormat::HIDL, Level::UNSPECIFIED, Level{7}, "@4.0::ISystemEtcFragment") +
2321 tail;
2322 expectFetch(kSystemManifestFragmentDir + "hidl.xml"s, hidlFragment);
2323
2324 auto aidlFragment =
2325 head + getFragment(HalFormat::AIDL, Level{5}, Level{6}, "ISystemEtcFragment3") + tail;
2326 expectFetch(kSystemManifestFragmentDir + "aidl.xml"s, aidlFragment);
2327
2328 EXPECT_CALL(fetcher(), listFiles(StrEq(kSystemManifestFragmentDir), _, _))
2329 .Times(AnyNumber())
2330 .WillRepeatedly(Invoke([](const auto&, auto* out, auto*) {
2331 *out = {"hidl.xml", "aidl.xml"};
2332 return ::android::OK;
2333 }));
2334 }
2335
expectTargetFcmVersion(size_t level)2336 void expectTargetFcmVersion(size_t level) {
2337 std::string xml = android::base::StringPrintf(
2338 R"(<manifest %s type="device" target-level="%s"/>)", kMetaVersionStr.c_str(),
2339 to_string(static_cast<Level>(level)).c_str());
2340 expectFetch(kVendorManifest, xml);
2341 (void)vintfObject->getDeviceHalManifest();
2342 }
2343
expectContainsHidl(const Version & version,const std::string & interfaceName,bool exists=true)2344 void expectContainsHidl(const Version& version, const std::string& interfaceName,
2345 bool exists = true) {
2346 auto manifest = vintfObject->getFrameworkHalManifest();
2347 ASSERT_NE(nullptr, manifest);
2348 EXPECT_NE(
2349 manifest->getHidlInstances("android.frameworks.foo", version, interfaceName).empty(),
2350 exists)
2351 << "@" << version << "::" << interfaceName << " should " << (exists ? "" : "not ")
2352 << "exist.";
2353 }
2354
expectContainsAidl(const std::string & interfaceName,bool exists=true)2355 void expectContainsAidl(const std::string& interfaceName, bool exists = true) {
2356 auto manifest = vintfObject->getFrameworkHalManifest();
2357 ASSERT_NE(nullptr, manifest);
2358 EXPECT_NE(manifest->getAidlInstances("android.frameworks.foo", interfaceName).empty(),
2359 exists)
2360 << interfaceName << " should " << (exists ? "" : "not ") << "exist.";
2361 }
2362
2363 private:
getFragment(HalFormat halFormat,Level minLevel,Level maxLevel,const char * versionedInterface)2364 std::string getFragment(HalFormat halFormat, Level minLevel, Level maxLevel,
2365 const char* versionedInterface) {
2366 auto format = R"(<hal format="%s"%s>
2367 <name>android.frameworks.foo</name>
2368 %s
2369 <fqname>%s/default</fqname>
2370 </hal>)";
2371 std::string halAttrs;
2372 if (minLevel != Level::UNSPECIFIED) {
2373 halAttrs +=
2374 android::base::StringPrintf(R"( min-level="%s")", to_string(minLevel).c_str());
2375 }
2376 if (maxLevel != Level::UNSPECIFIED) {
2377 halAttrs +=
2378 android::base::StringPrintf(R"( max-level="%s")", to_string(maxLevel).c_str());
2379 }
2380 const char* transport = "";
2381 if (halFormat == HalFormat::HIDL) {
2382 transport = "<transport>hwbinder</transport>";
2383 }
2384 return android::base::StringPrintf(format, to_string(halFormat).c_str(), halAttrs.c_str(),
2385 transport, versionedInterface);
2386 }
2387 };
2388
TEST_F(FrameworkManifestLevelTest,NoTargetFcmVersion)2389 TEST_F(FrameworkManifestLevelTest, NoTargetFcmVersion) {
2390 auto xml =
2391 android::base::StringPrintf(R"(<manifest %s type="device"/> )", kMetaVersionStr.c_str());
2392 expectFetch(kVendorManifest, xml);
2393
2394 // If no target FCM version, it is treated as an infinitely old device
2395 expectContainsHidl({3, 0}, "ISystemEtc");
2396 expectContainsHidl({4, 0}, "ISystemEtcFragment");
2397 expectContainsAidl("ISystemEtcFragment3", false);
2398 expectContainsAidl("ISystemEtc4", false);
2399 }
2400
TEST_F(FrameworkManifestLevelTest,TargetFcmVersion4)2401 TEST_F(FrameworkManifestLevelTest, TargetFcmVersion4) {
2402 expectTargetFcmVersion(4);
2403 expectContainsHidl({3, 0}, "ISystemEtc");
2404 expectContainsHidl({4, 0}, "ISystemEtcFragment");
2405 expectContainsAidl("ISystemEtcFragment3", false);
2406 expectContainsAidl("ISystemEtc4", false);
2407 }
2408
TEST_F(FrameworkManifestLevelTest,TargetFcmVersion5)2409 TEST_F(FrameworkManifestLevelTest, TargetFcmVersion5) {
2410 expectTargetFcmVersion(5);
2411 expectContainsHidl({3, 0}, "ISystemEtc");
2412 expectContainsHidl({4, 0}, "ISystemEtcFragment");
2413 expectContainsAidl("ISystemEtcFragment3");
2414 expectContainsAidl("ISystemEtc4", false);
2415 }
2416
TEST_F(FrameworkManifestLevelTest,TargetFcmVersion6)2417 TEST_F(FrameworkManifestLevelTest, TargetFcmVersion6) {
2418 expectTargetFcmVersion(6);
2419 expectContainsHidl({3, 0}, "ISystemEtc");
2420 expectContainsHidl({4, 0}, "ISystemEtcFragment");
2421 expectContainsAidl("ISystemEtcFragment3");
2422 expectContainsAidl("ISystemEtc4");
2423 }
2424
TEST_F(FrameworkManifestLevelTest,TargetFcmVersion7)2425 TEST_F(FrameworkManifestLevelTest, TargetFcmVersion7) {
2426 expectTargetFcmVersion(7);
2427 expectContainsHidl({3, 0}, "ISystemEtc", false);
2428 expectContainsHidl({4, 0}, "ISystemEtcFragment");
2429 expectContainsAidl("ISystemEtcFragment3", false);
2430 expectContainsAidl("ISystemEtc4");
2431 }
2432
TEST_F(FrameworkManifestLevelTest,TargetFcmVersion8)2433 TEST_F(FrameworkManifestLevelTest, TargetFcmVersion8) {
2434 expectTargetFcmVersion(8);
2435 expectContainsHidl({3, 0}, "ISystemEtc", false);
2436 expectContainsHidl({4, 0}, "ISystemEtcFragment", false);
2437 expectContainsAidl("ISystemEtcFragment3", false);
2438 expectContainsAidl("ISystemEtc4", false);
2439 }
2440
2441 // clang-format off
2442
2443 //
2444 // Set of OEM FCM matrices at different FCM version.
2445 //
2446
GetOemFcmMatrixLevels(const std::string & name)2447 std::vector<std::string> GetOemFcmMatrixLevels(const std::string& name) {
2448 return {
2449 // 1.xml
2450 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2451 " <hal format=\"hidl\" optional=\"true\">\n"
2452 " <name>vendor.foo." + name + "</name>\n"
2453 " <version>1.0</version>\n"
2454 " <interface>\n"
2455 " <name>IExtra</name>\n"
2456 " <instance>default</instance>\n"
2457 " </interface>\n"
2458 " </hal>\n"
2459 "</compatibility-matrix>\n",
2460 // 2.xml
2461 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
2462 " <hal format=\"hidl\" optional=\"true\">\n"
2463 " <name>vendor.foo." + name + "</name>\n"
2464 " <version>2.0</version>\n"
2465 " <interface>\n"
2466 " <name>IExtra</name>\n"
2467 " <instance>default</instance>\n"
2468 " </interface>\n"
2469 " </hal>\n"
2470 "</compatibility-matrix>\n",
2471 };
2472 }
2473
2474 class OemFcmLevelTest : public MultiMatrixTest,
2475 public WithParamInterface<std::tuple<size_t, bool, bool>> {
2476 protected:
SetUp()2477 virtual void SetUp() override {
2478 MultiMatrixTest::SetUp();
2479 SetUpMockSystemMatrices({systemMatrixLevel1, systemMatrixLevel2});
2480 }
2481 using Instances = std::set<std::string>;
GetInstances(const CompatibilityMatrix * fcm)2482 Instances GetInstances(const CompatibilityMatrix* fcm) {
2483 Instances instances;
2484 fcm->forEachHidlInstance([&instances](const auto& matrixInstance) {
2485 instances.insert(matrixInstance.description(matrixInstance.versionRange().minVer()));
2486 return true; // continue
2487 });
2488 return instances;
2489 }
2490 };
2491
TEST_P(OemFcmLevelTest,Test)2492 TEST_P(OemFcmLevelTest, Test) {
2493 auto&& [level, hasProduct, hasSystemExt] = GetParam();
2494
2495 expectTargetFcmVersion(level);
2496 if (hasProduct) {
2497 SetUpMockMatrices(kProductVintfDir, GetOemFcmMatrixLevels("product"));
2498 }
2499 if (hasSystemExt) {
2500 SetUpMockMatrices(kSystemExtVintfDir, GetOemFcmMatrixLevels("systemext"));
2501 }
2502
2503 auto fcm = vintfObject->getFrameworkCompatibilityMatrix();
2504 ASSERT_NE(nullptr, fcm);
2505 auto instances = GetInstances(fcm.get());
2506
2507 auto containsOrNot = [](bool contains, const std::string& e) {
2508 return contains ? SafeMatcherCast<Instances>(Contains(e))
2509 : SafeMatcherCast<Instances>(Not(Contains(e)));
2510 };
2511
2512 EXPECT_THAT(instances, containsOrNot(level == 1,
2513 "[email protected]::IMajor/default"));
2514 EXPECT_THAT(instances, containsOrNot(level == 1 && hasProduct,
2515 "[email protected]::IExtra/default"));
2516 EXPECT_THAT(instances, containsOrNot(level == 1 && hasSystemExt,
2517 "[email protected]::IExtra/default"));
2518 EXPECT_THAT(instances, Contains("[email protected]::IMajor/default"));
2519 EXPECT_THAT(instances, containsOrNot(hasProduct,
2520 "[email protected]::IExtra/default"));
2521 EXPECT_THAT(instances, containsOrNot(hasSystemExt,
2522 "[email protected]::IExtra/default"));
2523 }
2524
OemFcmLevelTestParamToString(const TestParamInfo<OemFcmLevelTest::ParamType> & info)2525 static std::string OemFcmLevelTestParamToString(
2526 const TestParamInfo<OemFcmLevelTest::ParamType>& info) {
2527 auto&& [level, hasProduct, hasSystemExt] = info.param;
2528 auto name = "Level" + std::to_string(level);
2529 name += "With"s + (hasProduct ? "" : "out") + "Product";
2530 name += "With"s + (hasSystemExt ? "" : "out") + "SystemExt";
2531 return name;
2532 }
2533 INSTANTIATE_TEST_SUITE_P(OemFcmLevel, OemFcmLevelTest, Combine(Values(1, 2), Bool(), Bool()),
2534 OemFcmLevelTestParamToString);
2535 // clang-format on
2536
2537 // Common test set up for checking matrices against lib*idlmetadata.
2538 class CheckMatricesWithHalDefTestBase : public MultiMatrixTest {
SetUp()2539 void SetUp() override {
2540 MultiMatrixTest::SetUp();
2541
2542 // clang-format off
2543 std::vector<std::string> matrices{
2544 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2545 " <hal format=\"hidl\" optional=\"false\">\n"
2546 " <name>android.hardware.hidl</name>\n"
2547 " <version>1.0</version>\n"
2548 " <interface>\n"
2549 " <name>IHidl</name>\n"
2550 " <instance>default</instance>\n"
2551 " </interface>\n"
2552 " </hal>\n"
2553 " <hal format=\"aidl\" optional=\"false\">\n"
2554 " <name>android.hardware.aidl</name>\n"
2555 " <interface>\n"
2556 " <name>IAidl</name>\n"
2557 " <instance>default</instance>\n"
2558 " </interface>\n"
2559 " </hal>\n"
2560 "</compatibility-matrix>\n",
2561 };
2562 // clang-format on
2563
2564 SetUpMockSystemMatrices(matrices);
2565 }
2566 };
2567
2568 // A set of tests on VintfObject::checkMissingHalsInMatrices
2569 class CheckMissingHalsTest : public CheckMatricesWithHalDefTestBase {
2570 public:
defaultPred(const std::string &)2571 static bool defaultPred(const std::string&) { return true; }
2572 };
2573
TEST_F(CheckMissingHalsTest,Empty)2574 TEST_F(CheckMissingHalsTest, Empty) {
2575 EXPECT_THAT(vintfObject->checkMissingHalsInMatrices({}, {}, defaultPred, defaultPred), Ok());
2576 }
2577
TEST_F(CheckMissingHalsTest,Pass)2578 TEST_F(CheckMissingHalsTest, Pass) {
2579 std::vector<HidlInterfaceMetadata> hidl{{.name = "[email protected]::IHidl"}};
2580 std::vector<AidlInterfaceMetadata> aidl{
2581 {.types = {"android.hardware.aidl.IAidl"}, .stability = "vintf", .versions = {1}}};
2582 EXPECT_THAT(vintfObject->checkMissingHalsInMatrices(hidl, {}, defaultPred, defaultPred), Ok());
2583 EXPECT_THAT(vintfObject->checkMissingHalsInMatrices({}, aidl, defaultPred, defaultPred), Ok());
2584 EXPECT_THAT(vintfObject->checkMissingHalsInMatrices(hidl, aidl, defaultPred, defaultPred),
2585 Ok());
2586 }
2587
TEST_F(CheckMissingHalsTest,FailVendor)2588 TEST_F(CheckMissingHalsTest, FailVendor) {
2589 std::vector<HidlInterfaceMetadata> hidl{{.name = "[email protected]"}};
2590 std::vector<AidlInterfaceMetadata> aidl{
2591 {.types = {"vendor.foo.aidl.IAidl"}, .stability = "vintf", .versions = {1}}};
2592
2593 auto res = vintfObject->checkMissingHalsInMatrices(hidl, {}, defaultPred, defaultPred);
2594 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]"))));
2595
2596 setCheckAidlFCM(true);
2597 res = vintfObject->checkMissingHalsInMatrices({}, aidl, defaultPred, defaultPred);
2598 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("vendor.foo.aidl"))));
2599
2600 res = vintfObject->checkMissingHalsInMatrices(hidl, aidl, defaultPred, defaultPred);
2601 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]"))));
2602 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("vendor.foo.aidl"))));
2603
2604 auto predicate = [](const auto& interfaceName) {
2605 return android::base::StartsWith(interfaceName, "android.hardware");
2606 };
2607 EXPECT_THAT(vintfObject->checkMissingHalsInMatrices(hidl, {}, predicate, predicate), Ok());
2608 EXPECT_THAT(vintfObject->checkMissingHalsInMatrices({}, aidl, predicate, predicate), Ok());
2609 EXPECT_THAT(vintfObject->checkMissingHalsInMatrices(hidl, aidl, predicate, predicate), Ok());
2610 }
2611
TEST_F(CheckMissingHalsTest,FailMajorVersion)2612 TEST_F(CheckMissingHalsTest, FailMajorVersion) {
2613 std::vector<HidlInterfaceMetadata> hidl{{.name = "[email protected]"}};
2614 std::vector<AidlInterfaceMetadata> aidl{
2615 {.types = {"android.hardware.aidl2.IAidl"}, .stability = "vintf", .versions = {1}}};
2616
2617 setCheckAidlFCM(true);
2618 auto res = vintfObject->checkMissingHalsInMatrices(hidl, {}, defaultPred, defaultPred);
2619 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]"))));
2620
2621 res = vintfObject->checkMissingHalsInMatrices({}, aidl, defaultPred, defaultPred);
2622 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("android.hardware.aidl2"))));
2623
2624 res = vintfObject->checkMissingHalsInMatrices(hidl, aidl, defaultPred, defaultPred);
2625 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]"))));
2626 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("android.hardware.aidl2"))));
2627
2628 auto predicate = [](const auto& interfaceName) {
2629 return android::base::StartsWith(interfaceName, "android.hardware");
2630 };
2631
2632 res = vintfObject->checkMissingHalsInMatrices(hidl, {}, predicate, predicate);
2633 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]"))));
2634
2635 res = vintfObject->checkMissingHalsInMatrices({}, aidl, predicate, predicate);
2636 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("android.hardware.aidl2"))));
2637
2638 res = vintfObject->checkMissingHalsInMatrices(hidl, aidl, predicate, predicate);
2639 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]"))));
2640 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("android.hardware.aidl2"))));
2641 }
2642
TEST_F(CheckMissingHalsTest,FailMinorVersion)2643 TEST_F(CheckMissingHalsTest, FailMinorVersion) {
2644 std::vector<HidlInterfaceMetadata> hidl{{.name = "[email protected]"}};
2645 std::vector<AidlInterfaceMetadata> aidl{
2646 {.types = {"android.hardware.aidl.IAidl"}, .stability = "vintf", .versions = {1, 2}}};
2647
2648 auto res = vintfObject->checkMissingHalsInMatrices(hidl, {}, defaultPred, defaultPred);
2649 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]"))));
2650
2651 setCheckAidlFCM(true);
2652 res = vintfObject->checkMissingHalsInMatrices({}, aidl, defaultPred, defaultPred);
2653 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("android.hardware.aidl@2"))));
2654
2655 res = vintfObject->checkMissingHalsInMatrices(hidl, aidl, defaultPred, defaultPred);
2656 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]"))));
2657 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("android.hardware.aidl@2"))));
2658 }
2659
TEST_F(CheckMissingHalsTest,SkipFcmCheckForAidl)2660 TEST_F(CheckMissingHalsTest, SkipFcmCheckForAidl) {
2661 std::vector<HidlInterfaceMetadata> hidl{{.name = "[email protected]"}};
2662 std::vector<AidlInterfaceMetadata> aidl{
2663 {.types = {"android.hardware.aidl.IAidl"}, .stability = "vintf", .versions = {1, 2}}};
2664
2665 auto res = vintfObject->checkMissingHalsInMatrices(hidl, {}, defaultPred, defaultPred);
2666 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]"))));
2667
2668 setCheckAidlFCM(false);
2669 res = vintfObject->checkMissingHalsInMatrices({}, aidl, defaultPred, defaultPred);
2670 EXPECT_THAT(res, Ok());
2671
2672 setCheckAidlFCM(true);
2673 res = vintfObject->checkMissingHalsInMatrices(hidl, aidl, defaultPred, defaultPred);
2674 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]"))));
2675 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("android.hardware.aidl@2"))));
2676 }
2677
TEST_F(CheckMissingHalsTest,PassAidlInDevelopment)2678 TEST_F(CheckMissingHalsTest, PassAidlInDevelopment) {
2679 std::vector<AidlInterfaceMetadata> aidl{{.types = {"android.hardware.aidl.IAidl"},
2680 .stability = "vintf",
2681 .versions = {},
2682 .has_development = true}};
2683
2684 auto res = vintfObject->checkMissingHalsInMatrices({}, aidl, defaultPred, defaultPred);
2685 EXPECT_THAT(res, Ok());
2686 }
2687
TEST_F(CheckMissingHalsTest,FailAidlInDevelopment)2688 TEST_F(CheckMissingHalsTest, FailAidlInDevelopment) {
2689 std::vector<AidlInterfaceMetadata> aidl{{.types = {"android.hardware.aidl.IAidl"},
2690 .stability = "vintf",
2691 .versions = {1},
2692 .has_development = true}};
2693
2694 setCheckAidlFCM(true);
2695 auto res = vintfObject->checkMissingHalsInMatrices({}, aidl, defaultPred, defaultPred);
2696 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("android.hardware.aidl@2"))));
2697 }
2698
2699 // A set of tests on VintfObject::checkMatrixHalsHasDefinition
2700 class CheckMatrixHalsHasDefinitionTest : public CheckMatricesWithHalDefTestBase {};
2701
TEST_F(CheckMatrixHalsHasDefinitionTest,Pass)2702 TEST_F(CheckMatrixHalsHasDefinitionTest, Pass) {
2703 std::vector<HidlInterfaceMetadata> hidl{{.name = "[email protected]::IHidl"}};
2704 std::vector<AidlInterfaceMetadata> aidl{
2705 {.types = {"android.hardware.aidl.IAidl"}, .stability = "vintf"}};
2706 EXPECT_THAT(vintfObject->checkMatrixHalsHasDefinition(hidl, aidl), Ok());
2707 }
2708
TEST_F(CheckMatrixHalsHasDefinitionTest,FailMissingHidl)2709 TEST_F(CheckMatrixHalsHasDefinitionTest, FailMissingHidl) {
2710 std::vector<AidlInterfaceMetadata> aidl{
2711 {.types = {"android.hardware.aidl.IAidl"}, .stability = "vintf"}};
2712 auto res = vintfObject->checkMatrixHalsHasDefinition({}, aidl);
2713 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]::IHidl"))));
2714 }
2715
TEST_F(CheckMatrixHalsHasDefinitionTest,FailMissingAidl)2716 TEST_F(CheckMatrixHalsHasDefinitionTest, FailMissingAidl) {
2717 std::vector<HidlInterfaceMetadata> hidl{{.name = "[email protected]::IHidl"}};
2718 auto res = vintfObject->checkMatrixHalsHasDefinition(hidl, {});
2719 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("android.hardware.aidl.IAidl"))));
2720 }
2721
TEST_F(CheckMatrixHalsHasDefinitionTest,FailMissingBoth)2722 TEST_F(CheckMatrixHalsHasDefinitionTest, FailMissingBoth) {
2723 auto res = vintfObject->checkMatrixHalsHasDefinition({}, {});
2724 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("[email protected]::IHidl"))));
2725 EXPECT_THAT(res, HasError(WithMessage(HasSubstr("android.hardware.aidl.IAidl"))));
2726 }
2727
2728 constexpr const char* systemMatrixHealthFormat = R"(
2729 <compatibility-matrix %s type="framework" level="%s">
2730 <hal format="%s" optional="%s">
2731 <name>android.hardware.health</name>
2732 <version>%s</version>
2733 <interface>
2734 <name>IHealth</name>
2735 <instance>default</instance>
2736 </interface>
2737 </hal>
2738 </compatibility-matrix>
2739 )";
2740
2741 constexpr const char* vendorManifestHealthHidlFormat = R"(
2742 <manifest %s type="device" target-level="%s">
2743 <hal format="hidl">
2744 <name>android.hardware.health</name>
2745 <transport>hwbinder</transport>
2746 <fqname>@%s::IHealth/default</fqname>
2747 </hal>
2748 </manifest>
2749 )";
2750
2751 constexpr const char* vendorManifestHealthAidlFormat = R"(
2752 <manifest %s type="device" target-level="%s">
2753 <hal format="aidl">
2754 <name>android.hardware.health</name>
2755 <version>%s</version>
2756 <fqname>IHealth/default</fqname>
2757 </hal>
2758 </manifest>
2759 )";
2760
2761 using HealthHalVersion = std::variant<Version /* HIDL */, size_t /* AIDL */>;
2762 struct VintfObjectHealthHalTestParam {
2763 Level targetLevel;
2764 HealthHalVersion halVersion;
2765 bool expected;
2766
getHalFormatandroid::vintf::testing::VintfObjectHealthHalTestParam2767 HalFormat getHalFormat() const {
2768 if (std::holds_alternative<Version>(halVersion)) return HalFormat::HIDL;
2769 if (std::holds_alternative<size_t>(halVersion)) return HalFormat::AIDL;
2770 __builtin_unreachable();
2771 }
2772 };
operator <<(std::ostream & os,const VintfObjectHealthHalTestParam & param)2773 std::ostream& operator<<(std::ostream& os, const VintfObjectHealthHalTestParam& param) {
2774 os << param.targetLevel << "_" << param.getHalFormat() << "_";
2775 switch (param.getHalFormat()) {
2776 case HalFormat::HIDL: {
2777 const auto& v = std::get<Version>(param.halVersion);
2778 os << "v" << v.majorVer << "_" << v.minorVer;
2779 } break;
2780 case HalFormat::AIDL: {
2781 os << "v" << std::get<size_t>(param.halVersion);
2782 } break;
2783 default:
2784 __builtin_unreachable();
2785 }
2786 return os << "_" << (param.expected ? "ok" : "not_ok");
2787 }
2788
2789 // Test fixture that provides compatible metadata from the mock device.
2790 class VintfObjectHealthHalTest : public MultiMatrixTest,
2791 public WithParamInterface<VintfObjectHealthHalTestParam> {
2792 public:
SetUp()2793 virtual void SetUp() {
2794 MultiMatrixTest::SetUp();
2795 SetUpMockSystemMatrices({
2796 android::base::StringPrintf(
2797 systemMatrixHealthFormat, kMetaVersionStr.c_str(), to_string(Level::P).c_str(),
2798 to_string(HalFormat::HIDL).c_str(), "true", to_string(Version{2, 0}).c_str()),
2799 android::base::StringPrintf(
2800 systemMatrixHealthFormat, kMetaVersionStr.c_str(), to_string(Level::Q).c_str(),
2801 to_string(HalFormat::HIDL).c_str(), "true", to_string(Version{2, 0}).c_str()),
2802 android::base::StringPrintf(
2803 systemMatrixHealthFormat, kMetaVersionStr.c_str(), to_string(Level::R).c_str(),
2804 to_string(HalFormat::HIDL).c_str(), "true", to_string(Version{2, 1}).c_str()),
2805 android::base::StringPrintf(
2806 systemMatrixHealthFormat, kMetaVersionStr.c_str(), to_string(Level::S).c_str(),
2807 to_string(HalFormat::HIDL).c_str(), "true", to_string(Version{2, 1}).c_str()),
2808 android::base::StringPrintf(
2809 systemMatrixHealthFormat, kMetaVersionStr.c_str(), to_string(Level::T).c_str(),
2810 to_string(HalFormat::AIDL).c_str(), "false", to_string(1).c_str()),
2811 });
2812 switch (GetParam().getHalFormat()) {
2813 case HalFormat::HIDL:
2814 expectFetchRepeatedly(
2815 kVendorManifest,
2816 android::base::StringPrintf(
2817 vendorManifestHealthHidlFormat, kMetaVersionStr.c_str(),
2818 to_string(GetParam().targetLevel).c_str(),
2819 to_string(std::get<Version>(GetParam().halVersion)).c_str()));
2820 break;
2821 case HalFormat::AIDL:
2822 expectFetchRepeatedly(
2823 kVendorManifest,
2824 android::base::StringPrintf(
2825 vendorManifestHealthAidlFormat, kMetaVersionStr.c_str(),
2826 to_string(GetParam().targetLevel).c_str(),
2827 to_string(std::get<size_t>(GetParam().halVersion)).c_str()));
2828 break;
2829 default:
2830 __builtin_unreachable();
2831 }
2832 }
GetParams()2833 static std::vector<VintfObjectHealthHalTestParam> GetParams() {
2834 std::vector<VintfObjectHealthHalTestParam> ret;
2835 for (auto level : {Level::P, Level::Q, Level::R, Level::S, Level::T}) {
2836 ret.push_back({level, Version{2, 0}, level < Level::R});
2837 ret.push_back({level, Version{2, 1}, level < Level::T});
2838 ret.push_back({level, 1u, true});
2839 }
2840 return ret;
2841 }
2842 };
2843
TEST_P(VintfObjectHealthHalTest,Test)2844 TEST_P(VintfObjectHealthHalTest, Test) {
2845 auto manifest = vintfObject->getDeviceHalManifest();
2846 ASSERT_NE(nullptr, manifest);
2847 std::string deprecatedError;
2848 auto deprecation = vintfObject->checkDeprecation({}, &deprecatedError);
2849 bool hasHidl =
2850 manifest->hasHidlInstance("android.hardware.health", {2, 0}, "IHealth", "default");
2851 bool hasAidl = manifest->hasAidlInstance("android.hardware.health", 1, "IHealth", "default");
2852 bool hasHal = hasHidl || hasAidl;
2853 EXPECT_EQ(GetParam().expected, deprecation == NO_DEPRECATED_HALS && hasHal)
2854 << "checkDeprecation() returns " << deprecation << "; hasHidl = " << hasHidl
2855 << ", hasAidl = " << hasAidl;
2856 }
2857
2858 INSTANTIATE_TEST_SUITE_P(VintfObjectHealthHalTest, VintfObjectHealthHalTest,
2859 ::testing::ValuesIn(VintfObjectHealthHalTest::GetParams()),
__anon539f1f852202(const auto& info) 2860 [](const auto& info) { return to_string(info.param); });
2861
2862 constexpr const char* systemMatrixComposerFormat = R"(
2863 <compatibility-matrix %s type="framework" level="%s">
2864 %s
2865 </compatibility-matrix>
2866 )";
2867
2868 constexpr const char* systemMatrixComposerHalFragmentFormat = R"(
2869 <hal format="%s" optional="%s">
2870 <name>%s</name>
2871 <version>%s</version>
2872 <interface>
2873 <name>IComposer</name>
2874 <instance>default</instance>
2875 </interface>
2876 </hal>
2877 )";
2878
2879 constexpr const char* vendorManifestComposerHidlFormat = R"(
2880 <manifest %s type="device" target-level="%s">
2881 %s
2882 </manifest>
2883 )";
2884
2885 constexpr const char* vendorManifestComposerHidlFragmentFormat = R"(
2886 <hal format="hidl">
2887 <name>android.hardware.graphics.composer</name>
2888 <version>%s</version>
2889 <transport>hwbinder</transport>
2890 <interface>
2891 <name>IComposer</name>
2892 <instance>default</instance>
2893 </interface>
2894 </hal>
2895 )";
2896
2897 constexpr const char* vendorManifestComposerAidlFragmentFormat = R"(
2898 <hal format="aidl">
2899 <name>android.hardware.graphics.composer3</name>
2900 <version>%s</version>
2901 <interface>
2902 <name>IComposer</name>
2903 <instance>default</instance>
2904 </interface>
2905 </hal>
2906 )";
2907
2908 constexpr const char* composerHidlHalName = "android.hardware.graphics.composer";
2909 constexpr const char* composerAidlHalName = "android.hardware.graphics.composer3";
2910
2911 using ComposerHalVersion = std::variant<Version /* HIDL */, size_t /* AIDL */>;
2912 struct VintfObjectComposerHalTestParam {
2913 Level targetLevel;
2914 std::optional<ComposerHalVersion> halVersion;
2915 bool expected;
2916
hasHalandroid::vintf::testing::VintfObjectComposerHalTestParam2917 bool hasHal() const { return halVersion.has_value(); }
2918
getHalFormatandroid::vintf::testing::VintfObjectComposerHalTestParam2919 HalFormat getHalFormat() const {
2920 if (std::holds_alternative<Version>(*halVersion)) return HalFormat::HIDL;
2921 if (std::holds_alternative<size_t>(*halVersion)) return HalFormat::AIDL;
2922 __builtin_unreachable();
2923 }
2924 };
operator <<(std::ostream & os,const VintfObjectComposerHalTestParam & param)2925 std::ostream& operator<<(std::ostream& os, const VintfObjectComposerHalTestParam& param) {
2926 os << param.targetLevel << "_";
2927 if (param.hasHal()) {
2928 os << param.getHalFormat() << "_";
2929 switch (param.getHalFormat()) {
2930 case HalFormat::HIDL: {
2931 const auto& v = std::get<Version>(*param.halVersion);
2932 os << "v" << v.majorVer << "_" << v.minorVer;
2933 } break;
2934 case HalFormat::AIDL: {
2935 os << "v" << std::get<size_t>(*param.halVersion);
2936 } break;
2937 default:
2938 __builtin_unreachable();
2939 }
2940 } else {
2941 os << "no_hal";
2942 }
2943 return os << "_" << (param.expected ? "ok" : "not_ok");
2944 }
2945
2946 // Test fixture that provides compatible metadata from the mock device.
2947 class VintfObjectComposerHalTest : public MultiMatrixTest,
2948 public WithParamInterface<VintfObjectComposerHalTestParam> {
2949 public:
SetUp()2950 virtual void SetUp() {
2951 MultiMatrixTest::SetUp();
2952
2953 const std::string requiresHidl2_1To2_2 = android::base::StringPrintf(
2954 systemMatrixComposerHalFragmentFormat, to_string(HalFormat::HIDL).c_str(), "false",
2955 composerHidlHalName, to_string(VersionRange{2, 1, 2}).c_str());
2956 const std::string requiresHidl2_1To2_3 = android::base::StringPrintf(
2957 systemMatrixComposerHalFragmentFormat, to_string(HalFormat::HIDL).c_str(), "false",
2958 composerHidlHalName, to_string(VersionRange{2, 1, 3}).c_str());
2959 const std::string requiresHidl2_1To2_4 = android::base::StringPrintf(
2960 systemMatrixComposerHalFragmentFormat, to_string(HalFormat::HIDL).c_str(), "false",
2961 composerHidlHalName, to_string(VersionRange{2, 1, 4}).c_str());
2962 const std::string optionalHidl2_1To2_4 = android::base::StringPrintf(
2963 systemMatrixComposerHalFragmentFormat, to_string(HalFormat::HIDL).c_str(), "true",
2964 composerHidlHalName, to_string(VersionRange{2, 1, 4}).c_str());
2965 const std::string optionalAidl1 = android::base::StringPrintf(
2966 systemMatrixComposerHalFragmentFormat, to_string(HalFormat::AIDL).c_str(), "true",
2967 composerAidlHalName, "1");
2968 const std::string optionalHidl2_1To2_4OrAidl1 = optionalHidl2_1To2_4 + optionalAidl1;
2969
2970 SetUpMockSystemMatrices({
2971 android::base::StringPrintf(systemMatrixComposerFormat, kMetaVersionStr.c_str(),
2972 to_string(Level::P).c_str(), requiresHidl2_1To2_2.c_str()),
2973 android::base::StringPrintf(systemMatrixComposerFormat, kMetaVersionStr.c_str(),
2974 to_string(Level::Q).c_str(), requiresHidl2_1To2_3.c_str()),
2975 android::base::StringPrintf(systemMatrixComposerFormat, kMetaVersionStr.c_str(),
2976 to_string(Level::R).c_str(), requiresHidl2_1To2_4.c_str()),
2977 android::base::StringPrintf(systemMatrixComposerFormat, kMetaVersionStr.c_str(),
2978 to_string(Level::S).c_str(), requiresHidl2_1To2_4.c_str()),
2979 android::base::StringPrintf(systemMatrixComposerFormat, kMetaVersionStr.c_str(),
2980 to_string(Level::T).c_str(),
2981 optionalHidl2_1To2_4OrAidl1.c_str()),
2982 });
2983
2984 const auto param = GetParam();
2985
2986 std::string vendorHalFragment;
2987 if (param.hasHal()) {
2988 switch (param.getHalFormat()) {
2989 case HalFormat::HIDL:
2990 vendorHalFragment = android::base::StringPrintf(
2991 vendorManifestComposerHidlFragmentFormat,
2992 to_string(std::get<Version>(*param.halVersion)).c_str());
2993 break;
2994 case HalFormat::AIDL:
2995 vendorHalFragment = android::base::StringPrintf(
2996 vendorManifestComposerAidlFragmentFormat,
2997 to_string(std::get<size_t>(*param.halVersion)).c_str());
2998 break;
2999 default:
3000 __builtin_unreachable();
3001 }
3002 } else {
3003 vendorHalFragment = "";
3004 }
3005 expectFetchRepeatedly(kVendorManifest,
3006 android::base::StringPrintf(
3007 vendorManifestComposerHidlFormat, kMetaVersionStr.c_str(),
3008 to_string(param.targetLevel).c_str(), vendorHalFragment.c_str()));
3009 }
GetParams()3010 static std::vector<VintfObjectComposerHalTestParam> GetParams() {
3011 std::vector<VintfObjectComposerHalTestParam> ret;
3012 for (auto level : {Level::P, Level::Q, Level::R, Level::S, Level::T}) {
3013 ret.push_back({level, std::nullopt, false});
3014 ret.push_back({level, ComposerHalVersion{Version{2, 1}}, true});
3015 ret.push_back({level, ComposerHalVersion{Version{2, 2}}, true});
3016 ret.push_back({level, ComposerHalVersion{Version{2, 3}}, true});
3017 ret.push_back({level, ComposerHalVersion{Version{2, 4}}, true});
3018 ret.push_back({level, ComposerHalVersion{1u}, true});
3019 }
3020 return ret;
3021 }
3022 };
3023
TEST_P(VintfObjectComposerHalTest,Test)3024 TEST_P(VintfObjectComposerHalTest, Test) {
3025 auto manifest = vintfObject->getDeviceHalManifest();
3026 ASSERT_NE(nullptr, manifest);
3027 std::string deprecatedError;
3028 auto deprecation = vintfObject->checkDeprecation({}, &deprecatedError);
3029 bool hasHidl = manifest->hasHidlInstance(composerHidlHalName, {2, 1}, "IComposer", "default");
3030 bool hasAidl = manifest->hasAidlInstance(composerAidlHalName, 1, "IComposer", "default");
3031 bool hasHal = hasHidl || hasAidl;
3032 EXPECT_EQ(GetParam().expected, deprecation == NO_DEPRECATED_HALS && hasHal)
3033 << "checkDeprecation() returns " << deprecation << "; hasHidl = " << hasHidl
3034 << ", hasAidl = " << hasAidl;
3035 }
3036
3037 INSTANTIATE_TEST_SUITE_P(VintfObjectComposerHalTest, VintfObjectComposerHalTest,
3038 ::testing::ValuesIn(VintfObjectComposerHalTest::GetParams()),
__anon539f1f852302(const auto& info) 3039 [](const auto& info) { return to_string(info.param); });
3040
3041 constexpr const char* systemMatrixLatestMinLtsFormat = R"(
3042 <compatibility-matrix %s type="framework" level="%s">
3043 <kernel version="%s" />
3044 <kernel version="%s" />
3045 <kernel version="%s" />
3046 </compatibility-matrix>
3047 )";
3048
3049 class VintfObjectLatestMinLtsTest : public MultiMatrixTest {};
3050
TEST_F(VintfObjectLatestMinLtsTest,TestEmpty)3051 TEST_F(VintfObjectLatestMinLtsTest, TestEmpty) {
3052 SetUpMockSystemMatrices({});
3053 EXPECT_THAT(vintfObject->getLatestMinLtsAtFcmVersion(Level::S),
3054 HasError(WithCode(-NAME_NOT_FOUND)));
3055 }
3056
TEST_F(VintfObjectLatestMinLtsTest,TestMissing)3057 TEST_F(VintfObjectLatestMinLtsTest, TestMissing) {
3058 SetUpMockSystemMatrices({
3059 android::base::StringPrintf(systemMatrixLatestMinLtsFormat, kMetaVersionStr.c_str(),
3060 to_string(Level::S).c_str(), "4.19.191", "5.4.86", "5.10.43"),
3061 });
3062 EXPECT_THAT(
3063 vintfObject->getLatestMinLtsAtFcmVersion(Level::T),
3064 HasError(WithMessage(HasSubstr("Can't find compatibility matrix fragment for level 7"))));
3065 }
3066
TEST_F(VintfObjectLatestMinLtsTest,TestSimple)3067 TEST_F(VintfObjectLatestMinLtsTest, TestSimple) {
3068 SetUpMockSystemMatrices({
3069 android::base::StringPrintf(systemMatrixLatestMinLtsFormat, kMetaVersionStr.c_str(),
3070 to_string(Level::S).c_str(), "4.19.191", "5.4.86", "5.10.43"),
3071 android::base::StringPrintf(systemMatrixLatestMinLtsFormat, kMetaVersionStr.c_str(),
3072 to_string(Level::T).c_str(), "5.4.86", "5.10.107", "5.15.41"),
3073 });
3074 EXPECT_THAT(vintfObject->getLatestMinLtsAtFcmVersion(Level::S),
3075 HasValue(KernelVersion{5, 10, 43}));
3076 EXPECT_THAT(vintfObject->getLatestMinLtsAtFcmVersion(Level::T),
3077 HasValue(KernelVersion{5, 15, 41}));
3078 }
3079
TEST_F(VintfObjectLatestMinLtsTest,TestMultipleFragment)3080 TEST_F(VintfObjectLatestMinLtsTest, TestMultipleFragment) {
3081 SetUpMockSystemMatrices({
3082 android::base::StringPrintf(systemMatrixLatestMinLtsFormat, kMetaVersionStr.c_str(),
3083 to_string(Level::S).c_str(), "4.19.191", "5.4.86", "5.10.43"),
3084 android::base::StringPrintf(systemMatrixLatestMinLtsFormat, kMetaVersionStr.c_str(),
3085 to_string(Level::S).c_str(), "5.4.86", "5.10.107", "5.15.41"),
3086 });
3087 EXPECT_THAT(vintfObject->getLatestMinLtsAtFcmVersion(Level::S),
3088 HasValue(KernelVersion{5, 15, 41}));
3089 }
3090
3091 } // namespace testing
3092 } // namespace vintf
3093 } // namespace android
3094
main(int argc,char ** argv)3095 int main(int argc, char** argv) {
3096 #ifndef LIBVINTF_TARGET
3097 // Silence logs on host because they pollute the gtest output. Negative tests writes a lot
3098 // of warning and error logs.
3099 android::base::SetMinimumLogSeverity(android::base::LogSeverity::FATAL);
3100 #endif
3101
3102 ::testing::InitGoogleMock(&argc, argv);
3103 return RUN_ALL_TESTS();
3104 }
3105