[pingcheck] / test / test_messagepayload.cpp

/*
The software in this package is distributed under the GNU General
Public License version 2 (with a special exception described below).

A copy of GNU General Public License (GPL) is included in this distribution,
in the file COPYING.GPL.

As a special exception, if other files instantiate templates or use macros
or inline functions from this file, or you compile this file and link it
with other works to produce a work based on this file, this file
does not by itself cause the resulting work to be covered
by the GNU General Public License.

However the source code for this file must still be made available
in accordance with section (3) of the GNU General Public License.

This exception does not invalidate any other reasons why a work based
on this file might be covered by the GNU General Public License.
*/

#define BOOST_TEST_MAIN
#define BOOST_TEST_DYN_LINK

#include <streambuf>

#include <boost/test/unit_test.hpp>

#include "host/messagepayload.h"

//------------------------------------------------------------------------------

MessagePayload create_message_payload( const std::size_t bytes_total );
void fill_message_payload(
        const std::size_t bytes_total,
        const uint8_t first_value,
        MessagePayload& mp
);

//------------------------------------------------------------------------------

MessagePayload create_message_payload( const std::size_t bytes_total )
{
    return MessagePayload( bytes_total );
}

void fill_message_payload(
        const std::size_t bytes_total,
        const uint8_t first_value,
        MessagePayload& mp
)
{
    for ( std::size_t byte_index = 0; byte_index < bytes_total; byte_index++ )
    {
        mp[ byte_index ] = static_cast<uint8_t>( first_value + byte_index );
    }
}

//------------------------------------------------------------------------------

BOOST_AUTO_TEST_SUITE( TestMessagePayload )

BOOST_AUTO_TEST_CASE( basic_assignment )
{
    MessagePayload mp_filled = create_message_payload( 10 );
    fill_message_payload( 10, 0xC0, mp_filled );

    MessagePayload mp_assigned = create_message_payload( 10 );
    mp_assigned = mp_filled;

    BOOST_CHECK_EQUAL( mp_assigned[0], 0xC0 );
    BOOST_CHECK_EQUAL( mp_assigned[1], 0xC1 );
    BOOST_CHECK_EQUAL( mp_assigned[2], 0xC2 );
    BOOST_CHECK_EQUAL( mp_assigned[3], 0xC3 );
    BOOST_CHECK_EQUAL( mp_assigned[4], 0xC4 );
    BOOST_CHECK_EQUAL( mp_assigned[5], 0xC5 );
    BOOST_CHECK_EQUAL( mp_assigned[6], 0xC6 );
    BOOST_CHECK_EQUAL( mp_assigned[7], 0xC7 );
    BOOST_CHECK_EQUAL( mp_assigned[8], 0xC8 );
    BOOST_CHECK_EQUAL( mp_assigned[9], 0xC9 );
}

BOOST_AUTO_TEST_CASE( array_subscript_const )
{
    MessagePayload mp_filled = create_message_payload( 10 );
    fill_message_payload( 10, 0xC0, mp_filled );

    const MessagePayload mp_const( mp_filled );

    BOOST_CHECK_EQUAL( mp_const[0], 0xC0 );
    BOOST_CHECK_EQUAL( mp_const[1], 0xC1 );
    BOOST_CHECK_EQUAL( mp_const[2], 0xC2 );
    BOOST_CHECK_EQUAL( mp_const[3], 0xC3 );
    BOOST_CHECK_EQUAL( mp_const[4], 0xC4 );
    BOOST_CHECK_EQUAL( mp_const[5], 0xC5 );
    BOOST_CHECK_EQUAL( mp_const[6], 0xC6 );
    BOOST_CHECK_EQUAL( mp_const[7], 0xC7 );
    BOOST_CHECK_EQUAL( mp_const[8], 0xC8 );
    BOOST_CHECK_EQUAL( mp_const[9], 0xC9 );
}

BOOST_AUTO_TEST_CASE( array_subscript )
{
    MessagePayload mp( 10 );
    mp[0] = 0xC0;
    mp[1] = 0xC1;
    mp[2] = 0xC2;
    mp[3] = 0xC3;
    mp[4] = 0xC4;
    mp[5] = 0xC5;
    mp[6] = 0xC6;
    mp[7] = 0xC7;
    mp[8] = 0xC8;
    mp[9] = 0xC9;

    BOOST_CHECK_EQUAL( mp[0], 0xC0 );
    BOOST_CHECK_EQUAL( mp[1], 0xC1 );
    BOOST_CHECK_EQUAL( mp[2], 0xC2 );
    BOOST_CHECK_EQUAL( mp[3], 0xC3 );
    BOOST_CHECK_EQUAL( mp[4], 0xC4 );
    BOOST_CHECK_EQUAL( mp[5], 0xC5 );
    BOOST_CHECK_EQUAL( mp[6], 0xC6 );
    BOOST_CHECK_EQUAL( mp[7], 0xC7 );
    BOOST_CHECK_EQUAL( mp[8], 0xC8 );
    BOOST_CHECK_EQUAL( mp[9], 0xC9 );
}

