stubbfel/1261Nat
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

add test src

Browse Source
This commit is contained in:
stubbfel
2017-02-16 00:55:04 +01:00
parent 9b65fca64a
commit 86ff923e8a
11 changed files with 20199 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
test/src/TestArpToNdpPacketHandler.cpp Normal file
View File

@@ -0,0 +1,112 @@
#include <fakeit.hpp>
#include <tins/arp.h>
#include <tins/ethernetII.h>
#include <tins/icmpv6.h>
#include <tins/ip.h>
#include <tins/ipv6.h>
#include <tins/ip_address.h>
#include <tins/ipv6_address.h>
#include <tins/tcp.h>
#include "ArpToNdpPacketHandler.h"
#include "HwAddressTranslator.h"
#include "IpAddressTranslator.h"
using namespace fakeit;
#ifndef ArpToNdpPacketHandler
#define ArpToNdpPacketHandlerTestPrefix "ff::"
#endif
namespace TestArpToNdpPacketHandler
{
Tins::PDU * currentInputPdu = nullptr;
void compareToInputPdu(const Tins::PDU & answerPdu)
{
REQUIRE(currentInputPdu != nullptr);
REQUIRE(answerPdu.find_pdu<Tins::IP>() == nullptr);
const Tins::ICMPv6 * ndp = answerPdu.find_pdu<Tins::ICMPv6>();
REQUIRE(ndp != nullptr);
const Tins::IPv6 * ip = answerPdu.find_pdu<Tins::IPv6>();
REQUIRE(ndp != nullptr);
const Tins::ARP * arp = currentInputPdu->find_pdu<Tins::ARP>();
REQUIRE(arp != nullptr);
Tins::IPv6Address tmp_ipv6(ArpToNdpPacketHandlerTestPrefix);
IpAddressTranslator::toIpv6Address(arp->sender_ip_addr(), tmp_ipv6);
REQUIRE(ip->src_addr() == tmp_ipv6);
bool isRequest = false;
switch (arp->opcode())
{
case Tins::ARP::REQUEST:
isRequest = true;
REQUIRE(ndp->source_link_layer_addr() == arp->sender_hw_addr());
IpAddressTranslator::toIpv6Address(arp->target_ip_addr(), tmp_ipv6);
REQUIRE(ndp->target_addr()== tmp_ipv6);
IpAddressTranslator::toSolicitedNodeAddress(arp->target_ip_addr(), tmp_ipv6);
REQUIRE(ip->dst_addr() == tmp_ipv6);
break;
case Tins::ARP::REPLY:
REQUIRE(ndp->target_link_layer_addr() == arp->sender_hw_addr());
REQUIRE(ndp->target_addr()== tmp_ipv6);
IpAddressTranslator::toIpv6Address(arp->target_ip_addr(), tmp_ipv6);
REQUIRE(ip->dst_addr() == tmp_ipv6);
break;
default:
REQUIRE( 1 == 0);
}
const Tins::EthernetII * currEth = currentInputPdu->find_pdu<Tins::EthernetII>();
if (currEth == nullptr)
{
return;
}
const Tins::EthernetII * answerEth = answerPdu.find_pdu<Tins::EthernetII>();
REQUIRE(answerEth->src_addr() == currEth->src_addr());
REQUIRE(answerEth->src_addr() == arp->sender_hw_addr());
if (isRequest)
{
HwAddress tmpHw;
HwAddressTranslator::toSolicitedNodeAddress(tmp_ipv6, tmpHw);
REQUIRE(answerEth->dst_addr() == tmpHw);
}
else
{
REQUIRE(answerEth->dst_addr() == currEth->dst_addr());
REQUIRE(answerEth->dst_addr() == arp->target_hw_addr());
}
}
}
TEST_CASE( "test ArpToNdpPacketHandler", "[ArpToNdpPacketHandler]" ) {
ArpToNdpPacketHandler handler(ArpToNdpPacketHandlerTestPrefix);
Mock<IPacketHandler> mockHandler;
When(Method(mockHandler, handle)).AlwaysDo([] (IN const Tins::PDU & pdu,...)
{
TestArpToNdpPacketHandler::compareToInputPdu(pdu);
return true;
});
Tins::IPv4Address to_resolve_address("192.168.0.1");
Tins::IPv4Address own_address("192.168.0.2");
HwAddress own_mac_address("01:02:03:12:34:56");
Tins::EthernetII arp_request = Tins::ARP::make_arp_request(to_resolve_address, own_address, own_mac_address);
TestArpToNdpPacketHandler::currentInputPdu = &arp_request;
REQUIRE(handler.handle(arp_request, nullptr) == false);
REQUIRE(handler.handle(arp_request, &mockHandler.get()) == true);
Verify(Method(mockHandler, handle)).Once();
HwAddress to_resolve_mac_address("50:60:70:65:43:21");
Tins::EthernetII arp_reply = Tins::ARP::make_arp_reply(to_resolve_address, own_address, to_resolve_mac_address, own_mac_address);
TestArpToNdpPacketHandler::currentInputPdu = &arp_reply;
REQUIRE(handler.handle(arp_reply, &mockHandler.get()) == true);
Verify(Method(mockHandler, handle)).Twice();
}

