From 0e5d7d7ae04045cae757c159f2a44b0a72524976 Mon Sep 17 00:00:00 2001 From: Matias Fontanini Date: Wed, 17 Feb 2016 21:04:28 -0800 Subject: [PATCH] Use C++11 mode by default --- CMakeLists.txt | 15 +++--- cmake/Modules/CheckCXX11Features.cmake | 2 + .../CheckCXX11Features/cxx11-test-declval.cpp | 19 +++++++ include/tins/ip_reassembler.h | 41 +++++++++++---- include/tins/pdu_option.h | 2 +- include/tins/sniffer.h | 2 +- tests/src/dns.cpp | 28 +++++----- tests/src/icmp.cpp | 6 +-- tests/src/icmp_extension.cpp | 4 +- tests/src/icmpv6.cpp | 2 +- tests/src/ip.cpp | 6 +-- tests/src/ipv6.cpp | 6 +-- tests/src/mpls.cpp | 6 +-- tests/src/tcp_ip.cpp | 52 +++++++++++-------- 14 files changed, 122 insertions(+), 69 deletions(-) create mode 100644 cmake/Modules/CheckCXX11Features/cxx11-test-declval.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 9cdf83d..5c76e2c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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 diff --git a/cmake/Modules/CheckCXX11Features.cmake b/cmake/Modules/CheckCXX11Features.cmake index 05c986c..fceca53 100644 --- a/cmake/Modules/CheckCXX11Features.cmake +++ b/cmake/Modules/CheckCXX11Features.cmake @@ -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) diff --git a/cmake/Modules/CheckCXX11Features/cxx11-test-declval.cpp b/cmake/Modules/CheckCXX11Features/cxx11-test-declval.cpp new file mode 100644 index 0000000..e0ed16f --- /dev/null +++ b/cmake/Modules/CheckCXX11Features/cxx11-test-declval.cpp @@ -0,0 +1,19 @@ +// Example code taken from http://en.cppreference.com/w/cpp/utility/declval + +#include +#include + +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().foo()) n2 = n1; // type of n2 is int + return (n1 == 1 && n2 == 1) ? 0 : 1; +} \ No newline at end of file diff --git a/include/tins/ip_reassembler.h b/include/tins/ip_reassembler.h index 73f863f..83a2db7 100644 --- a/include/tins/ip_reassembler.h +++ b/include/tins/ip_reassembler.h @@ -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 IPv4ReassemblerProxy make_ipv4_reassembler_proxy(Functor func) { return IPv4ReassemblerProxy(func); } -} +} // Tins #endif // TINS_IP_REASSEMBLER_H diff --git a/include/tins/pdu_option.h b/include/tins/pdu_option.h index 5d79e29..ab63796 100644 --- a/include/tins/pdu_option.h +++ b/include/tins/pdu_option.h @@ -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; } diff --git a/include/tins/sniffer.h b/include/tins/sniffer.h index 279f416..7de373e 100644 --- a/include/tins/sniffer.h +++ b/include/tins/sniffer.h @@ -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); } diff --git a/tests/src/dns.cpp b/tests/src/dns.cpp index dd72bed..183c2fc 100644 --- a/tests/src/dns.cpp +++ b/tests/src/dns.cpp @@ -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()); } diff --git a/tests/src/icmp.cpp b/tests/src/icmp.cpp index a9a86ab..ba17f85 100644 --- a/tests/src/icmp.cpp +++ b/tests/src/icmp.cpp @@ -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() diff --git a/tests/src/icmp_extension.cpp b/tests/src/icmp_extension.cpp index ab57414..e0f235d 100644 --- a/tests/src/icmp_extension.cpp +++ b/tests/src/icmp_extension.cpp @@ -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()); diff --git a/tests/src/icmpv6.cpp b/tests/src/icmpv6.cpp index 1268095..bf8298b 100644 --- a/tests/src/icmpv6.cpp +++ b/tests/src/icmpv6.cpp @@ -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 aux_data; diff --git a/tests/src/ip.cpp b/tests/src/ip.cpp index 79a72ce..701688a 100644 --- a/tests/src/ip.cpp +++ b/tests/src/ip.cpp @@ -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().extensions().extensions().size()); + ASSERT_EQ(1UL, serialized.rfind_pdu().extensions().extensions().size()); EXPECT_EQ(ext_payload, serialized.rfind_pdu().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().extensions().extensions().size()); + ASSERT_EQ(1UL, serialized.rfind_pdu().extensions().extensions().size()); EXPECT_EQ(ext_payload, serialized.rfind_pdu().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().extensions().extensions().size()); + ASSERT_EQ(1UL, serialized.rfind_pdu().extensions().extensions().size()); EXPECT_EQ(ext_payload, serialized.rfind_pdu().extensions().extensions().begin()->payload()); } diff --git a/tests/src/ipv6.cpp b/tests/src/ipv6.cpp index 54755ef..35f9d37 100644 --- a/tests/src/ipv6.cpp +++ b/tests/src/ipv6.cpp @@ -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().extensions().extensions().size()); + ASSERT_EQ(1UL, serialized.rfind_pdu().extensions().extensions().size()); EXPECT_EQ(ext_payload, serialized.rfind_pdu().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().extensions().extensions().size()); + ASSERT_EQ(1UL, serialized.rfind_pdu().extensions().extensions().size()); EXPECT_EQ(ext_payload, serialized.rfind_pdu().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().extensions().extensions().size()); + ASSERT_EQ(1UL, serialized.rfind_pdu().extensions().extensions().size()); EXPECT_EQ(ext_payload, serialized.rfind_pdu().extensions().extensions().begin()->payload()); } diff --git a/tests/src/mpls.cpp b/tests/src/mpls.cpp index d87f10b..a1e7662 100644 --- a/tests/src/mpls.cpp +++ b/tests/src/mpls.cpp @@ -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) { diff --git a/tests/src/tcp_ip.cpp b/tests/src/tcp_ip.cpp index 5c495fa..2f36527 100644 --- a/tests/src/tcp_ip.cpp +++ b/tests/src/tcp_ip.cpp @@ -1,8 +1,8 @@ #include "cxxstd.h" +#include #if TINS_IS_CXX11 -#include #include #include #include @@ -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::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