1 #include "android/hardware/tests/msgq/1.0/TestMsgQ.vts.h" 2 #include "vts_measurement.h" 3 #include <iostream> 4 #include <hidl/HidlSupport.h> 5 #include <android/hardware/tests/msgq/1.0/ITestMsgQ.h> 6 #include <android/hidl/base/1.0/types.h> 7 #include <android/hidl/allocator/1.0/IAllocator.h> 8 #include <fmq/MessageQueue.h> 9 #include <sys/stat.h> 10 #include <unistd.h> 11 12 13 using namespace android::hardware::tests::msgq::V1_0; 14 namespace android { 15 namespace vts { 16 ::android::hardware::tests::msgq::V1_0::ITestMsgQ::EventFlagBits EnumValue__android__hardware__tests__msgq__V1_0__ITestMsgQ__EventFlagBits(const ScalarDataValueMessage& arg) { 17 return (::android::hardware::tests::msgq::V1_0::ITestMsgQ::EventFlagBits) arg.uint32_t(); 18 } 19 uint32_t Random__android__hardware__tests__msgq__V1_0__ITestMsgQ__EventFlagBits() { 20 uint32_t choice = (uint32_t) rand() / 2; 21 if (choice == (uint32_t) 1) return static_cast<uint32_t>(::android::hardware::tests::msgq::V1_0::ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY); 22 if (choice == (uint32_t) 2) return static_cast<uint32_t>(::android::hardware::tests::msgq::V1_0::ITestMsgQ::EventFlagBits::FMQ_NOT_FULL); 23 return static_cast<uint32_t>(::android::hardware::tests::msgq::V1_0::ITestMsgQ::EventFlagBits::FMQ_NOT_EMPTY); 24 } 25 bool Verify__android__hardware__tests__msgq__V1_0__ITestMsgQ__EventFlagBits(const VariableSpecificationMessage& expected_result __attribute__((__unused__)), const VariableSpecificationMessage& actual_result __attribute__((__unused__))){ 26 if (actual_result.scalar_value().uint32_t() != expected_result.scalar_value().uint32_t()) { return false; } 27 return true; 28 } 29 30 void SetResult__android__hardware__tests__msgq__V1_0__ITestMsgQ__EventFlagBits(VariableSpecificationMessage* result_msg, ::android::hardware::tests::msgq::V1_0::ITestMsgQ::EventFlagBits result_value __attribute__((__unused__))){ 31 result_msg->set_type(TYPE_ENUM); 32 result_msg->set_scalar_type("uint32_t"); 33 result_msg->mutable_scalar_value()->set_uint32_t(static_cast<uint32_t>(result_value)); 34 } 35 36 bool FuzzerExtended_android_hardware_tests_msgq_V1_0_ITestMsgQ::GetService(bool get_stub, const char* service_name) { 37 static bool initialized = false; 38 if (!initialized) { 39 cout << "[agent:hal] HIDL getService" << endl; 40 if (service_name) { 41 cout << " - service name: " << service_name << endl; 42 } 43 hw_binder_proxy_ = ::android::hardware::tests::msgq::V1_0::ITestMsgQ::getService(service_name, get_stub); 44 if (hw_binder_proxy_ == nullptr) { 45 cerr << "getService() returned a null pointer." << endl; 46 return false; 47 } 48 cout << "[agent:hal] hw_binder_proxy_ = " << hw_binder_proxy_.get() << endl; 49 initialized = true; 50 } 51 return true; 52 } 53 54 55 ::android::hardware::Return<void> Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::configureFmqSyncReadWrite( 56 std::function<void(bool arg0,const ::android::hardware::MQDescriptorSync<uint16_t>& arg1)>) { 57 cout << "configureFmqSyncReadWrite called" << endl; 58 AndroidSystemCallbackRequestMessage callback_message; 59 callback_message.set_id(GetCallbackID("configureFmqSyncReadWrite")); 60 callback_message.set_name("Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::configureFmqSyncReadWrite"); 61 RpcCallToAgent(callback_message, callback_socket_name_); 62 return ::android::hardware::Void(); 63 } 64 65 ::android::hardware::Return<void> Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::getFmqUnsyncWrite( 66 bool arg0 __attribute__((__unused__)), std::function<void(bool arg0,const ::android::hardware::MQDescriptorUnsync<uint16_t>& arg1)>) { 67 cout << "getFmqUnsyncWrite called" << endl; 68 AndroidSystemCallbackRequestMessage callback_message; 69 callback_message.set_id(GetCallbackID("getFmqUnsyncWrite")); 70 callback_message.set_name("Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::getFmqUnsyncWrite"); 71 VariableSpecificationMessage* var_msg0 = callback_message.add_arg(); 72 var_msg0->set_type(TYPE_SCALAR); 73 var_msg0->set_scalar_type("bool_t"); 74 var_msg0->mutable_scalar_value()->set_bool_t(arg0); 75 RpcCallToAgent(callback_message, callback_socket_name_); 76 return ::android::hardware::Void(); 77 } 78 79 ::android::hardware::Return<bool> Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestWriteFmqSync( 80 int32_t arg0 __attribute__((__unused__))) { 81 cout << "requestWriteFmqSync called" << endl; 82 AndroidSystemCallbackRequestMessage callback_message; 83 callback_message.set_id(GetCallbackID("requestWriteFmqSync")); 84 callback_message.set_name("Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestWriteFmqSync"); 85 VariableSpecificationMessage* var_msg0 = callback_message.add_arg(); 86 var_msg0->set_type(TYPE_SCALAR); 87 var_msg0->set_scalar_type("int32_t"); 88 var_msg0->mutable_scalar_value()->set_int32_t(arg0); 89 RpcCallToAgent(callback_message, callback_socket_name_); 90 return static_cast<bool>(0); 91 } 92 93 ::android::hardware::Return<bool> Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestReadFmqSync( 94 int32_t arg0 __attribute__((__unused__))) { 95 cout << "requestReadFmqSync called" << endl; 96 AndroidSystemCallbackRequestMessage callback_message; 97 callback_message.set_id(GetCallbackID("requestReadFmqSync")); 98 callback_message.set_name("Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestReadFmqSync"); 99 VariableSpecificationMessage* var_msg0 = callback_message.add_arg(); 100 var_msg0->set_type(TYPE_SCALAR); 101 var_msg0->set_scalar_type("int32_t"); 102 var_msg0->mutable_scalar_value()->set_int32_t(arg0); 103 RpcCallToAgent(callback_message, callback_socket_name_); 104 return static_cast<bool>(0); 105 } 106 107 ::android::hardware::Return<bool> Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestWriteFmqUnsync( 108 int32_t arg0 __attribute__((__unused__))) { 109 cout << "requestWriteFmqUnsync called" << endl; 110 AndroidSystemCallbackRequestMessage callback_message; 111 callback_message.set_id(GetCallbackID("requestWriteFmqUnsync")); 112 callback_message.set_name("Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestWriteFmqUnsync"); 113 VariableSpecificationMessage* var_msg0 = callback_message.add_arg(); 114 var_msg0->set_type(TYPE_SCALAR); 115 var_msg0->set_scalar_type("int32_t"); 116 var_msg0->mutable_scalar_value()->set_int32_t(arg0); 117 RpcCallToAgent(callback_message, callback_socket_name_); 118 return static_cast<bool>(0); 119 } 120 121 ::android::hardware::Return<bool> Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestReadFmqUnsync( 122 int32_t arg0 __attribute__((__unused__))) { 123 cout << "requestReadFmqUnsync called" << endl; 124 AndroidSystemCallbackRequestMessage callback_message; 125 callback_message.set_id(GetCallbackID("requestReadFmqUnsync")); 126 callback_message.set_name("Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestReadFmqUnsync"); 127 VariableSpecificationMessage* var_msg0 = callback_message.add_arg(); 128 var_msg0->set_type(TYPE_SCALAR); 129 var_msg0->set_scalar_type("int32_t"); 130 var_msg0->mutable_scalar_value()->set_int32_t(arg0); 131 RpcCallToAgent(callback_message, callback_socket_name_); 132 return static_cast<bool>(0); 133 } 134 135 ::android::hardware::Return<void> Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestBlockingRead( 136 int32_t arg0 __attribute__((__unused__))) { 137 cout << "requestBlockingRead called" << endl; 138 AndroidSystemCallbackRequestMessage callback_message; 139 callback_message.set_id(GetCallbackID("requestBlockingRead")); 140 callback_message.set_name("Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestBlockingRead"); 141 VariableSpecificationMessage* var_msg0 = callback_message.add_arg(); 142 var_msg0->set_type(TYPE_SCALAR); 143 var_msg0->set_scalar_type("int32_t"); 144 var_msg0->mutable_scalar_value()->set_int32_t(arg0); 145 RpcCallToAgent(callback_message, callback_socket_name_); 146 return ::android::hardware::Void(); 147 } 148 149 ::android::hardware::Return<void> Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestBlockingReadDefaultEventFlagBits( 150 int32_t arg0 __attribute__((__unused__))) { 151 cout << "requestBlockingReadDefaultEventFlagBits called" << endl; 152 AndroidSystemCallbackRequestMessage callback_message; 153 callback_message.set_id(GetCallbackID("requestBlockingReadDefaultEventFlagBits")); 154 callback_message.set_name("Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestBlockingReadDefaultEventFlagBits"); 155 VariableSpecificationMessage* var_msg0 = callback_message.add_arg(); 156 var_msg0->set_type(TYPE_SCALAR); 157 var_msg0->set_scalar_type("int32_t"); 158 var_msg0->mutable_scalar_value()->set_int32_t(arg0); 159 RpcCallToAgent(callback_message, callback_socket_name_); 160 return ::android::hardware::Void(); 161 } 162 163 ::android::hardware::Return<void> Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestBlockingReadRepeat( 164 int32_t arg0 __attribute__((__unused__)), 165 int32_t arg1 __attribute__((__unused__))) { 166 cout << "requestBlockingReadRepeat called" << endl; 167 AndroidSystemCallbackRequestMessage callback_message; 168 callback_message.set_id(GetCallbackID("requestBlockingReadRepeat")); 169 callback_message.set_name("Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ::requestBlockingReadRepeat"); 170 VariableSpecificationMessage* var_msg0 = callback_message.add_arg(); 171 var_msg0->set_type(TYPE_SCALAR); 172 var_msg0->set_scalar_type("int32_t"); 173 var_msg0->mutable_scalar_value()->set_int32_t(arg0); 174 VariableSpecificationMessage* var_msg1 = callback_message.add_arg(); 175 var_msg1->set_type(TYPE_SCALAR); 176 var_msg1->set_scalar_type("int32_t"); 177 var_msg1->mutable_scalar_value()->set_int32_t(arg1); 178 RpcCallToAgent(callback_message, callback_socket_name_); 179 return ::android::hardware::Void(); 180 } 181 182 sp<::android::hardware::tests::msgq::V1_0::ITestMsgQ> VtsFuzzerCreateVts_android_hardware_tests_msgq_V1_0_ITestMsgQ(const string& callback_socket_name) { 183 static sp<::android::hardware::tests::msgq::V1_0::ITestMsgQ> result; 184 result = new Vts_android_hardware_tests_msgq_V1_0_ITestMsgQ(callback_socket_name); 185 return result; 186 } 187 188 bool FuzzerExtended_android_hardware_tests_msgq_V1_0_ITestMsgQ::Fuzz( 189 FunctionSpecificationMessage* /*func_msg*/, 190 void** /*result*/, const string& /*callback_socket_name*/) { 191 return true; 192 } 193 bool FuzzerExtended_android_hardware_tests_msgq_V1_0_ITestMsgQ::GetAttribute( 194 FunctionSpecificationMessage* /*func_msg*/, 195 void** /*result*/) { 196 cerr << "attribute not found" << endl; 197 return false; 198 } 199 bool FuzzerExtended_android_hardware_tests_msgq_V1_0_ITestMsgQ::CallFunction( 200 const FunctionSpecificationMessage& func_msg, 201 const string& callback_socket_name __attribute__((__unused__)), 202 FunctionSpecificationMessage* result_msg) { 203 const char* func_name = func_msg.name().c_str(); 204 cout << "Function: " << __func__ << " " << func_name << endl; 205 cout << "Callback socket name: " << callback_socket_name << endl; 206 if (hw_binder_proxy_ == nullptr) { 207 cerr << "hw_binder_proxy_ is null. "<< endl; 208 return false; 209 } 210 if (!strcmp(func_name, "configureFmqSyncReadWrite")) { 211 VtsMeasurement vts_measurement; 212 vts_measurement.Start(); 213 cout << "Call an API" << endl; 214 cout << "local_device = " << hw_binder_proxy_.get() << endl; 215 bool result0; 216 std::unique_ptr<::android::hardware::MQDescriptorSync<uint16_t>> result1; 217 hw_binder_proxy_->configureFmqSyncReadWrite([&](bool arg0,const ::android::hardware::MQDescriptorSync<uint16_t>& arg1){ 218 cout << "callback configureFmqSyncReadWrite called" << endl; 219 result0 = arg0; 220 result1.reset(new (std::nothrow) ::android::hardware::MQDescriptorSync<uint16_t>(arg1)); 221 }); 222 vector<float>* measured = vts_measurement.Stop(); 223 cout << "time " << (*measured)[0] << endl; 224 result_msg->set_name("configureFmqSyncReadWrite"); 225 VariableSpecificationMessage* result_val_0 = result_msg->add_return_type_hidl(); 226 result_val_0->set_type(TYPE_SCALAR); 227 result_val_0->set_scalar_type("bool_t"); 228 result_val_0->mutable_scalar_value()->set_bool_t(result0); 229 VariableSpecificationMessage* result_val_1 = result_msg->add_return_type_hidl(); 230 result_val_1->set_type(TYPE_FMQ_SYNC); 231 /* ERROR: TYPE_FMQ_SYNC is not supported yet. */ 232 cout << "called" << endl; 233 return true; 234 } 235 if (!strcmp(func_name, "getFmqUnsyncWrite")) { 236 bool arg0 = 0; 237 arg0 = func_msg.arg(0).scalar_value().bool_t(); 238 VtsMeasurement vts_measurement; 239 vts_measurement.Start(); 240 cout << "Call an API" << endl; 241 cout << "local_device = " << hw_binder_proxy_.get() << endl; 242 bool result0; 243 std::unique_ptr<::android::hardware::MQDescriptorUnsync<uint16_t>> result1; 244 hw_binder_proxy_->getFmqUnsyncWrite(arg0, [&](bool arg0,const ::android::hardware::MQDescriptorUnsync<uint16_t>& arg1){ 245 cout << "callback getFmqUnsyncWrite called" << endl; 246 result0 = arg0; 247 result1.reset(new (std::nothrow) ::android::hardware::MQDescriptorUnsync<uint16_t>(arg1)); 248 }); 249 vector<float>* measured = vts_measurement.Stop(); 250 cout << "time " << (*measured)[0] << endl; 251 result_msg->set_name("getFmqUnsyncWrite"); 252 VariableSpecificationMessage* result_val_0 = result_msg->add_return_type_hidl(); 253 result_val_0->set_type(TYPE_SCALAR); 254 result_val_0->set_scalar_type("bool_t"); 255 result_val_0->mutable_scalar_value()->set_bool_t(result0); 256 VariableSpecificationMessage* result_val_1 = result_msg->add_return_type_hidl(); 257 result_val_1->set_type(TYPE_FMQ_UNSYNC); 258 /* ERROR: TYPE_FMQ_UNSYNC is not supported yet. */ 259 cout << "called" << endl; 260 return true; 261 } 262 if (!strcmp(func_name, "requestWriteFmqSync")) { 263 int32_t arg0 = 0; 264 arg0 = func_msg.arg(0).scalar_value().int32_t(); 265 VtsMeasurement vts_measurement; 266 vts_measurement.Start(); 267 cout << "Call an API" << endl; 268 cout << "local_device = " << hw_binder_proxy_.get() << endl; 269 bool result0; 270 result0 = hw_binder_proxy_->requestWriteFmqSync(arg0); 271 vector<float>* measured = vts_measurement.Stop(); 272 cout << "time " << (*measured)[0] << endl; 273 result_msg->set_name("requestWriteFmqSync"); 274 VariableSpecificationMessage* result_val_0 = result_msg->add_return_type_hidl(); 275 result_val_0->set_type(TYPE_SCALAR); 276 result_val_0->set_scalar_type("bool_t"); 277 result_val_0->mutable_scalar_value()->set_bool_t(result0); 278 cout << "called" << endl; 279 return true; 280 } 281 if (!strcmp(func_name, "requestReadFmqSync")) { 282 int32_t arg0 = 0; 283 arg0 = func_msg.arg(0).scalar_value().int32_t(); 284 VtsMeasurement vts_measurement; 285 vts_measurement.Start(); 286 cout << "Call an API" << endl; 287 cout << "local_device = " << hw_binder_proxy_.get() << endl; 288 bool result0; 289 result0 = hw_binder_proxy_->requestReadFmqSync(arg0); 290 vector<float>* measured = vts_measurement.Stop(); 291 cout << "time " << (*measured)[0] << endl; 292 result_msg->set_name("requestReadFmqSync"); 293 VariableSpecificationMessage* result_val_0 = result_msg->add_return_type_hidl(); 294 result_val_0->set_type(TYPE_SCALAR); 295 result_val_0->set_scalar_type("bool_t"); 296 result_val_0->mutable_scalar_value()->set_bool_t(result0); 297 cout << "called" << endl; 298 return true; 299 } 300 if (!strcmp(func_name, "requestWriteFmqUnsync")) { 301 int32_t arg0 = 0; 302 arg0 = func_msg.arg(0).scalar_value().int32_t(); 303 VtsMeasurement vts_measurement; 304 vts_measurement.Start(); 305 cout << "Call an API" << endl; 306 cout << "local_device = " << hw_binder_proxy_.get() << endl; 307 bool result0; 308 result0 = hw_binder_proxy_->requestWriteFmqUnsync(arg0); 309 vector<float>* measured = vts_measurement.Stop(); 310 cout << "time " << (*measured)[0] << endl; 311 result_msg->set_name("requestWriteFmqUnsync"); 312 VariableSpecificationMessage* result_val_0 = result_msg->add_return_type_hidl(); 313 result_val_0->set_type(TYPE_SCALAR); 314 result_val_0->set_scalar_type("bool_t"); 315 result_val_0->mutable_scalar_value()->set_bool_t(result0); 316 cout << "called" << endl; 317 return true; 318 } 319 if (!strcmp(func_name, "requestReadFmqUnsync")) { 320 int32_t arg0 = 0; 321 arg0 = func_msg.arg(0).scalar_value().int32_t(); 322 VtsMeasurement vts_measurement; 323 vts_measurement.Start(); 324 cout << "Call an API" << endl; 325 cout << "local_device = " << hw_binder_proxy_.get() << endl; 326 bool result0; 327 result0 = hw_binder_proxy_->requestReadFmqUnsync(arg0); 328 vector<float>* measured = vts_measurement.Stop(); 329 cout << "time " << (*measured)[0] << endl; 330 result_msg->set_name("requestReadFmqUnsync"); 331 VariableSpecificationMessage* result_val_0 = result_msg->add_return_type_hidl(); 332 result_val_0->set_type(TYPE_SCALAR); 333 result_val_0->set_scalar_type("bool_t"); 334 result_val_0->mutable_scalar_value()->set_bool_t(result0); 335 cout << "called" << endl; 336 return true; 337 } 338 if (!strcmp(func_name, "requestBlockingRead")) { 339 int32_t arg0 = 0; 340 arg0 = func_msg.arg(0).scalar_value().int32_t(); 341 VtsMeasurement vts_measurement; 342 vts_measurement.Start(); 343 cout << "Call an API" << endl; 344 cout << "local_device = " << hw_binder_proxy_.get() << endl; 345 hw_binder_proxy_->requestBlockingRead(arg0); 346 vector<float>* measured = vts_measurement.Stop(); 347 cout << "time " << (*measured)[0] << endl; 348 result_msg->set_name("requestBlockingRead"); 349 cout << "called" << endl; 350 return true; 351 } 352 if (!strcmp(func_name, "requestBlockingReadDefaultEventFlagBits")) { 353 int32_t arg0 = 0; 354 arg0 = func_msg.arg(0).scalar_value().int32_t(); 355 VtsMeasurement vts_measurement; 356 vts_measurement.Start(); 357 cout << "Call an API" << endl; 358 cout << "local_device = " << hw_binder_proxy_.get() << endl; 359 hw_binder_proxy_->requestBlockingReadDefaultEventFlagBits(arg0); 360 vector<float>* measured = vts_measurement.Stop(); 361 cout << "time " << (*measured)[0] << endl; 362 result_msg->set_name("requestBlockingReadDefaultEventFlagBits"); 363 cout << "called" << endl; 364 return true; 365 } 366 if (!strcmp(func_name, "requestBlockingReadRepeat")) { 367 int32_t arg0 = 0; 368 arg0 = func_msg.arg(0).scalar_value().int32_t(); 369 int32_t arg1 = 0; 370 arg1 = func_msg.arg(1).scalar_value().int32_t(); 371 VtsMeasurement vts_measurement; 372 vts_measurement.Start(); 373 cout << "Call an API" << endl; 374 cout << "local_device = " << hw_binder_proxy_.get() << endl; 375 hw_binder_proxy_->requestBlockingReadRepeat(arg0, arg1); 376 vector<float>* measured = vts_measurement.Stop(); 377 cout << "time " << (*measured)[0] << endl; 378 result_msg->set_name("requestBlockingReadRepeat"); 379 cout << "called" << endl; 380 return true; 381 } 382 if (!strcmp(func_name, "notifySyspropsChanged")) { 383 cout << "Call notifySyspropsChanged" << endl; 384 hw_binder_proxy_->notifySyspropsChanged(); 385 result_msg->set_name("notifySyspropsChanged"); 386 cout << "called" << endl; 387 return true; 388 } 389 return false; 390 } 391 392 bool FuzzerExtended_android_hardware_tests_msgq_V1_0_ITestMsgQ::VerifyResults(const FunctionSpecificationMessage& expected_result __attribute__((__unused__)), 393 const FunctionSpecificationMessage& actual_result __attribute__((__unused__))) { 394 if (!strcmp(actual_result.name().c_str(), "configureFmqSyncReadWrite")) { 395 if (actual_result.return_type_hidl_size() != expected_result.return_type_hidl_size() ) { return false; } 396 if (actual_result.return_type_hidl(0).scalar_value().bool_t() != expected_result.return_type_hidl(0).scalar_value().bool_t()) { return false; } 397 /* ERROR: TYPE_FMQ_SYNC is not supported yet. */ 398 return true; 399 } 400 if (!strcmp(actual_result.name().c_str(), "getFmqUnsyncWrite")) { 401 if (actual_result.return_type_hidl_size() != expected_result.return_type_hidl_size() ) { return false; } 402 if (actual_result.return_type_hidl(0).scalar_value().bool_t() != expected_result.return_type_hidl(0).scalar_value().bool_t()) { return false; } 403 /* ERROR: TYPE_FMQ_UNSYNC is not supported yet. */ 404 return true; 405 } 406 if (!strcmp(actual_result.name().c_str(), "requestWriteFmqSync")) { 407 if (actual_result.return_type_hidl_size() != expected_result.return_type_hidl_size() ) { return false; } 408 if (actual_result.return_type_hidl(0).scalar_value().bool_t() != expected_result.return_type_hidl(0).scalar_value().bool_t()) { return false; } 409 return true; 410 } 411 if (!strcmp(actual_result.name().c_str(), "requestReadFmqSync")) { 412 if (actual_result.return_type_hidl_size() != expected_result.return_type_hidl_size() ) { return false; } 413 if (actual_result.return_type_hidl(0).scalar_value().bool_t() != expected_result.return_type_hidl(0).scalar_value().bool_t()) { return false; } 414 return true; 415 } 416 if (!strcmp(actual_result.name().c_str(), "requestWriteFmqUnsync")) { 417 if (actual_result.return_type_hidl_size() != expected_result.return_type_hidl_size() ) { return false; } 418 if (actual_result.return_type_hidl(0).scalar_value().bool_t() != expected_result.return_type_hidl(0).scalar_value().bool_t()) { return false; } 419 return true; 420 } 421 if (!strcmp(actual_result.name().c_str(), "requestReadFmqUnsync")) { 422 if (actual_result.return_type_hidl_size() != expected_result.return_type_hidl_size() ) { return false; } 423 if (actual_result.return_type_hidl(0).scalar_value().bool_t() != expected_result.return_type_hidl(0).scalar_value().bool_t()) { return false; } 424 return true; 425 } 426 if (!strcmp(actual_result.name().c_str(), "requestBlockingRead")) { 427 if (actual_result.return_type_hidl_size() != expected_result.return_type_hidl_size() ) { return false; } 428 return true; 429 } 430 if (!strcmp(actual_result.name().c_str(), "requestBlockingReadDefaultEventFlagBits")) { 431 if (actual_result.return_type_hidl_size() != expected_result.return_type_hidl_size() ) { return false; } 432 return true; 433 } 434 if (!strcmp(actual_result.name().c_str(), "requestBlockingReadRepeat")) { 435 if (actual_result.return_type_hidl_size() != expected_result.return_type_hidl_size() ) { return false; } 436 return true; 437 } 438 return false; 439 } 440 441 extern "C" { 442 android::vts::DriverBase* vts_func_4_android_hardware_tests_msgq_V1_0_ITestMsgQ_() { 443 return (android::vts::DriverBase*) new android::vts::FuzzerExtended_android_hardware_tests_msgq_V1_0_ITestMsgQ(); 444 } 445 446 android::vts::DriverBase* vts_func_4_android_hardware_tests_msgq_V1_0_ITestMsgQ_with_arg(uint64_t hw_binder_proxy) { 447 ::android::hardware::tests::msgq::V1_0::ITestMsgQ* arg = nullptr; 448 if (hw_binder_proxy) { 449 arg = reinterpret_cast<::android::hardware::tests::msgq::V1_0::ITestMsgQ*>(hw_binder_proxy); 450 } else { 451 cout << " Creating DriverBase with null proxy." << endl; 452 } 453 android::vts::DriverBase* result = 454 new android::vts::FuzzerExtended_android_hardware_tests_msgq_V1_0_ITestMsgQ( 455 arg); 456 if (arg != nullptr) { 457 arg->decStrong(arg); 458 } 459 return result; 460 } 461 462 } 463 } // namespace vts 464 } // namespace android 465
