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

#include <chrono>
#include <random>
#include <thread>

#include "server.h"

using namespace std::chrono;
using namespace std::chrono_literals;
using namespace testing::ext;
using namespace testing;

namespace Hdc {
class HdcHostUARTTest : public testing::Test {
public:
    static void SetUpTestCase(void);
    static void TearDownTestCase(void);
    void SetUp();
    void TearDown();

    constexpr static int PAIR = 2;
    constexpr static int SENDER = 0;
    constexpr static int RECEIVER = 1;

    std::default_random_engine rnd;
    const std::string nullDevPath = "/dev/null";
    class MockHdcServer : public HdcServer {
        MockHdcServer() : HdcServer(true) {};
        MOCK_METHOD3(AdminDaemonMap, string(uint8_t, const string &, HDaemonInfo &));
        MOCK_METHOD1(EnumUARTDeviceRegister, void(UartKickoutZombie));
        MOCK_METHOD4(MallocSession, HSession(bool, const ConnType, void *, uint32_t));
        MOCK_METHOD1(FreeSession, void(const uint32_t));
        MOCK_METHOD3(AdminSession, HSession(const uint8_t, const uint32_t, HSession));
        MOCK_METHOD2(EchoToClientsForSession, void(uint32_t, const string &));
    } mockServer;

    class MockBaseInterface : public ExternInterface {
    public:
        MOCK_METHOD4(StartWorkThread, int(uv_loop_t *, uv_work_cb, uv_after_work_cb, void *));
        MOCK_METHOD2(TryCloseHandle, void(const uv_handle_t *, uv_close_cb));
        MOCK_METHOD3(TimerUvTask, bool(uv_loop_t *, void *, uv_timer_cb));
        MOCK_METHOD3(SendToStream, int(uv_stream_t *, const uint8_t *, const int));
        MOCK_METHOD3(SendToPollFd, int(int, const uint8_t *, const int));
        MOCK_METHOD6(DelayDo, bool(uv_loop_t *, const int, const uint8_t, string, void *, DelayCB));
        MOCK_METHOD4(UvTimerStart, bool(uv_timer_t *, uv_timer_cb, uint64_t, uint64_t));
    } mockInterface;

    class MockHdcHostUART : public HdcHostUART {
    public:
        explicit MockHdcHostUART(HdcServer &daemonIn,
                        ExternInterface &externInterface = HdcUARTBase::defaultInterface)
            : HdcHostUART(daemonIn, externInterface)
        {
        }
        MOCK_METHOD0(StartupUARTWork, RetErrCode());
        MOCK_METHOD0(UartWriteThread, void());
        MOCK_METHOD1(CloseSerialPort, void(const HUART));
        MOCK_METHOD1(EnumSerialPort, bool(bool &));
        MOCK_METHOD0(Stop, void());
        MOCK_METHOD3(UpdateUARTDaemonInfo, void(const std::string &, HSession, ConnStatus));
        MOCK_METHOD1(StartUartReadThread, bool(HSession));
        MOCK_METHOD0(StartUartSendThread, bool());
        MOCK_METHOD0(WatchUartDevPlugin, void());
        MOCK_METHOD1(OpenSerialPort, int(const std::string &));
        MOCK_METHOD1(UartReadThread, void(HSession));
        MOCK_METHOD3(SendUARTRaw, bool(HSession, uint8_t *, const size_t));
        MOCK_METHOD3(RequestSendPackage, void(uint8_t *, const size_t, bool));
        MOCK_METHOD1(UartSendThread, void(HSession));
        MOCK_METHOD0(SendPkgInUARTOutMap, void());
        MOCK_METHOD1(IsDeviceOpened, bool(const HdcUART &));
        MOCK_METHOD3(ReadUartDev, ssize_t(std::vector<uint8_t> &, size_t, HdcUART &));
        MOCK_METHOD1(NeedStop, bool(const HSession));
        MOCK_METHOD2(PackageProcess, size_t(vector<uint8_t> &, HSession hSession));
        MOCK_METHOD1(OnTransferError, void(const HSession));
        MOCK_METHOD1(ClearUARTOutMap, void(uint32_t));
    } mockHostUART;

    HdcSession mySession;
    HdcUART myUART;
    const int testSerialHandle = 0x1234;
    const std::string testSerialPortName = "COMX";

