third_party/nlio/repo/tests/nlio-byteorder-test-cxx.cpp

   1 /**
   2  *    Copyright 2015-2016 Nest Labs Inc. All Rights Reserved.
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 /**
  18  *    @file
  19  *      This file implements a unit test suite for the C language
  20  *      binding of the Nest Labs memory-mapped I/O functions with
  21  *      byte reordering.
  22  *
  23  */
  24
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27
  28 #include <nlio-byteorder.hpp>
  29
  30 #include <nlunit-test.h>
  31
  32 #include "nlio-byteorder-test.h"
  33
  34 using namespace nl;
  35 using namespace nl::ByteOrder;
  36 using namespace nl::IO;
  37
  38 static void CheckGetBig(nlTestSuite *inSuite, void *inContext)
  39 {
  40     const uint8_t  v8_in  = MAGIC8;
  41     const uint16_t v16_in = MAGIC16;
  42     const uint32_t v32_in = MAGIC32;
  43     const uint64_t v64_in = MAGIC64;
  44     uint8_t        v8_out;
  45     uint16_t       v16_out;
  46     uint32_t       v32_out;
  47     uint64_t       v64_out;
  48
  49     v8_out  = BigEndian::Get8(&v8_in);
  50     v16_out = BigEndian::Get16(&v16_in);
  51     v32_out = BigEndian::Get32(&v32_in);
  52     v64_out = BigEndian::Get64(&v64_in);
  53
  54 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
  55     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
  56     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
  57     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
  58     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
  59
  60 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
  61     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
  62     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
  63     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
  64     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
  65
  66 #else
  67     NL_TEST_ASSERT(inSuite, false);
  68
  69 #endif
  70 }
  71
  72 static void CheckGetLittle(nlTestSuite *inSuite, void *inContext)
  73 {
  74     const uint8_t  v8_in  = MAGIC8;
  75     const uint16_t v16_in = MAGIC16;
  76     const uint32_t v32_in = MAGIC32;
  77     const uint64_t v64_in = MAGIC64;
  78     uint8_t        v8_out;
  79     uint16_t       v16_out;
  80     uint32_t       v32_out;
  81     uint64_t       v64_out;
  82
  83     v8_out  = LittleEndian::Get8(&v8_in);
  84     v16_out = LittleEndian::Get16(&v16_in);
  85     v32_out = LittleEndian::Get32(&v32_in);
  86     v64_out = LittleEndian::Get64(&v64_in);
  87
  88 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
  89     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
  90     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
  91     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
  92     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
  93
  94 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
  95     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
  96     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
  97     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
  98     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
  99
 100 #else
 101     NL_TEST_ASSERT(inSuite, false);
 102
 103 #endif
 104 }
 105
 106 static void CheckPutBig(nlTestSuite *inSuite, void *inContext)
 107 {
 108     const uint8_t  v8_in  = MAGIC8;
 109     const uint16_t v16_in = MAGIC16;
 110     const uint32_t v32_in = MAGIC32;
 111     const uint64_t v64_in = MAGIC64;
 112     uint8_t        v8_out;
 113     uint16_t       v16_out;
 114     uint32_t       v32_out;
 115     uint64_t       v64_out;
 116
 117     BigEndian::Put8(&v8_out,   v8_in);
 118     BigEndian::Put16(&v16_out, v16_in);
 119     BigEndian::Put32(&v32_out, v32_in);
 120     BigEndian::Put64(&v64_out, v64_in);
 121
 122 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 123     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 124     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 125     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 126     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 127
 128 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 129     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 130     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 131     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 132     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 133
 134 #else
 135     NL_TEST_ASSERT(inSuite, false);
 136
 137 #endif
 138 }
 139
 140 static void CheckPutLittle(nlTestSuite *inSuite, void *inContext)
 141 {
 142     const uint8_t  v8_in  = MAGIC8;
 143     const uint16_t v16_in = MAGIC16;
 144     const uint32_t v32_in = MAGIC32;
 145     const uint64_t v64_in = MAGIC64;
 146     uint8_t        v8_out;
 147     uint16_t       v16_out;
 148     uint32_t       v32_out;
 149     uint64_t       v64_out;
 150
 151     LittleEndian::Put8(&v8_out,   v8_in);
 152     LittleEndian::Put16(&v16_out, v16_in);
 153     LittleEndian::Put32(&v32_out, v32_in);
 154     LittleEndian::Put64(&v64_out, v64_in);
 155
 156 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 157     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 158     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 159     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 160     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 161
 162 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 163     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 164     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 165     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 166     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 167
 168 #else
 169     NL_TEST_ASSERT(inSuite, false);
 170
 171 #endif
 172 }
 173
 174 static void CheckReadBig(nlTestSuite *inSuite, void *inContext)
 175 {
 176     const uint8_t  v8_in   = MAGIC8;
 177     const uint16_t v16_in  = MAGIC16;
 178     const uint32_t v32_in  = MAGIC32;
 179     const uint64_t v64_in  = MAGIC64;
 180     const void     *p8_in  = &v8_in;
 181     const void     *p16_in = &v16_in;
 182     const void     *p32_in = &v32_in;
 183     const void     *p64_in = &v64_in;
 184     uint8_t        v8_out;
 185     uint16_t       v16_out;
 186     uint32_t       v32_out;
 187     uint64_t       v64_out;
 188
 189     v8_out  = BigEndian::Read8(p8_in);
 190     v16_out = BigEndian::Read16(p16_in);
 191     v32_out = BigEndian::Read32(p32_in);
 192     v64_out = BigEndian::Read64(p64_in);
 193
 194     NL_TEST_ASSERT(inSuite, p8_in == (&v8_in + 1));
 195     NL_TEST_ASSERT(inSuite, p16_in == (&v16_in + 1));
 196     NL_TEST_ASSERT(inSuite, p32_in == (&v32_in + 1));
 197     NL_TEST_ASSERT(inSuite, p64_in == (&v64_in + 1));
 198
 199 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 200     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 201     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 202     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 203     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 204
 205 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 206     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 207     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 208     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 209     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 210
 211 #else
 212     NL_TEST_ASSERT(inSuite, false);
 213
 214 #endif
 215 }
 216
 217 static void CheckReadLittle(nlTestSuite *inSuite, void *inContext)
 218 {
 219     const uint8_t  v8_in   = MAGIC8;
 220     const uint16_t v16_in  = MAGIC16;
 221     const uint32_t v32_in  = MAGIC32;
 222     const uint64_t v64_in  = MAGIC64;
 223     const void     *p8_in  = &v8_in;
 224     const void     *p16_in = &v16_in;
 225     const void     *p32_in = &v32_in;
 226     const void     *p64_in = &v64_in;
 227     uint8_t        v8_out;
 228     uint16_t       v16_out;
 229     uint32_t       v32_out;
 230     uint64_t       v64_out;
 231
 232     v8_out  = LittleEndian::Read8(p8_in);
 233     v16_out = LittleEndian::Read16(p16_in);
 234     v32_out = LittleEndian::Read32(p32_in);
 235     v64_out = LittleEndian::Read64(p64_in);
 236
 237     NL_TEST_ASSERT(inSuite, p8_in == (&v8_in + 1));
 238     NL_TEST_ASSERT(inSuite, p16_in == (&v16_in + 1));
 239     NL_TEST_ASSERT(inSuite, p32_in == (&v32_in + 1));
 240     NL_TEST_ASSERT(inSuite, p64_in == (&v64_in + 1));
 241
 242 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 243     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 244     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 245     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 246     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 247
 248 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 249     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 250     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 251     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 252     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 253
 254 #else
 255     NL_TEST_ASSERT(inSuite, false);
 256
 257 #endif
 258 }
 259
 260 static void CheckWriteBig(nlTestSuite *inSuite, void *inContext)
 261 {
 262     const uint8_t  v8_in   = MAGIC8;
 263     const uint16_t v16_in  = MAGIC16;
 264     const uint32_t v32_in  = MAGIC32;
 265     const uint64_t v64_in  = MAGIC64;
 266     uint8_t        v8_out;
 267     uint16_t       v16_out;
 268     uint32_t       v32_out;
 269     uint64_t       v64_out;
 270     void           *p8_out  = &v8_out;
 271     void           *p16_out = &v16_out;
 272     void           *p32_out = &v32_out;
 273     void           *p64_out = &v64_out;
 274
 275     BigEndian::Write8(p8_out, v8_in);
 276     BigEndian::Write16(p16_out, v16_in);
 277     BigEndian::Write32(p32_out, v32_in);
 278     BigEndian::Write64(p64_out, v64_in);
 279
 280     NL_TEST_ASSERT(inSuite, p8_out == (&v8_out + 1));
 281     NL_TEST_ASSERT(inSuite, p16_out == (&v16_out + 1));
 282     NL_TEST_ASSERT(inSuite, p32_out == (&v32_out + 1));
 283     NL_TEST_ASSERT(inSuite, p64_out == (&v64_out + 1));
 284
 285 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 286     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 287     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 288     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 289     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 290
 291 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 292     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 293     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 294     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 295     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 296
 297 #else
 298     NL_TEST_ASSERT(inSuite, false);
 299
 300 #endif
 301 }
 302
 303 static void CheckWriteLittle(nlTestSuite *inSuite, void *inContext)
 304 {
 305     const uint8_t  v8_in   = MAGIC8;
 306     const uint16_t v16_in  = MAGIC16;
 307     const uint32_t v32_in  = MAGIC32;
 308     const uint64_t v64_in  = MAGIC64;
 309     uint8_t        v8_out;
 310     uint16_t       v16_out;
 311     uint32_t       v32_out;
 312     uint64_t       v64_out;
 313     void           *p8_out  = &v8_out;
 314     void           *p16_out = &v16_out;
 315     void           *p32_out = &v32_out;
 316     void           *p64_out = &v64_out;
 317
 318     LittleEndian::Write8(p8_out, v8_in);
 319     LittleEndian::Write16(p16_out, v16_in);
 320     LittleEndian::Write32(p32_out, v32_in);
 321     LittleEndian::Write64(p64_out, v64_in);
 322
 323     NL_TEST_ASSERT(inSuite, p8_out == (&v8_out + 1));
 324     NL_TEST_ASSERT(inSuite, p16_out == (&v16_out + 1));
 325     NL_TEST_ASSERT(inSuite, p32_out == (&v32_out + 1));
 326     NL_TEST_ASSERT(inSuite, p64_out == (&v64_out + 1));
 327
 328 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 329     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 330     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 331     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 332     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 333
 334 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 335     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 336     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 337     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 338     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 339
 340 #else
 341     NL_TEST_ASSERT(inSuite, false);
 342
 343 #endif
 344 }
 345
 346 static void CheckGetBigAligned(nlTestSuite *inSuite, void *inContext)
 347 {
 348     const uint8_t  v8_in  = MAGIC8;
 349     const uint16_t v16_in = MAGIC16;
 350     const uint32_t v32_in = MAGIC32;
 351     const uint64_t v64_in = MAGIC64;
 352     uint8_t        v8_out;
 353     uint16_t       v16_out;
 354     uint32_t       v32_out;
 355     uint64_t       v64_out;
 356
 357     v8_out  = BigEndian::GetAligned8(&v8_in);
 358     v16_out = BigEndian::GetAligned16(&v16_in);
 359     v32_out = BigEndian::GetAligned32(&v32_in);
 360     v64_out = BigEndian::GetAligned64(&v64_in);
 361
 362 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 363     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 364     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 365     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 366     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 367
 368 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 369     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 370     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 371     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 372     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 373
 374 #else
 375     NL_TEST_ASSERT(inSuite, false);
 376
 377 #endif
 378 }
 379
 380 static void CheckGetLittleAligned(nlTestSuite *inSuite, void *inContext)
 381 {
 382     const uint8_t  v8_in  = MAGIC8;
 383     const uint16_t v16_in = MAGIC16;
 384     const uint32_t v32_in = MAGIC32;
 385     const uint64_t v64_in = MAGIC64;
 386     uint8_t        v8_out;
 387     uint16_t       v16_out;
 388     uint32_t       v32_out;
 389     uint64_t       v64_out;
 390
 391     v8_out  = LittleEndian::GetAligned8(&v8_in);
 392     v16_out = LittleEndian::GetAligned16(&v16_in);
 393     v32_out = LittleEndian::GetAligned32(&v32_in);
 394     v64_out = LittleEndian::GetAligned64(&v64_in);
 395
 396 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 397     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 398     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 399     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 400     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 401
 402 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 403     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 404     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 405     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 406     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 407
 408 #else
 409     NL_TEST_ASSERT(inSuite, false);
 410
 411 #endif
 412 }
 413
 414 static void CheckPutBigAligned(nlTestSuite *inSuite, void *inContext)
 415 {
 416     const uint8_t  v8_in  = MAGIC8;
 417     const uint16_t v16_in = MAGIC16;
 418     const uint32_t v32_in = MAGIC32;
 419     const uint64_t v64_in = MAGIC64;
 420     uint8_t        v8_out;
 421     uint16_t       v16_out;
 422     uint32_t       v32_out;
 423     uint64_t       v64_out;
 424
 425     BigEndian::PutAligned8(&v8_out,   v8_in);
 426     BigEndian::PutAligned16(&v16_out, v16_in);
 427     BigEndian::PutAligned32(&v32_out, v32_in);
 428     BigEndian::PutAligned64(&v64_out, v64_in);
 429
 430 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 431     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 432     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 433     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 434     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 435
 436 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 437     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 438     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 439     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 440     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 441
 442 #else
 443     NL_TEST_ASSERT(inSuite, false);
 444
 445 #endif
 446 }
 447
 448 static void CheckPutLittleAligned(nlTestSuite *inSuite, void *inContext)
 449 {
 450     const uint8_t  v8_in  = MAGIC8;
 451     const uint16_t v16_in = MAGIC16;
 452     const uint32_t v32_in = MAGIC32;
 453     const uint64_t v64_in = MAGIC64;
 454     uint8_t        v8_out;
 455     uint16_t       v16_out;
 456     uint32_t       v32_out;
 457     uint64_t       v64_out;
 458
 459     LittleEndian::PutAligned8(&v8_out,   v8_in);
 460     LittleEndian::PutAligned16(&v16_out, v16_in);
 461     LittleEndian::PutAligned32(&v32_out, v32_in);
 462     LittleEndian::PutAligned64(&v64_out, v64_in);
 463
 464 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 465     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 466     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 467     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 468     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 469
 470 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 471     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 472     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 473     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 474     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 475
 476 #else
 477     NL_TEST_ASSERT(inSuite, false);
 478
 479 #endif
 480 }
 481
 482 static void CheckReadBigAligned(nlTestSuite *inSuite, void *inContext)
 483 {
 484     const uint8_t  v8_in   = MAGIC8;
 485     const uint16_t v16_in  = MAGIC16;
 486     const uint32_t v32_in  = MAGIC32;
 487     const uint64_t v64_in  = MAGIC64;
 488     const void     *p8_in  = &v8_in;
 489     const void     *p16_in = &v16_in;
 490     const void     *p32_in = &v32_in;
 491     const void     *p64_in = &v64_in;
 492     uint8_t        v8_out;
 493     uint16_t       v16_out;
 494     uint32_t       v32_out;
 495     uint64_t       v64_out;
 496
 497     v8_out  = BigEndian::ReadAligned8(p8_in);
 498     v16_out = BigEndian::ReadAligned16(p16_in);
 499     v32_out = BigEndian::ReadAligned32(p32_in);
 500     v64_out = BigEndian::ReadAligned64(p64_in);
 501
 502     NL_TEST_ASSERT(inSuite, p8_in == (&v8_in + 1));
 503     NL_TEST_ASSERT(inSuite, p16_in == (&v16_in + 1));
 504     NL_TEST_ASSERT(inSuite, p32_in == (&v32_in + 1));
 505     NL_TEST_ASSERT(inSuite, p64_in == (&v64_in + 1));
 506
 507 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 508     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 509     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 510     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 511     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 512
 513 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 514     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 515     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 516     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 517     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 518
 519 #else
 520     NL_TEST_ASSERT(inSuite, false);
 521
 522 #endif
 523 }
 524
 525 static void CheckReadLittleAligned(nlTestSuite *inSuite, void *inContext)
 526 {
 527     const uint8_t  v8_in   = MAGIC8;
 528     const uint16_t v16_in  = MAGIC16;
 529     const uint32_t v32_in  = MAGIC32;
 530     const uint64_t v64_in  = MAGIC64;
 531     const void     *p8_in  = &v8_in;
 532     const void     *p16_in = &v16_in;
 533     const void     *p32_in = &v32_in;
 534     const void     *p64_in = &v64_in;
 535     uint8_t        v8_out;
 536     uint16_t       v16_out;
 537     uint32_t       v32_out;
 538     uint64_t       v64_out;
 539
 540     v8_out  = LittleEndian::ReadAligned8(p8_in);
 541     v16_out = LittleEndian::ReadAligned16(p16_in);
 542     v32_out = LittleEndian::ReadAligned32(p32_in);
 543     v64_out = LittleEndian::ReadAligned64(p64_in);
 544
 545     NL_TEST_ASSERT(inSuite, p8_in == (&v8_in + 1));
 546     NL_TEST_ASSERT(inSuite, p16_in == (&v16_in + 1));
 547     NL_TEST_ASSERT(inSuite, p32_in == (&v32_in + 1));
 548     NL_TEST_ASSERT(inSuite, p64_in == (&v64_in + 1));
 549
 550 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 551     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 552     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 553     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 554     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 555
 556 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 557     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 558     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 559     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 560     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 561
 562 #else
 563     NL_TEST_ASSERT(inSuite, false);
 564
 565 #endif
 566 }
 567
 568 static void CheckWriteBigAligned(nlTestSuite *inSuite, void *inContext)
 569 {
 570     const uint8_t  v8_in   = MAGIC8;
 571     const uint16_t v16_in  = MAGIC16;
 572     const uint32_t v32_in  = MAGIC32;
 573     const uint64_t v64_in  = MAGIC64;
 574     uint8_t        v8_out;
 575     uint16_t       v16_out;
 576     uint32_t       v32_out;
 577     uint64_t       v64_out;
 578     void           *p8_out  = &v8_out;
 579     void           *p16_out = &v16_out;
 580     void           *p32_out = &v32_out;
 581     void           *p64_out = &v64_out;
 582
 583     BigEndian::WriteAligned8(p8_out, v8_in);
 584     BigEndian::WriteAligned16(p16_out, v16_in);
 585     BigEndian::WriteAligned32(p32_out, v32_in);
 586     BigEndian::WriteAligned64(p64_out, v64_in);
 587
 588     NL_TEST_ASSERT(inSuite, p8_out == (&v8_out + 1));
 589     NL_TEST_ASSERT(inSuite, p16_out == (&v16_out + 1));
 590     NL_TEST_ASSERT(inSuite, p32_out == (&v32_out + 1));
 591     NL_TEST_ASSERT(inSuite, p64_out == (&v64_out + 1));
 592
 593 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 594     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 595     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 596     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 597     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 598
 599 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 600     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 601     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 602     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 603     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 604
 605 #else
 606     NL_TEST_ASSERT(inSuite, false);
 607
 608 #endif
 609 }
 610
 611 static void CheckWriteLittleAligned(nlTestSuite *inSuite, void *inContext)
 612 {
 613     const uint8_t  v8_in   = MAGIC8;
 614     const uint16_t v16_in  = MAGIC16;
 615     const uint32_t v32_in  = MAGIC32;
 616     const uint64_t v64_in  = MAGIC64;
 617     uint8_t        v8_out;
 618     uint16_t       v16_out;
 619     uint32_t       v32_out;
 620     uint64_t       v64_out;
 621     void           *p8_out  = &v8_out;
 622     void           *p16_out = &v16_out;
 623     void           *p32_out = &v32_out;
 624     void           *p64_out = &v64_out;
 625
 626     LittleEndian::WriteAligned8(p8_out, v8_in);
 627     LittleEndian::WriteAligned16(p16_out, v16_in);
 628     LittleEndian::WriteAligned32(p32_out, v32_in);
 629     LittleEndian::WriteAligned64(p64_out, v64_in);
 630
 631     NL_TEST_ASSERT(inSuite, p8_out == (&v8_out + 1));
 632     NL_TEST_ASSERT(inSuite, p16_out == (&v16_out + 1));
 633     NL_TEST_ASSERT(inSuite, p32_out == (&v32_out + 1));
 634     NL_TEST_ASSERT(inSuite, p64_out == (&v64_out + 1));
 635
 636 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 637     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
 638     NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
 639     NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
 640     NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);
 641
 642 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 643     NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
 644     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 645     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 646     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 647
 648 #else
 649     NL_TEST_ASSERT(inSuite, false);
 650
 651 #endif
 652 }
 653
 654 // XXX - Unaligned
 655
 656 static void CheckGetBigUnaligned(nlTestSuite *inSuite, void *inContext)
 657 {
 658     const uint8_t  v8_in  = MAGIC8;
 659     const uint16_t v16_in = MAGIC16;
 660     const uint32_t v32_in = MAGIC32;
 661     const uint64_t v64_in = MAGIC64;
 662     uint8_t        v8_out;
 663     uint16_t       v16_0_out;
 664     uint16_t       v16_1_out;
 665     uint32_t       v32_0_out;
 666     uint32_t       v32_1_out;
 667     uint32_t       v32_2_out;
 668     uint32_t       v32_3_out;
 669     uint64_t       v64_0_out;
 670     uint64_t       v64_1_out;
 671     uint64_t       v64_2_out;
 672     uint64_t       v64_3_out;
 673     uint64_t       v64_4_out;
 674     uint64_t       v64_5_out;
 675     uint64_t       v64_6_out;
 676     uint64_t       v64_7_out;
 677     uint8_t        buffer[sizeof(uint64_t) * 2];
 678     void *         p;
 679
 680     // Try an 8-bit quantity. They are aligned anywhere and unaligned
 681     // nowhere.
 682
 683     p = &buffer[0];
 684     memcpy(p, &v8_in, sizeof(v8_in));
 685
 686     v8_out = BigEndian::GetUnaligned8(p);
 687
 688     // Try 16-bit quantities.
 689
 690     p = &buffer[0];
 691     memcpy(p, &v16_in, sizeof(v16_in));
 692
 693     v16_0_out = BigEndian::GetUnaligned16(p);
 694
 695     p = &buffer[1];
 696     memcpy(p, &v16_in, sizeof(v16_in));
 697
 698     v16_1_out = BigEndian::GetUnaligned16(p);
 699
 700     // Try 32-bit quantities.
 701
 702     p = &buffer[0];
 703     memcpy(p, &v32_in, sizeof(v32_in));
 704
 705     v32_0_out = BigEndian::GetUnaligned32(p);
 706
 707     p = &buffer[1];
 708     memcpy(p, &v32_in, sizeof(v32_in));
 709
 710     v32_1_out = BigEndian::GetUnaligned32(p);
 711
 712     p = &buffer[2];
 713     memcpy(p, &v32_in, sizeof(v32_in));
 714
 715     v32_2_out = BigEndian::GetUnaligned32(p);
 716
 717     p = &buffer[3];
 718     memcpy(p, &v32_in, sizeof(v32_in));
 719
 720     v32_3_out = BigEndian::GetUnaligned32(p);
 721
 722     // Try 64-bit quantities.
 723
 724     p = &buffer[0];
 725     memcpy(p, &v64_in, sizeof(v64_in));
 726
 727     v64_0_out = BigEndian::GetUnaligned64(p);
 728
 729     p = &buffer[1];
 730     memcpy(p, &v64_in, sizeof(v64_in));
 731
 732     v64_1_out = BigEndian::GetUnaligned64(p);
 733
 734     p = &buffer[2];
 735     memcpy(p, &v64_in, sizeof(v64_in));
 736
 737     v64_2_out = BigEndian::GetUnaligned64(p);
 738
 739     p = &buffer[3];
 740     memcpy(p, &v64_in, sizeof(v64_in));
 741
 742     v64_3_out = BigEndian::GetUnaligned64(p);
 743
 744     p = &buffer[4];
 745     memcpy(p, &v64_in, sizeof(v64_in));
 746
 747     v64_4_out = BigEndian::GetUnaligned64(p);
 748
 749     p = &buffer[5];
 750     memcpy(p, &v64_in, sizeof(v64_in));
 751
 752     v64_5_out = BigEndian::GetUnaligned64(p);
 753
 754     p = &buffer[6];
 755     memcpy(p, &v64_in, sizeof(v64_in));
 756
 757     v64_6_out = BigEndian::GetUnaligned64(p);
 758
 759     p = &buffer[7];
 760     memcpy(p, &v64_in, sizeof(v64_in));
 761
 762     v64_7_out = BigEndian::GetUnaligned64(p);
 763
 764 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 765     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC_SWAP8);
 766     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC_SWAP16);
 767     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC_SWAP16);
 768     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC_SWAP32);
 769     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC_SWAP32);
 770     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC_SWAP32);
 771     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC_SWAP32);
 772     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC_SWAP64);
 773     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC_SWAP64);
 774     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC_SWAP64);
 775     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC_SWAP64);
 776     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC_SWAP64);
 777     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC_SWAP64);
 778     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC_SWAP64);
 779     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC_SWAP64);
 780
 781 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 782     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC8);
 783     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC16);
 784     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC16);
 785     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC32);
 786     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC32);
 787     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC32);
 788     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC32);
 789     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC64);
 790     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC64);
 791     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC64);
 792     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC64);
 793     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC64);
 794     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC64);
 795     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC64);
 796     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC64);
 797
 798 #else
 799     NL_TEST_ASSERT(inSuite, false);
 800
 801 #endif
 802 }
 803
 804 static void CheckGetLittleUnaligned(nlTestSuite *inSuite, void *inContext)
 805 {
 806     const uint8_t  v8_in  = MAGIC8;
 807     const uint16_t v16_in = MAGIC16;
 808     const uint32_t v32_in = MAGIC32;
 809     const uint64_t v64_in = MAGIC64;
 810     uint8_t        v8_out;
 811     uint16_t       v16_0_out;
 812     uint16_t       v16_1_out;
 813     uint32_t       v32_0_out;
 814     uint32_t       v32_1_out;
 815     uint32_t       v32_2_out;
 816     uint32_t       v32_3_out;
 817     uint64_t       v64_0_out;
 818     uint64_t       v64_1_out;
 819     uint64_t       v64_2_out;
 820     uint64_t       v64_3_out;
 821     uint64_t       v64_4_out;
 822     uint64_t       v64_5_out;
 823     uint64_t       v64_6_out;
 824     uint64_t       v64_7_out;
 825     uint8_t        buffer[sizeof(uint64_t) * 2];
 826     void *         p;
 827
 828     // Try an 8-bit quantity. They are aligned anywhere and unaligned
 829     // nowhere.
 830
 831     p = &buffer[0];
 832     memcpy(p, &v8_in, sizeof(v8_in));
 833
 834     v8_out = LittleEndian::GetUnaligned8(p);
 835
 836     // Try 16-bit quantities.
 837
 838     p = &buffer[0];
 839     memcpy(p, &v16_in, sizeof(v16_in));
 840
 841     v16_0_out = LittleEndian::GetUnaligned16(p);
 842
 843     p = &buffer[1];
 844     memcpy(p, &v16_in, sizeof(v16_in));
 845
 846     v16_1_out = LittleEndian::GetUnaligned16(p);
 847
 848     // Try 32-bit quantities.
 849
 850     p = &buffer[0];
 851     memcpy(p, &v32_in, sizeof(v32_in));
 852
 853     v32_0_out = LittleEndian::GetUnaligned32(p);
 854
 855     p = &buffer[1];
 856     memcpy(p, &v32_in, sizeof(v32_in));
 857
 858     v32_1_out = LittleEndian::GetUnaligned32(p);
 859
 860     p = &buffer[2];
 861     memcpy(p, &v32_in, sizeof(v32_in));
 862
 863     v32_2_out = LittleEndian::GetUnaligned32(p);
 864
 865     p = &buffer[3];
 866     memcpy(p, &v32_in, sizeof(v32_in));
 867
 868     v32_3_out = LittleEndian::GetUnaligned32(p);
 869
 870     // Try 64-bit quantities.
 871
 872     p = &buffer[0];
 873     memcpy(p, &v64_in, sizeof(v64_in));
 874
 875     v64_0_out = LittleEndian::GetUnaligned64(p);
 876
 877     p = &buffer[1];
 878     memcpy(p, &v64_in, sizeof(v64_in));
 879
 880     v64_1_out = LittleEndian::GetUnaligned64(p);
 881
 882     p = &buffer[2];
 883     memcpy(p, &v64_in, sizeof(v64_in));
 884
 885     v64_2_out = LittleEndian::GetUnaligned64(p);
 886
 887     p = &buffer[3];
 888     memcpy(p, &v64_in, sizeof(v64_in));
 889
 890     v64_3_out = LittleEndian::GetUnaligned64(p);
 891
 892     p = &buffer[4];
 893     memcpy(p, &v64_in, sizeof(v64_in));
 894
 895     v64_4_out = LittleEndian::GetUnaligned64(p);
 896
 897     p = &buffer[5];
 898     memcpy(p, &v64_in, sizeof(v64_in));
 899
 900     v64_5_out = LittleEndian::GetUnaligned64(p);
 901
 902     p = &buffer[6];
 903     memcpy(p, &v64_in, sizeof(v64_in));
 904
 905     v64_6_out = LittleEndian::GetUnaligned64(p);
 906
 907     p = &buffer[7];
 908     memcpy(p, &v64_in, sizeof(v64_in));
 909
 910     v64_7_out = LittleEndian::GetUnaligned64(p);
 911
 912 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 913     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC8);
 914     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC16);
 915     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC16);
 916     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC32);
 917     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC32);
 918     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC32);
 919     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC32);
 920     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC64);
 921     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC64);
 922     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC64);
 923     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC64);
 924     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC64);
 925     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC64);
 926     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC64);
 927     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC64);
 928
 929 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 930     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC_SWAP8);
 931     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC_SWAP16);
 932     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC_SWAP16);
 933     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC_SWAP32);
 934     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC_SWAP32);
 935     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC_SWAP32);
 936     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC_SWAP32);
 937     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC_SWAP64);
 938     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC_SWAP64);
 939     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC_SWAP64);
 940     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC_SWAP64);
 941     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC_SWAP64);
 942     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC_SWAP64);
 943     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC_SWAP64);
 944     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC_SWAP64);
 945
 946 #else
 947     NL_TEST_ASSERT(inSuite, false);
 948
 949 #endif
 950 }
 951
 952 static void CheckPutBigUnaligned(nlTestSuite *inSuite, void *inContext)
 953 {
 954     const uint8_t  v8_in  = MAGIC8;
 955     const uint16_t v16_in = MAGIC16;
 956     const uint32_t v32_in = MAGIC32;
 957     const uint64_t v64_in = MAGIC64;
 958     uint8_t        v8_out;
 959     uint16_t       v16_0_out;
 960     uint16_t       v16_1_out;
 961     uint32_t       v32_0_out;
 962     uint32_t       v32_1_out;
 963     uint32_t       v32_2_out;
 964     uint32_t       v32_3_out;
 965     uint64_t       v64_0_out;
 966     uint64_t       v64_1_out;
 967     uint64_t       v64_2_out;
 968     uint64_t       v64_3_out;
 969     uint64_t       v64_4_out;
 970     uint64_t       v64_5_out;
 971     uint64_t       v64_6_out;
 972     uint64_t       v64_7_out;
 973     uint8_t        buffer[sizeof(uint64_t) * 2];
 974     void *         p;
 975
 976     // Try an 8-bit quantity. They are aligned anywhere and unaligned
 977     // nowhere.
 978
 979     p = &buffer[0];
 980     BigEndian::PutUnaligned8(p, v8_in);
 981     memcpy(&v8_out, p, sizeof(v8_in));
 982
 983     // Try 16-bit quantities.
 984
 985     p = &buffer[0];
 986     BigEndian::PutUnaligned16(p, v16_in);
 987     memcpy(&v16_0_out, p, sizeof(v16_in));
 988
 989     p = &buffer[1];
 990     BigEndian::PutUnaligned16(p, v16_in);
 991     memcpy(&v16_1_out, p, sizeof(v16_in));
 992
 993     // Try 32-bit quantities.
 994
 995     p = &buffer[0];
 996     BigEndian::PutUnaligned32(p, v32_in);
 997     memcpy(&v32_0_out, p, sizeof(v32_in));
 998
 999     p = &buffer[1];
1000     BigEndian::PutUnaligned32(p, v32_in);
1001     memcpy(&v32_1_out, p, sizeof(v32_in));
1002
1003     p = &buffer[2];
1004     BigEndian::PutUnaligned32(p, v32_in);
1005     memcpy(&v32_2_out, p, sizeof(v32_in));
1006
1007     p = &buffer[3];
1008     BigEndian::PutUnaligned32(p, v32_in);
1009     memcpy(&v32_3_out, p, sizeof(v32_in));
1010
1011     // Try 64-bit quantities.
1012
1013     p = &buffer[0];
1014     BigEndian::PutUnaligned64(p, v64_in);
1015     memcpy(&v64_0_out, p, sizeof(v64_in));
1016
1017     p = &buffer[1];
1018     BigEndian::PutUnaligned64(p, v64_in);
1019     memcpy(&v64_1_out, p, sizeof(v64_in));
1020
1021     p = &buffer[2];
1022     BigEndian::PutUnaligned64(p, v64_in);
1023     memcpy(&v64_2_out, p, sizeof(v64_in));
1024
1025     p = &buffer[3];
1026     BigEndian::PutUnaligned64(p, v64_in);
1027     memcpy(&v64_3_out, p, sizeof(v64_in));
1028
1029     p = &buffer[4];
1030     BigEndian::PutUnaligned64(p, v64_in);
1031     memcpy(&v64_4_out, p, sizeof(v64_in));
1032
1033     p = &buffer[5];
1034     BigEndian::PutUnaligned64(p, v64_in);
1035     memcpy(&v64_5_out, p, sizeof(v64_in));
1036
1037     p = &buffer[6];
1038     BigEndian::PutUnaligned64(p, v64_in);
1039     memcpy(&v64_6_out, p, sizeof(v64_in));
1040
1041     p = &buffer[7];
1042     BigEndian::PutUnaligned64(p, v64_in);
1043     memcpy(&v64_7_out, p, sizeof(v64_in));
1044
1045 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
1046     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC_SWAP8);
1047     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC_SWAP16);
1048     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC_SWAP16);
1049     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC_SWAP32);
1050     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC_SWAP32);
1051     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC_SWAP32);
1052     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC_SWAP32);
1053     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC_SWAP64);
1054     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC_SWAP64);
1055     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC_SWAP64);
1056     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC_SWAP64);
1057     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC_SWAP64);
1058     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC_SWAP64);
1059     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC_SWAP64);
1060     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC_SWAP64);
1061
1062 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
1063     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC8);
1064     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC16);
1065     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC16);
1066     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC32);
1067     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC32);
1068     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC32);
1069     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC32);
1070     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC64);
1071     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC64);
1072     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC64);
1073     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC64);
1074     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC64);
1075     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC64);
1076     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC64);
1077     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC64);
1078
1079 #else
1080     NL_TEST_ASSERT(inSuite, false);
1081
1082 #endif
1083 }
1084
1085 static void CheckPutLittleUnaligned(nlTestSuite *inSuite, void *inContext)
1086 {
1087     const uint8_t  v8_in  = MAGIC8;
1088     const uint16_t v16_in = MAGIC16;
1089     const uint32_t v32_in = MAGIC32;
1090     const uint64_t v64_in = MAGIC64;
1091     uint8_t        v8_out;
1092     uint16_t       v16_0_out;
1093     uint16_t       v16_1_out;
1094     uint32_t       v32_0_out;
1095     uint32_t       v32_1_out;
1096     uint32_t       v32_2_out;
1097     uint32_t       v32_3_out;
1098     uint64_t       v64_0_out;
1099     uint64_t       v64_1_out;
1100     uint64_t       v64_2_out;
1101     uint64_t       v64_3_out;
1102     uint64_t       v64_4_out;
1103     uint64_t       v64_5_out;
1104     uint64_t       v64_6_out;
1105     uint64_t       v64_7_out;
1106     uint8_t        buffer[sizeof(uint64_t) * 2];
1107     void *         p;
1108
1109     // Try an 8-bit quantity. They are aligned anywhere and unaligned
1110     // nowhere.
1111
1112     p = &buffer[0];
1113     LittleEndian::PutUnaligned8(p, v8_in);
1114     memcpy(&v8_out, p, sizeof(v8_in));
1115
1116     // Try 16-bit quantities.
1117
1118     p = &buffer[0];
1119     LittleEndian::PutUnaligned16(p, v16_in);
1120     memcpy(&v16_0_out, p, sizeof(v16_in));
1121
1122     p = &buffer[1];
1123     LittleEndian::PutUnaligned16(p, v16_in);
1124     memcpy(&v16_1_out, p, sizeof(v16_in));
1125
1126     // Try 32-bit quantities.
1127
1128     p = &buffer[0];
1129     LittleEndian::PutUnaligned32(p, v32_in);
1130     memcpy(&v32_0_out, p, sizeof(v32_in));
1131
1132     p = &buffer[1];
1133     LittleEndian::PutUnaligned32(p, v32_in);
1134     memcpy(&v32_1_out, p, sizeof(v32_in));
1135
1136     p = &buffer[2];
1137     LittleEndian::PutUnaligned32(p, v32_in);
1138     memcpy(&v32_2_out, p, sizeof(v32_in));
1139
1140     p = &buffer[3];
1141     LittleEndian::PutUnaligned32(p, v32_in);
1142     memcpy(&v32_3_out, p, sizeof(v32_in));
1143
1144     // Try 64-bit quantities.
1145
1146     p = &buffer[0];
1147     LittleEndian::PutUnaligned64(p, v64_in);
1148     memcpy(&v64_0_out, p, sizeof(v64_in));
1149
1150     p = &buffer[1];
1151     LittleEndian::PutUnaligned64(p, v64_in);
1152     memcpy(&v64_1_out, p, sizeof(v64_in));
1153
1154     p = &buffer[2];
1155     LittleEndian::PutUnaligned64(p, v64_in);
1156     memcpy(&v64_2_out, p, sizeof(v64_in));
1157
1158     p = &buffer[3];
1159     LittleEndian::PutUnaligned64(p, v64_in);
1160     memcpy(&v64_3_out, p, sizeof(v64_in));
1161
1162     p = &buffer[4];
1163     LittleEndian::PutUnaligned64(p, v64_in);
1164     memcpy(&v64_4_out, p, sizeof(v64_in));
1165
1166     p = &buffer[5];
1167     LittleEndian::PutUnaligned64(p, v64_in);
1168     memcpy(&v64_5_out, p, sizeof(v64_in));
1169
1170     p = &buffer[6];
1171     LittleEndian::PutUnaligned64(p, v64_in);
1172     memcpy(&v64_6_out, p, sizeof(v64_in));
1173
1174     p = &buffer[7];
1175     LittleEndian::PutUnaligned64(p, v64_in);
1176     memcpy(&v64_7_out, p, sizeof(v64_in));
1177
1178 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
1179     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC8);
1180     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC16);
1181     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC16);
1182     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC32);
1183     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC32);
1184     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC32);
1185     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC32);
1186     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC64);
1187     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC64);
1188     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC64);
1189     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC64);
1190     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC64);
1191     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC64);
1192     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC64);
1193     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC64);
1194
1195 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
1196     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC_SWAP8);
1197     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC_SWAP16);
1198     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC_SWAP16);
1199     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC_SWAP32);
1200     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC_SWAP32);
1201     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC_SWAP32);
1202     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC_SWAP32);
1203     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC_SWAP64);
1204     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC_SWAP64);
1205     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC_SWAP64);
1206     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC_SWAP64);
1207     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC_SWAP64);
1208     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC_SWAP64);
1209     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC_SWAP64);
1210     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC_SWAP64);
1211
1212 #else
1213     NL_TEST_ASSERT(inSuite, false);
1214
1215 #endif
1216 }
1217
1218 static void CheckReadBigUnaligned(nlTestSuite *inSuite, void *inContext)
1219 {
1220     const uint8_t  v8_in  = MAGIC8;
1221     const uint16_t v16_in = MAGIC16;
1222     const uint32_t v32_in = MAGIC32;
1223     const uint64_t v64_in = MAGIC64;
1224     uint8_t        v8_out;
1225     uint16_t       v16_0_out;
1226     uint16_t       v16_1_out;
1227     uint32_t       v32_0_out;
1228     uint32_t       v32_1_out;
1229     uint32_t       v32_2_out;
1230     uint32_t       v32_3_out;
1231     uint64_t       v64_0_out;
1232     uint64_t       v64_1_out;
1233     uint64_t       v64_2_out;
1234     uint64_t       v64_3_out;
1235     uint64_t       v64_4_out;
1236     uint64_t       v64_5_out;
1237     uint64_t       v64_6_out;
1238     uint64_t       v64_7_out;
1239     uint8_t        buffer[sizeof(uint64_t) * 2];
1240     const void *   p;
1241
1242     // Try an 8-bit quantity. They are aligned anywhere and unaligned
1243     // nowhere.
1244
1245     p = &buffer[0];
1246     memcpy(&buffer[0], &v8_in, sizeof(v8_in));
1247
1248     v8_out = BigEndian::ReadUnaligned8(p);
1249     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v8_in));
1250
1251     // Try 16-bit quantities.
1252
1253     p = &buffer[0];
1254     memcpy(&buffer[0], &v16_in, sizeof(v16_in));
1255
1256     v16_0_out = BigEndian::ReadUnaligned16(p);
1257     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v16_in));
1258
1259     p = &buffer[1];
1260     memcpy(&buffer[1], &v16_in, sizeof(v16_in));
1261
1262     v16_1_out = BigEndian::ReadUnaligned16(p);
1263     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v16_in));
1264
1265     // Try 32-bit quantities.
1266
1267     p = &buffer[0];
1268     memcpy(&buffer[0], &v32_in, sizeof(v32_in));
1269
1270     v32_0_out = BigEndian::ReadUnaligned32(p);
1271     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v32_in));
1272
1273     p = &buffer[1];
1274     memcpy(&buffer[1], &v32_in, sizeof(v32_in));
1275
1276     v32_1_out = BigEndian::ReadUnaligned32(p);
1277     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v32_in));
1278
1279     p = &buffer[2];
1280     memcpy(&buffer[2], &v32_in, sizeof(v32_in));
1281
1282     v32_2_out = BigEndian::ReadUnaligned32(p);
1283     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(v32_in));
1284
1285     p = &buffer[3];
1286     memcpy(&buffer[3], &v32_in, sizeof(v32_in));
1287
1288     v32_3_out = BigEndian::ReadUnaligned32(p);
1289     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(v32_in));
1290
1291     // Try 64-bit quantities.
1292
1293     p = &buffer[0];
1294     memcpy(&buffer[0], &v64_in, sizeof(v64_in));
1295
1296     v64_0_out = BigEndian::ReadUnaligned64(p);
1297     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v64_in));
1298
1299     p = &buffer[1];
1300     memcpy(&buffer[1], &v64_in, sizeof(v64_in));
1301
1302     v64_1_out = BigEndian::ReadUnaligned64(p);
1303     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v64_in));
1304
1305     p = &buffer[2];
1306     memcpy(&buffer[2], &v64_in, sizeof(v64_in));
1307
1308     v64_2_out = BigEndian::ReadUnaligned64(p);
1309     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(v64_in));
1310
1311     p = &buffer[3];
1312     memcpy(&buffer[3], &v64_in, sizeof(v64_in));
1313
1314     v64_3_out = BigEndian::ReadUnaligned64(p);
1315     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(v64_in));
1316
1317     p = &buffer[4];
1318     memcpy(&buffer[4], &v64_in, sizeof(v64_in));
1319
1320     v64_4_out = BigEndian::ReadUnaligned64(p);
1321     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[4] + sizeof(v64_in));
1322
1323     p = &buffer[5];
1324     memcpy(&buffer[5], &v64_in, sizeof(v64_in));
1325
1326     v64_5_out = BigEndian::ReadUnaligned64(p);
1327     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[5] + sizeof(v64_in));
1328
1329     p = &buffer[6];
1330     memcpy(&buffer[6], &v64_in, sizeof(v64_in));
1331
1332     v64_6_out = BigEndian::ReadUnaligned64(p);
1333     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[6] + sizeof(v64_in));
1334
1335     p = &buffer[7];
1336     memcpy(&buffer[7], &v64_in, sizeof(v64_in));
1337
1338     v64_7_out = BigEndian::ReadUnaligned64(p);
1339     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[7] + sizeof(v64_in));
1340
1341 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
1342     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC_SWAP8);
1343     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC_SWAP16);
1344     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC_SWAP16);
1345     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC_SWAP32);
1346     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC_SWAP32);
1347     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC_SWAP32);
1348     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC_SWAP32);
1349     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC_SWAP64);
1350     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC_SWAP64);
1351     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC_SWAP64);
1352     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC_SWAP64);
1353     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC_SWAP64);
1354     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC_SWAP64);
1355     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC_SWAP64);
1356     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC_SWAP64);
1357
1358 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
1359     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC8);
1360     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC16);
1361     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC16);
1362     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC32);
1363     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC32);
1364     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC32);
1365     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC32);
1366     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC64);
1367     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC64);
1368     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC64);
1369     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC64);
1370     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC64);
1371     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC64);
1372     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC64);
1373     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC64);
1374
1375 #else
1376     NL_TEST_ASSERT(inSuite, false);
1377
1378 #endif
1379 }
1380
1381 static void CheckReadLittleUnaligned(nlTestSuite *inSuite, void *inContext)
1382 {
1383     const uint8_t  v8_in  = MAGIC8;
1384     const uint16_t v16_in = MAGIC16;
1385     const uint32_t v32_in = MAGIC32;
1386     const uint64_t v64_in = MAGIC64;
1387     uint8_t        v8_out;
1388     uint16_t       v16_0_out;
1389     uint16_t       v16_1_out;
1390     uint32_t       v32_0_out;
1391     uint32_t       v32_1_out;
1392     uint32_t       v32_2_out;
1393     uint32_t       v32_3_out;
1394     uint64_t       v64_0_out;
1395     uint64_t       v64_1_out;
1396     uint64_t       v64_2_out;
1397     uint64_t       v64_3_out;
1398     uint64_t       v64_4_out;
1399     uint64_t       v64_5_out;
1400     uint64_t       v64_6_out;
1401     uint64_t       v64_7_out;
1402     uint8_t        buffer[sizeof(uint64_t) * 2];
1403     const void *   p;
1404
1405     // Try an 8-bit quantity. They are aligned anywhere and unaligned
1406     // nowhere.
1407
1408     p = &buffer[0];
1409     memcpy(&buffer[0], &v8_in, sizeof(v8_in));
1410
1411     v8_out = LittleEndian::ReadUnaligned8(p);
1412     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v8_in));
1413
1414     // Try 16-bit quantities.
1415
1416     p = &buffer[0];
1417     memcpy(&buffer[0], &v16_in, sizeof(v16_in));
1418
1419     v16_0_out = LittleEndian::ReadUnaligned16(p);
1420     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v16_in));
1421
1422     p = &buffer[1];
1423     memcpy(&buffer[1], &v16_in, sizeof(v16_in));
1424
1425     v16_1_out = LittleEndian::ReadUnaligned16(p);
1426     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v16_in));
1427
1428     // Try 32-bit quantities.
1429
1430     p = &buffer[0];
1431     memcpy(&buffer[0], &v32_in, sizeof(v32_in));
1432
1433     v32_0_out = LittleEndian::ReadUnaligned32(p);
1434     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v32_in));
1435
1436     p = &buffer[1];
1437     memcpy(&buffer[1], &v32_in, sizeof(v32_in));
1438
1439     v32_1_out = LittleEndian::ReadUnaligned32(p);
1440     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v32_in));
1441
1442     p = &buffer[2];
1443     memcpy(&buffer[2], &v32_in, sizeof(v32_in));
1444
1445     v32_2_out = LittleEndian::ReadUnaligned32(p);
1446     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(v32_in));
1447
1448     p = &buffer[3];
1449     memcpy(&buffer[3], &v32_in, sizeof(v32_in));
1450
1451     v32_3_out = LittleEndian::ReadUnaligned32(p);
1452     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(v32_in));
1453
1454     // Try 64-bit quantities.
1455
1456     p = &buffer[0];
1457     memcpy(&buffer[0], &v64_in, sizeof(v64_in));
1458
1459     v64_0_out = LittleEndian::ReadUnaligned64(p);
1460     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v64_in));
1461
1462     p = &buffer[1];
1463     memcpy(&buffer[1], &v64_in, sizeof(v64_in));
1464
1465     v64_1_out = LittleEndian::ReadUnaligned64(p);
1466     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v64_in));
1467
1468     p = &buffer[2];
1469     memcpy(&buffer[2], &v64_in, sizeof(v64_in));
1470
1471     v64_2_out = LittleEndian::ReadUnaligned64(p);
1472     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(v64_in));
1473
1474     p = &buffer[3];
1475     memcpy(&buffer[3], &v64_in, sizeof(v64_in));
1476
1477     v64_3_out = LittleEndian::ReadUnaligned64(p);
1478     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(v64_in));
1479
1480     p = &buffer[4];
1481     memcpy(&buffer[4], &v64_in, sizeof(v64_in));
1482
1483     v64_4_out = LittleEndian::ReadUnaligned64(p);
1484     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[4] + sizeof(v64_in));
1485
1486     p = &buffer[5];
1487     memcpy(&buffer[5], &v64_in, sizeof(v64_in));
1488
1489     v64_5_out = LittleEndian::ReadUnaligned64(p);
1490     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[5] + sizeof(v64_in));
1491
1492     p = &buffer[6];
1493     memcpy(&buffer[6], &v64_in, sizeof(v64_in));
1494
1495     v64_6_out = LittleEndian::ReadUnaligned64(p);
1496     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[6] + sizeof(v64_in));
1497
1498     p = &buffer[7];
1499     memcpy(&buffer[7], &v64_in, sizeof(v64_in));
1500
1501     v64_7_out = LittleEndian::ReadUnaligned64(p);
1502     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[7] + sizeof(v64_in));
1503
1504 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
1505     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC8);
1506     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC16);
1507     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC16);
1508     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC32);
1509     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC32);
1510     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC32);
1511     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC32);
1512     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC64);
1513     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC64);
1514     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC64);
1515     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC64);
1516     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC64);
1517     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC64);
1518     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC64);
1519     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC64);
1520
1521 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
1522     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC_SWAP8);
1523     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC_SWAP16);
1524     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC_SWAP16);
1525     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC_SWAP32);
1526     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC_SWAP32);
1527     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC_SWAP32);
1528     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC_SWAP32);
1529     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC_SWAP64);
1530     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC_SWAP64);
1531     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC_SWAP64);
1532     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC_SWAP64);
1533     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC_SWAP64);
1534     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC_SWAP64);
1535     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC_SWAP64);
1536     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC_SWAP64);
1537
1538 #else
1539     NL_TEST_ASSERT(inSuite, false);
1540
1541 #endif
1542 }
1543
1544 static void CheckWriteBigUnaligned(nlTestSuite *inSuite, void *inContext)
1545 {
1546     const uint8_t  v8_in   = MAGIC8;
1547     const uint16_t v16_in  = MAGIC16;
1548     const uint32_t v32_in  = MAGIC32;
1549     const uint64_t v64_in  = MAGIC64;
1550     uint8_t        v8_out;
1551     uint16_t       v16_0_out;
1552     uint16_t       v16_1_out;
1553     uint32_t       v32_0_out;
1554     uint32_t       v32_1_out;
1555     uint32_t       v32_2_out;
1556     uint32_t       v32_3_out;
1557     uint64_t       v64_0_out;
1558     uint64_t       v64_1_out;
1559     uint64_t       v64_2_out;
1560     uint64_t       v64_3_out;
1561     uint64_t       v64_4_out;
1562     uint64_t       v64_5_out;
1563     uint64_t       v64_6_out;
1564     uint64_t       v64_7_out;
1565     uint8_t        buffer[sizeof(uint64_t) * 2];
1566     void *         p;
1567
1568     // Try an 8-bit quantity. They are aligned anywhere and unaligned
1569     // nowhere.
1570
1571     p = &buffer[0];
1572     BigEndian::WriteUnaligned8(p, v8_in);
1573     memcpy(&v8_out, &buffer[0], sizeof(v8_in));
1574     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v8_out));
1575
1576     // Try 16-bit quantities.
1577
1578     p = &buffer[0];
1579     BigEndian::WriteUnaligned16(p, v16_in);
1580     memcpy(&v16_0_out, &buffer[0], sizeof(v16_in));
1581     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v16_0_out));
1582
1583     p = &buffer[1];
1584     BigEndian::WriteUnaligned16(p, v16_in);
1585     memcpy(&v16_1_out, &buffer[1], sizeof(v16_in));
1586     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v16_1_out));
1587
1588     // Try 32-bit quantities.
1589
1590     p = &buffer[0];
1591     BigEndian::WriteUnaligned32(p, v32_in);
1592     memcpy(&v32_0_out, &buffer[0], sizeof(v32_in));
1593     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v32_0_out));
1594
1595     p = &buffer[1];
1596     BigEndian::WriteUnaligned32(p, v32_in);
1597     memcpy(&v32_1_out, &buffer[1], sizeof(v32_in));
1598     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v32_1_out));
1599
1600     p = &buffer[2];
1601     BigEndian::WriteUnaligned32(p, v32_in);
1602     memcpy(&v32_2_out, &buffer[2], sizeof(v32_in));
1603     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(v32_2_out));
1604
1605     p = &buffer[3];
1606     BigEndian::WriteUnaligned32(p, v32_in);
1607     memcpy(&v32_3_out, &buffer[3], sizeof(v32_in));
1608     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(v32_3_out));
1609
1610     // Try 64-bit quantities.
1611
1612     p = &buffer[0];
1613     BigEndian::WriteUnaligned64(p, v64_in);
1614     memcpy(&v64_0_out, &buffer[0], sizeof(v64_in));
1615     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v64_0_out));
1616
1617     p = &buffer[1];
1618     BigEndian::WriteUnaligned64(p, v64_in);
1619     memcpy(&v64_1_out, &buffer[1], sizeof(v64_in));
1620     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v64_1_out));
1621
1622     p = &buffer[2];
1623     BigEndian::WriteUnaligned64(p, v64_in);
1624     memcpy(&v64_2_out, &buffer[2], sizeof(v64_in));
1625     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(v64_2_out));
1626
1627     p = &buffer[3];
1628     BigEndian::WriteUnaligned64(p, v64_in);
1629     memcpy(&v64_3_out, &buffer[3], sizeof(v64_in));
1630     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(v64_3_out));
1631
1632     p = &buffer[4];
1633     BigEndian::WriteUnaligned64(p, v64_in);
1634     memcpy(&v64_4_out, &buffer[4], sizeof(v64_in));
1635     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[4] + sizeof(v64_4_out));
1636
1637     p = &buffer[5];
1638     BigEndian::WriteUnaligned64(p, v64_in);
1639     memcpy(&v64_5_out, &buffer[5], sizeof(v64_in));
1640     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[5] + sizeof(v64_5_out));
1641
1642     p = &buffer[6];
1643     BigEndian::WriteUnaligned64(p, v64_in);
1644     memcpy(&v64_6_out, &buffer[6], sizeof(v64_in));
1645     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[6] + sizeof(v64_6_out));
1646
1647     p = &buffer[7];
1648     BigEndian::WriteUnaligned64(p, v64_in);
1649     memcpy(&v64_7_out, &buffer[7], sizeof(v64_in));
1650     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[7] + sizeof(v64_7_out));
1651
1652 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
1653     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC_SWAP8);
1654     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC_SWAP16);
1655     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC_SWAP16);
1656     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC_SWAP32);
1657     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC_SWAP32);
1658     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC_SWAP32);
1659     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC_SWAP32);
1660     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC_SWAP64);
1661     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC_SWAP64);
1662     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC_SWAP64);
1663     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC_SWAP64);
1664     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC_SWAP64);
1665     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC_SWAP64);
1666     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC_SWAP64);
1667     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC_SWAP64);
1668
1669 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
1670     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC8);
1671     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC16);
1672     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC16);
1673     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC32);
1674     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC32);
1675     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC32);
1676     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC32);
1677     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC64);
1678     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC64);
1679     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC64);
1680     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC64);
1681     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC64);
1682     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC64);
1683     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC64);
1684     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC64);
1685
1686 #else
1687     NL_TEST_ASSERT(inSuite, false);
1688
1689 #endif
1690 }
1691
1692 static void CheckWriteLittleUnaligned(nlTestSuite *inSuite, void *inContext)
1693 {
1694     const uint8_t  v8_in   = MAGIC8;
1695     const uint16_t v16_in  = MAGIC16;
1696     const uint32_t v32_in  = MAGIC32;
1697     const uint64_t v64_in  = MAGIC64;
1698     uint8_t        v8_out;
1699     uint16_t       v16_0_out;
1700     uint16_t       v16_1_out;
1701     uint32_t       v32_0_out;
1702     uint32_t       v32_1_out;
1703     uint32_t       v32_2_out;
1704     uint32_t       v32_3_out;
1705     uint64_t       v64_0_out;
1706     uint64_t       v64_1_out;
1707     uint64_t       v64_2_out;
1708     uint64_t       v64_3_out;
1709     uint64_t       v64_4_out;
1710     uint64_t       v64_5_out;
1711     uint64_t       v64_6_out;
1712     uint64_t       v64_7_out;
1713     uint8_t        buffer[sizeof(uint64_t) * 2];
1714     void *         p;
1715
1716     // Try an 8-bit quantity. They are aligned anywhere and unaligned
1717     // nowhere.
1718
1719     p = &buffer[0];
1720     LittleEndian::WriteUnaligned8(p, v8_in);
1721     memcpy(&v8_out, &buffer[0], sizeof(v8_in));
1722     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v8_out));
1723
1724     // Try 16-bit quantities.
1725
1726     p = &buffer[0];
1727     LittleEndian::WriteUnaligned16(p, v16_in);
1728     memcpy(&v16_0_out, &buffer[0], sizeof(v16_in));
1729     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v16_0_out));
1730
1731     p = &buffer[1];
1732     LittleEndian::WriteUnaligned16(p, v16_in);
1733     memcpy(&v16_1_out, &buffer[1], sizeof(v16_in));
1734     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v16_1_out));
1735
1736     // Try 32-bit quantities.
1737
1738     p = &buffer[0];
1739     LittleEndian::WriteUnaligned32(p, v32_in);
1740     memcpy(&v32_0_out, &buffer[0], sizeof(v32_in));
1741     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v32_0_out));
1742
1743     p = &buffer[1];
1744     LittleEndian::WriteUnaligned32(p, v32_in);
1745     memcpy(&v32_1_out, &buffer[1], sizeof(v32_in));
1746     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v32_1_out));
1747
1748     p = &buffer[2];
1749     LittleEndian::WriteUnaligned32(p, v32_in);
1750     memcpy(&v32_2_out, &buffer[2], sizeof(v32_in));
1751     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(v32_2_out));
1752
1753     p = &buffer[3];
1754     LittleEndian::WriteUnaligned32(p, v32_in);
1755     memcpy(&v32_3_out, &buffer[3], sizeof(v32_in));
1756     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(v32_3_out));
1757
1758     // Try 64-bit quantities.
1759
1760     p = &buffer[0];
1761     LittleEndian::WriteUnaligned64(p, v64_in);
1762     memcpy(&v64_0_out, &buffer[0], sizeof(v64_in));
1763     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(v64_0_out));
1764
1765     p = &buffer[1];
1766     LittleEndian::WriteUnaligned64(p, v64_in);
1767     memcpy(&v64_1_out, &buffer[1], sizeof(v64_in));
1768     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(v64_1_out));
1769
1770     p = &buffer[2];
1771     LittleEndian::WriteUnaligned64(p, v64_in);
1772     memcpy(&v64_2_out, &buffer[2], sizeof(v64_in));
1773     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(v64_2_out));
1774
1775     p = &buffer[3];
1776     LittleEndian::WriteUnaligned64(p, v64_in);
1777     memcpy(&v64_3_out, &buffer[3], sizeof(v64_in));
1778     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(v64_3_out));
1779
1780     p = &buffer[4];
1781     LittleEndian::WriteUnaligned64(p, v64_in);
1782     memcpy(&v64_4_out, &buffer[4], sizeof(v64_in));
1783     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[4] + sizeof(v64_4_out));
1784
1785     p = &buffer[5];
1786     LittleEndian::WriteUnaligned64(p, v64_in);
1787     memcpy(&v64_5_out, &buffer[5], sizeof(v64_in));
1788     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[5] + sizeof(v64_5_out));
1789
1790     p = &buffer[6];
1791     LittleEndian::WriteUnaligned64(p, v64_in);
1792     memcpy(&v64_6_out, &buffer[6], sizeof(v64_in));
1793     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[6] + sizeof(v64_6_out));
1794
1795     p = &buffer[7];
1796     LittleEndian::WriteUnaligned64(p, v64_in);
1797     memcpy(&v64_7_out, &buffer[7], sizeof(v64_in));
1798     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[7] + sizeof(v64_7_out));
1799
1800 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
1801     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC8);
1802     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC16);
1803     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC16);
1804     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC32);
1805     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC32);
1806     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC32);
1807     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC32);
1808     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC64);
1809     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC64);
1810     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC64);
1811     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC64);
1812     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC64);
1813     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC64);
1814     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC64);
1815     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC64);
1816
1817 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
1818     NL_TEST_ASSERT(inSuite, v8_out    == MAGIC_SWAP8);
1819     NL_TEST_ASSERT(inSuite, v16_0_out == MAGIC_SWAP16);
1820     NL_TEST_ASSERT(inSuite, v16_1_out == MAGIC_SWAP16);
1821     NL_TEST_ASSERT(inSuite, v32_0_out == MAGIC_SWAP32);
1822     NL_TEST_ASSERT(inSuite, v32_1_out == MAGIC_SWAP32);
1823     NL_TEST_ASSERT(inSuite, v32_2_out == MAGIC_SWAP32);
1824     NL_TEST_ASSERT(inSuite, v32_3_out == MAGIC_SWAP32);
1825     NL_TEST_ASSERT(inSuite, v64_0_out == MAGIC_SWAP64);
1826     NL_TEST_ASSERT(inSuite, v64_1_out == MAGIC_SWAP64);
1827     NL_TEST_ASSERT(inSuite, v64_2_out == MAGIC_SWAP64);
1828     NL_TEST_ASSERT(inSuite, v64_3_out == MAGIC_SWAP64);
1829     NL_TEST_ASSERT(inSuite, v64_4_out == MAGIC_SWAP64);
1830     NL_TEST_ASSERT(inSuite, v64_5_out == MAGIC_SWAP64);
1831     NL_TEST_ASSERT(inSuite, v64_6_out == MAGIC_SWAP64);
1832     NL_TEST_ASSERT(inSuite, v64_7_out == MAGIC_SWAP64);
1833
1834 #else
1835     NL_TEST_ASSERT(inSuite, false);
1836
1837 #endif
1838 }
1839
1840 static const nlTest sTests[] = {
1841     NL_TEST_DEF("get big",                CheckGetBig),
1842     NL_TEST_DEF("get little",             CheckGetLittle),
1843     NL_TEST_DEF("put big",                CheckPutBig),
1844     NL_TEST_DEF("put little",             CheckPutLittle),
1845     NL_TEST_DEF("read big",               CheckReadBig),
1846     NL_TEST_DEF("read little",            CheckReadLittle),
1847     NL_TEST_DEF("write big",              CheckWriteBig),
1848     NL_TEST_DEF("write little",           CheckWriteLittle),
1849     NL_TEST_DEF("get big aligned",        CheckGetBigAligned),
1850     NL_TEST_DEF("get little aligned",     CheckGetLittleAligned),
1851     NL_TEST_DEF("put big aligned",        CheckPutBigAligned),
1852     NL_TEST_DEF("put little aligned",     CheckPutLittleAligned),
1853     NL_TEST_DEF("read big aligned",       CheckReadBigAligned),
1854     NL_TEST_DEF("read little aligned",    CheckReadLittleAligned),
1855     NL_TEST_DEF("write big aligned",      CheckWriteBigAligned),
1856     NL_TEST_DEF("write little aligned",   CheckWriteLittleAligned),
1857     NL_TEST_DEF("get big unaligned",      CheckGetBigUnaligned),
1858     NL_TEST_DEF("get little unaligned",   CheckGetLittleUnaligned),
1859     NL_TEST_DEF("put big unaligned",      CheckPutBigUnaligned),
1860     NL_TEST_DEF("put little unaligned",   CheckPutLittleUnaligned),
1861     NL_TEST_DEF("read big unaligned",     CheckReadBigUnaligned),
1862     NL_TEST_DEF("read little unaligned",  CheckReadLittleUnaligned),
1863     NL_TEST_DEF("write big unaligned",    CheckWriteBigUnaligned),
1864     NL_TEST_DEF("write little unaligned", CheckWriteLittleUnaligned),
1865
1866     NL_TEST_SENTINEL()
1867 };
1868
1869 int main(void)
1870 {
1871     nlTestSuite theSuite = {
1872         "nlio-byteorder-cxx",
1873         &sTests[0]
1874     };
1875
1876     nl_test_set_output_style(OUTPUT_CSV);
1877
1878     nlTestRunner(&theSuite, NULL);
1879
1880     return nlTestRunnerStats(&theSuite);
1881 }