haiku.git

/*
 * Copyright 2010-2015, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "NetworkAddressTest.h"

#include <arpa/inet.h>
#include <netinet6/in6.h>

#include <NetworkAddress.h>
#include <TypeConstants.h>

#include <cppunit/TestCaller.h>
#include <cppunit/TestSuite.h>


NetworkAddressTest::NetworkAddressTest()
{
}


NetworkAddressTest::~NetworkAddressTest()
{
}


void
NetworkAddressTest::TestUnset()
{
	BNetworkAddress unset;

	CPPUNIT_ASSERT(unset.InitCheck() == B_OK);
	CPPUNIT_ASSERT(unset.Family() == AF_UNSPEC);
	CPPUNIT_ASSERT(unset.Port() == 0);

	BNetworkAddress set(AF_INET, "127.0.0.1");
	CPPUNIT_ASSERT(set.InitCheck() == B_OK);
	CPPUNIT_ASSERT(set.Family() == AF_INET);
	CPPUNIT_ASSERT(unset != set);

	set.Unset();
	CPPUNIT_ASSERT(unset == set);
}


void
NetworkAddressTest::TestSetTo()
{
	BNetworkAddress address;

	CPPUNIT_ASSERT(address.SetTo("127.0.0.1") == B_OK);
	CPPUNIT_ASSERT(address.Family() == AF_INET);
	CPPUNIT_ASSERT(address == BNetworkAddress(htonl(INADDR_LOOPBACK)));

	CPPUNIT_ASSERT(address.SetTo("::1", (uint16)0,
		B_UNCONFIGURED_ADDRESS_FAMILIES) == B_OK);
	CPPUNIT_ASSERT(address.Family() == AF_INET6);
	CPPUNIT_ASSERT(address == BNetworkAddress(in6addr_loopback));

	CPPUNIT_ASSERT(address.SetTo(AF_INET, "::1") != B_OK);
	CPPUNIT_ASSERT(address.SetTo(AF_INET6, "127.0.0.1") != B_OK);
	CPPUNIT_ASSERT(address.SetTo(AF_INET, "127.0.0.1") == B_OK);
	CPPUNIT_ASSERT(address.SetTo(AF_INET6, "::1", (uint16)0,
		B_UNCONFIGURED_ADDRESS_FAMILIES) == B_OK);
}


void
NetworkAddressTest::TestWildcard()
{
	BNetworkAddress wildcard;
	wildcard.SetToWildcard(AF_INET);

	CPPUNIT_ASSERT(wildcard.Family() == AF_INET);
	CPPUNIT_ASSERT(wildcard.Length() == sizeof(sockaddr_in));
	CPPUNIT_ASSERT(wildcard.Port() == 0);
	CPPUNIT_ASSERT(((sockaddr_in&)wildcard.SockAddr()).sin_addr.s_addr
		== INADDR_ANY);
	CPPUNIT_ASSERT(wildcard.IsEmpty());

	BNetworkAddress null(AF_INET, NULL);
	CPPUNIT_ASSERT(wildcard == null);

	wildcard.SetPort(555);
	CPPUNIT_ASSERT(!wildcard.IsEmpty());
}


void
NetworkAddressTest::TestNullAddr()
{
	BNetworkAddress nullAddr(AF_INET, NULL, 555);
	CPPUNIT_ASSERT(nullAddr.InitCheck() == B_OK);

	CPPUNIT_ASSERT(nullAddr.Family() == AF_INET);
	CPPUNIT_ASSERT(nullAddr.Length() == sizeof(sockaddr_in));
	CPPUNIT_ASSERT(nullAddr.Port() == 555);
	CPPUNIT_ASSERT(!nullAddr.IsEmpty());
}


void
NetworkAddressTest::TestSetAddressFromFamilyPort()
{
	BString addressStr = "192.168.1.1";
	BNetworkAddress nullAddr(AF_INET, NULL, 555);
	in_addr_t inetAddress = inet_addr(addressStr.String());
	CPPUNIT_ASSERT(nullAddr.SetAddress(inetAddress) == B_OK);
	CPPUNIT_ASSERT(nullAddr.InitCheck() == B_OK);

	CPPUNIT_ASSERT(nullAddr.Family() == AF_INET);
	CPPUNIT_ASSERT(nullAddr.Length() == sizeof(sockaddr_in));

	sockaddr_in& sin = (sockaddr_in&)nullAddr.SockAddr();
	CPPUNIT_ASSERT(addressStr == inet_ntoa(sin.sin_addr));
	CPPUNIT_ASSERT(nullAddr.Port() == 555);
	CPPUNIT_ASSERT(!nullAddr.IsEmpty());
}


void
NetworkAddressTest::TestIsLocal()
{
	BNetworkAddress local(AF_INET, "localhost");
	CPPUNIT_ASSERT(local.IsLocal());

	BNetworkAddress google(AF_INET, "google.com");
	CPPUNIT_ASSERT(!google.IsLocal());
}


void
NetworkAddressTest::TestFlatten()
{
	// IPv4

	BNetworkAddress ipv4(AF_INET, "localhost", 9999);

	char buffer[256];
	CPPUNIT_ASSERT(ipv4.Flatten(buffer, sizeof(buffer)) == B_OK);

	BNetworkAddress unflattened;
	CPPUNIT_ASSERT(unflattened.Unflatten(B_NETWORK_ADDRESS_TYPE, buffer,
		sizeof(buffer)) == B_OK);

	// unflatten buffer too small
	CPPUNIT_ASSERT(unflattened.Unflatten(B_NETWORK_ADDRESS_TYPE, buffer, 0)
		!= B_OK);
	CPPUNIT_ASSERT(unflattened.Unflatten(B_NETWORK_ADDRESS_TYPE, buffer, 3)
		!= B_OK);
	CPPUNIT_ASSERT(unflattened.Unflatten(B_NETWORK_ADDRESS_TYPE, buffer, 16)
		!= B_OK);

	CPPUNIT_ASSERT(ipv4 == unflattened);
}


void
NetworkAddressTest::TestEquals()
{
	BNetworkAddress v4AddressA("192.168.1.100");
	BNetworkAddress v4AddressB("192.168.1.100");
	BNetworkAddress v6AddressA("feed::dead:beef", (uint16)0,
		B_UNCONFIGURED_ADDRESS_FAMILIES);
	BNetworkAddress v6AddressB("feed::dead:beef", (uint16)0,
		B_UNCONFIGURED_ADDRESS_FAMILIES);

	CPPUNIT_ASSERT(v4AddressA.Equals(v4AddressB));
	CPPUNIT_ASSERT(v6AddressA.Equals(v6AddressB));
	CPPUNIT_ASSERT(!v4AddressA.Equals(v6AddressA));
}


/*static*/ void
NetworkAddressTest::AddTests(BTestSuite& parent)
{
	CppUnit::TestSuite& suite = *new CppUnit::TestSuite("NetworkAddressTest");

	suite.addTest(new CppUnit::TestCaller<NetworkAddressTest>(
		"NetworkAddressTest::TestUnset", &NetworkAddressTest::TestUnset));
	suite.addTest(new CppUnit::TestCaller<NetworkAddressTest>(
		"NetworkAddressTest::TestSetTo", &NetworkAddressTest::TestSetTo));
	suite.addTest(new CppUnit::TestCaller<NetworkAddressTest>(
		"NetworkAddressTest::TestWildcard", &NetworkAddressTest::TestWildcard));
	suite.addTest(new CppUnit::TestCaller<NetworkAddressTest>(
		"NetworkAddressTest::TestNullAddr", &NetworkAddressTest::TestNullAddr));
	suite.addTest(new CppUnit::TestCaller<NetworkAddressTest>(
		"NetworkAddressTest::TestSetAddressFromFamilyPort",
		&NetworkAddressTest::TestSetAddressFromFamilyPort));
	suite.addTest(new CppUnit::TestCaller<NetworkAddressTest>(
		"NetworkAddressTest::TestIsLocal", &NetworkAddressTest::TestIsLocal));
	suite.addTest(new CppUnit::TestCaller<NetworkAddressTest>(
		"NetworkAddressTest::TestFlatten", &NetworkAddressTest::TestFlatten));
	suite.addTest(new CppUnit::TestCaller<NetworkAddressTest>(
		"NetworkAddressTest::TestEquals", &NetworkAddressTest::TestEquals));

	parent.addTest("NetworkAddressTest", &suite);
}