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

   1 /**
   2  *    Copyright 2012-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 and
  21  *      macros.
  22  *
  23  */
  24
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27
  28 #include <nlio.h>
  29
  30 #include <nlunit-test.h>
  31
  32 #include "nlio-test.h"
  33
  34 static void CheckIntrospection(nlTestSuite *inSuite, void *inContext)
  35 {
  36     bool aligned;
  37     uint8_t v8;
  38     uint16_t v16;
  39     uint32_t v32;
  40     uint64_t v64;
  41     _uint128_t v128;
  42
  43     // Check for natural alignment of an 8-bit stack variable.
  44
  45     aligned = nlIOIsAligned(&v8, sizeof(v8));
  46     NL_TEST_ASSERT(inSuite, aligned == true);
  47
  48     // Check for natural alignment of an 16-bit stack variable, which
  49     // should also be aligned on 8-bit as well.
  50
  51     aligned = nlIOIsAligned(&v16, sizeof(v16));
  52     NL_TEST_ASSERT(inSuite, aligned == true);
  53
  54     aligned = nlIOIsAligned(&v16, sizeof(v8));
  55     NL_TEST_ASSERT(inSuite, aligned == true);
  56
  57     // Check for natural alignment of an 32-bit stack variable, which
  58     // should also be aligned on 16- and 8-bit as well.
  59
  60     aligned = nlIOIsAligned(&v32, sizeof(v32));
  61     NL_TEST_ASSERT(inSuite, aligned == true);
  62
  63     aligned = nlIOIsAligned(&v32, sizeof(v16));
  64     NL_TEST_ASSERT(inSuite, aligned == true);
  65
  66     aligned = nlIOIsAligned(&v32, sizeof(v8));
  67     NL_TEST_ASSERT(inSuite, aligned == true);
  68
  69     // Check for natural alignment of an 64-bit stack variable, which
  70     // should also be aligned on 32-, 16-, and 8-bit as well.
  71
  72     aligned = nlIOIsAligned(&v64, sizeof(v64));
  73     NL_TEST_ASSERT(inSuite, aligned == true);
  74
  75     aligned = nlIOIsAligned(&v64, sizeof(v32));
  76     NL_TEST_ASSERT(inSuite, aligned == true);
  77
  78     aligned = nlIOIsAligned(&v64, sizeof(v16));
  79     NL_TEST_ASSERT(inSuite, aligned == true);
  80
  81     aligned = nlIOIsAligned(&v64, sizeof(v8));
  82     NL_TEST_ASSERT(inSuite, aligned == true);
  83
  84     // Check for natural alignment of an 128-bit stack variable, which
  85     // should also be aligned on 64-, 32-, 16-, and 8-bit as well.
  86
  87     aligned = nlIOIsAligned(&v128, sizeof(v128));
  88     NL_TEST_ASSERT(inSuite, aligned == true);
  89
  90     aligned = nlIOIsAligned(&v128, sizeof(v64));
  91     NL_TEST_ASSERT(inSuite, aligned == true);
  92
  93     aligned = nlIOIsAligned(&v128, sizeof(v32));
  94     NL_TEST_ASSERT(inSuite, aligned == true);
  95
  96     aligned = nlIOIsAligned(&v128, sizeof(v16));
  97     NL_TEST_ASSERT(inSuite, aligned == true);
  98
  99     aligned = nlIOIsAligned(&v128, sizeof(v8));
 100     NL_TEST_ASSERT(inSuite, aligned == true);
 101 }
 102
 103 static void CheckAlignedGet(nlTestSuite *inSuite, void *inContext)
 104 {
 105     const uint8_t s8 = MAGIC_8;
 106     const uint16_t s16 = MAGIC_16;
 107     const uint32_t s32 = MAGIC_32;
 108     const uint64_t s64 = MAGIC_64;
 109     uint8_t v8;
 110     uint16_t v16;
 111     uint32_t v32;
 112     uint64_t v64;
 113
 114     v8 = nlIOGetAligned8(&s8);
 115     NL_TEST_ASSERT(inSuite, v8 == MAGIC_8);
 116
 117     v16 = nlIOGetAligned16(&s16);
 118     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
 119
 120     v32 = nlIOGetAligned32(&s32);
 121     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 122
 123     v64 = nlIOGetAligned64(&s64);
 124     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 125 }
 126
 127 static void CheckAlignedPut(nlTestSuite *inSuite, void *inContext)
 128 {
 129     const uint8_t v8 = MAGIC_8;
 130     const uint16_t v16 = MAGIC_16;
 131     const uint32_t v32 = MAGIC_32;
 132     const uint64_t v64 = MAGIC_64;
 133     uint8_t s8;
 134     uint16_t s16;
 135     uint32_t s32;
 136     uint64_t s64;
 137
 138     nlIOPutAligned8(&s8, v8);
 139     NL_TEST_ASSERT(inSuite, s8 == MAGIC_8);
 140
 141     nlIOPutAligned16(&s16, v16);
 142     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
 143
 144     nlIOPutAligned32(&s32, v32);
 145     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 146
 147     nlIOPutAligned64(&s64, v64);
 148     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 149 }
 150
 151 static void CheckUnalignedGet(nlTestSuite *inSuite, void *inContext)
 152 {
 153     const uint8_t s8 = MAGIC_8;
 154     const uint16_t s16 = MAGIC_16;
 155     const uint32_t s32 = MAGIC_32;
 156     const uint64_t s64 = MAGIC_64;
 157     uint8_t buffer[sizeof(uint64_t) * 2];
 158     uint8_t v8;
 159     uint16_t v16;
 160     uint32_t v32;
 161     uint64_t v64;
 162     void *p;
 163
 164     // Try an 8-bit quantity. They are aligned anywhere and unaligned
 165     // nowhere.
 166
 167     p = &buffer[0];
 168     memcpy(p, &s8, sizeof(s8));
 169
 170     v8 = nlIOGetUnaligned8(p);
 171     NL_TEST_ASSERT(inSuite, v8 == MAGIC_8);
 172
 173     // Try 16-bit quantities.
 174
 175     p = &buffer[0];
 176     memcpy(p, &s16, sizeof(s16));
 177
 178     v16 = nlIOGetUnaligned16(p);
 179     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
 180
 181     p = &buffer[1];
 182     memcpy(p, &s16, sizeof(s16));
 183
 184     v16 = nlIOGetUnaligned16(p);
 185     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
 186
 187     // Try 32-bit quantities.
 188
 189     p = &buffer[0];
 190     memcpy(p, &s32, sizeof(s32));
 191
 192     v32 = nlIOGetUnaligned32(p);
 193     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 194
 195     p = &buffer[1];
 196     memcpy(p, &s32, sizeof(s32));
 197
 198     v32 = nlIOGetUnaligned32(p);
 199     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 200
 201     p = &buffer[2];
 202     memcpy(p, &s32, sizeof(s32));
 203
 204     v32 = nlIOGetUnaligned32(p);
 205     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 206
 207     p = &buffer[3];
 208     memcpy(p, &s32, sizeof(s32));
 209
 210     v32 = nlIOGetUnaligned32(p);
 211     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 212
 213     // Try 64-bit quantities.
 214
 215     p = &buffer[0];
 216     memcpy(p, &s64, sizeof(s64));
 217
 218     v64 = nlIOGetUnaligned64(p);
 219     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 220
 221     p = &buffer[1];
 222     memcpy(p, &s64, sizeof(s64));
 223
 224     v64 = nlIOGetUnaligned64(p);
 225     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 226
 227     p = &buffer[2];
 228     memcpy(p, &s64, sizeof(s64));
 229
 230     v64 = nlIOGetUnaligned64(p);
 231     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 232
 233     p = &buffer[3];
 234     memcpy(p, &s64, sizeof(s64));
 235
 236     v64 = nlIOGetUnaligned64(p);
 237     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 238
 239     p = &buffer[4];
 240     memcpy(p, &s64, sizeof(s64));
 241
 242     v64 = nlIOGetUnaligned64(p);
 243     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 244
 245     p = &buffer[5];
 246     memcpy(p, &s64, sizeof(s64));
 247
 248     v64 = nlIOGetUnaligned64(p);
 249     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 250
 251     p = &buffer[6];
 252     memcpy(p, &s64, sizeof(s64));
 253
 254     v64 = nlIOGetUnaligned64(p);
 255     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 256
 257     p = &buffer[7];
 258     memcpy(p, &s64, sizeof(s64));
 259
 260     v64 = nlIOGetUnaligned64(p);
 261     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 262 }
 263
 264 static void CheckUnalignedPut(nlTestSuite *inSuite, void *inContext)
 265 {
 266     const uint8_t v8 = MAGIC_8;
 267     const uint16_t v16 = MAGIC_16;
 268     const uint32_t v32 = MAGIC_32;
 269     const uint64_t v64 = MAGIC_64;
 270     uint8_t buffer[sizeof(uint64_t) * 2];
 271     uint8_t s8;
 272     uint16_t s16;
 273     uint32_t s32;
 274     uint64_t s64;
 275     void *p;
 276
 277     // Try an 8-bit quantity. They are aligned anywhere and unaligned
 278     // nowhere.
 279
 280     p = &buffer[0];
 281     nlIOPutUnaligned8(p, v8);
 282     memcpy(&s8, p, sizeof(v8));
 283     NL_TEST_ASSERT(inSuite, s8 == MAGIC_8);
 284
 285     // Try 16-bit quantities.
 286
 287     p = &buffer[0];
 288     nlIOPutUnaligned16(p, v16);
 289     memcpy(&s16, p, sizeof(v16));
 290     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
 291
 292     p = &buffer[1];
 293     nlIOPutUnaligned16(p, v16);
 294     memcpy(&s16, p, sizeof(v16));
 295     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
 296
 297     // Try 32-bit quantities.
 298
 299     p = &buffer[0];
 300     nlIOPutUnaligned32(p, v32);
 301     memcpy(&s32, p, sizeof(v32));
 302     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 303
 304     p = &buffer[1];
 305     nlIOPutUnaligned32(p, v32);
 306     memcpy(&s32, p, sizeof(v32));
 307     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 308
 309     p = &buffer[2];
 310     nlIOPutUnaligned32(p, v32);
 311     memcpy(&s32, p, sizeof(v32));
 312     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 313
 314     p = &buffer[3];
 315     nlIOPutUnaligned32(p, v32);
 316     memcpy(&s32, p, sizeof(v32));
 317     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 318
 319     // Try 64-bit quantities.
 320
 321     p = &buffer[0];
 322     nlIOPutUnaligned64(p, v64);
 323     memcpy(&s64, p, sizeof(v64));
 324     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 325
 326     p = &buffer[1];
 327     nlIOPutUnaligned64(p, v64);
 328     memcpy(&s64, p, sizeof(v64));
 329     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 330
 331     p = &buffer[2];
 332     nlIOPutUnaligned64(p, v64);
 333     memcpy(&s64, p, sizeof(v64));
 334     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 335
 336     p = &buffer[3];
 337     nlIOPutUnaligned64(p, v64);
 338     memcpy(&s64, p, sizeof(v64));
 339     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 340
 341     p = &buffer[4];
 342     nlIOPutUnaligned64(p, v64);
 343     memcpy(&s64, p, sizeof(v64));
 344     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 345
 346     p = &buffer[5];
 347     nlIOPutUnaligned64(p, v64);
 348     memcpy(&s64, p, sizeof(v64));
 349     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 350
 351     p = &buffer[6];
 352     nlIOPutUnaligned64(p, v64);
 353     memcpy(&s64, p, sizeof(v64));
 354     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 355
 356     p = &buffer[7];
 357     nlIOPutUnaligned64(p, v64);
 358     memcpy(&s64, p, sizeof(v64));
 359     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 360 }
 361
 362 static void CheckMaybeAlignedGet(nlTestSuite *inSuite, void *inContext)
 363 {
 364     const uint8_t s8 = MAGIC_8;
 365     const uint16_t s16 = MAGIC_16;
 366     const uint32_t s32 = MAGIC_32;
 367     const uint64_t s64 = MAGIC_64;
 368     uint8_t buffer[sizeof(uint64_t) * 2];
 369     uint8_t v8;
 370     uint16_t v16;
 371     uint32_t v32;
 372     uint64_t v64;
 373     void *p;
 374
 375     // Try an 8-bit quantity. They are aligned anywhere and unaligned
 376     // nowhere.
 377
 378     v8 = nlIOGetMaybeAligned8(&s8);
 379     NL_TEST_ASSERT(inSuite, v8 == MAGIC_8);
 380
 381     // Try 16-bit quantities.
 382
 383     p = &buffer[0];
 384     memcpy(p, &s16, sizeof(s16));
 385
 386     v16 = nlIOGetMaybeAligned16(p);
 387     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
 388
 389     p = &buffer[1];
 390     memcpy(p, &s16, sizeof(s16));
 391
 392     v16 = nlIOGetMaybeAligned16(p);
 393     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
 394
 395     // Try 32-bit quantities.
 396
 397     p = &buffer[0];
 398     memcpy(p, &s32, sizeof(s32));
 399
 400     v32 = nlIOGetMaybeAligned32(p);
 401     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 402
 403     p = &buffer[1];
 404     memcpy(p, &s32, sizeof(s32));
 405
 406     v32 = nlIOGetMaybeAligned32(p);
 407     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 408
 409     p = &buffer[2];
 410     memcpy(p, &s32, sizeof(s32));
 411
 412     v32 = nlIOGetMaybeAligned32(p);
 413     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 414
 415     p = &buffer[3];
 416     memcpy(p, &s32, sizeof(s32));
 417
 418     v32 = nlIOGetMaybeAligned32(p);
 419     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 420
 421     // Try 64-bit quantities.
 422
 423     p = &buffer[0];
 424     memcpy(p, &s64, sizeof(s64));
 425
 426     v64 = nlIOGetMaybeAligned64(p);
 427     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 428
 429     p = &buffer[1];
 430     memcpy(p, &s64, sizeof(s64));
 431
 432     v64 = nlIOGetMaybeAligned64(p);
 433     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 434
 435     p = &buffer[2];
 436     memcpy(p, &s64, sizeof(s64));
 437
 438     v64 = nlIOGetMaybeAligned64(p);
 439     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 440
 441     p = &buffer[3];
 442     memcpy(p, &s64, sizeof(s64));
 443
 444     v64 = nlIOGetMaybeAligned64(p);
 445     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 446
 447     p = &buffer[4];
 448     memcpy(p, &s64, sizeof(s64));
 449
 450     v64 = nlIOGetMaybeAligned64(p);
 451     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 452
 453     p = &buffer[5];
 454     memcpy(p, &s64, sizeof(s64));
 455
 456     v64 = nlIOGetMaybeAligned64(p);
 457     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 458
 459     p = &buffer[6];
 460     memcpy(p, &s64, sizeof(s64));
 461
 462     v64 = nlIOGetMaybeAligned64(p);
 463     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 464
 465     p = &buffer[7];
 466     memcpy(p, &s64, sizeof(s64));
 467
 468     v64 = nlIOGetMaybeAligned64(p);
 469     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 470 }
 471
 472 static void CheckMaybeAlignedPut(nlTestSuite *inSuite, void *inContext)
 473 {
 474     const uint8_t v8 = MAGIC_8;
 475     const uint16_t v16 = MAGIC_16;
 476     const uint32_t v32 = MAGIC_32;
 477     const uint64_t v64 = MAGIC_64;
 478     uint8_t buffer[sizeof(uint64_t) * 2];
 479     uint8_t s8;
 480     uint16_t s16;
 481     uint32_t s32;
 482     uint64_t s64;
 483     void *p;
 484
 485     // Try an 8-bit quantity. They are aligned anywhere and unaligned
 486     // nowhere.
 487
 488     p = &buffer[0];
 489     nlIOPutMaybeAligned8(p, v8);
 490     memcpy(&s8, p, sizeof(v8));
 491     NL_TEST_ASSERT(inSuite, s8 == MAGIC_8);
 492
 493     // Try 16-bit quantities.
 494
 495     p = &buffer[0];
 496     nlIOPutMaybeAligned16(p, v16);
 497     memcpy(&s16, p, sizeof(v16));
 498     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
 499
 500     p = &buffer[1];
 501     nlIOPutMaybeAligned16(p, v16);
 502     memcpy(&s16, p, sizeof(v16));
 503     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
 504
 505     // Try 32-bit quantities.
 506
 507     p = &buffer[0];
 508     nlIOPutMaybeAligned32(p, v32);
 509     memcpy(&s32, p, sizeof(v32));
 510     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 511
 512     p = &buffer[1];
 513     nlIOPutMaybeAligned32(p, v32);
 514     memcpy(&s32, p, sizeof(v32));
 515     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 516
 517     p = &buffer[2];
 518     nlIOPutMaybeAligned32(p, v32);
 519     memcpy(&s32, p, sizeof(v32));
 520     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 521
 522     p = &buffer[3];
 523     nlIOPutMaybeAligned32(p, v32);
 524     memcpy(&s32, p, sizeof(v32));
 525     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 526
 527     // Try 64-bit quantities.
 528
 529     p = &buffer[0];
 530     nlIOPutMaybeAligned64(p, v64);
 531     memcpy(&s64, p, sizeof(v64));
 532     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 533
 534     p = &buffer[1];
 535     nlIOPutMaybeAligned64(p, v64);
 536     memcpy(&s64, p, sizeof(v64));
 537     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 538
 539     p = &buffer[2];
 540     nlIOPutMaybeAligned64(p, v64);
 541     memcpy(&s64, p, sizeof(v64));
 542     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 543
 544     p = &buffer[3];
 545     nlIOPutMaybeAligned64(p, v64);
 546     memcpy(&s64, p, sizeof(v64));
 547     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 548
 549     p = &buffer[4];
 550     nlIOPutMaybeAligned64(p, v64);
 551     memcpy(&s64, p, sizeof(v64));
 552     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 553
 554     p = &buffer[5];
 555     nlIOPutMaybeAligned64(p, v64);
 556     memcpy(&s64, p, sizeof(v64));
 557     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 558
 559     p = &buffer[6];
 560     nlIOPutMaybeAligned64(p, v64);
 561     memcpy(&s64, p, sizeof(v64));
 562     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 563
 564     p = &buffer[7];
 565     nlIOPutMaybeAligned64(p, v64);
 566     memcpy(&s64, p, sizeof(v64));
 567     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 568 }
 569
 570 static void CheckGet(nlTestSuite *inSuite, void *inContext)
 571 {
 572     const uint8_t s8 = MAGIC_8;
 573     const uint16_t s16 = MAGIC_16;
 574     const uint32_t s32 = MAGIC_32;
 575     const uint64_t s64 = MAGIC_64;
 576     uint8_t buffer[sizeof(uint64_t) * 2];
 577     uint8_t v8;
 578     uint16_t v16;
 579     uint32_t v32;
 580     uint64_t v64;
 581     void *p;
 582
 583     // Try an 8-bit quantity. They are aligned anywhere and unaligned
 584     // nowhere.
 585
 586     v8 = nlIOGet8(&s8);
 587     NL_TEST_ASSERT(inSuite, v8 == MAGIC_8);
 588
 589     // Try 16-bit quantities.
 590
 591     p = &buffer[0];
 592     memcpy(p, &s16, sizeof(s16));
 593
 594     v16 = nlIOGet16(p);
 595     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
 596
 597     p = &buffer[1];
 598     memcpy(p, &s16, sizeof(s16));
 599
 600     v16 = nlIOGet16(p);
 601     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
 602
 603     // Try 32-bit quantities.
 604
 605     p = &buffer[0];
 606     memcpy(p, &s32, sizeof(s32));
 607
 608     v32 = nlIOGet32(p);
 609     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 610
 611     p = &buffer[1];
 612     memcpy(p, &s32, sizeof(s32));
 613
 614     v32 = nlIOGet32(p);
 615     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 616
 617     p = &buffer[2];
 618     memcpy(p, &s32, sizeof(s32));
 619
 620     v32 = nlIOGet32(p);
 621     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 622
 623     p = &buffer[3];
 624     memcpy(p, &s32, sizeof(s32));
 625
 626     v32 = nlIOGet32(p);
 627     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 628
 629     // Try 64-bit quantities.
 630
 631     p = &buffer[0];
 632     memcpy(p, &s64, sizeof(s64));
 633
 634     v64 = nlIOGet64(p);
 635     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 636
 637     p = &buffer[1];
 638     memcpy(p, &s64, sizeof(s64));
 639
 640     v64 = nlIOGet64(p);
 641     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 642
 643     p = &buffer[2];
 644     memcpy(p, &s64, sizeof(s64));
 645
 646     v64 = nlIOGet64(p);
 647     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 648
 649     p = &buffer[3];
 650     memcpy(p, &s64, sizeof(s64));
 651
 652     v64 = nlIOGet64(p);
 653     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 654
 655     p = &buffer[4];
 656     memcpy(p, &s64, sizeof(s64));
 657
 658     v64 = nlIOGet64(p);
 659     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 660
 661     p = &buffer[5];
 662     memcpy(p, &s64, sizeof(s64));
 663
 664     v64 = nlIOGet64(p);
 665     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 666
 667     p = &buffer[6];
 668     memcpy(p, &s64, sizeof(s64));
 669
 670     v64 = nlIOGet64(p);
 671     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 672
 673     p = &buffer[7];
 674     memcpy(p, &s64, sizeof(s64));
 675
 676     v64 = nlIOGet64(p);
 677     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 678 }
 679
 680 static void CheckPut(nlTestSuite *inSuite, void *inContext)
 681 {
 682     const uint8_t v8 = MAGIC_8;
 683     const uint16_t v16 = MAGIC_16;
 684     const uint32_t v32 = MAGIC_32;
 685     const uint64_t v64 = MAGIC_64;
 686     uint8_t buffer[sizeof(uint64_t) * 2];
 687     uint8_t s8;
 688     uint16_t s16;
 689     uint32_t s32;
 690     uint64_t s64;
 691     void *p;
 692
 693     // Try an 8-bit quantity. They are aligned anywhere and unaligned
 694     // nowhere.
 695
 696     p = &buffer[0];
 697     nlIOPut8(p, v8);
 698     memcpy(&s8, p, sizeof(v8));
 699     NL_TEST_ASSERT(inSuite, s8 == MAGIC_8);
 700
 701     // Try 16-bit quantities.
 702
 703     p = &buffer[0];
 704     nlIOPut16(p, v16);
 705     memcpy(&s16, p, sizeof(v16));
 706     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
 707
 708     p = &buffer[1];
 709     nlIOPut16(p, v16);
 710     memcpy(&s16, p, sizeof(v16));
 711     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
 712
 713     // Try 32-bit quantities.
 714
 715     p = &buffer[0];
 716     nlIOPut32(p, v32);
 717     memcpy(&s32, p, sizeof(v32));
 718     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 719
 720     p = &buffer[1];
 721     nlIOPut32(p, v32);
 722     memcpy(&s32, p, sizeof(v32));
 723     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 724
 725     p = &buffer[2];
 726     nlIOPut32(p, v32);
 727     memcpy(&s32, p, sizeof(v32));
 728     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 729
 730     p = &buffer[3];
 731     nlIOPut32(p, v32);
 732     memcpy(&s32, p, sizeof(v32));
 733     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 734
 735     // Try 64-bit quantities.
 736
 737     p = &buffer[0];
 738     nlIOPut64(p, v64);
 739     memcpy(&s64, p, sizeof(v64));
 740     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 741
 742     p = &buffer[1];
 743     nlIOPut64(p, v64);
 744     memcpy(&s64, p, sizeof(v64));
 745     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 746
 747     p = &buffer[2];
 748     nlIOPut64(p, v64);
 749     memcpy(&s64, p, sizeof(v64));
 750     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 751
 752     p = &buffer[3];
 753     nlIOPut64(p, v64);
 754     memcpy(&s64, p, sizeof(v64));
 755     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 756
 757     p = &buffer[4];
 758     nlIOPut64(p, v64);
 759     memcpy(&s64, p, sizeof(v64));
 760     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 761
 762     p = &buffer[5];
 763     nlIOPut64(p, v64);
 764     memcpy(&s64, p, sizeof(v64));
 765     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 766
 767     p = &buffer[6];
 768     nlIOPut64(p, v64);
 769     memcpy(&s64, p, sizeof(v64));
 770     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 771
 772     p = &buffer[7];
 773     nlIOPut64(p, v64);
 774     memcpy(&s64, p, sizeof(v64));
 775     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 776 }
 777
 778 static void CheckAlignedRead(nlTestSuite *inSuite, void *inContext)
 779 {
 780     const uint8_t s8 = MAGIC_8;
 781     const uint16_t s16 = MAGIC_16;
 782     const uint32_t s32 = MAGIC_32;
 783     const uint64_t s64 = MAGIC_64;
 784     uint8_t v8;
 785     uint16_t v16;
 786     uint32_t v32;
 787     uint64_t v64;
 788     const void *p;
 789
 790     p = &s8;
 791     v8 = nlIOReadAligned8(&p);
 792     NL_TEST_ASSERT(inSuite, v8 == MAGIC_8);
 793     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&s8 + sizeof(s8));
 794
 795     p = &s16;
 796     v16 = nlIOReadAligned16(&p);
 797     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
 798     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&s16 + sizeof(s16));
 799
 800     p = &s32;
 801     v32 = nlIOReadAligned32(&p);
 802     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 803     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&s32 + sizeof(s32));
 804
 805     p = &s64;
 806     v64 = nlIOReadAligned64(&p);
 807     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 808     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&s64 + sizeof(s64));
 809 }
 810
 811 static void CheckAlignedWrite(nlTestSuite *inSuite, void *inContext)
 812 {
 813     const uint8_t v8 = MAGIC_8;
 814     const uint16_t v16 = MAGIC_16;
 815     const uint32_t v32 = MAGIC_32;
 816     const uint64_t v64 = MAGIC_64;
 817     uint8_t s8;
 818     uint16_t s16;
 819     uint32_t s32;
 820     uint64_t s64;
 821     void *p;
 822
 823     p = &s8;
 824     nlIOWriteAligned8(&p, v8);
 825     NL_TEST_ASSERT(inSuite, s8 == MAGIC_8);
 826     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&s8 + sizeof(s8));
 827
 828     p = &s16;
 829     nlIOWriteAligned16(&p, v16);
 830     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
 831     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&s16 + sizeof(s16));
 832
 833     p = &s32;
 834     nlIOWriteAligned32(&p, v32);
 835     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
 836     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&s32 + sizeof(s32));
 837
 838     p = &s64;
 839     nlIOWriteAligned64(&p, v64);
 840     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
 841     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&s64 + sizeof(s64));
 842 }
 843
 844 static void CheckUnalignedRead(nlTestSuite *inSuite, void *inContext)
 845 {
 846     const uint8_t s8 = MAGIC_8;
 847     const uint16_t s16 = MAGIC_16;
 848     const uint32_t s32 = MAGIC_32;
 849     const uint64_t s64 = MAGIC_64;
 850     uint8_t buffer[sizeof(uint64_t) * 2];
 851     uint8_t v8;
 852     uint16_t v16;
 853     uint32_t v32;
 854     uint64_t v64;
 855     const void *p;
 856
 857     // Try an 8-bit quantity. They are aligned anywhere and unaligned
 858     // nowhere.
 859
 860     p = &buffer[0];
 861     memcpy(&buffer[0], &s8, sizeof(s8));
 862
 863     v8 = nlIOReadUnaligned8((const void **)&p);
 864     NL_TEST_ASSERT(inSuite, v8 == MAGIC_8);
 865     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s8));
 866
 867     // Try 16-bit quantities.
 868
 869     p = &buffer[0];
 870     memcpy(&buffer[0], &s16, sizeof(s16));
 871
 872     v16 = nlIOReadUnaligned16((const void **)&p);
 873     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
 874     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s16));
 875
 876     p = &buffer[1];
 877     memcpy(&buffer[1], &s16, sizeof(s16));
 878
 879     v16 = nlIOReadUnaligned16((const void **)&p);
 880     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
 881     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s16));
 882
 883     // Try 32-bit quantities.
 884
 885     p = &buffer[0];
 886     memcpy(&buffer[0], &s32, sizeof(s32));
 887
 888     v32 = nlIOReadUnaligned32((const void **)&p);
 889     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 890     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s32));
 891
 892     p = &buffer[1];
 893     memcpy(&buffer[1], &s32, sizeof(s32));
 894
 895     v32 = nlIOReadUnaligned32((const void **)&p);
 896     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 897     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s32));
 898
 899     p = &buffer[2];
 900     memcpy(&buffer[2], &s32, sizeof(s32));
 901
 902     v32 = nlIOReadUnaligned32((const void **)&p);
 903     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 904     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s32));
 905
 906     p = &buffer[3];
 907     memcpy(&buffer[3], &s32, sizeof(s32));
 908
 909     v32 = nlIOReadUnaligned32((const void **)&p);
 910     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
 911     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s32));
 912
 913     // Try 64-bit quantities.
 914
 915     p = &buffer[0];
 916     memcpy(&buffer[0], &s64, sizeof(s64));
 917
 918     v64 = nlIOReadUnaligned64((const void **)&p);
 919     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 920     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s64));
 921
 922     p = &buffer[1];
 923     memcpy(&buffer[1], &s64, sizeof(s64));
 924
 925     v64 = nlIOReadUnaligned64((const void **)&p);
 926     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 927     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s64));
 928
 929     p = &buffer[2];
 930     memcpy(&buffer[2], &s64, sizeof(s64));
 931
 932     v64 = nlIOReadUnaligned64((const void **)&p);
 933     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 934     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s64));
 935
 936     p = &buffer[3];
 937     memcpy(&buffer[3], &s64, sizeof(s64));
 938
 939     v64 = nlIOReadUnaligned64((const void **)&p);
 940     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 941     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s64));
 942
 943     p = &buffer[4];
 944     memcpy(&buffer[4], &s64, sizeof(s64));
 945
 946     v64 = nlIOReadUnaligned64((const void **)&p);
 947     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 948     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[4] + sizeof(s64));
 949
 950     p = &buffer[5];
 951     memcpy(&buffer[5], &s64, sizeof(s64));
 952
 953     v64 = nlIOReadUnaligned64((const void **)&p);
 954     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 955     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[5] + sizeof(s64));
 956
 957     p = &buffer[6];
 958     memcpy(&buffer[6], &s64, sizeof(s64));
 959
 960     v64 = nlIOReadUnaligned64((const void **)&p);
 961     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 962     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[6] + sizeof(s64));
 963
 964     p = &buffer[7];
 965     memcpy(&buffer[7], &s64, sizeof(s64));
 966
 967     v64 = nlIOReadUnaligned64((const void **)&p);
 968     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
 969     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[7] + sizeof(s64));
 970 }
 971
 972 static void CheckUnalignedWrite(nlTestSuite *inSuite, void *inContext)
 973 {
 974     const uint8_t v8 = MAGIC_8;
 975     const uint16_t v16 = MAGIC_16;
 976     const uint32_t v32 = MAGIC_32;
 977     const uint64_t v64 = MAGIC_64;
 978     uint8_t buffer[sizeof(uint64_t) * 2];
 979     uint8_t s8;
 980     uint16_t s16;
 981     uint32_t s32;
 982     uint64_t s64;
 983     void *p;
 984
 985     // Try an 8-bit quantity. They are aligned anywhere and unaligned
 986     // nowhere.
 987
 988     p = &buffer[0];
 989     nlIOWriteUnaligned8(&p, v8);
 990     memcpy(&s8, &buffer[0], sizeof(v8));
 991     NL_TEST_ASSERT(inSuite, s8 == MAGIC_8);
 992     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s8));
 993
 994     // Try 16-bit quantities.
 995
 996     p = &buffer[0];
 997     nlIOWriteUnaligned16(&p, v16);
 998     memcpy(&s16, &buffer[0], sizeof(v16));
 999     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