BOOST_AUTO_TEST_CASE( get )
{
    MessagePayload mp_filled = create_message_payload( 10 );
    fill_message_payload( 10, 0xC0, mp_filled );

    uint8_t *mp_ptr = mp_filled.get();
    BOOST_CHECK_EQUAL( mp_ptr[0], 0xC0 );
    BOOST_CHECK_EQUAL( mp_ptr[1], 0xC1 );
    BOOST_CHECK_EQUAL( mp_ptr[2], 0xC2 );
    BOOST_CHECK_EQUAL( mp_ptr[3], 0xC3 );
    BOOST_CHECK_EQUAL( mp_ptr[4], 0xC4 );
    BOOST_CHECK_EQUAL( mp_ptr[5], 0xC5 );
    BOOST_CHECK_EQUAL( mp_ptr[6], 0xC6 );
    BOOST_CHECK_EQUAL( mp_ptr[7], 0xC7 );
    BOOST_CHECK_EQUAL( mp_ptr[8], 0xC8 );
    BOOST_CHECK_EQUAL( mp_ptr[9], 0xC9 );
}

BOOST_AUTO_TEST_CASE( append )
{
    MessagePayload mp_original( 10 );
    fill_message_payload( 10, 0xC0, mp_original );

    MessagePayload mp_extra( 10 );
    fill_message_payload( 10, 0xB0, mp_extra );

    mp_original.append( mp_extra.get(), 10 );

    BOOST_CHECK_EQUAL( mp_original[0], 0xC0 );
    BOOST_CHECK_EQUAL( mp_original[1], 0xC1 );
    BOOST_CHECK_EQUAL( mp_original[2], 0xC2 );
    BOOST_CHECK_EQUAL( mp_original[3], 0xC3 );
    BOOST_CHECK_EQUAL( mp_original[4], 0xC4 );
    BOOST_CHECK_EQUAL( mp_original[5], 0xC5 );
    BOOST_CHECK_EQUAL( mp_original[6], 0xC6 );
    BOOST_CHECK_EQUAL( mp_original[7], 0xC7 );
    BOOST_CHECK_EQUAL( mp_original[8], 0xC8 );
    BOOST_CHECK_EQUAL( mp_original[9], 0xC9 );

    BOOST_CHECK_EQUAL( mp_original[10], 0xB0 );
    BOOST_CHECK_EQUAL( mp_original[11], 0xB1 );
    BOOST_CHECK_EQUAL( mp_original[12], 0xB2 );
    BOOST_CHECK_EQUAL( mp_original[13], 0xB3 );
    BOOST_CHECK_EQUAL( mp_original[14], 0xB4 );
    BOOST_CHECK_EQUAL( mp_original[15], 0xB5 );
    BOOST_CHECK_EQUAL( mp_original[16], 0xB6 );
    BOOST_CHECK_EQUAL( mp_original[17], 0xB7 );
    BOOST_CHECK_EQUAL( mp_original[18], 0xB8 );
    BOOST_CHECK_EQUAL( mp_original[19], 0xB9 );
}

BOOST_AUTO_TEST_CASE( decode1 )
{
    MessagePayload mp = create_message_payload( 2 );
    mp[0] = 0xAA;
    mp[1] = 0xAA;

    BOOST_CHECK_EQUAL( mp.decode1( 0, 0 ), true );
    BOOST_CHECK_EQUAL( mp.decode1( 0, 1 ), false );
    BOOST_CHECK_EQUAL( mp.decode1( 0, 2 ), true );
    BOOST_CHECK_EQUAL( mp.decode1( 0, 3 ), false );
    BOOST_CHECK_EQUAL( mp.decode1( 0, 4 ), true );
    BOOST_CHECK_EQUAL( mp.decode1( 0, 5 ), false );
    BOOST_CHECK_EQUAL( mp.decode1( 0, 6 ), true );
    BOOST_CHECK_EQUAL( mp.decode1( 0, 7 ), false );
    BOOST_CHECK_EQUAL( mp.decode1( 1, 0 ), true );
    BOOST_CHECK_EQUAL( mp.decode1( 1, 1 ), false );
    BOOST_CHECK_EQUAL( mp.decode1( 1, 2 ), true );
    BOOST_CHECK_EQUAL( mp.decode1( 1, 3 ), false );
    BOOST_CHECK_EQUAL( mp.decode1( 1, 4 ), true );
    BOOST_CHECK_EQUAL( mp.decode1( 1, 5 ), false );
    BOOST_CHECK_EQUAL( mp.decode1( 1, 6 ), true );
    BOOST_CHECK_EQUAL( mp.decode1( 1, 7 ), false );
}

