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