1000     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s16));
1001
1002     p = &buffer[1];
1003     nlIOWriteUnaligned16(&p, v16);
1004     memcpy(&s16, &buffer[1], sizeof(v16));
1005     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
1006     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s16));
1007
1008     // Try 32-bit quantities.
1009
1010     p = &buffer[0];
1011     nlIOWriteUnaligned32(&p, v32);
1012     memcpy(&s32, &buffer[0], sizeof(v32));
1013     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1014     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s32));
1015
1016     p = &buffer[1];
1017     nlIOWriteUnaligned32(&p, v32);
1018     memcpy(&s32, &buffer[1], sizeof(v32));
1019     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1020     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s32));
1021
1022     p = &buffer[2];
1023     nlIOWriteUnaligned32(&p, v32);
1024     memcpy(&s32, &buffer[2], sizeof(v32));
1025     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1026     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s32));
1027
1028     p = &buffer[3];
1029     nlIOWriteUnaligned32(&p, v32);
1030     memcpy(&s32, &buffer[3], sizeof(v32));
1031     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1032     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s32));
1033
1034     // Try 64-bit quantities.
1035
1036     p = &buffer[0];
1037     nlIOWriteUnaligned64(&p, v64);
1038     memcpy(&s64, &buffer[0], sizeof(v64));
1039     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1040     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s64));
1041
1042     p = &buffer[1];
1043     nlIOWriteUnaligned64(&p, v64);
1044     memcpy(&s64, &buffer[1], sizeof(v64));
1045     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1046     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s64));
1047
1048     p = &buffer[2];
1049     nlIOWriteUnaligned64(&p, v64);
1050     memcpy(&s64, &buffer[2], sizeof(v64));
1051     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1052     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s64));
1053
1054     p = &buffer[3];
1055     nlIOWriteUnaligned64(&p, v64);
1056     memcpy(&s64, &buffer[3], sizeof(v64));
1057     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1058     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s64));
1059
1060     p = &buffer[4];
1061     nlIOWriteUnaligned64(&p, v64);
1062     memcpy(&s64, &buffer[4], sizeof(v64));
1063     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1064     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[4] + sizeof(s64));
1065
1066     p = &buffer[5];
1067     nlIOWriteUnaligned64(&p, v64);
1068     memcpy(&s64, &buffer[5], sizeof(v64));
1069     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1070     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[5] + sizeof(s64));
1071
1072     p = &buffer[6];
1073     nlIOWriteUnaligned64(&p, v64);
1074     memcpy(&s64, &buffer[6], sizeof(v64));
1075     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1076     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[6] + sizeof(s64));
1077
1078     p = &buffer[7];
1079     nlIOWriteUnaligned64(&p, v64);
1080     memcpy(&s64, &buffer[7], sizeof(v64));
1081     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1082     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[7] + sizeof(s64));
1083 }
1084
1085 static void CheckMaybeAlignedRead(nlTestSuite *inSuite, void *inContext)
1086 {
1087     const uint8_t s8 = MAGIC_8;
1088     const uint16_t s16 = MAGIC_16;
1089     const uint32_t s32 = MAGIC_32;
1090     const uint64_t s64 = MAGIC_64;
1091     uint8_t buffer[sizeof(uint64_t) * 2];
1092     uint8_t v8;
1093     uint16_t v16;
1094     uint32_t v32;
1095     uint64_t v64;
1096     const void *p;
1097
1098     // Try an 8-bit quantity. They are aligned anywhere and unaligned
1099     // nowhere.
1100
1101     p = &buffer[0];
1102     memcpy(&buffer[0], &s8, sizeof(s8));
1103
1104     v8 = nlIOReadMaybeAligned8((const void **)&p);
1105     NL_TEST_ASSERT(inSuite, v8 == MAGIC_8);
1106     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s8));
1107
1108     // Try 16-bit quantities.
1109
1110     p = &buffer[0];
1111     memcpy(&buffer[0], &s16, sizeof(s16));
1112
1113     v16 = nlIOReadMaybeAligned16((const void **)&p);
1114     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
1115     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s16));
1116
1117     p = &buffer[1];
1118     memcpy(&buffer[1], &s16, sizeof(s16));
1119
1120     v16 = nlIOReadMaybeAligned16((const void **)&p);
1121     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
1122     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s16));
1123
1124     // Try 32-bit quantities.
1125
1126     p = &buffer[0];
1127     memcpy(&buffer[0], &s32, sizeof(s32));
1128
1129     v32 = nlIOReadMaybeAligned32((const void **)&p);
1130     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
1131     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s32));
1132
1133     p = &buffer[1];
1134     memcpy(&buffer[1], &s32, sizeof(s32));
1135
1136     v32 = nlIOReadMaybeAligned32((const void **)&p);
1137     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
1138     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s32));
1139
1140     p = &buffer[2];
1141     memcpy(&buffer[2], &s32, sizeof(s32));
1142
1143     v32 = nlIOReadMaybeAligned32((const void **)&p);
1144     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
1145     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s32));
1146
1147     p = &buffer[3];
1148     memcpy(&buffer[3], &s32, sizeof(s32));
1149
1150     v32 = nlIOReadMaybeAligned32((const void **)&p);
1151     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
1152     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s32));
1153
1154     // Try 64-bit quantities.
1155
1156     p = &buffer[0];
1157     memcpy(&buffer[0], &s64, sizeof(s64));
1158
1159     v64 = nlIOReadMaybeAligned64((const void **)&p);
1160     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1161     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s64));
1162
1163     p = &buffer[1];
1164     memcpy(&buffer[1], &s64, sizeof(s64));
1165
1166     v64 = nlIOReadMaybeAligned64((const void **)&p);
1167     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1168     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s64));
1169
1170     p = &buffer[2];
1171     memcpy(&buffer[2], &s64, sizeof(s64));
1172
1173     v64 = nlIOReadMaybeAligned64((const void **)&p);
1174     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1175     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s64));
1176
1177     p = &buffer[3];
1178     memcpy(&buffer[3], &s64, sizeof(s64));
1179
1180     v64 = nlIOReadMaybeAligned64((const void **)&p);
1181     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1182     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s64));
1183
1184     p = &buffer[4];
1185     memcpy(&buffer[4], &s64, sizeof(s64));
1186
1187     v64 = nlIOReadMaybeAligned64((const void **)&p);
1188     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1189     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[4] + sizeof(s64));
1190
1191     p = &buffer[5];
1192     memcpy(&buffer[5], &s64, sizeof(s64));
1193
1194     v64 = nlIOReadMaybeAligned64((const void **)&p);
1195     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1196     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[5] + sizeof(s64));
1197
1198     p = &buffer[6];
1199     memcpy(&buffer[6], &s64, sizeof(s64));
1200
1201     v64 = nlIOReadMaybeAligned64((const void **)&p);
1202     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1203     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[6] + sizeof(s64));
1204
1205     p = &buffer[7];
1206     memcpy(&buffer[7], &s64, sizeof(s64));
1207
1208     v64 = nlIOReadMaybeAligned64((const void **)&p);
1209     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1210     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[7] + sizeof(s64));
1211 }
1212
1213 static void CheckMaybeAlignedWrite(nlTestSuite *inSuite, void *inContext)
1214 {
1215     const uint8_t v8 = MAGIC_8;
1216     const uint16_t v16 = MAGIC_16;
1217     const uint32_t v32 = MAGIC_32;
1218     const uint64_t v64 = MAGIC_64;
1219     uint8_t buffer[sizeof(uint64_t) * 2];
1220     uint8_t s8;
1221     uint16_t s16;
1222     uint32_t s32;
1223     uint64_t s64;
1224     void *p;
1225
1226     // Try an 8-bit quantity. They are aligned anywhere and unaligned
1227     // nowhere.
1228
1229     p = &buffer[0];
1230     nlIOWriteMaybeAligned8(&p, v8);
1231     memcpy(&s8, &buffer[0], sizeof(v8));
1232     NL_TEST_ASSERT(inSuite, s8 == MAGIC_8);
1233     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s8));
1234
1235     // Try 16-bit quantities.
1236
1237     p = &buffer[0];
1238     nlIOWriteMaybeAligned16(&p, v16);
1239     memcpy(&s16, &buffer[0], sizeof(v16));
1240     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
1241     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s16));
1242
1243     p = &buffer[1];
1244     nlIOWriteMaybeAligned16(&p, v16);
1245     memcpy(&s16, &buffer[1], sizeof(v16));
1246     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
1247     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s16));
1248
1249     // Try 32-bit quantities.
1250
1251     p = &buffer[0];
1252     nlIOWriteMaybeAligned32(&p, v32);
1253     memcpy(&s32, &buffer[0], sizeof(v32));
1254     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1255     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s32));
1256
1257     p = &buffer[1];
1258     nlIOWriteMaybeAligned32(&p, v32);
1259     memcpy(&s32, &buffer[1], sizeof(v32));
1260     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1261     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s32));
1262
1263     p = &buffer[2];
1264     nlIOWriteMaybeAligned32(&p, v32);
1265     memcpy(&s32, &buffer[2], sizeof(v32));
1266     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1267     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s32));
1268
1269     p = &buffer[3];
1270     nlIOWriteMaybeAligned32(&p, v32);
1271     memcpy(&s32, &buffer[3], sizeof(v32));
1272     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1273     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s32));
1274
1275     // Try 64-bit quantities.
1276
1277     p = &buffer[0];
1278     nlIOWriteMaybeAligned64(&p, v64);
1279     memcpy(&s64, &buffer[0], sizeof(v64));
1280     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1281     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s64));
1282
1283     p = &buffer[1];
1284     nlIOWriteMaybeAligned64(&p, v64);
1285     memcpy(&s64, &buffer[1], sizeof(v64));
1286     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1287     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s64));
1288
1289     p = &buffer[2];
1290     nlIOWriteMaybeAligned64(&p, v64);
1291     memcpy(&s64, &buffer[2], sizeof(v64));
1292     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1293     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s64));
1294
1295     p = &buffer[3];
1296     nlIOWriteMaybeAligned64(&p, v64);
1297     memcpy(&s64, &buffer[3], sizeof(v64));
1298     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1299     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s64));
1300
1301     p = &buffer[4];
1302     nlIOWriteMaybeAligned64(&p, v64);
1303     memcpy(&s64, &buffer[4], sizeof(v64));
1304     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1305     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[4] + sizeof(s64));
1306
1307     p = &buffer[5];
1308     nlIOWriteMaybeAligned64(&p, v64);
1309     memcpy(&s64, &buffer[5], sizeof(v64));
1310     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1311     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[5] + sizeof(s64));
1312
1313     p = &buffer[6];
1314     nlIOWriteMaybeAligned64(&p, v64);
1315     memcpy(&s64, &buffer[6], sizeof(v64));
1316     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1317     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[6] + sizeof(s64));
1318
1319     p = &buffer[7];
1320     nlIOWriteMaybeAligned64(&p, v64);
1321     memcpy(&s64, &buffer[7], sizeof(v64));
1322     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1323     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[7] + sizeof(s64));
1324 }
1325
1326 static void CheckRead(nlTestSuite *inSuite, void *inContext)
1327 {
1328     const uint8_t s8 = MAGIC_8;
1329     const uint16_t s16 = MAGIC_16;
1330     const uint32_t s32 = MAGIC_32;
1331     const uint64_t s64 = MAGIC_64;
1332     uint8_t buffer[sizeof(uint64_t) * 2];
1333     uint8_t v8;
1334     uint16_t v16;
1335     uint32_t v32;
1336     uint64_t v64;
1337     const void *p;
1338
1339     // Try an 8-bit quantity. They are aligned anywhere and unaligned
1340     // nowhere.
1341
1342     p = &buffer[0];
1343     memcpy(&buffer[0], &s8, sizeof(s8));
1344
1345     v8 = nlIORead8((const void **)&p);
1346     NL_TEST_ASSERT(inSuite, v8 == MAGIC_8);
1347     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s8));
1348
1349     // Try 16-bit quantities.
1350
1351     p = &buffer[0];
1352     memcpy(&buffer[0], &s16, sizeof(s16));
1353
1354     v16 = nlIORead16((const void **)&p);
1355     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
1356     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s16));
1357
1358     p = &buffer[1];
1359     memcpy(&buffer[1], &s16, sizeof(s16));
1360
1361     v16 = nlIORead16((const void **)&p);
1362     NL_TEST_ASSERT(inSuite, v16 == MAGIC_16);
1363     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s16));
1364
1365     // Try 32-bit quantities.
1366
1367     p = &buffer[0];
1368     memcpy(&buffer[0], &s32, sizeof(s32));
1369
1370     v32 = nlIORead32((const void **)&p);
1371     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
1372     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s32));
1373
1374     p = &buffer[1];
1375     memcpy(&buffer[1], &s32, sizeof(s32));
1376
1377     v32 = nlIORead32((const void **)&p);
1378     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
1379     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s32));
1380
1381     p = &buffer[2];
1382     memcpy(&buffer[2], &s32, sizeof(s32));
1383
1384     v32 = nlIORead32((const void **)&p);
1385     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
1386     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s32));
1387
1388     p = &buffer[3];
1389     memcpy(&buffer[3], &s32, sizeof(s32));
1390
1391     v32 = nlIORead32((const void **)&p);
1392     NL_TEST_ASSERT(inSuite, v32 == MAGIC_32);
1393     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s32));
1394
1395     // Try 64-bit quantities.
1396
1397     p = &buffer[0];
1398     memcpy(&buffer[0], &s64, sizeof(s64));
1399
1400     v64 = nlIORead64((const void **)&p);
1401     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1402     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s64));
1403
1404     p = &buffer[1];
1405     memcpy(&buffer[1], &s64, sizeof(s64));
1406
1407     v64 = nlIORead64((const void **)&p);
1408     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1409     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s64));
1410
1411     p = &buffer[2];
1412     memcpy(&buffer[2], &s64, sizeof(s64));
1413
1414     v64 = nlIORead64((const void **)&p);
1415     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1416     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s64));
1417
1418     p = &buffer[3];
1419     memcpy(&buffer[3], &s64, sizeof(s64));
1420
1421     v64 = nlIORead64((const void **)&p);
1422     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1423     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s64));
1424
1425     p = &buffer[4];
1426     memcpy(&buffer[4], &s64, sizeof(s64));
1427
1428     v64 = nlIORead64((const void **)&p);
1429     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1430     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[4] + sizeof(s64));
1431
1432     p = &buffer[5];
1433     memcpy(&buffer[5], &s64, sizeof(s64));
1434
1435     v64 = nlIORead64((const void **)&p);
1436     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1437     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[5] + sizeof(s64));
1438
1439     p = &buffer[6];
1440     memcpy(&buffer[6], &s64, sizeof(s64));
1441
1442     v64 = nlIORead64((const void **)&p);
1443     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1444     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[6] + sizeof(s64));
1445
1446     p = &buffer[7];
1447     memcpy(&buffer[7], &s64, sizeof(s64));
1448
1449     v64 = nlIORead64((const void **)&p);
1450     NL_TEST_ASSERT(inSuite, v64 == MAGIC_64);
1451     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[7] + sizeof(s64));
1452 }
1453
1454 static void CheckWrite(nlTestSuite *inSuite, void *inContext)
1455 {
1456     const uint8_t v8 = MAGIC_8;
1457     const uint16_t v16 = MAGIC_16;
1458     const uint32_t v32 = MAGIC_32;
1459     const uint64_t v64 = MAGIC_64;
1460     uint8_t buffer[sizeof(uint64_t) * 2];
1461     uint8_t s8;
1462     uint16_t s16;
1463     uint32_t s32;
1464     uint64_t s64;
1465     void *p;
1466
1467     // Try an 8-bit quantity. They are aligned anywhere and unaligned
1468     // nowhere.
1469
1470     p = &buffer[0];
1471     nlIOWrite8(&p, v8);
1472     memcpy(&s8, &buffer[0], sizeof(v8));
1473     NL_TEST_ASSERT(inSuite, s8 == MAGIC_8);
1474     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s8));
1475
1476     // Try 16-bit quantities.
1477
1478     p = &buffer[0];
1479     nlIOWrite16(&p, v16);
1480     memcpy(&s16, &buffer[0], sizeof(v16));
1481     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
1482     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s16));
1483
1484     p = &buffer[1];
1485     nlIOWrite16(&p, v16);
1486     memcpy(&s16, &buffer[1], sizeof(v16));
1487     NL_TEST_ASSERT(inSuite, s16 == MAGIC_16);
1488     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s16));
1489
1490     // Try 32-bit quantities.
1491
1492     p = &buffer[0];
1493     nlIOWrite32(&p, v32);
1494     memcpy(&s32, &buffer[0], sizeof(v32));
1495     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1496     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s32));
1497
1498     p = &buffer[1];
1499     nlIOWrite32(&p, v32);
1500     memcpy(&s32, &buffer[1], sizeof(v32));
1501     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1502     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s32));
1503
1504     p = &buffer[2];
1505     nlIOWrite32(&p, v32);
1506     memcpy(&s32, &buffer[2], sizeof(v32));
1507     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1508     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s32));
1509
1510     p = &buffer[3];
1511     nlIOWrite32(&p, v32);
1512     memcpy(&s32, &buffer[3], sizeof(v32));
1513     NL_TEST_ASSERT(inSuite, s32 == MAGIC_32);
1514     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s32));
1515
1516     // Try 64-bit quantities.
1517
1518     p = &buffer[0];
1519     nlIOWrite64(&p, v64);
1520     memcpy(&s64, &buffer[0], sizeof(v64));
1521     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1522     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[0] + sizeof(s64));
1523
1524     p = &buffer[1];
1525     nlIOWrite64(&p, v64);
1526     memcpy(&s64, &buffer[1], sizeof(v64));
1527     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1528     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[1] + sizeof(s64));
1529
1530     p = &buffer[2];
1531     nlIOWrite64(&p, v64);
1532     memcpy(&s64, &buffer[2], sizeof(v64));
1533     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1534     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[2] + sizeof(s64));
1535
1536     p = &buffer[3];
1537     nlIOWrite64(&p, v64);
1538     memcpy(&s64, &buffer[3], sizeof(v64));
1539     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1540     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[3] + sizeof(s64));
1541
1542     p = &buffer[4];
1543     nlIOWrite64(&p, v64);
1544     memcpy(&s64, &buffer[4], sizeof(v64));
1545     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1546     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[4] + sizeof(s64));
1547
1548     p = &buffer[5];
1549     nlIOWrite64(&p, v64);
1550     memcpy(&s64, &buffer[5], sizeof(v64));
1551     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1552     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[5] + sizeof(s64));
1553
1554     p = &buffer[6];
1555     nlIOWrite64(&p, v64);
1556     memcpy(&s64, &buffer[6], sizeof(v64));
1557     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1558     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[6] + sizeof(s64));
1559
1560     p = &buffer[7];
1561     nlIOWrite64(&p, v64);
1562     memcpy(&s64, &buffer[7], sizeof(v64));
1563     NL_TEST_ASSERT(inSuite, s64 == MAGIC_64);
1564     NL_TEST_ASSERT(inSuite, p == (uint8_t *)&buffer[7] + sizeof(s64));
1565 }
1566
1567 static const nlTest sTests[] = {
1568     NL_TEST_DEF("introspection",       CheckIntrospection),
1569     NL_TEST_DEF("aligned get",         CheckAlignedGet),
1570     NL_TEST_DEF("aligned put",         CheckAlignedPut),
1571     NL_TEST_DEF("unaligned get",       CheckUnalignedGet),
1572     NL_TEST_DEF("unaligned put",       CheckUnalignedPut),
1573     NL_TEST_DEF("maybe aligned get",   CheckMaybeAlignedGet),
1574     NL_TEST_DEF("maybe aligned put",   CheckMaybeAlignedPut),
1575     NL_TEST_DEF("get",                 CheckGet),
1576     NL_TEST_DEF("put",                 CheckPut),
1577     NL_TEST_DEF("aligned read",        CheckAlignedRead),
1578     NL_TEST_DEF("aligned write",       CheckAlignedWrite),
1579     NL_TEST_DEF("unaligned read",      CheckUnalignedRead),
1580     NL_TEST_DEF("unaligned write",     CheckUnalignedWrite),
1581     NL_TEST_DEF("maybe aligned read",  CheckMaybeAlignedRead),
1582     NL_TEST_DEF("maybe aligned write", CheckMaybeAlignedWrite),
1583     NL_TEST_DEF("read",                CheckRead),
1584     NL_TEST_DEF("write",               CheckWrite),
1585     NL_TEST_SENTINEL()
1586 };
1587
1588 int main(void)
1589 {
1590     nlTestSuite theSuite = {
1591         "nlio",
1592         &sTests[0]
1593     };
1594
1595     nl_test_set_output_style(OUTPUT_CSV);
1596
1597     nlTestRunner(&theSuite, NULL);
1598
1599     return nlTestRunnerStats(&theSuite);
1600 }