Clear the buffer after allocation in the test module

Declare test class as the friend class to access the private functions for testing

Signed-off-by: Lo,Chin-Ran <chin-ran.lo@nxp.com>

Author: crlonxp

src/wifipaf/WiFiPAFEndPoint.h

@@ -55,6 +55,7 @@ class DLL_EXPORT WiFiPAFEndPoint
 {
     friend class WiFiPAFLayer;
     friend class WiFiPAFEndPointPool;
+    friend class TestWiFiPAFLayer;
 
 public:
     typedef uint64_t AlignT;
@@ -88,11 +89,6 @@ class DLL_EXPORT WiFiPAFEndPoint
     WiFiPAFEndPoint()  = default;
     ~WiFiPAFEndPoint() = default;
 
-    void DoClose(uint8_t flags, CHIP_ERROR err);
-    CHIP_ERROR HandleConnectComplete();
-    CHIP_ERROR DriveStandAloneAck();
-    CHIP_ERROR DoSendStandAloneAck();
-
 private:
     CHIP_ERROR _Receive(PacketBufferHandle && data);
     enum class PktDirect_t : uint8_t
@@ -144,17 +140,21 @@ class DLL_EXPORT WiFiPAFEndPoint
     SequenceNumber_t mReceiveWindowMaxSize;
 
     CHIP_ERROR Init(WiFiPAFLayer * WiFiPafLayer, WiFiPAFSession & SessionInfo);
+    void DoClose(uint8_t flags, CHIP_ERROR err);
     bool IsConnected(uint8_t state) const;
 
     // Transmit path:
     CHIP_ERROR DriveSending();
+    CHIP_ERROR DriveStandAloneAck();
     bool PrepareNextFragment(PacketBufferHandle && data, bool & sentAck);
     CHIP_ERROR SendNextMessage();
     CHIP_ERROR ContinueMessageSend();
+    CHIP_ERROR DoSendStandAloneAck();
     CHIP_ERROR SendCharacteristic(PacketBufferHandle && buf);
     CHIP_ERROR SendWrite(PacketBufferHandle && buf);
 
     // Receive path:
+    CHIP_ERROR HandleConnectComplete();
     CHIP_ERROR HandleSendConfirmationReceived(bool result);
     CHIP_ERROR HandleHandshakeConfirmationReceived();
     CHIP_ERROR HandleFragmentConfirmationReceived(bool result);

src/wifipaf/WiFiPAFLayer.h

@@ -160,6 +160,7 @@ enum class PafInfoAccess
 class DLL_EXPORT WiFiPAFLayer
 {
     friend class WiFiPAFEndPoint;
+    friend class TestWiFiPAFLayer;
 
 public:
     State mAppState                          = State::kNotReady;
@@ -188,12 +189,12 @@ class DLL_EXPORT WiFiPAFLayer
     static WiFiPAFTransportProtocolVersion
     GetHighestSupportedProtocolVersion(const PAFTransportCapabilitiesRequestMessage & reqMsg);
 
-    void InitialPafInfo();
     CHIP_ERROR AddPafSession(PafInfoAccess accType, WiFiPAFSession & SessionInfo);
     CHIP_ERROR RmPafSession(PafInfoAccess accType, WiFiPAFSession & SessionInfo);
     WiFiPAFSession * GetPAFInfo(PafInfoAccess accType, WiFiPAFSession & SessionInfo);
 
 private:
+    void InitialPafInfo();
     void CleanPafInfo(WiFiPAFSession & SessionInfo);
     WiFiPAFSession mPafInfoVect[WIFIPAF_LAYER_NUM_PAF_ENDPOINTS];
     chip::System::Layer * mSystemLayer;

src/wifipaf/tests/TestWiFiPAFLayer.cpp

@@ -59,6 +59,7 @@ class TestWiFiPAFLayer : public WiFiPAFLayer, private WiFiPAFLayerDelegate, publ
     {
         ASSERT_EQ(Init(&DeviceLayer::SystemLayer()), CHIP_NO_ERROR);
         mWiFiPAFTransport = this;
+        InitialPafInfo();
     }
 
     void TearDown() override
@@ -70,6 +71,15 @@ class TestWiFiPAFLayer : public WiFiPAFLayer, private WiFiPAFLayerDelegate, publ
     CHIP_ERROR WiFiPAFMessageReceived(WiFiPAFSession & RxInfo, System::PacketBufferHandle && msg) override { return CHIP_NO_ERROR; }
     CHIP_ERROR WiFiPAFMessageSend(WiFiPAFSession & TxInfo, System::PacketBufferHandle && msg) override { return CHIP_NO_ERROR; }
     CHIP_ERROR WiFiPAFCloseSession(WiFiPAFSession & SessionInfo) override { return CHIP_NO_ERROR; }
+    static constexpr size_t kTestPacketLength = 100;
+
+    void SetEndPoint(WiFiPAFEndPoint * pEndPoint) { mEndPoint = pEndPoint; }
+    void EpDoClose(uint8_t flags, CHIP_ERROR err) { return mEndPoint->DoClose(flags, err); }
+    CHIP_ERROR EpDriveStandAloneAck() { return mEndPoint->DriveStandAloneAck(); }
+    CHIP_ERROR EpDoSendStandAloneAck() { return mEndPoint->DoSendStandAloneAck(); }
+
+private:
+    WiFiPAFEndPoint * mEndPoint;
 };
 
 TEST_F(TestWiFiPAFLayer, CheckWiFiPAFTransportCapabilitiesRequestMessage)
@@ -115,7 +125,6 @@ TEST_F(TestWiFiPAFLayer, CheckWiFiPAFTransportCapabilitiesResponseMessage)
 
 TEST_F(TestWiFiPAFLayer, CheckPafSession)
 {
-    InitialPafInfo();
     // Add the 1st session by giving node_id, discriminator
     WiFiPAF::WiFiPAFSession sessionInfo = { .role = kWiFiPafRole_Subscriber, .nodeId = 0x1, .discriminator = 0xF01 };
     EXPECT_EQ(AddPafSession(PafInfoAccess::kAccNodeInfo, sessionInfo), CHIP_NO_ERROR);
@@ -180,6 +189,7 @@ TEST_F(TestWiFiPAFLayer, CheckRunAsCommissioner)
     WiFiPAFEndPoint * newEndPoint = nullptr;
     EXPECT_EQ(NewEndPoint(&newEndPoint, sessionInfo, sessionInfo.role), CHIP_NO_ERROR);
     EXPECT_NE(newEndPoint, nullptr);
+    SetEndPoint(newEndPoint);
     newEndPoint->mState = WiFiPAFEndPoint::kState_Ready;
     SetWiFiPAFState(State::kInitialized);
     EXPECT_EQ(GetWiFiPAFState(), State::kInitialized);
@@ -201,8 +211,9 @@ TEST_F(TestWiFiPAFLayer, CheckRunAsCommissioner)
     EXPECT_EQ(OnWiFiPAFMessageReceived(sessionInfo, std::move(packetCapResp)), true);
 
     // Send a packet
-    auto buf = System::PacketBufferHandle::New(100);
-    buf->SetDataLength(100);
+    auto buf = System::PacketBufferHandle::New(kTestPacketLength);
+    buf->SetDataLength(kTestPacketLength);
+    memset(buf->Start(), 0, buf->DataLength());
     EXPECT_EQ(SendMessage(sessionInfo, std::move(buf)), CHIP_NO_ERROR);
     EXPECT_EQ(HandleWriteConfirmed(sessionInfo, true), CHIP_NO_ERROR);
 
@@ -220,12 +231,12 @@ TEST_F(TestWiFiPAFLayer, CheckRunAsCommissioner)
     EXPECT_EQ(packet_rx->DataLength(), static_cast<size_t>(5));
     EXPECT_EQ(newEndPoint->Receive(std::move(packet_rx)), CHIP_NO_ERROR);
 
-    EXPECT_EQ(newEndPoint->DriveStandAloneAck(), CHIP_NO_ERROR);
-    EXPECT_EQ(newEndPoint->DoSendStandAloneAck(), CHIP_NO_ERROR);
+    EXPECT_EQ(EpDriveStandAloneAck(), CHIP_NO_ERROR);
+    EXPECT_EQ(EpDoSendStandAloneAck(), CHIP_NO_ERROR);
 
     // Close the session
     EXPECT_EQ(RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo), CHIP_NO_ERROR);
-    newEndPoint->DoClose(kWiFiPAFCloseFlag_AbortTransmission, WIFIPAF_ERROR_APP_CLOSED_CONNECTION);
+    EpDoClose(kWiFiPAFCloseFlag_AbortTransmission, WIFIPAF_ERROR_APP_CLOSED_CONNECTION);
 }
 
 TEST_F(TestWiFiPAFLayer, CheckRunAsCommissionee)
