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

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