made test data paths dynamically configurable with the default path of @srcdir@/testdata. This will allow testdata to be referred to from a non-src build directory.

We can also specify mulitiple directories, which may happen if we generate some data files from spec at build time and run tests under a non-src directory.


git-svn-id: svn://bind10.isc.org/svn/bind10/trunk@1709 e5f2f494-b856-4b98-b285-d166d9295462

src/lib/dns/tests/Makefile.am

@@ -1,5 +1,6 @@
 AM_CPPFLAGS = -I$(top_builddir)/src/lib -I$(top_srcdir)/src/lib
 AM_CPPFLAGS += -I$(top_srcdir)/src/lib/dns -I$(top_builddir)/src/lib/dns
+AM_CPPFLAGS += -DTEST_DATA_DIR=\"$(srcdir)/testdata\"
 
 CLEANFILES = *.gcno *.gcda
 

src/lib/dns/tests/message_unittest.cc

@@ -95,7 +95,7 @@ TEST_F(MessageTest, RcodeToText) {
 
 
 TEST_F(MessageTest, fromWire) {
-    factoryFromFile(message_parse, "testdata/message_fromWire1");
+    factoryFromFile(message_parse, "message_fromWire1");
     EXPECT_EQ(0x1035, message_parse.getQid());
     EXPECT_EQ(Opcode::QUERY(), message_parse.getOpcode());
     EXPECT_EQ(Rcode::NOERROR(), message_parse.getRcode());
@@ -129,17 +129,17 @@ TEST_F(MessageTest, fromWire) {
 
 TEST_F(MessageTest, GetEDNS0DOBit) {
     // Without EDNS0, DNSSEC is considered to be unsupported.
-    factoryFromFile(message_parse, "testdata/message_fromWire1");
+    factoryFromFile(message_parse, "message_fromWire1");
     EXPECT_FALSE(message_parse.isDNSSECSupported());
 
     // If DO bit is on, DNSSEC is considered to be supported.
     message_parse.clear(Message::PARSE);
-    factoryFromFile(message_parse, "testdata/message_fromWire2");
+    factoryFromFile(message_parse, "message_fromWire2");
     EXPECT_TRUE(message_parse.isDNSSECSupported());
 
     // If DO bit is off, DNSSEC is considered to be unsupported.
     message_parse.clear(Message::PARSE);
-    factoryFromFile(message_parse, "testdata/message_fromWire3");
+    factoryFromFile(message_parse, "message_fromWire3");
     EXPECT_FALSE(message_parse.isDNSSECSupported());
 }
 
@@ -165,17 +165,17 @@ TEST_F(MessageTest, SetEDNS0DOBit) {
 
 TEST_F(MessageTest, GetEDNS0UDPSize) {
     // Without EDNS0, the default max UDP size is used.
-    factoryFromFile(message_parse, "testdata/message_fromWire1");
+    factoryFromFile(message_parse, "message_fromWire1");
     EXPECT_EQ(Message::DEFAULT_MAX_UDPSIZE, message_parse.getUDPSize());
 
     // If the size specified in EDNS0 > default max, use it.
     message_parse.clear(Message::PARSE);
-    factoryFromFile(message_parse, "testdata/message_fromWire2");
+    factoryFromFile(message_parse, "message_fromWire2");
     EXPECT_EQ(4096, message_parse.getUDPSize());
 
     // If the size specified in EDNS0 < default max, keep using the default.
     message_parse.clear(Message::PARSE);
-    factoryFromFile(message_parse, "testdata/message_fromWire8");
+    factoryFromFile(message_parse, "message_fromWire8");
     EXPECT_EQ(Message::DEFAULT_MAX_UDPSIZE, message_parse.getUDPSize());
 }
 
@@ -204,36 +204,35 @@ TEST_F(MessageTest, SetEDNS0UDPSize) {
 
 TEST_F(MessageTest, EDNS0ExtCode) {
     // Extended Rcode = BADVERS
-    factoryFromFile(message_parse, "testdata/message_fromWire10");
+    factoryFromFile(message_parse, "message_fromWire10");
     EXPECT_EQ(Rcode::BADVERS(), message_parse.getRcode());
 
     // Maximum extended Rcode
     message_parse.clear(Message::PARSE);
-    factoryFromFile(message_parse, "testdata/message_fromWire11");
+    factoryFromFile(message_parse, "message_fromWire11");
     EXPECT_EQ(0xfff, message_parse.getRcode().getCode());
 }
 
 TEST_F(MessageTest, BadEDNS0) {
     // OPT RR in the answer section
-    EXPECT_THROW(factoryFromFile(message_parse, "testdata/message_fromWire4"),
+    EXPECT_THROW(factoryFromFile(message_parse, "message_fromWire4"),
                  DNSMessageFORMERR);
     // multiple OPT RRs (in the additional section)
     message_parse.clear(Message::PARSE);
-    EXPECT_THROW(factoryFromFile(message_parse, "testdata/message_fromWire5"),
+    EXPECT_THROW(factoryFromFile(message_parse, "message_fromWire5"),
                  DNSMessageFORMERR);
     // OPT RR of a non root name
     message_parse.clear(Message::PARSE);
-    EXPECT_THROW(factoryFromFile(message_parse, "testdata/message_fromWire6"),
+    EXPECT_THROW(factoryFromFile(message_parse, "message_fromWire6"),
                  DNSMessageFORMERR);
     // Compressed owner name of OPT RR points to a root name.
     // Not necessarily bogus, but very unusual and mostly pathological.
     // We accept it, but is it okay?
     message_parse.clear(Message::PARSE);
-    EXPECT_NO_THROW(factoryFromFile(message_parse,
-                                    "testdata/message_fromWire7"));
+    EXPECT_NO_THROW(factoryFromFile(message_parse, "message_fromWire7"));
     // Unsupported Version
     message_parse.clear(Message::PARSE);
-    EXPECT_THROW(factoryFromFile(message_parse, "testdata/message_fromWire9"),
+    EXPECT_THROW(factoryFromFile(message_parse, "message_fromWire9"),
                  DNSMessageBADVERS);
 }
 
@@ -259,7 +258,7 @@ TEST_F(MessageTest, toWire) {
 
     message_render.toWire(renderer);
     vector<unsigned char> data;
-    UnitTestUtil::readWireData("testdata/message_toWire1", data);
+    UnitTestUtil::readWireData("message_toWire1", data);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData, obuffer.getData(),
                         obuffer.getLength(), &data[0], data.size());
 }

src/lib/dns/tests/messagerenderer_unittest.cc

@@ -58,7 +58,7 @@ TEST_F(MessageRendererTest, writeIntger) {
 }
 
 TEST_F(MessageRendererTest, writeName) {
-    UnitTestUtil::readWireData("testdata/name_toWire1", data);
+    UnitTestUtil::readWireData("name_toWire1", data);
     renderer.writeName(Name("a.example.com."));
     renderer.writeName(Name("b.example.com."));
     renderer.writeName(Name("a.example.org."));
@@ -70,7 +70,7 @@ TEST_F(MessageRendererTest, writeNameInLargeBuffer) {
     size_t offset = 0x3fff;
     buffer.skip(offset);
 
-    UnitTestUtil::readWireData("testdata/name_toWire2", data);
+    UnitTestUtil::readWireData("name_toWire2", data);
     renderer.writeName(Name("a.example.com."));
     renderer.writeName(Name("a.example.com."));
     renderer.writeName(Name("b.example.com."));
@@ -81,7 +81,7 @@ TEST_F(MessageRendererTest, writeNameInLargeBuffer) {
 }
 
 TEST_F(MessageRendererTest, writeNameWithUncompressed) {
-    UnitTestUtil::readWireData("testdata/name_toWire3", data);
+    UnitTestUtil::readWireData("name_toWire3", data);
     renderer.writeName(Name("a.example.com."));
     renderer.writeName(Name("b.example.com."), false);
     renderer.writeName(Name("b.example.com."));
@@ -90,7 +90,7 @@ TEST_F(MessageRendererTest, writeNameWithUncompressed) {
 }
 
 TEST_F(MessageRendererTest, writeNamePointerChain) {
-    UnitTestUtil::readWireData("testdata/name_toWire4", data);
+    UnitTestUtil::readWireData("name_toWire4", data);
     renderer.writeName(Name("a.example.com."));
     renderer.writeName(Name("b.example.com."));
     renderer.writeName(Name("b.example.com."));
@@ -117,7 +117,7 @@ TEST_F(MessageRendererTest, compressMode) {
 TEST_F(MessageRendererTest, writeNameCaseCompress) {
     // By default MessageRenderer performs case insensitive compression.
 
-    UnitTestUtil::readWireData("testdata/name_toWire1", data);
+    UnitTestUtil::readWireData("name_toWire1", data);
     renderer.writeName(Name("a.example.com."));
     // this should match the first name in terms of compression:
     renderer.writeName(Name("b.exAmple.CoM."));
@@ -130,7 +130,7 @@ TEST_F(MessageRendererTest, writeNameCaseSensitiveCompress) {
     // name compression in case sensitive manner.  See the data file
     // description for details.
     renderer.setCompressMode(MessageRenderer::CASE_SENSITIVE);
-    UnitTestUtil::readWireData("testdata/name_toWire5", data);
+    UnitTestUtil::readWireData("name_toWire5", data);
     renderer.writeName(Name("a.example.com."));
     renderer.writeName(Name("b.eXample.com."));
     renderer.writeName(Name("c.eXample.com."));
@@ -140,7 +140,7 @@ TEST_F(MessageRendererTest, writeNameCaseSensitiveCompress) {
 
 TEST_F(MessageRendererTest, writeNameMixedCaseCompress) {
     renderer.setCompressMode(MessageRenderer::CASE_SENSITIVE);
-    UnitTestUtil::readWireData("testdata/name_toWire6", data);
+    UnitTestUtil::readWireData("name_toWire6", data);
     renderer.writeName(Name("a.example.com."));
     renderer.writeName(Name("b.eXample.com."));
 

src/lib/dns/tests/name_unittest.cc

@@ -222,33 +222,29 @@ TEST_F(NameTest, fromWire)
     //
     // normal case with a compression pointer
     EXPECT_PRED_FORMAT2(UnitTestUtil::matchName,
-                        nameFactoryFromWire("testdata/name_fromWire1", 25),
+                        nameFactoryFromWire("name_fromWire1", 25),
                         Name("vix.com"));
     // bogus label character (looks like a local compression pointer)
-    EXPECT_THROW(nameFactoryFromWire("testdata/name_fromWire2", 25),
-                 DNSMessageFORMERR);
+    EXPECT_THROW(nameFactoryFromWire("name_fromWire2", 25), DNSMessageFORMERR);
     // a bad compression pointer (too big)
-    EXPECT_THROW(nameFactoryFromWire("testdata/name_fromWire3_1", 25),
+    EXPECT_THROW(nameFactoryFromWire("name_fromWire3_1", 25),
                  DNSMessageFORMERR);
     // forward reference
-    EXPECT_THROW(nameFactoryFromWire("testdata/name_fromWire3_2", 25),
+    EXPECT_THROW(nameFactoryFromWire("name_fromWire3_2", 25),
                  DNSMessageFORMERR);
     // invalid name length
-    EXPECT_THROW(nameFactoryFromWire("testdata/name_fromWire4", 550),
-                 DNSMessageFORMERR);
+    EXPECT_THROW(nameFactoryFromWire("name_fromWire4", 550), DNSMessageFORMERR);
 
     // skip test for from Wire5.  It's for disabling decompression, but our
     // implementation always allows it.
 
     // bad pointer (too big)
-    EXPECT_THROW(nameFactoryFromWire("testdata/name_fromWire6", 25),
-                 DNSMessageFORMERR);
+    EXPECT_THROW(nameFactoryFromWire("name_fromWire6", 25), DNSMessageFORMERR);
     // input ends unexpectedly
-    EXPECT_THROW(nameFactoryFromWire("testdata/name_fromWire7", 25),
-                 DNSMessageFORMERR);
+    EXPECT_THROW(nameFactoryFromWire("name_fromWire7", 25), DNSMessageFORMERR);
     // many hops of compression but valid.  should succeed.
     EXPECT_PRED_FORMAT2(UnitTestUtil::matchName,
-                        nameFactoryFromWire("testdata/name_fromWire8", 383),
+                        nameFactoryFromWire("name_fromWire8", 383),
                         Name("vix.com"));
 
     //
@@ -257,25 +253,21 @@ TEST_F(NameTest, fromWire)
 
     // large names, a long but valid one, and invalid (too long) one.
     EXPECT_EQ(Name::MAX_WIRE,
-              nameFactoryFromWire("testdata/name_fromWire9", 0).getLength());
-    EXPECT_THROW(nameFactoryFromWire("testdata/name_fromWire10", 0).getLength(),
+              nameFactoryFromWire("name_fromWire9", 0).getLength());
+    EXPECT_THROW(nameFactoryFromWire("name_fromWire10", 0).getLength(),
                  DNSMessageFORMERR);
 
     // A name with possible maximum number of labels; awkward but valid
-    EXPECT_EQ(nameFactoryFromWire("testdata/name_fromWire11",
-                                  0).getLabelCount(),
+    EXPECT_EQ(nameFactoryFromWire("name_fromWire11", 0).getLabelCount(),
               Name::MAX_LABELS);
 
     // Wire format including an invalid label length
-    EXPECT_THROW(nameFactoryFromWire("testdata/name_fromWire12", 0),
-                 DNSMessageFORMERR);
+    EXPECT_THROW(nameFactoryFromWire("name_fromWire12", 0), DNSMessageFORMERR);
 
     // converting upper-case letters to down-case
-    EXPECT_EQ("vix.com.", nameFactoryFromWire("testdata/name_fromWire1",
-                                              25, true).toText());
-    EXPECT_EQ(3,
-              nameFactoryFromWire("testdata/name_fromWire1",
-                                  25).getLabelCount());
+    EXPECT_EQ("vix.com.",
+              nameFactoryFromWire("name_fromWire1", 25, true).toText());
+    EXPECT_EQ(3, nameFactoryFromWire("name_fromWire1", 25).getLabelCount());
 }
 
 TEST_F(NameTest, copyConstruct)
@@ -331,7 +323,7 @@ TEST_F(NameTest, toText)
                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                               "[\\\\]^_.`abcdefghijklmnopqrstuvwxyz{|}~.");
     EXPECT_EQ(all_printable,
-              nameFactoryFromWire("testdata/name_fromWire13", 0).toText());
+              nameFactoryFromWire("name_fromWire13", 0).toText());
 
     string all_nonprintable(
         "\\000\\001\\002\\003\\004\\005\\006\\007\\008\\009"
@@ -353,7 +345,7 @@ TEST_F(NameTest, toText)
         "\\240\\241\\242\\243\\244\\245\\246\\247\\248\\249"
         "\\250\\251\\252\\253\\254\\255.");
     EXPECT_EQ(all_nonprintable,
-              nameFactoryFromWire("testdata/name_fromWire14", 0).toText());
+              nameFactoryFromWire("name_fromWire14", 0).toText());
 }
 
 TEST_F(NameTest, toWireBuffer)

src/lib/dns/tests/question_unittest.cc

@@ -69,7 +69,7 @@ questionFromWire(const char* datafile, size_t position = 0)
 
 TEST_F(QuestionTest, fromWire)
 {
-    Question q = questionFromWire("testdata/question_fromWire");
+    Question q = questionFromWire("question_fromWire");
 
     EXPECT_EQ(example_name1, q.getName());
     EXPECT_EQ(RRClass::IN(), q.getClass());
@@ -77,17 +77,15 @@ TEST_F(QuestionTest, fromWire)
 
     // owner name of the second Question is compressed.  It's uncommon
     // (to have multiple questions), but isn't prohibited by the protocol.
-    q = questionFromWire("testdata/question_fromWire", 21);
+    q = questionFromWire("question_fromWire", 21);
     EXPECT_EQ(example_name2, q.getName());
     EXPECT_EQ(RRClass::CH(), q.getClass());
     EXPECT_EQ(RRType::A(), q.getType());
 
     // Pathological cases: Corresponding exceptions will be thrown from
     // the underlying parser.
-    EXPECT_THROW(questionFromWire("testdata/question_fromWire", 31),
-                 DNSMessageFORMERR);
-    EXPECT_THROW(questionFromWire("testdata/question_fromWire", 36),
-                 IncompleteRRClass);
+    EXPECT_THROW(questionFromWire("question_fromWire", 31), DNSMessageFORMERR);
+    EXPECT_THROW(questionFromWire("question_fromWire", 36), IncompleteRRClass);
 }
 
 TEST_F(QuestionTest, toText)
@@ -100,7 +98,7 @@ TEST_F(QuestionTest, toWireBuffer)
 {
     test_question1.toWire(obuffer);
     test_question2.toWire(obuffer);
-    UnitTestUtil::readWireData("testdata/question_toWire1", wiredata);
+    UnitTestUtil::readWireData("question_toWire1", wiredata);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData, obuffer.getData(),
                         obuffer.getLength(), &wiredata[0], wiredata.size());
 }
@@ -109,7 +107,7 @@ TEST_F(QuestionTest, toWireRenderer)
 {
     test_question1.toWire(renderer);
     test_question2.toWire(renderer);
-    UnitTestUtil::readWireData("testdata/question_toWire2", wiredata);
+    UnitTestUtil::readWireData("question_toWire2", wiredata);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData, obuffer.getData(),
                         obuffer.getLength(), &wiredata[0], wiredata.size());
 }

src/lib/dns/tests/rdata_cname_unittest.cc

@@ -68,25 +68,25 @@ TEST_F(Rdata_CNAME_Test, createFromWire)
 {
     EXPECT_EQ(0, rdata_cname.compare(
                   *rdataFactoryFromFile(RRType("CNAME"), RRClass("IN"),
-                                        "testdata/rdata_cname_fromWire")));
+                                        "rdata_cname_fromWire")));
     // RDLENGTH is too short
     EXPECT_THROW(rdataFactoryFromFile(RRType("CNAME"), RRClass("IN"),
-                                      "testdata/rdata_cname_fromWire", 18),
+                                      "rdata_cname_fromWire", 18),
                  InvalidRdataLength);
     // RDLENGTH is too long
     EXPECT_THROW(rdataFactoryFromFile(RRType("CNAME"), RRClass("IN"),
-                                      "testdata/rdata_cname_fromWire", 36),
+                                      "rdata_cname_fromWire", 36),
                  InvalidRdataLength);
     // incomplete name.  the error should be detected in the name constructor
     EXPECT_THROW(rdataFactoryFromFile(RRType("CNAME"), RRClass("IN"),
-                                      "testdata/rdata_cname_fromWire", 71),
+                                      "rdata_cname_fromWire", 71),
                  DNSMessageFORMERR);
 
     EXPECT_EQ(0, generic::CNAME("cn2.example.com").compare(
                   *rdataFactoryFromFile(RRType("CNAME"), RRClass("IN"),
-                                        "testdata/rdata_cname_fromWire", 55)));
+                                        "rdata_cname_fromWire", 55)));
     EXPECT_THROW(*rdataFactoryFromFile(RRType("CNAME"), RRClass("IN"),
-                                       "testdata/rdata_cname_fromWire", 63),
+                                       "rdata_cname_fromWire", 63),
                  InvalidRdataLength);
 }
 

src/lib/dns/tests/rdata_dname_unittest.cc

@@ -68,25 +68,25 @@ TEST_F(Rdata_DNAME_Test, createFromWire)
 {
     EXPECT_EQ(0, rdata_dname.compare(
                   *rdataFactoryFromFile(RRType("DNAME"), RRClass("IN"),
-                                        "testdata/rdata_dname_fromWire")));
+                                        "rdata_dname_fromWire")));
     // RDLENGTH is too short
     EXPECT_THROW(rdataFactoryFromFile(RRType("DNAME"), RRClass("IN"),
-                                      "testdata/rdata_dname_fromWire", 18),
+                                      "rdata_dname_fromWire", 18),
                  InvalidRdataLength);
     // RDLENGTH is too long
     EXPECT_THROW(rdataFactoryFromFile(RRType("DNAME"), RRClass("IN"),
-                                      "testdata/rdata_dname_fromWire", 36),
+                                      "rdata_dname_fromWire", 36),
                  InvalidRdataLength);
     // incomplete name.  the error should be detected in the name constructor
     EXPECT_THROW(rdataFactoryFromFile(RRType("DNAME"), RRClass("IN"),
-                                      "testdata/rdata_dname_fromWire", 71),
+                                      "rdata_dname_fromWire", 71),
                  DNSMessageFORMERR);
 
     EXPECT_EQ(0, generic::DNAME("dn2.example.com").compare(
                   *rdataFactoryFromFile(RRType("DNAME"), RRClass("IN"),
-                                        "testdata/rdata_dname_fromWire", 55)));
+                                        "rdata_dname_fromWire", 55)));
     EXPECT_THROW(*rdataFactoryFromFile(RRType("DNAME"), RRClass("IN"),
-                                       "testdata/rdata_dname_fromWire", 63),
+                                       "rdata_dname_fromWire", 63),
                  InvalidRdataLength);
 }
 