@@ -242,6 +253,7 @@ TEST_F(TestWiFiPAFLayer, CheckRunAsCommissionee)
     WiFiPAFEndPoint * newEndPoint = nullptr;
     EXPECT_EQ(NewEndPoint(&newEndPoint, sessionInfo, sessionInfo.role), CHIP_NO_ERROR);
     EXPECT_NE(newEndPoint, nullptr);
+    SetEndPoint(newEndPoint);
     newEndPoint->mState = WiFiPAFEndPoint::kState_Ready;
 
     EXPECT_EQ(newEndPoint->StartConnect(), CHIP_NO_ERROR);
@@ -261,8 +273,9 @@ TEST_F(TestWiFiPAFLayer, CheckRunAsCommissionee)
     EXPECT_EQ(HandleWriteConfirmed(sessionInfo, true), CHIP_NO_ERROR);
 
     // Send a packet
-    auto buf = System::PacketBufferHandle::New(100);
-    buf->SetDataLength(100);
+    auto buf = System::PacketBufferHandle::New(kTestPacketLength);
+    buf->SetDataLength(kTestPacketLength);
+    memset(buf->Start(), 0, buf->DataLength());
     EXPECT_EQ(SendMessage(sessionInfo, std::move(buf)), CHIP_NO_ERROR);
     EXPECT_EQ(HandleWriteConfirmed(sessionInfo, true), CHIP_NO_ERROR);
 