18
test/src/TestHwAddressTranslator.cpp Normal file
View File

@@ -0,0 +1,18 @@
#include "fakeit.hpp"
#include <tins/ipv6_address.h>
#include "HwAddressTranslator.h"
using namespace fakeit;
TEST_CASE( "test toHwSolicitedNodeAddress", "[HwAddressTranslator]" ) {
HwAddress result;
HwAddressTranslator::toSolicitedNodeAddress(Tins::IPv6Address("2011:0DB8::"), result);
REQUIRE(HwAddress("33:33:FF:00:00:00") == result);
HwAddressTranslator::toSolicitedNodeAddress(Tins::IPv6Address("2011:0DB8::ffff:ff12:3456"), result);
REQUIRE(HwAddress("33:33:FF:12:34:56") == result);
HwAddressTranslator::toSolicitedNodeAddress(Tins::IPv6Address("2011:0DB8::5678:9912:3456"), result);
REQUIRE(HwAddress("33:33:FF:12:34:56") == result);
}

60
test/src/TestIp4ToIp6PacketHandler.cpp Normal file
View File

@@ -0,0 +1,60 @@
#include "fakeit.hpp"
#include "tins/ethernetII.h"
#include <tins/ip.h>
#include <tins/ipv6.h>
#include <tins/ip_address.h>
#include <tins/ipv6_address.h>
#include <tins/tcp.h>
#include "Ip4ToIp6PacketHandler.h"
#include "IpAddressTranslator.h"
using namespace fakeit;
namespace TestIp4ToIp6PacketHandler
{
Tins::PDU * currentInputPdu = nullptr;
void compareToInputPdu(const Tins::PDU & answerPdu)
{
REQUIRE(currentInputPdu != nullptr);
REQUIRE(answerPdu.find_pdu<Tins::IP>() == nullptr);
const Tins::IPv6 * ip6 = answerPdu.find_pdu<Tins::IPv6>();
const Tins::IP * ip = currentInputPdu->find_pdu<Tins::IP>();
REQUIRE(ip != nullptr);
REQUIRE(ip6 != nullptr);
REQUIRE(ip->src_addr() == Tins::IPv4Address(IpAddressTranslator::toIpv4AddressBytes(ip6->src_addr())));
REQUIRE(ip->dst_addr() == Tins::IPv4Address(IpAddressTranslator::toIpv4AddressBytes(ip6->dst_addr())));
REQUIRE(answerPdu.inner_pdu() != nullptr);
const Tins::EthernetII * currEth = currentInputPdu->find_pdu<Tins::EthernetII>();
if (currEth == nullptr)
{
return;
}
const Tins::EthernetII * answerEth = answerPdu.find_pdu<Tins::EthernetII>();
REQUIRE(answerEth->src_addr() == currEth->src_addr());
REQUIRE(answerEth->dst_addr() == currEth->dst_addr());
}
}
TEST_CASE( "test Ip4ToIp6PacketHandler", "[Ip4ToIp6PacketHandler]" ) {
Ip4ToIp6PacketHandler handler("1::"); // tod fix prefix
Mock<IPacketHandler> mockHandler;
When(Method(mockHandler, handle)).AlwaysDo([] (IN const Tins::PDU & pdu,...)
{
TestIp4ToIp6PacketHandler::compareToInputPdu(pdu);
return true;
});
Tins::EthernetII pkt = Tins::EthernetII() / Tins::IP() / Tins::TCP();
TestIp4ToIp6PacketHandler::currentInputPdu = &pkt;
REQUIRE(handler.handle(pkt, nullptr) == false);
REQUIRE(handler.handle(pkt, &mockHandler.get()) == true);
Verify(Method(mockHandler, handle)).Once();
pkt = Tins::EthernetII("11:22:33:44:55:66", "66:55:44:33:22:11") / Tins::IP("1.2.3.4", "4.3.2.1") / Tins::TCP();
REQUIRE(handler.handle(pkt, &mockHandler.get()) == true);
Verify(Method(mockHandler, handle)).Twice();
}

