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 "LibHidlTest"
18
19 #include <functional>
20
21 #include <vintf/parse_string.h>
22 #include <vintf/parse_xml.h>
23 #include <vintf/CompatibilityMatrix.h>
24 #include <vintf/VintfObject.h>
25
26 #include <android-base/logging.h>
27 #include <android-base/parseint.h>
28 #include <gtest/gtest.h>
29
30 namespace android {
31 namespace vintf {
32
33 extern const XmlConverter<Version> &gVersionConverter;
34 extern const XmlConverter<ManifestHal> &gManifestHalConverter;
35 extern const XmlConverter<MatrixHal> &gMatrixHalConverter;
36 extern const XmlConverter<KernelConfigTypedValue> &gKernelConfigTypedValueConverter;
37 extern const XmlConverter<HalManifest> &gHalManifestConverter;
38 extern const XmlConverter<CompatibilityMatrix> &gCompatibilityMatrixConverter;
39
40 struct LibVintfTest : public ::testing::Test {
41 public:
SetUpandroid::vintf::LibVintfTest42 virtual void SetUp() override {
43 }
TearDownandroid::vintf::LibVintfTest44 virtual void TearDown() override {
45 }
addandroid::vintf::LibVintfTest46 bool add(CompatibilityMatrix &cm, MatrixHal &&hal) {
47 return cm.add(std::move(hal));
48 }
addandroid::vintf::LibVintfTest49 bool add(CompatibilityMatrix &cm, MatrixKernel &&kernel) {
50 return cm.add(std::move(kernel));
51 }
addandroid::vintf::LibVintfTest52 bool add(HalManifest &vm, ManifestHal &&hal) {
53 return vm.add(std::move(hal));
54 }
setandroid::vintf::LibVintfTest55 void set(CompatibilityMatrix &cm, Sepolicy &&sepolicy) {
56 cm.framework.mSepolicy = sepolicy;
57 }
setandroid::vintf::LibVintfTest58 void set(CompatibilityMatrix &cm, SchemaType type) {
59 cm.mType = type;
60 }
setandroid::vintf::LibVintfTest61 void set(CompatibilityMatrix &cm, VndkVersionRange &&range, std::set<std::string> &&libs) {
62 cm.device.mVndk.mVersionRange = range;
63 cm.device.mVndk.mLibraries = libs;
64 }
setAvbandroid::vintf::LibVintfTest65 void setAvb(RuntimeInfo &ki, Version vbmeta, Version boot) {
66 ki.mBootVbmetaAvbVersion = vbmeta;
67 ki.mBootAvbVersion = boot;
68 }
setAvbandroid::vintf::LibVintfTest69 void setAvb(CompatibilityMatrix &cm, Version &&avbVersion) {
70 cm.framework.mAvbMetaVersion = avbVersion;
71 }
getAvbandroid::vintf::LibVintfTest72 Version getAvb(CompatibilityMatrix &cm) {
73 return cm.framework.mAvbMetaVersion;
74 }
getAnyHalandroid::vintf::LibVintfTest75 const ManifestHal *getAnyHal(HalManifest &vm, const std::string &name) {
76 return vm.getAnyHal(name);
77 }
getAnyHalandroid::vintf::LibVintfTest78 MatrixHal *getAnyHal(CompatibilityMatrix &cm, const std::string &name) {
79 return cm.getAnyHal(name);
80 }
getHalsandroid::vintf::LibVintfTest81 ConstMultiMapValueIterable<std::string, ManifestHal> getHals(HalManifest &vm) {
82 return vm.getHals();
83 }
isValidandroid::vintf::LibVintfTest84 bool isValid(const ManifestHal &mh) {
85 return mh.isValid();
86 }
87
testHalInterfacesandroid::vintf::LibVintfTest88 std::map<std::string, HalInterface> testHalInterfaces() {
89 HalInterface intf;
90 intf.name = "IFoo";
91 intf.instances.insert("default");
92 std::map<std::string, HalInterface> map;
93 map[intf.name] = intf;
94 return map;
95 }
96
testDeviceManifestandroid::vintf::LibVintfTest97 HalManifest testDeviceManifest() {
98 HalManifest vm;
99 vm.mType = SchemaType::DEVICE;
100 vm.device.mSepolicyVersion = {25, 0};
101 vm.add(ManifestHal{
102 .format = HalFormat::HIDL,
103 .name = "android.hardware.camera",
104 .versions = {Version(2, 0)},
105 .transportArch = {Transport::HWBINDER, Arch::ARCH_EMPTY},
106 .interfaces = {
107 {"ICamera", {"ICamera", {"legacy/0", "default"}}},
108 {"IBetterCamera", {"IBetterCamera", {"camera"}}}
109 }
110 });
111 vm.add(ManifestHal{
112 .format = HalFormat::HIDL,
113 .name = "android.hardware.nfc",
114 .versions = {Version(1, 0)},
115 .transportArch = {Transport::PASSTHROUGH, Arch::ARCH_32_64},
116 .interfaces = {
117 {"INfc", {"INfc", {"default"}}}
118 }
119 });
120
121 return vm;
122 }
testFrameworkManfiestandroid::vintf::LibVintfTest123 HalManifest testFrameworkManfiest() {
124 HalManifest vm;
125 vm.mType = SchemaType::FRAMEWORK;
126 vm.add(ManifestHal{
127 .format = HalFormat::HIDL,
128 .name = "android.hidl.manager",
129 .versions = {Version(1, 0)},
130 .transportArch = {Transport::HWBINDER, Arch::ARCH_EMPTY},
131 .interfaces = {
132 {"IServiceManager", {"IServiceManager", {"default"}}},
133 }
134 });
135 Vndk vndk2505;
136 vndk2505.mVersionRange = {25, 0, 5};
137 vndk2505.mLibraries = { "libjpeg.so", "libbase.so" };
138 Vndk vndk2513;
139 vndk2513.mVersionRange = {25, 1, 3};
140 vndk2513.mLibraries = { "libjpeg.so", "libbase.so", "libtinyxml2.so" };
141 vm.framework.mVndks = { std::move(vndk2505), std::move(vndk2513) };
142
143 return vm;
144 }
testRuntimeInfoandroid::vintf::LibVintfTest145 RuntimeInfo testRuntimeInfo() {
146 RuntimeInfo info;
147 info.mOsName = "Linux";
148 info.mNodeName = "localhost";
149 info.mOsRelease = "3.18.31-g936f9a479d0f";
150 info.mKernelVersion = {3, 18, 31};
151 info.mOsVersion = "#4 SMP PREEMPT Wed Feb 1 18:10:52 PST 2017";
152 info.mHardwareId = "aarch64";
153 info.mKernelSepolicyVersion = 30;
154 info.mKernelConfigs = {
155 {"CONFIG_64BIT", "y"},
156 {"CONFIG_ANDROID_BINDER_DEVICES", "\"binder,hwbinder\""},
157 {"CONFIG_ARCH_MMAP_RND_BITS", "24"},
158 {"CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES", "\"\""},
159 {"CONFIG_ILLEGAL_POINTER_VALUE", "0xdead000000000000"}
160 };
161 setAvb(info, {2, 1}, {2, 1});
162 return info;
163 }
164 };
165
166
TEST_F(LibVintfTest,Stringify)167 TEST_F(LibVintfTest, Stringify) {
168 HalManifest vm = testDeviceManifest();
169 EXPECT_EQ(dump(vm), "hidl/android.hardware.camera/hwbinder/2.0:"
170 "hidl/android.hardware.nfc/passthrough32+64/1.0");
171
172 EXPECT_EQ(to_string(HalFormat::HIDL), "hidl");
173 EXPECT_EQ(to_string(HalFormat::NATIVE), "native");
174
175 VersionRange v(1, 2, 3);
176 EXPECT_EQ(to_string(v), "1.2-3");
177 VersionRange v2;
178 EXPECT_TRUE(parse("1.2-3", &v2));
179 EXPECT_EQ(v, v2);
180 }
181
TEST_F(LibVintfTest,GetTransport)182 TEST_F(LibVintfTest, GetTransport) {
183 HalManifest vm = testDeviceManifest();
184 EXPECT_EQ(Transport::HWBINDER, vm.getTransport("android.hardware.camera",
185 {2, 0}, "ICamera", "default"));
186 }
187
TEST_F(LibVintfTest,HalManifestConverter)188 TEST_F(LibVintfTest, HalManifestConverter) {
189 HalManifest vm = testDeviceManifest();
190 std::string xml = gHalManifestConverter(vm);
191 EXPECT_EQ(xml,
192 "<manifest version=\"1.0\" type=\"device\">\n"
193 " <hal format=\"hidl\">\n"
194 " <name>android.hardware.camera</name>\n"
195 " <transport>hwbinder</transport>\n"
196 " <version>2.0</version>\n"
197 " <interface>\n"
198 " <name>IBetterCamera</name>\n"
199 " <instance>camera</instance>\n"
200 " </interface>\n"
201 " <interface>\n"
202 " <name>ICamera</name>\n"
203 " <instance>default</instance>\n"
204 " <instance>legacy/0</instance>\n"
205 " </interface>\n"
206 " </hal>\n"
207 " <hal format=\"hidl\">\n"
208 " <name>android.hardware.nfc</name>\n"
209 " <transport arch=\"32+64\">passthrough</transport>\n"
210 " <version>1.0</version>\n"
211 " <interface>\n"
212 " <name>INfc</name>\n"
213 " <instance>default</instance>\n"
214 " </interface>\n"
215 " </hal>\n"
216 " <sepolicy>\n"
217 " <version>25.0</version>\n"
218 " </sepolicy>\n"
219 "</manifest>\n");
220 HalManifest vm2;
221 EXPECT_TRUE(gHalManifestConverter(&vm2, xml));
222 EXPECT_EQ(vm, vm2);
223 }
224
TEST_F(LibVintfTest,HalManifestConverterFramework)225 TEST_F(LibVintfTest, HalManifestConverterFramework) {
226 HalManifest vm = testFrameworkManfiest();
227 std::string xml = gHalManifestConverter(vm);
228 EXPECT_EQ(xml,
229 "<manifest version=\"1.0\" type=\"framework\">\n"
230 " <hal format=\"hidl\">\n"
231 " <name>android.hidl.manager</name>\n"
232 " <transport>hwbinder</transport>\n"
233 " <version>1.0</version>\n"
234 " <interface>\n"
235 " <name>IServiceManager</name>\n"
236 " <instance>default</instance>\n"
237 " </interface>\n"
238 " </hal>\n"
239 " <vndk>\n"
240 " <version>25.0.5</version>\n"
241 " <library>libbase.so</library>\n"
242 " <library>libjpeg.so</library>\n"
243 " </vndk>\n"
244 " <vndk>\n"
245 " <version>25.1.3</version>\n"
246 " <library>libbase.so</library>\n"
247 " <library>libjpeg.so</library>\n"
248 " <library>libtinyxml2.so</library>\n"
249 " </vndk>\n"
250 "</manifest>\n");
251 HalManifest vm2;
252 EXPECT_TRUE(gHalManifestConverter(&vm2, xml));
253 EXPECT_EQ(vm, vm2);
254 }
255
TEST_F(LibVintfTest,HalManifestOptional)256 TEST_F(LibVintfTest, HalManifestOptional) {
257 HalManifest vm;
258 EXPECT_TRUE(gHalManifestConverter(&vm,
259 "<manifest version=\"1.0\" type=\"device\"></manifest>"));
260 EXPECT_TRUE(gHalManifestConverter(&vm,
261 "<manifest version=\"1.0\" type=\"device\">"
262 " <hal>"
263 " <name>android.hidl.manager</name>"
264 " <transport>hwbinder</transport>"
265 " <version>1.0</version>"
266 " </hal>"
267 "</manifest>"));
268 EXPECT_FALSE(gHalManifestConverter(&vm,
269 "<manifest version=\"1.0\" type=\"device\">"
270 " <hal>"
271 " <name>android.hidl.manager</name>"
272 " <version>1.0</version>"
273 " </hal>"
274 "</manifest>"));
275 }
276
TEST_F(LibVintfTest,HalManifestDuplicate)277 TEST_F(LibVintfTest, HalManifestDuplicate) {
278 HalManifest vm;
279 EXPECT_FALSE(gHalManifestConverter(&vm,
280 "<manifest version=\"1.0\" type=\"device\">"
281 " <hal>"
282 " <name>android.hidl.manager</name>"
283 " <transport>hwbinder</transport>"
284 " <version>1.0</version>"
285 " <version>1.1</version>"
286 " </hal>"
287 "</manifest>"))
288 << "Should not allow duplicated major version in <hal>";
289 EXPECT_FALSE(gHalManifestConverter(&vm,
290 "<manifest version=\"1.0\" type=\"device\">"
291 " <hal>"
292 " <name>android.hidl.manager</name>"
293 " <transport>hwbinder</transport>"
294 " <version>1.0</version>"
295 " </hal>"
296 " <hal>"
297 " <name>android.hidl.manager</name>"
298 " <transport arch=\"32+64\">passthrough</transport>"
299 " <version>1.1</version>"
300 " </hal>"
301 "</manifest>"))
302 << "Should not allow duplicated major version across <hal>";
303 }
304
TEST_F(LibVintfTest,HalManifestGetTransport)305 TEST_F(LibVintfTest, HalManifestGetTransport) {
306 HalManifest vm;
307 EXPECT_TRUE(gHalManifestConverter(&vm,
308 "<manifest version=\"1.0\" type=\"device\">"
309 " <hal>"
310 " <name>android.hidl.manager</name>"
311 " <transport>hwbinder</transport>"
312 " <version>1.0</version>"
313 " <interface>"
314 " <name>IServiceManager</name>"
315 " <instance>default</instance>"
316 " </interface>"
317 " </hal>"
318 " <hal>"
319 " <name>android.hidl.manager</name>"
320 " <transport arch=\"32+64\">passthrough</transport>"
321 " <version>2.1</version>"
322 " <interface>"
323 " <name>IServiceManager</name>"
324 " <instance>default</instance>"
325 " </interface>"
326 " </hal>"
327 "</manifest>"));
328 EXPECT_EQ(Transport::PASSTHROUGH,
329 vm.getTransport("android.hidl.manager", {2, 1}, "IServiceManager", "default"));
330 EXPECT_EQ(Transport::PASSTHROUGH,
331 vm.getTransport("android.hidl.manager", {2, 0}, "IServiceManager", "default"));
332 EXPECT_EQ(Transport::EMPTY,
333 vm.getTransport("android.hidl.manager", {2, 2}, "IServiceManager", "default"));
334 EXPECT_EQ(Transport::HWBINDER,
335 vm.getTransport("android.hidl.manager", {1, 0}, "IServiceManager", "default"));
336 }
337
TEST_F(LibVintfTest,HalManifestInstances)338 TEST_F(LibVintfTest, HalManifestInstances) {
339 HalManifest vm = testDeviceManifest();
340 EXPECT_EQ(vm.getInstances("android.hardware.camera", "ICamera"),
341 std::set<std::string>({"default", "legacy/0"}));
342 EXPECT_EQ(vm.getInstances("android.hardware.camera", "IBetterCamera"),
343 std::set<std::string>({"camera"}));
344 EXPECT_EQ(vm.getInstances("android.hardware.camera", "INotExist"),
345 std::set<std::string>({}));
346 EXPECT_EQ(vm.getInstances("android.hardware.nfc", "INfc"),
347 std::set<std::string>({"default"}));
348
349 EXPECT_TRUE(vm.hasInstance("android.hardware.camera", "ICamera", "default"));
350 EXPECT_TRUE(vm.hasInstance("android.hardware.camera", "ICamera", "legacy/0"));
351 EXPECT_TRUE(vm.hasInstance("android.hardware.camera", "IBetterCamera", "camera"));
352 EXPECT_TRUE(vm.hasInstance("android.hardware.nfc", "INfc", "default"));
353
354 EXPECT_FALSE(vm.hasInstance("android.hardware.camera", "INotExist", "default"));
355 EXPECT_FALSE(vm.hasInstance("android.hardware.camera", "ICamera", "notexist"));
356 EXPECT_FALSE(vm.hasInstance("android.hardware.camera", "IBetterCamera", "default"));
357 EXPECT_FALSE(vm.hasInstance("android.hardware.camera", "INotExist", "notexist"));
358 EXPECT_FALSE(vm.hasInstance("android.hardware.nfc", "INfc", "notexist"));
359 }
360
TEST_F(LibVintfTest,VersionConverter)361 TEST_F(LibVintfTest, VersionConverter) {
362 Version v(3, 6);
363 std::string xml = gVersionConverter(v);
364 EXPECT_EQ(xml, "<version>3.6</version>\n");
365 Version v2;
366 EXPECT_TRUE(gVersionConverter(&v2, xml));
367 EXPECT_EQ(v, v2);
368 }
369
insert(std::map<std::string,HalInterface> * map,HalInterface && intf)370 static bool insert(std::map<std::string, HalInterface>* map, HalInterface&& intf) {
371 std::string name{intf.name};
372 return map->emplace(std::move(name), std::move(intf)).second;
373 }
374
TEST_F(LibVintfTest,MatrixHalConverter)375 TEST_F(LibVintfTest, MatrixHalConverter) {
376 MatrixHal mh{HalFormat::NATIVE, "android.hardware.camera",
377 {{VersionRange(1,2,3), VersionRange(4,5,6)}},
378 false /* optional */, {}};
379 EXPECT_TRUE(insert(&mh.interfaces, {"IBetterCamera", {"default", "great"}}));
380 EXPECT_TRUE(insert(&mh.interfaces, {"ICamera", {"default"}}));
381 std::string xml = gMatrixHalConverter(mh);
382 EXPECT_EQ(xml,
383 "<hal format=\"native\" optional=\"false\">\n"
384 " <name>android.hardware.camera</name>\n"
385 " <version>1.2-3</version>\n"
386 " <version>4.5-6</version>\n"
387 " <interface>\n"
388 " <name>IBetterCamera</name>\n"
389 " <instance>default</instance>\n"
390 " <instance>great</instance>\n"
391 " </interface>\n"
392 " <interface>\n"
393 " <name>ICamera</name>\n"
394 " <instance>default</instance>\n"
395 " </interface>\n"
396 "</hal>\n");
397 MatrixHal mh2;
398 EXPECT_TRUE(gMatrixHalConverter(&mh2, xml));
399 EXPECT_EQ(mh, mh2);
400 }
401
TEST_F(LibVintfTest,KernelConfigTypedValueConverter)402 TEST_F(LibVintfTest, KernelConfigTypedValueConverter) {
403
404 KernelConfigTypedValue converted;
405
406 auto testOne = [] (const KernelConfigTypedValue &original,
407 const std::string &expectXml) {
408 std::string xml;
409 KernelConfigTypedValue converted;
410 xml = gKernelConfigTypedValueConverter(original);
411 EXPECT_EQ(xml, expectXml);
412 EXPECT_TRUE(gKernelConfigTypedValueConverter(&converted, xml));
413 EXPECT_EQ(original, converted);
414 };
415
416 auto testParse = [] (const KernelConfigTypedValue &original,
417 const std::string &xml) {
418 KernelConfigTypedValue converted;
419 EXPECT_TRUE(gKernelConfigTypedValueConverter(&converted, xml));
420 EXPECT_EQ(original, converted);
421 };
422
423 testOne(KernelConfigTypedValue("stringvalue"),
424 "<value type=\"string\">stringvalue</value>\n");
425 testOne(KernelConfigTypedValue(""),
426 "<value type=\"string\"></value>\n");
427
428 testOne(KernelConfigTypedValue(Tristate::YES),
429 "<value type=\"tristate\">y</value>\n");
430 testOne(KernelConfigTypedValue(Tristate::NO),
431 "<value type=\"tristate\">n</value>\n");
432 testOne(KernelConfigTypedValue(Tristate::MODULE),
433 "<value type=\"tristate\">m</value>\n");
434 EXPECT_FALSE(gKernelConfigTypedValueConverter(&converted,
435 "<value type=\"tristate\">q</value>\n"));
436
437 testOne(KernelConfigTypedValue(KernelConfigRangeValue{4, 20}),
438 "<value type=\"range\">4-20</value>\n");
439 testOne(KernelConfigTypedValue(KernelConfigRangeValue{0, UINT64_MAX}),
440 "<value type=\"range\">0-18446744073709551615</value>\n");
441 testParse(KernelConfigTypedValue(KernelConfigRangeValue{0, UINT64_MAX}),
442 "<value type=\"range\">0x0-0xffffffffffffffff</value>\n");
443
444 EXPECT_FALSE(gKernelConfigTypedValueConverter(&converted,
445 "<value type=\"int\">-18446744073709551616</value>\n"));
446
447 testOne(KernelConfigTypedValue(INT64_MIN),
448 "<value type=\"int\">-9223372036854775808</value>\n");
449 testParse(KernelConfigTypedValue(INT64_MIN),
450 "<value type=\"int\">0x8000000000000000</value>\n");
451 testParse(KernelConfigTypedValue(INT64_MIN),
452 "<value type=\"int\">-0X8000000000000000</value>\n");
453
454 testParse(KernelConfigTypedValue(INT64_MIN + 1),
455 "<value type=\"int\">-0X7FFFFFFFFFFFFFFF</value>\n");
456
457 testParse(KernelConfigTypedValue(-0x50),
458 "<value type=\"int\">-0x50</value>\n");
459
460 testOne(KernelConfigTypedValue(0),
461 "<value type=\"int\">0</value>\n");
462
463 // Truncation for underflow.
464 testParse(KernelConfigTypedValue(1),
465 "<value type=\"int\">-0xffffffffffffffff</value>\n");
466 testParse(KernelConfigTypedValue(1),
467 "<value type=\"int\">-18446744073709551615</value>\n");
468
469 testOne(KernelConfigTypedValue(INT64_MAX),
470 "<value type=\"int\">9223372036854775807</value>\n");
471 testParse(KernelConfigTypedValue(INT64_MAX),
472 "<value type=\"int\">0x7FFFFFFFFFFFFFFF</value>\n");
473 // Truncation for underflow.
474 testParse(KernelConfigTypedValue(INT64_MAX),
475 "<value type=\"int\">-9223372036854775809</value>\n");
476
477 testParse(KernelConfigTypedValue(-1),
478 "<value type=\"int\">18446744073709551615</value>\n");
479 testParse(KernelConfigTypedValue(-1),
480 "<value type=\"int\">0xffffffffffffffff</value>\n");
481
482 EXPECT_FALSE(gKernelConfigTypedValueConverter(&converted,
483 "<value type=\"int\">18446744073709551616</value>\n"));
484 }
485
TEST_F(LibVintfTest,CompatibilityMatrixConverter)486 TEST_F(LibVintfTest, CompatibilityMatrixConverter) {
487 CompatibilityMatrix cm;
488 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE, "android.hardware.camera",
489 {{VersionRange(1,2,3), VersionRange(4,5,6)}},
490 false /* optional */, testHalInterfaces()}));
491 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE, "android.hardware.nfc",
492 {{VersionRange(4,5,6), VersionRange(10,11,12)}},
493 true /* optional */, testHalInterfaces()}));
494 EXPECT_TRUE(add(cm, MatrixKernel{KernelVersion(3, 18, 22),
495 {KernelConfig{"CONFIG_FOO", Tristate::YES}, KernelConfig{"CONFIG_BAR", "stringvalue"}}}));
496 EXPECT_TRUE(add(cm, MatrixKernel{KernelVersion(4, 4, 1),
497 {KernelConfig{"CONFIG_BAZ", 20}, KernelConfig{"CONFIG_BAR", KernelConfigRangeValue{3, 5} }}}));
498 set(cm, Sepolicy(30, {{25, 0}, {26, 0, 3}}));
499 setAvb(cm, Version{2, 1});
500 std::string xml = gCompatibilityMatrixConverter(cm);
501 EXPECT_EQ(xml,
502 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
503 " <hal format=\"native\" optional=\"false\">\n"
504 " <name>android.hardware.camera</name>\n"
505 " <version>1.2-3</version>\n"
506 " <version>4.5-6</version>\n"
507 " <interface>\n"
508 " <name>IFoo</name>\n"
509 " <instance>default</instance>\n"
510 " </interface>\n"
511 " </hal>\n"
512 " <hal format=\"native\" optional=\"true\">\n"
513 " <name>android.hardware.nfc</name>\n"
514 " <version>4.5-6</version>\n"
515 " <version>10.11-12</version>\n"
516 " <interface>\n"
517 " <name>IFoo</name>\n"
518 " <instance>default</instance>\n"
519 " </interface>\n"
520 " </hal>\n"
521 " <kernel version=\"3.18.22\">\n"
522 " <config>\n"
523 " <key>CONFIG_FOO</key>\n"
524 " <value type=\"tristate\">y</value>\n"
525 " </config>\n"
526 " <config>\n"
527 " <key>CONFIG_BAR</key>\n"
528 " <value type=\"string\">stringvalue</value>\n"
529 " </config>\n"
530 " </kernel>\n"
531 " <kernel version=\"4.4.1\">\n"
532 " <config>\n"
533 " <key>CONFIG_BAZ</key>\n"
534 " <value type=\"int\">20</value>\n"
535 " </config>\n"
536 " <config>\n"
537 " <key>CONFIG_BAR</key>\n"
538 " <value type=\"range\">3-5</value>\n"
539 " </config>\n"
540 " </kernel>\n"
541 " <sepolicy>\n"
542 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
543 " <sepolicy-version>25.0</sepolicy-version>\n"
544 " <sepolicy-version>26.0-3</sepolicy-version>\n"
545 " </sepolicy>\n"
546 " <avb>\n"
547 " <vbmeta-version>2.1</vbmeta-version>\n"
548 " </avb>\n"
549 "</compatibility-matrix>\n");
550 CompatibilityMatrix cm2;
551 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml));
552 EXPECT_EQ(cm, cm2);
553 }
554
TEST_F(LibVintfTest,DeviceCompatibilityMatrixCoverter)555 TEST_F(LibVintfTest, DeviceCompatibilityMatrixCoverter) {
556 CompatibilityMatrix cm;
557 EXPECT_TRUE(add(cm, MatrixHal{HalFormat::NATIVE, "android.hidl.manager",
558 {{VersionRange(1,0)}},
559 false /* optional */, testHalInterfaces()}));
560 set(cm, SchemaType::DEVICE);
561 set(cm, VndkVersionRange{25,0,1,5}, {"libjpeg.so", "libbase.so"});
562 std::string xml = gCompatibilityMatrixConverter(cm);
563 EXPECT_EQ(xml,
564 "<compatibility-matrix version=\"1.0\" type=\"device\">\n"
565 " <hal format=\"native\" optional=\"false\">\n"
566 " <name>android.hidl.manager</name>\n"
567 " <version>1.0</version>\n"
568 " <interface>\n"
569 " <name>IFoo</name>\n"
570 " <instance>default</instance>\n"
571 " </interface>\n"
572 " </hal>\n"
573 " <vndk>\n"
574 " <version>25.0.1-5</version>\n"
575 " <library>libbase.so</library>\n"
576 " <library>libjpeg.so</library>\n"
577 " </vndk>\n"
578 "</compatibility-matrix>\n");
579 CompatibilityMatrix cm2;
580 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm2, xml));
581 EXPECT_EQ(cm, cm2);
582 }
583
TEST_F(LibVintfTest,IsValid)584 TEST_F(LibVintfTest, IsValid) {
585 EXPECT_TRUE(isValid(ManifestHal()));
586
587 ManifestHal invalidHal{
588 .format = HalFormat::HIDL,
589 .name = "android.hardware.camera",
590 .versions = {{Version(2, 0), Version(2, 1)}},
591 .transportArch = {Transport::PASSTHROUGH, Arch::ARCH_32_64}
592 };
593
594 EXPECT_FALSE(isValid(invalidHal));
595 HalManifest vm2;
596 EXPECT_FALSE(add(vm2, std::move(invalidHal)));
597 }
598
TEST_F(LibVintfTest,HalManifestGetHalNames)599 TEST_F(LibVintfTest, HalManifestGetHalNames) {
600 HalManifest vm = testDeviceManifest();
601 EXPECT_EQ(vm.getHalNames(), std::set<std::string>(
602 {"android.hardware.camera", "android.hardware.nfc"}));
603 }
604
TEST_F(LibVintfTest,HalManifestGetInterfaceNames)605 TEST_F(LibVintfTest, HalManifestGetInterfaceNames) {
606 HalManifest vm = testDeviceManifest();
607 EXPECT_EQ(vm.getInterfaceNames("android.hardware.camera"),
608 std::set<std::string>({"ICamera", "IBetterCamera"}));
609 EXPECT_EQ(vm.getInterfaceNames("android.hardware.nfc"),
610 std::set<std::string>({"INfc"}));
611 }
612
TEST_F(LibVintfTest,HalManifestGetHal)613 TEST_F(LibVintfTest, HalManifestGetHal) {
614 HalManifest vm = testDeviceManifest();
615 EXPECT_NE(getAnyHal(vm, "android.hardware.camera"), nullptr);
616 EXPECT_EQ(getAnyHal(vm, "non-existent"), nullptr);
617
618 std::vector<std::string> arr{"android.hardware.camera", "android.hardware.nfc"};
619 size_t i = 0;
620 for (const auto &hal : getHals(vm)) {
621 EXPECT_EQ(hal.name, arr[i++]);
622 }
623 }
624
TEST_F(LibVintfTest,RuntimeInfo)625 TEST_F(LibVintfTest, RuntimeInfo) {
626 RuntimeInfo ki = testRuntimeInfo();
627 using KernelConfigs = std::vector<KernelConfig>;
628 const KernelConfigs configs {
629 KernelConfig{"CONFIG_64BIT", Tristate::YES},
630 KernelConfig{"CONFIG_ANDROID_BINDER_DEVICES", "binder,hwbinder"},
631 KernelConfig{"CONFIG_ARCH_MMAP_RND_BITS", 24},
632 KernelConfig{"CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES", ""},
633 KernelConfig{"CONFIG_ILLEGAL_POINTER_VALUE", 0xdead000000000000},
634 KernelConfig{"CONFIG_NOTEXIST", Tristate::NO},
635 };
636
637 auto testMatrix = [&] (MatrixKernel &&kernel) {
638 CompatibilityMatrix cm;
639 add(cm, std::move(kernel));
640 set(cm, {30, {{25, 0}}});
641 setAvb(cm, {2, 1});
642 return cm;
643 };
644
645 std::string error;
646
647 {
648 MatrixKernel kernel(KernelVersion{4, 4, 1}, KernelConfigs(configs));
649 CompatibilityMatrix cm = testMatrix(std::move(kernel));
650 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Kernel version shouldn't match";
651 }
652
653 {
654 MatrixKernel kernel(KernelVersion{3, 18, 22}, KernelConfigs(configs));
655 CompatibilityMatrix cm = testMatrix(std::move(kernel));
656 EXPECT_TRUE(ki.checkCompatibility(cm, &error)) << error;
657 }
658
659 {
660 MatrixKernel kernel(KernelVersion{3, 18, 22}, KernelConfigs(configs));
661 CompatibilityMatrix cm = testMatrix(std::move(kernel));
662 set(cm, Sepolicy{22, {{25, 0}}});
663 EXPECT_FALSE(ki.checkCompatibility(cm, &error))
664 << "kernel-sepolicy-version shouldn't match";
665 set(cm, Sepolicy{40, {{25, 0}}});
666 EXPECT_FALSE(ki.checkCompatibility(cm, &error))
667 << "kernel-sepolicy-version shouldn't match";
668 }
669
670 {
671 KernelConfigs newConfigs(configs);
672 newConfigs[0] = KernelConfig{"CONFIG_64BIT", Tristate::NO};
673 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
674 CompatibilityMatrix cm = testMatrix(std::move(kernel));
675 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Value shouldn't match for tristate";
676 }
677
678 {
679 KernelConfigs newConfigs(configs);
680 newConfigs[0] = KernelConfig{"CONFIG_64BIT", 20};
681 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
682 CompatibilityMatrix cm = testMatrix(std::move(kernel));
683 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Type shouldn't match";
684 }
685
686 {
687 KernelConfigs newConfigs(configs);
688 newConfigs[1] = KernelConfig{"CONFIG_ANDROID_BINDER_DEVICES", "binder"};
689 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
690 CompatibilityMatrix cm = testMatrix(std::move(kernel));
691 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Value shouldn't match for string";
692 }
693
694 {
695 KernelConfigs newConfigs(configs);
696 newConfigs[1] = KernelConfig{"CONFIG_ANDROID_BINDER_DEVICES", Tristate::YES};
697 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
698 CompatibilityMatrix cm = testMatrix(std::move(kernel));
699 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Type shouldn't match";
700 }
701
702 {
703 KernelConfigs newConfigs(configs);
704 newConfigs[2] = KernelConfig{"CONFIG_ARCH_MMAP_RND_BITS", 30};
705 MatrixKernel kernel(KernelVersion{3, 18, 22}, std::move(newConfigs));
706 CompatibilityMatrix cm = testMatrix(std::move(kernel));
707 EXPECT_FALSE(ki.checkCompatibility(cm)) << "Value shouldn't match for integer";
708 }
709
710 RuntimeInfo badAvb = testRuntimeInfo();
711 CompatibilityMatrix cm = testMatrix(MatrixKernel(KernelVersion{3, 18, 31}, {}));
712 {
713 setAvb(badAvb, {1, 0}, {2, 1});
714 EXPECT_FALSE(badAvb.checkCompatibility(cm, &error));
715 EXPECT_STREQ(error.c_str(), "Vbmeta version 1.0 does not match framework matrix 2.1");
716 }
717 {
718 setAvb(badAvb, {2, 1}, {3, 0});
719 EXPECT_FALSE(badAvb.checkCompatibility(cm, &error));
720 }
721 {
722 setAvb(badAvb, {2, 1}, {2, 3});
723 EXPECT_TRUE(badAvb.checkCompatibility(cm, &error));
724 }
725 {
726 setAvb(badAvb, {2, 3}, {2, 1});
727 EXPECT_TRUE(badAvb.checkCompatibility(cm, &error));
728 }
729 }
730
TEST_F(LibVintfTest,MissingAvb)731 TEST_F(LibVintfTest, MissingAvb) {
732 std::string xml =
733 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
734 " <kernel version=\"3.18.31\"></kernel>"
735 " <sepolicy>\n"
736 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
737 " <sepolicy-version>25.5</sepolicy-version>\n"
738 " </sepolicy>\n"
739 "</compatibility-matrix>\n";
740 CompatibilityMatrix cm;
741 EXPECT_TRUE(gCompatibilityMatrixConverter(&cm, xml));
742 EXPECT_EQ(getAvb(cm), Version(0, 0));
743 }
744
745 // This is the test extracted from VINTF Object doc
TEST_F(LibVintfTest,HalCompat)746 TEST_F(LibVintfTest, HalCompat) {
747 CompatibilityMatrix matrix;
748 std::string error;
749
750 std::string matrixXml =
751 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
752 " <hal format=\"hidl\" optional=\"false\">\n"
753 " <name>android.hardware.foo</name>\n"
754 " <version>1.0</version>\n"
755 " <version>3.1-2</version>\n"
756 " <interface>\n"
757 " <name>IFoo</name>\n"
758 " <instance>default</instance>\n"
759 " <instance>specific</instance>\n"
760 " </interface>\n"
761 " </hal>\n"
762 " <hal format=\"hidl\" optional=\"false\">\n"
763 " <name>android.hardware.foo</name>\n"
764 " <version>2.0</version>\n"
765 " <interface>\n"
766 " <name>IBar</name>\n"
767 " <instance>default</instance>\n"
768 " </interface>\n"
769 " </hal>\n"
770 " <sepolicy>\n"
771 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
772 " <sepolicy-version>25.5</sepolicy-version>\n"
773 " </sepolicy>\n"
774 "</compatibility-matrix>\n";
775 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml))
776 << gCompatibilityMatrixConverter.lastError();
777
778 {
779 std::string manifestXml =
780 "<manifest version=\"1.0\" type=\"device\">\n"
781 " <hal format=\"hidl\">\n"
782 " <name>android.hardware.foo</name>\n"
783 " <transport>hwbinder</transport>\n"
784 " <version>1.0</version>\n"
785 " <interface>\n"
786 " <name>IFoo</name>\n"
787 " <instance>default</instance>\n"
788 " <instance>specific</instance>\n"
789 " </interface>\n"
790 " </hal>\n"
791 " <hal format=\"hidl\">\n"
792 " <name>android.hardware.foo</name>\n"
793 " <transport>hwbinder</transport>\n"
794 " <version>2.0</version>\n"
795 " <interface>\n"
796 " <name>IBar</name>\n"
797 " <instance>default</instance>\n"
798 " </interface>\n"
799 " </hal>\n"
800 " <sepolicy>\n"
801 " <version>25.5</version>\n"
802 " </sepolicy>\n"
803 "</manifest>\n";
804
805 HalManifest manifest;
806 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
807 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
808 }
809
810 {
811 std::string manifestXml =
812 "<manifest version=\"1.0\" type=\"device\">\n"
813 " <hal format=\"hidl\">\n"
814 " <name>android.hardware.foo</name>\n"
815 " <transport>hwbinder</transport>\n"
816 " <version>1.0</version>\n"
817 " <interface>\n"
818 " <name>IFoo</name>\n"
819 " <instance>default</instance>\n"
820 " <instance>specific</instance>\n"
821 " </interface>\n"
822 " </hal>\n"
823 " <sepolicy>\n"
824 " <version>25.5</version>\n"
825 " </sepolicy>\n"
826 "</manifest>\n";
827 HalManifest manifest;
828 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
829 EXPECT_FALSE(manifest.checkCompatibility(matrix, &error))
830 << "should not be compatible because IBar is missing";
831 }
832
833 {
834 std::string manifestXml =
835 "<manifest version=\"1.0\" type=\"device\">\n"
836 " <hal format=\"hidl\">\n"
837 " <name>android.hardware.foo</name>\n"
838 " <transport>hwbinder</transport>\n"
839 " <version>1.0</version>\n"
840 " <interface>\n"
841 " <name>IFoo</name>\n"
842 " <instance>default</instance>\n"
843 " </interface>\n"
844 " </hal>\n"
845 " <hal format=\"hidl\">\n"
846 " <name>android.hardware.foo</name>\n"
847 " <transport>hwbinder</transport>\n"
848 " <version>2.0</version>\n"
849 " <interface>\n"
850 " <name>IBar</name>\n"
851 " <instance>default</instance>\n"
852 " </interface>\n"
853 " </hal>\n"
854 " <sepolicy>\n"
855 " <version>25.5</version>\n"
856 " </sepolicy>\n"
857 "</manifest>\n";
858 HalManifest manifest;
859 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
860 EXPECT_FALSE(manifest.checkCompatibility(matrix, &error))
861 << "should not be compatible because IFoo/default is missing";
862 }
863
864 {
865 std::string manifestXml =
866 "<manifest version=\"1.0\" type=\"device\">\n"
867 " <hal format=\"hidl\">\n"
868 " <name>android.hardware.foo</name>\n"
869 " <transport>hwbinder</transport>\n"
870 " <version>3.3</version>\n"
871 " <interface>\n"
872 " <name>IFoo</name>\n"
873 " <instance>default</instance>\n"
874 " <instance>specific</instance>\n"
875 " </interface>\n"
876 " </hal>\n"
877 " <hal format=\"hidl\">\n"
878 " <name>android.hardware.foo</name>\n"
879 " <transport>hwbinder</transport>\n"
880 " <version>2.0</version>\n"
881 " <interface>\n"
882 " <name>IBar</name>\n"
883 " <instance>default</instance>\n"
884 " </interface>\n"
885 " </hal>\n"
886 " <sepolicy>\n"
887 " <version>25.5</version>\n"
888 " </sepolicy>\n"
889 "</manifest>\n";
890 HalManifest manifest;
891 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
892 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
893 }
894
895 {
896 std::string manifestXml =
897 "<manifest version=\"1.0\" type=\"device\">\n"
898 " <hal format=\"hidl\">\n"
899 " <name>android.hardware.foo</name>\n"
900 " <transport>hwbinder</transport>\n"
901 " <version>1.0</version>\n"
902 " <interface>\n"
903 " <name>IFoo</name>\n"
904 " <instance>default</instance>\n"
905 " </interface>\n"
906 " </hal>\n"
907 " <hal format=\"hidl\">\n"
908 " <name>android.hardware.foo</name>\n"
909 " <transport>hwbinder</transport>\n"
910 " <version>3.2</version>\n"
911 " <interface>\n"
912 " <name>IFoo</name>\n"
913 " <instance>specific</instance>\n"
914 " </interface>\n"
915 " </hal>\n"
916 " <hal format=\"hidl\">\n"
917 " <name>android.hardware.foo</name>\n"
918 " <transport>hwbinder</transport>\n"
919 " <version>2.0</version>\n"
920 " <interface>\n"
921 " <name>IBar</name>\n"
922 " <instance>default</instance>\n"
923 " </interface>\n"
924 " </hal>\n"
925 " <sepolicy>\n"
926 " <version>25.5</version>\n"
927 " </sepolicy>\n"
928 "</manifest>\n";
929 HalManifest manifest;
930 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
931 EXPECT_FALSE(manifest.checkCompatibility(matrix, &error))
932 << "should not be compatible even though @1.0::IFoo/default "
933 << "and @3.2::IFoo/specific present";
934 }
935
936 {
937 std::string manifestXml =
938 "<manifest version=\"1.0\" type=\"device\">\n"
939 " <hal format=\"hidl\">\n"
940 " <name>android.hardware.foo</name>\n"
941 " <transport>hwbinder</transport>\n"
942 " <version>1.0</version>\n"
943 " <interface>\n"
944 " <name>IFoo</name>\n"
945 " <instance>default</instance>\n"
946 " <instance>specific</instance>\n"
947 " </interface>\n"
948 " </hal>\n"
949 " <hal format=\"hidl\">\n"
950 " <name>android.hardware.foo</name>\n"
951 " <transport>hwbinder</transport>\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 " <version>25.5</version>\n"
960 " </sepolicy>\n"
961 "</manifest>\n";
962 HalManifest manifest;
963 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml))
964 << gHalManifestConverter.lastError();
965 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
966 }
967 }
968
TEST_F(LibVintfTest,Compat)969 TEST_F(LibVintfTest, Compat) {
970 std::string manifestXml =
971 "<manifest version=\"1.0\" type=\"device\">\n"
972 " <hal format=\"hidl\">\n"
973 " <name>android.hardware.camera</name>\n"
974 " <transport>hwbinder</transport>\n"
975 " <version>3.5</version>\n"
976 " <interface>\n"
977 " <name>IBetterCamera</name>\n"
978 " <instance>camera</instance>\n"
979 " </interface>\n"
980 " <interface>\n"
981 " <name>ICamera</name>\n"
982 " <instance>default</instance>\n"
983 " <instance>legacy/0</instance>\n"
984 " </interface>\n"
985 " </hal>\n"
986 " <hal format=\"hidl\">\n"
987 " <name>android.hardware.nfc</name>\n"
988 " <transport>hwbinder</transport>\n"
989 " <version>1.0</version>\n"
990 " <interface>\n"
991 " <name>INfc</name>\n"
992 " <instance>nfc_nci</instance>\n"
993 " </interface>\n"
994 " </hal>\n"
995 " <hal format=\"hidl\">\n"
996 " <name>android.hardware.nfc</name>\n"
997 " <transport>hwbinder</transport>\n"
998 " <version>2.0</version>\n"
999 " <interface>\n"
1000 " <name>INfc</name>\n"
1001 " <instance>default</instance>\n"
1002 " <instance>nfc_nci</instance>\n"
1003 " </interface>\n"
1004 " </hal>\n"
1005 " <sepolicy>\n"
1006 " <version>25.5</version>\n"
1007 " </sepolicy>\n"
1008 "</manifest>\n";
1009
1010 std::string matrixXml =
1011 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1012 " <hal format=\"hidl\" optional=\"false\">\n"
1013 " <name>android.hardware.camera</name>\n"
1014 " <version>2.0-5</version>\n"
1015 " <version>3.4-16</version>\n"
1016 " <interface>\n"
1017 " <name>IBetterCamera</name>\n"
1018 " <instance>camera</instance>\n"
1019 " </interface>\n"
1020 " <interface>\n"
1021 " <name>ICamera</name>\n"
1022 " <instance>default</instance>\n"
1023 " <instance>legacy/0</instance>\n"
1024 " </interface>\n"
1025 " </hal>\n"
1026 " <hal format=\"hidl\" optional=\"false\">\n"
1027 " <name>android.hardware.nfc</name>\n"
1028 " <version>1.0</version>\n"
1029 " <version>2.0</version>\n"
1030 " <interface>\n"
1031 " <name>INfc</name>\n"
1032 " <instance>nfc_nci</instance>\n"
1033 " </interface>\n"
1034 " </hal>\n"
1035 " <hal format=\"hidl\" optional=\"true\">\n"
1036 " <name>android.hardware.foo</name>\n"
1037 " <version>1.0</version>\n"
1038 " </hal>\n"
1039 " <sepolicy>\n"
1040 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1041 " <sepolicy-version>25.5</sepolicy-version>\n"
1042 " <sepolicy-version>26.0-3</sepolicy-version>\n"
1043 " </sepolicy>\n"
1044 " <avb>\n"
1045 " <vbmeta-version>2.1</vbmeta-version>\n"
1046 " </avb>\n"
1047 "</compatibility-matrix>\n";
1048
1049 HalManifest manifest;
1050 CompatibilityMatrix matrix;
1051 std::string error;
1052 EXPECT_TRUE(gHalManifestConverter(&manifest, manifestXml));
1053 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1054 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1055
1056 // some smaller test cases
1057 matrixXml =
1058 "<compatibility-matrix version=\"1.0\" type=\"framework\">\n"
1059 " <hal format=\"hidl\" optional=\"false\">\n"
1060 " <name>android.hardware.camera</name>\n"
1061 " <version>3.4</version>\n"
1062 " </hal>\n"
1063 " <sepolicy>\n"
1064 " <kernel-sepolicy-version>30</kernel-sepolicy-version>\n"
1065 " <sepolicy-version>25.5</sepolicy-version>\n"
1066 " </sepolicy>\n"
1067 " <avb><vbmeta-version>2.1</vbmeta-version></avb>\n"
1068 "</compatibility-matrix>\n";
1069 matrix = {};
1070 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1071 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1072 MatrixHal *camera = getAnyHal(matrix, "android.hardware.camera");
1073 EXPECT_NE(camera, nullptr);
1074 camera->versionRanges[0] = {3, 5};
1075 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1076 camera->versionRanges[0] = {3, 6};
1077 EXPECT_FALSE(manifest.checkCompatibility(matrix));
1078
1079 // reset it
1080 matrix = {};
1081 EXPECT_TRUE(gCompatibilityMatrixConverter(&matrix, matrixXml));
1082 set(matrix, Sepolicy{30, {{26, 0}}});
1083 EXPECT_FALSE(manifest.checkCompatibility(matrix));
1084 set(matrix, Sepolicy{30, {{25, 6}}});
1085 EXPECT_FALSE(manifest.checkCompatibility(matrix));
1086 set(matrix, Sepolicy{30, {{25, 4}}});
1087 EXPECT_TRUE(manifest.checkCompatibility(matrix, &error)) << error;
1088 }
1089
1090 } // namespace vintf
1091 } // namespace android
1092
main(int argc,char ** argv)1093 int main(int argc, char **argv) {
1094 ::testing::InitGoogleTest(&argc, argv);
1095 return RUN_ALL_TESTS();
1096 }
1097