BOOST_AUTO_TEST_CASE_TEMPLATE(InstanceName, T, Tests)
{
BOOST_REQUIRE(T::Strategy::getStrategyName().at(-1).isVersion());
uint64_t maxVersion = T::Strategy::getStrategyName().at(-1).toVersion();
BOOST_REQUIRE_LE(T::getMinVersion(), maxVersion);
Forwarder forwarder;
for (uint64_t version = T::getMinVersion(); version <= maxVersion; ++version) {
Name versionedName = T::getVersionedStrategyName(version);
unique_ptr<typename T::Strategy> instance;
BOOST_CHECK_NO_THROW(instance = make_unique<typename T::Strategy>(forwarder, versionedName));
BOOST_CHECK_EQUAL(instance->getInstanceName(), versionedName);
if (!T::canAcceptParameters()) {
Name nameWithParameters = Name(versionedName).append("param");
BOOST_CHECK_THROW(typename T::Strategy(forwarder, nameWithParameters), std::invalid_argument);
}
}
if (T::getMinVersion() > 0) {
Name version0Name = T::getVersionedStrategyName(0);
BOOST_CHECK_THROW(typename T::Strategy(forwarder, version0Name), std::invalid_argument);
Name earlyVersionName = T::getVersionedStrategyName(T::getMinVersion() - 1);
BOOST_CHECK_THROW(typename T::Strategy(forwarder, earlyVersionName), std::invalid_argument);
}
if (maxVersion < std::numeric_limits<uint64_t>::max()) {
Name versionMaxName = T::getVersionedStrategyName(std::numeric_limits<uint64_t>::max());
BOOST_CHECK_THROW(typename T::Strategy(forwarder, versionMaxName), std::invalid_argument);
Name lateVersionName = T::getVersionedStrategyName(maxVersion + 1);
BOOST_CHECK_THROW(typename T::Strategy(forwarder, lateVersionName), std::invalid_argument);
}
}
BOOST_AUTO_TEST_CASE_TEMPLATE( move_random_data_through_the_buffer, sizes, test_sizes )
{
std::vector< std::uint8_t > test_data = this->random_data( 20 );
std::vector< std::uint8_t > received_data;
std::vector< std::size_t > transmit_sizes;
std::vector< std::size_t > receive_sizes;
const std::size_t max_rx_size_value = std::tuple_element< 0, sizes >::type::value;
const std::size_t min_size = std::tuple_element< 1, sizes >::type::value;
const std::size_t max_size = std::tuple_element< 2, sizes >::type::value;
max_rx_size( max_rx_size_value );
auto emergency_counter = 2 * test_data.size();
bool sequence_number = false;
for ( std::size_t send_size = 0; send_size < test_data.size(); --emergency_counter )
{
BOOST_REQUIRE( emergency_counter );
auto read = allocate_receive_buffer();
// if there is room in the receive buffer, I allocate that memory and simulate a received PDU
if ( read.size )
{
const std::size_t size = std::min< std::size_t >( random_value( min_size, max_size ), test_data.size() - send_size );
if ( size != 0 )
{
transmit_sizes.push_back( size );
}
read.buffer[ 1 ] = size;
read.buffer[ 0 ] = 2;
if ( sequence_number )
read.buffer[ 0 ] |= 8;
sequence_number = !sequence_number;
std::copy( test_data.begin() + send_size, test_data.begin() + send_size + size, &read.buffer[ 2 ] );
received( read );
send_size += size;
}
// if there is no more room left, I simulate the receiving of an pdu
else
{
auto next = next_received();
BOOST_REQUIRE_NE( next.size, 0u );
BOOST_REQUIRE_NE( next.buffer[ 1 ], 0u );
receive_sizes.push_back( next.buffer[ 1 ] );
BOOST_REQUIRE_LE( receive_sizes.size(), transmit_sizes.size() );
BOOST_REQUIRE_EQUAL( receive_sizes.back(), transmit_sizes[ receive_sizes.size() - 1 ] );
received_data.insert( received_data.end(), &next.buffer[ 2 ], &next.buffer[ 2 ] + next.buffer[ 1 ] );
free_received();
}
}
for ( auto next = next_received(); next.size; next = next_received(), --emergency_counter )
{
BOOST_REQUIRE( emergency_counter );
receive_sizes.push_back( next.buffer[ 1 ] );
BOOST_REQUIRE_LE( receive_sizes.size(), transmit_sizes.size() );
BOOST_REQUIRE_EQUAL( receive_sizes.back(), transmit_sizes[ receive_sizes.size() - 1 ] );
received_data.insert( received_data.end(), &next.buffer[ 2 ], &next.buffer[ 2 ] + next.buffer[ 1 ] );
free_received();
}
BOOST_CHECK_EQUAL_COLLECTIONS( test_data.begin(), test_data.end(), received_data.begin(), received_data.end() );
}
