/*
 * Copyright (c) 2023 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 "usb_bulkcallback_mock_test.h"

#include <iostream>
#include <sys/time.h>
#include <vector>

#include "ashmem.h"
#include "delayed_sp_singleton.h"
#include "hilog_wrapper.h"
#include "securec.h"
#include "usb_callback_test.h"
#include "usb_common_test.h"
#include "usb_device_pipe.h"
#include "usb_errors.h"
#include "usb_service.h"
#include "usb_srv_client.h"

using namespace OHOS;
using namespace OHOS::USB;
using namespace OHOS::USB::Common;
using namespace std;
using namespace testing::ext;
using ::testing::Eq;
using ::testing::Exactly;
using ::testing::Ge;
using ::testing::Le;
using ::testing::Ne;
using ::testing::Return;

namespace OHOS {
namespace USB {
constexpr uint32_t ASHMEM_MAX_SIZE = 1024;
constexpr uint32_t MEM_DATA = 1024 * 1024;
sptr<MockUsbImpl> UsbBulkcallbackMockTest::mockUsbImpl_ = nullptr;
sptr<UsbService> UsbBulkcallbackMockTest::usbSrv_ = nullptr;
UsbDev UsbBulkcallbackMockTest::dev_ = {BUS_NUM_OK, DEV_ADDR_OK};
UsbInterface UsbBulkcallbackMockTest::interface_ {};

int32_t UsbBulkcallbackMockTest::InitAshmemOne(sptr<Ashmem> &asmptr, int32_t asmSize, uint8_t flg)
{
    asmptr = Ashmem::CreateAshmem("ttashmem000", asmSize);
    if (asmptr == nullptr) {
        USB_HILOGE(MODULE_USB_SERVICE, "InitAshmemOne CreateAshmem failed");
        return UEC_SERVICE_NO_MEMORY;
    }

    asmptr->MapReadAndWriteAshmem();

    if (flg == 0) {
        uint8_t tData[ASHMEM_MAX_SIZE];
        int32_t offset = 0;
        int32_t tLen = 0;

        int32_t retSafe = memset_s(tData, sizeof(tData), 'Y', ASHMEM_MAX_SIZE);
        if (retSafe != EOK) {
            USB_HILOGE(MODULE_USB_SERVICE, "InitAshmemOne memset_s failed");
            return UEC_SERVICE_NO_MEMORY;
        }
        while (offset < asmSize) {
            tLen = (asmSize - offset) < ASHMEM_MAX_SIZE ? (asmSize - offset) : ASHMEM_MAX_SIZE;
            asmptr->WriteToAshmem(tData, tLen, offset);
            offset += tLen;
        }
    }

    return 0;
}

void UsbBulkcallbackMockTest::SetUpTestCase(void)
{
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest SetUpTestCase");
    UsbCommonTest::SetTestCaseHapApply();

    usbSrv_ = DelayedSpSingleton<UsbService>::GetInstance();
    EXPECT_NE(usbSrv_, nullptr);
    mockUsbImpl_ = DelayedSpSingleton<MockUsbImpl>::GetInstance();
    EXPECT_NE(mockUsbImpl_, nullptr);

    usbSrv_->SetUsbd(mockUsbImpl_);

    sptr<UsbServiceSubscriber> iSubscriber = new UsbServiceSubscriber();
    EXPECT_NE(iSubscriber, nullptr);
    mockUsbImpl_->BindUsbdSubscriber(iSubscriber);

    EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
    EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
    USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK};
    auto ret = mockUsbImpl_->SubscriberDeviceEvent(info);
    EXPECT_EQ(0, ret);

    ret = mockUsbImpl_->SetPortRole(DEFAULT_PORT_ID, UsbSrvSupport::POWER_ROLE_SOURCE, UsbSrvSupport::DATA_ROLE_HOST);
    EXPECT_EQ(0, ret);
    if (ret != 0) {
        exit(0);
    }

    vector<UsbDevice> devList;
    ret = usbSrv_->GetDevices(devList);
    EXPECT_EQ(0, ret);
    EXPECT_FALSE(devList.empty()) << "devList NULL";
    UsbDevice device = MockUsbImpl::FindDeviceInfo(devList);

    EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->OpenDevice(dev_.busNum, dev_.devAddr);
    EXPECT_EQ(0, ret);

    interface_ = device.GetConfigs().front().GetInterfaces().at(1);
    uint8_t interfaceId = interface_.GetId();
    EXPECT_CALL(*mockUsbImpl_, ClaimInterface(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->ClaimInterface(dev_.busNum, dev_.devAddr, interfaceId, true);
    EXPECT_EQ(0, ret);
}

void UsbBulkcallbackMockTest::TearDownTestCase(void)
{
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest TearDownTestCase");
    EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->Close(dev_.busNum, dev_.devAddr);
    EXPECT_EQ(0, ret);

    USBDeviceInfo info = {ACT_DEVDOWN, BUS_NUM_OK, DEV_ADDR_OK};
    ret = mockUsbImpl_->SubscriberDeviceEvent(info);
    EXPECT_EQ(0, ret);

    mockUsbImpl_->UnbindUsbdSubscriber(nullptr);
    sptr<IUsbInterface> usbd = IUsbInterface::Get();
    usbSrv_->SetUsbd(usbd);

    mockUsbImpl_ = nullptr;
    usbSrv_ = nullptr;
    DelayedSpSingleton<UsbService>::DestroyInstance();
    DelayedSpSingleton<MockUsbImpl>::DestroyInstance();
}

void UsbBulkcallbackMockTest::SetUp(void) {}

void UsbBulkcallbackMockTest::TearDown(void) {}

/**
 * @tc.name: RegBulkCallback001
 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
 * sptr<IRemoteObject> &cb)
 * @tc.desc: Positive test: parameters correctly
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, RegBulkCallback001, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().front();
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::RegBulkCallback001 RegBulkCallback=%{public}d", ret);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: RegBulkCallback002
 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
 * sptr<IRemoteObject> &cb)
 * @tc.desc: Positive test: parameters correctly
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, RegBulkCallback002, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().at(1);
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::RegBulkCallback002 RegBulkCallback=%{public}d", ret);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: RegBulkCallback003
 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
 * sptr<IRemoteObject> &cb)
 * @tc.desc: Negative test: parameters exception, busNum error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, RegBulkCallback003, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().at(1);
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    dev_.busNum = BUS_NUM_INVALID;
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_))
        .WillRepeatedly(Return(RETVAL_INVALID));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::RegBulkCallback003 RegBulkCallback=%{public}d", ret);
    EXPECT_NE(ret, 0);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_NE(ret, 0);

    dev_.busNum = BUS_NUM_OK;
}

/**
 * @tc.name: RegBulkCallback004
 * @tc.desc: Test functions to int32_t RegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe, const
 * sptr<IRemoteObject> &cb)
 * @tc.desc: Negative test: parameters exception, devAddr error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, RegBulkCallback004, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().at(1);
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    dev_.devAddr = DEV_ADDR_INVALID;
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_))
        .WillRepeatedly(Return(RETVAL_INVALID));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::RegBulkCallback004 RegBulkCallback=%{public}d", ret);
    EXPECT_NE(ret, 0);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_NE(ret, 0);

    dev_.devAddr = DEV_ADDR_OK;
}

/**
 * @tc.name: BulkRead001
 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
 * @tc.desc: Positive test: parameters correctly
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, BulkRead001, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().front();
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    sptr<Ashmem> ashmem;
    uint8_t flg = 0;
    int32_t asmSize = MEM_DATA;
    ret = UsbBulkcallbackMockTest::UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
    EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkRead001 BulkRead=%{public}d", ret);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: BulkRead002
 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
 * @tc.desc: Negative test: parameters exception,point error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, BulkRead002, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().at(1);
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    sptr<Ashmem> ashmem;
    uint8_t flg = 0;
    int32_t asmSize = MEM_DATA;
    ret = UsbBulkcallbackMockTest::UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
    EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkRead002 BulkRead=%{public}d", ret);
    EXPECT_NE(ret, 0);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: BulkRead003
 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
 * @tc.desc: Negative test: parameters exception,busNum error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, BulkRead003, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().front();
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    sptr<Ashmem> ashmem;
    uint8_t flg = 0;
    int32_t asmSize = MEM_DATA;
    ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
    dev_.busNum = BUS_NUM_INVALID;
    EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkRead003 BulkRead=%{public}d", ret);
    EXPECT_NE(ret, 0);

    dev_.busNum = BUS_NUM_OK;
    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: BulkRead004
 * @tc.desc: Test functions to int32_t BulkRead(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
 * @tc.desc: Negative test: parameters exception,devAddr error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, BulkRead004, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().front();
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    sptr<Ashmem> ashmem;
    uint8_t flg = 0;
    int32_t asmSize = MEM_DATA;
    ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
    dev_.devAddr = DEV_ADDR_INVALID;
    EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkRead004 BulkRead=%{public}d", ret);
    EXPECT_NE(ret, 0);

    dev_.devAddr = DEV_ADDR_OK;
    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: BulkWrite001
 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
 * @tc.desc: Positive test: parameters correctly
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, BulkWrite001, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().at(1);
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    sptr<Ashmem> ashmem;
    uint8_t flg = 0;
    int32_t asmSize = MEM_DATA;
    ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
    EXPECT_CALL(*mockUsbImpl_, BulkWrite(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkWrite(dev_, pipe, ashmem);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkWrite001 BulkWrite=%{public}d", ret);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: BulkWrite002
 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
 * @tc.desc: Negative test: parameters exception,point error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, BulkWrite002, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().front();
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    sptr<Ashmem> ashmem;
    uint8_t flg = 0;
    int32_t asmSize = MEM_DATA;
    ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
    EXPECT_CALL(*mockUsbImpl_, BulkWrite(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->BulkWrite(dev_, pipe, ashmem);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkWrite002 BulkWrite=%{public}d", ret);
    EXPECT_NE(ret, 0);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: BulkWrite003
 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
 * @tc.desc: Negative test: parameters exception,busNum error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, BulkWrite003, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().at(1);
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    sptr<Ashmem> ashmem;
    uint8_t flg = 0;
    int32_t asmSize = MEM_DATA;
    ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
    dev_.busNum = BUS_NUM_INVALID;
    EXPECT_CALL(*mockUsbImpl_, BulkWrite(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->BulkWrite(dev_, pipe, ashmem);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkWrite003 BulkWrite=%{public}d", ret);
    EXPECT_NE(ret, 0);

    dev_.busNum = BUS_NUM_OK;
    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: BulkWrite004
 * @tc.desc: Test functions to int32_t BulkWrite(const UsbDev &devInfo, const UsbPipe &pipe, sptr<Ashmem> &ashmem)
 * @tc.desc: Negative test: parameters exception,devAddr error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, BulkWrite004, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().at(1);
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    sptr<Ashmem> ashmem;
    uint8_t flg = 0;
    int32_t asmSize = MEM_DATA;
    ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
    dev_.devAddr = DEV_ADDR_INVALID;
    EXPECT_CALL(*mockUsbImpl_, BulkWrite(testing::_, testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->BulkWrite(dev_, pipe, ashmem);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkWrite004 BulkWrite=%{public}d", ret);
    EXPECT_NE(ret, 0);

    dev_.devAddr = DEV_ADDR_OK;
    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: BulkCancel001
 * @tc.desc: Test functions to int32_t BulkCancel(const UsbDev &devInfo, const UsbPipe &pipe)
 * @tc.desc: Positive test: parameters correctly
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, BulkCancel001, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().front();
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    sptr<Ashmem> ashmem;
    uint8_t flg = 0;
    int32_t asmSize = MEM_DATA;
    ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
    EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel001 BulkCancel=%{public}d", ret);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel001 BulkCancel=%{public}d", ret);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: BulkCancel002
 * @tc.desc: Test functions to int32_t BulkCancel(const UsbDev &devInfo, const UsbPipe &pipe)
 * @tc.desc: Negative test: parameters exception,busNum error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, BulkCancel002, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().front();
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    sptr<Ashmem> ashmem;
    uint8_t flg = 0;
    int32_t asmSize = MEM_DATA;
    ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
    EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);

    dev_.busNum = BUS_NUM_INVALID;
    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel002 BulkCancel=%{public}d", ret);
    EXPECT_NE(ret, 0);

    dev_.busNum = BUS_NUM_OK;
    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel002 BulkCancel=%{public}d", ret);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: BulkCancel003
 * @tc.desc: Test functions to int32_t BulkCancel(const UsbDev &devInfo, const UsbPipe &pipe)
 * @tc.desc: Negative test: parameters exception,devAddr error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, BulkCancel003, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().front();
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    sptr<Ashmem> ashmem;
    uint8_t flg = 0;
    int32_t asmSize = MEM_DATA;
    ret = UsbBulkcallbackMockTest::InitAshmemOne(ashmem, asmSize, flg);
    EXPECT_CALL(*mockUsbImpl_, BulkRead(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkRead(dev_, pipe, ashmem);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    EXPECT_EQ(0, ret);

    dev_.devAddr = DEV_ADDR_INVALID;
    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel002 BulkCancel=%{public}d", ret);
    EXPECT_NE(ret, 0);

    dev_.devAddr = DEV_ADDR_OK;
    EXPECT_CALL(*mockUsbImpl_, BulkCancel(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->BulkCancel(dev_, pipe);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::BulkCancel003 BulkCancel=%{public}d", ret);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: UnRegBulkCallback001
 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe)
 * @tc.desc: Positive test: parameters correctly
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, UnRegBulkCallback001, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().front();
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_)).WillRepeatedly(Return(0));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_EQ(0, ret);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(0));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::UnRegBulkCallback001 UnRegBulkCallback=%{public}d", ret);
    EXPECT_EQ(0, ret);
}

/**
 * @tc.name: UnRegBulkCallback002
 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe)
 * @tc.desc: Negative test: parameters exception,busNum error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, UnRegBulkCallback002, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().front();
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    dev_.busNum = BUS_NUM_INVALID;
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_))
        .WillRepeatedly(Return(RETVAL_INVALID));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_NE(ret, 0);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::UnRegBulkCallback002 UnRegBulkCallback=%{public}d", ret);
    EXPECT_NE(ret, 0);

    dev_.busNum = BUS_NUM_OK;
}

/**
 * @tc.name: UnRegBulkCallback003
 * @tc.desc: Test functions to int32_t UnRegBulkCallback(const UsbDev &devInfo, const UsbPipe &pipe)
 * @tc.desc: Negative test: parameters exception,devAddr error
 * @tc.type: FUNC
 */
