diff --git a/test/fuzztest/BUILD.gn b/test/fuzztest/BUILD.gn index d755c3e532db9bd0c96c1ea35f1a369a0e6dc61c..28346c3a50f50e07efaf09c1406b047a61ab78e3 100644 --- a/test/fuzztest/BUILD.gn +++ b/test/fuzztest/BUILD.gn @@ -1150,10 +1150,11 @@ ohos_fuzztest("UsbMgrCancelTransferFuzzTest") { ] } -ohos_fuzztest("UsbMgrSerialOpenFuzzTest") { +ohos_fuzztest("UsbMgrAddSerialRightFuzzTest") { module_out_path = module_output_path - fuzz_config_file = "${usb_manager_path}/test/fuzztest/usbmgrserialopen_fuzzer" + fuzz_config_file = + "${usb_manager_path}/test/fuzztest/usbmgraddserialright_fuzzer" configs = [ ":module_private_config" ] @@ -1164,18 +1165,19 @@ ohos_fuzztest("UsbMgrSerialOpenFuzzTest") { external_deps = [ "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", "hilog:libhilog", "ipc:ipc_core", ] - sources = [ "usbmgrserialopen_fuzzer/usbmgrserialopen_fuzzer.cpp" ] + sources = [ "usbmgraddserialright_fuzzer/usbmgraddserialright_fuzzer.cpp" ] } -ohos_fuzztest("UsbMgrSerialCloseFuzzTest") { +ohos_fuzztest("UsbMgrCancelSerialRightFuzzTest") { module_out_path = module_output_path fuzz_config_file = - "${usb_manager_path}/test/fuzztest/usbmgrserialclose_fuzzer" + "${usb_manager_path}/test/fuzztest/usbmgrcancelserialright_fuzzer" configs = [ ":module_private_config" ] @@ -1186,18 +1188,19 @@ ohos_fuzztest("UsbMgrSerialCloseFuzzTest") { external_deps = [ "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", "hilog:libhilog", "ipc:ipc_core", ] - sources = [ "usbmgrserialclose_fuzzer/usbmgrserialclose_fuzzer.cpp" ] + sources = [ "usbmgrcancelserialright_fuzzer/usbmgrcancelserialright_fuzzer.cpp" ] } -ohos_fuzztest("UsbMgrSerialGetAttributeFuzzTest") { +ohos_fuzztest("UsbMgrHasSerialRightFuzzTest") { module_out_path = module_output_path fuzz_config_file = - "${usb_manager_path}/test/fuzztest/usbmgrserialgetattribute_fuzzer" + "${usb_manager_path}/test/fuzztest/usbmgrhasserialright_fuzzer" configs = [ ":module_private_config" ] @@ -1208,19 +1211,19 @@ ohos_fuzztest("UsbMgrSerialGetAttributeFuzzTest") { external_deps = [ "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", "hilog:libhilog", "ipc:ipc_core", ] - sources = - [ "usbmgrserialgetattribute_fuzzer/usbmgrserialgetattribute_fuzzer.cpp" ] + sources = [ "usbmgrhasserialright_fuzzer/usbmgrhasserialright_fuzzer.cpp" ] } -ohos_fuzztest("UsbMgrSerialSetAttributeFuzzTest") { +ohos_fuzztest("UsbMgrRequestSerialRightFuzzTest") { module_out_path = module_output_path fuzz_config_file = - "${usb_manager_path}/test/fuzztest/usbmgrserialsetattribute_fuzzer" + "${usb_manager_path}/test/fuzztest/usbmgrrequestserialright_fuzzer" configs = [ ":module_private_config" ] @@ -1231,19 +1234,19 @@ ohos_fuzztest("UsbMgrSerialSetAttributeFuzzTest") { external_deps = [ "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", "hilog:libhilog", "ipc:ipc_core", ] - sources = - [ "usbmgrserialsetattribute_fuzzer/usbmgrserialsetattribute_fuzzer.cpp" ] + sources = [ "usbmgrrequestserialright_fuzzer/usbmgrrequestserialright_fuzzer.cpp" ] } -ohos_fuzztest("UsbMgrSerialGetPortListFuzzTest") { +ohos_fuzztest("UsbMgrSerialCloseFuzzTest") { module_out_path = module_output_path fuzz_config_file = - "${usb_manager_path}/test/fuzztest/usbmgrserialgetportlist_fuzzer" + "${usb_manager_path}/test/fuzztest/usbmgrserialclose_fuzzer" configs = [ ":module_private_config" ] @@ -1254,19 +1257,19 @@ ohos_fuzztest("UsbMgrSerialGetPortListFuzzTest") { external_deps = [ "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", "hilog:libhilog", "ipc:ipc_core", ] - sources = - [ "usbmgrserialgetportlist_fuzzer/usbmgrserialgetportlist_fuzzer.cpp" ] + sources = [ "usbmgrserialclose_fuzzer/usbmgrserialclose_fuzzer.cpp" ] } -ohos_fuzztest("UsbMgrSerialWriteFuzzTest") { +ohos_fuzztest("UsbMgrSerialGetAttributeFuzzTest") { module_out_path = module_output_path fuzz_config_file = - "${usb_manager_path}/test/fuzztest/usbmgrserialwrite_fuzzer" + "${usb_manager_path}/test/fuzztest/usbmgrserialgetattribute_fuzzer" configs = [ ":module_private_config" ] @@ -1277,17 +1280,19 @@ ohos_fuzztest("UsbMgrSerialWriteFuzzTest") { external_deps = [ "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", "hilog:libhilog", "ipc:ipc_core", ] - sources = [ "usbmgrserialwrite_fuzzer/usbmgrserialwrite_fuzzer.cpp" ] + sources = [ "usbmgrserialgetattribute_fuzzer/usbmgrserialgetattribute_fuzzer.cpp" ] } -ohos_fuzztest("UsbMgrSerialReadFuzzTest") { +ohos_fuzztest("UsbMgrSerialGetPortListFuzzTest") { module_out_path = module_output_path - fuzz_config_file = "${usb_manager_path}/test/fuzztest/usbmgrserialread_fuzzer" + fuzz_config_file = + "${usb_manager_path}/test/fuzztest/usbmgrserialgetportlist_fuzzer" configs = [ ":module_private_config" ] @@ -1298,18 +1303,19 @@ ohos_fuzztest("UsbMgrSerialReadFuzzTest") { external_deps = [ "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", "hilog:libhilog", "ipc:ipc_core", ] - sources = [ "usbmgrserialread_fuzzer/usbmgrserialread_fuzzer.cpp" ] + sources = [ "usbmgrserialgetportlist_fuzzer/usbmgrserialgetportlist_fuzzer.cpp" ] } -ohos_fuzztest("UsbMgrRequestSerialRightFuzzTest") { +ohos_fuzztest("UsbMgrSerialOpenFuzzTest") { module_out_path = module_output_path fuzz_config_file = - "${usb_manager_path}/test/fuzztest/usbmgrrequestserialright_fuzzer" + "${usb_manager_path}/test/fuzztest/usbmgrserialopen_fuzzer" configs = [ ":module_private_config" ] @@ -1320,19 +1326,19 @@ ohos_fuzztest("UsbMgrRequestSerialRightFuzzTest") { external_deps = [ "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", "hilog:libhilog", "ipc:ipc_core", ] - sources = - [ "usbmgrrequestserialright_fuzzer/usbmgrrequestserialright_fuzzer.cpp" ] + sources = [ "usbmgrserialopen_fuzzer/usbmgrserialopen_fuzzer.cpp" ] } -ohos_fuzztest("UsbMgrCancelSerialRightFuzzTest") { +ohos_fuzztest("UsbMgrSerialReadFuzzTest") { module_out_path = module_output_path fuzz_config_file = - "${usb_manager_path}/test/fuzztest/usbmgrcancelserialright_fuzzer" + "${usb_manager_path}/test/fuzztest/usbmgrserialread_fuzzer" configs = [ ":module_private_config" ] @@ -1343,19 +1349,19 @@ ohos_fuzztest("UsbMgrCancelSerialRightFuzzTest") { external_deps = [ "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", "hilog:libhilog", "ipc:ipc_core", ] - sources = - [ "usbmgrcancelserialright_fuzzer/usbmgrcancelserialright_fuzzer.cpp" ] + sources = [ "usbmgrserialread_fuzzer/usbmgrserialread_fuzzer.cpp" ] } -ohos_fuzztest("UsbMgrHasSerialRightFuzzTest") { +ohos_fuzztest("UsbMgrSerialSetAttributeFuzzTest") { module_out_path = module_output_path fuzz_config_file = - "${usb_manager_path}/test/fuzztest/usbmgrhasserialright_fuzzer" + "${usb_manager_path}/test/fuzztest/usbmgrserialsetattribute_fuzzer" configs = [ ":module_private_config" ] @@ -1366,11 +1372,35 @@ ohos_fuzztest("UsbMgrHasSerialRightFuzzTest") { external_deps = [ "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", "hilog:libhilog", "ipc:ipc_core", ] - sources = [ "usbmgrhasserialright_fuzzer/usbmgrhasserialright_fuzzer.cpp" ] + sources = [ "usbmgrserialsetattribute_fuzzer/usbmgrserialsetattribute_fuzzer.cpp" ] +} + +ohos_fuzztest("UsbMgrSerialWriteFuzzTest") { + module_out_path = module_output_path + + fuzz_config_file = + "${usb_manager_path}/test/fuzztest/usbmgrserialwrite_fuzzer" + + configs = [ ":module_private_config" ] + + deps = [ + "${usb_manager_path}/interfaces/innerkits:usbsrv_client", + "${usb_manager_path}/services:usbservice", + ] + + external_deps = [ + "c_utils:utils", + "drivers_interface_usb:libusb_proxy_1.0", + "hilog:libhilog", + "ipc:ipc_core", + ] + + sources = [ "usbmgrserialwrite_fuzzer/usbmgrserialwrite_fuzzer.cpp" ] } group("fuzztest") { @@ -1378,6 +1408,7 @@ group("fuzztest") { deps = [] if (usb_manager_feature_host) { deps += [ + ":UsbMgrAddSerialRightFuzzTest", ":UsbMgrAttachKernelDriverFuzzTest", ":UsbMgrBulkCancelFuzzTest", ":UsbMgrBulkReadFuzzTest", diff --git a/test/fuzztest/usbmgraddserialright_fuzzer/usbmgraddserialright_fuzzer.cpp b/test/fuzztest/usbmgraddserialright_fuzzer/usbmgraddserialright_fuzzer.cpp index d44c4f005eb982a4b75e9b7a4cc9edf18c40aeb3..457edfc2374912d36b91dc5a712f485413f59fe5 100644 --- a/test/fuzztest/usbmgraddserialright_fuzzer/usbmgraddserialright_fuzzer.cpp +++ b/test/fuzztest/usbmgraddserialright_fuzzer/usbmgraddserialright_fuzzer.cpp @@ -23,7 +23,7 @@ namespace USB { bool UsbMgrAddSerialRightFuzzTest(const uint8_t* data, size_t size) { auto &usbSrvClient = UsbSrvClient::GetInstance(); - if (data == nullptr || size < sizeof(int32_t) + sizeof(uint32_t)) { + if (data == nullptr || size < sizeof(uint32_t) + sizeof(int32_t)) { return false; } int32_t ret = usbSrvClient.AddSerialRight(*reinterpret_cast(data), diff --git a/test/fuzztest/usbmgrcancelserialright_fuzzer/usbmgrcancelserialright_fuzzer.cpp b/test/fuzztest/usbmgrcancelserialright_fuzzer/usbmgrcancelserialright_fuzzer.cpp index 45a7925311e89f5a213e6693d3399533e2640eb0..cceb26f7079c4d4678fb10b047af38b07765be64 100644 --- a/test/fuzztest/usbmgrcancelserialright_fuzzer/usbmgrcancelserialright_fuzzer.cpp +++ b/test/fuzztest/usbmgrcancelserialright_fuzzer/usbmgrcancelserialright_fuzzer.cpp @@ -16,34 +16,30 @@ #include "usbmgrcancelserialright_fuzzer.h" #include "usb_srv_client.h" -#include "v1_0/serial_types.h" +#include "usb_errors.h" -namespace { -constexpr int32_t OK = 0; -} -using OHOS::USB::UsbSrvClient; namespace OHOS { -namespace SERIAL { -bool UsbMgrCancelSerialRightFuzzTest(const uint8_t* data, size_t size) -{ - if (data == nullptr || size < sizeof(int32_t)) { - return false; +namespace USB { + bool UsbMgrCancelSerialRightFuzzTest(const uint8_t* data, size_t size) + { + auto &usbSrvClient = UsbSrvClient::GetInstance(); + if (data == nullptr || size < sizeof(int32_t)) { + return false; + } + int32_t ret = usbSrvClient.CancelSerialRight(*reinterpret_cast(data)); + if (ret == UEC_OK) { + return false; + } + return true; } - auto &usbSrvClient = UsbSrvClient::GetInstance(); - const int32_t portId = *reinterpret_cast(data); - if (usbSrvClient.CancelSerialRight(portId) != OK) { - return false; - } - return true; } -} // SERIAL -} // OHOS +} /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ - OHOS::SERIAL::UsbMgrCancelSerialRightFuzzTest(data, size); + OHOS::USB::UsbMgrCancelSerialRightFuzzTest(data, size); return 0; } diff --git a/test/fuzztest/usbmgrcontroltransfer_fuzzer/usbmgrcontroltransfer_fuzzer.cpp b/test/fuzztest/usbmgrcontroltransfer_fuzzer/usbmgrcontroltransfer_fuzzer.cpp index 199255c794041f79139423b1e385cc6a4d47f0e0..6722efbe523ca362d85efc0c5fc3e63f5ca28dcd 100644 --- a/test/fuzztest/usbmgrcontroltransfer_fuzzer/usbmgrcontroltransfer_fuzzer.cpp +++ b/test/fuzztest/usbmgrcontroltransfer_fuzzer/usbmgrcontroltransfer_fuzzer.cpp @@ -19,6 +19,7 @@ #include "usb_errors.h" using namespace OHOS::HDI::Usb::V1_0; +using namespace OHOS::HDI::Usb::V1_2; namespace OHOS { const uint32_t OFFSET = 4; constexpr size_t THRESHOLD = 10; diff --git a/test/fuzztest/usbmgrex_fuzzer/usbmgrex_fuzzer.cpp b/test/fuzztest/usbmgrex_fuzzer/usbmgrex_fuzzer.cpp index 3683ffa2418e8c9c83f72e641b8584cca6cedcd1..37c95dc4b010ef984ce469d3d7771ddf834e0eca 100644 --- a/test/fuzztest/usbmgrex_fuzzer/usbmgrex_fuzzer.cpp +++ b/test/fuzztest/usbmgrex_fuzzer/usbmgrex_fuzzer.cpp @@ -93,7 +93,7 @@ enum class UsbInterfaceCode { }; const std::u16string USB_INTERFACE_TOKEN = u"ohos.usb.IUsbServer"; static uint32_t g_usbInterfaceCode = 0; -static constexpr uint32_t USB_INTERFACE_CODE_COUNT = 64; +static constexpr uint32_t USB_INTERFACE_CODE_COUNT = 64; // UsbInterfaceCode Count - 1 void SetTestCaseNative(TokenInfoParams *infoInstance) { diff --git a/test/fuzztest/usbmgrhasserialright_fuzzer/usbmgrhasserialright_fuzzer.cpp b/test/fuzztest/usbmgrhasserialright_fuzzer/usbmgrhasserialright_fuzzer.cpp index 7e34741e00878f7f8db08f03164bf215a7a6ab57..e317c770de5003da5d36d28c7e3c264359ca3bea 100644 --- a/test/fuzztest/usbmgrhasserialright_fuzzer/usbmgrhasserialright_fuzzer.cpp +++ b/test/fuzztest/usbmgrhasserialright_fuzzer/usbmgrhasserialright_fuzzer.cpp @@ -16,35 +16,33 @@ #include "usbmgrhasserialright_fuzzer.h" #include "usb_srv_client.h" -#include "v1_0/serial_types.h" +#include "usb_errors.h" -namespace { -constexpr int32_t OK = 0; -} -using OHOS::USB::UsbSrvClient; namespace OHOS { -namespace SERIAL { -bool UsbMgrHasSerialRightFuzzTest(const uint8_t* data, size_t size) -{ - if (data == nullptr || size < sizeof(int32_t)) { - return false; - } - auto &usbSrvClient = UsbSrvClient::GetInstance(); - const int32_t portId = *reinterpret_cast(data); - bool hasRight = false; - if (!usbSrvClient.HasSerialRight(portId, hasRight) || !hasRight) { - return false; +const uint32_t OFFSET = 4; +namespace USB { + bool UsbMgrHasSerialRightFuzzTest(const uint8_t* data, size_t size) + { + auto &usbSrvClient = UsbSrvClient::GetInstance(); + if (data == nullptr || size < sizeof(int32_t) + sizeof(bool)) { + return false; + } + int32_t ret = usbSrvClient.HasSerialRight(*reinterpret_cast(data), + reinterpret_cast(std::move(data + OFFSET))); + if (ret == UEC_OK) { + return false; + } + + return true; } - return true; } -} // SERIAL -} // OHOS +} /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ - OHOS::SERIAL::UsbMgrHasSerialRightFuzzTest(data, size); + OHOS::USB::UsbMgrHasSerialRightFuzzTest(data, size); return 0; } diff --git a/test/fuzztest/usbmgrrequestserialright_fuzzer/usbmgrrequestserialright_fuzzer.cpp b/test/fuzztest/usbmgrrequestserialright_fuzzer/usbmgrrequestserialright_fuzzer.cpp index 298865a451f4f1b76d31b45dc1d23bf4b55567fc..b0970ba74b55bd743b2757170692ca975ddf085d 100644 --- a/test/fuzztest/usbmgrrequestserialright_fuzzer/usbmgrrequestserialright_fuzzer.cpp +++ b/test/fuzztest/usbmgrrequestserialright_fuzzer/usbmgrrequestserialright_fuzzer.cpp @@ -16,34 +16,33 @@ #include "usbmgrrequestserialright_fuzzer.h" #include "usb_srv_client.h" +#include "usb_errors.h" -namespace { -constexpr int32_t OK = 0; -} -using OHOS::USB::UsbSrvClient; namespace OHOS { -namespace SERIAL { -bool UsbMgrRequestSerialRightFuzzTest(const uint8_t* data, size_t size) -{ - if (data == nullptr || size < sizeof(int32_t)) { - return false; - } - auto &usbSrvClient = UsbSrvClient::GetInstance(); - bool hasRight = false; - const int32_t portId = *reinterpret_cast(data); - if (usbSrvClient.RequestSerialRight(portId, hasRight) != OK || !hasRight) { - return false; +const uint32_t OFFSET = 4; +namespace USB { + bool UsbMgrSerialWriteFuzzTest(const uint8_t* data, size_t size) + { + auto &usbSrvClient = UsbSrvClient::GetInstance(); + if (data == nullptr || size < sizeof(int32_t) + bool) { + return false; + } + int32_t ret = usbSrvClient.RequestSerialRight(*reinterpret_cast(data), + reinterpret_cast(std::move(data + OFFSET))); + if (ret == UEC_OK) { + return false; + } + + return true; } - return true; } -} // SERIAL -} // OHOS +} /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ - OHOS::SERIAL::UsbMgrRequestSerialRightFuzzTest(data, size); + OHOS::USB::UsbMgrRequestSerialRightFuzzTest(data, size); return 0; } diff --git a/test/fuzztest/usbmgrserial_fuzzer/corpus/init b/test/fuzztest/usbmgrserial_fuzzer/corpus/init new file mode 100644 index 0000000000000000000000000000000000000000..65af8ee8d11bf23407ea34d4de49f7cbb6a2b791 --- /dev/null +++ b/test/fuzztest/usbmgrserial_fuzzer/corpus/init @@ -0,0 +1,14 @@ +# Copyright (c) 2025 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +FUZZ \ No newline at end of file diff --git a/test/fuzztest/usbmgrserial_fuzzer/project.xml b/test/fuzztest/usbmgrserial_fuzzer/project.xml new file mode 100644 index 0000000000000000000000000000000000000000..2eb360c27f1b159e1b043e38846f10fcf37fa37c --- /dev/null +++ b/test/fuzztest/usbmgrserial_fuzzer/project.xml @@ -0,0 +1,25 @@ + + + + + + 1000 + + 120 + + 2048 + + diff --git a/test/fuzztest/usbmgrserial_fuzzer/usbmgrserial_fuzzer.cpp b/test/fuzztest/usbmgrserial_fuzzer/usbmgrserial_fuzzer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b14e068892e2493dc5db5b734c177ab1188b8082 --- /dev/null +++ b/test/fuzztest/usbmgrserial_fuzzer/usbmgrserial_fuzzer.cpp @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "usbmgrserial_fuzzer.h" +#include +#include +#include "usb_service.h" + +using namespace OHOS::HDI::Usb::V1_0; +using namespace OHOS::USB; + +namespace OHOS { +constexpr size_t THRESHOLD = 10; +constexpr int32_t OFFSET = 4; +enum class UsbInterfaceCode { + USB_FUN_HAS_RIGHT = 0, + USB_FUN_REQUEST_RIGHT, + USB_FUN_REMOVE_RIGHT, + USB_FUN_OPEN_DEVICE, + USB_FUN_RESET_DEVICE, + USB_FUN_GET_DEVICE, + USB_FUN_GET_DEVICES, + USB_FUN_GET_CURRENT_FUNCTIONS, + USB_FUN_SET_CURRENT_FUNCTIONS, + USB_FUN_USB_FUNCTIONS_FROM_STRING, + USB_FUN_USB_FUNCTIONS_TO_STRING, + USB_FUN_CLAIM_INTERFACE, + USB_FUN_RELEASE_INTERFACE, + USB_FUN_BULK_TRANSFER_READ, + USB_FUN_BULK_TRANSFER_WRITE, + USB_FUN_CONTROL_TRANSFER, + USB_FUN_USB_CONTROL_TRANSFER, + USB_FUN_SET_ACTIVE_CONFIG, + USB_FUN_GET_ACTIVE_CONFIG, + USB_FUN_SET_INTERFACE, + USB_FUN_GET_PORTS, + USB_FUN_GET_SUPPORTED_MODES, + USB_FUN_SET_PORT_ROLE, + USB_FUN_REQUEST_QUEUE, + USB_FUN_REQUEST_WAIT, + USB_FUN_REQUEST_CANCEL, + USB_FUN_GET_DESCRIPTOR, + USB_FUN_GET_FILEDESCRIPTOR, + USB_FUN_CLOSE_DEVICE, + USB_FUN_SUBMIT_TRANSFER, + USB_FUN_CANCEL_TRANSFER, + USB_FUN_BULK_AYSNC_READ, + USB_FUN_BULK_AYSNC_WRITE, + USB_FUN_BULK_AYSNC_CANCEL, + USB_FUN_REG_BULK_CALLBACK, + USB_FUN_UNREG_BULK_CALLBACK, + USB_FUN_ADD_RIGHT, + USB_FUN_DISABLE_GLOBAL_INTERFACE, + USB_FUN_DISABLE_DEVICE, + USB_FUN_DISABLE_INTERFACE_TYPE, + USB_FUN_CLEAR_HALT, + USB_FUN_GET_DEVICE_SPEED, + USB_FUN_GET_DRIVER_ACTIVE_STATUS, + USB_FUN_ADD_ACCESS_RIGHT, + USB_FUN_BULK_TRANSFER_READ_WITH_LENGTH, + USB_FUN_ATTACH_KERNEL_DRIVER, + USB_FUN_DETACH_KERNEL_DRIVER, + USB_FUN_GET_ACCESSORY_LIST, + USB_FUN_OPEN_ACCESSORY, + USB_FUN_CLOSE_ACCESSORY, + USB_FUN_HAS_ACCESSORY_RIGHT, + USB_FUN_REQUEST_ACCESSORY_RIGHT, + USB_FUN_REMOVE_ACCESSORY_RIGHT, + USB_FUN_ADD_ACCESSORY_RIGHT, + USB_FUN_SERIAL_OPEN, + USB_FUN_SERIAL_CLOSE, + USB_FUN_SERIAL_READ, + USB_FUN_SERIAL_WRITE, + USB_FUN_SERIAL_GET_ATTRIBUTE, + USB_FUN_SERIAL_SET_ATTRIBUTE, + USB_FUN_SERIAL_GET_PORTLIST, + USB_FUN_HAS_SERIAL_RIGHT, + USB_FUN_ADD_SERIAL_RIGHT, + USB_FUN_CANCEL_SERIAL_RIGHT, + USB_FUN_REQUEST_SERIAL_RIGHT +}; +const std::u16string USB_INTERFACE_TOKEN = u"ohos.usb.IUsbServer"; +static uint32_t g_usbInterfaceCode = 0; +static constexpr uint32_t USB_INTERFACE_CODE_COUNT = 64; // UsbInterfaceCode Count - 1 + +void SetTestCaseNative(TokenInfoParams *infoInstance) +{ + uint64_t tokenId = GetAccessTokenId(infoInstance); + int ret = SetSelfTokenID(tokenId); + if (ret == 0) { + USB_HILOGI(MODULE_USB_SERVICE, "SetSelfTokenID success %{public}d", __LINE__); + } else { + USB_HILOGE(MODULE_USB_SERVICE, "SetSelfTokenID fail %{public}d", ret); + } + ret = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo(); + if (ret == 0) { + USB_HILOGI(MODULE_USB_SERVICE, "ReloadNativeTokenInfo success %{public}d", __LINE__); + } else { + USB_HILOGE(MODULE_USB_SERVICE, "ReloadNativeTokenInfo fail %{public}d", ret); + } +} + +bool DoSomethingInterestingWithMyAPI(const uint8_t *rawData, size_t size) +{ + auto &usbSrvClient = UsbSrvClient::GetInstance(); + if (rawData == nullptr || size < OFFSET) { + return false; + } + if (g_usbInterfaceCode > USB_INTERFACE_CODE_COUNT) { + return true; + } + g_usbInterfaceCode += 1; + rawData = rawData + OFFSET; + size = size - OFFSET; + + MessageParcel data; + data.WriteInterfaceToken(USB_INTERFACE_TOKEN); + data.WriteBuffer(rawData, size); + data.RewindRead(0); + MessageParcel reply; + MessageOption option; + for (; g_usbInterfaceCode < USB_INTERFACE_CODE_COUNT; g_usbInterfaceCode++) { + DelayedSpSingleton::GetInstance()->OnRemoteRequest(g_usbInterfaceCode, data, reply, option); + } + + return true; +} +} // OHOS + +/* Fuzzer entry point */ +extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) +{ + /* Run your code on data */ + OHOS::USB::UsbMgrSerialCloseFuzzTest(data, size); + return 0; +} + diff --git a/test/fuzztest/usbmgrserial_fuzzer/usbmgrserial_fuzzer.h b/test/fuzztest/usbmgrserial_fuzzer/usbmgrserial_fuzzer.h new file mode 100644 index 0000000000000000000000000000000000000000..e6a87292533b5df6b1bf36ecd607211ec5975c23 --- /dev/null +++ b/test/fuzztest/usbmgrserial_fuzzer/usbmgrserial_fuzzer.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef USBMGRSERIAL_FUZZER_H +#define USBMGRSERIAL_FUZZER_H +#include "accesstoken_kit.h" +#include "hdf_log.h" +#include "nativetoken_kit.h" +#include "token_setproc.h" +#include "usb_common_test.h" +#include "usb_errors.h" +#include "hilog_wrapper.h" + +#define FUZZ_PROJECT_NAME "usbmgrserial_fuzzer" + +#endif // USBMGRSERIAL_FUZZER_H diff --git a/test/fuzztest/usbmgrserialclose_fuzzer/project.xml b/test/fuzztest/usbmgrserialclose_fuzzer/project.xml index ab180580690ef90070fd12d7c4534de48179f1f2..2eb360c27f1b159e1b043e38846f10fcf37fa37c 100644 --- a/test/fuzztest/usbmgrserialclose_fuzzer/project.xml +++ b/test/fuzztest/usbmgrserialclose_fuzzer/project.xml @@ -18,7 +18,7 @@ 1000 - 20 + 120 2048 diff --git a/test/fuzztest/usbmgrserialclose_fuzzer/usbmgrserialclose_fuzzer.cpp b/test/fuzztest/usbmgrserialclose_fuzzer/usbmgrserialclose_fuzzer.cpp index 89d6b895eebaf66115c593c4e8b32721dae4f48d..cbbfb37dda3cd9243bb431907331f34775bae973 100644 --- a/test/fuzztest/usbmgrserialclose_fuzzer/usbmgrserialclose_fuzzer.cpp +++ b/test/fuzztest/usbmgrserialclose_fuzzer/usbmgrserialclose_fuzzer.cpp @@ -16,35 +16,30 @@ #include "usbmgrserialclose_fuzzer.h" #include "usb_srv_client.h" +#include "usb_errors.h" -namespace { -constexpr int32_t OK = 0; -} -using OHOS::USB::UsbSrvClient; namespace OHOS { -namespace SERIAL { -bool UsbMgrSerialCloseFuzzTest(const uint8_t* data, size_t size) -{ - if (data == nullptr || size < sizeof(int32_t)) { - return false; - } - auto &usbSrvClient = UsbSrvClient::GetInstance(); - const int32_t portId = *reinterpret_cast(data); - - if (usbSrvClient.SerialClose(portId) != OK) { - return false; +namespace USB { + bool UsbMgrSerialCloseFuzzTest(const uint8_t* data, size_t size) + { + auto &usbSrvClient = UsbSrvClient::GetInstance(); + if (data == nullptr || size < sizeof(int32_t)) { + return false; + } + int32_t ret = usbSrvClient.SerialClose(*reinterpret_cast(data)); + if (ret == UEC_OK) { + return false; + } + return true; } - - return true; } -} // SERIAL -} // OHOS +} /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ - OHOS::SERIAL::UsbMgrSerialCloseFuzzTest(data, size); + OHOS::USB::UsbMgrSerialCloseFuzzTest(data, size); return 0; } diff --git a/test/fuzztest/usbmgrserialclose_fuzzer/usbmgrserialclose_fuzzer.h b/test/fuzztest/usbmgrserialclose_fuzzer/usbmgrserialclose_fuzzer.h index 89909af8de8d455cf06565349332f1bf79a8a266..fd6cd2cdc43242693b82b7ed703d6ad1f155acc5 100644 --- a/test/fuzztest/usbmgrserialclose_fuzzer/usbmgrserialclose_fuzzer.h +++ b/test/fuzztest/usbmgrserialclose_fuzzer/usbmgrserialclose_fuzzer.h @@ -13,9 +13,9 @@ * limitations under the License. */ -#ifndef USBMGRUSBSERIALCLOSE_FUZZER_H -#define USBMGRUSBSERIALCLOSE_FUZZER_H +#ifndef USBMGRSERIALCLOSE_FUZZER_H +#define USBMGRSERIALCLOSE_FUZZER_H #define FUZZ_PROJECT_NAME "usbmgrserialclose_fuzzer" -#endif // USBMGRUSBSERIALCLOSE_FUZZER_H +#endif // USBMGRSERIALCLOSE_FUZZER_H diff --git a/test/fuzztest/usbmgrserialgetattribute_fuzzer/project.xml b/test/fuzztest/usbmgrserialgetattribute_fuzzer/project.xml index ab180580690ef90070fd12d7c4534de48179f1f2..2eb360c27f1b159e1b043e38846f10fcf37fa37c 100644 --- a/test/fuzztest/usbmgrserialgetattribute_fuzzer/project.xml +++ b/test/fuzztest/usbmgrserialgetattribute_fuzzer/project.xml @@ -18,7 +18,7 @@ 1000 - 20 + 120 2048 diff --git a/test/fuzztest/usbmgrserialgetattribute_fuzzer/usbmgrserialgetattribute_fuzzer.cpp b/test/fuzztest/usbmgrserialgetattribute_fuzzer/usbmgrserialgetattribute_fuzzer.cpp index dc0fb1f0403d6dc1f79db1e4c8c5f0aac371b2b5..e0d8f08613a653dad33f4236cfeb008b3a8eaeb9 100644 --- a/test/fuzztest/usbmgrserialgetattribute_fuzzer/usbmgrserialgetattribute_fuzzer.cpp +++ b/test/fuzztest/usbmgrserialgetattribute_fuzzer/usbmgrserialgetattribute_fuzzer.cpp @@ -16,37 +16,32 @@ #include "usbmgrserialgetattribute_fuzzer.h" #include "usb_srv_client.h" -#include "v1_0/serial_types.h" -#include "usb_serial_type.h" -namespace { -constexpr int32_t OK = 0; -} -using OHOS::USB::UsbSrvClient; -namespace OHOS { -namespace SERIAL { -bool UsbMgrSerialGetAttributeFuzzTest(const uint8_t* data, size_t size) -{ - if (data == nullptr || size < sizeof(int32_t)) { - return false; - } - auto &usbSrvClient = UsbSrvClient::GetInstance(); - struct UsbSerialAttr info; - int32_t portId = *reinterpret_cast(data); +#include "usb_errors.h" - if (usbSrvClient.SerialGetAttribute(portId, info) != OK) { - return false; +namespace OHOS { +const uint32_t OFFSET = 4; +namespace USB { + bool UsbMgrSerialGetAttributeFuzzTest(const uint8_t* data, size_t size) + { + auto &usbSrvClient = UsbSrvClient::GetInstance(); + if (data == nullptr || size < OFFSET + sizeof(UsbSerialAttr)) { + return false; + } + int32_t ret = usbSrvClient.SerialSetAttribute(*reinterpret_cast(data), + reinterpret_cast(std::move(data + OFFSET))); + if (ret == UEC_OK) { + return false; + } + return true; } - - return true; } -} // SERIAL -} // OHOS +} /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ - OHOS::SERIAL::UsbMgrSerialGetAttributeFuzzTest(data, size); + OHOS::USB::UsbMgrSerialGetAttributeFuzzTest(data, size); return 0; } diff --git a/test/fuzztest/usbmgrserialgetportlist_fuzzer/project.xml b/test/fuzztest/usbmgrserialgetportlist_fuzzer/project.xml index ab180580690ef90070fd12d7c4534de48179f1f2..2eb360c27f1b159e1b043e38846f10fcf37fa37c 100644 --- a/test/fuzztest/usbmgrserialgetportlist_fuzzer/project.xml +++ b/test/fuzztest/usbmgrserialgetportlist_fuzzer/project.xml @@ -18,7 +18,7 @@ 1000 - 20 + 120 2048 diff --git a/test/fuzztest/usbmgrserialgetportlist_fuzzer/usbmgrserialgetportlist_fuzzer.cpp b/test/fuzztest/usbmgrserialgetportlist_fuzzer/usbmgrserialgetportlist_fuzzer.cpp index 6fd1d48f1ad9d63e81b4246753ef9e6170d218d2..f968d57291da5bd4f2ddfb3b753c5e00019c2908 100644 --- a/test/fuzztest/usbmgrserialgetportlist_fuzzer/usbmgrserialgetportlist_fuzzer.cpp +++ b/test/fuzztest/usbmgrserialgetportlist_fuzzer/usbmgrserialgetportlist_fuzzer.cpp @@ -15,40 +15,42 @@ #include "usbmgrserialgetportlist_fuzzer.h" -#include #include "usb_srv_client.h" #include "usb_errors.h" -#include "usb_serial_type.h" -using OHOS::USB::UsbSrvClient; + namespace OHOS { -namespace SERIAL { -bool UsbMgrSerialGetPortListFuzzTest(const uint8_t* data, size_t size) -{ - unsigned seed = 0; - if (size >= sizeof(unsigned)) { - errno_t ret = memcpy_s(&seed, sizeof(unsigned), data, sizeof(unsigned)); - if (ret != USB::UEC_OK) { +const uint32_t OFFSET = 4; +namespace USB { + bool UsbMgrSerialGetPortListFuzzTest(const uint8_t* data, size_t size) + { + unsigned seed = 0; + if (size < sizeof(unsigned)) { + errno_t ret = mencpy_s(&seed, sizeof(unsigned), data, sizeof(unsigned)) + if (ret != UEC_OK) { + return false; + } + srand(seed); + } + auto &usbSrvClient = UsbSrvClient::GetInstance(); + std::vector devList; + devList.clear; + if (data == nullptr || size < sizeof(UsbSerialPort)) { return false; } - srand(seed); - } - auto &usbSrvClient = UsbSrvClient::GetInstance(); - std::vector devList; - devList.clear(); - int32_t ret = usbSrvClient.SerialGetPortList(devList); - if (ret == USB::UEC_OK) { - return false; + int32_t ret = usbSrvClient.SerialGetPortList(devList); + if (ret == UEC_OK) { + return false; + } + return true; } - return true; } -} // SERIAL -} // OHOS +} /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ - OHOS::SERIAL::UsbMgrSerialGetPortListFuzzTest(data, size); + OHOS::USB::UsbMgrSerialGetPortListFuzzTest(data, size); return 0; } diff --git a/test/fuzztest/usbmgrserialopen_fuzzer/project.xml b/test/fuzztest/usbmgrserialopen_fuzzer/project.xml index ab180580690ef90070fd12d7c4534de48179f1f2..2eb360c27f1b159e1b043e38846f10fcf37fa37c 100644 --- a/test/fuzztest/usbmgrserialopen_fuzzer/project.xml +++ b/test/fuzztest/usbmgrserialopen_fuzzer/project.xml @@ -18,7 +18,7 @@ 1000 - 20 + 120 2048 diff --git a/test/fuzztest/usbmgrserialopen_fuzzer/usbmgrserialopen_fuzzer.cpp b/test/fuzztest/usbmgrserialopen_fuzzer/usbmgrserialopen_fuzzer.cpp index 6169299614bd9e026a279a8cc0d3aa18479cf375..097a258c9fee815eabd168cd9a485d816ab54634 100644 --- a/test/fuzztest/usbmgrserialopen_fuzzer/usbmgrserialopen_fuzzer.cpp +++ b/test/fuzztest/usbmgrserialopen_fuzzer/usbmgrserialopen_fuzzer.cpp @@ -16,35 +16,30 @@ #include "usbmgrserialopen_fuzzer.h" #include "usb_srv_client.h" +#include "usb_errors.h" -namespace { -constexpr int32_t OK = 0; -} -using OHOS::USB::UsbSrvClient; namespace OHOS { -namespace SERIAL { -bool UsbMgrSerialOpenFuzzTest(const uint8_t* data, size_t size) -{ - if (data == nullptr || size < sizeof(int32_t)) { - return false; - } - auto &usbSrvClient = UsbSrvClient::GetInstance(); - int32_t portId = *reinterpret_cast(data); - - if (usbSrvClient.SerialOpen(portId) != OK) { - return false; +namespace USB { + bool UsbMgrSerialOpenFuzzTest(const uint8_t* data, size_t size) + { + auto &usbSrvClient = UsbSrvClient::GetInstance(); + if (data == nullptr || size < sizeof(int32_t)) { + return false; + } + int32_t ret = usbSrvClient.SerialOpen(*reinterpret_cast(data)); + if (ret == UEC_OK) { + return false; + } + return true; } - - return true; } -} // SERIAL -} // OHOS +} /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ - OHOS::SERIAL::UsbMgrSerialOpenFuzzTest(data, size); + OHOS::USB::UsbMgrSerialOpenFuzzTest(data, size); return 0; } diff --git a/test/fuzztest/usbmgrserialread_fuzzer/project.xml b/test/fuzztest/usbmgrserialread_fuzzer/project.xml index ab180580690ef90070fd12d7c4534de48179f1f2..2eb360c27f1b159e1b043e38846f10fcf37fa37c 100644 --- a/test/fuzztest/usbmgrserialread_fuzzer/project.xml +++ b/test/fuzztest/usbmgrserialread_fuzzer/project.xml @@ -18,7 +18,7 @@ 1000 - 20 + 120 2048 diff --git a/test/fuzztest/usbmgrserialread_fuzzer/usbmgrserialread_fuzzer.cpp b/test/fuzztest/usbmgrserialread_fuzzer/usbmgrserialread_fuzzer.cpp index 6eaac0461bf42b2855a08ba9a7fc7cdad894d948..3b7346a4e0c160b779eef2b26dc0b2d2cfe6fa92 100644 --- a/test/fuzztest/usbmgrserialread_fuzzer/usbmgrserialread_fuzzer.cpp +++ b/test/fuzztest/usbmgrserialread_fuzzer/usbmgrserialread_fuzzer.cpp @@ -15,36 +15,30 @@ #include "usbmgrserialread_fuzzer.h" -#include #include "usb_srv_client.h" -#include "v1_0/serial_types.h" +#include "usb_errors.h" -namespace { -constexpr int32_t OK = 0; -constexpr int32_t MAX_MEMORY = 8192; -} -using OHOS::USB::UsbSrvClient; namespace OHOS { -namespace SERIAL { - -bool UsbMgrSerialReadFuzzTest(const uint8_t* data, size_t size) -{ - if (data == nullptr || size < sizeof(int32_t) + sizeof(uint32_t) + sizeof(size_t)) { - return false; +namespace USB { + bool UsbMgrSerialReadFuzzTest(const uint8_t* data, size_t size) + { + auto &usbSrvClient = UsbSrvClient::GetInstance(); + if (data == nullptr || size < sizeof(int32_t)) { + return false; + } + uint32_t bufferSize = 0; + uint32_t actualSize = 0; + uint32_t timeout = 0; + std::vector = buf; + int32_t ret = usbSrvClient.SerialRead(*reinterpret_cast(data), buf, + bufferSize, actualSize, timeout); + if (ret == UEC_OK) { + return false; + } + return true; } - auto &usbSrvClient = UsbSrvClient::GetInstance(); - const int32_t portId = *reinterpret_cast(data); - const uint32_t timeout = *reinterpret_cast(data + sizeof(int32_t)); - const uint32_t readSize = *reinterpret_cast(data + sizeof(int32_t) + sizeof(uint32_t)); - std::vector bufferData; - uint32_t actualLen = 0; - if (usbSrvClient.SerialRead(portId, bufferData, readSize, actualLen, timeout) != OK) { - return false; - } - return true; } -} // SERIAL -} // OHOS +} /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) diff --git a/test/fuzztest/usbmgrserialsetattribute_fuzzer/project.xml b/test/fuzztest/usbmgrserialsetattribute_fuzzer/project.xml index ab180580690ef90070fd12d7c4534de48179f1f2..2eb360c27f1b159e1b043e38846f10fcf37fa37c 100644 --- a/test/fuzztest/usbmgrserialsetattribute_fuzzer/project.xml +++ b/test/fuzztest/usbmgrserialsetattribute_fuzzer/project.xml @@ -18,7 +18,7 @@ 1000 - 20 + 120 2048 diff --git a/test/fuzztest/usbmgrserialsetattribute_fuzzer/usbmgrserialsetattribute_fuzzer.cpp b/test/fuzztest/usbmgrserialsetattribute_fuzzer/usbmgrserialsetattribute_fuzzer.cpp index 86408c24f4f639a96b5435cba3ae77be59ca6564..62766b3360fe0b05fa8aa9263bfd0df9db1d481d 100644 --- a/test/fuzztest/usbmgrserialsetattribute_fuzzer/usbmgrserialsetattribute_fuzzer.cpp +++ b/test/fuzztest/usbmgrserialsetattribute_fuzzer/usbmgrserialsetattribute_fuzzer.cpp @@ -16,31 +16,26 @@ #include "usbmgrserialsetattribute_fuzzer.h" #include "usb_srv_client.h" -#include "v1_0/serial_types.h" -#include "usb_serial_type.h" -namespace { -constexpr int32_t OK = 0; -} -using OHOS::USB::UsbSrvClient; +#include "usb_errors.h" + namespace OHOS { const uint32_t OFFSET = 4; -namespace SERIAL { -bool UsbMgrSerialSetAttributeFuzzTest(const uint8_t* data, size_t size) -{ - if (data == nullptr || size < sizeof(UsbSerialAttr) + OFFSET) { - return false; +namespace USB { + bool UsbMgrSerialSetAttributeFuzzTest(const uint8_t* data, size_t size) + { + auto &usbSrvClient = UsbSrvClient::GetInstance(); + if (data == nullptr || size < OFFSET + sizeof(UsbSerialAttr)) { + return false; + } + int32_t ret = usbSrvClient.SerialSetAttribute(*reinterpret_cast(data), + reinterpret_cast(std::move(data + OFFSET))); + if (ret = UEC_OK) { + return false; + } + return true; } - auto &usbSrvClient = UsbSrvClient::GetInstance(); - int32_t portId = *reinterpret_cast(data); - - if (usbSrvClient.SerialSetAttribute(portId, reinterpret_cast(std::move(data + OFFSET))) != OK) { - return false; - } - - return true; } -} // SERIAL -} // OHOS +} /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) diff --git a/test/fuzztest/usbmgrserialwrite_fuzzer/usbmgrserialwrite_fuzzer.cpp b/test/fuzztest/usbmgrserialwrite_fuzzer/usbmgrserialwrite_fuzzer.cpp index a5c9298f910917fb57cc6b8497b878fa56351e98..a661e3d11709fd3bf9b0b0232c39912919781b84 100644 --- a/test/fuzztest/usbmgrserialwrite_fuzzer/usbmgrserialwrite_fuzzer.cpp +++ b/test/fuzztest/usbmgrserialwrite_fuzzer/usbmgrserialwrite_fuzzer.cpp @@ -16,38 +16,36 @@ #include "usbmgrserialwrite_fuzzer.h" #include "usb_srv_client.h" -#include "v1_0/serial_types.h" +#include "usb_errors.h" -namespace { -constexpr int32_t OK = 0; -} -using OHOS::USB::UsbSrvClient; namespace OHOS { -namespace SERIAL { -bool UsbMgrSerialWriteFuzzTest(const uint8_t* data, size_t size) -{ - if (data == nullptr || size < sizeof(int32_t) + sizeof(uint32_t)) { - return false; - } - auto &usbSrvClient = UsbSrvClient::GetInstance(); - const int32_t portId = *reinterpret_cast(data); - const uint32_t timeout = *reinterpret_cast(data + sizeof(int32_t)); - std::vector buffer(data, data + size); - uint32_t actualLen = 0; - if (usbSrvClient.SerialWrite(portId, buffer, size, actualLen, timeout) != OK) { - return false; - } +namespace USB { + bool UsbMgrSerialWriteFuzzTest(const uint8_t* data, size_t size) + { + auto &usbSrvClient = UsbSrvClient::GetInstance(); + if (data == nullptr || size < sizeof(int32_t)) { + return false; + } + uint32_t bufferSize = 0; + uint32_t actualSize = 0; + uint32_t timeout = 0; + std::vector = buf; + int32_t ret = usbSrvClient.SerialWrite(*reinterpret_cast(data), buf, + bufferSize, actualSize, timeout); + if (ret == UEC_OK) { + return false; + } - return true; + return true; + } +} } -} // SERIAL -} // OHOS /* Fuzzer entry point */ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { /* Run your code on data */ - OHOS::SERIAL::UsbMgrSerialWriteFuzzTest(data, size); + OHOS::USB::UsbMgrSerialWriteFuzzTest(data, size); return 0; } diff --git a/test/fuzztest/usbmgrsubmittransfer_fuzzer/usbmgrsubmittransfer_fuzzer.cpp b/test/fuzztest/usbmgrsubmittransfer_fuzzer/usbmgrsubmittransfer_fuzzer.cpp index 5032ceba531545cdbb7a9ad0ce4ef1a0c6a8b1d4..a2e645b7167225c838d2a42b9033a3282cf0d965 100644 --- a/test/fuzztest/usbmgrsubmittransfer_fuzzer/usbmgrsubmittransfer_fuzzer.cpp +++ b/test/fuzztest/usbmgrsubmittransfer_fuzzer/usbmgrsubmittransfer_fuzzer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at diff --git a/test/fuzztest/usbmgrsubmittransfer_fuzzer/usbmgrsubmittransfer_fuzzer.h b/test/fuzztest/usbmgrsubmittransfer_fuzzer/usbmgrsubmittransfer_fuzzer.h index b39aa9198e6f1708f6ddae4f71e64e5f1f2a1edf..15ec185ec68f4c4a993704f2c828cbfe2302513e 100644 --- a/test/fuzztest/usbmgrsubmittransfer_fuzzer/usbmgrsubmittransfer_fuzzer.h +++ b/test/fuzztest/usbmgrsubmittransfer_fuzzer/usbmgrsubmittransfer_fuzzer.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) 2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at diff --git a/test/native/js_unittest/UsbApiParamExceJsunit.test.js b/test/native/js_unittest/UsbApiParamExceJsunit.test.js deleted file mode 100644 index 3092eac3b316a25b851ec7f1c6e181d869520bca..0000000000000000000000000000000000000000 --- a/test/native/js_unittest/UsbApiParamExceJsunit.test.js +++ /dev/null @@ -1,1490 +0,0 @@ -/* - * Copyright (c) 2024 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -import usbManager from '@ohos.usbManager'; -import { UiDriver, BY } from '@ohos.UiTest'; -import CheckEmptyUtils from '../../../../../ohos_master/test/xts/acts/usb/usb_standard/entry/src/ohosTest/js/test/CheckEmptyUtils.js'; -import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium' - - -export default function UsbApiParamExceJsunitTest() { -describe('UsbApiParamExceJsunitTest', function () { - - const TAG = "[UsbApiParamExceJsunitTest]"; - const PARAM_NULL = null; - const PARAM_UNDEFINED = undefined; - const PARAM_NULLSTRING = ""; - const PARAM_NUMBEREX = 123; - let gDeviceList; - let devices; - let gPipe; - let isDeviceConnected; - let tmpPipe = { - busNum: null, - devAddress: null - }; - function deviceConnected() { - if (gDeviceList.length > 0) { - console.info(TAG, "Test USB device is connected"); - return true; - } - console.info(TAG, "Test USB device is not connected"); - return false; - } - - beforeAll(async function () { - console.log(TAG, '*************Usb Unit UsbApiParamExceJsunitTest Begin*************'); - const Version = usbManager.getVersion(); - console.info(TAG, 'usb unit begin test getversion :' + Version); - - // version > 17 host currentMode = 2 device currentMode = 1 - gDeviceList = usbManager.getDevices(); - isDeviceConnected = deviceConnected(); - if (isDeviceConnected) { - let hasRight = usbManager.hasRight(gDeviceList[0].name); - if (!hasRight) { - console.info(TAG, `beforeAll: usb requestRight start`); - await getPermission(); - CheckEmptyUtils.sleep(1000); - await driveFn(); - CheckEmptyUtils.sleep(1000); - } - - tmpPipe.busNum = gDeviceList[0].busNum; - tmpPipe.devAddress = gDeviceList[0].devAddress; - } - }) - - beforeEach(function () { - console.info(TAG, 'beforeEach: *************Usb Unit Test CaseEx*************'); - gDeviceList = usbManager.getDevices(); - if (isDeviceConnected) { - devices = gDeviceList[0]; - console.info(TAG, 'beforeEach return devices : ' + JSON.stringify(devices)); - } - }) - - afterEach(function () { - console.info(TAG, 'afterEach: *************Usb Unit Test CaseEx*************'); - devices = null; - gPipe = null; - console.info(TAG, 'afterEach return devices : ' + JSON.stringify(devices)); - }) - - afterAll(function () { - console.log(TAG, '*************Usb Unit UsbApiParamExceJsunitTest End*************'); - }) - - async function driveFn() { - console.info('**************driveFn**************'); - try { - let driver = await UiDriver.create(); - console.info(TAG, ` come in driveFn`); - console.info(TAG, `driver is ${JSON.stringify(driver)}`); - CheckEmptyUtils.sleep(1000); - let button = await driver.findComponent(BY.text('允许')); - console.info(TAG, `button is ${JSON.stringify(button)}`); - CheckEmptyUtils.sleep(1000); - await button.click(); - } catch (err) { - console.info(TAG, 'err is ' + err); - return; - } - } - - async function getPermission() { - console.info('**************getPermission**************'); - try { - usbManager.requestRight(gDeviceList[0].name).then(hasRight => { - console.info(TAG, `usb requestRight success, hasRight: ${hasRight}`); - }) - } catch (err) { - console.info(TAG, `usb getPermission to requestRight hasRight fail: `, err); - return - } - } - - function getPipe(testCaseName) { - gPipe = usbManager.connectDevice(devices); - console.info(TAG, `usb ${testCaseName} connectDevice getPipe ret: ${JSON.stringify(gPipe)}`); - expect(gPipe !== null).assertTrue(); - } - - function toReleaseInterface(testCaseName, tInterface) { - let ret = usbManager.releaseInterface(tmpPipe, tInterface); - console.info(TAG, `usb ${testCaseName} releaseInterface ret: ${ret}`); - expect(ret).assertEqual(0); - } - - function toClosePipe(testCaseName) { - let isPipClose = usbManager.closePipe(tmpPipe); - console.info(TAG, `usb ${testCaseName} closePipe ret: ${isPipClose}`); - expect(isPipClose).assertEqual(0); - } - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_0100 - * @tc.name : testHasRightParamEx001 - * @tc.desc : Negative test: Param is null string - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testHasRightParamEx001', 0, function () { - console.info(TAG, 'usb testHasRightParamEx001 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let isHasRight = usbManager.hasRight(PARAM_NULLSTRING); - console.info(TAG, 'usb case hasRight ret : ' + isHasRight); - expect(isHasRight).assertFalse(); - } catch (err) { - console.info(TAG, 'testHasRightParamEx001 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_0200 - * @tc.name : testHasRightParamEx002 - * @tc.desc : Negative test: Param add number '123' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testHasRightParamEx002', 0, function () { - console.info(TAG, 'usb testHasRightParamEx002 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - for (var i = 0; i < gDeviceList.length; i++) { - let deviceName = gDeviceList[i].name; - deviceName = deviceName + "123"; - let isHasRight = usbManager.hasRight(deviceName); - console.info(TAG, 'usb [', deviceName, '] hasRight ret : ' + isHasRight); - expect(isHasRight).assertFalse(); - } - } catch (err) { - console.info(TAG, 'testHasRightParamEx002 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_0300 - * @tc.name : testRequestRightParamEx001 - * @tc.desc : Negative test: Param is null string - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testRequestRightParamEx001', 0, async function () { - console.info(TAG, 'usb testRequestRightParamEx001 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let isHasRight = await usbManager.requestRight(PARAM_NULLSTRING); - console.info(TAG, 'usb case requestRight ret : ' + isHasRight); - expect(isHasRight).assertFalse(); - } catch (err) { - console.info(TAG, 'testRequestRightParamEx001 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_0400 - * @tc.name : testRequestRightParamEx002 - * @tc.desc : Negative test: Param add number 'abc' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testRequestRightParamEx002', 0, async function () { - console.info(TAG, 'usb testRequestRightParamEx002 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - for (var i = 0; i < gDeviceList.length; i++) { - let deviceName = gDeviceList[i].name; - deviceName = deviceName + "abc"; - let isHasRight = await usbManager.requestRight(deviceName); - console.info(TAG, 'usb [', deviceName, '] requestRight ret : ' + isHasRight); - expect(isHasRight).assertFalse(); - } - } catch (err) { - console.info(TAG, 'testRequestRightParamEx002 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_0500 - * @tc.name : testRemoveRightParamEx001 - * @tc.desc : Negative test: Param is null string - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testRemoveRightParamEx001', 0, function () { - console.info(TAG, 'usb testRemoveRightParamEx001 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let remRight = usbManager.removeRight(PARAM_NULLSTRING); - console.info(TAG, 'usb case removeRight ret : ' + remRight); - expect(remRight).assertFalse(); - } catch (err) { - console.info(TAG, 'testRemoveRightParamEx001 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_0600 - * @tc.name : testRemoveRightParamEx002 - * @tc.desc : Negative test: Param add letter 'abc' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testRemoveRightParamEx002', 0, function () { - console.info(TAG, 'usb testRemoveRightParamEx002 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - for (var i = 0; i < gDeviceList.length; i++) { - let deviceName = gDeviceList[i].name; - deviceName = deviceName + "abc"; - let remRight = usbManager.removeRight(deviceName); - console.info(TAG, 'usb [', deviceName, '] removeRight ret : ', remRight); - expect(remRight).assertFalse(); - } - } catch (err) { - console.info(TAG, 'testRemoveRightParamEx002 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_0700 - * @tc.name : testRemoveRightParamEx003 - * @tc.desc : Negative test: Param add special characters '@#' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testRemoveRightParamEx003', 0, function () { - console.info(TAG, 'usb testRemoveRightParamEx003 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - for (var i = 0; i < gDeviceList.length; i++) { - let deviceName = gDeviceList[i].name; - deviceName = deviceName + "@#"; - let remRight = usbManager.removeRight(deviceName); - console.info(TAG, 'usb [', deviceName, '] removeRight ret : ', remRight); - expect(remRight).assertFalse(); - } - } catch (err) { - console.info(TAG, 'testRemoveRightParamEx003 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_0800 - * @tc.name : testRemoveRightParamEx004 - * @tc.desc : Negative test: Param add number '123' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testRemoveRightParamEx004', 0, function () { - console.info(TAG, 'usb testRemoveRightParamEx004 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - for (var i = 0; i < gDeviceList.length; i++) { - let deviceName = gDeviceList[i].name; - deviceName = deviceName + "123"; - let remRight = usbManager.removeRight(deviceName); - console.info(TAG, 'usb [', deviceName, '] removeRight ret : ', remRight); - expect(remRight).assertFalse(); - } - } catch (err) { - console.info(TAG, 'testRemoveRightParamEx004 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_0900 - * @tc.name : testConnectDeviceParamEx001 - * @tc.desc : Negative test: Param add number '123' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx001', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx001 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let deviceName = devices.name + "123"; - devices.name = deviceName; - let gPipe = usbManager.connectDevice(devices); - - console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx001 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_1000 - * @tc.name : testConnectDeviceParamEx002 - * @tc.desc : Negative test: Param add letter 'abc' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx002', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx002 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let deviceName = devices.name + "abc"; - devices.name = deviceName; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx002 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_1100 - * @tc.name : testConnectDeviceParamEx003 - * @tc.desc : Negative test: Param add special characters '@#' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx003', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx003 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let deviceName = devices.name + "@#"; - devices.name = deviceName; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx003 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_1200 - * @tc.name : testConnectDeviceParamEx004 - * @tc.desc : Negative test: devices name is null string "" - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx004', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx004 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - devices.name = PARAM_NULLSTRING; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.name, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx004 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_1300 - * @tc.name : testConnectDeviceParamEx005 - * @tc.desc : Negative test: devices serial is null string "" - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx005', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx005 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - devices.serial = PARAM_NULLSTRING; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.serial, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx005 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_1400 - * @tc.name : testConnectDeviceParamEx006 - * @tc.desc : Negative test: devices serial add letter abc - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx006', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx006 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devSerial = devices.serial + "abc"; - devices.serial = devSerial; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.serial, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx006 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_1500 - * @tc.name : testConnectDeviceParamEx007 - * @tc.desc : Negative test: devices serial add number 123 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx007', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx007 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devSerial = devices.serial + "123"; - devices.serial = devSerial; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.serial, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx007 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_1600 - * @tc.name : testConnectDeviceParamEx008 - * @tc.desc : Negative test: devices serial add special characters '@#' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx008', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx008 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devSerial = devices.serial + "@#"; - devices.serial = devSerial; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.serial, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx008 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_1700 - * @tc.name : testConnectDeviceParamEx009 - * @tc.desc : Negative test: devices manufacturerName add special characters '@#' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx009', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx009 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devManufacturerName = devices.manufacturerName + "@#"; - devices.manufacturerName = devManufacturerName; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.manufacturerName, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx009 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_1800 - * @tc.name : testConnectDeviceParamEx010 - * @tc.desc : Negative test: devices manufacturerName add special characters 'abc' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx010', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx010 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devManufacturerName = devices.manufacturerName + "abc"; - devices.manufacturerName = devManufacturerName; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.manufacturerName, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx010 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_1900 - * @tc.name : testConnectDeviceParamEx011 - * @tc.desc : Negative test: devices manufacturerName add special characters '123' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx011', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx011 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devManufacturerName = devices.manufacturerName + "123"; - devices.manufacturerName = devManufacturerName; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.manufacturerName, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx011 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_2000 - * @tc.name : testConnectDeviceParamEx012 - * @tc.desc : Negative test: devices manufacturerName add special characters "" - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx012', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx012 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - devices.manufacturerName = PARAM_NULLSTRING; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.manufacturerName, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx012 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_2100 - * @tc.name : testConnectDeviceParamEx013 - * @tc.desc : Negative test: devices productName add special characters '@#' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx013', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx013 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devProductName = devices.productName + "@#"; - devices.productName = devProductName; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.productName, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx013 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_2200 - * @tc.name : testConnectDeviceParamEx014 - * @tc.desc : Negative test: devices productName add special characters 'abc' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx014', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx014 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devProductName = devices.productName + "abc"; - devices.productName = devProductName; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.productName, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx014 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_2300 - * @tc.name : testConnectDeviceParamEx015 - * @tc.desc : Negative test: devices productName add special characters '123' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx015', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx015 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devProductName = devices.productName + "123"; - devices.productName = devProductName; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.productName, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx015 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_2400 - * @tc.name : testConnectDeviceParamEx016 - * @tc.desc : Negative test: devices productName is null string "" - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx016', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx016 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - devices.productName = PARAM_NULLSTRING; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.productName, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx016 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_2500 - * @tc.name : testConnectDeviceParamEx017 - * @tc.desc : Negative test: devices version add special characters '@#' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx017', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx017 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devVersion = devices.version + "@#"; - devices.version = devVersion; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.version, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx017 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_2600 - * @tc.name : testConnectDeviceParamEx018 - * @tc.desc : Negative test: devices version add special characters 'abc' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx018', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx018 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devVersion = devices.version + "abc"; - devices.version = devVersion; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.version, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx018 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_2700 - * @tc.name : testConnectDeviceParamEx019 - * @tc.desc : Negative test: devices version add special characters '123' - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx019', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx019 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devVersion = devices.version + "123"; - devices.version = devVersion; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.version, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx019 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_2800 - * @tc.name : testConnectDeviceParamEx020 - * @tc.desc : Negative test: devices version is null string "" - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx020', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx020 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - devices.version = PARAM_NULLSTRING; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.version, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx020 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_2900 - * @tc.name : testConnectDeviceParamEx021 - * @tc.desc : Negative test: devices vendorId is add number 1000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx021', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx021 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devVendorId = devices.vendorId + 1000; - devices.vendorId = devVendorId; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.vendorId, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx021 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_3000 - * @tc.name : testConnectDeviceParamEx022 - * @tc.desc : Negative test: devices productId is add number 1000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx022', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx022 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devProductId = devices.productId + 1000; - devices.productId = devProductId; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.productId, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx022 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_3100 - * @tc.name : testConnectDeviceParamEx023 - * @tc.desc : Negative test: devices clazz is add number 1000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx023', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx023 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devClazz = devices.clazz + 1000; - devices.clazz = devClazz; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.clazz, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx023 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_3200 - * @tc.name : testConnectDeviceParamEx024 - * @tc.desc : Negative test: devices subClass is add number 1000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx024', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx024 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devSubClass = devices.subClass + 1000; - devices.subClass = devSubClass; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.subClass, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx024 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_3300 - * @tc.name : testConnectDeviceParamEx025 - * @tc.desc : Negative test: devices protocol is add number 1000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx025', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx025 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devProtocol = devices.protocol + 1000; - devices.protocol = devProtocol; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.protocol, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(CheckEmptyUtils.isEmpty(gPipe)).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx025 catch err code: ', err.code, ', message: ', err.message); - expect(err !== null).assertFalse(); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_3400 - * @tc.name : testConnectDeviceParamEx026 - * @tc.desc : Negative test: devices busNum is add number 1000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx026', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx026 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devBusNum = devices.busNum + 1000; - devices.busNum = devBusNum; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.busNum, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(gPipe !== null).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx026 catch err code: ', err.code, ', message: ', err.message); - expect(err.code).assertEqual(14400001); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_3500 - * @tc.name : testConnectDeviceParamEx027 - * @tc.desc : Negative test: devices devAddress is add number 10000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testConnectDeviceParamEx027', 0, function () { - console.info(TAG, 'usb testConnectDeviceParamEx027 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - try { - let devDevAddress = devices.devAddress + 1000; - devices.devAddress = devDevAddress; - let gPipe = usbManager.connectDevice(devices); - console.info(TAG, 'usb [', devices.devAddress, '] connectDevice ret : ', JSON.stringify(gPipe)); - expect(gPipe !== null).assertFalse(); - } catch (err) { - console.info(TAG, 'testConnectDeviceParamEx027 catch err code: ', err.code, ', message: ', err.message); - expect(err.code).assertEqual(14400001); - } - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_3600 - * @tc.name : testClosePipeParamEx001 - * @tc.desc : Negative test: pipe busNum add number 1000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testClosePipeParamEx001', 0, function () { - console.info(TAG, 'usb testClosePipeParamEx001 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testClosePipeParamEx001"); - try { - gPipe.busNum = gPipe.busNum + 1000; - let ret = usbManager.closePipe(gPipe); - console.info(TAG, 'usb [', gPipe.busNum, '] closePipe ret : ', ret); - expect(ret !== 0).assertTrue(); - } catch (err) { - console.info(TAG, 'testClosePipeParamEx001 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testClosePipeParamEx001"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_3700 - * @tc.name : testClosePipeParamEx002 - * @tc.desc : Negative test: pipe devAddress add number 10000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testClosePipeParamEx002', 0, function () { - console.info(TAG, 'usb testClosePipeParamEx002 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testClosePipeParamEx002"); - try { - let pipDevAdd = gPipe.devAddress + 10000; - gPipe.devAddress = pipDevAdd; - let ret = usbManager.closePipe(gPipe); - console.info(TAG, 'usb [', gPipe.devAddress, '] closePipe ret : ', ret); - expect(ret !== 0).assertTrue(); - } catch (err) { - console.info(TAG, 'testClosePipeParamEx002 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testClosePipeParamEx002"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_3800 - * @tc.name : testGetRawDescriptorParamEx001 - * @tc.desc : Negative test: pipe busNum add number 1000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testGetRawDescriptorParamEx001', 0, function () { - console.info(TAG, 'usb testGetRawDescriptorParamEx001 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testGetRawDescriptorParamEx001"); - try { - let pipBusNum = gPipe.busNum + 1000; - gPipe.busNum = pipBusNum; - let ret = usbManager.getRawDescriptor(gPipe); - console.info(TAG, 'usb [', gPipe.busNum, '] getRawDescriptor ret : ', ret); - expect(ret).assertEqual(undefined); - } catch (err) { - console.info(TAG, 'testGetRawDescriptorParamEx001 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testGetRawDescriptorParamEx001"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_3900 - * @tc.name : testGetRawDescriptorParamEx002 - * @tc.desc : Negative test: pipe devAddress add number 10000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testGetRawDescriptorParamEx002', 0, function () { - console.info(TAG, 'usb testGetRawDescriptorParamEx002 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testGetRawDescriptorParamEx002"); - try { - let pipDevAdd = gPipe.devAddress + 10000; - gPipe.devAddress = pipDevAdd; - let ret = usbManager.getRawDescriptor(gPipe); - console.info(TAG, 'usb [', gPipe.devAddress, '] getRawDescriptor ret : ', ret); - expect(ret).assertEqual(undefined); - } catch (err) { - console.info(TAG, 'testGetRawDescriptorParamEx002 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testGetRawDescriptorParamEx002"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_4000 - * @tc.name : testGetRawDescriptorParamEx003 - * @tc.desc : Negative test: pipe busNum -23 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testGetRawDescriptorParamEx003', 0, function () { - console.info(TAG, 'usb testGetRawDescriptorParamEx003 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testGetRawDescriptorParamEx003"); - try { - gPipe.busNum = -23; - let ret = usbManager.getRawDescriptor(gPipe); - console.info(TAG, 'usb [', gPipe.busNum, '] getRawDescriptor ret : ', ret); - expect(ret).assertEqual(undefined); - } catch (err) { - console.info(TAG, 'testGetRawDescriptorParamEx003 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testGetRawDescriptorParamEx003"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_4100 - * @tc.name : testGetRawDescriptorParamEx004 - * @tc.desc : Negative test: pipe devAddress -23 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testGetRawDescriptorParamEx004', 0, function () { - console.info(TAG, 'usb testGetRawDescriptorParamEx004 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testGetRawDescriptorParamEx004"); - try { - gPipe.devAddress = -23; - let ret = usbManager.getRawDescriptor(gPipe); - console.info(TAG, 'usb [', gPipe.devAddress, '] getRawDescriptor ret : ', ret); - expect(ret).assertEqual(undefined); - } catch (err) { - console.info(TAG, 'testGetRawDescriptorParamEx004 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testGetRawDescriptorParamEx004"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_4200 - * @tc.name : testGetRawDescriptorParamEx005 - * @tc.desc : Negative test: pipe busNum -23, devAddress -23 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testGetRawDescriptorParamEx005', 0, function () { - console.info(TAG, 'usb testGetRawDescriptorParamEx005 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testGetRawDescriptorParamEx005"); - try { - gPipe.busNum = -23; - gPipe.devAddress = -23; - let ret = usbManager.getRawDescriptor(gPipe); - console.info(TAG, 'usb [', gPipe.devAddress, '] getRawDescriptor ret : ', ret); - expect(ret).assertEqual(undefined); - } catch (err) { - console.info(TAG, 'testGetRawDescriptorParamEx005 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testGetRawDescriptorParamEx005"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_4300 - * @tc.name : testGetFileDescriptorParamEx001 - * @tc.desc : Negative test: pipe busNum add number 1000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testGetFileDescriptorParamEx001', 0, function () { - console.info(TAG, 'usb testGetFileDescriptorParamEx001 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testGetFileDescriptorParamEx001"); - try { - let pipBusNum = gPipe.busNum + 1000; - gPipe.busNum = pipBusNum; - let ret = usbManager.getFileDescriptor(gPipe); - console.info(TAG, 'usb [', gPipe.busNum, '] getFileDescriptor ret : ', ret); - expect(ret).assertEqual(-1); - } catch (err) { - console.info(TAG, 'testGetFileDescriptorParamEx001 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testGetFileDescriptorParamEx001"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_4400 - * @tc.name : testGetFileDescriptorParamEx002 - * @tc.desc : Negative test: pipe devAddress add number 10000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testGetFileDescriptorParamEx002', 0, function () { - console.info(TAG, 'usb testGetFileDescriptorParamEx002 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testGetFileDescriptorParamEx002"); - try { - let pipDevAdd = gPipe.devAddress + 10000; - gPipe.devAddress = pipDevAdd; - let ret = usbManager.getFileDescriptor(gPipe); - console.info(TAG, 'usb [', gPipe.devAddress, '] getFileDescriptor ret : ', ret); - expect(ret).assertEqual(-1); - } catch (err) { - console.info(TAG, 'testGetFileDescriptorParamEx002 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testGetFileDescriptorParamEx002"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_4500 - * @tc.name : testGetFileDescriptorParamEx003 - * @tc.desc : Negative test: pipe busNum -23 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testGetFileDescriptorParamEx003', 0, function () { - console.info(TAG, 'usb testGetFileDescriptorParamEx003 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testGetFileDescriptorParamEx003"); - try { - gPipe.busNum = -23; - let ret = usbManager.getFileDescriptor(gPipe); - console.info(TAG, 'usb [', gPipe.busNum, '] getFileDescriptor ret : ', ret); - expect(ret).assertEqual(-1); - } catch (err) { - console.info(TAG, 'testGetFileDescriptorParamEx003 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testGetFileDescriptorParamEx003"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_4600 - * @tc.name : testGetFileDescriptorParamEx004 - * @tc.desc : Negative test: pipe devAddress -23 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testGetFileDescriptorParamEx004', 0, function () { - console.info(TAG, 'usb testGetFileDescriptorParamEx004 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testGetFileDescriptorParamEx004"); - try { - gPipe.devAddress = -23; - let ret = usbManager.getFileDescriptor(gPipe); - console.info(TAG, 'usb [', gPipe.devAddress, '] getFileDescriptor ret : ', ret); - expect(ret).assertEqual(-1); - } catch (err) { - console.info(TAG, 'testGetFileDescriptorParamEx004 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testGetFileDescriptorParamEx004"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_4700 - * @tc.name : testGetFileDescriptorParamEx005 - * @tc.desc : Negative test: pipe busNum -23, devAddress -23 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testGetFileDescriptorParamEx005', 0, function () { - console.info(TAG, 'usb testGetFileDescriptorParamEx005 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testGetFileDescriptorParamEx005"); - try { - gPipe.busNum = -23; - gPipe.devAddress = -23; - let ret = usbManager.getFileDescriptor(gPipe); - console.info(TAG, 'usb [', gPipe.devAddress, '] getFileDescriptor ret : ', ret); - expect(ret).assertEqual(-1); - } catch (err) { - console.info(TAG, 'testGetFileDescriptorParamEx005 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testGetFileDescriptorParamEx005"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_4800 - * @tc.name : testClaimInterfaceParamEx001 - * @tc.desc : Negative test: interfaces id add 123 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testClaimInterfaceParamEx001', 0, function () { - console.info(TAG, 'usb testClaimInterfaceParamEx001 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testClaimInterfaceParamEx001"); - try { - let tmpInterface = devices.configs[0].interfaces[0]; - tmpInterface.id = tmpInterface.id + 123; - let ret = usbManager.claimInterface(gPipe, tmpInterface); - console.info(TAG, 'usb [', tmpInterface.id, '] claimInterface ret : ', ret); - expect(ret !== 0).assertTrue(); - } catch (err) { - console.info(TAG, 'testClaimInterfaceParamEx001 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testClaimInterfaceParamEx001"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_4900 - * @tc.name : testClaimInterfaceParamEx002 - * @tc.desc : Negative test: interfaces id -1 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testClaimInterfaceParamEx002', 0, function () { - console.info(TAG, 'usb testClaimInterfaceParamEx002 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testClaimInterfaceParamEx002"); - try { - let tmpInterface = devices.configs[0].interfaces[0]; - tmpInterface.id = -1; - let ret = usbManager.claimInterface(gPipe, tmpInterface); - console.info(TAG, 'usb [', tmpInterface.id, '] claimInterface ret : ', ret); - expect(ret !== 0).assertTrue(); - } catch (err) { - console.info(TAG, 'testClaimInterfaceParamEx002 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testClaimInterfaceParamEx002"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_5000 - * @tc.name : testClaimInterfaceParamEx003 - * @tc.desc : Negative test: pipe busNum add 1000 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testClaimInterfaceParamEx003', 0, function () { - console.info(TAG, 'usb testClaimInterfaceParamEx003 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testClaimInterfaceParamEx003"); - try { - gPipe.busNum = gPipe.busNum + 1000; - let tmpInterface = devices.configs[0].interfaces[0]; - let ret = usbManager.claimInterface(gPipe, tmpInterface); - console.info(TAG, 'usb [', gPipe.busNum, '] claimInterface ret : ', ret); - expect(ret !== 0).assertTrue(); - } catch (err) { - console.info(TAG, 'testClaimInterfaceParamEx003 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testClaimInterfaceParamEx003"); - }) - - /** - * @tc.number : SUB_USB_HostManager_JS_ParamEx_5100 - * @tc.name : testClaimInterfaceParamEx004 - * @tc.desc : Negative test: pipe busNum -1 - * @tc.size : MediumTest - * @tc.type : Function - * @tc.level : Level 3 - */ - it('testClaimInterfaceParamEx004', 0, function () { - console.info(TAG, 'usb testClaimInterfaceParamEx004 begin'); - if (!isDeviceConnected) { - expect(isDeviceConnected).assertFalse(); - return - } - getPipe("testClaimInterfaceParamEx004"); - try { - gPipe.busNum = -1; - let tmpInterface = devices.configs[0].interfaces[0]; - let ret = usbManager.claimInterface(gPipe, tmpInterface); - console.info(TAG, 'usb [', gPipe.busNum, '] claimInterface ret : ', ret); - expect(ret !== 0).assertTrue(); - } catch (err) { - console.info(TAG, 'testClaimInterfaceParamEx004 catch err code: ', err); - expect(err !== null).assertFalse(); - } - toClosePipe("testClaimInterfaceParamEx004"); - }) -}) -}