encoding: convert to span
Change-Id: I8bd73284fbd5acc0ff8ad2626af9b4324e9df7a1
diff --git a/ndn-cxx/data.cpp b/ndn-cxx/data.cpp
index fff95b8..a54458c 100644
--- a/ndn-cxx/data.cpp
+++ b/ndn-cxx/data.cpp
@@ -60,7 +60,7 @@
if (!m_signatureInfo) {
NDN_THROW(Error("Requested wire format, but Data has not been signed"));
}
- totalLength += encoder.prependBlock(m_signatureValue);
+ totalLength += prependBlock(encoder, m_signatureValue);
}
// SignatureInfo
@@ -68,7 +68,7 @@
// Content
if (hasContent()) {
- totalLength += encoder.prependBlock(m_content);
+ totalLength += prependBlock(encoder, m_content);
}
// MetaInfo
@@ -91,10 +91,12 @@
Data::wireEncode<encoding::EstimatorTag>(EncodingEstimator&, bool) const;
const Block&
-Data::wireEncode(EncodingBuffer& encoder, const Block& signatureValue) const
+Data::wireEncode(EncodingBuffer& encoder, span<const uint8_t> signature) const
{
size_t totalLength = encoder.size();
- totalLength += encoder.appendBlock(signatureValue);
+ totalLength += encoder.appendVarNumber(tlv::SignatureValue);
+ totalLength += encoder.appendVarNumber(signature.size());
+ totalLength += encoder.appendBytes(signature);
encoder.prependVarNumber(totalLength);
encoder.prependVarNumber(tlv::Data);
@@ -261,7 +263,7 @@
Data&
Data::setContent(span<const uint8_t> value)
{
- m_content = makeBinaryBlock(tlv::Content, value.data(), value.size());
+ m_content = makeBinaryBlock(tlv::Content, value);
resetWire();
return *this;
}
diff --git a/ndn-cxx/data.hpp b/ndn-cxx/data.hpp
index c75e138..040774a 100644
--- a/ndn-cxx/data.hpp
+++ b/ndn-cxx/data.hpp
@@ -60,36 +60,39 @@
explicit
Data(const Block& wire);
- /** @brief Prepend wire encoding to @p encoder
- * @param encoder EncodingEstimator or EncodingBuffer instance.
- * @param wantUnsignedPortionOnly If true, prepend only Name, MetaInfo, Content, and
- * SignatureInfo to @p encoder, but omit SignatureValue and the outermost TLV
- * Type and Length of the Data element. This is intended to be used with
- * wireEncode(EncodingBuffer&, const Block&) const.
- * @throw Error %Signature is not present and @p wantUnsignedPortionOnly is false.
+ /**
+ * @brief Prepend wire encoding to @p encoder.
+ * @param encoder EncodingEstimator or EncodingBuffer instance.
+ * @param wantUnsignedPortionOnly If true, prepend only Name, MetaInfo, Content, and
+ * SignatureInfo to @p encoder, but omit SignatureValue and the outermost TLV
+ * Type and Length of the %Data element. This is intended to be used with
+ * wireEncode(EncodingBuffer&, span<const uint8_t>) const.
+ * @throw Error Signature is not present and @p wantUnsignedPortionOnly is false.
*/
template<encoding::Tag TAG>
size_t
wireEncode(EncodingImpl<TAG>& encoder, bool wantUnsignedPortionOnly = false) const;
- /** @brief Finalize Data packet encoding with the specified SignatureValue
- * @param encoder EncodingBuffer containing Name, MetaInfo, Content, and SignatureInfo, but
- * without SignatureValue and the outermost Type-Length of the Data element.
- * @param signatureValue SignatureValue element.
+ /**
+ * @brief Finalize Data packet encoding with the specified signature.
+ * @param encoder EncodingBuffer containing Name, MetaInfo, Content, and SignatureInfo, but
+ * without SignatureValue and the outermost Type-Length of the %Data element.
+ * @param signature Raw signature bytes, without TLV Type and Length; this will become the
+ * TLV-VALUE of the SignatureValue element added to the packet.
*
- * This method is intended to be used in concert with `wireEncode(encoder, true)`, e.g.:
- * @code
- * Data data;
- * ...
- * EncodingBuffer encoder;
- * data.wireEncode(encoder, true);
- * ...
- * Block signatureValue = <sign_over_unsigned_portion>(encoder.buf(), encoder.size());
- * data.wireEncode(encoder, signatureValue)
- * @endcode
+ * This method is intended to be used in concert with `wireEncode(encoder, true)`, e.g.:
+ * @code
+ * Data data;
+ * ...
+ * EncodingBuffer encoder;
+ * data.wireEncode(encoder, true);
+ * ...
+ * auto signature = create_signature_over_signed_portion(encoder.data(), encoder.size());
+ * data.wireEncode(encoder, signature);
+ * @endcode
*/
const Block&
- wireEncode(EncodingBuffer& encoder, const Block& signatureValue) const;
+ wireEncode(EncodingBuffer& encoder, span<const uint8_t> signature) const;
/** @brief Encode into a Block.
* @pre Data must be signed.
diff --git a/ndn-cxx/encoding/block-helpers.cpp b/ndn-cxx/encoding/block-helpers.cpp
index f7ea61e..99ada84 100644
--- a/ndn-cxx/encoding/block-helpers.cpp
+++ b/ndn-cxx/encoding/block-helpers.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -34,12 +34,11 @@
size_t
prependNonNegativeIntegerBlock(EncodingImpl<TAG>& encoder, uint32_t type, uint64_t value)
{
- size_t valueLength = encoder.prependNonNegativeInteger(value);
- size_t totalLength = valueLength;
- totalLength += encoder.prependVarNumber(valueLength);
- totalLength += encoder.prependVarNumber(type);
+ size_t length = encoder.prependNonNegativeInteger(value);
+ length += encoder.prependVarNumber(length);
+ length += encoder.prependVarNumber(type);
- return totalLength;
+ return length;
}
template size_t
@@ -73,10 +72,10 @@
size_t
prependEmptyBlock(EncodingImpl<TAG>& encoder, uint32_t type)
{
- size_t totalLength = encoder.prependVarNumber(0);
- totalLength += encoder.prependVarNumber(type);
+ size_t length = encoder.prependVarNumber(0);
+ length += encoder.prependVarNumber(type);
- return totalLength;
+ return length;
}
template size_t
@@ -103,7 +102,7 @@
size_t
prependStringBlock(EncodingImpl<TAG>& encoder, uint32_t type, const std::string& value)
{
- return encoder.prependByteArrayBlock(type, reinterpret_cast<const uint8_t*>(value.data()), value.size());
+ return prependBinaryBlock(encoder, type, {reinterpret_cast<const uint8_t*>(value.data()), value.size()});
}
template size_t
@@ -135,7 +134,7 @@
uint64_t temp = 0;
std::memcpy(&temp, &value, 8);
endian::native_to_big_inplace(temp);
- return encoder.prependByteArrayBlock(type, reinterpret_cast<const uint8_t*>(&temp), 8);
+ return prependBinaryBlock(encoder, type, {reinterpret_cast<const uint8_t*>(&temp), 8});
}
template size_t
@@ -177,17 +176,55 @@
// ---- binary ----
+template<Tag TAG>
+size_t
+prependBinaryBlock(EncodingImpl<TAG>& encoder, uint32_t type, span<const uint8_t> value)
+{
+ size_t length = encoder.prependBytes(value);
+ length += encoder.prependVarNumber(length);
+ length += encoder.prependVarNumber(type);
+
+ return length;
+}
+
+template size_t
+prependBinaryBlock<EstimatorTag>(EncodingImpl<EstimatorTag>&, uint32_t, span<const uint8_t>);
+
+template size_t
+prependBinaryBlock<EncoderTag>(EncodingImpl<EncoderTag>&, uint32_t, span<const uint8_t>);
+
Block
makeBinaryBlock(uint32_t type, span<const uint8_t> value)
{
EncodingEstimator estimator;
- size_t totalLength = estimator.prependByteArrayBlock(type, value.data(), value.size());
+ size_t totalLength = prependBinaryBlock(estimator, type, value);
EncodingBuffer encoder(totalLength, 0);
- encoder.prependByteArrayBlock(type, value.data(), value.size());
+ prependBinaryBlock(encoder, type, value);
return encoder.block();
}
+// ---- block ----
+
+template<Tag TAG>
+size_t
+prependBlock(EncodingImpl<TAG>& encoder, const Block& block)
+{
+ if (block.hasWire()) {
+ return encoder.prependBytes({block.wire(), block.size()});
+ }
+ else {
+ // FIXME: blindly calling Block::value() is not safe if the value is not wire-encoded
+ return prependBinaryBlock(encoder, block.type(), {block.value(), block.value_size()});
+ }
+}
+
+template size_t
+prependBlock<EstimatorTag>(EncodingImpl<EstimatorTag>&, const Block&);
+
+template size_t
+prependBlock<EncoderTag>(EncodingImpl<EncoderTag>&, const Block&);
+
} // namespace encoding
} // namespace ndn
diff --git a/ndn-cxx/encoding/block-helpers.hpp b/ndn-cxx/encoding/block-helpers.hpp
index 3418d76..8224a77 100644
--- a/ndn-cxx/encoding/block-helpers.hpp
+++ b/ndn-cxx/encoding/block-helpers.hpp
@@ -25,7 +25,6 @@
#include "ndn-cxx/encoding/block.hpp"
#include "ndn-cxx/encoding/encoding-buffer.hpp"
#include "ndn-cxx/util/concepts.hpp"
-#include "ndn-cxx/util/span.hpp"
namespace ndn {
namespace encoding {
@@ -182,10 +181,28 @@
double
readDouble(const Block& block);
-/** @brief Create a TLV block copying the TLV-VALUE from a range.
- * @param type TLV-TYPE number
- * @param value range of bytes to use as TLV-VALUE
- * @sa Encoder::prependByteArrayBlock
+/**
+ * @brief Prepend a TLV element containing a sequence of raw bytes.
+ * @param encoder an EncodingBuffer or EncodingEstimator
+ * @param type TLV-TYPE number
+ * @param value range of bytes to use as TLV-VALUE
+ * @sa makeBinaryBlock
+ */
+template<Tag TAG>
+size_t
+prependBinaryBlock(EncodingImpl<TAG>& encoder, uint32_t type, span<const uint8_t> value);
+
+extern template size_t
+prependBinaryBlock<EstimatorTag>(EncodingImpl<EstimatorTag>&, uint32_t, span<const uint8_t>);
+
+extern template size_t
+prependBinaryBlock<EncoderTag>(EncodingImpl<EncoderTag>&, uint32_t, span<const uint8_t>);
+
+/**
+ * @brief Create a TLV block copying the TLV-VALUE from a byte range.
+ * @param type TLV-TYPE number
+ * @param value range of bytes to use as TLV-VALUE
+ * @sa prependBinaryBlock
*/
Block
makeBinaryBlock(uint32_t type, span<const uint8_t> value);
@@ -194,8 +211,9 @@
* @param type TLV-TYPE number
* @param value raw buffer as TLV-VALUE
* @param length length of value buffer
- * @sa Encoder::prependByteArrayBlock
+ * @deprecated
*/
+[[deprecated("use the overload that takes a span<>")]]
inline Block
makeBinaryBlock(uint32_t type, const uint8_t* value, size_t length)
{
@@ -206,7 +224,7 @@
* @param type TLV-TYPE number
* @param value raw buffer as TLV-VALUE
* @param length length of value buffer
- * @sa Encoder::prependByteArrayBlock
+ * @deprecated
*/
inline Block
makeBinaryBlock(uint32_t type, const char* value, size_t length)
@@ -216,7 +234,8 @@
namespace detail {
-/** @brief Create a binary block copying from RandomAccessIterator.
+/**
+ * @brief Create a binary block copying from RandomAccessIterator.
*/
template<class Iterator>
class BinaryBlockFast
@@ -242,7 +261,8 @@
}
};
-/** @brief Create a binary block copying from generic InputIterator.
+/**
+ * @brief Create a binary block copying from generic InputIterator.
*/
template<class Iterator>
class BinaryBlockSlow
@@ -272,6 +292,7 @@
* @param type TLV-TYPE number
* @param first begin iterator
* @param last past-the-end iterator
+ * @sa prependBinaryBlock
*/
template<class Iterator>
Block
@@ -286,6 +307,21 @@
return BinaryBlockHelper::makeBlock(type, first, last);
}
+/**
+ * @brief Prepend a TLV element.
+ * @param encoder an EncodingBuffer or EncodingEstimator
+ * @param block the TLV element
+ */
+template<Tag TAG>
+size_t
+prependBlock(EncodingImpl<TAG>& encoder, const Block& block);
+
+extern template size_t
+prependBlock<EstimatorTag>(EncodingImpl<EstimatorTag>&, const Block&);
+
+extern template size_t
+prependBlock<EncoderTag>(EncodingImpl<EncoderTag>&, const Block&);
+
/** @brief Prepend a TLV element containing a nested TLV element.
* @tparam U type that satisfies WireEncodableWithEncodingBuffer concept
* @param encoder an EncodingBuffer or EncodingEstimator
diff --git a/ndn-cxx/encoding/block.cpp b/ndn-cxx/encoding/block.cpp
index 052b049..56a1477 100644
--- a/ndn-cxx/encoding/block.cpp
+++ b/ndn-cxx/encoding/block.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -48,6 +48,30 @@
Block&
Block::operator=(const Block&) = default;
+Block::Block(span<const uint8_t> buffer)
+{
+ auto pos = buffer.begin();
+ const auto end = buffer.end();
+
+ m_type = tlv::readType(pos, end);
+ uint64_t length = tlv::readVarNumber(pos, end);
+ // pos now points to TLV-VALUE
+
+ BOOST_ASSERT(pos <= end);
+ if (length > static_cast<uint64_t>(std::distance(pos, end))) {
+ NDN_THROW(Error("Not enough bytes in the buffer to fully parse TLV"));
+ }
+ std::advance(pos, length);
+ // pos now points to the end of the TLV
+
+ m_buffer = std::make_shared<Buffer>(buffer.begin(), pos);
+ m_begin = m_buffer->begin();
+ m_end = m_buffer->end();
+ m_valueBegin = std::prev(m_end, length);
+ m_valueEnd = m_buffer->end();
+ m_size = m_buffer->size();
+}
+
Block::Block(const EncodingBuffer& buffer)
: Block(buffer.getBuffer(), buffer.begin(), buffer.end(), true)
{
@@ -65,7 +89,7 @@
, m_end(end)
, m_valueBegin(m_begin)
, m_valueEnd(m_end)
- , m_size(m_end - m_begin)
+ , m_size(static_cast<size_t>(std::distance(m_begin, m_end)))
{
if (m_buffer->empty()) {
NDN_THROW(std::invalid_argument("Buffer is empty"));
@@ -102,32 +126,13 @@
, m_valueBegin(valueBegin)
, m_valueEnd(valueEnd)
, m_type(type)
- , m_size(m_end - m_begin)
+ , m_size(static_cast<size_t>(std::distance(m_begin, m_end)))
{
}
Block::Block(const uint8_t* buf, size_t bufSize)
+ : Block(make_span(buf, bufSize))
{
- const uint8_t* pos = buf;
- const uint8_t* const end = buf + bufSize;
-
- m_type = tlv::readType(pos, end);
- uint64_t length = tlv::readVarNumber(pos, end);
- // pos now points to TLV-VALUE
-
- BOOST_ASSERT(pos <= end);
- if (length > static_cast<uint64_t>(end - pos)) {
- NDN_THROW(Error("Not enough bytes in the buffer to fully parse TLV"));
- }
-
- BOOST_ASSERT(pos > buf);
- uint64_t typeLengthSize = static_cast<uint64_t>(pos - buf);
- m_size = typeLengthSize + length;
-
- m_buffer = make_shared<Buffer>(buf, m_size);
- m_begin = m_buffer->begin();
- m_end = m_valueEnd = m_buffer->end();
- m_valueBegin = m_begin + typeLengthSize;
}
Block::Block(uint32_t type)
@@ -158,6 +163,70 @@
m_size = tlv::sizeOfVarNumber(m_type) + tlv::sizeOfVarNumber(value_size()) + value_size();
}
+std::tuple<bool, Block>
+Block::fromBuffer(ConstBufferPtr buffer, size_t offset)
+{
+ auto begin = std::next(buffer->begin(), offset);
+ auto pos = begin;
+ const auto end = buffer->end();
+
+ uint32_t type = 0;
+ bool isOk = tlv::readType(pos, end, type);
+ if (!isOk) {
+ return std::make_tuple(false, Block());
+ }
+
+ uint64_t length = 0;
+ isOk = tlv::readVarNumber(pos, end, length);
+ if (!isOk) {
+ return std::make_tuple(false, Block());
+ }
+ // pos now points to TLV-VALUE
+
+ BOOST_ASSERT(pos <= end);
+ if (length > static_cast<uint64_t>(std::distance(pos, end))) {
+ return std::make_tuple(false, Block());
+ }
+
+ return std::make_tuple(true, Block(std::move(buffer), type, begin, pos + length, pos, pos + length));
+}
+
+std::tuple<bool, Block>
+Block::fromBuffer(span<const uint8_t> buffer)
+{
+ auto pos = buffer.begin();
+ const auto end = buffer.end();
+
+ uint32_t type = 0;
+ bool isOk = tlv::readType(pos, end, type);
+ if (!isOk) {
+ return std::make_tuple(false, Block());
+ }
+ uint64_t length = 0;
+ isOk = tlv::readVarNumber(pos, end, length);
+ if (!isOk) {
+ return std::make_tuple(false, Block());
+ }
+ // pos now points to TLV-VALUE
+
+ BOOST_ASSERT(pos <= end);
+ if (length > static_cast<uint64_t>(std::distance(pos, end))) {
+ return std::make_tuple(false, Block());
+ }
+ std::advance(pos, length);
+ // pos now points to the end of the TLV
+
+ auto b = std::make_shared<Buffer>(buffer.begin(), pos);
+ return std::make_tuple(true, Block(b, type, b->begin(), b->end(),
+ std::prev(b->end(), length), b->end()));
+}
+
+std::tuple<bool, Block>
+Block::fromBuffer(const uint8_t* buf, size_t bufSize)
+{
+ return fromBuffer({buf, bufSize});
+}
+
Block
Block::fromStream(std::istream& is)
{
@@ -176,7 +245,7 @@
}
EncodingBuffer eb(tlSize + length, length);
- uint8_t* valueBuf = eb.buf();
+ uint8_t* valueBuf = eb.data();
is.read(reinterpret_cast<char*>(valueBuf), length);
if (length != static_cast<uint64_t>(is.gcount())) {
NDN_THROW(Error("Not enough bytes from stream to fully parse TLV"));
@@ -190,60 +259,6 @@
return Block(eb.getBuffer());
}
-std::tuple<bool, Block>
-Block::fromBuffer(ConstBufferPtr buffer, size_t offset)
-{
- auto begin = buffer->begin() + offset;
- auto pos = begin;
-
- uint32_t type = 0;
- bool isOk = tlv::readType(pos, buffer->end(), type);
- if (!isOk) {
- return std::make_tuple(false, Block());
- }
-
- uint64_t length = 0;
- isOk = tlv::readVarNumber(pos, buffer->end(), length);
- if (!isOk) {
- return std::make_tuple(false, Block());
- }
- // pos now points to TLV-VALUE
-
- if (length > static_cast<uint64_t>(buffer->end() - pos)) {
- return std::make_tuple(false, Block());
- }
-
- return std::make_tuple(true, Block(std::move(buffer), type, begin, pos + length, pos, pos + length));
-}
-
-std::tuple<bool, Block>
-Block::fromBuffer(const uint8_t* buf, size_t bufSize)
-{
- const uint8_t* pos = buf;
- const uint8_t* const end = buf + bufSize;
-
- uint32_t type = 0;
- bool isOk = tlv::readType(pos, end, type);
- if (!isOk) {
- return std::make_tuple(false, Block());
- }
- uint64_t length = 0;
- isOk = tlv::readVarNumber(pos, end, length);
- if (!isOk) {
- return std::make_tuple(false, Block());
- }
- // pos now points to TLV-VALUE
-
- if (length > static_cast<uint64_t>(end - pos)) {
- return std::make_tuple(false, Block());
- }
-
- size_t typeLengthSize = pos - buf;
- auto b = make_shared<Buffer>(buf, pos + length);
- return std::make_tuple(true, Block(b, type, b->begin(), b->end(),
- b->begin() + typeLengthSize, b->end()));
-}
-
// ---- wire format ----
void
@@ -342,7 +357,7 @@
}
// pos now points to TLV-VALUE of sub element
- auto subEnd = pos + length;
+ auto subEnd = std::next(pos, length);
m_elements.emplace_back(m_buffer, type, begin, subEnd, pos, subEnd);
begin = subEnd;
diff --git a/ndn-cxx/encoding/block.hpp b/ndn-cxx/encoding/block.hpp
index 41a1b30..9da1946 100644
--- a/ndn-cxx/encoding/block.hpp
+++ b/ndn-cxx/encoding/block.hpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2020 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -27,6 +27,7 @@
#include "ndn-cxx/encoding/buffer.hpp"
#include "ndn-cxx/encoding/encoding-buffer-fwd.hpp"
#include "ndn-cxx/encoding/tlv.hpp"
+#include "ndn-cxx/util/span.hpp"
namespace boost {
namespace asio {
@@ -36,8 +37,9 @@
namespace ndn {
-/** @brief Represents a TLV element of the NDN packet format.
- * @sa https://named-data.net/doc/NDN-packet-spec/0.3/tlv.html#tlv-encoding
+/**
+ * @brief Represents a TLV element of the NDN packet format.
+ * @sa https://named-data.net/doc/NDN-packet-spec/0.3/tlv.html
*/
class Block
{
@@ -76,6 +78,15 @@
Block&
operator=(Block&&) noexcept;
+ /** @brief Parse Block from a byte range
+ * @param buffer sequence of bytes containing a TLV element; the element must be found at
+ * the beginning of the buffer but does not need to span the entire buffer
+ * @throw tlv::Error Type-Length parsing fails, or TLV-LENGTH exceeds the size of @p buffer
+ * @note This constructor copies the TLV element octets to an internal buffer.
+ */
+ explicit
+ Block(span<const uint8_t> buffer);
+
/** @brief Parse Block from an EncodingBuffer
* @param buffer an EncodingBuffer containing one TLV element
* @throw tlv::Error Type-Length parsing fails, or TLV-LENGTH does not match size of TLV-VALUE
@@ -85,8 +96,8 @@
/** @brief Parse Block from a wire Buffer
* @param buffer a Buffer containing one TLV element
- * @note This constructor takes shared ownership of @p buffer.
* @throw tlv::Error Type-Length parsing fails, or TLV-LENGTH does not match size of TLV-VALUE
+ * @note This constructor takes shared ownership of @p buffer.
*/
explicit
Block(const ConstBufferPtr& buffer);
@@ -98,7 +109,6 @@
* @param verifyLength if true, check TLV-LENGTH equals size of TLV-VALUE
* @throw std::invalid_argument @p buffer is empty, or [@p begin,@p end) range is not within @p buffer
* @throw tlv::Error Type-Length parsing fails, or TLV-LENGTH does not match size of TLV-VALUE
- * @note This overload automatically detects TLV-TYPE and position of TLV-VALUE.
*/
Block(ConstBufferPtr buffer, Buffer::const_iterator begin, Buffer::const_iterator end,
bool verifyLength = true);
@@ -130,8 +140,10 @@
* @param buf pointer to the first octet of a TLV element
* @param bufSize size of the raw buffer; may be greater than the actual size of the TLV element
* @throw tlv::Error Type-Length parsing fails, or size of TLV-VALUE exceeds @p bufSize
- * @note This overload copies the TLV element octets into an internal wire buffer.
+ * @note This constructor copies the TLV element octets to an internal buffer.
+ * @deprecated
*/
+ [[deprecated("use the constructor that takes a span<>")]]
Block(const uint8_t* buf, size_t bufSize);
/** @brief Create a zero-length Block with the specified TLV-TYPE
@@ -152,6 +164,37 @@
*/
Block(uint32_t type, const Block& value);
+ /** @brief Try to parse Block from a wire buffer
+ * @param buffer a Buffer containing a TLV element at offset @p offset
+ * @param offset begin position of the TLV element within @p buffer
+ * @return `true` and the parsed Block if parsing succeeds; otherwise `false` and an invalid Block
+ * @note This function does not throw upon decoding failure.
+ */
+ NDN_CXX_NODISCARD static std::tuple<bool, Block>
+ fromBuffer(ConstBufferPtr buffer, size_t offset = 0);
+
+ /** @brief Try to parse Block from a byte range
+ * @param buffer sequence of bytes containing a TLV element; the element must be found at
+ * the beginning of the buffer but does not need to span the entire buffer
+ * @return `true` and the parsed Block if parsing succeeds; otherwise `false` and an invalid Block
+ * @note This overload copies the TLV element octets to an internal buffer.
+ * @note This function does not throw upon decoding failure.
+ */
+ NDN_CXX_NODISCARD static std::tuple<bool, Block>
+ fromBuffer(span<const uint8_t> buffer);
+
+ /** @brief Try to parse Block from a raw buffer
+ * @param buf pointer to the first octet of a TLV element
+ * @param bufSize size of the raw buffer; may be greater than the actual size of the TLV element
+ * @return `true` and the parsed Block if parsing succeeds; otherwise `false` and an invalid Block
+ * @note This overload copies the TLV element octets to an internal buffer.
+ * @note This function does not throw upon decoding failure.
+ * @deprecated
+ */
+ [[deprecated("use the overload that takes a span<>")]]
+ NDN_CXX_NODISCARD static std::tuple<bool, Block>
+ fromBuffer(const uint8_t* buf, size_t bufSize);
+
/** @brief Parse Block from an input stream
* @throw tlv::Error TLV-LENGTH is zero or exceeds upper bound
* @warning If decoding fails, bytes are still consumed from the input stream.
@@ -159,25 +202,6 @@
static Block
fromStream(std::istream& is);
- /** @brief Try to parse Block from a wire buffer
- * @param buffer a Buffer containing a TLV element at offset @p offset
- * @param offset begin position of the TLV element within @p buffer
- * @note This function does not throw upon decoding failure.
- * @return `true` and the parsed Block if parsing succeeds; otherwise `false` and an invalid Block
- */
- NDN_CXX_NODISCARD static std::tuple<bool, Block>
- fromBuffer(ConstBufferPtr buffer, size_t offset);
-
- /** @brief Try to parse Block from a raw buffer
- * @param buf pointer to the first octet of a TLV element
- * @param bufSize size of the raw buffer; may be greater than the actual size of the TLV element
- * @note This function does not throw upon decoding failure.
- * @note This overload copies the TLV element octets into an internal wire buffer.
- * @return `true` and the parsed Block if parsing succeeds; otherwise `false` and an invalid Block
- */
- NDN_CXX_NODISCARD static std::tuple<bool, Block>
- fromBuffer(const uint8_t* buf, size_t bufSize);
-
public: // wire format
/** @brief Check if the Block is valid
*
diff --git a/ndn-cxx/encoding/encoder.cpp b/ndn-cxx/encoding/encoder.cpp
index 2323c26..7cc9e17 100644
--- a/ndn-cxx/encoding/encoder.cpp
+++ b/ndn-cxx/encoding/encoder.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2018 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -95,68 +95,40 @@
}
size_t
-Encoder::prependByte(uint8_t value)
+Encoder::prependBytes(span<const uint8_t> bytes)
{
- reserveFront(1);
-
- m_begin--;
- *m_begin = value;
- return 1;
+ return prependRange(bytes.begin(), bytes.end());
}
size_t
-Encoder::appendByte(uint8_t value)
+Encoder::appendBytes(span<const uint8_t> bytes)
{
- reserveBack(1);
-
- *m_end = value;
- m_end++;
- return 1;
-}
-
-size_t
-Encoder::prependByteArray(const uint8_t* array, size_t length)
-{
- reserveFront(length);
-
- m_begin -= length;
- std::copy(array, array + length, m_begin);
- return length;
-}
-
-size_t
-Encoder::appendByteArray(const uint8_t* array, size_t length)
-{
- reserveBack(length);
-
- std::copy(array, array + length, m_end);
- m_end += length;
- return length;
+ return appendRange(bytes.begin(), bytes.end());
}
size_t
Encoder::prependVarNumber(uint64_t varNumber)
{
if (varNumber < 253) {
- prependByte(static_cast<uint8_t>(varNumber));
+ prependBytes({static_cast<uint8_t>(varNumber)});
return 1;
}
else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
uint16_t value = endian::native_to_big(static_cast<uint16_t>(varNumber));
- prependByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
- prependByte(253);
+ prependBytes({reinterpret_cast<const uint8_t*>(&value), 2});
+ prependBytes({253});
return 3;
}
else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
uint32_t value = endian::native_to_big(static_cast<uint32_t>(varNumber));
- prependByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
- prependByte(254);
+ prependBytes({reinterpret_cast<const uint8_t*>(&value), 4});
+ prependBytes({254});
return 5;
}
else {
uint64_t value = endian::native_to_big(varNumber);
- prependByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
- prependByte(255);
+ prependBytes({reinterpret_cast<const uint8_t*>(&value), 8});
+ prependBytes({255});
return 9;
}
}
@@ -165,25 +137,25 @@
Encoder::appendVarNumber(uint64_t varNumber)
{
if (varNumber < 253) {
- appendByte(static_cast<uint8_t>(varNumber));
+ appendBytes({static_cast<uint8_t>(varNumber)});
return 1;
}
else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
- appendByte(253);
+ appendBytes({253});
uint16_t value = endian::native_to_big(static_cast<uint16_t>(varNumber));
- appendByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
+ appendBytes({reinterpret_cast<const uint8_t*>(&value), 2});
return 3;
}
else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
- appendByte(254);
+ appendBytes({254});
uint32_t value = endian::native_to_big(static_cast<uint32_t>(varNumber));
- appendByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
+ appendBytes({reinterpret_cast<const uint8_t*>(&value), 4});
return 5;
}
else {
- appendByte(255);
+ appendBytes({255});
uint64_t value = endian::native_to_big(varNumber);
- appendByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
+ appendBytes({reinterpret_cast<const uint8_t*>(&value), 8});
return 9;
}
}
@@ -192,19 +164,19 @@
Encoder::prependNonNegativeInteger(uint64_t varNumber)
{
if (varNumber <= std::numeric_limits<uint8_t>::max()) {
- return prependByte(static_cast<uint8_t>(varNumber));
+ return prependBytes({static_cast<uint8_t>(varNumber)});
}
else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
uint16_t value = endian::native_to_big(static_cast<uint16_t>(varNumber));
- return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
+ return prependBytes({reinterpret_cast<const uint8_t*>(&value), 2});
}
else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
uint32_t value = endian::native_to_big(static_cast<uint32_t>(varNumber));
- return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
+ return prependBytes({reinterpret_cast<const uint8_t*>(&value), 4});
}
else {
uint64_t value = endian::native_to_big(varNumber);
- return prependByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
+ return prependBytes({reinterpret_cast<const uint8_t*>(&value), 8});
}
}
@@ -212,26 +184,26 @@
Encoder::appendNonNegativeInteger(uint64_t varNumber)
{
if (varNumber <= std::numeric_limits<uint8_t>::max()) {
- return appendByte(static_cast<uint8_t>(varNumber));
+ return appendBytes({static_cast<uint8_t>(varNumber)});
}
else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
uint16_t value = endian::native_to_big(static_cast<uint16_t>(varNumber));
- return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 2);
+ return appendBytes({reinterpret_cast<const uint8_t*>(&value), 2});
}
else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
uint32_t value = endian::native_to_big(static_cast<uint32_t>(varNumber));
- return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 4);
+ return appendBytes({reinterpret_cast<const uint8_t*>(&value), 4});
}
else {
uint64_t value = endian::native_to_big(varNumber);
- return appendByteArray(reinterpret_cast<const uint8_t*>(&value), 8);
+ return appendBytes({reinterpret_cast<const uint8_t*>(&value), 8});
}
}
size_t
Encoder::prependByteArrayBlock(uint32_t type, const uint8_t* array, size_t arraySize)
{
- size_t totalLength = prependByteArray(array, arraySize);
+ size_t totalLength = prependBytes({array, arraySize});
totalLength += prependVarNumber(arraySize);
totalLength += prependVarNumber(type);
@@ -243,16 +215,18 @@
{
size_t totalLength = appendVarNumber(type);
totalLength += appendVarNumber(arraySize);
- totalLength += appendByteArray(array, arraySize);
+ totalLength += appendBytes({array, arraySize});
return totalLength;
}
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
size_t
Encoder::prependBlock(const Block& block)
{
if (block.hasWire()) {
- return prependByteArray(block.wire(), block.size());
+ return prependBytes({block.wire(), block.size()});
}
else {
return prependByteArrayBlock(block.type(), block.value(), block.value_size());
@@ -263,7 +237,7 @@
Encoder::appendBlock(const Block& block)
{
if (block.hasWire()) {
- return appendByteArray(block.wire(), block.size());
+ return appendBytes({block.wire(), block.size()});
}
else {
return appendByteArrayBlock(block.type(), block.value(), block.value_size());
diff --git a/ndn-cxx/encoding/encoder.hpp b/ndn-cxx/encoding/encoder.hpp
index d875cbf..186ee2a 100644
--- a/ndn-cxx/encoding/encoder.hpp
+++ b/ndn-cxx/encoding/encoder.hpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -28,36 +28,70 @@
namespace encoding {
/**
- * @brief Helper class to perform TLV encoding
- * Interface of this class (mostly) matches interface of Estimator class
+ * @brief Helper class to perform TLV encoding.
+ *
+ * The interface of this class (mostly) matches that of the Estimator class.
+ *
* @sa Estimator
*/
class Encoder : noncopyable
{
public: // common interface between Encoder and Estimator
/**
- * @brief Prepend a byte
+ * @brief Prepend a sequence of bytes
*/
size_t
- prependByte(uint8_t value);
+ prependBytes(span<const uint8_t> bytes);
+
+ /**
+ * @brief Append a sequence of bytes
+ */
+ size_t
+ appendBytes(span<const uint8_t> bytes);
+
+ /**
+ * @brief Prepend a byte
+ * @deprecated
+ */
+ [[deprecated("use prependBytes()")]]
+ size_t
+ prependByte(uint8_t value)
+ {
+ return prependBytes({value});
+ }
/**
* @brief Append a byte
+ * @deprecated
*/
+ [[deprecated("use appendBytes()")]]
size_t
- appendByte(uint8_t value);
+ appendByte(uint8_t value)
+ {
+ return appendBytes({value});
+ }
/**
* @brief Prepend a byte array @p array of length @p length
+ * @deprecated
*/
+ [[deprecated("use prependBytes()")]]
size_t
- prependByteArray(const uint8_t* array, size_t length);
+ prependByteArray(const uint8_t* array, size_t length)
+ {
+ return prependBytes({array, length});
+ }
/**
* @brief Append a byte array @p array of length @p length
+ * @deprecated
*/
+ [[deprecated("use appendBytes()")]]
size_t
- appendByteArray(const uint8_t* array, size_t length);
+ appendByteArray(const uint8_t* array, size_t length)
+ {
+ return appendBytes({array, length});
+ }
/**
* @brief Prepend range of bytes from the range [@p first, @p last)
@@ -74,54 +108,62 @@
appendRange(Iterator first, Iterator last);
/**
- * @brief Prepend VarNumber @p varNumber of NDN TLV encoding
- * @sa http://named-data.net/doc/ndn-tlv/
+ * @brief Prepend @p number encoded as a VAR-NUMBER in NDN-TLV format
+ * @sa https://named-data.net/doc/NDN-packet-spec/current/tlv.html
*/
size_t
- prependVarNumber(uint64_t varNumber);
+ prependVarNumber(uint64_t number);
/**
- * @brief Prepend VarNumber @p varNumber of NDN TLV encoding
- * @sa http://named-data.net/doc/ndn-tlv/
+ * @brief Append @p number encoded as a VAR-NUMBER in NDN-TLV format
+ * @sa https://named-data.net/doc/NDN-packet-spec/current/tlv.html
*/
size_t
- appendVarNumber(uint64_t varNumber);
+ appendVarNumber(uint64_t number);
/**
- * @brief Prepend non-negative integer @p integer of NDN TLV encoding
- * @sa http://named-data.net/doc/ndn-tlv/
+ * @brief Prepend @p integer encoded as a NonNegativeInteger in NDN-TLV format
+ * @sa https://named-data.net/doc/NDN-packet-spec/current/tlv.html
*/
size_t
prependNonNegativeInteger(uint64_t integer);
/**
- * @brief Append non-negative integer @p integer of NDN TLV encoding
- * @sa http://named-data.net/doc/ndn-tlv/
+ * @brief Append @p integer encoded as a NonNegativeInteger in NDN-TLV format
+ * @sa https://named-data.net/doc/NDN-packet-spec/current/tlv.html
*/
size_t
appendNonNegativeInteger(uint64_t integer);
/**
* @brief Prepend TLV block of type @p type and value from buffer @p array of size @p arraySize
+ * @deprecated
*/
+ [[deprecated("use encoding::prependBinaryBlock()")]]
size_t
prependByteArrayBlock(uint32_t type, const uint8_t* array, size_t arraySize);
/**
* @brief Append TLV block of type @p type and value from buffer @p array of size @p arraySize
+ * @deprecated
*/
+ [[deprecated]]
size_t
appendByteArrayBlock(uint32_t type, const uint8_t* array, size_t arraySize);
/**
* @brief Prepend TLV block @p block
+ * @deprecated
*/
+ [[deprecated("use encoding::prependBlock()")]]
size_t
prependBlock(const Block& block);
/**
* @brief Append TLV block @p block
+ * @deprecated
*/
+ [[deprecated]]
size_t
appendBlock(const Block& block);
@@ -183,56 +225,103 @@
* @brief Get size of the underlying buffer
*/
size_t
- capacity() const noexcept;
+ capacity() const noexcept
+ {
+ return m_buffer->size();
+ }
/**
* @brief Get underlying buffer
*/
shared_ptr<Buffer>
- getBuffer() const noexcept;
+ getBuffer() const noexcept
+ {
+ return m_buffer;
+ }
public: // accessors
/**
- * @brief Get an iterator pointing to the first byte of the encoded buffer
+ * @brief Returns an iterator pointing to the first byte of the encoded buffer
*/
iterator
- begin();
+ begin() noexcept
+ {
+ return m_begin;
+ }
/**
- * @brief Get an iterator pointing to the past-the-end byte of the encoded buffer
+ * @brief Returns an iterator pointing to the first byte of the encoded buffer
+ */
+ const_iterator
+ begin() const noexcept
+ {
+ return m_begin;
+ }
+
+ /**
+ * @brief Returns an iterator pointing to the past-the-end byte of the encoded buffer
*/
iterator
- end();
+ end() noexcept
+ {
+ return m_end;
+ }
/**
- * @brief Get an iterator pointing to the first byte of the encoded buffer
+ * @brief Returns an iterator pointing to the past-the-end byte of the encoded buffer
*/
const_iterator
- begin() const;
+ end() const noexcept
+ {
+ return m_end;
+ }
/**
- * @brief Get an iterator pointing to the past-the-end byte of the encoded buffer
- */
- const_iterator
- end() const;
-
- /**
- * @brief Get a pointer to the first byte of the encoded buffer
+ * @brief Returns a pointer to the first byte of the encoded buffer
*/
uint8_t*
- buf();
+ data() noexcept
+ {
+ return &*m_begin;
+ }
/**
- * @brief Get a pointer to the first byte of the encoded buffer
+ * @brief Returns a pointer to the first byte of the encoded buffer
*/
const uint8_t*
- buf() const;
+ data() const noexcept
+ {
+ return &*m_begin;
+ }
/**
- * @brief Get the size of the encoded buffer
+ * @deprecated
+ */
+ [[deprecated("use data()")]]
+ uint8_t*
+ buf() noexcept
+ {
+ return data();
+ }
+
+ /**
+ * @deprecated
+ */
+ [[deprecated("use data()")]]
+ const uint8_t*
+ buf() const noexcept
+ {
+ return data();
+ }
+
+ /**
+ * @brief Returns the size of the encoded buffer
*/
size_t
- size() const noexcept;
+ size() const noexcept
+ {
+ return static_cast<size_t>(std::distance(m_begin, m_end));
+ }
/**
* @brief Create Block from the underlying buffer
@@ -253,60 +342,6 @@
iterator m_end;
};
-inline size_t
-Encoder::size() const noexcept
-{
- return m_end - m_begin;
-}
-
-inline shared_ptr<Buffer>
-Encoder::getBuffer() const noexcept
-{
- return m_buffer;
-}
-
-inline size_t
-Encoder::capacity() const noexcept
-{
- return m_buffer->size();
-}
-
-inline Buffer::iterator
-Encoder::begin()
-{
- return m_begin;
-}
-
-inline Buffer::iterator
-Encoder::end()
-{
- return m_end;
-}
-
-inline Buffer::const_iterator
-Encoder::begin() const
-{
- return m_begin;
-}
-
-inline Buffer::const_iterator
-Encoder::end() const
-{
- return m_end;
-}
-
-inline uint8_t*
-Encoder::buf()
-{
- return &(*m_begin);
-}
-
-inline const uint8_t*
-Encoder::buf() const
-{
- return &(*m_begin);
-}
-
template<class Iterator>
size_t
Encoder::prependRange(Iterator first, Iterator last)
@@ -317,7 +352,7 @@
size_t length = std::distance(first, last);
reserveFront(length);
- m_begin -= length;
+ std::advance(m_begin, -length);
std::copy(first, last, m_begin);
return length;
}
@@ -333,7 +368,7 @@
reserveBack(length);
std::copy(first, last, m_end);
- m_end += length;
+ std::advance(m_end, length);
return length;
}
diff --git a/ndn-cxx/encoding/estimator.cpp b/ndn-cxx/encoding/estimator.cpp
index a6d0c24..299e0f5 100644
--- a/ndn-cxx/encoding/estimator.cpp
+++ b/ndn-cxx/encoding/estimator.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -24,6 +24,8 @@
namespace ndn {
namespace encoding {
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
size_t
Estimator::prependBlock(const Block& block) const
{
@@ -35,5 +37,11 @@
}
}
+size_t
+Estimator::appendBlock(const Block& block) const
+{
+ return prependBlock(block);
+}
+
} // namespace encoding
} // namespace ndn
diff --git a/ndn-cxx/encoding/estimator.hpp b/ndn-cxx/encoding/estimator.hpp
index 9f43c1f..ff85695 100644
--- a/ndn-cxx/encoding/estimator.hpp
+++ b/ndn-cxx/encoding/estimator.hpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -38,9 +38,29 @@
{
public: // common interface between Encoder and Estimator
/**
- * @brief Prepend a single byte
+ * @brief Prepend a sequence of bytes
*/
constexpr size_t
+ prependBytes(span<const uint8_t> bytes) const noexcept
+ {
+ return bytes.size();
+ }
+
+ /**
+ * @brief Append a sequence of bytes
+ */
+ constexpr size_t
+ appendBytes(span<const uint8_t> bytes) const noexcept
+ {
+ return bytes.size();
+ }
+
+ /**
+ * @brief Prepend a single byte
+ * @deprecated
+ */
+ [[deprecated("use prependBytes()")]]
+ constexpr size_t
prependByte(uint8_t) const noexcept
{
return 1;
@@ -48,7 +68,9 @@
/**
* @brief Append a single byte
+ * @deprecated
*/
+ [[deprecated("use appendBytes()")]]
constexpr size_t
appendByte(uint8_t) const noexcept
{
@@ -57,7 +79,9 @@
/**
* @brief Prepend a byte array @p array of length @p length
+ * @deprecated
*/
+ [[deprecated("use prependBytes()")]]
constexpr size_t
prependByteArray(const uint8_t*, size_t length) const noexcept
{
@@ -66,7 +90,9 @@
/**
* @brief Append a byte array @p array of length @p length
+ * @deprecated
*/
+ [[deprecated("use appendBytes()")]]
constexpr size_t
appendByteArray(const uint8_t*, size_t length) const noexcept
{
@@ -131,7 +157,9 @@
/**
* @brief Prepend TLV block of type @p type and value from buffer @p array of size @p arraySize
+ * @deprecated
*/
+ [[deprecated("use encoding::prependBinaryBlock()")]]
constexpr size_t
prependByteArrayBlock(uint32_t type, const uint8_t* array, size_t arraySize) const noexcept
{
@@ -140,7 +168,9 @@
/**
* @brief Append TLV block of type @p type and value from buffer @p array of size @p arraySize
+ * @deprecated
*/
+ [[deprecated]]
constexpr size_t
appendByteArrayBlock(uint32_t type, const uint8_t* array, size_t arraySize) const noexcept
{
@@ -149,18 +179,19 @@
/**
* @brief Prepend TLV block @p block
+ * @deprecated
*/
+ [[deprecated("use encoding::prependBlock()")]]
size_t
prependBlock(const Block& block) const;
/**
* @brief Append TLV block @p block
+ * @deprecated
*/
+ [[deprecated]]
size_t
- appendBlock(const Block& block) const
- {
- return prependBlock(block);
- }
+ appendBlock(const Block& block) const;
};
} // namespace encoding
diff --git a/ndn-cxx/face.cpp b/ndn-cxx/face.cpp
index db4d196..48f1095 100644
--- a/ndn-cxx/face.cpp
+++ b/ndn-cxx/face.cpp
@@ -314,9 +314,8 @@
lp::Packet lpPacket(blockFromDaemon); // bare Interest/Data is a valid lp::Packet,
// no need to distinguish
- Buffer::const_iterator begin, end;
- std::tie(begin, end) = lpPacket.get<lp::FragmentField>();
- Block netPacket(&*begin, std::distance(begin, end));
+ auto frag = lpPacket.get<lp::FragmentField>();
+ Block netPacket({frag.first, frag.second});
switch (netPacket.type()) {
case tlv::Interest: {
auto interest = make_shared<Interest>(netPacket);
diff --git a/ndn-cxx/impl/name-component-types.hpp b/ndn-cxx/impl/name-component-types.hpp
index 5f224ae..0ca8bdf 100644
--- a/ndn-cxx/impl/name-component-types.hpp
+++ b/ndn-cxx/impl/name-component-types.hpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -55,10 +55,10 @@
* If \p comp is the maximum possible value of this component type, return true to indicate
* that the successor should have a greater TLV-TYPE.
*/
- virtual std::pair<bool, Component>
+ virtual std::tuple<bool, Component>
getSuccessor(const Component& comp) const
{
- return {false, getSuccessorImpl(comp).second};
+ return {false, std::get<Block>(getSuccessorImpl(comp))};
}
/** \brief Return the minimum allowable TLV-VALUE of this component type.
@@ -112,7 +112,7 @@
/** \brief Calculate the successor of \p comp, extending TLV-LENGTH if value overflows.
* \return whether TLV-LENGTH was extended, and the successor
*/
- std::pair<bool, Block>
+ std::tuple<bool, Block>
getSuccessorImpl(const Component& comp) const
{
EncodingBuffer encoder(comp.size() + 9, 9);
@@ -122,14 +122,14 @@
size_t i = comp.value_size();
for (; isOverflow && i > 0; i--) {
uint8_t newValue = static_cast<uint8_t>((comp.value()[i - 1] + 1) & 0xFF);
- encoder.prependByte(newValue);
+ encoder.prependBytes({newValue});
isOverflow = (newValue == 0);
}
- encoder.prependByteArray(comp.value(), i);
+ encoder.prependBytes({comp.value(), i});
if (isOverflow) {
// new name component has to be extended
- encoder.appendByte(0);
+ encoder.appendBytes({0});
}
encoder.prependVarNumber(encoder.size());
@@ -206,7 +206,7 @@
return makeBinaryBlock(m_type, value);
}
- std::pair<bool, Component>
+ std::tuple<bool, Component>
getSuccessor(const Component& comp) const final
{
bool isExtended = false;
diff --git a/ndn-cxx/interest.cpp b/ndn-cxx/interest.cpp
index 66e240a..8edb092 100644
--- a/ndn-cxx/interest.cpp
+++ b/ndn-cxx/interest.cpp
@@ -90,12 +90,12 @@
// ApplicationParameters and following elements (in reverse order)
for (const auto& block : m_parameters | boost::adaptors::reversed) {
- totalLength += encoder.prependBlock(block);
+ totalLength += prependBlock(encoder, block);
}
// HopLimit
if (getHopLimit()) {
- totalLength += encoder.prependByteArrayBlock(tlv::HopLimit, &*m_hopLimit, 1);
+ totalLength += prependBinaryBlock(encoder, tlv::HopLimit, {*m_hopLimit});
}
// InterestLifetime
@@ -107,7 +107,7 @@
// Nonce
getNonce(); // if nonce was unset, this generates a fresh nonce
BOOST_ASSERT(hasNonce());
- totalLength += encoder.prependByteArrayBlock(tlv::Nonce, m_nonce->data(), m_nonce->size());
+ totalLength += prependBinaryBlock(encoder, tlv::Nonce, *m_nonce);
// ForwardingHint
if (!m_forwardingHint.empty()) {
@@ -494,7 +494,7 @@
Interest&
Interest::setApplicationParameters(span<const uint8_t> value)
{
- setApplicationParametersInternal(makeBinaryBlock(tlv::ApplicationParameters, value.data(), value.size()));
+ setApplicationParametersInternal(makeBinaryBlock(tlv::ApplicationParameters, value));
addOrReplaceParametersDigestComponent();
m_wire.reset();
return *this;
diff --git a/ndn-cxx/key-locator.cpp b/ndn-cxx/key-locator.cpp
index 6cf24ac..0d35dc9 100644
--- a/ndn-cxx/key-locator.cpp
+++ b/ndn-cxx/key-locator.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -59,7 +59,7 @@
auto visitor = overload(
[] (monostate) {}, // nothing to encode, TLV-VALUE is empty
[&] (const Name& name) { totalLength += name.wireEncode(encoder); },
- [&] (const Block& digest) { totalLength += encoder.prependBlock(digest); },
+ [&] (const Block& digest) { totalLength += prependBlock(encoder, digest); },
[] (uint32_t type) { NDN_THROW(Error("Unsupported KeyLocator type " + to_string(type))); });
visit(visitor, m_locator);
diff --git a/ndn-cxx/lp/cache-policy.cpp b/ndn-cxx/lp/cache-policy.cpp
index b4f4d82..c64bd04 100644
--- a/ndn-cxx/lp/cache-policy.cpp
+++ b/ndn-cxx/lp/cache-policy.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2019 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -57,7 +57,7 @@
}
size_t length = 0;
- length += prependNonNegativeIntegerBlock(encoder, tlv::CachePolicyType, static_cast<uint32_t>(m_policy));
+ length += prependNonNegativeIntegerBlock(encoder, tlv::CachePolicyType, static_cast<uint64_t>(m_policy));
length += encoder.prependVarNumber(length);
length += encoder.prependVarNumber(tlv::CachePolicy);
return length;
@@ -103,8 +103,8 @@
}
if (it->type() == tlv::CachePolicyType) {
- m_policy = static_cast<CachePolicyType>(readNonNegativeInteger(*it));
- if (this->getPolicy() == CachePolicyType::NONE) {
+ m_policy = readNonNegativeIntegerAs<CachePolicyType>(*it);
+ if (getPolicy() == CachePolicyType::NONE) {
NDN_THROW(Error("Unknown CachePolicyType"));
}
}
diff --git a/ndn-cxx/lp/field-decl.hpp b/ndn-cxx/lp/field-decl.hpp
index 627ae13..1cb74ef 100644
--- a/ndn-cxx/lp/field-decl.hpp
+++ b/ndn-cxx/lp/field-decl.hpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2019 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -121,12 +121,9 @@
struct EncodeHelper<TAG, TlvType, EmptyValue>
{
static size_t
- encode(EncodingImpl<TAG>& encoder, const EmptyValue value)
+ encode(EncodingImpl<TAG>& encoder, EmptyValue)
{
- size_t length = 0;
- length += encoder.prependVarNumber(0);
- length += encoder.prependVarNumber(TlvType::value);
- return length;
+ return prependEmptyBlock(encoder, TlvType::value);
}
};
@@ -147,8 +144,8 @@
encode(EncodingImpl<TAG>& encoder, uint64_t value)
{
boost::endian::native_to_big_inplace(value);
- return encoder.prependByteArrayBlock(TlvType::value,
- reinterpret_cast<const uint8_t*>(&value), sizeof(value));
+ return prependBinaryBlock(encoder, TlvType::value,
+ {reinterpret_cast<const uint8_t*>(&value), sizeof(value)});
}
};
diff --git a/ndn-cxx/lp/nack-header.cpp b/ndn-cxx/lp/nack-header.cpp
index b3053be..ab1cc86 100644
--- a/ndn-cxx/lp/nack-header.cpp
+++ b/ndn-cxx/lp/nack-header.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2019 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -69,7 +69,7 @@
NackHeader::wireEncode(EncodingImpl<TAG>& encoder) const
{
size_t length = 0;
- length += prependNonNegativeIntegerBlock(encoder, tlv::NackReason, static_cast<uint32_t>(m_reason));
+ length += prependNonNegativeIntegerBlock(encoder, tlv::NackReason, static_cast<uint64_t>(m_reason));
length += encoder.prependVarNumber(length);
length += encoder.prependVarNumber(tlv::Nack);
return length;
@@ -107,10 +107,9 @@
m_reason = NackReason::NONE;
if (m_wire.elements_size() > 0) {
- Block::element_const_iterator it = m_wire.elements_begin();
-
+ auto it = m_wire.elements_begin();
if (it->type() == tlv::NackReason) {
- m_reason = static_cast<NackReason>(readNonNegativeInteger(*it));
+ m_reason = readNonNegativeIntegerAs<NackReason>(*it);
}
else {
NDN_THROW(ndn::tlv::Error("NackReason", it->type()));
diff --git a/ndn-cxx/meta-info.cpp b/ndn-cxx/meta-info.cpp
index 4315fc8..2d64691 100644
--- a/ndn-cxx/meta-info.cpp
+++ b/ndn-cxx/meta-info.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2019 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -21,7 +21,8 @@
#include "ndn-cxx/meta-info.hpp"
#include "ndn-cxx/encoding/block-helpers.hpp"
-#include "ndn-cxx/encoding/encoding-buffer.hpp"
+
+#include <boost/range/adaptor/reversed.hpp>
namespace ndn {
@@ -132,8 +133,9 @@
size_t totalLength = 0;
- for (auto it = m_appMetaInfo.rbegin(); it != m_appMetaInfo.rend(); ++it) {
- totalLength += encoder.prependBlock(*it);
+ // AppMetaInfo (in reverse order)
+ for (const auto& block : m_appMetaInfo | boost::adaptors::reversed) {
+ totalLength += prependBlock(encoder, block);
}
// FinalBlockId
@@ -181,11 +183,11 @@
m_wire = wire;
m_wire.parse();
- // MetaInfo ::= META-INFO-TYPE TLV-LENGTH
- // ContentType?
- // FreshnessPeriod?
- // FinalBlockId?
- // AppMetaInfo*
+ // MetaInfo = META-INFO-TYPE TLV-LENGTH
+ // [ContentType]
+ // [FreshnessPeriod]
+ // [FinalBlockId]
+ // *AppMetaInfo
auto val = m_wire.elements_begin();
diff --git a/ndn-cxx/name-component.cpp b/ndn-cxx/name-component.cpp
index 23f0060..61c3afe 100644
--- a/ndn-cxx/name-component.cpp
+++ b/ndn-cxx/name-component.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -366,16 +366,15 @@
Component::fromNumberWithMarker(uint8_t marker, uint64_t number)
{
EncodingEstimator estimator;
-
size_t valueLength = estimator.prependNonNegativeInteger(number);
- valueLength += estimator.prependByteArray(&marker, 1);
+ valueLength += estimator.prependBytes({marker});
size_t totalLength = valueLength;
totalLength += estimator.prependVarNumber(valueLength);
totalLength += estimator.prependVarNumber(tlv::GenericNameComponent);
EncodingBuffer encoder(totalLength, 0);
encoder.prependNonNegativeInteger(number);
- encoder.prependByteArray(&marker, 1);
+ encoder.prependBytes({marker});
encoder.prependVarNumber(valueLength);
encoder.prependVarNumber(tlv::GenericNameComponent);
@@ -523,7 +522,7 @@
{
size_t totalLength = 0;
if (value_size() > 0)
- totalLength += encoder.prependByteArray(value(), value_size());
+ totalLength += encoder.prependBytes({value(), value_size()});
totalLength += encoder.prependVarNumber(value_size());
totalLength += encoder.prependVarNumber(type());
return totalLength;
diff --git a/ndn-cxx/security/detail/certificate-bundle-decoder.cpp b/ndn-cxx/security/detail/certificate-bundle-decoder.cpp
index 19fba7f..83f94e1 100644
--- a/ndn-cxx/security/detail/certificate-bundle-decoder.cpp
+++ b/ndn-cxx/security/detail/certificate-bundle-decoder.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2020 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -45,7 +45,7 @@
while (!m_bufferedData.empty()) {
bool isOk;
Block element;
- std::tie(isOk, element) = Block::fromBuffer(m_bufferedData.data(), m_bufferedData.size());
+ std::tie(isOk, element) = Block::fromBuffer(m_bufferedData);
if (!isOk) {
return;
}
diff --git a/ndn-cxx/security/key-chain.cpp b/ndn-cxx/security/key-chain.cpp
index 0b55c91..07828cb 100644
--- a/ndn-cxx/security/key-chain.cpp
+++ b/ndn-cxx/security/key-chain.cpp
@@ -450,10 +450,8 @@
EncodingBuffer encoder;
data.wireEncode(encoder, true);
- Block sigValue(tlv::SignatureValue,
- sign({{encoder.buf(), encoder.size()}}, keyName, params.getDigestAlgorithm()));
-
- data.wireEncode(encoder, sigValue);
+ auto sigValue = sign({encoder}, keyName, params.getDigestAlgorithm());
+ data.wireEncode(encoder, *sigValue);
}
void
diff --git a/ndn-cxx/security/safe-bag.cpp b/ndn-cxx/security/safe-bag.cpp
index 7612e45..b538d02 100644
--- a/ndn-cxx/security/safe-bag.cpp
+++ b/ndn-cxx/security/safe-bag.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -60,16 +60,13 @@
size_t totalLength = 0;
// EncryptedKey
- totalLength += encoder.prependByteArrayBlock(tlv::security::EncryptedKey,
- m_encryptedKey.data(),
- m_encryptedKey.size());
+ totalLength += prependBinaryBlock(encoder, tlv::security::EncryptedKey, m_encryptedKey);
// Certificate
- totalLength += this->m_certificate.wireEncode(encoder);
+ totalLength += m_certificate.wireEncode(encoder);
totalLength += encoder.prependVarNumber(totalLength);
totalLength += encoder.prependVarNumber(tlv::security::SafeBag);
-
return totalLength;
}
diff --git a/ndn-cxx/signature-info.cpp b/ndn-cxx/signature-info.cpp
index 7c84ae3..fb062d4 100644
--- a/ndn-cxx/signature-info.cpp
+++ b/ndn-cxx/signature-info.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -75,7 +75,7 @@
// m_otherTlvs contains (if set) SignatureNonce, SignatureTime, SignatureSeqNum, ValidityPeriod,
// and AdditionalDescription, as well as any custom elements added by the user
for (const auto& block : m_otherTlvs | boost::adaptors::reversed) {
- totalLength += encoder.prependBlock(block);
+ totalLength += prependBlock(encoder, block);
}
if (m_keyLocator) {
@@ -92,10 +92,10 @@
}
template size_t
-SignatureInfo::wireEncode<encoding::EncoderTag>(encoding::EncodingBuffer&, SignatureInfo::Type) const;
+SignatureInfo::wireEncode<encoding::EncoderTag>(EncodingBuffer&, SignatureInfo::Type) const;
template size_t
-SignatureInfo::wireEncode<encoding::EstimatorTag>(encoding::EncodingEstimator&, SignatureInfo::Type) const;
+SignatureInfo::wireEncode<encoding::EstimatorTag>(EncodingEstimator&, SignatureInfo::Type) const;
const Block&
SignatureInfo::wireEncode(SignatureInfo::Type type) const
@@ -266,7 +266,8 @@
removeCustomTlv(tlv::SignatureTime);
}
else {
- addCustomTlv(makeNonNegativeIntegerBlock(tlv::SignatureTime, time::toUnixTimestamp(*time).count()));
+ addCustomTlv(makeNonNegativeIntegerBlock(tlv::SignatureTime,
+ static_cast<uint64_t>(time::toUnixTimestamp(*time).count())));
}
return *this;
}
@@ -366,7 +367,7 @@
case tlv::SignatureNonce: {
os << "Nonce=";
auto nonce = *info.getNonce();
- printHex(os, nonce.data(), nonce.size(), false);
+ printHex(os, nonce, false);
os << " ";
break;
}
diff --git a/ndn-cxx/signature-info.hpp b/ndn-cxx/signature-info.hpp
index b1dfecc..87f5531 100644
--- a/ndn-cxx/signature-info.hpp
+++ b/ndn-cxx/signature-info.hpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -237,11 +237,13 @@
operator<<(std::ostream& os, const SignatureInfo& info);
};
+#ifndef DOXYGEN
extern template size_t
SignatureInfo::wireEncode<encoding::EncoderTag>(EncodingBuffer&, SignatureInfo::Type) const;
extern template size_t
SignatureInfo::wireEncode<encoding::EstimatorTag>(EncodingEstimator&, SignatureInfo::Type) const;
+#endif
bool
operator==(const SignatureInfo& lhs, const SignatureInfo& rhs);
diff --git a/ndn-cxx/transport/detail/stream-transport-impl.hpp b/ndn-cxx/transport/detail/stream-transport-impl.hpp
index 68646d6..f11a622 100644
--- a/ndn-cxx/transport/detail/stream-transport-impl.hpp
+++ b/ndn-cxx/transport/detail/stream-transport-impl.hpp
@@ -231,7 +231,7 @@
while (offset < nBytesAvailable) {
bool isOk = false;
Block element;
- std::tie(isOk, element) = Block::fromBuffer(buffer + offset, nBytesAvailable - offset);
+ std::tie(isOk, element) = Block::fromBuffer({buffer + offset, nBytesAvailable - offset});
if (!isOk)
return false;
diff --git a/ndn-cxx/util/dummy-client-face.cpp b/ndn-cxx/util/dummy-client-face.cpp
index 017bb76..8079353 100644
--- a/ndn-cxx/util/dummy-client-face.cpp
+++ b/ndn-cxx/util/dummy-client-face.cpp
@@ -117,19 +117,16 @@
void
DummyClientFace::construct(const Options& options)
{
- static_pointer_cast<Transport>(getTransport())->onSendBlock.connect([this] (const Block& blockFromDaemon) {
- Block packet(blockFromDaemon);
+ static_pointer_cast<Transport>(getTransport())->onSendBlock.connect([this] (Block packet) {
packet.encode();
lp::Packet lpPacket(packet);
-
- Buffer::const_iterator begin, end;
- std::tie(begin, end) = lpPacket.get<lp::FragmentField>();
- Block block(&*begin, std::distance(begin, end));
+ auto frag = lpPacket.get<lp::FragmentField>();
+ Block block({frag.first, frag.second});
if (block.type() == tlv::Interest) {
- shared_ptr<Interest> interest = make_shared<Interest>(block);
+ auto interest = make_shared<Interest>(block);
if (lpPacket.has<lp::NackField>()) {
- shared_ptr<lp::Nack> nack = make_shared<lp::Nack>(std::move(*interest));
+ auto nack = make_shared<lp::Nack>(std::move(*interest));
nack->setHeader(lpPacket.get<lp::NackField>());
addTagFromField<lp::CongestionMarkTag, lp::CongestionMarkField>(*nack, lpPacket);
onSendNack(*nack);
@@ -141,7 +138,7 @@
}
}
else if (block.type() == tlv::Data) {
- shared_ptr<Data> data = make_shared<Data>(block);
+ auto data = make_shared<Data>(block);
addTagFromField<lp::CachePolicyTag, lp::CachePolicyField>(*data, lpPacket);
addTagFromField<lp::CongestionMarkTag, lp::CongestionMarkField>(*data, lpPacket);
onSendData(*data);
diff --git a/ndn-cxx/util/io.cpp b/ndn-cxx/util/io.cpp
index e3277fe..663c4e0 100644
--- a/ndn-cxx/util/io.cpp
+++ b/ndn-cxx/util/io.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -60,21 +60,20 @@
}
void
-saveBuffer(const uint8_t* buf, size_t size, std::ostream& os, IoEncoding encoding)
+saveBuffer(span<const uint8_t> buf, std::ostream& os, IoEncoding encoding)
{
namespace t = ndn::security::transform;
- auto src = make_span(buf, size);
try {
switch (encoding) {
case NO_ENCODING:
- t::bufferSource(src) >> t::streamSink(os);
+ t::bufferSource(buf) >> t::streamSink(os);
return;
case BASE64:
- t::bufferSource(src) >> t::base64Encode() >> t::streamSink(os);
+ t::bufferSource(buf) >> t::base64Encode() >> t::streamSink(os);
return;
case HEX:
- t::bufferSource(src) >> t::hexEncode(true) >> t::streamSink(os);
+ t::bufferSource(buf) >> t::hexEncode(true) >> t::streamSink(os);
return;
}
}
diff --git a/ndn-cxx/util/io.hpp b/ndn-cxx/util/io.hpp
index 7a2afd6..5d80ede 100644
--- a/ndn-cxx/util/io.hpp
+++ b/ndn-cxx/util/io.hpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -156,12 +156,13 @@
return load<T>(is, encoding);
}
-/** \brief Writes a byte buffer to a stream.
- * \throw Error error during saving
- * \throw std::invalid_argument the specified encoding is not supported
+/**
+ * \brief Writes a sequence of bytes to a stream.
+ * \throw Error error during saving
+ * \throw std::invalid_argument the specified encoding is not supported
*/
void
-saveBuffer(const uint8_t* buf, size_t size, std::ostream& os, IoEncoding encoding = BASE64);
+saveBuffer(span<const uint8_t> buf, std::ostream& os, IoEncoding encoding = BASE64);
/** \brief Writes a TLV element to a stream.
* \tparam T type of TLV element; `T` must be WireEncodable and the nested type
@@ -184,7 +185,7 @@
NDN_THROW_NESTED(Error("Encode error during save: "s + e.what()));
}
- saveBuffer(block.wire(), block.size(), os, encoding);
+ saveBuffer({block.wire(), block.size()}, os, encoding);
}
/** \brief Writes a TLV element to a file.
diff --git a/ndn-cxx/util/sqlite3-statement.cpp b/ndn-cxx/util/sqlite3-statement.cpp
index 4426a02..709ea51 100644
--- a/ndn-cxx/util/sqlite3-statement.cpp
+++ b/ndn-cxx/util/sqlite3-statement.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2019 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -47,7 +47,7 @@
int
Sqlite3Statement::bind(int index, const std::string& value, void(*destructor)(void*))
{
- return sqlite3_bind_text(m_stmt, index, value.c_str(), value.size(), destructor);
+ return sqlite3_bind_text(m_stmt, index, value.data(), value.size(), destructor);
}
int
@@ -78,8 +78,8 @@
Block
Sqlite3Statement::getBlock(int column)
{
- return Block(reinterpret_cast<const uint8_t*>(sqlite3_column_blob(m_stmt, column)),
- sqlite3_column_bytes(m_stmt, column));
+ return Block(make_span(reinterpret_cast<const uint8_t*>(sqlite3_column_blob(m_stmt, column)),
+ sqlite3_column_bytes(m_stmt, column)));
}
int
@@ -88,7 +88,6 @@
return sqlite3_column_int(m_stmt, column);
}
-
const uint8_t*
Sqlite3Statement::getBlob(int column)
{
diff --git a/tests/unit/data.t.cpp b/tests/unit/data.t.cpp
index 2ab660e..153c471 100644
--- a/tests/unit/data.t.cpp
+++ b/tests/unit/data.t.cpp
@@ -284,7 +284,7 @@
BOOST_AUTO_TEST_CASE(Full)
{
- d.wireDecode(Block(DATA1, sizeof(DATA1)));
+ d.wireDecode(Block(DATA1));
BOOST_CHECK_EQUAL(d.getName(), "/local/ndn/prefix");
BOOST_CHECK_EQUAL(d.getContentType(), tlv::ContentType_Blob);
BOOST_CHECK_EQUAL(d.getFreshnessPeriod(), 10_s);
@@ -415,7 +415,7 @@
d.setFreshnessPeriod(100_s); // invalidates FullName
BOOST_CHECK_THROW(d.getFullName(), Data::Error);
- Data d1(Block(DATA1, sizeof(DATA1)));
+ Data d1(Block{DATA1});
BOOST_CHECK_EQUAL(d1.getFullName(),
"/local/ndn/prefix/"
"sha256digest=28bad4b5275bd392dbb670c75cf0b66f13f7942b21e80f55c0e86b374753a548");
@@ -518,7 +518,7 @@
// Block overload, nested inside Content element
const uint8_t nested[] = {0x99, 0x02, 0xca, 0xfe};
- d.setContent(Block(nested, sizeof(nested)));
+ d.setContent(Block(nested));
BOOST_CHECK_EQUAL(d.hasContent(), true);
BOOST_CHECK_EQUAL(d.getContent().type(), tlv::Content);
BOOST_CHECK_EQUAL_COLLECTIONS(d.getContent().value_begin(), d.getContent().value_end(),
@@ -597,8 +597,7 @@
0x17, 0x00, // SignatureValue
0xAA, 0x00 // Unrecognized non-critical element
};
- Block wire2(WIRE, sizeof(WIRE));
- Data d2(wire2);
+ Data d2(Block{WIRE});
auto ranges2 = d2.extractSignedRanges();
BOOST_REQUIRE_EQUAL(ranges2.size(), 1);
BOOST_CHECK_EQUAL_COLLECTIONS(ranges2.front().begin(), ranges2.front().end(), &WIRE[2], &WIRE[9]);
@@ -651,7 +650,7 @@
BOOST_AUTO_TEST_CASE(Print)
{
- Data d1(Block(DATA1, sizeof(DATA1)));
+ Data d1(Block{DATA1});
BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(d1),
"Name: /local/ndn/prefix\n"
"MetaInfo: [ContentType: 0, FreshnessPeriod: 10000 milliseconds]\n"
diff --git a/tests/unit/encoding/block-helpers.t.cpp b/tests/unit/encoding/block-helpers.t.cpp
index 2ca1e02..9325851 100644
--- a/tests/unit/encoding/block-helpers.t.cpp
+++ b/tests/unit/encoding/block-helpers.t.cpp
@@ -108,18 +108,43 @@
std::list<uint8_t> buf3{1, 1, 1, 1};
Block b1 = makeBinaryBlock(100, buf1.data(), buf1.size()); // char* overload
- Block b2 = makeBinaryBlock(100, buf2, sizeof(buf2)); // uint8_t* overload
- Block b3 = makeBinaryBlock(100, buf2); // span overload
- Block b4 = makeBinaryBlock(100, buf1.begin(), buf1.end()); // fast encoding (random access iterator)
- Block b5 = makeBinaryBlock(100, buf3.begin(), buf3.end()); // slow encoding (general iterator)
+ Block b2 = makeBinaryBlock(100, buf2); // span overload
+ Block b3 = makeBinaryBlock(100, buf1.begin(), buf1.end()); // fast encoding (random access iterator)
+ Block b4 = makeBinaryBlock(100, buf3.begin(), buf3.end()); // slow encoding (general iterator)
BOOST_CHECK_EQUAL(b1, b2);
BOOST_CHECK_EQUAL(b1, b3);
BOOST_CHECK_EQUAL(b1, b4);
- BOOST_CHECK_EQUAL(b1, b5);
BOOST_CHECK_EQUAL(b1.type(), 100);
BOOST_CHECK_EQUAL(b1.value_size(), buf1.size());
BOOST_CHECK_EQUAL_COLLECTIONS(b1.value_begin(), b1.value_end(), buf2, buf2 + sizeof(buf2));
+
+ EncodingEstimator estimator;
+ size_t length = prependBinaryBlock(estimator, 100, buf2);
+ BOOST_CHECK_EQUAL(length, 6);
+
+ EncodingBuffer encoder(length, 0);
+ BOOST_CHECK_EQUAL(prependBinaryBlock(encoder, 100, buf2), 6);
+ BOOST_CHECK_EQUAL(encoder.block(), b1);
+}
+
+BOOST_AUTO_TEST_CASE(PrependBlock)
+{
+ EncodingEstimator estimator;
+ Block b1({0x01, 0x03, 0x00, 0x00, 0x00});
+ size_t length = prependBlock(estimator, b1);
+ BOOST_CHECK_EQUAL(length, 5);
+ Block b2(100, b1);
+ length += prependBlock(estimator, b2);
+ BOOST_CHECK_EQUAL(length, 12);
+
+ EncodingBuffer encoder(length, 0);
+ BOOST_CHECK_EQUAL(prependBlock(encoder, b1), 5);
+ BOOST_CHECK_EQUAL(prependBlock(encoder, b2), 7);
+ BOOST_CHECK_EQUAL(encoder.size(), 12);
+ encoder.prependVarNumber(encoder.size());
+ encoder.prependVarNumber(200);
+ BOOST_CHECK_EQUAL(encoder.block(), "C80C 64050103000000 0103000000"_block);
}
BOOST_AUTO_TEST_CASE(Nested)
diff --git a/tests/unit/encoding/block.t.cpp b/tests/unit/encoding/block.t.cpp
index b6a841b..a39df87 100644
--- a/tests/unit/encoding/block.t.cpp
+++ b/tests/unit/encoding/block.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -68,7 +68,7 @@
BOOST_CHECK_THROW(Block{encoder}, tlv::Error);
const uint8_t VALUE[] = {0x11, 0x12, 0x13, 0x14};
- size_t length = encoder.prependByteArray(VALUE, sizeof(VALUE));
+ size_t length = encoder.prependBytes(VALUE);
encoder.prependVarNumber(length);
encoder.prependVarNumber(0xe0);
@@ -87,18 +87,18 @@
BOOST_AUTO_TEST_CASE(FromBlock)
{
- const uint8_t BUFFER[] = {0x80, 0x06, 0x81, 0x01, 0x01, 0x82, 0x01, 0x01};
- Block block(BUFFER, sizeof(BUFFER));
+ const uint8_t buf[] = {0x80, 0x06, 0x81, 0x01, 0x01, 0x82, 0x01, 0x01};
+ Block block(buf);
Block derivedBlock(block, block.begin(), block.end());
BOOST_CHECK_EQUAL(derivedBlock.wire(), block.wire()); // pointers should match
- BOOST_CHECK(derivedBlock == block); // blocks should match
+ BOOST_CHECK_EQUAL(derivedBlock, block); // blocks should match
derivedBlock = Block(block, block.begin() + 2, block.begin() + 5);
BOOST_CHECK(derivedBlock.begin() == block.begin() + 2);
- BOOST_CHECK(derivedBlock == Block(BUFFER + 2, 3));
+ BOOST_CHECK_EQUAL(derivedBlock, Block(make_span(buf + 2, 3)));
- Buffer otherBuffer(BUFFER, sizeof(BUFFER));
+ Buffer otherBuffer(buf, sizeof(buf));
BOOST_CHECK_THROW(Block(block, otherBuffer.begin(), block.end()), std::invalid_argument);
BOOST_CHECK_THROW(Block(block, block.begin(), otherBuffer.end()), std::invalid_argument);
BOOST_CHECK_THROW(Block(block, otherBuffer.begin(), otherBuffer.end()), std::invalid_argument);
@@ -106,11 +106,11 @@
BOOST_AUTO_TEST_CASE(FromBlockCopyOnWriteModifyOriginal)
{
- const uint8_t BUFFER[] = {
+ const uint8_t buf[] = {
0x05, 0x0b, 0x07, 0x03, 0x01, 0x02, 0x03, 0x0a, 0x04, 0x04, 0x05, 0x06, 0x07,
};
- Block b1(BUFFER, sizeof(BUFFER));
+ Block b1(buf);
Block b2(b1, b1.begin(), b1.end());
auto buf2 = b2.getBuffer();
@@ -121,17 +121,17 @@
b2.parse();
- BOOST_CHECK_EQUAL_COLLECTIONS(b2.begin(), b2.end(), BUFFER, BUFFER + sizeof(BUFFER));
+ BOOST_CHECK_EQUAL_COLLECTIONS(b2.begin(), b2.end(), buf, buf + sizeof(buf));
BOOST_CHECK_EQUAL(buf2, b2.getBuffer());
}
BOOST_AUTO_TEST_CASE(FromBlockCopyOnWriteModifyCopy)
{
- const uint8_t BUFFER[] = {
+ const uint8_t buf[] = {
0x05, 0x0b, 0x07, 0x03, 0x01, 0x02, 0x03, 0x0a, 0x04, 0x04, 0x05, 0x06, 0x07,
};
- Block b1(BUFFER, sizeof(BUFFER));
+ Block b1(buf);
auto buf1 = b1.getBuffer();
Block b2(b1, b1.begin(), b1.end());
@@ -141,7 +141,7 @@
b2.encode();
b1.parse();
- BOOST_CHECK_EQUAL_COLLECTIONS(b1.begin(), b1.end(), BUFFER, BUFFER + sizeof(BUFFER));
+ BOOST_CHECK_EQUAL_COLLECTIONS(b1.begin(), b1.end(), buf, buf + sizeof(buf));
BOOST_CHECK_EQUAL(buf1, b1.getBuffer());
}
@@ -177,7 +177,7 @@
BOOST_AUTO_TEST_CASE(FromTypeAndBuffer)
{
const uint8_t VALUE[] = {0x11, 0x12, 0x13, 0x14};
- auto bufferPtr = make_shared<Buffer>(VALUE, sizeof(VALUE));
+ auto bufferPtr = std::make_shared<Buffer>(VALUE, sizeof(VALUE));
Block b1(42, std::move(bufferPtr));
BOOST_CHECK_EQUAL(b1.isValid(), true);
@@ -188,7 +188,7 @@
BOOST_CHECK(b1.value() != nullptr);
// empty buffer as TLV-VALUE
- Block b2(63, make_shared<Buffer>());
+ Block b2(63, std::make_shared<Buffer>());
BOOST_CHECK_EQUAL(b2.isValid(), true);
BOOST_CHECK_EQUAL(b2.type(), 63);
BOOST_CHECK_EQUAL(b2.size(), 2);
@@ -199,15 +199,15 @@
BOOST_AUTO_TEST_CASE(FromTypeAndBlock)
{
- const uint8_t BUFFER[] = {0x80, 0x06, 0x81, 0x01, 0x01, 0x82, 0x01, 0x01};
- Block nested(BUFFER, sizeof(BUFFER));
+ const uint8_t buf[] = {0x80, 0x06, 0x81, 0x01, 0x01, 0x82, 0x01, 0x01};
+ Block nested(buf);
Block b(84, nested);
BOOST_CHECK_EQUAL(b.isValid(), true);
BOOST_CHECK_EQUAL(b.type(), 84);
BOOST_CHECK_EQUAL(b.size(), 10);
BOOST_CHECK_EQUAL(b.hasValue(), true);
- BOOST_CHECK_EQUAL(b.value_size(), sizeof(BUFFER));
+ BOOST_CHECK_EQUAL(b.value_size(), sizeof(buf));
BOOST_CHECK(b.value() != nullptr);
}
@@ -322,19 +322,18 @@
BOOST_AUTO_TEST_CASE(FromWireBuffer)
{
- auto buffer = make_shared<Buffer>(TEST_BUFFER, sizeof(TEST_BUFFER));
+ auto buffer = std::make_shared<Buffer>(TEST_BUFFER, sizeof(TEST_BUFFER));
- size_t offset = 0;
bool isOk = false;
Block b;
- std::tie(isOk, b) = Block::fromBuffer(buffer, offset);
+ std::tie(isOk, b) = Block::fromBuffer(buffer);
BOOST_CHECK(isOk);
BOOST_CHECK_EQUAL(b.type(), 66);
BOOST_CHECK_EQUAL(b.size(), 3);
BOOST_CHECK_EQUAL(b.value_size(), 1);
BOOST_CHECK_EQUAL(*b.wire(), 0x42);
BOOST_CHECK_EQUAL(*b.value(), 0xfa);
- offset += b.size();
+ size_t offset = b.size();
std::tie(isOk, b) = Block::fromBuffer(buffer, offset);
BOOST_CHECK(isOk);
@@ -356,19 +355,18 @@
BOOST_AUTO_TEST_CASE(FromRawBuffer)
{
- size_t offset = 0;
bool isOk = false;
Block b;
- std::tie(isOk, b) = Block::fromBuffer(TEST_BUFFER + offset, sizeof(TEST_BUFFER) - offset);
+ std::tie(isOk, b) = Block::fromBuffer(TEST_BUFFER);
BOOST_CHECK(isOk);
BOOST_CHECK_EQUAL(b.type(), 66);
BOOST_CHECK_EQUAL(b.size(), 3);
BOOST_CHECK_EQUAL(b.value_size(), 1);
BOOST_CHECK_EQUAL(*b.wire(), 0x42);
BOOST_CHECK_EQUAL(*b.value(), 0xfa);
- offset += b.size();
+ auto offset = b.size();
- std::tie(isOk, b) = Block::fromBuffer(TEST_BUFFER + offset, sizeof(TEST_BUFFER) - offset);
+ std::tie(isOk, b) = Block::fromBuffer(make_span(TEST_BUFFER).subspan(offset));
BOOST_CHECK(isOk);
BOOST_CHECK_EQUAL(b.type(), 1);
BOOST_CHECK_EQUAL(b.size(), 3);
@@ -377,7 +375,7 @@
BOOST_CHECK_EQUAL(*b.value(), 0xfb);
offset += b.size();
- std::tie(isOk, b) = Block::fromBuffer(TEST_BUFFER + offset, sizeof(TEST_BUFFER) - offset);
+ std::tie(isOk, b) = Block::fromBuffer(make_span(TEST_BUFFER).subspan(offset));
BOOST_CHECK(isOk);
BOOST_CHECK_EQUAL(b.type(), 0xffffffff);
BOOST_CHECK_EQUAL(b.size(), 6);
@@ -395,8 +393,8 @@
BOOST_DATA_TEST_CASE(Malformed, MalformedInputs)
{
- // constructor from raw buffer
- BOOST_CHECK_THROW(Block(sample.data(), sample.size()), tlv::Error);
+ // constructor from span
+ BOOST_CHECK_THROW(Block{sample}, tlv::Error);
// fromStream()
std::stringstream stream;
@@ -405,15 +403,15 @@
BOOST_CHECK_THROW(Block::fromStream(stream), tlv::Error);
// fromBuffer(), ConstBufferPtr overload
- auto buf = make_shared<Buffer>(sample.begin(), sample.end());
+ auto buf = std::make_shared<Buffer>(sample.begin(), sample.end());
bool isOk;
Block b;
- std::tie(isOk, b) = Block::fromBuffer(buf, 0);
+ std::tie(isOk, b) = Block::fromBuffer(buf);
BOOST_CHECK(!isOk);
BOOST_CHECK(!b.isValid());
- // fromBuffer(), raw buffer overload
- std::tie(isOk, b) = Block::fromBuffer(sample.data(), sample.size());
+ // fromBuffer(), span overload
+ std::tie(isOk, b) = Block::fromBuffer(sample);
BOOST_CHECK(!isOk);
BOOST_CHECK(!b.isValid());
}
@@ -427,7 +425,7 @@
return e.what() == "Cannot construct block from empty TLV-VALUE"s;
});
- Block b2(302, make_shared<Buffer>());
+ Block b2(302, std::make_shared<Buffer>());
BOOST_CHECK_EXCEPTION(b2.blockFromValue(), Block::Error, [] (const auto& e) {
return e.what() == "Cannot construct block from empty TLV-VALUE"s;
});
@@ -459,7 +457,7 @@
0x1c, 0x00, // KeyLocator empty
0x17, 0x00 // SignatureValue empty
};
- Block data(PACKET, sizeof(PACKET));
+ Block data(PACKET);
data.parse();
BOOST_CHECK_EQUAL(data.elements_size(), 5);
@@ -478,7 +476,7 @@
// TLV-LENGTH of nested element is greater than TLV-LENGTH of enclosing element
0x05, 0x05, 0x07, 0x07, 0x08, 0x05, 0x68, 0x65, 0x6c, 0x6c, 0x6f
};
- Block bad(MALFORMED, sizeof(MALFORMED));
+ Block bad(MALFORMED);
BOOST_CHECK_EXCEPTION(bad.parse(), Block::Error, [] (const auto& e) {
return e.what() == "TLV-LENGTH of sub-element of type 7 exceeds TLV-VALUE boundary of parent block"s;
});
@@ -634,20 +632,20 @@
BOOST_AUTO_TEST_CASE(Equality)
{
const uint8_t one[] = {0x08, 0x00};
- Block a(one, sizeof(one));
- Block b(one, sizeof(one));
+ Block a(one);
+ Block b(one);
BOOST_CHECK_EQUAL(a == b, true);
BOOST_CHECK_EQUAL(a != b, false);
const uint8_t two[] = {0x06, 0x00};
- Block c(two, sizeof(two));
- Block d(one, sizeof(one));
+ Block c(two);
+ Block d(one);
BOOST_CHECK_EQUAL(c == d, false);
BOOST_CHECK_EQUAL(c != d, true);
const uint8_t three[] = {0x06, 0x01, 0xcc};
- Block e(two, sizeof(two));
- Block f(three, sizeof(three));
+ Block e(two);
+ Block f(three);
BOOST_CHECK_EQUAL(e == f, false);
BOOST_CHECK_EQUAL(e != f, true);
}
diff --git a/tests/unit/encoding/encoder.t.cpp b/tests/unit/encoding/encoder.t.cpp
index 3f5fe8e..57a1f3d 100644
--- a/tests/unit/encoding/encoder.t.cpp
+++ b/tests/unit/encoding/encoder.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2018 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -41,14 +41,16 @@
Encoder e2(100, 100);
BOOST_CHECK_EQUAL(e2.capacity(), 100);
- BOOST_CHECK_EQUAL(e.prependByte(1), 1);
- BOOST_CHECK_EQUAL(e.appendByte(1), 1);
+ BOOST_CHECK_EQUAL(e.prependBytes({1}), 1);
+ BOOST_CHECK_EQUAL(e.appendBytes({1}), 1);
- uint8_t buf1[] = {'t', 'e', 's', 't', '1'};
- BOOST_CHECK_EQUAL(e1.prependByteArray(buf1, sizeof(buf1)), 5);
- BOOST_CHECK_EQUAL(e1.appendByteArray(buf1, sizeof(buf1)), 5);
+ const uint8_t buf1[] = {'t', 'e', 's', 't', '1'};
+ BOOST_CHECK_EQUAL(e1.prependBytes(buf1), 5);
+ BOOST_CHECK_EQUAL(e1.appendBytes(buf1), 5);
std::vector<uint8_t> buf2 = {'t', 'e', 's', 't', '2'};
+ BOOST_CHECK_EQUAL(e2.prependBytes(buf2), 5);
+ BOOST_CHECK_EQUAL(e2.appendBytes(buf2), 5);
BOOST_CHECK_EQUAL(e1.prependRange(buf2.begin(), buf2.end()), 5);
BOOST_CHECK_EQUAL(e1.appendRange(buf2.begin(), buf2.end()), 5);
@@ -56,17 +58,16 @@
BOOST_CHECK_EQUAL(e2.prependRange(buf3.begin(), buf3.end()), 5);
BOOST_CHECK_EQUAL(e2.appendRange(buf3.begin(), buf3.end()), 5);
- uint8_t expected1[] = {1, 1};
- BOOST_CHECK_EQUAL_COLLECTIONS(e.buf(), e.buf() + e.size(),
+ const uint8_t expected1[] = {1, 1};
+ BOOST_CHECK_EQUAL_COLLECTIONS(e.data(), e.data() + e.size(),
expected1, expected1 + sizeof(expected1));
const Encoder& constE = e;
- BOOST_CHECK_EQUAL_COLLECTIONS(constE.buf(), constE.buf() + constE.size(),
+ BOOST_CHECK_EQUAL_COLLECTIONS(constE.data(), constE.data() + constE.size(),
expected1, expected1 + sizeof(expected1));
- uint8_t expected2[] = {'t', 'e', 's', 't', '2',
- 't', 'e', 's', 't', '1', 't', 'e', 's', 't', '1',
- 't', 'e', 's', 't', '2'};
+ const uint8_t expected2[] = {'t', 'e', 's', 't', '2', 't', 'e', 's', 't', '1',
+ 't', 'e', 's', 't', '1', 't', 'e', 's', 't', '2'};
BOOST_CHECK_EQUAL_COLLECTIONS(e1.begin(), e1.end(),
expected2, expected2 + sizeof(expected2));
const Encoder& constE1 = e1;
@@ -129,19 +130,16 @@
//
- uint8_t buf[] = {0x01, 0x03, 0x00, 0x00, 0x00};
- Block block1(buf, sizeof(buf));
-
- BOOST_CHECK_EQUAL(e.prependByteArrayBlock(100, buf, sizeof(buf)), 7);
- BOOST_CHECK_EQUAL(e.appendByteArrayBlock(100, buf, sizeof(buf)), 7);
-
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+ Block block1({0x01, 0x03, 0x00, 0x00, 0x00});
BOOST_CHECK_EQUAL(e.prependBlock(block1), 5);
BOOST_CHECK_EQUAL(e.appendBlock(block1), 5);
Block block2(100, block1);
-
BOOST_CHECK_EQUAL(e.prependBlock(block2), 7);
BOOST_CHECK_EQUAL(e.appendBlock(block2), 7);
+#pragma GCC diagnostic pop
}
BOOST_AUTO_TEST_CASE(Reserve)
diff --git a/tests/unit/encoding/estimator.t.cpp b/tests/unit/encoding/estimator.t.cpp
index f5e4392..d4ecbaf 100644
--- a/tests/unit/encoding/estimator.t.cpp
+++ b/tests/unit/encoding/estimator.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2018 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -34,14 +34,16 @@
{
Estimator e;
- BOOST_CHECK_EQUAL(e.prependByte(1), 1);
- BOOST_CHECK_EQUAL(e.appendByte(1), 1);
+ BOOST_CHECK_EQUAL(e.prependBytes({1}), 1);
+ BOOST_CHECK_EQUAL(e.appendBytes({1}), 1);
- uint8_t buf1[] = {'t', 'e', 's', 't', '1'};
- BOOST_CHECK_EQUAL(e.prependByteArray(buf1, sizeof(buf1)), 5);
- BOOST_CHECK_EQUAL(e.appendByteArray(buf1, sizeof(buf1)), 5);
+ const uint8_t buf1[] = {'t', 'e', 's', 't', '1'};
+ BOOST_CHECK_EQUAL(e.prependBytes(buf1), 5);
+ BOOST_CHECK_EQUAL(e.appendBytes(buf1), 5);
std::vector<uint8_t> buf2 = {'t', 'e', 's', 't', '2'};
+ BOOST_CHECK_EQUAL(e.prependBytes(buf2), 5);
+ BOOST_CHECK_EQUAL(e.appendBytes(buf2), 5);
BOOST_CHECK_EQUAL(e.prependRange(buf2.begin(), buf2.end()), 5);
BOOST_CHECK_EQUAL(e.appendRange(buf2.begin(), buf2.end()), 5);
@@ -97,19 +99,16 @@
//
- uint8_t buf[] = {0x01, 0x03, 0x00, 0x00, 0x00};
- Block block1(buf, sizeof(buf));
-
- BOOST_CHECK_EQUAL(e.prependByteArrayBlock(100, buf, sizeof(buf)), 7);
- BOOST_CHECK_EQUAL(e.appendByteArrayBlock(100, buf, sizeof(buf)), 7);
-
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+ Block block1({0x01, 0x03, 0x00, 0x00, 0x00});
BOOST_CHECK_EQUAL(e.prependBlock(block1), 5);
BOOST_CHECK_EQUAL(e.appendBlock(block1), 5);
Block block2(100, block1);
-
BOOST_CHECK_EQUAL(e.prependBlock(block2), 7);
BOOST_CHECK_EQUAL(e.appendBlock(block2), 7);
+#pragma GCC diagnostic pop
}
BOOST_AUTO_TEST_SUITE_END() // TestEstimator
diff --git a/tests/unit/interest.t.cpp b/tests/unit/interest.t.cpp
index d36e0a9..ff50e8a 100644
--- a/tests/unit/interest.t.cpp
+++ b/tests/unit/interest.t.cpp
@@ -241,7 +241,7 @@
si.setNonce(nonce);
Block sv("2E20 12471AE0F8723AC1156C370A38711EBEBF2817DE9B2DD94E9B7E62F117B876C1"_block);
- Interest i1(Block(WIRE, sizeof(WIRE)));
+ Interest i1(Block{WIRE});
BOOST_CHECK_EQUAL(i1.getName(),
"/local/ndn/prefix/params-sha256=6f29586053ee9fccd8a422122925287c0a18435f4074c40abb0d5b30e4aa6220");
BOOST_CHECK_EQUAL(i1.getCanBePrefix(), false);
@@ -319,7 +319,7 @@
si.setNonce(nonce);
Block sv("2E20 12471AE0F8723AC1156C370A38711EBEBF2817DE9B2DD94E9B7E62F117B876C1"_block);
- Interest i1(Block(WIRE, sizeof(WIRE)));
+ Interest i1(Block{WIRE});
BOOST_CHECK_EQUAL(i1.getName(),
"/local/ndn/prefix/params-sha256=bc3630a4d65e0db5483dfa0d28b3312fcac1d441ec8961d4175e61751778108e");
BOOST_CHECK_EQUAL(i1.getCanBePrefix(), false);
@@ -1125,7 +1125,7 @@
0xbf, 0x28, 0x17, 0xde, 0x9b, 0x2d, 0xd9, 0x4e,
0x9b, 0x7e, 0x62, 0xf1, 0x17, 0xb8, 0x76, 0xc1,
};
- Block wire3(WIRE, sizeof(WIRE));
+ Block wire3(WIRE);
Interest i2(wire3);
auto ranges3 = i2.extractSignedRanges();
BOOST_REQUIRE_EQUAL(ranges3.size(), 2);
diff --git a/tests/unit/link.t.cpp b/tests/unit/link.t.cpp
index 2d7fa9c..fe4b45c 100644
--- a/tests/unit/link.t.cpp
+++ b/tests/unit/link.t.cpp
@@ -77,7 +77,7 @@
BOOST_AUTO_TEST_CASE(Decode)
{
- Link link(Block(GOOD_LINK, sizeof(GOOD_LINK)));
+ Link link(Block{GOOD_LINK});
BOOST_CHECK_EQUAL(link.getName(), Name("/local/ndn/prefix"));
BOOST_TEST(link.getDelegationList() == std::vector<Name>({"/local", "/ndn"}),
boost::test_tools::per_element());
@@ -85,11 +85,11 @@
BOOST_AUTO_TEST_CASE(DecodeBadContentType)
{
- Data linkData(Block(GOOD_LINK, sizeof(GOOD_LINK)));
+ Data linkData(Block{GOOD_LINK});
linkData.setContentType(tlv::ContentType_Key);
Block badLink = linkData.wireEncode();
- BOOST_CHECK_THROW((Link(badLink)), Link::Error);
+ BOOST_CHECK_THROW(Link{badLink}, Link::Error);
Link link;
BOOST_CHECK_THROW(link.wireDecode(badLink), Link::Error);
}
diff --git a/tests/unit/lp/cache-policy.t.cpp b/tests/unit/lp/cache-policy.t.cpp
index 78c1548..8b27a6c 100644
--- a/tests/unit/lp/cache-policy.t.cpp
+++ b/tests/unit/lp/cache-policy.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2018 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -38,10 +38,10 @@
policy.setPolicy(CachePolicyType::NO_CACHE);
Block wire;
- BOOST_REQUIRE_NO_THROW(wire = policy.wireEncode());
+ BOOST_CHECK_NO_THROW(wire = policy.wireEncode());
// Sample encoded value obtained with:
- // for (Buffer::const_iterator it = wire.begin(); it != wire.end(); ++it) {
+ // for (auto it = wire.begin(); it != wire.end(); ++it) {
// printf("0x%02x, ", *it);
// }
@@ -53,40 +53,31 @@
BOOST_CHECK_EQUAL_COLLECTIONS(expectedBlock, expectedBlock + sizeof(expectedBlock),
wire.begin(), wire.end());
- BOOST_REQUIRE_NO_THROW(policy.wireDecode(wire));
+ BOOST_CHECK_NO_THROW(policy.wireDecode(wire));
}
BOOST_AUTO_TEST_CASE(DecodeUnknownPolicyError)
{
- static const uint8_t expectedBlock[] = {
- 0xfd, 0x03, 0x34, 0x08, 0xfd, 0x03, 0x35, 0x04, 0xff, 0xff, 0xff, 0xff
- };
+ const Block wire({0xfd, 0x03, 0x34, 0x08, 0xfd, 0x03, 0x35, 0x04, 0x1f, 0xff, 0xff, 0xff});
CachePolicy policy;
- Block wire(expectedBlock, sizeof(expectedBlock));
- BOOST_REQUIRE_THROW(policy.wireDecode(wire), CachePolicy::Error);
+ BOOST_CHECK_THROW(policy.wireDecode(wire), CachePolicy::Error);
}
BOOST_AUTO_TEST_CASE(DecodeMissingPolicyError)
{
- static const uint8_t inputBlock[] = {
- 0xfd, 0x03, 0x34, 0x00
- };
+ const Block wire({0xfd, 0x03, 0x34, 0x00});
CachePolicy policy;
- Block wire(inputBlock, sizeof(inputBlock));
- BOOST_REQUIRE_THROW(policy.wireDecode(wire), CachePolicy::Error);
+ BOOST_CHECK_THROW(policy.wireDecode(wire), CachePolicy::Error);
}
BOOST_AUTO_TEST_CASE(DecodeInvalidPolicyError)
{
- static const uint8_t inputBlock[] = {
- 0xfd, 0x03, 0x34, 0x05, 0xfd, 0x03, 0x35, 0x01, 0x00
- };
+ const Block wire({0xfd, 0x03, 0x34, 0x05, 0xfd, 0x03, 0x35, 0x01, 0x00});
CachePolicy policy;
- Block wire(inputBlock, sizeof(inputBlock));
- BOOST_REQUIRE_THROW(policy.wireDecode(wire), CachePolicy::Error);
+ BOOST_CHECK_THROW(policy.wireDecode(wire), CachePolicy::Error);
}
BOOST_AUTO_TEST_CASE(Policy)
diff --git a/tests/unit/lp/nack-header.t.cpp b/tests/unit/lp/nack-header.t.cpp
index 4670608..c914eb0 100644
--- a/tests/unit/lp/nack-header.t.cpp
+++ b/tests/unit/lp/nack-header.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2018 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -50,10 +50,10 @@
header.setReason(NackReason::DUPLICATE);
Block wire;
- BOOST_REQUIRE_NO_THROW(wire = header.wireEncode());
+ BOOST_CHECK_NO_THROW(wire = header.wireEncode());
// Sample encoded value obtained with:
- // for (Buffer::const_iterator it = wire.begin(); it != wire.end(); ++it) {
+ // for (auto it = wire.begin(); it != wire.end(); ++it) {
// printf("0x%02x, ", *it);
// }
@@ -65,20 +65,20 @@
BOOST_CHECK_EQUAL_COLLECTIONS(expectedBlock, expectedBlock + sizeof(expectedBlock),
wire.begin(), wire.end());
- BOOST_REQUIRE_NO_THROW(header.wireDecode(wire));
+ BOOST_CHECK_NO_THROW(header.wireDecode(wire));
}
BOOST_AUTO_TEST_CASE(DecodeUnknownReasonCode)
{
static const uint8_t expectedBlock[] = {
- 0xfd, 0x03, 0x20, 0x08, 0xfd, 0x03, 0x21, 0x04, 0xff, 0xff, 0xff, 0xff,
+ 0xfd, 0x03, 0x20, 0x08, 0xfd, 0x03, 0x21, 0x04, 0x1f, 0xff, 0xff, 0xff,
};
NackHeader header;
- Block wire(expectedBlock, sizeof(expectedBlock));
- BOOST_REQUIRE_NO_THROW(header.wireDecode(wire));
+ Block wire(expectedBlock);
+ BOOST_CHECK_NO_THROW(header.wireDecode(wire));
Block wireEncoded;
- BOOST_REQUIRE_NO_THROW(wireEncoded = header.wireEncode());
+ BOOST_CHECK_NO_THROW(wireEncoded = header.wireEncode());
BOOST_CHECK_EQUAL_COLLECTIONS(expectedBlock, expectedBlock + sizeof(expectedBlock),
wireEncoded.begin(), wireEncoded.end());
BOOST_CHECK_EQUAL(header.getReason(), NackReason::NONE);
@@ -91,10 +91,10 @@
};
NackHeader header;
- Block wire(expectedBlock, sizeof(expectedBlock));
- BOOST_REQUIRE_NO_THROW(header.wireDecode(wire));
+ Block wire(expectedBlock);
+ BOOST_CHECK_NO_THROW(header.wireDecode(wire));
Block wireEncoded;
- BOOST_REQUIRE_NO_THROW(wireEncoded = header.wireEncode());
+ BOOST_CHECK_NO_THROW(wireEncoded = header.wireEncode());
BOOST_CHECK_EQUAL_COLLECTIONS(expectedBlock, expectedBlock + sizeof(expectedBlock),
wireEncoded.begin(), wireEncoded.end());
BOOST_CHECK_EQUAL(header.getReason(), NackReason::NONE);
diff --git a/tests/unit/lp/packet.t.cpp b/tests/unit/lp/packet.t.cpp
index 5f750c3..7763f06 100644
--- a/tests/unit/lp/packet.t.cpp
+++ b/tests/unit/lp/packet.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2020 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -197,7 +197,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
packet.wireDecode(wire);
BOOST_CHECK_EQUAL(packet.count<FragIndexField>(), 1);
@@ -231,7 +231,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
packet.wireDecode(wire);
BOOST_CHECK_EQUAL(0, packet.count<FragmentField>());
BOOST_CHECK_EQUAL(1, packet.count<FragIndexField>());
@@ -249,7 +249,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
packet.wireDecode(wire);
BOOST_CHECK_EQUAL(1, packet.count<FragmentField>());
BOOST_CHECK_EQUAL(0, packet.count<FragIndexField>());
@@ -268,7 +268,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
packet.wireDecode(wire);
BOOST_CHECK_EQUAL(true, packet.has<NonDiscoveryField>());
packet.get<NonDiscoveryField>();
@@ -281,7 +281,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
packet.wireDecode(wire);
BOOST_CHECK_EQUAL(0, packet.count<FragmentField>());
BOOST_CHECK_EQUAL(0, packet.count<FragIndexField>());
@@ -299,7 +299,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
BOOST_CHECK_THROW(packet.wireDecode(wire), Packet::Error);
}
@@ -314,7 +314,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
BOOST_CHECK_THROW(packet.wireDecode(wire), Packet::Error);
}
@@ -331,7 +331,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
BOOST_CHECK_THROW(packet.wireDecode(wire), Packet::Error);
}
@@ -348,7 +348,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
BOOST_CHECK_THROW(packet.wireDecode(wire), Packet::Error);
}
@@ -365,7 +365,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
packet.wireDecode(wire);
BOOST_CHECK_EQUAL(1, packet.count<FragmentField>());
BOOST_CHECK_EQUAL(1, packet.count<FragIndexField>());
@@ -384,7 +384,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
BOOST_CHECK_THROW(packet.wireDecode(wire), Packet::Error);
}
@@ -399,7 +399,7 @@
};
Packet packet;
- Block wire(inputBlock, sizeof(inputBlock));
+ Block wire(inputBlock);
packet.wireDecode(wire);
BOOST_CHECK_EQUAL(1, packet.count<FragmentField>());
@@ -423,7 +423,7 @@
BOOST_AUTO_TEST_CASE(DecodeUnrecognizedTlvType)
{
Packet packet;
- Block wire = encoding::makeEmptyBlock(ndn::tlv::Name);
+ Block wire = makeEmptyBlock(ndn::tlv::Name);
BOOST_CHECK_THROW(packet.wireDecode(wire), Packet::Error);
}
diff --git a/tests/unit/meta-info.t.cpp b/tests/unit/meta-info.t.cpp
index e5229bf..87add29 100644
--- a/tests/unit/meta-info.t.cpp
+++ b/tests/unit/meta-info.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2019 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -124,11 +124,11 @@
0x6c, 0x65, 0x78, 0x2c, 0x20, 0x49, 0x20, 0x61, 0x6d, 0x20, 0x58,
0x69, 0x61, 0x6f, 0x6b, 0x65, 0x20, 0x4a, 0x69, 0x61, 0x6e, 0x67};
- BOOST_REQUIRE_EQUAL_COLLECTIONS(info1.wireEncode().begin(), info1.wireEncode().end(),
- METAINFO, METAINFO + sizeof(METAINFO));
+ BOOST_CHECK_EQUAL_COLLECTIONS(info1.wireEncode().begin(), info1.wireEncode().end(),
+ METAINFO, METAINFO + sizeof(METAINFO));
MetaInfo info2;
- info2.wireDecode(Block(METAINFO, sizeof(METAINFO)));
+ info2.wireDecode(Block(METAINFO));
for (size_t i = 0; i < 5; i++) {
uint32_t tlvType = 128 + i * 10;
diff --git a/tests/unit/mgmt/control-response.t.cpp b/tests/unit/mgmt/control-response.t.cpp
index 74b1b03..c23f7f0 100644
--- a/tests/unit/mgmt/control-response.t.cpp
+++ b/tests/unit/mgmt/control-response.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2018 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -48,7 +48,7 @@
BOOST_AUTO_TEST_CASE(Decode)
{
- ControlResponse cr(Block(WIRE, sizeof(WIRE)));
+ ControlResponse cr(Block{WIRE});
BOOST_CHECK_EQUAL(cr.getCode(), 404);
BOOST_CHECK_EQUAL(cr.getText(), "Nothing not found");
}
diff --git a/tests/unit/mgmt/dispatcher.t.cpp b/tests/unit/mgmt/dispatcher.t.cpp
index 7827516..30b5853 100644
--- a/tests/unit/mgmt/dispatcher.t.cpp
+++ b/tests/unit/mgmt/dispatcher.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -245,7 +245,7 @@
Block
wireEncode() const final
{
- return Block();
+ return {};
}
void
@@ -298,8 +298,7 @@
BOOST_AUTO_TEST_CASE(StatusDataset)
{
- const uint8_t smallBuf[] = {0x81, 0x01, 0x01};
- const Block smallBlock(smallBuf, sizeof(smallBuf));
+ const Block smallBlock({0x81, 0x01, 0x01});
const Block largeBlock = [] {
Block b(129, std::make_shared<const Buffer>(3000));
b.encode();
@@ -399,10 +398,10 @@
content = [&dataInStorage] () -> Block {
EncodingBuffer encoder;
- size_t valueLength = encoder.prependByteArray(dataInStorage[1].getContent().value(),
- dataInStorage[1].getContent().value_size());
- valueLength += encoder.prependByteArray(dataInStorage[0].getContent().value(),
- dataInStorage[0].getContent().value_size());
+ size_t valueLength = encoder.prependBytes({dataInStorage[1].getContent().value(),
+ dataInStorage[1].getContent().value_size()});
+ valueLength += encoder.prependBytes({dataInStorage[0].getContent().value(),
+ dataInStorage[0].getContent().value_size()});
encoder.prependVarNumber(valueLength);
encoder.prependVarNumber(tlv::Content);
return encoder.block();
@@ -427,8 +426,7 @@
BOOST_AUTO_TEST_CASE(NotificationStream)
{
- const uint8_t buf[] = {0x82, 0x01, 0x02};
- const Block block(buf, sizeof(buf));
+ const Block block({0x82, 0x01, 0x02});
auto post = dispatcher.addNotificationStream("test");
post(block);
diff --git a/tests/unit/mgmt/nfd/status-dataset.t.cpp b/tests/unit/mgmt/nfd/status-dataset.t.cpp
index 21fb288..2c8c7f7 100644
--- a/tests/unit/mgmt/nfd/status-dataset.t.cpp
+++ b/tests/unit/mgmt/nfd/status-dataset.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -70,12 +70,12 @@
BOOST_CONCEPT_ASSERT((WireEncodable<T1>));
BOOST_CONCEPT_ASSERT((WireEncodable<T2>));
- ndn::encoding::EncodingBuffer buffer;
+ EncodingBuffer buffer;
payload2.wireEncode(buffer);
payload1.wireEncode(buffer);
auto data = this->prepareDatasetReply(prefix);
- data->setContent(buffer.buf(), buffer.size());
+ data->setContent(buffer);
face.receive(*signData(data));
}
diff --git a/tests/unit/mgmt/status-dataset-context.t.cpp b/tests/unit/mgmt/status-dataset-context.t.cpp
index 6d1e0b9..4192337 100644
--- a/tests/unit/mgmt/status-dataset-context.t.cpp
+++ b/tests/unit/mgmt/status-dataset-context.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -67,7 +67,7 @@
size_t valueLength = 0;
for (const auto& args : sendDataHistory) {
const auto& content = args.content;
- valueLength += encoder.appendByteArray(content.value(), content.value_size());
+ valueLength += encoder.appendBytes({content.value(), content.value_size()});
}
encoder.prependVarNumber(valueLength);
encoder.prependVarNumber(tlv::Content);
@@ -237,7 +237,7 @@
BOOST_AUTO_TEST_CASE(AppendReject)
{
const uint8_t buf[] = {0x82, 0x01, 0x02};
- BOOST_CHECK_NO_THROW(context.append(Block(buf, sizeof(buf))));
+ BOOST_CHECK_NO_THROW(context.append(Block(buf)));
BOOST_CHECK_EXCEPTION(context.reject(), std::logic_error, [] (const auto& e) {
return e.what() == "cannot call reject() after append/end"s;
});
@@ -246,7 +246,7 @@
BOOST_AUTO_TEST_CASE(AppendEndReject)
{
const uint8_t buf[] = {0x82, 0x01, 0x02};
- BOOST_CHECK_NO_THROW(context.append(Block(buf, sizeof(buf))));
+ BOOST_CHECK_NO_THROW(context.append(Block(buf)));
BOOST_CHECK_NO_THROW(context.end());
BOOST_CHECK_EXCEPTION(context.reject(), std::logic_error, [] (const auto& e) {
return e.what() == "cannot call reject() after append/end"s;
@@ -257,7 +257,7 @@
{
BOOST_CHECK_NO_THROW(context.end());
const uint8_t buf[] = {0x82, 0x01, 0x02};
- BOOST_CHECK_EXCEPTION(context.append(Block(buf, sizeof(buf))), std::logic_error, [] (const auto& e) {
+ BOOST_CHECK_EXCEPTION(context.append(Block(buf)), std::logic_error, [] (const auto& e) {
return e.what() == "cannot call append() on a finalized context"s;
});
}
@@ -282,7 +282,7 @@
{
BOOST_CHECK_NO_THROW(context.reject());
const uint8_t buf[] = {0x82, 0x01, 0x02};
- BOOST_CHECK_EXCEPTION(context.append(Block(buf, sizeof(buf))), std::logic_error, [] (const auto& e) {
+ BOOST_CHECK_EXCEPTION(context.append(Block(buf)), std::logic_error, [] (const auto& e) {
return e.what() == "cannot call append() on a finalized context"s;
});
}
diff --git a/tests/unit/name.t.cpp b/tests/unit/name.t.cpp
index fccb838..4e8d104 100644
--- a/tests/unit/name.t.cpp
+++ b/tests/unit/name.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -257,11 +257,14 @@
name.append("xKh");
BOOST_CHECK_EQUAL(name.wireEncode(), "070B 080428F0A36B 0803784B68"_block);
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
name.append("0100"_block);
BOOST_CHECK_EQUAL(name.wireEncode(), "070F 080428F0A36B 0803784B68 08020100"_block);
name.append("080109"_block);
BOOST_CHECK_EQUAL(name.wireEncode(), "0712 080428F0A36B 0803784B68 08020100 080109"_block);
+#pragma GCC diagnostic pop
}
BOOST_AUTO_TEST_CASE(AppendPartialName)
diff --git a/tests/unit/security/additional-description.t.cpp b/tests/unit/security/additional-description.t.cpp
index 657870f..56a9090 100644
--- a/tests/unit/security/additional-description.t.cpp
+++ b/tests/unit/security/additional-description.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2020 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -30,7 +30,7 @@
BOOST_AUTO_TEST_SUITE(Security)
BOOST_AUTO_TEST_SUITE(TestAdditionalDescription)
-const uint8_t description[] = {
+const uint8_t DESC[] = {
0xfd, 0x01, 0x02, 0x28,
0xfd, 0x02, 0x00, 0x10, // DescriptionEntry
0xfd, 0x02, 0x01, 0x04, // DescriptionKey
@@ -44,8 +44,6 @@
0x76, 0x61, 0x6c, 0x32, // "val2"
};
-const std::string text = "[(key1:val1), (key2:val2)]";
-
BOOST_AUTO_TEST_CASE(Basic)
{
AdditionalDescription aDescription;
@@ -76,12 +74,10 @@
BOOST_CHECK_EQUAL_COLLECTIONS(aDescription.wireEncode().wire(),
aDescription.wireEncode().wire() + aDescription.wireEncode().size(),
- description,
- description + sizeof(description));
+ DESC,
+ DESC + sizeof(DESC));
- BOOST_REQUIRE_NO_THROW(AdditionalDescription(Block(description, sizeof(description))));
- AdditionalDescription aDescription2(Block(description, sizeof(description)));
-
+ AdditionalDescription aDescription2(Block{DESC});
BOOST_CHECK_EQUAL(aDescription2, aDescription);
AdditionalDescription aDescription3;
@@ -92,7 +88,7 @@
std::ostringstream os;
os << aDescription;
- BOOST_CHECK_EQUAL(os.str(), text);
+ BOOST_CHECK_EQUAL(os.str(), "[(key1:val1), (key2:val2)]");
}
BOOST_AUTO_TEST_SUITE_END() // TestAdditionalDescription
diff --git a/tests/unit/security/certificate.t.cpp b/tests/unit/security/certificate.t.cpp
index 7626e04..63b29a6 100644
--- a/tests/unit/security/certificate.t.cpp
+++ b/tests/unit/security/certificate.t.cpp
@@ -126,7 +126,7 @@
static void
generateFakeSignature(Data& data)
{
- SignatureInfo signatureInfo(Block(SIG_INFO, sizeof(SIG_INFO)));
+ SignatureInfo signatureInfo(Block{SIG_INFO});
signatureInfo.setKeyLocator(KeyLocator(Name("/ndn/site1/KEY/ksk-2516425377094")));
signatureInfo.setValidityPeriod(ValidityPeriod(time::fromIsoString("20141111T050000"),
time::fromIsoString("20141111T060000")));
@@ -137,7 +137,7 @@
BOOST_AUTO_TEST_CASE(Construction)
{
- Block block(CERT, sizeof(CERT));
+ Block block(CERT);
Certificate certificate(block);
BOOST_CHECK_EQUAL(certificate.getName(), "/ndn/site1/KEY/ksk-1416425377094/0123/%FD%00%00%01I%C9%8B");
@@ -201,7 +201,7 @@
public:
InvalidCertFixture()
{
- Certificate certBase(Block(CERT, sizeof(CERT)));
+ Certificate certBase(Block{CERT});
BOOST_CHECK_NO_THROW((Certificate(certBase)));
m_certBase = Data(certBase);
@@ -267,7 +267,7 @@
Key Locator: Name=/ndn/site1/KEY/ksk-2516425377094
)INFO").substr(1);
- Certificate certificate(Block(CERT, sizeof(CERT)));
+ Certificate certificate(Block{CERT});
BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(certificate), expectedCertificateInfo);
// TODO: Check output formats of other certificates
diff --git a/tests/unit/security/detail/certificate-bundle-decoder.t.cpp b/tests/unit/security/detail/certificate-bundle-decoder.t.cpp
index ae81c82..630aaec 100644
--- a/tests/unit/security/detail/certificate-bundle-decoder.t.cpp
+++ b/tests/unit/security/detail/certificate-bundle-decoder.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2020 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -99,7 +99,7 @@
{
// First segment contains first 250 bytes of cert1
Data d;
- d.setContent(certBlock1.wire(), 250);
+ d.setContent(make_span(certBlock1.wire(), 250));
// Second segment contains the rest of cert1 and the first 100 bytes of cert2
auto buf = std::make_shared<Buffer>(certBlock1.begin() + 250, certBlock1.end());
@@ -145,7 +145,7 @@
};
// Second segment contains non-Certificate data
Data d2;
- d2.setContent(buf, sizeof(buf));
+ d2.setContent(buf);
// Third segment contains all of cert2
Data d3;
diff --git a/tests/unit/security/pib/pib-data-fixture.cpp b/tests/unit/security/pib/pib-data-fixture.cpp
index d27c742..37e1e6d 100644
--- a/tests/unit/security/pib/pib-data-fixture.cpp
+++ b/tests/unit/security/pib/pib-data-fixture.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -360,15 +360,15 @@
};
PibDataFixture::PibDataFixture()
- : id1Key1Cert1(Block(ID1_KEY1_CERT1, sizeof(ID1_KEY1_CERT1)))
- , id1Key1Cert2(Block(ID1_KEY1_CERT2, sizeof(ID1_KEY1_CERT2)))
- , id1Key2Cert1(Block(ID1_KEY2_CERT1, sizeof(ID1_KEY2_CERT1)))
- , id1Key2Cert2(Block(ID1_KEY2_CERT2, sizeof(ID1_KEY2_CERT2)))
+ : id1Key1Cert1(Block(ID1_KEY1_CERT1))
+ , id1Key1Cert2(Block(ID1_KEY1_CERT2))
+ , id1Key2Cert1(Block(ID1_KEY2_CERT1))
+ , id1Key2Cert2(Block(ID1_KEY2_CERT2))
- , id2Key1Cert1(Block(ID2_KEY1_CERT1, sizeof(ID2_KEY1_CERT1)))
- , id2Key1Cert2(Block(ID2_KEY1_CERT2, sizeof(ID2_KEY1_CERT2)))
- , id2Key2Cert1(Block(ID2_KEY2_CERT1, sizeof(ID2_KEY2_CERT1)))
- , id2Key2Cert2(Block(ID2_KEY2_CERT2, sizeof(ID2_KEY2_CERT2)))
+ , id2Key1Cert1(Block(ID2_KEY1_CERT1))
+ , id2Key1Cert2(Block(ID2_KEY1_CERT2))
+ , id2Key2Cert1(Block(ID2_KEY2_CERT1))
+ , id2Key2Cert2(Block(ID2_KEY2_CERT2))
, id1(id1Key1Cert1.getIdentity())
, id2(id2Key1Cert1.getIdentity())
diff --git a/tests/unit/security/safe-bag.t.cpp b/tests/unit/security/safe-bag.t.cpp
index c3cc7c2..5d24112 100644
--- a/tests/unit/security/safe-bag.t.cpp
+++ b/tests/unit/security/safe-bag.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -121,10 +121,10 @@
BOOST_AUTO_TEST_CASE(Constructor)
{
- Data data(Block(CERT, sizeof(CERT)));
- SafeBag safeBag1(data, ENCRYPTED_KEY);
- SafeBag safeBag2(Block(SAFE_BAG, sizeof(SAFE_BAG)));
+ Data data(Block{CERT});
auto encKey = make_span(ENCRYPTED_KEY);
+ SafeBag safeBag1(data, encKey);
+ SafeBag safeBag2(Block{SAFE_BAG});
BOOST_CHECK(safeBag1.getCertificate() == data);
BOOST_CHECK_EQUAL_COLLECTIONS(safeBag1.getEncryptedKey().begin(), safeBag1.getEncryptedKey().end(),
@@ -136,13 +136,12 @@
BOOST_AUTO_TEST_CASE(EncoderAndDecoder)
{
- Block dataBlock(CERT, sizeof(CERT));
- Data data(dataBlock);
+ Data data(Block{CERT});
SafeBag safeBag(data, ENCRYPTED_KEY);
// wire encode
- Block wireBlock = safeBag.wireEncode();
- Block block(SAFE_BAG, sizeof(SAFE_BAG));
+ const auto& wireBlock = safeBag.wireEncode();
+ Block block(SAFE_BAG);
// check safe bag block
BOOST_CHECK_EQUAL(wireBlock, block);
diff --git a/tests/unit/security/validation-policy-command-interest.t.cpp b/tests/unit/security/validation-policy-command-interest.t.cpp
index 478b2d5..4fe05b7 100644
--- a/tests/unit/security/validation-policy-command-interest.t.cpp
+++ b/tests/unit/security/validation-policy-command-interest.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -176,7 +176,7 @@
{
auto i1 = makeCommandInterest(identity);
KeyLocator kl;
- kl.setKeyDigest(makeBinaryBlock(tlv::KeyDigest, "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD", 8));
+ kl.setKeyDigest(makeBinaryBlock(tlv::KeyDigest, {0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD, 0xDD}));
SignatureInfo sigInfo(tlv::SignatureSha256WithRsa);
sigInfo.setKeyLocator(kl);
setNameComponent(i1, command_interest::POS_SIG_INFO,
diff --git a/tests/unit/security/validity-period.t.cpp b/tests/unit/security/validity-period.t.cpp
index 1dc7740..5dc8d9d 100644
--- a/tests/unit/security/validity-period.t.cpp
+++ b/tests/unit/security/validity-period.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2020 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -87,15 +87,11 @@
{
time::system_clock::TimePoint notBefore = time::getUnixEpoch();
time::system_clock::TimePoint notAfter = notBefore + 1_day;
-
ValidityPeriod v1(notBefore, notAfter);
-
BOOST_CHECK_EQUAL_COLLECTIONS(v1.wireEncode().begin(), v1.wireEncode().end(),
VP1, VP1 + sizeof(VP1));
- BOOST_REQUIRE_NO_THROW(ValidityPeriod(Block(VP1, sizeof(VP1))));
- Block block(VP1, sizeof(VP1));
- ValidityPeriod v2(block);
+ ValidityPeriod v2(Block{VP1});
BOOST_CHECK(v1.getPeriod() == v2.getPeriod());
}
@@ -159,21 +155,17 @@
0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30
};
-
BOOST_AUTO_TEST_CASE(DecodingError)
{
- BOOST_CHECK_THROW(ValidityPeriod(Block(VP_E1, sizeof(VP_E1))), ValidityPeriod::Error);
-
- BOOST_CHECK_THROW(ValidityPeriod(Block(VP_E2, sizeof(VP_E2))), ValidityPeriod::Error);
- BOOST_CHECK_THROW(ValidityPeriod(Block(VP_E3, sizeof(VP_E3))), ValidityPeriod::Error);
-
- BOOST_CHECK_THROW(ValidityPeriod(Block(VP_E4, sizeof(VP_E4))), ValidityPeriod::Error);
- BOOST_CHECK_THROW(ValidityPeriod(Block(VP_E5, sizeof(VP_E5))), ValidityPeriod::Error);
+ BOOST_CHECK_THROW(ValidityPeriod(Block{VP_E1}), ValidityPeriod::Error);
+ BOOST_CHECK_THROW(ValidityPeriod(Block{VP_E2}), ValidityPeriod::Error);
+ BOOST_CHECK_THROW(ValidityPeriod(Block{VP_E3}), ValidityPeriod::Error);
+ BOOST_CHECK_THROW(ValidityPeriod(Block{VP_E4}), ValidityPeriod::Error);
+ BOOST_CHECK_THROW(ValidityPeriod(Block{VP_E5}), ValidityPeriod::Error);
+ BOOST_CHECK_THROW(ValidityPeriod(Block{VP_E6}), ValidityPeriod::Error);
Block emptyBlock;
- BOOST_CHECK_THROW((ValidityPeriod(emptyBlock)), ValidityPeriod::Error);
-
- BOOST_CHECK_THROW(ValidityPeriod(Block(VP_E6, sizeof(VP_E6))), ValidityPeriod::Error);
+ BOOST_CHECK_THROW(ValidityPeriod{emptyBlock}, ValidityPeriod::Error);
}
BOOST_AUTO_TEST_CASE(Comparison)
diff --git a/tests/unit/security/verification-helpers.t.cpp b/tests/unit/security/verification-helpers.t.cpp
index 479a655..5e313ec 100644
--- a/tests/unit/security/verification-helpers.t.cpp
+++ b/tests/unit/security/verification-helpers.t.cpp
@@ -49,7 +49,7 @@
// };
// auto print = [] (const std::string& name, const uint8_t* buf, size_t size) {
-// std::cout << " std::vector<uint8_t> " + name + " = {\n ";
+// std::cout << " const Block " + name + "{{\n ";
// std::string hex = toHex(buf, size);
@@ -63,7 +63,7 @@
// if ((i + 1) != hex.size())
// std::cout << ", ";
// }
-// std::cout << "\n };";
+// std::cout << "\n }};";
// };
// for (const auto& i : identities) {
@@ -130,7 +130,7 @@
struct EcdsaDataset
{
const std::string name = "Ecdsa";
- std::vector<uint8_t> cert = {
+ const Block cert{{
0x06, 0xFD, 0x01, 0x62, 0x07, 0x47, 0x08, 0x08, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79,
0x08, 0x17, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69,
0x6F, 0x6E, 0x48, 0x65, 0x6C, 0x70, 0x65, 0x72, 0x73, 0x08, 0x02, 0x45, 0x43, 0x08, 0x03, 0x4B,
@@ -154,8 +154,8 @@
0x6B, 0x24, 0xF5, 0x7F, 0x02, 0x20, 0x1C, 0x88, 0xDE, 0x32, 0x3F, 0x1A, 0xE6, 0x60, 0xA2, 0x29,
0x94, 0xD9, 0x05, 0x8F, 0x57, 0x14, 0xD6, 0x17, 0x3C, 0x78, 0xBF, 0x85, 0xF5, 0x1D, 0xCC, 0x03,
0x35, 0x9E, 0xC9, 0xA9, 0x6B, 0x09
- };
- std::vector<uint8_t> goodData = {
+ }};
+ const Block goodData{{
0x06, 0xA2, 0x07, 0x13, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x04, 0x64, 0x61, 0x74, 0x61,
0x08, 0x05, 0x45, 0x63, 0x64, 0x73, 0x61, 0x14, 0x00, 0x15, 0x00, 0x16, 0x3D, 0x1B, 0x01, 0x03,
0x1C, 0x38, 0x07, 0x36, 0x08, 0x08, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x08, 0x17,
@@ -167,8 +167,8 @@
0xC3, 0x02, 0x21, 0x00, 0xB5, 0xA3, 0x87, 0xD8, 0x9B, 0xB6, 0x92, 0xAD, 0x19, 0x84, 0xAE, 0x4D,
0xF5, 0x64, 0xEC, 0x1C, 0xF2, 0xA0, 0xB7, 0x4D, 0x6B, 0x74, 0xFF, 0x39, 0x38, 0xFD, 0x5D, 0x9D,
0x46, 0xE0, 0xD2, 0xB4
- };
- std::vector<uint8_t> badSigData = {
+ }};
+ const Block badSigData{{
0x06, 0xA5, 0x07, 0x13, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x04, 0x64, 0x61, 0x74, 0x61,
0x08, 0x05, 0x45, 0x63, 0x64, 0x73, 0x61, 0x14, 0x00, 0x15, 0x00, 0x16, 0x40, 0x1B, 0x01, 0x03,
0x1C, 0x3B, 0x07, 0x39, 0x08, 0x08, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x08, 0x17,
@@ -180,8 +180,8 @@
0x13, 0xB4, 0xB8, 0x95, 0x02, 0x21, 0x00, 0xDA, 0x54, 0x99, 0xF8, 0xE5, 0xC1, 0x74, 0xAC, 0xE0,
0xF2, 0xDF, 0x0D, 0xC5, 0xE1, 0xCF, 0x99, 0x28, 0x6C, 0xB0, 0x2D, 0x55, 0xC8, 0x74, 0x63, 0x56,
0x2A, 0x1A, 0xB0, 0x00, 0xBD, 0xFF, 0xC5
- };
- std::vector<uint8_t> goodInterest = {
+ }};
+ const Block goodInterest{{
0x05, 0xCA, 0x07, 0x39, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E, 0x74, 0x65,
0x72, 0x65, 0x73, 0x74, 0x08, 0x05, 0x45, 0x63, 0x64, 0x73, 0x61, 0x02, 0x20, 0x8F, 0x41, 0x49,
0x40, 0xDA, 0x38, 0xC1, 0x0E, 0x75, 0x5A, 0x6D, 0x4A, 0xD4, 0xFC, 0xE2, 0xDF, 0xBA, 0x52, 0xAF,
@@ -195,8 +195,8 @@
0xDB, 0xEA, 0x3A, 0x71, 0x83, 0x0D, 0xC4, 0x26, 0xB7, 0x24, 0x02, 0x20, 0x0F, 0x14, 0x10, 0xDB,
0xDB, 0x24, 0xCB, 0xB3, 0xD2, 0x4B, 0x45, 0x6D, 0xA0, 0xBB, 0x4B, 0x87, 0xC1, 0x59, 0x9F, 0xC8,
0xBE, 0x75, 0xF5, 0xCC, 0xCB, 0xD2, 0x4F, 0xD8, 0x87, 0x26, 0x51, 0xBF
- };
- std::vector<uint8_t> badSigInterest = {
+ }};
+ const Block badSigInterest{{
0x05, 0xCF, 0x07, 0x39, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E, 0x74, 0x65,
0x72, 0x65, 0x73, 0x74, 0x08, 0x05, 0x45, 0x63, 0x64, 0x73, 0x61, 0x02, 0x20, 0x53, 0x14, 0x5E,
0xA3, 0x31, 0x41, 0xD8, 0xA1, 0x10, 0x06, 0x3C, 0x8E, 0xF3, 0x51, 0xA0, 0xC2, 0x8A, 0xBC, 0xFC,
@@ -211,8 +211,8 @@
0x00, 0xC7, 0x23, 0x25, 0xF7, 0xFA, 0x6A, 0x2D, 0x3D, 0xF4, 0xD8, 0xDB, 0xE9, 0x76, 0x6A, 0x63,
0xD4, 0x11, 0x17, 0x4A, 0xDB, 0x7F, 0x85, 0x52, 0x97, 0xFC, 0x5B, 0x0B, 0x1B, 0xBA, 0xE5, 0xED,
0x9A
- };
- std::vector<uint8_t> goodInterestOldFormat = {
+ }};
+ const Block goodInterestOldFormat{{
0x05, 0xCB, 0x07, 0x39, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E, 0x74, 0x65,
0x72, 0x65, 0x73, 0x74, 0x08, 0x05, 0x45, 0x63, 0x64, 0x73, 0x61, 0x02, 0x20, 0xDB, 0x6D, 0x5E,
0xA7, 0xBF, 0xAF, 0xEC, 0xA0, 0xC6, 0x20, 0x4E, 0xF2, 0x04, 0xF8, 0xFF, 0x39, 0x2A, 0x5F, 0xE6,
@@ -226,8 +226,8 @@
0x60, 0x63, 0x51, 0xB3, 0x52, 0xBC, 0x6D, 0x24, 0x0C, 0x6D, 0x38, 0x02, 0x20, 0x0E, 0x21, 0xF1,
0x51, 0x39, 0x2D, 0x4A, 0x45, 0x05, 0x45, 0xFA, 0x85, 0xA7, 0xCC, 0x00, 0xFE, 0x89, 0x8A, 0xD6,
0xD7, 0x34, 0x0D, 0x31, 0x6A, 0x94, 0xAE, 0x1F, 0xD8, 0x07, 0xF1, 0xDF, 0x80
- };
- std::vector<uint8_t> badSigInterestOldFormat = {
+ }};
+ const Block badSigInterestOldFormat{{
0x05, 0xFD, 0x01, 0x5B, 0x07, 0xC9, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E,
0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x08, 0x05, 0x45, 0x63, 0x64, 0x73, 0x61, 0x02, 0x20, 0xDB,
0x6D, 0x5E, 0xA7, 0xBF, 0xAF, 0xEC, 0xA0, 0xC6, 0x20, 0x4E, 0xF2, 0x04, 0xF8, 0xFF, 0x39, 0x2A,
@@ -250,13 +250,13 @@
0x64, 0xAA, 0x60, 0x63, 0x51, 0xB3, 0x52, 0xBC, 0x6D, 0x24, 0x0C, 0x6D, 0x38, 0x02, 0x20, 0x0E,
0x21, 0xF1, 0x51, 0x39, 0x2D, 0x4A, 0x45, 0x05, 0x45, 0xFA, 0x85, 0xA7, 0xCC, 0x00, 0xFE, 0x89,
0x8A, 0xD6, 0xD7, 0x34, 0x0D, 0x31, 0x6A, 0x94, 0xAE, 0x1F, 0xD8, 0x07, 0xF1, 0xDF, 0x80
- };
+ }};
};
struct RsaDataset
{
const std::string name = "Rsa";
- std::vector<uint8_t> cert = {
+ const Block cert{{
0x06, 0xFD, 0x02, 0xED, 0x07, 0x48, 0x08, 0x08, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79,
0x08, 0x17, 0x54, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69,
0x6F, 0x6E, 0x48, 0x65, 0x6C, 0x70, 0x65, 0x72, 0x73, 0x08, 0x03, 0x52, 0x53, 0x41, 0x08, 0x03,
@@ -305,8 +305,8 @@
0x3E, 0xFA, 0xE6, 0xB9, 0x8E, 0x08, 0x82, 0x50, 0xCA, 0xEE, 0x7F, 0x5D, 0x80, 0x65, 0xBA, 0x10,
0x1F, 0x24, 0xC1, 0x15, 0x78, 0xB7, 0x90, 0xE5, 0x3D, 0xDA, 0x0F, 0x0E, 0x03, 0x20, 0xC1, 0xEA,
0x85
- };
- std::vector<uint8_t> goodData = {
+ }};
+ const Block goodData{{
0x06, 0xFD, 0x01, 0x5B, 0x07, 0x11, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x04, 0x64, 0x61,
0x74, 0x61, 0x08, 0x03, 0x52, 0x73, 0x61, 0x14, 0x00, 0x15, 0x00, 0x16, 0x3E, 0x1B, 0x01, 0x01,
0x1C, 0x39, 0x07, 0x37, 0x08, 0x08, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x08, 0x17,
@@ -329,8 +329,8 @@
0x4F, 0xD9, 0xEB, 0xC1, 0x5D, 0x53, 0x15, 0xBF, 0x8C, 0x7C, 0x6B, 0x22, 0xB9, 0x24, 0x70, 0xAE,
0x63, 0x13, 0x96, 0x3B, 0x2A, 0xDA, 0x7F, 0x64, 0x0D, 0x9E, 0xA7, 0x90, 0x20, 0x2A, 0x2A, 0xAB,
0xA9, 0xA6, 0xC9, 0xB2, 0x37, 0x8E, 0xE3, 0x09, 0xFD, 0xA3, 0x68, 0x06, 0xCB, 0x96, 0x80
- };
- std::vector<uint8_t> badSigData = {
+ }};
+ const Block badSigData{{
0x06, 0xA2, 0x07, 0x11, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x04, 0x64, 0x61, 0x74, 0x61,
0x08, 0x03, 0x52, 0x73, 0x61, 0x14, 0x00, 0x15, 0x00, 0x16, 0x40, 0x1B, 0x01, 0x03, 0x1C, 0x3B,
0x07, 0x39, 0x08, 0x08, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x08, 0x17, 0x54, 0x65,
@@ -342,8 +342,8 @@
0x1E, 0x02, 0x21, 0x00, 0xA5, 0x62, 0xA5, 0x04, 0x60, 0xBC, 0x96, 0x54, 0x2C, 0x9E, 0x6F, 0xA8,
0x1B, 0xDB, 0xF9, 0xF0, 0x7E, 0xFF, 0xED, 0x92, 0x3A, 0x4B, 0xDE, 0x3D, 0x20, 0x02, 0x7B, 0xD7,
0x1C, 0xD0, 0xAA, 0xAB
- };
- std::vector<uint8_t> goodInterest = {
+ }};
+ const Block goodInterest{{
0x05, 0xFD, 0x01, 0x85, 0x07, 0x37, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E,
0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x08, 0x03, 0x52, 0x73, 0x61, 0x02, 0x20, 0x08, 0x39, 0xEE,
0x12, 0xF1, 0x10, 0xB7, 0x8B, 0x49, 0xF2, 0xE2, 0x54, 0x23, 0xFF, 0x66, 0xB3, 0x0F, 0xC6, 0x91,
@@ -369,8 +369,8 @@
0xE3, 0x11, 0x85, 0xCC, 0x0E, 0xAF, 0x56, 0x6B, 0xE1, 0xAC, 0xB3, 0x20, 0xF2, 0x47, 0xFE, 0x95,
0xC8, 0x71, 0x99, 0xCC, 0x52, 0x8A, 0x6F, 0xF1, 0x01, 0xD6, 0xE9, 0x2E, 0x6C, 0x27, 0xC3, 0xED,
0xE3, 0xF2, 0xDD, 0x78, 0xB4, 0x7F, 0xFA, 0xD0, 0xC2
- };
- std::vector<uint8_t> badSigInterest = {
+ }};
+ const Block badSigInterest{{
0x05, 0xCC, 0x07, 0x37, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E, 0x74, 0x65,
0x72, 0x65, 0x73, 0x74, 0x08, 0x03, 0x52, 0x73, 0x61, 0x02, 0x20, 0x64, 0xE3, 0x6F, 0xD5, 0x73,
0x21, 0xBC, 0xAB, 0xDE, 0xDE, 0x0F, 0x99, 0xCB, 0x49, 0x7F, 0x46, 0xE7, 0xF0, 0x7A, 0xF1, 0x2C,
@@ -384,8 +384,8 @@
0x4A, 0xBF, 0xC0, 0x5B, 0xA8, 0x05, 0xA2, 0xC8, 0x61, 0xC4, 0x2E, 0x64, 0x02, 0x20, 0x1F, 0x5E,
0xF5, 0x8E, 0xC9, 0xDC, 0x9E, 0x15, 0x1C, 0xFA, 0x58, 0x5F, 0xDF, 0xAE, 0xA0, 0xFD, 0xDA, 0x34,
0x21, 0xE0, 0xA8, 0x2D, 0x32, 0x47, 0x9E, 0x44, 0x83, 0x79, 0x23, 0x5F, 0xBE, 0x16
- };
- std::vector<uint8_t> goodInterestOldFormat = {
+ }};
+ const Block goodInterestOldFormat{{
0x05, 0xFD, 0x01, 0x85, 0x07, 0x37, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E,
0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x08, 0x03, 0x52, 0x73, 0x61, 0x02, 0x20, 0x08, 0x39, 0xEE,
0x12, 0xF1, 0x10, 0xB7, 0x8B, 0x49, 0xF2, 0xE2, 0x54, 0x23, 0xFF, 0x66, 0xB3, 0x0F, 0xC6, 0x91,
@@ -411,8 +411,8 @@
0xE3, 0x11, 0x85, 0xCC, 0x0E, 0xAF, 0x56, 0x6B, 0xE1, 0xAC, 0xB3, 0x20, 0xF2, 0x47, 0xFE, 0x95,
0xC8, 0x71, 0x99, 0xCC, 0x52, 0x8A, 0x6F, 0xF1, 0x01, 0xD6, 0xE9, 0x2E, 0x6C, 0x27, 0xC3, 0xED,
0xE3, 0xF2, 0xDD, 0x78, 0xB4, 0x7F, 0xFA, 0xD0, 0xC2
- };
- std::vector<uint8_t> badSigInterestOldFormat = {
+ }};
+ const Block badSigInterestOldFormat{{
0x05, 0xFD, 0x02, 0x15, 0x07, 0xC7, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E,
0x74, 0x65, 0x72, 0x65, 0x73, 0x74, 0x08, 0x03, 0x52, 0x73, 0x61, 0x02, 0x20, 0x08, 0x39, 0xEE,
0x12, 0xF1, 0x10, 0xB7, 0x8B, 0x49, 0xF2, 0xE2, 0x54, 0x23, 0xFF, 0x66, 0xB3, 0x0F, 0xC6, 0x91,
@@ -447,23 +447,22 @@
0xE3, 0x11, 0x85, 0xCC, 0x0E, 0xAF, 0x56, 0x6B, 0xE1, 0xAC, 0xB3, 0x20, 0xF2, 0x47, 0xFE, 0x95,
0xC8, 0x71, 0x99, 0xCC, 0x52, 0x8A, 0x6F, 0xF1, 0x01, 0xD6, 0xE9, 0x2E, 0x6C, 0x27, 0xC3, 0xED,
0xE3, 0xF2, 0xDD, 0x78, 0xB4, 0x7F, 0xFA, 0xD0, 0xC2
- };
+ }};
};
struct Sha256Dataset
{
const std::string name = "Sha256";
- std::vector<uint8_t> cert = {
-
- };
- std::vector<uint8_t> goodData = {
+ const Block cert{{
+ }};
+ const Block goodData{{
0x06, 0x41, 0x07, 0x14, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x04, 0x64, 0x61, 0x74, 0x61,
0x08, 0x06, 0x53, 0x68, 0x61, 0x32, 0x35, 0x36, 0x14, 0x00, 0x15, 0x00, 0x16, 0x03, 0x1B, 0x01,
0x00, 0x17, 0x20, 0xE2, 0xE2, 0x2F, 0x02, 0x70, 0xA7, 0xF7, 0x48, 0x70, 0x45, 0x29, 0x46, 0xBD,
0xD2, 0x62, 0x24, 0xA6, 0x1E, 0x1D, 0x75, 0x2A, 0x26, 0x98, 0x04, 0xAD, 0x9C, 0x47, 0x63, 0xF8,
0x98, 0x5A, 0x49
- };
- std::vector<uint8_t> badSigData = {
+ }};
+ const Block badSigData{{
0x06, 0xA6, 0x07, 0x14, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x04, 0x64, 0x61, 0x74, 0x61,
0x08, 0x06, 0x53, 0x68, 0x61, 0x32, 0x35, 0x36, 0x14, 0x00, 0x15, 0x00, 0x16, 0x40, 0x1B, 0x01,
0x03, 0x1C, 0x3B, 0x07, 0x39, 0x08, 0x08, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x08,
@@ -475,8 +474,8 @@
0x28, 0x19, 0x6C, 0x5C, 0xD6, 0x02, 0x21, 0x00, 0xF0, 0xD2, 0x23, 0xEA, 0xD9, 0x43, 0x6D, 0x8A,
0xD2, 0x02, 0x3F, 0xF1, 0x41, 0x12, 0xA6, 0xED, 0x87, 0xB3, 0xD5, 0x5A, 0x27, 0x5D, 0x4E, 0xEB,
0x13, 0x29, 0x01, 0xBC, 0x3C, 0xCC, 0x50, 0x61
- };
- std::vector<uint8_t> goodInterest = {
+ }};
+ const Block goodInterest{{
0x05, 0x6B, 0x07, 0x3A, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E, 0x74, 0x65,
0x72, 0x65, 0x73, 0x74, 0x08, 0x06, 0x53, 0x68, 0x61, 0x32, 0x35, 0x36, 0x02, 0x20, 0x8F, 0x03,
0x0B, 0x85, 0xA7, 0x05, 0xD8, 0x05, 0x31, 0x8E, 0x80, 0x81, 0xD3, 0xE2, 0xA8, 0x5E, 0x74, 0xD7,
@@ -484,8 +483,8 @@
0xF7, 0x2C, 0x8A, 0x4B, 0x24, 0x00, 0x2C, 0x03, 0x1B, 0x01, 0x00, 0x2E, 0x20, 0xEF, 0x45, 0x55,
0x75, 0xC8, 0x18, 0x5E, 0xE9, 0x2A, 0xAE, 0x52, 0x61, 0x0A, 0x94, 0x41, 0x03, 0x36, 0x4C, 0x13,
0x59, 0xD4, 0xC7, 0xA4, 0x3A, 0xA0, 0x40, 0x61, 0x44, 0x33, 0x93, 0x5E, 0x99
- };
- std::vector<uint8_t> badSigInterest = {
+ }};
+ const Block badSigInterest{{
0x05, 0xCE, 0x07, 0x3A, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E, 0x74, 0x65,
0x72, 0x65, 0x73, 0x74, 0x08, 0x06, 0x53, 0x68, 0x61, 0x32, 0x35, 0x36, 0x02, 0x20, 0x32, 0x3F,
0x2F, 0xA3, 0xDC, 0x15, 0x7E, 0x8C, 0xA9, 0x75, 0xF7, 0x66, 0xFF, 0xFD, 0x13, 0x42, 0x1B, 0xE1,
@@ -499,8 +498,8 @@
0x73, 0xB3, 0xA6, 0xD2, 0x99, 0x32, 0x26, 0xE2, 0x46, 0x3A, 0xE0, 0x69, 0xDF, 0xB2, 0x02, 0x20,
0x6A, 0x03, 0xCE, 0xB6, 0x85, 0x1E, 0x01, 0x5E, 0xF8, 0x48, 0xDE, 0x65, 0xB9, 0xE1, 0xEB, 0x9A,
0xF8, 0x47, 0x43, 0x5B, 0xBA, 0x63, 0xCB, 0xBA, 0xFB, 0x62, 0x1C, 0x38, 0xE8, 0x53, 0xF7, 0x29
- };
- std::vector<uint8_t> goodInterestOldFormat = {
+ }};
+ const Block goodInterestOldFormat{{
0x05, 0x6B, 0x07, 0x3A, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E, 0x74, 0x65,
0x72, 0x65, 0x73, 0x74, 0x08, 0x06, 0x53, 0x68, 0x61, 0x32, 0x35, 0x36, 0x02, 0x20, 0x8F, 0x03,
0x0B, 0x85, 0xA7, 0x05, 0xD8, 0x05, 0x31, 0x8E, 0x80, 0x81, 0xD3, 0xE2, 0xA8, 0x5E, 0x74, 0xD7,
@@ -508,8 +507,8 @@
0xF7, 0x2C, 0x8A, 0x4B, 0x24, 0x00, 0x2C, 0x03, 0x1B, 0x01, 0x00, 0x2E, 0x20, 0xEF, 0x45, 0x55,
0x75, 0xC8, 0x18, 0x5E, 0xE9, 0x2A, 0xAE, 0x52, 0x61, 0x0A, 0x94, 0x41, 0x03, 0x36, 0x4C, 0x13,
0x59, 0xD4, 0xC7, 0xA4, 0x3A, 0xA0, 0x40, 0x61, 0x44, 0x33, 0x93, 0x5E, 0x99
- };
- std::vector<uint8_t> badSigInterestOldFormat = {
+ }};
+ const Block badSigInterestOldFormat{{
0x05, 0xFA, 0x07, 0xC9, 0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x08, 0x69, 0x6E, 0x74, 0x65,
0x72, 0x65, 0x73, 0x74, 0x08, 0x06, 0x53, 0x68, 0x61, 0x32, 0x35, 0x36, 0x02, 0x20, 0x8F, 0x03,
0x0B, 0x85, 0xA7, 0x05, 0xD8, 0x05, 0x31, 0x8E, 0x80, 0x81, 0xD3, 0xE2, 0xA8, 0x5E, 0x74, 0xD7,
@@ -526,7 +525,7 @@
0x2C, 0x8A, 0x4B, 0x24, 0x00, 0x2C, 0x03, 0x1B, 0x01, 0x00, 0x2E, 0x20, 0xEF, 0x45, 0x55, 0x75,
0xC8, 0x18, 0x5E, 0xE9, 0x2A, 0xAE, 0x52, 0x61, 0x0A, 0x94, 0x41, 0x03, 0x36, 0x4C, 0x13, 0x59,
0xD4, 0xC7, 0xA4, 0x3A, 0xA0, 0x40, 0x61, 0x44, 0x33, 0x93, 0x5E, 0x99
- };
+ }};
};
// Note about the datasets:
@@ -547,18 +546,17 @@
BOOST_AUTO_TEST_CASE_TEMPLATE(VerifySignature, Dataset, SignatureDatasets)
{
const Dataset dataset;
- Certificate cert(Block(dataset.cert.data(), dataset.cert.size()));
- Buffer keyRaw = cert.getPublicKey();
+ Certificate cert(dataset.cert);
+ auto keyRaw = cert.getPublicKey();
transform::PublicKey key;
key.loadPkcs8(keyRaw);
- Data data(Block(dataset.goodData.data(), dataset.goodData.size()));
- Data badSigData(Block(dataset.badSigData.data(), dataset.badSigData.size()));
- Interest interest(Block(dataset.goodInterest.data(), dataset.goodInterest.size()));
- Interest badSigInterest(Block(dataset.badSigInterest.data(), dataset.badSigInterest.size()));
- Interest interestOldFormat(Block(dataset.goodInterestOldFormat.data(),
- dataset.goodInterestOldFormat.size()));
- Interest badSigInterestOldFormat(Block(dataset.badSigInterestOldFormat.data(),
- dataset.badSigInterestOldFormat.size()));
+
+ Data data(dataset.goodData);
+ Data badSigData(dataset.badSigData);
+ Interest interest(dataset.goodInterest);
+ Interest badSigInterest(dataset.badSigInterest);
+ Interest interestOldFormat(dataset.goodInterestOldFormat);
+ Interest badSigInterestOldFormat(dataset.badSigInterestOldFormat);
BOOST_CHECK(verifySignature(data, key));
BOOST_CHECK(verifySignature(data, keyRaw));
@@ -634,14 +632,12 @@
BOOST_AUTO_TEST_CASE_TEMPLATE(VerifyDigest, Dataset, DigestDatasets)
{
const Dataset dataset;
- Data data(Block(dataset.goodData.data(), dataset.goodData.size()));
- Data badSigData(Block(dataset.badSigData.data(), dataset.badSigData.size()));
- Interest interest(Block(dataset.goodInterest.data(), dataset.goodInterest.size()));
- Interest badSigInterest(Block(dataset.badSigInterest.data(), dataset.badSigInterest.size()));
- Interest interestOldFormat(Block(dataset.goodInterestOldFormat.data(),
- dataset.goodInterestOldFormat.size()));
- Interest badSigInterestOldFormat(Block(dataset.badSigInterestOldFormat.data(),
- dataset.badSigInterestOldFormat.size()));
+ Data data(dataset.goodData);
+ Data badSigData(dataset.badSigData);
+ Interest interest(dataset.goodInterest);
+ Interest badSigInterest(dataset.badSigInterest);
+ Interest interestOldFormat(dataset.goodInterestOldFormat);
+ Interest badSigInterestOldFormat(dataset.badSigInterestOldFormat);
BOOST_CHECK(verifySignature(data, nullopt));
BOOST_CHECK(verifySignature(interest, nullopt));
@@ -683,8 +679,8 @@
BOOST_AUTO_TEST_CASE(VerifyWithUnrecognizedElements) // Bug #4583
{
- Data data(Block(sha256DataUnrecognizedElements, sizeof(sha256DataUnrecognizedElements)));
- Interest interest(Block(sha256InterestUnrecognizedElements, sizeof(sha256InterestUnrecognizedElements)));
+ Data data(Block{sha256DataUnrecognizedElements});
+ Interest interest(Block{sha256InterestUnrecognizedElements});
BOOST_CHECK(verifySignature(data, nullopt));
BOOST_CHECK(verifySignature(interest, nullopt));
diff --git a/tests/unit/signature-info.t.cpp b/tests/unit/signature-info.t.cpp
index eb08285..11fdff1 100644
--- a/tests/unit/signature-info.t.cpp
+++ b/tests/unit/signature-info.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2020 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -243,8 +243,7 @@
encodedData.begin(), encodedData.end());
// Decode as (Data)SignatureInfo
- info = SignatureInfo(Block(sigInfoDataRsa, sizeof(sigInfoDataRsa)),
- SignatureInfo::Type::Data);
+ info = SignatureInfo(Block(sigInfoDataRsa), SignatureInfo::Type::Data);
BOOST_CHECK_EQUAL(info.getSignatureType(), tlv::SignatureSha256WithRsa);
BOOST_CHECK_EQUAL(info.hasKeyLocator(), true);
@@ -265,8 +264,7 @@
encodedInterest.begin(), encodedInterest.end());
// Decode as InterestSignatureInfo
- info = SignatureInfo(Block(sigInfoInterestRsa, sizeof(sigInfoInterestRsa)),
- SignatureInfo::Type::Interest);
+ info = SignatureInfo(Block(sigInfoInterestRsa), SignatureInfo::Type::Interest);
BOOST_CHECK_EQUAL(info.getSignatureType(), tlv::SignatureSha256WithRsa);
BOOST_CHECK_EQUAL(info.hasKeyLocator(), true);
@@ -285,8 +283,7 @@
encodedDataEcdsa.begin(), encodedDataEcdsa.end());
// Decode as (Data)SignatureInfo
- info = SignatureInfo(Block(sigInfoDataEcdsa, sizeof(sigInfoDataEcdsa)),
- SignatureInfo::Type::Data);
+ info = SignatureInfo(Block(sigInfoDataEcdsa), SignatureInfo::Type::Data);
BOOST_CHECK_EQUAL(info.getSignatureType(), tlv::SignatureSha256WithEcdsa);
BOOST_CHECK_EQUAL(info.hasKeyLocator(), true);
@@ -311,7 +308,7 @@
0x08, 0x07,
0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72
};
- Block errorBlock1(error1, sizeof(error1));
+ Block errorBlock1(error1);
BOOST_CHECK_THROW(SignatureInfo(errorBlock1, SignatureInfo::Type::Data), tlv::Error);
const uint8_t error2[] = {
@@ -320,13 +317,13 @@
0x01, // Sha256WithRsa
0x83, 0x00, // Unrecognized critical TLV
};
- Block errorBlock2(error2, sizeof(error2));
+ Block errorBlock2(error2);
BOOST_CHECK_THROW(SignatureInfo(errorBlock2, SignatureInfo::Type::Data), tlv::Error);
const uint8_t error3[] = {
0x16, 0x00 // Empty SignatureInfo
};
- Block errorBlock3(error3, sizeof(error3));
+ Block errorBlock3(error3);
BOOST_CHECK_THROW(SignatureInfo(errorBlock3, SignatureInfo::Type::Data), tlv::Error);
// Encoding is correct for SignatureInfo, but decoder is expecting InterestSignatureInfo
@@ -343,7 +340,7 @@
0x08, 0x07,
0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72
};
- Block errorBlock4(error4, sizeof(error4));
+ Block errorBlock4(error4);
BOOST_CHECK_THROW(SignatureInfo(errorBlock4, SignatureInfo::Type::Interest), tlv::Error);
// SignatureType and KeyLocator out-of-order
@@ -360,7 +357,7 @@
0x1b, 0x01, // SignatureType
0x01, // Sha256WithRsa
};
- Block errorBlock5(error5, sizeof(error5));
+ Block errorBlock5(error5);
BOOST_CHECK_THROW(SignatureInfo(errorBlock5, SignatureInfo::Type::Interest), tlv::Error);
// Repeated KeyLocator
@@ -385,7 +382,7 @@
0x08, 0x07,
0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72
};
- Block errorBlock6(error6, sizeof(error6));
+ Block errorBlock6(error6);
BOOST_CHECK_THROW(SignatureInfo(errorBlock6, SignatureInfo::Type::Interest), tlv::Error);
// Zero-length SignatureNonce
@@ -395,7 +392,7 @@
0x01, // Sha256WithRsa
0x26, 0x00 // SignatureNonce
};
- Block errorBlock7(error7, sizeof(error7));
+ Block errorBlock7(error7);
BOOST_CHECK_THROW(SignatureInfo(errorBlock7, SignatureInfo::Type::Interest), tlv::Error);
}
@@ -444,7 +441,7 @@
BOOST_CHECK_EQUAL(info.hasWire(), true);
// decode
- Block block(sigInfo, sizeof(sigInfo));
+ Block block(sigInfo);
SignatureInfo info2(block, SignatureInfo::Type::Data);
BOOST_CHECK_EQUAL(info2.getValidityPeriod(), vp1);
BOOST_CHECK_EQUAL(info2.hasWire(), true);
@@ -503,7 +500,7 @@
0x6a, 0x05, 0x54, 0x68, 0x69, 0x72, 0x64 // 106 "Third"
};
- SignatureInfo info3(Block(infoBytes, sizeof(infoBytes)), SignatureInfo::Type::Data);
+ SignatureInfo info3(Block(infoBytes), SignatureInfo::Type::Data);
BOOST_CHECK_EQUAL(info3, info1);
BOOST_CHECK_EQUAL_COLLECTIONS(infoBytes, infoBytes + sizeof(infoBytes),
info1.wireEncode().begin(), info1.wireEncode().end());
diff --git a/tests/unit/util/io.t.cpp b/tests/unit/util/io.t.cpp
index 8b19fe3..ebe5799 100644
--- a/tests/unit/util/io.t.cpp
+++ b/tests/unit/util/io.t.cpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2013-2021 Regents of the University of California.
+ * Copyright (c) 2013-2022 Regents of the University of California.
*
* This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
*
@@ -67,7 +67,7 @@
{
T t;
std::ostringstream os(std::ios_base::binary);
- io::saveBuffer(t.blob.data(), t.blob.size(), os, t.encoding);
+ io::saveBuffer(t.blob, os, t.encoding);
BOOST_CHECK_EQUAL(os.str(), t.stream.str());
}
@@ -86,7 +86,7 @@
NullStreambuf nullbuf;
std::ostream out(&nullbuf);
const Buffer buffer(1);
- BOOST_CHECK_THROW(io::saveBuffer(buffer.data(), buffer.size(), out, io::NO_ENCODING), io::Error);
+ BOOST_CHECK_THROW(io::saveBuffer(buffer, out, io::NO_ENCODING), io::Error);
}
BOOST_AUTO_TEST_CASE(UnknownIoEncoding)
@@ -94,7 +94,7 @@
std::stringstream ss;
BOOST_CHECK_THROW(io::loadTlv<Name>(ss, static_cast<io::IoEncoding>(5)), std::invalid_argument);
BOOST_CHECK_THROW(io::loadBuffer(ss, static_cast<io::IoEncoding>(5)), std::invalid_argument);
- BOOST_CHECK_THROW(io::saveBuffer(nullptr, 0, ss, static_cast<io::IoEncoding>(5)), std::invalid_argument);
+ BOOST_CHECK_THROW(io::saveBuffer({}, ss, static_cast<io::IoEncoding>(5)), std::invalid_argument);
}
class FileIoFixture
diff --git a/tests/unit/util/sha256.t.cpp b/tests/unit/util/sha256.t.cpp
index 501a015..3340204 100644
--- a/tests/unit/util/sha256.t.cpp
+++ b/tests/unit/util/sha256.t.cpp
@@ -134,7 +134,7 @@
auto expected = fromHex("b372edfd4d6a4db2cfeaeead6c34fdee9b9e759f7b8d799cf8067e39e7f2886c");
Sha256 statefulSha256;
- statefulSha256 << Block{input, sizeof(input)};
+ statefulSha256 << Block{input};
ConstBufferPtr digest = statefulSha256.computeDigest();
BOOST_CHECK_EQUAL(statefulSha256.empty(), false);
diff --git a/tests/unit/util/simple-notification.hpp b/tests/unit/util/simple-notification.hpp
index 280045a..acfa172 100644
--- a/tests/unit/util/simple-notification.hpp
+++ b/tests/unit/util/simple-notification.hpp
@@ -1,6 +1,6 @@
/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
- * Copyright (c) 2014-2021 Regents of the University of California,
+ * Copyright (c) 2014-2022 Regents of the University of California,
* Arizona Board of Regents,
* Colorado State University,
* University Pierre & Marie Curie, Sorbonne University,
@@ -28,7 +28,7 @@
#ifndef NDN_CXX_TESTS_UNIT_UTIL_SIMPLE_NOTIFICATION_HPP
#define NDN_CXX_TESTS_UNIT_UTIL_SIMPLE_NOTIFICATION_HPP
-#include "ndn-cxx/encoding/encoding-buffer.hpp"
+#include "ndn-cxx/encoding/block-helpers.hpp"
namespace ndn {
namespace util {
@@ -53,11 +53,7 @@
Block
wireEncode() const
{
- ndn::EncodingBuffer buffer;
- buffer.prependByteArrayBlock(0x8888,
- reinterpret_cast<const uint8_t*>(m_message.c_str()),
- m_message.size());
- return buffer.block();
+ return makeStringBlock(0x8888, m_message);
}
void