@@ -281,7 +294,7 @@ TEST_F(TestWiFiPAFLayer, CheckRunAsCommissionee)
 
     // Close the session
     EXPECT_EQ(RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo), CHIP_NO_ERROR);
-    newEndPoint->DoClose(kWiFiPAFCloseFlag_AbortTransmission, WIFIPAF_ERROR_APP_CLOSED_CONNECTION);
+    EpDoClose(kWiFiPAFCloseFlag_AbortTransmission, WIFIPAF_ERROR_APP_CLOSED_CONNECTION);
 }
 }; // namespace WiFiPAF
 }; // namespace chip

src/wifipaf/tests/TestWiFiPAFTP.cpp

@@ -87,8 +87,10 @@ TEST_F(TestWiFiPAFTP, CheckLogState)
 
 TEST_F(TestWiFiPAFTP, CheckSendSingle)
 {
-    auto buf = System::PacketBufferHandle::New(100);
-    buf->SetDataLength(100);
+    constexpr size_t kShortPacketLength = 100;
+    auto buf                            = System::PacketBufferHandle::New(kShortPacketLength);
+    buf->SetDataLength(kShortPacketLength);
+    memset(buf->Start(), 0, buf->DataLength());
     mRxNextSeqNum = 1;
     EXPECT_TRUE(HandleCharacteristicSend(buf.Retain(), true));
     EXPECT_EQ(TxState(), kState_Complete);
@@ -98,8 +100,11 @@ TEST_F(TestWiFiPAFTP, CheckSendSingle)
 
 TEST_F(TestWiFiPAFTP, CheckSendMultiple)
 {
-    auto buf = System::PacketBufferHandle::New(500);
-    buf->SetDataLength(500);
+    constexpr size_t kLongPacketLength = 500;
+    auto buf                           = System::PacketBufferHandle::New(kLongPacketLength);
+    ASSERT_FALSE(buf.IsNull());
+    buf->SetDataLength(kLongPacketLength);
+    memset(buf->Start(), 0, buf->DataLength());
     EXPECT_TRUE(HandleCharacteristicSend(buf.Retain(), false));
 
     EXPECT_EQ(TxState(), kState_InProgress);