Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 1 | /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ |
Davide Pesavento | 6d1c1c3 | 2017-10-08 21:44:05 -0400 | [diff] [blame] | 2 | /* |
Davide Pesavento | 14e71f0 | 2019-03-28 17:35:25 -0400 | [diff] [blame] | 3 | * Copyright (c) 2014-2019, Regents of the University of California, |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 4 | * Arizona Board of Regents, |
| 5 | * Colorado State University, |
| 6 | * University Pierre & Marie Curie, Sorbonne University, |
| 7 | * Washington University in St. Louis, |
| 8 | * Beijing Institute of Technology, |
| 9 | * The University of Memphis. |
| 10 | * |
| 11 | * This file is part of NFD (Named Data Networking Forwarding Daemon). |
| 12 | * See AUTHORS.md for complete list of NFD authors and contributors. |
| 13 | * |
| 14 | * NFD is free software: you can redistribute it and/or modify it under the terms |
| 15 | * of the GNU General Public License as published by the Free Software Foundation, |
| 16 | * either version 3 of the License, or (at your option) any later version. |
| 17 | * |
| 18 | * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; |
| 19 | * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| 20 | * PURPOSE. See the GNU General Public License for more details. |
| 21 | * |
| 22 | * You should have received a copy of the GNU General Public License along with |
| 23 | * NFD, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>. |
| 24 | */ |
| 25 | |
| 26 | #include "tcp-transport-fixture.hpp" |
| 27 | #include "unix-stream-transport-fixture.hpp" |
| 28 | |
Davide Pesavento | 22fba35 | 2017-10-17 15:53:51 -0400 | [diff] [blame] | 29 | #include "transport-test-common.hpp" |
| 30 | |
Eric Newberry | 65caf20 | 2015-12-17 15:08:16 -0700 | [diff] [blame] | 31 | #include <boost/mpl/vector.hpp> |
| 32 | |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 33 | namespace nfd { |
| 34 | namespace face { |
| 35 | namespace tests { |
| 36 | |
| 37 | BOOST_AUTO_TEST_SUITE(Face) |
| 38 | BOOST_AUTO_TEST_SUITE(TestStreamTransport) |
| 39 | |
Davide Pesavento | 22fba35 | 2017-10-17 15:53:51 -0400 | [diff] [blame] | 40 | using StreamTransportFixtures = boost::mpl::vector< |
| 41 | GENERATE_IP_TRANSPORT_FIXTURE_INSTANTIATIONS(TcpTransportFixture), |
| 42 | UnixStreamTransportFixture |
| 43 | >; |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 44 | |
| 45 | BOOST_FIXTURE_TEST_CASE_TEMPLATE(Send, T, StreamTransportFixtures, T) |
| 46 | { |
Davide Pesavento | 22fba35 | 2017-10-17 15:53:51 -0400 | [diff] [blame] | 47 | TRANSPORT_TEST_INIT(); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 48 | |
| 49 | auto block1 = ndn::encoding::makeStringBlock(300, "hello"); |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 50 | this->transport->send(block1); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 51 | BOOST_CHECK_EQUAL(this->transport->getCounters().nOutPackets, 1); |
| 52 | BOOST_CHECK_EQUAL(this->transport->getCounters().nOutBytes, block1.size()); |
| 53 | |
| 54 | auto block2 = ndn::encoding::makeStringBlock(301, "world"); |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 55 | this->transport->send(block2); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 56 | BOOST_CHECK_EQUAL(this->transport->getCounters().nOutPackets, 2); |
| 57 | BOOST_CHECK_EQUAL(this->transport->getCounters().nOutBytes, block1.size() + block2.size()); |
| 58 | |
| 59 | std::vector<uint8_t> readBuf(block1.size() + block2.size()); |
| 60 | boost::asio::async_read(this->remoteSocket, boost::asio::buffer(readBuf), |
| 61 | [this] (const boost::system::error_code& error, size_t) { |
| 62 | BOOST_REQUIRE_EQUAL(error, boost::system::errc::success); |
| 63 | this->limitedIo.afterOp(); |
| 64 | }); |
| 65 | |
Davide Pesavento | 14e71f0 | 2019-03-28 17:35:25 -0400 | [diff] [blame] | 66 | BOOST_REQUIRE_EQUAL(this->limitedIo.run(1, 1_s), LimitedIo::EXCEED_OPS); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 67 | |
| 68 | BOOST_CHECK_EQUAL_COLLECTIONS(readBuf.begin(), readBuf.begin() + block1.size(), block1.begin(), block1.end()); |
| 69 | BOOST_CHECK_EQUAL_COLLECTIONS(readBuf.begin() + block1.size(), readBuf.end(), block2.begin(), block2.end()); |
| 70 | BOOST_CHECK_EQUAL(this->transport->getState(), TransportState::UP); |
| 71 | } |
| 72 | |
| 73 | BOOST_FIXTURE_TEST_CASE_TEMPLATE(ReceiveNormal, T, StreamTransportFixtures, T) |
| 74 | { |
Davide Pesavento | 22fba35 | 2017-10-17 15:53:51 -0400 | [diff] [blame] | 75 | TRANSPORT_TEST_INIT(); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 76 | |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 77 | auto pkt1 = ndn::encoding::makeStringBlock(300, "hello"); |
| 78 | ndn::Buffer buf1(pkt1.begin(), pkt1.end()); |
| 79 | this->remoteWrite(buf1); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 80 | |
| 81 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInPackets, 1); |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 82 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInBytes, pkt1.size()); |
| 83 | |
| 84 | auto pkt2 = ndn::encoding::makeStringBlock(301, "world!"); |
| 85 | ndn::Buffer buf2(pkt2.begin(), pkt2.end()); |
| 86 | this->remoteWrite(buf2); |
| 87 | |
| 88 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInPackets, 2); |
| 89 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInBytes, pkt1.size() + pkt2.size()); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 90 | BOOST_CHECK_EQUAL(this->transport->getState(), TransportState::UP); |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 91 | |
| 92 | BOOST_REQUIRE_EQUAL(this->receivedPackets->size(), 2); |
| 93 | BOOST_CHECK(this->receivedPackets->at(0).packet == pkt1); |
| 94 | BOOST_CHECK(this->receivedPackets->at(1).packet == pkt2); |
| 95 | BOOST_CHECK_EQUAL(this->receivedPackets->at(0).endpoint, 0); |
| 96 | BOOST_CHECK_EQUAL(this->receivedPackets->at(1).endpoint, 0); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | BOOST_FIXTURE_TEST_CASE_TEMPLATE(ReceiveMultipleSegments, T, StreamTransportFixtures, T) |
| 100 | { |
Davide Pesavento | 22fba35 | 2017-10-17 15:53:51 -0400 | [diff] [blame] | 101 | TRANSPORT_TEST_INIT(); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 102 | |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 103 | auto pkt = ndn::encoding::makeStringBlock(300, "hello"); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 104 | ndn::Buffer buf1(pkt.begin(), pkt.end() - 2); |
| 105 | ndn::Buffer buf2(pkt.end() - 2, pkt.end()); |
| 106 | |
| 107 | this->remoteWrite(buf1); |
| 108 | |
| 109 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInPackets, 0); |
| 110 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInBytes, 0); |
| 111 | BOOST_CHECK_EQUAL(this->receivedPackets->size(), 0); |
| 112 | BOOST_CHECK_EQUAL(this->transport->getState(), TransportState::UP); |
| 113 | |
| 114 | this->remoteWrite(buf2); |
| 115 | |
| 116 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInPackets, 1); |
| 117 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInBytes, pkt.size()); |
| 118 | BOOST_CHECK_EQUAL(this->receivedPackets->size(), 1); |
| 119 | BOOST_CHECK_EQUAL(this->transport->getState(), TransportState::UP); |
| 120 | } |
| 121 | |
| 122 | BOOST_FIXTURE_TEST_CASE_TEMPLATE(ReceiveMultipleBlocks, T, StreamTransportFixtures, T) |
| 123 | { |
Davide Pesavento | 22fba35 | 2017-10-17 15:53:51 -0400 | [diff] [blame] | 124 | TRANSPORT_TEST_INIT(); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 125 | |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 126 | auto pkt1 = ndn::encoding::makeStringBlock(300, "hello"); |
| 127 | auto pkt2 = ndn::encoding::makeStringBlock(301, "world"); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 128 | ndn::Buffer buf(pkt1.size() + pkt2.size()); |
Davide Pesavento | 6d1c1c3 | 2017-10-08 21:44:05 -0400 | [diff] [blame] | 129 | std::copy(pkt1.begin(), pkt1.end(), buf.begin()); |
| 130 | std::copy(pkt2.begin(), pkt2.end(), buf.begin() + pkt1.size()); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 131 | |
| 132 | this->remoteWrite(buf); |
| 133 | |
| 134 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInPackets, 2); |
| 135 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInBytes, buf.size()); |
| 136 | BOOST_CHECK_EQUAL(this->receivedPackets->size(), 2); |
| 137 | BOOST_CHECK_EQUAL(this->transport->getState(), TransportState::UP); |
| 138 | } |
| 139 | |
| 140 | BOOST_FIXTURE_TEST_CASE_TEMPLATE(ReceiveTooLarge, T, StreamTransportFixtures, T) |
| 141 | { |
Davide Pesavento | 22fba35 | 2017-10-17 15:53:51 -0400 | [diff] [blame] | 142 | TRANSPORT_TEST_INIT(); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 143 | |
Eric Newberry | 65caf20 | 2015-12-17 15:08:16 -0700 | [diff] [blame] | 144 | std::vector<uint8_t> bytes(ndn::MAX_NDN_PACKET_SIZE, 0); |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 145 | auto pkt1 = ndn::encoding::makeBinaryBlock(300, bytes.data(), bytes.size() - 6); |
Eric Newberry | 65caf20 | 2015-12-17 15:08:16 -0700 | [diff] [blame] | 146 | ndn::Buffer buf1(pkt1.begin(), pkt1.end()); |
| 147 | BOOST_REQUIRE_EQUAL(buf1.size(), ndn::MAX_NDN_PACKET_SIZE); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 148 | |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 149 | auto pkt2 = ndn::encoding::makeBinaryBlock(301, bytes.data(), bytes.size()); |
Eric Newberry | 65caf20 | 2015-12-17 15:08:16 -0700 | [diff] [blame] | 150 | ndn::Buffer buf2(pkt2.begin(), pkt2.end()); |
| 151 | BOOST_REQUIRE_GT(buf2.size(), ndn::MAX_NDN_PACKET_SIZE); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 152 | |
Eric Newberry | 65caf20 | 2015-12-17 15:08:16 -0700 | [diff] [blame] | 153 | this->remoteWrite(buf1); // this should succeed |
| 154 | |
| 155 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInPackets, 1); |
| 156 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInBytes, buf1.size()); |
| 157 | BOOST_CHECK_EQUAL(this->receivedPackets->size(), 1); |
| 158 | BOOST_CHECK_EQUAL(this->transport->getState(), TransportState::UP); |
| 159 | |
| 160 | int nStateChanges = 0; |
| 161 | this->transport->afterStateChange.connect( |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 162 | [&nStateChanges] (auto oldState, auto newState) { |
Eric Newberry | 65caf20 | 2015-12-17 15:08:16 -0700 | [diff] [blame] | 163 | switch (nStateChanges) { |
| 164 | case 0: |
| 165 | BOOST_CHECK_EQUAL(oldState, TransportState::UP); |
| 166 | BOOST_CHECK_EQUAL(newState, TransportState::FAILED); |
| 167 | break; |
| 168 | case 1: |
| 169 | BOOST_CHECK_EQUAL(oldState, TransportState::FAILED); |
| 170 | BOOST_CHECK_EQUAL(newState, TransportState::CLOSED); |
| 171 | break; |
| 172 | default: |
| 173 | BOOST_CHECK(false); |
| 174 | } |
| 175 | nStateChanges++; |
| 176 | }); |
| 177 | |
| 178 | this->remoteWrite(buf2, false); // this should fail |
| 179 | |
| 180 | BOOST_CHECK_EQUAL(nStateChanges, 2); |
| 181 | |
| 182 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInPackets, 1); |
| 183 | BOOST_CHECK_EQUAL(this->transport->getCounters().nInBytes, buf1.size()); |
| 184 | BOOST_CHECK_EQUAL(this->receivedPackets->size(), 1); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 185 | } |
| 186 | |
| 187 | BOOST_FIXTURE_TEST_CASE_TEMPLATE(Close, T, StreamTransportFixtures, T) |
| 188 | { |
Davide Pesavento | 22fba35 | 2017-10-17 15:53:51 -0400 | [diff] [blame] | 189 | TRANSPORT_TEST_INIT(); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 190 | |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 191 | this->transport->afterStateChange.connectSingleShot([] (auto oldState, auto newState) { |
Eric Newberry | 65caf20 | 2015-12-17 15:08:16 -0700 | [diff] [blame] | 192 | BOOST_CHECK_EQUAL(oldState, TransportState::UP); |
| 193 | BOOST_CHECK_EQUAL(newState, TransportState::CLOSING); |
| 194 | }); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 195 | |
Eric Newberry | 65caf20 | 2015-12-17 15:08:16 -0700 | [diff] [blame] | 196 | this->transport->close(); |
| 197 | |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 198 | this->transport->afterStateChange.connectSingleShot([this] (auto oldState, auto newState) { |
Eric Newberry | 65caf20 | 2015-12-17 15:08:16 -0700 | [diff] [blame] | 199 | BOOST_CHECK_EQUAL(oldState, TransportState::CLOSING); |
| 200 | BOOST_CHECK_EQUAL(newState, TransportState::CLOSED); |
| 201 | this->limitedIo.afterOp(); |
| 202 | }); |
| 203 | |
Davide Pesavento | 14e71f0 | 2019-03-28 17:35:25 -0400 | [diff] [blame] | 204 | BOOST_REQUIRE_EQUAL(this->limitedIo.run(1, 1_s), LimitedIo::EXCEED_OPS); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | BOOST_FIXTURE_TEST_CASE_TEMPLATE(RemoteClose, T, StreamTransportFixtures, T) |
| 208 | { |
Davide Pesavento | 22fba35 | 2017-10-17 15:53:51 -0400 | [diff] [blame] | 209 | TRANSPORT_TEST_INIT(); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 210 | |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 211 | this->transport->afterStateChange.connectSingleShot([this] (auto oldState, auto newState) { |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 212 | BOOST_CHECK_EQUAL(oldState, TransportState::UP); |
Davide Pesavento | 68ab43d | 2017-07-02 13:37:35 -0400 | [diff] [blame] | 213 | BOOST_CHECK_EQUAL(newState, TransportState::CLOSING); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 214 | this->limitedIo.afterOp(); |
| 215 | }); |
| 216 | |
| 217 | this->remoteSocket.close(); |
Davide Pesavento | 14e71f0 | 2019-03-28 17:35:25 -0400 | [diff] [blame] | 218 | BOOST_REQUIRE_EQUAL(this->limitedIo.run(1, 1_s), LimitedIo::EXCEED_OPS); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 219 | |
Davide Pesavento | b3a23ca | 2019-05-04 20:40:21 -0400 | [diff] [blame] | 220 | this->transport->afterStateChange.connectSingleShot([this] (auto oldState, auto newState) { |
Davide Pesavento | 68ab43d | 2017-07-02 13:37:35 -0400 | [diff] [blame] | 221 | BOOST_CHECK_EQUAL(oldState, TransportState::CLOSING); |
Eric Newberry | 65caf20 | 2015-12-17 15:08:16 -0700 | [diff] [blame] | 222 | BOOST_CHECK_EQUAL(newState, TransportState::CLOSED); |
| 223 | this->limitedIo.afterOp(); |
| 224 | }); |
| 225 | |
Davide Pesavento | 14e71f0 | 2019-03-28 17:35:25 -0400 | [diff] [blame] | 226 | BOOST_REQUIRE_EQUAL(this->limitedIo.run(1, 1_s), LimitedIo::EXCEED_OPS); |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 227 | } |
| 228 | |
Eric Newberry | b49313d | 2017-12-24 20:22:27 -0700 | [diff] [blame] | 229 | BOOST_FIXTURE_TEST_CASE_TEMPLATE(SendQueueLength, T, StreamTransportFixtures, T) |
| 230 | { |
| 231 | TRANSPORT_TEST_INIT(); |
| 232 | |
| 233 | BOOST_CHECK_EQUAL(this->transport->getSendQueueLength(), 0); |
| 234 | } |
| 235 | |
Eric Newberry | f68f378 | 2015-12-11 00:31:32 -0700 | [diff] [blame] | 236 | BOOST_AUTO_TEST_SUITE_END() // TestStreamTransport |
| 237 | BOOST_AUTO_TEST_SUITE_END() // Face |
| 238 | |
| 239 | } // namespace tests |
| 240 | } // namespace face |
Eric Newberry | 65caf20 | 2015-12-17 15:08:16 -0700 | [diff] [blame] | 241 | } // namespace nfd |