/*
 *
 *    Copyright (c) 2015-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 *    @file
 *      This file implements a unit test suite for the Weave
 *      memory-mapped I/O and byte reordering interfaces.
 *
 */

#include <stdlib.h>
#include <unistd.h>

#include <nlbyteorder.h>
#include <nlunit-test.h>

#include <Weave/Core/WeaveEncoding.h>

#define MAGIC8          0x01U
#define MAGIC16         0x0123U
#define MAGIC32         0x01234567UL
#define MAGIC64         0x0123456789ABCDEFULL

#define MAGIC_SWAP8     0x01U
#define MAGIC_SWAP16    0x2301U
#define MAGIC_SWAP32    0x67452301UL
#define MAGIC_SWAP64    0xEFCDAB8967452301ULL

using namespace nl::Weave::Encoding;

static void CheckSwap(nlTestSuite *inSuite, void *inContext)
{
    // Check that the constant swap inline free functions work.

    NL_TEST_ASSERT(inSuite, Swap16(MAGIC16) == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, Swap32(MAGIC32) == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, Swap64(MAGIC64) == MAGIC_SWAP64);
}

static void CheckSwapBig(nlTestSuite *inSuite, void *inContext)
{
    uint16_t v16_in = MAGIC16;
    uint32_t v32_in = MAGIC32;
    uint64_t v64_in = MAGIC64;
    uint16_t v16_out;
    uint32_t v32_out;
    uint64_t v64_out;

    // Check swap by value of big endian values against the host
    // system ordering.

    v16_out = BigEndian::HostSwap16(v16_in);
    v32_out = BigEndian::HostSwap32(v32_in);
    v64_out = BigEndian::HostSwap64(v64_in);

#if NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v16_out == v16_in);
    NL_TEST_ASSERT(inSuite, v32_out == v32_in);
    NL_TEST_ASSERT(inSuite, v64_out == v64_in);

#elif NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#endif
}

static void CheckSwapLittle(nlTestSuite *inSuite, void *inContext)
{
    uint16_t v16_in = MAGIC16;
    uint32_t v32_in = MAGIC32;
    uint64_t v64_in = MAGIC64;
    uint16_t v16_out;
    uint32_t v32_out;
    uint64_t v64_out;

    // Check swap by value of little endian values against the host
    // system ordering.

    v16_out = LittleEndian::HostSwap16(v16_in);
    v32_out = LittleEndian::HostSwap32(v32_in);
    v64_out = LittleEndian::HostSwap64(v64_in);

#if NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#elif NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v16_out == v16_in);
    NL_TEST_ASSERT(inSuite, v32_out == v32_in);
    NL_TEST_ASSERT(inSuite, v64_out == v64_in);

#endif
}

static void CheckGetBig(nlTestSuite *inSuite, void *inContext)
{
    const uint8_t  v8_in  = MAGIC8;
    const uint16_t v16_in = MAGIC16;
    const uint32_t v32_in = MAGIC32;
    const uint64_t v64_in = MAGIC64;
    uint8_t        v8_out;
    uint16_t       v16_out;
    uint32_t       v32_out;
    uint64_t       v64_out;

    v8_out  = Get8(&v8_in);
    v16_out = BigEndian::Get16(reinterpret_cast<const uint8_t *>(&v16_in));
    v32_out = BigEndian::Get32(reinterpret_cast<const uint8_t *>(&v32_in));
    v64_out = BigEndian::Get64(reinterpret_cast<const uint8_t *>(&v64_in));

#if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);

#else
    NL_TEST_ASSERT(inSuite, false);

#endif
}

static void CheckGetLittle(nlTestSuite *inSuite, void *inContext)
{
    const uint8_t  v8_in  = MAGIC8;
    const uint16_t v16_in = MAGIC16;
    const uint32_t v32_in = MAGIC32;
    const uint64_t v64_in = MAGIC64;
    uint8_t        v8_out;
    uint16_t       v16_out;
    uint32_t       v32_out;
    uint64_t       v64_out;

    v8_out  = Get8(&v8_in);
    v16_out = LittleEndian::Get16(reinterpret_cast<const uint8_t *>(&v16_in));
    v32_out = LittleEndian::Get32(reinterpret_cast<const uint8_t *>(&v32_in));
    v64_out = LittleEndian::Get64(reinterpret_cast<const uint8_t *>(&v64_in));

#if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);

#elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#else
    NL_TEST_ASSERT(inSuite, false);

#endif
}

