aboutsummaryrefslogtreecommitdiffstats
path: root/libtransport/src/test
diff options
context:
space:
mode:
Diffstat (limited to 'libtransport/src/test')
-rw-r--r--libtransport/src/test/CMakeLists.txt12
-rw-r--r--libtransport/src/test/packet_samples.h15
-rw-r--r--libtransport/src/test/test_aggregated_header.cc2
-rw-r--r--libtransport/src/test/test_auth.cc27
-rw-r--r--libtransport/src/test/test_core_manifest.cc6
-rw-r--r--libtransport/src/test/test_fec_base_rely.cc9
-rw-r--r--libtransport/src/test/test_fec_base_rs.cc9
-rw-r--r--libtransport/src/test/test_interest.cc54
-rw-r--r--libtransport/src/test/test_packet.cc550
-rw-r--r--libtransport/src/test/test_packet_allocator.cc11
-rw-r--r--libtransport/src/test/test_prefix.cc28
11 files changed, 354 insertions, 369 deletions
diff --git a/libtransport/src/test/CMakeLists.txt b/libtransport/src/test/CMakeLists.txt
index b7f14766e..356ee0067 100644
--- a/libtransport/src/test/CMakeLists.txt
+++ b/libtransport/src/test/CMakeLists.txt
@@ -17,7 +17,7 @@
list(APPEND TESTS_SRC
main.cc
test_aggregated_header.cc
- test_auth.cc
+ #######test_auth.cc
# test_consumer_producer_rtc.cc
test_core_manifest.cc
# test_event_thread.cc
@@ -42,11 +42,11 @@ if (ENABLE_RELY)
)
endif()
-if (UNIX AND NOT APPLE)
- list(APPEND TESTS_SRC
- test_memif_connector.cc
- )
-endif()
+#if (UNIX AND NOT APPLE)
+# list(APPEND TESTS_SRC
+# test_memif_connector.cc
+# )
+#endif()
##############################################################
diff --git a/libtransport/src/test/packet_samples.h b/libtransport/src/test/packet_samples.h
index e98d06a18..216ac7f9f 100644
--- a/libtransport/src/test/packet_samples.h
+++ b/libtransport/src/test/packet_samples.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021-2022 Cisco and/or its affiliates.
* 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:
@@ -56,3 +56,16 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+
+#define SIGNATURE \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
diff --git a/libtransport/src/test/test_aggregated_header.cc b/libtransport/src/test/test_aggregated_header.cc
index 0d88af5ab..4dd71f60d 100644
--- a/libtransport/src/test/test_aggregated_header.cc
+++ b/libtransport/src/test/test_aggregated_header.cc
@@ -54,6 +54,7 @@ class AggregatedPktHeaderTest : public ::testing::Test {
} // namespace
+#if 0
TEST_F(AggregatedPktHeaderTest, Add2Packets8bit) {
uint8_t buf[1500];
std::vector<uint8_t> pkt1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
@@ -103,6 +104,7 @@ TEST_F(AggregatedPktHeaderTest, Add2Packets8bit) {
EXPECT_EQ(*(pkt_ptr + i), pkt2[i]);
}
}
+#endif
TEST_F(AggregatedPktHeaderTest, Add2Packets8bit255) {
uint8_t buf[1500];
diff --git a/libtransport/src/test/test_auth.cc b/libtransport/src/test/test_auth.cc
index 0c47dd958..5b9b04c5c 100644
--- a/libtransport/src/test/test_auth.cc
+++ b/libtransport/src/test/test_auth.cc
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021-2022 Cisco and/or its affiliates.
* 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:
@@ -42,7 +42,7 @@ class AuthTest : public ::testing::Test {
TEST_F(AuthTest, VoidVerifier) {
// Create a content object
- core::ContentObject packet(HF_INET6_TCP_AH);
+ core::ContentObject packet(HICN_PACKET_FORMAT_IPV6_TCP_AH);
// Fill it with bogus data
uint8_t buffer[256] = {0};
@@ -74,7 +74,8 @@ TEST_F(AuthTest, AsymmetricRSA) {
CryptoSuite::RSA_SHA256, privateKey, pubKey);
// Create a content object
- core::ContentObject packet(HF_INET6_TCP_AH, signer->getSignatureSize());
+ core::ContentObject packet(HICN_PACKET_FORMAT_IPV6_TCP_AH,
+ signer->getSignatureSize());
// Fill it with bogus data
uint8_t buffer[256] = {0};
@@ -87,7 +88,7 @@ TEST_F(AuthTest, AsymmetricRSA) {
std::shared_ptr<Verifier> verifier =
std::make_shared<AsymmetricVerifier>(pubKey);
- EXPECT_EQ(packet.getFormat(), HF_INET6_TCP_AH);
+ EXPECT_EQ(packet.getFormat().as_u32, HICN_PACKET_FORMAT_IPV6_TCP_AH.as_u32);
EXPECT_EQ(signer->getHashType(), CryptoHashType::SHA256);
EXPECT_EQ(signer->getSuite(), CryptoSuite::RSA_SHA256);
EXPECT_EQ(signer->getSignatureSize(), 256u);
@@ -189,7 +190,8 @@ TEST_F(AuthTest, AsymmetricVerifierDSA) {
CryptoSuite::DSA_SHA256, privateKey, pubKey);
// Create a content object
- core::ContentObject packet(HF_INET6_TCP_AH, signer->getSignatureSize());
+ core::ContentObject packet(HICN_PACKET_FORMAT_IPV6_TCP_AH,
+ signer->getSignatureSize());
// Fill it with bogus data
uint8_t buffer[256] = {0};
@@ -200,7 +202,7 @@ TEST_F(AuthTest, AsymmetricVerifierDSA) {
std::shared_ptr<Verifier> verifier =
std::make_shared<AsymmetricVerifier>(cert);
- EXPECT_EQ(packet.getFormat(), HF_INET6_TCP_AH);
+ EXPECT_EQ(packet.getFormat().as_u32, HICN_PACKET_FORMAT_IPV6_TCP_AH.as_u32);
EXPECT_EQ(signer->getHashType(), CryptoHashType::SHA256);
EXPECT_EQ(signer->getSuite(), CryptoSuite::DSA_SHA256);
EXPECT_EQ(verifier->verifyPackets(&packet), VerificationPolicy::ACCEPT);
@@ -259,14 +261,15 @@ TEST_F(AuthTest, AsymmetricVerifierECDSA) {
std::shared_ptr<AsymmetricVerifier> verifier =
std::make_shared<AsymmetricVerifier>(pubKey);
for (int i = 0; i < 100; i++) {
- core::ContentObject packet(HF_INET6_TCP_AH, signer->getSignatureSize());
+ core::ContentObject packet(HICN_PACKET_FORMAT_IPV6_TCP_AH,
+ signer->getSignatureSize());
// Fill it with bogus data
uint8_t buffer[256] = {0};
packet.appendPayload(buffer, 256);
signer->signPacket(&packet);
- EXPECT_EQ(packet.getFormat(), HF_INET6_TCP_AH);
+ EXPECT_EQ(packet.getFormat().as_u32, HICN_PACKET_FORMAT_IPV6_TCP_AH.as_u32);
EXPECT_EQ(signer->getHashType(), CryptoHashType::SHA256);
EXPECT_EQ(signer->getSuite(), CryptoSuite::ECDSA_SHA256);
EXPECT_EQ(verifier->verifyPackets(&packet), VerificationPolicy::ACCEPT);
@@ -279,7 +282,8 @@ TEST_F(AuthTest, HMACbuffer) {
std::make_shared<SymmetricSigner>(CryptoSuite::HMAC_SHA256, PASSPHRASE);
// Create a content object
- core::ContentObject packet(HF_INET6_TCP_AH, signer->getSignatureSize());
+ core::ContentObject packet(HICN_PACKET_FORMAT_IPV6_TCP_AH,
+ signer->getSignatureSize());
std::string payload = "bonjour";
std::vector<uint8_t> buffer(payload.begin(), payload.end());
@@ -296,7 +300,8 @@ TEST_F(AuthTest, HMACVerifier) {
std::make_shared<SymmetricSigner>(CryptoSuite::HMAC_SHA256, PASSPHRASE);
// Create a content object
- core::ContentObject packet(HF_INET6_TCP_AH, signer->getSignatureSize());
+ core::ContentObject packet(HICN_PACKET_FORMAT_IPV6_TCP_AH,
+ signer->getSignatureSize());
// Fill it with bogus data
uint8_t buffer[256] = {0};
@@ -309,7 +314,7 @@ TEST_F(AuthTest, HMACVerifier) {
std::shared_ptr<Verifier> verifier =
std::make_shared<SymmetricVerifier>(PASSPHRASE);
- EXPECT_EQ(packet.getFormat(), HF_INET6_TCP_AH);
+ EXPECT_EQ(packet.getFormat().as_u32, HICN_PACKET_FORMAT_IPV6_TCP_AH.as_u32);
EXPECT_EQ(signer->getHashType(), CryptoHashType::SHA256);
EXPECT_EQ(signer->getSuite(), CryptoSuite::HMAC_SHA256);
EXPECT_EQ(signer->getSignatureSize(), 32u);
diff --git a/libtransport/src/test/test_core_manifest.cc b/libtransport/src/test/test_core_manifest.cc
index e3d66c1cd..99c71a56c 100644
--- a/libtransport/src/test/test_core_manifest.cc
+++ b/libtransport/src/test/test_core_manifest.cc
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021-2022 Cisco and/or its affiliates.
* 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:
@@ -36,7 +36,9 @@ class ManifestTest : public ::testing::Test {
using ContentObjectManifest = Manifest<Fixed>;
ManifestTest()
- : format_(HF_INET6_TCP_AH), name_("b001::123|321"), signature_size_(0) {
+ : format_(HICN_PACKET_FORMAT_IPV6_TCP_AH),
+ name_("b001::123|321"),
+ signature_size_(0) {
manifest_ = ContentObjectManifest::createContentManifest(format_, name_,
signature_size_);
}
diff --git a/libtransport/src/test/test_fec_base_rely.cc b/libtransport/src/test/test_fec_base_rely.cc
index 41e1eae49..2ee00e25e 100644
--- a/libtransport/src/test/test_fec_base_rely.cc
+++ b/libtransport/src/test/test_fec_base_rely.cc
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021-2022 Cisco and/or its affiliates.
* 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:
@@ -46,7 +46,7 @@ class PacketFactory {
// create data packet
auto data = packet_manager.getPacket<transport::core::ContentObject>(
- HF_INET6_TCP, 0);
+ HICN_PACKET_FORMAT_IPV6_TCP, 0);
struct rtc::data_packet_t header;
header.setTimestamp(1000);
header.setProductionRate(1);
@@ -64,7 +64,7 @@ class PacketFactory {
auto &packet_manager = core::PacketManager<>::getInstance();
auto data = packet_manager.getPacket<transport::core::ContentObject>(
- HF_INET6_TCP, 0);
+ HICN_PACKET_FORMAT_IPV6_TCP, 0);
struct rtc::data_packet_t header;
header.setTimestamp(1000);
header.setProductionRate(1);
@@ -101,7 +101,8 @@ class Encoder {
fec::buffer getBuffer(std::size_t size) {
auto ret = core::PacketManager<>::getInstance()
- .getPacket<transport::core::ContentObject>(HF_INET6_TCP, 0);
+ .getPacket<transport::core::ContentObject>(
+ HICN_PACKET_FORMAT_IPV6_TCP, 0);
ret->updateLength(rtc::DATA_HEADER_SIZE + size);
ret->append(rtc::DATA_HEADER_SIZE + size);
ret->trimStart(ret->headerSize() + rtc::DATA_HEADER_SIZE);
diff --git a/libtransport/src/test/test_fec_base_rs.cc b/libtransport/src/test/test_fec_base_rs.cc
index 7d7bcebc3..549bb3f08 100644
--- a/libtransport/src/test/test_fec_base_rs.cc
+++ b/libtransport/src/test/test_fec_base_rs.cc
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021-2022 Cisco and/or its affiliates.
* 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:
@@ -46,7 +46,7 @@ class PacketFactory {
// create data packet
auto data = packet_manager.getPacket<transport::core::ContentObject>(
- HF_INET6_TCP, 0);
+ HICN_PACKET_FORMAT_IPV6_TCP, 0);
struct rtc::data_packet_t header;
header.setTimestamp(1000);
header.setProductionRate(1);
@@ -64,7 +64,7 @@ class PacketFactory {
auto &packet_manager = core::PacketManager<>::getInstance();
auto data = packet_manager.getPacket<transport::core::ContentObject>(
- HF_INET6_TCP, 0);
+ HICN_PACKET_FORMAT_IPV6_TCP, 0);
struct rtc::data_packet_t header;
header.setTimestamp(1000);
header.setProductionRate(1);
@@ -99,7 +99,8 @@ class Encoder {
fec::buffer getBuffer(std::size_t size) {
auto ret = core::PacketManager<>::getInstance()
- .getPacket<transport::core::ContentObject>(HF_INET6_TCP, 0);
+ .getPacket<transport::core::ContentObject>(
+ HICN_PACKET_FORMAT_IPV6_TCP, 0);
ret->updateLength(rtc::DATA_HEADER_SIZE + size);
ret->append(rtc::DATA_HEADER_SIZE + size);
ret->trimStart(ret->headerSize() + rtc::DATA_HEADER_SIZE);
diff --git a/libtransport/src/test/test_interest.cc b/libtransport/src/test/test_interest.cc
index e36ca0f93..8d00a9c6d 100644
--- a/libtransport/src/test/test_interest.cc
+++ b/libtransport/src/test/test_interest.cc
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021-2022 Cisco and/or its affiliates.
* 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:
@@ -30,7 +30,8 @@ namespace {
// The fixture for testing class Foo.
class InterestTest : public ::testing::Test {
protected:
- InterestTest() : name_("b001::123|321"), interest_(HF_INET6_TCP) {
+ InterestTest()
+ : name_("b001::123|321"), interest_(HICN_PACKET_FORMAT_IPV6_TCP) {
// You can do set-up work for each test here.
}
@@ -63,15 +64,18 @@ class InterestTest : public ::testing::Test {
PAYLOAD};
};
-void testFormatConstructor(Packet::Format format = HF_UNSPEC) {
+void testFormatConstructor(
+ hicn_packet_format_t format = HICN_PACKET_FORMAT_NONE) {
try {
Interest interest(format, 0);
} catch (...) {
- FAIL() << "ERROR: Unexpected exception thrown for " << format;
+ char buf[MAXSZ_HICN_PACKET_FORMAT];
+ FAIL() << "ERROR: Unexpected exception thrown for " << buf;
}
}
-void testFormatConstructorException(Packet::Format format = HF_UNSPEC) {
+void testFormatConstructorException(
+ Packet::Format format = HICN_PACKET_FORMAT_NONE) {
try {
Interest interest(format, 0);
FAIL() << "We expected an exception here";
@@ -86,29 +90,29 @@ void testFormatConstructorException(Packet::Format format = HF_UNSPEC) {
TEST_F(InterestTest, ConstructorWithFormat) {
/**
- * Without arguments it should be format = HF_UNSPEC.
+ * Without arguments it should be format = HICN_PACKET_FORMAT_NONE.
* We expect a crash.
*/
- testFormatConstructor(Packet::Format::HF_INET_TCP);
- testFormatConstructor(Packet::Format::HF_INET6_TCP);
- testFormatConstructorException(Packet::Format::HF_INET_ICMP);
- testFormatConstructorException(Packet::Format::HF_INET6_ICMP);
- testFormatConstructor(Packet::Format::HF_INET_TCP_AH);
- testFormatConstructor(Packet::Format::HF_INET6_TCP_AH);
- testFormatConstructorException(Packet::Format::HF_INET_ICMP_AH);
- testFormatConstructorException(Packet::Format::HF_INET6_ICMP_AH);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV4_TCP);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV6_TCP);
+ testFormatConstructorException(HICN_PACKET_FORMAT_IPV4_ICMP);
+ testFormatConstructorException(HICN_PACKET_FORMAT_IPV6_ICMP);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV4_TCP_AH);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV6_TCP_AH);
+ testFormatConstructorException(HICN_PACKET_FORMAT_IPV4_ICMP_AH);
+ testFormatConstructorException(HICN_PACKET_FORMAT_IPV6_ICMP_AH);
}
TEST_F(InterestTest, ConstructorWithName) {
/**
- * Without arguments it should be format = HF_UNSPEC.
+ * Without arguments it should be format = HICN_PACKET_FORMAT_NONE.
* We expect a crash.
*/
Name n("b001::1|123");
try {
- Interest interest(HF_INET6_TCP, n);
+ Interest interest(HICN_PACKET_FORMAT_IPV6_TCP, n);
} catch (...) {
FAIL() << "ERROR: Unexpected exception thrown";
}
@@ -116,8 +120,10 @@ TEST_F(InterestTest, ConstructorWithName) {
TEST_F(InterestTest, ConstructorWithBuffer) {
// Ensure buffer is interest
+#if 0
auto ret = Interest::isInterest(&buffer_[0]);
EXPECT_TRUE(ret);
+#endif
// Create interest from buffer
try {
@@ -175,9 +181,9 @@ TEST_F(InterestTest, SetGetLocator) {
// Get locator
auto l = interest.getLocator();
- ip_address_t address;
+ hicn_ip_address_t address;
inet_pton(AF_INET6, "b006::ab:cdab:cdef", &address);
- auto ret = !ip_address_cmp(&l, &address, AF_INET6);
+ auto ret = !hicn_ip_address_cmp(&l, &address);
EXPECT_TRUE(ret);
@@ -189,14 +195,14 @@ TEST_F(InterestTest, SetGetLocator) {
// Check it was set
l = interest.getLocator();
- ret = !ip_address_cmp(&l, &address, AF_INET6);
+ ret = !hicn_ip_address_cmp(&l, &address);
EXPECT_TRUE(ret);
}
TEST_F(InterestTest, SetGetLifetime) {
// Create interest from buffer
- Interest interest(HF_INET6_TCP);
+ Interest interest(HICN_PACKET_FORMAT_IPV6_TCP);
const constexpr uint32_t lifetime = 10000;
// Set lifetime
@@ -211,7 +217,7 @@ TEST_F(InterestTest, SetGetLifetime) {
TEST_F(InterestTest, HasManifest) {
// Create interest from buffer
- Interest interest(HF_INET6_TCP);
+ Interest interest(HICN_PACKET_FORMAT_IPV6_TCP);
// Let's expect anexception here
try {
@@ -232,7 +238,7 @@ TEST_F(InterestTest, HasManifest) {
TEST_F(InterestTest, AppendSuffixesEncodeAndIterate) {
// Create interest from buffer
- Interest interest(HF_INET6_TCP);
+ Interest interest(HICN_PACKET_FORMAT_IPV6_TCP);
// Appenad some suffixes, with some duplicates
interest.appendSuffix(1);
@@ -260,7 +266,7 @@ TEST_F(InterestTest, AppendSuffixesEncodeAndIterate) {
TEST_F(InterestTest, AppendSuffixesWithGaps) {
// Create interest from buffer
- Interest interest(HF_INET6_TCP);
+ Interest interest(HICN_PACKET_FORMAT_IPV6_TCP);
// Appenad some suffixes, out of order and with gaps
interest.appendSuffix(6);
@@ -289,7 +295,7 @@ TEST_F(InterestTest, AppendSuffixesWithGaps) {
TEST_F(InterestTest, InterestWithoutManifest) {
// Create interest without manifest
- Interest interest(HF_INET6_TCP);
+ Interest interest(HICN_PACKET_FORMAT_IPV6_TCP);
auto suffix = interest.firstSuffix();
EXPECT_FALSE(interest.hasManifest());
diff --git a/libtransport/src/test/test_packet.cc b/libtransport/src/test/test_packet.cc
index ca20cdfb7..3dfca8f9a 100644
--- a/libtransport/src/test/test_packet.cc
+++ b/libtransport/src/test/test_packet.cc
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021-2022 Cisco and/or its affiliates.
* 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:
@@ -23,6 +23,8 @@
#include <random>
#include <vector>
+#include "../../lib/src/protocol.h"
+
namespace transport {
namespace core {
@@ -56,13 +58,13 @@ class PacketForTest : public Packet {
throw errors::NotImplementedException();
}
- void setLocator(const ip_address_t &locator) override {
+ void setLocator(const hicn_ip_address_t &locator) override {
throw errors::NotImplementedException();
}
void resetForHash() override { throw errors::NotImplementedException(); }
- ip_address_t getLocator() const override {
+ hicn_ip_address_t getLocator() const override {
throw errors::NotImplementedException();
}
};
@@ -73,8 +75,9 @@ class PacketTest : public ::testing::Test {
protected:
PacketTest()
: name_("b001::123|321"),
- packet(Packet::COPY_BUFFER, &raw_packets_[HF_INET6_TCP][0],
- raw_packets_[HF_INET6_TCP].size()) {
+ packet(Packet::COPY_BUFFER,
+ &raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32][0],
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size()) {
// You can do set-up work for each test here.
}
@@ -99,7 +102,7 @@ class PacketTest : public ::testing::Test {
PacketForTest packet;
- static std::map<Packet::Format, std::vector<uint8_t>> raw_packets_;
+ static std::map<uint32_t, std::vector<uint8_t>> raw_packets_;
std::vector<uint8_t> payload = {
0x11, 0x11, 0x01, 0x00, 0xb0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -115,8 +118,8 @@ class PacketTest : public ::testing::Test {
};
};
-std::map<Packet::Format, std::vector<uint8_t>> PacketTest::raw_packets_ = {
- {Packet::Format::HF_INET6_TCP,
+std::map<uint32_t, std::vector<uint8_t>> PacketTest::raw_packets_ = {
+ {HICN_PACKET_FORMAT_IPV6_TCP.as_u32,
{// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca
IPV6_HEADER(TCP_PROTO, 20 + PAYLOAD_SIZE),
@@ -125,7 +128,7 @@ std::map<Packet::Format, std::vector<uint8_t>> PacketTest::raw_packets_ = {
// Payload
PAYLOAD}},
- {Packet::Format::HF_INET_TCP,
+ {HICN_PACKET_FORMAT_IPV4_TCP.as_u32,
{// IPv4 src=3.13.127.8, dst=192.168.1.92
IPV4_HEADER(TCP_PROTO, 20 + PAYLOAD_SIZE),
// TCP src=0x1234 dst=0x4321, seq=0x0001
@@ -133,64 +136,68 @@ std::map<Packet::Format, std::vector<uint8_t>> PacketTest::raw_packets_ = {
// Other
PAYLOAD}},
- {Packet::Format::HF_INET_ICMP,
+ {HICN_PACKET_FORMAT_IPV4_ICMP.as_u32,
{// IPv4 src=3.13.127.8, dst=192.168.1.92
IPV4_HEADER(ICMP_PROTO, 64),
// ICMP echo request
ICMP_ECHO_REQUEST}},
- {Packet::Format::HF_INET6_ICMP,
+ {HICN_PACKET_FORMAT_IPV6_ICMP.as_u32,
{// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca
IPV6_HEADER(ICMP6_PROTO, 60),
// ICMP6 echo request
ICMP6_ECHO_REQUEST}},
- {Packet::Format::HF_INET6_TCP_AH,
+ {HICN_PACKET_FORMAT_IPV6_TCP_AH.as_u32,
{// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca
IPV6_HEADER(TCP_PROTO, 20 + 44 + 128),
// ICMP6 echo request
TCP_HEADER(0x18),
// hICN AH header
- AH_HEADER}},
+ AH_HEADER, SIGNATURE}},
- {Packet::Format::HF_INET_TCP_AH,
+ {HICN_PACKET_FORMAT_IPV4_TCP_AH.as_u32,
{// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca
IPV4_HEADER(TCP_PROTO, 20 + 44 + 128),
// ICMP6 echo request
TCP_HEADER(0x18),
// hICN AH header
- AH_HEADER}},
+ AH_HEADER, SIGNATURE}},
// XXX No flag defined in ICMP header to signal AH header.
- {Packet::Format::HF_INET_ICMP_AH,
+ {HICN_PACKET_FORMAT_IPV4_ICMP_AH.as_u32,
{// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca
IPV4_HEADER(ICMP_PROTO, 64 + 44),
// ICMP6 echo request
ICMP_ECHO_REQUEST,
// hICN AH header
- AH_HEADER}},
+ AH_HEADER, SIGNATURE}},
- {Packet::Format::HF_INET6_ICMP_AH,
+ {HICN_PACKET_FORMAT_IPV6_ICMP_AH.as_u32,
{// IPv6 src=b001::ab:cdab:cdef, dst=b002::ca
IPV6_HEADER(ICMP6_PROTO, 60 + 44),
// ICMP6 echo request
ICMP6_ECHO_REQUEST,
// hICN AH header
- AH_HEADER}},
+ AH_HEADER, SIGNATURE}},
};
-void testFormatConstructor(Packet::Format format = HF_UNSPEC) {
+void testFormatConstructor(Packet::Format format = HICN_PACKET_FORMAT_NONE) {
try {
- PacketForTest packet(format);
+ PacketForTest packet(HICN_PACKET_TYPE_INTEREST, format);
} catch (...) {
- FAIL() << "ERROR: Unexpected exception thrown for " << format;
+ char buf[MAXSZ_HICN_PACKET_FORMAT];
+ int rc = hicn_packet_format_snprintf(buf, MAXSZ_HICN_PACKET_FORMAT, format);
+ if (rc < 0 || rc >= MAXSZ_HICN_PACKET_FORMAT)
+ snprintf(buf, MAXSZ_HICN_PACKET_FORMAT, "%s", "(error");
+ FAIL() << "ERROR: Unexpected exception thrown for " << buf;
}
}
void testFormatAndAdditionalHeaderConstructor(Packet::Format format,
std::size_t additional_header) {
- PacketForTest packet(format, additional_header);
+ PacketForTest packet(HICN_PACKET_TYPE_INTEREST, format, additional_header);
// Packet length should be the one of the normal header + the
// additional_header
@@ -206,7 +213,7 @@ void testRawBufferConstructor(std::vector<uint8_t> packet,
packet.size());
// Check format is expected one.
- EXPECT_EQ(p.getFormat(), format);
+ EXPECT_EQ(p.getFormat().as_u32, format.as_u32);
// // Try the same using a MemBuf
// auto buf = utils::MemBuf::wrapBuffer(&packet[0], packet.size());
@@ -229,17 +236,19 @@ void testRawBufferConstructor(std::vector<uint8_t> packet,
PacketForTest p(Packet::WRAP_BUFFER, &packet[0], packet.size(),
packet.size());
- // Format should fallback to HF_UNSPEC
- EXPECT_EQ(p.getFormat(), HF_UNSPEC);
+ // Format should fallback to HICN_PACKET_FORMAT_NONE
+ EXPECT_EQ(p.getFormat().as_u32, HICN_PACKET_FORMAT_NONE.as_u32);
+ } catch (errors::MalformedPacketException &exc) {
+ // Ok right exception
} catch (...) {
FAIL() << "ERROR: Unexpected exception thrown.";
}
}
-void getHeaderSizeFromBuffer(Packet::Format format,
- std::vector<uint8_t> &packet,
+void getHeaderSizeFromBuffer(std::vector<uint8_t> &packet,
std::size_t expected) {
- auto header_size = PacketForTest::getHeaderSizeFromBuffer(format, &packet[0]);
+ auto header_size =
+ PacketForTest::getHeaderSizeFromBuffer(&packet[0], packet.size());
EXPECT_EQ(header_size, expected);
}
@@ -248,18 +257,17 @@ void getHeaderSizeFromFormat(Packet::Format format, std::size_t expected) {
EXPECT_EQ(header_size, expected);
}
-void getPayloadSizeFromBuffer(Packet::Format format,
- std::vector<uint8_t> &packet,
+void getPayloadSizeFromBuffer(std::vector<uint8_t> &packet,
std::size_t expected) {
auto payload_size =
- PacketForTest::getPayloadSizeFromBuffer(format, &packet[0]);
+ PacketForTest::getPayloadSizeFromBuffer(&packet[0], packet.size());
EXPECT_EQ(payload_size, expected);
}
void getFormatFromBuffer(Packet::Format expected,
std::vector<uint8_t> &packet) {
auto format = PacketForTest::getFormatFromBuffer(&packet[0], packet.size());
- EXPECT_EQ(format, expected);
+ EXPECT_EQ(format.as_u32, expected.as_u32);
}
void getHeaderSize(std::size_t expected, const PacketForTest &packet) {
@@ -269,143 +277,160 @@ void getHeaderSize(std::size_t expected, const PacketForTest &packet) {
void testGetFormat(Packet::Format expected, const Packet &packet) {
auto format = packet.getFormat();
- EXPECT_EQ(format, expected);
+ EXPECT_EQ(format.as_u32, expected.as_u32);
}
} // namespace
TEST_F(PacketTest, ConstructorWithFormat) {
- testFormatConstructor(Packet::Format::HF_INET_TCP);
- testFormatConstructor(Packet::Format::HF_INET6_TCP);
- testFormatConstructor(Packet::Format::HF_INET_ICMP);
- testFormatConstructor(Packet::Format::HF_INET6_ICMP);
- testFormatConstructor(Packet::Format::HF_INET_TCP_AH);
- testFormatConstructor(Packet::Format::HF_INET6_TCP_AH);
- testFormatConstructor(Packet::Format::HF_INET_ICMP_AH);
- testFormatConstructor(Packet::Format::HF_INET6_ICMP_AH);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV4_TCP);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV6_TCP);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV4_ICMP);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV6_ICMP);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV4_TCP_AH);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV6_TCP_AH);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV4_ICMP_AH);
+ testFormatConstructor(HICN_PACKET_FORMAT_IPV6_ICMP_AH);
}
TEST_F(PacketTest, ConstructorWithFormatAndAdditionalHeader) {
- testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET_TCP, 123);
- testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET6_TCP, 360);
- testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET_ICMP, 21);
- testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET6_ICMP, 444);
- testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET_TCP_AH, 555);
- testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET6_TCP_AH,
- 321);
- testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET_ICMP_AH,
+ testFormatAndAdditionalHeaderConstructor(HICN_PACKET_FORMAT_IPV4_TCP, 123);
+ testFormatAndAdditionalHeaderConstructor(HICN_PACKET_FORMAT_IPV6_TCP, 360);
+ testFormatAndAdditionalHeaderConstructor(HICN_PACKET_FORMAT_IPV4_ICMP, 21);
+ testFormatAndAdditionalHeaderConstructor(HICN_PACKET_FORMAT_IPV6_ICMP, 444);
+ testFormatAndAdditionalHeaderConstructor(HICN_PACKET_FORMAT_IPV4_TCP_AH, 555);
+ testFormatAndAdditionalHeaderConstructor(HICN_PACKET_FORMAT_IPV6_TCP_AH, 321);
+ testFormatAndAdditionalHeaderConstructor(HICN_PACKET_FORMAT_IPV4_ICMP_AH,
123);
- testFormatAndAdditionalHeaderConstructor(Packet::Format::HF_INET6_ICMP_AH,
- 44);
+ testFormatAndAdditionalHeaderConstructor(HICN_PACKET_FORMAT_IPV6_ICMP_AH, 44);
}
TEST_F(PacketTest, ConstructorWithNew) {
- auto &_packet = raw_packets_[HF_INET6_TCP];
+ auto &_packet = raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32];
auto packet_ptr = new PacketForTest(Packet::WRAP_BUFFER, &_packet[0],
_packet.size(), _packet.size());
delete packet_ptr;
}
TEST_F(PacketTest, ConstructorWithRawBufferInet6Tcp) {
- auto format = Packet::Format::HF_INET6_TCP;
- testRawBufferConstructor(raw_packets_[format], format);
+ auto format = HICN_PACKET_FORMAT_IPV6_TCP;
+ testRawBufferConstructor(raw_packets_[format.as_u32], format);
}
TEST_F(PacketTest, ConstructorWithRawBufferInetTcp) {
- auto format = Packet::Format::HF_INET_TCP;
- testRawBufferConstructor(raw_packets_[format], format);
+ auto format = HICN_PACKET_FORMAT_IPV4_TCP;
+ testRawBufferConstructor(raw_packets_[format.as_u32], format);
}
TEST_F(PacketTest, ConstructorWithRawBufferInetIcmp) {
- auto format = Packet::Format::HF_INET_ICMP;
- testRawBufferConstructor(raw_packets_[format], format);
+ auto format = HICN_PACKET_FORMAT_IPV4_ICMP;
+ testRawBufferConstructor(raw_packets_[format.as_u32], format);
}
TEST_F(PacketTest, ConstructorWithRawBufferInet6Icmp) {
- auto format = Packet::Format::HF_INET6_ICMP;
- testRawBufferConstructor(raw_packets_[format], format);
+ auto format = HICN_PACKET_FORMAT_IPV6_ICMP;
+ testRawBufferConstructor(raw_packets_[format.as_u32], format);
}
TEST_F(PacketTest, ConstructorWithRawBufferInet6TcpAh) {
- auto format = Packet::Format::HF_INET6_TCP_AH;
- testRawBufferConstructor(raw_packets_[format], format);
+ auto format = HICN_PACKET_FORMAT_IPV6_TCP_AH;
+ testRawBufferConstructor(raw_packets_[format.as_u32], format);
}
TEST_F(PacketTest, ConstructorWithRawBufferInetTcpAh) {
- auto format = Packet::Format::HF_INET_TCP_AH;
- testRawBufferConstructor(raw_packets_[format], format);
+ auto format = HICN_PACKET_FORMAT_IPV4_TCP_AH;
+ testRawBufferConstructor(raw_packets_[format.as_u32], format);
}
TEST_F(PacketTest, MoveConstructor) {
- PacketForTest p0(Packet::Format::HF_INET6_TCP);
+ PacketForTest p0(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_TCP);
PacketForTest p1(std::move(p0));
- EXPECT_EQ(p0.getFormat(), Packet::Format::HF_UNSPEC);
- EXPECT_EQ(p1.getFormat(), Packet::Format::HF_INET6_TCP);
+ EXPECT_EQ(p0.getFormat().as_u32, HICN_PACKET_FORMAT_NONE.as_u32);
+ EXPECT_EQ(p1.getFormat().as_u32, HICN_PACKET_FORMAT_IPV6_TCP.as_u32);
}
TEST_F(PacketTest, TestGetHeaderSizeFromBuffer) {
- getHeaderSizeFromBuffer(HF_INET6_TCP, raw_packets_[HF_INET6_TCP],
- HICN_V6_TCP_HDRLEN);
- getHeaderSizeFromBuffer(HF_INET_TCP, raw_packets_[HF_INET_TCP],
- HICN_V4_TCP_HDRLEN);
- getHeaderSizeFromBuffer(HF_INET6_ICMP, raw_packets_[HF_INET6_ICMP],
+ getHeaderSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32],
+ IPV6_HDRLEN + TCP_HDRLEN);
+ getHeaderSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP.as_u32],
+ IPV4_HDRLEN + TCP_HDRLEN);
+ getHeaderSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32],
IPV6_HDRLEN + 4);
- getHeaderSizeFromBuffer(HF_INET_ICMP, raw_packets_[HF_INET_ICMP],
+ getHeaderSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV4_ICMP.as_u32],
IPV4_HDRLEN + 4);
- getHeaderSizeFromBuffer(HF_INET6_TCP_AH, raw_packets_[HF_INET6_TCP_AH],
- HICN_V6_TCP_AH_HDRLEN + 128);
- getHeaderSizeFromBuffer(HF_INET_TCP_AH, raw_packets_[HF_INET_TCP_AH],
- HICN_V4_TCP_AH_HDRLEN + 128);
+ getHeaderSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP_AH.as_u32],
+ IPV6_HDRLEN + TCP_HDRLEN + AH_HDRLEN + 128);
+ getHeaderSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP_AH.as_u32],
+ IPV4_HDRLEN + TCP_HDRLEN + AH_HDRLEN + 128);
}
TEST_F(PacketTest, TestGetHeaderSizeFromFormat) {
- getHeaderSizeFromFormat(HF_INET6_TCP, HICN_V6_TCP_HDRLEN);
- getHeaderSizeFromFormat(HF_INET_TCP, HICN_V4_TCP_HDRLEN);
- getHeaderSizeFromFormat(HF_INET6_ICMP, IPV6_HDRLEN + 4);
- getHeaderSizeFromFormat(HF_INET_ICMP, IPV4_HDRLEN + 4);
- getHeaderSizeFromFormat(HF_INET6_TCP_AH, HICN_V6_TCP_AH_HDRLEN);
- getHeaderSizeFromFormat(HF_INET_TCP_AH, HICN_V4_TCP_AH_HDRLEN);
+ getHeaderSizeFromFormat(HICN_PACKET_FORMAT_IPV6_TCP,
+ IPV6_HDRLEN + TCP_HDRLEN);
+ getHeaderSizeFromFormat(HICN_PACKET_FORMAT_IPV4_TCP,
+ IPV4_HDRLEN + TCP_HDRLEN);
+ getHeaderSizeFromFormat(HICN_PACKET_FORMAT_IPV6_ICMP, IPV6_HDRLEN + 4);
+ getHeaderSizeFromFormat(HICN_PACKET_FORMAT_IPV4_ICMP, IPV4_HDRLEN + 4);
+ getHeaderSizeFromFormat(HICN_PACKET_FORMAT_IPV6_TCP_AH,
+ IPV6_HDRLEN + TCP_HDRLEN + AH_HDRLEN);
+ getHeaderSizeFromFormat(HICN_PACKET_FORMAT_IPV4_TCP_AH,
+ IPV4_HDRLEN + TCP_HDRLEN + AH_HDRLEN);
}
TEST_F(PacketTest, TestGetPayloadSizeFromBuffer) {
- getPayloadSizeFromBuffer(HF_INET6_TCP, raw_packets_[HF_INET6_TCP], 12);
- getPayloadSizeFromBuffer(HF_INET_TCP, raw_packets_[HF_INET_TCP], 12);
- getPayloadSizeFromBuffer(HF_INET6_ICMP, raw_packets_[HF_INET6_ICMP], 56);
- getPayloadSizeFromBuffer(HF_INET_ICMP, raw_packets_[HF_INET_ICMP], 60);
- getPayloadSizeFromBuffer(HF_INET6_TCP_AH, raw_packets_[HF_INET6_TCP_AH], 0);
- getPayloadSizeFromBuffer(HF_INET_TCP_AH, raw_packets_[HF_INET_TCP_AH], 0);
-}
-
+ getPayloadSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32],
+ 12);
+ getPayloadSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP.as_u32],
+ 12);
+ getPayloadSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32],
+ 56);
+ getPayloadSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV4_ICMP.as_u32],
+ 60);
+ getPayloadSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP_AH.as_u32],
+ 0);
+ getPayloadSizeFromBuffer(raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP_AH.as_u32],
+ 0);
+}
+
+#if 0
TEST_F(PacketTest, TestIsInterest) {
- auto ret = PacketForTest::isInterest(&raw_packets_[HF_INET6_TCP][0]);
+ auto ret = PacketForTest::isInterest(&raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32][0]);
EXPECT_TRUE(ret);
}
+#endif
TEST_F(PacketTest, TestGetFormatFromBuffer) {
- getFormatFromBuffer(HF_INET6_TCP, raw_packets_[HF_INET6_TCP]);
- getFormatFromBuffer(HF_INET_TCP, raw_packets_[HF_INET_TCP]);
- getFormatFromBuffer(HF_INET6_ICMP, raw_packets_[HF_INET6_ICMP]);
- getFormatFromBuffer(HF_INET_ICMP, raw_packets_[HF_INET_ICMP]);
- getFormatFromBuffer(HF_INET6_TCP_AH, raw_packets_[HF_INET6_TCP_AH]);
- getFormatFromBuffer(HF_INET_TCP_AH, raw_packets_[HF_INET_TCP_AH]);
+ getFormatFromBuffer(HICN_PACKET_FORMAT_IPV6_TCP,
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32]);
+ getFormatFromBuffer(HICN_PACKET_FORMAT_IPV4_TCP,
+ raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP.as_u32]);
+ getFormatFromBuffer(HICN_PACKET_FORMAT_IPV6_ICMP,
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32]);
+ getFormatFromBuffer(HICN_PACKET_FORMAT_IPV4_ICMP,
+ raw_packets_[HICN_PACKET_FORMAT_IPV4_ICMP.as_u32]);
+ getFormatFromBuffer(HICN_PACKET_FORMAT_IPV6_TCP_AH,
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP_AH.as_u32]);
+ getFormatFromBuffer(HICN_PACKET_FORMAT_IPV4_TCP_AH,
+ raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP_AH.as_u32]);
}
// TEST_F(PacketTest, TestReplace) {
-// PacketForTest packet(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_TCP][0],
-// raw_packets_[HF_INET6_TCP].size());
+// PacketForTest packet(Packet::WRAP_BUFFER,
+// &raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32][0],
+// raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size());
// // Replace current packet with another one
-// packet.replace(&raw_packets_[HF_INET_TCP][0],
-// raw_packets_[HF_INET_TCP].size());
+// packet.replace(&raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP.as_u32][0],
+// raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP.as_u32].size());
// // Check new format
-// ASSERT_EQ(packet.getFormat(), HF_INET_TCP);
+// ASSERT_EQ(packet.getFormat(), HICN_PACKET_FORMAT_IPV4_TCP);
// }
TEST_F(PacketTest, TestPayloadSize) {
// Check payload size of existing packet
- auto &_packet = raw_packets_[HF_INET6_TCP];
+ auto &_packet = raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32];
PacketForTest packet(Packet::WRAP_BUFFER, &_packet[0], _packet.size(),
_packet.size());
@@ -415,7 +440,7 @@ TEST_F(PacketTest, TestPayloadSize) {
std::string payload0(1024, 'X');
// Create the packet
- PacketForTest packet2(HF_INET6_TCP);
+ PacketForTest packet2(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_TCP);
// Payload size should now be zero
EXPECT_EQ(packet2.payloadSize(), std::size_t(0));
@@ -442,22 +467,29 @@ TEST_F(PacketTest, TestPayloadSize) {
}
TEST_F(PacketTest, TestHeaderSize) {
- getHeaderSize(HICN_V6_TCP_HDRLEN,
- PacketForTest(Packet::Format::HF_INET6_TCP));
- getHeaderSize(HICN_V4_TCP_HDRLEN, PacketForTest(Packet::Format::HF_INET_TCP));
- getHeaderSize(HICN_V6_ICMP_HDRLEN,
- PacketForTest(Packet::Format::HF_INET6_ICMP));
- getHeaderSize(HICN_V4_ICMP_HDRLEN,
- PacketForTest(Packet::Format::HF_INET_ICMP));
- getHeaderSize(HICN_V6_TCP_AH_HDRLEN,
- PacketForTest(Packet::Format::HF_INET6_TCP_AH));
- getHeaderSize(HICN_V4_TCP_AH_HDRLEN,
- PacketForTest(Packet::Format::HF_INET_TCP_AH));
+ getHeaderSize(
+ IPV6_HDRLEN + TCP_HDRLEN,
+ PacketForTest(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_TCP));
+ getHeaderSize(
+ IPV4_HDRLEN + TCP_HDRLEN,
+ PacketForTest(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV4_TCP));
+ getHeaderSize(
+ IPV6_HDRLEN + ICMP_HDRLEN,
+ PacketForTest(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_ICMP));
+ getHeaderSize(
+ IPV4_HDRLEN + ICMP_HDRLEN,
+ PacketForTest(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV4_ICMP));
+ getHeaderSize(
+ IPV6_HDRLEN + TCP_HDRLEN + AH_HDRLEN,
+ PacketForTest(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_TCP_AH));
+ getHeaderSize(
+ IPV4_HDRLEN + TCP_HDRLEN + AH_HDRLEN,
+ PacketForTest(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV4_TCP_AH));
}
TEST_F(PacketTest, TestMemBufReference) {
// Create packet
- auto &_packet = raw_packets_[HF_INET6_TCP];
+ auto &_packet = raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32];
// Packet was not created as a shared_ptr. If we try to get a membuf shared
// ptr we should get an exception.
@@ -498,16 +530,17 @@ TEST_F(PacketTest, TestMemBufReference) {
TEST_F(PacketTest, TestReset) {
// Check everything is ok
- EXPECT_EQ(packet.getFormat(), HF_INET6_TCP);
- EXPECT_EQ(packet.length(), raw_packets_[HF_INET6_TCP].size());
- EXPECT_EQ(packet.headerSize(), HICN_V6_TCP_HDRLEN);
+ EXPECT_EQ(packet.getFormat().as_u32, HICN_PACKET_FORMAT_IPV6_TCP.as_u32);
+ EXPECT_EQ(packet.length(),
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size());
+ EXPECT_EQ(packet.headerSize(), IPV6_HDRLEN + TCP_HDRLEN);
EXPECT_EQ(packet.payloadSize(), packet.length() - packet.headerSize());
// Reset the packet
packet.reset();
// Rerun test
- EXPECT_EQ(packet.getFormat(), HF_UNSPEC);
+ EXPECT_EQ(packet.getFormat().as_u32, HICN_PACKET_FORMAT_NONE.as_u32);
EXPECT_EQ(packet.length(), std::size_t(0));
EXPECT_EQ(packet.headerSize(), std::size_t(0));
EXPECT_EQ(packet.payloadSize(), std::size_t(0));
@@ -548,7 +581,7 @@ TEST_F(PacketTest, TestAppendPayload) {
// There should be no more bufferls left in the chain
EXPECT_EQ(&packet, packet.next());
- EXPECT_EQ(packet.getFormat(), HF_UNSPEC);
+ EXPECT_EQ(packet.getFormat().as_u32, HICN_PACKET_FORMAT_NONE.as_u32);
EXPECT_EQ(packet.length(), std::size_t(0));
EXPECT_EQ(packet.headerSize(), std::size_t(0));
EXPECT_EQ(packet.payloadSize(), std::size_t(0));
@@ -557,6 +590,7 @@ TEST_F(PacketTest, TestAppendPayload) {
TEST_F(PacketTest, GetPayload) {
// Append payload with raw buffer
uint8_t raw_buffer[2048];
+ memset(raw_buffer, 0, sizeof(raw_buffer));
auto original_payload_length = packet.payloadSize();
packet.appendPayload(raw_buffer, 2048);
@@ -621,61 +655,63 @@ TEST_F(PacketTest, SetGetPayloadType) {
TEST_F(PacketTest, GetFormat) {
{
PacketForTest p0(Packet::WRAP_BUFFER,
- &raw_packets_[Packet::Format::HF_INET_TCP][0],
- raw_packets_[Packet::Format::HF_INET_TCP].size(),
- raw_packets_[Packet::Format::HF_INET_TCP].size());
- testGetFormat(Packet::Format::HF_INET_TCP, p0);
+ &raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP.as_u32][0],
+ raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP.as_u32].size(),
+ raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP.as_u32].size());
+ testGetFormat(HICN_PACKET_FORMAT_IPV4_TCP, p0);
PacketForTest p1(Packet::WRAP_BUFFER,
- &raw_packets_[Packet::Format::HF_INET6_TCP][0],
- raw_packets_[Packet::Format::HF_INET6_TCP].size(),
- raw_packets_[Packet::Format::HF_INET6_TCP].size());
- testGetFormat(Packet::Format::HF_INET6_TCP, p1);
+ &raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32][0],
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size(),
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size());
+ testGetFormat(HICN_PACKET_FORMAT_IPV6_TCP, p1);
PacketForTest p2(Packet::WRAP_BUFFER,
- &raw_packets_[Packet::Format::HF_INET_ICMP][0],
- raw_packets_[Packet::Format::HF_INET_ICMP].size(),
- raw_packets_[Packet::Format::HF_INET_ICMP].size());
- testGetFormat(Packet::Format::HF_INET_ICMP, p2);
+ &raw_packets_[HICN_PACKET_FORMAT_IPV4_ICMP.as_u32][0],
+ raw_packets_[HICN_PACKET_FORMAT_IPV4_ICMP.as_u32].size(),
+ raw_packets_[HICN_PACKET_FORMAT_IPV4_ICMP.as_u32].size());
+ testGetFormat(HICN_PACKET_FORMAT_IPV4_ICMP, p2);
PacketForTest p3(Packet::WRAP_BUFFER,
- &raw_packets_[Packet::Format::HF_INET6_ICMP][0],
- raw_packets_[Packet::Format::HF_INET6_ICMP].size(),
- raw_packets_[Packet::Format::HF_INET6_ICMP].size());
- testGetFormat(Packet::Format::HF_INET6_ICMP, p3);
-
- PacketForTest p4(Packet::WRAP_BUFFER,
- &raw_packets_[Packet::Format::HF_INET_TCP_AH][0],
- raw_packets_[Packet::Format::HF_INET_TCP_AH].size(),
- raw_packets_[Packet::Format::HF_INET_TCP_AH].size());
- testGetFormat(Packet::Format::HF_INET_TCP_AH, p4);
-
- PacketForTest p5(Packet::WRAP_BUFFER,
- &raw_packets_[Packet::Format::HF_INET6_TCP_AH][0],
- raw_packets_[Packet::Format::HF_INET6_TCP_AH].size(),
- raw_packets_[Packet::Format::HF_INET6_TCP_AH].size());
- testGetFormat(Packet::Format::HF_INET6_TCP_AH, p5);
+ &raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32][0],
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32].size(),
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32].size());
+ testGetFormat(HICN_PACKET_FORMAT_IPV6_ICMP, p3);
+
+ PacketForTest p4(
+ Packet::WRAP_BUFFER,
+ &raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP_AH.as_u32][0],
+ raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP_AH.as_u32].size(),
+ raw_packets_[HICN_PACKET_FORMAT_IPV4_TCP_AH.as_u32].size());
+ testGetFormat(HICN_PACKET_FORMAT_IPV4_TCP_AH, p4);
+
+ PacketForTest p5(
+ Packet::WRAP_BUFFER,
+ &raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP_AH.as_u32][0],
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP_AH.as_u32].size(),
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP_AH.as_u32].size());
+ testGetFormat(HICN_PACKET_FORMAT_IPV6_TCP_AH, p5);
}
// Let's try now creating empty packets
{
- PacketForTest p0(Packet::Format::HF_INET_TCP);
- testGetFormat(Packet::Format::HF_INET_TCP, p0);
+ PacketForTest p0(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV4_TCP);
+ testGetFormat(HICN_PACKET_FORMAT_IPV4_TCP, p0);
- PacketForTest p1(Packet::Format::HF_INET6_TCP);
- testGetFormat(Packet::Format::HF_INET6_TCP, p1);
+ PacketForTest p1(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_TCP);
+ testGetFormat(HICN_PACKET_FORMAT_IPV6_TCP, p1);
- PacketForTest p2(Packet::Format::HF_INET_ICMP);
- testGetFormat(Packet::Format::HF_INET_ICMP, p2);
+ PacketForTest p2(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV4_ICMP);
+ testGetFormat(HICN_PACKET_FORMAT_IPV4_ICMP, p2);
- PacketForTest p3(Packet::Format::HF_INET6_ICMP);
- testGetFormat(Packet::Format::HF_INET6_ICMP, p3);
+ PacketForTest p3(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_ICMP);
+ testGetFormat(HICN_PACKET_FORMAT_IPV6_ICMP, p3);
- PacketForTest p4(Packet::Format::HF_INET_TCP_AH);
- testGetFormat(Packet::Format::HF_INET_TCP_AH, p4);
+ PacketForTest p4(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV4_TCP_AH);
+ testGetFormat(HICN_PACKET_FORMAT_IPV4_TCP_AH, p4);
- PacketForTest p5(Packet::Format::HF_INET6_TCP_AH);
- testGetFormat(Packet::Format::HF_INET6_TCP_AH, p5);
+ PacketForTest p5(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_TCP_AH);
+ testGetFormat(HICN_PACKET_FORMAT_IPV6_TCP_AH, p5);
}
}
@@ -707,7 +743,7 @@ TEST_F(PacketTest, SetGetTestSignatureTimestamp) {
}
// Now let's construct a AH packet, with no additional space for signature
- PacketForTest p(HF_INET6_TCP_AH);
+ PacketForTest p(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_TCP_AH);
p.setSignatureTimestamp(now);
uint64_t now_get = p.getSignatureTimestamp();
@@ -741,7 +777,7 @@ TEST_F(PacketTest, TestSetGetValidationAlgorithm) {
}
// Now let's construct a AH packet, with no additional space for signature
- PacketForTest p(HF_INET6_TCP_AH);
+ PacketForTest p(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_TCP_AH);
p.setValidationAlgorithm(auth::CryptoSuite::RSA_SHA256);
auto v_get = p.getValidationAlgorithm();
@@ -751,6 +787,7 @@ TEST_F(PacketTest, TestSetGetValidationAlgorithm) {
TEST_F(PacketTest, TestSetGetKeyId) {
uint8_t key[32];
+ memset(key, 0, sizeof(key));
auth::KeyId key_id = std::make_pair(key, sizeof(key));
try {
@@ -762,7 +799,7 @@ TEST_F(PacketTest, TestSetGetKeyId) {
FAIL() << "Unexpected exception";
}
- // Same fot get method
+ // Same for get method
try {
auto k = packet.getKeyId();
// Let's make compiler happy
@@ -775,7 +812,7 @@ TEST_F(PacketTest, TestSetGetKeyId) {
}
// Now let's construct a AH packet, with no additional space for signature
- PacketForTest p(HF_INET6_TCP_AH);
+ PacketForTest p(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_TCP_AH);
p.setKeyId(key_id);
auto p_get = p.getKeyId();
@@ -799,7 +836,8 @@ TEST_F(PacketTest, DISABLED_TestChecksum) {
EXPECT_TRUE(integrity);
// Check with AH header and 300 bytes signature
- PacketForTest p(HF_INET6_TCP_AH, 300);
+ PacketForTest p(HICN_PACKET_TYPE_INTEREST, HICN_PACKET_FORMAT_IPV6_TCP_AH,
+ 300);
std::string payload(5000, 'X');
p.appendPayload((const uint8_t *)payload.c_str(), payload.size() / 2);
p.appendPayload((const uint8_t *)(payload.c_str() + payload.size() / 2),
@@ -810,116 +848,13 @@ TEST_F(PacketTest, DISABLED_TestChecksum) {
EXPECT_TRUE(integrity);
}
-TEST_F(PacketTest, TestSetSyn) {
- // Test syn of non-tcp format and check exception is thrown
- try {
- auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0],
- raw_packets_[HF_INET6_ICMP].size(),
- raw_packets_[HF_INET6_ICMP].size());
- // Let's make compiler happy
- p.setSyn();
- FAIL() << "We should not reach this point.";
- } catch (const errors::RuntimeException &exc) {
- /* ok right exception*/
- } catch (...) {
- FAIL() << "Unexpected exception";
- }
-
- packet.setSyn();
- EXPECT_TRUE(packet.testSyn());
-
- packet.resetSyn();
- EXPECT_FALSE(packet.testSyn());
-}
-
-TEST_F(PacketTest, TestSetFin) {
- // Test syn of non-tcp format and check exception is thrown
- try {
- auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0],
- raw_packets_[HF_INET6_ICMP].size(),
- raw_packets_[HF_INET6_ICMP].size());
- // Let's make compiler happy
- p.setFin();
- FAIL() << "We should not reach this point.";
- } catch (const errors::RuntimeException &exc) {
- /* ok right exception*/
- } catch (...) {
- FAIL() << "Unexpected exception";
- }
-
- packet.setFin();
- EXPECT_TRUE(packet.testFin());
-
- packet.resetFin();
- EXPECT_FALSE(packet.testFin());
-}
-
-TEST_F(PacketTest, TestSetAck) {
- // Test syn of non-tcp format and check exception is thrown
- try {
- auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0],
- raw_packets_[HF_INET6_ICMP].size(),
- raw_packets_[HF_INET6_ICMP].size());
- // Let's make compiler happy
- p.setAck();
- FAIL() << "We should not reach this point.";
- } catch (const errors::RuntimeException &exc) {
- /* ok right exception*/
- } catch (...) {
- FAIL() << "Unexpected exception";
- }
-
- packet.setAck();
- EXPECT_TRUE(packet.testAck());
-
- packet.resetAck();
- EXPECT_FALSE(packet.testAck());
-}
-
-TEST_F(PacketTest, TestSetRst) {
- // Test syn of non-tcp format and check exception is thrown
- try {
- auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0],
- raw_packets_[HF_INET6_ICMP].size(),
- raw_packets_[HF_INET6_ICMP].size());
- // Let's make compiler happy
- p.setRst();
- FAIL() << "We should not reach this point.";
- } catch (const errors::RuntimeException &exc) {
- /* ok right exception*/
- } catch (...) {
- FAIL() << "Unexpected exception";
- }
-
- packet.setRst();
- EXPECT_TRUE(packet.testRst());
-
- packet.resetRst();
- EXPECT_FALSE(packet.testRst());
-}
-
-TEST_F(PacketTest, TestResetFlags) {
- packet.setRst();
- packet.setSyn();
- packet.setAck();
- packet.setFin();
- EXPECT_TRUE(packet.testRst());
- EXPECT_TRUE(packet.testAck());
- EXPECT_TRUE(packet.testFin());
- EXPECT_TRUE(packet.testSyn());
-
- packet.resetFlags();
- EXPECT_FALSE(packet.testRst());
- EXPECT_FALSE(packet.testAck());
- EXPECT_FALSE(packet.testFin());
- EXPECT_FALSE(packet.testSyn());
-}
-
TEST_F(PacketTest, TestSetGetSrcPort) {
try {
- auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0],
- raw_packets_[HF_INET6_ICMP].size(),
- raw_packets_[HF_INET6_ICMP].size());
+ auto p =
+ PacketForTest(Packet::WRAP_BUFFER,
+ &raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32][0],
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32].size(),
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32].size());
// Let's make compiler happy
p.setSrcPort(12345);
FAIL() << "We should not reach this point.";
@@ -935,9 +870,11 @@ TEST_F(PacketTest, TestSetGetSrcPort) {
TEST_F(PacketTest, TestSetGetDstPort) {
try {
- auto p = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0],
- raw_packets_[HF_INET6_ICMP].size(),
- raw_packets_[HF_INET6_ICMP].size());
+ auto p =
+ PacketForTest(Packet::WRAP_BUFFER,
+ &raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32][0],
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32].size(),
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32].size());
// Let's make compiler happy
p.setDstPort(12345);
FAIL() << "We should not reach this point.";
@@ -955,58 +892,73 @@ TEST_F(PacketTest, TestEnsureCapacity) {
PacketForTest &p = packet;
// This shoul be false
- auto ret = p.ensureCapacity(raw_packets_[HF_INET6_TCP].size() + 10);
+ auto ret = p.ensureCapacity(
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size() + 10);
EXPECT_FALSE(ret);
// This should be true
- ret = p.ensureCapacity(raw_packets_[HF_INET6_TCP].size());
+ ret =
+ p.ensureCapacity(raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size());
EXPECT_TRUE(ret);
// This should be true
- ret = p.ensureCapacity(raw_packets_[HF_INET6_TCP].size() - 10);
+ ret = p.ensureCapacity(
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size() - 10);
EXPECT_TRUE(ret);
// Try to trim the packet start
p.trimStart(10);
// Now this should be false
- ret = p.ensureCapacity(raw_packets_[HF_INET6_TCP].size());
+ ret =
+ p.ensureCapacity(raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size());
EXPECT_FALSE(ret);
// Create a new packet
- auto p2 = PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_ICMP][0],
- raw_packets_[HF_INET6_ICMP].size(),
- raw_packets_[HF_INET6_ICMP].size());
+ auto p2 =
+ PacketForTest(Packet::WRAP_BUFFER,
+ &raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32][0],
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32].size(),
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_ICMP.as_u32].size());
p2.appendPayload(utils::MemBuf::createCombined(2000));
// This should be false, since the buffer is chained
- ret = p2.ensureCapacity(raw_packets_[HF_INET6_TCP].size() - 10);
+ ret = p2.ensureCapacity(
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size() - 10);
EXPECT_FALSE(ret);
}
-TEST_F(PacketTest, TestEnsureCapacityAndFillUnused) {
+//
+// This test is disabled as it manipulates a ipv6 header with the wrong payload
+// length inside.
+//
+TEST_F(PacketTest, DISABLED_TestEnsureCapacityAndFillUnused) {
// Create packet by excluding the payload (So only L3 + L4 headers). The
// payload will be trated as unused tailroom
- PacketForTest p =
- PacketForTest(Packet::WRAP_BUFFER, &raw_packets_[HF_INET6_TCP][0],
- raw_packets_[HF_INET6_TCP].size() - PAYLOAD_SIZE,
- raw_packets_[HF_INET6_TCP].size());
+ PacketForTest p = PacketForTest(
+ Packet::WRAP_BUFFER, &raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32][0],
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size() - PAYLOAD_SIZE,
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size());
// Copy original packet payload, which is here trated as a unused tailroom
uint8_t original_payload[PAYLOAD_SIZE];
- uint8_t *payload = &raw_packets_[HF_INET6_TCP][0] +
- raw_packets_[HF_INET6_TCP].size() - PAYLOAD_SIZE;
+ uint8_t *payload = &raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32][0] +
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size() -
+ PAYLOAD_SIZE;
std::memcpy(original_payload, payload, PAYLOAD_SIZE);
// This should be true and the unused tailroom should be unmodified
auto ret = p.ensureCapacityAndFillUnused(
- raw_packets_[HF_INET6_TCP].size() - (PAYLOAD_SIZE + 10), 0);
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size() -
+ (PAYLOAD_SIZE + 10),
+ 0);
EXPECT_TRUE(ret);
ret = std::memcmp(original_payload, payload, PAYLOAD_SIZE);
EXPECT_EQ(ret, 0);
// This should fill the payload with zeros
- ret = p.ensureCapacityAndFillUnused(raw_packets_[HF_INET6_TCP].size(), 0);
+ ret = p.ensureCapacityAndFillUnused(
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size(), 0);
EXPECT_TRUE(ret);
uint8_t zeros[PAYLOAD_SIZE];
std::memset(zeros, 0, PAYLOAD_SIZE);
@@ -1014,7 +966,8 @@ TEST_F(PacketTest, TestEnsureCapacityAndFillUnused) {
EXPECT_EQ(ret, 0);
// This should fill the payload with ones
- ret = p.ensureCapacityAndFillUnused(raw_packets_[HF_INET6_TCP].size(), 1);
+ ret = p.ensureCapacityAndFillUnused(
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size(), 1);
EXPECT_TRUE(ret);
uint8_t ones[PAYLOAD_SIZE];
std::memset(ones, 1, PAYLOAD_SIZE);
@@ -1022,7 +975,8 @@ TEST_F(PacketTest, TestEnsureCapacityAndFillUnused) {
EXPECT_EQ(ret, 0);
// This should return false and the payload should be unmodified
- ret = p.ensureCapacityAndFillUnused(raw_packets_[HF_INET6_TCP].size() + 1, 1);
+ ret = p.ensureCapacityAndFillUnused(
+ raw_packets_[HICN_PACKET_FORMAT_IPV6_TCP.as_u32].size() + 1, 1);
EXPECT_FALSE(ret);
ret = std::memcmp(payload, ones, PAYLOAD_SIZE);
EXPECT_EQ(ret, 0);
diff --git a/libtransport/src/test/test_packet_allocator.cc b/libtransport/src/test/test_packet_allocator.cc
index 744f1bd24..0de35a817 100644
--- a/libtransport/src/test/test_packet_allocator.cc
+++ b/libtransport/src/test/test_packet_allocator.cc
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2021 Cisco and/or its affiliates.
+ * Copyright (c) 2021-2022 Cisco and/or its affiliates.
* 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:
@@ -70,11 +70,11 @@ class PacketAllocatorTest : public ::testing::Test {
};
TEST_F(PacketAllocatorTest, ContentObjectAllocation) {
- allocationTest<core::ContentObject>(HF_INET_TCP);
+ allocationTest<core::ContentObject>(HICN_PACKET_FORMAT_IPV4_TCP);
}
TEST_F(PacketAllocatorTest, InterestAllocation) {
- allocationTest<core::Interest>(HF_INET_TCP);
+ allocationTest<core::Interest>(HICN_PACKET_FORMAT_IPV4_TCP);
}
// TEST_F(PacketAllocatorTest, MemBufAllocation) {
@@ -83,7 +83,8 @@ TEST_F(PacketAllocatorTest, InterestAllocation) {
TEST_F(PacketAllocatorTest, CheckAllocationIsCorrect) {
// Create packet
- auto packet = allocator_.getPacket<core::ContentObject>(HF_INET_TCP);
+ auto packet =
+ allocator_.getPacket<core::ContentObject>(HICN_PACKET_FORMAT_IPV4_TCP);
// Address of actual buffer
uint8_t *buffer_address = packet->writableData();
@@ -128,4 +129,4 @@ TEST_F(PacketAllocatorTest, CheckAllocationSpeed) {
}
} // namespace core
-} // namespace transport \ No newline at end of file
+} // namespace transport
diff --git a/libtransport/src/test/test_prefix.cc b/libtransport/src/test/test_prefix.cc
index 5de737566..3eab72bcb 100644
--- a/libtransport/src/test/test_prefix.cc
+++ b/libtransport/src/test/test_prefix.cc
@@ -194,47 +194,47 @@ TEST_F(PrefixTest, SetGetNetwork) {
TEST_F(PrefixTest, Contains) {
// IPv6 prefix
Prefix p0(prefix_str0);
- ip_address_t ip0, ip1;
+ hicn_ip_address_t ip0, ip1;
- ip_address_pton("2001:db8:1::1234", &ip0);
- ip_address_pton("2001:db9:1::1234", &ip1);
+ hicn_ip_address_pton("2001:db8:1::1234", &ip0);
+ hicn_ip_address_pton("2001:db9:1::1234", &ip1);
EXPECT_TRUE(p0.contains(ip0));
EXPECT_FALSE(p0.contains(ip1));
Prefix p1(prefix_str1);
- ip_address_pton("10.11.12.12", &ip0);
- ip_address_pton("10.12.12.13", &ip1);
+ hicn_ip_address_pton("10.11.12.12", &ip0);
+ hicn_ip_address_pton("10.12.12.13", &ip1);
EXPECT_TRUE(p1.contains(ip0));
EXPECT_FALSE(p1.contains(ip1));
Prefix p2(prefix_str2);
- ip_address_pton("2001:db8:1::dbca", &ip0);
- ip_address_pton("10.12.12.12", &ip1);
+ hicn_ip_address_pton("2001:db8:1::dbca", &ip0);
+ hicn_ip_address_pton("10.12.12.12", &ip1);
EXPECT_TRUE(p2.contains(ip0));
EXPECT_FALSE(p2.contains(ip1));
Prefix p3(prefix_str3);
- ip_address_pton("10.11.12.245", &ip0);
- ip_address_pton("10.11.12.1", &ip1);
+ hicn_ip_address_pton("10.11.12.245", &ip0);
+ hicn_ip_address_pton("10.11.12.1", &ip1);
EXPECT_TRUE(p3.contains(ip0));
EXPECT_FALSE(p3.contains(ip1));
// Corner cases
Prefix p4("::/0");
- ip_address_pton("7001:db8:1::1234", &ip0);
- ip_address_pton("8001:db8:1::1234", &ip1);
+ hicn_ip_address_pton("7001:db8:1::1234", &ip0);
+ hicn_ip_address_pton("8001:db8:1::1234", &ip1);
EXPECT_TRUE(p4.contains(ip0));
EXPECT_TRUE(p4.contains(ip1));
// Corner cases
Prefix p5("b001:a:b:c:d:e:f:1/128");
- ip_address_pton("b001:a:b:c:d:e:f:1", &ip0);
- ip_address_pton("b001:a:b:c:d:e:f:2", &ip1);
+ hicn_ip_address_pton("b001:a:b:c:d:e:f:1", &ip0);
+ hicn_ip_address_pton("b001:a:b:c:d:e:f:2", &ip1);
EXPECT_TRUE(p5.contains(ip0));
EXPECT_FALSE(p5.contains(ip1));
@@ -331,4 +331,4 @@ TEST_F(PrefixTest, MakeNameWithIndex) {
} // namespace
} // namespace core
-} // namespace transport \ No newline at end of file
+} // namespace transport