Add more unit-test cases

crlonxp · crlonxp · commit e4b076bbb86b · 2025-03-18T12:22:00.000+01:00
Signed-off-by: Lo,Chin-Ran &lt;chin-ran.lo@nxp.com&gt;
diff --git a/src/wifipaf/WiFiPAFEndPoint.h b/src/wifipaf/WiFiPAFEndPoint.h
@@ -88,6 +88,11 @@ 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
@@ -140,20 +145,16 @@ class DLL_EXPORT WiFiPAFEndPoint
 
     CHIP_ERROR Init(WiFiPAFLayer * WiFiPafLayer, WiFiPAFSession & SessionInfo);
     bool IsConnected(uint8_t state) const;
-    void DoClose(uint8_t flags, CHIP_ERROR err);
 
     // 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);
diff --git a/src/wifipaf/WiFiPAFLayer.h b/src/wifipaf/WiFiPAFLayer.h
@@ -188,12 +188,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;
diff --git a/src/wifipaf/tests/BUILD.gn b/src/wifipaf/tests/BUILD.gn
@@ -23,6 +23,7 @@ chip_test_suite("tests") {
   test_sources = [
     "TestWiFiPAFErrorStr.cpp",
     "TestWiFiPAFLayer.cpp",
+    "TestWiFiPAFTP.cpp",
   ]
 
   cflags = [ "-Wconversion" ]
diff --git a/src/wifipaf/tests/TestWiFiPAFLayer.cpp b/src/wifipaf/tests/TestWiFiPAFLayer.cpp
@@ -33,6 +33,7 @@
 #include <system/SystemLayer.h>
 #include <system/SystemPacketBuffer.h>
 
+#include <wifipaf/WiFiPAFError.h>
 #include <wifipaf/WiFiPAFLayer.h>
 #include <wifipaf/WiFiPAFLayerDelegate.h>
 
@@ -114,10 +115,9 @@ TEST_F(TestWiFiPAFLayer, CheckWiFiPAFTransportCapabilitiesResponseMessage)
 
 TEST_F(TestWiFiPAFLayer, CheckPafSession)
 {
+    InitialPafInfo();
     // Add the 1st session by giving node_id, discriminator
-    WiFiPAF::WiFiPAFSession sessionInfo = { .role          = WiFiPAF::WiFiPafRole::kWiFiPafRole_Subscriber,
-                                            .nodeId        = 0x1,
-                                            .discriminator = 0xF01 };
+    WiFiPAF::WiFiPAFSession sessionInfo = { .role = kWiFiPafRole_Subscriber, .nodeId = 0x1, .discriminator = 0xF01 };
     EXPECT_EQ(AddPafSession(PafInfoAccess::kAccNodeInfo, sessionInfo), CHIP_NO_ERROR);
 
     // Add the 2nd session
@@ -161,11 +161,14 @@ TEST_F(TestWiFiPAFLayer, CheckPafSession)
     EXPECT_EQ(RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo), CHIP_NO_ERROR);
     sessionInfo.id = 0x2;
     EXPECT_EQ(RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo), CHIP_NO_ERROR);
+
+    EXPECT_EQ(RmPafSession(PafInfoAccess::kAccNodeInfo, sessionInfo), CHIP_ERROR_NOT_IMPLEMENTED);
+    EXPECT_EQ(RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo), CHIP_ERROR_NOT_FOUND);
 }
 