static void CheckPutBig(nlTestSuite *inSuite, void *inContext)
{
    const uint8_t  v8_in  = MAGIC8;
    const uint16_t v16_in = MAGIC16;
    const uint32_t v32_in = MAGIC32;
    const uint64_t v64_in = MAGIC64;
    uint8_t        v8_out;
    uint16_t       v16_out;
    uint32_t       v32_out;
    uint64_t       v64_out;

    Put8(&v8_out,   v8_in);
    BigEndian::Put16(reinterpret_cast<uint8_t *>(&v16_out), v16_in);
    BigEndian::Put32(reinterpret_cast<uint8_t *>(&v32_out), v32_in);
    BigEndian::Put64(reinterpret_cast<uint8_t *>(&v64_out), v64_in);

#if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);

#else
    NL_TEST_ASSERT(inSuite, false);

#endif
}

static void CheckPutLittle(nlTestSuite *inSuite, void *inContext)
{
    const uint8_t  v8_in  = MAGIC8;
    const uint16_t v16_in = MAGIC16;
    const uint32_t v32_in = MAGIC32;
    const uint64_t v64_in = MAGIC64;
    uint8_t        v8_out;
    uint16_t       v16_out;
    uint32_t       v32_out;
    uint64_t       v64_out;

    Put8(&v8_out,   v8_in);
    LittleEndian::Put16(reinterpret_cast<uint8_t *>(&v16_out), v16_in);
    LittleEndian::Put32(reinterpret_cast<uint8_t *>(&v32_out), v32_in);
    LittleEndian::Put64(reinterpret_cast<uint8_t *>(&v64_out), v64_in);

#if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);

#elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#else
    NL_TEST_ASSERT(inSuite, false);

#endif
}

static void CheckReadBig(nlTestSuite *inSuite, void *inContext)
{
    uint8_t        v8_in   = MAGIC8;
    uint16_t       v16_in  = MAGIC16;
    uint32_t       v32_in  = MAGIC32;
    uint64_t       v64_in  = MAGIC64;
    uint8_t        *p8_in  = &v8_in;
    uint8_t        *p16_in = reinterpret_cast<uint8_t *>(&v16_in);
    uint8_t        *p32_in = reinterpret_cast<uint8_t *>(&v32_in);
    uint8_t        *p64_in = reinterpret_cast<uint8_t *>(&v64_in);
    uint8_t        v8_out;
    uint16_t       v16_out;
    uint32_t       v32_out;
    uint64_t       v64_out;

    v8_out  = Read8(p8_in);
    v16_out = BigEndian::Read16(p16_in);
    v32_out = BigEndian::Read32(p32_in);
    v64_out = BigEndian::Read64(p64_in);

    NL_TEST_ASSERT(inSuite, p8_in == (&v8_in + 1));
    NL_TEST_ASSERT(inSuite, p16_in == reinterpret_cast<uint8_t *>((&v16_in + 1)));
    NL_TEST_ASSERT(inSuite, p32_in == reinterpret_cast<uint8_t *>((&v32_in + 1)));
    NL_TEST_ASSERT(inSuite, p64_in == reinterpret_cast<uint8_t *>((&v64_in + 1)));

#if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);

#else
    NL_TEST_ASSERT(inSuite, false);

#endif
}

