host_uart_test.cpp - OpenGrok cross reference for /developtools/hdc/test/unittest/common/host_uart

Lines Matching refs:mockHostUART
92     } mockHostUART;

99     HdcHostUARTTest() : mockHostUART(mockServer, mockInterface)

104         mySession.classModule = &mockHostUART;

123     EXPECT_CALL(mockHostUART, Stop).Times(AnyNumber());

172     EXPECT_CALL(mockHostUART, StartupUARTWork).Times(1);

173     EXPECT_EQ(mockHostUART.Initial(), 0);

174     EXPECT_EQ(mockHostUART.uartOpened, false);

175     EXPECT_EQ(mockHostUART.stopped, false);

185     ON_CALL(mockHostUART, Stop).WillByDefault(Invoke([&]() {

186         return mockHostUART.HdcHostUART::Stop();

188     EXPECT_CALL(mockHostUART, Stop).Times(1);

191         TryCloseHandle(reinterpret_cast<uv_handle_t *>(&mockHostUART.devUartWatcher), nullptr))

193     mockHostUART.Stop();

196     EXPECT_CALL(mockHostUART, Stop).Times(1);

198     mockHostUART.Stop();

208     mockHostUART.uartOpened = true;

210     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo(mySession.connectKey, &mySession, STATUS_READY))

212     EXPECT_CALL(mockHostUART, StartUartReadThread(&mySession)).Times(1).WillOnce(Return(true));

221     EXPECT_EQ(mockHostUART.ConnectDaemonByUart(&mySession), &mySession);

224     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo(mySession.connectKey, &mySession, STATUS_READY))

226     EXPECT_CALL(mockHostUART, StartUartReadThread(&mySession)).Times(1).WillOnce(Return(true));

240     EXPECT_EQ(mockHostUART.ConnectDaemonByUart(&mySession), &mySession);

251     mockHostUART.uartOpened = false;

252     EXPECT_EQ(mockHostUART.ConnectDaemonByUart(&mySession), nullptr);

254     mockHostUART.uartOpened = true;

255     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo(mySession.connectKey, &mySession, STATUS_READY))

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

258     EXPECT_EQ(mockHostUART.ConnectDaemonByUart(&mySession), nullptr);

268     EXPECT_CALL(mockHostUART, WatchUartDevPlugin).Times(0);

271     EXPECT_CALL(mockHostUART, WatchUartDevPlugin()).Times(1);

273     handle.data = &mockHostUART;

287     EXPECT_CALL(mockHostUART, WatchUartDevPlugin).WillRepeatedly([&]() {

288         mockHostUART.HdcHostUART::WatchUartDevPlugin();

291     EXPECT_CALL(mockHostUART, EnumSerialPort).WillOnce(Return(false));

293     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo).Times(0);

294     mockHostUART.WatchUartDevPlugin();

297     EXPECT_CALL(mockHostUART, EnumSerialPort)

300     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo).Times(0);

301     mockHostUART.WatchUartDevPlugin();

311     EXPECT_CALL(mockHostUART, WatchUartDevPlugin).WillRepeatedly([&]() {

312         mockHostUART.HdcHostUART::WatchUartDevPlugin();

317     EXPECT_CALL(mockHostUART, EnumSerialPort).WillOnce(DoAll(SetArgReferee<0>(true), Return(true)));

318     mockHostUART.serialPortInfo.clear();

319     mockHostUART.serialPortInfo.emplace_back("COMX");

320     mockHostUART.serialPortInfo.emplace_back("COMY");

321     mockHostUART.connectedPorts.clear();

322     mockHostUART.connectedPorts.emplace("COMY");

325     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo("COMX", nullptr, STATUS_READY)).Times(1);

328     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo("COMY", nullptr, STATUS_READY)).Times(0);

329     mockHostUART.WatchUartDevPlugin();

339     EXPECT_CALL(mockHostUART, WatchUartDevPlugin).WillRepeatedly([&]() {

340         mockHostUART.HdcHostUART::WatchUartDevPlugin();

345     EXPECT_CALL(mockHostUART, EnumSerialPort).WillOnce(DoAll(SetArgReferee<0>(true), Return(true)));

346     mockHostUART.serialPortInfo.clear();

347     mockHostUART.serialPortInfo.emplace_back("COMX");

348     mockHostUART.serialPortInfo.emplace_back("COMY");

349     mockHostUART.connectedPorts.clear();

350     mockHostUART.connectedPorts.emplace("COMY");

351     mockHostUART.serialPortRemoved.clear();

352     mockHostUART.serialPortRemoved.emplace_back("COMZ");

357     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo("COMX", nullptr, STATUS_READY)).Times(1);

360     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo("COMY", nullptr, STATUS_READY)).Times(0);