BOOST_AUTO_TEST_CASE( encode1 )
{
    MessagePayload mp = create_message_payload( 2 );
    mp[0] = 0x00;
    mp[1] = 0xFF;

    mp.encode1( 0, 0, true );
    mp.encode1( 0, 1, false );
    mp.encode1( 0, 2, true );
    mp.encode1( 0, 3, false );
    mp.encode1( 0, 4, true );
    mp.encode1( 0, 5, false );
    mp.encode1( 0, 6, true );
    mp.encode1( 0, 7, false );
    mp.encode1( 1, 0, true );
    mp.encode1( 1, 1, false );
    mp.encode1( 1, 2, true );
    mp.encode1( 1, 3, false );
    mp.encode1( 1, 4, true );
    mp.encode1( 1, 5, false );
    mp.encode1( 1, 6, true );
    mp.encode1( 1, 7, false );

    BOOST_CHECK_EQUAL( mp[0], 0xAA );
    BOOST_CHECK_EQUAL( mp[1], 0xAA );
}

BOOST_AUTO_TEST_CASE( decode16 )
{
    MessagePayload mp = create_message_payload( 10 );
    fill_message_payload( 10, 0xC0, mp );

    BOOST_CHECK_EQUAL( mp.decode16( 0, 1 ), 0xC0C1 );
    BOOST_CHECK_EQUAL( mp.decode16( 1, 2 ), 0xC1C2 );
    BOOST_CHECK_EQUAL( mp.decode16( 2, 3 ), 0xC2C3 );
    BOOST_CHECK_EQUAL( mp.decode16( 3, 4 ), 0xC3C4 );
    BOOST_CHECK_EQUAL( mp.decode16( 4, 5 ), 0xC4C5 );
    BOOST_CHECK_EQUAL( mp.decode16( 5, 6 ), 0xC5C6 );
    BOOST_CHECK_EQUAL( mp.decode16( 6, 7 ), 0xC6C7 );
    BOOST_CHECK_EQUAL( mp.decode16( 7, 8 ), 0xC7C8 );
    BOOST_CHECK_EQUAL( mp.decode16( 8, 9 ), 0xC8C9 );
}

BOOST_AUTO_TEST_CASE( encode16 )
{
    MessagePayload mp = create_message_payload( 10 );

    mp.encode16( 0, 1, 0xC0C1 );
    mp.encode16( 1, 2, 0xC1C2 );
    mp.encode16( 2, 3, 0xC2C3 );
    mp.encode16( 3, 4, 0xC3C4 );
    mp.encode16( 4, 5, 0xC4C5 );
    mp.encode16( 5, 6, 0xC5C6 );
    mp.encode16( 6, 7, 0xC6C7 );
    mp.encode16( 7, 8, 0xC7C8 );
    mp.encode16( 8, 9, 0xC8C9 );

    BOOST_CHECK_EQUAL( mp[0], 0xC0 );
    BOOST_CHECK_EQUAL( mp[1], 0xC1 );
    BOOST_CHECK_EQUAL( mp[2], 0xC2 );
    BOOST_CHECK_EQUAL( mp[3], 0xC3 );
    BOOST_CHECK_EQUAL( mp[4], 0xC4 );
    BOOST_CHECK_EQUAL( mp[5], 0xC5 );
    BOOST_CHECK_EQUAL( mp[6], 0xC6 );
    BOOST_CHECK_EQUAL( mp[7], 0xC7 );
    BOOST_CHECK_EQUAL( mp[8], 0xC8 );
    BOOST_CHECK_EQUAL( mp[9], 0xC9 );
}

BOOST_AUTO_TEST_CASE( decode32 )
{
    MessagePayload mp = create_message_payload( 10 );
    fill_message_payload( 10, 0xC0, mp );

    BOOST_CHECK_EQUAL( mp.decode32( 0, 3 ), 0xC0C1C2C3 );
    BOOST_CHECK_EQUAL( mp.decode32( 1, 4 ), 0xC1C2C3C4 );
    BOOST_CHECK_EQUAL( mp.decode32( 2, 5 ), 0xC2C3C4C5 );
    BOOST_CHECK_EQUAL( mp.decode32( 3, 6 ), 0xC3C4C5C6 );
    BOOST_CHECK_EQUAL( mp.decode32( 4, 7 ), 0xC4C5C6C7 );
    BOOST_CHECK_EQUAL( mp.decode32( 5, 8 ), 0xC5C6C7C8 );
    BOOST_CHECK_EQUAL( mp.decode32( 6, 9 ), 0xC6C7C8C9 );
}

