3rd-party/libtins
1
0
Fork 0
mirror of https://github.com/mfontanini/libtins synced 2026-01-23 02:35:57 +01:00
Code Issues Releases Wiki Activity

Use C++11 mode by default

Browse Source
This commit is contained in:
Matias Fontanini
2016-02-17 21:04:28 -08:00
parent 9ef6f7a612
commit 0e5d7d7ae0
14 changed files with 122 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
CMakeLists.txt
View File

@@ -63,16 +63,19 @@ INCLUDE(ExternalProject)
# *******************
# C++11 support
OPTION(LIBTINS_ENABLE_CXX11 "Compile libtins with c++11 features" OFF)
OPTION(LIBTINS_ENABLE_CXX11 "Compile libtins with c++11 features" ON)
IF(LIBTINS_ENABLE_CXX11)
SET(HAVE_CXX11 ON)
INCLUDE(CheckCXX11Features)
IF(HAS_CXX11_NULLPTR AND HAS_CXX11_RVALUE_REFERENCES)
# We only use declval and decltype on gcc/clang as VC fails to build that code,
# at least on VC2013
IF(HAS_CXX11_RVALUE_REFERENCES AND ((HAS_CXX11_DECLVAL AND HAS_CXX11_DECLTYPE) OR MSVC))
SET(HAVE_CXX11 ON)
MESSAGE(STATUS "Enabling C++11 features")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX11_COMPILER_FLAGS}")
ELSE(HAS_CXX11_NULLPTR AND HAS_CXX11_RVALUE_REFERENCES)
MESSAGE(FATAL_ERROR "C++11 features requested but the compiler does not support them.")
ENDIF(HAS_CXX11_NULLPTR AND HAS_CXX11_RVALUE_REFERENCES)
ELSE()
MESSAGE(WARNING "The compiler doesn't support the necessary C++11 features. "
"Disabling C++11 on this build")
ENDIF()
ELSE(LIBTINS_ENABLE_CXX11)
MESSAGE(
WARNING

2
cmake/Modules/CheckCXX11Features.cmake
View File

@@ -10,6 +10,7 @@
# HAS_CXX11_CONSTEXPR - constexpr keyword
# HAS_CXX11_CSTDINT_H - cstdint header
# HAS_CXX11_DECLTYPE - decltype keyword
# HAS_CXX11_DECLVAL - declval feature
# HAS_CXX11_FUNC - __func__ preprocessor constant
# HAS_CXX11_INITIALIZER_LIST - initializer list
# HAS_CXX11_LAMBDA - lambdas
@@ -131,6 +132,7 @@ cxx11_check_feature("class_override_final" HAS_CXX11_CLASS_OVERRIDE)
cxx11_check_feature("constexpr" HAS_CXX11_CONSTEXPR)
cxx11_check_feature("cstdint" HAS_CXX11_CSTDINT_H)
cxx11_check_feature("decltype" HAS_CXX11_DECLTYPE)
cxx11_check_feature("declval" HAS_CXX11_DECLVAL)
cxx11_check_feature("initializer_list" HAS_CXX11_INITIALIZER_LIST)
cxx11_check_feature("lambda" HAS_CXX11_LAMBDA)
cxx11_check_feature("long_long" HAS_CXX11_LONG_LONG)

19
cmake/Modules/CheckCXX11Features/cxx11-test-declval.cpp Normal file
View File

@@ -0,0 +1,19 @@
// Example code taken from http://en.cppreference.com/w/cpp/utility/declval
#include <utility>
#include <iostream>
struct Default { int foo() const { return 1; } };
struct NonDefault
{
NonDefault(const NonDefault&) { }
int foo() const { return 1; }
};
int main()
{
decltype(Default().foo()) n1 = 1; // type of n1 is int
decltype(std::declval<NonDefault>().foo()) n2 = n1; // type of n2 is int
return (n1 == 1 && n2 == 1) ? 0 : 1;
}

41
include/tins/ip_reassembler.h
View File

@@ -93,6 +93,27 @@ private:
/**
* \brief Reassembles fragmented IP packets.
*
* This class is fairly simple: just feed packets into it using IPv4Reassembler::process.
* If the return value is IPv4Reassembler::FRAGMENTED, then the packet is fragmented
* and we haven't yet seen the missing fragments, hence we can't reassemble it.
* If the function returns either IPv4Reassembler::NOT_FRAGMENTED (meaning the
* packet wasn't fragmented) or IPv4Reassembler::REASSEMBLED (meaning the packet was
* fragmented but it's now reassembled), then you can process the packet normally.
*
* Simple example:
*
* \code
* IPv4Reassembler reassembler;
* Sniffer sniffer = ...;
* sniffer.sniff_loop([&](PDU& pdu) {
* // Process it in any case, unless it's fragmented (and can't be reassembled yet)
* if (reassembler.process(pdu) != IPv4Reassembler::FRAGMENTED) {
* // Now actually process the packet
* process_packet(pdu);
* }
* });
* \endcode
*/
class TINS_API IPv4Reassembler {
public:
@@ -100,17 +121,17 @@ public:
* The status of each processed packet.
*/
enum packet_status {
NOT_FRAGMENTED,
FRAGMENTED,
REASSEMBLED
NOT_FRAGMENTED, ///< The given packet is not fragmented
FRAGMENTED, ///< The given packet is fragmented and can't be reassembled yet
REASSEMBLED ///< The given packet was fragmented but is now reassembled
};
/**
* The type used to represent the overlapped segment
* reassembly technique to be used.
* The type used to represent the overlapped segment reassembly
* technique to be used.
*/
enum overlapping_technique {
NONE
NONE
};
/**
@@ -190,10 +211,12 @@ public:
*/
bool operator()(PDU& pdu) {
// Forward it unless it's fragmented.
if(reassembler_.process(pdu) != IPv4Reassembler::FRAGMENTED)
if (reassembler_.process(pdu) != IPv4Reassembler::FRAGMENTED) {
return functor_(pdu);
else
}
else {
return true;
}
}
private:
IPv4Reassembler reassembler_;
@@ -210,7 +233,7 @@ template<typename Functor>
IPv4ReassemblerProxy<Functor> make_ipv4_reassembler_proxy(Functor func) {
return IPv4ReassemblerProxy<Functor>(func);
}
}
} // Tins
#endif // TINS_IP_REASSEMBLER_H

