developer.intra2net.com Git - pingcheck/blob - test/test_messagepayload.cpp

   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()