src/lib/dns/tests/rdata_dnskey_unittest.cc

@@ -91,7 +91,7 @@ TEST_F(Rdata_DNSKEY_Test, toWireRenderer)
     rdata_dnskey.toWire(renderer);
 
     vector<unsigned char> data;
-    UnitTestUtil::readWireData("testdata/rdata_dnskey_fromWire", data);
+    UnitTestUtil::readWireData("rdata_dnskey_fromWire", data);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData,
                         static_cast<const uint8_t *>(obuffer.getData()) + 2,
                         obuffer.getLength() - 2, &data[2], data.size() - 2);
@@ -108,7 +108,7 @@ TEST_F(Rdata_DNSKEY_Test, createFromWire)
     generic::DNSKEY rdata_dnskey(dnskey_txt);
     EXPECT_EQ(0, rdata_dnskey.compare(
                   *rdataFactoryFromFile(RRType("DNSKEY"), RRClass("IN"),
-                                        "testdata/rdata_dnskey_fromWire")));
+                                        "rdata_dnskey_fromWire")));
 }
 
 TEST_F(Rdata_DNSKEY_Test, getTag)

src/lib/dns/tests/rdata_ds_unittest.cc

@@ -64,7 +64,7 @@ TEST_F(Rdata_DS_Test, badText_DS) {
 TEST_F(Rdata_DS_Test, createFromWire_DS) {
     EXPECT_EQ(0, rdata_ds.compare(
                   *rdataFactoryFromFile(RRType::DS(), RRClass::IN(),
-                                        "testdata/rdata_ds_fromWire")));
+                                        "rdata_ds_fromWire")));
 }
 
 TEST_F(Rdata_DS_Test, getTag_DS) {
@@ -77,7 +77,7 @@ TEST_F(Rdata_DS_Test, toWireRenderer) {
     rdata_ds.toWire(renderer);
 
     vector<unsigned char> data;
-    UnitTestUtil::readWireData("testdata/rdata_ds_fromWire", data);
+    UnitTestUtil::readWireData("rdata_ds_fromWire", data);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData,
                         static_cast<const uint8_t *>(obuffer.getData()) + 2,
                         obuffer.getLength() - 2, &data[2], data.size() - 2);

src/lib/dns/tests/rdata_in_a_unittest.cc

@@ -54,18 +54,18 @@ TEST_F(Rdata_IN_A_Test, createFromWire) {
     // Valid data
     EXPECT_EQ(0, rdata_in_a.compare(
                   *rdataFactoryFromFile(RRType::A(), RRClass::IN(),
-                                        "testdata/rdata_in_a_fromWire")));
+                                        "rdata_in_a_fromWire")));
     // RDLENGTH is too short
     EXPECT_THROW(rdataFactoryFromFile(RRType::A(), RRClass::IN(),
-                                      "testdata/rdata_in_a_fromWire", 6),
+                                      "rdata_in_a_fromWire", 6),
                  DNSMessageFORMERR);
     // RDLENGTH is too long
     EXPECT_THROW(rdataFactoryFromFile(RRType::A(), RRClass::IN(),
-                                      "testdata/rdata_in_a_fromWire", 12),
+                                      "rdata_in_a_fromWire", 12),
                  DNSMessageFORMERR);
     // buffer too short.
     EXPECT_THROW(rdataFactoryFromFile(RRType::A(), RRClass::IN(),
-                                      "testdata/rdata_in_a_fromWire", 19),
+                                      "rdata_in_a_fromWire", 19),
                  DNSMessageFORMERR);
 }
 

