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
22 #include <vintf/CompatibilityMatrix.h>
23 #include <vintf/KernelConfigParser.h>
24 #include <vintf/VintfObject.h>
25 #include <vintf/parse_string.h>
26 #include <vintf/parse_xml.h>
27
28 #include <android-base/logging.h>
29 #include <android-base/parseint.h>
30 #include <android-base/strings.h>
31 #include <gtest/gtest.h>
32
33 namespace android {
34 namespace vintf {
35
36 extern XmlConverter<Version>& gVersionConverter;
37 extern XmlConverter<ManifestHal>& gManifestHalConverter;
38 extern XmlConverter<MatrixHal>& gMatrixHalConverter;
39 extern XmlConverter<KernelConfigTypedValue>& gKernelConfigTypedValueConverter;
40 extern XmlConverter<HalManifest>& gHalManifestConverter;
41 extern XmlConverter<CompatibilityMatrix>& gCompatibilityMatrixConverter;
42
In(const std::string & sub,const std::string & str)43 static bool In(const std::string& sub, const std::string& str) {
44 return str.find(sub) != std::string::npos;
45 }
46 #define EXPECT_IN(sub, str) EXPECT_TRUE(In((sub), (str))) << (str);
47
48 #ifndef LIBVINTF_TARGET
49 #define EXPECT_CONTAINS(str, sub) EXPECT_IN(sub, str);
50 #endif
51
52 struct LibVintfTest : public ::testing::Test {
53 public:
SetUpandroid::vintf::LibVintfTest54 virtual void SetUp() override {
55 }
TearDownandroid::vintf::LibVintfTest56 virtual void TearDown() override {
57 }
addandroid::vintf::LibVintfTest58 bool add(CompatibilityMatrix &cm, MatrixHal &&hal) {
59 return cm.add(std::move(hal));
60 }
addandroid::vintf::LibVintfTest61 bool add(CompatibilityMatrix &cm, MatrixKernel &&kernel) {
62 return cm.add(std::move(kernel));
63 }
addandroid::vintf::LibVintfTest64 bool add(HalManifest &vm, ManifestHal &&hal) {
65 return vm.add(std::move(hal));
66 }
addXmlFileandroid::vintf::LibVintfTest67 void addXmlFile(CompatibilityMatrix& cm, std::string name, VersionRange range) {
68 MatrixXmlFile f;
69 f.mName = name;
70 f.mVersionRange = range;
71 f.mFormat = XmlSchemaFormat::DTD;
72 f.mOptional = true;
73 cm.addXmlFile(std::move(f));
74 }
setandroid::vintf::LibVintfTest75 void set(CompatibilityMatrix &cm, Sepolicy &&sepolicy) {
76 cm.framework.mSepolicy = sepolicy;
77 }
setandroid::vintf::LibVintfTest78 void set(CompatibilityMatrix &cm, SchemaType type) {
79 cm.mType = type;
80 }
setandroid::vintf::LibVintfTest81 void set(CompatibilityMatrix &cm, VndkVersionRange &&range, std::set<std::string> &&libs) {
82 cm.device.mVndk.mVersionRange = range;
83 cm.device.mVndk.mLibraries = libs;
84 }
setAvbandroid::vintf::LibVintfTest85 void setAvb(RuntimeInfo &ki, Version vbmeta, Version boot) {
86 ki.mBootVbmetaAvbVersion = vbmeta;
87 ki.mBootAvbVersion = boot;
88 }
setAvbandroid::vintf::LibVintfTest89 void setAvb(CompatibilityMatrix &cm, Version &&avbVersion) {
90 cm.framework.mAvbMetaVersion = avbVersion;
91 }
getAvbandroid::vintf::LibVintfTest92 Version getAvb(CompatibilityMatrix &cm) {
93 return cm.framework.mAvbMetaVersion;
94 }
getAnyHalandroid::vintf::LibVintfTest95 const ManifestHal *getAnyHal(HalManifest &vm, const std::string &name) {
96 return vm.getAnyHal(name);
97 }
getAnyHalandroid::vintf::LibVintfTest98 MatrixHal *getAnyHal(CompatibilityMatrix &cm, const std::string &name) {
99 return cm.getAnyHal(name);
100 }
getHalsandroid::vintf::LibVintfTest101 ConstMultiMapValueIterable<std::string, ManifestHal> getHals(HalManifest &vm) {
102 return vm.getHals();
103 }
isValidandroid::vintf::LibVintfTest104 bool isValid(const ManifestHal &mh) {
105 return mh.isValid();
106 }
getKernelsandroid::vintf::LibVintfTest107 std::vector<MatrixKernel>& getKernels(CompatibilityMatrix& cm) { return cm.framework.mKernels; }
addAllHalsAsOptionalandroid::vintf::LibVintfTest108 bool addAllHalsAsOptional(CompatibilityMatrix* cm1, CompatibilityMatrix* cm2, std::string* e) {
109 return cm1->addAllHalsAsOptional(cm2, e);
110 }
addAllXmlFilesAsOptionalandroid::vintf::LibVintfTest111 bool addAllXmlFilesAsOptional(CompatibilityMatrix* cm1, CompatibilityMatrix* cm2,
112 std::string* e) {
113 return cm1->addAllXmlFilesAsOptional(cm2, e);
114 }
checkUnusedHalsandroid::vintf::LibVintfTest115 std::set<std::string> checkUnusedHals(const HalManifest& m, const CompatibilityMatrix& cm) {
116 return m.checkUnusedHals(cm);
117 }
118
testHalInterfacesandroid::vintf::LibVintfTest119 std::map<std::string, HalInterface> testHalInterfaces() {
120 HalInterface intf("IFoo", {"default"});
121 std::map<std::string, HalInterface> map;
122 map[intf.name()] = intf;
123 return map;
124 }
125
testDeviceManifestandroid::vintf::LibVintfTest126 HalManifest testDeviceManifest() {
127 HalManifest vm;
128 vm.mType = SchemaType::DEVICE;
129 vm.device.mSepolicyVersion = {25, 0};
130 vm.add(ManifestHal{HalFormat::HIDL,
131 "android.hardware.camera",
132 {Version(2, 0)},
133 {Transport::HWBINDER, Arch::ARCH_EMPTY},
134 {{"ICamera", {"ICamera", {"legacy/0", "default"}}},
135 {"IBetterCamera", {"IBetterCamera", {"camera"}}}}});
136 vm.add(ManifestHal{HalFormat::HIDL,
137 "android.hardware.nfc",
138 {Version(1, 0)},
139 {Transport::PASSTHROUGH, Arch::ARCH_32_64},
140 {{"INfc", {"INfc", {"default"}}}}});
141
142 return vm;
143 }
testDeviceManifestWithXmlFileandroid::vintf::LibVintfTest144 HalManifest testDeviceManifestWithXmlFile() {
145 HalManifest vm = testDeviceManifest();
146 ManifestXmlFile xmlFile;
147 xmlFile.mName = "media_profile";
148 xmlFile.mVersion = {1, 0};
149 vm.addXmlFile(std::move(xmlFile));
150 return vm;
151 }
testFrameworkManfiestandroid::vintf::LibVintfTest152 HalManifest testFrameworkManfiest() {
153 HalManifest vm;
154 vm.mType = SchemaType::FRAMEWORK;
155 vm.add(ManifestHal{HalFormat::HIDL,
156 "android.hidl.manager",
157 {Version(1, 0)},
158 {Transport::HWBINDER, Arch::ARCH_EMPTY},
159 {
160 {"IServiceManager", {"IServiceManager", {"default"}}},
161 }});
162 Vndk vndk2505;
163 vndk2505.mVersionRange = {25, 0, 5};
164 vndk2505.mLibraries = { "libjpeg.so", "libbase.so" };
165 Vndk vndk2513;
166 vndk2513.mVersionRange = {25, 1, 3};
167 vndk2513.mLibraries = { "libjpeg.so", "libbase.so", "libtinyxml2.so" };
168 vm.framework.mVndks = { std::move(vndk2505), std::move(vndk2513) };
169
170 return vm;
171 }
testRuntimeInfoandroid::vintf::LibVintfTest172 RuntimeInfo testRuntimeInfo() {
173 RuntimeInfo info;
174 info.mOsName = "Linux";
175 info.mNodeName = "localhost";
176 info.mOsRelease = "3.18.31-g936f9a479d0f";
177 info.mKernelVersion = {3, 18, 31};
178 info.mOsVersion = "#4 SMP PREEMPT Wed Feb 1 18:10:52 PST 2017";
179 info.mHardwareId = "aarch64";
180 info.mKernelSepolicyVersion = 30;
181 info.mKernelConfigs = {
182 {"CONFIG_64BIT", "y"},
183 {"CONFIG_ANDROID_BINDER_DEVICES", "\"binder,hwbinder\""},
184 {"CONFIG_ARCH_MMAP_RND_BITS", "24"},
185 {"CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES", "\"\""},
186 {"CONFIG_ILLEGAL_POINTER_VALUE", "0xdead000000000000"}
187 };
188 setAvb(info, {2, 1}, {2, 1});
189 return info;
190 }
191 };
192
TEST_F(LibVintfTest,ArchOperatorOr)193 TEST_F(LibVintfTest, ArchOperatorOr) {
194 Arch a = Arch::ARCH_EMPTY;
195 a |= Arch::ARCH_32;
196 EXPECT_EQ(Arch::ARCH_32, a);
197
198 a |= Arch::ARCH_64;
199 EXPECT_EQ(Arch::ARCH_32_64, a);
200
201 a = Arch::ARCH_EMPTY;
202 a |= Arch::ARCH_64;
203 EXPECT_EQ(Arch::ARCH_64, a);
204 }
205
TEST_F(LibVintfTest,Stringify)206 TEST_F(LibVintfTest, Stringify) {
207 HalManifest vm = testDeviceManifest();
208 EXPECT_EQ(dump(vm), "hidl/android.hardware.camera/hwbinder/2.0:"
209 "hidl/android.hardware.nfc/passthrough32+64/1.0");
210
211 EXPECT_EQ(to_string(HalFormat::HIDL), "hidl");
212 EXPECT_EQ(to_string(HalFormat::NATIVE), "native");
213
214 VersionRange v(1, 2, 3);
215 EXPECT_EQ(to_string(v), "1.2-3");
216 VersionRange v2;
217 EXPECT_TRUE(parse("1.2-3", &v2));
218 EXPECT_EQ(v, v2);
219 }
220
TEST_F(LibVintfTest,GetTransport)221 TEST_F(LibVintfTest, GetTransport) {
222 HalManifest vm = testDeviceManifest();
223 EXPECT_EQ(Transport::HWBINDER, vm.getTransport("android.hardware.camera",
224 {2, 0}, "ICamera", "default"));
225 }
226
TEST_F(LibVintfTest,FutureManifestCompatible)227 TEST_F(LibVintfTest, FutureManifestCompatible) {
228 HalManifest expectedManifest;
229 expectedManifest.add(ManifestHal{HalFormat::HIDL,
230 "android.hardware.foo",
231 {Version(1, 0)},
232 {Transport::HWBINDER, Arch::ARCH_EMPTY},
233 {
234 {"IFoo", {"IFoo", {"default"}}},
235 }});
236 std::string manifestXml =
237 "<manifest version=\"1.0\" type=\"device\" might_add=\"true\">\n"
238 " <hal format=\"hidl\" attribuet_might_be_added=\"value\">\n"
239 " <name>android.hardware.foo</name>\n"
240 " <transport>hwbinder</transport>\n"
241 " <version>1.0</version>\n"
242 " <interface>\n"
243 " <name>IFoo</name>\n"
244 " <instance>default</instance>\n"
245 " </interface>\n"
246 " </hal>\n"
247 " <tag_might_be_added/>\n"
248 "</manifest>\n";
249 HalManifest manifest;
250 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
251 EXPECT_EQ(expectedManifest, manifest);
252 }
253
TEST_F(LibVintfTest,HalManifestConverter)254 TEST_F(LibVintfTest, HalManifestConverter) {
255 HalManifest vm = testDeviceManifest();
256 std::string xml =
257 gHalManifestConverter(vm, SerializeFlag::HALS_NO_FQNAME & SerializeFlag::SEPOLICY_ONLY);
258 EXPECT_EQ(xml,
259 "<manifest version=\"1.0\" type=\"device\">\n"
260 " <hal format=\"hidl\">\n"
261 " <name>android.hardware.camera</name>\n"
262 " <transport>hwbinder</transport>\n"
263 " <version>2.0</version>\n"
264 " <interface>\n"
265 " <name>IBetterCamera</name>\n"
266 " <instance>camera</instance>\n"
267 " </interface>\n"
268 " <interface>\n"
269 " <name>ICamera</name>\n"
270 " <instance>default</instance>\n"
271 " <instance>legacy/0</instance>\n"
272 " </interface>\n"
273 " </hal>\n"
274 " <hal format=\"hidl\">\n"
275 " <name>android.hardware.nfc</name>\n"
276 " <transport arch=\"32+64\">passthrough</transport>\n"
277 " <version>1.0</version>\n"
278 " <interface>\n"
279 " <name>INfc</name>\n"
280 " <instance>default</instance>\n"
281 " </interface>\n"
282 " </hal>\n"
283 " <sepolicy>\n"
284 " <version>25.0</version>\n"
285 " </sepolicy>\n"
286 "</manifest>\n");
287 HalManifest vm2;
288 EXPECT_TRUE(gHalManifestConverter(&vm2, xml));
289 EXPECT_EQ(vm, vm2);
290 }
291
TEST_F(LibVintfTest,HalManifestConverterFramework)292 TEST_F(LibVintfTest, HalManifestConverterFramework) {
293 HalManifest vm = testFrameworkManfiest();
294 std::string xml =
295 gHalManifestConverter(vm, SerializeFlag::HALS_NO_FQNAME & SerializeFlag::VNDK_ONLY);
296 EXPECT_EQ(xml,
297 "<manifest version=\"1.0\" type=\"framework\">\n"
298 " <hal format=\"hidl\">\n"
299 " <name>android.hidl.manager</name>\n"
300 " <transport>hwbinder</transport>\n"
301 " <version>1.0</version>\n"
302 " <interface>\n"
303 " <name>IServiceManager</name>\n"
304 " <instance>default</instance>\n"
305 " </interface>\n"
306 " </hal>\n"
307 " <vndk>\n"
308 " <version>25.0.5</version>\n"
309 " <library>libbase.so</library>\n"
310 " <library>libjpeg.so</library>\n"
311 " </vndk>\n"
312 " <vndk>\n"
313 " <version>25.1.3</version>\n"
314 " <library>libbase.so</library>\n"
315 " <library>libjpeg.so</library>\n"
316 " <library>libtinyxml2.so</library>\n"
317 " </vndk>\n"
318 "</manifest>\n");
319 HalManifest vm2;
320 EXPECT_TRUE(gHalManifestConverter(&vm2, xml));
321 EXPECT_EQ(vm, vm2);
322 }
323
TEST_F(LibVintfTest,HalManifestOptional)324 TEST_F(LibVintfTest, HalManifestOptional) {
325 HalManifest vm;
326 EXPECT_TRUE(gHalManifestConverter(&vm,
327 "<manifest version=\"1.0\" type=\"device\"></manifest>"));
328 EXPECT_TRUE(gHalManifestConverter(&vm,
329 "<manifest version=\"1.0\" type=\"device\">"
330 " <hal>"
331 " <name>android.hidl.manager</name>"
332 " <transport>hwbinder</transport>"
333 " <version>1.0</version>"
334 " </hal>"
335 "</manifest>"));
336 EXPECT_FALSE(gHalManifestConverter(&vm,
337 "<manifest version=\"1.0\" type=\"device\">"
338 " <hal>"
339 " <name>android.hidl.manager</name>"
340 " <version>1.0</version>"
341 " </hal>"
342 "</manifest>"));
343 }
344
TEST_F(LibVintfTest,HalManifestNative)345 TEST_F(LibVintfTest, HalManifestNative) {
346 HalManifest vm;
347 EXPECT_TRUE(gHalManifestConverter(&vm,
348 "<manifest version=\"1.0\" type=\"device\">"
349 " <hal format=\"native\">"
350 " <name>foo</name>"
351 " <version>1.0</version>"
352 " </hal>"
353 "</manifest>"))
354 << gHalManifestConverter.lastError();
355 EXPECT_FALSE(gHalManifestConverter(&vm,
356 "<manifest version=\"1.0\" type=\"device\">"
357 " <hal format=\"native\">"
358 " <name>foo</name>"
359 " <version>1.0</version>"
360 " <transport>hwbinder</transport>"
361 " </hal>"
362 "</manifest>"));
363 EXPECT_TRUE(gHalManifestConverter.lastError().find(
364 "Native HAL 'foo' should not have <transport> defined") != std::string::npos);
365 }
366
TEST_F(LibVintfTest,HalManifestDuplicate)367 TEST_F(LibVintfTest, HalManifestDuplicate) {
368 HalManifest vm;
369 EXPECT_FALSE(gHalManifestConverter(&vm,
370 "<manifest version=\"1.0\" type=\"device\">"
371 " <hal>"
372 " <name>android.hidl.manager</name>"
373 " <transport>hwbinder</transport>"
374 " <version>1.0</version>"
375 " <version>1.1</version>"
376 " </hal>"
377 "</manifest>"))
378 << "Should not allow duplicated major version in <hal>";
379 EXPECT_FALSE(gHalManifestConverter(&vm,
380 "<manifest version=\"1.0\" type=\"device\">"
381 " <hal>"
382 " <name>android.hidl.manager</name>"
383 " <transport>hwbinder</transport>"
384 " <version>1.0</version>"
385 " </hal>"
386 " <hal>"
387 " <name>android.hidl.manager</name>"
388 " <transport arch=\"32+64\">passthrough</transport>"
389 " <version>1.1</version>"
390 " </hal>"
391 "</manifest>"))
392 << "Should not allow duplicated major version across <hal>";
393 }
394
TEST_F(LibVintfTest,HalManifestGetTransport)395 TEST_F(LibVintfTest, HalManifestGetTransport) {
396 HalManifest vm;
397 EXPECT_TRUE(gHalManifestConverter(&vm,
398 "<manifest version=\"1.0\" type=\"device\">"
399 " <hal>"
400 " <name>android.hidl.manager</name>"
401 " <transport>hwbinder</transport>"
402 " <version>1.0</version>"
403 " <interface>"
404 " <name>IServiceManager</name>"
405 " <instance>default</instance>"
406 " </interface>"
407 " </hal>"
408 " <hal>"
409 " <name>android.hidl.manager</name>"
410 " <transport arch=\"32+64\">passthrough</transport>"
411 " <version>2.1</version>"
412 " <interface>"
413 " <name>IServiceManager</name>"
414 " <instance>default</instance>"
415 " </interface>"
416 " </hal>"
417 "</manifest>"));
418 EXPECT_EQ(Transport::PASSTHROUGH,
419 vm.getTransport("android.hidl.manager", {2, 1}, "IServiceManager", "default"));
420 EXPECT_EQ(Transport::PASSTHROUGH,
421 vm.getTransport("android.hidl.manager", {2, 0}, "IServiceManager", "default"));
422 EXPECT_EQ(Transport::EMPTY,
423 vm.getTransport("android.hidl.manager", {2, 2}, "IServiceManager", "default"));
424 EXPECT_EQ(Transport::HWBINDER,
425 vm.getTransport("android.hidl.manager", {1, 0}, "IServiceManager", "default"));
426 }
427
TEST_F(LibVintfTest,HalManifestInstances)428 TEST_F(LibVintfTest, HalManifestInstances) {
429 HalManifest vm = testDeviceManifest();
430 EXPECT_EQ(vm.getInstances("android.hardware.camera", {2, 0}, "ICamera"),
431 std::set<std::string>({"default", "legacy/0"}));
432 EXPECT_EQ(vm.getInstances("android.hardware.camera", {2, 0}, "IBetterCamera"),
433 std::set<std::string>({"camera"}));
434 EXPECT_EQ(vm.getInstances("android.hardware.camera", {2, 0}, "INotExist"),
435 std::set<std::string>({}));
436 EXPECT_EQ(vm.getInstances("android.hardware.nfc", {1, 0}, "INfc"),
437 std::set<std::string>({"default"}));
438
439 EXPECT_TRUE(vm.hasInstance("android.hardware.camera", {2, 0}, "ICamera", "default"));
440 EXPECT_TRUE(vm.hasInstance("android.hardware.camera", {2, 0}, "ICamera", "legacy/0"));
441 EXPECT_TRUE(vm.hasInstance("android.hardware.camera", {2, 0}, "IBetterCamera", "camera"));
442 EXPECT_TRUE(vm.hasInstance("android.hardware.nfc", {1, 0}, "INfc", "default"));
443
444 EXPECT_FALSE(vm.hasInstance("android.hardware.camera", {2, 0}, "INotExist", "default"));
445 EXPECT_FALSE(vm.hasInstance("android.hardware.camera", {2, 0}, "ICamera", "notexist"));
446 EXPECT_FALSE(vm.hasInstance("android.hardware.camera", {2, 0}, "IBetterCamera", "default"));
447 EXPECT_FALSE(vm.hasInstance("android.hardware.camera", {2, 0}, "INotExist", "notexist"));
448 EXPECT_FALSE(vm.hasInstance("android.hardware.nfc", {1, 0}, "INfc", "notexist"));
449 }
450
TEST_F(LibVintfTest,VersionConverter)451 TEST_F(LibVintfTest, VersionConverter) {
452 Version v(3, 6);
453 std::string xml = gVersionConverter(v);
454 EXPECT_EQ(xml, "<version>3.6</version>\n");
455 Version v2;
456 EXPECT_TRUE(gVersionConverter(&v2, xml));
457 EXPECT_EQ(v, v2);
458 }
459
insert(std::map<std::string,HalInterface> * map,HalInterface && intf)460 static bool insert(std::map<std::string, HalInterface>* map, HalInterface&& intf) {
461 std::string name{intf.name()};
462 return map->emplace(std::move(name), std::move(intf)).second;
463 }
464
TEST_F(LibVintfTest,MatrixHalConverter)465 TEST_F(LibVintfTest, MatrixHalConverter) {
466 MatrixHal mh{HalFormat::NATIVE, "android.hardware.camera",
467 {{VersionRange(1,2,3), VersionRange(4,5,6)}},
468 false /* optional */, {}};
469 EXPECT_TRUE(insert(&mh.interfaces, {"IBetterCamera", {"default", "great"}}));
470 EXPECT_TRUE(insert(&mh.interfaces, {"ICamera", {"default"}}));
471 std::string xml = gMatrixHalConverter(mh);
472 EXPECT_EQ(xml,
473 "<hal format=\"native\" optional=\"false\">\n"
474 " <name>android.hardware.camera</name>\n"
475 " <version>1.2-3</version>\n"
476 " <version>4.5-6</version>\n"
477 " <interface>\n"
478 " <name>IBetterCamera</name>\n"
479 " <instance>default</instance>\n"
480 " <instance>great</instance>\n"
481 " </interface>\n"
482 " <interface>\n"
483 " <name>ICamera</name>\n"
484 " <instance>default</instance>\n"
485 " </interface>\n"
486 "</hal>\n");
487 MatrixHal mh2;
488 EXPECT_TRUE(gMatrixHalConverter(&mh2, xml));
489 EXPECT_EQ(mh, mh2);
490 }
491
TEST_F(LibVintfTest,KernelConfigTypedValueConverter)492 TEST_F(LibVintfTest, KernelConfigTypedValueConverter) {
493
494 KernelConfigTypedValue converted;
495
496 auto testOne = [] (const KernelConfigTypedValue &original,
497 const std::string &expectXml) {
498 std::string xml;
499 KernelConfigTypedValue converted;
500 xml = gKernelConfigTypedValueConverter(original);
501 EXPECT_EQ(xml, expectXml);
502 EXPECT_TRUE(gKernelConfigTypedValueConverter(&converted, xml));
503 EXPECT_EQ(original, converted);
504 };
505
506 auto testParse = [] (const KernelConfigTypedValue &original,
507 const std::string &xml) {
508 KernelConfigTypedValue converted;
509 EXPECT_TRUE(gKernelConfigTypedValueConverter(&converted, xml));
510 EXPECT_EQ(original, converted);
511 };
512
513 testOne(KernelConfigTypedValue("stringvalue"),
514 "<value type=\"string\">stringvalue</value>\n");
515 testOne(KernelConfigTypedValue(""),
516 "<value type=\"string\"></value>\n");
517
518 testOne(KernelConfigTypedValue(Tristate::YES),
519 "<value type=\"tristate\">y</value>\n");
520 testOne(KernelConfigTypedValue(Tristate::NO),
521 "<value type=\"tristate\">n</value>\n");
522 testOne(KernelConfigTypedValue(Tristate::MODULE),
523 "<value type=\"tristate\">m</value>\n");
524 EXPECT_FALSE(gKernelConfigTypedValueConverter(&converted,
525 "<value type=\"tristate\">q</value>\n"));
526
527 testOne(KernelConfigTypedValue(KernelConfigRangeValue{4, 20}),
528 "<value type=\"range\">4-20</value>\n");
529 testOne(KernelConfigTypedValue(KernelConfigRangeValue{0, UINT64_MAX}),
530 "<value type=\"range\">0-18446744073709551615</value>\n");
531 testParse(KernelConfigTypedValue(KernelConfigRangeValue{0, UINT64_MAX}),
532 "<value type=\"range\">0x0-0xffffffffffffffff</value>\n");
533
534 EXPECT_FALSE(gKernelConfigTypedValueConverter(&converted,
535 "<value type=\"int\">-18446744073709551616</value>\n"));
536
537 testOne(KernelConfigTypedValue(INT64_MIN),
538 "<value type=\"int\">-9223372036854775808</value>\n");
539 testParse(KernelConfigTypedValue(INT64_MIN),
540 "<value type=\"int\">0x8000000000000000</value>\n");
541 testParse(KernelConfigTypedValue(INT64_MIN),
542 "<value type=\"int\">-0X8000000000000000</value>\n");
543
544 testParse(KernelConfigTypedValue(INT64_MIN + 1),
545 "<value type=\"int\">-0X7FFFFFFFFFFFFFFF</value>\n");
546
547 testParse(KernelConfigTypedValue(-0x50),
548 "<value type=\"int\">-0x50</value>\n");
549
550 testOne(KernelConfigTypedValue(0),
551 "<value type=\"int\">0</value>\n");
552
553 // Truncation for underflow.
554 testParse(KernelConfigTypedValue(1),
555 "<value type=\"int\">-0xffffffffffffffff</value>\n");
556 testParse(KernelConfigTypedValue(1),
557 "<value type=\"int\">-18446744073709551615</value>\n");
558
559 testOne(KernelConfigTypedValue(INT64_MAX),
560 "<value type=\"int\">9223372036854775807</value>\n");
561 testParse(KernelConfigTypedValue(INT64_MAX),
562 "<value type=\"int\">0x7FFFFFFFFFFFFFFF</value>\n");
563 // Truncation for underflow.
564 testParse(KernelConfigTypedValue(INT64_MAX),
565 "<value type=\"int\">-9223372036854775809</value>\n");
566
567 testParse(KernelConfigTypedValue(-1),
568 "<value type=\"int\">18446744073709551615</value>\n");
569 testParse(KernelConfigTypedValue(-1),
570 "<value type=\"int\">0xffffffffffffffff</value>\n");
571
572 EXPECT_FALSE(gKernelConfigTypedValueConverter(&converted,
573 "<value type=\"int\">18446744073709551616</value>\n"));
574 }
575
TEST_F(LibVintfTest,CompatibilityMatrixConverter)576 TEST_F(LibVintfTest, CompatibilityMatrixConverter) {
577 CompatibilityMatrix cm;
578 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE, "android.hardware.camera",
579 {{VersionRange(1,2,3), VersionRange(4,5,6)}},
580 false /* optional */, testHalInterfaces()}));
581 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE, "android.hardware.nfc",
582 {{VersionRange(4,5,6), VersionRange(10,11,12)}},
583 true /* optional */, testHalInterfaces()}));
584 EXPECT_TRUE(add(cm, MatrixKernel{KernelVersion(3, 18, 22),
585 {KernelConfig{"CONFIG_FOO", Tristate::YES}, KernelConfig{"CONFIG_BAR", "stringvalue"}}}));
586 EXPECT_TRUE(add(cm, MatrixKernel{KernelVersion(4, 4, 1),
587 {KernelConfig{"CONFIG_BAZ", 20}, KernelConfig{"CONFIG_BAR", KernelConfigRangeValue{3, 5} }}}));
588 set(cm, Sepolicy(30, {{25, 0}, {26, 0, 3}}));
589 setAvb(cm, Version{2, 1});
590 std::string xml = gCompatibilityMatrixConverter(cm);
591 EXPECT_EQ(xml,
592 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
593 " <hal format=\"native\" optional=\"false\">\n"
594 " <name>android.hardware.camera</name>\n"
595 " <version>1.2-3</version>\n"
596 " <version>4.5-6</version>\n"
597 " <interface>\n"
598 " <name>IFoo</name>\n"
599 " <instance>default</instance>\n"
600 " </interface>\n"
601 " </hal>\n"
602 " <hal format=\"native\" optional=\"true\">\n"
603 " <name>android.hardware.nfc</name>\n"
604 " <version>4.5-6</version>\n"
605 " <version>10.11-12</version>\n"
606 " <interface>\n"
607 " <name>IFoo</name>\n"
608 " <instance>default</instance>\n"
609 " </interface>\n"
610 " </hal>\n"
611 " <kernel version=\"3.18.22\">\n"
612 " <config>\n"
613 " <key>CONFIG_FOO</key>\n"
614 " <value type=\"tristate\">y</value>\n"
615 " </config>\n"
616 " <config>\n"
617 " <key>CONFIG_BAR</key>\n"
618 " <value type=\"string\">stringvalue</value>\n"
619 " </config>\n"
620 " </kernel>\n"
621 " <kernel version=\"4.4.1\">\n"
622 " <config>\n"
623 " <key>CONFIG_BAZ</key>\n"
624 " <value type=\"int\">20</value>\n"
625 " </config>\n"
626 " <config>\n"
627 " <key>CONFIG_BAR</key>\n"
628 " <value type=\"range\">3-5</value>\n"
629 " </config>\n"
630 " </kernel>\n"
631 " <sepolicy>\n"
632 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
633 " <sepolicy-version>25.0</sepolicy-version>\n"
634 " <sepolicy-version>26.0-3</sepolicy-version>\n"
635 " </sepolicy>\n"
636 " <avb>\n"
637 " <vbmeta-version>2.1</vbmeta-version>\n"
638 " </avb>\n"
639 "</compatibility-matrix>\n");
640 CompatibilityMatrix cm2;
641 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml));
642 EXPECT_EQ(cm, cm2);
643 }
644
TEST_F(LibVintfTest,DeviceCompatibilityMatrixCoverter)645 TEST_F(LibVintfTest, DeviceCompatibilityMatrixCoverter) {
646 CompatibilityMatrix cm;
647 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE, "android.hidl.manager",
648 {{VersionRange(1,0)}},
649 false /* optional */, testHalInterfaces()}));
650 set(cm, SchemaType::DEVICE);
651 set(cm, VndkVersionRange{25,0,1,5}, {"libjpeg.so", "libbase.so"});
652 std::string xml = gCompatibilityMatrixConverter(cm);
653 EXPECT_EQ(xml,
654 "<compatibility-matrix version=\"1.0\" type=\"device\">\n"
655 " <hal format=\"native\" optional=\"false\">\n"
656 " <name>android.hidl.manager</name>\n"
657 " <version>1.0</version>\n"
658 " <interface>\n"
659 " <name>IFoo</name>\n"
660 " <instance>default</instance>\n"
661 " </interface>\n"
662 " </hal>\n"
663 " <vndk>\n"
664 " <version>25.0.1-5</version>\n"
665 " <library>libbase.so</library>\n"
666 " <library>libjpeg.so</library>\n"
667 " </vndk>\n"
668 "</compatibility-matrix>\n");
669 CompatibilityMatrix cm2;
670 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml));
671 EXPECT_EQ(cm, cm2);
672 }
673
TEST_F(LibVintfTest,IsValid)674 TEST_F(LibVintfTest, IsValid) {
675 EXPECT_TRUE(isValid(ManifestHal()));
676
677 ManifestHal invalidHal{HalFormat::HIDL,
678 "android.hardware.camera",
679 {{Version(2, 0), Version(2, 1)}},
680 {Transport::PASSTHROUGH, Arch::ARCH_32_64},
681 {}};
682
683 EXPECT_FALSE(isValid(invalidHal));
684 HalManifest vm2;
685 EXPECT_FALSE(add(vm2, std::move(invalidHal)));
686 }
687
TEST_F(LibVintfTest,HalManifestGetHalNames)688 TEST_F(LibVintfTest, HalManifestGetHalNames) {
689 HalManifest vm = testDeviceManifest();
690 EXPECT_EQ(vm.getHalNames(), std::set<std::string>(
691 {"android.hardware.camera", "android.hardware.nfc"}));
692 }
693
TEST_F(LibVintfTest,HalManifestGetAllHals)694 TEST_F(LibVintfTest, HalManifestGetAllHals) {
695 HalManifest vm = testDeviceManifest();
696 EXPECT_NE(getAnyHal(vm, "android.hardware.camera"), nullptr);
697 EXPECT_EQ(getAnyHal(vm, "non-existent"), nullptr);
698
699 std::vector<std::string> arr{"android.hardware.camera", "android.hardware.nfc"};
700 size_t i = 0;
701 for (const auto &hal : getHals(vm)) {
702 EXPECT_EQ(hal.name, arr[i++]);
703 }
704 }
705
TEST_F(LibVintfTest,HalManifestGetHals)706 TEST_F(LibVintfTest, HalManifestGetHals) {
707 HalManifest vm;
708 EXPECT_TRUE(add(vm, ManifestHal{HalFormat::HIDL,
709 "android.hardware.camera",
710 {Version(1, 2)},
711 {Transport::HWBINDER, Arch::ARCH_EMPTY},
712 {{"ICamera", {"ICamera", {"legacy/0", "default"}}},
713 {"IBetterCamera", {"IBetterCamera", {"camera"}}}}}));
714 EXPECT_TRUE(add(vm, ManifestHal{HalFormat::HIDL,
715 "android.hardware.camera",
716 {Version(2, 0)},
717 {Transport::HWBINDER, Arch::ARCH_EMPTY},
718 {{"ICamera", {"ICamera", {"legacy/0", "default"}}},
719 {"IBetterCamera", {"IBetterCamera", {"camera"}}}}}));
720 EXPECT_TRUE(add(vm, ManifestHal{HalFormat::HIDL,
721 "android.hardware.nfc",
722 {Version(1, 0), Version(2, 1)},
723 {Transport::PASSTHROUGH, Arch::ARCH_32_64},
724 {{"INfc", {"INfc", {"default"}}}}}));
725 ManifestHal expectedCameraHalV1_2 =
726 ManifestHal{HalFormat::HIDL,
727 "android.hardware.camera",
728 {Version(1, 2)},
729 {Transport::HWBINDER, Arch::ARCH_EMPTY},
730 {{"ICamera", {"ICamera", {"legacy/0", "default"}}},
731 {"IBetterCamera", {"IBetterCamera", {"camera"}}}}};
732 ManifestHal expectedCameraHalV2_0 =
733 ManifestHal{HalFormat::HIDL,
734 "android.hardware.camera",
735 {Version(2, 0)},
736 {Transport::HWBINDER, Arch::ARCH_EMPTY},
737 {{"ICamera", {"ICamera", {"legacy/0", "default"}}},
738 {"IBetterCamera", {"IBetterCamera", {"camera"}}}}};
739 ManifestHal expectedNfcHal = ManifestHal{HalFormat::HIDL,
740 "android.hardware.nfc",
741 {Version(1, 0), Version(2, 1)},
742 {Transport::PASSTHROUGH, Arch::ARCH_32_64},
743 {{"INfc", {"INfc", {"default"}}}}};
744 auto cameraHals = vm.getHals("android.hardware.camera");
745 EXPECT_EQ((int)cameraHals.size(), 2);
746 EXPECT_EQ(*cameraHals[0], expectedCameraHalV1_2);
747 EXPECT_EQ(*cameraHals[1], expectedCameraHalV2_0);
748 auto nfcHals = vm.getHals("android.hardware.nfc");
749 EXPECT_EQ((int)nfcHals.size(), 1);
750 EXPECT_EQ(*nfcHals[0], expectedNfcHal);
751 }
752
TEST_F(LibVintfTest,CompatibilityMatrixGetHals)753 TEST_F(LibVintfTest, CompatibilityMatrixGetHals) {
754 CompatibilityMatrix cm;
755 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE,
756 "android.hardware.camera",
757 {{VersionRange(1, 2, 3), VersionRange(4, 5, 6)}},
758 false /* optional */,
759 testHalInterfaces()}));
760 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE,
761 "android.hardware.nfc",
762 {{VersionRange(4, 5, 6), VersionRange(10, 11, 12)}},
763 true /* optional */,
764 testHalInterfaces()}));
765
766 MatrixHal expectedCameraHal = MatrixHal{
767 HalFormat::NATIVE,
768 "android.hardware.camera",
769 {{VersionRange(1, 2, 3), VersionRange(4, 5, 6)}},
770 false /* optional */,
771 testHalInterfaces(),
772 };
773 MatrixHal expectedNfcHal = MatrixHal{HalFormat::NATIVE,
774 "android.hardware.nfc",
775 {{VersionRange(4, 5, 6), VersionRange(10, 11, 12)}},
776 true /* optional */,
777 testHalInterfaces()};
778 auto cameraHals = cm.getHals("android.hardware.camera");
779 EXPECT_EQ((int)cameraHals.size(), 1);
780 EXPECT_EQ(*cameraHals[0], expectedCameraHal);
781 auto nfcHals = cm.getHals("android.hardware.nfc");
782 EXPECT_EQ((int)nfcHals.size(), 1);
783 EXPECT_EQ(*nfcHals[0], expectedNfcHal);
784 }
785
TEST_F(LibVintfTest,RuntimeInfo)786 TEST_F(LibVintfTest, RuntimeInfo) {
787 RuntimeInfo ki = testRuntimeInfo();
788 using KernelConfigs = std::vector<KernelConfig>;
789 const KernelConfigs configs {
790 KernelConfig{"CONFIG_64BIT", Tristate::YES},
791 KernelConfig{"CONFIG_ANDROID_BINDER_DEVICES", "binder,hwbinder"},
792 KernelConfig{"CONFIG_ARCH_MMAP_RND_BITS", 24},
793 KernelConfig{"CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES", ""},
794 KernelConfig{"CONFIG_ILLEGAL_POINTER_VALUE", 0xdead000000000000},
795 KernelConfig{"CONFIG_NOTEXIST", Tristate::NO},
796 };
797
798 auto testMatrix = [&] (MatrixKernel &&kernel) {
799 CompatibilityMatrix cm;
800 add(cm, std::move(kernel));
801 set(cm, {30, {{25, 0}}});
802 setAvb(cm, {2, 1});
803 return cm;
804 };
805
806 std::string error;
807
808 {
809 MatrixKernel kernel(KernelVersion{4, 4, 1}, KernelConfigs(configs));
810 CompatibilityMatrix cm = testMatrix(std::move(kernel));
811 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Kernel version shouldn't match";
812 }
813
814 {
815 MatrixKernel kernel(KernelVersion{3, 18, 60}, KernelConfigs(configs));
816 CompatibilityMatrix cm = testMatrix(std::move(kernel));
817 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Kernel version shouldn't match";
818 }
819
820 {
821 MatrixKernel kernel(KernelVersion{3, 18, 22}, KernelConfigs(configs));
822 CompatibilityMatrix cm = testMatrix(std::move(kernel));
823 EXPECT_TRUE(ki.checkCompatibility(cm, &error)) << error;
824 }
825
826 {
827 MatrixKernel kernel(KernelVersion{3, 18, 22}, KernelConfigs(configs));
828 CompatibilityMatrix cm = testMatrix(std::move(kernel));
829 set(cm, Sepolicy{22, {{25, 0}}});
830 EXPECT_TRUE(ki.checkCompatibility(cm, &error)) << error;
831 set(cm, Sepolicy{40, {{25, 0}}});
832 EXPECT_FALSE(ki.checkCompatibility(cm, &error))
833 << "kernel-sepolicy-version shouldn't match";
834 EXPECT_IN("kernelSepolicyVersion = 30 but required >= 40", error);
835 }
836
837 {
838 KernelConfigs newConfigs(configs);
839 newConfigs[0] = KernelConfig{"CONFIG_64BIT", Tristate::NO};
840 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
841 CompatibilityMatrix cm = testMatrix(std::move(kernel));
842 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Value shouldn't match for tristate";
843 }
844
845 {
846 KernelConfigs newConfigs(configs);
847 newConfigs[0] = KernelConfig{"CONFIG_64BIT", 20};
848 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
849 CompatibilityMatrix cm = testMatrix(std::move(kernel));
850 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Type shouldn't match";
851 }
852
853 {
854 KernelConfigs newConfigs(configs);
855 newConfigs[1] = KernelConfig{"CONFIG_ANDROID_BINDER_DEVICES", "binder"};
856 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
857 CompatibilityMatrix cm = testMatrix(std::move(kernel));
858 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Value shouldn't match for string";
859 }
860
861 {
862 KernelConfigs newConfigs(configs);
863 newConfigs[1] = KernelConfig{"CONFIG_ANDROID_BINDER_DEVICES", Tristate::YES};
864 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
865 CompatibilityMatrix cm = testMatrix(std::move(kernel));
866 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Type shouldn't match";
867 }
868
869 {
870 KernelConfigs newConfigs(configs);
871 newConfigs[2] = KernelConfig{"CONFIG_ARCH_MMAP_RND_BITS", 30};
872 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
873 CompatibilityMatrix cm = testMatrix(std::move(kernel));
874 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Value shouldn't match for integer";
875 }
876
877 RuntimeInfo badAvb = testRuntimeInfo();
878 CompatibilityMatrix cm = testMatrix(MatrixKernel(KernelVersion{3, 18, 31}, {}));
879 {
880 setAvb(badAvb, {1, 0}, {2, 1});
881 EXPECT_FALSE(badAvb.checkCompatibility(cm, &error));
882 EXPECT_STREQ(error.c_str(), "Vbmeta version 1.0 does not match framework matrix 2.1");
883 }
884 {
885 setAvb(badAvb, {2, 1}, {3, 0});
886 EXPECT_FALSE(badAvb.checkCompatibility(cm, &error));
887 }
888 {
889 setAvb(badAvb, {2, 1}, {2, 3});
890 EXPECT_TRUE(badAvb.checkCompatibility(cm, &error));
891 }
892 {
893 setAvb(badAvb, {2, 3}, {2, 1});
894 EXPECT_TRUE(badAvb.checkCompatibility(cm, &error));
895 }
896 }
897
TEST_F(LibVintfTest,MissingAvb)898 TEST_F(LibVintfTest, MissingAvb) {
899 std::string xml =
900 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
901 " <kernel version=\"3.18.31\"></kernel>"
902 " <sepolicy>\n"
903 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
904 " <sepolicy-version>25.5</sepolicy-version>\n"
905 " </sepolicy>\n"
906 "</compatibility-matrix>\n";
907 CompatibilityMatrix cm;
908 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml));
909 EXPECT_EQ(getAvb(cm), Version(0, 0));
910 }
911
TEST_F(LibVintfTest,DisableAvb)912 TEST_F(LibVintfTest, DisableAvb) {
913 std::string xml =
914 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
915 " <kernel version=\"3.18.31\"></kernel>"
916 " <sepolicy>\n"
917 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
918 " <sepolicy-version>25.5</sepolicy-version>\n"
919 " </sepolicy>\n"
920 " <avb>\n"
921 " <vbmeta-version>1.0</vbmeta-version>\n"
922 " </avb>\n"
923 "</compatibility-matrix>\n";
924 CompatibilityMatrix cm;
925 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml));
926 RuntimeInfo ki = testRuntimeInfo();
927 std::string error;
928 EXPECT_FALSE(ki.checkCompatibility(cm, &error));
929 EXPECT_STREQ(error.c_str(), "AVB version 2.1 does not match framework matrix 1.0");
930 EXPECT_TRUE(ki.checkCompatibility(cm, &error, DISABLE_AVB_CHECK)) << error;
931 }
932
933 // This is the test extracted from VINTF Object doc
TEST_F(LibVintfTest,HalCompat)934 TEST_F(LibVintfTest, HalCompat) {
935 CompatibilityMatrix matrix;
936 std::string error;
937
938 std::string matrixXml =
939 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
940 " <hal format=\"hidl\" optional=\"false\">\n"
941 " <name>android.hardware.foo</name>\n"
942 " <version>1.0</version>\n"
943 " <version>3.1-2</version>\n"
944 " <interface>\n"
945 " <name>IFoo</name>\n"
946 " <instance>default</instance>\n"
947 " <instance>specific</instance>\n"
948 " </interface>\n"
949 " </hal>\n"
950 " <hal format=\"hidl\" optional=\"false\">\n"
951 " <name>android.hardware.foo</name>\n"
952 " <version>2.0</version>\n"
953 " <interface>\n"
954 " <name>IBar</name>\n"
955 " <instance>default</instance>\n"
956 " </interface>\n"
957 " </hal>\n"
958 " <sepolicy>\n"
959 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
960 " <sepolicy-version>25.5</sepolicy-version>\n"
961 " </sepolicy>\n"
962 "</compatibility-matrix>\n";
963 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml))
964 << gCompatibilityMatrixConverter.lastError();
965
966 {
967 std::string manifestXml =
968 "<manifest version=\"1.0\" type=\"device\">\n"
969 " <hal format=\"hidl\">\n"
970 " <name>android.hardware.foo</name>\n"
971 " <transport>hwbinder</transport>\n"
972 " <version>1.0</version>\n"
973 " <interface>\n"
974 " <name>IFoo</name>\n"
975 " <instance>default</instance>\n"
976 " <instance>specific</instance>\n"
977 " </interface>\n"
978 " </hal>\n"
979 " <hal format=\"hidl\">\n"
980 " <name>android.hardware.foo</name>\n"
981 " <transport>hwbinder</transport>\n"
982 " <version>2.0</version>\n"
983 " <interface>\n"
984 " <name>IBar</name>\n"
985 " <instance>default</instance>\n"
986 " </interface>\n"
987 " </hal>\n"
988 " <sepolicy>\n"
989 " <version>25.5</version>\n"
990 " </sepolicy>\n"
991 "</manifest>\n";
992
993 HalManifest manifest;
994 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
995 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
996 }
997
998 {
999 std::string manifestXml =
1000 "<manifest version=\"1.0\" type=\"device\">\n"
1001 " <hal format=\"hidl\">\n"
1002 " <name>android.hardware.foo</name>\n"
1003 " <transport>hwbinder</transport>\n"
1004 " <version>1.0</version>\n"
1005 " <interface>\n"
1006 " <name>IFoo</name>\n"
1007 " <instance>default</instance>\n"
1008 " <instance>specific</instance>\n"
1009 " </interface>\n"
1010 " </hal>\n"
1011 " <sepolicy>\n"
1012 " <version>25.5</version>\n"
1013 " </sepolicy>\n"
1014 "</manifest>\n";
1015 HalManifest manifest;
1016 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
1017 EXPECT_FALSE(manifest.checkCompatibility(matrix, &error))
1018 << "should not be compatible because IBar is missing";
1019 }
1020
1021 {
1022 std::string manifestXml =
1023 "<manifest version=\"1.0\" type=\"device\">\n"
1024 " <hal format=\"hidl\">\n"
1025 " <name>android.hardware.foo</name>\n"
1026 " <transport>hwbinder</transport>\n"
1027 " <version>1.0</version>\n"
1028 " <interface>\n"
1029 " <name>IFoo</name>\n"
1030 " <instance>default</instance>\n"
1031 " </interface>\n"
1032 " </hal>\n"
1033 " <hal format=\"hidl\">\n"
1034 " <name>android.hardware.foo</name>\n"
1035 " <transport>hwbinder</transport>\n"
1036 " <version>2.0</version>\n"
1037 " <interface>\n"
1038 " <name>IBar</name>\n"
1039 " <instance>default</instance>\n"
1040 " </interface>\n"
1041 " </hal>\n"
1042 " <sepolicy>\n"
1043 " <version>25.5</version>\n"
1044 " </sepolicy>\n"
1045 "</manifest>\n";
1046 HalManifest manifest;
1047 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
1048 EXPECT_FALSE(manifest.checkCompatibility(matrix, &error))
1049 << "should not be compatible because IFoo/specific is missing";
1050 }
1051
1052 {
1053 std::string manifestXml =
1054 "<manifest version=\"1.0\" type=\"device\">\n"
1055 " <hal format=\"hidl\">\n"
1056 " <name>android.hardware.foo</name>\n"
1057 " <transport>hwbinder</transport>\n"
1058 " <version>3.3</version>\n"
1059 " <interface>\n"
1060 " <name>IFoo</name>\n"
1061 " <instance>default</instance>\n"
1062 " <instance>specific</instance>\n"
1063 " </interface>\n"
1064 " </hal>\n"
1065 " <hal format=\"hidl\">\n"
1066 " <name>android.hardware.foo</name>\n"
1067 " <transport>hwbinder</transport>\n"
1068 " <version>2.0</version>\n"
1069 " <interface>\n"
1070 " <name>IBar</name>\n"
1071 " <instance>default</instance>\n"
1072 " </interface>\n"
1073 " </hal>\n"
1074 " <sepolicy>\n"
1075 " <version>25.5</version>\n"
1076 " </sepolicy>\n"
1077 "</manifest>\n";
1078 HalManifest manifest;
1079 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
1080 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1081 }
1082
1083 {
1084 std::string manifestXml =
1085 "<manifest version=\"1.0\" type=\"device\">\n"
1086 " <hal format=\"hidl\">\n"
1087 " <name>android.hardware.foo</name>\n"
1088 " <transport>hwbinder</transport>\n"
1089 " <version>1.0</version>\n"
1090 " <interface>\n"
1091 " <name>IFoo</name>\n"
1092 " <instance>default</instance>\n"
1093 " </interface>\n"
1094 " </hal>\n"
1095 " <hal format=\"hidl\">\n"
1096 " <name>android.hardware.foo</name>\n"
1097 " <transport>hwbinder</transport>\n"
1098 " <version>3.2</version>\n"
1099 " <interface>\n"
1100 " <name>IFoo</name>\n"
1101 " <instance>specific</instance>\n"
1102 " </interface>\n"
1103 " </hal>\n"
1104 " <hal format=\"hidl\">\n"
1105 " <name>android.hardware.foo</name>\n"
1106 " <transport>hwbinder</transport>\n"
1107 " <version>2.0</version>\n"
1108 " <interface>\n"
1109 " <name>IBar</name>\n"
1110 " <instance>default</instance>\n"
1111 " </interface>\n"
1112 " </hal>\n"
1113 " <sepolicy>\n"
1114 " <version>25.5</version>\n"
1115 " </sepolicy>\n"
1116 "</manifest>\n";
1117 HalManifest manifest;
1118 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
1119 EXPECT_FALSE(manifest.checkCompatibility(matrix, &error))
1120 << "should not be compatible even though @1.0::IFoo/default "
1121 << "and @3.2::IFoo/specific present";
1122 }
1123
1124 {
1125 std::string manifestXml =
1126 "<manifest version=\"1.0\" type=\"device\">\n"
1127 " <hal format=\"hidl\">\n"
1128 " <name>android.hardware.foo</name>\n"
1129 " <transport>hwbinder</transport>\n"
1130 " <version>1.0</version>\n"
1131 " <interface>\n"
1132 " <name>IFoo</name>\n"
1133 " <instance>default</instance>\n"
1134 " <instance>specific</instance>\n"
1135 " </interface>\n"
1136 " </hal>\n"
1137 " <hal format=\"hidl\">\n"
1138 " <name>android.hardware.foo</name>\n"
1139 " <transport>hwbinder</transport>\n"
1140 " <version>2.0</version>\n"
1141 " <interface>\n"
1142 " <name>IBar</name>\n"
1143 " <instance>default</instance>\n"
1144 " </interface>\n"
1145 " </hal>\n"
1146 " <sepolicy>\n"
1147 " <version>25.5</version>\n"
1148 " </sepolicy>\n"
1149 "</manifest>\n";
1150 HalManifest manifest;
1151 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml))
1152 << gHalManifestConverter.lastError();
1153 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1154 }
1155 }
1156
TEST_F(LibVintfTest,Compat)1157 TEST_F(LibVintfTest, Compat) {
1158 std::string manifestXml =
1159 "<manifest version=\"1.0\" type=\"device\">\n"
1160 " <hal format=\"hidl\">\n"
1161 " <name>android.hardware.camera</name>\n"
1162 " <transport>hwbinder</transport>\n"
1163 " <version>3.5</version>\n"
1164 " <interface>\n"
1165 " <name>IBetterCamera</name>\n"
1166 " <instance>camera</instance>\n"
1167 " </interface>\n"
1168 " <interface>\n"
1169 " <name>ICamera</name>\n"
1170 " <instance>default</instance>\n"
1171 " <instance>legacy/0</instance>\n"
1172 " </interface>\n"
1173 " </hal>\n"
1174 " <hal format=\"hidl\">\n"
1175 " <name>android.hardware.nfc</name>\n"
1176 " <transport>hwbinder</transport>\n"
1177 " <version>1.0</version>\n"
1178 " <interface>\n"
1179 " <name>INfc</name>\n"
1180 " <instance>nfc_nci</instance>\n"
1181 " </interface>\n"
1182 " </hal>\n"
1183 " <hal format=\"hidl\">\n"
1184 " <name>android.hardware.nfc</name>\n"
1185 " <transport>hwbinder</transport>\n"
1186 " <version>2.0</version>\n"
1187 " <interface>\n"
1188 " <name>INfc</name>\n"
1189 " <instance>default</instance>\n"
1190 " <instance>nfc_nci</instance>\n"
1191 " </interface>\n"
1192 " </hal>\n"
1193 " <sepolicy>\n"
1194 " <version>25.5</version>\n"
1195 " </sepolicy>\n"
1196 "</manifest>\n";
1197
1198 std::string matrixXml =
1199 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1200 " <hal format=\"hidl\" optional=\"false\">\n"
1201 " <name>android.hardware.camera</name>\n"
1202 " <version>2.0-5</version>\n"
1203 " <version>3.4-16</version>\n"
1204 " <interface>\n"
1205 " <name>IBetterCamera</name>\n"
1206 " <instance>camera</instance>\n"
1207 " </interface>\n"
1208 " <interface>\n"
1209 " <name>ICamera</name>\n"
1210 " <instance>default</instance>\n"
1211 " <instance>legacy/0</instance>\n"
1212 " </interface>\n"
1213 " </hal>\n"
1214 " <hal format=\"hidl\" optional=\"false\">\n"
1215 " <name>android.hardware.nfc</name>\n"
1216 " <version>1.0</version>\n"
1217 " <version>2.0</version>\n"
1218 " <interface>\n"
1219 " <name>INfc</name>\n"
1220 " <instance>nfc_nci</instance>\n"
1221 " </interface>\n"
1222 " </hal>\n"
1223 " <hal format=\"hidl\" optional=\"true\">\n"
1224 " <name>android.hardware.foo</name>\n"
1225 " <version>1.0</version>\n"
1226 " </hal>\n"
1227 " <sepolicy>\n"
1228 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1229 " <sepolicy-version>25.5</sepolicy-version>\n"
1230 " <sepolicy-version>26.0-3</sepolicy-version>\n"
1231 " </sepolicy>\n"
1232 " <avb>\n"
1233 " <vbmeta-version>2.1</vbmeta-version>\n"
1234 " </avb>\n"
1235 "</compatibility-matrix>\n";
1236
1237 HalManifest manifest;
1238 CompatibilityMatrix matrix;
1239 std::string error;
1240 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
1241 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1242 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1243
1244 // some smaller test cases
1245 matrixXml =
1246 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1247 " <hal format=\"hidl\" optional=\"false\">\n"
1248 " <name>android.hardware.camera</name>\n"
1249 " <version>3.4</version>\n"
1250 " </hal>\n"
1251 " <sepolicy>\n"
1252 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1253 " <sepolicy-version>25.5</sepolicy-version>\n"
1254 " </sepolicy>\n"
1255 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
1256 "</compatibility-matrix>\n";
1257 matrix = {};
1258 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1259 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1260 MatrixHal *camera = getAnyHal(matrix, "android.hardware.camera");
1261 EXPECT_NE(camera, nullptr);
1262 camera->versionRanges[0] = {3, 5};
1263 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1264 camera->versionRanges[0] = {3, 6};
1265 EXPECT_FALSE(manifest.checkCompatibility(matrix));
1266
1267 // reset it
1268 matrix = {};
1269 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1270 set(matrix, Sepolicy{30, {{26, 0}}});
1271 EXPECT_FALSE(manifest.checkCompatibility(matrix));
1272 set(matrix, Sepolicy{30, {{25, 6}}});
1273 EXPECT_FALSE(manifest.checkCompatibility(matrix));
1274 set(matrix, Sepolicy{30, {{25, 4}}});
1275 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1276 }
1277
1278 /////////////////// xmlfile tests
1279
TEST_F(LibVintfTest,HalManifestConverterXmlFile)1280 TEST_F(LibVintfTest, HalManifestConverterXmlFile) {
1281 HalManifest vm = testDeviceManifestWithXmlFile();
1282 std::string xml =
1283 gHalManifestConverter(vm, SerializeFlag::HALS_NO_FQNAME & SerializeFlag::SEPOLICY_ONLY &
1284 SerializeFlag::XMLFILES_ONLY);
1285 EXPECT_EQ(xml,
1286 "<manifest version=\"1.0\" type=\"device\">\n"
1287 " <hal format=\"hidl\">\n"
1288 " <name>android.hardware.camera</name>\n"
1289 " <transport>hwbinder</transport>\n"
1290 " <version>2.0</version>\n"
1291 " <interface>\n"
1292 " <name>IBetterCamera</name>\n"
1293 " <instance>camera</instance>\n"
1294 " </interface>\n"
1295 " <interface>\n"
1296 " <name>ICamera</name>\n"
1297 " <instance>default</instance>\n"
1298 " <instance>legacy/0</instance>\n"
1299 " </interface>\n"
1300 " </hal>\n"
1301 " <hal format=\"hidl\">\n"
1302 " <name>android.hardware.nfc</name>\n"
1303 " <transport arch=\"32+64\">passthrough</transport>\n"
1304 " <version>1.0</version>\n"
1305 " <interface>\n"
1306 " <name>INfc</name>\n"
1307 " <instance>default</instance>\n"
1308 " </interface>\n"
1309 " </hal>\n"
1310 " <sepolicy>\n"
1311 " <version>25.0</version>\n"
1312 " </sepolicy>\n"
1313 " <xmlfile>\n"
1314 " <name>media_profile</name>\n"
1315 " <version>1.0</version>\n"
1316 " </xmlfile>\n"
1317 "</manifest>\n");
1318 HalManifest vm2;
1319 EXPECT_TRUE(gHalManifestConverter(&vm2, xml));
1320 EXPECT_EQ(vm, vm2);
1321 }
1322
TEST_F(LibVintfTest,CompatibilityMatrixConverterXmlFile)1323 TEST_F(LibVintfTest, CompatibilityMatrixConverterXmlFile) {
1324 CompatibilityMatrix cm;
1325 addXmlFile(cm, "media_profile", {1, 0});
1326 std::string xml = gCompatibilityMatrixConverter(cm, SerializeFlag::XMLFILES_ONLY);
1327 EXPECT_EQ(xml,
1328 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1329 " <xmlfile format=\"dtd\" optional=\"true\">\n"
1330 " <name>media_profile</name>\n"
1331 " <version>1.0</version>\n"
1332 " </xmlfile>\n"
1333 "</compatibility-matrix>\n");
1334 CompatibilityMatrix cm2;
1335 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml));
1336 EXPECT_EQ(cm, cm2);
1337 }
1338
TEST_F(LibVintfTest,CompatibilityMatrixConverterXmlFile2)1339 TEST_F(LibVintfTest, CompatibilityMatrixConverterXmlFile2) {
1340 std::string xml =
1341 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1342 " <xmlfile format=\"dtd\" optional=\"false\">\n"
1343 " <name>media_profile</name>\n"
1344 " <version>1.0</version>\n"
1345 " </xmlfile>\n"
1346 "</compatibility-matrix>\n";
1347 CompatibilityMatrix cm;
1348 EXPECT_FALSE(gCompatibilityMatrixConverter(&cm, xml));
1349 EXPECT_EQ(
1350 "compatibility-matrix.xmlfile entry media_profile has to be optional for "
1351 "compatibility matrix version 1.0",
1352 gCompatibilityMatrixConverter.lastError());
1353 }
1354
TEST_F(LibVintfTest,ManifestXmlFilePathDevice)1355 TEST_F(LibVintfTest, ManifestXmlFilePathDevice) {
1356 std::string manifestXml =
1357 "<manifest version=\"1.0\" type=\"device\">"
1358 " <xmlfile>"
1359 " <name>media_profile</name>"
1360 " <version>1.0</version>"
1361 " </xmlfile>"
1362 "</manifest>";
1363 HalManifest manifest;
1364 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
1365 EXPECT_EQ(manifest.getXmlFilePath("media_profile", {1, 0}),
1366 "/vendor/etc/media_profile_V1_0.xml");
1367 }
1368
TEST_F(LibVintfTest,ManifestXmlFilePathFramework)1369 TEST_F(LibVintfTest, ManifestXmlFilePathFramework) {
1370 std::string manifestXml =
1371 "<manifest version=\"1.0\" type=\"framework\">"
1372 " <xmlfile>"
1373 " <name>media_profile</name>"
1374 " <version>1.0</version>"
1375 " </xmlfile>"
1376 "</manifest>";
1377 HalManifest manifest;
1378 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
1379 EXPECT_EQ(manifest.getXmlFilePath("media_profile", {1, 0}),
1380 "/system/etc/media_profile_V1_0.xml");
1381 }
1382
TEST_F(LibVintfTest,ManifestXmlFilePathOverride)1383 TEST_F(LibVintfTest, ManifestXmlFilePathOverride) {
1384 std::string manifestXml =
1385 "<manifest version=\"1.0\" type=\"device\">"
1386 " <xmlfile>"
1387 " <name>media_profile</name>"
1388 " <version>1.0</version>"
1389 " <path>/vendor/etc/foo.xml</path>"
1390 " </xmlfile>"
1391 "</manifest>";
1392 HalManifest manifest;
1393 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
1394 EXPECT_EQ(manifest.getXmlFilePath("media_profile", {1, 0}), "/vendor/etc/foo.xml");
1395 }
1396
TEST_F(LibVintfTest,ManifestXmlFilePathMissing)1397 TEST_F(LibVintfTest, ManifestXmlFilePathMissing) {
1398 std::string manifestXml =
1399 "<manifest version=\"1.0\" type=\"device\">"
1400 " <xmlfile>"
1401 " <name>media_profile</name>"
1402 " <version>1.1</version>"
1403 " </xmlfile>"
1404 "</manifest>";
1405 HalManifest manifest;
1406 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
1407 EXPECT_EQ(manifest.getXmlFilePath("media_profile", {1, 0}), "");
1408 }
1409
TEST_F(LibVintfTest,MatrixXmlFilePathFramework)1410 TEST_F(LibVintfTest, MatrixXmlFilePathFramework) {
1411 std::string matrixXml =
1412 "<compatibility-matrix version=\"1.0\" type=\"framework\">"
1413 " <xmlfile format=\"dtd\" optional=\"true\">"
1414 " <name>media_profile</name>"
1415 " <version>2.0-1</version>"
1416 " </xmlfile>"
1417 "</compatibility-matrix>";
1418 CompatibilityMatrix matrix;
1419 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1420 EXPECT_EQ(matrix.getXmlSchemaPath("media_profile", {2, 1}),
1421 "/system/etc/media_profile_V2_1.dtd");
1422 }
1423
TEST_F(LibVintfTest,MatrixXmlFilePathDevice)1424 TEST_F(LibVintfTest, MatrixXmlFilePathDevice) {
1425 std::string matrixXml =
1426 "<compatibility-matrix version=\"1.0\" type=\"device\">"
1427 " <xmlfile format=\"xsd\" optional=\"true\">"
1428 " <name>media_profile</name>"
1429 " <version>2.0-1</version>"
1430 " </xmlfile>"
1431 "</compatibility-matrix>";
1432 CompatibilityMatrix matrix;
1433 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1434 EXPECT_EQ(matrix.getXmlSchemaPath("media_profile", {2, 0}),
1435 "/vendor/etc/media_profile_V2_1.xsd");
1436 }
1437
TEST_F(LibVintfTest,MatrixXmlFilePathOverride)1438 TEST_F(LibVintfTest, MatrixXmlFilePathOverride) {
1439 std::string matrixXml =
1440 "<compatibility-matrix version=\"1.0\" type=\"framework\">"
1441 " <xmlfile format=\"xsd\" optional=\"true\">"
1442 " <name>media_profile</name>"
1443 " <version>2.0-1</version>"
1444 " <path>/system/etc/foo.xsd</path>"
1445 " </xmlfile>"
1446 "</compatibility-matrix>";
1447 CompatibilityMatrix matrix;
1448 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1449 EXPECT_EQ(matrix.getXmlSchemaPath("media_profile", {2, 0}), "/system/etc/foo.xsd");
1450 }
1451
TEST_F(LibVintfTest,MatrixXmlFilePathMissing)1452 TEST_F(LibVintfTest, MatrixXmlFilePathMissing) {
1453 std::string matrixXml =
1454 "<compatibility-matrix version=\"1.0\" type=\"framework\">"
1455 " <xmlfile format=\"dtd\" optional=\"true\">"
1456 " <name>media_profile</name>"
1457 " <version>2.1</version>"
1458 " </xmlfile>"
1459 "</compatibility-matrix>";
1460 CompatibilityMatrix matrix;
1461 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1462 EXPECT_EQ(matrix.getXmlSchemaPath("media_profile", {2, 0}), "");
1463 }
1464
processData(const std::string & data,bool processComments,bool relaxedFormat=false)1465 std::pair<KernelConfigParser, status_t> processData(const std::string& data, bool processComments,
1466 bool relaxedFormat = false) {
1467 KernelConfigParser parser(processComments, relaxedFormat);
1468 const char* p = data.c_str();
1469 size_t n = 0;
1470 size_t chunkSize;
1471 status_t status = OK;
1472 for (; n < data.size(); p += chunkSize, n += chunkSize) {
1473 chunkSize = std::min<size_t>(5, data.size() - n);
1474 if ((status = parser.process(p, chunkSize)) != OK) {
1475 break;
1476 }
1477 }
1478 return {std::move(parser), status};
1479 }
1480
TEST_F(LibVintfTest,KernelConfigParser)1481 TEST_F(LibVintfTest, KernelConfigParser) {
1482 // usage in /proc/config.gz
1483 const std::string data =
1484 "# CONFIG_NOT_SET is not set\n"
1485 "CONFIG_ONE=1\n"
1486 "CONFIG_Y=y\n"
1487 "CONFIG_STR=\"string\"\n";
1488 auto pair = processData(data, false /* processComments */);
1489 ASSERT_EQ(OK, pair.second) << pair.first.error();
1490 const auto& configs = pair.first.configs();
1491
1492 EXPECT_EQ(configs.find("CONFIG_ONE")->second, "1");
1493 EXPECT_EQ(configs.find("CONFIG_Y")->second, "y");
1494 EXPECT_EQ(configs.find("CONFIG_STR")->second, "\"string\"");
1495 EXPECT_EQ(configs.find("CONFIG_NOT_SET"), configs.end());
1496 }
1497
TEST_F(LibVintfTest,KernelConfigParser2)1498 TEST_F(LibVintfTest, KernelConfigParser2) {
1499 // usage in android-base.cfg
1500 const std::string data =
1501 "# CONFIG_NOT_SET is not set\n"
1502 "CONFIG_ONE=1\n"
1503 "CONFIG_Y=y\n"
1504 "CONFIG_STR=string\n"
1505 "# ignore_thiscomment\n"
1506 "# CONFIG_NOT_SET2 is not set\n";
1507 auto pair = processData(data, true /* processComments */);
1508 ASSERT_EQ(OK, pair.second) << pair.first.error();
1509 const auto& configs = pair.first.configs();
1510
1511 EXPECT_EQ(configs.find("CONFIG_ONE")->second, "1");
1512 EXPECT_EQ(configs.find("CONFIG_Y")->second, "y");
1513 EXPECT_EQ(configs.find("CONFIG_STR")->second, "string");
1514 EXPECT_EQ(configs.find("CONFIG_NOT_SET")->second, "n");
1515 EXPECT_EQ(configs.find("CONFIG_NOT_SET2")->second, "n");
1516 }
1517
TEST_F(LibVintfTest,KernelConfigParserSpace)1518 TEST_F(LibVintfTest, KernelConfigParserSpace) {
1519 // usage in android-base.cfg
1520 const std::string data =
1521 " # CONFIG_NOT_SET is not set \n"
1522 " CONFIG_ONE=1 # 'tis a one!\n"
1523 " CONFIG_TWO=2 #'tis a two! \n"
1524 " CONFIG_THREE=3#'tis a three! \n"
1525 " CONFIG_233=233#'tis a three! \n"
1526 "#yey! random comments\n"
1527 "CONFIG_Y=y \n"
1528 " CONFIG_YES=y#YES! \n"
1529 "CONFIG_STR=string\n"
1530 "CONFIG_HELLO=hello world! #still works\n"
1531 "CONFIG_WORLD=hello world! \n"
1532 "CONFIG_GOOD = good morning! #comments here\n"
1533 " CONFIG_MORNING = good morning! \n";
1534 auto pair = processData(data, true /* processComments */, true /* relaxedFormat */);
1535 ASSERT_EQ(OK, pair.second) << pair.first.error();
1536 const auto& configs = pair.first.configs();
1537
1538 EXPECT_EQ(configs.find("CONFIG_ONE")->second, "1");
1539 EXPECT_EQ(configs.find("CONFIG_TWO")->second, "2");
1540 EXPECT_EQ(configs.find("CONFIG_THREE")->second, "3");
1541 EXPECT_EQ(configs.find("CONFIG_Y")->second, "y");
1542 EXPECT_EQ(configs.find("CONFIG_STR")->second, "string");
1543 EXPECT_EQ(configs.find("CONFIG_HELLO")->second, "hello world!")
1544 << "Value should be \"hello world!\" without trailing spaces";
1545 EXPECT_EQ(configs.find("CONFIG_WORLD")->second, "hello world!")
1546 << "Value should be \"hello world!\" without trailing spaces";
1547 EXPECT_EQ(configs.find("CONFIG_GOOD")->second, "good morning!")
1548 << "Value should be \"good morning!\" without leading or trailing spaces";
1549 EXPECT_EQ(configs.find("CONFIG_MORNING")->second, "good morning!")
1550 << "Value should be \"good morning!\" without leading or trailing spaces";
1551 EXPECT_EQ(configs.find("CONFIG_NOT_SET")->second, "n");
1552 }
1553
TEST_F(LibVintfTest,NetutilsWrapperMatrix)1554 TEST_F(LibVintfTest, NetutilsWrapperMatrix) {
1555 std::string matrixXml;
1556 CompatibilityMatrix matrix;
1557
1558 matrixXml =
1559 "<compatibility-matrix version=\"1.0\" type=\"device\">"
1560 " <hal format=\"native\" optional=\"false\">"
1561 " <name>netutils-wrapper</name>"
1562 " <version>1.0</version>"
1563 " </hal>"
1564 "</compatibility-matrix>";
1565 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml))
1566 << gCompatibilityMatrixConverter.lastError();
1567
1568 // only host libvintf hardcodes netutils-wrapper version requirements
1569 #ifndef LIBVINTF_TARGET
1570
1571 matrixXml =
1572 "<compatibility-matrix version=\"1.0\" type=\"device\">"
1573 " <hal format=\"native\" optional=\"false\">"
1574 " <name>netutils-wrapper</name>"
1575 " <version>1.0-1</version>"
1576 " </hal>"
1577 "</compatibility-matrix>";
1578 EXPECT_FALSE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1579 EXPECT_CONTAINS(
1580 gCompatibilityMatrixConverter.lastError(),
1581 "netutils-wrapper HAL must specify exactly one version x.0, but a range is provided. "
1582 "Perhaps you mean '1.0'?");
1583
1584 matrixXml =
1585 "<compatibility-matrix version=\"1.0\" type=\"device\">"
1586 " <hal format=\"native\" optional=\"false\">"
1587 " <name>netutils-wrapper</name>"
1588 " <version>1.1</version>"
1589 " </hal>"
1590 "</compatibility-matrix>";
1591 EXPECT_FALSE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1592 EXPECT_CONTAINS(
1593 gCompatibilityMatrixConverter.lastError(),
1594 "netutils-wrapper HAL must specify exactly one version x.0, but minor version is not 0. "
1595 "Perhaps you mean '1.0'?");
1596
1597 matrixXml =
1598 "<compatibility-matrix version=\"1.0\" type=\"device\">"
1599 " <hal format=\"native\" optional=\"false\">"
1600 " <name>netutils-wrapper</name>"
1601 " <version>1.0</version>"
1602 " <version>2.0</version>"
1603 " </hal>"
1604 "</compatibility-matrix>";
1605 EXPECT_FALSE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1606 EXPECT_CONTAINS(
1607 gCompatibilityMatrixConverter.lastError(),
1608 "netutils-wrapper HAL must specify exactly one version x.0, but multiple <version> element "
1609 "is specified.");
1610
1611 #endif // LIBVINTF_TARGET
1612 }
1613
TEST_F(LibVintfTest,NetutilsWrapperManifest)1614 TEST_F(LibVintfTest, NetutilsWrapperManifest) {
1615 std::string manifestXml;
1616 HalManifest manifest;
1617
1618 manifestXml =
1619 "<manifest version=\"1.0\" type=\"framework\">"
1620 " <hal format=\"native\">"
1621 " <name>netutils-wrapper</name>"
1622 " <version>1.0</version>"
1623 " <version>2.0</version>"
1624 " </hal>"
1625 "</manifest>";
1626 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml)) << gHalManifestConverter.lastError();
1627
1628 // only host libvintf hardcodes netutils-wrapper version requirements
1629 #ifndef LIBVINTF_TARGET
1630
1631 manifestXml =
1632 "<manifest version=\"1.0\" type=\"framework\">"
1633 " <hal format=\"native\">"
1634 " <name>netutils-wrapper</name>"
1635 " <version>1.1</version>"
1636 " </hal>"
1637 "</manifest>";
1638 EXPECT_FALSE(gHalManifestConverter(&manifest, manifestXml));
1639 EXPECT_CONTAINS(
1640 gCompatibilityMatrixConverter.lastError(),
1641 "netutils-wrapper HAL must specify exactly one version x.0, but multiple <version> element "
1642 "is specified.");
1643
1644 manifestXml =
1645 "<manifest version=\"1.0\" type=\"framework\">"
1646 " <hal format=\"native\">"
1647 " <name>netutils-wrapper</name>"
1648 " <version>1.0</version>"
1649 " <version>2.1</version>"
1650 " </hal>"
1651 "</manifest>";
1652 EXPECT_FALSE(gHalManifestConverter(&manifest, manifestXml));
1653 EXPECT_CONTAINS(
1654 gCompatibilityMatrixConverter.lastError(),
1655 "netutils-wrapper HAL must specify exactly one version x.0, but multiple <version> element "
1656 "is specified.");
1657
1658 #endif // LIBVINTF_TARGET
1659 }
1660
TEST_F(LibVintfTest,KernelConfigConditionTest)1661 TEST_F(LibVintfTest, KernelConfigConditionTest) {
1662 std::string xml =
1663 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1664 " <kernel version=\"3.18.22\"/>\n"
1665 " <kernel version=\"3.18.22\">\n"
1666 " <conditions>\n"
1667 " <config>\n"
1668 " <key>CONFIG_ARM</key>\n"
1669 " <value type=\"tristate\">y</value>\n"
1670 " </config>\n"
1671 " </conditions>\n"
1672 " <config>\n"
1673 " <key>CONFIG_FOO</key>\n"
1674 " <value type=\"tristate\">y</value>\n"
1675 " </config>\n"
1676 " </kernel>\n"
1677 " <sepolicy>\n"
1678 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1679 " <sepolicy-version>25.0</sepolicy-version>\n"
1680 " </sepolicy>\n"
1681 " <avb>\n"
1682 " <vbmeta-version>2.1</vbmeta-version>\n"
1683 " </avb>\n"
1684 "</compatibility-matrix>\n";
1685
1686 CompatibilityMatrix cm;
1687 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
1688 << gCompatibilityMatrixConverter.lastError();
1689 const auto& kernels = getKernels(cm);
1690 ASSERT_GE(kernels.size(), 2u);
1691 ASSERT_TRUE(kernels[0].conditions().empty());
1692 const auto& kernel = kernels[1];
1693 const auto& cond = kernel.conditions();
1694 ASSERT_FALSE(cond.empty());
1695 EXPECT_EQ("CONFIG_ARM", cond.begin()->first);
1696 EXPECT_EQ(KernelConfigTypedValue(Tristate::YES), cond.begin()->second);
1697 EXPECT_FALSE(kernel.configs().empty());
1698
1699 EXPECT_EQ(xml, gCompatibilityMatrixConverter(cm));
1700 }
1701
TEST_F(LibVintfTest,KernelConfigConditionEmptyTest)1702 TEST_F(LibVintfTest, KernelConfigConditionEmptyTest) {
1703 std::string xml =
1704 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1705 " <kernel version=\"4.4.0\"/>\n"
1706 " <kernel version=\"3.18.22\">\n"
1707 " <conditions>\n"
1708 " <config>\n"
1709 " <key>CONFIG_ARM</key>\n"
1710 " <value type=\"tristate\">y</value>\n"
1711 " </config>\n"
1712 " </conditions>\n"
1713 " </kernel>\n"
1714 "</compatibility-matrix>\n";
1715
1716 CompatibilityMatrix cm;
1717 EXPECT_FALSE(gCompatibilityMatrixConverter(&cm, xml))
1718 << "Should not accept first kernel version with non-empty conditions";
1719 EXPECT_EQ(
1720 "First <kernel> for version 3.18 must have empty <conditions> "
1721 "for backwards compatibility.",
1722 gCompatibilityMatrixConverter.lastError());
1723 }
1724
TEST_F(LibVintfTest,KernelConfigConditionMatch)1725 TEST_F(LibVintfTest, KernelConfigConditionMatch) {
1726 RuntimeInfo runtime = testRuntimeInfo();
1727 std::string error;
1728 std::string xml;
1729 CompatibilityMatrix cm;
1730
1731 xml =
1732 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1733 " <kernel version=\"3.18.22\"/>\n"
1734 " <kernel version=\"3.18.22\">\n"
1735 " <conditions>\n"
1736 " <config>\n"
1737 " <key>CONFIG_64BIT</key>\n"
1738 " <value type=\"tristate\">y</value>\n"
1739 " </config>\n"
1740 " </conditions>\n"
1741 " <config>\n"
1742 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
1743 " <value type=\"int\">24</value>\n"
1744 " </config>\n"
1745 " </kernel>\n"
1746 " <sepolicy>\n"
1747 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1748 " </sepolicy>\n"
1749 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
1750 "</compatibility-matrix>\n";
1751
1752 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
1753 << gCompatibilityMatrixConverter.lastError();
1754 EXPECT_TRUE(runtime.checkCompatibility(cm, &error)) << error;
1755
1756 xml =
1757 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1758 " <kernel version=\"3.18.22\"/>\n"
1759 " <kernel version=\"3.18.22\">\n"
1760 " <conditions>\n"
1761 " <config>\n"
1762 " <key>CONFIG_64BIT</key>\n"
1763 " <value type=\"tristate\">y</value>\n"
1764 " </config>\n"
1765 " </conditions>\n"
1766 " <config>\n"
1767 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
1768 " <value type=\"int\">26</value>\n"
1769 " </config>\n"
1770 " </kernel>\n"
1771 " <sepolicy>\n"
1772 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1773 " </sepolicy>\n"
1774 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
1775 "</compatibility-matrix>\n";
1776
1777 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
1778 << gCompatibilityMatrixConverter.lastError();
1779 EXPECT_FALSE(runtime.checkCompatibility(cm, &error))
1780 << "conditions met, so CONFIG_ARCH_MMAP_RND_BITS should not match";
1781
1782 xml =
1783 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1784 " <kernel version=\"3.18.22\"/>\n"
1785 " <kernel version=\"3.18.22\">\n"
1786 " <conditions>\n"
1787 " <config>\n"
1788 " <key>CONFIG_64BIT</key>\n"
1789 " <value type=\"tristate\">n</value>\n"
1790 " </config>\n"
1791 " </conditions>\n"
1792 " <config>\n"
1793 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
1794 " <value type=\"int\">26</value>\n"
1795 " </config>\n"
1796 " </kernel>\n"
1797 " <sepolicy>\n"
1798 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1799 " </sepolicy>\n"
1800 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
1801 "</compatibility-matrix>\n";
1802
1803 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
1804 << gCompatibilityMatrixConverter.lastError();
1805 EXPECT_TRUE(runtime.checkCompatibility(cm, &error)) << error;
1806 xml =
1807 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1808 " <kernel version=\"3.18.22\"/>\n"
1809 " <kernel version=\"3.18.22\">\n"
1810 " <conditions>\n"
1811 " <config>\n"
1812 " <key>CONFIG_64BIT</key>\n"
1813 " <value type=\"tristate\">y</value>\n"
1814 " </config>\n"
1815 " <config>\n"
1816 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
1817 " <value type=\"int\">24</value>\n"
1818 " </config>\n"
1819 " </conditions>\n"
1820 " <config>\n"
1821 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
1822 " <value type=\"int\">0xdead000000000000</value>\n"
1823 " </config>\n"
1824 " </kernel>\n"
1825 " <sepolicy>\n"
1826 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1827 " </sepolicy>\n"
1828 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
1829 "</compatibility-matrix>\n";
1830
1831 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
1832 << gCompatibilityMatrixConverter.lastError();
1833 EXPECT_TRUE(runtime.checkCompatibility(cm, &error));
1834
1835 xml =
1836 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1837 " <kernel version=\"3.18.22\"/>\n"
1838 " <kernel version=\"3.18.22\">\n"
1839 " <conditions>\n"
1840 " <config>\n"
1841 " <key>CONFIG_64BIT</key>\n"
1842 " <value type=\"tristate\">y</value>\n"
1843 " </config>\n"
1844 " <config>\n"
1845 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
1846 " <value type=\"int\">24</value>\n"
1847 " </config>\n"
1848 " </conditions>\n"
1849 " <config>\n"
1850 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
1851 " <value type=\"int\">0xbeaf000000000000</value>\n"
1852 " </config>\n"
1853 " </kernel>\n"
1854 " <sepolicy>\n"
1855 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1856 " </sepolicy>\n"
1857 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
1858 "</compatibility-matrix>\n";
1859
1860 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
1861 << gCompatibilityMatrixConverter.lastError();
1862 EXPECT_FALSE(runtime.checkCompatibility(cm, &error))
1863 << "conditions have 'and' relationship, so CONFIG_ILLEGAL_POINTER_VALUE should not match";
1864
1865 xml =
1866 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1867 " <kernel version=\"3.18.22\"/>\n"
1868 " <kernel version=\"3.18.22\">\n"
1869 " <conditions>\n"
1870 " <config>\n"
1871 " <key>CONFIG_64BIT</key>\n"
1872 " <value type=\"tristate\">y</value>\n"
1873 " </config>\n"
1874 " <config>\n"
1875 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
1876 " <value type=\"int\">26</value>\n"
1877 " </config>\n"
1878 " </conditions>\n"
1879 " <config>\n"
1880 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
1881 " <value type=\"int\">0xbeaf000000000000</value>\n"
1882 " </config>\n"
1883 " </kernel>\n"
1884 " <sepolicy>\n"
1885 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1886 " </sepolicy>\n"
1887 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
1888 "</compatibility-matrix>\n";
1889
1890 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
1891 << gCompatibilityMatrixConverter.lastError();
1892 EXPECT_TRUE(runtime.checkCompatibility(cm, &error)) << error;
1893
1894 xml =
1895 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1896 " <kernel version=\"3.18.22\">\n"
1897 " <config>\n"
1898 " <key>CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES</key>\n"
1899 " <value type=\"string\"/>\n"
1900 " </config>\n"
1901 " </kernel>\n"
1902 " <kernel version=\"3.18.22\">\n"
1903 " <conditions>\n"
1904 " <config>\n"
1905 " <key>CONFIG_64BIT</key>\n"
1906 " <value type=\"tristate\">y</value>\n"
1907 " </config>\n"
1908 " </conditions>\n"
1909 " <config>\n"
1910 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
1911 " <value type=\"int\">0xdead000000000000</value>\n"
1912 " </config>\n"
1913 " </kernel>\n"
1914 " <kernel version=\"3.18.22\">\n"
1915 " <conditions>\n"
1916 " <config>\n"
1917 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
1918 " <value type=\"int\">24</value>\n"
1919 " </config>\n"
1920 " </conditions>\n"
1921 " <config>\n"
1922 " <key>CONFIG_ANDROID_BINDER_DEVICES</key>\n"
1923 " <value type=\"string\">binder,hwbinder</value>\n"
1924 " </config>\n"
1925 " </kernel>\n"
1926 " <sepolicy>\n"
1927 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1928 " </sepolicy>\n"
1929 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
1930 "</compatibility-matrix>\n";
1931
1932 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
1933 << gCompatibilityMatrixConverter.lastError();
1934 EXPECT_TRUE(runtime.checkCompatibility(cm, &error)) << error;
1935
1936 xml =
1937 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1938 " <kernel version=\"3.18.22\">\n"
1939 " <config>\n"
1940 " <key>CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES</key>\n"
1941 " <value type=\"string\"/>\n"
1942 " </config>\n"
1943 " </kernel>\n"
1944 " <kernel version=\"3.18.22\">\n"
1945 " <conditions>\n"
1946 " <config>\n"
1947 " <key>CONFIG_64BIT</key>\n"
1948 " <value type=\"tristate\">y</value>\n"
1949 " </config>\n"
1950 " </conditions>\n"
1951 " <config>\n"
1952 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
1953 " <value type=\"int\">0xbeaf000000000000</value>\n"
1954 " </config>\n"
1955 " </kernel>\n"
1956 " <kernel version=\"3.18.22\">\n"
1957 " <conditions>\n"
1958 " <config>\n"
1959 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
1960 " <value type=\"int\">24</value>\n"
1961 " </config>\n"
1962 " </conditions>\n"
1963 " <config>\n"
1964 " <key>CONFIG_ANDROID_BINDER_DEVICES</key>\n"
1965 " <value type=\"string\">binder,hwbinder</value>\n"
1966 " </config>\n"
1967 " </kernel>\n"
1968 " <sepolicy>\n"
1969 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1970 " </sepolicy>\n"
1971 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
1972 "</compatibility-matrix>\n";
1973
1974 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
1975 << gCompatibilityMatrixConverter.lastError();
1976 EXPECT_FALSE(runtime.checkCompatibility(cm, &error)) << "all fragments should be used.";
1977
1978 xml =
1979 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1980 " <kernel version=\"3.18.22\">\n"
1981 " <config>\n"
1982 " <key>CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES</key>\n"
1983 " <value type=\"string\"/>\n"
1984 " </config>\n"
1985 " </kernel>\n"
1986 " <kernel version=\"3.18.22\">\n"
1987 " <conditions>\n"
1988 " <config>\n"
1989 " <key>CONFIG_64BIT</key>\n"
1990 " <value type=\"tristate\">y</value>\n"
1991 " </config>\n"
1992 " </conditions>\n"
1993 " <config>\n"
1994 " <key>CONFIG_ILLEGAL_POINTER_VALUE</key>\n"
1995 " <value type=\"int\">0xdead000000000000</value>\n"
1996 " </config>\n"
1997 " </kernel>\n"
1998 " <kernel version=\"3.18.22\">\n"
1999 " <conditions>\n"
2000 " <config>\n"
2001 " <key>CONFIG_ARCH_MMAP_RND_BITS</key>\n"
2002 " <value type=\"int\">24</value>\n"
2003 " </config>\n"
2004 " </conditions>\n"
2005 " <config>\n"
2006 " <key>CONFIG_ANDROID_BINDER_DEVICES</key>\n"
2007 " <value type=\"string\">binder</value>\n"
2008 " </config>\n"
2009 " </kernel>\n"
2010 " <sepolicy>\n"
2011 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
2012 " </sepolicy>\n"
2013 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
2014 "</compatibility-matrix>\n";
2015
2016 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
2017 << gCompatibilityMatrixConverter.lastError();
2018 EXPECT_FALSE(runtime.checkCompatibility(cm, &error)) << "all fragments should be used";
2019 }
2020
2021 // Run KernelConfigParserInvalidTest on processComments = {true, false}
2022 class KernelConfigParserInvalidTest : public ::testing::TestWithParam<bool> {};
2023
TEST_P(KernelConfigParserInvalidTest,NonSet1)2024 TEST_P(KernelConfigParserInvalidTest, NonSet1) {
2025 const std::string data = "# CONFIG_NOT_EXIST is not sat\n";
2026 auto pair = processData(data, GetParam() /* processComments */, true /* relaxedFormat */);
2027 ASSERT_EQ(OK, pair.second) << pair.first.error();
2028 const auto& configs = pair.first.configs();
2029 EXPECT_EQ(configs.find("CONFIG_NOT_EXIST"), configs.end())
2030 << "CONFIG_NOT_EXIST should not exist because of typo";
2031 }
2032
TEST_P(KernelConfigParserInvalidTest,InvalidLine1)2033 TEST_P(KernelConfigParserInvalidTest, InvalidLine1) {
2034 const std::string data = "FOO_CONFIG=foo\n";
2035 ASSERT_NE(OK,
2036 processData(data, GetParam() /* processComments */, true /* relaxedFormat */).second);
2037 }
2038
TEST_P(KernelConfigParserInvalidTest,InvalidLine2)2039 TEST_P(KernelConfigParserInvalidTest, InvalidLine2) {
2040 const std::string data = "CONFIG_BAR-BAZ=foo\n";
2041 ASSERT_NE(OK,
2042 processData(data, GetParam() /* processComments */, true /* relaxedFormat */).second);
2043 }
2044
2045 INSTANTIATE_TEST_CASE_P(KernelConfigParser, KernelConfigParserInvalidTest, ::testing::Bool());
2046
TEST_F(LibVintfTest,MatrixLevel)2047 TEST_F(LibVintfTest, MatrixLevel) {
2048 CompatibilityMatrix cm;
2049 std::string xml;
2050
2051 xml = "<compatibility-matrix version=\"1.0\" type=\"framework\"/>";
2052 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
2053 << gCompatibilityMatrixConverter.lastError();
2054 EXPECT_EQ(Level::UNSPECIFIED, cm.level());
2055
2056 xml = "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"legacy\"/>";
2057 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
2058 << gCompatibilityMatrixConverter.lastError();
2059 EXPECT_EQ(Level::LEGACY, cm.level());
2060
2061 xml = "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\"/>";
2062 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
2063 << gCompatibilityMatrixConverter.lastError();
2064 EXPECT_EQ(1u, cm.level());
2065 }
2066
TEST_F(LibVintfTest,ManifestLevel)2067 TEST_F(LibVintfTest, ManifestLevel) {
2068 HalManifest manifest;
2069 std::string xml;
2070
2071 xml = "<manifest version=\"1.0\" type=\"device\"/>";
2072 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2073 EXPECT_EQ(Level::UNSPECIFIED, manifest.level());
2074
2075 xml = "<manifest version=\"1.0\" type=\"device\" target-level=\"legacy\"/>";
2076 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2077 EXPECT_EQ(Level::LEGACY, manifest.level());
2078
2079 xml = "<manifest version=\"1.0\" type=\"device\" target-level=\"1\"/>";
2080 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2081 EXPECT_EQ(1u, manifest.level());
2082 }
2083
TEST_F(LibVintfTest,AddOptionalHal)2084 TEST_F(LibVintfTest, AddOptionalHal) {
2085 CompatibilityMatrix cm1;
2086 CompatibilityMatrix cm2;
2087 std::string error;
2088 std::string xml;
2089
2090 xml = "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\"/>";
2091 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm1, xml))
2092 << gCompatibilityMatrixConverter.lastError();
2093
2094 xml =
2095 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"2\">\n"
2096 " <hal format=\"hidl\" optional=\"false\">\n"
2097 " <name>android.hardware.foo</name>\n"
2098 " <version>1.0-1</version>\n"
2099 " <interface>\n"
2100 " <name>IFoo</name>\n"
2101 " <instance>default</instance>\n"
2102 " </interface>\n"
2103 " </hal>\n"
2104 "</compatibility-matrix>\n";
2105 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml))
2106 << gCompatibilityMatrixConverter.lastError();
2107
2108 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2109 xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
2110 EXPECT_EQ(xml,
2111 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2112 " <hal format=\"hidl\" optional=\"true\">\n"
2113 " <name>android.hardware.foo</name>\n"
2114 " <version>1.0-1</version>\n"
2115 " <interface>\n"
2116 " <name>IFoo</name>\n"
2117 " <instance>default</instance>\n"
2118 " </interface>\n"
2119 " </hal>\n"
2120 "</compatibility-matrix>\n");
2121 }
2122
TEST_F(LibVintfTest,AddOptionalHalMinorVersion)2123 TEST_F(LibVintfTest, AddOptionalHalMinorVersion) {
2124 CompatibilityMatrix cm1;
2125 CompatibilityMatrix cm2;
2126 std::string error;
2127 std::string xml;
2128
2129 xml =
2130 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2131 " <hal format=\"hidl\" optional=\"false\">\n"
2132 " <name>android.hardware.foo</name>\n"
2133 " <version>1.2-3</version>\n"
2134 " <interface>\n"
2135 " <name>IFoo</name>\n"
2136 " <instance>default</instance>\n"
2137 " </interface>\n"
2138 " </hal>\n"
2139 "</compatibility-matrix>\n";
2140 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm1, xml))
2141 << gCompatibilityMatrixConverter.lastError();
2142
2143 xml =
2144 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"2\">\n"
2145 " <hal format=\"hidl\" optional=\"false\">\n"
2146 " <name>android.hardware.foo</name>\n"
2147 " <version>1.0-4</version>\n"
2148 " <interface>\n"
2149 " <name>IFoo</name>\n"
2150 " <instance>default</instance>\n"
2151 " </interface>\n"
2152 " </hal>\n"
2153 "</compatibility-matrix>\n";
2154 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml))
2155 << gCompatibilityMatrixConverter.lastError();
2156
2157 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2158 xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
2159 EXPECT_EQ(xml,
2160 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2161 " <hal format=\"hidl\" optional=\"false\">\n"
2162 " <name>android.hardware.foo</name>\n"
2163 " <version>1.0-4</version>\n"
2164 " <interface>\n"
2165 " <name>IFoo</name>\n"
2166 " <instance>default</instance>\n"
2167 " </interface>\n"
2168 " </hal>\n"
2169 "</compatibility-matrix>\n");
2170 }
2171
TEST_F(LibVintfTest,AddOptionalHalMajorVersion)2172 TEST_F(LibVintfTest, AddOptionalHalMajorVersion) {
2173 CompatibilityMatrix cm1;
2174 CompatibilityMatrix cm2;
2175 std::string error;
2176 std::string xml;
2177
2178 xml =
2179 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2180 " <hal format=\"hidl\" optional=\"false\">\n"
2181 " <name>android.hardware.foo</name>\n"
2182 " <version>1.2-3</version>\n"
2183 " <interface>\n"
2184 " <name>IFoo</name>\n"
2185 " <instance>default</instance>\n"
2186 " </interface>\n"
2187 " </hal>\n"
2188 "</compatibility-matrix>\n";
2189 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm1, xml))
2190 << gCompatibilityMatrixConverter.lastError();
2191
2192 xml =
2193 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"2\">\n"
2194 " <hal format=\"hidl\" optional=\"false\">\n"
2195 " <name>android.hardware.foo</name>\n"
2196 " <version>1.2-3</version>\n"
2197 " <version>2.0-4</version>\n"
2198 " <interface>\n"
2199 " <name>IFoo</name>\n"
2200 " <instance>default</instance>\n"
2201 " </interface>\n"
2202 " </hal>\n"
2203 "</compatibility-matrix>\n";
2204 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml))
2205 << gCompatibilityMatrixConverter.lastError();
2206
2207 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2208 xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
2209 EXPECT_EQ(xml,
2210 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2211 " <hal format=\"hidl\" optional=\"false\">\n"
2212 " <name>android.hardware.foo</name>\n"
2213 " <version>1.2-3</version>\n"
2214 " <version>2.0-4</version>\n"
2215 " <interface>\n"
2216 " <name>IFoo</name>\n"
2217 " <instance>default</instance>\n"
2218 " </interface>\n"
2219 " </hal>\n"
2220 "</compatibility-matrix>\n");
2221 }
2222
TEST_F(LibVintfTest,AddOptionalHalMinorVersionDiffInstance)2223 TEST_F(LibVintfTest, AddOptionalHalMinorVersionDiffInstance) {
2224 CompatibilityMatrix cm1;
2225 CompatibilityMatrix cm2;
2226 std::string error;
2227 std::string xml;
2228
2229 xml =
2230 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2231 " <hal format=\"hidl\" optional=\"false\">\n"
2232 " <name>android.hardware.foo</name>\n"
2233 " <version>1.0-1</version>\n"
2234 " <interface>\n"
2235 " <name>IFoo</name>\n"
2236 " <instance>default</instance>\n"
2237 " </interface>\n"
2238 " </hal>\n"
2239 "</compatibility-matrix>\n";
2240 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm1, xml))
2241 << gCompatibilityMatrixConverter.lastError();
2242
2243 xml =
2244 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"2\">\n"
2245 " <hal format=\"hidl\" optional=\"false\">\n"
2246 " <name>android.hardware.foo</name>\n"
2247 " <version>1.1-2</version>\n"
2248 " <interface>\n"
2249 " <name>IFoo</name>\n"
2250 " <instance>custom</instance>\n"
2251 " </interface>\n"
2252 " </hal>\n"
2253 "</compatibility-matrix>\n";
2254 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml))
2255 << gCompatibilityMatrixConverter.lastError();
2256
2257 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2258 xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
2259 EXPECT_EQ(xml,
2260 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2261 " <hal format=\"hidl\" optional=\"false\">\n"
2262 " <name>android.hardware.foo</name>\n"
2263 " <version>1.0-1</version>\n"
2264 " <interface>\n"
2265 " <name>IFoo</name>\n"
2266 " <instance>default</instance>\n"
2267 " </interface>\n"
2268 " </hal>\n"
2269 " <hal format=\"hidl\" optional=\"true\">\n"
2270 " <name>android.hardware.foo</name>\n"
2271 " <version>1.1-2</version>\n"
2272 " <interface>\n"
2273 " <name>IFoo</name>\n"
2274 " <instance>custom</instance>\n"
2275 " </interface>\n"
2276 " </hal>\n"
2277 "</compatibility-matrix>\n");
2278 }
2279
TEST_F(LibVintfTest,AddRequiredHalOverlapInstance)2280 TEST_F(LibVintfTest, AddRequiredHalOverlapInstance) {
2281 CompatibilityMatrix cm1;
2282 std::string error;
2283 std::string xml;
2284
2285 xml =
2286 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2287 " <hal format=\"hidl\" optional=\"false\">\n"
2288 " <name>android.hardware.foo</name>\n"
2289 " <version>1.0</version>\n"
2290 " <interface>\n"
2291 " <name>IFoo</name>\n"
2292 " <instance>default</instance>\n"
2293 " <instance>custom</instance>\n"
2294 " </interface>\n"
2295 " </hal>\n"
2296 "</compatibility-matrix>\n";
2297 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm1, xml))
2298 << gCompatibilityMatrixConverter.lastError();
2299
2300 {
2301 // Test that 2.0 should be added to IFoo/default, so 1.0::IFoo/custom
2302 // should be in a new <hal> tag
2303 CompatibilityMatrix cm2;
2304 xml =
2305 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"2\">\n"
2306 " <hal format=\"hidl\" optional=\"false\">\n"
2307 " <name>android.hardware.foo</name>\n"
2308 " <version>2.0</version>\n"
2309 " <interface>\n"
2310 " <name>IFoo</name>\n"
2311 " <instance>default</instance>\n"
2312 " </interface>\n"
2313 " </hal>\n"
2314 "</compatibility-matrix>\n";
2315 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml))
2316 << gCompatibilityMatrixConverter.lastError();
2317
2318 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2319
2320 xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
2321 EXPECT_EQ(xml,
2322 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2323 " <hal format=\"hidl\" optional=\"false\">\n"
2324 " <name>android.hardware.foo</name>\n"
2325 " <version>1.0</version>\n"
2326 " <interface>\n"
2327 " <name>IFoo</name>\n"
2328 " <instance>custom</instance>\n"
2329 " </interface>\n"
2330 " </hal>\n"
2331 " <hal format=\"hidl\" optional=\"false\">\n"
2332 " <name>android.hardware.foo</name>\n"
2333 " <version>1.0</version>\n"
2334 " <version>2.0</version>\n"
2335 " <interface>\n"
2336 " <name>IFoo</name>\n"
2337 " <instance>default</instance>\n"
2338 " </interface>\n"
2339 " </hal>\n"
2340 "</compatibility-matrix>\n");
2341 }
2342
2343 {
2344 // Test that 2.0::IFoo/strong should be added as an optional <hal> tag.
2345 CompatibilityMatrix cm2;
2346 xml =
2347 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"2\">\n"
2348 " <hal format=\"hidl\" optional=\"false\">\n"
2349 " <name>android.hardware.foo</name>\n"
2350 " <version>2.0</version>\n"
2351 " <interface>\n"
2352 " <name>IFoo</name>\n"
2353 " <instance>default</instance>\n"
2354 " <instance>strong</instance>\n"
2355 " </interface>\n"
2356 " </hal>\n"
2357 "</compatibility-matrix>\n";
2358 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml))
2359 << gCompatibilityMatrixConverter.lastError();
2360
2361 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2362
2363 xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
2364 EXPECT_EQ(xml,
2365 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2366 " <hal format=\"hidl\" optional=\"false\">\n"
2367 " <name>android.hardware.foo</name>\n"
2368 " <version>1.0</version>\n"
2369 " <interface>\n"
2370 " <name>IFoo</name>\n"
2371 " <instance>custom</instance>\n"
2372 " </interface>\n"
2373 " </hal>\n"
2374 " <hal format=\"hidl\" optional=\"false\">\n"
2375 " <name>android.hardware.foo</name>\n"
2376 " <version>1.0</version>\n"
2377 " <version>2.0</version>\n"
2378 " <interface>\n"
2379 " <name>IFoo</name>\n"
2380 " <instance>default</instance>\n"
2381 " </interface>\n"
2382 " </hal>\n"
2383 " <hal format=\"hidl\" optional=\"true\">\n"
2384 " <name>android.hardware.foo</name>\n"
2385 " <version>2.0</version>\n"
2386 " <interface>\n"
2387 " <name>IFoo</name>\n"
2388 " <instance>strong</instance>\n"
2389 " </interface>\n"
2390 " </hal>\n"
2391 "</compatibility-matrix>\n");
2392 }
2393 }
2394
TEST_F(LibVintfTest,AddRequiredHalOverlapInstanceSplit)2395 TEST_F(LibVintfTest, AddRequiredHalOverlapInstanceSplit) {
2396 CompatibilityMatrix cm1;
2397 CompatibilityMatrix cm2;
2398 std::string error;
2399 std::string xml;
2400
2401 xml =
2402 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2403 " <hal format=\"hidl\" optional=\"false\">\n"
2404 " <name>android.hardware.foo</name>\n"
2405 " <version>1.0</version>\n"
2406 " <interface>\n"
2407 " <name>IFoo</name>\n"
2408 " <instance>default</instance>\n"
2409 " </interface>\n"
2410 " </hal>\n"
2411 " <hal format=\"hidl\" optional=\"false\">\n"
2412 " <name>android.hardware.foo</name>\n"
2413 " <version>1.0</version>\n"
2414 " <interface>\n"
2415 " <name>IFoo</name>\n"
2416 " <instance>custom</instance>\n"
2417 " </interface>\n"
2418 " </hal>\n"
2419 "</compatibility-matrix>\n";
2420 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm1, xml))
2421 << gCompatibilityMatrixConverter.lastError();
2422
2423 xml =
2424 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"2\">\n"
2425 " <hal format=\"hidl\" optional=\"false\">\n"
2426 " <name>android.hardware.foo</name>\n"
2427 " <version>2.0</version>\n"
2428 " <interface>\n"
2429 " <name>IFoo</name>\n"
2430 " <instance>default</instance>\n"
2431 " </interface>\n"
2432 " </hal>\n"
2433 " <hal format=\"hidl\" optional=\"false\">\n"
2434 " <name>android.hardware.foo</name>\n"
2435 " <version>2.0</version>\n"
2436 " <interface>\n"
2437 " <name>IFoo</name>\n"
2438 " <instance>strong</instance>\n"
2439 " </interface>\n"
2440 " </hal>\n"
2441 "</compatibility-matrix>\n";
2442 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml))
2443 << gCompatibilityMatrixConverter.lastError();
2444
2445 EXPECT_TRUE(addAllHalsAsOptional(&cm1, &cm2, &error)) << error;
2446 xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::HALS_ONLY);
2447 EXPECT_EQ(
2448 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2449 " <hal format=\"hidl\" optional=\"false\">\n"
2450 " <name>android.hardware.foo</name>\n"
2451 " <version>1.0</version>\n"
2452 " <version>2.0</version>\n"
2453 " <interface>\n"
2454 " <name>IFoo</name>\n"
2455 " <instance>default</instance>\n"
2456 " </interface>\n"
2457 " </hal>\n"
2458 " <hal format=\"hidl\" optional=\"false\">\n"
2459 " <name>android.hardware.foo</name>\n"
2460 " <version>1.0</version>\n"
2461 " <interface>\n"
2462 " <name>IFoo</name>\n"
2463 " <instance>custom</instance>\n"
2464 " </interface>\n"
2465 " </hal>\n"
2466 " <hal format=\"hidl\" optional=\"true\">\n"
2467 " <name>android.hardware.foo</name>\n"
2468 " <version>2.0</version>\n"
2469 " <interface>\n"
2470 " <name>IFoo</name>\n"
2471 " <instance>strong</instance>\n"
2472 " </interface>\n"
2473 " </hal>\n"
2474 "</compatibility-matrix>\n",
2475 xml);
2476 }
TEST_F(LibVintfTest,AddOptionalXmlFile)2477 TEST_F(LibVintfTest, AddOptionalXmlFile) {
2478 CompatibilityMatrix cm1;
2479 CompatibilityMatrix cm2;
2480 std::string error;
2481 std::string xml;
2482
2483 xml =
2484 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2485 " <xmlfile format=\"xsd\" optional=\"true\">\n"
2486 " <name>foo</name>\n"
2487 " <version>1.0-2</version>\n"
2488 " <path>/foo/bar/baz.xsd</path>\n"
2489 " </xmlfile>\n"
2490 "</compatibility-matrix>\n";
2491 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm1, xml))
2492 << gCompatibilityMatrixConverter.lastError();
2493
2494 xml =
2495 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"2\">\n"
2496 " <xmlfile format=\"xsd\" optional=\"true\">\n"
2497 " <name>foo</name>\n"
2498 " <version>1.1-3</version>\n"
2499 " <path>/foo/bar/quux.xsd</path>\n"
2500 " </xmlfile>\n"
2501 "</compatibility-matrix>\n";
2502 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml))
2503 << gCompatibilityMatrixConverter.lastError();
2504
2505 EXPECT_TRUE(addAllXmlFilesAsOptional(&cm1, &cm2, &error)) << error;
2506 xml = gCompatibilityMatrixConverter(cm1, SerializeFlag::XMLFILES_ONLY);
2507 EXPECT_EQ(xml,
2508 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"1\">\n"
2509 " <xmlfile format=\"xsd\" optional=\"true\">\n"
2510 " <name>foo</name>\n"
2511 " <version>1.0-2</version>\n"
2512 " <path>/foo/bar/baz.xsd</path>\n"
2513 " </xmlfile>\n"
2514 " <xmlfile format=\"xsd\" optional=\"true\">\n"
2515 " <name>foo</name>\n"
2516 " <version>1.1-3</version>\n"
2517 " <path>/foo/bar/quux.xsd</path>\n"
2518 " </xmlfile>\n"
2519 "</compatibility-matrix>\n");
2520 }
2521
TEST_F(LibVintfTest,VendorNdk)2522 TEST_F(LibVintfTest, VendorNdk) {
2523 CompatibilityMatrix cm;
2524 std::string error;
2525 std::string xml;
2526
2527 xml =
2528 "<compatibility-matrix version=\"1.0\" type=\"device\">\n"
2529 " <vendor-ndk>\n"
2530 " <version>P</version>\n"
2531 " <library>libbase.so</library>\n"
2532 " <library>libjpeg.so</library>\n"
2533 " </vendor-ndk>\n"
2534 "</compatibility-matrix>\n";
2535 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
2536 << gCompatibilityMatrixConverter.lastError();
2537 EXPECT_EQ(xml, gCompatibilityMatrixConverter(cm));
2538
2539 {
2540 HalManifest manifest;
2541 xml =
2542 "<manifest version=\"1.0\" type=\"framework\">\n"
2543 " <vendor-ndk>\n"
2544 " <version>27</version>\n"
2545 " <library>libbase.so</library>\n"
2546 " <library>libjpeg.so</library>\n"
2547 " </vendor-ndk>\n"
2548 " <vendor-ndk>\n"
2549 " <version>P</version>\n"
2550 " <library>libbase.so</library>\n"
2551 " <library>libjpeg.so</library>\n"
2552 " <library>libtinyxml2.so</library>\n"
2553 " </vendor-ndk>\n"
2554 "</manifest>\n";
2555
2556 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2557 EXPECT_EQ(xml, gHalManifestConverter(manifest));
2558 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
2559 }
2560
2561 {
2562 HalManifest manifest;
2563 xml =
2564 "<manifest version=\"1.0\" type=\"framework\">\n"
2565 " <vendor-ndk>\n"
2566 " <version>27</version>\n"
2567 " <library>libbase.so</library>\n"
2568 " <library>libjpeg.so</library>\n"
2569 " </vendor-ndk>\n"
2570 "</manifest>\n";
2571
2572 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2573 EXPECT_EQ(xml, gHalManifestConverter(manifest));
2574 EXPECT_FALSE(manifest.checkCompatibility(cm, &error));
2575 EXPECT_IN("Vndk version P is not supported.", error);
2576 }
2577
2578 {
2579 HalManifest manifest;
2580 xml =
2581 "<manifest version=\"1.0\" type=\"framework\">\n"
2582 " <vendor-ndk>\n"
2583 " <version>P</version>\n"
2584 " <library>libbase.so</library>\n"
2585 " </vendor-ndk>\n"
2586 "</manifest>\n";
2587
2588 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2589 EXPECT_EQ(xml, gHalManifestConverter(manifest));
2590 EXPECT_FALSE(manifest.checkCompatibility(cm, &error));
2591 EXPECT_IN("Vndk libs incompatible for version P.", error);
2592 EXPECT_IN("libjpeg.so", error);
2593 }
2594 }
2595
TEST_F(LibVintfTest,MissingVendorNdkInMatrix)2596 TEST_F(LibVintfTest, MissingVendorNdkInMatrix) {
2597 CompatibilityMatrix cm;
2598 std::string xml;
2599 std::string error;
2600
2601 xml = "<compatibility-matrix version=\"1.0\" type=\"device\"/>\n";
2602 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
2603 << gCompatibilityMatrixConverter.lastError();
2604
2605 {
2606 HalManifest manifest;
2607 xml = "<manifest version=\"1.0\" type=\"framework\"/>\n";
2608 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2609
2610 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
2611 }
2612
2613 {
2614 HalManifest manifest;
2615 xml =
2616 "<manifest version=\"1.0\" type=\"framework\">\n"
2617 " <vendor-ndk>\n"
2618 " <version>P</version>\n"
2619 " <library>libbase.so</library>\n"
2620 " </vendor-ndk>\n"
2621 "</manifest>\n";
2622 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2623
2624 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
2625 }
2626 }
2627
TEST_F(LibVintfTest,DuplicatedVendorNdkVersion)2628 TEST_F(LibVintfTest, DuplicatedVendorNdkVersion) {
2629 std::string error;
2630 HalManifest manifest;
2631 std::string xml =
2632 "<manifest version=\"1.0\" type=\"framework\">\n"
2633 " <vendor-ndk>\n"
2634 " <version>27</version>\n"
2635 " </vendor-ndk>\n"
2636 " <vendor-ndk>\n"
2637 " <version>27</version>\n"
2638 " </vendor-ndk>\n"
2639 "</manifest>\n";
2640
2641 EXPECT_FALSE(gHalManifestConverter(&manifest, xml));
2642 EXPECT_EQ("Duplicated manifest.vendor-ndk.version 27", gHalManifestConverter.lastError());
2643 }
2644
TEST_F(LibVintfTest,ManifestHalOverride)2645 TEST_F(LibVintfTest, ManifestHalOverride) {
2646 HalManifest manifest;
2647 std::string xml =
2648 "<manifest version=\"1.0\" type=\"device\">\n"
2649 " <hal format=\"hidl\" override=\"true\">\n"
2650 " <name>android.hardware.foo</name>\n"
2651 " <transport>hwbinder</transport>\n"
2652 " <version>1.0</version>\n"
2653 " </hal>\n"
2654 " <hal format=\"hidl\">\n"
2655 " <name>android.hardware.bar</name>\n"
2656 " <transport>hwbinder</transport>\n"
2657 " <version>1.0</version>\n"
2658 " </hal>\n"
2659 "</manifest>\n";
2660 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2661 const auto& foo = manifest.getHals("android.hardware.foo");
2662 ASSERT_FALSE(foo.empty());
2663 EXPECT_TRUE(foo.front()->isOverride());
2664 const auto& bar = manifest.getHals("android.hardware.bar");
2665 ASSERT_FALSE(bar.empty());
2666 EXPECT_FALSE(bar.front()->isOverride());
2667 }
2668
2669 // Test functionality of override="true" tag
TEST_F(LibVintfTest,ManifestAddOverrideHalSimple)2670 TEST_F(LibVintfTest, ManifestAddOverrideHalSimple) {
2671 HalManifest manifest;
2672 std::string xml = "<manifest version=\"1.0\" type=\"device\"/>\n";
2673 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2674
2675 HalManifest newManifest;
2676 xml =
2677 "<manifest version=\"1.0\" type=\"device\">\n"
2678 " <hal format=\"hidl\" override=\"true\">\n"
2679 " <name>android.hardware.foo</name>\n"
2680 " <transport>hwbinder</transport>\n"
2681 " <version>1.1</version>\n"
2682 " <interface>\n"
2683 " <name>IFoo</name>\n"
2684 " <instance>default</instance>\n"
2685 " </interface>\n"
2686 " </hal>\n"
2687 "</manifest>\n";
2688 EXPECT_TRUE(gHalManifestConverter(&newManifest, xml)) << gHalManifestConverter.lastError();
2689
2690 manifest.addAllHals(&newManifest);
2691 EXPECT_EQ(xml, gHalManifestConverter(manifest, SerializeFlag::HALS_NO_FQNAME));
2692 }
2693
TEST_F(LibVintfTest,ManifestAddOverrideHalSimpleOverride)2694 TEST_F(LibVintfTest, ManifestAddOverrideHalSimpleOverride) {
2695 HalManifest manifest;
2696 std::string xml =
2697 "<manifest version=\"1.0\" type=\"device\">\n"
2698 " <hal format=\"hidl\">\n"
2699 " <name>android.hardware.foo</name>\n"
2700 " <transport>hwbinder</transport>\n"
2701 " <version>1.0</version>\n"
2702 " </hal>\n"
2703 "</manifest>\n";
2704 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2705
2706 HalManifest newManifest;
2707 xml =
2708 "<manifest version=\"1.0\" type=\"device\">\n"
2709 " <hal format=\"hidl\" override=\"true\">\n"
2710 " <name>android.hardware.foo</name>\n"
2711 " <transport>hwbinder</transport>\n"
2712 " <version>1.1</version>\n"
2713 " <interface>\n"
2714 " <name>IFoo</name>\n"
2715 " <instance>default</instance>\n"
2716 " </interface>\n"
2717 " </hal>\n"
2718 "</manifest>\n";
2719 EXPECT_TRUE(gHalManifestConverter(&newManifest, xml)) << gHalManifestConverter.lastError();
2720
2721 manifest.addAllHals(&newManifest);
2722 EXPECT_EQ(xml, gHalManifestConverter(manifest, SerializeFlag::HALS_NO_FQNAME));
2723 }
2724
2725 // Existing major versions should be removed.
TEST_F(LibVintfTest,ManifestAddOverrideHalMultiVersion)2726 TEST_F(LibVintfTest, ManifestAddOverrideHalMultiVersion) {
2727 HalManifest manifest;
2728 std::string xml =
2729 "<manifest version=\"1.0\" type=\"device\">\n"
2730 " <hal format=\"hidl\">\n"
2731 " <name>android.hardware.foo</name>\n"
2732 " <transport>hwbinder</transport>\n"
2733 " <version>1.3</version>\n"
2734 " <version>2.4</version>\n"
2735 " <interface>\n"
2736 " <name>IFoo</name>\n"
2737 " <instance>slot1</instance>\n"
2738 " </interface>\n"
2739 " </hal>\n"
2740 " <hal format=\"hidl\">\n"
2741 " <name>android.hardware.bar</name>\n"
2742 " <transport>hwbinder</transport>\n"
2743 " <version>1.3</version>\n"
2744 " </hal>\n"
2745 "</manifest>\n";
2746 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2747
2748 HalManifest newManifest;
2749 xml =
2750 "<manifest version=\"1.0\" type=\"device\">\n"
2751 " <hal format=\"hidl\" override=\"true\">\n"
2752 " <name>android.hardware.foo</name>\n"
2753 " <transport>hwbinder</transport>\n"
2754 " <version>1.1</version>\n"
2755 " <version>3.1</version>\n"
2756 " <interface>\n"
2757 " <name>IFoo</name>\n"
2758 " <instance>slot2</instance>\n"
2759 " </interface>\n"
2760 " </hal>\n"
2761 "</manifest>\n";
2762 EXPECT_TRUE(gHalManifestConverter(&newManifest, xml)) << gHalManifestConverter.lastError();
2763
2764 manifest.addAllHals(&newManifest);
2765 EXPECT_EQ(
2766 "<manifest version=\"1.0\" type=\"device\">\n"
2767 " <hal format=\"hidl\">\n"
2768 " <name>android.hardware.bar</name>\n"
2769 " <transport>hwbinder</transport>\n"
2770 " <version>1.3</version>\n"
2771 " </hal>\n"
2772 " <hal format=\"hidl\">\n"
2773 " <name>android.hardware.foo</name>\n"
2774 " <transport>hwbinder</transport>\n"
2775 " <version>2.4</version>\n"
2776 " <interface>\n"
2777 " <name>IFoo</name>\n"
2778 " <instance>slot1</instance>\n"
2779 " </interface>\n"
2780 " </hal>\n"
2781 " <hal format=\"hidl\" override=\"true\">\n"
2782 " <name>android.hardware.foo</name>\n"
2783 " <transport>hwbinder</transport>\n"
2784 " <version>1.1</version>\n"
2785 " <version>3.1</version>\n"
2786 " <interface>\n"
2787 " <name>IFoo</name>\n"
2788 " <instance>slot2</instance>\n"
2789 " </interface>\n"
2790 " </hal>\n"
2791 "</manifest>\n",
2792 gHalManifestConverter(manifest, SerializeFlag::HALS_NO_FQNAME));
2793 }
2794
TEST_F(LibVintfTest,ManifestAddOverrideHalMultiVersion2)2795 TEST_F(LibVintfTest, ManifestAddOverrideHalMultiVersion2) {
2796 HalManifest manifest;
2797 std::string xml =
2798 "<manifest version=\"1.0\" type=\"device\">\n"
2799 " <hal format=\"hidl\">\n"
2800 " <name>android.hardware.foo</name>\n"
2801 " <transport>hwbinder</transport>\n"
2802 " <version>1.3</version>\n"
2803 " <version>2.4</version>\n"
2804 " <interface>\n"
2805 " <name>IFoo</name>\n"
2806 " <instance>slot1</instance>\n"
2807 " </interface>\n"
2808 " </hal>\n"
2809 "</manifest>\n";
2810 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2811
2812 HalManifest newManifest;
2813 xml =
2814 "<manifest version=\"1.0\" type=\"device\">\n"
2815 " <hal format=\"hidl\" override=\"true\">\n"
2816 " <name>android.hardware.foo</name>\n"
2817 " <transport>hwbinder</transport>\n"
2818 " <version>1.1</version>\n"
2819 " <version>2.1</version>\n"
2820 " <interface>\n"
2821 " <name>IFoo</name>\n"
2822 " <instance>slot2</instance>\n"
2823 " </interface>\n"
2824 " </hal>\n"
2825 "</manifest>\n";
2826 EXPECT_TRUE(gHalManifestConverter(&newManifest, xml)) << gHalManifestConverter.lastError();
2827
2828 manifest.addAllHals(&newManifest);
2829 EXPECT_EQ(xml, gHalManifestConverter(manifest, SerializeFlag::HALS_NO_FQNAME));
2830 }
2831
2832 // if no <versions>, remove all existing <hal> with given <name>.
TEST_F(LibVintfTest,ManifestAddOverrideHalRemoveAll)2833 TEST_F(LibVintfTest, ManifestAddOverrideHalRemoveAll) {
2834 HalManifest manifest;
2835 std::string xml =
2836 "<manifest version=\"1.0\" type=\"device\">\n"
2837 " <hal format=\"hidl\">\n"
2838 " <name>android.hardware.foo</name>\n"
2839 " <transport>hwbinder</transport>\n"
2840 " <version>1.3</version>\n"
2841 " <version>2.4</version>\n"
2842 " <interface>\n"
2843 " <name>IFoo</name>\n"
2844 " <instance>slot1</instance>\n"
2845 " </interface>\n"
2846 " </hal>\n"
2847 " <hal format=\"hidl\">\n"
2848 " <name>android.hardware.foo</name>\n"
2849 " <transport>hwbinder</transport>\n"
2850 " <version>3.1</version>\n"
2851 " <version>4.3</version>\n"
2852 " <interface>\n"
2853 " <name>IBar</name>\n"
2854 " <instance>slot2</instance>\n"
2855 " </interface>\n"
2856 " </hal>\n"
2857 " <hal format=\"hidl\">\n"
2858 " <name>android.hardware.bar</name>\n"
2859 " <transport>hwbinder</transport>\n"
2860 " <version>1.3</version>\n"
2861 " </hal>\n"
2862 "</manifest>\n";
2863 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2864
2865 HalManifest newManifest;
2866 xml =
2867 "<manifest version=\"1.0\" type=\"device\">\n"
2868 " <hal format=\"hidl\" override=\"true\">\n"
2869 " <name>android.hardware.foo</name>\n"
2870 " <transport>hwbinder</transport>\n"
2871 " </hal>\n"
2872 "</manifest>\n";
2873 EXPECT_TRUE(gHalManifestConverter(&newManifest, xml)) << gHalManifestConverter.lastError();
2874
2875 manifest.addAllHals(&newManifest);
2876 EXPECT_EQ(
2877 "<manifest version=\"1.0\" type=\"device\">\n"
2878 " <hal format=\"hidl\">\n"
2879 " <name>android.hardware.bar</name>\n"
2880 " <transport>hwbinder</transport>\n"
2881 " <version>1.3</version>\n"
2882 " </hal>\n"
2883 " <hal format=\"hidl\" override=\"true\">\n"
2884 " <name>android.hardware.foo</name>\n"
2885 " <transport>hwbinder</transport>\n"
2886 " </hal>\n"
2887 "</manifest>\n",
2888 gHalManifestConverter(manifest, SerializeFlag::HALS_ONLY));
2889 }
2890
2891 // Make sure missing tags in old VINTF files does not cause incompatibilities.
TEST_F(LibVintfTest,Empty)2892 TEST_F(LibVintfTest, Empty) {
2893 CompatibilityMatrix cm;
2894 HalManifest manifest;
2895 std::string xml;
2896 std::string error;
2897
2898 xml = "<compatibility-matrix version=\"1.0\" type=\"device\"/>\n";
2899 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
2900 << gCompatibilityMatrixConverter.lastError();
2901
2902 xml = "<manifest version=\"1.0\" type=\"framework\"/>\n";
2903 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2904
2905 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
2906 }
2907
TEST_F(LibVintfTest,SystemSdk)2908 TEST_F(LibVintfTest, SystemSdk) {
2909 CompatibilityMatrix cm;
2910 std::string xml;
2911 std::string error;
2912
2913 xml =
2914 "<compatibility-matrix version=\"1.0\" type=\"device\">\n"
2915 " <system-sdk>\n"
2916 " <version>1</version>\n"
2917 " <version>P</version>\n"
2918 " </system-sdk>\n"
2919 "</compatibility-matrix>\n";
2920 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml))
2921 << gCompatibilityMatrixConverter.lastError();
2922 EXPECT_EQ(xml, gCompatibilityMatrixConverter(cm, ~SerializeFlag::NO_SSDK));
2923
2924 {
2925 HalManifest manifest;
2926 xml =
2927 "<manifest version=\"1.0\" type=\"framework\">\n"
2928 " <system-sdk>\n"
2929 " <version>1</version>\n"
2930 " <version>P</version>\n"
2931 " </system-sdk>\n"
2932 "</manifest>\n";
2933 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2934 EXPECT_EQ(xml, gHalManifestConverter(manifest, ~SerializeFlag::NO_SSDK));
2935
2936 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
2937 }
2938
2939 {
2940 HalManifest manifest;
2941 xml =
2942 "<manifest version=\"1.0\" type=\"framework\">\n"
2943 " <system-sdk>\n"
2944 " <version>1</version>\n"
2945 " <version>3</version>\n"
2946 " <version>P</version>\n"
2947 " </system-sdk>\n"
2948 "</manifest>\n";
2949 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2950 EXPECT_TRUE(manifest.checkCompatibility(cm, &error));
2951 }
2952
2953 {
2954 HalManifest manifest;
2955 xml =
2956 "<manifest version=\"1.0\" type=\"framework\">\n"
2957 " <system-sdk>\n"
2958 " <version>1</version>\n"
2959 " </system-sdk>\n"
2960 "</manifest>\n";
2961 EXPECT_TRUE(gHalManifestConverter(&manifest, xml)) << gHalManifestConverter.lastError();
2962 EXPECT_FALSE(manifest.checkCompatibility(cm, &error));
2963 EXPECT_TRUE(error.find("System SDK") != std::string::npos) << error;
2964 }
2965 }
2966
TEST_F(LibVintfTest,ManifestLastError)2967 TEST_F(LibVintfTest, ManifestLastError) {
2968 HalManifest e;
2969 // Set mLastError to something else before testing.
2970 EXPECT_FALSE(gHalManifestConverter(&e, "<manifest/>"));
2971 EXPECT_NE("Not a valid XML", gHalManifestConverter.lastError());
2972
2973 std::string error;
2974 std::string prevError = gHalManifestConverter.lastError();
2975 EXPECT_FALSE(gHalManifestConverter(&e, "", &error));
2976 EXPECT_EQ("Not a valid XML", error);
2977 EXPECT_EQ(prevError, gHalManifestConverter.lastError()) << "lastError() should not be modified";
2978 }
2979
TEST_F(LibVintfTest,MatrixLastError)2980 TEST_F(LibVintfTest, MatrixLastError) {
2981 CompatibilityMatrix e;
2982 // Set mLastError to something else before testing.
2983 EXPECT_FALSE(gCompatibilityMatrixConverter(&e, "<compatibility-matrix/>"));
2984 EXPECT_NE("Not a valid XML", gCompatibilityMatrixConverter.lastError());
2985
2986 std::string error;
2987 std::string prevError = gCompatibilityMatrixConverter.lastError();
2988 EXPECT_FALSE(gCompatibilityMatrixConverter(&e, "", &error));
2989 EXPECT_EQ("Not a valid XML", error);
2990 EXPECT_EQ(prevError, gCompatibilityMatrixConverter.lastError())
2991 << "lastError() should not be modified";
2992 }
2993
TEST_F(LibVintfTest,MatrixDetailErrorMsg)2994 TEST_F(LibVintfTest, MatrixDetailErrorMsg) {
2995 std::string error;
2996 std::string xml;
2997
2998 HalManifest manifest;
2999 xml =
3000 "<manifest version=\"1.0\" type=\"device\" target-level=\"103\">\n"
3001 " <hal format=\"hidl\">\n"
3002 " <name>android.hardware.foo</name>\n"
3003 " <transport>hwbinder</transport>\n"
3004 " <version>1.0</version>\n"
3005 " <interface>\n"
3006 " <name>IFoo</name>\n"
3007 " <instance>default</instance>\n"
3008 " </interface>\n"
3009 " </hal>\n"
3010 "</manifest>\n";
3011 ASSERT_TRUE(gHalManifestConverter(&manifest, xml, &error)) << error;
3012
3013 {
3014 CompatibilityMatrix cm;
3015 xml =
3016 "<compatibility-matrix version=\"1.0\" type=\"framework\" level=\"100\">\n"
3017 " <hal format=\"hidl\" optional=\"false\">\n"
3018 " <name>android.hardware.foo</name>\n"
3019 " <version>1.2-3</version>\n"
3020 " <version>4.5</version>\n"
3021 " <interface>\n"
3022 " <name>IFoo</name>\n"
3023 " <instance>default</instance>\n"
3024 " <instance>slot1</instance>\n"
3025 " </interface>\n"
3026 " <interface>\n"
3027 " <name>IBar</name>\n"
3028 " <instance>default</instance>\n"
3029 " </interface>\n"
3030 " </hal>\n"
3031 "</compatibility-matrix>\n";
3032 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml, &error)) << error;
3033 EXPECT_FALSE(manifest.checkCompatibility(cm, &error));
3034 EXPECT_IN("Manifest level = 103", error)
3035 EXPECT_IN("Matrix level = 100", error)
3036 EXPECT_IN(
3037 "android.hardware.foo:\n"
3038 " required: \n"
3039 " (@1.2-3::IBar/default AND @1.2-3::IFoo/default AND @1.2-3::IFoo/slot1) OR\n"
3040 " (@4.5::IBar/default AND @4.5::IFoo/default AND @4.5::IFoo/slot1)\n"
3041 " provided: @1.0::IFoo/default",
3042 error);
3043 }
3044
3045 {
3046 CompatibilityMatrix cm;
3047 xml =
3048 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
3049 " <hal format=\"hidl\" optional=\"false\">\n"
3050 " <name>android.hardware.foo</name>\n"
3051 " <version>1.2-3</version>\n"
3052 " <interface>\n"
3053 " <name>IFoo</name>\n"
3054 " <instance>default</instance>\n"
3055 " <instance>slot1</instance>\n"
3056 " </interface>\n"
3057 " </hal>\n"
3058 "</compatibility-matrix>\n";
3059 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml, &error)) << error;
3060 EXPECT_FALSE(manifest.checkCompatibility(cm, &error));
3061 EXPECT_IN(
3062 "android.hardware.foo:\n"
3063 " required: (@1.2-3::IFoo/default AND @1.2-3::IFoo/slot1)\n"
3064 " provided: @1.0::IFoo/default",
3065 error);
3066 }
3067
3068 // the most frequent use case.
3069 {
3070 CompatibilityMatrix cm;
3071 xml =
3072 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
3073 " <hal format=\"hidl\" optional=\"false\">\n"
3074 " <name>android.hardware.foo</name>\n"
3075 " <version>1.2-3</version>\n"
3076 " <interface>\n"
3077 " <name>IFoo</name>\n"
3078 " <instance>default</instance>\n"
3079 " </interface>\n"
3080 " </hal>\n"
3081 "</compatibility-matrix>\n";
3082 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml, &error)) << error;
3083 EXPECT_FALSE(manifest.checkCompatibility(cm, &error));
3084 EXPECT_IN(
3085 "android.hardware.foo:\n"
3086 " required: @1.2-3::IFoo/default\n"
3087 " provided: @1.0::IFoo/default",
3088 error);
3089 }
3090 }
3091
TEST_F(LibVintfTest,DisabledHal)3092 TEST_F(LibVintfTest, DisabledHal) {
3093 std::string error;
3094 std::string xml;
3095 HalManifest manifest;
3096 xml =
3097 "<manifest version=\"1.0\" type=\"framework\">\n"
3098 " <hal format=\"hidl\" override=\"true\">\n"
3099 " <transport>hwbinder</transport>\n"
3100 " <name>android.hardware.foo</name>\n"
3101 " <transport>hwbinder</transport>\n"
3102 " </hal>\n"
3103 " <hal format=\"hidl\" override=\"true\">\n"
3104 " <name>android.hardware.bar</name>\n"
3105 " <transport>hwbinder</transport>\n"
3106 " <fqname>@1.1::IFoo/custom</fqname>\n"
3107 " </hal>\n"
3108 " <hal format=\"hidl\">\n"
3109 " <name>android.hardware.baz</name>\n"
3110 " <transport>hwbinder</transport>\n"
3111 " </hal>\n"
3112 "</manifest>\n";
3113 ASSERT_TRUE(gHalManifestConverter(&manifest, xml, &error)) << error;
3114
3115 auto foo = manifest.getHals("android.hardware.foo");
3116 ASSERT_EQ(1u, foo.size());
3117 EXPECT_TRUE(foo.front()->isDisabledHal());
3118 auto bar = manifest.getHals("android.hardware.bar");
3119 ASSERT_EQ(1u, bar.size());
3120 EXPECT_FALSE(bar.front()->isDisabledHal());
3121 auto baz = manifest.getHals("android.hardware.baz");
3122 ASSERT_EQ(1u, baz.size());
3123 EXPECT_FALSE(baz.front()->isDisabledHal());
3124 }
3125
TEST_F(LibVintfTest,FqNameValid)3126 TEST_F(LibVintfTest, FqNameValid) {
3127 std::string error;
3128 std::string xml;
3129
3130 CompatibilityMatrix cm;
3131 xml =
3132 "<compatibility-matrix version=\"1.0\" type=\"device\">\n"
3133 " <hal format=\"hidl\" optional=\"false\">\n"
3134 " <name>android.hardware.foo</name>\n"
3135 " <version>1.0</version>\n"
3136 " <interface>\n"
3137 " <name>IFoo</name>\n"
3138 " <instance>default</instance>\n"
3139 " </interface>\n"
3140 " </hal>\n"
3141 " <hal format=\"hidl\" optional=\"false\">\n"
3142 " <name>android.hardware.foo</name>\n"
3143 " <version>1.1</version>\n"
3144 " <interface>\n"
3145 " <name>IFoo</name>\n"
3146 " <instance>custom</instance>\n"
3147 " </interface>\n"
3148 " </hal>\n"
3149 "</compatibility-matrix>\n";
3150 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml, &error)) << error;
3151
3152 {
3153 HalManifest manifest;
3154 xml =
3155 "<manifest version=\"1.0\" type=\"framework\">\n"
3156 " <hal format=\"hidl\">\n"
3157 " <name>android.hardware.foo</name>\n"
3158 " <transport>hwbinder</transport>\n"
3159 " <version>1.0</version>\n"
3160 " <interface>\n"
3161 " <name>IFoo</name>\n"
3162 " <instance>default</instance>\n"
3163 " <instance>custom</instance>\n"
3164 " </interface>\n"
3165 " <fqname>@1.1::IFoo/custom</fqname>\n"
3166 " </hal>\n"
3167 "</manifest>\n";
3168 ASSERT_TRUE(gHalManifestConverter(&manifest, xml, &error)) << error;
3169 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
3170
3171 EXPECT_EQ(Transport::HWBINDER,
3172 manifest.getTransport("android.hardware.foo", {1, 1}, "IFoo", "custom"));
3173 }
3174
3175 {
3176 HalManifest manifest;
3177 xml =
3178 "<manifest version=\"1.0\" type=\"framework\">\n"
3179 " <hal format=\"hidl\">\n"
3180 " <name>android.hardware.foo</name>\n"
3181 " <transport>hwbinder</transport>\n"
3182 " <fqname>@1.0::IFoo/default</fqname>\n"
3183 " <fqname>@1.1::IFoo/custom</fqname>\n"
3184 " </hal>\n"
3185 "</manifest>\n";
3186 ASSERT_TRUE(gHalManifestConverter(&manifest, xml, &error)) << error;
3187 EXPECT_TRUE(manifest.checkCompatibility(cm, &error)) << error;
3188 }
3189
3190 {
3191 HalManifest manifest;
3192 xml =
3193 "<manifest version=\"1.0\" type=\"framework\">\n"
3194 " <hal format=\"hidl\">\n"
3195 " <name>android.hardware.foo</name>\n"
3196 " <transport>hwbinder</transport>\n"
3197 " <version>1.0</version>\n"
3198 " <interface>\n"
3199 " <name>IFoo</name>\n"
3200 " <instance>default</instance>\n"
3201 " <instance>custom</instance>\n"
3202 " </interface>\n"
3203 " </hal>\n"
3204 "</manifest>\n";
3205 ASSERT_TRUE(gHalManifestConverter(&manifest, xml, &error)) << error;
3206 EXPECT_FALSE(manifest.checkCompatibility(cm, &error));
3207 EXPECT_IN(
3208 "android.hardware.foo:\n"
3209 " required: @1.1::IFoo/custom\n"
3210 " provided: \n"
3211 " @1.0::IFoo/custom\n"
3212 " @1.0::IFoo/default",
3213 error);
3214 }
3215
3216 {
3217 HalManifest manifest;
3218 xml =
3219 "<manifest version=\"1.0\" type=\"framework\">\n"
3220 " <hal format=\"hidl\">\n"
3221 " <name>android.hardware.foo</name>\n"
3222 " <transport>hwbinder</transport>\n"
3223 " <fqname>@1.0::IFoo/default</fqname>\n"
3224 " <fqname>@1.0::IFoo/custom</fqname>\n"
3225 " </hal>\n"
3226 "</manifest>\n";
3227 ASSERT_TRUE(gHalManifestConverter(&manifest, xml, &error)) << error;
3228 EXPECT_IN(
3229 "android.hardware.foo:\n"
3230 " required: @1.1::IFoo/custom\n"
3231 " provided: \n"
3232 " @1.0::IFoo/custom\n"
3233 " @1.0::IFoo/default",
3234 error);
3235 }
3236 }
3237
TEST_F(LibVintfTest,FqNameInvalid)3238 TEST_F(LibVintfTest, FqNameInvalid) {
3239 std::string error;
3240 std::string xml;
3241 ManifestHal hal;
3242 xml =
3243 "<hal format=\"hidl\">\n"
3244 " <name>android.hardware.foo</name>\n"
3245 " <transport>hwbinder</transport>\n"
3246 " <fqname>@1.1::IFoo/custom</fqname>\n"
3247 "</hal>\n";
3248 EXPECT_TRUE(gManifestHalConverter(&hal, xml, &error)) << error;
3249 xml =
3250 "<hal format=\"hidl\">\n"
3251 " <name>android.hardware.foo</name>\n"
3252 " <transport>hwbinder</transport>\n"
3253 " <fqname>1.1::IFoo/custom</fqname>\n"
3254 "</hal>\n";
3255 ASSERT_FALSE(gManifestHalConverter(&hal, xml, &error));
3256 EXPECT_IN("Could not parse text \"1.1::IFoo/custom\" in element <fqname>", error);
3257 xml =
3258 "<hal format=\"hidl\">\n"
3259 " <name>android.hardware.foo</name>\n"
3260 " <transport>hwbinder</transport>\n"
3261 " <fqname>android.hardware.foo@1.1::IFoo/custom</fqname>\n"
3262 "</hal>\n";
3263 ASSERT_FALSE(gManifestHalConverter(&hal, xml, &error));
3264 EXPECT_IN("Should not specify package", error);
3265 xml =
3266 "<hal format=\"hidl\">\n"
3267 " <name>android.hardware.foo</name>\n"
3268 " <transport>hwbinder</transport>\n"
3269 " <fqname>IFoo/custom</fqname>\n"
3270 "</hal>\n";
3271 ASSERT_FALSE(gManifestHalConverter(&hal, xml, &error));
3272 EXPECT_IN("Should specify version", error);
3273 xml =
3274 "<hal format=\"hidl\">\n"
3275 " <name>android.hardware.foo</name>\n"
3276 " <transport>hwbinder</transport>\n"
3277 " <fqname>@1.0::IFoo</fqname>\n"
3278 "</hal>\n";
3279 ASSERT_FALSE(gManifestHalConverter(&hal, xml, &error));
3280 EXPECT_IN("Should specify instance", error);
3281 xml =
3282 "<hal format=\"hidl\">\n"
3283 " <name>n07 4 v4l1d 1n73rf4c3</name>\n"
3284 " <transport>hwbinder</transport>\n"
3285 " <fqname>@1.0::IFoo/custom</fqname>\n"
3286 "</hal>\n";
3287 ASSERT_FALSE(gManifestHalConverter(&hal, xml, &error));
3288 EXPECT_IN("Cannot create FqInstance", error);
3289 EXPECT_IN("n07 4 v4l1d 1n73rf4c3", error);
3290 }
3291
TEST_F(LibVintfTest,RegexInstanceValid)3292 TEST_F(LibVintfTest, RegexInstanceValid) {
3293 CompatibilityMatrix matrix;
3294 std::string error;
3295
3296 std::string xml =
3297 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
3298 " <hal format=\"hidl\" optional=\"false\">\n"
3299 " <name>android.hardware.foo</name>\n"
3300 " <version>1.0</version>\n"
3301 " <interface>\n"
3302 " <name>IFoo</name>\n"
3303 " <regex-instance>legacy/[0-9]+</regex-instance>\n"
3304 " <regex-instance>slot[0-9]+</regex-instance>\n"
3305 " <regex-instance>.*</regex-instance>\n"
3306 " </interface>\n"
3307 " </hal>\n"
3308 "</compatibility-matrix>\n";
3309 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, xml, &error)) << error;
3310 }
3311
TEST_F(LibVintfTest,RegexInstanceInvalid)3312 TEST_F(LibVintfTest, RegexInstanceInvalid) {
3313 CompatibilityMatrix matrix;
3314 std::string error;
3315 std::string xml =
3316 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
3317 " <hal format=\"hidl\" optional=\"false\">\n"
3318 " <name>android.hardware.foo</name>\n"
3319 " <version>1.0</version>\n"
3320 " <interface>\n"
3321 " <name>IFoo</name>\n"
3322 " <regex-instance>e{1,2,3}</regex-instance>\n"
3323 " <regex-instance>*</regex-instance>\n"
3324 " <regex-instance>+</regex-instance>\n"
3325 " <regex-instance>[0-9]+</regex-instance>\n"
3326 " <regex-instance>[0-9]+</regex-instance>\n"
3327 " </interface>\n"
3328 " </hal>\n"
3329 "</compatibility-matrix>\n";
3330 EXPECT_FALSE(gCompatibilityMatrixConverter(&matrix, xml, &error));
3331 EXPECT_IN("Invalid regular expression 'e{1,2,3}'", error);
3332 EXPECT_IN("Invalid regular expression '*'", error);
3333 EXPECT_IN("Invalid regular expression '+'", error);
3334 EXPECT_IN("Duplicated regex-instance '[0-9]+'", error);
3335 }
3336
TEST_F(LibVintfTest,RegexInstanceCompat)3337 TEST_F(LibVintfTest, RegexInstanceCompat) {
3338 CompatibilityMatrix matrix;
3339 std::string error;
3340
3341 std::string xml =
3342 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
3343 " <hal format=\"hidl\" optional=\"false\">\n"
3344 " <name>android.hardware.foo</name>\n"
3345 " <version>1.0</version>\n"
3346 " <version>3.1-2</version>\n"
3347 " <interface>\n"
3348 " <name>IFoo</name>\n"
3349 " <instance>default</instance>\n"
3350 " <regex-instance>legacy/[0-9]+</regex-instance>\n"
3351 " </interface>\n"
3352 " </hal>\n"
3353 " <sepolicy>\n"
3354 " <kernel-sepolicy-version>0</kernel-sepolicy-version>\n"
3355 " <sepolicy-version>0.0</sepolicy-version>\n"
3356 " </sepolicy>\n"
3357 "</compatibility-matrix>\n";
3358 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, xml))
3359 << gCompatibilityMatrixConverter.lastError();
3360
3361 {
3362 std::string xml =
3363 "<manifest version=\"1.0\" type=\"device\">\n"
3364 " <hal format=\"hidl\">\n"
3365 " <name>android.hardware.foo</name>\n"
3366 " <transport>hwbinder</transport>\n"
3367 " <version>1.0</version>\n"
3368 " <interface>\n"
3369 " <name>IFoo</name>\n"
3370 " <instance>default</instance>\n"
3371 " <instance>legacy/0</instance>\n"
3372 " <instance>legacy/1</instance>\n"
3373 " </interface>\n"
3374 " </hal>\n"
3375 "</manifest>\n";
3376
3377 HalManifest manifest;
3378 EXPECT_TRUE(gHalManifestConverter(&manifest, xml));
3379 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
3380
3381 auto unused = checkUnusedHals(manifest, matrix);
3382 EXPECT_TRUE(unused.empty())
3383 << "Contains unused HALs: " << android::base::Join(unused, "\n");
3384 }
3385
3386 {
3387 std::string xml =
3388 "<manifest version=\"1.0\" type=\"device\">\n"
3389 " <hal format=\"hidl\">\n"
3390 " <name>android.hardware.foo</name>\n"
3391 " <transport>hwbinder</transport>\n"
3392 " <version>1.0</version>\n"
3393 " <interface>\n"
3394 " <name>IFoo</name>\n"
3395 " <instance>default</instance>\n"
3396 " <instance>legacy0</instance>\n"
3397 " <instance>nonmatch/legacy/0</instance>\n"
3398 " <instance>legacy/0/nonmatch</instance>\n"
3399 " </interface>\n"
3400 " </hal>\n"
3401 "</manifest>\n";
3402
3403 HalManifest manifest;
3404 EXPECT_TRUE(gHalManifestConverter(&manifest, xml));
3405 EXPECT_FALSE(manifest.checkCompatibility(matrix, &error))
3406 << "Should not be compatible because no legacy/[0-9]+ is provided.";
3407
3408 auto unused = checkUnusedHals(manifest, matrix);
3409 EXPECT_EQ((std::set<std::string>{"android.hardware.foo@1.0::IFoo/nonmatch/legacy/0",
3410 "android.hardware.foo@1.0::IFoo/legacy/0/nonmatch",
3411 "android.hardware.foo@1.0::IFoo/legacy0"}),
3412 unused);
3413 }
3414 }
3415
TEST_F(LibVintfTest,Regex)3416 TEST_F(LibVintfTest, Regex) {
3417 details::Regex regex;
3418
3419 EXPECT_FALSE(regex.compile("+"));
3420 EXPECT_FALSE(regex.compile("*"));
3421
3422 ASSERT_TRUE(regex.compile("legacy/[0-9]+"));
3423 EXPECT_TRUE(regex.matches("legacy/0"));
3424 EXPECT_TRUE(regex.matches("legacy/000"));
3425 EXPECT_FALSE(regex.matches("legacy/"));
3426 EXPECT_FALSE(regex.matches("ssslegacy/0"));
3427 EXPECT_FALSE(regex.matches("legacy/0sss"));
3428 }
3429
3430 } // namespace vintf
3431 } // namespace android
3432
main(int argc,char ** argv)3433 int main(int argc, char **argv) {
3434 ::testing::InitGoogleTest(&argc, argv);
3435 return RUN_ALL_TESTS();
3436 }
3437