[thirdparty/pdns.git] / pdns / test-misc_hh.cc

#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_NO_MAIN

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <boost/test/unit_test.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/foreach.hpp>
#include <boost/tuple/tuple.hpp>
#include "misc.hh"
#include "dns.hh"
#include <arpa/inet.h>
#include <utility>

using std::string;

BOOST_AUTO_TEST_SUITE(misc_hh)
typedef pair<std::string, uint16_t> typedns_t;

BOOST_AUTO_TEST_CASE(test_CIStringCompare) {
        set<std::string, CIStringCompare> nsset;
        nsset.insert("abc");
        nsset.insert("ns.example.com");
        nsset.insert("");
        nsset.insert("def");
        nsset.insert("aBc");
        nsset.insert("ns.example.com");
        BOOST_CHECK_EQUAL(nsset.size(), 4);

        ostringstream s;
        for(set<std::string, CIStringCompare>::const_iterator i=nsset.begin();i!=nsset.end();++i) {
                s<<"("<<*i<<")";
        }
        BOOST_CHECK_EQUAL(s.str(), "()(abc)(def)(ns.example.com)");
}

BOOST_AUTO_TEST_CASE(test_CIStringPairCompare) {
        set<typedns_t, CIStringPairCompare> nsset2;
        nsset2.insert(make_pair("ns.example.com", 1));
        nsset2.insert(make_pair("abc", 1));
        nsset2.insert(make_pair("", 1));
        nsset2.insert(make_pair("def", 1));
        nsset2.insert(make_pair("abc", 2));
        nsset2.insert(make_pair("abc", 1));
        nsset2.insert(make_pair("ns.example.com", 0));
        nsset2.insert(make_pair("abc", 2));
        nsset2.insert(make_pair("ABC", 2));
        BOOST_CHECK_EQUAL(nsset2.size(), 6);

        ostringstream s;
        for(set<typedns_t, CIStringPairCompare>::const_iterator i=nsset2.begin();i!=nsset2.end();++i) {
                s<<"("<<i->first<<"|"<<i->second<<")";
        }
        BOOST_CHECK_EQUAL(s.str(), "(|1)(abc|1)(abc|2)(def|1)(ns.example.com|0)(ns.example.com|1)");
}

BOOST_AUTO_TEST_CASE(test_pdns_ilexicographical_compare) {
  typedef boost::tuple<const std::string, const std::string, bool> case_t;
  typedef std::list<case_t> cases_t;

  cases_t cases = boost::assign::list_of
    (case_t(std::string(""), std::string(""), false))
    (case_t(std::string(""), std::string("abc"), true))
    (case_t(std::string("abc"), std::string(""), false))
    (case_t(std::string("abc"), std::string("abcd"), true))
    (case_t(std::string("abcd"), std::string("abc"), false))
    (case_t(std::string("abd"), std::string("abc"), false))
    (case_t(std::string("abc"), std::string("abd"), true))
    (case_t(std::string("abc"), std::string("Abc"), false))
    (case_t(std::string("Abc"), std::string("abc"), false))
  ;

  BOOST_FOREACH(const case_t& val, cases) {
    bool res;
    res = pdns_ilexicographical_compare(val.get<0>(), val.get<1>());
    BOOST_CHECK_EQUAL(res, val.get<2>());
  }
}

BOOST_AUTO_TEST_CASE(test_pdns_iequals) {
  typedef boost::tuple<const std::string, const std::string, bool> case_t;
  typedef std::list<case_t> cases_t;

  cases_t cases = boost::assign::list_of
    (case_t(std::string(""), std::string(""), true))
    (case_t(std::string(""), std::string("abc"), false))
    (case_t(std::string("abc"), std::string(""), false))
    (case_t(std::string("abc"), std::string("abcd"), false))
    (case_t(std::string("abcd"), std::string("abc"), false))
    (case_t(std::string("abd"), std::string("abc"), false))
    (case_t(std::string("abc"), std::string("abd"), false))
    (case_t(std::string("abc"), std::string("Abc"), true))
    (case_t(std::string("Abc"), std::string("abc"), true))
  ;

  BOOST_FOREACH(const case_t& val, cases) {
    bool res;
    res = pdns_iequals(val.get<0>(), val.get<1>());
    BOOST_CHECK_EQUAL(res, val.get<2>());
  }
}

