Lines Matching refs:sessionId

36     bool MakeRndData(std::vector<uint8_t> &data, uint32_t sessionId);

37     bool MakeDemoData(std::vector<uint8_t> &data, uint32_t sessionId);

119     server->sessionId = SERVER_ID;

125     daemon->sessionId = DAEMON_SESSION_ID;

133 bool HdcUARTBaseTest::MakeRndData(std::vector<uint8_t> &data, uint32_t sessionId)

137     head.sessionId = sessionId;

149 bool HdcUARTBaseTest::MakeDemoData(std::vector<uint8_t> &data, uint32_t sessionId)

153     head.sessionId = sessionId;

201     EXPECT_CALL(mockUARTBase, ResetOldSession).WillRepeatedly([&](uint32_t sessionId) {

202         mockUARTBase.HdcUARTBase::ResetOldSession(sessionId);

204     const uint32_t sessionId = 12345;

205     EXPECT_CALL(mockUARTBase, ResetOldSession(sessionId)).Times(1);

206     mockUARTBase.ResetOldSession(sessionId);

217         .WillRepeatedly([&](HSession hUART, uint32_t sessionId) {

218             mockUARTBase.HdcUARTBase::SendUartSoftReset(hUART, sessionId);

221     uint32_t sessionId = 1234567980;

222     EXPECT_CALL(mockUARTBase, SendUartSoftReset(hSession, sessionId)).Times(1);

223     mockUARTBase.SendUartSoftReset(hSession, sessionId);

234     MakeRndData(sourceData, server->sessionId);

259                 // sessionId always should this one

260                 ASSERT_EQ(pUARTHead->sessionId, server->sessionId);

294     MakeRndData(data, server->sessionId);

341     ASSERT_TRUE(MakeDemoData(data, server->sessionId));

376     ASSERT_TRUE(MakeDemoData(data, server->sessionId));

380     uint32_t diffSessionId = server->sessionId + 1;

384     EXPECT_CALL(mockUARTBase, SendUartSoftReset(server.get(), server->sessionId)).Times(0);

393     EXPECT_CALL(mockUARTBase, SendUartSoftReset(daemon.get(), server->sessionId)).Times(0);

401     // here we use daemonSession_ with server_->sessionId (it's different)

450     hdcSession.sessionId = testSessionId;

522     uint32_t sessionId = 0;

532     testHead.sessionId = sessionIdTest;

544     EXPECT_EQ(mockUARTBase.ValidateUartPacket(buffer, sessionId, packageIndex, pkgLenth),

551     EXPECT_EQ(mockUARTBase.ValidateUartPacket(buffer, sessionId, packageIndex, pkgLenth),

558     EXPECT_EQ(mockUARTBase.ValidateUartPacket(buffer, sessionId, packageIndex, pkgLenth),

560     EXPECT_EQ(sessionId, testHead.sessionId);

568     EXPECT_EQ(mockUARTBase.ValidateUartPacket(buffer, sessionId, packageIndex, pkgLenth),

576     EXPECT_EQ(mockUARTBase.ValidateUartPacket(buffer, sessionId, packageIndex, pkgLenth),

584     EXPECT_EQ(mockUARTBase.ValidateUartPacket(buffer, sessionId, packageIndex, pkgLenth),

586     EXPECT_EQ(sessionId, testHead.sessionId);

597     EXPECT_EQ(mockUARTBase.ValidateUartPacket(buffer, sessionId, packageIndex, pkgLenth),

607     EXPECT_EQ(mockUARTBase.ValidateUartPacket(buffer, sessionId, packageIndex, pkgLenth),

674     const uint32_t sessionId = 12345;

678     head.sessionId = sessionId;

692     const uint32_t sessionId = 12345;

693     HdcUARTBase::HandleOutputPkg testPackage("key", sessionId, nullptr, 0);

755     const uint32_t sessionId = 12345;

757     slot.Free(sessionId);

758     EXPECT_THAT(slot.hasWaitPkg, Not(Contains(sessionId)));

759     slot.Wait(sessionId);

760     EXPECT_THAT(slot.hasWaitPkg, Contains(sessionId));

762     EXPECT_THAT(slot.hasWaitPkg, Contains(sessionId));

795     const uint32_t sessionId = 12345;

797     session.sessionId = sessionId;

798     EXPECT_CALL(mockUARTBase, ClearUARTOutMap(sessionId)).WillOnce(Return());

799     EXPECT_CALL(mockSessionBase, FreeSession(sessionId)).WillOnce(Return());

815     const uint32_t sessionId = 12345;

817     session.sessionId = sessionId;

818     EXPECT_CALL(mockUARTBase, ClearUARTOutMap(sessionId)).WillOnce(Return());

832         .WillRepeatedly([&](uint32_t sessionId, uint32_t packageIndex, UartProtocolOption option) {

833             return mockUARTBase.HdcUARTBase::ResponseUartTrans(sessionId, packageIndex, option);

835     const uint32_t sessionId = 12345;

838     mockUARTBase.ResponseUartTrans(sessionId, packageIndex, PKG_OPTION_FREE);