Replace packet creation macros in tests with cpp functions. (#1928)

* Added RawPacketFactory to replace macros `READ_FILE_AND_CREATE_PACKET` and `READ_FILE_AND_CREATE_PACKET_LINKTYPE`.

* Added example usage.

* Reverted test utils changes.

* Added project pcpp test utils for common utils.

* Added PcppTestUtilities to replace packet load macros.

* Moved default resource provider into PcppTestUtilities.

* Lint

* Fix std::uint8_t to uint8_t.

* Fix explicit ctors.

* Fix includes.

* Fix constness.

* Fix cmake define.

* Fix typo.

* Fix style.

* Simplified readHexResource.

* Removed reserve.

* Removed extra overloads on ResourceProvider.

* Remove BinaryData for now.

* Fixed OS separator.

* Fixed header extensions.

* Lint

* Added documentation.

* Removed unused PacketFactory API.

* Lint

Author: Dimi1010

Tests/CMakeLists.txt

@@ -1,5 +1,6 @@
 if(PCAPPP_BUILD_TESTS)
   add_subdirectory(PcppTestFramework)
+  add_subdirectory(PcppTestUtilities)
   add_subdirectory(Packet++Test)
 
   if(PCAPPP_BUILD_PCAPPP)

Tests/Packet++Test/CMakeLists.txt

@@ -51,7 +51,15 @@ add_executable(
   Utils/TestUtils.cpp
 )
 
-target_link_libraries(Packet++Test PUBLIC memplumber Packet++ PcppTestFramework EndianPortable)
+target_link_libraries(
+  Packet++Test
+  PUBLIC memplumber Packet++ PcppTestUtilities PcppTestFramework EndianPortable
+)
+
+if(WIN32)
+  # Otherwise winsock2.h will get conflict definitions with windows.h
+  target_compile_definitions(Packet++Test PUBLIC WIN32_LEAN_AND_MEAN)
+endif()
 
 if(MSVC)
   # This executable requires getopt.h not available on VStudio

Tests/Packet++Test/Tests/BgpTests.cpp

@@ -10,20 +10,19 @@
 
 PTF_TEST_CASE(BgpLayerParsingTest)
 {
-	timeval time;
-	gettimeofday(&time, nullptr);
+	using pcpp_tests::utils::createPacketFromHexResource;
 
-	READ_FILE_AND_CREATE_PACKET(1, "PacketExamples/Bgp_keepalive.dat");
-	READ_FILE_AND_CREATE_PACKET(2, "PacketExamples/Bgp_open.dat");
-	READ_FILE_AND_CREATE_PACKET(3, "PacketExamples/Bgp_notification.dat");
-	READ_FILE_AND_CREATE_PACKET(4, "PacketExamples/Bgp_notification2.dat");
-	READ_FILE_AND_CREATE_PACKET(5, "PacketExamples/Bgp_route-refresh.dat");
-	READ_FILE_AND_CREATE_PACKET(6, "PacketExamples/Bgp_update1.dat");
-	READ_FILE_AND_CREATE_PACKET(7, "PacketExamples/Bgp_update2.dat");
+	auto rawPacket1 = createPacketFromHexResource("PacketExamples/Bgp_keepalive.dat");
+	auto rawPacket2 = createPacketFromHexResource("PacketExamples/Bgp_open.dat");
+	auto rawPacket3 = createPacketFromHexResource("PacketExamples/Bgp_notification.dat");
+	auto rawPacket4 = createPacketFromHexResource("PacketExamples/Bgp_notification2.dat");
+	auto rawPacket5 = createPacketFromHexResource("PacketExamples/Bgp_route-refresh.dat");
+	auto rawPacket6 = createPacketFromHexResource("PacketExamples/Bgp_update1.dat");
+	auto rawPacket7 = createPacketFromHexResource("PacketExamples/Bgp_update2.dat");
 
 	// parse BGP KEEPALIVE message
 
-	pcpp::Packet bgpKAPacket(&rawPacket1);
+	pcpp::Packet bgpKAPacket(rawPacket1.get());
 
 	PTF_ASSERT_TRUE(bgpKAPacket.isPacketOfType(pcpp::BGP));
 	pcpp::BgpLayer* bgpLayer = bgpKAPacket.getLayerOfType<pcpp::BgpLayer>();
@@ -42,7 +41,7 @@ PTF_TEST_CASE(BgpLayerParsingTest)
 
 	// parse BGP OPEN message
 
-	pcpp::Packet bgpOpenPacket(&rawPacket2);
+	pcpp::Packet bgpOpenPacket(rawPacket2.get());
 
 	PTF_ASSERT_TRUE(bgpOpenPacket.isPacketOfType(pcpp::BGP));
 	bgpLayer = bgpOpenPacket.getLayerOfType<pcpp::BgpLayer>();
@@ -78,7 +77,7 @@ PTF_TEST_CASE(BgpLayerParsingTest)
 
 	// parse BGP NOTIFICATION message
 
-	pcpp::Packet bgpNotificationPacket(&rawPacket3);
+	pcpp::Packet bgpNotificationPacket(rawPacket3.get());
 
 	PTF_ASSERT_TRUE(bgpNotificationPacket.isPacketOfType(pcpp::BGP));
 	pcpp::BgpNotificationMessageLayer* bgpNotificationLayer =
@@ -100,7 +99,7 @@ PTF_TEST_CASE(BgpLayerParsingTest)
 	    "726520696e666f726d6174696f6e2e";
 	PTF_ASSERT_EQUAL(bgpNotificationLayer->getNotificationDataAsHexString(), notificationDataAsHexString);
 
-	pcpp::Packet bgpNotificationNoDataPacket(&rawPacket4);
+	pcpp::Packet bgpNotificationNoDataPacket(rawPacket4.get());
 
 	PTF_ASSERT_TRUE(bgpNotificationNoDataPacket.isPacketOfType(pcpp::BGP));
 	bgpNotificationLayer = bgpNotificationNoDataPacket.getLayerOfType<pcpp::BgpNotificationMessageLayer>();
@@ -111,7 +110,7 @@ PTF_TEST_CASE(BgpLayerParsingTest)
 
 	// parse BGP ROUTE-REFRESH message
 
-	pcpp::Packet bgpRRPacket(&rawPacket5);
+	pcpp::Packet bgpRRPacket(rawPacket5.get());
 
 	PTF_ASSERT_TRUE(bgpRRPacket.isPacketOfType(pcpp::BGP));
 	pcpp::BgpRouteRefreshMessageLayer* bgpRRLayer = bgpRRPacket.getLayerOfType<pcpp::BgpRouteRefreshMessageLayer>();
@@ -124,7 +123,7 @@ PTF_TEST_CASE(BgpLayerParsingTest)
 
 	// parse BGP UPDATE message with Withdrawn Routes
 
-	pcpp::Packet bgpUpdatePacket1(&rawPacket6);
+	pcpp::Packet bgpUpdatePacket1(rawPacket6.get());
 
 	PTF_ASSERT_TRUE(bgpUpdatePacket1.isPacketOfType(pcpp::BGP));
 	pcpp::BgpUpdateMessageLayer* bgpUpdateLayer = bgpUpdatePacket1.getLayerOfType<pcpp::BgpUpdateMessageLayer>();
@@ -156,7 +155,7 @@ PTF_TEST_CASE(BgpLayerParsingTest)
 
 	// parse BGP UPDATE message with Path Attributes
 
-	pcpp::Packet bgpUpdatePacket2(&rawPacket7);
+	pcpp::Packet bgpUpdatePacket2(rawPacket7.get());
 
 	PTF_ASSERT_TRUE(bgpUpdatePacket2.isPacketOfType(pcpp::BGP));
 	bgpUpdateLayer = bgpUpdatePacket2.getLayerOfType<pcpp::BgpUpdateMessageLayer>();

Tests/Packet++Test/Utils/TestUtils.h

@@ -9,6 +9,8 @@
 #include <cstdlib>
 #include <vector>
 
+#include "PacketFactory.h"
+
 namespace pcpp_tests
 {
 

Tests/Packet++Test/main.cpp

@@ -4,6 +4,7 @@
 #include "TestDefinition.h"
 #include "Logger.h"
 #include "../../Tests/Packet++Test/Utils/TestUtils.h"
+#include "Resources.h"
 
 static struct option PacketTestOptions[] = {
 	{ "include-tags",        required_argument, nullptr, 't' },
@@ -76,6 +77,12 @@ int main(int argc, char* argv[])
 	          << "Built: " << pcpp::getBuildDateTime() << std::endl
 	          << "Built from: " << pcpp::getGitInfo() << std::endl;
 
+	std::cout << "Using data root: current directory" << std::endl;
+
+	// Set the resource provider for the tests
+	auto resourceProvider = std::make_unique<pcpp_tests::utils::ResourceProvider>("");
+	pcpp_tests::setDefaultResourceProvider(resourceProvider.get());
+
 #ifdef NDEBUG
 	skipMemLeakCheck = true;
 	std::cout

Tests/PcppTestUtilities/CMakeLists.txt

@@ -0,0 +1,6 @@
+cmake_minimum_required(VERSION 3.12)
+
+add_library(PcppTestUtilities STATIC EXCLUDE_FROM_ALL "PacketFactory.cpp" "Resources.cpp")
+
+target_include_directories(PcppTestUtilities PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/")
+target_link_libraries(PcppTestUtilities PUBLIC Packet++)

Tests/PcppTestUtilities/PacketFactory.cpp

@@ -0,0 +1,79 @@
+#include "PacketFactory.h"
+
+#include <stdexcept>
+
+#include "SystemUtils.h"
+#include "TimespecTimeval.h"
+
+namespace pcpp_tests
+{
+	using namespace pcpp;
+
+	namespace utils
+	{
+		PacketFactory::PacketFactory()
+		{
+			timeval factoryTimeTV;
+			// Initialize factoryTime to the current time
+			gettimeofday(&factoryTimeTV, nullptr);
+			factoryTime = internal::toTimespec(factoryTimeTV);
+		}
+
+		PacketFactory::PacketFactory(timespec time) : factoryTime(time)
+		{}
+
+		PacketFactory::PacketFactory(timeval time) : PacketFactory(internal::toTimespec(time))
+		{}
+
+		PacketFactory::PacketFactory(LinkLayerType linkType) : PacketFactory()
+		{
+			// Call to the default constructor to initialize factoryTime to the current time
+			defaultLinkType = linkType;
+		}
+
+		std::unique_ptr<RawPacket> PacketFactory::createFromBuffer(std::unique_ptr<uint8_t[]> buffer,
+		                                                           size_t bufferLen) const
+		{
+			if (buffer == nullptr || bufferLen == 0)
+			{
+				throw std::invalid_argument("Buffer cannot be null and length must be greater than zero");
+			}
+
+			return std::make_unique<RawPacket>(buffer.release(), static_cast<int>(bufferLen), factoryTime, true,
+			                                   defaultLinkType);
+		}
+
+		std::unique_ptr<RawPacket> PacketFactory::createFromBufferNonOwning(std::vector<uint8_t> const& buffer) const
+		{
+			return createFromBufferNonOwning(buffer.data(), buffer.size());
+		}
+
+		std::unique_ptr<RawPacket> PacketFactory::createFromBufferNonOwning(const uint8_t* buffer,
+		                                                                    size_t bufferLen) const
+		{
+			if (buffer == nullptr || bufferLen == 0)
+			{
+				throw std::invalid_argument("Buffer cannot be null and length must be greater than zero");
+			}
+
+			return std::make_unique<RawPacket>(buffer, static_cast<int>(bufferLen), factoryTime, false,
+			                                   defaultLinkType);
+		}
+
+		std::unique_ptr<pcpp::RawPacket> createPacketFromHexResource(const std::string& resourceName,
+		                                                             const utils::PacketFactory& factory,
+		                                                             utils::ResourceProvider const* resourceProvider)
+		{
+			using pcpp_tests::utils::ResourceType;
+
+			if (resourceProvider == nullptr)
+			{
+				// If no data loader is provided, use the current test environment's data loader
+				resourceProvider = getDefaultResourceProvider();
+			}
+
+			auto resource = resourceProvider->loadResource(resourceName.c_str(), ResourceType::HexData);
+			return factory.createFromBuffer(std::move(resource.data), resource.length);
+		}
+	}  // namespace utils
+}  // namespace pcpp_tests

Tests/PcppTestUtilities/PacketFactory.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "RawPacket.h"
+#include "Resources.h"
+
+namespace pcpp_tests
+{
+	namespace utils
+	{
+		class PacketFactory
+		{
+		public:
+			/// @brief The time used for creating packets in the factory.
+			timespec factoryTime;
+			/// @brief The default link layer type for packets created by this factory.
+			pcpp::LinkLayerType defaultLinkType = pcpp::LinkLayerType::LINKTYPE_ETHERNET;
+
+			/// @brief Creates a new PacketFactory instance with the current time as factoryTime.
+			PacketFactory();
+			/// @brief Creates a new PacketFactory instance with a specified time.
+			/// @param time The time to use for creating packets in the factory.
+			explicit PacketFactory(timespec time);
+			/// @brief Creates a new PacketFactory instance with a specified time.
+			/// @param time The time to use for creating packets in the factory.
+			explicit PacketFactory(timeval time);
+			/// @brief Creates a new PacketFactory instance with a specified link layer type.
+			/// @param linkType The link layer type to use for packets created by this factory.
+			explicit PacketFactory(pcpp::LinkLayerType linkType);
+
+			// TODO: RawPacket requires a move constructor to return by value efficiently.
+			/// @brief Creates a RawPacket from a vector of bytes.
+			/// @param buffer A unique pointer to a buffer containing the raw packet data.
+			/// @param bufferLen The length of the buffer in bytes.
+			/// @return A RawPacket object created from the buffer.
+			std::unique_ptr<pcpp::RawPacket> createFromBuffer(std::unique_ptr<uint8_t[]> buffer,
+			                                                  size_t bufferLen) const;
+
+			/// @brief Creates a RawPacket from a vector of bytes without taking ownership of the data.
+			/// @param buffer A vector containing the raw packet data.
+			/// @return A RawPacket object created from the buffer.
+			std::unique_ptr<pcpp::RawPacket> createFromBufferNonOwning(std::vector<uint8_t> const& buffer) const;
+
+			/// @brief Creates a RawPacket from a buffer without taking ownership of the data.
+			/// @param buffer A pointer to the raw packet data.
+			/// @param bufferLen The length of the buffer in bytes.
+			/// @return A RawPacket object created from the buffer.
+			std::unique_ptr<pcpp::RawPacket> createFromBufferNonOwning(const uint8_t* buffer, size_t bufferLen) const;
+		};
+
+		/// @brief Creates a RawPacket from a resource file.
+		/// @param resourceName The name of the resource file to read the packet data from.
+		/// @param factory The PacketFactory to use for creating the RawPacket.
+		/// @param resourceProvider An optional ResourceProvider to use for loading the resource file.
+		///   Uses the default resource provider if not provided.
+		/// @return A RawPacket object created from the resource file.
+		std::unique_ptr<pcpp::RawPacket> createPacketFromHexResource(
+		    const std::string& resourceName, const PacketFactory& factory = PacketFactory(),
+		    ResourceProvider const* resourceProvider = nullptr);
+	}  // namespace utils
+}  // namespace pcpp_tests