src/lib/dns/tests/rdata_in_aaaa_unittest.cc

@@ -52,18 +52,18 @@ TEST_F(Rdata_IN_AAAA_Test, createFromWire) {
     // Valid data
     EXPECT_EQ(0, rdata_in_aaaa.compare(
                   *rdataFactoryFromFile(RRType::AAAA(), RRClass::IN(),
-                                        "testdata/rdata_in_aaaa_fromWire")));
+                                        "rdata_in_aaaa_fromWire")));
     // RDLENGTH is too short
     EXPECT_THROW(rdataFactoryFromFile(RRType::AAAA(), RRClass::IN(),
-                                      "testdata/rdata_in_aaaa_fromWire", 18),
+                                      "rdata_in_aaaa_fromWire", 18),
                  DNSMessageFORMERR);
     // RDLENGTH is too long
     EXPECT_THROW(rdataFactoryFromFile(RRType::AAAA(), RRClass::IN(),
-                                      "testdata/rdata_in_aaaa_fromWire", 36),
+                                      "rdata_in_aaaa_fromWire", 36),
                  DNSMessageFORMERR);
     // buffer too short.
     EXPECT_THROW(rdataFactoryFromFile(RRType::AAAA(), RRClass::IN(),
-                                      "testdata/rdata_in_aaaa_fromWire", 55),
+                                      "rdata_in_aaaa_fromWire", 55),
                  DNSMessageFORMERR);
 }
 

src/lib/dns/tests/rdata_mx_unittest.cc

@@ -63,7 +63,7 @@ TEST_F(Rdata_MX_Test, createFromWire)
 {
     EXPECT_EQ(0, rdata_mx.compare(
                   *rdataFactoryFromFile(RRType("MX"), RRClass("IN"),
-                                        "testdata/rdata_mx_fromWire")));
+                                        "rdata_mx_fromWire")));
     // TBD: more tests
 }
 
@@ -73,7 +73,7 @@ TEST_F(Rdata_MX_Test, toWireRenderer)
     rdata_mx.toWire(renderer);
 
     vector<unsigned char> data;
-    UnitTestUtil::readWireData("testdata/rdata_mx_toWire1", data);
+    UnitTestUtil::readWireData("rdata_mx_toWire1", data);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData, obuffer.getData(),
                         obuffer.getLength(), &data[0], data.size());
 }
@@ -86,7 +86,7 @@ TEST_F(Rdata_MX_Test, toWireBuffer)
 #if 0
 // XXX: does not pass
     vector<unsigned char> data;
-    UnitTestUtil::readWireData("testdata/rdata_mx_toWire1", data);
+    UnitTestUtil::readWireData("rdata_mx_toWire1", data);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData, obuffer.getData(),
                         obuffer.getLength(), &data[0], data.size());
 #endif

src/lib/dns/tests/rdata_ns_unittest.cc

@@ -67,25 +67,25 @@ TEST_F(Rdata_NS_Test, createFromWire)
 {
     EXPECT_EQ(0, rdata_ns.compare(
                   *rdataFactoryFromFile(RRType("NS"), RRClass("IN"),
-                                        "testdata/rdata_ns_fromWire")));
+                                        "rdata_ns_fromWire")));
     // RDLENGTH is too short
     EXPECT_THROW(rdataFactoryFromFile(RRType("NS"), RRClass("IN"),
-                                      "testdata/rdata_ns_fromWire", 18),
+                                      "rdata_ns_fromWire", 18),
                  InvalidRdataLength);
     // RDLENGTH is too long
     EXPECT_THROW(rdataFactoryFromFile(RRType("NS"), RRClass("IN"),
-                                      "testdata/rdata_ns_fromWire", 36),
+                                      "rdata_ns_fromWire", 36),
                  InvalidRdataLength);
     // incomplete name.  the error should be detected in the name constructor
     EXPECT_THROW(rdataFactoryFromFile(RRType("NS"), RRClass("IN"),
-                                      "testdata/rdata_ns_fromWire", 71),
+                                      "rdata_ns_fromWire", 71),
                  DNSMessageFORMERR);
 
     EXPECT_EQ(0, generic::NS("ns2.example.com").compare(
                   *rdataFactoryFromFile(RRType("NS"), RRClass("IN"),
-                                        "testdata/rdata_ns_fromWire", 55)));
+                                        "rdata_ns_fromWire", 55)));
     EXPECT_THROW(*rdataFactoryFromFile(RRType("NS"), RRClass("IN"),
-                                       "testdata/rdata_ns_fromWire", 63),
+                                       "rdata_ns_fromWire", 63),
                  InvalidRdataLength);
 }
 

src/lib/dns/tests/rdata_nsec3_unittest.cc

@@ -85,16 +85,16 @@ TEST_F(Rdata_NSEC3_Test, createFromWire)
     const generic::NSEC3 rdata_nsec3(nsec3_txt);
     EXPECT_EQ(0, rdata_nsec3.compare(
                   *rdataFactoryFromFile(RRType::NSEC3(), RRClass::IN(),
-                                        "testdata/rdata_nsec3_fromWire1")));
+                                        "rdata_nsec3_fromWire1")));
 
     // Too short RDLENGTH
     EXPECT_THROW(rdataFactoryFromFile(RRType::NSEC3(), RRClass::IN(),
-                                      "testdata/rdata_nsec3_fromWire2"),
+                                      "rdata_nsec3_fromWire2"),
                  InvalidRdataLength);
 
     // Invalid type bits
     EXPECT_THROW(rdataFactoryFromFile(RRType::NSEC3(), RRClass::IN(),
-                                      "testdata/rdata_nsec3_fromWire3"),
+                                      "rdata_nsec3_fromWire3"),
                  DNSMessageFORMERR);
 }
 
@@ -105,7 +105,7 @@ TEST_F(Rdata_NSEC3_Test, toWireRenderer)
     rdata_nsec3.toWire(renderer);
 
     vector<unsigned char> data;
-    UnitTestUtil::readWireData("testdata/rdata_nsec3_fromWire1", data);
+    UnitTestUtil::readWireData("rdata_nsec3_fromWire1", data);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData,
                         static_cast<const uint8_t *>(obuffer.getData()) + 2,
                         obuffer.getLength() - 2, &data[2], data.size() - 2);

src/lib/dns/tests/rdata_nsec3param_unittest.cc

@@ -65,7 +65,7 @@ TEST_F(Rdata_NSEC3PARAM_Test, createFromWire)
     const generic::NSEC3PARAM rdata_nsec3param(nsec3param_txt);
     EXPECT_EQ(0, rdata_nsec3param.compare(
                   *rdataFactoryFromFile(RRType::NSEC3PARAM(), RRClass::IN(),
-                                       "testdata/rdata_nsec3param_fromWire1")));
+                                       "rdata_nsec3param_fromWire1")));
 }
 
 TEST_F(Rdata_NSEC3PARAM_Test, toWireRenderer)
@@ -75,7 +75,7 @@ TEST_F(Rdata_NSEC3PARAM_Test, toWireRenderer)
     rdata_nsec3param.toWire(renderer);
 
     vector<unsigned char> data;
-    UnitTestUtil::readWireData("testdata/rdata_nsec3param_fromWire1", data);
+    UnitTestUtil::readWireData("rdata_nsec3param_fromWire1", data);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData,
                         static_cast<const uint8_t *>(obuffer.getData()) + 2,
                         obuffer.getLength() - 2, &data[2], data.size() - 2);

src/lib/dns/tests/rdata_nsec_unittest.cc