BOOST_AUTO_TEST_CASE(test_stripDot) {
  BOOST_CHECK_EQUAL(stripDot("."), "");
  BOOST_CHECK_EQUAL(stripDot(""), "");
  BOOST_CHECK_EQUAL(stripDot("www.powerdns.com."), "www.powerdns.com");
  BOOST_CHECK_EQUAL(stripDot("www.powerdns.com"), "www.powerdns.com");
}

BOOST_AUTO_TEST_CASE(test_labelReverse) {
    BOOST_CHECK_EQUAL(labelReverse("www.powerdns.com"), "com powerdns www");
}

BOOST_AUTO_TEST_CASE(test_makeRelative) {
    BOOST_CHECK_EQUAL(makeRelative("www.powerdns.com", "powerdns.com"), "www");
    BOOST_CHECK_EQUAL(makeRelative("PoWeRdNs.CoM", "powerdns.com"), "");
}

BOOST_AUTO_TEST_CASE(test_AtomicCounter) {
    AtomicCounter ac;
    ++ac;
    ++ac;
    BOOST_CHECK_EQUAL(ac, 2);
}

BOOST_AUTO_TEST_CASE(test_endianness) {
  uint32_t i = 1;
#if BYTE_ORDER == BIG_ENDIAN
  BOOST_CHECK_EQUAL(i, htonl(i));
#elif BYTE_ORDER == LITTLE_ENDIAN 
  uint32_t j=0x01000000;
  BOOST_CHECK_EQUAL(i, ntohl(j));
#else
  BOOST_FAIL("Did not detect endianness at all");
#endif
}

BOOST_AUTO_TEST_CASE(test_parseService) {
    ServiceTuple tp;
    parseService("smtp.powerdns.com:25", tp);
    BOOST_CHECK_EQUAL(tp.host, "smtp.powerdns.com");
    BOOST_CHECK_EQUAL(tp.port, 25);
    parseService("smtp.powerdns.com", tp);    
    BOOST_CHECK_EQUAL(tp.port, 25);
}

BOOST_AUTO_TEST_CASE(test_ternary) {
  int maxqps=1024;
  BOOST_CHECK_EQUAL(defTer(maxqps, 16384), maxqps);
  BOOST_CHECK_EQUAL(defTer(0, 16384), 16384);

  int* qps=0;
  BOOST_CHECK_EQUAL(*defTer(qps, &maxqps), 1024);
}

BOOST_AUTO_TEST_CASE(test_SimpleMatch) {
  BOOST_CHECK_EQUAL(SimpleMatch("").match(std::string("")), true);
  BOOST_CHECK_EQUAL(SimpleMatch("?").match(std::string("")), false);
  BOOST_CHECK_EQUAL(SimpleMatch("*").match(std::string("")), true);

  BOOST_CHECK_EQUAL(SimpleMatch("abc").match(std::string("abc")), true);
  BOOST_CHECK_EQUAL(SimpleMatch("abc").match(std::string("ab")), false);
  BOOST_CHECK_EQUAL(SimpleMatch("abc").match(std::string("bc")), false);

  BOOST_CHECK_EQUAL(SimpleMatch("?").match(std::string("a")), true);
  BOOST_CHECK_EQUAL(SimpleMatch("a?c").match(std::string("abc")), true);
  BOOST_CHECK_EQUAL(SimpleMatch("a?c").match(std::string("ab")), false);
  BOOST_CHECK_EQUAL(SimpleMatch("a?c").match(std::string("bc")), false);

  BOOST_CHECK_EQUAL(SimpleMatch("*").match(std::string("*")), true);
  BOOST_CHECK_EQUAL(SimpleMatch("a*c").match(std::string("abc")), true);
  BOOST_CHECK_EQUAL(SimpleMatch("a*c").match(std::string("ab")), false);
  BOOST_CHECK_EQUAL(SimpleMatch("a*c").match(std::string("bc")), false);

  BOOST_CHECK_EQUAL(SimpleMatch("*").match(std::string("abcdefghj")), true);
  BOOST_CHECK_EQUAL(SimpleMatch("*a").match(std::string("abca")), true);
  BOOST_CHECK_EQUAL(SimpleMatch("*a").match(std::string("abcb")), false);
  BOOST_CHECK_EQUAL(SimpleMatch("abc*").match(std::string("abcabcabcabacabac")), true);
  BOOST_CHECK_EQUAL(SimpleMatch("abc*").match(std::string("abc")), true);
}

BOOST_AUTO_TEST_SUITE_END()
Commit	Line	Data
9bacbe09 PD	1	#define BOOST_TEST_DYN_LINK
	2	#define BOOST_TEST_NO_MAIN
	3
870a0fe4 AT	4	#ifdef HAVE_CONFIG_H
	5	#include "config.h"
	6	#endif
9bacbe09	7	#include <boost/test/unit_test.hpp>
8fb5b29a KM	8	#include <boost/assign/list_of.hpp>
	9	#include <boost/foreach.hpp>
	10	#include <boost/tuple/tuple.hpp>
9bacbe09	11	#include "misc.hh"
6e427101	12	#include "dns.hh"
c6e47b32	13	#include <arpa/inet.h>
9bacbe09 PD	14	#include <utility>
	15
	16	using std::string;
	17
	18	BOOST_AUTO_TEST_SUITE(misc_hh)
	19	typedef pair<std::string, uint16_t> typedns_t;
	20
	21	BOOST_AUTO_TEST_CASE(test_CIStringCompare) {
232f0877 CH	22	set<std::string, CIStringCompare> nsset;
	23	nsset.insert("abc");
	24	nsset.insert("ns.example.com");
	25	nsset.insert("");
	26	nsset.insert("def");
	27	nsset.insert("aBc");
	28	nsset.insert("ns.example.com");
	29	BOOST_CHECK_EQUAL(nsset.size(), 4);
9bacbe09	30
232f0877 CH	31	ostringstream s;
	32	for(set<std::string, CIStringCompare>::const_iterator i=nsset.begin();i!=nsset.end();++i) {
	33	s<<"("<<*i<<")";
	34	}
	35	BOOST_CHECK_EQUAL(s.str(), "()(abc)(def)(ns.example.com)");
9bacbe09 PD	36	}
	37
	38	BOOST_AUTO_TEST_CASE(test_CIStringPairCompare) {
232f0877 CH	39	set<typedns_t, CIStringPairCompare> nsset2;
	40	nsset2.insert(make_pair("ns.example.com", 1));
	41	nsset2.insert(make_pair("abc", 1));
	42	nsset2.insert(make_pair("", 1));
	43	nsset2.insert(make_pair("def", 1));
	44	nsset2.insert(make_pair("abc", 2));
	45	nsset2.insert(make_pair("abc", 1));
	46	nsset2.insert(make_pair("ns.example.com", 0));
	47	nsset2.insert(make_pair("abc", 2));
	48	nsset2.insert(make_pair("ABC", 2));
	49	BOOST_CHECK_EQUAL(nsset2.size(), 6);
9bacbe09	50
232f0877 CH	51	ostringstream s;
	52	for(set<typedns_t, CIStringPairCompare>::const_iterator i=nsset2.begin();i!=nsset2.end();++i) {
	53	s<<"("<<i->first<<"\|"<<i->second<<")";
	54	}
	55	BOOST_CHECK_EQUAL(s.str(), "(\|1)(abc\|1)(abc\|2)(def\|1)(ns.example.com\|0)(ns.example.com\|1)");
9bacbe09 PD	56	}
9bacbe09 PD	57
8fb5b29a KM	58	BOOST_AUTO_TEST_CASE(test_pdns_ilexicographical_compare) {
	59	typedef boost::tuple<const std::string, const std::string, bool> case_t;
	60	typedef std::list<case_t> cases_t;
	61
	62	cases_t cases = boost::assign::list_of
	63	(case_t(std::string(""), std::string(""), false))
	64	(case_t(std::string(""), std::string("abc"), true))
	65	(case_t(std::string("abc"), std::string(""), false))
	66	(case_t(std::string("abc"), std::string("abcd"), true))
	67	(case_t(std::string("abcd"), std::string("abc"), false))
	68	(case_t(std::string("abd"), std::string("abc"), false))
	69	(case_t(std::string("abc"), std::string("abd"), true))
	70	(case_t(std::string("abc"), std::string("Abc"), false))
	71	(case_t(std::string("Abc"), std::string("abc"), false))
	72	;
	73
	74	BOOST_FOREACH(const case_t& val, cases) {
	75	bool res;
	76	res = pdns_ilexicographical_compare(val.get<0>(), val.get<1>());
	77	BOOST_CHECK_EQUAL(res, val.get<2>());
	78	}
	79	}
	80
	81	BOOST_AUTO_TEST_CASE(test_pdns_iequals) {
	82	typedef boost::tuple<const std::string, const std::string, bool> case_t;
	83	typedef std::list<case_t> cases_t;
	84
	85	cases_t cases = boost::assign::list_of
	86	(case_t(std::string(""), std::string(""), true))
	87	(case_t(std::string(""), std::string("abc"), false))
	88	(case_t(std::string("abc"), std::string(""), false))
	89	(case_t(std::string("abc"), std::string("abcd"), false))
	90	(case_t(std::string("abcd"), std::string("abc"), false))
	91	(case_t(std::string("abd"), std::string("abc"), false))
	92	(case_t(std::string("abc"), std::string("abd"), false))
	93	(case_t(std::string("abc"), std::string("Abc"), true))
	94	(case_t(std::string("Abc"), std::string("abc"), true))
	95	;
	96
	97	BOOST_FOREACH(const case_t& val, cases) {
	98	bool res;
	99	res = pdns_iequals(val.get<0>(), val.get<1>());
	100	BOOST_CHECK_EQUAL(res, val.get<2>());
	101	}
	102	}
	103