HWTEST_F(UsbBulkcallbackMockTest, UnRegBulkCallback003, TestSize.Level1)
{
    sptr<UsbCallbackTest> cb = new UsbCallbackTest();
    EXPECT_NE(cb, nullptr);
    USBEndpoint point = interface_.GetEndpoints().front();
    UsbPipe pipe = {point.GetInterfaceId(), point.GetAddress()};
    dev_.devAddr = DEV_ADDR_INVALID;
    EXPECT_CALL(*mockUsbImpl_, RegBulkCallback(testing::_, testing::_, testing::_))
        .WillRepeatedly(Return(RETVAL_INVALID));
    auto ret = usbSrv_->RegBulkCallback(dev_, pipe, cb);
    EXPECT_NE(ret, 0);

    EXPECT_CALL(*mockUsbImpl_, UnRegBulkCallback(testing::_, testing::_)).WillRepeatedly(Return(RETVAL_INVALID));
    ret = usbSrv_->UnRegBulkCallback(dev_, pipe);
    USB_HILOGI(MODULE_USB_SERVICE, "UsbBulkcallbackMockTest::UnRegBulkCallback003 UnRegBulkCallback=%{public}d", ret);
    EXPECT_NE(ret, 0);

    dev_.devAddr = DEV_ADDR_OK;
}
} // namespace USB
} // namespace OHOS