Commit ec7c5400 authored by JINMEI Tatuya's avatar JINMEI Tatuya
Browse files

[2389] tepmlated common "from text" test pattern and used it for A/AAAA/SOA.

parent b791d348
......@@ -41,32 +41,11 @@ class Rdata_IN_A_Test : public RdataTest {
protected:
Rdata_IN_A_Test() : rdata_in_a("192.0.2.1") {}
// Common check to see the result of in::A Rdata construction either from
// std::string or with MasterLexer object. If it's expected to succeed
// the result should be identical to the commonly used test data
// (rdata_in_a); otherwise it should result in the exception specified as
// the template parameter.
template <typename ExForString, typename ExForLexer>
void checkFromText(const string& in_a_txt,
void checkFromTextIN_A(const std::string& rdata_txt,
bool throw_str_version = true,
bool throw_lexer_version = true)
{
if (throw_str_version) {
EXPECT_THROW(in::A in_a(in_a_txt), ExForString);
} else {
EXPECT_EQ(0, in::A(in_a_txt).compare(rdata_in_a));
}
std::stringstream ss(in_a_txt);
MasterLexer lexer;
lexer.pushSource(ss);
if (throw_lexer_version) {
EXPECT_THROW(in::A soa(lexer, NULL, MasterLoader::DEFAULT,
loader_cb), ExForLexer);
} else {
EXPECT_EQ(0, in::A(lexer, NULL, MasterLoader::DEFAULT,
loader_cb).compare(rdata_in_a));
}
bool throw_lexer_version = true) {
checkFromText<in::A, InvalidRdataText, InvalidRdataText>(
rdata_txt, rdata_in_a, throw_str_version, throw_lexer_version);
}
const in::A rdata_in_a;
......@@ -77,35 +56,32 @@ const uint8_t wiredata_in_a[] = { 192, 0, 2, 1 };
TEST_F(Rdata_IN_A_Test, createFromText) {
// Normal case: no exception for either case, so the exception type
// doesn't matter.
checkFromText<isc::Exception, isc::Exception>("192.0.2.1", false, false);
checkFromText<in::A, isc::Exception, isc::Exception>("192.0.2.1",
rdata_in_a, false,
false);
// should reject an abbreviated form of IPv4 address
checkFromText<InvalidRdataText, InvalidRdataText>("10.1");
checkFromTextIN_A("10.1");
// or an IPv6 address
checkFromText<InvalidRdataText, InvalidRdataText>("2001:db8::1234");
checkFromTextIN_A("2001:db8::1234");
// or any meaningless text as an IP address
checkFromText<InvalidRdataText, InvalidRdataText>("xxx");
checkFromTextIN_A("xxx");
// trailing white space: only string version throws
checkFromText<InvalidRdataText, InvalidRdataText>("192.0.2.1 ",
true, false);
checkFromTextIN_A("192.0.2.1 ", true, false);
// same for beginning white space.
checkFromText<InvalidRdataText, InvalidRdataText>(" 192.0.2.1",
true, false);
checkFromTextIN_A(" 192.0.2.1", true, false);
// same for trailing non-space garbage (note that lexer version still
// ignore it; it's expected to be detected at a higher layer).
checkFromText<InvalidRdataText, InvalidRdataText>("192.0.2.1 xxx",
true, false);
checkFromTextIN_A("192.0.2.1 xxx", true, false);
// nul character after a valid textual representation.
string nul_after_addr = "192.0.2.1";
nul_after_addr.push_back(0);
checkFromText<InvalidRdataText, InvalidRdataText>(nul_after_addr, true,
true);
checkFromTextIN_A(nul_after_addr, true, true);
// a valid address surrounded by parentheses; only okay with lexer
checkFromText<InvalidRdataText, InvalidRdataText>("(192.0.2.1)", true,
false);
checkFromTextIN_A("(192.0.2.1)", true, false);
}
TEST_F(Rdata_IN_A_Test, createFromWire) {
......
......@@ -41,27 +41,13 @@ protected:
// the result should be identical to the commonly used test data
// (rdata_in_a); otherwise it should result in the exception specified as
// the template parameter.
template <typename ExForString, typename ExForLexer>
void checkFromText(const string& in_aaaa_txt,
bool throw_str_version = true,
bool throw_lexer_version = true)
void checkFromTextIN_AAAA(const string& in_aaaa_txt,
bool throw_str_version = true,
bool throw_lexer_version = true)
{
if (throw_str_version) {
EXPECT_THROW(in::AAAA in_aaaa(in_aaaa_txt), ExForString);
} else {
EXPECT_EQ(0, in::AAAA(in_aaaa_txt).compare(rdata_in_aaaa));
}
std::stringstream ss(in_aaaa_txt);
MasterLexer lexer;
lexer.pushSource(ss);
if (throw_lexer_version) {
EXPECT_THROW(in::AAAA soa(lexer, NULL, MasterLoader::DEFAULT,
loader_cb), ExForLexer);
} else {
EXPECT_EQ(0, in::AAAA(lexer, NULL, MasterLoader::DEFAULT,
loader_cb).compare(rdata_in_aaaa));
}
checkFromText<in::AAAA, InvalidRdataText, InvalidRdataText>(
in_aaaa_txt, rdata_in_aaaa, throw_str_version,
throw_lexer_version);
}
const in::AAAA rdata_in_aaaa;
......@@ -74,34 +60,29 @@ const uint8_t wiredata_in_aaaa[] = {
TEST_F(Rdata_IN_AAAA_Test, createFromText) {
// Normal case: no exception for either case, so the exception type
// doesn't matter.
checkFromText<isc::Exception, isc::Exception>("2001:db8::1234", false,
false);
checkFromText<in::AAAA, isc::Exception, isc::Exception>(
"2001:db8::1234", rdata_in_aaaa, false, false);
// should reject an IP4 address.
checkFromText<InvalidRdataText, InvalidRdataText>("192.0.2.1");
checkFromTextIN_AAAA("192.0.2.1");
// or any meaningless text as an IPv6 address
checkFromText<InvalidRdataText, InvalidRdataText>("xxx");
checkFromTextIN_AAAA("xxx");
// trailing white space: only string version throws
checkFromText<InvalidRdataText, InvalidRdataText>("2001:db8::1234 ",
true, false);
checkFromTextIN_AAAA("2001:db8::1234 ", true, false);
// same for beginning white space.
checkFromText<InvalidRdataText, InvalidRdataText>(" 2001:db8::1234",
true, false);
checkFromTextIN_AAAA(" 2001:db8::1234", true, false);
// same for trailing non-space garbage (note that lexer version still
// ignore it; it's expected to be detected at a higher layer).
checkFromText<InvalidRdataText, InvalidRdataText>("2001:db8::1234 xxx",
true, false);
checkFromTextIN_AAAA("2001:db8::1234 xxx", true, false);
// nul character after a valid textual representation.
string nul_after_addr = "2001:db8::1234";
nul_after_addr.push_back(0);
checkFromText<InvalidRdataText, InvalidRdataText>(nul_after_addr, true,
true);
checkFromTextIN_AAAA(nul_after_addr, true, true);
// a valid address surrounded by parentheses; only okay with lexer
checkFromText<InvalidRdataText, InvalidRdataText>("(2001:db8::1234)", true,
false);
checkFromTextIN_AAAA("(2001:db8::1234)", true, false);
}
TEST_F(Rdata_IN_AAAA_Test, createFromWire) {
......
......@@ -39,35 +39,14 @@ protected:
2010012601, 3600, 300, 3600000, 1200)
{}
// Common check to see if the given text can be used to construct SOA
// Rdata that is identical rdata_soa.
void checkFromText(const char* soa_txt, const Name* origin = NULL) {
std::stringstream ss(soa_txt);
MasterLexer lexer;
lexer.pushSource(ss);
if (origin == NULL) {
// from-string constructor works correctly only when origin
// is NULL (by its nature).
EXPECT_EQ(0, generic::SOA(soa_txt).compare(rdata_soa));
}
EXPECT_EQ(0, generic::SOA(lexer, origin, MasterLoader::DEFAULT,
loader_cb).compare(rdata_soa));
}
// Common check if given text (which is invalid as SOA RDATA) is rejected
// with the specified type of exception: ExForString is the expected
// exception for the "from string" constructor; ExForLexer is for the
// constructor with master lexer.
template <typename ExForString, typename ExForLexer>
void checkFromBadTexxt(const char* soa_txt, const Name* origin = NULL) {
EXPECT_THROW(generic::SOA soa(soa_txt), ExForString);
std::stringstream ss(soa_txt);
MasterLexer lexer;
lexer.pushSource(ss);
EXPECT_THROW(generic::SOA soa(lexer, origin, MasterLoader::DEFAULT,
loader_cb), ExForLexer);
void checkFromTextSOA(const string& soa_txt, const Name* origin = NULL,
bool throw_str_version = true,
bool throw_lexer_version = true)
{
checkFromText<generic::SOA, ExForString, ExForLexer>(
soa_txt, rdata_soa, throw_str_version, throw_lexer_version,
origin);
}
const generic::SOA rdata_soa;
......@@ -75,87 +54,106 @@ protected:
TEST_F(Rdata_SOA_Test, createFromText) {
// A simple case.
checkFromText("ns.example.com. root.example.com. "
"2010012601 3600 300 3600000 1200");
checkFromTextSOA<isc::Exception, isc::Exception>(
"ns.example.com. root.example.com. 2010012601 3600 300 3600000 1200",
NULL, false, false);
// Beginning and trailing space are ignored.
checkFromText(" ns.example.com. root.example.com. "
"2010012601 3600 300 3600000 1200 ");
checkFromTextSOA<isc::Exception, isc::Exception>(
" ns.example.com. root.example.com. "
"2010012601 3600 300 3600000 1200 ", NULL, false, false);
// using extended TTL-like form for some parameters.
checkFromText("ns.example.com. root.example.com. "
"2010012601 1H 5M 1000H 20M");
checkFromTextSOA<isc::Exception, isc::Exception>(
"ns.example.com. root.example.com. 2010012601 1H 5M 1000H 20M",
NULL, false, false);
// multi-line.
checkFromText("ns.example.com. (root.example.com.\n"
"2010012601 1H 5M 1000H) 20M");
checkFromTextSOA<isc::Exception, isc::Exception>(
"ns.example.com. (root.example.com.\n"
"2010012601 1H 5M 1000H) 20M", NULL, false, false);
// relative names for MNAME and RNAME with a separate origin (lexer
// version only)
const Name origin("example.com");
checkFromText("ns root 2010012601 1H 5M 1000H 20M", &origin);
checkFromTextSOA<MissingNameOrigin, isc::Exception>(
"ns root 2010012601 1H 5M 1000H 20M", &origin, true, false);
// with the '@' notation with a separate origin (lexer version only)
// with the '@' notation with a separate origin (lexer version only;
// string version would throw)
const Name full_mname("ns.example.com");
checkFromText("@ root.example.com. 2010012601 1H 5M 1000H 20M",
&full_mname);
checkFromTextSOA<MissingNameOrigin, isc::Exception>(
"@ root.example.com. 2010012601 1H 5M 1000H 20M", &full_mname, true,
false);
// bad MNAME/RNAMEs
checkFromBadTexxt<EmptyLabel, EmptyLabel>(
checkFromTextSOA<EmptyLabel, EmptyLabel>(
"bad..example. . 2010012601 1H 5M 1000H 20M");
checkFromBadTexxt<EmptyLabel, EmptyLabel>(
checkFromTextSOA<EmptyLabel, EmptyLabel>(
". bad..example. 2010012601 1H 5M 1000H 20M");
// Names shouldn't be quoted. (Note: on completion of #2534, the resulting
// exception will be different).
checkFromBadTexxt<MissingNameOrigin, MissingNameOrigin>(
checkFromTextSOA<MissingNameOrigin, MissingNameOrigin>(
"\".\" . 0 0 0 0 0");
checkFromBadTexxt<MissingNameOrigin, MissingNameOrigin>(
checkFromTextSOA<MissingNameOrigin, MissingNameOrigin>(
". \".\" 0 0 0 0 0");
// Missing MAME or RNAME: for the string version, the serial would be
// tried as RNAME and result in "not absolute". For the lexer version,
// it reaches the end-of-line, missing min TTL.
checkFromBadTexxt<MissingNameOrigin, MasterLexer::LexerError>(
checkFromTextSOA<MissingNameOrigin, MasterLexer::LexerError>(
". 2010012601 0 0 0 0", &Name::ROOT_NAME());
// bad serial. the string version converts lexer error to
// InvalidRdataText.
checkFromBadTexxt<InvalidRdataText, MasterLexer::LexerError>(
checkFromTextSOA<InvalidRdataText, MasterLexer::LexerError>(
". . bad 0 0 0 0");
// bad serial; exceeding the uint32_t range (4294967296 = 2^32)
checkFromBadTexxt<InvalidRdataText, MasterLexer::LexerError>(
checkFromTextSOA<InvalidRdataText, MasterLexer::LexerError>(
". . 4294967296 0 0 0 0");
// Bad format for other numeric parameters. These will be tried as a TTL,
// and result in an exception there.
checkFromBadTexxt<InvalidRRTTL, InvalidRRTTL>(". . 2010012601 bad 0 0 0");
checkFromBadTexxt<InvalidRRTTL, InvalidRRTTL>(
checkFromTextSOA<InvalidRRTTL, InvalidRRTTL>(
". . 2010012601 bad 0 0 0");
checkFromTextSOA<InvalidRRTTL, InvalidRRTTL>(
". . 2010012601 4294967296 0 0 0");
checkFromBadTexxt<InvalidRRTTL, InvalidRRTTL>(". . 2010012601 0 bad 0 0");
checkFromBadTexxt<InvalidRRTTL, InvalidRRTTL>(
checkFromTextSOA<InvalidRRTTL, InvalidRRTTL>(
". . 2010012601 0 bad 0 0");
checkFromTextSOA<InvalidRRTTL, InvalidRRTTL>(
". . 2010012601 0 4294967296 0 0");
checkFromBadTexxt<InvalidRRTTL, InvalidRRTTL>(". . 2010012601 0 0 bad 0");
checkFromBadTexxt<InvalidRRTTL, InvalidRRTTL>(
checkFromTextSOA<InvalidRRTTL, InvalidRRTTL>(
". . 2010012601 0 0 bad 0");
checkFromTextSOA<InvalidRRTTL, InvalidRRTTL>(
". . 2010012601 0 0 4294967296 0");
checkFromBadTexxt<InvalidRRTTL, InvalidRRTTL>(". . 2010012601 0 0 0 bad");
checkFromBadTexxt<InvalidRRTTL, InvalidRRTTL>(
checkFromTextSOA<InvalidRRTTL, InvalidRRTTL>(
". . 2010012601 0 0 0 bad");
checkFromTextSOA<InvalidRRTTL, InvalidRRTTL>(
". . 2010012601 0 0 0 4294967296");
// No space between RNAME and serial. This case is the same as missing
// M/RNAME.
checkFromBadTexxt<MissingNameOrigin, MasterLexer::LexerError>(
checkFromTextSOA<MissingNameOrigin, MasterLexer::LexerError>(
". example.0 0 0 0 0", &Name::ROOT_NAME());
// Extra parameter. string version immediately detects the error.
EXPECT_THROW(generic::SOA soa(". . 0 0 0 0 0 extra"), InvalidRdataText);
// Likewise. Redundant newline is also considered an error.
EXPECT_THROW(generic::SOA soa(". . 0 0 0 0 0\n"), InvalidRdataText);
EXPECT_THROW(generic::SOA soa("\n. . 0 0 0 0 0"), InvalidRdataText);
// lexer version defers the check to the upper layer (we pass origin
// to skip the check with the string version).
checkFromText("ns root 2010012601 1H 5M 1000H 20M extra", &origin);
checkFromTextSOA<InvalidRdataText, isc::Exception>(
"ns.example.com. root.example.com. 2010012601 1H 5M 1000H 20M "
"extra", &origin, true, false);
// Likewise. Redundant newline is also considered an error. The lexer
// version accepts trailing newline, but not the beginning one (where
// the lexer expects a string excluding newline and EOF).
checkFromTextSOA<InvalidRdataText, isc::Exception>(
"ns.example.com. root.example.com. 2010012601 1H 5M 1000H 20M\n",
NULL, true, false);
checkFromTextSOA<InvalidRdataText, MasterLexer::LexerError>(
"\nns.example.com. root.example.com. 2010012601 1H 5M 1000H 20M",
NULL, true, true);
}
TEST_F(Rdata_SOA_Test, createFromWire) {
......
......@@ -24,6 +24,9 @@
#include <gtest/gtest.h>
#include <string>
#include <sstream>
using namespace isc::util;
namespace isc {
......@@ -36,6 +39,44 @@ protected:
const RRClass& rrclass,
const char* datafile,
size_t position = 0);
// Common check to see the result of Rdata construction of given type
// (template parameter RdataType) either from std::string or with
// MasterLexer object. If it's expected to succeed the result should be
// identical to the commonly used test data (rdata_expected); otherwise it
// should result in the exception specified as the template parameter:
// ExForString for the string version, and ExForLexer for the lexer
// version. throw_str_version and throw_lexer_version are set to true
// iff the string/lexer version is expected to throw, respectively.
// Parameter origin can be set to non NULL for the origin parameter of
// the lexer version of Rdata constructor.
template <typename RdataType, typename ExForString, typename ExForLexer>
void checkFromText(const std::string& rdata_txt,
const RdataType& rdata_expected,
bool throw_str_version = true,
bool throw_lexer_version = true,
const Name* origin = NULL)
{
SCOPED_TRACE(rdata_txt);
if (throw_str_version) {
EXPECT_THROW(RdataType rdata(rdata_txt), ExForString);
} else {
EXPECT_EQ(0, RdataType(rdata_txt).compare(rdata_expected));
}
std::stringstream ss(rdata_txt);
MasterLexer lexer;
lexer.pushSource(ss);
if (throw_lexer_version) {
EXPECT_THROW(RdataType rdata(lexer, origin, MasterLoader::DEFAULT,
loader_cb), ExForLexer);
} else {
EXPECT_EQ(0, RdataType(lexer, origin, MasterLoader::DEFAULT,
loader_cb).compare(rdata_expected));
}
}
OutputBuffer obuffer;
MessageRenderer renderer;
/// This is an RDATA object of some "unknown" RR type so that it can be
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment