face: InternalForwarderTransport & InternalClientTransport
InternalForwarderTransport and InternalClientTransport are a pair of forwarder-side
and client-side transports that can be connected with each other, so that link-layer
packets sent by one transport can be received by the other.
They are used together with LpFace, GenericLinkService, and ndn::Face to replace
InternalFace and InternalClientFace used by NFD management.
They also replace TopologyForwarderTransport and TopologyClientTransport used by
TopologyTester of forwarding unit tests.
refs #3225
Change-Id: I5b6b579c43dfd0b1b9def5100be2ce516219cb74
diff --git a/tests/daemon/face/internal-client-face.t.cpp b/tests/daemon/face/internal-client-face.t.cpp
deleted file mode 100644
index 0b2295c..0000000
--- a/tests/daemon/face/internal-client-face.t.cpp
+++ /dev/null
@@ -1,134 +0,0 @@
-/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
-/**
- * Copyright (c) 2014-2015, Regents of the University of California,
- * Arizona Board of Regents,
- * Colorado State University,
- * University Pierre & Marie Curie, Sorbonne University,
- * Washington University in St. Louis,
- * Beijing Institute of Technology,
- * The University of Memphis.
- *
- * This file is part of NFD (Named Data Networking Forwarding Daemon).
- * See AUTHORS.md for complete list of NFD authors and contributors.
- *
- * NFD is free software: you can redistribute it and/or modify it under the terms
- * of the GNU General Public License as published by the Free Software Foundation,
- * either version 3 of the License, or (at your option) any later version.
- *
- * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with
- * NFD, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "face/internal-client-face.hpp"
-#include "face/internal-face.hpp"
-#include "tests/test-common.hpp"
-#include "tests/identity-management-fixture.hpp"
-
-namespace nfd {
-namespace tests {
-
-class InternalClientFaceFixture : public UnitTestTimeFixture
- , public IdentityManagementFixture
-{
-public:
- InternalClientFaceFixture()
- : m_internalFace(make_shared<InternalFace>())
- , m_face(makeInternalClientFace(m_internalFace, m_keyChain))
- {
- }
-
-protected:
- shared_ptr<InternalFace> m_internalFace;
- shared_ptr<InternalClientFace> m_face;
-};
-
-BOOST_FIXTURE_TEST_SUITE(FaceInternalClientFace, InternalClientFaceFixture)
-
-BOOST_AUTO_TEST_CASE(ExpressInterest)
-{
- bool didReceiveDataBack = false;
- bool didTimeoutCallbackFire = false;
- Data receivedData;
-
- auto expressInterest = [&] (shared_ptr<Interest> interest) {
- didReceiveDataBack = false;
- didTimeoutCallbackFire = false;
- m_face->expressInterest(interest->setInterestLifetime(time::milliseconds(100)),
- [&] (const Interest& interest, Data& data) {
- didReceiveDataBack = true;
- receivedData = data;
- },
- bind([&] { didTimeoutCallbackFire = true; }));
- advanceClocks(time::milliseconds(1));
- };
-
- expressInterest(makeInterest("/test/timeout"));
- advanceClocks(time::milliseconds(1), 200); // wait for time out
- BOOST_CHECK(didTimeoutCallbackFire);
-
- auto dataToSend = makeData("/test/data")->setContent(Block("\x81\x01\0x01", 3));
- expressInterest(makeInterest("/test/data"));
- m_internalFace->sendData(dataToSend); // send data to satisfy the expressed interest
- advanceClocks(time::milliseconds(1));
- BOOST_CHECK(didReceiveDataBack);
- BOOST_CHECK(receivedData.wireEncode() == dataToSend.wireEncode());
-}
-
-BOOST_AUTO_TEST_CASE(InterestFilter)
-{
- bool didOnInterestCallbackFire = false;
- Block receivedBlock, expectedBlock;
-
- auto testSendInterest = [&] (shared_ptr<Interest> interest) {
- didOnInterestCallbackFire = false;
- expectedBlock = interest->wireEncode();
- m_internalFace->sendInterest(*interest);
- };
-
- testSendInterest(makeInterest("/test/filter")); // no filter is set now
- BOOST_CHECK(!didOnInterestCallbackFire);
-
- // set filter
- auto filter = m_face->setInterestFilter("/test/filter",
- bind([&](const Interest& interset) {
- didOnInterestCallbackFire = true;
- receivedBlock = interset.wireEncode();
- }, _2));
- advanceClocks(time::milliseconds(1));
-
- testSendInterest(makeInterest("/test/filter"));
- BOOST_CHECK(didOnInterestCallbackFire);
- BOOST_CHECK(receivedBlock == expectedBlock);
-
- // unset filter
- didOnInterestCallbackFire = false;
- m_face->unsetInterestFilter(filter);
- advanceClocks(time::milliseconds(1));
- testSendInterest(makeInterest("/test/filter"));
- BOOST_CHECK(!didOnInterestCallbackFire);
-}
-
-BOOST_AUTO_TEST_CASE(PutData)
-{
- bool didInternalFaceReceiveData = false;
- Data receivedData;
- m_internalFace->onReceiveData.connect([&] (const Data& data) {
- didInternalFaceReceiveData = true;
- receivedData = data;
- });
-
- auto dataToPut = makeData("/test/put/data");
- m_face->put(*dataToPut);
- advanceClocks(time::milliseconds(1));
- BOOST_CHECK(didInternalFaceReceiveData);
- BOOST_CHECK(receivedData.wireEncode() == dataToPut->wireEncode());
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-} // namespace tests
-} // namespace nfd
diff --git a/tests/daemon/face/internal-face.t.cpp b/tests/daemon/face/internal-face.t.cpp
index 44f5e7b..eab0b67 100644
--- a/tests/daemon/face/internal-face.t.cpp
+++ b/tests/daemon/face/internal-face.t.cpp
@@ -24,120 +24,194 @@
*/
#include "face/internal-face.hpp"
+#include "face/lp-face-wrapper.hpp"
#include "tests/test-common.hpp"
+#include "tests/identity-management-fixture.hpp"
namespace nfd {
+namespace face {
namespace tests {
-class InternalFaceFixture : protected BaseFixture
+using namespace nfd::tests;
+
+BOOST_AUTO_TEST_SUITE(Face)
+
+class InternalFaceFixture : public UnitTestTimeFixture
+ , public IdentityManagementFixture
{
public:
InternalFaceFixture()
{
- m_face.onReceiveInterest.connect([this] (const Interest& interest) {
- inInterests.push_back(interest);
- });
- m_face.onSendInterest.connect([this] (const Interest& interest) {
- outInterests.push_back(interest);
- });
- m_face.onReceiveData.connect([this] (const Data& data) {
- inData.push_back(data);
- });
- m_face.onSendData.connect([this] (const Data& data) {
- outData.push_back(data);
- });
+ std::tie(forwarderFace, clientFace) = makeInternalFace(m_keyChain);;
+
+ // TODO#3172 connect to afterReceive* signals
+ forwarderFace->onReceiveInterest.connect(
+ [this] (const Interest& interest) { receivedInterests.push_back(interest); } );
+ forwarderFace->onReceiveData.connect(
+ [this] (const Data& data) { receivedData.push_back(data); } );
+ forwarderFace->onReceiveNack.connect(
+ [this] (const lp::Nack& nack) { receivedNacks.push_back(nack); } );
}
protected:
- InternalFace m_face;
- std::vector<Interest> inInterests;
- std::vector<Interest> outInterests;
- std::vector<Data> inData;
- std::vector<Data> outData;
+ shared_ptr<nfd::Face> forwarderFace;
+ shared_ptr<ndn::Face> clientFace;
+
+ std::vector<Interest> receivedInterests;
+ std::vector<Data> receivedData;
+ std::vector<lp::Nack> receivedNacks;
};
-BOOST_FIXTURE_TEST_SUITE(FaceInternalFace, InternalFaceFixture)
+BOOST_FIXTURE_TEST_SUITE(TestInternalFace, InternalFaceFixture)
-BOOST_AUTO_TEST_CASE(SendInterest)
+// note: "send" and "receive" in test case names refer to the direction seen on forwarderFace.
+// i.e. "send" means transmission from forwarder to client,
+// "receive" means transmission client to forwarder.
+
+BOOST_AUTO_TEST_CASE(ReceiveInterestTimeout)
{
- BOOST_CHECK(outInterests.empty());
+ shared_ptr<Interest> interest = makeInterest("/TLETccRv");
+ interest->setInterestLifetime(time::milliseconds(100));
- auto interest = makeInterest("/test/send/interest");
- Block expectedBlock = interest->wireEncode(); // assign a value to nonce
- m_face.sendInterest(*interest);
+ bool hasTimeout = false;
+ clientFace->expressInterest(*interest,
+ bind([] { BOOST_ERROR("unexpected Data"); }),
+ bind([] { BOOST_ERROR("unexpected Nack"); }),
+ bind([&hasTimeout] { hasTimeout = true; }));
+ this->advanceClocks(time::milliseconds(1), 10);
- BOOST_CHECK_EQUAL(outInterests.size(), 1);
- BOOST_CHECK(outInterests[0].wireEncode() == expectedBlock);
+ BOOST_REQUIRE_EQUAL(receivedInterests.size(), 1);
+ BOOST_CHECK_EQUAL(receivedInterests.back().getName(), "/TLETccRv");
+
+ this->advanceClocks(time::milliseconds(1), 100);
+
+ BOOST_CHECK(hasTimeout);
}
-BOOST_AUTO_TEST_CASE(SendData)
+BOOST_AUTO_TEST_CASE(ReceiveInterestSendData)
{
- BOOST_CHECK(outData.empty());
+ shared_ptr<Interest> interest = makeInterest("/PQstEJGdL");
- auto data = makeData("/test/send/data");
- m_face.sendData(*data);
+ bool hasReceivedData = false;
+ clientFace->expressInterest(*interest,
+ [&hasReceivedData] (const Interest&, const Data& data) {
+ hasReceivedData = true;
+ BOOST_CHECK_EQUAL(data.getName(), "/PQstEJGdL/aI7oCrDXNX");
+ },
+ bind([] { BOOST_ERROR("unexpected Nack"); }),
+ bind([] { BOOST_ERROR("unexpected timeout"); }));
+ this->advanceClocks(time::milliseconds(1), 10);
- BOOST_CHECK_EQUAL(outData.size(), 1);
- BOOST_CHECK(outData[0].wireEncode() == data->wireEncode());
+ BOOST_REQUIRE_EQUAL(receivedInterests.size(), 1);
+ BOOST_CHECK_EQUAL(receivedInterests.back().getName(), "/PQstEJGdL");
+
+ shared_ptr<Data> data = makeData("/PQstEJGdL/aI7oCrDXNX");
+ forwarderFace->sendData(*data);
+ this->advanceClocks(time::milliseconds(1), 10);
+
+ BOOST_CHECK(hasReceivedData);
}
-BOOST_AUTO_TEST_CASE(ReceiveInterest)
+BOOST_AUTO_TEST_CASE(ReceiveInterestSendNack)
{
- BOOST_CHECK(inInterests.empty());
+ shared_ptr<Interest> interest = makeInterest("/1HrsRM1X", 152);
- auto interest = makeInterest("/test/receive/interest");
- Block expectedBlock = interest->wireEncode(); // assign a value to nonce
- m_face.receiveInterest(*interest);
+ bool hasReceivedNack = false;
+ clientFace->expressInterest(*interest,
+ bind([] { BOOST_ERROR("unexpected Data"); }),
+ [&hasReceivedNack] (const Interest&, const lp::Nack& nack) {
+ hasReceivedNack = true;
+ BOOST_CHECK_EQUAL(nack.getReason(), lp::NackReason::NO_ROUTE);
+ },
+ bind([] { BOOST_ERROR("unexpected timeout"); }));
+ this->advanceClocks(time::milliseconds(1), 10);
- BOOST_CHECK_EQUAL(inInterests.size(), 1);
- BOOST_CHECK(inInterests[0].wireEncode() == expectedBlock);
+ BOOST_REQUIRE_EQUAL(receivedInterests.size(), 1);
+ BOOST_CHECK_EQUAL(receivedInterests.back().getName(), "/1HrsRM1X");
+
+ lp::Nack nack = makeNack("/1HrsRM1X", 152, lp::NackReason::NO_ROUTE);
+ forwarderFace->sendNack(nack);
+ this->advanceClocks(time::milliseconds(1), 10);
+
+ BOOST_CHECK(hasReceivedNack);
}
-BOOST_AUTO_TEST_CASE(ReceiveData)
+BOOST_AUTO_TEST_CASE(SendInterestReceiveData)
{
- BOOST_CHECK(inData.empty());
+ bool hasDeliveredInterest = false;
+ clientFace->setInterestFilter("/Wpc8TnEeoF",
+ [this, &hasDeliveredInterest] (const ndn::InterestFilter&, const Interest& interest) {
+ hasDeliveredInterest = true;
+ BOOST_CHECK_EQUAL(interest.getName(), "/Wpc8TnEeoF/f6SzV8hD");
- auto data = makeData("/test/send/data");
- m_face.receiveData(*data);
+ shared_ptr<Data> data = makeData("/Wpc8TnEeoF/f6SzV8hD/3uytUJCuIi");
+ clientFace->put(*data);
+ });
- BOOST_CHECK_EQUAL(inData.size(), 1);
- BOOST_CHECK(inData[0].wireEncode() == data->wireEncode());
+ shared_ptr<Interest> interest = makeInterest("/Wpc8TnEeoF/f6SzV8hD");
+ forwarderFace->sendInterest(*interest);
+ this->advanceClocks(time::milliseconds(1), 10);
+
+ BOOST_CHECK(hasDeliveredInterest);
+ BOOST_REQUIRE_EQUAL(receivedData.size(), 1);
+ BOOST_CHECK_EQUAL(receivedData.back().getName(), "/Wpc8TnEeoF/f6SzV8hD/3uytUJCuIi");
}
-BOOST_AUTO_TEST_CASE(ReceiveBlock)
+BOOST_AUTO_TEST_CASE(SendInterestReceiveNack)
{
- BOOST_CHECK(inInterests.empty());
- BOOST_CHECK(inData.empty());
+ bool hasDeliveredInterest = false;
+ clientFace->setInterestFilter("/4YgJKWcXN",
+ [this, &hasDeliveredInterest] (const ndn::InterestFilter&, const Interest& interest) {
+ hasDeliveredInterest = true;
+ BOOST_CHECK_EQUAL(interest.getName(), "/4YgJKWcXN/5oaTe05o");
- Block interestBlock = makeInterest("test/receive/interest")->wireEncode();
- m_face.receive(interestBlock);
- BOOST_CHECK_EQUAL(inInterests.size(), 1);
- BOOST_CHECK(inInterests[0].wireEncode() == interestBlock);
+ lp::Nack nack = makeNack("/4YgJKWcXN/5oaTe05o", 191, lp::NackReason::NO_ROUTE);
+ clientFace->put(nack);
+ });
- Block dataBlock = makeData("test/receive/data")->wireEncode();
- m_face.receive(dataBlock);
- BOOST_CHECK_EQUAL(inData.size(), 1);
- BOOST_CHECK(inData[0].wireEncode() == dataBlock);
+ shared_ptr<Interest> interest = makeInterest("/4YgJKWcXN/5oaTe05o", 191);
+ forwarderFace->sendInterest(*interest);
+ this->advanceClocks(time::milliseconds(1), 10);
+
+ BOOST_CHECK(hasDeliveredInterest);
+ BOOST_REQUIRE_EQUAL(receivedNacks.size(), 1);
+ BOOST_CHECK_EQUAL(receivedNacks.back().getReason(), lp::NackReason::NO_ROUTE);
}
-BOOST_AUTO_TEST_CASE(ExtractPacketFromBlock)
+BOOST_AUTO_TEST_CASE(CloseForwarderFace)
{
- {
- Block block = makeInterest("/test/interest")->wireEncode();
- const Block& payload = ndn::nfd::LocalControlHeader::getPayload(block);
- auto interest = m_face.extractPacketFromBlock<Interest>(block, payload);
- BOOST_CHECK(interest->wireEncode() == block);
- }
+ forwarderFace->close();
+ this->advanceClocks(time::milliseconds(1), 10);
+ BOOST_CHECK_EQUAL(static_pointer_cast<face::LpFaceWrapper>(forwarderFace)->getLpFace()->getState(), FaceState::CLOSED);
+ forwarderFace.reset();
- {
- Block block = makeData("/test/data")->wireEncode();
- const Block& payload = ndn::nfd::LocalControlHeader::getPayload(block);
- auto data = m_face.extractPacketFromBlock<Data>(block, payload);
- BOOST_CHECK(data->wireEncode() == block);
- }
+ shared_ptr<Interest> interest = makeInterest("/zpHsVesu0B");
+ interest->setInterestLifetime(time::milliseconds(100));
+
+ bool hasTimeout = false;
+ clientFace->expressInterest(*interest,
+ bind([] { BOOST_ERROR("unexpected Data"); }),
+ bind([] { BOOST_ERROR("unexpected Nack"); }),
+ bind([&hasTimeout] { hasTimeout = true; }));
+ BOOST_CHECK_NO_THROW(this->advanceClocks(time::milliseconds(1), 200));
+
+ BOOST_CHECK_EQUAL(receivedInterests.size(), 0);
+ BOOST_CHECK(hasTimeout);
}
-BOOST_AUTO_TEST_SUITE_END()
+BOOST_AUTO_TEST_CASE(CloseClientFace)
+{
+ g_io.poll(); // #3248 workaround
+ clientFace.reset();
+
+ shared_ptr<Interest> interest = makeInterest("/aau42XQqb");
+ forwarderFace->sendInterest(*interest);
+ BOOST_CHECK_NO_THROW(this->advanceClocks(time::milliseconds(1), 10));
+}
+
+BOOST_AUTO_TEST_SUITE_END() // TestInternalFace
+BOOST_AUTO_TEST_SUITE_END() // Face
} // namespace tests
+} // namespace face
} // namespace nfd