76cd6661	104	BOOST_AUTO_TEST_CASE(test_stripDot) {
8fb5b29a KM	105	BOOST_CHECK_EQUAL(stripDot("."), "");
	106	BOOST_CHECK_EQUAL(stripDot(""), "");
	107	BOOST_CHECK_EQUAL(stripDot("www.powerdns.com."), "www.powerdns.com");
	108	BOOST_CHECK_EQUAL(stripDot("www.powerdns.com"), "www.powerdns.com");
76cd6661	109	}
	110
	111	BOOST_AUTO_TEST_CASE(test_labelReverse) {
	112	BOOST_CHECK_EQUAL(labelReverse("www.powerdns.com"), "com powerdns www");
	113	}
	114
	115	BOOST_AUTO_TEST_CASE(test_makeRelative) {
	116	BOOST_CHECK_EQUAL(makeRelative("www.powerdns.com", "powerdns.com"), "www");
bd414f9b	117	BOOST_CHECK_EQUAL(makeRelative("PoWeRdNs.CoM", "powerdns.com"), "");
76cd6661	118	}
76cd6661	119
1df6d212	120	BOOST_AUTO_TEST_CASE(test_AtomicCounter) {
76cd6661	121	AtomicCounter ac;
	122	++ac;
	123	++ac;
	124	BOOST_CHECK_EQUAL(ac, 2);
	125	}
	126
