SunnyQjm/NLSR
1
0 Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

tlv: remove unused class LsdbStatus

Browse Source 
refs: #4787

Change-Id: I9c7ce59238a3bac06d3db32423853f11f22e9160
This commit is contained in:
Ashlesh Gawande committed 2020-03-31 19:18:46 -07:00
1 parent fd021d5e3d
commit f89878c12c
4 files changed
+1 -789
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/publisher/dataset-interest-handler.cpp
+1 -2
View File
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
* Copyright (c) 2014-2019, The University of Memphis,
* Copyright (c) 2014-2020, The University of Memphis,
* Regents of the University of California,
* Arizona Board of Regents.
*
@@ -21,7 +21,6 @@
#include "dataset-interest-handler.hpp"
#include "nlsr.hpp"
#include "tlv/lsdb-status.hpp"
#include "logger.hpp"
#include <ndn-cxx/mgmt/nfd/control-response.hpp>
src/tlv/lsdb-status.cpp
-239
View File
@@ -1,239 +0,0 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2014-2018, The University of Memphis,
* Regents of the University of California,
* Arizona Board of Regents.
*
* This file is part of NLSR (Named-data Link State Routing).
* See AUTHORS.md for complete list of NLSR authors and contributors.
*
* NLSR 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.
*
* NLSR 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
* NLSR, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
*/
#include "lsdb-status.hpp"
#include "tlv-nlsr.hpp"
#include <ndn-cxx/util/concepts.hpp>
#include <ndn-cxx/encoding/block-helpers.hpp>
namespace nlsr {
namespace tlv {
BOOST_CONCEPT_ASSERT((ndn::WireEncodable<LsdbStatus>));
BOOST_CONCEPT_ASSERT((ndn::WireDecodable<LsdbStatus>));
static_assert(std::is_base_of<ndn::tlv::Error, LsdbStatus::Error>::value,
"LsdbStatus::Error must inherit from tlv::Error");
LsdbStatus::LsdbStatus()
: m_hasAdjacencyLsas(false)
, m_hasCoordinateLsas(false)
, m_hasNameLsas(false)
{
}
LsdbStatus::LsdbStatus(const ndn::Block& block)
{
wireDecode(block);
}
LsdbStatus&
LsdbStatus::addAdjacencyLsa(const AdjacencyLsa& adjacencyLsa)
{
m_adjacencyLsas.push_back(adjacencyLsa);
m_wire.reset();
m_hasAdjacencyLsas = true;
return *this;
}
LsdbStatus&
LsdbStatus::clearAdjacencyLsas()
{
m_adjacencyLsas.clear();
m_hasAdjacencyLsas = false;
return *this;
}
LsdbStatus&
LsdbStatus::addCoordinateLsa(const CoordinateLsa& coordinateLsa)
{
m_coordinateLsas.push_back(coordinateLsa);
m_wire.reset();
m_hasCoordinateLsas = true;
return *this;
}
LsdbStatus&
LsdbStatus::clearCoordinateLsas()
{
m_coordinateLsas.clear();
m_hasCoordinateLsas = false;
return *this;
}
LsdbStatus&
LsdbStatus::addNameLsa(const NameLsa& nameLsa)
{
m_nameLsas.push_back(nameLsa);
m_wire.reset();
m_hasNameLsas = true;
return *this;
}
LsdbStatus&
LsdbStatus::clearNameLsas()
{
m_nameLsas.clear();
m_hasNameLsas = false;
return *this;
}
template<ndn::encoding::Tag TAG>
size_t
LsdbStatus::wireEncode(ndn::EncodingImpl<TAG>& block) const
{
size_t totalLength = 0;
for (std::list<NameLsa>::const_reverse_iterator it = m_nameLsas.rbegin();
it != m_nameLsas.rend(); ++it) {
totalLength += it->wireEncode(block);
}
for (std::list<CoordinateLsa>::const_reverse_iterator it = m_coordinateLsas.rbegin();
it != m_coordinateLsas.rend(); ++it) {
totalLength += it->wireEncode(block);
}
for (std::list<AdjacencyLsa>::const_reverse_iterator it = m_adjacencyLsas.rbegin();
it != m_adjacencyLsas.rend(); ++it) {
totalLength += it->wireEncode(block);
}
totalLength += block.prependVarNumber(totalLength);
totalLength += block.prependVarNumber(ndn::tlv::nlsr::LsdbStatus);
return totalLength;
}
NDN_CXX_DEFINE_WIRE_ENCODE_INSTANTIATIONS(LsdbStatus);
const ndn::Block&
LsdbStatus::wireEncode() const
{
if (m_wire.hasWire()) {
return m_wire;
}
ndn::EncodingEstimator estimator;
size_t estimatedSize = wireEncode(estimator);
ndn::EncodingBuffer buffer(estimatedSize, 0);
wireEncode(buffer);
m_wire = buffer.block();
return m_wire;
}
void
LsdbStatus::wireDecode(const ndn::Block& wire)
{
m_adjacencyLsas.clear();
m_coordinateLsas.clear();
m_nameLsas.clear();
m_hasAdjacencyLsas = false;
m_hasCoordinateLsas = false;
m_hasNameLsas = false;
m_wire = wire;
if (m_wire.type() != ndn::tlv::nlsr::LsdbStatus) {
std::stringstream error;
error << "Expected LsdbStatus Block, but Block is of a different type: #"
<< m_wire.type();
BOOST_THROW_EXCEPTION(Error(error.str()));
}
m_wire.parse();
ndn::Block::element_const_iterator val = m_wire.elements_begin();
for (; val != m_wire.elements_end() && val->type() == ndn::tlv::nlsr::AdjacencyLsa; ++val) {
m_adjacencyLsas.push_back(AdjacencyLsa(*val));
m_hasAdjacencyLsas = true;
}
for (; val != m_wire.elements_end() && val->type() == ndn::tlv::nlsr::CoordinateLsa; ++val) {
m_coordinateLsas.push_back(CoordinateLsa(*val));
m_hasCoordinateLsas = true;
}
for (; val != m_wire.elements_end() && val->type() == ndn::tlv::nlsr::NameLsa; ++val) {
m_nameLsas.push_back(NameLsa(*val));
m_hasNameLsas = true;
}
if (val != m_wire.elements_end()) {
std::stringstream error;
error << "Expected the end of elements, but Block is of a different type: #"
<< val->type();
BOOST_THROW_EXCEPTION(Error(error.str()));
}
}
std::ostream&
operator<<(std::ostream& os, const LsdbStatus& lsdbStatus)
{
os << "LsdbStatus(";
bool isFirst = true;
for (const auto& adjacencyLsa : lsdbStatus.getAdjacencyLsas()) {
if (isFirst) {
isFirst = false;
}
else {
os << ", ";
}
os << adjacencyLsa;
}
for (const auto& coordinateLsa : lsdbStatus.getCoordinateLsas()) {
if (isFirst) {
isFirst = false;
}
else {
os << ", ";
}
os << coordinateLsa;
}
for (const auto& nameLsa : lsdbStatus.getNameLsas()) {
if (isFirst) {
isFirst = false;
}
else {
os << ", ";
}
os << nameLsa;
}
os << ")";
return os;
}
} // namespace tlv
} // namespace nlsr
src/tlv/lsdb-status.hpp
-176
View File
@@ -1,176 +0,0 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2014-2018, The University of Memphis,
* Regents of the University of California,
* Arizona Board of Regents.
*
* This file is part of NLSR (Named-data Link State Routing).
* See AUTHORS.md for complete list of NLSR authors and contributors.
*
* NLSR 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.
*
* NLSR 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
* NLSR, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef NLSR_TLV_LSDB_STATUS_HPP
#define NLSR_TLV_LSDB_STATUS_HPP
#include "adjacency-lsa.hpp"
#include "coordinate-lsa.hpp"
#include "name-lsa.hpp"
#include <ndn-cxx/util/time.hpp>
#include <ndn-cxx/encoding/block.hpp>
#include <ndn-cxx/encoding/encoding-buffer.hpp>
#include <ndn-cxx/encoding/tlv.hpp>
#include <ndn-cxx/name.hpp>
#include <list>
namespace nlsr {
namespace tlv {
/*! \brief Data abstraction for LsdbStatus
*
* LsdbStatus := LSDB-STATUS-TYPE TLV-LENGTH
* AdjacencyLsa*
* CoordinateLsa*
* NameLsa*
*
* \sa https://redmine.named-data.net/projects/nlsr/wiki/LSDB_DataSet
*/
class LsdbStatus
{
public:
class Error : public ndn::tlv::Error
{
public:
explicit
Error(const std::string& what)
: ndn::tlv::Error(what)
{
}
};
typedef std::list<AdjacencyLsa> AdjacencyLsaList;
typedef std::list<CoordinateLsa> CoordinateLsaList;
typedef std::list<NameLsa> NameLsaList;
LsdbStatus();
explicit
LsdbStatus(const ndn::Block& block);
const std::list<AdjacencyLsa>&
getAdjacencyLsas() const
{
return m_adjacencyLsas;
}
LsdbStatus&
addAdjacencyLsa(const AdjacencyLsa& adjacencyLsa);
LsdbStatus&
clearAdjacencyLsas();
bool
hasAdjacencyLsas()
{
return m_hasAdjacencyLsas;
}
const std::list<CoordinateLsa>&
getCoordinateLsas() const
{
return m_coordinateLsas;
}
LsdbStatus&
addCoordinateLsa(const CoordinateLsa& coordinateLsa);
LsdbStatus&
clearCoordinateLsas();
bool
hasCoordinateLsas()
{
return m_hasCoordinateLsas;
}
const std::list<NameLsa>&
getNameLsas() const
{
return m_nameLsas;
}
LsdbStatus&
addNameLsa(const NameLsa& nameLsa);
LsdbStatus&
clearNameLsas();
bool
hasNameLsas()
{
return m_hasNameLsas;
}
/*! \brief Encodes the LSA objects and some info for each LSA using
* the method in TAG.
*
* This function will TLV-format the LSA objects and some LSA
* info using the implementation specified by TAG. Usually this is
* called with an estimator first to guess how long the buffer needs
* to be, then with an encoder to do the real work. This process is
* automated by the other wireEncode.
* \sa LsdbStatus::wireEncode()
*/
template<ndn::encoding::Tag TAG>
size_t
wireEncode(ndn::EncodingImpl<TAG>& block) const;
/*! \brief Create a TLV encoding of this object.
*
* Create a block containing the TLV encoding of this object. That
* involves two steps: estimating the size that the information will
* take up, and then creating a buffer of that size and encoding the
* information into it. Both steps are accomplished by
* LsdbStatus::wireEncode(ndn::EncodingImpl<TAG>&)
*/
const ndn::Block&
wireEncode() const;
/*! \brief Populate this object by decoding the one contained in the
* given block.
*/
void
wireDecode(const ndn::Block& wire);
private:
AdjacencyLsaList m_adjacencyLsas;
CoordinateLsaList m_coordinateLsas;
NameLsaList m_nameLsas;
bool m_hasAdjacencyLsas;
bool m_hasCoordinateLsas;
bool m_hasNameLsas;
mutable ndn::Block m_wire;
};
NDN_CXX_DECLARE_WIRE_ENCODE_INSTANTIATIONS(LsdbStatus);
std::ostream&
operator<<(std::ostream& os, const LsdbStatus& lsdbStatus);
} // namespace tlv
} // namespace nlsr
#endif // NLSR_TLV_LSDB_STATUS_HPP
tests/tlv/test-lsdb-status.cpp
-372
View File
@@ -1,372 +0,0 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/**
* Copyright (c) 2014-2019, The University of Memphis,
* Regents of the University of California,
* Arizona Board of Regents.
*
* This file is part of NLSR (Named-data Link State Routing).
* See AUTHORS.md for complete list of NLSR authors and contributors.
*
* NLSR 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.
*
* NLSR 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
* NLSR, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
**/
#include "tlv/lsdb-status.hpp"
#include "tests/boost-test.hpp"
#include <boost/mpl/vector.hpp>
#include <boost/lexical_cast.hpp>
namespace nlsr {
namespace tlv {
namespace test {
BOOST_AUTO_TEST_SUITE(TlvTestLsdbStatus)
const uint8_t LsdbStatusData1[] =
{
// Header
0x8a, 0x7b,
// AdjacencyLsa
0x83, 0x32,
// LsaInfo
0x80, 0x11, 0x81, 0x08, 0x07, 0x06, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x82, 0x01,
0x80, 0x8b, 0x02, 0x27, 0x10,
// Adjacency
0x84, 0x1d, 0x07, 0x0c, 0x08, 0x0a, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65, 0x6e, 0x63,
0x79, 0x31, 0x8d, 0x0a, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65, 0x6e, 0x63, 0x79, 0x31,
0x8c, 0x01, 0x80,
// CoordinateLsa
0x85, 0x27,
// LsaInfo
0x80, 0x11, 0x81, 0x08, 0x07, 0x06, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x82, 0x01,
0x80, 0x8b, 0x02, 0x27, 0x10,
// HyperbolicRadius
0x87, 0x08, 0x3f, 0xfa, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
// HyperbolicAngle
0x88, 0x08, 0x3f, 0xfc, 0x7a, 0xe1, 0x47, 0xae, 0x14, 0x7b,
// NameLsa
0x89, 0x1c,
// LsaInfo
0x80, 0x11, 0x81, 0x08, 0x07, 0x06, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x82, 0x01,
0x80, 0x8b, 0x02, 0x27, 0x10,
// Name
0x07, 0x07, 0x08, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x31
};
const uint8_t LsdbStatusData2[] =
{
// Header
0x8a, 0x00
};
const uint8_t LsdbStatusData3[] =
{
// Header
0x8a, 0x7b,
// CoordianteLsa
0x85, 0x27,
// LsaInfo
0x80, 0x11, 0x81, 0x08, 0x07, 0x06, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x82, 0x01,
0x80, 0x8B, 0x02, 0x27, 0x10,
// HyperbolicRadius
0x87, 0x08, 0x3F, 0xFA, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
// HyperbolicAngle
0x88, 0x08, 0x3F, 0xFC, 0x7A, 0xE1, 0x47, 0xAE, 0x14, 0x7B,
// NameLsa
0x89, 0x1c,
// LsaInfo
0x80, 0x11, 0x81, 0x08, 0x07, 0x06, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x82, 0x01,
0x80, 0x8b, 0x02, 0x27, 0x10,
// Name
0x07, 0x07, 0x08, 0x05, 0x6e, 0x61, 0x6d, 0x65, 0x31,
// AdjacencyLsa
0x83, 0x32,
// LsaInfo
0x80, 0x11, 0x81, 0x08, 0x07, 0x06, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x82, 0x01,
0x80, 0x8B, 0x02, 0x27, 0x10,
// Adjacency
0x84, 0x1d, 0x07, 0x0c, 0x08, 0x0a, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65, 0x6e, 0x63,
0x79, 0x31, 0x8d, 0x0a, 0x61, 0x64, 0x6a, 0x61, 0x63, 0x65, 0x6e, 0x63, 0x79, 0x31,
0x8c, 0x01, 0x80
};
BOOST_AUTO_TEST_CASE(LsdbStatusEncode1)
{
LsdbStatus lsdbStatus;
LsaInfo lsaInfo;
lsaInfo.setOriginRouter("test");
lsaInfo.setSequenceNumber(128);
lsaInfo.setExpirationPeriod(ndn::time::milliseconds(10000));
// AdjacencyLsa
AdjacencyLsa adjacencyLsa;
adjacencyLsa.setLsaInfo(lsaInfo);
Adjacency adjacency1;
adjacency1.setName("adjacency1");
adjacency1.setUri("adjacency1");
adjacency1.setCost(128);
adjacencyLsa.addAdjacency(adjacency1);
lsdbStatus.addAdjacencyLsa(adjacencyLsa);
// CoordinateLsa
CoordinateLsa coordinateLsa;
coordinateLsa.setLsaInfo(lsaInfo);
coordinateLsa.setHyperbolicRadius(1.65);
std::vector<double> angles;
angles.push_back(1.78);
coordinateLsa.setHyperbolicAngle(angles);
lsdbStatus.addCoordinateLsa(coordinateLsa);
// NameLsa
NameLsa nameLsa;
nameLsa.setLsaInfo(lsaInfo);
nameLsa.addName("name1");
lsdbStatus.addNameLsa(nameLsa);
const ndn::Block& wire = lsdbStatus.wireEncode();
BOOST_REQUIRE_EQUAL_COLLECTIONS(LsdbStatusData1,
LsdbStatusData1 + sizeof(LsdbStatusData1),
wire.begin(), wire.end());
}
BOOST_AUTO_TEST_CASE(LsdbStatusEncode2)
{
LsdbStatus lsdbStatus;
const ndn::Block& wire = lsdbStatus.wireEncode();
BOOST_REQUIRE_EQUAL_COLLECTIONS(LsdbStatusData2,
LsdbStatusData2 + sizeof(LsdbStatusData2),
wire.begin(), wire.end());
}
BOOST_AUTO_TEST_CASE(LsdbStatusDecode1)
{
LsdbStatus lsdbStatus;
lsdbStatus.wireDecode(ndn::Block(LsdbStatusData1, sizeof(LsdbStatusData1)));
std::list<AdjacencyLsa> adjacencyLsas = lsdbStatus.getAdjacencyLsas();
std::list<AdjacencyLsa>::const_iterator it1 = adjacencyLsas.begin();
LsaInfo lsaInfo = it1->getLsaInfo();
BOOST_CHECK_EQUAL(lsaInfo.getOriginRouter(), "test");
BOOST_CHECK_EQUAL(lsaInfo.getSequenceNumber(), 128);
BOOST_CHECK_EQUAL(lsaInfo.getExpirationPeriod(), ndn::time::milliseconds(10000));
std::list<Adjacency> adjacencies = it1->getAdjacencies();
std::list<Adjacency>::const_iterator it2 = adjacencies.begin();
BOOST_CHECK_EQUAL(it2->getName(), "adjacency1");
BOOST_CHECK_EQUAL(it2->getUri(), "adjacency1");
BOOST_CHECK_EQUAL(it2->getCost(), 128);
BOOST_CHECK_EQUAL(lsdbStatus.hasAdjacencyLsas(), true);
std::list<CoordinateLsa> coordinateLsas = lsdbStatus.getCoordinateLsas();
std::list<CoordinateLsa>::const_iterator it3 = coordinateLsas.begin();
lsaInfo = it3->getLsaInfo();
BOOST_CHECK_EQUAL(lsaInfo.getOriginRouter(), "test");
BOOST_CHECK_EQUAL(lsaInfo.getSequenceNumber(), 128);
BOOST_CHECK_EQUAL(lsaInfo.getExpirationPeriod(), ndn::time::milliseconds(10000));
BOOST_REQUIRE_EQUAL(it3->getHyperbolicRadius(), 1.65);
std::vector<double> angles;
angles.push_back(1.78);
BOOST_REQUIRE(it3->getHyperbolicAngle() == angles);
BOOST_CHECK_EQUAL(lsdbStatus.hasCoordinateLsas(), true);
std::list<NameLsa> nameLsas = lsdbStatus.getNameLsas();
std::list<NameLsa>::const_iterator it4 = nameLsas.begin();
lsaInfo = it4->getLsaInfo();
BOOST_CHECK_EQUAL(lsaInfo.getOriginRouter(), "test");
BOOST_CHECK_EQUAL(lsaInfo.getSequenceNumber(), 128);
BOOST_CHECK_EQUAL(lsaInfo.getExpirationPeriod(), ndn::time::milliseconds(10000));
std::list<ndn::Name> names = it4->getNames();
std::list<ndn::Name>::const_iterator it5 = names.begin();
BOOST_CHECK_EQUAL(*it5, "name1");
BOOST_CHECK_EQUAL(lsdbStatus.hasNameLsas(), true);
}
BOOST_AUTO_TEST_CASE(LsdbStatusDecode2)
{
LsdbStatus lsdbStatus;
lsdbStatus.wireDecode(ndn::Block(LsdbStatusData2, sizeof(LsdbStatusData2)));
BOOST_CHECK_EQUAL(lsdbStatus.hasAdjacencyLsas(), false);
BOOST_CHECK_EQUAL(lsdbStatus.hasCoordinateLsas(), false);
BOOST_CHECK_EQUAL(lsdbStatus.hasNameLsas(), false);
}
BOOST_AUTO_TEST_CASE(LsdbStatusDecode3)
{
LsdbStatus lsdbStatus;
BOOST_CHECK_THROW(lsdbStatus.wireDecode(ndn::Block(LsdbStatusData3, sizeof(LsdbStatusData3))),
LsdbStatus::Error);
}
BOOST_AUTO_TEST_CASE(LsdbStatusClear)
{
LsdbStatus lsdbStatus;
LsaInfo lsaInfo;
lsaInfo.setOriginRouter("test");
lsaInfo.setSequenceNumber(128);
lsaInfo.setExpirationPeriod(ndn::time::milliseconds(10000));
// AdjacencyLsa
AdjacencyLsa adjacencyLsa;
adjacencyLsa.setLsaInfo(lsaInfo);
Adjacency adjacency1;
adjacency1.setName("adjacency1");
adjacency1.setUri("adjacency1");
adjacency1.setCost(128);
adjacencyLsa.addAdjacency(adjacency1);
lsdbStatus.addAdjacencyLsa(adjacencyLsa);
BOOST_CHECK_EQUAL(lsdbStatus.hasAdjacencyLsas(), true);
lsdbStatus.clearAdjacencyLsas();
BOOST_CHECK_EQUAL(lsdbStatus.hasAdjacencyLsas(), false);
// CoordinateLsa
CoordinateLsa coordinateLsa;
coordinateLsa.setLsaInfo(lsaInfo);
coordinateLsa.setHyperbolicRadius(1.65);
std::vector<double> angles;
angles.push_back(1.78);
coordinateLsa.setHyperbolicAngle(angles);
lsdbStatus.addCoordinateLsa(coordinateLsa);
BOOST_CHECK_EQUAL(lsdbStatus.hasCoordinateLsas(), true);
lsdbStatus.clearCoordinateLsas();
BOOST_CHECK_EQUAL(lsdbStatus.hasCoordinateLsas(), false);
// NameLsa
NameLsa nameLsa;
nameLsa.setLsaInfo(lsaInfo);
nameLsa.addName("name1");
lsdbStatus.addNameLsa(nameLsa);
BOOST_CHECK_EQUAL(lsdbStatus.hasNameLsas(), true);
lsdbStatus.clearNameLsas();
BOOST_CHECK_EQUAL(lsdbStatus.hasNameLsas(), false);
}
class Theta
{
public:
std::vector<double> angles = {1.78};
};
class ThetaAndPhi
{
public:
std::vector<double> angles = {1.78, 3.21};
};
typedef boost::mpl::vector<Theta, ThetaAndPhi> HyperbolicAngleVectorFixture;
BOOST_AUTO_TEST_CASE_TEMPLATE(LsdbStatusOutputStream, HRAngleVector, HyperbolicAngleVectorFixture)
{
HRAngleVector angleVector;
LsdbStatus lsdbStatus;
LsaInfo lsaInfo;
lsaInfo.setOriginRouter("test");
lsaInfo.setSequenceNumber(128);
lsaInfo.setExpirationPeriod(ndn::time::milliseconds(10000));
// AdjacencyLsa
AdjacencyLsa adjacencyLsa;
adjacencyLsa.setLsaInfo(lsaInfo);
Adjacency adjacency1;
adjacency1.setName("adjacency1");
adjacency1.setUri("adjacency1");
adjacency1.setCost(128);
adjacencyLsa.addAdjacency(adjacency1);
lsdbStatus.addAdjacencyLsa(adjacencyLsa);
// NameLsa
NameLsa nameLsa;
nameLsa.setLsaInfo(lsaInfo);
nameLsa.addName("name1");
lsdbStatus.addNameLsa(nameLsa);
// CoordinateLsa
CoordinateLsa coordinateLsa;
coordinateLsa.setLsaInfo(lsaInfo);
coordinateLsa.setHyperbolicRadius(1.65);
coordinateLsa.setHyperbolicAngle(angleVector.angles);
std::string outputAngles = "HyperbolicAngles: ";
for (uint i = 0; i < angleVector.angles.size(); i++) {
std::string angle = boost::lexical_cast<std::string>(angleVector.angles[i]);
if (i == angleVector.angles.size()-1) {
outputAngles += angle;
}
else {
outputAngles += angle + ", ";
}
}
outputAngles += "), ";
lsdbStatus.addCoordinateLsa(coordinateLsa);
std::ostringstream os;
os << lsdbStatus;
BOOST_CHECK_EQUAL(os.str(), "LsdbStatus("
"AdjacencyLsa("
"LsaInfo("
"OriginRouter: /test, "
"SequenceNumber: 128, "
"ExpirationPeriod: 10000 milliseconds), "
"Adjacency(Name: /adjacency1, Uri: adjacency1, Cost: 128)), "
"CoordinateLsa("
"LsaInfo("
"OriginRouter: /test, "
"SequenceNumber: 128, "
"ExpirationPeriod: 10000 milliseconds), "
"HyperbolicRadius: 1.65, "
+ outputAngles +
"NameLsa("
"LsaInfo("
"OriginRouter: /test, "
"SequenceNumber: 128, "
"ExpirationPeriod: 10000 milliseconds), "
"Name: /name1))");
}
BOOST_AUTO_TEST_SUITE_END()
} // namespace test
} // namespace tlv
} // namespace nlsr