diff --git a/tests/daemon/face/tcp-transport-fixture.hpp b/tests/daemon/face/tcp-transport-fixture.hpp
index 97b195f..08f55b6 100644
--- a/tests/daemon/face/tcp-transport-fixture.hpp
+++ b/tests/daemon/face/tcp-transport-fixture.hpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California,
+ * Copyright (c) 2014-2016,  Regents of the University of California,
  *                           Arizona Board of Regents,
  *                           Colorado State University,
  *                           University Pierre & Marie Curie, Sorbonne University,
@@ -53,9 +53,9 @@
   }
 
   void
-  initialize(ip::address address = ip::address_v4::loopback())
+  startAccept(const tcp::endpoint& remoteEp)
   {
-    tcp::endpoint remoteEp(address, 7070);
+    BOOST_REQUIRE(!acceptor.is_open());
     acceptor.open(remoteEp.protocol());
     acceptor.set_option(tcp::acceptor::reuse_address(true));
     acceptor.bind(remoteEp);
@@ -64,6 +64,21 @@
       BOOST_REQUIRE_EQUAL(error, boost::system::errc::success);
       limitedIo.afterOp();
     });
+  }
+
+  void
+  stopAccept()
+  {
+    BOOST_REQUIRE(acceptor.is_open());
+    acceptor.close();
+  }
+
+  void
+  initialize(ip::address address = ip::address_v4::loopback(),
+             ndn::nfd::FacePersistency persistency = ndn::nfd::FACE_PERSISTENCY_PERSISTENT)
+  {
+    tcp::endpoint remoteEp(address, 7070);
+    startAccept(remoteEp);
 
     tcp::socket sock(g_io);
     sock.async_connect(remoteEp, [this] (const boost::system::error_code& error) {
@@ -75,8 +90,7 @@
 
     localEp = sock.local_endpoint();
     face = make_unique<Face>(make_unique<DummyReceiveLinkService>(),
-                             make_unique<TcpTransport>(std::move(sock),
-                                                       ndn::nfd::FACE_PERSISTENCY_PERSISTENT));
+                             make_unique<TcpTransport>(std::move(sock), persistency));
     transport = static_cast<TcpTransport*>(face->getTransport());
     receivedPackets = &static_cast<DummyReceiveLinkService*>(face->getLinkService())->receivedPackets;
 
diff --git a/tests/daemon/face/tcp-transport.t.cpp b/tests/daemon/face/tcp-transport.t.cpp
index fd0d7ae..a881f83 100644
--- a/tests/daemon/face/tcp-transport.t.cpp
+++ b/tests/daemon/face/tcp-transport.t.cpp
@@ -102,6 +102,166 @@
   BOOST_CHECK_EQUAL(transport->getMtu(), MTU_UNLIMITED);
 }
 
+BOOST_AUTO_TEST_CASE(PermanentReconnect)
+{
+  auto address = getTestIp<ip::address_v4>();
+  SKIP_IF_IP_UNAVAILABLE(address);
+  initialize(address, ndn::nfd::FACE_PERSISTENCY_PERMANENT);
+
+  transport->afterStateChange.connectSingleShot([this] (TransportState oldState, TransportState newState) {
+    BOOST_CHECK_EQUAL(oldState, TransportState::UP);
+    BOOST_CHECK_EQUAL(newState, TransportState::DOWN);
+    limitedIo.afterOp();
+  });
+  remoteSocket.close();
+  BOOST_REQUIRE_EQUAL(limitedIo.run(1, time::seconds(1)), LimitedIo::EXCEED_OPS);
+
+  transport->afterStateChange.connectSingleShot([this] (TransportState oldState, TransportState newState) {
+    BOOST_CHECK_EQUAL(oldState, TransportState::DOWN);
+    BOOST_CHECK_EQUAL(newState, TransportState::UP);
+    limitedIo.afterOp();
+  });
+  BOOST_REQUIRE_EQUAL(limitedIo.run(1, time::seconds(1)), LimitedIo::EXCEED_OPS);
+}
+
+BOOST_AUTO_TEST_CASE(ChangePersistencyFromPermanentWhenDown)
+{
+  // when persistency is changed out of permanent while transport is DOWN,
+  // the transport immediately goes into FAILED state
+
+  auto address = getTestIp<ip::address_v4>();
+  SKIP_IF_IP_UNAVAILABLE(address);
+  initialize(address, ndn::nfd::FACE_PERSISTENCY_PERMANENT);
+
+  transport->afterStateChange.connectSingleShot([this] (TransportState oldState, TransportState newState) {
+    BOOST_CHECK_EQUAL(oldState, TransportState::UP);
+    BOOST_CHECK_EQUAL(newState, TransportState::DOWN);
+    limitedIo.afterOp();
+  });
+  remoteSocket.close();
+  BOOST_REQUIRE_EQUAL(limitedIo.run(1, time::seconds(1)), LimitedIo::EXCEED_OPS);
+
+  bool didStateChange = false;
+  transport->afterStateChange.connectSingleShot(
+    [this, &didStateChange] (TransportState oldState, TransportState newState) {
+      didStateChange = true;
+      BOOST_CHECK_EQUAL(oldState, TransportState::DOWN);
+      BOOST_CHECK_EQUAL(newState, TransportState::FAILED);
+    });
+  transport->setPersistency(ndn::nfd::FACE_PERSISTENCY_PERSISTENT);
+  BOOST_CHECK(didStateChange);
+}
+
+class PermanentTcpTransportReconnectObserver : public TcpTransport
+{
+public:
+  PermanentTcpTransportReconnectObserver(protocol::socket&& socket, LimitedIo& io)
+    : TcpTransport(std::move(socket), ndn::nfd::FACE_PERSISTENCY_PERMANENT)
+    , m_io(io)
+  {
+  }
+
+protected:
+  void
+  reconnect() final
+  {
+    TcpTransport::reconnect();
+    m_io.afterOp();
+  }
+
+  void
+  handleReconnect(const boost::system::error_code& error) final
+  {
+    TcpTransport::handleReconnect(error);
+    m_io.afterOp();
+  }
+
+  void
+  handleReconnectTimeout() final
+  {
+    TcpTransport::handleReconnectTimeout();
+    m_io.afterOp();
+  }
+
+private:
+  LimitedIo& m_io;
+};
+
+static double
+asFloatMilliseconds(const time::nanoseconds& t)
+{
+  return static_cast<double>(t.count()) / 1000000.0;
+}
+
+BOOST_AUTO_TEST_CASE(PermanentReconnectWithExponentialBackoff)
+{
+  auto address = getTestIp<ip::address_v4>();
+  SKIP_IF_IP_UNAVAILABLE(address);
+
+  tcp::endpoint remoteEp(address, 7070);
+  startAccept(remoteEp);
+
+  tcp::socket sock(g_io);
+  sock.async_connect(remoteEp, [this] (const boost::system::error_code& error) {
+    BOOST_REQUIRE_EQUAL(error, boost::system::errc::success);
+    limitedIo.afterOp();
+  });
+  BOOST_REQUIRE_EQUAL(limitedIo.run(2, time::seconds(1)), LimitedIo::EXCEED_OPS);
+
+  auto transportObserver = make_unique<PermanentTcpTransportReconnectObserver>(std::move(sock),
+                                                                               std::ref(limitedIo));
+  BOOST_REQUIRE_EQUAL(transportObserver->getState(), TransportState::UP);
+
+  // break the TCP connection
+  stopAccept();
+  remoteSocket.close();
+
+  // measure retry intervals
+  BOOST_REQUIRE_EQUAL(limitedIo.run(2, time::seconds(5)), LimitedIo::EXCEED_OPS);
+  auto retryTime1 = time::steady_clock::now();
+  BOOST_CHECK_EQUAL(transportObserver->getState(), TransportState::DOWN);
+
+  BOOST_REQUIRE_EQUAL(limitedIo.run(2, time::seconds(5)), LimitedIo::EXCEED_OPS);
+  auto retryTime2 = time::steady_clock::now();
+  BOOST_CHECK_EQUAL(transportObserver->getState(), TransportState::DOWN);
+
+  BOOST_REQUIRE_EQUAL(limitedIo.run(2, time::seconds(5)), LimitedIo::EXCEED_OPS);
+  auto retryTime3 = time::steady_clock::now();
+  BOOST_CHECK_EQUAL(transportObserver->getState(), TransportState::DOWN);
+
+  // check that the backoff algorithm works
+  BOOST_CHECK_CLOSE(asFloatMilliseconds(retryTime2 - retryTime1),
+                    asFloatMilliseconds(TcpTransport::s_initialReconnectWait),
+                    10.0);
+  BOOST_CHECK_CLOSE(asFloatMilliseconds(retryTime3 - retryTime2),
+                    asFloatMilliseconds(TcpTransport::s_initialReconnectWait) * TcpTransport::s_reconnectWaitMultiplier,
+                    10.0);
+
+  // reestablish the TCP connection
+  startAccept(remoteEp);
+
+  BOOST_REQUIRE_EQUAL(limitedIo.run(3, time::seconds(10)), LimitedIo::EXCEED_OPS);
+  BOOST_CHECK_EQUAL(transportObserver->getState(), TransportState::UP);
+
+  // break the TCP connection again
+  stopAccept();
+  remoteSocket.close();
+
+  // measure retry intervals
+  BOOST_REQUIRE_EQUAL(limitedIo.run(2, time::seconds(5)), LimitedIo::EXCEED_OPS);
+  auto retryTime4 = time::steady_clock::now();
+  BOOST_CHECK_EQUAL(transportObserver->getState(), TransportState::DOWN);
+
+  BOOST_REQUIRE_EQUAL(limitedIo.run(2, time::seconds(5)), LimitedIo::EXCEED_OPS);
+  auto retryTime5 = time::steady_clock::now();
+  BOOST_CHECK_EQUAL(transportObserver->getState(), TransportState::DOWN);
+
+  // check that the timeout restarts from the initial value after a successful reconnection
+  BOOST_CHECK_CLOSE(asFloatMilliseconds(retryTime5 - retryTime4),
+                    asFloatMilliseconds(TcpTransport::s_initialReconnectWait),
+                    10.0);
+}
+
 BOOST_AUTO_TEST_SUITE_END() // TestTcpTransport
 BOOST_AUTO_TEST_SUITE_END() // Face