static void CheckReadLittle(nlTestSuite *inSuite, void *inContext)
{
    uint8_t        v8_in   = MAGIC8;
    uint16_t       v16_in  = MAGIC16;
    uint32_t       v32_in  = MAGIC32;
    uint64_t       v64_in  = MAGIC64;
    uint8_t        *p8_in  = &v8_in;
    uint8_t        *p16_in = reinterpret_cast<uint8_t *>(&v16_in);
    uint8_t        *p32_in = reinterpret_cast<uint8_t *>(&v32_in);
    uint8_t        *p64_in = reinterpret_cast<uint8_t *>(&v64_in);
    uint8_t        v8_out;
    uint16_t       v16_out;
    uint32_t       v32_out;
    uint64_t       v64_out;

    v8_out  = Read8(p8_in);
    v16_out = LittleEndian::Read16(p16_in);
    v32_out = LittleEndian::Read32(p32_in);
    v64_out = LittleEndian::Read64(p64_in);

    NL_TEST_ASSERT(inSuite, p8_in == (&v8_in + 1));
    NL_TEST_ASSERT(inSuite, p16_in == reinterpret_cast<uint8_t *>((&v16_in + 1)));
    NL_TEST_ASSERT(inSuite, p32_in == reinterpret_cast<uint8_t *>((&v32_in + 1)));
    NL_TEST_ASSERT(inSuite, p64_in == reinterpret_cast<uint8_t *>((&v64_in + 1)));

#if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);

#elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#else
    NL_TEST_ASSERT(inSuite, false);

#endif
}

static void CheckConstReadBig(nlTestSuite *inSuite, void *inContext)
{
    const uint8_t  v8_in   = MAGIC8;
    const uint16_t v16_in  = MAGIC16;
    const uint32_t v32_in  = MAGIC32;
    const uint64_t v64_in  = MAGIC64;
    const uint8_t  *p8_in  = &v8_in;
    const uint8_t  *p16_in = reinterpret_cast<const uint8_t *>(&v16_in);
    const uint8_t  *p32_in = reinterpret_cast<const uint8_t *>(&v32_in);
    const uint8_t  *p64_in = reinterpret_cast<const uint8_t *>(&v64_in);
    uint8_t        v8_out;
    uint16_t       v16_out;
    uint32_t       v32_out;
    uint64_t       v64_out;

    v8_out  = Read8(p8_in);
    v16_out = BigEndian::Read16(p16_in);
    v32_out = BigEndian::Read32(p32_in);
    v64_out = BigEndian::Read64(p64_in);

    NL_TEST_ASSERT(inSuite, p8_in == (&v8_in + 1));
    NL_TEST_ASSERT(inSuite, p16_in == reinterpret_cast<const uint8_t *>((&v16_in + 1)));
    NL_TEST_ASSERT(inSuite, p32_in == reinterpret_cast<const uint8_t *>((&v32_in + 1)));
    NL_TEST_ASSERT(inSuite, p64_in == reinterpret_cast<const uint8_t *>((&v64_in + 1)));

#if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);

#else
    NL_TEST_ASSERT(inSuite, false);

#endif
}

static void CheckConstReadLittle(nlTestSuite *inSuite, void *inContext)
{
    const uint8_t  v8_in   = MAGIC8;
    const uint16_t v16_in  = MAGIC16;
    const uint32_t v32_in  = MAGIC32;
    const uint64_t v64_in  = MAGIC64;
    const uint8_t  *p8_in  = &v8_in;
    const uint8_t  *p16_in = reinterpret_cast<const uint8_t *>(&v16_in);
    const uint8_t  *p32_in = reinterpret_cast<const uint8_t *>(&v32_in);
    const uint8_t  *p64_in = reinterpret_cast<const uint8_t *>(&v64_in);
    uint8_t        v8_out;
    uint16_t       v16_out;
    uint32_t       v32_out;
    uint64_t       v64_out;

    v8_out  = Read8(p8_in);
    v16_out = LittleEndian::Read16(p16_in);
    v32_out = LittleEndian::Read32(p32_in);
    v64_out = LittleEndian::Read64(p64_in);

    NL_TEST_ASSERT(inSuite, p8_in == (&v8_in + 1));
    NL_TEST_ASSERT(inSuite, p16_in == reinterpret_cast<const uint8_t *>((&v16_in + 1)));
    NL_TEST_ASSERT(inSuite, p32_in == reinterpret_cast<const uint8_t *>((&v32_in + 1)));
    NL_TEST_ASSERT(inSuite, p64_in == reinterpret_cast<const uint8_t *>((&v64_in + 1)));

#if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);

#elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#else
    NL_TEST_ASSERT(inSuite, false);

#endif
}