60
test/src/TestIp6ToIp4PacketHandler.cpp Normal file
View File

@@ -0,0 +1,60 @@
#include "fakeit.hpp"
#include "tins/ethernetII.h"
#include <tins/ip.h>
#include <tins/ipv6.h>
#include <tins/ip_address.h>
#include <tins/ipv6_address.h>
#include <tins/tcp.h>
#include "Ip6ToIp4PacketHandler.h"
#include "IpAddressTranslator.h"
using namespace fakeit;
namespace TestIp6ToIp4PacketHandler
{
Tins::PDU * currentInputPdu = nullptr;
void compareToInputPdu(const Tins::PDU & answerPdu)
{
REQUIRE(currentInputPdu != nullptr);
REQUIRE(answerPdu.find_pdu<Tins::IPv6>() == nullptr);
const Tins::IP * ip = answerPdu.find_pdu<Tins::IP>();
REQUIRE(ip != nullptr);
const Tins::IPv6 * ip6 = currentInputPdu->find_pdu<Tins::IPv6>();
REQUIRE(ip6 != nullptr);
REQUIRE(ip->src_addr() == Tins::IPv4Address(IpAddressTranslator::toIpv4AddressBytes(ip6->src_addr())));
REQUIRE(ip->dst_addr() == Tins::IPv4Address(IpAddressTranslator::toIpv4AddressBytes(ip6->dst_addr())));
REQUIRE(answerPdu.inner_pdu() != nullptr);
const Tins::EthernetII * currEth = currentInputPdu->find_pdu<Tins::EthernetII>();
if (currEth == nullptr)
{
return;
}
const Tins::EthernetII * answerEth = answerPdu.find_pdu<Tins::EthernetII>();
REQUIRE(answerEth->src_addr() == currEth->src_addr());
REQUIRE(answerEth->dst_addr() == currEth->dst_addr());
}
}
TEST_CASE( "test Ip6ToIp4PacketHandler", "[Ip6ToIp4PacketHandler]" ) {
Ip6ToIp4PacketHandler handler;
Mock<IPacketHandler> mockHandler;
When(Method(mockHandler, handle)).AlwaysDo([] (IN const Tins::PDU & pdu,...)
{
TestIp6ToIp4PacketHandler::compareToInputPdu(pdu);
return true;
});
Tins::EthernetII pkt = Tins::EthernetII() / Tins::IPv6() / Tins::TCP();
TestIp6ToIp4PacketHandler::currentInputPdu = &pkt;
REQUIRE(handler.handle(pkt, nullptr) == false);
REQUIRE(handler.handle(pkt, &mockHandler.get()) == true);
Verify(Method(mockHandler, handle)).Once();
pkt = Tins::EthernetII("11:22:33:44:55:66", "66:55:44:33:22:11") / Tins::IPv6("::1", "::2") / Tins::TCP();
REQUIRE(handler.handle(pkt, &mockHandler.get()) == true);
Verify(Method(mockHandler, handle)).Twice();
}

114
test/src/TestIpAddressTranslator.cpp Normal file
View File

