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

Fix tests compilation warnings on Windows.

Browse Source
This commit is contained in:
Matias Fontanini
2015-05-16 11:08:52 -07:00
parent 325de4abca
commit d4e632f513
41 changed files with 163 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
tests/include/tests/dot11_mgmt.h
View File

@@ -68,22 +68,22 @@ inline void test_equals(const capability_information &info1, const capability_in
}
inline void test_equals_empty(const capability_information &info) {
EXPECT_EQ(info.ess(), 0);
EXPECT_EQ(info.ibss(), 0);
EXPECT_EQ(info.cf_poll(), 0);
EXPECT_EQ(info.cf_poll_req(), 0);
EXPECT_EQ(info.privacy(), 0);
EXPECT_EQ(info.short_preamble(), 0);
EXPECT_EQ(info.pbcc(), 0);
EXPECT_EQ(info.channel_agility(), 0);
EXPECT_EQ(info.spectrum_mgmt(), 0);
EXPECT_EQ(info.qos(), 0);
EXPECT_EQ(info.sst(), 0);
EXPECT_EQ(info.apsd(), 0);
EXPECT_EQ(info.radio_measurement(), 0);
EXPECT_EQ(info.dsss_ofdm(), 0);
EXPECT_EQ(info.delayed_block_ack(), 0);
EXPECT_EQ(info.immediate_block_ack(), 0);
EXPECT_EQ(info.ess(), false);
EXPECT_EQ(info.ibss(), false);
EXPECT_EQ(info.cf_poll(), false);
EXPECT_EQ(info.cf_poll_req(), false);
EXPECT_EQ(info.privacy(), false);
EXPECT_EQ(info.short_preamble(), false);
EXPECT_EQ(info.pbcc(), false);
EXPECT_EQ(info.channel_agility(), false);
EXPECT_EQ(info.spectrum_mgmt(), false);
EXPECT_EQ(info.qos(), false);
EXPECT_EQ(info.sst(), false);
EXPECT_EQ(info.apsd(), false);
EXPECT_EQ(info.radio_measurement(), false);
EXPECT_EQ(info.dsss_ofdm(), false);
EXPECT_EQ(info.delayed_block_ack(), false);
EXPECT_EQ(info.immediate_block_ack(), false);
}
#endif // TINS_DOT11_MGMT_TEST_H

16
tests/src/allocators.cpp
View File

@@ -76,22 +76,22 @@ TEST_F(AllocatorsTest, LinkLayerPDUs) {
);
{
EthernetII pkt(&link_layer_data[0], link_layer_data.size());
EXPECT_TRUE(pkt.find_pdu<DummyPDU<0> >());
EXPECT_TRUE(pkt.find_pdu<DummyPDU<0> >() != NULL);
EXPECT_EQ(pkt.serialize(), link_layer_data);
}
{
SNAP pkt(&link_layer_data[0], link_layer_data.size());
EXPECT_TRUE(pkt.find_pdu<DummyPDU<1> >());
EXPECT_TRUE(pkt.find_pdu<DummyPDU<1> >() != NULL);
EXPECT_EQ(pkt.serialize(), link_layer_data);
}
{
Dot1Q pkt(&link_layer_data[0], link_layer_data.size());
EXPECT_TRUE(pkt.find_pdu<DummyPDU<2> >());
EXPECT_TRUE(pkt.find_pdu<DummyPDU<2> >() != NULL);
EXPECT_EQ(pkt.serialize(), link_layer_data);
}
{
SLL pkt(&link_layer_data[0], link_layer_data.size());
EXPECT_TRUE(pkt.find_pdu<DummyPDU<3> >());
EXPECT_TRUE(pkt.find_pdu<DummyPDU<3> >() != NULL);
EXPECT_EQ(pkt.serialize(), link_layer_data);
}
}
@@ -103,8 +103,8 @@ TEST_F(AllocatorsTest, IP) {
);
Allocators::register_allocator<IP, DummyPDU<0> >(255);
EthernetII pkt(&ipv4_data[0], ipv4_data.size());
EXPECT_TRUE(pkt.find_pdu<IP>());
EXPECT_TRUE(pkt.find_pdu<DummyPDU<0> >());
EXPECT_TRUE(pkt.find_pdu<IP>() != NULL);
EXPECT_TRUE(pkt.find_pdu<DummyPDU<0> >() != NULL);
EXPECT_EQ(pkt.serialize(), ipv4_data);
}
@@ -116,8 +116,8 @@ TEST_F(AllocatorsTest, IPv6) {
Allocators::register_allocator<IPv6, DummyPDU<0> >(250);
{
EthernetII pkt(&ipv6_data[0], ipv6_data.size());
EXPECT_TRUE(pkt.find_pdu<IPv6>());
EXPECT_TRUE(pkt.find_pdu<DummyPDU<0> >());
EXPECT_TRUE(pkt.find_pdu<IPv6>() != NULL);
EXPECT_TRUE(pkt.find_pdu<DummyPDU<0> >() != NULL);
EXPECT_EQ(pkt.serialize(), ipv6_data);
}
}

2
tests/src/arp.cpp
View File

