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