1 /*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "LibVintfTest"
18
19 #include <algorithm>
20 #include <functional>
21 #include <vector>
22
23 #include <android-base/logging.h>
24 #include <android-base/parseint.h>
25 #include <android-base/stringprintf.h>
26 #include <android-base/strings.h>
27 #include <gmock/gmock.h>
28 #include <gtest/gtest.h>
29
30 #include <vintf/CompatibilityMatrix.h>
31 #include <vintf/KernelConfigParser.h>
32 #include <vintf/VintfObject.h>
33 #include <vintf/parse_string.h>
34 #include <vintf/parse_xml.h>
35 #include "constants-private.h"
36 #include "parse_xml_for_test.h"
37 #include "parse_xml_internal.h"
38 #include "test_constants.h"
39 #include "utils.h"
40
41 using android::base::StringPrintf;
42 using ::testing::Combine;
43 using ::testing::ElementsAre;
44 using ::testing::Eq;
45 using ::testing::HasSubstr;
46 using ::testing::IsEmpty;
47 using ::testing::Optional;
48 using ::testing::Property;
49 using ::testing::Range;
50 using ::testing::SizeIs;
51 using ::testing::TestParamInfo;
52
53 using std::string_literals::operator""s;
54
55 namespace android {
56 namespace vintf {
57
58 #define EXPECT_IN(sub, str) EXPECT_THAT(str, HasSubstr(sub))
59
60 struct LibVintfTest : public ::testing::Test {
61 public:
SetUpandroid::vintf::LibVintfTest62 virtual void SetUp() override {
63 }
TearDownandroid::vintf::LibVintfTest64 virtual void TearDown() override {
65 }
addandroid::vintf::LibVintfTest66 bool add(CompatibilityMatrix &cm, MatrixHal &&hal) {
67 return cm.add(std::move(hal));
68 }
addandroid::vintf::LibVintfTest69 bool add(CompatibilityMatrix &cm, MatrixKernel &&kernel) {
70 std::string error;
71 bool success = cm.addKernel(std::move(kernel), &error);
72 EXPECT_EQ(success, error == "") << "success: " << success << ", error: " << error;
73 return success;
74 }
addandroid::vintf::LibVintfTest75 bool add(HalManifest& vm, ManifestHal&& hal) { return vm.add(std::move(hal), nullptr); }
addXmlFileandroid::vintf::LibVintfTest76 void addXmlFile(CompatibilityMatrix& cm, std::string name, VersionRange range) {
77 MatrixXmlFile f;
78 f.mName = name;
79 f.mVersionRange = range;
80 f.mFormat = XmlSchemaFormat::DTD;
81 cm.addXmlFile(std::move(f));
82 }
setandroid::vintf::LibVintfTest83 void set(CompatibilityMatrix &cm, Sepolicy &&sepolicy) {
84 cm.framework.mSepolicy = sepolicy;
85 }
setandroid::vintf::LibVintfTest86 void set(CompatibilityMatrix &cm, SchemaType type) {
87 cm.mType = type;
88 }
setandroid::vintf::LibVintfTest89 void set(CompatibilityMatrix &cm, VndkVersionRange &&range, std::set<std::string> &&libs) {
90 cm.device.mVndk.mVersionRange = range;
91 cm.device.mVndk.mLibraries = libs;
92 }
setAvbandroid::vintf::LibVintfTest93 void setAvb(RuntimeInfo &ki, Version vbmeta, Version boot) {
94 ki.mBootVbmetaAvbVersion = vbmeta;
95 ki.mBootAvbVersion = boot;
96 }
setAvbandroid::vintf::LibVintfTest97 void setAvb(CompatibilityMatrix &cm, Version &&avbVersion) {
98 cm.framework.mAvbMetaVersion = avbVersion;
99 }
getAvbandroid::vintf::LibVintfTest100 Version getAvb(CompatibilityMatrix &cm) {
101 return cm.framework.mAvbMetaVersion;
102 }
getAnyHalandroid::vintf::LibVintfTest103 const ManifestHal *getAnyHal(HalManifest &vm, const std::string &name) {
104 return vm.getAnyHal(name);
105 }
getAnyHalandroid::vintf::LibVintfTest106 MatrixHal *getAnyHal(CompatibilityMatrix &cm, const std::string &name) {
107 return cm.getAnyHal(name);
108 }
getHalsandroid::vintf::LibVintfTest109 ConstMultiMapValueIterable<std::string, ManifestHal> getHals(const HalManifest& vm) {
110 return vm.getHals();
111 }
getHalsandroid::vintf::LibVintfTest112 std::vector<const ManifestHal*> getHals(const HalManifest& vm, const std::string& name) {
113 return vm.getHals(name);
114 }
getHalsandroid::vintf::LibVintfTest115 std::vector<const MatrixHal*> getHals(const CompatibilityMatrix& cm, const std::string& name) {
116 return cm.getHals(name);
117 }
isValidandroid::vintf::LibVintfTest118 bool isValid(const ManifestHal &mh) {
119 return mh.isValid();
120 }
getKernelsandroid::vintf::LibVintfTest121 std::vector<MatrixKernel>& getKernels(CompatibilityMatrix& cm) { return cm.framework.mKernels; }
addAllHalsAsOptionalandroid::vintf::LibVintfTest122 bool addAllHalsAsOptional(CompatibilityMatrix* cm1, CompatibilityMatrix* cm2, std::string* e) {
123 return cm1->addAllHalsAsOptional(cm2, e);
124 }
addAllXmlFilesAsOptionalandroid::vintf::LibVintfTest125 bool addAllXmlFilesAsOptional(CompatibilityMatrix* cm1, CompatibilityMatrix* cm2,
126 std::string* e) {
127 return cm1->addAllXmlFilesAsOptional(cm2, e);
128 }
checkUnusedHalsandroid::vintf::LibVintfTest129 std::set<std::string> checkUnusedHals(const HalManifest& m, const CompatibilityMatrix& cm) {
130 return m.checkUnusedHals(cm, {});
131 }
getLevelandroid::vintf::LibVintfTest132 Level getLevel(const KernelInfo& ki) { return ki.level(); }
parseGkiKernelReleaseandroid::vintf::LibVintfTest133 static status_t parseGkiKernelRelease(RuntimeInfo::FetchFlags flags,
134 const std::string& kernelRelease, KernelVersion* version,
135 Level* kernelLevel) {
136 return RuntimeInfo::parseGkiKernelRelease(flags, kernelRelease, version, kernelLevel);
137 }
138
testHalInterfacesandroid::vintf::LibVintfTest139 std::map<std::string, HalInterface> testHalInterfaces() {
140 HalInterface intf("IFoo", {"default"});
141 std::map<std::string, HalInterface> map;
142 map[intf.name()] = intf;
143 return map;
144 }
145
createManifestHalandroid::vintf::LibVintfTest146 ManifestHal createManifestHal(HalFormat format, std::string name, TransportArch ta,
147 ExclusiveTo exclusiveTo,
148 const std::set<FqInstance>& fqInstances) {
149 ManifestHal ret;
150 ret.format = format;
151 ret.name = std::move(name);
152 // AIDL versions are stored in the versions field instead of only in the
153 // FqInstance
154 if (format == HalFormat::AIDL) {
155 for (const auto& fq : fqInstances) {
156 auto [major, minor] = fq.getVersion();
157 ret.versions.push_back({major, minor});
158 }
159 }
160 ret.transportArch = ta;
161 ret.exclusiveTo = exclusiveTo;
162 std::string error;
163 EXPECT_TRUE(ret.insertInstances(fqInstances, false, &error)) << error;
164 return ret;
165 }
166
testDeviceManifestWithSepolicyandroid::vintf::LibVintfTest167 HalManifest testDeviceManifestWithSepolicy(SepolicyVersion sepolicyVersion) {
168 HalManifest vm;
169 vm.mType = SchemaType::DEVICE;
170 vm.device.mSepolicyVersion = sepolicyVersion;
171 vm.add(createManifestHal(HalFormat::HIDL, "android.hardware.camera",
172 {Transport::HWBINDER, Arch::ARCH_EMPTY}, ExclusiveTo::EMPTY,
173 {
174 *FqInstance::from(2, 0, "ICamera", "legacy/0"),
175 *FqInstance::from(2, 0, "ICamera", "default"),
176 *FqInstance::from(2, 0, "IBetterCamera", "camera"),
177 }));
178 vm.add(createManifestHal(HalFormat::HIDL, "android.hardware.nfc",
179 {Transport::PASSTHROUGH, Arch::ARCH_32_64}, ExclusiveTo::EMPTY,
180 std::set({*FqInstance::from(1, 0, "INfc", "default")})));
181
182 return vm;
183 }
testDeviceManifestandroid::vintf::LibVintfTest184 HalManifest testDeviceManifest() { return testDeviceManifestWithSepolicy({25, 0}); }
testDeviceManifestWithXmlFileandroid::vintf::LibVintfTest185 HalManifest testDeviceManifestWithXmlFile() {
186 HalManifest vm = testDeviceManifest();
187 ManifestXmlFile xmlFile;
188 xmlFile.mName = "media_profile";
189 xmlFile.mVersion = {1, 0};
190 vm.addXmlFile(std::move(xmlFile));
191 return vm;
192 }
testFrameworkManfiestandroid::vintf::LibVintfTest193 HalManifest testFrameworkManfiest() {
194 HalManifest vm;
195 vm.mType = SchemaType::FRAMEWORK;
196 vm.add(createManifestHal(
197 HalFormat::HIDL, "android.hidl.manager", {Transport::HWBINDER, Arch::ARCH_EMPTY},
198 ExclusiveTo::EMPTY, std::set({*FqInstance::from(1, 0, "IServiceManager", "default")})));
199 Vndk vndk2505;
200 vndk2505.mVersionRange = {25, 0, 5};
201 vndk2505.mLibraries = {"libjpeg.so", "libbase.so"};
202 Vndk vndk2513;
203 vndk2513.mVersionRange = {25, 1, 3};
204 vndk2513.mLibraries = {"libjpeg.so", "libbase.so", "libtinyxml2.so"};
205 vm.framework.mVndks = { std::move(vndk2505), std::move(vndk2513) };
206
207 return vm;
208 }
testRuntimeInfoandroid::vintf::LibVintfTest209 RuntimeInfo testRuntimeInfo() {
210 RuntimeInfo info;
211 info.mOsName = "Linux";
212 info.mNodeName = "localhost";
213 info.mOsRelease = "3.18.31-g936f9a479d0f";
214 info.mOsVersion = "#4 SMP PREEMPT Wed Feb 1 18:10:52 PST 2017";
215 info.mHardwareId = "aarch64";
216 info.mKernelSepolicyVersion = 30;
217 info.mKernel = testKernelInfo();
218 setAvb(info, {2, 1}, {2, 1});
219 return info;
220 }
testKernelInfoandroid::vintf::LibVintfTest221 KernelInfo testKernelInfo() {
222 KernelInfo info;
223 info.mVersion = {3, 18, 31};
224 info.mConfigs = {{"CONFIG_64BIT", "y"},
225 {"CONFIG_ANDROID_BINDER_DEVICES", "\"binder,hwbinder\""},
226 {"CONFIG_ARCH_MMAP_RND_BITS", "24"},
227 {"CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES", "\"\""},
228 {"CONFIG_ILLEGAL_POINTER_VALUE", "0xdead000000000000"}};
229 return info;
230 }
fetchManifestandroid::vintf::LibVintfTest231 status_t fetchManifest(HalManifest& manifest, FileSystem* files, const std::string& path,
232 std::string* error) {
233 return manifest.fetchAllInformation(files, path, error);
234 }
235 };
236
237 // clang-format off
238
TEST_F(LibVintfTest,ArchOperatorOr)239 TEST_F(LibVintfTest, ArchOperatorOr) {
240 Arch a = Arch::ARCH_EMPTY;
241 a |= Arch::ARCH_32;
242 EXPECT_EQ(Arch::ARCH_32, a);
243
244 a |= Arch::ARCH_64;
245 EXPECT_EQ(Arch::ARCH_32_64, a);
246
247 a = Arch::ARCH_EMPTY;
248 a |= Arch::ARCH_64;
249 EXPECT_EQ(Arch::ARCH_64, a);
250 }
251
TEST_F(LibVintfTest,Stringify)252 TEST_F(LibVintfTest, Stringify) {
253 HalManifest vm = testDeviceManifest();
254 EXPECT_EQ(dump(vm), "hidl/android.hardware.camera/hwbinder/:"
255 "hidl/android.hardware.nfc/passthrough32+64/");
256
257 EXPECT_EQ(to_string(HalFormat::HIDL), "hidl");
258 EXPECT_EQ(to_string(HalFormat::NATIVE), "native");
259
260 VersionRange v(1, 2, 3);
261 EXPECT_EQ(to_string(v), "1.2-3");
262 VersionRange v2;
263 EXPECT_TRUE(parse("1.2-3", &v2));
264 EXPECT_EQ(v, v2);
265 SepolicyVersionRange v3(4, std::nullopt);
266 EXPECT_EQ(to_string(v3), "4");
267 SepolicyVersionRange v4;
268 EXPECT_TRUE(parse("4", &v4));
269 EXPECT_EQ(v3, v4);
270 SepolicyVersion v5(5, std::nullopt);
271 EXPECT_EQ(to_string(v5), "5");
272 SepolicyVersion v6;
273 EXPECT_TRUE(parse("5", &v6));
274 EXPECT_EQ(v5, v6);
275 }
276
TEST_F(LibVintfTest,GetTransport)277 TEST_F(LibVintfTest, GetTransport) {
278 HalManifest vm = testDeviceManifest();
279 EXPECT_EQ(Transport::HWBINDER, vm.getHidlTransport("android.hardware.camera",
280 {2, 0}, "ICamera", "default"));
281 }
282
TEST_F(LibVintfTest,FutureManifestCompatible)283 TEST_F(LibVintfTest, FutureManifestCompatible) {
284 HalManifest expectedManifest;
285 expectedManifest.add(createManifestHal(HalFormat::HIDL,
286 "android.hardware.foo",
287 {Transport::HWBINDER, Arch::ARCH_EMPTY},
288 ExclusiveTo::EMPTY,
289 {*FqInstance::from(1, 0, "IFoo", "default")}));
290 std::string manifestXml =
291 "<manifest " + kMetaVersionStr + " type=\"device\" might_add=\"true\">\n"
292 " <hal format=\"hidl\" attribuet_might_be_added=\"value\">\n"
293 " <name>android.hardware.foo</name>\n"
294 " <transport>hwbinder</transport>\n"
295 " <version>1.0</version>\n"
296 " <interface>\n"
297 " <name>IFoo</name>\n"
298 " <instance>default</instance>\n"
299 " </interface>\n"
300 " </hal>\n"
301 " <tag_might_be_added/>\n"
302 "</manifest>\n";
303 HalManifest manifest;
304 EXPECT_TRUE(fromXml(&manifest, manifestXml));
305 EXPECT_EQ(expectedManifest, manifest) << dump(expectedManifest)
306 << " is expected but got " << dump(manifest);
307 }
308
TEST_F(LibVintfTest,HalManifestConverter)309 TEST_F(LibVintfTest, HalManifestConverter) {
310 HalManifest vm = testDeviceManifest();
311 std::string xml =
312 toXml(vm, SerializeFlags::HALS_ONLY.enableSepolicy());
313 EXPECT_EQ(xml,
314 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
315 " <hal format=\"hidl\">\n"
316 " <name>android.hardware.camera</name>\n"
317 " <transport>hwbinder</transport>\n"
318 " <fqname>@2.0::IBetterCamera/camera</fqname>\n"
319 " <fqname>@2.0::ICamera/default</fqname>\n"
320 " <fqname>@2.0::ICamera/legacy/0</fqname>\n"
321 " </hal>\n"
322 " <hal format=\"hidl\">\n"
323 " <name>android.hardware.nfc</name>\n"
324 " <transport arch=\"32+64\">passthrough</transport>\n"
325 " <fqname>@1.0::INfc/default</fqname>\n"
326 " </hal>\n"
327 " <sepolicy>\n"
328 " <version>25.0</version>\n"
329 " </sepolicy>\n"
330 "</manifest>\n");
331 HalManifest vm2;
332 EXPECT_TRUE(fromXml(&vm2, xml));
333 EXPECT_EQ(vm, vm2);
334 }
335
TEST_F(LibVintfTest,HalManifestConverterWithVfrcSepolicy)336 TEST_F(LibVintfTest, HalManifestConverterWithVfrcSepolicy) {
337 HalManifest vm = testDeviceManifestWithSepolicy({202404, std::nullopt});
338 std::string xml =
339 toXml(vm, SerializeFlags::HALS_ONLY.enableSepolicy());
340 EXPECT_EQ(xml,
341 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
342 " <hal format=\"hidl\">\n"
343 " <name>android.hardware.camera</name>\n"
344 " <transport>hwbinder</transport>\n"
345 " <fqname>@2.0::IBetterCamera/camera</fqname>\n"
346 " <fqname>@2.0::ICamera/default</fqname>\n"
347 " <fqname>@2.0::ICamera/legacy/0</fqname>\n"
348 " </hal>\n"
349 " <hal format=\"hidl\">\n"
350 " <name>android.hardware.nfc</name>\n"
351 " <transport arch=\"32+64\">passthrough</transport>\n"
352 " <fqname>@1.0::INfc/default</fqname>\n"
353 " </hal>\n"
354 " <sepolicy>\n"
355 " <version>202404</version>\n"
356 " </sepolicy>\n"
357 "</manifest>\n");
358 HalManifest vm2;
359 EXPECT_TRUE(fromXml(&vm2, xml));
360 EXPECT_EQ(vm, vm2);
361 }
362
TEST_F(LibVintfTest,HalManifestConverterWithInterface)363 TEST_F(LibVintfTest, HalManifestConverterWithInterface) {
364 HalManifest vm = testDeviceManifest();
365 std::string xml =
366 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
367 " <hal format=\"hidl\">\n"
368 " <name>android.hardware.camera</name>\n"
369 " <transport>hwbinder</transport>\n"
370 " <version>2.0</version>\n"
371 " <interface>\n"
372 " <name>IBetterCamera</name>\n"
373 " <instance>camera</instance>\n"
374 " </interface>\n"
375 " <interface>\n"
376 " <name>ICamera</name>\n"
377 " <instance>default</instance>\n"
378 " <instance>legacy/0</instance>\n"
379 " </interface>\n"
380 " </hal>\n"
381 " <hal format=\"hidl\">\n"
382 " <name>android.hardware.nfc</name>\n"
383 " <transport arch=\"32+64\">passthrough</transport>\n"
384 " <version>1.0</version>\n"
385 " <interface>\n"
386 " <name>INfc</name>\n"
387 " <instance>default</instance>\n"
388 " </interface>\n"
389 " </hal>\n"
390 " <sepolicy>\n"
391 " <version>25.0</version>\n"
392 " </sepolicy>\n"
393 "</manifest>\n";
394 HalManifest vm2;
395 EXPECT_TRUE(fromXml(&vm2, xml));
396 EXPECT_EQ(vm, vm2);
397 }
398
TEST_F(LibVintfTest,HalManifestConverterFramework)399 TEST_F(LibVintfTest, HalManifestConverterFramework) {
400 HalManifest vm = testFrameworkManfiest();
401 std::string xml = toXml(vm, SerializeFlags::HALS_ONLY.enableVndk());
402 EXPECT_EQ(xml,
403 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
404 " <hal format=\"hidl\">\n"
405 " <name>android.hidl.manager</name>\n"
406 " <transport>hwbinder</transport>\n"
407 " <fqname>@1.0::IServiceManager/default</fqname>\n"
408 " </hal>\n"
409 " <vndk>\n"
410 " <version>25.0.5</version>\n"
411 " <library>libbase.so</library>\n"
412 " <library>libjpeg.so</library>\n"
413 " </vndk>\n"
414 " <vndk>\n"
415 " <version>25.1.3</version>\n"
416 " <library>libbase.so</library>\n"
417 " <library>libjpeg.so</library>\n"
418 " <library>libtinyxml2.so</library>\n"
419 " </vndk>\n"
420 "</manifest>\n");
421 HalManifest vm2;
422 EXPECT_TRUE(fromXml(&vm2, xml));
423 EXPECT_EQ(vm, vm2);
424 }
425
TEST_F(LibVintfTest,HalManifestConverterFrameworkWithInterface)426 TEST_F(LibVintfTest, HalManifestConverterFrameworkWithInterface) {
427 HalManifest vm = testFrameworkManfiest();
428 std::string xml =
429 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
430 " <hal format=\"hidl\">\n"
431 " <name>android.hidl.manager</name>\n"
432 " <transport>hwbinder</transport>\n"
433 " <version>1.0</version>\n"
434 " <interface>\n"
435 " <name>IServiceManager</name>\n"
436 " <instance>default</instance>\n"
437 " </interface>\n"
438 " </hal>\n"
439 " <vndk>\n"
440 " <version>25.0.5</version>\n"
441 " <library>libbase.so</library>\n"
442 " <library>libjpeg.so</library>\n"
443 " </vndk>\n"
444 " <vndk>\n"
445 " <version>25.1.3</version>\n"
446 " <library>libbase.so</library>\n"
447 " <library>libjpeg.so</library>\n"
448 " <library>libtinyxml2.so</library>\n"
449 " </vndk>\n"
450 "</manifest>\n";
451 HalManifest vm2;
452 EXPECT_TRUE(fromXml(&vm2, xml));
453 EXPECT_EQ(vm, vm2);
454 }
455
TEST_F(LibVintfTest,HalManifestOptional)456 TEST_F(LibVintfTest, HalManifestOptional) {
457 HalManifest vm;
458 EXPECT_TRUE(fromXml(&vm,
459 "<manifest " + kMetaVersionStr + " type=\"device\"></manifest>"));
460 EXPECT_TRUE(fromXml(&vm,
461 "<manifest version=\"5.0\" type=\"device\">"
462 " <hal>"
463 " <name>android.hidl.manager</name>"
464 " <transport>hwbinder</transport>"
465 " <version>1.0</version>"
466 " </hal>"
467 "</manifest>"));
468 EXPECT_FALSE(fromXml(&vm,
469 "<manifest version=\"5.0\" type=\"device\">"
470 " <hal>"
471 " <name>android.hidl.manager</name>"
472 " <version>1.0</version>"
473 " </hal>"
474 "</manifest>"));
475 }
476
TEST_F(LibVintfTest,HalManifestNativeNoInstance)477 TEST_F(LibVintfTest, HalManifestNativeNoInstance) {
478 std::string error;
479 HalManifest vm;
480 EXPECT_TRUE(fromXml(&vm,
481 "<manifest " + kMetaVersionStr + " type=\"device\">"
482 " <hal format=\"native\">"
483 " <name>foo</name>"
484 " <version>1.0</version>"
485 " </hal>"
486 "</manifest>", &error)) << error;
487 }
488
TEST_F(LibVintfTest,HalManifestNativeWithTransport)489 TEST_F(LibVintfTest, HalManifestNativeWithTransport) {
490 std::string error;
491 HalManifest vm;
492 EXPECT_FALSE(fromXml(&vm,
493 "<manifest " + kMetaVersionStr + " type=\"device\">"
494 " <hal format=\"native\">"
495 " <name>foo</name>"
496 " <version>1.0</version>"
497 " <transport>hwbinder</transport>"
498 " </hal>"
499 "</manifest>", &error));
500 EXPECT_THAT(error, HasSubstr("Native HAL 'foo' should not have <transport> defined"));
501 }
502
503 // clang-format on
504
TEST_F(LibVintfTest,HalManifestNativeInstancesWithInterface)505 TEST_F(LibVintfTest, HalManifestNativeInstancesWithInterface) {
506 std::string error;
507 HalManifest manifest;
508 std::string xml = "<manifest " + kMetaVersionStr + R"( type="device">
509 <hal format="native">
510 <name>foo</name>
511 <version>1.0</version>
512 <interface>
513 <name>IFoo</name>
514 <instance>inst</instance>
515 </interface>
516 </hal>
517 </manifest>
518 )";
519
520 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
521
522 manifest.forEachInstance([](const auto& manifestInstance) {
523 EXPECT_EQ(manifestInstance.package(), "foo");
524 EXPECT_EQ(manifestInstance.version(), Version(1, 0));
525 EXPECT_EQ(manifestInstance.interface(), "IFoo");
526 EXPECT_EQ(manifestInstance.instance(), "inst");
527 return true; // continue
528 });
529 }
530
TEST_F(LibVintfTest,HalManifestNativeFqInstancesWithInterface)531 TEST_F(LibVintfTest, HalManifestNativeFqInstancesWithInterface) {
532 std::string error;
533 HalManifest manifest;
534 std::string xml = "<manifest " + kMetaVersionStr + R"( type="device">
535 <hal format="native">
536 <name>foo</name>
537 <fqname>@1.0::IFoo/inst</fqname>
538 </hal>
539 </manifest>
540 )";
541
542 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
543
544 manifest.forEachInstance([](const auto& manifestInstance) {
545 EXPECT_EQ(manifestInstance.package(), "foo");
546 EXPECT_EQ(manifestInstance.version(), Version(1, 0));
547 EXPECT_EQ(manifestInstance.interface(), "IFoo");
548 EXPECT_EQ(manifestInstance.instance(), "inst");
549 return true; // continue
550 });
551 }
552
TEST_F(LibVintfTest,HalManifestNativeInstancesNoInterface)553 TEST_F(LibVintfTest, HalManifestNativeInstancesNoInterface) {
554 std::string error;
555 HalManifest manifest;
556 std::string xml = "<manifest " + kMetaVersionStr + R"( type="device">
557 <hal format="native">
558 <name>foo</name>
559 <version>1.0</version>
560 <interface>
561 <instance>inst</instance>
562 </interface>
563 </hal>
564 </manifest>
565 )";
566
567 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
568
569 manifest.forEachInstance([](const auto& manifestInstance) {
570 EXPECT_EQ(manifestInstance.package(), "foo");
571 EXPECT_EQ(manifestInstance.version(), Version(1, 0));
572 EXPECT_EQ(manifestInstance.interface(), "");
573 EXPECT_EQ(manifestInstance.instance(), "inst");
574 return true; // continue
575 });
576 }
577
TEST_F(LibVintfTest,HalManifestNativeFqInstancesNoInterface)578 TEST_F(LibVintfTest, HalManifestNativeFqInstancesNoInterface) {
579 std::string error;
580 HalManifest manifest;
581 std::string xml = "<manifest " + kMetaVersionStr + R"( type="device">
582 <hal format="native">
583 <name>foo</name>
584 <fqname>@1.0/inst</fqname>
585 </hal>
586 </manifest>
587 )";
588
589 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
590
591 manifest.forEachInstance([](const auto& manifestInstance) {
592 EXPECT_EQ(manifestInstance.package(), "foo");
593 EXPECT_EQ(manifestInstance.version(), Version(1, 0));
594 EXPECT_EQ(manifestInstance.interface(), "");
595 EXPECT_EQ(manifestInstance.instance(), "inst");
596 return true; // continue
597 });
598 }
599
TEST_F(LibVintfTest,QueryNativeInstances)600 TEST_F(LibVintfTest, QueryNativeInstances) {
601 std::string error;
602 HalManifest manifest;
603 std::string xml = "<manifest " + kMetaVersionStr + R"( type="device">
604 <hal format="native">
605 <name>foo</name>
606 <version>1.0</version>
607 <interface>
608 <instance>fooinst</instance>
609 </interface>
610 </hal>
611 <hal format="native">
612 <name>bar</name>
613 <fqname>@1.0::I/barinst</fqname>
614 </hal>
615 </manifest>
616 )";
617 ASSERT_TRUE(fromXml(&manifest, xml, &error)) << error;
618
619 EXPECT_EQ(manifest.getNativeInstances("foo"), std::set<std::string>{"fooinst"});
620 EXPECT_TRUE(manifest.hasNativeInstance("foo", "fooinst"));
621 EXPECT_EQ(manifest.getNativeInstances("bar"), std::set<std::string>{"barinst"});
622 EXPECT_TRUE(manifest.hasNativeInstance("bar", "barinst"));
623
624 EXPECT_EQ(manifest.getNativeInstances("baz"), std::set<std::string>{});
625 EXPECT_FALSE(manifest.hasNativeInstance("baz", "bazinst"));
626 }
627
628 // clang-format off
629
TEST_F(LibVintfTest,HalManifestDuplicate)630 TEST_F(LibVintfTest, HalManifestDuplicate) {
631 HalManifest vm;
632 EXPECT_FALSE(fromXml(&vm,
633 "<manifest " + kMetaVersionStr + " type=\"device\">"
634 " <hal>"
635 " <name>android.hidl.manager</name>"
636 " <transport>hwbinder</transport>"
637 " <version>1.0</version>"
638 " <version>1.1</version>"
639 " </hal>"
640 "</manifest>"))
641 << "Should not allow duplicated major version in <hal>";
642 EXPECT_FALSE(fromXml(&vm,
643 "<manifest " + kMetaVersionStr + " type=\"device\">"
644 " <hal>"
645 " <name>android.hidl.manager</name>"
646 " <transport>hwbinder</transport>"
647 " <version>1.0</version>"
648 " </hal>"
649 " <hal>"
650 " <name>android.hidl.manager</name>"
651 " <transport arch=\"32+64\">passthrough</transport>"
652 " <version>1.1</version>"
653 " </hal>"
654 "</manifest>"))
655 << "Should not allow duplicated major version across <hal>";
656 }
657
TEST_F(LibVintfTest,HalManifestGetTransport)658 TEST_F(LibVintfTest, HalManifestGetTransport) {
659 HalManifest vm;
660 EXPECT_TRUE(fromXml(&vm,
661 "<manifest " + kMetaVersionStr + " type=\"device\">"
662 " <hal>"
663 " <name>android.hidl.manager</name>"
664 " <transport>hwbinder</transport>"
665 " <version>1.0</version>"
666 " <interface>"
667 " <name>IServiceManager</name>"
668 " <instance>default</instance>"
669 " </interface>"
670 " </hal>"
671 " <hal>"
672 " <name>android.hidl.manager</name>"
673 " <transport arch=\"32+64\">passthrough</transport>"
674 " <version>2.1</version>"
675 " <interface>"
676 " <name>IServiceManager</name>"
677 " <instance>default</instance>"
678 " </interface>"
679 " </hal>"
680 "</manifest>"));
681 EXPECT_EQ(Transport::PASSTHROUGH,
682 vm.getHidlTransport("android.hidl.manager", {2, 1}, "IServiceManager", "default"));
683 EXPECT_EQ(Transport::PASSTHROUGH,
684 vm.getHidlTransport("android.hidl.manager", {2, 0}, "IServiceManager", "default"));
685 EXPECT_EQ(Transport::EMPTY,
686 vm.getHidlTransport("android.hidl.manager", {2, 2}, "IServiceManager", "default"));
687 EXPECT_EQ(Transport::HWBINDER,
688 vm.getHidlTransport("android.hidl.manager", {1, 0}, "IServiceManager", "default"));
689 }
690
TEST_F(LibVintfTest,HalManifestInstances)691 TEST_F(LibVintfTest, HalManifestInstances) {
692 HalManifest vm = testDeviceManifest();
693 EXPECT_EQ(vm.getHidlInstances("android.hardware.camera", {2, 0}, "ICamera"),
694 std::set<std::string>({"default", "legacy/0"}));
695 EXPECT_EQ(vm.getHidlInstances("android.hardware.camera", {2, 0}, "IBetterCamera"),
696 std::set<std::string>({"camera"}));
697 EXPECT_EQ(vm.getHidlInstances("android.hardware.camera", {2, 0}, "INotExist"),
698 std::set<std::string>({}));
699 EXPECT_EQ(vm.getHidlInstances("android.hardware.nfc", {1, 0}, "INfc"),
700 std::set<std::string>({"default"}));
701
702 EXPECT_TRUE(vm.hasHidlInstance("android.hardware.camera", {2, 0}, "ICamera", "default"));
703 EXPECT_TRUE(vm.hasHidlInstance("android.hardware.camera", {2, 0}, "ICamera", "legacy/0"));
704 EXPECT_TRUE(vm.hasHidlInstance("android.hardware.camera", {2, 0}, "IBetterCamera", "camera"));
705 EXPECT_TRUE(vm.hasHidlInstance("android.hardware.nfc", {1, 0}, "INfc", "default"));
706
707 EXPECT_FALSE(vm.hasHidlInstance("android.hardware.camera", {2, 0}, "INotExist", "default"));
708 EXPECT_FALSE(vm.hasHidlInstance("android.hardware.camera", {2, 0}, "ICamera", "notexist"));
709 EXPECT_FALSE(vm.hasHidlInstance("android.hardware.camera", {2, 0}, "IBetterCamera", "default"));
710 EXPECT_FALSE(vm.hasHidlInstance("android.hardware.camera", {2, 0}, "INotExist", "notexist"));
711 EXPECT_FALSE(vm.hasHidlInstance("android.hardware.nfc", {1, 0}, "INfc", "notexist"));
712 }
713
TEST_F(LibVintfTest,VersionConverter)714 TEST_F(LibVintfTest, VersionConverter) {
715 Version v(3, 6);
716 std::string xml = toXml(v);
717 EXPECT_EQ(xml, "<version>3.6</version>\n");
718 Version v2;
719 EXPECT_TRUE(fromXml(&v2, xml));
720 EXPECT_EQ(v, v2);
721
722 SepolicyVersion v3(202404, std::nullopt);
723 std::string xml2 = toXml(v3);
724 EXPECT_EQ(xml2, "<version>202404</version>\n");
725 SepolicyVersion v4;
726 EXPECT_TRUE(fromXml(&v4, xml2));
727 EXPECT_EQ(v3, v4);
728 }
729
insert(std::map<std::string,HalInterface> * map,HalInterface && intf)730 static bool insert(std::map<std::string, HalInterface>* map, HalInterface&& intf) {
731 std::string name{intf.name()};
732 return map->emplace(std::move(name), std::move(intf)).second;
733 }
734
TEST_F(LibVintfTest,MatrixHalConverter)735 TEST_F(LibVintfTest, MatrixHalConverter) {
736 MatrixHal mh{HalFormat::NATIVE, "android.hardware.camera",
737 {{VersionRange(1,2,3), VersionRange(4,5,6)}},
738 ExclusiveTo::EMPTY, false /* updatableViaApex */, {}};
739 EXPECT_TRUE(insert(&mh.interfaces, {"IBetterCamera", {"default", "great"}}));
740 EXPECT_TRUE(insert(&mh.interfaces, {"ICamera", {"default"}}));
741 std::string xml = toXml(mh);
742 EXPECT_EQ(xml,
743 "<hal format=\"native\">\n"
744 " <name>android.hardware.camera</name>\n"
745 " <version>1.2-3</version>\n"
746 " <version>4.5-6</version>\n"
747 " <interface>\n"
748 " <name>IBetterCamera</name>\n"
749 " <instance>default</instance>\n"
750 " <instance>great</instance>\n"
751 " </interface>\n"
752 " <interface>\n"
753 " <name>ICamera</name>\n"
754 " <instance>default</instance>\n"
755 " </interface>\n"
756 "</hal>\n");
757 MatrixHal mh2;
758 EXPECT_TRUE(fromXml(&mh2, xml));
759 EXPECT_EQ(mh, mh2);
760 }
761
TEST_F(LibVintfTest,KernelConfigTypedValueConverter)762 TEST_F(LibVintfTest, KernelConfigTypedValueConverter) {
763
764 KernelConfigTypedValue converted;
765
766 auto testOne = [] (const KernelConfigTypedValue &original,
767 const std::string &expectXml) {
768 std::string xml;
769 KernelConfigTypedValue converted;
770 xml = toXml(original);
771 EXPECT_EQ(xml, expectXml);
772 EXPECT_TRUE(fromXml(&converted, xml));
773 EXPECT_EQ(original, converted);
774 };
775
776 auto testParse = [] (const KernelConfigTypedValue &original,
777 const std::string &xml) {
778 KernelConfigTypedValue converted;
779 EXPECT_TRUE(fromXml(&converted, xml));
780 EXPECT_EQ(original, converted);
781 };
782
783 testOne(KernelConfigTypedValue("stringvalue"),
784 "<value type=\"string\">stringvalue</value>\n");
785 testOne(KernelConfigTypedValue(""),
786 "<value type=\"string\"></value>\n");
787
788 testOne(KernelConfigTypedValue(Tristate::YES),
789 "<value type=\"tristate\">y</value>\n");
790 testOne(KernelConfigTypedValue(Tristate::NO),
791 "<value type=\"tristate\">n</value>\n");
792 testOne(KernelConfigTypedValue(Tristate::MODULE),
793 "<value type=\"tristate\">m</value>\n");
794 EXPECT_FALSE(fromXml(&converted,
795 "<value type=\"tristate\">q</value>\n"));
796
797 testOne(KernelConfigTypedValue(KernelConfigRangeValue{4, 20}),
798 "<value type=\"range\">4-20</value>\n");
799 testOne(KernelConfigTypedValue(KernelConfigRangeValue{0, UINT64_MAX}),
800 "<value type=\"range\">0-18446744073709551615</value>\n");
801 testParse(KernelConfigTypedValue(KernelConfigRangeValue{0, UINT64_MAX}),
802 "<value type=\"range\">0x0-0xffffffffffffffff</value>\n");
803
804 EXPECT_FALSE(fromXml(&converted,
805 "<value type=\"int\">-18446744073709551616</value>\n"));
806
807 testOne(KernelConfigTypedValue(INT64_MIN),
808 "<value type=\"int\">-9223372036854775808</value>\n");
809 testParse(KernelConfigTypedValue(INT64_MIN),
810 "<value type=\"int\">0x8000000000000000</value>\n");
811 testParse(KernelConfigTypedValue(INT64_MIN),
812 "<value type=\"int\">-0X8000000000000000</value>\n");
813
814 testParse(KernelConfigTypedValue(INT64_MIN + 1),
815 "<value type=\"int\">-0X7FFFFFFFFFFFFFFF</value>\n");
816
817 testParse(KernelConfigTypedValue(-0x50),
818 "<value type=\"int\">-0x50</value>\n");
819
820 testOne(KernelConfigTypedValue(0),
821 "<value type=\"int\">0</value>\n");
822
823 // Truncation for underflow.
824 testParse(KernelConfigTypedValue(1),
825 "<value type=\"int\">-0xffffffffffffffff</value>\n");
826 testParse(KernelConfigTypedValue(1),
827 "<value type=\"int\">-18446744073709551615</value>\n");
828
829 testOne(KernelConfigTypedValue(INT64_MAX),
830 "<value type=\"int\">9223372036854775807</value>\n");
831 testParse(KernelConfigTypedValue(INT64_MAX),
832 "<value type=\"int\">0x7FFFFFFFFFFFFFFF</value>\n");
833 // Truncation for underflow.
834 testParse(KernelConfigTypedValue(INT64_MAX),
835 "<value type=\"int\">-9223372036854775809</value>\n");
836
837 testParse(KernelConfigTypedValue(-1),
838 "<value type=\"int\">18446744073709551615</value>\n");
839 testParse(KernelConfigTypedValue(-1),
840 "<value type=\"int\">0xffffffffffffffff</value>\n");
841
842 EXPECT_FALSE(fromXml(&converted,
843 "<value type=\"int\">18446744073709551616</value>\n"));
844 }
845
TEST_F(LibVintfTest,CompatibilityMatrixConverter)846 TEST_F(LibVintfTest, CompatibilityMatrixConverter) {
847 CompatibilityMatrix cm;
848 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE, "android.hardware.camera",
849 {{VersionRange(1,2,3), VersionRange(4,5,6)}},
850 ExclusiveTo::EMPTY, false /* updatableViaApex */,
851 testHalInterfaces()}));
852 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE, "android.hardware.nfc",
853 {{VersionRange(4,5,6), VersionRange(10,11,12)}},
854 ExclusiveTo::EMPTY, false /* updatableViaApex */,
855 testHalInterfaces()}));
856 EXPECT_TRUE(add(cm, MatrixKernel{KernelVersion(3, 18, 22),
857 {KernelConfig{"CONFIG_FOO", Tristate::YES},
858 KernelConfig{"CONFIG_BAR", "stringvalue"}}}));
859 EXPECT_TRUE(add(cm, MatrixKernel{KernelVersion(4, 4, 1),
860 {KernelConfig{"CONFIG_BAZ", 20},
861 KernelConfig{"CONFIG_BAR", KernelConfigRangeValue{3, 5} }}}));
862 set(cm, Sepolicy(30, {{25, 0}, {26, 0, 3}, {202404, std::nullopt}}));
863 setAvb(cm, Version{2, 1});
864 std::string xml = toXml(cm);
865 EXPECT_EQ(xml,
866 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
867 " <hal format=\"native\">\n"
868 " <name>android.hardware.camera</name>\n"
869 " <version>1.2-3</version>\n"
870 " <version>4.5-6</version>\n"
871 " <interface>\n"
872 " <name>IFoo</name>\n"
873 " <instance>default</instance>\n"
874 " </interface>\n"
875 " </hal>\n"
876 " <hal format=\"native\">\n"
877 " <name>android.hardware.nfc</name>\n"
878 " <version>4.5-6</version>\n"
879 " <version>10.11-12</version>\n"
880 " <interface>\n"
881 " <name>IFoo</name>\n"
882 " <instance>default</instance>\n"
883 " </interface>\n"
884 " </hal>\n"
885 " <kernel version=\"3.18.22\">\n"
886 " <config>\n"
887 " <key>CONFIG_FOO</key>\n"
888 " <value type=\"tristate\">y</value>\n"
889 " </config>\n"
890 " <config>\n"
891 " <key>CONFIG_BAR</key>\n"
892 " <value type=\"string\">stringvalue</value>\n"
893 " </config>\n"
894 " </kernel>\n"
895 " <kernel version=\"4.4.1\">\n"
896 " <config>\n"
897 " <key>CONFIG_BAZ</key>\n"
898 " <value type=\"int\">20</value>\n"
899 " </config>\n"
900 " <config>\n"
901 " <key>CONFIG_BAR</key>\n"
902 " <value type=\"range\">3-5</value>\n"
903 " </config>\n"
904 " </kernel>\n"
905 " <sepolicy>\n"
906 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
907 " <sepolicy-version>25.0</sepolicy-version>\n"
908 " <sepolicy-version>26.0-3</sepolicy-version>\n"
909 " <sepolicy-version>202404</sepolicy-version>\n"
910 " </sepolicy>\n"
911 " <avb>\n"
912 " <vbmeta-version>2.1</vbmeta-version>\n"
913 " </avb>\n"
914 "</compatibility-matrix>\n");
915 CompatibilityMatrix cm2;
916 EXPECT_TRUE(fromXml(&cm2, xml));
917 EXPECT_EQ(cm, cm2);
918 }
919
TEST_F(LibVintfTest,DeviceCompatibilityMatrixCoverter)920 TEST_F(LibVintfTest, DeviceCompatibilityMatrixCoverter) {
921 CompatibilityMatrix cm;
922 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE, "android.hidl.manager",
923 {{VersionRange(1,0)}},
924 ExclusiveTo::EMPTY, false /* updatableViaApex */,
925 testHalInterfaces()}));
926 set(cm, SchemaType::DEVICE);
927 set(cm, VndkVersionRange{25,0,1,5}, {"libjpeg.so", "libbase.so"});
928 std::string xml = toXml(cm);
929 EXPECT_EQ(xml,
930 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
931 " <hal format=\"native\">\n"
932 " <name>android.hidl.manager</name>\n"
933 " <version>1.0</version>\n"
934 " <interface>\n"
935 " <name>IFoo</name>\n"
936 " <instance>default</instance>\n"
937 " </interface>\n"
938 " </hal>\n"
939 " <vndk>\n"
940 " <version>25.0.1-5</version>\n"
941 " <library>libbase.so</library>\n"
942 " <library>libjpeg.so</library>\n"
943 " </vndk>\n"
944 "</compatibility-matrix>\n");
945 CompatibilityMatrix cm2;
946 EXPECT_TRUE(fromXml(&cm2, xml));
947 EXPECT_EQ(cm, cm2);
948 }
949
950 // clang-format on
951
TEST_F(LibVintfTest,CompatibilityMatrixDefaultOptionalTrue)952 TEST_F(LibVintfTest, CompatibilityMatrixDefaultOptionalTrue) {
953 auto xml = "<compatibility-matrix " + kMetaVersionStr + R"( type="device">
954 <hal format="aidl">
955 <name>android.foo.bar</name>
956 <version>1</version>
957 <interface>
958 <name>IFoo</name>
959 <instance>default</instance>
960 </interface>
961 </hal>
962 </compatibility-matrix>)";
963 CompatibilityMatrix cm;
964 EXPECT_TRUE(fromXml(&cm, xml));
965 auto hal = getAnyHal(cm, "android.foo.bar");
966 ASSERT_NE(nullptr, hal);
967 }
968
TEST_F(LibVintfTest,IsValid)969 TEST_F(LibVintfTest, IsValid) {
970 EXPECT_TRUE(isValid(ManifestHal()));
971
972 auto invalidHal =
973 createManifestHal(HalFormat::HIDL, "android.hardware.camera",
974 {Transport::PASSTHROUGH, Arch::ARCH_32_64}, ExclusiveTo::EMPTY, {});
975 invalidHal.versions = {{Version(2, 0), Version(2, 1)}};
976
977 EXPECT_FALSE(isValid(invalidHal));
978 HalManifest vm2;
979 EXPECT_FALSE(add(vm2, std::move(invalidHal)));
980 }
981 // clang-format off
982
TEST_F(LibVintfTest,HalManifestGetHalNames)983 TEST_F(LibVintfTest, HalManifestGetHalNames) {
984 HalManifest vm = testDeviceManifest();
985 EXPECT_EQ(vm.getHalNames(), std::set<std::string>(
986 {"android.hardware.camera", "android.hardware.nfc"}));
987 }
988
TEST_F(LibVintfTest,HalManifestGetAllHals)989 TEST_F(LibVintfTest, HalManifestGetAllHals) {
990 HalManifest vm = testDeviceManifest();
991 EXPECT_NE(getAnyHal(vm, "android.hardware.camera"), nullptr);
992 EXPECT_EQ(getAnyHal(vm, "non-existent"), nullptr);
993
994 std::vector<std::string> arr{"android.hardware.camera", "android.hardware.nfc"};
995 size_t i = 0;
996 for (const auto &hal : getHals(vm)) {
997 EXPECT_EQ(hal.name, arr[i++]);
998 }
999 }
1000
1001 // clang-format on
TEST_F(LibVintfTest,HalManifestGetHals)1002 TEST_F(LibVintfTest, HalManifestGetHals) {
1003 HalManifest vm;
1004
1005 EXPECT_TRUE(
1006 add(vm, createManifestHal(HalFormat::HIDL, "android.hardware.camera",
1007 {Transport::HWBINDER, Arch::ARCH_EMPTY}, ExclusiveTo::EMPTY,
1008 {
1009 *FqInstance::from(1, 2, "ICamera", "legacy/0"),
1010 *FqInstance::from(1, 2, "ICamera", "default"),
1011 *FqInstance::from(1, 2, "IBetterCamera", "camera"),
1012 })));
1013 EXPECT_TRUE(
1014 add(vm, createManifestHal(HalFormat::HIDL, "android.hardware.camera",
1015 {Transport::HWBINDER, Arch::ARCH_EMPTY}, ExclusiveTo::EMPTY,
1016 {
1017 *FqInstance::from(2, 0, "ICamera", "legacy/0"),
1018 *FqInstance::from(2, 0, "ICamera", "default"),
1019 *FqInstance::from(2, 0, "IBetterCamera", "camera"),
1020 })));
1021
1022 EXPECT_TRUE(
1023 add(vm, createManifestHal(HalFormat::HIDL, "android.hardware.nfc",
1024 {Transport::PASSTHROUGH, Arch::ARCH_32_64}, ExclusiveTo::EMPTY,
1025 {*FqInstance::from(1, 0, "INfc", "default"),
1026 *FqInstance::from(2, 1, "INfc", "default")})));
1027
1028 ManifestHal expectedCameraHalV1_2 =
1029 createManifestHal(HalFormat::HIDL, "android.hardware.camera",
1030 {Transport::HWBINDER, Arch::ARCH_EMPTY}, ExclusiveTo::EMPTY,
1031 {
1032 *FqInstance::from(1, 2, "ICamera", "legacy/0"),
1033 *FqInstance::from(1, 2, "ICamera", "default"),
1034 *FqInstance::from(1, 2, "IBetterCamera", "camera"),
1035 });
1036 ManifestHal expectedCameraHalV2_0 =
1037 createManifestHal(HalFormat::HIDL, "android.hardware.camera",
1038 {Transport::HWBINDER, Arch::ARCH_EMPTY}, ExclusiveTo::EMPTY,
1039 {
1040 *FqInstance::from(2, 0, "ICamera", "legacy/0"),
1041 *FqInstance::from(2, 0, "ICamera", "default"),
1042 *FqInstance::from(2, 0, "IBetterCamera", "camera"),
1043 });
1044 ManifestHal expectedNfcHal = createManifestHal(
1045 HalFormat::HIDL, "android.hardware.nfc", {Transport::PASSTHROUGH, Arch::ARCH_32_64},
1046 ExclusiveTo::EMPTY,
1047 {*FqInstance::from(1, 0, "INfc", "default"), *FqInstance::from(2, 1, "INfc", "default")});
1048
1049 auto cameraHals = getHals(vm, "android.hardware.camera");
1050 EXPECT_EQ((int)cameraHals.size(), 2);
1051 EXPECT_EQ(*cameraHals[0], expectedCameraHalV1_2);
1052 EXPECT_EQ(*cameraHals[1], expectedCameraHalV2_0);
1053 auto nfcHals = getHals(vm, "android.hardware.nfc");
1054 EXPECT_EQ((int)nfcHals.size(), 1);
1055 EXPECT_EQ(*nfcHals[0], expectedNfcHal);
1056 }
1057 // clang-format off
1058
TEST_F(LibVintfTest,CompatibilityMatrixGetHals)1059 TEST_F(LibVintfTest, CompatibilityMatrixGetHals) {
1060 CompatibilityMatrix cm;
1061 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE,
1062 "android.hardware.camera",
1063 {{VersionRange(1, 2, 3), VersionRange(4, 5, 6)}},
1064 ExclusiveTo::EMPTY,
1065 false /* updatableViaApex */,
1066 testHalInterfaces()}));
1067 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE,
1068 "android.hardware.nfc",
1069 {{VersionRange(4, 5, 6), VersionRange(10, 11, 12)}},
1070 ExclusiveTo::EMPTY,
1071 false /* updatableViaApex */,
1072 testHalInterfaces()}));
1073
1074 MatrixHal expectedCameraHal = MatrixHal{
1075 HalFormat::NATIVE,
1076 "android.hardware.camera",
1077 {{VersionRange(1, 2, 3), VersionRange(4, 5, 6)}},
1078 ExclusiveTo::EMPTY,
1079 false /* updatableViaApex */,
1080 testHalInterfaces(),
1081 };
1082 MatrixHal expectedNfcHal = MatrixHal{HalFormat::NATIVE,
1083 "android.hardware.nfc",
1084 {{VersionRange(4, 5, 6), VersionRange(10, 11, 12)}},
1085 ExclusiveTo::EMPTY,
1086 false /* updatableViaApex */,
1087 testHalInterfaces()};
1088 auto cameraHals = getHals(cm, "android.hardware.camera");
1089 EXPECT_EQ((int)cameraHals.size(), 1);
1090 EXPECT_EQ(*cameraHals[0], expectedCameraHal);
1091 auto nfcHals = getHals(cm, "android.hardware.nfc");
1092 EXPECT_EQ((int)nfcHals.size(), 1);
1093 EXPECT_EQ(*nfcHals[0], expectedNfcHal);
1094 }
1095
TEST_F(LibVintfTest,RuntimeInfo)1096 TEST_F(LibVintfTest, RuntimeInfo) {
1097 RuntimeInfo ki = testRuntimeInfo();
1098 using KernelConfigs = std::vector<KernelConfig>;
1099 const KernelConfigs configs {
1100 KernelConfig{"CONFIG_64BIT", Tristate::YES},
1101 KernelConfig{"CONFIG_ANDROID_BINDER_DEVICES", "binder,hwbinder"},
1102 KernelConfig{"CONFIG_ARCH_MMAP_RND_BITS", 24},
1103 KernelConfig{"CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES", ""},
1104 KernelConfig{"CONFIG_ILLEGAL_POINTER_VALUE", 0xdead000000000000},
1105 KernelConfig{"CONFIG_NOTEXIST", Tristate::NO},
1106 };
1107
1108 auto testMatrix = [&] (MatrixKernel &&kernel) {
1109 CompatibilityMatrix cm;
1110 add(cm, std::move(kernel));
1111 set(cm, {30, {{25, 0}}});
1112 setAvb(cm, {2, 1});
1113 return cm;
1114 };
1115
1116 std::string error;
1117
1118 {
1119 MatrixKernel kernel(KernelVersion{4, 4, 1}, KernelConfigs(configs));
1120 CompatibilityMatrix cm = testMatrix(std::move(kernel));
1121 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Kernel version shouldn't match";
1122 }
1123
1124 {
1125 MatrixKernel kernel(KernelVersion{3, 18, 60}, KernelConfigs(configs));
1126 CompatibilityMatrix cm = testMatrix(std::move(kernel));
1127 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Kernel version shouldn't match";
1128 }
1129
1130 {
1131 MatrixKernel kernel(KernelVersion{3, 18, 22}, KernelConfigs(configs));
1132 CompatibilityMatrix cm = testMatrix(std::move(kernel));
1133 EXPECT_TRUE(ki.checkCompatibility(cm, &error)) << error;
1134 }
1135
1136 {
1137 MatrixKernel kernel(KernelVersion{3, 18, 22}, KernelConfigs(configs));
1138 CompatibilityMatrix cm = testMatrix(std::move(kernel));
1139 set(cm, Sepolicy{22, {{25, 0}}});
1140 EXPECT_TRUE(ki.checkCompatibility(cm, &error)) << error;
1141 set(cm, Sepolicy{40, {{25, 0}}});
1142 EXPECT_FALSE(ki.checkCompatibility(cm, &error))
1143 << "kernel-sepolicy-version shouldn't match";
1144 EXPECT_IN("kernelSepolicyVersion = 30 but required >= 40", error);
1145 }
1146
1147 {
1148 KernelConfigs newConfigs(configs);
1149 newConfigs[0] = KernelConfig{"CONFIG_64BIT", Tristate::NO};
1150 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
1151 CompatibilityMatrix cm = testMatrix(std::move(kernel));
1152 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Value shouldn't match for tristate";
1153 }
1154
1155 {
1156 KernelConfigs newConfigs(configs);
1157 newConfigs[0] = KernelConfig{"CONFIG_64BIT", 20};
1158 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
1159 CompatibilityMatrix cm = testMatrix(std::move(kernel));
1160 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Type shouldn't match";
1161 }
1162
1163 {
1164 KernelConfigs newConfigs(configs);
1165 newConfigs[1] = KernelConfig{"CONFIG_ANDROID_BINDER_DEVICES", "binder"};
1166 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
1167 CompatibilityMatrix cm = testMatrix(std::move(kernel));
1168 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Value shouldn't match for string";
1169 }
1170
1171 {
1172 KernelConfigs newConfigs(configs);
1173 newConfigs[1] = KernelConfig{"CONFIG_ANDROID_BINDER_DEVICES", Tristate::YES};
1174 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
1175 CompatibilityMatrix cm = testMatrix(std::move(kernel));
1176 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Type shouldn't match";
1177 }
1178
1179 {
1180 KernelConfigs newConfigs(configs);
1181 newConfigs[2] = KernelConfig{"CONFIG_ARCH_MMAP_RND_BITS", 30};
1182 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
1183 CompatibilityMatrix cm = testMatrix(std::move(kernel));
1184 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Value shouldn't match for integer";
1185 }
1186
1187 RuntimeInfo badAvb = testRuntimeInfo();
1188 CompatibilityMatrix cm = testMatrix(MatrixKernel(KernelVersion{3, 18, 31}, {}));
1189 {
1190 setAvb(badAvb, {1, 0}, {2, 1});
1191 EXPECT_FALSE(badAvb.checkCompatibility(cm, &error, CheckFlags::ENABLE_ALL_CHECKS));
1192 EXPECT_STREQ(error.c_str(), "Vbmeta version 1.0 does not match framework matrix 2.1");
1193 }
1194 {
1195 setAvb(badAvb, {2, 1}, {3, 0});
1196 EXPECT_FALSE(badAvb.checkCompatibility(cm, &error, CheckFlags::ENABLE_ALL_CHECKS));
1197 }
1198 {
1199 setAvb(badAvb, {2, 1}, {2, 3});
1200 EXPECT_TRUE(badAvb.checkCompatibility(cm, &error, CheckFlags::ENABLE_ALL_CHECKS));
1201 }
1202 {
1203 setAvb(badAvb, {2, 3}, {2, 1});
1204 EXPECT_TRUE(badAvb.checkCompatibility(cm, &error, CheckFlags::ENABLE_ALL_CHECKS));
1205 }
1206 }
1207
TEST_F(LibVintfTest,MissingAvb)1208 TEST_F(LibVintfTest, MissingAvb) {
1209 std::string xml =
1210 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
1211 " <kernel version=\"3.18.31\"></kernel>"
1212 " <sepolicy>\n"
1213 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1214 " <sepolicy-version>25.5</sepolicy-version>\n"
1215 " </sepolicy>\n"
1216 "</compatibility-matrix>\n";
1217 CompatibilityMatrix cm;
1218 EXPECT_TRUE(fromXml(&cm, xml));
1219 EXPECT_EQ(getAvb(cm), Version(0, 0));
1220 }
1221
TEST_F(LibVintfTest,DisableAvb)1222 TEST_F(LibVintfTest, DisableAvb) {
1223 std::string xml =
1224 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
1225 " <kernel version=\"3.18.31\"></kernel>"
1226 " <sepolicy>\n"
1227 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1228 " <sepolicy-version>25.5</sepolicy-version>\n"
1229 " </sepolicy>\n"
1230 " <avb>\n"
1231 " <vbmeta-version>1.0</vbmeta-version>\n"
1232 " </avb>\n"
1233 "</compatibility-matrix>\n";
1234 CompatibilityMatrix cm;
1235 EXPECT_TRUE(fromXml(&cm, xml));
1236 RuntimeInfo ki = testRuntimeInfo();
1237 std::string error;
1238 EXPECT_FALSE(ki.checkCompatibility(cm, &error, CheckFlags::ENABLE_ALL_CHECKS));
1239 EXPECT_STREQ(error.c_str(), "AVB version 2.1 does not match framework matrix 1.0");
1240 EXPECT_TRUE(ki.checkCompatibility(cm, &error, CheckFlags::DISABLE_AVB_CHECK)) << error;
1241 }
1242
TEST_F(LibVintfTest,FullCompat)1243 TEST_F(LibVintfTest, FullCompat) {
1244 std::string manifestXml =
1245 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
1246 " <hal format=\"hidl\">\n"
1247 " <name>android.hardware.camera</name>\n"
1248 " <transport>hwbinder</transport>\n"
1249 " <version>3.5</version>\n"
1250 " <interface>\n"
1251 " <name>IBetterCamera</name>\n"
1252 " <instance>camera</instance>\n"
1253 " </interface>\n"
1254 " <interface>\n"
1255 " <name>ICamera</name>\n"
1256 " <instance>default</instance>\n"
1257 " <instance>legacy/0</instance>\n"
1258 " </interface>\n"
1259 " </hal>\n"
1260 " <hal format=\"hidl\">\n"
1261 " <name>android.hardware.nfc</name>\n"
1262 " <transport>hwbinder</transport>\n"
1263 " <version>1.0</version>\n"
1264 " <interface>\n"
1265 " <name>INfc</name>\n"
1266 " <instance>nfc_nci</instance>\n"
1267 " </interface>\n"
1268 " </hal>\n"
1269 " <hal format=\"hidl\">\n"
1270 " <name>android.hardware.nfc</name>\n"
1271 " <transport>hwbinder</transport>\n"
1272 " <version>2.0</version>\n"
1273 " <interface>\n"
1274 " <name>INfc</name>\n"
1275 " <instance>default</instance>\n"
1276 " <instance>nfc_nci</instance>\n"
1277 " </interface>\n"
1278 " </hal>\n"
1279 " <sepolicy>\n"
1280 " <version>25.5</version>\n"
1281 " </sepolicy>\n"
1282 "</manifest>\n";
1283
1284 std::string matrixXml =
1285 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
1286 " <hal format=\"hidl\">\n"
1287 " <name>android.hardware.camera</name>\n"
1288 " <version>2.0-5</version>\n"
1289 " <version>3.4-16</version>\n"
1290 " <interface>\n"
1291 " <name>IBetterCamera</name>\n"
1292 " <instance>camera</instance>\n"
1293 " </interface>\n"
1294 " <interface>\n"
1295 " <name>ICamera</name>\n"
1296 " <instance>default</instance>\n"
1297 " <instance>legacy/0</instance>\n"
1298 " </interface>\n"
1299 " </hal>\n"
1300 " <hal format=\"hidl\">\n"
1301 " <name>android.hardware.nfc</name>\n"
1302 " <version>1.0</version>\n"
1303 " <version>2.0</version>\n"
1304 " <interface>\n"
1305 " <name>INfc</name>\n"
1306 " <instance>nfc_nci</instance>\n"
1307 " </interface>\n"
1308 " </hal>\n"
1309 " <hal format=\"hidl\">\n"
1310 " <name>android.hardware.foo</name>\n"
1311 " <version>1.0</version>\n"
1312 " </hal>\n"
1313 " <sepolicy>\n"
1314 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1315 " <sepolicy-version>25.5</sepolicy-version>\n"
1316 " <sepolicy-version>26.0-3</sepolicy-version>\n"
1317 " <sepolicy-version>202404</sepolicy-version>\n"
1318 " </sepolicy>\n"
1319 " <avb>\n"
1320 " <vbmeta-version>2.1</vbmeta-version>\n"
1321 " </avb>\n"
1322 "</compatibility-matrix>\n";
1323
1324 HalManifest manifest;
1325 CompatibilityMatrix matrix;
1326 std::string error;
1327 EXPECT_TRUE(fromXml(&manifest, manifestXml));
1328 EXPECT_TRUE(fromXml(&matrix, matrixXml));
1329 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1330
1331 set(matrix, Sepolicy{30, {{26, 0}}});
1332 EXPECT_FALSE(manifest.checkCompatibility(matrix));
1333 set(matrix, Sepolicy{30, {{25, 6}}});
1334 EXPECT_FALSE(manifest.checkCompatibility(matrix));
1335 set(matrix, Sepolicy{30, {{25, 4}}});
1336 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1337 set(matrix, Sepolicy{30, {{202404, std::nullopt}}});
1338 EXPECT_FALSE(manifest.checkCompatibility(matrix));
1339
1340 // vFRC sepolicy test cases
1341 manifestXml =
1342 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
1343 " <sepolicy>\n"
1344 " <version>202404</version>\n"
1345 " </sepolicy>\n"
1346 "</manifest>\n";
1347 EXPECT_TRUE(fromXml(&manifest, manifestXml));
1348 set(matrix, Sepolicy{30, {{202404, std::nullopt}}});
1349 EXPECT_TRUE(manifest.checkCompatibility(matrix)) << error;
1350 set(matrix, Sepolicy{30, {{202404, 0}}});
1351 EXPECT_FALSE(manifest.checkCompatibility(matrix)) << error;
1352 set(matrix, Sepolicy{30, {{202504, std::nullopt}}});
1353 EXPECT_FALSE(manifest.checkCompatibility(matrix));
1354 }
1355
1356 // clang-format on
1357
TEST_F(LibVintfTest,ApexInterfaceShouldBeOkayWithoutApexInfoList)1358 TEST_F(LibVintfTest, ApexInterfaceShouldBeOkayWithoutApexInfoList) {
1359 details::FileSystemNoOp fs;
1360 details::PropertyFetcherNoOp pf;
1361 EXPECT_THAT(apex::GetModifiedTime(&fs, &pf), std::nullopt);
1362 std::vector<std::string> dirs;
1363 ASSERT_EQ(OK, apex::GetVendorVintfDirs(&fs, &pf, &dirs, nullptr));
1364 ASSERT_EQ(dirs, std::vector<std::string>{});
1365 }
1366
1367 struct NativeHalCompatTestParam {
1368 std::string matrixXml;
1369 std::string manifestXml;
1370 bool compatible;
1371 std::string expectedError;
1372 };
1373
1374 class NativeHalCompatTest : public LibVintfTest,
1375 public ::testing::WithParamInterface<NativeHalCompatTestParam> {
1376 public:
createParams()1377 static std::vector<NativeHalCompatTestParam> createParams() {
1378 std::string matrixIntf = "<compatibility-matrix " + kMetaVersionStr + R"( type="device">
1379 <hal format="native">
1380 <name>foo</name>
1381 <version>1.0</version>
1382 <interface>
1383 <name>IFoo</name>
1384 <instance>default</instance>
1385 </interface>
1386 </hal>
1387 </compatibility-matrix>
1388 )";
1389 std::string matrixNoIntf = "<compatibility-matrix " + kMetaVersionStr + R"( type="device">
1390 <hal format="native">
1391 <name>foo</name>
1392 <version>1.0</version>
1393 <interface>
1394 <instance>default</instance>
1395 </interface>
1396 </hal>
1397 </compatibility-matrix>
1398 )";
1399 std::string matrixNoInst = "<compatibility-matrix " + kMetaVersionStr + R"( type="device">
1400 <hal format="native">
1401 <name>foo</name>
1402 <version>1.0</version>
1403 </hal>
1404 </compatibility-matrix>
1405 )";
1406 std::string manifestFqnameIntf = "<manifest " + kMetaVersionStr + R"( type="framework">
1407 <hal format="native">
1408 <name>foo</name>
1409 <fqname>@1.0::IFoo/default</fqname>
1410 </hal>
1411 </manifest>
1412 )";
1413 std::string manifestLegacyIntf = "<manifest " + kMetaVersionStr + R"( type="framework">
1414 <hal format="native">
1415 <name>foo</name>
1416 <version>1.0</version>
1417 <interface>
1418 <name>IFoo</name>
1419 <instance>default</instance>
1420 </interface>
1421 </hal>
1422 </manifest>
1423 )";
1424 std::string manifestFqnameNoIntf = "<manifest " + kMetaVersionStr + R"( type="framework">
1425 <hal format="native">
1426 <name>foo</name>
1427 <fqname>@1.0/default</fqname>
1428 </hal>
1429 </manifest>
1430 )";
1431 std::string manifestLegacyNoIntf = "<manifest " + kMetaVersionStr + R"( type="framework">
1432 <hal format="native">
1433 <name>foo</name>
1434 <version>1.0</version>
1435 <interface>
1436 <instance>default</instance>
1437 </interface>
1438 </hal>
1439 </manifest>
1440 )";
1441 std::string manifestNoInst = "<manifest " + kMetaVersionStr + R"( type="framework">
1442 <hal format="native">
1443 <name>foo</name>
1444 <version>1.0</version>
1445 </hal>
1446 </manifest>
1447 )";
1448
1449 std::vector<NativeHalCompatTestParam> ret;
1450
1451 // If the matrix specifies interface name, the manifest can specify or
1452 // not.
1453 ret.emplace_back(NativeHalCompatTestParam{matrixIntf, manifestFqnameIntf, true, ""});
1454 ret.emplace_back(NativeHalCompatTestParam{matrixIntf, manifestLegacyIntf, true, ""});
1455 ret.emplace_back(NativeHalCompatTestParam{matrixIntf, manifestFqnameNoIntf, true, ""});
1456 ret.emplace_back(NativeHalCompatTestParam{matrixIntf, manifestLegacyNoIntf, true, ""});
1457 ret.emplace_back(NativeHalCompatTestParam{matrixIntf, manifestNoInst, true, ""});
1458
1459 // If the matrix does not specify an interface name, the manifest can
1460 // specify it or not.
1461 ret.emplace_back(NativeHalCompatTestParam{matrixNoIntf, manifestFqnameIntf, true, ""});
1462 ret.emplace_back(NativeHalCompatTestParam{matrixNoIntf, manifestLegacyIntf, true, ""});
1463 ret.emplace_back(NativeHalCompatTestParam{matrixNoIntf, manifestFqnameNoIntf, true, ""});
1464 ret.emplace_back(NativeHalCompatTestParam{matrixNoIntf, manifestLegacyNoIntf, true, ""});
1465 ret.emplace_back(NativeHalCompatTestParam{matrixNoIntf, manifestNoInst, true, ""});
1466
1467 // If the matrix does not specify interface name nor instances, the manifest may either
1468 // provide instances of that version, or just a version number with no instances.
1469 ret.emplace_back(NativeHalCompatTestParam{matrixNoInst, manifestFqnameIntf, true, ""});
1470 ret.emplace_back(NativeHalCompatTestParam{matrixNoInst, manifestLegacyIntf, true, ""});
1471 ret.emplace_back(NativeHalCompatTestParam{matrixNoInst, manifestFqnameNoIntf, true, ""});
1472 ret.emplace_back(NativeHalCompatTestParam{matrixNoInst, manifestLegacyNoIntf, true, ""});
1473 ret.emplace_back(NativeHalCompatTestParam{matrixNoInst, manifestNoInst, true, ""});
1474
1475 return ret;
1476 }
1477 };
1478
TEST_P(NativeHalCompatTest,Compat)1479 TEST_P(NativeHalCompatTest, Compat) {
1480 auto params = GetParam();
1481 std::string error;
1482 HalManifest manifest;
1483 ASSERT_TRUE(fromXml(&manifest, params.manifestXml, &error)) << error;
1484 CompatibilityMatrix matrix;
1485 ASSERT_TRUE(fromXml(&matrix, params.matrixXml, &error)) << error;
1486 EXPECT_EQ(params.compatible, manifest.checkCompatibility(matrix, &error)) << error;
1487 if (!params.expectedError.empty()) {
1488 EXPECT_THAT(error, HasSubstr(params.expectedError));
1489 } else {
1490 EXPECT_THAT(error, IsEmpty());
1491 }
1492 }
1493
1494 INSTANTIATE_TEST_CASE_P(LibVintfTest, NativeHalCompatTest,
1495 ::testing::ValuesIn(NativeHalCompatTest::createParams()));
1496
1497 // clang-format off
1498
1499 /////////////////// xmlfile tests
1500
TEST_F(LibVintfTest,HalManifestConverterXmlFile)1501 TEST_F(LibVintfTest, HalManifestConverterXmlFile) {
1502 HalManifest vm = testDeviceManifestWithXmlFile();
1503 std::string xml = toXml(
1504 vm, SerializeFlags::HALS_ONLY.enableSepolicy().enableXmlFiles());
1505 EXPECT_EQ(xml,
1506 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
1507 " <hal format=\"hidl\">\n"
1508 " <name>android.hardware.camera</name>\n"
1509 " <transport>hwbinder</transport>\n"
1510 " <fqname>@2.0::IBetterCamera/camera</fqname>\n"
1511 " <fqname>@2.0::ICamera/default</fqname>\n"
1512 " <fqname>@2.0::ICamera/legacy/0</fqname>\n"
1513 " </hal>\n"
1514 " <hal format=\"hidl\">\n"
1515 " <name>android.hardware.nfc</name>\n"
1516 " <transport arch=\"32+64\">passthrough</transport>\n"
1517 " <fqname>@1.0::INfc/default</fqname>\n"
1518 " </hal>\n"
1519 " <sepolicy>\n"
1520 " <version>25.0</version>\n"
1521 " </sepolicy>\n"
1522 " <xmlfile>\n"
1523 " <name>media_profile</name>\n"
1524 " <version>1.0</version>\n"
1525 " </xmlfile>\n"
1526 "</manifest>\n");
1527 HalManifest vm2;
1528 EXPECT_TRUE(fromXml(&vm2, xml));
1529 EXPECT_EQ(vm, vm2);
1530 }
1531
TEST_F(LibVintfTest,HalManifestConverterXmlFileWithInterface)1532 TEST_F(LibVintfTest, HalManifestConverterXmlFileWithInterface) {
1533 HalManifest vm = testDeviceManifestWithXmlFile();
1534 std::string xml =
1535 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
1536 " <hal format=\"hidl\">\n"
1537 " <name>android.hardware.camera</name>\n"
1538 " <transport>hwbinder</transport>\n"
1539 " <version>2.0</version>\n"
1540 " <interface>\n"
1541 " <name>IBetterCamera</name>\n"
1542 " <instance>camera</instance>\n"
1543 " </interface>\n"
1544 " <interface>\n"
1545 " <name>ICamera</name>\n"
1546 " <instance>default</instance>\n"
1547 " <instance>legacy/0</instance>\n"
1548 " </interface>\n"
1549 " </hal>\n"
1550 " <hal format=\"hidl\">\n"
1551 " <name>android.hardware.nfc</name>\n"
1552 " <transport arch=\"32+64\">passthrough</transport>\n"
1553 " <version>1.0</version>\n"
1554 " <interface>\n"
1555 " <name>INfc</name>\n"
1556 " <instance>default</instance>\n"
1557 " </interface>\n"
1558 " </hal>\n"
1559 " <sepolicy>\n"
1560 " <version>25.0</version>\n"
1561 " </sepolicy>\n"
1562 " <xmlfile>\n"
1563 " <name>media_profile</name>\n"
1564 " <version>1.0</version>\n"
1565 " </xmlfile>\n"
1566 "</manifest>\n";
1567 HalManifest vm2;
1568 EXPECT_TRUE(fromXml(&vm2, xml));
1569 EXPECT_EQ(vm, vm2);
1570 }
1571
TEST_F(LibVintfTest,CompatibilityMatrixConverterXmlFile)1572 TEST_F(LibVintfTest, CompatibilityMatrixConverterXmlFile) {
1573 CompatibilityMatrix cm;
1574 addXmlFile(cm, "media_profile", {1, 0});
1575 std::string xml = toXml(cm, SerializeFlags::XMLFILES_ONLY);
1576 EXPECT_EQ(xml,
1577 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
1578 " <xmlfile format=\"dtd\">\n"
1579 " <name>media_profile</name>\n"
1580 " <version>1.0</version>\n"
1581 " </xmlfile>\n"
1582 "</compatibility-matrix>\n");
1583 CompatibilityMatrix cm2;
1584 EXPECT_TRUE(fromXml(&cm2, xml));
1585 EXPECT_EQ(cm, cm2);
1586 }
1587
TEST_F(LibVintfTest,ManifestXmlFilePathDevice)1588 TEST_F(LibVintfTest, ManifestXmlFilePathDevice) {
1589 std::string manifestXml =
1590 "<manifest " + kMetaVersionStr + " type=\"device\">"
1591 " <xmlfile>"
1592 " <name>media_profile</name>"
1593 " <version>1.0</version>"
1594 " </xmlfile>"
1595 "</manifest>";
1596 HalManifest manifest;
1597 EXPECT_TRUE(fromXml(&manifest, manifestXml));
1598 EXPECT_EQ(manifest.getXmlFilePath("media_profile", {1, 0}),
1599 "/vendor/etc/media_profile_V1_0.xml");
1600 }
1601
TEST_F(LibVintfTest,ManifestXmlFilePathFramework)1602 TEST_F(LibVintfTest, ManifestXmlFilePathFramework) {
1603 std::string manifestXml =
1604 "<manifest " + kMetaVersionStr + " type=\"framework\">"
1605 " <xmlfile>"
1606 " <name>media_profile</name>"
1607 " <version>1.0</version>"
1608 " </xmlfile>"
1609 "</manifest>";
1610 HalManifest manifest;
1611 EXPECT_TRUE(fromXml(&manifest, manifestXml));
1612 EXPECT_EQ(manifest.getXmlFilePath("media_profile", {1, 0}),
1613 "/system/etc/media_profile_V1_0.xml");
1614 }
1615
TEST_F(LibVintfTest,ManifestXmlFilePathOverride)1616 TEST_F(LibVintfTest, ManifestXmlFilePathOverride) {
1617 std::string manifestXml =
1618 "<manifest " + kMetaVersionStr + " type=\"device\">"
1619 " <xmlfile>"
1620 " <name>media_profile</name>"
1621 " <version>1.0</version>"
1622 " <path>/vendor/etc/foo.xml</path>"
1623 " </xmlfile>"
1624 "</manifest>";
1625 HalManifest manifest;
1626 EXPECT_TRUE(fromXml(&manifest, manifestXml));
1627 EXPECT_EQ(manifest.getXmlFilePath("media_profile", {1, 0}), "/vendor/etc/foo.xml");
1628 }
1629
TEST_F(LibVintfTest,ManifestXmlFilePathMissing)1630 TEST_F(LibVintfTest, ManifestXmlFilePathMissing) {
1631 std::string manifestXml =
1632 "<manifest " + kMetaVersionStr + " type=\"device\">"
1633 " <xmlfile>"
1634 " <name>media_profile</name>"
1635 " <version>1.1</version>"
1636 " </xmlfile>"
1637 "</manifest>";
1638 HalManifest manifest;
1639 EXPECT_TRUE(fromXml(&manifest, manifestXml));
1640 EXPECT_EQ(manifest.getXmlFilePath("media_profile", {1, 0}), "");
1641 }
1642
TEST_F(LibVintfTest,MatrixXmlFilePathFramework)1643 TEST_F(LibVintfTest, MatrixXmlFilePathFramework) {
1644 std::string matrixXml =
1645 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">"
1646 " <xmlfile format=\"dtd\">"
1647 " <name>media_profile</name>"
1648 " <version>2.0-1</version>"
1649 " </xmlfile>"
1650 "</compatibility-matrix>";
1651 CompatibilityMatrix matrix;
1652 EXPECT_TRUE(fromXml(&matrix, matrixXml));
1653 EXPECT_EQ(matrix.getXmlSchemaPath("media_profile", {2, 1}),
1654 "/system/etc/media_profile_V2_1.dtd");
1655 }
1656
TEST_F(LibVintfTest,MatrixXmlFilePathDevice)1657 TEST_F(LibVintfTest, MatrixXmlFilePathDevice) {
1658 std::string matrixXml =
1659 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">"
1660 " <xmlfile format=\"xsd\">"
1661 " <name>media_profile</name>"
1662 " <version>2.0-1</version>"
1663 " </xmlfile>"
1664 "</compatibility-matrix>";
1665 CompatibilityMatrix matrix;
1666 EXPECT_TRUE(fromXml(&matrix, matrixXml));
1667 EXPECT_EQ(matrix.getXmlSchemaPath("media_profile", {2, 0}),
1668 "/vendor/etc/media_profile_V2_1.xsd");
1669 }
1670
TEST_F(LibVintfTest,MatrixXmlFilePathOverride)1671 TEST_F(LibVintfTest, MatrixXmlFilePathOverride) {
1672 std::string matrixXml =
1673 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">"
1674 " <xmlfile format=\"xsd\">"
1675 " <name>media_profile</name>"
1676 " <version>2.0-1</version>"
1677 " <path>/system/etc/foo.xsd</path>"
1678 " </xmlfile>"
1679 "</compatibility-matrix>";
1680 CompatibilityMatrix matrix;
1681 EXPECT_TRUE(fromXml(&matrix, matrixXml));
1682 EXPECT_EQ(matrix.getXmlSchemaPath("media_profile", {2, 0}), "/system/etc/foo.xsd");
1683 }
1684
TEST_F(LibVintfTest,MatrixXmlFilePathMissing)1685 TEST_F(LibVintfTest, MatrixXmlFilePathMissing) {
1686 std::string matrixXml =
1687 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">"
1688 " <xmlfile format=\"dtd\">"
1689 " <name>media_profile</name>"
1690 " <version>2.1</version>"
1691 " </xmlfile>"
1692 "</compatibility-matrix>";
1693 CompatibilityMatrix matrix;
1694 EXPECT_TRUE(fromXml(&matrix, matrixXml));
1695 EXPECT_EQ(matrix.getXmlSchemaPath("media_profile", {2, 0}), "");
1696 }
1697
processData(const std::string & data,bool processComments,bool relaxedFormat=false)1698 std::pair<KernelConfigParser, status_t> processData(const std::string& data, bool processComments,
1699 bool relaxedFormat = false) {
1700 KernelConfigParser parser(processComments, relaxedFormat);
1701 const char* p = data.c_str();
1702 size_t n = 0;
1703 size_t chunkSize;
1704 status_t status = OK;
1705 for (; n < data.size(); p += chunkSize, n += chunkSize) {
1706 chunkSize = std::min<size_t>(5, data.size() - n);
1707 if ((status = parser.process(p, chunkSize)) != OK) {
1708 break;
1709 }
1710 }
1711 return {std::move(parser), status};
1712 }
1713
TEST_F(LibVintfTest,KernelConfigParser)1714 TEST_F(LibVintfTest, KernelConfigParser) {
1715 // usage in /proc/config.gz
1716 const std::string data =
1717 "# CONFIG_NOT_SET is not set\n"
1718 "CONFIG_ONE=1\n"
1719 "CONFIG_Y=y\n"
1720 "CONFIG_STR=\"string\"\n";
1721 auto pair = processData(data, false /* processComments */);
1722 ASSERT_EQ(OK, pair.second) << pair.first.error();
1723 const auto& configs = pair.first.configs();
1724
1725 EXPECT_EQ(configs.find("CONFIG_ONE")->second, "1");
1726 EXPECT_EQ(configs.find("CONFIG_Y")->second, "y");
1727 EXPECT_EQ(configs.find("CONFIG_STR")->second, "\"string\"");
1728 EXPECT_EQ(configs.find("CONFIG_NOT_SET"), configs.end());
1729 }
1730
TEST_F(LibVintfTest,KernelConfigParser2)1731 TEST_F(LibVintfTest, KernelConfigParser2) {
1732 // usage in android-base.config
1733 const std::string data =
1734 "# CONFIG_NOT_SET is not set\n"
1735 "CONFIG_ONE=1\n"
1736 "CONFIG_Y=y\n"
1737 "CONFIG_STR=string\n"
1738 "# ignore_thiscomment\n"
1739 "# CONFIG_NOT_SET2 is not set\n";
1740 auto pair = processData(data, true /* processComments */);
1741 ASSERT_EQ(OK, pair.second) << pair.first.error();
1742 const auto& configs = pair.first.configs();
1743
1744 EXPECT_EQ(configs.find("CONFIG_ONE")->second, "1");
1745 EXPECT_EQ(configs.find("CONFIG_Y")->second, "y");
1746 EXPECT_EQ(configs.find("CONFIG_STR")->second, "string");
1747 EXPECT_EQ(configs.find("CONFIG_NOT_SET")->second, "n");
1748 EXPECT_EQ(configs.find("CONFIG_NOT_SET2")->second, "n");
1749 }
1750
TEST_F(LibVintfTest,KernelConfigParserSpace)1751 TEST_F(LibVintfTest, KernelConfigParserSpace) {
1752 // usage in android-base.config
1753 const std::string data =
1754 " # CONFIG_NOT_SET is not set \n"
1755 " CONFIG_ONE=1 # 'tis a one!\n"
1756 " CONFIG_TWO=2 #'tis a two! \n"
1757 " CONFIG_THREE=3#'tis a three! \n"
1758 " CONFIG_233=233#'tis a three! \n"
1759 "#yey! random comments\n"
1760 "CONFIG_Y=y \n"
1761 " CONFIG_YES=y#YES! \n"
1762 "CONFIG_STR=string\n"
1763 "CONFIG_HELLO=hello world! #still works\n"
1764 "CONFIG_WORLD=hello world! \n"
1765 "CONFIG_GOOD = good morning! #comments here\n"
1766 " CONFIG_MORNING = good morning! \n";
1767 auto pair = processData(data, true /* processComments */, true /* relaxedFormat */);
1768 ASSERT_EQ(OK, pair.second) << pair.first.error();
1769 const auto& configs = pair.first.configs();
1770
1771 EXPECT_EQ(configs.find("CONFIG_ONE")->second, "1");
1772 EXPECT_EQ(configs.find("CONFIG_TWO")->second, "2");
1773 EXPECT_EQ(configs.find("CONFIG_THREE")->second, "3");
1774 EXPECT_EQ(configs.find("CONFIG_Y")->second, "y");
1775 EXPECT_EQ(configs.find("CONFIG_STR")->second, "string");
1776 EXPECT_EQ(configs.find("CONFIG_HELLO")->second, "hello world!")
1777 << "Value should be \"hello world!\" without trailing spaces";
1778 EXPECT_EQ(configs.find("CONFIG_WORLD")->second, "hello world!")
1779 << "Value should be \"hello world!\" without trailing spaces";
1780 EXPECT_EQ(configs.find("CONFIG_GOOD")->second, "good morning!")
1781 << "Value should be \"good morning!\" without leading or trailing spaces";
1782 EXPECT_EQ(configs.find("CONFIG_MORNING")->second, "good morning!")
1783 << "Value should be \"good morning!\" without leading or trailing spaces";
1784 EXPECT_EQ(configs.find("CONFIG_NOT_SET")->second, "n");
1785 }
1786
TEST_F(LibVintfTest,NetutilsWrapperMatrix)1787 TEST_F(LibVintfTest, NetutilsWrapperMatrix) {
1788 std::string matrixXml;
1789 CompatibilityMatrix matrix;
1790 std::string error;
1791
1792 matrixXml =
1793 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">"
1794 " <hal format=\"native\">"
1795 " <name>netutils-wrapper</name>"
1796 " <version>1.0</version>"
1797 " </hal>"
1798 "</compatibility-matrix>";
1799 EXPECT_TRUE(fromXml(&matrix, matrixXml, &error)) << error;
1800
1801 // only host libvintf hardcodes netutils-wrapper version requirements
1802 #ifndef LIBVINTF_TARGET
1803
1804 matrixXml =
1805 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">"
1806 " <hal format=\"native\">"
1807 " <name>netutils-wrapper</name>"
1808 " <version>1.0-1</version>"
1809 " </hal>"
1810 "</compatibility-matrix>";
1811 EXPECT_FALSE(fromXml(&matrix, matrixXml, &error));
1812 EXPECT_THAT(error, HasSubstr(
1813 "netutils-wrapper HAL must specify exactly one version x.0, but a range is provided. "
1814 "Perhaps you mean '1.0'?"));
1815
1816 matrixXml =
1817 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">"
1818 " <hal format=\"native\">"
1819 " <name>netutils-wrapper</name>"
1820 " <version>1.1</version>"
1821 " </hal>"
1822 "</compatibility-matrix>";
1823 EXPECT_FALSE(fromXml(&matrix, matrixXml, &error));
1824 EXPECT_THAT(error, HasSubstr(
1825 "netutils-wrapper HAL must specify exactly one version x.0, but minor version is not 0. "
1826 "Perhaps you mean '1.0'?"));
1827
1828 matrixXml =
1829 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">"
1830 " <hal format=\"native\">"
1831 " <name>netutils-wrapper</name>"
1832 " <version>1.0</version>"
1833 " <version>2.0</version>"
1834 " </hal>"
1835 "</compatibility-matrix>";
1836 EXPECT_FALSE(fromXml(&matrix, matrixXml, &error));
1837 EXPECT_THAT(error, HasSubstr(
1838 "netutils-wrapper HAL must specify exactly one version x.0, but multiple <version> element "
1839 "is specified."));
1840
1841 #endif // LIBVINTF_TARGET
1842 }
1843
TEST_F(LibVintfTest,NetutilsWrapperManifest)1844 TEST_F(LibVintfTest, NetutilsWrapperManifest) {
1845 std::string manifestXml;
1846 HalManifest manifest;
1847 std::string error;
1848
1849 manifestXml =
1850 "<manifest " + kMetaVersionStr + " type=\"framework\">"
1851 " <hal format=\"native\">"
1852 " <name>netutils-wrapper</name>"
1853 " <version>1.0</version>"
1854 " <version>2.0</version>"
1855 " </hal>"
1856 "</manifest>";
1857 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
1858
1859 // only host libvintf hardcodes netutils-wrapper version requirements
1860 #ifndef LIBVINTF_TARGET
1861
1862 manifestXml =
1863 "<manifest " + kMetaVersionStr + " type=\"framework\">"
1864 " <hal format=\"native\">"
1865 " <name>netutils-wrapper</name>"
1866 " <version>1.1</version>"
1867 " </hal>"
1868 "</manifest>";
1869 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
1870 EXPECT_THAT(error, HasSubstr(
1871 "netutils-wrapper HAL must specify exactly one version x.0, but minor version is not 0."));
1872
1873 manifestXml =
1874 "<manifest " + kMetaVersionStr + " type=\"framework\">"
1875 " <hal format=\"native\">"
1876 " <name>netutils-wrapper</name>"
1877 " <version>1.0</version>"
1878 " <version>2.1</version>"
1879 " </hal>"
1880 "</manifest>";
1881 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
1882 EXPECT_THAT(error, HasSubstr(
1883 "netutils-wrapper HAL must specify exactly one version x.0, but minor version is not 0."));
1884
1885 #endif // LIBVINTF_TARGET
1886 }
1887
TEST_F(LibVintfTest,KernelConfigConditionTest)1888 TEST_F(LibVintfTest, KernelConfigConditionTest) {
1889 std::string error;
1890 std::string xml =
1891 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
1892 " <kernel version=\"3.18.22\"/>\n"
1893 " <kernel version=\"3.18.22\">\n"
1894 " <conditions>\n"
1895 " <config>\n"
1896 " <key>CONFIG_ARM</key>\n"
1897 " <value type=\"tristate\">y</value>\n"
1898 " </config>\n"
1899 " </conditions>\n"
1900 " <config>\n"
1901 " <key>CONFIG_FOO</key>\n"
1902 " <value type=\"tristate\">y</value>\n"
1903 " </config>\n"
1904 " </kernel>\n"
1905 " <sepolicy>\n"
1906 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1907 " <sepolicy-version>25.0</sepolicy-version>\n"
1908 " </sepolicy>\n"
1909 " <avb>\n"
1910 " <vbmeta-version>2.1</vbmeta-version>\n"
1911 " </avb>\n"
1912 "</compatibility-matrix>\n";
1913
1914 CompatibilityMatrix cm;
1915 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
1916 const auto& kernels = getKernels(cm);
1917 ASSERT_GE(kernels.size(), 2u);
1918 ASSERT_TRUE(kernels[0].conditions().empty());
1919 const auto& kernel = kernels[1];
1920 const auto& cond = kernel.conditions();
1921 ASSERT_FALSE(cond.empty());
1922 EXPECT_EQ("CONFIG_ARM", cond.begin()->first);
1923 EXPECT_EQ(KernelConfigTypedValue(Tristate::YES), cond.begin()->second);
1924 EXPECT_FALSE(kernel.configs().empty());
1925
1926 EXPECT_EQ(xml, toXml(cm));
1927 }
1928
TEST_F(LibVintfTest,KernelConfigConditionEmptyTest)1929 TEST_F(LibVintfTest, KernelConfigConditionEmptyTest) {
1930 std::string error;
1931 std::string xml =
1932 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
1933 " <kernel version=\"4.4.0\"/>\n"
1934 " <kernel version=\"3.18.22\">\n"
1935 " <conditions>\n"
1936 " <config>\n"
1937 " <key>CONFIG_ARM</key>\n"
1938 " <value type=\"tristate\">y</value>\n"
1939 " </config>\n"
1940 " </conditions>\n"
1941 " </kernel>\n"
1942 "</compatibility-matrix>\n";
1943
1944 CompatibilityMatrix cm;
1945 EXPECT_FALSE(fromXml(&cm, xml, &error))
1946 << "Should not accept first kernel version with non-empty conditions";
1947 EXPECT_EQ(
1948 "First <kernel> for version 3.18 must have empty <conditions> "
1949 "for backwards compatibility.", error);
1950 }
1951
TEST_F(LibVintfTest,KernelConfigConditionMatch)1952 TEST_F(LibVintfTest, KernelConfigConditionMatch) {
1953 RuntimeInfo runtime = testRuntimeInfo();
1954 std::string error;
1955 std::string xml;
1956 CompatibilityMatrix cm;
1957
1958 xml =
1959 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
1960 " <kernel version=\"3.18.22\"/>\n"
1961 " <kernel version=\"3.18.22\">\n"
1962 " <conditions>\n"
1963 " <config>\n"
1964 " <key>CONFIG_64BIT</key>\n"
1965 " <value type=\"tristate\">y</value>\n"
1966 " </config>\n"
1967 " </conditions>\n"
1968 " <config>\n"
1969 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
1970 " <value type=\"int\">24</value>\n"
1971 " </config>\n"
1972 " </kernel>\n"
1973 " <sepolicy>\n"
1974 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1975 " </sepolicy>\n"
1976 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
1977 "</compatibility-matrix>\n";
1978
1979 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
1980 EXPECT_TRUE(runtime.checkCompatibility(cm, &error)) << error;
1981
1982 xml =
1983 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
1984 " <kernel version=\"3.18.22\"/>\n"
1985 " <kernel version=\"3.18.22\">\n"
1986 " <conditions>\n"
1987 " <config>\n"
1988 " <key>CONFIG_64BIT</key>\n"
1989 " <value type=\"tristate\">y</value>\n"
1990 " </config>\n"
1991 " </conditions>\n"
1992 " <config>\n"
1993 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
1994 " <value type=\"int\">26</value>\n"
1995 " </config>\n"
1996 " </kernel>\n"
1997 " <sepolicy>\n"
1998 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1999 " </sepolicy>\n"
2000 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
2001 "</compatibility-matrix>\n";
2002
2003 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2004 EXPECT_FALSE(runtime.checkCompatibility(cm, &error))
2005 << "conditions met, so CONFIG_ARCH_MMAP_RND_BITS should not match";
2006
2007 xml =
2008 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
2009 " <kernel version=\"3.18.22\"/>\n"
2010 " <kernel version=\"3.18.22\">\n"
2011 " <conditions>\n"
2012 " <config>\n"
2013 " <key>CONFIG_64BIT</key>\n"
2014 " <value type=\"tristate\">n</value>\n"
2015 " </config>\n"
2016 " </conditions>\n"
2017 " <config>\n"
2018 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
2019 " <value type=\"int\">26</value>\n"
2020 " </config>\n"
2021 " </kernel>\n"
2022 " <sepolicy>\n"
2023 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
2024 " </sepolicy>\n"
2025 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
2026 "</compatibility-matrix>\n";
2027
2028 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2029 EXPECT_TRUE(runtime.checkCompatibility(cm, &error)) << error;
2030 xml =
2031 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
2032 " <kernel version=\"3.18.22\"/>\n"
2033 " <kernel version=\"3.18.22\">\n"
2034 " <conditions>\n"
2035 " <config>\n"
2036 " <key>CONFIG_64BIT</key>\n"
2037 " <value type=\"tristate\">y</value>\n"
2038 " </config>\n"
2039 " <config>\n"
2040 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
2041 " <value type=\"int\">24</value>\n"
2042 " </config>\n"
2043 " </conditions>\n"
2044 " <config>\n"
2045 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
2046 " <value type=\"int\">0xdead000000000000</value>\n"
2047 " </config>\n"
2048 " </kernel>\n"
2049 " <sepolicy>\n"
2050 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
2051 " </sepolicy>\n"
2052 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
2053 "</compatibility-matrix>\n";
2054
2055 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2056 EXPECT_TRUE(runtime.checkCompatibility(cm, &error));
2057
2058 xml =
2059 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
2060 " <kernel version=\"3.18.22\"/>\n"
2061 " <kernel version=\"3.18.22\">\n"
2062 " <conditions>\n"
2063 " <config>\n"
2064 " <key>CONFIG_64BIT</key>\n"
2065 " <value type=\"tristate\">y</value>\n"
2066 " </config>\n"
2067 " <config>\n"
2068 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
2069 " <value type=\"int\">24</value>\n"
2070 " </config>\n"
2071 " </conditions>\n"
2072 " <config>\n"
2073 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
2074 " <value type=\"int\">0xbeaf000000000000</value>\n"
2075 " </config>\n"
2076 " </kernel>\n"
2077 " <sepolicy>\n"
2078 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
2079 " </sepolicy>\n"
2080 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
2081 "</compatibility-matrix>\n";
2082
2083 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2084 EXPECT_FALSE(runtime.checkCompatibility(cm, &error))
2085 << "conditions have 'and' relationship, so CONFIG_ILLEGAL_POINTER_VALUE should not match";
2086
2087 xml =
2088 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
2089 " <kernel version=\"3.18.22\"/>\n"
2090 " <kernel version=\"3.18.22\">\n"
2091 " <conditions>\n"
2092 " <config>\n"
2093 " <key>CONFIG_64BIT</key>\n"
2094 " <value type=\"tristate\">y</value>\n"
2095 " </config>\n"
2096 " <config>\n"
2097 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
2098 " <value type=\"int\">26</value>\n"
2099 " </config>\n"
2100 " </conditions>\n"
2101 " <config>\n"
2102 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
2103 " <value type=\"int\">0xbeaf000000000000</value>\n"
2104 " </config>\n"
2105 " </kernel>\n"
2106 " <sepolicy>\n"
2107 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
2108 " </sepolicy>\n"
2109 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
2110 "</compatibility-matrix>\n";
2111
2112 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2113 EXPECT_TRUE(runtime.checkCompatibility(cm, &error)) << error;
2114
2115 xml =
2116 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
2117 " <kernel version=\"3.18.22\">\n"
2118 " <config>\n"
2119 " <key>CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES</key>\n"
2120 " <value type=\"string\"/>\n"
2121 " </config>\n"
2122 " </kernel>\n"
2123 " <kernel version=\"3.18.22\">\n"
2124 " <conditions>\n"
2125 " <config>\n"
2126 " <key>CONFIG_64BIT</key>\n"
2127 " <value type=\"tristate\">y</value>\n"
2128 " </config>\n"
2129 " </conditions>\n"
2130 " <config>\n"
2131 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
2132 " <value type=\"int\">0xdead000000000000</value>\n"
2133 " </config>\n"
2134 " </kernel>\n"
2135 " <kernel version=\"3.18.22\">\n"
2136 " <conditions>\n"
2137 " <config>\n"
2138 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
2139 " <value type=\"int\">24</value>\n"
2140 " </config>\n"
2141 " </conditions>\n"
2142 " <config>\n"
2143 " <key>CONFIG_ANDROID_BINDER_DEVICES</key>\n"
2144 " <value type=\"string\">binder,hwbinder</value>\n"
2145 " </config>\n"
2146 " </kernel>\n"
2147 " <sepolicy>\n"
2148 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
2149 " </sepolicy>\n"
2150 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
2151 "</compatibility-matrix>\n";
2152
2153 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2154 EXPECT_TRUE(runtime.checkCompatibility(cm, &error)) << error;
2155
2156 xml =
2157 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
2158 " <kernel version=\"3.18.22\">\n"
2159 " <config>\n"
2160 " <key>CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES</key>\n"
2161 " <value type=\"string\"/>\n"
2162 " </config>\n"
2163 " </kernel>\n"
2164 " <kernel version=\"3.18.22\">\n"
2165 " <conditions>\n"
2166 " <config>\n"
2167 " <key>CONFIG_64BIT</key>\n"
2168 " <value type=\"tristate\">y</value>\n"
2169 " </config>\n"
2170 " </conditions>\n"
2171 " <config>\n"
2172 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
2173 " <value type=\"int\">0xbeaf000000000000</value>\n"
2174 " </config>\n"
2175 " </kernel>\n"
2176 " <kernel version=\"3.18.22\">\n"
2177 " <conditions>\n"
2178 " <config>\n"
2179 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
2180 " <value type=\"int\">24</value>\n"
2181 " </config>\n"
2182 " </conditions>\n"
2183 " <config>\n"
2184 " <key>CONFIG_ANDROID_BINDER_DEVICES</key>\n"
2185 " <value type=\"string\">binder,hwbinder</value>\n"
2186 " </config>\n"
2187 " </kernel>\n"
2188 " <sepolicy>\n"
2189 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
2190 " </sepolicy>\n"
2191 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
2192 "</compatibility-matrix>\n";
2193
2194 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2195 EXPECT_FALSE(runtime.checkCompatibility(cm, &error)) << "all fragments should be used.";
2196
2197 xml =
2198 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
2199 " <kernel version=\"3.18.22\">\n"
2200 " <config>\n"
2201 " <key>CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES</key>\n"
2202 " <value type=\"string\"/>\n"
2203 " </config>\n"
2204 " </kernel>\n"
2205 " <kernel version=\"3.18.22\">\n"
2206 " <conditions>\n"
2207 " <config>\n"
2208 " <key>CONFIG_64BIT</key>\n"
2209 " <value type=\"tristate\">y</value>\n"
2210 " </config>\n"
2211 " </conditions>\n"
2212 " <config>\n"
2213 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
2214 " <value type=\"int\">0xdead000000000000</value>\n"
2215 " </config>\n"
2216 " </kernel>\n"
2217 " <kernel version=\"3.18.22\">\n"
2218 " <conditions>\n"
2219 " <config>\n"
2220 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
2221 " <value type=\"int\">24</value>\n"
2222 " </config>\n"
2223 " </conditions>\n"
2224 " <config>\n"
2225 " <key>CONFIG_ANDROID_BINDER_DEVICES</key>\n"
2226 " <value type=\"string\">binder</value>\n"
2227 " </config>\n"
2228 " </kernel>\n"
2229 " <sepolicy>\n"
2230 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
2231 " </sepolicy>\n"
2232 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
2233 "</compatibility-matrix>\n";
2234
2235 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2236 EXPECT_FALSE(runtime.checkCompatibility(cm, &error)) << "all fragments should be used";
2237 }
2238
2239 // Run KernelConfigParserInvalidTest on processComments = {true, false}
2240 class KernelConfigParserInvalidTest : public ::testing::TestWithParam<bool> {};
2241
TEST_P(KernelConfigParserInvalidTest,NonSet1)2242 TEST_P(KernelConfigParserInvalidTest, NonSet1) {
2243 const std::string data = "# CONFIG_NOT_EXIST is not sat\n";
2244 auto pair = processData(data, GetParam() /* processComments */, true /* relaxedFormat */);
2245 ASSERT_EQ(OK, pair.second) << pair.first.error();
2246 const auto& configs = pair.first.configs();
2247 EXPECT_EQ(configs.find("CONFIG_NOT_EXIST"), configs.end())
2248 << "CONFIG_NOT_EXIST should not exist because of typo";
2249 }
2250
TEST_P(KernelConfigParserInvalidTest,InvalidLine1)2251 TEST_P(KernelConfigParserInvalidTest, InvalidLine1) {
2252 const std::string data = "FOO_CONFIG=foo\n";
2253 ASSERT_NE(OK,
2254 processData(data, GetParam() /* processComments */, true /* relaxedFormat */).second);
2255 }
2256
TEST_P(KernelConfigParserInvalidTest,InvalidLine2)2257 TEST_P(KernelConfigParserInvalidTest, InvalidLine2) {
2258 const std::string data = "CONFIG_BAR-BAZ=foo\n";
2259 ASSERT_NE(OK,
2260 processData(data, GetParam() /* processComments */, true /* relaxedFormat */).second);
2261 }
2262
2263 INSTANTIATE_TEST_CASE_P(KernelConfigParser, KernelConfigParserInvalidTest, ::testing::Bool());
2264
TEST_F(LibVintfTest,MatrixLevel)2265 TEST_F(LibVintfTest, MatrixLevel) {
2266 std::string error;
2267 CompatibilityMatrix cm;
2268 std::string xml;
2269
2270 xml = "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\"/>";
2271 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2272 EXPECT_EQ(Level::UNSPECIFIED, cm.level());
2273
2274 xml = "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"legacy\"/>";
2275 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2276 EXPECT_EQ(Level::LEGACY, cm.level());
2277
2278 xml = "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\"/>";
2279 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2280 EXPECT_EQ(Level{1}, cm.level());
2281 }
2282
TEST_F(LibVintfTest,ManifestLevel)2283 TEST_F(LibVintfTest, ManifestLevel) {
2284 std::string error;
2285 HalManifest manifest;
2286 std::string xml;
2287
2288 xml = "<manifest " + kMetaVersionStr + " type=\"device\"/>";
2289 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2290 EXPECT_EQ(Level::UNSPECIFIED, manifest.level());
2291
2292 xml = "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"legacy\"/>";
2293 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2294 EXPECT_EQ(Level::LEGACY, manifest.level());
2295
2296 xml = "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"1\"/>";
2297 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2298 EXPECT_EQ(Level{1}, manifest.level());
2299 }
2300
TEST_F(LibVintfTest,AddOptionalHal)2301 TEST_F(LibVintfTest, AddOptionalHal) {
2302 CompatibilityMatrix cm1;
2303 CompatibilityMatrix cm2;
2304 std::string error;
2305 std::string xml;
2306
2307 xml = "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\"/>";
2308 EXPECT_TRUE(fromXml(&cm1, xml, &error)) << error;
2309
2310 xml =
2311 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
2312 " <hal format=\"hidl\">\n"
2313 " <name>android.hardware.foo</name>\n"
2314 " <version>1.0-1</version>\n"
2315 " <interface>\n"
2316 " <name>IFoo</name>\n"
2317 " <instance>default</instance>\n"
2318 " </interface>\n"
2319 " </hal>\n"
2320 "</compatibility-matrix>\n";
2321 EXPECT_TRUE(fromXml(&cm2, xml, &error)) << error;
2322
2323 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2324 xml = toXml(cm1, SerializeFlags::HALS_ONLY);
2325 EXPECT_EQ(xml,
2326 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2327 " <hal format=\"hidl\">\n"
2328 " <name>android.hardware.foo</name>\n"
2329 " <version>1.0-1</version>\n"
2330 " <interface>\n"
2331 " <name>IFoo</name>\n"
2332 " <instance>default</instance>\n"
2333 " </interface>\n"
2334 " </hal>\n"
2335 "</compatibility-matrix>\n");
2336 }
2337
TEST_F(LibVintfTest,AddOptionalHalMinorVersion)2338 TEST_F(LibVintfTest, AddOptionalHalMinorVersion) {
2339 CompatibilityMatrix cm1;
2340 CompatibilityMatrix cm2;
2341 std::string error;
2342 std::string xml;
2343
2344 xml =
2345 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2346 " <hal format=\"hidl\">\n"
2347 " <name>android.hardware.foo</name>\n"
2348 " <version>1.2-3</version>\n"
2349 " <interface>\n"
2350 " <name>IFoo</name>\n"
2351 " <instance>default</instance>\n"
2352 " </interface>\n"
2353 " </hal>\n"
2354 "</compatibility-matrix>\n";
2355 EXPECT_TRUE(fromXml(&cm1, xml, &error)) << error;
2356
2357 xml =
2358 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
2359 " <hal format=\"hidl\">\n"
2360 " <name>android.hardware.foo</name>\n"
2361 " <version>1.0-4</version>\n"
2362 " <interface>\n"
2363 " <name>IFoo</name>\n"
2364 " <instance>default</instance>\n"
2365 " </interface>\n"
2366 " </hal>\n"
2367 "</compatibility-matrix>\n";
2368 EXPECT_TRUE(fromXml(&cm2, xml, &error)) << error;
2369
2370 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2371 xml = toXml(cm1, SerializeFlags::HALS_ONLY);
2372 EXPECT_EQ(xml,
2373 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2374 " <hal format=\"hidl\">\n"
2375 " <name>android.hardware.foo</name>\n"
2376 " <version>1.0-4</version>\n"
2377 " <interface>\n"
2378 " <name>IFoo</name>\n"
2379 " <instance>default</instance>\n"
2380 " </interface>\n"
2381 " </hal>\n"
2382 "</compatibility-matrix>\n");
2383 }
2384
TEST_F(LibVintfTest,AddOptionalHalMajorVersion)2385 TEST_F(LibVintfTest, AddOptionalHalMajorVersion) {
2386 CompatibilityMatrix cm1;
2387 CompatibilityMatrix cm2;
2388 std::string error;
2389 std::string xml;
2390
2391 xml =
2392 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2393 " <hal format=\"hidl\">\n"
2394 " <name>android.hardware.foo</name>\n"
2395 " <version>1.2-3</version>\n"
2396 " <interface>\n"
2397 " <name>IFoo</name>\n"
2398 " <instance>default</instance>\n"
2399 " </interface>\n"
2400 " </hal>\n"
2401 "</compatibility-matrix>\n";
2402 EXPECT_TRUE(fromXml(&cm1, xml, &error)) << error;
2403
2404 xml =
2405 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
2406 " <hal format=\"hidl\">\n"
2407 " <name>android.hardware.foo</name>\n"
2408 " <version>1.2-3</version>\n"
2409 " <version>2.0-4</version>\n"
2410 " <interface>\n"
2411 " <name>IFoo</name>\n"
2412 " <instance>default</instance>\n"
2413 " </interface>\n"
2414 " </hal>\n"
2415 "</compatibility-matrix>\n";
2416 EXPECT_TRUE(fromXml(&cm2, xml, &error)) << error;
2417
2418 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2419 xml = toXml(cm1, SerializeFlags::HALS_ONLY);
2420 EXPECT_EQ(xml,
2421 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2422 " <hal format=\"hidl\">\n"
2423 " <name>android.hardware.foo</name>\n"
2424 " <version>1.2-3</version>\n"
2425 " <version>2.0-4</version>\n"
2426 " <interface>\n"
2427 " <name>IFoo</name>\n"
2428 " <instance>default</instance>\n"
2429 " </interface>\n"
2430 " </hal>\n"
2431 "</compatibility-matrix>\n");
2432 }
2433
TEST_F(LibVintfTest,AddOptionalHalMinorVersionDiffInstance)2434 TEST_F(LibVintfTest, AddOptionalHalMinorVersionDiffInstance) {
2435 CompatibilityMatrix cm1;
2436 CompatibilityMatrix cm2;
2437 std::string error;
2438 std::string xml;
2439
2440 xml =
2441 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2442 " <hal format=\"hidl\">\n"
2443 " <name>android.hardware.foo</name>\n"
2444 " <version>1.0-1</version>\n"
2445 " <interface>\n"
2446 " <name>IFoo</name>\n"
2447 " <instance>default</instance>\n"
2448 " </interface>\n"
2449 " </hal>\n"
2450 "</compatibility-matrix>\n";
2451 EXPECT_TRUE(fromXml(&cm1, xml, &error)) << error;
2452
2453 xml =
2454 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
2455 " <hal format=\"hidl\">\n"
2456 " <name>android.hardware.foo</name>\n"
2457 " <version>1.1-2</version>\n"
2458 " <interface>\n"
2459 " <name>IFoo</name>\n"
2460 " <instance>custom</instance>\n"
2461 " </interface>\n"
2462 " </hal>\n"
2463 "</compatibility-matrix>\n";
2464 EXPECT_TRUE(fromXml(&cm2, xml, &error)) << error;
2465
2466 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2467 xml = toXml(cm1, SerializeFlags::HALS_ONLY);
2468 EXPECT_EQ(xml,
2469 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2470 " <hal format=\"hidl\">\n"
2471 " <name>android.hardware.foo</name>\n"
2472 " <version>1.0-1</version>\n"
2473 " <interface>\n"
2474 " <name>IFoo</name>\n"
2475 " <instance>default</instance>\n"
2476 " </interface>\n"
2477 " </hal>\n"
2478 " <hal format=\"hidl\">\n"
2479 " <name>android.hardware.foo</name>\n"
2480 " <version>1.1-2</version>\n"
2481 " <interface>\n"
2482 " <name>IFoo</name>\n"
2483 " <instance>custom</instance>\n"
2484 " </interface>\n"
2485 " </hal>\n"
2486 "</compatibility-matrix>\n");
2487 }
2488
TEST_F(LibVintfTest,AddRequiredHalOverlapInstance)2489 TEST_F(LibVintfTest, AddRequiredHalOverlapInstance) {
2490 CompatibilityMatrix cm1;
2491 std::string error;
2492 std::string xml;
2493
2494 xml =
2495 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2496 " <hal format=\"hidl\">\n"
2497 " <name>android.hardware.foo</name>\n"
2498 " <version>1.0</version>\n"
2499 " <interface>\n"
2500 " <name>IFoo</name>\n"
2501 " <instance>default</instance>\n"
2502 " <instance>custom</instance>\n"
2503 " </interface>\n"
2504 " </hal>\n"
2505 "</compatibility-matrix>\n";
2506 EXPECT_TRUE(fromXml(&cm1, xml, &error)) << error;
2507
2508 {
2509 // Test that 2.0 should be added to IFoo/default, so 1.0::IFoo/custom
2510 // should be in a new <hal> tag
2511 CompatibilityMatrix cm2;
2512 xml =
2513 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
2514 " <hal format=\"hidl\">\n"
2515 " <name>android.hardware.foo</name>\n"
2516 " <version>2.0</version>\n"
2517 " <interface>\n"
2518 " <name>IFoo</name>\n"
2519 " <instance>default</instance>\n"
2520 " </interface>\n"
2521 " </hal>\n"
2522 "</compatibility-matrix>\n";
2523 EXPECT_TRUE(fromXml(&cm2, xml, &error)) << error;
2524
2525 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2526
2527 xml = toXml(cm1, SerializeFlags::HALS_ONLY);
2528 EXPECT_EQ(xml,
2529 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2530 " <hal format=\"hidl\">\n"
2531 " <name>android.hardware.foo</name>\n"
2532 " <version>1.0</version>\n"
2533 " <interface>\n"
2534 " <name>IFoo</name>\n"
2535 " <instance>custom</instance>\n"
2536 " </interface>\n"
2537 " </hal>\n"
2538 " <hal format=\"hidl\">\n"
2539 " <name>android.hardware.foo</name>\n"
2540 " <version>1.0</version>\n"
2541 " <version>2.0</version>\n"
2542 " <interface>\n"
2543 " <name>IFoo</name>\n"
2544 " <instance>default</instance>\n"
2545 " </interface>\n"
2546 " </hal>\n"
2547 "</compatibility-matrix>\n");
2548 }
2549
2550 {
2551 // Test that 2.0::IFoo/strong should be added as an optional <hal> tag.
2552 CompatibilityMatrix cm2;
2553 xml =
2554 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
2555 " <hal format=\"hidl\">\n"
2556 " <name>android.hardware.foo</name>\n"
2557 " <version>2.0</version>\n"
2558 " <interface>\n"
2559 " <name>IFoo</name>\n"
2560 " <instance>default</instance>\n"
2561 " <instance>strong</instance>\n"
2562 " </interface>\n"
2563 " </hal>\n"
2564 "</compatibility-matrix>\n";
2565 EXPECT_TRUE(fromXml(&cm2, xml, &error)) << error;
2566
2567 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2568
2569 xml = toXml(cm1, SerializeFlags::HALS_ONLY);
2570 EXPECT_EQ(xml,
2571 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2572 " <hal format=\"hidl\">\n"
2573 " <name>android.hardware.foo</name>\n"
2574 " <version>1.0</version>\n"
2575 " <interface>\n"
2576 " <name>IFoo</name>\n"
2577 " <instance>custom</instance>\n"
2578 " </interface>\n"
2579 " </hal>\n"
2580 " <hal format=\"hidl\">\n"
2581 " <name>android.hardware.foo</name>\n"
2582 " <version>1.0</version>\n"
2583 " <version>2.0</version>\n"
2584 " <interface>\n"
2585 " <name>IFoo</name>\n"
2586 " <instance>default</instance>\n"
2587 " </interface>\n"
2588 " </hal>\n"
2589 " <hal format=\"hidl\">\n"
2590 " <name>android.hardware.foo</name>\n"
2591 " <version>2.0</version>\n"
2592 " <interface>\n"
2593 " <name>IFoo</name>\n"
2594 " <instance>strong</instance>\n"
2595 " </interface>\n"
2596 " </hal>\n"
2597 "</compatibility-matrix>\n");
2598 }
2599 }
2600
TEST_F(LibVintfTest,AddRequiredHalOverlapInstanceSplit)2601 TEST_F(LibVintfTest, AddRequiredHalOverlapInstanceSplit) {
2602 CompatibilityMatrix cm1;
2603 CompatibilityMatrix cm2;
2604 std::string error;
2605 std::string xml;
2606
2607 xml =
2608 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2609 " <hal format=\"hidl\">\n"
2610 " <name>android.hardware.foo</name>\n"
2611 " <version>1.0</version>\n"
2612 " <interface>\n"
2613 " <name>IFoo</name>\n"
2614 " <instance>default</instance>\n"
2615 " </interface>\n"
2616 " </hal>\n"
2617 " <hal format=\"hidl\">\n"
2618 " <name>android.hardware.foo</name>\n"
2619 " <version>1.0</version>\n"
2620 " <interface>\n"
2621 " <name>IFoo</name>\n"
2622 " <instance>custom</instance>\n"
2623 " </interface>\n"
2624 " </hal>\n"
2625 "</compatibility-matrix>\n";
2626 EXPECT_TRUE(fromXml(&cm1, xml, &error)) << error;
2627
2628 xml =
2629 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
2630 " <hal format=\"hidl\">\n"
2631 " <name>android.hardware.foo</name>\n"
2632 " <version>2.0</version>\n"
2633 " <interface>\n"
2634 " <name>IFoo</name>\n"
2635 " <instance>default</instance>\n"
2636 " </interface>\n"
2637 " </hal>\n"
2638 " <hal format=\"hidl\">\n"
2639 " <name>android.hardware.foo</name>\n"
2640 " <version>2.0</version>\n"
2641 " <interface>\n"
2642 " <name>IFoo</name>\n"
2643 " <instance>strong</instance>\n"
2644 " </interface>\n"
2645 " </hal>\n"
2646 "</compatibility-matrix>\n";
2647 EXPECT_TRUE(fromXml(&cm2, xml, &error)) << error;
2648
2649 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2650 xml = toXml(cm1, SerializeFlags::HALS_ONLY);
2651 EXPECT_EQ(
2652 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2653 " <hal format=\"hidl\">\n"
2654 " <name>android.hardware.foo</name>\n"
2655 " <version>1.0</version>\n"
2656 " <version>2.0</version>\n"
2657 " <interface>\n"
2658 " <name>IFoo</name>\n"
2659 " <instance>default</instance>\n"
2660 " </interface>\n"
2661 " </hal>\n"
2662 " <hal format=\"hidl\">\n"
2663 " <name>android.hardware.foo</name>\n"
2664 " <version>1.0</version>\n"
2665 " <interface>\n"
2666 " <name>IFoo</name>\n"
2667 " <instance>custom</instance>\n"
2668 " </interface>\n"
2669 " </hal>\n"
2670 " <hal format=\"hidl\">\n"
2671 " <name>android.hardware.foo</name>\n"
2672 " <version>2.0</version>\n"
2673 " <interface>\n"
2674 " <name>IFoo</name>\n"
2675 " <instance>strong</instance>\n"
2676 " </interface>\n"
2677 " </hal>\n"
2678 "</compatibility-matrix>\n",
2679 xml);
2680 }
2681
TEST_F(LibVintfTest,AddOptionalHalUpdatableViaApex)2682 TEST_F(LibVintfTest, AddOptionalHalUpdatableViaApex) {
2683 CompatibilityMatrix cm1;
2684 CompatibilityMatrix cm2;
2685 std::string error;
2686 std::string xml;
2687
2688 xml =
2689 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2690 " <hal format=\"aidl\">\n"
2691 " <name>android.hardware.foo</name>\n"
2692 " <interface>\n"
2693 " <name>IFoo</name>\n"
2694 " <instance>default</instance>\n"
2695 " </interface>\n"
2696 " </hal>\n"
2697 "</compatibility-matrix>\n";
2698 EXPECT_TRUE(fromXml(&cm1, xml, &error)) << error;
2699
2700 xml =
2701 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
2702 " <hal format=\"aidl\" updatable-via-apex=\"true\">\n"
2703 " <name>android.hardware.foo</name>\n"
2704 " <interface>\n"
2705 " <name>IFoo</name>\n"
2706 " <instance>default</instance>\n"
2707 " </interface>\n"
2708 " </hal>\n"
2709 "</compatibility-matrix>\n";
2710 EXPECT_TRUE(fromXml(&cm2, xml, &error)) << error;
2711
2712 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2713 xml = toXml(cm1, SerializeFlags::HALS_ONLY);
2714 EXPECT_EQ(xml,
2715 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2716 " <hal format=\"aidl\" updatable-via-apex=\"true\">\n"
2717 " <name>android.hardware.foo</name>\n"
2718 " <interface>\n"
2719 " <name>IFoo</name>\n"
2720 " <instance>default</instance>\n"
2721 " </interface>\n"
2722 " </hal>\n"
2723 "</compatibility-matrix>\n");
2724 }
2725
TEST_F(LibVintfTest,AddOptionalXmlFile)2726 TEST_F(LibVintfTest, AddOptionalXmlFile) {
2727 CompatibilityMatrix cm1;
2728 CompatibilityMatrix cm2;
2729 std::string error;
2730 std::string xml;
2731
2732 xml =
2733 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2734 " <xmlfile format=\"xsd\">\n"
2735 " <name>foo</name>\n"
2736 " <version>1.0-2</version>\n"
2737 " <path>/foo/bar/baz.xsd</path>\n"
2738 " </xmlfile>\n"
2739 "</compatibility-matrix>\n";
2740 EXPECT_TRUE(fromXml(&cm1, xml, &error)) << error;
2741
2742 xml =
2743 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"
2744 " <xmlfile format=\"xsd\">\n"
2745 " <name>foo</name>\n"
2746 " <version>1.1-3</version>\n"
2747 " <path>/foo/bar/quux.xsd</path>\n"
2748 " </xmlfile>\n"
2749 "</compatibility-matrix>\n";
2750 EXPECT_TRUE(fromXml(&cm2, xml, &error)) << error;
2751
2752 EXPECT_TRUE(addAllXmlFilesAsOptional(&cm1, &cm2, &error)) << error;
2753 xml = toXml(cm1, SerializeFlags::XMLFILES_ONLY);
2754 EXPECT_EQ(xml,
2755 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
2756 " <xmlfile format=\"xsd\">\n"
2757 " <name>foo</name>\n"
2758 " <version>1.0-2</version>\n"
2759 " <path>/foo/bar/baz.xsd</path>\n"
2760 " </xmlfile>\n"
2761 " <xmlfile format=\"xsd\">\n"
2762 " <name>foo</name>\n"
2763 " <version>1.1-3</version>\n"
2764 " <path>/foo/bar/quux.xsd</path>\n"
2765 " </xmlfile>\n"
2766 "</compatibility-matrix>\n");
2767 }
2768
TEST_F(LibVintfTest,VendorNdk)2769 TEST_F(LibVintfTest, VendorNdk) {
2770 CompatibilityMatrix cm;
2771 std::string error;
2772 std::string xml;
2773
2774 xml =
2775 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
2776 " <vendor-ndk>\n"
2777 " <version>P</version>\n"
2778 " <library>libbase.so</library>\n"
2779 " <library>libjpeg.so</library>\n"
2780 " </vendor-ndk>\n"
2781 "</compatibility-matrix>\n";
2782 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2783 EXPECT_EQ(xml, toXml(cm));
2784
2785 EXPECT_EQ("P", cm.getVendorNdkVersion());
2786
2787 {
2788 HalManifest manifest;
2789 xml =
2790 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
2791 " <vendor-ndk>\n"
2792 " <version>27</version>\n"
2793 " <library>libbase.so</library>\n"
2794 " <library>libjpeg.so</library>\n"
2795 " </vendor-ndk>\n"
2796 " <vendor-ndk>\n"
2797 " <version>P</version>\n"
2798 " <library>libbase.so</library>\n"
2799 " <library>libjpeg.so</library>\n"
2800 " <library>libtinyxml2.so</library>\n"
2801 " </vendor-ndk>\n"
2802 "</manifest>\n";
2803
2804 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2805 EXPECT_EQ(xml, toXml(manifest));
2806 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
2807 }
2808
2809 {
2810 HalManifest manifest;
2811 xml =
2812 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
2813 " <vendor-ndk>\n"
2814 " <version>27</version>\n"
2815 " <library>libbase.so</library>\n"
2816 " <library>libjpeg.so</library>\n"
2817 " </vendor-ndk>\n"
2818 "</manifest>\n";
2819
2820 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2821 EXPECT_EQ(xml, toXml(manifest));
2822 EXPECT_FALSE(manifest.checkCompatibility(cm, &error));
2823 EXPECT_IN("Vndk version P is not supported.", error);
2824 }
2825
2826 {
2827 HalManifest manifest;
2828 xml =
2829 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
2830 " <vendor-ndk>\n"
2831 " <version>P</version>\n"
2832 " <library>libbase.so</library>\n"
2833 " </vendor-ndk>\n"
2834 "</manifest>\n";
2835
2836 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2837 EXPECT_EQ(xml, toXml(manifest));
2838 EXPECT_FALSE(manifest.checkCompatibility(cm, &error));
2839 EXPECT_IN("Vndk libs incompatible for version P.", error);
2840 EXPECT_IN("libjpeg.so", error);
2841 }
2842 }
2843
TEST_F(LibVintfTest,MissingVendorNdkInMatrix)2844 TEST_F(LibVintfTest, MissingVendorNdkInMatrix) {
2845 CompatibilityMatrix cm;
2846 std::string xml;
2847 std::string error;
2848
2849 xml = "<compatibility-matrix " + kMetaVersionStr + " type=\"device\"/>\n";
2850 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
2851
2852 {
2853 HalManifest manifest;
2854 xml = "<manifest " + kMetaVersionStr + " type=\"framework\"/>\n";
2855 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2856
2857 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
2858 }
2859
2860 {
2861 HalManifest manifest;
2862 xml =
2863 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
2864 " <vendor-ndk>\n"
2865 " <version>P</version>\n"
2866 " <library>libbase.so</library>\n"
2867 " </vendor-ndk>\n"
2868 "</manifest>\n";
2869 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2870
2871 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
2872 }
2873 }
2874
TEST_F(LibVintfTest,DuplicatedVendorNdkVersion)2875 TEST_F(LibVintfTest, DuplicatedVendorNdkVersion) {
2876 std::string error;
2877 HalManifest manifest;
2878 std::string xml =
2879 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
2880 " <vendor-ndk>\n"
2881 " <version>27</version>\n"
2882 " </vendor-ndk>\n"
2883 " <vendor-ndk>\n"
2884 " <version>27</version>\n"
2885 " </vendor-ndk>\n"
2886 "</manifest>\n";
2887
2888 EXPECT_FALSE(fromXml(&manifest, xml, &error));
2889 EXPECT_EQ("Duplicated manifest.vendor-ndk.version 27", error);
2890 }
2891
TEST_F(LibVintfTest,ManifestHalOverride)2892 TEST_F(LibVintfTest, ManifestHalOverride) {
2893 std::string error;
2894 HalManifest manifest;
2895 std::string xml =
2896 "<manifest version=\"5.0\" type=\"device\">\n"
2897 " <hal format=\"hidl\" override=\"true\">\n"
2898 " <name>android.hardware.foo</name>\n"
2899 " <transport>hwbinder</transport>\n"
2900 " <version>1.0</version>\n"
2901 " </hal>\n"
2902 " <hal format=\"hidl\">\n"
2903 " <name>android.hardware.bar</name>\n"
2904 " <transport>hwbinder</transport>\n"
2905 " <version>1.0</version>\n"
2906 " </hal>\n"
2907 "</manifest>\n";
2908 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2909 const auto& foo = getHals(manifest, "android.hardware.foo");
2910 ASSERT_FALSE(foo.empty());
2911 EXPECT_TRUE(foo.front()->isOverride());
2912 const auto& bar = getHals(manifest, "android.hardware.bar");
2913 ASSERT_FALSE(bar.empty());
2914 EXPECT_FALSE(bar.front()->isOverride());
2915 }
2916
TEST_F(LibVintfTest,ManifestHalOverrideLatest)2917 TEST_F(LibVintfTest, ManifestHalOverrideLatest) {
2918 std::string error;
2919 HalManifest manifest;
2920 std::string xml =
2921 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
2922 " <hal format=\"hidl\" override=\"true\">\n"
2923 " <name>android.hardware.foo</name>\n"
2924 " <transport>hwbinder</transport>\n"
2925 " <version>1.0</version>\n"
2926 " </hal>\n"
2927 "</manifest>\n";
2928 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2929 const auto& foo = getHals(manifest, "android.hardware.foo");
2930 ASSERT_FALSE(foo.empty());
2931 EXPECT_TRUE(foo.front()->isOverride());
2932 }
2933
2934 // Test functionality of override="true" tag
TEST_F(LibVintfTest,ManifestAddOverrideHalSimple)2935 TEST_F(LibVintfTest, ManifestAddOverrideHalSimple) {
2936 std::string error;
2937 HalManifest manifest;
2938 std::string xml = "<manifest " + kMetaVersionStr + " type=\"device\"/>\n";
2939 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2940
2941 HalManifest newManifest;
2942 xml =
2943 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
2944 " <hal format=\"hidl\" override=\"true\">\n"
2945 " <name>android.hardware.foo</name>\n"
2946 " <transport>hwbinder</transport>\n"
2947 " <fqname>@1.1::IFoo/default</fqname>\n"
2948 " </hal>\n"
2949 "</manifest>\n";
2950 EXPECT_TRUE(fromXml(&newManifest, xml, &error)) << error;
2951
2952 manifest.addAllHals(&newManifest);
2953 EXPECT_EQ(xml, toXml(manifest, SerializeFlags::HALS_ONLY));
2954 }
2955
2956 // Test functionality of override="true" tag
TEST_F(LibVintfTest,ManifestAddOverrideHalSimpleWithInterface)2957 TEST_F(LibVintfTest, ManifestAddOverrideHalSimpleWithInterface) {
2958 std::string error;
2959 HalManifest manifest;
2960 std::string xml = "<manifest " + kMetaVersionStr + " type=\"device\"/>\n";
2961 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
2962
2963 HalManifest newManifest;
2964 xml =
2965 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
2966 " <hal format=\"hidl\" override=\"true\">\n"
2967 " <name>android.hardware.foo</name>\n"
2968 " <transport>hwbinder</transport>\n"
2969 " <version>1.1</version>\n"
2970 " <interface>\n"
2971 " <name>IFoo</name>\n"
2972 " <instance>default</instance>\n"
2973 " </interface>\n"
2974 " </hal>\n"
2975 "</manifest>\n";
2976 EXPECT_TRUE(fromXml(&newManifest, xml, &error)) << error;
2977
2978 manifest.addAllHals(&newManifest);
2979 EXPECT_EQ(
2980 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
2981 " <hal format=\"hidl\" override=\"true\">\n"
2982 " <name>android.hardware.foo</name>\n"
2983 " <transport>hwbinder</transport>\n"
2984 " <fqname>@1.1::IFoo/default</fqname>\n"
2985 " </hal>\n"
2986 "</manifest>\n",
2987 toXml(manifest, SerializeFlags::HALS_ONLY));
2988 }
2989
TEST_F(LibVintfTest,ManifestAddOverrideHalSimpleOverride)2990 TEST_F(LibVintfTest, ManifestAddOverrideHalSimpleOverride) {
2991 std::string error;
2992 HalManifest manifest;
2993 std::string xml =
2994 "<manifest version=\"5.0\" type=\"device\">\n"
2995 " <hal format=\"hidl\">\n"
2996 " <name>android.hardware.foo</name>\n"
2997 " <transport>hwbinder</transport>\n"
2998 " <version>1.0</version>\n"
2999 " </hal>\n"
3000 "</manifest>\n";
3001 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
3002
3003 HalManifest newManifest;
3004 xml =
3005 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3006 " <hal format=\"hidl\" override=\"true\">\n"
3007 " <name>android.hardware.foo</name>\n"
3008 " <transport>hwbinder</transport>\n"
3009 " <fqname>@1.1::IFoo/default</fqname>\n"
3010 " </hal>\n"
3011 "</manifest>\n";
3012 EXPECT_TRUE(fromXml(&newManifest, xml, &error)) << error;
3013
3014 manifest.addAllHals(&newManifest);
3015 EXPECT_EQ(xml, toXml(manifest, SerializeFlags::HALS_ONLY));
3016 }
3017
TEST_F(LibVintfTest,ManifestAddOverrideHalSimpleOverrideWithInterface)3018 TEST_F(LibVintfTest, ManifestAddOverrideHalSimpleOverrideWithInterface) {
3019 std::string error;
3020 HalManifest manifest;
3021 std::string xml =
3022 "<manifest version=\"5.0\" type=\"device\">\n"
3023 " <hal format=\"hidl\">\n"
3024 " <name>android.hardware.foo</name>\n"
3025 " <transport>hwbinder</transport>\n"
3026 " <version>1.0</version>\n"
3027 " </hal>\n"
3028 "</manifest>\n";
3029 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
3030
3031 HalManifest newManifest;
3032 xml =
3033 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3034 " <hal format=\"hidl\" override=\"true\">\n"
3035 " <name>android.hardware.foo</name>\n"
3036 " <transport>hwbinder</transport>\n"
3037 " <version>1.1</version>\n"
3038 " <interface>\n"
3039 " <name>IFoo</name>\n"
3040 " <instance>default</instance>\n"
3041 " </interface>\n"
3042 " </hal>\n"
3043 "</manifest>\n";
3044 EXPECT_TRUE(fromXml(&newManifest, xml, &error)) << error;
3045
3046 manifest.addAllHals(&newManifest);
3047 EXPECT_EQ(
3048 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3049 " <hal format=\"hidl\" override=\"true\">\n"
3050 " <name>android.hardware.foo</name>\n"
3051 " <transport>hwbinder</transport>\n"
3052 " <fqname>@1.1::IFoo/default</fqname>\n"
3053 " </hal>\n"
3054 "</manifest>\n",
3055 toXml(manifest, SerializeFlags::HALS_ONLY));
3056 }
3057
3058 // Existing major versions should be removed.
TEST_F(LibVintfTest,ManifestAddOverrideHalMultiVersion)3059 TEST_F(LibVintfTest, ManifestAddOverrideHalMultiVersion) {
3060 std::string error;
3061 HalManifest manifest;
3062 std::string xml =
3063 "<manifest version=\"5.0\" type=\"device\">\n"
3064 " <hal format=\"hidl\">\n"
3065 " <name>android.hardware.foo</name>\n"
3066 " <transport>hwbinder</transport>\n"
3067 " <version>1.3</version>\n"
3068 " <version>2.4</version>\n"
3069 " <interface>\n"
3070 " <name>IFoo</name>\n"
3071 " <instance>slot1</instance>\n"
3072 " </interface>\n"
3073 " </hal>\n"
3074 " <hal format=\"hidl\">\n"
3075 " <name>android.hardware.bar</name>\n"
3076 " <transport>hwbinder</transport>\n"
3077 " <version>1.3</version>\n"
3078 " </hal>\n"
3079 "</manifest>\n";
3080 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
3081
3082 HalManifest newManifest;
3083 xml =
3084 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3085 " <hal format=\"hidl\" override=\"true\">\n"
3086 " <name>android.hardware.foo</name>\n"
3087 " <transport>hwbinder</transport>\n"
3088 " <version>1.1</version>\n"
3089 " <version>3.1</version>\n"
3090 " <interface>\n"
3091 " <name>IFoo</name>\n"
3092 " <instance>slot2</instance>\n"
3093 " </interface>\n"
3094 " </hal>\n"
3095 "</manifest>\n";
3096 EXPECT_TRUE(fromXml(&newManifest, xml, &error)) << error;
3097
3098 manifest.addAllHals(&newManifest);
3099 EXPECT_EQ(
3100 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3101 " <hal format=\"hidl\">\n"
3102 " <name>android.hardware.bar</name>\n"
3103 " <transport>hwbinder</transport>\n"
3104 " <version>1.3</version>\n"
3105 " </hal>\n"
3106 " <hal format=\"hidl\">\n"
3107 " <name>android.hardware.foo</name>\n"
3108 " <transport>hwbinder</transport>\n"
3109 " <fqname>@2.4::IFoo/slot1</fqname>\n"
3110 " </hal>\n"
3111 " <hal format=\"hidl\" override=\"true\">\n"
3112 " <name>android.hardware.foo</name>\n"
3113 " <transport>hwbinder</transport>\n"
3114 " <fqname>@1.1::IFoo/slot2</fqname>\n"
3115 " <fqname>@3.1::IFoo/slot2</fqname>\n"
3116 " </hal>\n"
3117 "</manifest>\n",
3118 toXml(manifest, SerializeFlags::HALS_ONLY));
3119 }
3120
TEST_F(LibVintfTest,ManifestAddOverrideHalMultiVersion2)3121 TEST_F(LibVintfTest, ManifestAddOverrideHalMultiVersion2) {
3122 std::string error;
3123 HalManifest manifest;
3124 std::string xml =
3125 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3126 " <hal format=\"hidl\">\n"
3127 " <name>android.hardware.foo</name>\n"
3128 " <transport>hwbinder</transport>\n"
3129 " <version>1.3</version>\n"
3130 " <version>2.4</version>\n"
3131 " <interface>\n"
3132 " <name>IFoo</name>\n"
3133 " <instance>slot1</instance>\n"
3134 " </interface>\n"
3135 " </hal>\n"
3136 "</manifest>\n";
3137 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
3138
3139 HalManifest newManifest;
3140 xml =
3141 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3142 " <hal format=\"hidl\" override=\"true\">\n"
3143 " <name>android.hardware.foo</name>\n"
3144 " <transport>hwbinder</transport>\n"
3145 " <fqname>@1.1::IFoo/slot2</fqname>\n"
3146 " <fqname>@2.1::IFoo/slot2</fqname>\n"
3147 " </hal>\n"
3148 "</manifest>\n";
3149
3150 EXPECT_TRUE(fromXml(&newManifest, xml, &error)) << error;
3151
3152 manifest.addAllHals(&newManifest);
3153 EXPECT_EQ(xml, toXml(manifest, SerializeFlags::HALS_ONLY));
3154 }
3155
TEST_F(LibVintfTest,ManifestAddOverrideHalMultiVersion2WithInterface)3156 TEST_F(LibVintfTest, ManifestAddOverrideHalMultiVersion2WithInterface) {
3157 std::string error;
3158 HalManifest manifest;
3159 std::string xml =
3160 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3161 " <hal format=\"hidl\">\n"
3162 " <name>android.hardware.foo</name>\n"
3163 " <transport>hwbinder</transport>\n"
3164 " <version>1.3</version>\n"
3165 " <version>2.4</version>\n"
3166 " <interface>\n"
3167 " <name>IFoo</name>\n"
3168 " <instance>slot1</instance>\n"
3169 " </interface>\n"
3170 " </hal>\n"
3171 "</manifest>\n";
3172 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
3173
3174 HalManifest newManifest;
3175 xml =
3176 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3177 " <hal format=\"hidl\" override=\"true\">\n"
3178 " <name>android.hardware.foo</name>\n"
3179 " <transport>hwbinder</transport>\n"
3180 " <version>1.1</version>\n"
3181 " <version>2.1</version>\n"
3182 " <interface>\n"
3183 " <name>IFoo</name>\n"
3184 " <instance>slot2</instance>\n"
3185 " </interface>\n"
3186 " </hal>\n"
3187 "</manifest>\n";
3188
3189 EXPECT_TRUE(fromXml(&newManifest, xml, &error)) << error;
3190
3191 manifest.addAllHals(&newManifest);
3192 EXPECT_EQ(
3193 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3194 " <hal format=\"hidl\" override=\"true\">\n"
3195 " <name>android.hardware.foo</name>\n"
3196 " <transport>hwbinder</transport>\n"
3197 " <fqname>@1.1::IFoo/slot2</fqname>\n"
3198 " <fqname>@2.1::IFoo/slot2</fqname>\n"
3199 " </hal>\n"
3200 "</manifest>\n",
3201 toXml(manifest, SerializeFlags::HALS_ONLY));
3202 }
3203
3204 // if no <versions>, remove all existing <hal> with given <name>.
TEST_F(LibVintfTest,ManifestAddOverrideHalRemoveAll)3205 TEST_F(LibVintfTest, ManifestAddOverrideHalRemoveAll) {
3206 std::string error;
3207 HalManifest manifest;
3208 std::string xml =
3209 "<manifest version=\"5.0\" type=\"device\">\n"
3210 " <hal format=\"hidl\">\n"
3211 " <name>android.hardware.foo</name>\n"
3212 " <transport>hwbinder</transport>\n"
3213 " <version>1.3</version>\n"
3214 " <version>2.4</version>\n"
3215 " <interface>\n"
3216 " <name>IFoo</name>\n"
3217 " <instance>slot1</instance>\n"
3218 " </interface>\n"
3219 " </hal>\n"
3220 " <hal format=\"hidl\">\n"
3221 " <name>android.hardware.foo</name>\n"
3222 " <transport>hwbinder</transport>\n"
3223 " <version>3.1</version>\n"
3224 " <version>4.3</version>\n"
3225 " <interface>\n"
3226 " <name>IBar</name>\n"
3227 " <instance>slot2</instance>\n"
3228 " </interface>\n"
3229 " </hal>\n"
3230 " <hal format=\"hidl\">\n"
3231 " <name>android.hardware.bar</name>\n"
3232 " <transport>hwbinder</transport>\n"
3233 " <version>1.3</version>\n"
3234 " </hal>\n"
3235 "</manifest>\n";
3236 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
3237
3238 HalManifest newManifest;
3239 xml =
3240 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3241 " <hal format=\"hidl\" override=\"true\">\n"
3242 " <name>android.hardware.foo</name>\n"
3243 " <transport>hwbinder</transport>\n"
3244 " </hal>\n"
3245 "</manifest>\n";
3246
3247 EXPECT_TRUE(fromXml(&newManifest, xml, &error)) << error;
3248
3249 manifest.addAllHals(&newManifest);
3250 EXPECT_EQ(
3251 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3252 " <hal format=\"hidl\">\n"
3253 " <name>android.hardware.bar</name>\n"
3254 " <transport>hwbinder</transport>\n"
3255 " <version>1.3</version>\n"
3256 " </hal>\n"
3257 " <hal format=\"hidl\" override=\"true\">\n"
3258 " <name>android.hardware.foo</name>\n"
3259 " <transport>hwbinder</transport>\n"
3260 " </hal>\n"
3261 "</manifest>\n",
3262 toXml(manifest, SerializeFlags::HALS_ONLY));
3263 }
3264
3265 // Make sure missing tags in old VINTF files does not cause incompatibilities.
TEST_F(LibVintfTest,Empty)3266 TEST_F(LibVintfTest, Empty) {
3267 CompatibilityMatrix cm;
3268 HalManifest manifest;
3269 std::string xml;
3270 std::string error;
3271
3272 xml = "<compatibility-matrix " + kMetaVersionStr + " type=\"device\"/>\n";
3273 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
3274
3275 xml = "<manifest " + kMetaVersionStr + " type=\"framework\"/>\n";
3276 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
3277
3278 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
3279 }
3280
TEST_F(LibVintfTest,ParsingUpdatableHals)3281 TEST_F(LibVintfTest, ParsingUpdatableHals) {
3282 std::string error;
3283
3284 HalManifest manifest;
3285 std::string manifestXml =
3286 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3287 " <hal format=\"aidl\" updatable-via-apex=\"com.android.foo\">\n"
3288 " <name>android.hardware.foo</name>\n"
3289 " <fqname>IFoo/default</fqname>\n"
3290 " </hal>\n"
3291 "</manifest>\n";
3292 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
3293 EXPECT_EQ(manifestXml, toXml(manifest, SerializeFlags::HALS_ONLY));
3294
3295 // check by calling the API: updatableViaApex()
3296 auto foo = getHals(manifest, "android.hardware.foo");
3297 ASSERT_EQ(1u, foo.size());
3298 EXPECT_THAT(foo.front()->updatableViaApex(), Optional(Eq("com.android.foo")));
3299 }
3300
TEST_F(LibVintfTest,ParsingUpdatableViaApex_EmptyIsValidForNonUpdatableHal)3301 TEST_F(LibVintfTest, ParsingUpdatableViaApex_EmptyIsValidForNonUpdatableHal) {
3302 std::string error;
3303
3304 HalManifest manifest;
3305 manifest.setFileName("/apex/com.foo/etc/vintf/manifest.xml");
3306 std::string manifestXml =
3307 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3308 " <hal format=\"aidl\" updatable-via-apex=\"\">\n"
3309 " <name>android.hardware.foo</name>\n"
3310 " <fqname>IFoo/default</fqname>\n"
3311 " </hal>\n"
3312 "</manifest>\n";
3313 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
3314 EXPECT_EQ(manifestXml, toXml(manifest, SerializeFlags::HALS_ONLY));
3315
3316 // check by calling the API: updatableViaApex()
3317 auto foo = getHals(manifest, "android.hardware.foo");
3318 ASSERT_EQ(1u, foo.size());
3319 EXPECT_THAT(foo.front()->updatableViaApex(), Optional(Eq("")));
3320 }
3321
TEST_F(LibVintfTest,ParsingUpdatableViaApex_UpdatableHalCanExplicitlySet)3322 TEST_F(LibVintfTest, ParsingUpdatableViaApex_UpdatableHalCanExplicitlySet) {
3323 std::string error;
3324
3325 HalManifest manifest;
3326 manifest.setFileName("/apex/com.foo/etc/vintf/manifest.xml");
3327 std::string manifestXml =
3328 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3329 " <hal format=\"aidl\" updatable-via-apex=\"com.foo\">\n"
3330 " <name>android.hardware.foo</name>\n"
3331 " <fqname>IFoo/default</fqname>\n"
3332 " </hal>\n"
3333 "</manifest>\n";
3334 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
3335 EXPECT_EQ(manifestXml, toXml(manifest, SerializeFlags::HALS_ONLY));
3336
3337 // check by calling the API: updatableViaApex()
3338 auto foo = getHals(manifest, "android.hardware.foo");
3339 ASSERT_EQ(1u, foo.size());
3340 EXPECT_THAT(foo.front()->updatableViaApex(), Optional(Eq("com.foo")));
3341 }
3342
TEST_F(LibVintfTest,ParsingUpdatableViaApex_ErrorIfExplicitValueMismatch)3343 TEST_F(LibVintfTest, ParsingUpdatableViaApex_ErrorIfExplicitValueMismatch) {
3344 std::string error;
3345
3346 HalManifest manifest;
3347 manifest.setFileName("/apex/com.bar/etc/vintf/manifest.xml");
3348 std::string manifestXml =
3349 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3350 " <hal format=\"aidl\" updatable-via-apex=\"com.foo\">\n"
3351 " <name>android.hardware.foo</name>\n"
3352 " <fqname>IFoo/default</fqname>\n"
3353 " </hal>\n"
3354 "</manifest>\n";
3355 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
3356 EXPECT_IN("updatable-via-apex com.foo doesn't match", error);
3357 }
3358
TEST_F(LibVintfTest,ParsingUpdatableViaApex_SetToCurrentApex)3359 TEST_F(LibVintfTest, ParsingUpdatableViaApex_SetToCurrentApex) {
3360 std::string error;
3361
3362 HalManifest manifest;
3363 manifest.setFileName("/apex/com.foo/etc/vintf/manifest.xml");
3364 std::string manifestXml =
3365 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3366 " <hal format=\"aidl\">\n"
3367 " <name>android.hardware.foo</name>\n"
3368 " <fqname>IFoo/default</fqname>\n"
3369 " </hal>\n"
3370 "</manifest>\n";
3371 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error));
3372 EXPECT_IN("updatable-via-apex=\"com.foo\"", toXml(manifest, SerializeFlags::HALS_ONLY));
3373
3374 // check by calling the API: updatableViaApex()
3375 auto foo = getHals(manifest, "android.hardware.foo");
3376 ASSERT_EQ(1u, foo.size());
3377 EXPECT_THAT(foo.front()->updatableViaApex(), Optional(Eq("com.foo")));
3378 }
3379
TEST_F(LibVintfTest,ParsingUpdatableHalsWithInterface)3380 TEST_F(LibVintfTest, ParsingUpdatableHalsWithInterface) {
3381 std::string error;
3382
3383 HalManifest manifest;
3384 std::string manifestXml =
3385 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3386 " <hal format=\"aidl\" updatable-via-apex=\"com.android.foo\">\n"
3387 " <name>android.hardware.foo</name>\n"
3388 " <interface>\n"
3389 " <name>IFoo</name>\n"
3390 " <instance>default</instance>\n"
3391 " </interface>\n"
3392 " </hal>\n"
3393 "</manifest>\n";
3394 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
3395 EXPECT_EQ(
3396 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3397 " <hal format=\"aidl\" updatable-via-apex=\"com.android.foo\">\n"
3398 " <name>android.hardware.foo</name>\n"
3399 " <fqname>IFoo/default</fqname>\n"
3400 " </hal>\n"
3401 "</manifest>\n",
3402 toXml(manifest, SerializeFlags::HALS_ONLY));
3403
3404 // check by calling the API: updatableViaApex()
3405 auto foo = getHals(manifest, "android.hardware.foo");
3406 ASSERT_EQ(1u, foo.size());
3407 EXPECT_THAT(foo.front()->updatableViaApex(), Optional(Eq("com.android.foo")));
3408 }
3409
TEST_F(LibVintfTest,ParsingUpdatableViaSystemHals)3410 TEST_F(LibVintfTest, ParsingUpdatableViaSystemHals) {
3411 std::string error;
3412
3413 HalManifest manifest;
3414 std::string manifestXml =
3415 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3416 " <hal format=\"aidl\" updatable-via-system=\"true\">\n"
3417 " <name>android.hardware.foo</name>\n"
3418 " <fqname>IFoo/default</fqname>\n"
3419 " </hal>\n"
3420 "</manifest>\n";
3421 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
3422 EXPECT_EQ(manifestXml, toXml(manifest, SerializeFlags::HALS_ONLY));
3423
3424 auto foo = getHals(manifest, "android.hardware.foo");
3425 ASSERT_EQ(1u, foo.size());
3426 EXPECT_THAT(foo.front()->updatableViaSystem(), true);
3427 }
3428
TEST_F(LibVintfTest,ParsingUpdatableViaSystemHals_defaultIsNonUpdatableHal)3429 TEST_F(LibVintfTest, ParsingUpdatableViaSystemHals_defaultIsNonUpdatableHal) {
3430 std::string error;
3431
3432 HalManifest manifest;
3433 std::string manifestXml =
3434 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3435 " <hal format=\"aidl\">\n"
3436 " <name>android.hardware.foo</name>\n"
3437 " <fqname>IFoo/default</fqname>\n"
3438 " </hal>\n"
3439 "</manifest>\n";
3440 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
3441 EXPECT_EQ(manifestXml, toXml(manifest, SerializeFlags::HALS_ONLY));
3442
3443 auto foo = getHals(manifest, "android.hardware.foo");
3444 ASSERT_EQ(1u, foo.size());
3445 EXPECT_THAT(foo.front()->updatableViaSystem(), false);
3446 }
3447
TEST_F(LibVintfTest,ParsingHalsAccessor)3448 TEST_F(LibVintfTest, ParsingHalsAccessor) {
3449 std::string error;
3450
3451 HalManifest manifest;
3452 std::string manifestXml =
3453 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3454 " <hal format=\"aidl\">\n"
3455 " <name>android.hardware.foo</name>\n"
3456 " <fqname>IFoo/default</fqname>\n"
3457 " </hal>\n"
3458 "</manifest>\n";
3459 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
3460 EXPECT_EQ(manifestXml, toXml(manifest, SerializeFlags::HALS_ONLY));
3461
3462 auto foo = getHals(manifest, "android.hardware.foo");
3463 ASSERT_EQ(1u, foo.size());
3464 ASSERT_FALSE(foo.front()->accessor().has_value());
3465
3466 HalManifest newManifest;
3467 std::string accessorName = "android.os.IAccessor/android.hardware.foo.IFoo/default";
3468 manifestXml =
3469 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3470 " <hal format=\"aidl\">\n"
3471 " <name>android.hardware.foo</name>\n"
3472 " <accessor>" + accessorName + "</accessor>\n"
3473 " <fqname>IFoo/default</fqname>\n"
3474 " </hal>\n"
3475 "</manifest>\n";
3476 EXPECT_TRUE(fromXml(&newManifest, manifestXml, &error)) << error;
3477 EXPECT_EQ(manifestXml, toXml(newManifest, SerializeFlags::HALS_ONLY));
3478
3479 foo = getHals(newManifest, "android.hardware.foo");
3480 ASSERT_EQ(1u, foo.size());
3481 ASSERT_EQ(accessorName, foo.front()->accessor());
3482 }
3483
TEST_F(LibVintfTest,RejectHalsAccessorNoValue)3484 TEST_F(LibVintfTest, RejectHalsAccessorNoValue) {
3485 std::string error;
3486
3487 HalManifest manifest;
3488 std::string manifestXml =
3489 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3490 " <hal format=\"aidl\">\n"
3491 " <name>android.hardware.foo</name>\n"
3492 " <accessor></accessor>\n"
3493 " <fqname>IFoo/default</fqname>\n"
3494 " </hal>\n"
3495 "</manifest>\n";
3496 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
3497 EXPECT_IN("Accessor requires a non-empty value", error);
3498 }
3499
TEST_F(LibVintfTest,RejectHalsAccessorMoreThanOneValue)3500 TEST_F(LibVintfTest, RejectHalsAccessorMoreThanOneValue) {
3501 std::string error;
3502
3503 HalManifest manifest;
3504 std::string accessorName1 = "android.os.IAccessor/android.hardware.foo.IFoo/default";
3505 std::string accessorName2 = "android.os.IAccessor/android.hardware.foo.IFoo/vm";
3506 std::string manifestXml =
3507 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3508 " <hal format=\"aidl\">\n"
3509 " <name>android.hardware.foo</name>\n"
3510 " <accessor>" + accessorName1 + "</accessor>\n"
3511 " <accessor>" + accessorName2 + "</accessor>\n"
3512 " <fqname>IFoo/default</fqname>\n"
3513 " </hal>\n"
3514 "</manifest>\n";
3515 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
3516 EXPECT_IN("No more than one <accessor> is allowed in <hal>", error);
3517 }
3518
TEST_F(LibVintfTest,ParsingHalsInetTransport)3519 TEST_F(LibVintfTest, ParsingHalsInetTransport) {
3520 std::string error;
3521
3522 HalManifest manifest;
3523 std::string manifestXml =
3524 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3525 " <hal format=\"aidl\">\n"
3526 " <name>android.hardware.foo</name>\n"
3527 " <transport ip=\"1.2.3.4\" port=\"12\">inet</transport>\n"
3528 " <fqname>IFoo/default</fqname>\n"
3529 " </hal>\n"
3530 "</manifest>\n";
3531 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
3532 EXPECT_EQ(manifestXml, toXml(manifest, SerializeFlags::HALS_ONLY));
3533
3534 auto foo = getHals(manifest, "android.hardware.foo");
3535 ASSERT_EQ(1u, foo.size());
3536 ASSERT_TRUE(foo.front()->ip().has_value());
3537 ASSERT_TRUE(foo.front()->port().has_value());
3538 EXPECT_EQ("1.2.3.4", *foo.front()->ip());
3539 EXPECT_EQ(12, *foo.front()->port());
3540 }
3541
TEST_F(LibVintfTest,ParsingHalsInetTransportWithInterface)3542 TEST_F(LibVintfTest, ParsingHalsInetTransportWithInterface) {
3543 std::string error;
3544
3545 HalManifest manifest;
3546 std::string manifestXml =
3547 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3548 " <hal format=\"aidl\">\n"
3549 " <name>android.hardware.foo</name>\n"
3550 " <transport ip=\"1.2.3.4\" port=\"12\">inet</transport>\n"
3551 " <interface>\n"
3552 " <name>IFoo</name>\n"
3553 " <instance>default</instance>\n"
3554 " </interface>\n"
3555 " </hal>\n"
3556 "</manifest>\n";
3557 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
3558 EXPECT_EQ(
3559 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3560 " <hal format=\"aidl\">\n"
3561 " <name>android.hardware.foo</name>\n"
3562 " <transport ip=\"1.2.3.4\" port=\"12\">inet</transport>\n"
3563 " <fqname>IFoo/default</fqname>\n"
3564 " </hal>\n"
3565 "</manifest>\n",
3566 toXml(manifest, SerializeFlags::HALS_ONLY));
3567
3568 auto foo = getHals(manifest, "android.hardware.foo");
3569 ASSERT_EQ(1u, foo.size());
3570 ASSERT_TRUE(foo.front()->ip().has_value());
3571 ASSERT_TRUE(foo.front()->port().has_value());
3572 EXPECT_EQ("1.2.3.4", *foo.front()->ip());
3573 EXPECT_EQ(12, *foo.front()->port());
3574 }
3575
TEST_F(LibVintfTest,RejectHalsInetTransportNoAttrs)3576 TEST_F(LibVintfTest, RejectHalsInetTransportNoAttrs) {
3577 std::string error;
3578
3579 HalManifest manifest;
3580 std::string manifestXml =
3581 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3582 " <hal format=\"aidl\">\n"
3583 " <name>android.hardware.foo</name>\n"
3584 " <transport>inet</transport>\n"
3585 " <interface>\n"
3586 " <name>IFoo</name>\n"
3587 " <instance>default</instance>\n"
3588 " </interface>\n"
3589 " </hal>\n"
3590 "</manifest>\n";
3591 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
3592 EXPECT_IN("Transport inet requires ip and port attributes", error);
3593 }
3594
TEST_F(LibVintfTest,RejectHalsInetTransportMissingAttrs)3595 TEST_F(LibVintfTest, RejectHalsInetTransportMissingAttrs) {
3596 std::string error;
3597
3598 HalManifest manifest;
3599 std::string manifestXml =
3600 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3601 " <hal format=\"aidl\">\n"
3602 " <name>android.hardware.foo</name>\n"
3603 " <transport ip=\"1.2.3.4\">inet</transport>\n"
3604 " <interface>\n"
3605 " <name>IFoo</name>\n"
3606 " <instance>default</instance>\n"
3607 " </interface>\n"
3608 " </hal>\n"
3609 "</manifest>\n";
3610 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
3611 EXPECT_IN("Transport inet requires ip and port", error);
3612 }
3613
TEST_F(LibVintfTest,RejectHalsEmptyTransportWithInetAttrs)3614 TEST_F(LibVintfTest, RejectHalsEmptyTransportWithInetAttrs) {
3615 std::string error;
3616
3617 HalManifest manifest;
3618 std::string manifestXml =
3619 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3620 " <hal format=\"aidl\">\n"
3621 " <name>android.hardware.foo</name>\n"
3622 " <transport ip=\"1.2.3.4\" port=\"12\"></transport>\n"
3623 " <interface>\n"
3624 " <name>IFoo</name>\n"
3625 " <instance>default</instance>\n"
3626 " </interface>\n"
3627 " </hal>\n"
3628 "</manifest>\n";
3629 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
3630 EXPECT_IN("Transport requires empty ip and port attributes", error);
3631 }
3632
TEST_F(LibVintfTest,RejectHidlHalsInetTransport)3633 TEST_F(LibVintfTest, RejectHidlHalsInetTransport) {
3634 std::string error;
3635
3636 HalManifest manifest;
3637 std::string manifestXml =
3638 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3639 " <hal format=\"hidl\">\n"
3640 " <name>android.hardware.foo</name>\n"
3641 " <transport ip=\"1.2.3.4\" port=\"12\">inet</transport>\n"
3642 " <interface>\n"
3643 " <name>IFoo</name>\n"
3644 " <instance>default</instance>\n"
3645 " </interface>\n"
3646 " </hal>\n"
3647 "</manifest>\n";
3648 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
3649 EXPECT_IN(
3650 "HIDL HAL 'android.hardware.foo' should not have <transport> \"inet\" or ip or port",
3651 error);
3652 }
3653
TEST_F(LibVintfTest,RejectHidlHalsHwbinderInetAttrs)3654 TEST_F(LibVintfTest, RejectHidlHalsHwbinderInetAttrs) {
3655 std::string error;
3656
3657 HalManifest manifest;
3658 std::string manifestXml =
3659 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
3660 " <hal format=\"hidl\">\n"
3661 " <name>android.hardware.foo</name>\n"
3662 " <transport ip=\"1.2.3.4\" port=\"12\">hwbinder</transport>\n"
3663 " <interface>\n"
3664 " <name>IFoo</name>\n"
3665 " <instance>default</instance>\n"
3666 " </interface>\n"
3667 " </hal>\n"
3668 "</manifest>\n";
3669 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
3670 EXPECT_IN("Transport hwbinder requires empty ip and port attributes", error);
3671 }
3672
TEST_F(LibVintfTest,SystemSdk)3673 TEST_F(LibVintfTest, SystemSdk) {
3674 CompatibilityMatrix cm;
3675 std::string xml;
3676 std::string error;
3677
3678 xml =
3679 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
3680 " <system-sdk>\n"
3681 " <version>1</version>\n"
3682 " <version>P</version>\n"
3683 " </system-sdk>\n"
3684 "</compatibility-matrix>\n";
3685 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
3686 EXPECT_EQ(xml, toXml(cm, SerializeFlags::SSDK_ONLY));
3687
3688 {
3689 HalManifest manifest;
3690 xml =
3691 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
3692 " <system-sdk>\n"
3693 " <version>1</version>\n"
3694 " <version>P</version>\n"
3695 " </system-sdk>\n"
3696 "</manifest>\n";
3697 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
3698 EXPECT_EQ(xml, toXml(manifest, SerializeFlags::SSDK_ONLY));
3699
3700 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
3701 }
3702
3703 {
3704 HalManifest manifest;
3705 xml =
3706 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
3707 " <system-sdk>\n"
3708 " <version>1</version>\n"
3709 " <version>3</version>\n"
3710 " <version>P</version>\n"
3711 " </system-sdk>\n"
3712 "</manifest>\n";
3713 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
3714 EXPECT_TRUE(manifest.checkCompatibility(cm, &error));
3715 }
3716
3717 {
3718 HalManifest manifest;
3719 xml =
3720 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
3721 " <system-sdk>\n"
3722 " <version>1</version>\n"
3723 " </system-sdk>\n"
3724 "</manifest>\n";
3725 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
3726 EXPECT_FALSE(manifest.checkCompatibility(cm, &error));
3727 EXPECT_TRUE(error.find("System SDK") != std::string::npos) << error;
3728 }
3729 }
3730
TEST_F(LibVintfTest,ManifestEmpty)3731 TEST_F(LibVintfTest, ManifestEmpty) {
3732 std::string error;
3733 HalManifest e;
3734 EXPECT_FALSE(fromXml(&e, "<manifest/>", &error));
3735 EXPECT_NE("Not a valid XML", error);
3736
3737 std::string prevError = error;
3738 EXPECT_FALSE(fromXml(&e, "", &error));
3739 EXPECT_EQ("Not a valid XML", error);
3740 }
3741
TEST_F(LibVintfTest,MatrixEmpty)3742 TEST_F(LibVintfTest, MatrixEmpty) {
3743 std::string error;
3744 CompatibilityMatrix e;
3745 EXPECT_FALSE(fromXml(&e, "<compatibility-matrix/>", &error));
3746 EXPECT_NE("Not a valid XML", error);
3747
3748 std::string prevError = error;
3749 EXPECT_FALSE(fromXml(&e, "", &error));
3750 EXPECT_EQ("Not a valid XML", error);
3751 }
3752
TEST_F(LibVintfTest,MatrixDetailErrorMsg)3753 TEST_F(LibVintfTest, MatrixDetailErrorMsg) {
3754 std::string error;
3755 std::string xml;
3756
3757 HalManifest manifest;
3758 xml =
3759 "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"8\">\n"
3760 " <hal format=\"hidl\">\n"
3761 " <name>android.hardware.foo</name>\n"
3762 " <transport>hwbinder</transport>\n"
3763 " <version>1.0</version>\n"
3764 " <interface>\n"
3765 " <name>IFoo</name>\n"
3766 " <instance>default</instance>\n"
3767 " </interface>\n"
3768 " </hal>\n"
3769 "</manifest>\n";
3770 ASSERT_TRUE(fromXml(&manifest, xml, &error)) << error;
3771 }
3772
TEST_F(LibVintfTest,DisabledHal)3773 TEST_F(LibVintfTest, DisabledHal) {
3774 std::string error;
3775 std::string xml;
3776 HalManifest manifest;
3777 xml =
3778 "<manifest version=\"5.0\" type=\"framework\">\n"
3779 " <hal format=\"hidl\" override=\"true\">\n"
3780 " <transport>hwbinder</transport>\n"
3781 " <name>android.hardware.foo</name>\n"
3782 " <transport>hwbinder</transport>\n"
3783 " </hal>\n"
3784 " <hal format=\"hidl\" override=\"true\">\n"
3785 " <name>android.hardware.bar</name>\n"
3786 " <transport>hwbinder</transport>\n"
3787 " <fqname>@1.1::IFoo/custom</fqname>\n"
3788 " </hal>\n"
3789 " <hal format=\"hidl\">\n"
3790 " <name>android.hardware.baz</name>\n"
3791 " <transport>hwbinder</transport>\n"
3792 " </hal>\n"
3793 "</manifest>\n";
3794 ASSERT_TRUE(fromXml(&manifest, xml, &error)) << error;
3795
3796 auto foo = getHals(manifest, "android.hardware.foo");
3797 ASSERT_EQ(1u, foo.size());
3798 EXPECT_TRUE(foo.front()->isDisabledHal());
3799 auto bar = getHals(manifest, "android.hardware.bar");
3800 ASSERT_EQ(1u, bar.size());
3801 EXPECT_FALSE(bar.front()->isDisabledHal());
3802 auto baz = getHals(manifest, "android.hardware.baz");
3803 ASSERT_EQ(1u, baz.size());
3804 EXPECT_FALSE(baz.front()->isDisabledHal());
3805 }
3806
TEST_F(LibVintfTest,FqNameValid)3807 TEST_F(LibVintfTest, FqNameValid) {
3808 std::string error;
3809 std::string xml;
3810
3811 CompatibilityMatrix cm;
3812 xml =
3813 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
3814 " <hal format=\"hidl\">\n"
3815 " <name>android.hardware.foo</name>\n"
3816 " <version>1.0</version>\n"
3817 " <interface>\n"
3818 " <name>IFoo</name>\n"
3819 " <instance>default</instance>\n"
3820 " </interface>\n"
3821 " </hal>\n"
3822 " <hal format=\"hidl\">\n"
3823 " <name>android.hardware.foo</name>\n"
3824 " <version>1.1</version>\n"
3825 " <interface>\n"
3826 " <name>IFoo</name>\n"
3827 " <instance>custom</instance>\n"
3828 " </interface>\n"
3829 " </hal>\n"
3830 "</compatibility-matrix>\n";
3831 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
3832
3833 {
3834 HalManifest manifest;
3835 xml =
3836 "<manifest version=\"5.0\" type=\"framework\">\n"
3837 " <hal format=\"hidl\">\n"
3838 " <name>android.hardware.foo</name>\n"
3839 " <transport>hwbinder</transport>\n"
3840 " <version>1.0</version>\n"
3841 " <interface>\n"
3842 " <name>IFoo</name>\n"
3843 " <instance>default</instance>\n"
3844 " <instance>custom</instance>\n"
3845 " </interface>\n"
3846 " <fqname>@1.1::IFoo/custom</fqname>\n"
3847 " </hal>\n"
3848 "</manifest>\n";
3849 ASSERT_TRUE(fromXml(&manifest, xml, &error)) << error;
3850 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
3851
3852 EXPECT_EQ(Transport::HWBINDER,
3853 manifest.getHidlTransport("android.hardware.foo", {1, 1}, "IFoo", "custom"));
3854 }
3855
3856 {
3857 HalManifest manifest;
3858 xml =
3859 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
3860 " <hal format=\"hidl\">\n"
3861 " <name>android.hardware.foo</name>\n"
3862 " <transport>hwbinder</transport>\n"
3863 " <fqname>@1.0::IFoo/default</fqname>\n"
3864 " <fqname>@1.1::IFoo/custom</fqname>\n"
3865 " </hal>\n"
3866 "</manifest>\n";
3867 ASSERT_TRUE(fromXml(&manifest, xml, &error)) << error;
3868 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
3869 }
3870
3871 {
3872 HalManifest manifest;
3873 xml =
3874 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
3875 " <hal format=\"hidl\">\n"
3876 " <name>android.hardware.foo</name>\n"
3877 " <transport>hwbinder</transport>\n"
3878 " <fqname>@1.0::IFoo/default</fqname>\n"
3879 " <fqname>@1.0::IFoo/custom</fqname>\n"
3880 " </hal>\n"
3881 "</manifest>\n";
3882 ASSERT_TRUE(fromXml(&manifest, xml, &error)) << error;
3883 }
3884 }
3885
TEST_F(LibVintfTest,FqNameInvalid)3886 TEST_F(LibVintfTest, FqNameInvalid) {
3887 std::string error;
3888 std::string xml;
3889 {
3890 ManifestHal hal;
3891 xml =
3892 "<hal format=\"hidl\">\n"
3893 " <name>android.hardware.foo</name>\n"
3894 " <transport>hwbinder</transport>\n"
3895 " <fqname>@1.1::IFoo/custom</fqname>\n"
3896 "</hal>\n";
3897 EXPECT_TRUE(fromXml(&hal, xml, &error)) << error;
3898 }
3899 ManifestHal hal;
3900 xml =
3901 "<hal format=\"hidl\">\n"
3902 " <name>android.hardware.foo</name>\n"
3903 " <transport>hwbinder</transport>\n"
3904 " <fqname>1.1::IFoo/custom</fqname>\n"
3905 "</hal>\n";
3906 ASSERT_FALSE(fromXml(&hal, xml, &error));
3907 EXPECT_IN("Could not parse text \"1.1::IFoo/custom\" in element <fqname>", error);
3908 xml =
3909 "<hal format=\"hidl\">\n"
3910 " <name>android.hardware.foo</name>\n"
3911 " <transport>hwbinder</transport>\n"
3912 " <fqname>android.hardware.foo@1.1::IFoo/custom</fqname>\n"
3913 "</hal>\n";
3914 ASSERT_FALSE(fromXml(&hal, xml, &error));
3915 EXPECT_IN("Should not specify package", error);
3916 xml =
3917 "<hal format=\"hidl\">\n"
3918 " <name>android.hardware.foo</name>\n"
3919 " <transport>hwbinder</transport>\n"
3920 " <fqname>IFoo/custom</fqname>\n"
3921 "</hal>\n";
3922 ASSERT_FALSE(fromXml(&hal, xml, &error));
3923 EXPECT_IN("Should specify version", error);
3924 xml =
3925 "<hal format=\"hidl\">\n"
3926 " <name>android.hardware.foo</name>\n"
3927 " <transport>hwbinder</transport>\n"
3928 " <fqname>@1.0::IFoo</fqname>\n"
3929 "</hal>\n";
3930 ASSERT_FALSE(fromXml(&hal, xml, &error));
3931 EXPECT_IN("Could not parse text \"@1.0::IFoo\" in element <fqname>", error);
3932 xml =
3933 "<hal format=\"hidl\">\n"
3934 " <name>n07 4 v4l1d 1n73rf4c3</name>\n"
3935 " <transport>hwbinder</transport>\n"
3936 " <fqname>@1.0::IFoo/custom</fqname>\n"
3937 "</hal>\n";
3938 ASSERT_FALSE(fromXml(&hal, xml, &error));
3939 EXPECT_IN("Cannot create FqInstance", error);
3940 EXPECT_IN("n07 4 v4l1d 1n73rf4c3", error);
3941 }
3942
TEST_F(LibVintfTest,RegexInstanceValid)3943 TEST_F(LibVintfTest, RegexInstanceValid) {
3944 CompatibilityMatrix matrix;
3945 std::string error;
3946
3947 std::string xml =
3948 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
3949 " <hal format=\"hidl\">\n"
3950 " <name>android.hardware.foo</name>\n"
3951 " <version>1.0</version>\n"
3952 " <interface>\n"
3953 " <name>IFoo</name>\n"
3954 " <regex-instance>legacy/[0-9]+</regex-instance>\n"
3955 " <regex-instance>slot[0-9]+</regex-instance>\n"
3956 " <regex-instance>.*</regex-instance>\n"
3957 " </interface>\n"
3958 " </hal>\n"
3959 "</compatibility-matrix>\n";
3960 EXPECT_TRUE(fromXml(&matrix, xml, &error)) << error;
3961 }
3962
TEST_F(LibVintfTest,RegexInstanceInvalid)3963 TEST_F(LibVintfTest, RegexInstanceInvalid) {
3964 CompatibilityMatrix matrix;
3965 std::string error;
3966 std::string xml =
3967 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
3968 " <hal format=\"hidl\">\n"
3969 " <name>android.hardware.foo</name>\n"
3970 " <version>1.0</version>\n"
3971 " <interface>\n"
3972 " <name>IFoo</name>\n"
3973 " <regex-instance>e{1,2,3}</regex-instance>\n"
3974 " <regex-instance>*</regex-instance>\n"
3975 " <regex-instance>+</regex-instance>\n"
3976 " <regex-instance>[0-9]+</regex-instance>\n"
3977 " <regex-instance>[0-9]+</regex-instance>\n"
3978 " </interface>\n"
3979 " </hal>\n"
3980 "</compatibility-matrix>\n";
3981 EXPECT_FALSE(fromXml(&matrix, xml, &error));
3982 EXPECT_IN("Invalid regular expression 'e{1,2,3}'", error);
3983 EXPECT_IN("Invalid regular expression '*'", error);
3984 EXPECT_IN("Invalid regular expression '+'", error);
3985 EXPECT_IN("Duplicated regex-instance '[0-9]+'", error);
3986 }
3987
TEST_F(LibVintfTest,RegexInstanceCompat)3988 TEST_F(LibVintfTest, RegexInstanceCompat) {
3989 CompatibilityMatrix matrix;
3990 std::string error;
3991
3992 std::string matrixXml =
3993 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\">\n"
3994 " <hal format=\"hidl\">\n"
3995 " <name>android.hardware.foo</name>\n"
3996 " <version>1.0</version>\n"
3997 " <version>3.1-2</version>\n"
3998 " <interface>\n"
3999 " <name>IFoo</name>\n"
4000 " <instance>default</instance>\n"
4001 " <regex-instance>legacy/[0-9]+</regex-instance>\n"
4002 " </interface>\n"
4003 " </hal>\n"
4004 " <sepolicy>\n"
4005 " <kernel-sepolicy-version>0</kernel-sepolicy-version>\n"
4006 " <sepolicy-version>0</sepolicy-version>\n"
4007 " </sepolicy>\n"
4008 "</compatibility-matrix>\n";
4009 EXPECT_TRUE(fromXml(&matrix, matrixXml, &error)) << error;
4010
4011 {
4012 std::string xml =
4013 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
4014 " <hal format=\"hidl\">\n"
4015 " <name>android.hardware.foo</name>\n"
4016 " <transport>hwbinder</transport>\n"
4017 " <version>1.0</version>\n"
4018 " <interface>\n"
4019 " <name>IFoo</name>\n"
4020 " <instance>default</instance>\n"
4021 " <instance>legacy/0</instance>\n"
4022 " <instance>legacy/1</instance>\n"
4023 " </interface>\n"
4024 " </hal>\n"
4025 "</manifest>\n";
4026
4027 HalManifest manifest;
4028 EXPECT_TRUE(fromXml(&manifest, xml));
4029 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
4030
4031 auto unused = checkUnusedHals(manifest, matrix);
4032 EXPECT_TRUE(unused.empty())
4033 << "Contains unused HALs: " << android::base::Join(unused, "\n");
4034 }
4035
4036 {
4037 std::string xml =
4038 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
4039 " <hal format=\"hidl\">\n"
4040 " <name>android.hardware.foo</name>\n"
4041 " <transport>hwbinder</transport>\n"
4042 " <version>1.0</version>\n"
4043 " <interface>\n"
4044 " <name>IFoo</name>\n"
4045 " <instance>default</instance>\n"
4046 " <instance>legacy0</instance>\n"
4047 " <instance>nonmatch/legacy/0</instance>\n"
4048 " <instance>legacy/0/nonmatch</instance>\n"
4049 " </interface>\n"
4050 " </hal>\n"
4051 "</manifest>\n";
4052
4053 HalManifest manifest;
4054 EXPECT_TRUE(fromXml(&manifest, xml));
4055 auto unused = checkUnusedHals(manifest, matrix);
4056 EXPECT_EQ((std::set<std::string>{"android.hardware.foo@1.0::IFoo/nonmatch/legacy/0",
4057 "android.hardware.foo@1.0::IFoo/legacy/0/nonmatch",
4058 "android.hardware.foo@1.0::IFoo/legacy0"}),
4059 unused);
4060 }
4061 }
4062
TEST_F(LibVintfTest,Regex)4063 TEST_F(LibVintfTest, Regex) {
4064 details::Regex regex;
4065
4066 EXPECT_FALSE(regex.compile("+"));
4067 EXPECT_FALSE(regex.compile("*"));
4068
4069 ASSERT_TRUE(regex.compile("legacy/[0-9]+"));
4070 EXPECT_TRUE(regex.matches("legacy/0"));
4071 EXPECT_TRUE(regex.matches("legacy/000"));
4072 EXPECT_FALSE(regex.matches("legacy/"));
4073 EXPECT_FALSE(regex.matches("ssslegacy/0"));
4074 EXPECT_FALSE(regex.matches("legacy/0sss"));
4075 }
4076
TEST_F(LibVintfTest,ManifestGetHalNamesAndVersions)4077 TEST_F(LibVintfTest, ManifestGetHalNamesAndVersions) {
4078 HalManifest vm = testDeviceManifest();
4079 EXPECT_EQ(vm.getHalNamesAndVersions(),
4080 std::set<std::string>({"android.hardware.camera@2.0", "android.hardware.nfc@1.0"}));
4081 }
4082
TEST_F(LibVintfTest,KernelInfo)4083 TEST_F(LibVintfTest, KernelInfo) {
4084 KernelInfo ki = testKernelInfo();
4085
4086 EXPECT_EQ(
4087 "<kernel version=\"3.18.31\">\n"
4088 " <config>\n"
4089 " <key>CONFIG_64BIT</key>\n"
4090 " <value>y</value>\n"
4091 " </config>\n"
4092 " <config>\n"
4093 " <key>CONFIG_ANDROID_BINDER_DEVICES</key>\n"
4094 " <value>\"binder,hwbinder\"</value>\n"
4095 " </config>\n"
4096 " <config>\n"
4097 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
4098 " <value>24</value>\n"
4099 " </config>\n"
4100 " <config>\n"
4101 " <key>CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES</key>\n"
4102 " <value>\"\"</value>\n"
4103 " </config>\n"
4104 " <config>\n"
4105 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
4106 " <value>0xdead000000000000</value>\n"
4107 " </config>\n"
4108 "</kernel>\n",
4109 toXml(ki, SerializeFlags::NO_TAGS.enableKernelConfigs()));
4110 }
4111
TEST_F(LibVintfTest,ManifestAddAllDeviceManifest)4112 TEST_F(LibVintfTest, ManifestAddAllDeviceManifest) {
4113 std::string xml1 = "<manifest " + kMetaVersionStr + " type=\"device\" />\n";
4114 std::string xml2 =
4115 "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"3\">\n"
4116 " <hal format=\"hidl\">\n"
4117 " <name>android.hardware.foo</name>\n"
4118 " <transport>hwbinder</transport>\n"
4119 " <fqname>@1.0::IFoo/default</fqname>\n"
4120 " </hal>\n"
4121 " <sepolicy>\n"
4122 " <version>25.5</version>\n"
4123 " </sepolicy>\n"
4124 " <kernel version=\"3.18.31\">\n"
4125 " <config>\n"
4126 " <key>CONFIG_64BIT</key>\n"
4127 " <value>y</value>\n"
4128 " </config>\n"
4129 " </kernel>\n"
4130 " <xmlfile>\n"
4131 " <name>media_profile</name>\n"
4132 " <version>1.0</version>\n"
4133 " </xmlfile>\n"
4134 "</manifest>\n";
4135
4136 std::string error;
4137 HalManifest manifest1;
4138 ASSERT_TRUE(fromXml(&manifest1, xml1, &error)) << error;
4139 HalManifest manifest2;
4140 ASSERT_TRUE(fromXml(&manifest2, xml2, &error)) << error;
4141
4142 ASSERT_TRUE(manifest1.addAll(&manifest2, &error)) << error;
4143
4144 EXPECT_EQ(xml2, toXml(manifest1));
4145 }
4146
TEST_F(LibVintfTest,ManifestAddAllFrameworkManifest)4147 TEST_F(LibVintfTest, ManifestAddAllFrameworkManifest) {
4148 std::string xml1 = "<manifest " + kMetaVersionStr + " type=\"framework\" />\n";
4149 std::string xml2 =
4150 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4151 " <hal format=\"hidl\">\n"
4152 " <name>android.hardware.foo</name>\n"
4153 " <transport>hwbinder</transport>\n"
4154 " <fqname>@1.0::IFoo/default</fqname>\n"
4155 " </hal>\n"
4156 " <vendor-ndk>\n"
4157 " <version>P</version>\n"
4158 " <library>libbase.so</library>\n"
4159 " </vendor-ndk>\n"
4160 " <system-sdk>\n"
4161 " <version>1</version>\n"
4162 " </system-sdk>\n"
4163 " <xmlfile>\n"
4164 " <name>media_profile</name>\n"
4165 " <version>1.0</version>\n"
4166 " </xmlfile>\n"
4167 "</manifest>\n";
4168
4169 std::string error;
4170 HalManifest manifest1;
4171 ASSERT_TRUE(fromXml(&manifest1, xml1, &error)) << error;
4172 HalManifest manifest2;
4173 ASSERT_TRUE(fromXml(&manifest2, xml2, &error)) << error;
4174
4175 ASSERT_TRUE(manifest1.addAll(&manifest2, &error)) << error;
4176
4177 EXPECT_EQ(xml2, toXml(manifest1));
4178 }
4179
TEST_F(LibVintfTest,ManifestAddAllConflictMajorVersion)4180 TEST_F(LibVintfTest, ManifestAddAllConflictMajorVersion) {
4181 std::string head =
4182 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
4183 " <hal format=\"hidl\">\n"
4184 " <name>android.hardware.foo</name>\n"
4185 " <transport>hwbinder</transport>\n"
4186 " <version>";
4187 std::string tail =
4188 "</version>\n"
4189 " <interface>\n"
4190 " <name>IFoo</name>\n"
4191 " <instance>default</instance>\n"
4192 " </interface>\n"
4193 " </hal>\n"
4194 "</manifest>\n";
4195
4196 std::string xml1 = head + "1.0" + tail;
4197 std::string xml2 = head + "1.1" + tail;
4198
4199 std::string error;
4200 HalManifest manifest1;
4201 manifest1.setFileName("1.xml");
4202 ASSERT_TRUE(fromXml(&manifest1, xml1, &error)) << error;
4203 HalManifest manifest2;
4204 manifest2.setFileName("2.xml");
4205 ASSERT_TRUE(fromXml(&manifest2, xml2, &error)) << error;
4206
4207 ASSERT_FALSE(manifest1.addAll(&manifest2, &error));
4208
4209 EXPECT_IN("android.hardware.foo", error);
4210 EXPECT_IN("@1.0::IFoo/default (from 1.xml)", error);
4211 EXPECT_IN("@1.1::IFoo/default (from 2.xml)", error);
4212 }
4213
TEST_F(LibVintfTest,ManifestAddAllConflictLevel)4214 TEST_F(LibVintfTest, ManifestAddAllConflictLevel) {
4215 std::string xml1 = "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"2\" />\n";
4216 std::string xml2 = "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"3\" />\n";
4217
4218 std::string error;
4219 HalManifest manifest1;
4220 ASSERT_TRUE(fromXml(&manifest1, xml1, &error)) << error;
4221 HalManifest manifest2;
4222 ASSERT_TRUE(fromXml(&manifest2, xml2, &error)) << error;
4223
4224 ASSERT_FALSE(manifest1.addAll(&manifest2, &error));
4225 EXPECT_IN("Conflicting target-level", error);
4226 }
4227
TEST_F(LibVintfTest,ManifestAddAllConflictSepolicy)4228 TEST_F(LibVintfTest, ManifestAddAllConflictSepolicy) {
4229 std::string xml1 =
4230 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
4231 " <sepolicy>\n"
4232 " <version>25.5</version>\n"
4233 " </sepolicy>\n"
4234 "</manifest>\n";
4235 std::string xml2 =
4236 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
4237 " <sepolicy>\n"
4238 " <version>30.0</version>\n"
4239 " </sepolicy>\n"
4240 "</manifest>\n";
4241
4242 std::string error;
4243 HalManifest manifest1;
4244 ASSERT_TRUE(fromXml(&manifest1, xml1, &error)) << error;
4245 HalManifest manifest2;
4246 ASSERT_TRUE(fromXml(&manifest2, xml2, &error)) << error;
4247
4248 ASSERT_FALSE(manifest1.addAll(&manifest2, &error));
4249 EXPECT_IN("Conflicting sepolicy version", error);
4250 }
4251
TEST_F(LibVintfTest,ManifestAddAllConflictKernel)4252 TEST_F(LibVintfTest, ManifestAddAllConflictKernel) {
4253 std::string xml1 =
4254 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
4255 " <kernel version=\"3.18.0\" />\n"
4256 "</manifest>\n";
4257 std::string xml2 =
4258 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
4259 " <kernel version=\"3.18.1\" />\n"
4260 "</manifest>\n";
4261
4262 std::string error;
4263 HalManifest manifest1;
4264 ASSERT_TRUE(fromXml(&manifest1, xml1, &error)) << error;
4265 HalManifest manifest2;
4266 ASSERT_TRUE(fromXml(&manifest2, xml2, &error)) << error;
4267
4268 ASSERT_FALSE(manifest1.addAll(&manifest2, &error));
4269 EXPECT_IN("Conflicting kernel", error);
4270 }
4271
TEST_F(LibVintfTest,ManifestMetaVersionCompat)4272 TEST_F(LibVintfTest, ManifestMetaVersionCompat) {
4273 std::string xml = "<manifest version=\"2.0\" type=\"device\" />";
4274 std::string error;
4275 HalManifest manifest;
4276 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
4277 }
4278
TEST_F(LibVintfTest,ManifestMetaVersionIncompat)4279 TEST_F(LibVintfTest, ManifestMetaVersionIncompat) {
4280 std::string xml = "<manifest version=\"10000.0\" type=\"device\" />";
4281 std::string error;
4282 HalManifest manifest;
4283 EXPECT_FALSE(fromXml(&manifest, xml, &error))
4284 << "Should not parse metaversion 10000.0";
4285 }
4286
TEST_F(LibVintfTest,ManifestMetaVersionWriteLatest)4287 TEST_F(LibVintfTest, ManifestMetaVersionWriteLatest) {
4288 std::string xml = "<manifest version=\"1.0\" type=\"device\" />";
4289 std::string error;
4290 HalManifest manifest;
4291 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
4292 EXPECT_IN(kMetaVersionStr, toXml(manifest, SerializeFlags::NO_TAGS));
4293 }
4294
TEST_F(LibVintfTest,MatrixMetaVersionCompat)4295 TEST_F(LibVintfTest, MatrixMetaVersionCompat) {
4296 std::string xml = "<compatibility-matrix version=\"2.0\" type=\"framework\" />";
4297 std::string error;
4298 CompatibilityMatrix matrix;
4299 EXPECT_TRUE(fromXml(&matrix, xml, &error)) << error;
4300 }
4301
TEST_F(LibVintfTest,MatrixMetaVersionIncompat)4302 TEST_F(LibVintfTest, MatrixMetaVersionIncompat) {
4303 std::string xml = "<compatibility-matrix version=\"10000.0\" type=\"framework\" />";
4304 std::string error;
4305 CompatibilityMatrix matrix;
4306 EXPECT_FALSE(fromXml(&matrix, xml, &error))
4307 << "Should not parse metaversion 10000.0";
4308 }
4309
TEST_F(LibVintfTest,MatrixMetaVersionWriteLatest)4310 TEST_F(LibVintfTest, MatrixMetaVersionWriteLatest) {
4311 std::string xml = "<compatibility-matrix version=\"1.0\" type=\"framework\" />";
4312 std::string error;
4313 CompatibilityMatrix matrix;
4314 EXPECT_TRUE(fromXml(&matrix, xml, &error)) << error;
4315 EXPECT_IN(kMetaVersionStr, toXml(matrix, SerializeFlags::NO_TAGS));
4316 }
4317
4318 // clang-format on
4319
4320 struct InMemoryFileSystem : FileSystem {
4321 std::map<std::string, std::string> files;
InMemoryFileSystemandroid::vintf::InMemoryFileSystem4322 InMemoryFileSystem(std::map<std::string, std::string> files) : files(std::move(files)) {}
fetchandroid::vintf::InMemoryFileSystem4323 status_t fetch(const std::string& path, std::string* fetched,
4324 std::string* error) const override {
4325 (void)error;
4326 if (auto it = files.find(path); it != files.end()) {
4327 *fetched = it->second;
4328 return OK;
4329 }
4330 return NAME_NOT_FOUND;
4331 }
listFilesandroid::vintf::InMemoryFileSystem4332 status_t listFiles(const std::string& path, std::vector<std::string>* out,
4333 std::string* error) const override {
4334 (void)error;
4335 std::set<std::string> entries;
4336 for (const auto& pair : files) {
4337 std::string_view entry{pair.first};
4338 if (android::base::ConsumePrefix(&entry, path)) {
4339 android::base::ConsumePrefix(&entry, "/");
4340 entries.emplace(entry.substr(0, entry.find('/')));
4341 }
4342 }
4343 *out = std::vector<std::string>{begin(entries), end(entries)};
4344 return OK;
4345 }
modifiedTimeandroid::vintf::InMemoryFileSystem4346 status_t modifiedTime(const std::string& path, timespec* mtime, std::string* error) const {
4347 (void)error;
4348 if (auto it = files.find(path); it != files.end()) {
4349 *mtime = timespec{};
4350 return OK;
4351 }
4352 return NAME_NOT_FOUND;
4353 }
4354 };
4355
TEST_F(LibVintfTest,HalManifestWithMultipleFiles)4356 TEST_F(LibVintfTest, HalManifestWithMultipleFiles) {
4357 std::string vendorXmlPath = "/vendor/etc/vintf/manifest.xml";
4358 std::string vendorXml = "<manifest " + kMetaVersionStr +
4359 " type=\"device\">\n"
4360 " <hal format=\"aidl\">\n"
4361 " <name>android.hardware.foo</name>\n"
4362 " <fqname>IFoo/default</fqname>\n"
4363 " </hal>\n"
4364 "</manifest>";
4365 std::string apexXmlPath = "/apex/com.android.bar/etc/vintf/manifest.xml";
4366 std::string apexXml = "<manifest " + kMetaVersionStr +
4367 " type=\"device\">\n"
4368 " <hal format=\"aidl\">\n"
4369 " <name>android.hardware.bar</name>\n"
4370 " <fqname>IBar/default</fqname>\n"
4371 " </hal>\n"
4372 "</manifest>";
4373 InMemoryFileSystem files{{
4374 {vendorXmlPath, vendorXml},
4375 {apexXmlPath, apexXml},
4376 }};
4377 // Read apexXml later. This shouldn't affect the result except HalManifest::fileName.
4378 {
4379 std::string error;
4380 HalManifest manifest;
4381 EXPECT_EQ(OK, fetchManifest(manifest, &files, vendorXmlPath, &error)) << error;
4382 EXPECT_EQ(OK, fetchManifest(manifest, &files, apexXmlPath, &error)) << error;
4383 EXPECT_EQ(vendorXmlPath + ":" + apexXmlPath, manifest.fileName());
4384 EXPECT_EQ(std::nullopt, getAnyHal(manifest, "android.hardware.foo")->updatableViaApex());
4385 EXPECT_EQ(std::make_optional("com.android.bar"s),
4386 getAnyHal(manifest, "android.hardware.bar")->updatableViaApex());
4387 }
4388 // Read apexXml first. This shouldn't affect the result except HalManifest::fileName.
4389 {
4390 std::string error;
4391 HalManifest manifest;
4392 EXPECT_EQ(OK, fetchManifest(manifest, &files, apexXmlPath, &error)) << error;
4393 EXPECT_EQ(OK, fetchManifest(manifest, &files, vendorXmlPath, &error)) << error;
4394 EXPECT_EQ(apexXmlPath + ":" + vendorXmlPath, manifest.fileName());
4395 EXPECT_EQ(std::nullopt, getAnyHal(manifest, "android.hardware.foo")->updatableViaApex());
4396 EXPECT_EQ(std::make_optional("com.android.bar"s),
4397 getAnyHal(manifest, "android.hardware.bar")->updatableViaApex());
4398 }
4399 }
4400
4401 // clang-format off
4402
TEST_F(LibVintfTest,Aidl)4403 TEST_F(LibVintfTest, Aidl) {
4404 std::string xml =
4405 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
4406 " <hal format=\"aidl\">\n"
4407 " <name>android.system.foo</name>\n"
4408 " <interface>\n"
4409 " <name>IFoo</name>\n"
4410 " <instance>default</instance>\n"
4411 " <regex-instance>test.*</regex-instance>\n"
4412 " </interface>\n"
4413 " </hal>\n"
4414 "</compatibility-matrix>\n";
4415 std::string error;
4416 CompatibilityMatrix matrix;
4417 EXPECT_TRUE(fromXml(&matrix, xml, &error)) << error;
4418 EXPECT_EQ(xml, toXml(matrix, SerializeFlags::HALS_NO_FQNAME));
4419
4420 {
4421 HalManifest manifest;
4422 std::string manifestXml =
4423 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4424 " <hal format=\"aidl\">\n"
4425 " <name>android.system.foo</name>\n"
4426 " <interface>\n"
4427 " <name>IFoo</name>\n"
4428 " <instance>default</instance>\n"
4429 " <instance>test0</instance>\n"
4430 " </interface>\n"
4431 " </hal>\n"
4432 "</manifest>\n";
4433 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
4434 EXPECT_EQ(
4435 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4436 " <hal format=\"aidl\">\n"
4437 " <name>android.system.foo</name>\n"
4438 " <fqname>IFoo/default</fqname>\n"
4439 " <fqname>IFoo/test0</fqname>\n"
4440 " </hal>\n"
4441 "</manifest>\n",
4442 toXml(manifest, SerializeFlags::HALS_ONLY));
4443 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
4444 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", "IFoo", "default"));
4445 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", "IFoo", "test0"));
4446 EXPECT_FALSE(manifest.hasAidlInstance("android.system.foo", "IFoo", "does_not_exist"));
4447 EXPECT_FALSE(manifest.hasAidlInstance("android.system.foo", "IDoesNotExist", "default"));
4448 EXPECT_FALSE(manifest.hasAidlInstance("android.system.does_not_exist", "IFoo", "default"));
4449 EXPECT_EQ(manifest.getAidlInstances("android.system.foo", "IFoo"),
4450 std::set<std::string>({"default", "test0"}));
4451 EXPECT_EQ(manifest.getAidlInstances("android.system.does_not_exist", "IFoo"),
4452 std::set<std::string>({}));
4453 }
4454
4455 {
4456 HalManifest manifest;
4457 std::string manifestXml =
4458 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4459 " <hal format=\"aidl\">\n"
4460 " <name>android.system.foo</name>\n"
4461 " <fqname>IFoo/default</fqname>\n"
4462 " <fqname>IFoo/test0</fqname>\n"
4463 " </hal>\n"
4464 "</manifest>\n";
4465 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
4466 EXPECT_EQ(manifestXml, toXml(manifest, SerializeFlags::HALS_ONLY));
4467 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
4468 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", "IFoo", "default"));
4469 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", "IFoo", "test0"));
4470 EXPECT_FALSE(manifest.hasAidlInstance("android.system.foo", "IFoo", "does_not_exist"));
4471 EXPECT_FALSE(manifest.hasAidlInstance("android.system.foo", "IDoesNotExist", "default"));
4472 EXPECT_FALSE(manifest.hasAidlInstance("android.system.does_not_exist", "IFoo", "default"));
4473 EXPECT_EQ(manifest.getAidlInstances("android.system.foo", "IFoo"),
4474 std::set<std::string>({"default", "test0"}));
4475 EXPECT_EQ(manifest.getAidlInstances("android.system.does_not_exist", "IFoo"),
4476 std::set<std::string>({}));
4477 }
4478 }
4479
TEST_F(LibVintfTest,AidlAndHidlNamesMatrix)4480 TEST_F(LibVintfTest, AidlAndHidlNamesMatrix) {
4481 std::string xml =
4482 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
4483 " <hal format=\"aidl\">\n"
4484 " <name>android.system.foo</name>\n"
4485 " <interface>\n"
4486 " <name>IFoo</name>\n"
4487 " <instance>default</instance>\n"
4488 " </interface>\n"
4489 " </hal>\n"
4490 " <hal format=\"hidl\">\n"
4491 " <name>android.system.foo</name>\n"
4492 " <version>1.0</version>\n"
4493 " <interface>\n"
4494 " <name>IFoo</name>\n"
4495 " <instance>default</instance>\n"
4496 " </interface>\n"
4497 " </hal>\n"
4498 "</compatibility-matrix>\n";
4499 std::string error;
4500 CompatibilityMatrix matrix;
4501 EXPECT_TRUE(fromXml(&matrix, xml, &error)) << error;
4502 EXPECT_EQ(xml, toXml(matrix, SerializeFlags::HALS_ONLY));
4503 }
4504
TEST_F(LibVintfTest,AidlAndHidlNamesManifest)4505 TEST_F(LibVintfTest, AidlAndHidlNamesManifest) {
4506 std::string xml =
4507 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4508 " <hal format=\"aidl\">\n"
4509 " <name>android.system.foo</name>\n"
4510 " <fqname>IFoo/default</fqname>\n"
4511 " </hal>\n"
4512 " <hal format=\"hidl\">\n"
4513 " <name>android.system.foo</name>\n"
4514 " <transport>hwbinder</transport>\n"
4515 " <fqname>@1.0::IFoo/default</fqname>\n"
4516 " </hal>\n"
4517 "</manifest>\n";
4518 std::string error;
4519 HalManifest manifest;
4520 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
4521 EXPECT_EQ(xml, toXml(manifest, SerializeFlags::HALS_ONLY));
4522 }
4523
TEST_F(LibVintfTest,AidlAndHidlCheckUnused)4524 TEST_F(LibVintfTest, AidlAndHidlCheckUnused) {
4525 std::string manifestXml =
4526 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4527 " <hal format=\"aidl\">\n"
4528 " <name>android.system.foo</name>\n"
4529 " <fqname>IFoo/default</fqname>\n"
4530 " </hal>\n"
4531 " <hal format=\"hidl\">\n"
4532 " <name>android.system.foo</name>\n"
4533 " <transport>hwbinder</transport>\n"
4534 " <fqname>@1.0::IFoo/default</fqname>\n"
4535 " </hal>\n"
4536 "</manifest>\n";
4537 std::string matrixXml =
4538 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
4539 " <hal format=\"aidl\">\n"
4540 " <name>android.system.foo</name>\n"
4541 " <interface>\n"
4542 " <name>IFoo</name>\n"
4543 " <instance>default</instance>\n"
4544 " </interface>\n"
4545 " </hal>\n"
4546 " <hal format=\"hidl\">\n"
4547 " <name>android.system.foo</name>\n"
4548 " <version>1.0</version>\n"
4549 " <interface>\n"
4550 " <name>IFoo</name>\n"
4551 " <instance>default</instance>\n"
4552 " </interface>\n"
4553 " </hal>\n"
4554 "</compatibility-matrix>\n";
4555 std::string error;
4556 HalManifest manifest;
4557 CompatibilityMatrix matrix;
4558
4559 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
4560 EXPECT_TRUE(fromXml(&matrix, matrixXml, &error)) << error;
4561 auto unused = checkUnusedHals(manifest, matrix);
4562 EXPECT_TRUE(unused.empty()) << android::base::Join(unused, "\n");
4563 }
4564
TEST_F(LibVintfTest,AidlVersion)4565 TEST_F(LibVintfTest, AidlVersion) {
4566 std::string xml =
4567 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
4568 " <hal format=\"aidl\">\n"
4569 " <name>android.system.foo</name>\n"
4570 " <version>4-100</version>\n"
4571 " <interface>\n"
4572 " <name>IFoo</name>\n"
4573 " <instance>default</instance>\n"
4574 " <regex-instance>test.*</regex-instance>\n"
4575 " </interface>\n"
4576 " </hal>\n"
4577 "</compatibility-matrix>\n";
4578 std::string error;
4579 CompatibilityMatrix matrix;
4580 EXPECT_TRUE(fromXml(&matrix, xml, &error)) << error;
4581 EXPECT_EQ(xml, toXml(matrix, SerializeFlags::HALS_NO_FQNAME));
4582
4583 {
4584 std::vector<std::string> matrixInstances;
4585 (void)matrix.forEachInstance([&](const MatrixInstance& matrixInstance) {
4586 EXPECT_EQ(matrixInstance.versionRange(),
4587 VersionRange(details::kFakeAidlMajorVersion, 4, 100));
4588 matrixInstances.push_back(matrixInstance.description(
4589 matrixInstance.versionRange().minVer()));
4590 return true;
4591 });
4592 EXPECT_THAT(matrixInstances, SizeIs(2)) << android::base::Join(matrixInstances, ", ");
4593 }
4594
4595 {
4596 HalManifest manifest;
4597 std::string manifestXml =
4598 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4599 " <hal format=\"aidl\">\n"
4600 " <name>android.system.foo</name>\n"
4601 " <version>5</version>\n"
4602 " <interface>\n"
4603 " <name>IFoo</name>\n"
4604 " <instance>default</instance>\n"
4605 " <instance>test0</instance>\n"
4606 " </interface>\n"
4607 " </hal>\n"
4608 "</manifest>\n";
4609 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
4610 EXPECT_EQ(
4611 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4612 " <hal format=\"aidl\">\n"
4613 " <name>android.system.foo</name>\n"
4614 " <version>5</version>\n"
4615 " <fqname>IFoo/default</fqname>\n"
4616 " <fqname>IFoo/test0</fqname>\n"
4617 " </hal>\n"
4618 "</manifest>\n",
4619 toXml(manifest, SerializeFlags::HALS_ONLY));
4620 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
4621 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", "IFoo", "default"));
4622 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", "IFoo", "test0"));
4623 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", 5, "IFoo", "default"));
4624 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", 5, "IFoo", "test0"));
4625 EXPECT_FALSE(manifest.hasAidlInstance("android.system.foo", "IFoo", "does_not_exist"));
4626 EXPECT_FALSE(manifest.hasAidlInstance("android.system.foo", "IDoesNotExist", "default"));
4627 EXPECT_FALSE(manifest.hasAidlInstance("android.system.does_not_exist", "IFoo", "default"));
4628 EXPECT_EQ(manifest.getAidlInstances("android.system.foo", "IFoo"),
4629 std::set<std::string>({"default", "test0"}));
4630 EXPECT_EQ(manifest.getAidlInstances("android.system.foo", 5, "IFoo"),
4631 std::set<std::string>({"default", "test0"}));
4632 EXPECT_EQ(manifest.getAidlInstances("android.system.does_not_exist", "IFoo"),
4633 std::set<std::string>({}));
4634 }
4635
4636 {
4637 HalManifest manifest;
4638 std::string manifestXml =
4639 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4640 " <hal format=\"aidl\">\n"
4641 " <name>android.system.foo</name>\n"
4642 " <version>5</version>\n"
4643 " <fqname>IFoo/default</fqname>\n"
4644 " <fqname>IFoo/test0</fqname>\n"
4645 " </hal>\n"
4646 "</manifest>\n";
4647 EXPECT_TRUE(fromXml(&manifest, manifestXml, &error)) << error;
4648 EXPECT_EQ(manifestXml, toXml(manifest, SerializeFlags::HALS_ONLY));
4649 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
4650 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", "IFoo", "default"));
4651 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", "IFoo", "test0"));
4652 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", 5, "IFoo", "default"));
4653 EXPECT_TRUE(manifest.hasAidlInstance("android.system.foo", 5, "IFoo", "test0"));
4654 EXPECT_FALSE(manifest.hasAidlInstance("android.system.foo", "IFoo", "does_not_exist"));
4655 EXPECT_FALSE(manifest.hasAidlInstance("android.system.foo", "IDoesNotExist", "default"));
4656 EXPECT_FALSE(manifest.hasAidlInstance("android.system.does_not_exist", "IFoo", "default"));
4657 EXPECT_EQ(manifest.getAidlInstances("android.system.foo", "IFoo"),
4658 std::set<std::string>({"default", "test0"}));
4659 EXPECT_EQ(manifest.getAidlInstances("android.system.foo", 5, "IFoo"),
4660 std::set<std::string>({"default", "test0"}));
4661 EXPECT_EQ(manifest.getAidlInstances("android.system.does_not_exist", "IFoo"),
4662 std::set<std::string>({}));
4663 }
4664 }
4665
TEST_F(LibVintfTest,AidlFqnameNoVersion)4666 TEST_F(LibVintfTest, AidlFqnameNoVersion) {
4667 std::string error;
4668 HalManifest manifest;
4669 std::string manifestXml =
4670 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4671 " <hal format=\"aidl\">\n"
4672 " <name>android.system.foo</name>\n"
4673 " <fqname>@1.0::IFoo/default</fqname>\n"
4674 " </hal>\n"
4675 "</manifest>\n";
4676 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error)) << error;
4677 EXPECT_IN("Should not specify version in <fqname> for AIDL HAL: \"@1.0::IFoo/default\"", error);
4678 }
4679
TEST_F(LibVintfTest,GetTransportHidlHalWithFakeAidlVersion)4680 TEST_F(LibVintfTest, GetTransportHidlHalWithFakeAidlVersion) {
4681 std::string xml =
4682 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4683 " <hal format=\"hidl\">\n"
4684 " <name>android.system.foo</name>\n"
4685 " <transport>hwbinder</transport>\n"
4686 " <fqname>@" + to_string(details::kDefaultAidlVersion) + "::IFoo/default</fqname>\n"
4687 " </hal>\n"
4688 "</manifest>\n";
4689 std::string error;
4690 HalManifest manifest;
4691 EXPECT_FALSE(fromXml(&manifest, xml, &error))
4692 << "This should fail to parse";
4693 EXPECT_IN("Could not parse text \"@1::IFoo/default\"", error);
4694 }
4695
TEST_F(LibVintfTest,RejectAidlHalsWithUnsupportedTransport)4696 TEST_F(LibVintfTest, RejectAidlHalsWithUnsupportedTransport) {
4697 std::string error;
4698 HalManifest manifest;
4699 std::string manifestXml =
4700 "<manifest " + kMetaVersionStr + R"( type="framework">"
4701 <hal format="aidl">
4702 <name>android.system.foo</name>
4703 <transport>hwbinder</transport>
4704 <fqname>IFoo/default</fqname>
4705 </hal>
4706 </manifest>)";
4707 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
4708 EXPECT_IN("android.system.foo", error);
4709 EXPECT_IN("hwbinder", error);
4710 }
4711
4712 TEST_F(LibVintfTest, GetTransportAidlHalWithDummyTransport) {
4713 // Check that even if <transport> is specified for AIDL, it is ignored and getHidlTransport
4714 // will return EMPTY.
4715 // This is only supported for libvintf 4.0 and below.
4716 constexpr Version kLegacyMetaVersion{4, 0};
4717 ASSERT_GE(kMetaVersionAidlInet, kLegacyMetaVersion);
4718 std::string xml =
4719 "<manifest version=\"" + to_string(kLegacyMetaVersion) + "\" type=\"framework\">\n"
4720 " <hal format=\"aidl\">\n"
4721 " <name>android.system.foo</name>\n"
4722 " <transport>hwbinder</transport>\n"
4723 " <fqname>IFoo/default</fqname>\n"
4724 " </hal>\n"
4725 "</manifest>\n";
4726 std::string error;
4727 HalManifest manifest;
4728 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
4729 EXPECT_EQ(Transport::EMPTY,
4730 manifest.getHidlTransport("android.system.foo", details::kDefaultAidlVersion, "IFoo",
4731 "default"));
4732 }
4733
TEST_F(LibVintfTest,AidlGetHalNamesAndVersions)4734 TEST_F(LibVintfTest, AidlGetHalNamesAndVersions) {
4735 HalManifest manifest;
4736 std::string xml =
4737 "<manifest " + kMetaVersionStr + " type=\"framework\">\n"
4738 " <hal format=\"aidl\">\n"
4739 " <name>android.system.foo</name>\n"
4740 " <fqname>IFoo/default</fqname>\n"
4741 " </hal>\n"
4742 "</manifest>\n";
4743 std::string error;
4744 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
4745 auto names = manifest.getHalNamesAndVersions();
4746 ASSERT_EQ(1u, names.size());
4747 EXPECT_EQ("android.system.foo@1", *names.begin());
4748 }
4749
TEST_F(LibVintfTest,ManifestAddAidl)4750 TEST_F(LibVintfTest, ManifestAddAidl) {
4751 std::string head =
4752 "<manifest " + kMetaVersionStr + " type=\"device\">\n"
4753 " <hal format=\"aidl\">\n"
4754 " <name>android.hardware.foo</name>\n"
4755 " <fqname>";
4756 std::string tail =
4757 "</fqname>\n"
4758 " </hal>\n"
4759 "</manifest>\n";
4760
4761 std::string xml1 = head + "IFoo/default" + tail;
4762 std::string xml2 = head + "IFoo/another" + tail;
4763
4764 std::string error;
4765 HalManifest manifest1;
4766 manifest1.setFileName("1.xml");
4767 ASSERT_TRUE(fromXml(&manifest1, xml1, &error)) << error;
4768 HalManifest manifest2;
4769 manifest2.setFileName("2.xml");
4770 ASSERT_TRUE(fromXml(&manifest2, xml2, &error)) << error;
4771
4772 ASSERT_TRUE(manifest1.addAll(&manifest2, &error)) << error;
4773 }
4774
4775 // clang-format on
4776
TEST_F(LibVintfTest,NativeGetHalNamesAndVersions)4777 TEST_F(LibVintfTest, NativeGetHalNamesAndVersions) {
4778 HalManifest manifest;
4779 std::string xml = "<manifest " + kMetaVersionStr + R"( type="device">
4780 <hal format="native">
4781 <name>foo</name>
4782 <version>1.0</version>
4783 <interface>
4784 <instance>inst</instance>
4785 </interface>
4786 </hal>
4787 </manifest>
4788 )";
4789 std::string error;
4790 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
4791 auto names = manifest.getHalNamesAndVersions();
4792 ASSERT_EQ(1u, names.size());
4793 EXPECT_EQ("foo@1.0", *names.begin());
4794 }
4795
TEST_F(LibVintfTest,NativeGetHalNamesAndVersionsFqName)4796 TEST_F(LibVintfTest, NativeGetHalNamesAndVersionsFqName) {
4797 HalManifest manifest;
4798 std::string xml = "<manifest " + kMetaVersionStr + R"( type="device">
4799 <hal format="native">
4800 <name>foo</name>
4801 <fqname>@1.0/inst</fqname>
4802 </hal>
4803 </manifest>
4804 )";
4805 std::string error;
4806 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
4807 auto names = manifest.getHalNamesAndVersions();
4808 ASSERT_EQ(1u, names.size());
4809 EXPECT_EQ("foo@1.0", *names.begin());
4810 }
4811
4812 // clang-format off
4813
TEST_F(LibVintfTest,KernelInfoLevel)4814 TEST_F(LibVintfTest, KernelInfoLevel) {
4815 std::string error;
4816 std::string xml = "<kernel version=\"3.18.31\" target-level=\"1\"/>\n";
4817 KernelInfo ki;
4818 ASSERT_TRUE(fromXml(&ki, xml, &error)) << error;
4819 EXPECT_EQ(Level{1}, getLevel(ki));
4820 EXPECT_EQ(xml, toXml(ki));
4821 }
4822
4823 // Test merge of <kernel target-level=""> with autogenerated <kernel> by parsing
4824 // kernel prebuilt.
TEST_F(LibVintfTest,HalManifestMergeKernel)4825 TEST_F(LibVintfTest, HalManifestMergeKernel) {
4826 std::string head =
4827 "<manifest " + kMetaVersionStr + " type=\"device\" target-level=\"1\">\n";
4828 std::string tail =
4829 "</manifest>\n";
4830 std::string xml1 =
4831 " <kernel target-level=\"2\"/>\n";
4832 std::string xml2 =
4833 " <kernel version=\"3.18.31\">\n"
4834 " <config>\n"
4835 " <key>CONFIG_64BIT</key>\n"
4836 " <value>y</value>\n"
4837 " </config>\n"
4838 " </kernel>\n";
4839
4840 std::string error;
4841 HalManifest manifest1;
4842 HalManifest manifest2;
4843 ASSERT_TRUE(fromXml(&manifest1, head + xml1 + tail, &error)) << error;
4844 ASSERT_TRUE(fromXml(&manifest2, head + xml2 + tail, &error)) << error;
4845 ASSERT_TRUE(manifest1.addAll(&manifest2, &error)) << error;
4846 std::string merged_xml = toXml(manifest1);
4847 EXPECT_IN(head, merged_xml);
4848 EXPECT_IN("target-level=\"2\"", merged_xml);
4849 EXPECT_IN("version=\"3.18.31\"", merged_xml);
4850 EXPECT_IN("CONFIG_64BIT", merged_xml);
4851 }
4852
4853 // clang-format on
4854
TEST_F(LibVintfTest,FrameworkManifestHalMaxLevel)4855 TEST_F(LibVintfTest, FrameworkManifestHalMaxLevel) {
4856 std::string xml = "<manifest " + kMetaVersionStr + R"( type="framework">
4857 <hal max-level="3">
4858 <name>android.frameworks.schedulerservice</name>
4859 <transport>hwbinder</transport>
4860 <fqname>@1.0::ISchedulingPolicyService/default</fqname>
4861 </hal>
4862 <hal format="aidl" max-level="4">
4863 <name>android.frameworks.myaidl</name>
4864 <fqname>IAidl/default</fqname>
4865 </hal>
4866 <hal format="native" max-level="5">
4867 <name>some-native-hal</name>
4868 <version>1.0</version>
4869 </hal>
4870 </manifest>)";
4871
4872 std::string error;
4873 HalManifest manifest;
4874 ASSERT_TRUE(fromXml(&manifest, xml, &error)) << error;
4875
4876 auto hals = getHals(manifest, "android.frameworks.schedulerservice");
4877 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMaxLevel, Eq(static_cast<Level>(3)))));
4878
4879 hals = getHals(manifest, "android.frameworks.myaidl");
4880 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMaxLevel, Eq(static_cast<Level>(4)))));
4881
4882 hals = getHals(manifest, "some-native-hal");
4883 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMaxLevel, Eq(static_cast<Level>(5)))));
4884 }
4885
TEST_F(LibVintfTest,FrameworkManifestHalMinLevel)4886 TEST_F(LibVintfTest, FrameworkManifestHalMinLevel) {
4887 std::string xml = "<manifest " + kMetaVersionStr + R"( type="framework">
4888 <hal min-level="3">
4889 <name>android.frameworks.schedulerservice</name>
4890 <transport>hwbinder</transport>
4891 <fqname>@1.0::ISchedulingPolicyService/default</fqname>
4892 </hal>
4893 <hal format="aidl" min-level="4">
4894 <name>android.frameworks.myaidl</name>
4895 <fqname>IAidl/default</fqname>
4896 </hal>
4897 <hal format="native" min-level="5">
4898 <name>some-native-hal</name>
4899 <version>1.0</version>
4900 </hal>
4901 </manifest>)";
4902
4903 std::string error;
4904 HalManifest manifest;
4905 ASSERT_TRUE(fromXml(&manifest, xml, &error)) << error;
4906
4907 auto hals = getHals(manifest, "android.frameworks.schedulerservice");
4908 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMinLevel, Eq(static_cast<Level>(3)))));
4909
4910 hals = getHals(manifest, "android.frameworks.myaidl");
4911 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMinLevel, Eq(static_cast<Level>(4)))));
4912
4913 hals = getHals(manifest, "some-native-hal");
4914 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMinLevel, Eq(static_cast<Level>(5)))));
4915 }
4916
TEST_F(LibVintfTest,FrameworkManifestHalMinMaxLevel)4917 TEST_F(LibVintfTest, FrameworkManifestHalMinMaxLevel) {
4918 std::string xml = "<manifest " + kMetaVersionStr + R"( type="framework">
4919 <hal min-level="2" max-level="5">
4920 <name>android.frameworks.schedulerservice</name>
4921 <transport>hwbinder</transport>
4922 <fqname>@1.0::ISchedulingPolicyService/default</fqname>
4923 </hal>
4924 <hal format="aidl" min-level="3" max-level="6">
4925 <name>android.frameworks.myaidl</name>
4926 <fqname>IAidl/default</fqname>
4927 </hal>
4928 <hal format="native" min-level="4" max-level="7">
4929 <name>some-native-hal</name>
4930 <version>1.0</version>
4931 </hal>
4932 </manifest>)";
4933
4934 std::string error;
4935 HalManifest manifest;
4936 ASSERT_TRUE(fromXml(&manifest, xml, &error)) << error;
4937
4938 auto hals = getHals(manifest, "android.frameworks.schedulerservice");
4939 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMinLevel, Eq(static_cast<Level>(2)))));
4940 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMaxLevel, Eq(static_cast<Level>(5)))));
4941
4942 hals = getHals(manifest, "android.frameworks.myaidl");
4943 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMinLevel, Eq(static_cast<Level>(3)))));
4944 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMaxLevel, Eq(static_cast<Level>(6)))));
4945
4946 hals = getHals(manifest, "some-native-hal");
4947 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMinLevel, Eq(static_cast<Level>(4)))));
4948 EXPECT_THAT(hals, ElementsAre(Property(&ManifestHal::getMaxLevel, Eq(static_cast<Level>(7)))));
4949 }
4950
TEST_F(LibVintfTest,RuntimeInfoParseGkiKernelReleaseOk)4951 TEST_F(LibVintfTest, RuntimeInfoParseGkiKernelReleaseOk) {
4952 KernelVersion version;
4953 Level level = Level::UNSPECIFIED;
4954 EXPECT_EQ(OK, parseGkiKernelRelease(RuntimeInfo::FetchFlag::ALL, "5.4.42-android12-0-something",
4955 &version, &level));
4956 EXPECT_EQ(KernelVersion(5, 4, 42), version);
4957 EXPECT_EQ(Level::S, level);
4958 }
4959
TEST_F(LibVintfTest,RuntimeInfoParseGkiKernelReleaseVersionOnly)4960 TEST_F(LibVintfTest, RuntimeInfoParseGkiKernelReleaseVersionOnly) {
4961 KernelVersion version;
4962 EXPECT_EQ(OK, parseGkiKernelRelease(RuntimeInfo::FetchFlag::CPU_VERSION,
4963 "5.4.42-android12-0-something", &version, nullptr));
4964 EXPECT_EQ(KernelVersion(5, 4, 42), version);
4965 }
4966
TEST_F(LibVintfTest,RuntimeInfoParseGkiKernelReleaseLevelOnly)4967 TEST_F(LibVintfTest, RuntimeInfoParseGkiKernelReleaseLevelOnly) {
4968 Level level = Level::UNSPECIFIED;
4969 EXPECT_EQ(OK, parseGkiKernelRelease(RuntimeInfo::FetchFlag::KERNEL_FCM,
4970 "5.4.42-android12-0-something", nullptr, &level));
4971 EXPECT_EQ(Level::S, level);
4972 }
4973
TEST_F(LibVintfTest,RuntimeInfoParseGkiKernelReleaseLevelConsistent)4974 TEST_F(LibVintfTest, RuntimeInfoParseGkiKernelReleaseLevelConsistent) {
4975 Level level = Level::S;
4976 EXPECT_EQ(OK, parseGkiKernelRelease(RuntimeInfo::FetchFlag::KERNEL_FCM,
4977 "5.4.42-android12-0-something", nullptr, &level));
4978 EXPECT_EQ(Level::S, level);
4979 }
4980
TEST_F(LibVintfTest,RuntimeInfoParseGkiKernelReleaseLevelInconsistent)4981 TEST_F(LibVintfTest, RuntimeInfoParseGkiKernelReleaseLevelInconsistent) {
4982 Level level = Level::R;
4983 EXPECT_EQ(UNKNOWN_ERROR,
4984 parseGkiKernelRelease(RuntimeInfo::FetchFlag::KERNEL_FCM,
4985 "5.4.42-android12-0-something", nullptr, &level));
4986 }
4987
4988 // We bump level numbers for V, so check for consistency
TEST_F(LibVintfTest,RuntimeInfoGkiReleaseV)4989 TEST_F(LibVintfTest, RuntimeInfoGkiReleaseV) {
4990 Level level = Level::UNSPECIFIED;
4991 EXPECT_EQ(OK, parseGkiKernelRelease(RuntimeInfo::FetchFlag::KERNEL_FCM, "6.1.0-android15-0",
4992 nullptr, &level));
4993 EXPECT_EQ(Level::V, level);
4994 }
4995
TEST_F(LibVintfTest,AccessEntryInManifest)4996 TEST_F(LibVintfTest, AccessEntryInManifest) {
4997 HalManifest expectedManifest;
4998 expectedManifest.add(createManifestHal(HalFormat::AIDL, "android.hardware.foo",
4999 {Transport::EMPTY, Arch::ARCH_EMPTY}, ExclusiveTo::VM,
5000 {*FqInstance::from(SIZE_MAX, 1, "IFoo", "default")}));
5001 std::string manifestXml = "<manifest " + kMetaVersionStr +
5002 " type=\"device\">\n"
5003 " <hal format=\"aidl\" exclusive-to=\"virtual-machine\">\n"
5004 " <name>android.hardware.foo</name>\n"
5005 " <version>1</version>\n"
5006 " <interface>\n"
5007 " <name>IFoo</name>\n"
5008 " <instance>default</instance>\n"
5009 " </interface>\n"
5010 " </hal>\n"
5011 "</manifest>\n";
5012 HalManifest manifest;
5013 EXPECT_TRUE(fromXml(&manifest, manifestXml));
5014 EXPECT_EQ(expectedManifest, manifest)
5015 << dump(expectedManifest) << " is expected but got " << dump(manifest);
5016 }
5017
TEST_F(LibVintfTest,NoAccessEntryInManifestIsEmpty)5018 TEST_F(LibVintfTest, NoAccessEntryInManifestIsEmpty) {
5019 HalManifest expectedManifest;
5020 expectedManifest.add(createManifestHal(HalFormat::AIDL, "android.hardware.foo",
5021 {Transport::EMPTY, Arch::ARCH_EMPTY}, ExclusiveTo::EMPTY,
5022 {*FqInstance::from(SIZE_MAX, 1, "IFoo", "default")}));
5023 std::string manifestXml = "<manifest " + kMetaVersionStr +
5024 " type=\"device\">\n"
5025 " <hal format=\"aidl\">\n"
5026 " <name>android.hardware.foo</name>\n"
5027 " <version>1</version>\n"
5028 " <interface>\n"
5029 " <name>IFoo</name>\n"
5030 " <instance>default</instance>\n"
5031 " </interface>\n"
5032 " </hal>\n"
5033 "</manifest>\n";
5034 HalManifest manifest;
5035 EXPECT_TRUE(fromXml(&manifest, manifestXml));
5036 EXPECT_EQ(expectedManifest, manifest)
5037 << dump(expectedManifest) << " is expected but got " << dump(manifest);
5038 }
5039
TEST_F(LibVintfTest,UnknownAccessEntryInManifestIsEmpty)5040 TEST_F(LibVintfTest, UnknownAccessEntryInManifestIsEmpty) {
5041 HalManifest expectedManifest;
5042 expectedManifest.add(createManifestHal(HalFormat::AIDL, "android.hardware.foo",
5043 {Transport::EMPTY, Arch::ARCH_EMPTY}, ExclusiveTo::EMPTY,
5044 {*FqInstance::from(SIZE_MAX, 1, "IFoo", "default")}));
5045 std::string manifestXml = "<manifest " + kMetaVersionStr +
5046 " type=\"device\">\n"
5047 " <hal format=\"aidl\" exclusive-to=\"blooper\">\n"
5048 " <name>android.hardware.foo</name>\n"
5049 " <version>1</version>\n"
5050 " <interface>\n"
5051 " <name>IFoo</name>\n"
5052 " <instance>default</instance>\n"
5053 " </interface>\n"
5054 " </hal>\n"
5055 "</manifest>\n";
5056 HalManifest manifest;
5057 std::string error;
5058 EXPECT_FALSE(fromXml(&manifest, manifestXml, &error));
5059 EXPECT_EQ(error,
5060 "Could not parse element with name <hal> in element <manifest>: Unknown value "
5061 "(\"blooper\") for attribute 'exclusive-to' is considered a failure.");
5062 }
5063
TEST_F(LibVintfTest,AccessEntryInMatrix)5064 TEST_F(LibVintfTest, AccessEntryInMatrix) {
5065 MatrixHal mh{HalFormat::AIDL, "android.hardware.foo", {{SIZE_MAX, 1}},
5066 ExclusiveTo::VM, false /* updatableViaApex */, {}};
5067 EXPECT_TRUE(insert(&mh.interfaces, {"IFoo", {"default"}}));
5068 std::string xml = toXml(mh);
5069 EXPECT_EQ(xml,
5070 "<hal format=\"aidl\" exclusive-to=\"virtual-machine\">\n"
5071 " <name>android.hardware.foo</name>\n"
5072 " <interface>\n"
5073 " <name>IFoo</name>\n"
5074 " <instance>default</instance>\n"
5075 " </interface>\n"
5076 "</hal>\n");
5077 MatrixHal mh2;
5078 EXPECT_TRUE(fromXml(&mh2, xml));
5079 EXPECT_EQ(mh, mh2);
5080 }
5081
TEST_F(LibVintfTest,NoAccessEntryInMatrix)5082 TEST_F(LibVintfTest, NoAccessEntryInMatrix) {
5083 MatrixHal mh{HalFormat::AIDL, "android.hardware.foo", {{SIZE_MAX, 1}},
5084 ExclusiveTo::EMPTY, false /* updatableViaApex */, {}};
5085 EXPECT_TRUE(insert(&mh.interfaces, {"IFoo", {"default"}}));
5086 std::string xml = toXml(mh);
5087 EXPECT_EQ(xml,
5088 "<hal format=\"aidl\">\n"
5089 " <name>android.hardware.foo</name>\n"
5090 " <interface>\n"
5091 " <name>IFoo</name>\n"
5092 " <instance>default</instance>\n"
5093 " </interface>\n"
5094 "</hal>\n");
5095 MatrixHal mh2;
5096 EXPECT_TRUE(fromXml(&mh2, xml));
5097 EXPECT_EQ(mh, mh2);
5098 }
5099
5100 // Specific access desired and declared
TEST_F(LibVintfTest,AccessCompatibleSimple)5101 TEST_F(LibVintfTest, AccessCompatibleSimple) {
5102 CompatibilityMatrix cm;
5103 HalManifest manifest;
5104 std::string xml;
5105 std::string error;
5106
5107 xml = "<compatibility-matrix " + kMetaVersionStr +
5108 " type=\"framework\">\n"
5109 " <hal format=\"aidl\" exclusive-to=\"virtual-machine\">\n"
5110 " <name>android.hardware.foo</name>\n"
5111 " <interface>\n"
5112 " <name>IFoo</name>\n"
5113 " <instance>default</instance>\n"
5114 " </interface>\n"
5115 " </hal>\n"
5116 " <sepolicy>\n"
5117 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
5118 " <sepolicy-version>25.5</sepolicy-version>\n"
5119 " </sepolicy>\n"
5120 "</compatibility-matrix>\n";
5121 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
5122
5123 xml = "<manifest " + kMetaVersionStr +
5124 " type=\"device\">\n"
5125 " <hal format=\"aidl\" exclusive-to=\"virtual-machine\">\n"
5126 " <name>android.hardware.foo</name>\n"
5127 " <version>1</version>\n"
5128 " <interface>\n"
5129 " <name>IFoo</name>\n"
5130 " <instance>default</instance>\n"
5131 " </interface>\n"
5132 " </hal>\n"
5133 " <sepolicy>\n"
5134 " <version>25.5</version>\n"
5135 " </sepolicy>\n"
5136 "</manifest>\n";
5137 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
5138
5139 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
5140 }
5141
5142 // FCM expects specific access, but device provides normal access to host
TEST_F(LibVintfTest,AccessIncompatibleNoAccess)5143 TEST_F(LibVintfTest, AccessIncompatibleNoAccess) {
5144 CompatibilityMatrix cm;
5145 HalManifest manifest;
5146 std::string xml;
5147 std::string error;
5148
5149 xml = "<compatibility-matrix " + kMetaVersionStr +
5150 " type=\"framework\">\n"
5151 " <hal format=\"aidl\" exclusive-to=\"virtual-machine\">\n"
5152 " <name>android.hardware.foo</name>\n"
5153 " <interface>\n"
5154 " <name>IFoo</name>\n"
5155 " <instance>default</instance>\n"
5156 " </interface>\n"
5157 " </hal>\n"
5158 " <sepolicy>\n"
5159 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
5160 " <sepolicy-version>25.5</sepolicy-version>\n"
5161 " </sepolicy>\n"
5162 "</compatibility-matrix>\n";
5163 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
5164
5165 xml = "<manifest " + kMetaVersionStr +
5166 " type=\"device\">\n"
5167 " <hal format=\"aidl\">\n"
5168 " <name>android.hardware.foo</name>\n"
5169 " <version>1</version>\n"
5170 " <interface>\n"
5171 " <name>IFoo</name>\n"
5172 " <instance>default</instance>\n"
5173 " </interface>\n"
5174 " </hal>\n"
5175 " <sepolicy>\n"
5176 " <version>25.5</version>\n"
5177 " </sepolicy>\n"
5178 "</manifest>\n";
5179 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
5180
5181 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
5182
5183 // Error comes from unused HALs because the manifest provided a service
5184 // with access that the matrix doesn't expect
5185 auto unused = checkUnusedHals(manifest, cm);
5186 EXPECT_FALSE(unused.empty())
5187 << "Should conatin 'android.hardware.foo' HAL with ExclusiveTo::EMPTY but doesn't";
5188 }
5189
5190 // FCM expects normal, non-exclusive, access for service but device
5191 // only provides exclusive access to virtual-machine clients
TEST_F(LibVintfTest,AccessIncompatibleWrongAccess)5192 TEST_F(LibVintfTest, AccessIncompatibleWrongAccess) {
5193 CompatibilityMatrix cm;
5194 HalManifest manifest;
5195 std::string xml;
5196 std::string error;
5197
5198 xml = "<compatibility-matrix " + kMetaVersionStr +
5199 " type=\"framework\">\n"
5200 " <hal format=\"aidl\">\n"
5201 " <name>android.hardware.foo</name>\n"
5202 " <interface>\n"
5203 " <name>IFoo</name>\n"
5204 " <instance>default</instance>\n"
5205 " </interface>\n"
5206 " </hal>\n"
5207 " <sepolicy>\n"
5208 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
5209 " <sepolicy-version>25.5</sepolicy-version>\n"
5210 " </sepolicy>\n"
5211 "</compatibility-matrix>\n";
5212 EXPECT_TRUE(fromXml(&cm, xml, &error)) << error;
5213
5214 xml = "<manifest " + kMetaVersionStr +
5215 " type=\"device\">\n"
5216 " <hal format=\"aidl\" exclusive-to=\"virtual-machine\">\n"
5217 " <name>android.hardware.foo</name>\n"
5218 " <version>1</version>\n"
5219 " <interface>\n"
5220 " <name>IFoo</name>\n"
5221 " <instance>default</instance>\n"
5222 " </interface>\n"
5223 " </hal>\n"
5224 " <sepolicy>\n"
5225 " <version>25.5</version>\n"
5226 " </sepolicy>\n"
5227 "</manifest>\n";
5228 EXPECT_TRUE(fromXml(&manifest, xml, &error)) << error;
5229
5230 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
5231 // Error comes from unused HALs because the manifest provided a service
5232 // with access that the matrix doesn't expect
5233 auto unused = checkUnusedHals(manifest, cm);
5234 EXPECT_FALSE(unused.empty())
5235 << "Should contain 'android.hardware.foo' HAL with ExclusiveTo::VM but doesn't";
5236 }
5237
5238 class ManifestMissingITest : public LibVintfTest,
5239 public ::testing::WithParamInterface<std::string> {
5240 public:
createParams()5241 static std::vector<std::string> createParams() {
5242 std::vector<std::string> ret;
5243
5244 ret.push_back("<manifest " + kMetaVersionStr + R"( type="device">
5245 <hal format="aidl">
5246 <name>android.hardware.foo</name>
5247 <version>1</version>
5248 <interface>
5249 <name>MyFoo</name>
5250 <instance>default</instance>
5251 </interface>
5252 </hal>
5253 </manifest>)");
5254
5255 ret.push_back("<manifest " + kMetaVersionStr + R"( type="device">
5256 <hal format="hidl">
5257 <name>android.hardware.foo</name>
5258 <transport>hwbinder</transport>
5259 <version>1.0</version>
5260 <interface>
5261 <name>MyFoo</name>
5262 <instance>default</instance>
5263 </interface>
5264 </hal>
5265 </manifest>)");
5266
5267 ret.push_back("<manifest " + kMetaVersionStr + R"( type="device">
5268 <hal format="native">
5269 <name>android.hardware.foo</name>
5270 <version>1.0</version>
5271 <interface>
5272 <name>MyFoo</name>
5273 <instance>default</instance>
5274 </interface>
5275 </hal>
5276 </manifest>)");
5277
5278 return ret;
5279 }
5280 };
5281
TEST_P(ManifestMissingITest,CheckErrorMsg)5282 TEST_P(ManifestMissingITest, CheckErrorMsg) {
5283 std::string xml = GetParam();
5284 HalManifest manifest;
5285 std::string error;
5286 ASSERT_FALSE(fromXml(&manifest, xml, &error)) << "Should not be valid:\n" << xml;
5287 EXPECT_THAT(error, HasSubstr("Interface 'MyFoo' should have the format I[a-zA-Z0-9_]*")) << "\n"
5288 << xml;
5289 }
5290
5291 INSTANTIATE_TEST_SUITE_P(LibVintfTest, ManifestMissingITest,
5292 ::testing::ValuesIn(ManifestMissingITest::createParams()));
5293
5294 struct ManifestMissingInterfaceTestParam {
5295 std::string xml;
5296 std::string expectedError;
5297 };
5298
5299 class ManifestMissingInterfaceTest
5300 : public LibVintfTest,
5301 public ::testing::WithParamInterface<ManifestMissingInterfaceTestParam> {
5302 public:
createParams()5303 static std::vector<ManifestMissingInterfaceTestParam> createParams() {
5304 std::vector<ManifestMissingInterfaceTestParam> ret;
5305
5306 ret.emplace_back(ManifestMissingInterfaceTestParam{
5307 "<manifest " + kMetaVersionStr + R"( type="device">
5308 <hal format="aidl">
5309 <name>android.hardware.foo</name>
5310 <version>1</version>
5311 <interface>
5312 <instance>default</instance>
5313 </interface>
5314 </hal>
5315 </manifest>)",
5316 "Interface '' should have the format I[a-zA-Z0-9_]*",
5317 });
5318
5319 ret.emplace_back(ManifestMissingInterfaceTestParam{
5320 "<manifest " + kMetaVersionStr + R"( type="device">
5321 <hal format="aidl">
5322 <name>android.hardware.foo</name>
5323 <version>1</version>
5324 <fqname>/default</fqname>
5325 </hal>
5326 </manifest>)",
5327 "Could not parse text \"/default\" in element <fqname>",
5328 });
5329
5330 ret.emplace_back(ManifestMissingInterfaceTestParam{
5331 "<manifest " + kMetaVersionStr + R"( type="device">
5332 <hal format="hidl">
5333 <name>android.hardware.foo</name>
5334 <transport>hwbinder</transport>
5335 <version>1.0</version>
5336 <interface>
5337 <instance>default</instance>
5338 </interface>
5339 </hal>
5340 </manifest>)",
5341 "Interface '' should have the format I[a-zA-Z0-9_]*",
5342 });
5343
5344 ret.emplace_back(ManifestMissingInterfaceTestParam{
5345 "<manifest " + kMetaVersionStr + R"( type="device">
5346 <hal format="hidl">
5347 <name>android.hardware.foo</name>
5348 <transport>hwbinder</transport>
5349 <fqname>@1.0/default</fqname>
5350 </hal>
5351 </manifest>)",
5352 "Should specify interface: \"@1.0/default\"",
5353 });
5354
5355 return ret;
5356 }
5357 };
5358
TEST_P(ManifestMissingInterfaceTest,CheckErrorMsg)5359 TEST_P(ManifestMissingInterfaceTest, CheckErrorMsg) {
5360 auto&& [xml, expectedError] = GetParam();
5361 HalManifest manifest;
5362 std::string error;
5363 ASSERT_FALSE(fromXml(&manifest, xml, &error)) << "Should not be valid:\n" << xml;
5364 EXPECT_THAT(error, HasSubstr(expectedError)) << "\n" << xml;
5365 }
5366
5367 INSTANTIATE_TEST_SUITE_P(LibVintfTest, ManifestMissingInterfaceTest,
5368 ::testing::ValuesIn(ManifestMissingInterfaceTest::createParams()));
5369
TEST_F(LibVintfTest,HalManifestInvalidPackage)5370 TEST_F(LibVintfTest, HalManifestInvalidPackage) {
5371 // If package name, interface or instance contains characters invalid to FqInstance,
5372 // it must be rejected because forEachInstance requires them to fit into FqInstance.
5373 std::string xml = "<manifest " + kMetaVersionStr + R"( type="framework">
5374 <hal format="aidl">
5375 <name>not_a_valid_package!</name>
5376 <version>1</version>
5377 <interface>
5378 <name>MyFoo</name>
5379 <instance>default</instance>
5380 </interface>
5381 </hal>
5382 </manifest>)";
5383 HalManifest manifest;
5384 std::string error;
5385 ASSERT_FALSE(fromXml(&manifest, xml, &error)) << "Should not be valid:\n" << xml;
5386 EXPECT_THAT(error, HasSubstr("not_a_valid_package!"));
5387 }
5388
5389 class MatrixMissingITest : public LibVintfTest, public ::testing::WithParamInterface<std::string> {
5390 public:
createParams()5391 static std::vector<std::string> createParams() {
5392 std::vector<std::string> ret;
5393
5394 ret.push_back("<compatibility-matrix " + kMetaVersionStr + R"( type="device">
5395 <hal format="aidl">
5396 <name>android.hardware.foo</name>
5397 <version>1</version>
5398 <interface>
5399 <name>MyFoo</name>
5400 <instance>default</instance>
5401 </interface>
5402 </hal>
5403 </compatibility-matrix>)");
5404
5405 ret.push_back("<compatibility-matrix " + kMetaVersionStr + R"( type="device">
5406 <hal format="hidl">
5407 <name>android.hardware.foo</name>
5408 <version>1.0</version>
5409 <interface>
5410 <name>MyFoo</name>
5411 <instance>default</instance>
5412 </interface>
5413 </hal>
5414 </compatibility-matrix>)");
5415
5416 ret.push_back("<compatibility-matrix " + kMetaVersionStr + R"( type="device">
5417 <hal format="native">
5418 <name>android.hardware.foo</name>
5419 <version>1.0</version>
5420 <interface>
5421 <name>MyFoo</name>
5422 <instance>default</instance>
5423 </interface>
5424 </hal>
5425 </compatibility-matrix>)");
5426
5427 return ret;
5428 }
5429 };
5430
TEST_P(MatrixMissingITest,CheckErrorMsg)5431 TEST_P(MatrixMissingITest, CheckErrorMsg) {
5432 std::string xml = GetParam();
5433 CompatibilityMatrix matrix;
5434 std::string error;
5435 ASSERT_FALSE(fromXml(&matrix, xml, &error)) << "Should not be valid:\n" << xml;
5436 EXPECT_THAT(error, HasSubstr("Interface 'MyFoo' should have the format I[a-zA-Z0-9_]*"));
5437 }
5438
5439 INSTANTIATE_TEST_SUITE_P(LibVintfTest, MatrixMissingITest,
5440 ::testing::ValuesIn(MatrixMissingITest::createParams()));
5441
5442 struct MatrixMissingInterfaceTestParam {
5443 std::string xml;
5444 std::string expectedError;
5445 };
5446
5447 class MatrixMissingInterfaceTest
5448 : public LibVintfTest,
5449 public ::testing::WithParamInterface<MatrixMissingInterfaceTestParam> {
5450 public:
createParams()5451 static std::vector<MatrixMissingInterfaceTestParam> createParams() {
5452 std::vector<MatrixMissingInterfaceTestParam> ret;
5453
5454 ret.emplace_back(MatrixMissingInterfaceTestParam{
5455 "<compatibility-matrix " + kMetaVersionStr + R"( type="device">
5456 <hal format="aidl">
5457 <name>android.hardware.foo</name>
5458 <version>1</version>
5459 <interface>
5460 <instance>default</instance>
5461 </interface>
5462 </hal>
5463 </compatibility-matrix>)",
5464 "Interface '' should have the format I[a-zA-Z0-9_]*",
5465 });
5466
5467 ret.emplace_back(MatrixMissingInterfaceTestParam{
5468 "<compatibility-matrix " + kMetaVersionStr + R"( type="device">
5469 <hal format="hidl">
5470 <name>android.hardware.foo</name>
5471 <version>1.0</version>
5472 <interface>
5473 <instance>default</instance>
5474 </interface>
5475 </hal>
5476 </compatibility-matrix>)",
5477 "Interface '' should have the format I[a-zA-Z0-9_]*",
5478 });
5479
5480 return ret;
5481 }
5482 };
5483
TEST_P(MatrixMissingInterfaceTest,CheckErrorMsg)5484 TEST_P(MatrixMissingInterfaceTest, CheckErrorMsg) {
5485 auto&& [xml, expectedError] = GetParam();
5486 CompatibilityMatrix matrix;
5487 std::string error;
5488 ASSERT_FALSE(fromXml(&matrix, xml, &error)) << "Should not be valid:\n" << xml;
5489 EXPECT_THAT(error, HasSubstr(expectedError)) << "\n" << xml;
5490 }
5491
5492 INSTANTIATE_TEST_SUITE_P(LibVintfTest, MatrixMissingInterfaceTest,
5493 ::testing::ValuesIn(MatrixMissingInterfaceTest::createParams()));
5494
TEST_F(LibVintfTest,CompatibilityMatrixInvalidPackage)5495 TEST_F(LibVintfTest, CompatibilityMatrixInvalidPackage) {
5496 // If package name, interface or instance contains characters invalid to FqInstance,
5497 // it must be rejected because forEachInstance requires them to fit into FqInstance.
5498 std::string xml = "<compatibility-matrix " + kMetaVersionStr + R"( type="framework">
5499 <hal format="aidl">
5500 <name>not_a_valid_package!</name>
5501 <version>1-2</version>
5502 <interface>
5503 <name>MyFoo</name>
5504 <instance>default</instance>
5505 </interface>
5506 </hal>
5507 </compatibility-matrix>)";
5508 CompatibilityMatrix matrix;
5509 std::string error;
5510 ASSERT_FALSE(fromXml(&matrix, xml, &error)) << "Should not be valid:\n" << xml;
5511 EXPECT_THAT(error, HasSubstr("not_a_valid_package!"));
5512 }
5513
5514 struct DupInterfaceAndFqnameTestParam {
5515 HalFormat format;
5516 std::string footer;
5517 std::string halName;
5518 };
5519
5520 class DupInterfaceAndFqnameTest
5521 : public LibVintfTest,
5522 public ::testing::WithParamInterface<DupInterfaceAndFqnameTestParam> {
5523 public:
createParams()5524 static std::vector<DupInterfaceAndFqnameTestParam> createParams() {
5525 std::vector<DupInterfaceAndFqnameTestParam> ret;
5526
5527 std::string hidlFooter = R"(
5528 <hal>
5529 <name>android.hardware.nfc</name>
5530 <transport>hwbinder</transport>
5531 <version>1.0</version>
5532 <interface>
5533 <name>INfc</name>
5534 <instance>default</instance>
5535 </interface>
5536 <fqname>@1.0::INfc/default</fqname>
5537 </hal>
5538 </manifest>
5539 )";
5540
5541 std::string aidlFooter = R"(
5542 <hal format="aidl">
5543 <name>android.hardware.nfc</name>
5544 <interface>
5545 <name>INfc</name>
5546 <instance>default</instance>
5547 </interface>
5548 <fqname>INfc/default</fqname>
5549 </hal>
5550 </manifest>
5551 )";
5552
5553 return {
5554 {HalFormat::HIDL, hidlFooter, "android.hardware.nfc@1.0::INfc/default"},
5555 {HalFormat::AIDL, aidlFooter, "android.hardware.nfc.INfc/default"},
5556 };
5557 }
getTestSuffix(const TestParamInfo<ParamType> & info)5558 static std::string getTestSuffix(const TestParamInfo<ParamType>& info) {
5559 return to_string(info.param.format);
5560 }
5561 };
5562
TEST_P(DupInterfaceAndFqnameTest,Test5_0)5563 TEST_P(DupInterfaceAndFqnameTest, Test5_0) {
5564 auto&& [_, footer, halName] = GetParam();
5565 std::string xml = R"(<manifest version="5.0" type="device">)" + footer;
5566 HalManifest vm;
5567 std::string error;
5568 EXPECT_TRUE(fromXml(&vm, xml, &error))
5569 << "<fqname> and <interface> are allowed to exist "
5570 "together for the same instance for libvintf 5.0, but error is: "
5571 << error;
5572 }
5573
TEST_P(DupInterfaceAndFqnameTest,Test6_0)5574 TEST_P(DupInterfaceAndFqnameTest, Test6_0) {
5575 auto&& [_, footer, halName] = GetParam();
5576 std::string xml = R"(<manifest version=")" + to_string(kMetaVersionNoHalInterfaceInstance) +
5577 R"(" type="device">)" + footer;
5578 HalManifest vm;
5579 std::string error;
5580 EXPECT_FALSE(fromXml(&vm, xml, &error));
5581 EXPECT_THAT(error,
5582 HasSubstr("Duplicated " + halName + " in <interface><instance> and <fqname>."))
5583 << "<fqname> and <interface> are not allowed to exist "
5584 "together for the same instance for libvintf "
5585 << kMetaVersionNoHalInterfaceInstance << ".";
5586 }
5587
5588 INSTANTIATE_TEST_SUITE_P(LibVintfTest, DupInterfaceAndFqnameTest,
5589 ::testing::ValuesIn(DupInterfaceAndFqnameTest::createParams()),
5590 &DupInterfaceAndFqnameTest::getTestSuffix);
5591
5592 struct AllowDupMajorVersionTestParam {
5593 std::string testName;
5594 std::string expectedError;
5595 std::string footer;
5596 };
5597
5598 class AllowDupMajorVersionTest
5599 : public LibVintfTest,
5600 public ::testing::WithParamInterface<AllowDupMajorVersionTestParam> {
5601 public:
createParams()5602 static std::vector<AllowDupMajorVersionTestParam> createParams() {
5603 std::vector<AllowDupMajorVersionTestParam> ret;
5604 ret.push_back({"HidlInterfaceAndFqName", "Duplicated major version", R"(
5605 <hal>
5606 <name>android.hardware.nfc</name>
5607 <transport>hwbinder</transport>
5608 <version>1.0</version>
5609 <interface>
5610 <name>INfc</name>
5611 <instance>default</instance>
5612 </interface>
5613 <fqname>@1.1::INfc/default</fqname>
5614 </hal>
5615 </manifest>
5616 )"});
5617 ret.push_back({"HidlFqNameInTheSameHal", "Duplicated major version", R"(
5618 <hal>
5619 <name>android.hardware.nfc</name>
5620 <transport>hwbinder</transport>
5621 <fqname>@1.0::INfc/default</fqname>
5622 <fqname>@1.1::INfc/default</fqname>
5623 </hal>
5624 </manifest>
5625 )"});
5626 ret.push_back({"HidlFqNameInDifferentHals", "Conflicting FqInstance", R"(
5627 <hal>
5628 <name>android.hardware.nfc</name>
5629 <transport>hwbinder</transport>
5630 <fqname>@1.0::INfc/default</fqname>
5631 </hal>
5632 <hal>
5633 <name>android.hardware.nfc</name>
5634 <transport>hwbinder</transport>
5635 <fqname>@1.1::INfc/default</fqname>
5636 </hal>
5637 </manifest>
5638 )"});
5639 ret.push_back({"HidlInterfaceAndFqNameInDifferentHals", "Conflicting FqInstance", R"(
5640 <hal>
5641 <name>android.hardware.nfc</name>
5642 <transport>hwbinder</transport>
5643 <version>1.0</version>
5644 <interface>
5645 <name>INfc</name>
5646 <instance>default</instance>
5647 </interface>
5648 </hal>
5649 <hal>
5650 <name>android.hardware.nfc</name>
5651 <transport>hwbinder</transport>
5652 <fqname>@1.1::INfc/default</fqname>
5653 </hal>
5654 </manifest>
5655 )"});
5656 ret.push_back({"AidlInterfaceInDifferentHals", "Conflicting FqInstance", R"(
5657 <hal format="aidl">
5658 <name>android.hardware.nfc</name>
5659 <version>1</version>
5660 <interface>
5661 <name>INfc</name>
5662 <instance>default</instance>
5663 </interface>
5664 </hal>
5665 <hal format="aidl">
5666 <name>android.hardware.nfc</name>
5667 <version>2</version>
5668 <interface>
5669 <name>INfc</name>
5670 <instance>default</instance>
5671 </interface>
5672 </hal>
5673 </manifest>
5674 )"});
5675 ret.push_back({"AidlFqNameInDifferentHals", "Conflicting FqInstance", R"(
5676 <hal format="aidl">
5677 <name>android.hardware.nfc</name>
5678 <version>1</version>
5679 <fqname>INfc/default</fqname>
5680 </hal>
5681 <hal format="aidl">
5682 <name>android.hardware.nfc</name>
5683 <version>2</version>
5684 <fqname>INfc/default</fqname>
5685 </hal>
5686 </manifest>
5687 )"});
5688 ret.push_back({"AidlInterfaceAndFqNameInDifferentHals", "Conflicting FqInstance", R"(
5689 <hal format="aidl">
5690 <name>android.hardware.nfc</name>
5691 <version>1</version>
5692 <interface>
5693 <name>INfc</name>
5694 <instance>default</instance>
5695 </interface>
5696 </hal>
5697 <hal format="aidl">
5698 <name>android.hardware.nfc</name>
5699 <version>2</version>
5700 <fqname>INfc/default</fqname>
5701 </hal>
5702 </manifest>
5703 )"});
5704 ret.push_back({"AidlAccessorInDifferentHals", "Conflicting Accessor", R"(
5705 <hal format="aidl">
5706 <name>android.hardware.nfc</name>
5707 <version>2</version>
5708 <accessor>android.os.accessor.IAccessor/android.hardware.nfc.INfc/a</accessor>
5709 <fqname>INfc/default</fqname>
5710 </hal>
5711 <hal format="aidl">
5712 <name>android.hardware.nfc</name>
5713 <version>2</version>
5714 <accessor>android.os.accessor.IAccessor/android.hardware.nfc.INfc/a</accessor>
5715 <fqname>INfc/foo</fqname>
5716 </hal>
5717 </manifest>
5718 )"});
5719 return ret;
5720 }
getTestSuffix(const TestParamInfo<ParamType> & info)5721 static std::string getTestSuffix(const TestParamInfo<ParamType>& info) {
5722 return info.param.testName;
5723 }
5724 };
5725
TEST_P(AllowDupMajorVersionTest,Allow5_0)5726 TEST_P(AllowDupMajorVersionTest, Allow5_0) {
5727 auto&& [_, expectedError, footer] = GetParam();
5728 std::string xml = R"(<manifest version="5.0" type="device">)" + footer;
5729 HalManifest vm;
5730 std::string error;
5731 EXPECT_TRUE(fromXml(&vm, xml, &error))
5732 << "Conflicting major version in <fqname> is allowed in libvintf 5.0. However, error is: "
5733 << error;
5734 }
5735
TEST_P(AllowDupMajorVersionTest,DoNotAllow6_0)5736 TEST_P(AllowDupMajorVersionTest, DoNotAllow6_0) {
5737 auto&& [_, expectedError, footer] = GetParam();
5738 std::string xml = R"(<manifest version=")" + to_string(kMetaVersionNoHalInterfaceInstance) +
5739 R"(" type="device">)" + footer;
5740 HalManifest vm;
5741 std::string error;
5742 EXPECT_FALSE(fromXml(&vm, xml, &error));
5743 EXPECT_THAT(error, HasSubstr(expectedError));
5744 }
5745
5746 INSTANTIATE_TEST_SUITE_P(LibVintfTest, AllowDupMajorVersionTest,
5747 ::testing::ValuesIn(AllowDupMajorVersionTest::createParams()),
5748 &AllowDupMajorVersionTest::getTestSuffix);
5749
5750 struct InterfaceMissingInstanceTestParam {
5751 HalFormat format;
5752 std::string footer;
5753 };
5754
5755 class InterfaceMissingInstanceTest
5756 : public LibVintfTest,
5757 public ::testing::WithParamInterface<InterfaceMissingInstanceTestParam> {
5758 public:
createParams()5759 static std::vector<InterfaceMissingInstanceTestParam> createParams() {
5760 std::vector<InterfaceMissingInstanceTestParam> ret;
5761
5762 std::string hidlFooter = R"(
5763 <hal>
5764 <name>android.hardware.nfc</name>
5765 <transport>hwbinder</transport>
5766 <version>1.0</version>
5767 <interface>
5768 <name>INfc</name>
5769 </interface>
5770 </hal>
5771 </manifest>
5772 )";
5773 std::string aidlFooter = R"(
5774 <hal format="aidl">
5775 <name>android.hardware.nfc</name>
5776 <interface>
5777 <name>INfc</name>
5778 </interface>
5779 </hal>
5780 </manifest>
5781 )";
5782
5783 return {{HalFormat::HIDL, hidlFooter}, {HalFormat::AIDL, aidlFooter}};
5784 }
getTestSuffix(const TestParamInfo<ParamType> & info)5785 static std::string getTestSuffix(const TestParamInfo<ParamType>& info) {
5786 return to_string(info.param.format);
5787 }
5788 };
5789
TEST_P(InterfaceMissingInstanceTest,Test5_0)5790 TEST_P(InterfaceMissingInstanceTest, Test5_0) {
5791 auto&& [testName, footer] = GetParam();
5792 std::string header = R"(<manifest version="5.0" type="device">)";
5793 std::string xml = header + footer;
5794 HalManifest vm;
5795 std::string error;
5796 EXPECT_TRUE(fromXml(&vm, xml, &error)) << error;
5797 }
5798
TEST_P(InterfaceMissingInstanceTest,Test6_0)5799 TEST_P(InterfaceMissingInstanceTest, Test6_0) {
5800 auto&& [testName, footer] = GetParam();
5801 std::string header = R"(<manifest version=")" + to_string(kMetaVersionNoHalInterfaceInstance) +
5802 R"(" type="device">)";
5803 std::string xml = header + footer;
5804 HalManifest vm;
5805 std::string error;
5806 EXPECT_FALSE(fromXml(&vm, xml, &error));
5807 EXPECT_THAT(error, HasSubstr("<hal> android.hardware.nfc <interface> INfc has no <instance>."));
5808 }
5809
5810 INSTANTIATE_TEST_SUITE_P(LibVintfTest, InterfaceMissingInstanceTest,
5811 ::testing::ValuesIn(InterfaceMissingInstanceTest::createParams()),
5812 &InterfaceMissingInstanceTest::getTestSuffix);
5813
5814 struct ManifestHalNoInstanceTestParam {
5815 HalFormat format;
5816 std::string footer;
5817 };
5818
5819 class ManifestHalNoInstanceTest
5820 : public LibVintfTest,
5821 public ::testing::WithParamInterface<ManifestHalNoInstanceTestParam> {
5822 public:
createParams()5823 static std::vector<ManifestHalNoInstanceTestParam> createParams() {
5824 std::vector<ManifestHalNoInstanceTestParam> ret;
5825
5826 std::string hidlFooter = R"(
5827 <hal>
5828 <name>android.hardware.nfc</name>
5829 <transport>hwbinder</transport>
5830 <version>1.0</version>
5831 </hal>
5832 </manifest>
5833 )";
5834 std::string aidlFooter = R"(
5835 <hal format="aidl">
5836 <name>android.hardware.nfc</name>
5837 </hal>
5838 </manifest>
5839 )";
5840
5841 return {{HalFormat::HIDL, hidlFooter}, {HalFormat::AIDL, aidlFooter}};
5842 }
getTestSuffix(const TestParamInfo<ParamType> & info)5843 static std::string getTestSuffix(const TestParamInfo<ParamType>& info) {
5844 return to_string(info.param.format);
5845 }
5846 };
5847
TEST_P(ManifestHalNoInstanceTest,Test5_0)5848 TEST_P(ManifestHalNoInstanceTest, Test5_0) {
5849 auto&& [testName, footer] = GetParam();
5850 std::string header = R"(<manifest version="5.0" type="device">)";
5851 std::string xml = header + footer;
5852 HalManifest vm;
5853 std::string error;
5854 EXPECT_TRUE(fromXml(&vm, xml, &error)) << error;
5855 }
5856
TEST_P(ManifestHalNoInstanceTest,Test6_0)5857 TEST_P(ManifestHalNoInstanceTest, Test6_0) {
5858 auto&& [testName, footer] = GetParam();
5859 std::string header = R"(<manifest version=")" + to_string(kMetaVersionNoHalInterfaceInstance) +
5860 R"(" type="device">)";
5861 std::string xml = header + footer;
5862 HalManifest vm;
5863 std::string error;
5864 EXPECT_FALSE(fromXml(&vm, xml, &error));
5865 EXPECT_THAT(error,
5866 HasSubstr("<hal> android.hardware.nfc has no instance. Fix by adding <fqname>."));
5867 }
5868
5869 INSTANTIATE_TEST_SUITE_P(LibVintfTest, ManifestHalNoInstanceTest,
5870 ::testing::ValuesIn(ManifestHalNoInstanceTest::createParams()),
5871 &ManifestHalNoInstanceTest::getTestSuffix);
5872
5873 // clang-format off
5874
5875 struct FrameworkCompatibilityMatrixCombineTest : public LibVintfTest {
SetUpandroid::vintf::FrameworkCompatibilityMatrixCombineTest5876 virtual void SetUp() override {
5877 matrices.resize(2);
5878 matrices[0].setFileName("compatibility_matrix.1_1.xml");
5879 matrices[1].setFileName("compatibility_matrix.1_2.xml");
5880 }
5881 // Access to private methods.
combineandroid::vintf::FrameworkCompatibilityMatrixCombineTest5882 std::unique_ptr<CompatibilityMatrix> combine(Level deviceLevel,
5883 std::vector<CompatibilityMatrix>* theMatrices,
5884 std::string* errorPtr) {
5885 return CompatibilityMatrix::combine(deviceLevel, Level::UNSPECIFIED, theMatrices, errorPtr);
5886 }
combineandroid::vintf::FrameworkCompatibilityMatrixCombineTest5887 std::unique_ptr<CompatibilityMatrix> combine(Level deviceLevel, Level kernellevel,
5888 std::vector<CompatibilityMatrix>* theMatrices,
5889 std::string* errorPtr) {
5890 return CompatibilityMatrix::combine(deviceLevel, kernellevel, theMatrices, errorPtr);
5891 }
5892
5893 std::vector<CompatibilityMatrix> matrices;
5894 std::string error;
5895 };
5896
5897 // Combining framework compatibility matrix with conflicting minlts fails
TEST_F(FrameworkCompatibilityMatrixCombineTest,ConflictMinlts)5898 TEST_F(FrameworkCompatibilityMatrixCombineTest, ConflictMinlts) {
5899 ASSERT_TRUE(fromXml(
5900 &matrices[0],
5901 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
5902 " <kernel version=\"3.18.5\" />\n"
5903 "</compatibility-matrix>\n",
5904 &error))
5905 << error;
5906 ASSERT_TRUE(fromXml(
5907 &matrices[1],
5908 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
5909 " <kernel version=\"3.18.6\" />\n"
5910 "</compatibility-matrix>\n",
5911 &error))
5912 << error;
5913
5914 auto combined = combine(Level{1}, &matrices, &error);
5915 ASSERT_EQ(nullptr, combined) << toXml(*combined);
5916 EXPECT_IN("Kernel version mismatch", error);
5917 }
5918
5919 // <kernel> without <conditions> always comes first
TEST_F(FrameworkCompatibilityMatrixCombineTest,KernelNoConditions)5920 TEST_F(FrameworkCompatibilityMatrixCombineTest, KernelNoConditions) {
5921 std::string conditionedKernel =
5922 " <kernel version=\"3.18.5\" level=\"1\">\n"
5923 " <conditions>\n"
5924 " <config>\n"
5925 " <key>CONFIG_ARM</key>\n"
5926 " <value type=\"tristate\">y</value>\n"
5927 " </config>\n"
5928 " </conditions>\n"
5929 " <config>\n"
5930 " <key>CONFIG_FOO</key>\n"
5931 " <value type=\"tristate\">y</value>\n"
5932 " </config>\n"
5933 " </kernel>\n";
5934 std::string simpleKernel =
5935 " <kernel version=\"3.18.5\" level=\"1\">\n"
5936 " <config>\n"
5937 " <key>CONFIG_BAR</key>\n"
5938 " <value type=\"tristate\">y</value>\n"
5939 " </config>\n"
5940 " </kernel>\n";
5941
5942 ASSERT_TRUE(fromXml(
5943 &matrices[0],
5944 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
5945 " <kernel version=\"3.18.5\" />\n" +
5946 conditionedKernel + "</compatibility-matrix>\n",
5947 &error))
5948 << error;
5949 ASSERT_TRUE(fromXml(
5950 &matrices[1],
5951 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n" + simpleKernel +
5952 "</compatibility-matrix>\n",
5953 &error))
5954 << error;
5955
5956 auto combined = combine(Level{1}, &matrices, &error);
5957 ASSERT_NE(nullptr, combined);
5958 EXPECT_EQ("", error);
5959 EXPECT_EQ("<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n" +
5960 simpleKernel + conditionedKernel + "</compatibility-matrix>\n",
5961 toXml(*combined));
5962 }
5963
5964 // Combining framework compatibility matrix with conflicting sepolicy fails
TEST_F(FrameworkCompatibilityMatrixCombineTest,ConflictSepolicy)5965 TEST_F(FrameworkCompatibilityMatrixCombineTest, ConflictSepolicy) {
5966 ASSERT_TRUE(fromXml(
5967 &matrices[0],
5968 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
5969 " <sepolicy>\n"
5970 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
5971 " </sepolicy>\n"
5972 "</compatibility-matrix>\n",
5973 &error))
5974 << error;
5975 ASSERT_TRUE(fromXml(
5976 &matrices[1],
5977 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
5978 " <sepolicy>\n"
5979 " <kernel-sepolicy-version>29</kernel-sepolicy-version>\n"
5980 " </sepolicy>\n"
5981 "</compatibility-matrix>\n",
5982 &error))
5983 << error;
5984
5985 auto combined = combine(Level{1}, &matrices, &error);
5986 ASSERT_EQ(nullptr, combined) << toXml(*combined);
5987 EXPECT_IN("<sepolicy> is already defined", error);
5988 }
5989
5990 // Combining framework compatibility matrix with conflicting avb fails
TEST_F(FrameworkCompatibilityMatrixCombineTest,ConflictAvb)5991 TEST_F(FrameworkCompatibilityMatrixCombineTest, ConflictAvb) {
5992 ASSERT_TRUE(fromXml(
5993 &matrices[0],
5994 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
5995 " <avb>\n"
5996 " <vbmeta-version>1.1</vbmeta-version>\n"
5997 " </avb>\n"
5998 "</compatibility-matrix>\n",
5999 &error))
6000 << error;
6001 ASSERT_TRUE(fromXml(
6002 &matrices[1],
6003 "<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"
6004 " <avb>\n"
6005 " <vbmeta-version>1.0</vbmeta-version>\n"
6006 " </avb>\n"
6007 "</compatibility-matrix>\n",
6008 &error))
6009 << error;
6010
6011 auto combined = combine(Level{1}, &matrices, &error);
6012 ASSERT_EQ(nullptr, combined) << toXml(*combined);
6013 EXPECT_IN("<avb><vbmeta-version> is already defined", error);
6014 }
6015
TEST_F(FrameworkCompatibilityMatrixCombineTest,AidlAndHidlNames)6016 TEST_F(FrameworkCompatibilityMatrixCombineTest, AidlAndHidlNames) {
6017 std::string head1{"<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"1\">\n"};
6018 std::string head2{"<compatibility-matrix " + kMetaVersionStr + " type=\"framework\" level=\"2\">\n"};
6019 std::string tail{"</compatibility-matrix>\n"};
6020 std::string aidl =
6021 " <hal format=\"aidl\">\n"
6022 " <name>android.system.foo</name>\n"
6023 " <interface>\n"
6024 " <name>IFoo</name>\n"
6025 " <instance>default</instance>\n"
6026 " </interface>\n"
6027 " </hal>\n";
6028 std::string hidl =
6029 " <hal format=\"hidl\">\n"
6030 " <name>android.system.foo</name>\n"
6031 " <version>1.0</version>\n"
6032 " <interface>\n"
6033 " <name>IFoo</name>\n"
6034 " <instance>default</instance>\n"
6035 " </interface>\n"
6036 " </hal>\n";
6037 std::string error;
6038 {
6039 ASSERT_TRUE(fromXml(&matrices[0], head1 + aidl + tail, &error))
6040 << error;
6041 ASSERT_TRUE(fromXml(&matrices[1], head1 + hidl + tail, &error))
6042 << error;
6043
6044 auto combined = combine(Level{1}, &matrices, &error);
6045 ASSERT_NE(nullptr, combined) << error;
6046
6047 auto combinedXml = toXml(*combined);
6048 EXPECT_IN(aidl, combinedXml);
6049 EXPECT_IN(hidl, combinedXml);
6050 }
6051 {
6052 ASSERT_TRUE(fromXml(&matrices[0], head1 + aidl + tail, &error))
6053 << error;
6054 ASSERT_TRUE(fromXml(&matrices[1], head2 + hidl + tail, &error))
6055 << error;
6056
6057 auto combined = combine(Level{1}, &matrices, &error);
6058 ASSERT_NE(nullptr, combined) << error;
6059
6060 auto combinedXml = toXml(*combined);
6061 EXPECT_IN(aidl, combinedXml);
6062 EXPECT_IN(hidl, combinedXml);
6063 }
6064 {
6065 ASSERT_TRUE(fromXml(&matrices[0], head2 + aidl + tail, &error))
6066 << error;
6067 ASSERT_TRUE(fromXml(&matrices[1], head1 + hidl + tail, &error))
6068 << error;
6069
6070 auto combined = combine(Level{1}, &matrices, &error);
6071 ASSERT_NE(nullptr, combined) << error;
6072
6073 auto combinedXml = toXml(*combined);
6074 EXPECT_IN(hidl, combinedXml);
6075 EXPECT_IN(aidl, combinedXml);
6076 }
6077 }
6078
6079 // clang-format on
6080
6081 class FcmCombineKernelTest : public FrameworkCompatibilityMatrixCombineTest,
6082 public ::testing::WithParamInterface<std::tuple<size_t, size_t>> {
6083 public:
PrintTestParams(const TestParamInfo<FcmCombineKernelTest::ParamType> & info)6084 static std::string PrintTestParams(const TestParamInfo<FcmCombineKernelTest::ParamType>& info) {
6085 auto [deviceLevelNum, kernelLevelNum] = info.param;
6086 return "device_" + std::to_string(deviceLevelNum) + "_kernel_" +
6087 std::to_string(kernelLevelNum);
6088 }
6089 static constexpr size_t kMinLevel = 1;
6090 static constexpr size_t kMaxLevel = 5;
6091 };
6092
TEST_P(FcmCombineKernelTest,OlderKernel)6093 TEST_P(FcmCombineKernelTest, OlderKernel) {
6094 auto [deviceLevelNum, kernelLevelNum] = GetParam();
6095
6096 std::vector<size_t> levelNums;
6097 for (size_t i = kMinLevel; i <= kMaxLevel; ++i) levelNums.push_back(i);
6098
6099 constexpr auto fmt = R"(
6100 <compatibility-matrix %s type="framework" level="%s">
6101 <hal format="hidl">
6102 <name>android.system.foo</name>
6103 <version>%zu.0</version>
6104 <interface>
6105 <name>IFoo</name>
6106 <instance>default</instance>
6107 </interface>
6108 </hal>
6109 <kernel version="%zu.0.0">
6110 <config>
6111 <key>CONFIG_%zu</key>
6112 <value type="tristate">y</value>
6113 </config>
6114 </kernel>
6115 </compatibility-matrix>
6116 )";
6117 std::string error;
6118 std::vector<CompatibilityMatrix> matrices;
6119 for (size_t levelNum : levelNums) {
6120 auto levelStr = android::vintf::to_string((Level)levelNum);
6121 auto xml = StringPrintf(fmt, kMetaVersionStr.c_str(), levelStr.c_str(), levelNum, levelNum,
6122 levelNum);
6123 CompatibilityMatrix& matrix = matrices.emplace_back();
6124 ASSERT_TRUE(fromXml(&matrix, xml, &error)) << error;
6125 }
6126 ASSERT_FALSE(matrices.empty());
6127
6128 auto combined = combine(Level(deviceLevelNum), Level(kernelLevelNum), &matrices, &error);
6129 ASSERT_NE(nullptr, combined);
6130 auto combinedXml = toXml(*combined);
6131
6132 // Check that HALs are combined correctly.
6133 for (size_t i = kMinLevel; i < deviceLevelNum; ++i)
6134 EXPECT_THAT(combinedXml, Not(HasSubstr(StringPrintf("<version>%zu.0</version>", i))));
6135
6136 for (size_t i = deviceLevelNum; i <= kMaxLevel; ++i)
6137 EXPECT_THAT(combinedXml, HasSubstr(StringPrintf("<version>%zu.0</version>", i)));
6138
6139 // Check that kernels are combined correctly. <kernel> tags from
6140 // matrices with level >= min(kernelLevel, deviceLevel) are added.
6141 // The "level" tag on <kernel> must also be set properly so that old kernel requirements from
6142 // deviceLevel <= x < kernelLevel won't be used.
6143 auto hasKernelFrom = std::min(kernelLevelNum, deviceLevelNum);
6144 for (size_t i = kMinLevel; i < hasKernelFrom; ++i) {
6145 EXPECT_THAT(combinedXml,
6146 Not(HasSubstr(StringPrintf(R"(<kernel version="%zu.0.0" level="%zu")", i, i))));
6147 EXPECT_THAT(combinedXml, Not(HasSubstr(StringPrintf("CONFIG_%zu", i))));
6148 }
6149
6150 for (size_t i = hasKernelFrom; i <= kMaxLevel; ++i) {
6151 EXPECT_THAT(combinedXml,
6152 HasSubstr(StringPrintf(R"(<kernel version="%zu.0.0" level="%zu")", i, i)));
6153 EXPECT_THAT(combinedXml, HasSubstr(StringPrintf("CONFIG_%zu", i)));
6154 }
6155
6156 if (::testing::Test::HasFailure()) ADD_FAILURE() << "Resulting matrix is \n" << combinedXml;
6157 }
6158
6159 INSTANTIATE_TEST_CASE_P(
6160 FrameworkCompatibilityMatrixCombineTest, FcmCombineKernelTest,
6161 Combine(Range(FcmCombineKernelTest::kMinLevel, FcmCombineKernelTest::kMaxLevel + 1),
6162 Range(FcmCombineKernelTest::kMinLevel, FcmCombineKernelTest::kMaxLevel + 1)),
6163 FcmCombineKernelTest::PrintTestParams);
6164
6165 // clang-format off
6166
6167 struct DeviceCompatibilityMatrixCombineTest : public LibVintfTest {
SetUpandroid::vintf::DeviceCompatibilityMatrixCombineTest6168 virtual void SetUp() override {
6169 matrices.resize(2);
6170 matrices[0].setFileName("compatibility_matrix.1.xml");
6171 matrices[1].setFileName("compatibility_matrix.2.xml");
6172 }
6173 // Access to private methods.
combineandroid::vintf::DeviceCompatibilityMatrixCombineTest6174 std::unique_ptr<CompatibilityMatrix> combine(std::vector<CompatibilityMatrix>* theMatrices,
6175 std::string* errorPtr) {
6176 return CompatibilityMatrix::combineDeviceMatrices(theMatrices, errorPtr);
6177 }
6178
6179 std::vector<CompatibilityMatrix> matrices;
6180 std::string error;
6181 };
6182
TEST_F(DeviceCompatibilityMatrixCombineTest,Success)6183 TEST_F(DeviceCompatibilityMatrixCombineTest, Success) {
6184 std::string head{"<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"};
6185 std::string tail{"</compatibility-matrix>\n"};
6186 std::string halFoo{
6187 " <hal format=\"hidl\">\n"
6188 " <name>android.hardware.foo</name>\n"
6189 " <version>1.0</version>\n"
6190 " <interface>\n"
6191 " <name>IFoo</name>\n"
6192 " <instance>default</instance>\n"
6193 " </interface>\n"
6194 " </hal>\n"};
6195 std::string halBar{
6196 " <hal format=\"hidl\">\n"
6197 " <name>android.hardware.bar</name>\n"
6198 " <version>1.0</version>\n"
6199 " <interface>\n"
6200 " <name>IBar</name>\n"
6201 " <instance>default</instance>\n"
6202 " </interface>\n"
6203 " </hal>\n"};
6204 ASSERT_TRUE(fromXml(&matrices[0], head + halFoo + tail, &error))
6205 << error;
6206 ASSERT_TRUE(fromXml(&matrices[1], head + halBar + tail, &error))
6207 << error;
6208
6209 auto combined = combine(&matrices, &error);
6210 ASSERT_NE(nullptr, combined) << error;
6211 EXPECT_EQ("", error);
6212 auto combinedXml = toXml(*combined);
6213 EXPECT_IN(halFoo, combinedXml);
6214 EXPECT_IN(halBar, combinedXml);
6215 }
6216
TEST_F(DeviceCompatibilityMatrixCombineTest,ConflictVendorNdk)6217 TEST_F(DeviceCompatibilityMatrixCombineTest, ConflictVendorNdk) {
6218 std::string vendorNdkP{
6219 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
6220 " <vendor-ndk>\n"
6221 " <version>P</version>\n"
6222 " </vendor-ndk>\n"
6223 "</compatibility-matrix>\n"};
6224 std::string vendorNdkQ{
6225 "<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"
6226 " <vendor-ndk>\n"
6227 " <version>Q</version>\n"
6228 " </vendor-ndk>\n"
6229 "</compatibility-matrix>\n"};
6230 ASSERT_TRUE(fromXml(&matrices[0], vendorNdkP, &error)) << error;
6231 ASSERT_TRUE(fromXml(&matrices[1], vendorNdkQ, &error)) << error;
6232
6233 auto combined = combine(&matrices, &error);
6234 ASSERT_EQ(nullptr, combined) << toXml(*combined);
6235 EXPECT_IN("<vendor-ndk> is already defined", error);
6236 }
6237
TEST_F(DeviceCompatibilityMatrixCombineTest,AidlAndHidlNames)6238 TEST_F(DeviceCompatibilityMatrixCombineTest, AidlAndHidlNames) {
6239 std::string head{"<compatibility-matrix " + kMetaVersionStr + " type=\"device\">\n"};
6240 std::string tail{"</compatibility-matrix>\n"};
6241 std::string aidl =
6242 " <hal format=\"aidl\">\n"
6243 " <name>android.system.foo</name>\n"
6244 " <interface>\n"
6245 " <name>IFoo</name>\n"
6246 " <instance>default</instance>\n"
6247 " </interface>\n"
6248 " </hal>\n";
6249 std::string hidl =
6250 " <hal format=\"hidl\">\n"
6251 " <name>android.system.foo</name>\n"
6252 " <version>1.0</version>\n"
6253 " <interface>\n"
6254 " <name>IFoo</name>\n"
6255 " <instance>default</instance>\n"
6256 " </interface>\n"
6257 " </hal>\n";
6258 ASSERT_TRUE(fromXml(&matrices[0], head + aidl + tail, &error))
6259 << error;
6260 ASSERT_TRUE(fromXml(&matrices[1], head + hidl + tail, &error))
6261 << error;
6262
6263 auto combined = combine(&matrices, &error);
6264 ASSERT_NE(nullptr, combined) << error;
6265
6266 auto combinedXml = toXml(*combined);
6267 EXPECT_IN(aidl, combinedXml);
6268 EXPECT_IN(hidl, combinedXml);
6269 }
6270
6271 // clang-format on
6272
TEST(FileSystem,PathReplacingFileSystem)6273 TEST(FileSystem, PathReplacingFileSystem) {
6274 std::map<std::string, std::string> files = {
6275 {"a/a", "a/a"}, {"aa/aa", "aa/aa"}, {"b/b", "b/b"}, {"bb/bb", "bb/bb"}, {"x/y/z", "x/y/z"},
6276 };
6277 std::map<std::string, std::string> replacements = {
6278 {"a", "b"},
6279 {"aa", "bb"},
6280 {"x", "a"},
6281 {"x/y", "b"},
6282 };
6283 details::PathReplacingFileSystem fs(std::make_unique<InMemoryFileSystem>(files), replacements);
6284
6285 std::string fetched;
6286 std::vector<std::string> list;
6287
6288 // no replace
6289 ASSERT_EQ(OK, fs.fetch("b/b", &fetched, nullptr));
6290 ASSERT_EQ("b/b", fetched);
6291
6292 // replace
6293 ASSERT_EQ(OK, fs.fetch("a/b", &fetched, nullptr));
6294 ASSERT_EQ("b/b", fetched);
6295 ASSERT_EQ(OK, fs.fetch("aa/bb", &fetched, nullptr));
6296 ASSERT_EQ("bb/bb", fetched);
6297
6298 // "a" doesn't match with "aa"
6299 ASSERT_EQ(OK, fs.listFiles("aa/", &list, nullptr));
6300 ASSERT_EQ(std::vector{"bb"s}, list);
6301
6302 // do not replace recursively
6303 ASSERT_EQ(OK, fs.fetch("x/a", &fetched, nullptr));
6304 ASSERT_EQ("a/a", fetched);
6305
6306 // longer match wins.
6307 ASSERT_EQ(OK, fs.fetch("x/y/b", &fetched, nullptr));
6308 ASSERT_EQ("b/b", fetched);
6309
6310 ASSERT_EQ(OK, fs.fetch("x/a", &fetched, nullptr));
6311 ASSERT_EQ("a/a", fetched);
6312 }
6313
6314 } // namespace vintf
6315 } // namespace android
6316
main(int argc,char ** argv)6317 int main(int argc, char **argv) {
6318 ::testing::InitGoogleMock(&argc, argv);
6319 return RUN_ALL_TESTS();
6320 }
6321