third_party/nlio/repo/tests/nlbyteorder-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 byte ordering functions and macros.
  21  *
  22  */
  23
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26
  27 #include <nlbyteorder.h>
  28
  29 #include <nlunit-test.h>
  30
  31 #include "nlbyteorder-test.h"
  32
  33 static void CheckPreprocessorDefinitions(nlTestSuite *inSuite, void *inContext)
  34 {
  35     NL_TEST_ASSERT(inSuite, NLBYTEORDER_LITTLE_ENDIAN  == 0x1234);
  36     NL_TEST_ASSERT(inSuite, NLBYTEORDER_BIG_ENDIAN     == 0x4321);
  37     NL_TEST_ASSERT(inSuite, NLBYTEORDER_UNKNOWN_ENDIAN == 0xFFFF);
  38     NL_TEST_ASSERT(inSuite, NLBYTEORDER != NLBYTEORDER_UNKNOWN_ENDIAN);
  39 }
  40
  41 static void CheckEnumerations(nlTestSuite *inSuite, void *inContext)
  42 {
  43     NL_TEST_ASSERT(inSuite, nlByteOrderUnknown      == NLBYTEORDER_UNKNOWN_ENDIAN);
  44     NL_TEST_ASSERT(inSuite, nlByteOrderLittleEndian == NLBYTEORDER_LITTLE_ENDIAN);
  45     NL_TEST_ASSERT(inSuite, nlByteOrderBigEndian    == NLBYTEORDER_BIG_ENDIAN);
  46 }
  47
  48 static void CheckByteOrder(nlTestSuite *inSuite, void *inContext)
  49 {
  50     // Check that we get a meaningful value for the current byte order.
  51
  52     NL_TEST_ASSERT(inSuite, nlByteOrderGetCurrent() != nlByteOrderUnknown);
  53 }
  54
  55 static void CheckConstantMacros(nlTestSuite *inSuite, void *inContext)
  56 {
  57     const uint16_t v16 = nlByteOrderConstantSwap16(MAGIC16);
  58     const uint32_t v32 = nlByteOrderConstantSwap32(MAGIC32);
  59     const uint64_t v64 = nlByteOrderConstantSwap64(MAGIC64);
  60
  61     // Check that the constant swap macros work.
  62
  63     NL_TEST_ASSERT(inSuite, v16 == MAGIC_SWAP16);
  64     NL_TEST_ASSERT(inSuite, v32 == MAGIC_SWAP32);
  65     NL_TEST_ASSERT(inSuite, v64 == MAGIC_SWAP64);
  66 }
  67
  68 static void CheckValueInlines(nlTestSuite *inSuite, void *inContext)
  69 {
  70     // Check that the constant swap inline free functions work.
  71
  72     NL_TEST_ASSERT(inSuite, nlByteOrderValueSwap16(MAGIC16) == MAGIC_SWAP16);
  73     NL_TEST_ASSERT(inSuite, nlByteOrderValueSwap32(MAGIC32) == MAGIC_SWAP32);
  74     NL_TEST_ASSERT(inSuite, nlByteOrderValueSwap64(MAGIC64) == MAGIC_SWAP64);
  75 }
  76
  77 static void CheckInPlaceInlines(nlTestSuite *inSuite, void *inContext)
  78 {
  79     uint16_t v16 = MAGIC16;
  80     uint32_t v32 = MAGIC32;
  81     uint64_t v64 = MAGIC64;
  82
  83     nlByteOrderPointerSwap16(&v16);
  84     NL_TEST_ASSERT(inSuite, v16 == MAGIC_SWAP16);
  85
  86     nlByteOrderPointerSwap32(&v32);
  87     NL_TEST_ASSERT(inSuite, v32 == MAGIC_SWAP32);
  88
  89     nlByteOrderPointerSwap64(&v64);
  90     NL_TEST_ASSERT(inSuite, v64 == MAGIC_SWAP64);
  91 }
  92
  93 static void CheckSwapByValue(nlTestSuite *inSuite, void *inContext)
  94 {
  95     uint16_t v16_in = MAGIC16;
  96     uint32_t v32_in = MAGIC32;
  97     uint64_t v64_in = MAGIC64;
  98     uint16_t v16_out;
  99     uint32_t v32_out;
 100     uint64_t v64_out;
 101
 102     // Check little-to-host and host-to-little swap by value.
 103
 104     v16_out = nlByteOrderSwap16LittleToHost(v16_in);
 105     v32_out = nlByteOrderSwap32LittleToHost(v32_in);
 106     v64_out = nlByteOrderSwap64LittleToHost(v64_in);
 107
 108 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 109     NL_TEST_ASSERT(inSuite, v16_out == v16_in);
 110     NL_TEST_ASSERT(inSuite, v32_out == v32_in);
 111     NL_TEST_ASSERT(inSuite, v64_out == v64_in);
 112
 113 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 114     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 115     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 116     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 117
 118 #endif
 119
 120     v16_in = nlByteOrderSwap16HostToLittle(v16_out);
 121     v32_in = nlByteOrderSwap32HostToLittle(v32_out);
 122     v64_in = nlByteOrderSwap64HostToLittle(v64_out);
 123
 124 #if NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 125     NL_TEST_ASSERT(inSuite, v16_out == v16_in);
 126     NL_TEST_ASSERT(inSuite, v32_out == v32_in);
 127     NL_TEST_ASSERT(inSuite, v64_out == v64_in);
 128
 129 #elif NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 130     NL_TEST_ASSERT(inSuite, v16_in == MAGIC16);
 131     NL_TEST_ASSERT(inSuite, v32_in == MAGIC32);
 132     NL_TEST_ASSERT(inSuite, v64_in == MAGIC64);
 133
 134 #endif
 135
 136     // Check big-to-host and host-to-big swap by value.
 137
 138     v16_out = nlByteOrderSwap16BigToHost(v16_in);
 139     v32_out = nlByteOrderSwap32BigToHost(v32_in);
 140     v64_out = nlByteOrderSwap64BigToHost(v64_in);
 141
 142 #if NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 143     NL_TEST_ASSERT(inSuite, v16_out == v16_in);
 144     NL_TEST_ASSERT(inSuite, v32_out == v32_in);
 145     NL_TEST_ASSERT(inSuite, v64_out == v64_in);
 146
 147 #elif NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 148     NL_TEST_ASSERT(inSuite, v16_out == MAGIC_SWAP16);
 149     NL_TEST_ASSERT(inSuite, v32_out == MAGIC_SWAP32);
 150     NL_TEST_ASSERT(inSuite, v64_out == MAGIC_SWAP64);
 151
 152 #endif
 153
 154     v16_in = nlByteOrderSwap16HostToBig(v16_out);
 155     v32_in = nlByteOrderSwap32HostToBig(v32_out);
 156     v64_in = nlByteOrderSwap64HostToBig(v64_out);
 157
 158 #if NLBYTEORDER == NLBYTEORDER_BIG_ENDIAN
 159     NL_TEST_ASSERT(inSuite, v16_out == v16_in);
 160     NL_TEST_ASSERT(inSuite, v32_out == v32_in);
 161     NL_TEST_ASSERT(inSuite, v64_out == v64_in);
 162
 163 #elif NLBYTEORDER == NLBYTEORDER_LITTLE_ENDIAN
 164     NL_TEST_ASSERT(inSuite, v16_in == MAGIC16);
 165     NL_TEST_ASSERT(inSuite, v32_in == MAGIC32);
 166     NL_TEST_ASSERT(inSuite, v64_in == MAGIC64);
 167
 168 #endif
 169 }
 170
 171 static const nlTest sTests[] = {
 172     NL_TEST_DEF("preprocessor definitions", CheckPreprocessorDefinitions),
 173     NL_TEST_DEF("enumerations",             CheckEnumerations),
 174     NL_TEST_DEF("byte order",               CheckByteOrder),
 175     NL_TEST_DEF("constant macros",          CheckConstantMacros),
 176     NL_TEST_DEF("value inlines",            CheckValueInlines),
 177     NL_TEST_DEF("in-place inlines",         CheckInPlaceInlines),
 178     NL_TEST_DEF("swap-by-value",            CheckSwapByValue),
 179     NL_TEST_SENTINEL()
 180 };
 181
 182 int main(void)
 183 {
 184     nlTestSuite theSuite = {
 185         "nlbyteorder",
 186         &sTests[0]
 187     };
 188
 189     nl_test_set_output_style(OUTPUT_CSV);
 190
 191     nlTestRunner(&theSuite, NULL);
 192
 193     return nlTestRunnerStats(&theSuite);
 194 }