static void CheckWriteBig(nlTestSuite *inSuite, void *inContext)
{
    const uint8_t  v8_in   = MAGIC8;
    const uint16_t v16_in  = MAGIC16;
    const uint32_t v32_in  = MAGIC32;
    const uint64_t v64_in  = MAGIC64;
    uint8_t        v8_out;
    uint16_t       v16_out;
    uint32_t       v32_out;
    uint64_t       v64_out;
    uint8_t        *p8_out  = &v8_out;
    uint8_t        *p16_out = reinterpret_cast<uint8_t *>(&v16_out);
    uint8_t        *p32_out = reinterpret_cast<uint8_t *>(&v32_out);
    uint8_t        *p64_out = reinterpret_cast<uint8_t *>(&v64_out);

    Write8(p8_out, v8_in);
    BigEndian::Write16(p16_out, v16_in);
    BigEndian::Write32(p32_out, v32_in);
    BigEndian::Write64(p64_out, v64_in);

    NL_TEST_ASSERT(inSuite, p8_out == (&v8_out + 1));
    NL_TEST_ASSERT(inSuite, p16_out == reinterpret_cast<uint8_t *>((&v16_out + 1)));
    NL_TEST_ASSERT(inSuite, p32_out == reinterpret_cast<uint8_t *>((&v32_out + 1)));
    NL_TEST_ASSERT(inSuite, p64_out == reinterpret_cast<uint8_t *>((&v64_out + 1)));

#if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);

#else
    NL_TEST_ASSERT(inSuite, false);

#endif
}

static void CheckWriteLittle(nlTestSuite *inSuite, void *inContext)
{
    const uint8_t  v8_in   = MAGIC8;
    const uint16_t v16_in  = MAGIC16;
    const uint32_t v32_in  = MAGIC32;
    const uint64_t v64_in  = MAGIC64;
    uint8_t        v8_out;
    uint16_t       v16_out;
    uint32_t       v32_out;
    uint64_t       v64_out;
    uint8_t        *p8_out  = &v8_out;
    uint8_t        *p16_out = reinterpret_cast<uint8_t *>(&v16_out);
    uint8_t        *p32_out = reinterpret_cast<uint8_t *>(&v32_out);
    uint8_t        *p64_out = reinterpret_cast<uint8_t *>(&v64_out);

    Write8(p8_out, v8_in);
    LittleEndian::Write16(p16_out, v16_in);
    LittleEndian::Write32(p32_out, v32_in);
    LittleEndian::Write64(p64_out, v64_in);

    NL_TEST_ASSERT(inSuite, p8_out == (&v8_out + 1));
    NL_TEST_ASSERT(inSuite, p16_out == reinterpret_cast<uint8_t *>((&v16_out + 1)));
    NL_TEST_ASSERT(inSuite, p32_out == reinterpret_cast<uint8_t *>((&v32_out + 1)));
    NL_TEST_ASSERT(inSuite, p64_out == reinterpret_cast<uint8_t *>((&v64_out + 1)));

#if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC64);

#elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
    NL_TEST_ASSERT(inSuite, v8_out  == MAGIC_SWAP8);
    NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
    NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
    NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);

#else
    NL_TEST_ASSERT(inSuite, false);

#endif
}

static const nlTest sTests[] = {
    NL_TEST_DEF("swap",                CheckSwap),
    NL_TEST_DEF("swap big",            CheckSwapBig),
    NL_TEST_DEF("swap little",         CheckSwapLittle),
    NL_TEST_DEF("get big",             CheckGetBig),
    NL_TEST_DEF("get little",          CheckGetLittle),
    NL_TEST_DEF("put big",             CheckPutBig),
    NL_TEST_DEF("put little",          CheckPutLittle),
    NL_TEST_DEF("read big",            CheckReadBig),
    NL_TEST_DEF("read little",         CheckReadLittle),
    NL_TEST_DEF("const read big",      CheckConstReadBig),
    NL_TEST_DEF("const read little",   CheckConstReadLittle),
    NL_TEST_DEF("write big",           CheckWriteBig),
    NL_TEST_DEF("write little",        CheckWriteLittle),
    NL_TEST_SENTINEL()
};

int main(void)
{
    nlTestSuite theSuite = {
        "weave-encoding",
        &sTests[0]
    };

    nl_test_set_output_style(OUTPUT_CSV);

    nlTestRunner(&theSuite, NULL);

    return nlTestRunnerStats(&theSuite);
}