@@ -57,52 +57,52 @@ TEST_F(Rdata_NSEC_Test, createFromWire_NSEC) {
     const generic::NSEC rdata_nsec(nsec_txt);
     EXPECT_EQ(0, rdata_nsec.compare(
                   *rdataFactoryFromFile(RRType::NSEC(), RRClass::IN(),
-                                        "testdata/rdata_nsec_fromWire1")));
+                                        "rdata_nsec_fromWire1")));
 
     // Too short RDLENGTH
     EXPECT_THROW(rdataFactoryFromFile(RRType::NSEC(), RRClass::IN(),
-                                      "testdata/rdata_nsec_fromWire2"),
+                                      "rdata_nsec_fromWire2"),
                  DNSMessageFORMERR);
 
     EXPECT_THROW(rdataFactoryFromFile(RRType::NSEC(), RRClass::IN(),
-                                      "testdata/rdata_nsec_fromWire3"),
+                                      "rdata_nsec_fromWire3"),
                  DNSMessageFORMERR);
 
     // A malformed NSEC bitmap length field that could cause overflow.
     EXPECT_THROW(rdataFactoryFromFile(RRType::NSEC(), RRClass::IN(),
-                                      "testdata/rdata_nsec_fromWire4"),
+                                      "rdata_nsec_fromWire4"),
                  DNSMessageFORMERR);
 
     // The bitmap field is incomplete (only the first byte is included)
     EXPECT_THROW(rdataFactoryFromFile(RRType::NSEC(), RRClass::IN(),
-                                      "testdata/rdata_nsec_fromWire5"),
+                                      "rdata_nsec_fromWire5"),
                  DNSMessageFORMERR);
 
     // Bitmap length is 0, which is invalid.
     EXPECT_THROW(rdataFactoryFromFile(RRType::NSEC(), RRClass::IN(),
-                                      "testdata/rdata_nsec_fromWire6"),
+                                      "rdata_nsec_fromWire6"),
                  DNSMessageFORMERR);
 
     // A boundary case: longest possible bitmaps (32 maps).  This should be
     // accepted.
     EXPECT_NO_THROW(rdataFactoryFromFile(RRType::NSEC(), RRClass::IN(),
-                                         "testdata/rdata_nsec_fromWire7"));
+                                         "rdata_nsec_fromWire7"));
 
     // Another boundary condition: 33 bitmaps, which should be rejected.
     EXPECT_THROW(rdataFactoryFromFile(RRType::NSEC(), RRClass::IN(),
-                                      "testdata/rdata_nsec_fromWire8"),
+                                      "rdata_nsec_fromWire8"),
                  DNSMessageFORMERR);
 
     // Disordered bitmap window blocks.
     EXPECT_THROW(rdataFactoryFromFile(RRType::NSEC(), RRClass::IN(),
-                                      "testdata/rdata_nsec_fromWire9"),
+                                      "rdata_nsec_fromWire9"),
                  DNSMessageFORMERR);
 
     // Bitmap ending with all-zero bytes.  Not necessarily harmful except
     // the additional overhead of parsing, but invalid according to the
     // spec anyway.
     EXPECT_THROW(rdataFactoryFromFile(RRType::NSEC(), RRClass::IN(),
-                                      "testdata/rdata_nsec_fromWire10"),
+                                      "rdata_nsec_fromWire10"),
                  DNSMessageFORMERR);
 }
 
@@ -112,7 +112,7 @@ TEST_F(Rdata_NSEC_Test, toWireRenderer_NSEC) {
     rdata_nsec.toWire(renderer);
 
     vector<unsigned char> data;
-    UnitTestUtil::readWireData("testdata/rdata_nsec_fromWire1", data);
+    UnitTestUtil::readWireData("rdata_nsec_fromWire1", data);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData,
                         static_cast<const uint8_t *>(obuffer.getData()) + 2,
                         obuffer.getLength() - 2, &data[2], data.size() - 2);

src/lib/dns/tests/rdata_opt_unittest.cc

@@ -49,13 +49,13 @@ TEST_F(Rdata_OPT_Test, createFromWire)
     // Valid cases: in the simple implementation with no supported options,
     // we can only check these don't throw.
     EXPECT_NO_THROW(rdataFactoryFromFile(RRType::OPT(), RRClass("CLASS4096"),
-                                         "testdata/rdata_opt_fromWire"));
+                                         "rdata_opt_fromWire"));
     EXPECT_NO_THROW(rdataFactoryFromFile(RRType::OPT(), RRClass::CH(),
-                                         "testdata/rdata_opt_fromWire", 2));
+                                         "rdata_opt_fromWire", 2));
 
     // short buffer case.
     EXPECT_THROW(rdataFactoryFromFile(RRType::OPT(), RRClass::IN(),
-                                      "testdata/rdata_opt_fromWire", 11),
+                                      "rdata_opt_fromWire", 11),
                  InvalidRdataLength);
 }
 
@@ -81,7 +81,7 @@ TEST_F(Rdata_OPT_Test, compare)
     // This simple implementation always returns "true"
     EXPECT_EQ(0, rdata_opt.compare(
                   *rdataFactoryFromFile(RRType::OPT(), RRClass::CH(),
-                                        "testdata/rdata_opt_fromWire", 2)));
+                                        "rdata_opt_fromWire", 2)));
 
     // comparison attempt between incompatible RR types should be rejected
     EXPECT_THROW(rdata_opt.compare(*RdataTest::rdata_nomatch), bad_cast); 

src/lib/dns/tests/rdata_ptr_unittest.cc

@@ -71,25 +71,25 @@ TEST_F(Rdata_PTR_Test, createFromWire)
 {
     EXPECT_EQ(0, rdata_ptr.compare(
                   *rdataFactoryFromFile(RRType("PTR"), RRClass("IN"),
-                                        "testdata/rdata_ns_fromWire")));
+                                        "rdata_ns_fromWire")));
     // RDLENGTH is too short
     EXPECT_THROW(rdataFactoryFromFile(RRType("PTR"), RRClass("IN"),
-                                      "testdata/rdata_ns_fromWire", 18),
+                                      "rdata_ns_fromWire", 18),
                  InvalidRdataLength);
     // RDLENGTH is too long
     EXPECT_THROW(rdataFactoryFromFile(RRType("PTR"), RRClass("IN"),
-                                      "testdata/rdata_ns_fromWire", 36),
+                                      "rdata_ns_fromWire", 36),
                  InvalidRdataLength);
     // incomplete name.  the error should be detected in the name constructor
     EXPECT_THROW(rdataFactoryFromFile(RRType("PTR"), RRClass("IN"),
-                                      "testdata/rdata_ns_fromWire", 71),
+                                      "rdata_ns_fromWire", 71),
                  DNSMessageFORMERR);
 
     EXPECT_EQ(0, generic::PTR("ns2.example.com").compare(
                   *rdataFactoryFromFile(RRType("PTR"), RRClass("IN"),
-                                        "testdata/rdata_ns_fromWire", 55)));
+                                        "rdata_ns_fromWire", 55)));
     EXPECT_THROW(*rdataFactoryFromFile(RRType("PTR"), RRClass("IN"),
-                                       "testdata/rdata_ns_fromWire", 63),
+                                       "rdata_ns_fromWire", 63),
                  InvalidRdataLength);
 }
 

src/lib/dns/tests/rdata_rrsig_unittest.cc

