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 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: 54 virtual void SetUp() override { 55 } 56 virtual void TearDown() override { 57 } 58 bool add(CompatibilityMatrix &cm, MatrixHal &&hal) { 59 return cm.add(std::move(hal)); 60 } 61 bool add(CompatibilityMatrix &cm, MatrixKernel &&kernel) { 62 return cm.add(std::move(kernel)); 63 } 64 bool add(HalManifest &vm, ManifestHal &&hal) { 65 return vm.add(std::move(hal)); 66 } 67 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 } 75 void set(CompatibilityMatrix &cm, Sepolicy &&sepolicy) { 76 cm.framework.mSepolicy = sepolicy; 77 } 78 void set(CompatibilityMatrix &cm, SchemaType type) { 79 cm.mType = type; 80 } 81 void set(CompatibilityMatrix &cm, VndkVersionRange &&range, std::set<std::string> &&libs) { 82 cm.device.mVndk.mVersionRange = range; 83 cm.device.mVndk.mLibraries = libs; 84 } 85 void setAvb(RuntimeInfo &ki, Version vbmeta, Version boot) { 86 ki.mBootVbmetaAvbVersion = vbmeta; 87 ki.mBootAvbVersion = boot; 88 } 89 void setAvb(CompatibilityMatrix &cm, Version &&avbVersion) { 90 cm.framework.mAvbMetaVersion = avbVersion; 91 } 92 Version getAvb(CompatibilityMatrix &cm) { 93 return cm.framework.mAvbMetaVersion; 94 } 95 const ManifestHal *getAnyHal(HalManifest &vm, const std::string &name) { 96 return vm.getAnyHal(name); 97 } 98 MatrixHal *getAnyHal(CompatibilityMatrix &cm, const std::string &name) { 99 return cm.getAnyHal(name); 100 } 101 ConstMultiMapValueIterable<std::string, ManifestHal> getHals(HalManifest &vm) { 102 return vm.getHals(); 103 } 104 bool isValid(const ManifestHal &mh) { 105 return mh.isValid(); 106 } 107 std::vector<MatrixKernel>& getKernels(CompatibilityMatrix& cm) { return cm.framework.mKernels; } 108 bool addAllHalsAsOptional(CompatibilityMatrix* cm1, CompatibilityMatrix* cm2, std::string* e) { 109 return cm1->addAllHalsAsOptional(cm2, e); 110 } 111 bool addAllXmlFilesAsOptional(CompatibilityMatrix* cm1, CompatibilityMatrix* cm2, 112 std::string* e) { 113 return cm1->addAllXmlFilesAsOptional(cm2, e); 114 } 115 std::set<std::string> checkUnusedHals(const HalManifest& m, const CompatibilityMatrix& cm) { 116 return m.checkUnusedHals(cm); 117 } 118 119 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 126 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 } 144 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 } 152 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 } 172 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 } 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 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 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 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 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 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 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. 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 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>. 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. 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 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 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 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 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 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 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 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 (at) 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 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 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 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 (at) 1.0::IFoo/nonmatch/legacy/0", 3410 "android.hardware.foo (at) 1.0::IFoo/legacy/0/nonmatch", 3411 "android.hardware.foo (at) 1.0::IFoo/legacy0"}), 3412 unused); 3413 } 3414 } 3415 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 3433 int main(int argc, char **argv) { 3434 ::testing::InitGoogleTest(&argc, argv); 3435 return RUN_ALL_TESTS(); 3436 } 3437