-TEST_F(TestWiFiPAFLayer, CheckNewEndpoint)
+TEST_F(TestWiFiPAFLayer, CheckRunAsCommissioner)
 {
-    WiFiPAFSession SessionInfo = {
+    WiFiPAFSession sessionInfo = {
         .role          = kWiFiPafRole_Subscriber,
         .id            = 1,
         .peer_id       = 1,
@@ -175,8 +178,110 @@ TEST_F(TestWiFiPAFLayer, CheckNewEndpoint)
     };
 
     WiFiPAFEndPoint * newEndPoint = nullptr;
-    EXPECT_EQ(NewEndPoint(&newEndPoint, SessionInfo, SessionInfo.role), CHIP_NO_ERROR);
+    EXPECT_EQ(NewEndPoint(&newEndPoint, sessionInfo, sessionInfo.role), CHIP_NO_ERROR);
+    EXPECT_NE(newEndPoint, nullptr);
+    newEndPoint->mState = WiFiPAFEndPoint::kState_Ready;
+    SetWiFiPAFState(State::kInitialized);
+    EXPECT_EQ(GetWiFiPAFState(), State::kInitialized);
+
+    EXPECT_EQ(newEndPoint->StartConnect(), CHIP_NO_ERROR);
+    EXPECT_EQ(AddPafSession(PafInfoAccess::kAccSessionId, sessionInfo), CHIP_NO_ERROR);
+    newEndPoint->mState = WiFiPAFEndPoint::kState_Connected;
+
+    // Send the capability request packet
+    constexpr uint8_t bufCapReq[] = { 0x65, 0x6c, 0x04, 0x00, 0x00, 0x00, 0x5e, 0x01, 0x06 };
+    auto packetCapReq             = System::PacketBufferHandle::NewWithData(bufCapReq, sizeof(bufCapReq));
+    EXPECT_EQ(SendMessage(sessionInfo, std::move(packetCapReq)), CHIP_NO_ERROR);
+    EXPECT_EQ(HandleWriteConfirmed(sessionInfo, true), CHIP_NO_ERROR);
+
+    // Receive the capability response packet
+    constexpr uint8_t bufCapResp[] = { 0x65, 0x6c, 0x04, 0x5b, 0x01, 0x06 };
+    auto packetCapResp             = System::PacketBufferHandle::NewWithData(bufCapResp, sizeof(bufCapResp));
+    newEndPoint->mState            = WiFiPAFEndPoint::kState_Connecting;
+    EXPECT_EQ(OnWiFiPAFMessageReceived(sessionInfo, std::move(packetCapResp)), true);
+
+    // Send a packet
+    auto buf = System::PacketBufferHandle::New(100);
+    buf->SetDataLength(100);
+    EXPECT_EQ(SendMessage(sessionInfo, std::move(buf)), CHIP_NO_ERROR);
+    EXPECT_EQ(HandleWriteConfirmed(sessionInfo, true), CHIP_NO_ERROR);
+
+    constexpr uint8_t buf_rx[] = {
+        to_underlying(WiFiPAFTP::HeaderFlags::kStartMessage) | to_underlying(WiFiPAFTP::HeaderFlags::kEndMessage) |
+            to_underlying(WiFiPAFTP::HeaderFlags::kFragmentAck),
+        0x01,
+        0x01,
+        0x00,
+        0x00, // payload
+    };
+
+    // Receive a pcaket
+    auto packet_rx = System::PacketBufferHandle::NewWithData(buf_rx, sizeof(buf_rx));
+    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);
+
+    // Close the session
+    EXPECT_EQ(RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo), CHIP_NO_ERROR);
+    newEndPoint->DoClose(kWiFiPAFCloseFlag_AbortTransmission, WIFIPAF_ERROR_APP_CLOSED_CONNECTION);
+}
+
+TEST_F(TestWiFiPAFLayer, CheckRunAsCommissionee)
+{
+    WiFiPAFSession sessionInfo = {
+        .role          = kWiFiPafRole_Publisher,
+        .id            = 1,
+        .peer_id       = 1,
+        .peer_addr     = { 0xd0, 0x17, 0x69, 0xee, 0x7f, 0x3c },
+        .nodeId        = 1,
+        .discriminator = 0xF00,
+    };
+
+    WiFiPAFEndPoint * newEndPoint = nullptr;
+    EXPECT_EQ(NewEndPoint(&newEndPoint, sessionInfo, sessionInfo.role), CHIP_NO_ERROR);
     EXPECT_NE(newEndPoint, nullptr);
+    newEndPoint->mState = WiFiPAFEndPoint::kState_Ready;
+
+    EXPECT_EQ(newEndPoint->StartConnect(), CHIP_NO_ERROR);
+    EXPECT_EQ(AddPafSession(PafInfoAccess::kAccSessionId, sessionInfo), CHIP_NO_ERROR);
+
+    newEndPoint->mState = WiFiPAFEndPoint::kState_Ready;
+
+    // Receive the Capability_Request packet
+    constexpr uint8_t bufCapReq[] = { 0x65, 0x6c, 0x04, 0x00, 0x00, 0x00, 0x5e, 0x01, 0x06 };
+    auto packetCapReq             = System::PacketBufferHandle::NewWithData(bufCapReq, sizeof(bufCapReq));
+    EXPECT_EQ(OnWiFiPAFMessageReceived(sessionInfo, std::move(packetCapReq)), true);
+
+    // Reply the Capability Response packet
+    constexpr uint8_t bufCapResp[] = { 0x65, 0x6c, 0x04, 0x5b, 0x01, 0x06 };
+    auto packetCapResp             = System::PacketBufferHandle::NewWithData(bufCapResp, sizeof(bufCapResp));
+    EXPECT_EQ(SendMessage(sessionInfo, std::move(packetCapResp)), CHIP_NO_ERROR);
+    EXPECT_EQ(HandleWriteConfirmed(sessionInfo, true), CHIP_NO_ERROR);
+
+    // Send a packet
+    auto buf = System::PacketBufferHandle::New(100);
+    buf->SetDataLength(100);
+    EXPECT_EQ(SendMessage(sessionInfo, std::move(buf)), CHIP_NO_ERROR);
+    EXPECT_EQ(HandleWriteConfirmed(sessionInfo, true), CHIP_NO_ERROR);
+
+    // Receive a packet
+    constexpr uint8_t buf_rx[] = {
+        to_underlying(WiFiPAFTP::HeaderFlags::kStartMessage) | to_underlying(WiFiPAFTP::HeaderFlags::kEndMessage) |
+            to_underlying(WiFiPAFTP::HeaderFlags::kFragmentAck),
+        0x01,
+        0x01,
+        0x00,
+        0x00, // payload
+    };
+    auto packet_rx = System::PacketBufferHandle::NewWithData(buf_rx, sizeof(buf_rx));
+    EXPECT_EQ(packet_rx->DataLength(), static_cast<size_t>(5));
+    EXPECT_EQ(newEndPoint->Receive(std::move(packet_rx)), CHIP_NO_ERROR);
+
+    // Close the session
+    EXPECT_EQ(RmPafSession(PafInfoAccess::kAccSessionId, sessionInfo), CHIP_NO_ERROR);
+    newEndPoint->DoClose(kWiFiPAFCloseFlag_AbortTransmission, WIFIPAF_ERROR_APP_CLOSED_CONNECTION);
 }
 }; // namespace WiFiPAF
 }; // namespace chip