363     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo("COMZ", nullptr, STATUS_READY)).Times(0);

364     mockHostUART.WatchUartDevPlugin();

374     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo)

377                 mockHostUART.HdcHostUART::UpdateUARTDaemonInfo(connectKey, hSession, connStatus);

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

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

412     EXPECT_CALL(mockHostUART, StartUartReadThread).WillOnce(Invoke([&](HSession hSession) {

413         return mockHostUART.HdcHostUART::StartUartReadThread(hSession);

416     EXPECT_CALL(mockHostUART, UartReadThread(&mySession)).Times(1);

417     mockHostUART.StartUartReadThread(&mySession);

432     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo(myUART.serialPort, nullptr, STATUS_READY))

434     EXPECT_CALL(mockServer, MallocSession(true, CONN_SERIAL, &mockHostUART, 0))

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

457     EXPECT_CALL(mockHostUART, UpdateUARTDaemonInfo(myUART.serialPort, nullptr, STATUS_READY))

459     EXPECT_CALL(mockServer, MallocSession(true, CONN_SERIAL, &mockHostUART, 0))

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

480     EXPECT_CALL(mockHostUART, StartupUARTWork).WillRepeatedly([&]() {

481         return mockHostUART.HdcHostUART::StartupUARTWork();

483     EXPECT_CALL(mockInterface, UvTimerStart(Field(&uv_timer_t::data, &mockHostUART),

484                                             mockHostUART.UvWatchUartDevPlugin, _, _))

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

490     EXPECT_EQ(mockHostUART.StartupUARTWork(), ERR_GENERIC);

492     EXPECT_CALL(mockInterface, UvTimerStart(Field(&uv_timer_t::data, &mockHostUART),

493                                             mockHostUART.UvWatchUartDevPlugin, _, _))

496     EXPECT_EQ(mockHostUART.StartupUARTWork(), ERR_GENERIC);

518     EXPECT_CALL(mockHostUART,

521     mockHostUART.SendUartSoftReset(&mySession, sessionId);

531     mockHostUART.KickoutZombie(nullptr);

534     mockHostUART.KickoutZombie(&mySession);

538     mockHostUART.KickoutZombie(&mySession);

542     mockHostUART.KickoutZombie(&mySession);

552     EXPECT_CALL(mockHostUART, StartUartSendThread).WillRepeatedly([&]() {

553         return mockHostUART.HdcHostUART::StartUartSendThread();

555     EXPECT_CALL(mockHostUART, UartWriteThread).Times(1);

556     EXPECT_TRUE(mockHostUART.StartUartSendThread());

567     EXPECT_CALL(mockHostUART, NeedStop).WillRepeatedly([&](const HSession hSession) {

568         return mockHostUART.HdcHostUART::NeedStop(hSession);

570     mockHostUART.uartOpened = true;

573     EXPECT_EQ(mockHostUART.NeedStop(&mySession), false);

575     mockHostUART.uartOpened = true;

578     EXPECT_EQ(mockHostUART.NeedStop(&mySession), false);

580     mockHostUART.uartOpened = true;

583     EXPECT_EQ(mockHostUART.NeedStop(&mySession), false);

585     mockHostUART.uartOpened = true;

588     EXPECT_EQ(mockHostUART.NeedStop(&mySession), true);

590     mockHostUART.uartOpened = false;

593     EXPECT_EQ(mockHostUART.NeedStop(&mySession), true);

603     EXPECT_CALL(mockHostUART, IsDeviceOpened).WillRepeatedly([&](const HdcUART &uart) {

604         return mockHostUART.HdcHostUART::IsDeviceOpened(uart);

607     EXPECT_EQ(mockHostUART.IsDeviceOpened(myUART), false);

610     EXPECT_EQ(mockHostUART.IsDeviceOpened(myUART), false);

613     EXPECT_EQ(mockHostUART.IsDeviceOpened(myUART), true);

616     EXPECT_EQ(mockHostUART.IsDeviceOpened(myUART), true);

626     EXPECT_CALL(mockHostUART, UartWriteThread).WillOnce(Invoke([&]() {

627         return mockHostUART.HdcHostUART::UartWriteThread();

630     EXPECT_CALL(mockHostUART, SendPkgInUARTOutMap).Times(0);

631     auto sendThread = std::thread(&HdcHostUART::UartWriteThread, &mockHostUART);

633     EXPECT_CALL(mockHostUART, SendPkgInUARTOutMap).Times(1);

634     mockHostUART.transfer.Request();

636     mockHostUART.stopped = true;

637     mockHostUART.transfer.Request();

648     EXPECT_CALL(mockHostUART, UartReadThread).WillRepeatedly(Invoke([&](HSession hSession) {

649         return mockHostUART.HdcHostUART::UartReadThread(hSession);

653     EXPECT_CALL(mockHostUART, NeedStop).WillOnce(Return(true));

654     auto readThread = std::thread(&HdcHostUART::UartReadThread, &mockHostUART, &mySession);

658     EXPECT_CALL(mockHostUART, NeedStop).WillOnce(Return(false)).WillOnce(Return(true));

659     EXPECT_CALL(mockHostUART, ReadUartDev).WillOnce(Return(-1));

660     EXPECT_CALL(mockHostUART, OnTransferError).Times(1);

661     EXPECT_CALL(mockHostUART, PackageProcess).Times(0);

662     auto readThread2 = std::thread(&HdcHostUART::UartReadThread, &mockHostUART, &mySession);

666     EXPECT_CALL(mockHostUART, NeedStop).WillOnce(Return(false)).WillOnce(Return(true));

667     EXPECT_CALL(mockHostUART, ReadUartDev).WillOnce(Return(0));

668     EXPECT_CALL(mockHostUART, OnTransferError).Times(0);

669     EXPECT_CALL(mockHostUART, PackageProcess).Times(0);

670     auto readThread3 = std::thread(&HdcHostUART::UartReadThread, &mockHostUART, &mySession);

674     EXPECT_CALL(mockHostUART, NeedStop).WillOnce(Return(false)).WillOnce(Return(true));

675     EXPECT_CALL(mockHostUART, ReadUartDev)

680     EXPECT_CALL(mockHostUART, OnTransferError).Times(0);

681     EXPECT_CALL(mockHostUART, PackageProcess).WillOnce(Return(0));

682     auto readThread4 = std::thread(&HdcHostUART::UartReadThread, &mockHostUART, &mySession);

686     EXPECT_CALL(mockHostUART, NeedStop).WillOnce(Return(false)).WillOnce(Return(true));

689     EXPECT_CALL(mockHostUART, ReadUartDev)

694     EXPECT_CALL(mockHostUART, OnTransferError).Times(0);

695     EXPECT_CALL(mockHostUART, PackageProcess).WillOnce(Return(0));

696     auto readThread5 = std::thread(&HdcHostUART::UartReadThread, &mockHostUART, &mySession);

707     EXPECT_CALL(mockHostUART, ReadUartDev(_, 1, Ref(myUART))).WillOnce(Return(0));

708     EXPECT_EQ(mockHostUART.WaitUartIdle(myUART), true);

710     EXPECT_CALL(mockHostUART, ReadUartDev(_, 1, Ref(myUART)))

713     EXPECT_EQ(mockHostUART.WaitUartIdle(myUART), true);

715     EXPECT_CALL(mockHostUART, ReadUartDev(_, 1, Ref(myUART)))

718     EXPECT_EQ(mockHostUART.WaitUartIdle(myUART), false);

729     EXPECT_CALL(mockHostUART, OpenSerialPort(connectKey)).WillOnce(Return(0));

730     EXPECT_EQ(mockHostUART.ConnectDaemon(connectKey), nullptr);

747     mockHostUART.GetSession(sessionId, false);

758     mockHostUART.CloseSerialPort(&myUART);

772     EXPECT_EQ(mockHostUART.GetPortFromKey("COM1", portName, baudRate), true);

774     EXPECT_EQ(baudRate, mockHostUART.DEFAULT_BAUD_RATE_VALUE);

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

778     EXPECT_EQ(mockHostUART.GetPortFromKey("COM1,111", portName, baudRate), true);

793     EXPECT_CALL(mockHostUART, CloseSerialPort(mySession.hUART)).WillOnce(Return());

795     mockHostUART.Restartession(&mySession);

807     mockHostUART.StopSession(nullptr);

809     mockHostUART.StopSession(&mySession);

820     EXPECT_CALL(mockHostUART, OnTransferError).WillRepeatedly(Invoke([&](const HSession session) {

821         return mockHostUART.HdcHostUART::OnTransferError(session);

823     mockHostUART.OnTransferError(nullptr);

826     EXPECT_CALL(mockHostUART, IsDeviceOpened(Ref(*mySession.hUART))).WillOnce(Return(true));

828     EXPECT_CALL(mockHostUART, CloseSerialPort(mySession.hUART)).WillOnce(Return());

829     EXPECT_CALL(mockHostUART,

833     EXPECT_CALL(mockHostUART, ClearUARTOutMap(sessionId)).WillOnce(Return());

834     mockHostUART.OnTransferError(&mySession);