BOOST_AUTO_TEST_CASE( encode32 )
{
    MessagePayload mp = create_message_payload( 10 );

    mp.encode32( 0, 3, 0xC0C1C2C3 );
    mp.encode32( 1, 4, 0xC1C2C3C4 );
    mp.encode32( 2, 5, 0xC2C3C4C5 );
    mp.encode32( 3, 6, 0xC3C4C5C6 );
    mp.encode32( 4, 7, 0xC4C5C6C7 );
    mp.encode32( 5, 8, 0xC5C6C7C8 );
    mp.encode32( 6, 9, 0xC6C7C8C9 );

    BOOST_CHECK_EQUAL( mp[0], 0xC0 );
    BOOST_CHECK_EQUAL( mp[1], 0xC1 );
    BOOST_CHECK_EQUAL( mp[2], 0xC2 );
    BOOST_CHECK_EQUAL( mp[3], 0xC3 );
    BOOST_CHECK_EQUAL( mp[4], 0xC4 );
    BOOST_CHECK_EQUAL( mp[5], 0xC5 );
    BOOST_CHECK_EQUAL( mp[6], 0xC6 );
    BOOST_CHECK_EQUAL( mp[7], 0xC7 );
    BOOST_CHECK_EQUAL( mp[8], 0xC8 );
    BOOST_CHECK_EQUAL( mp[9], 0xC9 );
}

BOOST_AUTO_TEST_CASE( read )
{
    uint8_t numbers[] = {
            0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9
    };
    std::size_t numbers_count = sizeof(numbers);

    std::basic_stringbuf<uint8_t> sb;
    sb.pubsetbuf( numbers, numbers_count );
    std::basic_istream<uint8_t> is( &sb );

    MessagePayload mp = create_message_payload( numbers_count );
    mp.read( reinterpret_cast<std::istream&>(is) );

    BOOST_CHECK_EQUAL( mp[0], 0xC0 );
    BOOST_CHECK_EQUAL( mp[1], 0xC1 );
    BOOST_CHECK_EQUAL( mp[2], 0xC2 );
    BOOST_CHECK_EQUAL( mp[3], 0xC3 );
    BOOST_CHECK_EQUAL( mp[4], 0xC4 );
    BOOST_CHECK_EQUAL( mp[5], 0xC5 );
    BOOST_CHECK_EQUAL( mp[6], 0xC6 );
    BOOST_CHECK_EQUAL( mp[7], 0xC7 );
    BOOST_CHECK_EQUAL( mp[8], 0xC8 );
    BOOST_CHECK_EQUAL( mp[9], 0xC9 );
}

BOOST_AUTO_TEST_CASE( write )
{
    uint8_t numbers[ 10 ];
    std::fill( numbers, numbers + 9, 0 );

    std::size_t numbers_count = sizeof(numbers);

    std::basic_stringbuf<uint8_t> sb;
    sb.pubsetbuf( numbers, numbers_count );
    std::basic_ostream<uint8_t> os( &sb );

    MessagePayload mp = create_message_payload( numbers_count );
    fill_message_payload( numbers_count, 0xC0, mp );
    mp.write( reinterpret_cast<std::ostream&>(os) );
    os.flush();

    BOOST_CHECK_EQUAL( numbers[0], 0xC0 );
    BOOST_CHECK_EQUAL( numbers[1], 0xC1 );
    BOOST_CHECK_EQUAL( numbers[2], 0xC2 );
    BOOST_CHECK_EQUAL( numbers[3], 0xC3 );
    BOOST_CHECK_EQUAL( numbers[4], 0xC4 );
    BOOST_CHECK_EQUAL( numbers[5], 0xC5 );
    BOOST_CHECK_EQUAL( numbers[6], 0xC6 );
    BOOST_CHECK_EQUAL( numbers[7], 0xC7 );
    BOOST_CHECK_EQUAL( numbers[8], 0xC8 );
    BOOST_CHECK_EQUAL( numbers[9], 0xC9 );
}