@@ -124,15 +124,15 @@ TEST_F(Rdata_RRSIG_Test, createFromWire)
                 "ZgWZzQKeTKPOYWrnYtdZW4PnPQFeUl3orgLev7F8J6FZlDn0y/J/ThR5"
                 "m36Mo2/Gdxjj8lJ/IjPVkdpKyBpcnYND8KEIma5MyNCNeyO1UkfPQZGHNSQ=");
     EXPECT_EQ(rrsig_txt, rdataFactoryFromFile(RRType("RRSIG"), RRClass("IN"),
-                             "testdata/rdata_rrsig_fromWire1")->toText());
+                             "rdata_rrsig_fromWire1")->toText());
     generic::RRSIG rdata_rrsig(rrsig_txt);
     EXPECT_EQ(0, rdata_rrsig.compare(
                       *rdataFactoryFromFile(RRType("RRSIG"), RRClass("IN"),
-                                          "testdata/rdata_rrsig_fromWire1")));
+                                          "rdata_rrsig_fromWire1")));
 
     // RDLEN is too short
     EXPECT_THROW(rdataFactoryFromFile(RRType::RRSIG(), RRClass::IN(),
-                                      "testdata/rdata_rrsig_fromWire2"),
+                                      "rdata_rrsig_fromWire2"),
                  InvalidRdataLength);
 }
 }

src/lib/dns/tests/rdata_soa_unittest.cc

@@ -46,7 +46,7 @@ TEST_F(Rdata_SOA_Test, createFromText) {
 TEST_F(Rdata_SOA_Test, createFromWire) {
     EXPECT_EQ(0, rdata_soa.compare(
                   *rdataFactoryFromFile(RRType("SOA"), RRClass("IN"),
-                                        "testdata/rdata_soa_fromWire")));
+                                        "rdata_soa_fromWire")));
     // TBD: more tests
 }
 
@@ -55,7 +55,7 @@ TEST_F(Rdata_SOA_Test, toWireRenderer) {
     rdata_soa.toWire(renderer);
 
     vector<unsigned char> data;
-    UnitTestUtil::readWireData("testdata/rdata_soa_fromWire", data);
+    UnitTestUtil::readWireData("rdata_soa_fromWire", data);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData,
                         static_cast<const uint8_t *>(obuffer.getData()) + 2,
                         obuffer.getLength() - 2, &data[2], data.size() - 2);
@@ -65,7 +65,7 @@ TEST_F(Rdata_SOA_Test, toWireBuffer) {
     obuffer.skip(2);
     rdata_soa.toWire(obuffer);
     vector<unsigned char> data;
-    UnitTestUtil::readWireData("testdata/rdata_soa_toWireUncompressed", data);
+    UnitTestUtil::readWireData("rdata_soa_toWireUncompressed", data);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData,
                         static_cast<const uint8_t *>(obuffer.getData()) + 2,
                         obuffer.getLength() - 2, &data[2], data.size() - 2);

src/lib/dns/tests/rdata_txt_unittest.cc

@@ -104,17 +104,17 @@ makeLargest(vector<uint8_t>& data) {
 TEST_F(Rdata_TXT_Test, createFromWire) {
     EXPECT_EQ(0, rdata_txt.compare(
                   *rdataFactoryFromFile(RRType("TXT"), RRClass("IN"),
-                                        "testdata/rdata_txt_fromWire1")));
+                                        "rdata_txt_fromWire1")));
 
     // Empty character string
     EXPECT_EQ(0, rdata_txt_empty.compare(
                   *rdataFactoryFromFile(RRType("TXT"), RRClass("IN"),
-                                        "testdata/rdata_txt_fromWire2")));
+                                        "rdata_txt_fromWire2")));
 
     // Multiple character strings
     obuffer.clear();
     rdataFactoryFromFile(RRType("TXT"), RRClass("IN"),
-                         "testdata/rdata_txt_fromWire3")->toWire(obuffer);
+                         "rdata_txt_fromWire3")->toWire(obuffer);
     // the result should be 'wiredata_txt' repeated twice
     vector<uint8_t> expected_data(wiredata_txt, wiredata_txt +
                                   sizeof(wiredata_txt));
@@ -145,12 +145,12 @@ TEST_F(Rdata_TXT_Test, createFromWire) {
 
     // RDATA is empty, which is invalid for TXT.
     EXPECT_THROW(rdataFactoryFromFile(RRType("TXT"), RRClass("IN"),
-                                      "testdata/rdata_txt_fromWire4"),
+                                      "rdata_txt_fromWire4"),
                  DNSMessageFORMERR);
 
     // character-string length is too large, which could cause overrun.
     EXPECT_THROW(rdataFactoryFromFile(RRType("TXT"), RRClass("IN"),
-                                      "testdata/rdata_txt_fromWire5"),
+                                      "rdata_txt_fromWire5"),
                  DNSMessageFORMERR);
 }
 

src/lib/dns/tests/rdata_unittest.cc

@@ -107,15 +107,15 @@ TEST_F(Rdata_Unknown_Test, createFromText)
     // valid construction.  This also tests a normal case of "FromWire".
     EXPECT_EQ(0, generic::Generic("\\# 4 a1b2c30d").compare(
                   *rdataFactoryFromFile(unknown_rrtype, RRClass::IN(),
-                                        "testdata/rdata_unknown_fromWire")));
+                                        "rdata_unknown_fromWire")));
     // upper case hexadecimal digits should also be okay. 
     EXPECT_EQ(0, generic::Generic("\\# 4 A1B2C30D").compare(
                   *rdataFactoryFromFile(unknown_rrtype, RRClass::IN(),
-                                        "testdata/rdata_unknown_fromWire")));
+                                        "rdata_unknown_fromWire")));
     // 0-length RDATA should be accepted
     EXPECT_EQ(0, generic::Generic("\\# 0").compare(
                   *rdataFactoryFromFile(unknown_rrtype, RRClass::IN(),
-                                        "testdata/rdata_unknown_fromWire", 6)));
+                                        "rdata_unknown_fromWire", 6)));
     // hex encoding can be space-separated
     EXPECT_EQ(0, generic::Generic("\\# 4 a1 b2c30d").compare(rdata_unknown));
     EXPECT_EQ(0, generic::Generic("\\# 4 a1b2 c30d").compare(rdata_unknown));
@@ -154,7 +154,7 @@ TEST_F(Rdata_Unknown_Test, createFromWire)
 
     // buffer too short.  the error should be detected in buffer read
     EXPECT_THROW(rdataFactoryFromFile(unknown_rrtype, RRClass::IN(),
-                                      "testdata/rdata_unknown_fromWire", 8),
+                                      "rdata_unknown_fromWire", 8),
                  InvalidBufferPosition);
 
     // too large data

