third_party/nlio/repo/tests/nlio-byteorder-test.c

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