@@ -0,0 +1,114 @@
#include "fakeit.hpp"
#include <tins/ip_address.h>
#include <tins/ipv6_address.h>
#include <tins/ethernetII.h>
#include "IpAddressTranslator.h"
using namespace fakeit;
TEST_CASE( "test not operator", "[IpAddressTranslator]" ) {
REQUIRE(Tins::IPv4Address("0.0.0.0") == ~Tins::IPv4Address("255.255.255.255"));
REQUIRE(Tins::IPv4Address("0.0.0.255") == ~Tins::IPv4Address("255.255.255.0"));
REQUIRE(Tins::IPv4Address("0.0.255.255") == ~Tins::IPv4Address("255.255.0.0"));
REQUIRE(Tins::IPv4Address("0.255.255.255") == ~Tins::IPv4Address("255.0.0.0"));
REQUIRE(Tins::IPv4Address("255.255.255.255") == ~Tins::IPv4Address("0.0.0.0"));
REQUIRE(Tins::IPv4Address("0.255.1.255") == ~Tins::IPv4Address("255.0.254.0"));
REQUIRE(Tins::IPv4Address("255.254.255.255") == ~Tins::IPv4Address("0.1.0.0"));
REQUIRE(Tins::IPv6Address("::0") == ~Tins::IPv6Address("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF"));
REQUIRE(Tins::IPv6Address("::FF") == ~Tins::IPv6Address("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FF00"));
REQUIRE(Tins::IPv6Address("::FFFF") == ~Tins::IPv6Address("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:0"));
REQUIRE(Tins::IPv6Address("::FFFF:FFFF") == ~Tins::IPv6Address("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:0:0"));
REQUIRE(Tins::IPv6Address("FFFF:FFFF::FFFF:FFFF") == ~Tins::IPv6Address("0:0:FFFF:FFFF:FFFF:FFFF:0:0"));
REQUIRE(Tins::IPv6Address("FFFF:0:FFFF:0:FFFF:0:FFFF:0") == ~Tins::IPv6Address("::FFFF:0:FFFF:0:FFFF:0:FFFF"));
REQUIRE(Tins::IPv6Address("FFFF:1:FFFF:1:FFFF:1:FFFF:1") == ~Tins::IPv6Address("::FFFE:0:FFFE:0:FFFE:0:FFFE"));
REQUIRE(Tins::EthernetII::address_type("00:00:00:00:00:00") == ~Tins::EthernetII::address_type("FF:FF:FF:FF:FF:FF"));
REQUIRE(Tins::EthernetII::address_type("00:00:00:FF:FF:FF") == ~Tins::EthernetII::address_type("FF:FF:FF:00:00:00"));
REQUIRE(Tins::EthernetII::address_type("00:00:FF:FF:FF:FF") == ~Tins::EthernetII::address_type("FF:FF:00:00:00:00"));
REQUIRE(Tins::EthernetII::address_type("00:FF:FF:FF:FF:FF") == ~Tins::EthernetII::address_type("FF:00:00:00:00:00"));
REQUIRE(Tins::EthernetII::address_type("FF:FF:FF:FF:FF:FF") == ~Tins::EthernetII::address_type("00:00:00:00:00:00"));
REQUIRE(Tins::EthernetII::address_type("00:FF:01:FF:FF:FF") == ~Tins::EthernetII::address_type("FF:00:FE:00:00:00"));
REQUIRE(Tins::EthernetII::address_type("FF:FE:FF:FF:FF:FF") == ~Tins::EthernetII::address_type("00:01:00:00:00:00"));
}
TEST_CASE( "test and operator", "[IpAddressTranslator]" ) {
REQUIRE(Tins::IPv4Address("0.0.0.0") == (Tins::IPv4Address("0.0.0.0") & Tins::IPv4Address("255.255.255.255")));
REQUIRE(Tins::IPv4Address("0.0.255.0") == (Tins::IPv4Address("0.0.255.255") & Tins::IPv4Address("255.255.255.0")));
REQUIRE(Tins::IPv4Address("0.255.255.0") == (Tins::IPv4Address("0.255.255.255") & Tins::IPv4Address("255.255.255.0")));
REQUIRE(Tins::IPv4Address("255.0.0.0") == (Tins::IPv4Address("255.255.255.255") & Tins::IPv4Address("255.0.0.0")));
REQUIRE(Tins::IPv4Address("255.255.255.255") == (Tins::IPv4Address("255.255.255.255") & Tins::IPv4Address("255.255.255.255")));
REQUIRE(Tins::IPv4Address("0.1.1.1") == (Tins::IPv4Address("0.255.1.255") & Tins::IPv4Address("1.1.255.1")));
REQUIRE(Tins::IPv4Address("0.0.0.0") == (Tins::IPv4Address("255.254.255.255") & Tins::IPv4Address("0.1.0.0")));
REQUIRE(Tins::IPv6Address("::0") == (Tins::IPv6Address("::0") & Tins::IPv6Address("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF")));
REQUIRE(Tins::IPv6Address("::FF") == (Tins::IPv6Address("::FF") & Tins::IPv6Address("FFFF:FFFF:0000:FFFF:0000:FFFF:FFFF:FFFF")));
REQUIRE(Tins::IPv6Address("1:0:1:0:1:0:1:0") == (Tins::IPv6Address("FFFF:0:FFFF:0:FFFF:0:FFFF:0") & Tins::IPv6Address("1:FFFF:1:FFFF:1:FFFF:1:FFFF")));
REQUIRE(Tins::EthernetII::address_type("00:00:00:00:00:00") == (Tins::EthernetII::address_type("00:00:00:00:00:00") & Tins::EthernetII::address_type("FF:FF:FF:FF:FF:FF")));
REQUIRE(Tins::EthernetII::address_type("00:00:00:00:00:05") == (Tins::EthernetII::address_type("00:00:00:FF:FF:FF") & Tins::EthernetII::address_type("FF:FF:FF:00:00:05")));
REQUIRE(Tins::EthernetII::address_type("00:07:00:00:00:05") == (Tins::EthernetII::address_type("00:07:00:FF:FF:FF") & Tins::EthernetII::address_type("FF:FF:FF:00:00:05")));
}
TEST_CASE( "test or operator", "[IpAddressTranslator]" ) {
REQUIRE(Tins::IPv4Address("255.255.255.255") == (Tins::IPv4Address("0.0.0.0") | Tins::IPv4Address("255.255.255.255")));
REQUIRE(Tins::IPv4Address("0.255.255.255") == (Tins::IPv4Address("0.0.255.255") | Tins::IPv4Address("0.255.255.0")));
REQUIRE(Tins::IPv4Address("255.255.255.255") == (Tins::IPv4Address("0.255.255.255") | Tins::IPv4Address("255.255.255.255")));
REQUIRE(Tins::IPv4Address("255.0.0.0") == (Tins::IPv4Address("255.0.0.0") | Tins::IPv4Address("255.0.0.0")));
REQUIRE(Tins::IPv4Address("255.255.255.255") == (Tins::IPv4Address("255.255.255.255") | Tins::IPv4Address("255.255.255.255")));
REQUIRE(Tins::IPv4Address("1.255.255.255") == (Tins::IPv4Address("0.255.1.255") | Tins::IPv4Address("1.1.255.1")));
REQUIRE(Tins::IPv4Address("0.255.0.0") == (Tins::IPv4Address("0.254.0.0") | Tins::IPv4Address("0.1.0.0")));
REQUIRE(Tins::IPv6Address("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF") == (Tins::IPv6Address("::0") | Tins::IPv6Address("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF")));
REQUIRE(Tins::IPv6Address("FFFF:FFFF:0000:FFFF:00FF:FFFF:FFFF:FFFF") == (Tins::IPv6Address("FFFF:FFFF:0000:FFFF:00AA:FFFF:FFFF:FFFF") | Tins::IPv6Address("0000:FFFF:0000:FFFF:00FF:FFFF:FFFF:FFFF")));
REQUIRE(Tins::IPv6Address("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF") == (Tins::IPv6Address("FFFF:0:FFFF:0:FFFF:0:FFFF:0") | Tins::IPv6Address("1:FFFF:1:FFFF:1:FFFF:1:FFFF")));
REQUIRE(Tins::EthernetII::address_type("FF:FF:FF:FF:FF:FF") == (Tins::EthernetII::address_type("00:00:00:00:00:00") | Tins::EthernetII::address_type("FF:FF:FF:FF:FF:FF")));
REQUIRE(Tins::EthernetII::address_type("FF:FF:FF:FF:FF:05") == (Tins::EthernetII::address_type("00:00:00:FF:FF:00") | Tins::EthernetII::address_type("FF:FF:FF:00:00:05")));
REQUIRE(Tins::EthernetII::address_type("FF:07:FF:00:00:05") == (Tins::EthernetII::address_type("00:06:00:00:00:00") | Tins::EthernetII::address_type("FF:01:FF:00:00:05")));
}
TEST_CASE( "test toIpv4AddressBytes", "[IpAddressTranslator]" ) {
REQUIRE(0 == IpAddressTranslator::toIpv4AddressBytes(Tins::IPv6Address()));
REQUIRE(Tins::IPv4Address("0.0.0.1") == Tins::IPv4Address(IpAddressTranslator::toIpv4AddressBytes( "::1")));
REQUIRE(Tins::IPv4Address("111.111.111.111") == Tins::IPv4Address(IpAddressTranslator::toIpv4AddressBytes("::111.111.111.111")));
REQUIRE(Tins::IPv4Address("192.168.42.1") == Tins::IPv4Address(IpAddressTranslator::toIpv4AddressBytes("2011:0DB8::1111:192.168.42.1")));
REQUIRE(Tins::IPv4Address("1.2.3.4") == Tins::IPv4Address(IpAddressTranslator::toIpv4AddressBytes("2011:0DB8::0102:0304")));
}
TEST_CASE( "test toIpv6Address", "[IpAddressTranslator]" ) {
Tins::IPv6Address ipv6;
IpAddressTranslator::toIpv6Address(Tins::IPv4Address("0.0.0.1"), ipv6);
REQUIRE(Tins::IPv6Address("::1") == ipv6);
IpAddressTranslator::toIpv6Address(Tins::IPv4Address("111.111.111.111"), ipv6);
REQUIRE(Tins::IPv6Address("::111.111.111.111") == ipv6);
ipv6 = Tins::IPv6Address("2011:0DB8::");
IpAddressTranslator::toIpv6Address(Tins::IPv4Address("192.168.42.1"), ipv6);
REQUIRE(Tins::IPv6Address("2011:0DB8::192.168.42.1") == ipv6);
IpAddressTranslator::toIpv6Address(Tins::IPv4Address("1.2.3.4"), ipv6);
REQUIRE(Tins::IPv6Address("2011:0DB8::0102:0304") == ipv6);
ipv6 = Tins::IPv6Address("2011:0DB8::ffff:ffff:ffff");
IpAddressTranslator::toIpv6Address(Tins::IPv4Address("1.2.3.4"), ipv6);
REQUIRE(Tins::IPv6Address("2011:0DB8::ffff:0102:0304") == ipv6);
}
TEST_CASE( "test toSolicitedNodeAddress", "[IpAddressTranslator]" ) {
Tins::IPv6Address ipv6;
IpAddressTranslator::toSolicitedNodeAddress(Tins::IPv6Address("2011:0DB8::"), ipv6);
REQUIRE(Tins::IPv6Address("FF02::1:FF00:0") == ipv6);
IpAddressTranslator::toSolicitedNodeAddress(Tins::IPv6Address("2011:0DB8::ffff:ff12:3456"), ipv6);
REQUIRE(Tins::IPv6Address("FF02::1:FF12:3456") == ipv6);
IpAddressTranslator::toSolicitedNodeAddress(Tins::IPv4Address("0.0.0.1"), ipv6);
REQUIRE(Tins::IPv6Address("FF02::1:FF00:1") == ipv6);
IpAddressTranslator::toSolicitedNodeAddress(Tins::IPv4Address("1.2.3.4"), ipv6);
REQUIRE(Tins::IPv6Address("FF02::1:FF02:0304") == ipv6);
}

26
test/src/testcase.cpp Normal file
View File

@@ -0,0 +1,26 @@
#define CATCH_CONFIG_MAIN // This tells Catch to provide a main() - only do this in one cpp file
#include "fakeit.hpp"
using namespace fakeit;
struct SomeInterface {
virtual int foo(int) = 0;
virtual int bar(int,int) = 0;
};
TEST_CASE( "test foo succss", "[footest]" ) {
// Stub a method to return a value once
Mock<SomeInterface> mock;
// Stub a method to return a value once
When(Method(mock,foo)).AlwaysReturn(1);
SomeInterface & i = mock.get();
// Production code:
i.foo(1);
i.foo(2);
i.foo(3);
//c checks
Verify(Method(mock,foo));
REQUIRE(1 == 1);
}