    HdcHostUARTTest() : mockHostUART(mockServer, mockInterface)
    {
        myUART.serialPort = testSerialPortName;
        myUART.devUartHandle = testSerialHandle;
        mySession.hUART = &myUART;
        mySession.classModule = &mockHostUART;
        mySession.classInstance = &mockServer;
    };
};

void HdcHostUARTTest::SetUpTestCase()
{
#ifdef UT_DEBUG
    Hdc::Base::SetLogLevel(LOG_ALL);
#else
    Hdc::Base::SetLogLevel(LOG_OFF);
#endif
}

void HdcHostUARTTest::TearDownTestCase() {}

void HdcHostUARTTest::SetUp()
{
    // The destructor will call these
    EXPECT_CALL(mockHostUART, Stop).Times(AnyNumber());
    EXPECT_CALL(mockInterface, TryCloseHandle).Times(AnyNumber());
}

void HdcHostUARTTest::TearDown()
{
    // session will close mockDaemon.loopMain ,so we dont need close it in UT

    // ~HdcHostUART will call close
}

/*
 * @tc.name: HdcHostUART
 * @tc.desc: Check the behavior of the HdcHostUART function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, HdcHostUART, TestSize.Level1)
{
    HdcHostUART hostUart(mockServer);
    EXPECT_EQ(hostUart.uartOpened, false);
    EXPECT_EQ(hostUart.baudRate, 0u);
    EXPECT_EQ(hostUart.mapIgnoreDevice.empty(), true);
    EXPECT_EQ(hostUart.serialPortInfo.empty(), true);

    hostUart.devUartWatcher.data = this;
    uv_timer_start(
        &hostUart.devUartWatcher,
        [](uv_timer_s *timer) {
            EXPECT_NE(timer->data, nullptr);
            timer->data = nullptr;
        },
        100, 0);

    std::this_thread::sleep_for(200ms);
    uv_run(&mockServer.loopMain, UV_RUN_NOWAIT);

    EXPECT_EQ(hostUart.devUartWatcher.data, nullptr);
    EXPECT_EQ(hostUart.semUartDevCheck.try_lock(), true);

    EXPECT_NE(uv_has_ref(reinterpret_cast<uv_handle_t *>(&hostUart.devUartWatcher)), 0);
}

/*
 * @tc.name: Initial
 * @tc.desc: Check the behavior of the Initial function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, Initial, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, StartupUARTWork).Times(1);
    EXPECT_EQ(mockHostUART.Initial(), 0);
    EXPECT_EQ(mockHostUART.uartOpened, false);
    EXPECT_EQ(mockHostUART.stopped, false);
}

/*
 * @tc.name: Stop
 * @tc.desc: Check the behavior of the Stop function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, Stop, TestSize.Level1)
{
    ON_CALL(mockHostUART, Stop).WillByDefault(Invoke([&]() {
        return mockHostUART.HdcHostUART::Stop();
    }));
    EXPECT_CALL(mockHostUART, Stop).Times(1);
    EXPECT_CALL(
        mockInterface,
        TryCloseHandle(reinterpret_cast<uv_handle_t *>(&mockHostUART.devUartWatcher), nullptr))
        .Times(1);
    mockHostUART.Stop();

    // unable stop twice
    EXPECT_CALL(mockHostUART, Stop).Times(1);
    EXPECT_CALL(mockInterface, TryCloseHandle).Times(0);
    mockHostUART.Stop();
}

/*
 * @tc.name: ConnectDaemonByUart
 * @tc.desc: Check the behavior of the ConnectDaemonByUart function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, ConnectDaemonByUart, TestSize.Level1)
{
    mockHostUART.uartOpened = true;

    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo(mySession.connectKey, &mySession, STATUS_READY))
        .Times(1);
    EXPECT_CALL(mockHostUART, StartUartReadThread(&mySession)).Times(1).WillOnce(Return(true));
    EXPECT_CALL(mockInterface, StartWorkThread(&mockServer.loopMain, mockServer.SessionWorkThread,
                                               Base::FinishWorkThread, &mySession))
        .Times(1);
    EXPECT_CALL(
        mockInterface,
        SendToPollFd(mySession.ctrlFd[STREAM_MAIN], _, _))
        .Times(1);
    mySession.childLoop.active_handles = 1;
    EXPECT_EQ(mockHostUART.ConnectDaemonByUart(&mySession), &mySession);

    // delay case
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo(mySession.connectKey, &mySession, STATUS_READY))
        .Times(1);
    EXPECT_CALL(mockHostUART, StartUartReadThread(&mySession)).Times(1).WillOnce(Return(true));
    EXPECT_CALL(mockInterface, StartWorkThread(&mockServer.loopMain, mockServer.SessionWorkThread,
                                               Base::FinishWorkThread, &mySession))
        .Times(1);
    EXPECT_CALL(
        mockInterface,
        SendToPollFd(mySession.ctrlFd[STREAM_MAIN], _, _))
        .Times(1);

    mySession.childLoop.active_handles = 0;
    std::thread mockActiveHandles([&]() {
        std::this_thread::sleep_for(1000ms);
        mySession.childLoop.active_handles = 1;
    });
    EXPECT_EQ(mockHostUART.ConnectDaemonByUart(&mySession), &mySession);
    mockActiveHandles.join();
}

/*
 * @tc.name: ConnectDaemonByUart
 * @tc.desc: Check the behavior of the ConnectDaemonByUart function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, ConnectDaemonByUartFail, TestSize.Level1)
{
    mockHostUART.uartOpened = false;
    EXPECT_EQ(mockHostUART.ConnectDaemonByUart(&mySession), nullptr);

    mockHostUART.uartOpened = true;
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo(mySession.connectKey, &mySession, STATUS_READY))
        .Times(1);
    EXPECT_CALL(mockHostUART, StartUartReadThread).Times(1).WillOnce(Return(false));
    EXPECT_EQ(mockHostUART.ConnectDaemonByUart(&mySession), nullptr);
}

/*
 * @tc.name: UvWatchUartDevPlugin
 * @tc.desc: Check the behavior of the UvWatchUartDevPlugin function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, UvWatchUartDevPlugin, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, WatchUartDevPlugin).Times(0);
    HdcHostUART::UvWatchUartDevPlugin(nullptr);

    EXPECT_CALL(mockHostUART, WatchUartDevPlugin()).Times(1);
    uv_timer_t handle;
    handle.data = &mockHostUART;
    HdcHostUART::UvWatchUartDevPlugin(&handle);

    handle.data = nullptr;
    HdcHostUART::UvWatchUartDevPlugin(&handle);
}

/*
 * @tc.name: WatchUartDevPlugin
 * @tc.desc: Check the behavior of the WatchUartDevPlugin function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, WatchUartDevPluginHaveSerialDaemon, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, WatchUartDevPlugin).WillRepeatedly([&]() {
        mockHostUART.HdcHostUART::WatchUartDevPlugin();
    });
    // case 1 EnumSerialPort failed
    EXPECT_CALL(mockHostUART, EnumSerialPort).WillOnce(Return(false));
    EXPECT_CALL(mockServer, AdminDaemonMap).Times(0);
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo).Times(0);
    mockHostUART.WatchUartDevPlugin();

    // case 2 EnumSerialPort not fail but no port change
    EXPECT_CALL(mockHostUART, EnumSerialPort)
        .WillOnce(DoAll(SetArgReferee<0>(false), Return(true)));
    EXPECT_CALL(mockServer, AdminDaemonMap).Times(0);
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo).Times(0);
    mockHostUART.WatchUartDevPlugin();
}

/*
 * @tc.name: WatchUartDevPlugin
 * @tc.desc: Check the behavior of the WatchUartDevPlugin function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, WatchUartDevPluginHaveSomePort, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, WatchUartDevPlugin).WillRepeatedly([&]() {
        mockHostUART.HdcHostUART::WatchUartDevPlugin();
    });

    // case 3 EnumSerialPort return two port, not port removed
    // one port is not connected , the other is connected
    EXPECT_CALL(mockHostUART, EnumSerialPort).WillOnce(DoAll(SetArgReferee<0>(true), Return(true)));
    mockHostUART.serialPortInfo.clear();
    mockHostUART.serialPortInfo.emplace_back("COMX");
    mockHostUART.serialPortInfo.emplace_back("COMY");
    mockHostUART.connectedPorts.clear();
    mockHostUART.connectedPorts.emplace("COMY");
    EXPECT_CALL(mockServer, AdminDaemonMap(OP_QUERY, "COMX", _))
        .WillOnce(DoAll(SetArgReferee<2>(nullptr), Return("")));
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo("COMX", nullptr, STATUS_READY)).Times(1);
    EXPECT_CALL(mockServer, AdminDaemonMap(OP_QUERY, "COMY", _))
        .WillOnce(DoAll(SetArgReferee<2>(nullptr), Return("")));
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo("COMY", nullptr, STATUS_READY)).Times(0);
    mockHostUART.WatchUartDevPlugin();
}

/*
 * @tc.name: WatchUartDevPlugin
 * @tc.desc: Check the behavior of the WatchUartDevPlugin function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, WatchUartDevPluginHaveRemovedPort, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, WatchUartDevPlugin).WillRepeatedly([&]() {
        mockHostUART.HdcHostUART::WatchUartDevPlugin();
    });

    // case 4 EnumSerialPort return two port, and one port removed
    // one port is not connected , the other is connected
    EXPECT_CALL(mockHostUART, EnumSerialPort).WillOnce(DoAll(SetArgReferee<0>(true), Return(true)));
    mockHostUART.serialPortInfo.clear();
    mockHostUART.serialPortInfo.emplace_back("COMX");
    mockHostUART.serialPortInfo.emplace_back("COMY");
    mockHostUART.connectedPorts.clear();
    mockHostUART.connectedPorts.emplace("COMY");
    mockHostUART.serialPortRemoved.clear();
    mockHostUART.serialPortRemoved.emplace_back("COMZ");

    HdcDaemonInformation di;
    EXPECT_CALL(mockServer, AdminDaemonMap(OP_QUERY, "COMX", _))
        .WillOnce(DoAll(SetArgReferee<2>(nullptr), Return("")));
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo("COMX", nullptr, STATUS_READY)).Times(1);
    EXPECT_CALL(mockServer, AdminDaemonMap(OP_QUERY, "COMY", _))
        .WillOnce(DoAll(SetArgReferee<2>(nullptr), Return("")));
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo("COMY", nullptr, STATUS_READY)).Times(0);
    EXPECT_CALL(mockServer, AdminDaemonMap(OP_QUERY, "COMZ", _))
        .WillOnce(DoAll(SetArgReferee<2>(&di), Return("")));
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo("COMZ", nullptr, STATUS_READY)).Times(0);
    mockHostUART.WatchUartDevPlugin();
}

/*
 * @tc.name: UpdateUARTDaemonInfo
 * @tc.desc: Check the behavior of the UpdateUARTDaemonInfo function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, UpdateUARTDaemonInfo, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo)
        .WillRepeatedly(
            [&](const std::string &connectKey, HSession hSession, ConnStatus connStatus) {
                mockHostUART.HdcHostUART::UpdateUARTDaemonInfo(connectKey, hSession, connStatus);
            });

    // case 1 STATUS_UNKNOW
    HdcDaemonInformation diNew;
    EXPECT_CALL(mockServer,
                AdminDaemonMap(OP_REMOVE, testSerialPortName,
                               Field(&HdcDaemonInformation::connectKey, testSerialPortName)))
        .Times(1)
        .WillOnce(DoAll(SetArgReferee<2>(nullptr), Return("")));

    mockHostUART.UpdateUARTDaemonInfo(myUART.serialPort, &mySession, STATUS_UNKNOW);

    // case 2 STATUS_CONNECTED
    HdcDaemonInformation diDummy;
    EXPECT_CALL(mockServer, AdminDaemonMap(OP_QUERY, testSerialPortName, _))
        .Times(1)
        .WillOnce(DoAll(SetArgReferee<2>(&diDummy), Return("")));

    EXPECT_CALL(mockServer,
                AdminDaemonMap(OP_UPDATE, testSerialPortName,
                               Field(&HdcDaemonInformation::connectKey, testSerialPortName)))
        .Times(1)
        .WillOnce(DoAll(SetArgReferee<2>(nullptr), Return("")));

    mockHostUART.UpdateUARTDaemonInfo(myUART.serialPort, &mySession, STATUS_CONNECTED);
}

/*
 * @tc.name: StartUartReadThread
 * @tc.desc: Check the behavior of the StartUartReadThread function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, StartUartReadThread, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, StartUartReadThread).WillOnce(Invoke([&](HSession hSession) {
        return mockHostUART.HdcHostUART::StartUartReadThread(hSession);
    }));

    EXPECT_CALL(mockHostUART, UartReadThread(&mySession)).Times(1);
    mockHostUART.StartUartReadThread(&mySession);
    if (mySession.hUART->readThread.joinable()) {
        mySession.hUART->readThread.join();
    }
}

/*
 * @tc.name: ConnectMyNeed
 * @tc.desc: Check the behavior of the ConnectMyNeed function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, ConnectMyNeed, TestSize.Level1)
{
    HdcUART newUART;
    mySession.hUART = &newUART;
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo(myUART.serialPort, nullptr, STATUS_READY))
        .Times(1);
    EXPECT_CALL(mockServer, MallocSession(true, CONN_SERIAL, &mockHostUART, 0))
        .Times(1)
        .WillOnce(Return(&mySession));
    EXPECT_CALL(mockInterface, UvTimerStart(Field(&uv_timer_t::data, &mySession),
                                            &mockServer.UartPreConnect, UV_TIMEOUT, UV_REPEAT))
        .Times(1)
        .WillOnce(Return(RET_SUCCESS));

    EXPECT_EQ(mockHostUART.ConnectMyNeed(&myUART, myUART.serialPort), true);

    EXPECT_EQ(newUART.devUartHandle, testSerialHandle);
    EXPECT_EQ(newUART.serialPort, testSerialPortName);
}

/*
 * @tc.name: ConnectMyNeed
 * @tc.desc: Check the behavior of the ConnectMyNeed function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, ConnectMyNeedFail, TestSize.Level1)
{
    HdcUART newUART;
    mySession.hUART = &newUART;
    EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo(myUART.serialPort, nullptr, STATUS_READY))
        .Times(1);
    EXPECT_CALL(mockServer, MallocSession(true, CONN_SERIAL, &mockHostUART, 0))
        .Times(1)
        .WillOnce(Return(&mySession));
    EXPECT_CALL(mockInterface, UvTimerStart(Field(&uv_timer_t::data, &mySession),
                                            &mockServer.UartPreConnect, UV_TIMEOUT, UV_REPEAT))
        .Times(1)
        .WillOnce(Return(-1));

    EXPECT_EQ(mockHostUART.ConnectMyNeed(&myUART), false);

    EXPECT_EQ(newUART.devUartHandle, testSerialHandle);
    EXPECT_EQ(newUART.serialPort, testSerialPortName);
}

/*
 * @tc.name: StartupUARTWork
 * @tc.desc: Check the behavior of the StartupUARTWork function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, StartupUARTWork, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, StartupUARTWork).WillRepeatedly([&]() {
        return mockHostUART.HdcHostUART::StartupUARTWork();
    });
    EXPECT_CALL(mockInterface, UvTimerStart(Field(&uv_timer_t::data, &mockHostUART),
                                            mockHostUART.UvWatchUartDevPlugin, _, _))
        .Times(1)
        .WillOnce(Return(0));

    EXPECT_CALL(mockHostUART, StartUartSendThread()).Times(1).WillOnce(Return(false));

    EXPECT_EQ(mockHostUART.StartupUARTWork(), ERR_GENERIC);

    EXPECT_CALL(mockInterface, UvTimerStart(Field(&uv_timer_t::data, &mockHostUART),
                                            mockHostUART.UvWatchUartDevPlugin, _, _))
        .Times(1)
        .WillOnce(Return(-1));
    EXPECT_EQ(mockHostUART.StartupUARTWork(), ERR_GENERIC);
}

MATCHER_P(EqUartHead, otherUartHead, "Equality matcher for type UartHead")
{
    UartHead *argUartHead = reinterpret_cast<UartHead *>(arg);
    return *argUartHead == *otherUartHead;
}

/*
 * @tc.name: SendUartSoftReset
 * @tc.desc: Check the behavior of the SendUartSoftReset function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, SendUartSoftReset, TestSize.Level1)
{
    UartHead resetPackage;
    constexpr uint32_t sessionId = 1234;
    resetPackage.option = PKG_OPTION_RESET;
    resetPackage.dataSize = sizeof(UartHead);
    resetPackage.sessionId = sessionId;

    EXPECT_CALL(mockHostUART,
                RequestSendPackage(EqUartHead(&resetPackage), sizeof(UartHead), false))
        .Times(1);
    mockHostUART.SendUartSoftReset(&mySession, sessionId);
}

/*
 * @tc.name: KickoutZombie
 * @tc.desc: Check the behavior of the KickoutZombie function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, KickoutZombie, TestSize.Level1)
{
    mockHostUART.KickoutZombie(nullptr);

    mySession.isDead = true;
    mockHostUART.KickoutZombie(&mySession);
    mySession.isDead = false;

    myUART.devUartHandle = -1;
    mockHostUART.KickoutZombie(&mySession);
    myUART.devUartHandle = 0;

    EXPECT_CALL(mockServer, FreeSession(mySession.sessionId)).Times(1);
    mockHostUART.KickoutZombie(&mySession);
}

/*
 * @tc.name: StartUartSendThread
 * @tc.desc: Check the behavior of the StartUartSendThread function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, StartUartSendThread, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, StartUartSendThread).WillRepeatedly([&]() {
        return mockHostUART.HdcHostUART::StartUartSendThread();
    });
    EXPECT_CALL(mockHostUART, UartWriteThread).Times(1);
    EXPECT_TRUE(mockHostUART.StartUartSendThread());
    std::this_thread::sleep_for(500ms);
}

/*
 * @tc.name: NeedStop
 * @tc.desc: Check the behavior of the NeedStop function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, NeedStop, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, NeedStop).WillRepeatedly([&](const HSession hSession) {
        return mockHostUART.HdcHostUART::NeedStop(hSession);
    });
    mockHostUART.uartOpened = true;
    mySession.isDead = false;
    mySession.ref = 1;
    EXPECT_EQ(mockHostUART.NeedStop(&mySession), false);

    mockHostUART.uartOpened = true;
    mySession.isDead = false;
    mySession.ref = 0;
    EXPECT_EQ(mockHostUART.NeedStop(&mySession), false);

    mockHostUART.uartOpened = true;
    mySession.isDead = true;
    mySession.ref = 1;
    EXPECT_EQ(mockHostUART.NeedStop(&mySession), false);

    mockHostUART.uartOpened = true;
    mySession.isDead = true;
    mySession.ref = 0;
    EXPECT_EQ(mockHostUART.NeedStop(&mySession), true);

    mockHostUART.uartOpened = false;
    mySession.isDead = false;
    mySession.ref = 1;
    EXPECT_EQ(mockHostUART.NeedStop(&mySession), true);
}

/*
 * @tc.name: IsDeviceOpened
 * @tc.desc: Check the behavior of the IsDeviceOpened function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, IsDeviceOpened, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, IsDeviceOpened).WillRepeatedly([&](const HdcUART &uart) {
        return mockHostUART.HdcHostUART::IsDeviceOpened(uart);
    });
    myUART.devUartHandle = -1;
    EXPECT_EQ(mockHostUART.IsDeviceOpened(myUART), false);

    myUART.devUartHandle = -2;
    EXPECT_EQ(mockHostUART.IsDeviceOpened(myUART), false);

    myUART.devUartHandle = 0;
    EXPECT_EQ(mockHostUART.IsDeviceOpened(myUART), true);

    myUART.devUartHandle = 1;
    EXPECT_EQ(mockHostUART.IsDeviceOpened(myUART), true);
}

/*
 * @tc.name: UartWriteThread
 * @tc.desc: Check the behavior of the UartWriteThread function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, UartWriteThread, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, UartWriteThread).WillOnce(Invoke([&]() {
        return mockHostUART.HdcHostUART::UartWriteThread();
    }));

    EXPECT_CALL(mockHostUART, SendPkgInUARTOutMap).Times(0);
    auto sendThread = std::thread(&HdcHostUART::UartWriteThread, &mockHostUART);
    std::this_thread::sleep_for(1000ms);
    EXPECT_CALL(mockHostUART, SendPkgInUARTOutMap).Times(1);
    mockHostUART.transfer.Request();
    std::this_thread::sleep_for(200ms);
    mockHostUART.stopped = true;
    mockHostUART.transfer.Request();
    sendThread.join();
}

/*
 * @tc.name: UartReadThread
 * @tc.desc: Check the behavior of the UartReadThread function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, UartReadThread, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, UartReadThread).WillRepeatedly(Invoke([&](HSession hSession) {
        return mockHostUART.HdcHostUART::UartReadThread(hSession);
    }));

    // case 1 need stop
    EXPECT_CALL(mockHostUART, NeedStop).WillOnce(Return(true));
    auto readThread = std::thread(&HdcHostUART::UartReadThread, &mockHostUART, &mySession);
    readThread.join();

    // case 2 ReadUartDev return -1 will cause OnTransferError
    EXPECT_CALL(mockHostUART, NeedStop).WillOnce(Return(false)).WillOnce(Return(true));
    EXPECT_CALL(mockHostUART, ReadUartDev).WillOnce(Return(-1));
    EXPECT_CALL(mockHostUART, OnTransferError).Times(1);
    EXPECT_CALL(mockHostUART, PackageProcess).Times(0);
    auto readThread2 = std::thread(&HdcHostUART::UartReadThread, &mockHostUART, &mySession);
    readThread2.join();

    // case 3 ReadUartDev retturn 0 will timeout, try again
    EXPECT_CALL(mockHostUART, NeedStop).WillOnce(Return(false)).WillOnce(Return(true));
    EXPECT_CALL(mockHostUART, ReadUartDev).WillOnce(Return(0));
    EXPECT_CALL(mockHostUART, OnTransferError).Times(0);
    EXPECT_CALL(mockHostUART, PackageProcess).Times(0);
    auto readThread3 = std::thread(&HdcHostUART::UartReadThread, &mockHostUART, &mySession);
    readThread3.join();

    // case 4 ReadUartDev return sizeof(UartHead)
    EXPECT_CALL(mockHostUART, NeedStop).WillOnce(Return(false)).WillOnce(Return(true));
    EXPECT_CALL(mockHostUART, ReadUartDev)
        .WillOnce(Invoke([&](std::vector<uint8_t> &readBuf, size_t expectedSize, HdcUART &uart) {
            readBuf.resize(sizeof(UartHead));
            return readBuf.size();
        }));
    EXPECT_CALL(mockHostUART, OnTransferError).Times(0);
    EXPECT_CALL(mockHostUART, PackageProcess).WillOnce(Return(0));
    auto readThread4 = std::thread(&HdcHostUART::UartReadThread, &mockHostUART, &mySession);
    readThread4.join();

    // case 5 ReadUartDev return more than sizeof(UartHead)
    EXPECT_CALL(mockHostUART, NeedStop).WillOnce(Return(false)).WillOnce(Return(true));
    const size_t testDataSize = sizeof(UartHead) * 2;

    EXPECT_CALL(mockHostUART, ReadUartDev)
        .WillOnce(Invoke([&](std::vector<uint8_t> &readBuf, size_t expectedSize, HdcUART &uart) {
            readBuf.resize(testDataSize);
            return readBuf.size();
        }));
    EXPECT_CALL(mockHostUART, OnTransferError).Times(0);
    EXPECT_CALL(mockHostUART, PackageProcess).WillOnce(Return(0));
    auto readThread5 = std::thread(&HdcHostUART::UartReadThread, &mockHostUART, &mySession);
    readThread5.join();
}

/*
 * @tc.name: WaitUartIdle
 * @tc.desc: Check the behavior of the WaitUartIdle function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, WaitUartIdle, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, ReadUartDev(_, 1, Ref(myUART))).WillOnce(Return(0));
    EXPECT_EQ(mockHostUART.WaitUartIdle(myUART), true);

    EXPECT_CALL(mockHostUART, ReadUartDev(_, 1, Ref(myUART)))
        .WillOnce(Return(1))
        .WillOnce(Return(0));
    EXPECT_EQ(mockHostUART.WaitUartIdle(myUART), true);

    EXPECT_CALL(mockHostUART, ReadUartDev(_, 1, Ref(myUART)))
        .WillOnce(Return(1))
        .WillOnce(Return(1));
    EXPECT_EQ(mockHostUART.WaitUartIdle(myUART), false);
}

/*
 * @tc.name: ConnectDaemon
 * @tc.desc: Check the behavior of the ConnectDaemon function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, ConnectDaemon, TestSize.Level1)
{
    std::string connectKey = "dummykey";
    EXPECT_CALL(mockHostUART, OpenSerialPort(connectKey)).WillOnce(Return(0));
    EXPECT_EQ(mockHostUART.ConnectDaemon(connectKey), nullptr);
}

/*
 * @tc.name: GetSession
 * @tc.desc: Check the behavior of the GetSession function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, GetSession, TestSize.Level1)
{
    constexpr uint32_t sessionId = 1234;
    HdcSession mySession;
    HdcUART myUART;
    mySession.hUART = &myUART;
    EXPECT_CALL(mockServer, AdminSession(OP_QUERY, sessionId, nullptr))
        .Times(1)
        .WillOnce(Return(&mySession));
    mockHostUART.GetSession(sessionId, false);
}

/*
 * @tc.name: CloseSerialPort
 * @tc.desc: Check the behavior of the CloseSerialPort function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, CloseSerialPort, TestSize.Level1)
{
    myUART.devUartHandle = -1;
    mockHostUART.CloseSerialPort(&myUART);
    EXPECT_EQ(myUART.devUartHandle, -1);
}

/*
 * @tc.name: GetPortFromKey
 * @tc.desc: Check the behavior of the GetPortFromKey function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, GetPortFromKey, TestSize.Level1)
{
    std::string portName;
    uint32_t baudRate;
    const uint32_t baudRateTest = 111u;
    EXPECT_EQ(mockHostUART.GetPortFromKey("COM1", portName, baudRate), true);
    EXPECT_STREQ(portName.c_str(), "COM1");
    EXPECT_EQ(baudRate, mockHostUART.DEFAULT_BAUD_RATE_VALUE);

    EXPECT_EQ(mockHostUART.GetPortFromKey("COM1,aaa", portName, baudRate), false);

    EXPECT_EQ(mockHostUART.GetPortFromKey("COM1,111", portName, baudRate), true);
    EXPECT_STREQ(portName.c_str(), "COM1");
    EXPECT_EQ(baudRate, baudRateTest);
}

/*
 * @tc.name: Restartession
 * @tc.desc: Check the behavior of the Restartession function
 * successed
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, Restartession, TestSize.Level1)
{
    const uint32_t sessionId = 12345;
    mySession.sessionId = sessionId;
    EXPECT_CALL(mockHostUART, CloseSerialPort(mySession.hUART)).WillOnce(Return());
    EXPECT_CALL(mockServer, EchoToClientsForSession(sessionId, _)).WillOnce(Return());
    mockHostUART.Restartession(&mySession);
}

/*
 * @tc.name: StopSession
 * @tc.desc: Check the behavior of the StopSession function
 * successed
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, StopSession, TestSize.Level1)
{
    EXPECT_EQ(mySession.hUART->ioCancel, false);
    mockHostUART.StopSession(nullptr);
    EXPECT_EQ(mySession.hUART->ioCancel, false);
    mockHostUART.StopSession(&mySession);
    EXPECT_EQ(mySession.hUART->ioCancel, true);
}

/*
 * @tc.name: OnTransferError
 * @tc.desc: Check the behavior of the OnTransferError function
 * @tc.type: FUNC
 */
HWTEST_F(HdcHostUARTTest, OnTransferError, TestSize.Level1)
{
    EXPECT_CALL(mockHostUART, OnTransferError).WillRepeatedly(Invoke([&](const HSession session) {
        return mockHostUART.HdcHostUART::OnTransferError(session);
    }));
    mockHostUART.OnTransferError(nullptr);
    const uint32_t sessionId = mySession.sessionId;

    EXPECT_CALL(mockHostUART, IsDeviceOpened(Ref(*mySession.hUART))).WillOnce(Return(true));
    EXPECT_CALL(mockServer, EchoToClientsForSession(sessionId, _)).WillOnce(Return());
    EXPECT_CALL(mockHostUART, CloseSerialPort(mySession.hUART)).WillOnce(Return());
    EXPECT_CALL(mockHostUART,
                UpdateUARTDaemonInfo(mySession.connectKey, &mySession, STATUS_OFFLINE))
        .WillOnce(Return());
    EXPECT_CALL(mockServer, FreeSession(sessionId)).WillOnce(Return());
    EXPECT_CALL(mockHostUART, ClearUARTOutMap(sessionId)).WillOnce(Return());
    mockHostUART.OnTransferError(&mySession);
}
} // namespace Hdc