diff --git a/src/wifipaf/tests/TestWiFiPAFTP.cpp b/src/wifipaf/tests/TestWiFiPAFTP.cpp
@@ -0,0 +1,180 @@
+/*
+ *
+ *    Copyright (c) 2025 Project CHIP Authors
+ *
+ *    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 <cstdint>
+#include <cstring>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include <pw_unit_test/framework.h>
+
+#include <lib/core/CHIPError.h>
+#include <lib/core/StringBuilderAdapters.h>
+#include <lib/support/CHIPMem.h>
+#include <lib/support/Span.h>
+#include <lib/support/TypeTraits.h>
+#include <lib/support/logging/CHIPLogging.h>
+#include <platform/CHIPDeviceLayer.h>
+#include <system/SystemLayer.h>
+#include <system/SystemPacketBuffer.h>
+
+#include <wifipaf/WiFiPAFTP.h>
+
+namespace chip {
+namespace WiFiPAF {
+
+class TestWiFiPAFTP : public WiFiPAFTP, public ::testing::Test
+{
+public:
+    static void SetUpTestSuite()
+    {
+        ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR);
+        ASSERT_EQ(DeviceLayer::SystemLayer().Init(), CHIP_NO_ERROR);
+    }
+
+    static void TearDownTestSuite()
+    {
+        DeviceLayer::SystemLayer().Shutdown();
+        chip::Platform::MemoryShutdown();
+    }
+
+    void SetUp() override { ASSERT_EQ(Init(nullptr, false), CHIP_NO_ERROR); }
+
+    void TearDown() override {}
+};
+
+TEST_F(TestWiFiPAFTP, CheckLogState)
+{
+    LogState();
+    TakeTxPacket();
+    TakeRxPacket();
+
+    PacketBufferHandle AckToSend = System::PacketBufferHandle::New(kTransferProtocolStandaloneAckHeaderSize);
+    EXPECT_EQ(EncodeStandAloneAck(AckToSend), CHIP_NO_ERROR);
+
+    EXPECT_NE(GetAndIncrementNextTxSeqNum(), 0);
+    EXPECT_NE(GetAndRecordRxAckSeqNum(), 0);
+    HasUnackedData();
+
+    uint16_t FragSize = 300;
+    SetTxFragmentSize(FragSize);
+    SetRxFragmentSize(FragSize);
+    EXPECT_EQ(GetTxFragmentSize(), FragSize);
+    EXPECT_EQ(GetRxFragmentSize(), FragSize);
+
+    EXPECT_NE(GetRxNextSeqNum(), 0);
+    EXPECT_NE(GetLastReceivedSequenceNumber(), 0);
+    EXPECT_NE(GetNewestUnackedSentSequenceNumber(), 0);
+    EXPECT_EQ(ExpectingAck(), true);
+    ClearRxPacket();
+    ClearTxPacket();
+}
+
+TEST_F(TestWiFiPAFTP, CheckSendSingle)
+{
+    auto buf = System::PacketBufferHandle::New(100);
+    buf->SetDataLength(100);
+    mRxNextSeqNum = 1;
+    EXPECT_TRUE(HandleCharacteristicSend(buf.Retain(), true));
+    EXPECT_EQ(TxState(), kState_Complete);
+    TakeTxPacket();
+    EXPECT_EQ(TxState(), kState_Idle);
+}
+
+TEST_F(TestWiFiPAFTP, CheckSendMultiple)
+{
+    auto buf = System::PacketBufferHandle::New(500);
+    buf->SetDataLength(500);
+    EXPECT_TRUE(HandleCharacteristicSend(buf.Retain(), false));
+
+    EXPECT_EQ(TxState(), kState_InProgress);
+    EXPECT_TRUE(HandleCharacteristicSend(nullptr, false));
+    EXPECT_EQ(TxState(), kState_Complete);
+    TakeTxPacket();
+    EXPECT_EQ(TxState(), kState_Idle);
+}
+
+TEST_F(TestWiFiPAFTP, CheckRecv)
+{
+    SequenceNumber_t receivedAck = 0;
+    bool didReceiveAck           = false;
+
+    // Receive a packet
+    constexpr uint8_t packetData0[] = {
+        to_underlying(HeaderFlags::kStartMessage) | to_underlying(HeaderFlags::kEndMessage),
+        0x01,
+        0x01,
+        0x00,
+        0xff, // payload
+    };
+
+    auto packet0 = System::PacketBufferHandle::NewWithData(packetData0, sizeof(packetData0));
+    EXPECT_EQ(packet0->DataLength(), static_cast<size_t>(5));
+
+    receivedAck   = 0;
+    didReceiveAck = false;
+    EXPECT_EQ(HandleCharacteristicReceived(std::move(packet0), receivedAck, didReceiveAck), CHIP_NO_ERROR);
+    EXPECT_EQ(RxState(), kState_Complete);
+    TakeRxPacket();
+    EXPECT_EQ(RxState(), kState_Idle);
+}
+
+TEST_F(TestWiFiPAFTP, CheckAckRecv)
+{
+    constexpr uint8_t packetData0[] = {
+        to_underlying(HeaderFlags::kStartMessage) | to_underlying(HeaderFlags::kEndMessage) |
+            to_underlying(HeaderFlags::kFragmentAck),
+        0x01,
+        0x01,
+        0x00,
+        0x00, // payload
+    };
+
+    auto packet0 = System::PacketBufferHandle::NewWithData(packetData0, sizeof(packetData0));
+
+    EXPECT_EQ(packet0->DataLength(), static_cast<size_t>(5));
+
+    SequenceNumber_t receivedAck = 0;
+    bool didReceiveAck           = true;
+    mExpectingAck                = true;
+    EXPECT_EQ(HandleCharacteristicReceived(std::move(packet0), receivedAck, didReceiveAck), CHIP_NO_ERROR);
+    EXPECT_EQ(RxState(), kState_Idle);
+}
+
+TEST_F(TestWiFiPAFTP, CheckErrorRecv)
+{
+    SequenceNumber_t receivedAck = 0;
+    bool didReceiveAck           = false;
+
+    // Null-buffer
+    auto nullbuf = System::PacketBufferHandle::New(0);
+    EXPECT_NE(HandleCharacteristicReceived(std::move(nullbuf), receivedAck, didReceiveAck), CHIP_NO_ERROR);
+
+    // Reveived Invalid packet
+    constexpr uint8_t packetData_invalid_ack[] = {
+        to_underlying(HeaderFlags::kFragmentAck) | to_underlying(HeaderFlags::kEndMessage),
+        0xf0,
+        0x01,
+        0x00,
+        0xff, // payload
+    };
+    auto packet_invalid_ack = System::PacketBufferHandle::NewWithData(packetData_invalid_ack, sizeof(packetData_invalid_ack));
+    EXPECT_EQ(HandleCharacteristicReceived(std::move(packet_invalid_ack), receivedAck, didReceiveAck), CHIP_NO_ERROR);
+}
+}; // namespace WiFiPAF
+}; // namespace chip

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ chip_test_suite("tests") {`
`23`	`23`	`test_sources = [`
`24`	`24`	`"TestWiFiPAFErrorStr.cpp",`
`25`	`25`	`"TestWiFiPAFLayer.cpp",`
	`26`	`+ "TestWiFiPAFTP.cpp",`
`26`	`27`	`]`
`27`	`28`
`28`	`29`	`cflags = [ "-Wconversion" ]`