Moved TCPBaseTestAccess into an H file so it can be used by other tests in the future.

Author: feasel0

src/transport/raw/TCP.h

@@ -39,6 +39,8 @@
 namespace chip {
 namespace Transport {
 
+template <size_t kActiveConnectionsSize, size_t kPendingPacketSize> class TCPBaseTestAccess;
+
 /** Defines listening parameters for setting up a TCP transport */
 class TcpListenParameters
 {
@@ -181,7 +183,8 @@ class DLL_EXPORT TCPBase : public Base
     void CloseActiveConnections();
 
 private:
-    friend class TCPTestAccess;
+    // Allow tests to access private members.
+    template <size_t kActiveConnectionsSize, size_t kPendingPacketSize> friend class TCPBaseTestAccess;
 
     /**
      * Find an active connection to the given peer or return nullptr if

src/transport/raw/tests/TCPBaseTestAccess.h

@@ -0,0 +1,49 @@
+/*
+ *
+ *    Copyright (c) 2024 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.
+ */
+
+#pragma once
+
+#include <transport/raw/TCP.h>
+
+using namespace chip::Inet;
+
+namespace chip {
+namespace Transport {
+/**
+ * @brief Class acts as an accessor to private members of the TCPBase class without needing to give
+ *        friend access to each individual test.
+ */
+template <size_t kActiveConnectionsSize, size_t kPendingPacketSize>
+class TCPBaseTestAccess
+{
+public:
+    using TCPImpl = Transport::TCP<kActiveConnectionsSize, kPendingPacketSize>;
+
+    static void * FindActiveConnection(TCPImpl & tcp, Transport::PeerAddress & peerAddress)
+    {
+        return tcp.FindActiveConnection(peerAddress);
+    }
+    static TCPEndPoint * GetEndpoint(void * state) { return static_cast<TCPBase::ActiveConnectionState *>(state)->mEndPoint; }
+
+    static CHIP_ERROR ProcessReceivedBuffer(TCPImpl & tcp, TCPEndPoint * endPoint, const PeerAddress & peerAddress,
+                                            System::PacketBufferHandle && buffer)
+    {
+        return tcp.ProcessReceivedBuffer(endPoint, peerAddress, std::move(buffer));
+    }
+};
+} // namespace Transport
+} // namespace chip

src/transport/raw/tests/TestTCP.cpp

@@ -32,6 +32,7 @@
 #include <system/SystemLayer.h>
 #include <transport/TransportMgr.h>
 #include <transport/raw/TCP.h>
+#include <transport/raw/tests/TCPBaseTestAccess.h>
 
 #include <errno.h>
 #include <stdlib.h>
@@ -42,33 +43,14 @@ using namespace chip;
 using namespace chip::Test;
 using namespace chip::Inet;
 
+namespace {
+
 constexpr size_t kMaxTcpActiveConnectionCount = 4;
 constexpr size_t kMaxTcpPendingPackets        = 4;
 constexpr uint16_t kPacketSizeBytes           = static_cast<uint16_t>(sizeof(uint16_t));
 
-using TCPImpl = Transport::TCP<kMaxTcpActiveConnectionCount, kMaxTcpPendingPackets>;
-
-namespace chip {
-namespace Transport {
-class TCPTestAccess
-{
-public:
-    static void * FindActiveConnection(TCPImpl & tcp, Transport::PeerAddress & lPeerAddress)
-    {
-        return tcp.FindActiveConnection(lPeerAddress);
-    }
-    static TCPEndPoint * GetEndpoint(void * state) { return static_cast<TCPBase::ActiveConnectionState *>(state)->mEndPoint; }
-
-    static CHIP_ERROR ProcessReceivedBuffer(TCPImpl & tcp, TCPEndPoint * endPoint, const PeerAddress & peerAddress,
-                                            System::PacketBufferHandle && buffer)
-    {
-        return tcp.ProcessReceivedBuffer(endPoint, peerAddress, std::move(buffer));
-    }
-};
-} // namespace Transport
-} // namespace chip
-
-namespace {
+using TCPImpl    = Transport::TCP<kMaxTcpActiveConnectionCount, kMaxTcpPendingPackets>;
+using TestAccess = Transport::TCPBaseTestAccess<kMaxTcpActiveConnectionCount, kMaxTcpPendingPackets>;
 
 constexpr NodeId kSourceNodeId      = 123654;
 constexpr NodeId kDestinationNodeId = 111222333;
@@ -421,9 +403,9 @@ TEST_F(TestTCP, CheckProcessReceivedBuffer)
     gMockTransportMgrDelegate.SingleMessageTest(tcp, addr);
 
     Transport::PeerAddress lPeerAddress = Transport::PeerAddress::TCP(addr);
-    void * state                        = Transport::TCPTestAccess::FindActiveConnection(tcp, lPeerAddress);
+    void * state                        = TestAccess::FindActiveConnection(tcp, lPeerAddress);
     ASSERT_NE(state, nullptr);
-    TCPEndPoint * lEndPoint = Transport::TCPTestAccess::GetEndpoint(state);
+    TCPEndPoint * lEndPoint = TestAccess::GetEndpoint(state);
     ASSERT_NE(lEndPoint, nullptr);
 
     CHIP_ERROR err = CHIP_NO_ERROR;
@@ -433,14 +415,14 @@ TEST_F(TestTCP, CheckProcessReceivedBuffer)
     // Test a single packet buffer.
     gMockTransportMgrDelegate.mReceiveHandlerCallCount = 0;
     EXPECT_TRUE(testData[0].Init((const uint16_t[]){ 111, 0 }));
-    err = Transport::TCPTestAccess::ProcessReceivedBuffer(tcp, lEndPoint, lPeerAddress, std::move(testData[0].mHandle));
+    err = TestAccess::ProcessReceivedBuffer(tcp, lEndPoint, lPeerAddress, std::move(testData[0].mHandle));
     EXPECT_EQ(err, CHIP_NO_ERROR);
     EXPECT_EQ(gMockTransportMgrDelegate.mReceiveHandlerCallCount, 1);
 
     // Test a message in a chain of three packet buffers. The message length is split across buffers.
     gMockTransportMgrDelegate.mReceiveHandlerCallCount = 0;
     EXPECT_TRUE(testData[0].Init((const uint16_t[]){ 1, 122, 123, 0 }));
-    err = Transport::TCPTestAccess::ProcessReceivedBuffer(tcp, lEndPoint, lPeerAddress, std::move(testData[0].mHandle));
+    err = TestAccess::ProcessReceivedBuffer(tcp, lEndPoint, lPeerAddress, std::move(testData[0].mHandle));
     EXPECT_EQ(err, CHIP_NO_ERROR);
     EXPECT_EQ(gMockTransportMgrDelegate.mReceiveHandlerCallCount, 1);
 
@@ -449,7 +431,7 @@ TEST_F(TestTCP, CheckProcessReceivedBuffer)
     EXPECT_TRUE(testData[0].Init((const uint16_t[]){ 131, 0 }));
     EXPECT_TRUE(testData[1].Init((const uint16_t[]){ 132, 0 }));
     testData[0].mHandle->AddToEnd(std::move(testData[1].mHandle));
-    err = Transport::TCPTestAccess::ProcessReceivedBuffer(tcp, lEndPoint, lPeerAddress, std::move(testData[0].mHandle));
+    err = TestAccess::ProcessReceivedBuffer(tcp, lEndPoint, lPeerAddress, std::move(testData[0].mHandle));
     EXPECT_EQ(err, CHIP_NO_ERROR);
     EXPECT_EQ(gMockTransportMgrDelegate.mReceiveHandlerCallCount, 2);
 
@@ -458,7 +440,7 @@ TEST_F(TestTCP, CheckProcessReceivedBuffer)
     EXPECT_TRUE(testData[0].Init((const uint16_t[]){ 141, 142, 0 }));
     EXPECT_TRUE(testData[1].Init((const uint16_t[]){ 143, 144, 0 }));
     testData[0].mHandle->AddToEnd(std::move(testData[1].mHandle));
-    err = Transport::TCPTestAccess::ProcessReceivedBuffer(tcp, lEndPoint, lPeerAddress, std::move(testData[0].mHandle));
+    err = TestAccess::ProcessReceivedBuffer(tcp, lEndPoint, lPeerAddress, std::move(testData[0].mHandle));
     EXPECT_EQ(err, CHIP_NO_ERROR);
     EXPECT_EQ(gMockTransportMgrDelegate.mReceiveHandlerCallCount, 2);
 
@@ -468,7 +450,7 @@ TEST_F(TestTCP, CheckProcessReceivedBuffer)
     EXPECT_TRUE(testData[0].Init((const uint16_t[]){ 51, System::PacketBuffer::kMaxSizeWithoutReserve, 0 }));
     // Sending only the first buffer of the long chain. This should be enough to trigger the error.
     System::PacketBufferHandle head = testData[0].mHandle.PopHead();
-    err = Transport::TCPTestAccess::ProcessReceivedBuffer(tcp, lEndPoint, lPeerAddress, std::move(head));
+    err                             = TestAccess::ProcessReceivedBuffer(tcp, lEndPoint, lPeerAddress, std::move(head));
     EXPECT_EQ(err, CHIP_ERROR_MESSAGE_TOO_LONG);
     EXPECT_EQ(gMockTransportMgrDelegate.mReceiveHandlerCallCount, 0);