6e427101	127	BOOST_AUTO_TEST_CASE(test_endianness) {
	128	uint32_t i = 1;
	129	#if BYTE_ORDER == BIG_ENDIAN
	130	BOOST_CHECK_EQUAL(i, htonl(i));
	131	#elif BYTE_ORDER == LITTLE_ENDIAN
	132	uint32_t j=0x01000000;
	133	BOOST_CHECK_EQUAL(i, ntohl(j));
	134	#else
	135	BOOST_FAIL("Did not detect endianness at all");
	136	#endif
	137	}
76cd6661	138
	139	BOOST_AUTO_TEST_CASE(test_parseService) {
	140	ServiceTuple tp;
	141	parseService("smtp.powerdns.com:25", tp);
	142	BOOST_CHECK_EQUAL(tp.host, "smtp.powerdns.com");
	143	BOOST_CHECK_EQUAL(tp.port, 25);
	144	parseService("smtp.powerdns.com", tp);
	145	BOOST_CHECK_EQUAL(tp.port, 25);
	146	}
	147
83e5035d	148	BOOST_AUTO_TEST_CASE(test_ternary) {
	149	int maxqps=1024;
	150	BOOST_CHECK_EQUAL(defTer(maxqps, 16384), maxqps);
	151	BOOST_CHECK_EQUAL(defTer(0, 16384), 16384);
	152
	153	int* qps=0;
	154	BOOST_CHECK_EQUAL(*defTer(qps, &maxqps), 1024);
	155	}
	156
ac84f00c AT	157	BOOST_AUTO_TEST_CASE(test_SimpleMatch) {
	158	BOOST_CHECK_EQUAL(SimpleMatch("").match(std::string("")), true);
	159	BOOST_CHECK_EQUAL(SimpleMatch("?").match(std::string("")), false);
	160	BOOST_CHECK_EQUAL(SimpleMatch("*").match(std::string("")), true);
	161
	162	BOOST_CHECK_EQUAL(SimpleMatch("abc").match(std::string("abc")), true);
	163	BOOST_CHECK_EQUAL(SimpleMatch("abc").match(std::string("ab")), false);
	164	BOOST_CHECK_EQUAL(SimpleMatch("abc").match(std::string("bc")), false);
	165
	166	BOOST_CHECK_EQUAL(SimpleMatch("?").match(std::string("a")), true);
	167	BOOST_CHECK_EQUAL(SimpleMatch("a?c").match(std::string("abc")), true);
	168	BOOST_CHECK_EQUAL(SimpleMatch("a?c").match(std::string("ab")), false);
	169	BOOST_CHECK_EQUAL(SimpleMatch("a?c").match(std::string("bc")), false);
	170
	171	BOOST_CHECK_EQUAL(SimpleMatch("").match(std::string("")), true);
	172	BOOST_CHECK_EQUAL(SimpleMatch("a*c").match(std::string("abc")), true);
	173	BOOST_CHECK_EQUAL(SimpleMatch("a*c").match(std::string("ab")), false);
	174	BOOST_CHECK_EQUAL(SimpleMatch("a*c").match(std::string("bc")), false);
	175
	176	BOOST_CHECK_EQUAL(SimpleMatch("*").match(std::string("abcdefghj")), true);
	177	BOOST_CHECK_EQUAL(SimpleMatch("*a").match(std::string("abca")), true);
	178	BOOST_CHECK_EQUAL(SimpleMatch("*a").match(std::string("abcb")), false);
	179	BOOST_CHECK_EQUAL(SimpleMatch("abc*").match(std::string("abcabcabcabacabac")), true);
	180	BOOST_CHECK_EQUAL(SimpleMatch("abc*").match(std::string("abc")), true);
	181	}
	182
9bacbe09 PD	183	BOOST_AUTO_TEST_SUITE_END()
9bacbe09 PD	184