src/lib/dns/tests/rrclass_unittest.cc

@@ -84,8 +84,8 @@ TEST_F(RRClassTest, fromText)
 TEST_F(RRClassTest, fromWire)
 {
     EXPECT_EQ(0x1234,
-              rrclassFactoryFromWire("testdata/rrcode16_fromWire1").getCode());
-    EXPECT_THROW(rrclassFactoryFromWire("testdata/rrcode16_fromWire2"),
+              rrclassFactoryFromWire("rrcode16_fromWire1").getCode());
+    EXPECT_THROW(rrclassFactoryFromWire("rrcode16_fromWire2"),
                  IncompleteRRClass);
 }
 

src/lib/dns/tests/rrset_unittest.cc

@@ -201,7 +201,7 @@ TEST_F(RRsetTest, toWireBuffer)
 {
     rrset_a.toWire(buffer);
 
-    UnitTestUtil::readWireData("testdata/rrset_toWire1", wiredata);
+    UnitTestUtil::readWireData("rrset_toWire1", wiredata);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData, buffer.getData(),
                         buffer.getLength(), &wiredata[0], wiredata.size());
 
@@ -217,7 +217,7 @@ TEST_F(RRsetTest, toWireRenderer)
     rrset_a.toWire(renderer);
     rrset_ns.toWire(renderer);
 
-    UnitTestUtil::readWireData("testdata/rrset_toWire2", wiredata);
+    UnitTestUtil::readWireData("rrset_toWire2", wiredata);
     EXPECT_PRED_FORMAT4(UnitTestUtil::matchWireData, buffer.getData(),
                         buffer.getLength(), &wiredata[0], wiredata.size());
 

src/lib/dns/tests/rrttl_unittest.cc

@@ -85,8 +85,8 @@ TEST_F(RRTTLTest, fromText)
 TEST_F(RRTTLTest, fromWire)
 {
     EXPECT_EQ(0x12345678,
-              rrttlFactoryFromWire("testdata/rrcode32_fromWire1").getValue());
-    EXPECT_THROW(rrttlFactoryFromWire("testdata/rrcode32_fromWire2"),
+              rrttlFactoryFromWire("rrcode32_fromWire1").getValue());
+    EXPECT_THROW(rrttlFactoryFromWire("rrcode32_fromWire2"),
                  IncompleteRRTTL);
 }
 

src/lib/dns/tests/rrtype_unittest.cc

@@ -88,9 +88,8 @@ TEST_F(RRTypeTest, fromText)
 TEST_F(RRTypeTest, fromWire)
 {
     EXPECT_EQ(0x1234,
-              rrtypeFactoryFromWire("testdata/rrcode16_fromWire1").getCode());
-    EXPECT_THROW(rrtypeFactoryFromWire("testdata/rrcode16_fromWire2"),
-                 IncompleteRRType);
+              rrtypeFactoryFromWire("rrcode16_fromWire1").getCode());
+    EXPECT_THROW(rrtypeFactoryFromWire("rrcode16_fromWire2"), IncompleteRRType);
 }
 
 // from string, lower case

src/lib/dns/tests/run_unittests.cc

@@ -16,9 +16,12 @@
 
 #include <gtest/gtest.h>
 
+#include "unittest_util.h"
+
 int
-main(int argc, char* argv[])
-{
+main(int argc, char* argv[]) {
     ::testing::InitGoogleTest(&argc, argv);
+    isc::UnitTestUtil::addDataPath(TEST_DATA_DIR);
+
     return (RUN_ALL_TESTS());
 }

src/lib/dns/tests/unittest_util.cc

@@ -33,16 +33,51 @@ using namespace std;
 using isc::UnitTestUtil;
 using isc::dns::NameComparisonResult;
 
+namespace {
+class UnitTestUtilConfig {
+private:
+    // This is a singleton object and cannot be constructed explicitly.
+    UnitTestUtilConfig() {}
+    UnitTestUtilConfig(const UnitTestUtilConfig& source);
+    ~UnitTestUtilConfig() {}
+public:
+    /// Return a singleton unit test configuration object.  On first invocation
+    /// one will be constructed.
+    static UnitTestUtilConfig& getConfig();
+
+    /// A list of paths to wire data files.
+    /// \c UnitTestUtil::readWireData() (first version)
+    /// will search the directories in this list for the specified data file.
+    std::vector<string> data_paths_;
+};
+
+UnitTestUtilConfig&
+UnitTestUtilConfig::getConfig() {
+    static UnitTestUtilConfig config;
+    return (config);
+}
+}
+
 void
-UnitTestUtil::readWireData(const char* datafile,
-                           vector<unsigned char>& data)
-{
+UnitTestUtil::readWireData(const char* datafile, vector<unsigned char>& data) {
     ifstream ifs;
- 
-    ifs.open(datafile, ios_base::in);
-    if ((ifs.rdstate() & istream::failbit) != 0) {
-        throw runtime_error("failed to open data file: " +
-                                 string(datafile));
+
+    const UnitTestUtilConfig& config = UnitTestUtilConfig::getConfig();
+    vector<string>::const_iterator it = config.data_paths_.begin();
+    for (; it != config.data_paths_.end(); ++it) {
+        string data_path = *it;
+        if (data_path.empty() || *data_path.rend() != '/') {
+            data_path.push_back('/');
+        }
+        ifs.open((data_path + datafile).c_str(), ios_base::in);
+        if ((ifs.rdstate() & istream::failbit) == 0) {
+            break;
+        }
+    }
+
+    if (it == config.data_paths_.end()) {
+        throw runtime_error("failed to open data file in data paths: " +
+                            string(datafile));
     }
 
     data.clear();
@@ -61,6 +96,11 @@ UnitTestUtil::readWireData(const char* datafile,
 }
 
 void
+UnitTestUtil::addDataPath(const string& directory) {
+    UnitTestUtilConfig::getConfig().data_paths_.push_back(directory);
+}
+
+void
 UnitTestUtil::readWireData(const string& datastr,
                            vector<unsigned char>& data)
 {

src/lib/dns/tests/unittest_util.h

@@ -31,10 +31,15 @@ public:
     ///
     /// read text format wire data from a file and put it to the given vector.
     ///
-    static void readWireData(const char*datafile,
+    static void readWireData(const char* datafile,
                              std::vector<unsigned char>& data);
 
     ///
+    /// add a path that \c readWireData() will search for test data files.
+    ///
+    static void addDataPath(const std::string& directory);
+
+    ///
     /// convert a sequence of hex strings into the corresponding list of
     /// 8-bit integers, and append them to the vector.
     ///