@@ -44,7 +44,7 @@ void ARPTest::test_equals(const ARP &arp1, const ARP &arp2) {
EXPECT_EQ(arp1.target_ip_addr(), arp2.target_ip_addr());
EXPECT_EQ(arp1.sender_hw_addr(), arp2.sender_hw_addr());
EXPECT_EQ(arp1.target_hw_addr(), arp2.target_hw_addr());
EXPECT_EQ((bool)arp1.inner_pdu(), (bool)arp2.inner_pdu());
EXPECT_EQ(arp1.inner_pdu() != NULL, arp2.inner_pdu() != NULL);
}
TEST_F(ARPTest, DefaultContructor) {

10
tests/src/dhcpv6.cpp
View File

@@ -30,11 +30,11 @@ TEST_F(DHCPv6Test, ConstructorFromBuffer) {
DHCPv6 dhcp(expected_packet, sizeof(expected_packet));
EXPECT_EQ(DHCPv6::SOLICIT, dhcp.msg_type());
EXPECT_EQ(0xe828b9U, dhcp.transaction_id());
EXPECT_TRUE(dhcp.search_option(DHCPv6::CLIENTID));
EXPECT_TRUE(dhcp.search_option(DHCPv6::IA_NA));
EXPECT_TRUE(dhcp.search_option(DHCPv6::ELAPSED_TIME));
EXPECT_TRUE(dhcp.search_option(DHCPv6::OPTION_REQUEST));
EXPECT_FALSE(dhcp.search_option(DHCPv6::SERVERID));
EXPECT_TRUE(dhcp.search_option(DHCPv6::CLIENTID) != NULL);
EXPECT_TRUE(dhcp.search_option(DHCPv6::IA_NA) != NULL);
EXPECT_TRUE(dhcp.search_option(DHCPv6::ELAPSED_TIME) != NULL);
EXPECT_TRUE(dhcp.search_option(DHCPv6::OPTION_REQUEST) != NULL);
EXPECT_FALSE(dhcp.search_option(DHCPv6::SERVERID) != NULL);
}
TEST_F(DHCPv6Test, Serialize) {

2
tests/src/dns.cpp
View File

@@ -63,7 +63,7 @@ void DNSTest::test_equals(const DNS &dns1, const DNS &dns2) {
EXPECT_EQ(dns1.additional_count(), dns2.additional_count());
EXPECT_EQ(dns1.pdu_type(), dns2.pdu_type());
EXPECT_EQ(dns1.header_size(), dns2.header_size());
EXPECT_EQ(bool(dns1.inner_pdu()), bool(dns2.inner_pdu()));
EXPECT_EQ(dns1.inner_pdu() != NULL, dns2.inner_pdu() != NULL);
}
void DNSTest::test_equals(const DNS::Query &q1, const DNS::Query &q2) {

4
tests/src/dot11/ack.cpp
View File

@@ -88,9 +88,9 @@ TEST_F(Dot11AckTest, ClonePDU) {
TEST_F(Dot11AckTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11Ack *inner = dot11->find_pdu<Dot11Ack>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/assoc_response.cpp
View File

@@ -85,9 +85,9 @@ TEST_F(Dot11AssocResponseTest, ClonePDU) {
TEST_F(Dot11AssocResponseTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11AssocResponse *inner = dot11->find_pdu<Dot11AssocResponse>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/authentication.cpp
View File

@@ -93,9 +93,9 @@ TEST_F(Dot11AuthenticationTest, ClonePDU) {
TEST_F(Dot11AuthenticationTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11Authentication *inner = dot11->find_pdu<Dot11Authentication>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/block_ack_request.cpp
View File

@@ -81,9 +81,9 @@ TEST_F(Dot11BlockAckRequestTest, ClonePDU) {
TEST_F(Dot11BlockAckRequestTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11BlockAckRequest *inner = dot11->find_pdu<Dot11BlockAckRequest>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/cfend.cpp
View File

@@ -65,9 +65,9 @@ TEST_F(Dot11CFEndTest, ClonePDU) {
TEST_F(Dot11CFEndTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11CFEnd *inner = dot11->find_pdu<Dot11CFEnd>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/cfendack.cpp
View File

@@ -65,9 +65,9 @@ TEST_F(Dot11EndCFAckTest, ClonePDU) {
TEST_F(Dot11EndCFAckTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11EndCFAck *inner = dot11->find_pdu<Dot11EndCFAck>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/data.cpp
View File

@@ -103,9 +103,9 @@ TEST_F(Dot11DataTest, ClonePDU) {
TEST_F(Dot11DataTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11Data *inner = dot11->find_pdu<Dot11Data>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/deauthentication.cpp
View File

@@ -75,9 +75,9 @@ TEST_F(Dot11DeauthenticationTest, ClonePDU) {
TEST_F(Dot11DeauthenticationTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11Deauthentication *inner = dot11->find_pdu<Dot11Deauthentication>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/disassoc.cpp
View File

@@ -76,9 +76,9 @@ TEST_F(Dot11DisassocTest, ClonePDU) {
TEST_F(Dot11DisassocTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11Disassoc *inner = dot11->find_pdu<Dot11Disassoc>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

12
tests/src/dot11/dot11.cpp
View File

@@ -96,14 +96,14 @@ TEST_F(Dot11Test, Subtype) {
TEST_F(Dot11Test, ToDS) {
Dot11 dot11;
dot11.to_ds(true);
EXPECT_EQ(dot11.to_ds(), true);
dot11.to_ds(1);
EXPECT_EQ(1, dot11.to_ds());
}
TEST_F(Dot11Test, FromDS) {
Dot11 dot11;
dot11.from_ds(true);
EXPECT_EQ(dot11.from_ds(), true);
dot11.from_ds(1);
EXPECT_EQ(1, dot11.from_ds());
}
TEST_F(Dot11Test, MoreFrag) {
@@ -151,8 +151,8 @@ TEST_F(Dot11Test, Addr1) {
TEST_F(Dot11Test, AddTaggedOption) {
Dot11 dot11;
dot11.add_option(Dot11::option(Dot11::SSID, hwaddr.begin(), hwaddr.end()));
const Dot11::option *option;
ASSERT_TRUE((option = dot11.search_option(Dot11::SSID)));
const Dot11::option *option = dot11.search_option(Dot11::SSID);
ASSERT_TRUE(option != NULL);
EXPECT_EQ(option->data_size(), hwaddr.size());
EXPECT_EQ(option->option(), Dot11::SSID);
EXPECT_TRUE(std::equal(hwaddr.begin(), hwaddr.end(), option->data_ptr()));

4
tests/src/dot11/probe_request.cpp
View File

@@ -66,9 +66,9 @@ TEST_F(Dot11ProbeRequestTest, ClonePDU) {
TEST_F(Dot11ProbeRequestTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11ProbeRequest *inner = dot11->find_pdu<Dot11ProbeRequest>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/probe_response.cpp
View File

@@ -84,9 +84,9 @@ TEST_F(Dot11ProbeResponseTest, ClonePDU) {
TEST_F(Dot11ProbeResponseTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11ProbeResponse *inner = dot11->find_pdu<Dot11ProbeResponse>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/pspoll.cpp
View File

@@ -65,9 +65,9 @@ TEST_F(Dot11PSPollTest, ClonePDU) {
TEST_F(Dot11PSPollTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11PSPoll *inner = dot11->find_pdu<Dot11PSPoll>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/reassoc_request.cpp
View File

@@ -84,9 +84,9 @@ TEST_F(Dot11ReAssocRequestTest, ClonePDU) {
TEST_F(Dot11ReAssocRequestTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11ReAssocRequest *inner = dot11->find_pdu<Dot11ReAssocRequest>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/reassoc_response.cpp
View File

@@ -73,9 +73,9 @@ TEST_F(Dot11ReAssocResponseTest, ClonePDU) {
TEST_F(Dot11ReAssocResponseTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11ReAssocResponse *inner = dot11->find_pdu<Dot11ReAssocResponse>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot11/rts.cpp
View File

@@ -65,9 +65,9 @@ TEST_F(Dot11RTSTest, ClonePDU) {
TEST_F(Dot11RTSTest, FromBytes) {
Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
ASSERT_TRUE(dot11.get());
ASSERT_TRUE(dot11.get() != NULL);
const Dot11RTS *inner = dot11->find_pdu<Dot11RTS>();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
test_equals_expected(*inner);
}

4
tests/src/dot1q.cpp
View File

@@ -35,14 +35,14 @@ TEST_F(Dot1QTest, DefaultConstructor) {
TEST_F(Dot1QTest, ConstructorFromBuffer) {
EthernetII eth(expected_packet, sizeof(expected_packet));
const Dot1Q *dot1 = eth.find_pdu<Dot1Q>();
ASSERT_TRUE(dot1);
ASSERT_TRUE(dot1 != NULL);
EXPECT_EQ(0x806, dot1->payload_type());
EXPECT_EQ(5, dot1->priority());
EXPECT_EQ(1, dot1->cfi());
EXPECT_EQ(123, dot1->id());
const ARP *arp = dot1->find_pdu<ARP>();
ASSERT_TRUE(arp);
ASSERT_TRUE(arp != NULL);
// just to check it the offset's OK
EXPECT_EQ(ARP::hwaddress_type("00:19:06:ea:b8:c1"), arp->sender_hw_addr());
}

10
tests/src/ethernetII.cpp
View File

@@ -57,7 +57,7 @@ void EthernetIITest::test_equals(const EthernetII &eth1, const EthernetII &eth2)
EXPECT_EQ(eth1.dst_addr(), eth2.dst_addr());
EXPECT_EQ(eth1.src_addr(), eth2.src_addr());
EXPECT_EQ(eth1.payload_type(), eth2.payload_type());
EXPECT_EQ((bool)eth1.inner_pdu(), (bool)eth2.inner_pdu());
EXPECT_EQ(eth1.inner_pdu() != NULL, eth2.inner_pdu() != NULL);
}
TEST_F(EthernetIITest, DefaultConstructor) {
@@ -126,7 +126,7 @@ TEST_F(EthernetIITest, Serialize) {
TEST_F(EthernetIITest, SerializeSmallEthernetWithPadding) {
EthernetII eth(smallip_packet, sizeof(smallip_packet));
ASSERT_TRUE(eth.inner_pdu());
ASSERT_TRUE(eth.inner_pdu() != NULL);
PDU::serialization_type serialized = eth.serialize();
EXPECT_EQ(serialized.size(), sizeof(smallip_packet));
EXPECT_TRUE(std::equal(serialized.begin(), serialized.end(), smallip_packet));
@@ -141,19 +141,19 @@ TEST_F(EthernetIITest, ConstructorFromBuffer) {
TEST_F(EthernetIITest, ConstructorFromIPBuffer) {
EthernetII eth(ip_packet, sizeof(ip_packet));
ASSERT_TRUE(eth.inner_pdu());
ASSERT_TRUE(eth.inner_pdu() != NULL);
EXPECT_EQ(eth.find_pdu<IP>(), eth.inner_pdu());
}
TEST_F(EthernetIITest, ConstructorFromIPv6Buffer) {
EthernetII eth(ipv6_packet, sizeof(ipv6_packet));
ASSERT_TRUE(eth.inner_pdu());
ASSERT_TRUE(eth.inner_pdu() != NULL);
EXPECT_EQ(eth.find_pdu<IPv6>(), eth.inner_pdu());
}
TEST_F(EthernetIITest, EliminateEthernetPadding) {
EthernetII eth(smallip_packet, sizeof(smallip_packet));
ASSERT_TRUE(eth.inner_pdu());
ASSERT_TRUE(eth.inner_pdu() != NULL);
ASSERT_TRUE(eth.find_pdu<IP>());
ASSERT_TRUE(eth.find_pdu<TCP>());
ASSERT_FALSE(eth.find_pdu<RawPDU>());

2
tests/src/icmp.cpp
View File

@@ -243,7 +243,7 @@ void ICMPTest::test_equals(const ICMP &icmp1, const ICMP &icmp2) {
EXPECT_EQ(icmp1.sequence(), icmp2.sequence());
EXPECT_EQ(icmp1.pointer(), icmp2.pointer());
EXPECT_EQ(icmp1.mtu(), icmp2.mtu());
EXPECT_EQ((bool)icmp1.inner_pdu(), (bool)icmp2.inner_pdu());
EXPECT_EQ(icmp1.inner_pdu() != NULL, icmp2.inner_pdu() != NULL);
}
TEST_F(ICMPTest, Serialize) {

6
tests/src/icmpv6.cpp
View File

@@ -84,16 +84,16 @@ TEST_F(ICMPv6Test, ConstructorFromBuffer2) {
EXPECT_EQ(icmp.reachable_time(), 30000U);
EXPECT_EQ(icmp.retransmit_timer(), 1000U);
const ICMPv6::option *opt = icmp.search_option(ICMPv6::SOURCE_ADDRESS);
ASSERT_TRUE(opt);
ASSERT_TRUE(opt != NULL);
EXPECT_EQ(opt->data_size(), 6U);
EXPECT_EQ(HWAddress<6>(opt->data_ptr()), "00:60:97:07:69:ea");
opt = icmp.search_option(ICMPv6::MTU);
ASSERT_TRUE(opt);
ASSERT_TRUE(opt != NULL);
EXPECT_EQ(opt->data_size(), 6U);
opt = icmp.search_option(ICMPv6::PREFIX_INFO);
ASSERT_TRUE(opt);
ASSERT_TRUE(opt != NULL);
EXPECT_EQ(opt->data_size(), 30U);
}

18
tests/src/ip.cpp
View File

@@ -484,7 +484,7 @@ TEST_F(IPTest, Constructor) {
TEST_F(IPTest, ConstructorFromFragmentedPacket) {
IP ip(fragmented_packet, sizeof(fragmented_packet));
ASSERT_TRUE(ip.inner_pdu());
ASSERT_TRUE(ip.inner_pdu() != NULL);
EXPECT_EQ(PDU::RAW, ip.inner_pdu()->pdu_type());
}
@@ -502,8 +502,8 @@ TEST_F(IPTest, SerializeFragmentedPacket) {
TEST_F(IPTest, TotalLengthZeroPacket) {
EthernetII pkt(tot_len_zero_packet, sizeof(tot_len_zero_packet));
ASSERT_TRUE(pkt.find_pdu<TCP>());
ASSERT_TRUE(pkt.find_pdu<RawPDU>());
ASSERT_TRUE(pkt.find_pdu<TCP>() != NULL);
ASSERT_TRUE(pkt.find_pdu<RawPDU>() != NULL);
EXPECT_EQ(8192, pkt.rfind_pdu<RawPDU>().payload_size());
}
@@ -623,8 +623,8 @@ TEST_F(IPTest, AddOption) {
const uint8_t data[] = { 0x15, 0x17, 0x94, 0x66, 0xff };
IP::option_identifier id(IP::SEC, IP::CONTROL, 1);
ip.add_option(IP::option(id, data, data + sizeof(data)));
const IP::option *opt;
ASSERT_TRUE((opt = ip.search_option(id)));
const IP::option *opt = ip.search_option(id);
ASSERT_TRUE(opt != NULL);
ASSERT_EQ(opt->data_size(), sizeof(data));
EXPECT_TRUE(memcmp(opt->data_ptr(), data, sizeof(data)) == 0);
}
@@ -637,7 +637,7 @@ void IPTest::test_equals(const IP &ip1, const IP &ip2) {
EXPECT_EQ(ip1.tos(), ip2.tos());
EXPECT_EQ(ip1.ttl(), ip2.ttl());
EXPECT_EQ(ip1.version(), ip2.version());
EXPECT_EQ((bool)ip1.inner_pdu(), (bool)ip2.inner_pdu());
EXPECT_EQ(ip1.inner_pdu() != NULL, ip2.inner_pdu() != NULL);
}
TEST_F(IPTest, ConstructorFromBuffer) {
@@ -662,15 +662,15 @@ TEST_F(IPTest, ConstructorFromBuffer) {
TEST_F(IPTest, StackedProtocols) {
IP ip = IP() / TCP();
IP::serialization_type buffer = ip.serialize();
EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<TCP>());
EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<TCP>() != NULL);
ip = IP() / UDP();
buffer = ip.serialize();
EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<UDP>());
EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<UDP>() != NULL);
ip = IP() / ICMP();
buffer = ip.serialize();
EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<ICMP>());
EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<ICMP>() != NULL);
}
TEST_F(IPTest, SpoofedOptions) {

4
tests/src/ip_reassembler.cpp
View File

@@ -50,9 +50,9 @@ void IPv4ReassemblerTest::test_packets(const std::vector<std::pair<const uint8_t
EXPECT_NE(IPv4Reassembler::NOT_FRAGMENTED, status);
if(status == IPv4Reassembler::REASSEMBLED) {
ASSERT_EQ(static_cast<size_t>(vt.size() - 1), i);
ASSERT_TRUE(eth.find_pdu<UDP>());
ASSERT_TRUE(eth.find_pdu<UDP>() != NULL);
RawPDU *raw = eth.find_pdu<RawPDU>();
ASSERT_TRUE(raw);
ASSERT_TRUE(raw != NULL);
ASSERT_EQ(15000, raw->payload().size());
}
else if(status == IPv4Reassembler::FRAGMENTED)

12
tests/src/ipsec.cpp
View File

@@ -72,9 +72,9 @@ TEST_F(IPSecAHTest, DefaultConstructor) {
TEST_F(IPSecAHTest, EthPacket) {
EthernetII eth(whole_packet, sizeof(whole_packet));
EXPECT_TRUE(eth.find_pdu<IPSecAH>());
EXPECT_TRUE(eth.find_pdu<IPSecESP>());
EXPECT_TRUE(eth.find_pdu<RawPDU>());
EXPECT_TRUE(eth.find_pdu<IPSecAH>() != NULL);
EXPECT_TRUE(eth.find_pdu<IPSecESP>() != NULL);
EXPECT_TRUE(eth.find_pdu<RawPDU>() != NULL);
}
TEST_F(IPSecAHTest, ConstructorFromBuffer) {
@@ -86,8 +86,8 @@ TEST_F(IPSecAHTest, ConstructorFromBuffer) {
EXPECT_EQ(1, ipsec.seq_number());
ASSERT_EQ(12, ipsec.icv().size());
EXPECT_EQ(ipsec.icv(), byte_array(icv_ptr, icv_ptr + 12));
EXPECT_TRUE(ipsec.find_pdu<IPSecESP>());
EXPECT_TRUE(ipsec.find_pdu<RawPDU>());
EXPECT_TRUE(ipsec.find_pdu<IPSecESP>() != NULL);
EXPECT_TRUE(ipsec.find_pdu<RawPDU>() != NULL);
}
TEST_F(IPSecAHTest, Serialize) {
@@ -147,7 +147,7 @@ TEST_F(IPSecESPTest, ConstructorFromBuffer) {
IPSecESP ipsec(expected_packet, sizeof(expected_packet));
EXPECT_EQ(0x48dac2e4, ipsec.spi());
EXPECT_EQ(1, ipsec.seq_number());
EXPECT_TRUE(ipsec.find_pdu<RawPDU>());
EXPECT_TRUE(ipsec.find_pdu<RawPDU>() != NULL);
}
TEST_F(IPSecESPTest, SPI) {

15
tests/src/ipv6.cpp
View File

@@ -44,17 +44,18 @@ void IPv6Test::test_equals(IPv6 &ip1, IPv6 &ip2) {
EXPECT_EQ(ip1.dst_addr(), ip2.dst_addr());
EXPECT_EQ(ip1.src_addr(), ip2.src_addr());
EXPECT_EQ(bool(ip1.search_header(IPv6::HOP_BY_HOP)), bool(ip2.search_header(IPv6::HOP_BY_HOP)));
EXPECT_EQ(ip1.search_header(IPv6::HOP_BY_HOP) != NULL,
ip2.search_header(IPv6::HOP_BY_HOP) != NULL);
const IPv6::ext_header *header1 = ip1.search_header(IPv6::HOP_BY_HOP),
*header2 = ip2.search_header(IPv6::HOP_BY_HOP);
if(header1 && header2) {
EXPECT_EQ(header1->data_size(), header2->data_size());
}
EXPECT_EQ(bool(ip1.inner_pdu()), bool(ip2.inner_pdu()));
EXPECT_EQ(ip1.inner_pdu() != NULL, ip2.inner_pdu() != NULL);
const ICMPv6 *icmp1 = ip1.find_pdu<ICMPv6>(), *icmp2 = ip2.find_pdu<ICMPv6>();
ASSERT_EQ(bool(icmp1), bool(icmp2));
ASSERT_EQ(icmp1 != NULL, icmp2 != NULL);
if(icmp1 && icmp2) {
EXPECT_EQ(icmp1->checksum(), icmp2->checksum());
@@ -83,9 +84,9 @@ TEST_F(IPv6Test, ConstructorFromBuffer) {
EXPECT_EQ(ipv6.hop_limit(), 64);
EXPECT_EQ(ipv6.dst_addr(), "::1");
EXPECT_EQ(ipv6.src_addr(), "::1");
ASSERT_TRUE(ipv6.inner_pdu());
ASSERT_TRUE(ipv6.inner_pdu() != NULL);
TCP *tcp = ipv6.find_pdu<TCP>();
ASSERT_TRUE(tcp);
ASSERT_TRUE(tcp != NULL);
EXPECT_EQ(tcp->sport(), 50828);
EXPECT_EQ(tcp->dport(), 80);
}
@@ -103,14 +104,14 @@ TEST_F(IPv6Test, ConstructorFromBuffer2) {
EXPECT_EQ(ipv6.src_addr(), "fe80::2d0:9ff:fee3:e8de");
ICMPv6 *pdu = ipv6.find_pdu<ICMPv6>();
ASSERT_TRUE(pdu);
ASSERT_TRUE(pdu != NULL);
EXPECT_EQ(pdu->type(), 143);
EXPECT_EQ(pdu->code(), 0);
EXPECT_EQ(pdu->checksum(), 0x74fe);
EXPECT_EQ(pdu->checksum(), 0x74fe);
const IPv6::ext_header *header = ipv6.search_header(IPv6::HOP_BY_HOP);
ASSERT_TRUE(header);
ASSERT_TRUE(header != NULL);
EXPECT_EQ(header->data_size(), 6U);
}

8
tests/src/matches_response.cpp
View File

@@ -106,8 +106,8 @@ TEST_F(MatchesResponseTest, DHCP) {
EthernetII discover(dhcp_discover, sizeof(dhcp_discover));
UDP *udp = discover.find_pdu<UDP>();
const RawPDU *raw = discover.find_pdu<RawPDU>();
ASSERT_TRUE(udp);
ASSERT_TRUE(raw);
ASSERT_TRUE(udp != NULL);
ASSERT_TRUE(raw != NULL);
udp->inner_pdu(raw->to<DHCP>());
EXPECT_TRUE(discover.matches_response(dhcp_offer, sizeof(dhcp_offer)));
@@ -223,8 +223,8 @@ TEST_F(MatchesResponseTest, DHCPv6) {
EthernetII pkt(request, sizeof(request));
UDP *udp = pkt.find_pdu<UDP>();
const RawPDU *raw = pkt.find_pdu<RawPDU>();
ASSERT_TRUE(udp);
ASSERT_TRUE(raw);
ASSERT_TRUE(udp != NULL);
ASSERT_TRUE(raw != NULL);
udp->inner_pdu(raw->to<DHCPv6>());
EXPECT_TRUE(pkt.matches_response(reply, sizeof(reply)));

22
tests/src/pdu.cpp
View File

@@ -18,9 +18,9 @@ public:
TEST_F(PDUTest, FindPDU) {
IP ip = IP("192.168.0.1") / TCP(22, 52) / RawPDU("Test");
EXPECT_TRUE(ip.find_pdu<TCP>());
EXPECT_TRUE(ip.find_pdu<RawPDU>());
EXPECT_FALSE(ip.find_pdu<UDP>());
EXPECT_TRUE(ip.find_pdu<TCP>() != NULL);
EXPECT_TRUE(ip.find_pdu<RawPDU>() != NULL);
EXPECT_FALSE(ip.find_pdu<UDP>() != NULL);
TCP &t1 = ip.rfind_pdu<TCP>();
const TCP &t2 = ip.rfind_pdu<TCP>();
(void)t1;
@@ -32,14 +32,14 @@ TEST_F(PDUTest, OperatorConcat) {
std::string raw_payload = "Test";
IP ip = IP("192.168.0.1") / TCP(22, 52) / RawPDU(raw_payload);
EXPECT_EQ(ip.dst_addr(), "192.168.0.1");
ASSERT_TRUE(ip.inner_pdu());
ASSERT_TRUE(ip.inner_pdu() != NULL);
TCP *tcp = ip.find_pdu<TCP>();
ASSERT_TRUE(tcp);
ASSERT_TRUE(tcp != NULL);
EXPECT_EQ(tcp->dport(), 22);
EXPECT_EQ(tcp->sport(), 52);
ASSERT_TRUE(tcp->inner_pdu());
ASSERT_TRUE(tcp->inner_pdu() != NULL);
RawPDU *raw = tcp->find_pdu<RawPDU>();
ASSERT_TRUE(raw);
ASSERT_TRUE(raw != NULL);
ASSERT_EQ(raw->payload_size(), raw_payload.size());
EXPECT_TRUE(std::equal(raw_payload.begin(), raw_payload.end(), raw->payload().begin()));
}
@@ -48,10 +48,10 @@ TEST_F(PDUTest, OperatorConcatOnPointers) {
std::string raw_payload = "Test";
IP ip = IP("192.168.0.1") / TCP(22, 52);
TCP *tcp = ip.find_pdu<TCP>();
ASSERT_TRUE(tcp);
ASSERT_TRUE(tcp != NULL);
tcp /= RawPDU(raw_payload);
RawPDU *raw = ip.find_pdu<RawPDU>();
ASSERT_TRUE(raw);
ASSERT_TRUE(raw != NULL);
ASSERT_EQ(raw->payload_size(), raw_payload.size());
EXPECT_TRUE(std::equal(raw->payload().begin(), raw->payload().end(), raw_payload.begin()));
}
@@ -60,10 +60,10 @@ TEST_F(PDUTest, OperatorConcatOnPacket) {
std::string raw_payload = "Test";
Packet packet = IP("192.168.0.1") / TCP(22, 52);
TCP *tcp = packet.pdu()->find_pdu<TCP>();
ASSERT_TRUE(tcp);
ASSERT_TRUE(tcp != NULL);
tcp /= RawPDU(raw_payload);
RawPDU *raw = packet.pdu()->find_pdu<RawPDU>();
ASSERT_TRUE(raw);
ASSERT_TRUE(raw != NULL);
ASSERT_EQ(raw->payload_size(), raw_payload.size());
EXPECT_TRUE(std::equal(raw->payload().begin(), raw->payload().end(), raw_payload.begin()));
}

2
tests/src/pktap.cpp
View File

@@ -22,6 +22,6 @@ const uint8_t PKTAPTest::packet1[] = {
TEST_F(PKTAPTest, ConstructorFromBuffer) {
PKTAP pkt(packet1, sizeof(packet1));
PDU* inner = pkt.inner_pdu();
ASSERT_TRUE(inner);
ASSERT_TRUE(inner != NULL);
EXPECT_EQ(PDU::ETHERNET_II, inner->pdu_type());
}

4
tests/src/ppi.cpp
View File

@@ -36,8 +36,8 @@ TEST_F(PPITest, ConstructorFromBuffer) {
EXPECT_EQ(0, pdu.flags());
EXPECT_EQ(84, pdu.length());
EXPECT_EQ(105U, pdu.dlt());
EXPECT_TRUE(pdu.find_pdu<Dot11Data>());
EXPECT_TRUE(pdu.find_pdu<UDP>());
EXPECT_TRUE(pdu.find_pdu<Dot11Data>() != NULL);
EXPECT_TRUE(pdu.find_pdu<UDP>() != NULL);
}
#endif // HAVE_DOT11

10
tests/src/pppoe.cpp
View File

@@ -52,7 +52,7 @@ TEST_F(PPPoETest, ConstructorFromSessionBuffer) {
EXPECT_EQ(0U, pdu.tags().size());
const RawPDU* raw = pdu.find_pdu<RawPDU>();
ASSERT_TRUE(raw);
ASSERT_TRUE(raw != NULL);
EXPECT_EQ(21, raw->payload_size());
}
@@ -67,7 +67,7 @@ TEST_F(PPPoETest, ConstructorFromFullSessionBuffer) {
EXPECT_EQ(0U, pdu.tags().size());
const RawPDU* raw = pdu.find_pdu<RawPDU>();
ASSERT_TRUE(raw);
ASSERT_TRUE(raw != NULL);
EXPECT_EQ(21, raw->payload_size());
}
@@ -81,14 +81,14 @@ TEST_F(PPPoETest, ConstructorFromBuffer) {
EXPECT_EQ(3U, pdu.tags().size());
EXPECT_EQ("", pdu.service_name());
ASSERT_TRUE(pdu.search_tag(PPPoE::SERVICE_NAME));
ASSERT_TRUE(pdu.search_tag(PPPoE::SERVICE_NAME) != NULL);
}
TEST_F(PPPoETest, StackedOnEthernet) {
EthernetII eth = EthernetII() / PPPoE();
PDU::serialization_type buffer = eth.serialize();
EthernetII eth2(&buffer[0], buffer.size());
ASSERT_TRUE(eth2.find_pdu<PPPoE>());
ASSERT_TRUE(eth2.find_pdu<PPPoE>() != NULL);
}
TEST_F(PPPoETest, StackedOnEthernetSerializationWithTags) {
@@ -97,7 +97,7 @@ TEST_F(PPPoETest, StackedOnEthernetSerializationWithTags) {
PDU::serialization_type buffer = eth.serialize();
EthernetII eth2(&buffer[0], buffer.size());
PPPoE* unserialized = eth2.find_pdu<PPPoE>();
ASSERT_TRUE(unserialized);
ASSERT_TRUE(unserialized != NULL);
EXPECT_EQ(
PPPoE::serialization_type(expected_packet, expected_packet + sizeof(expected_packet)),
unserialized->serialize()

58
tests/src/radiotap.cpp
View File

@@ -214,13 +214,13 @@ TEST_F(RadioTapTest, ConstructorFromBuffer) {
EXPECT_EQ(radio.rate(), 0xc);
EXPECT_EQ(radio.flags(), 0x10);
EXPECT_TRUE(radio.present() & RadioTap::TSTF);
EXPECT_TRUE(radio.present() & RadioTap::RATE);
EXPECT_TRUE(radio.present() & RadioTap::DBM_SIGNAL);
EXPECT_TRUE(radio.present() & RadioTap::ANTENNA);
EXPECT_TRUE(radio.present() & RadioTap::CHANNEL_PLUS);
EXPECT_TRUE((radio.present() & RadioTap::TSTF) != 0);
EXPECT_TRUE((radio.present() & RadioTap::RATE) != 0);
EXPECT_TRUE((radio.present() & RadioTap::DBM_SIGNAL) != 0);
EXPECT_TRUE((radio.present() & RadioTap::ANTENNA) != 0);
EXPECT_TRUE((radio.present() & RadioTap::CHANNEL_PLUS) != 0);
EXPECT_TRUE(radio.flags() & RadioTap::FCS);
EXPECT_TRUE((radio.flags() & RadioTap::FCS) != 0);
EXPECT_THROW(radio.channel_type(), field_not_present);
EXPECT_THROW(radio.channel_freq(), field_not_present);
EXPECT_EQ(radio.tsft(), 616089172U);
@@ -237,17 +237,17 @@ TEST_F(RadioTapTest, ConstructorFromBuffer1) {
EXPECT_EQ(radio.flags(), 0x10);
EXPECT_TRUE(radio.flags() & RadioTap::FCS);
EXPECT_EQ(radio.antenna(), 1);
EXPECT_TRUE(radio.find_pdu<Dot11Beacon>());
EXPECT_TRUE(radio.find_pdu<Dot11Beacon>() != NULL);
}
TEST_F(RadioTapTest, ConstructorFromBuffer2) {
RadioTap radio(expected_packet2, sizeof(expected_packet2));
EXPECT_TRUE(radio.present() & RadioTap::RATE);
EXPECT_TRUE(radio.present() & RadioTap::CHANNEL);
EXPECT_TRUE(radio.present() & RadioTap::DBM_SIGNAL);
EXPECT_TRUE(radio.present() & RadioTap::ANTENNA);
EXPECT_TRUE(radio.present() & RadioTap::RX_FLAGS);
EXPECT_TRUE((radio.present() & RadioTap::RATE) != 0);
EXPECT_TRUE((radio.present() & RadioTap::CHANNEL) != 0);
EXPECT_TRUE((radio.present() & RadioTap::DBM_SIGNAL) != 0);
EXPECT_TRUE((radio.present() & RadioTap::ANTENNA) != 0);
EXPECT_TRUE((radio.present() & RadioTap::RX_FLAGS) != 0);
EXPECT_EQ(radio.version(), 0);
EXPECT_EQ(radio.length(), 34);
@@ -257,31 +257,31 @@ TEST_F(RadioTapTest, ConstructorFromBuffer2) {
EXPECT_EQ(radio.channel_type(), 192);
EXPECT_EQ(radio.channel_freq(), 2447);
EXPECT_EQ(radio.antenna(), 0);
EXPECT_TRUE(radio.find_pdu<Dot11QoSData>());
EXPECT_TRUE(radio.find_pdu<Dot11QoSData>() != NULL);
}
TEST_F(RadioTapTest, ConstructorFromBuffer3) {
RadioTap radio(expected_packet3, sizeof(expected_packet3));
EXPECT_TRUE(radio.present() & RadioTap::RATE);
EXPECT_TRUE(radio.present() & RadioTap::CHANNEL);
EXPECT_TRUE(radio.present() & RadioTap::DBM_SIGNAL);
EXPECT_TRUE(radio.present() & RadioTap::ANTENNA);
EXPECT_TRUE(radio.present() & RadioTap::RX_FLAGS);
EXPECT_TRUE((radio.present() & RadioTap::RATE) != 0);
EXPECT_TRUE((radio.present() & RadioTap::CHANNEL) != 0);
EXPECT_TRUE((radio.present() & RadioTap::DBM_SIGNAL) != 0);
EXPECT_TRUE((radio.present() & RadioTap::ANTENNA) != 0);
EXPECT_TRUE((radio.present() & RadioTap::RX_FLAGS) != 0);
EXPECT_EQ(0, radio.antenna());
EXPECT_EQ(-75, radio.dbm_signal());
EXPECT_TRUE(radio.find_pdu<ARP>());
EXPECT_TRUE(radio.find_pdu<ARP>() != NULL);
}
TEST_F(RadioTapTest, ConstructorFromBuffer4) {
RadioTap radio(expected_packet4, sizeof(expected_packet4));
EXPECT_TRUE(radio.present() & RadioTap::TSTF);
EXPECT_TRUE(radio.present() & RadioTap::DBM_SIGNAL);
EXPECT_TRUE(radio.present() & RadioTap::CHANNEL);
EXPECT_TRUE(radio.present() & RadioTap::ANTENNA);
EXPECT_TRUE(radio.present() & RadioTap::RX_FLAGS);
EXPECT_TRUE(radio.present() & RadioTap::MCS);
EXPECT_TRUE((radio.present() & RadioTap::TSTF) != 0);
EXPECT_TRUE((radio.present() & RadioTap::DBM_SIGNAL) != 0);
EXPECT_TRUE((radio.present() & RadioTap::CHANNEL) != 0);
EXPECT_TRUE((radio.present() & RadioTap::ANTENNA) != 0);
EXPECT_TRUE((radio.present() & RadioTap::RX_FLAGS) != 0);
EXPECT_TRUE((radio.present() & RadioTap::MCS) != 0);
EXPECT_EQ(2076020709598, radio.tsft());
EXPECT_EQ(0, radio.rx_flags());
@@ -293,14 +293,14 @@ TEST_F(RadioTapTest, ConstructorFromBuffer4) {
EXPECT_EQ(0x00, radio.mcs().flags);
EXPECT_EQ(0x01, radio.mcs().mcs);
EXPECT_TRUE(radio.find_pdu<Dot11Data>());
EXPECT_TRUE(radio.find_pdu<Dot11Data>() != NULL);
}
TEST_F(RadioTapTest, ConstructorFromBuffer5) {
RadioTap radio(expected_packet5, sizeof(expected_packet5));
EXPECT_TRUE(radio.present() & RadioTap::DATA_RETRIES);
EXPECT_TRUE(radio.present() & RadioTap::TX_FLAGS);
EXPECT_TRUE(radio.present() & RadioTap::MCS);
EXPECT_TRUE((radio.present() & RadioTap::DATA_RETRIES) != 0);
EXPECT_TRUE((radio.present() & RadioTap::TX_FLAGS) != 0);
EXPECT_TRUE((radio.present() & RadioTap::MCS) != 0);
EXPECT_EQ(0, radio.data_retries());
EXPECT_EQ(0, radio.tx_flags());

2
tests/src/rsn_eapol.cpp
View File

@@ -103,7 +103,7 @@ TEST_F(RSNEAPOLTest, DefaultConstructor) {
TEST_F(RSNEAPOLTest, EAPOLOverSnap) {
SNAP snap(eapol_over_snap, sizeof(eapol_over_snap));
EXPECT_TRUE(snap.find_pdu<RSNEAPOL>());
EXPECT_TRUE(snap.find_pdu<RSNEAPOL>() != NULL);
}
TEST_F(RSNEAPOLTest, ConstructorFromBuffer) {

2
tests/src/sll.cpp
View File

@@ -48,7 +48,7 @@ TEST_F(SLLTest, ConstructorFromBuffer) {
EXPECT_EQ(Constants::Ethernet::IP, sll.protocol());
EXPECT_EQ(addr, sll.address());
ASSERT_TRUE(sll.inner_pdu());
ASSERT_TRUE(sll.inner_pdu() != NULL);
EXPECT_EQ(sll.find_pdu<IP>(), sll.inner_pdu());
}

2
tests/src/snap.cpp
View File

@@ -88,7 +88,7 @@ TEST_F(SNAPTest, ClonePDU) {
snap1.org_code(0xfab1c3);
snap1.control(0x1);
SNAP *snap2 = static_cast<SNAP*>(snap1.clone());
ASSERT_TRUE(snap2);
ASSERT_TRUE(snap2 != NULL);
test_equals(snap1, *snap2);
delete snap2;

4
tests/src/stp.cpp
View File

@@ -80,8 +80,8 @@ TEST_F(STPTest, ChainedPDUs) {
Dot3 pkt(input, sizeof(input));
STP *stp = pkt.find_pdu<STP>();
LLC *llc = pkt.find_pdu<LLC>();
ASSERT_TRUE(stp);
ASSERT_TRUE(llc);
ASSERT_TRUE(stp != NULL);
ASSERT_TRUE(llc != NULL);
EXPECT_EQ(0x8001, stp->port_id());
EXPECT_EQ(0, stp->msg_age());
EXPECT_EQ(20, stp->max_age());

2
tests/src/tcp.cpp
View File

@@ -201,7 +201,7 @@ void TCPTest::test_equals(const TCP &tcp1, const TCP &tcp2) {
EXPECT_EQ(tcp1.checksum(), tcp2.checksum());
EXPECT_EQ(tcp1.urg_ptr(), tcp2.urg_ptr());
EXPECT_EQ(tcp1.data_offset(), tcp2.data_offset());
EXPECT_EQ((bool)tcp1.inner_pdu(), (bool)tcp2.inner_pdu());
EXPECT_EQ(tcp1.inner_pdu() != NULL, tcp2.inner_pdu() != NULL);
}
TEST_F(TCPTest, ConstructorFromBuffer) {

4
tests/src/udp.cpp
View File

@@ -35,7 +35,7 @@ void UDPTest::test_equals(const UDP& udp1, const UDP& udp2) {
EXPECT_EQ(udp1.length(), udp2.length());
EXPECT_EQ(udp1.size(), udp2.size());
EXPECT_EQ(udp1.header_size(), udp2.header_size());
EXPECT_EQ(bool(udp1.inner_pdu()), bool(udp2.inner_pdu()));
EXPECT_EQ(udp1.inner_pdu() != NULL, udp2.inner_pdu() != NULL);
}
TEST_F(UDPTest, DefaultConstructor) {
@@ -110,7 +110,7 @@ TEST_F(UDPTest, ClonePDU) {
udp1.length(length);
UDP *udp2 = udp1.clone();
ASSERT_TRUE(udp2);
ASSERT_TRUE(udp2 != NULL);
EXPECT_EQ(udp2->sport(), sport);
EXPECT_EQ(udp2->dport(), dport);
EXPECT_EQ(udp2->length(), length);