2
include/tins/pdu_option.h
View File

@@ -368,7 +368,7 @@ public:
}
real_size_ = rhs.real_size_;
if (real_size_ > small_buffer_size) {
payload_.big_buffer_ptr = nullptr;
payload_.big_buffer_ptr = 0;
std::swap(payload_.big_buffer_ptr, rhs.payload_.big_buffer_ptr);
rhs.real_size_ = 0;
}

2
include/tins/sniffer.h
View File

@@ -71,7 +71,7 @@ public:
* This constructor is available only in C++11.
*/
BaseSniffer(BaseSniffer &&rhs) TINS_NOEXCEPT
: handle_(nullptr), mask_(), extract_raw_(false) {
: handle_(0), mask_(), extract_raw_(false) {
*this = std::move(rhs);
}

28
tests/src/dns.cpp
View File

@@ -467,7 +467,7 @@ TEST_F(DNSTest, MXPreferenceField) {
DNS::serialization_type buffer = dns1.serialize();
DNS dns2(&buffer[0], buffer.size());
DNS::resources_type answers = dns1.answers();
ASSERT_EQ(1, answers.size());
ASSERT_EQ(1UL, answers.size());
const DNS::resource& resource = *answers.begin();
EXPECT_EQ(42, resource.preference());
@@ -490,7 +490,7 @@ TEST_F(DNSTest, SOARecordConstructor) {
EXPECT_EQ(0x918273aa, r.refresh());
EXPECT_EQ(0x827361ad, r.retry());
EXPECT_EQ(0x8ad71928, r.expire());
EXPECT_EQ(0x1ad92871, r.minimum_ttl());
EXPECT_EQ(0x1ad92871U, r.minimum_ttl());
}
TEST_F(DNSTest, SOARecordGettersAndSetters) {
@@ -508,7 +508,7 @@ TEST_F(DNSTest, SOARecordGettersAndSetters) {
EXPECT_EQ(0x918273aa, r.refresh());
EXPECT_EQ(0x827361ad, r.retry());
EXPECT_EQ(0x8ad71928, r.expire());
EXPECT_EQ(0x1ad92871, r.minimum_ttl());
EXPECT_EQ(0x1ad92871U, r.minimum_ttl());
}
TEST_F(DNSTest, SOARecordFromBuffer) {
@@ -521,16 +521,16 @@ TEST_F(DNSTest, SOARecordFromBuffer) {
};
DNS dns(raw, sizeof(raw));
ASSERT_EQ(1, dns.answers().size());
ASSERT_EQ(1UL, dns.answers().size());
DNS::resource r(dns.answers().front());
DNS::soa_record soa(r);
EXPECT_EQ("ns2.google.com", soa.mname());
EXPECT_EQ("dns-admin.google.com", soa.rname());
EXPECT_EQ(112108372, soa.serial());
EXPECT_EQ(900, soa.refresh());
EXPECT_EQ(900, soa.retry());
EXPECT_EQ(1800, soa.expire());
EXPECT_EQ(60, soa.minimum_ttl());
EXPECT_EQ(112108372U, soa.serial());
EXPECT_EQ(900U, soa.refresh());
EXPECT_EQ(900U, soa.retry());
EXPECT_EQ(1800U, soa.expire());
EXPECT_EQ(60U, soa.minimum_ttl());
}
TEST_F(DNSTest, SOARecordSerialize) {
@@ -547,9 +547,9 @@ TEST_F(DNSTest, SOARecordSerialize) {
DNS::soa_record r2(&buffer[0], buffer.size());
EXPECT_EQ("hehehehe.example.com", r2.mname());
EXPECT_EQ("john.example.com", r2.rname());
EXPECT_EQ(0x9823ade9, r2.serial());
EXPECT_EQ(0x918273aa, r2.refresh());
EXPECT_EQ(0x827361ad, r2.retry());
EXPECT_EQ(0x8ad71928, r2.expire());
EXPECT_EQ(0x1ad92871, r2.minimum_ttl());
EXPECT_EQ(0x9823ade9U, r2.serial());
EXPECT_EQ(0x918273aaU, r2.refresh());
EXPECT_EQ(0x827361adU, r2.retry());
EXPECT_EQ(0x8ad71928U, r2.expire());
EXPECT_EQ(0x1ad92871U, r2.minimum_ttl());
}

6
tests/src/icmp.cpp
View File

@@ -313,9 +313,9 @@ TEST_F(ICMPTest, ExtensionsParsingWithoutALengthField) {
const uint8_t ext[] = { 0, 8, 1, 1, 24, 150, 1, 1 };
ICMP icmp(packet_with_extensions, sizeof(packet_with_extensions));
ICMPExtensionsStructure extensions = icmp.extensions();
ASSERT_EQ(1, extensions.extensions().size());
ASSERT_EQ(1UL, extensions.extensions().size());
MPLS mpls(*extensions.extensions().begin());
EXPECT_EQ(100704, mpls.label());
EXPECT_EQ(100704U, mpls.label());
EXPECT_EQ(
ICMPExtension::payload_type(ext, ext + sizeof(ext)),
extensions.extensions().begin()->serialize()
@@ -340,7 +340,7 @@ TEST_F(ICMPTest, ExtensionsParsingWithALengthField) {
const uint8_t ext[] = { 0, 8, 1, 1, 24, 150, 1, 1 };
ICMP icmp(packet_with_extensions_and_length, sizeof(packet_with_extensions_and_length));
ICMPExtensionsStructure extensions = icmp.extensions();
ASSERT_EQ(1, extensions.extensions().size());
ASSERT_EQ(1UL, extensions.extensions().size());
EXPECT_EQ(
ICMPExtension::payload_type(ext, ext + sizeof(ext)),
extensions.extensions().begin()->serialize()

4
tests/src/icmp_extension.cpp
View File

@@ -64,7 +64,7 @@ TEST_F(ICMPExtensionTest, ExtensionStructureFromBuffer) {
EXPECT_EQ(0, structure.reserved());
EXPECT_EQ(0xc55f, structure.checksum());
const ICMPExtensionsStructure::extensions_type& extensions = structure.extensions();
EXPECT_EQ(1, extensions.size());
EXPECT_EQ(1UL, extensions.size());
const ICMPExtension& ext = *extensions.begin();
const uint8_t payload[] = { 24, 150, 1, 1 };
@@ -107,7 +107,7 @@ TEST_F(ICMPExtensionTest, MPLSExtension) {
PDU::serialization_type buffer = structure.serialize();
ICMPExtensionsStructure new_structure(&buffer[0], buffer.size());
ASSERT_EQ(1, new_structure.extensions().size());
ASSERT_EQ(1UL, new_structure.extensions().size());
MPLS mpls2(*new_structure.extensions().begin());
EXPECT_EQ(mpls1.label(), mpls2.label());
EXPECT_EQ(mpls1.bottom_of_stack(), mpls2.bottom_of_stack());

2
tests/src/icmpv6.cpp
View File

@@ -143,7 +143,7 @@ TEST_F(ICMPv6Test, ConstructorFromBuffer_MLD2_Layer) {
ICMPv6 icmp(mld2_icmpv6_layer, sizeof(mld2_icmpv6_layer));
ICMPv6::multicast_address_records_list records = icmp.multicast_address_records();
ASSERT_EQ(1, records.size());
ASSERT_EQ(1UL, records.size());
ICMPv6::multicast_address_record r = *records.begin();
EXPECT_EQ(1, r.type);
std::vector<uint8_t> aux_data;

6
tests/src/ip.cpp
View File

@@ -808,7 +808,7 @@ TEST_F(IPTest, SerializePacketHavingICMPExtensionsWithLengthAndLotsOfPayload) {
PDU::serialization_type buffer = pkt.serialize();
EthernetII serialized(&buffer[0], buffer.size());
ASSERT_EQ(1, serialized.rfind_pdu<ICMP>().extensions().extensions().size());
ASSERT_EQ(1UL, serialized.rfind_pdu<ICMP>().extensions().extensions().size());
EXPECT_EQ(ext_payload, serialized.rfind_pdu<ICMP>().extensions().extensions().begin()->payload());
}
@@ -825,7 +825,7 @@ TEST_F(IPTest, SerializePacketHavingICMPExtensionsWithLengthAndShortPayload) {
PDU::serialization_type buffer = pkt.serialize();
EthernetII serialized(&buffer[0], buffer.size());
ASSERT_EQ(1, serialized.rfind_pdu<ICMP>().extensions().extensions().size());
ASSERT_EQ(1UL, serialized.rfind_pdu<ICMP>().extensions().extensions().size());
EXPECT_EQ(ext_payload, serialized.rfind_pdu<ICMP>().extensions().extensions().begin()->payload());
}
@@ -842,6 +842,6 @@ TEST_F(IPTest, SerializePacketHavingICMPExtensionsWithoutLengthAndShortPayload)
PDU::serialization_type buffer = pkt.serialize();
EthernetII serialized(&buffer[0], buffer.size());
ASSERT_EQ(1, serialized.rfind_pdu<ICMP>().extensions().extensions().size());
ASSERT_EQ(1UL, serialized.rfind_pdu<ICMP>().extensions().extensions().size());
EXPECT_EQ(ext_payload, serialized.rfind_pdu<ICMP>().extensions().extensions().begin()->payload());
}

6
tests/src/ipv6.cpp
View File

@@ -232,7 +232,7 @@ TEST_F(IPv6Test, SerializePacketHavingICMPExtensionsWithLengthAndLotsOfPayload)
PDU::serialization_type buffer = pkt.serialize();
EthernetII serialized(&buffer[0], buffer.size());
ASSERT_EQ(1, serialized.rfind_pdu<ICMPv6>().extensions().extensions().size());
ASSERT_EQ(1UL, serialized.rfind_pdu<ICMPv6>().extensions().extensions().size());
EXPECT_EQ(ext_payload, serialized.rfind_pdu<ICMPv6>().extensions().extensions().begin()->payload());
}
@@ -249,7 +249,7 @@ TEST_F(IPv6Test, SerializePacketHavingICMPExtensionsWithLengthAndShortPayload) {
PDU::serialization_type buffer = pkt.serialize();
EthernetII serialized(&buffer[0], buffer.size());
ASSERT_EQ(1, serialized.rfind_pdu<ICMPv6>().extensions().extensions().size());
ASSERT_EQ(1UL, serialized.rfind_pdu<ICMPv6>().extensions().extensions().size());
EXPECT_EQ(ext_payload, serialized.rfind_pdu<ICMPv6>().extensions().extensions().begin()->payload());
}
@@ -266,6 +266,6 @@ TEST_F(IPv6Test, SerializePacketHavingICMPExtensionsWithoutLengthAndShortPayload
PDU::serialization_type buffer = pkt.serialize();
EthernetII serialized(&buffer[0], buffer.size());
ASSERT_EQ(1, serialized.rfind_pdu<ICMPv6>().extensions().extensions().size());
ASSERT_EQ(1UL, serialized.rfind_pdu<ICMPv6>().extensions().extensions().size());
EXPECT_EQ(ext_payload, serialized.rfind_pdu<ICMPv6>().extensions().extensions().begin()->payload());
}

6
tests/src/mpls.cpp
View File

@@ -62,7 +62,7 @@ TEST_F(MPLSTest, ConstructWholePacket) {
TEST_F(MPLSTest, ConstructorFromBuffer) {
MPLS mpls(mpls_layer, sizeof(mpls_layer));
EXPECT_EQ(100704, mpls.label());
EXPECT_EQ(100704U, mpls.label());
EXPECT_EQ(1, mpls.bottom_of_stack());
EXPECT_EQ(1, mpls.ttl());
}
@@ -100,7 +100,7 @@ TEST_F(MPLSTest, SetAllFields) {
mpls.ttl(0xde);
mpls.bottom_of_stack(1);
mpls.label(0xdead8);
EXPECT_EQ(0xdead8, mpls.label());
EXPECT_EQ(0xdead8U, mpls.label());
EXPECT_EQ(1, mpls.bottom_of_stack());
EXPECT_EQ(0xde, mpls.ttl());
}
@@ -108,7 +108,7 @@ TEST_F(MPLSTest, SetAllFields) {
TEST_F(MPLSTest, Label) {
MPLS mpls;
mpls.label(0xdead8);
EXPECT_EQ(0xdead8, mpls.label());
EXPECT_EQ(0xdead8U, mpls.label());
}
TEST_F(MPLSTest, BottomOfStack) {

52
tests/src/tcp_ip.cpp
View File

@@ -1,8 +1,8 @@
#include "cxxstd.h"
#include <gtest/gtest.h>
#if TINS_IS_CXX11
#include <gtest/gtest.h>
#include <iostream>
#include <algorithm>
#include <string>
@@ -151,7 +151,7 @@ void FlowTest::run_test(uint32_t initial_seq, const ordering_info_type& chunks,
}
string flow_payload = merge_chunks(flow_payload_chunks);
EXPECT_EQ(payload, string(flow_payload.begin(), flow_payload.end()));
EXPECT_EQ(0, flow.total_buffered_bytes());
EXPECT_EQ(0U, flow.total_buffered_bytes());
EXPECT_TRUE(flow.buffered_payload().empty());
}
@@ -353,8 +353,8 @@ TEST_F(FlowTest, StreamFollower_ThreeWayHandshake) {
IPv4Address("4.3.2.1"), 25);
EXPECT_EQ(Flow::ESTABLISHED, stream.client_flow().state());
EXPECT_EQ(Flow::SYN_SENT, stream.server_flow().state());
EXPECT_EQ(30, stream.client_flow().sequence_number());
EXPECT_EQ(60, stream.server_flow().sequence_number());
EXPECT_EQ(30U, stream.client_flow().sequence_number());
EXPECT_EQ(60U, stream.server_flow().sequence_number());
EXPECT_EQ(IPv4Address("4.3.2.1"), stream.client_flow().dst_addr_v4());
EXPECT_EQ(25, stream.client_flow().dport());
EXPECT_EQ(IPv4Address("1.2.3.4"), stream.server_flow().dst_addr_v4());
@@ -373,7 +373,7 @@ TEST_F(FlowTest, StreamFollower_ThreeWayHandshake) {
follower.process_packet(server_packet);
EXPECT_EQ(Flow::ESTABLISHED, stream.server_flow().state());
EXPECT_EQ(61, stream.server_flow().sequence_number());
EXPECT_EQ(61U, stream.server_flow().sequence_number());
}
TEST_F(FlowTest, StreamFollower_TCPOptions) {
@@ -601,20 +601,20 @@ TEST_F(AckTrackerTest, AckedRange_WrapAround) {
TEST_F(AckTrackerTest, AckingTcp1) {
AckTracker tracker(0, false);
EXPECT_EQ(0, tracker.ack_number());
EXPECT_EQ(0U, tracker.ack_number());
tracker.process_packet(make_tcp_ack(100));
EXPECT_EQ(100, tracker.ack_number());
EXPECT_EQ(100U, tracker.ack_number());
EXPECT_TRUE(tracker.is_segment_acked(0, 10));
EXPECT_TRUE(tracker.is_segment_acked(50, 10));
EXPECT_TRUE(tracker.is_segment_acked(99, 1));
EXPECT_FALSE(tracker.is_segment_acked(90, 20));
EXPECT_FALSE(tracker.is_segment_acked(99, 2));
tracker.process_packet(make_tcp_ack(50));
EXPECT_EQ(100, tracker.ack_number());
EXPECT_EQ(100U, tracker.ack_number());
tracker.process_packet(make_tcp_ack(150));
EXPECT_EQ(150, tracker.ack_number());
EXPECT_EQ(150U, tracker.ack_number());
tracker.process_packet(make_tcp_ack(200));
EXPECT_EQ(200, tracker.ack_number());
EXPECT_EQ(200U, tracker.ack_number());
}
TEST_F(AckTrackerTest, AckingTcp2) {
@@ -626,29 +626,29 @@ TEST_F(AckTrackerTest, AckingTcp2) {
tracker.process_packet(make_tcp_ack(maximum));
EXPECT_EQ(maximum, tracker.ack_number());
tracker.process_packet(make_tcp_ack(5));
EXPECT_EQ(5, tracker.ack_number());
EXPECT_EQ(5U, tracker.ack_number());
}
TEST_F(AckTrackerTest, AckingTcp3) {
uint32_t maximum = numeric_limits<uint32_t>::max();
AckTracker tracker(maximum - 10, false);
tracker.process_packet(make_tcp_ack(5));
EXPECT_EQ(5, tracker.ack_number());
EXPECT_EQ(5U, tracker.ack_number());
}
TEST_F(AckTrackerTest, AckingTcp_Sack1) {
AckTracker tracker(0, true);
tracker.process_packet(make_tcp_ack(0, make_pair(2, 5), make_pair(9, 11)));
EXPECT_EQ(3 + 2, tracker.acked_intervals().size());
EXPECT_EQ(3U + 2U, tracker.acked_intervals().size());
EXPECT_TRUE(tracker.is_segment_acked(2, 3));
EXPECT_TRUE(tracker.is_segment_acked(9, 2));
EXPECT_FALSE(tracker.is_segment_acked(2, 9));
tracker.process_packet(make_tcp_ack(9));
EXPECT_EQ(1, tracker.acked_intervals().size());
EXPECT_EQ(1UL, tracker.acked_intervals().size());
tracker.process_packet(make_tcp_ack(15));
EXPECT_EQ(0, tracker.acked_intervals().size());
EXPECT_EQ(0UL, tracker.acked_intervals().size());
}
TEST_F(AckTrackerTest, AckingTcp_Sack2) {
@@ -659,20 +659,20 @@ TEST_F(AckTrackerTest, AckingTcp_Sack2) {
make_pair(maximum - 3, maximum),
make_pair(0, 10)
));
EXPECT_EQ(3 + 10, tracker.acked_intervals().size());
EXPECT_EQ(3U + 10U, tracker.acked_intervals().size());
EXPECT_TRUE(tracker.is_segment_acked(maximum - 12, 2));
EXPECT_TRUE(tracker.is_segment_acked(maximum - 2, 1));
EXPECT_TRUE(tracker.is_segment_acked(2, 3));
EXPECT_FALSE(tracker.is_segment_acked(maximum - 10, 10));
tracker.process_packet(make_tcp_ack(maximum - 2));
EXPECT_EQ(1 + 10, tracker.acked_intervals().size());
EXPECT_EQ(1U + 10U, tracker.acked_intervals().size());
tracker.process_packet(make_tcp_ack(5));
EXPECT_EQ(4, tracker.acked_intervals().size());
EXPECT_EQ(4U, tracker.acked_intervals().size());
tracker.process_packet(make_tcp_ack(15));
EXPECT_EQ(0, tracker.acked_intervals().size());
EXPECT_EQ(0U, tracker.acked_intervals().size());
}
TEST_F(AckTrackerTest, AckingTcp_Sack3) {
@@ -682,10 +682,10 @@ TEST_F(AckTrackerTest, AckingTcp_Sack3) {
maximum - 10,
make_pair(maximum - 3, 5)
));
EXPECT_EQ(9, tracker.acked_intervals().size());
EXPECT_EQ(9U, tracker.acked_intervals().size());
tracker.process_packet(make_tcp_ack(maximum));
EXPECT_EQ(5, tracker.acked_intervals().size());
EXPECT_EQ(5U, tracker.acked_intervals().size());
}
TEST_F(FlowTest, AckNumbersAreCorrect) {
@@ -703,10 +703,16 @@ TEST_F(FlowTest, AckNumbersAreCorrect) {
}
Stream& stream = follower.find_stream(IPv4Address("1.2.3.4"), 22,
IPv4Address("4.3.2.1"), 25);
EXPECT_EQ(1717, stream.client_flow().ack_tracker().ack_number());
EXPECT_EQ(9898, stream.server_flow().ack_tracker().ack_number());
EXPECT_EQ(1717U, stream.client_flow().ack_tracker().ack_number());
EXPECT_EQ(9898U, stream.server_flow().ack_tracker().ack_number());
}
#endif // HAVE_ACK_TRACKER
#else
TEST(Foo, Dummy) {
}
#endif // TINS_IS_CXX11