BOOST_AUTO_TEST_SUITE_END()
Commit	Line	Data
	1	/*
	2	The software in this package is distributed under the GNU General
	3	Public License version 2 (with a special exception described below).
	4
	5	A copy of GNU General Public License (GPL) is included in this distribution,
	6	in the file COPYING.GPL.
	7
	8	As a special exception, if other files instantiate templates or use macros
	9	or inline functions from this file, or you compile this file and link it
	10	with other works to produce a work based on this file, this file
	11	does not by itself cause the resulting work to be covered
	12	by the GNU General Public License.
	13
	14	However the source code for this file must still be made available
	15	in accordance with section (3) of the GNU General Public License.
	16
	17	This exception does not invalidate any other reasons why a work based
	18	on this file might be covered by the GNU General Public License.
	19	*/
	20
	21	#define BOOST_TEST_MAIN
	22	#define BOOST_TEST_DYN_LINK
	23
	24	#include <streambuf>
	25
	26	#include <boost/test/unit_test.hpp>
	27
	28	#include "host/messagepayload.h"
	29
	30	//------------------------------------------------------------------------------
	31
	32	MessagePayload create_message_payload( const std::size_t bytes_total );
	33	void fill_message_payload(
	34	const std::size_t bytes_total,
	35	const uint8_t first_value,
	36	MessagePayload& mp
	37	);
	38
	39	//------------------------------------------------------------------------------
	40
	41	MessagePayload create_message_payload( const std::size_t bytes_total )
	42	{
	43	return MessagePayload( bytes_total );
	44	}
	45
	46	void fill_message_payload(
	47	const std::size_t bytes_total,
	48	const uint8_t first_value,
	49	MessagePayload& mp
	50	)
	51	{
	52	for ( std::size_t byte_index = 0; byte_index < bytes_total; byte_index++ )
	53	{
	54	mp[ byte_index ] = static_cast<uint8_t>( first_value + byte_index );
	55	}
	56	}
	57
	58	//------------------------------------------------------------------------------
	59
	60	BOOST_AUTO_TEST_SUITE( TestMessagePayload )
	61
	62	BOOST_AUTO_TEST_CASE( basic_assignment )
	63	{
	64	MessagePayload mp_filled = create_message_payload( 10 );
	65	fill_message_payload( 10, 0xC0, mp_filled );
	66
	67	MessagePayload mp_assigned = create_message_payload( 10 );
	68	mp_assigned = mp_filled;
	69
	70	BOOST_CHECK_EQUAL( mp_assigned[0], 0xC0 );
	71	BOOST_CHECK_EQUAL( mp_assigned[1], 0xC1 );
	72	BOOST_CHECK_EQUAL( mp_assigned[2], 0xC2 );
	73	BOOST_CHECK_EQUAL( mp_assigned[3], 0xC3 );
	74	BOOST_CHECK_EQUAL( mp_assigned[4], 0xC4 );
	75	BOOST_CHECK_EQUAL( mp_assigned[5], 0xC5 );
	76	BOOST_CHECK_EQUAL( mp_assigned[6], 0xC6 );
	77	BOOST_CHECK_EQUAL( mp_assigned[7], 0xC7 );
	78	BOOST_CHECK_EQUAL( mp_assigned[8], 0xC8 );
	79	BOOST_CHECK_EQUAL( mp_assigned[9], 0xC9 );
	80	}
	81
	82	BOOST_AUTO_TEST_CASE( array_subscript_const )
	83	{
	84	MessagePayload mp_filled = create_message_payload( 10 );
	85	fill_message_payload( 10, 0xC0, mp_filled );
	86
	87	const MessagePayload mp_const( mp_filled );
	88
	89	BOOST_CHECK_EQUAL( mp_const[0], 0xC0 );
	90	BOOST_CHECK_EQUAL( mp_const[1], 0xC1 );
	91	BOOST_CHECK_EQUAL( mp_const[2], 0xC2 );
	92	BOOST_CHECK_EQUAL( mp_const[3], 0xC3 );
	93	BOOST_CHECK_EQUAL( mp_const[4], 0xC4 );
	94	BOOST_CHECK_EQUAL( mp_const[5], 0xC5 );
	95	BOOST_CHECK_EQUAL( mp_const[6], 0xC6 );
	96	BOOST_CHECK_EQUAL( mp_const[7], 0xC7 );
	97	BOOST_CHECK_EQUAL( mp_const[8], 0xC8 );
	98	BOOST_CHECK_EQUAL( mp_const[9], 0xC9 );
	99	}
	100
	101	BOOST_AUTO_TEST_CASE( array_subscript )
	102	{
	103	MessagePayload mp( 10 );
	104	mp[0] = 0xC0;
	105	mp[1] = 0xC1;
	106	mp[2] = 0xC2;
	107	mp[3] = 0xC3;
	108	mp[4] = 0xC4;
	109	mp[5] = 0xC5;
	110	mp[6] = 0xC6;
	111	mp[7] = 0xC7;
	112	mp[8] = 0xC8;
	113	mp[9] = 0xC9;
	114
	115	BOOST_CHECK_EQUAL( mp[0], 0xC0 );
	116	BOOST_CHECK_EQUAL( mp[1], 0xC1 );
	117	BOOST_CHECK_EQUAL( mp[2], 0xC2 );
	118	BOOST_CHECK_EQUAL( mp[3], 0xC3 );
	119	BOOST_CHECK_EQUAL( mp[4], 0xC4 );
	120	BOOST_CHECK_EQUAL( mp[5], 0xC5 );
	121	BOOST_CHECK_EQUAL( mp[6], 0xC6 );
	122	BOOST_CHECK_EQUAL( mp[7], 0xC7 );
	123	BOOST_CHECK_EQUAL( mp[8], 0xC8 );
	124	BOOST_CHECK_EQUAL( mp[9], 0xC9 );
	125	}
	126
	127	BOOST_AUTO_TEST_CASE( get )
	128	{
	129	MessagePayload mp_filled = create_message_payload( 10 );
	130	fill_message_payload( 10, 0xC0, mp_filled );
	131
	132	uint8_t *mp_ptr = mp_filled.get();
	133	BOOST_CHECK_EQUAL( mp_ptr[0], 0xC0 );
	134	BOOST_CHECK_EQUAL( mp_ptr[1], 0xC1 );
	135	BOOST_CHECK_EQUAL( mp_ptr[2], 0xC2 );
	136	BOOST_CHECK_EQUAL( mp_ptr[3], 0xC3 );
	137	BOOST_CHECK_EQUAL( mp_ptr[4], 0xC4 );
	138	BOOST_CHECK_EQUAL( mp_ptr[5], 0xC5 );
	139	BOOST_CHECK_EQUAL( mp_ptr[6], 0xC6 );
	140	BOOST_CHECK_EQUAL( mp_ptr[7], 0xC7 );
	141	BOOST_CHECK_EQUAL( mp_ptr[8], 0xC8 );
	142	BOOST_CHECK_EQUAL( mp_ptr[9], 0xC9 );
	143	}
	144
	145	BOOST_AUTO_TEST_CASE( append )
	146	{
	147	MessagePayload mp_original( 10 );
	148	fill_message_payload( 10, 0xC0, mp_original );
	149
	150	MessagePayload mp_extra( 10 );
	151	fill_message_payload( 10, 0xB0, mp_extra );
	152
	153	mp_original.append( mp_extra.get(), 10 );
	154
	155	BOOST_CHECK_EQUAL( mp_original[0], 0xC0 );
	156	BOOST_CHECK_EQUAL( mp_original[1], 0xC1 );
	157	BOOST_CHECK_EQUAL( mp_original[2], 0xC2 );
	158	BOOST_CHECK_EQUAL( mp_original[3], 0xC3 );
	159	BOOST_CHECK_EQUAL( mp_original[4], 0xC4 );
	160	BOOST_CHECK_EQUAL( mp_original[5], 0xC5 );
	161	BOOST_CHECK_EQUAL( mp_original[6], 0xC6 );
	162	BOOST_CHECK_EQUAL( mp_original[7], 0xC7 );
	163	BOOST_CHECK_EQUAL( mp_original[8], 0xC8 );
	164	BOOST_CHECK_EQUAL( mp_original[9], 0xC9 );
	165
	166	BOOST_CHECK_EQUAL( mp_original[10], 0xB0 );
	167	BOOST_CHECK_EQUAL( mp_original[11], 0xB1 );
	168	BOOST_CHECK_EQUAL( mp_original[12], 0xB2 );
	169	BOOST_CHECK_EQUAL( mp_original[13], 0xB3 );
	170	BOOST_CHECK_EQUAL( mp_original[14], 0xB4 );
	171	BOOST_CHECK_EQUAL( mp_original[15], 0xB5 );
	172	BOOST_CHECK_EQUAL( mp_original[16], 0xB6 );
	173	BOOST_CHECK_EQUAL( mp_original[17], 0xB7 );
	174	BOOST_CHECK_EQUAL( mp_original[18], 0xB8 );
	175	BOOST_CHECK_EQUAL( mp_original[19], 0xB9 );
	176	}
	177
	178	BOOST_AUTO_TEST_CASE( decode1 )
	179	{
	180	MessagePayload mp = create_message_payload( 2 );
	181	mp[0] = 0xAA;
	182	mp[1] = 0xAA;
	183
	184	BOOST_CHECK_EQUAL( mp.decode1( 0, 0 ), true );
	185	BOOST_CHECK_EQUAL( mp.decode1( 0, 1 ), false );
	186	BOOST_CHECK_EQUAL( mp.decode1( 0, 2 ), true );
	187	BOOST_CHECK_EQUAL( mp.decode1( 0, 3 ), false );
	188	BOOST_CHECK_EQUAL( mp.decode1( 0, 4 ), true );
	189	BOOST_CHECK_EQUAL( mp.decode1( 0, 5 ), false );
	190	BOOST_CHECK_EQUAL( mp.decode1( 0, 6 ), true );
	191	BOOST_CHECK_EQUAL( mp.decode1( 0, 7 ), false );
	192	BOOST_CHECK_EQUAL( mp.decode1( 1, 0 ), true );
	193	BOOST_CHECK_EQUAL( mp.decode1( 1, 1 ), false );
	194	BOOST_CHECK_EQUAL( mp.decode1( 1, 2 ), true );
	195	BOOST_CHECK_EQUAL( mp.decode1( 1, 3 ), false );
	196	BOOST_CHECK_EQUAL( mp.decode1( 1, 4 ), true );
	197	BOOST_CHECK_EQUAL( mp.decode1( 1, 5 ), false );
	198	BOOST_CHECK_EQUAL( mp.decode1( 1, 6 ), true );
	199	BOOST_CHECK_EQUAL( mp.decode1( 1, 7 ), false );
	200	}
	201
	202	BOOST_AUTO_TEST_CASE( encode1 )
	203	{
	204	MessagePayload mp = create_message_payload( 2 );
	205	mp[0] = 0x00;
	206	mp[1] = 0xFF;
	207
	208	mp.encode1( 0, 0, true );
	209	mp.encode1( 0, 1, false );
	210	mp.encode1( 0, 2, true );
	211	mp.encode1( 0, 3, false );
	212	mp.encode1( 0, 4, true );
	213	mp.encode1( 0, 5, false );
	214	mp.encode1( 0, 6, true );
	215	mp.encode1( 0, 7, false );
	216	mp.encode1( 1, 0, true );
	217	mp.encode1( 1, 1, false );
	218	mp.encode1( 1, 2, true );
	219	mp.encode1( 1, 3, false );
	220	mp.encode1( 1, 4, true );
	221	mp.encode1( 1, 5, false );
	222	mp.encode1( 1, 6, true );
	223	mp.encode1( 1, 7, false );
	224
	225	BOOST_CHECK_EQUAL( mp[0], 0xAA );
	226	BOOST_CHECK_EQUAL( mp[1], 0xAA );
	227	}
	228
	229	BOOST_AUTO_TEST_CASE( decode16 )
	230	{
	231	MessagePayload mp = create_message_payload( 10 );
	232	fill_message_payload( 10, 0xC0, mp );
	233
	234	BOOST_CHECK_EQUAL( mp.decode16( 0, 1 ), 0xC0C1 );
	235	BOOST_CHECK_EQUAL( mp.decode16( 1, 2 ), 0xC1C2 );
	236	BOOST_CHECK_EQUAL( mp.decode16( 2, 3 ), 0xC2C3 );
	237	BOOST_CHECK_EQUAL( mp.decode16( 3, 4 ), 0xC3C4 );
	238	BOOST_CHECK_EQUAL( mp.decode16( 4, 5 ), 0xC4C5 );
	239	BOOST_CHECK_EQUAL( mp.decode16( 5, 6 ), 0xC5C6 );
	240	BOOST_CHECK_EQUAL( mp.decode16( 6, 7 ), 0xC6C7 );
	241	BOOST_CHECK_EQUAL( mp.decode16( 7, 8 ), 0xC7C8 );
	242	BOOST_CHECK_EQUAL( mp.decode16( 8, 9 ), 0xC8C9 );
	243	}
	244
	245	BOOST_AUTO_TEST_CASE( encode16 )
	246	{
	247	MessagePayload mp = create_message_payload( 10 );
	248
	249	mp.encode16( 0, 1, 0xC0C1 );
	250	mp.encode16( 1, 2, 0xC1C2 );
	251	mp.encode16( 2, 3, 0xC2C3 );
	252	mp.encode16( 3, 4, 0xC3C4 );
	253	mp.encode16( 4, 5, 0xC4C5 );
	254	mp.encode16( 5, 6, 0xC5C6 );
	255	mp.encode16( 6, 7, 0xC6C7 );
	256	mp.encode16( 7, 8, 0xC7C8 );
	257	mp.encode16( 8, 9, 0xC8C9 );
	258
	259	BOOST_CHECK_EQUAL( mp[0], 0xC0 );
	260	BOOST_CHECK_EQUAL( mp[1], 0xC1 );
	261	BOOST_CHECK_EQUAL( mp[2], 0xC2 );
	262	BOOST_CHECK_EQUAL( mp[3], 0xC3 );
	263	BOOST_CHECK_EQUAL( mp[4], 0xC4 );
	264	BOOST_CHECK_EQUAL( mp[5], 0xC5 );
	265	BOOST_CHECK_EQUAL( mp[6], 0xC6 );
	266	BOOST_CHECK_EQUAL( mp[7], 0xC7 );
	267	BOOST_CHECK_EQUAL( mp[8], 0xC8 );
	268	BOOST_CHECK_EQUAL( mp[9], 0xC9 );
	269	}
	270
	271	BOOST_AUTO_TEST_CASE( decode32 )
	272	{
	273	MessagePayload mp = create_message_payload( 10 );
	274	fill_message_payload( 10, 0xC0, mp );
	275
	276	BOOST_CHECK_EQUAL( mp.decode32( 0, 3 ), 0xC0C1C2C3 );
	277	BOOST_CHECK_EQUAL( mp.decode32( 1, 4 ), 0xC1C2C3C4 );
	278	BOOST_CHECK_EQUAL( mp.decode32( 2, 5 ), 0xC2C3C4C5 );
	279	BOOST_CHECK_EQUAL( mp.decode32( 3, 6 ), 0xC3C4C5C6 );
	280	BOOST_CHECK_EQUAL( mp.decode32( 4, 7 ), 0xC4C5C6C7 );
	281	BOOST_CHECK_EQUAL( mp.decode32( 5, 8 ), 0xC5C6C7C8 );
	282	BOOST_CHECK_EQUAL( mp.decode32( 6, 9 ), 0xC6C7C8C9 );
	283	}
	284
	285	BOOST_AUTO_TEST_CASE( encode32 )
	286	{
	287	MessagePayload mp = create_message_payload( 10 );
	288
	289	mp.encode32( 0, 3, 0xC0C1C2C3 );
	290	mp.encode32( 1, 4, 0xC1C2C3C4 );
	291	mp.encode32( 2, 5, 0xC2C3C4C5 );
	292	mp.encode32( 3, 6, 0xC3C4C5C6 );
	293	mp.encode32( 4, 7, 0xC4C5C6C7 );
	294	mp.encode32( 5, 8, 0xC5C6C7C8 );
	295	mp.encode32( 6, 9, 0xC6C7C8C9 );
	296
	297	BOOST_CHECK_EQUAL( mp[0], 0xC0 );
	298	BOOST_CHECK_EQUAL( mp[1], 0xC1 );
	299	BOOST_CHECK_EQUAL( mp[2], 0xC2 );
	300	BOOST_CHECK_EQUAL( mp[3], 0xC3 );
	301	BOOST_CHECK_EQUAL( mp[4], 0xC4 );
	302	BOOST_CHECK_EQUAL( mp[5], 0xC5 );
	303	BOOST_CHECK_EQUAL( mp[6], 0xC6 );
	304	BOOST_CHECK_EQUAL( mp[7], 0xC7 );
	305	BOOST_CHECK_EQUAL( mp[8], 0xC8 );
	306	BOOST_CHECK_EQUAL( mp[9], 0xC9 );
	307	}
	308
	309	BOOST_AUTO_TEST_CASE( read )
	310	{
	311	uint8_t numbers[] = {
	312	0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9
	313	};
	314	std::size_t numbers_count = sizeof(numbers);
	315
	316	std::basic_stringbuf<uint8_t> sb;
	317	sb.pubsetbuf( numbers, numbers_count );
	318	std::basic_istream<uint8_t> is( &sb );
	319
	320	MessagePayload mp = create_message_payload( numbers_count );
	321	mp.read( reinterpret_cast<std::istream&>(is) );
	322
	323	BOOST_CHECK_EQUAL( mp[0], 0xC0 );
	324	BOOST_CHECK_EQUAL( mp[1], 0xC1 );
	325	BOOST_CHECK_EQUAL( mp[2], 0xC2 );
	326	BOOST_CHECK_EQUAL( mp[3], 0xC3 );
	327	BOOST_CHECK_EQUAL( mp[4], 0xC4 );
	328	BOOST_CHECK_EQUAL( mp[5], 0xC5 );
	329	BOOST_CHECK_EQUAL( mp[6], 0xC6 );
	330	BOOST_CHECK_EQUAL( mp[7], 0xC7 );
	331	BOOST_CHECK_EQUAL( mp[8], 0xC8 );
	332	BOOST_CHECK_EQUAL( mp[9], 0xC9 );
	333	}
	334
	335	BOOST_AUTO_TEST_CASE( write )
	336	{
	337	uint8_t numbers[ 10 ];
	338	std::fill( numbers, numbers + 9, 0 );
	339
	340	std::size_t numbers_count = sizeof(numbers);
	341
	342	std::basic_stringbuf<uint8_t> sb;
	343	sb.pubsetbuf( numbers, numbers_count );
	344	std::basic_ostream<uint8_t> os( &sb );
	345
	346	MessagePayload mp = create_message_payload( numbers_count );
	347	fill_message_payload( numbers_count, 0xC0, mp );
	348	mp.write( reinterpret_cast<std::ostream&>(os) );
	349	os.flush();
	350
	351	BOOST_CHECK_EQUAL( numbers[0], 0xC0 );
	352	BOOST_CHECK_EQUAL( numbers[1], 0xC1 );
	353	BOOST_CHECK_EQUAL( numbers[2], 0xC2 );
	354	BOOST_CHECK_EQUAL( numbers[3], 0xC3 );
	355	BOOST_CHECK_EQUAL( numbers[4], 0xC4 );
	356	BOOST_CHECK_EQUAL( numbers[5], 0xC5 );
	357	BOOST_CHECK_EQUAL( numbers[6], 0xC6 );
	358	BOOST_CHECK_EQUAL( numbers[7], 0xC7 );
	359	BOOST_CHECK_EQUAL( numbers[8], 0xC8 );
	360	BOOST_CHECK_EQUAL( numbers[9], 0xC9 );
	361	}
	362
	363	BOOST_AUTO_TEST_SUITE_END()