weave/src/test-apps/TestCodeUtils.cpp - nest-cam/4320010/weave - Git at Google

 /*
  *
  *    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
  *      code utilities templates and macros.
  *
  */

 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS
 #endif

 #include <stdint.h>

 #include <nltest.h>

 static void TestWeaveDie(void);

 #define WeaveDie() TestWeaveDie()

 #include <Weave/Support/CodeUtils.h>

 struct TestVerifyOrDieContext
 {
     bool mShouldDie;
     bool mDidDie;
 };

 static struct TestVerifyOrDieContext sContext;

 static void CheckMin(nlTestSuite *inSuite, void *inContext)
 {
     int8_t   s8result;
     int16_t  s16result;
     int32_t  s32result;
     int64_t  s64result;
     uint8_t  u8result;
     uint16_t u16result;
     uint32_t u32result;
     uint64_t u64result;

     // Test 8-bit signed integers

     s8result = nl::Weave::min(INT8_MIN, INT8_MAX);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

     s8result = nl::Weave::min(INT8_MAX, INT8_MIN);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

     s8result = nl::Weave::min(INT8_MIN, 0);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

     s8result = nl::Weave::min(0, INT8_MIN);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

     s8result = nl::Weave::min(0, INT8_MAX);
     NL_TEST_ASSERT(inSuite, s8result == 0);

     s8result = nl::Weave::min(INT8_MAX, 0);
     NL_TEST_ASSERT(inSuite, s8result == 0);

     s8result = nl::Weave::min(0, 0);
     NL_TEST_ASSERT(inSuite, s8result == 0);

     s8result = nl::Weave::min(INT8_MIN, INT8_MIN);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

     s8result = nl::Weave::min(INT8_MAX, INT8_MAX);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

     // Test 16-bit signed integers

     s16result = nl::Weave::min(INT16_MIN, INT16_MAX);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

     s16result = nl::Weave::min(INT16_MAX, INT16_MIN);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

     s16result = nl::Weave::min(INT16_MIN, 0);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

     s16result = nl::Weave::min(0, INT16_MIN);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

     s16result = nl::Weave::min(0, INT16_MAX);
     NL_TEST_ASSERT(inSuite, s16result == 0);

     s16result = nl::Weave::min(INT16_MAX, 0);
     NL_TEST_ASSERT(inSuite, s16result == 0);

     s16result = nl::Weave::min(0, 0);
     NL_TEST_ASSERT(inSuite, s16result == 0);

     s16result = nl::Weave::min(INT16_MIN, INT16_MIN);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

     s16result = nl::Weave::min(INT16_MAX, INT16_MAX);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

     // Test 32-bit signed integers

     s32result = nl::Weave::min(INT32_MIN, INT32_MAX);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

     s32result = nl::Weave::min(INT32_MAX, INT32_MIN);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

     s32result = nl::Weave::min(INT32_MIN, 0);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

     s32result = nl::Weave::min(0, INT32_MIN);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

     s32result = nl::Weave::min(0, INT32_MAX);
     NL_TEST_ASSERT(inSuite, s32result == 0);

     s32result = nl::Weave::min(INT32_MAX, 0);
     NL_TEST_ASSERT(inSuite, s32result == 0);

     s32result = nl::Weave::min(0, 0);
     NL_TEST_ASSERT(inSuite, s32result == 0);

     s32result = nl::Weave::min(INT32_MIN, INT32_MIN);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

     s32result = nl::Weave::min(INT32_MAX, INT32_MAX);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

     // Test 64-bit signed integers

     s64result = nl::Weave::min(INT64_MIN, INT64_MAX);
     NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

     s64result = nl::Weave::min(INT64_MAX, INT64_MIN);
     NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

     s64result = nl::Weave::min(INT64_MIN, static_cast<int64_t>(0));
     NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

     s64result = nl::Weave::min(static_cast<int64_t>(0), INT64_MIN);
     NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

     s64result = nl::Weave::min(static_cast<int64_t>(0), INT64_MAX);
     NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

     s64result = nl::Weave::min(INT64_MAX, static_cast<int64_t>(0));
     NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

     s64result = nl::Weave::min(static_cast<int64_t>(0), static_cast<int64_t>(0));
     NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

     s64result = nl::Weave::min(INT64_MIN, INT64_MIN);
     NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

     s64result = nl::Weave::min(INT64_MAX, INT64_MAX);
     NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

     // Test 8-bit unsigned integers

     u8result = nl::Weave::min(UINT8_MAX, UINT8_MAX);
     NL_TEST_ASSERT(inSuite, u8result == UINT8_MAX);

     u8result = nl::Weave::min(0, UINT8_MAX);
     NL_TEST_ASSERT(inSuite, u8result == 0);

     u8result = nl::Weave::min(UINT8_MAX, 0);
     NL_TEST_ASSERT(inSuite, u8result == 0);

     u8result = nl::Weave::min(0, 0);
     NL_TEST_ASSERT(inSuite, u8result == 0);

     // Test 16-bit unsigned integers

     u16result = nl::Weave::min(UINT16_MAX, UINT16_MAX);
     NL_TEST_ASSERT(inSuite, u16result == UINT16_MAX);

     u16result = nl::Weave::min(0, UINT16_MAX);
     NL_TEST_ASSERT(inSuite, u16result == 0);

     u16result = nl::Weave::min(UINT16_MAX, 0);
     NL_TEST_ASSERT(inSuite, u16result == 0);

     u16result = nl::Weave::min(0, 0);
     NL_TEST_ASSERT(inSuite, u16result == 0);

     // Test 32-bit unsigned integers

     u32result = nl::Weave::min(UINT32_MAX, UINT32_MAX);
     NL_TEST_ASSERT(inSuite, u32result == UINT32_MAX);

     u32result = nl::Weave::min(static_cast<uint32_t>(0), UINT32_MAX);
     NL_TEST_ASSERT(inSuite, u32result == static_cast<uint32_t>(0));

     u32result = nl::Weave::min(UINT32_MAX, static_cast<uint32_t>(0));
     NL_TEST_ASSERT(inSuite, u32result == static_cast<uint32_t>(0));

     u32result = nl::Weave::min(static_cast<uint32_t>(0), static_cast<uint32_t>(0));
     NL_TEST_ASSERT(inSuite, u32result == static_cast<uint32_t>(0));

     // Test 64-bit unsigned integers

     u64result = nl::Weave::min(UINT64_MAX, UINT64_MAX);
     NL_TEST_ASSERT(inSuite, u64result == UINT64_MAX);

     u64result = nl::Weave::min(static_cast<uint64_t>(0), UINT64_MAX);
     NL_TEST_ASSERT(inSuite, u64result == static_cast<uint64_t>(0));

     u64result = nl::Weave::min(UINT64_MAX, static_cast<uint64_t>(0));
     NL_TEST_ASSERT(inSuite, u64result == static_cast<uint64_t>(0));

     u64result = nl::Weave::min(static_cast<uint64_t>(0), static_cast<uint64_t>(0));
     NL_TEST_ASSERT(inSuite, u64result == static_cast<uint64_t>(0));
 }

 static void CheckMax(nlTestSuite *inSuite, void *inContext)
 {
     int8_t   s8result;
     int16_t  s16result;
     int32_t  s32result;
     int64_t  s64result;
     uint8_t  u8result;
     uint16_t u16result;
     uint32_t u32result;
     uint64_t u64result;

     // Test 8-bit signed integers

     s8result = nl::Weave::max(INT8_MIN, INT8_MAX);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

     s8result = nl::Weave::max(INT8_MAX, INT8_MIN);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

     s8result = nl::Weave::max(INT8_MIN, 0);
     NL_TEST_ASSERT(inSuite, s8result == 0);

     s8result = nl::Weave::max(0, INT8_MIN);
     NL_TEST_ASSERT(inSuite, s8result == 0);

     s8result = nl::Weave::max(0, INT8_MAX);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

     s8result = nl::Weave::max(INT8_MAX, 0);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

     s8result = nl::Weave::max(0, 0);
     NL_TEST_ASSERT(inSuite, s8result == 0);

     s8result = nl::Weave::max(INT8_MIN, INT8_MIN);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

     s8result = nl::Weave::max(INT8_MAX, INT8_MAX);
     NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

     // Test 16-bit signed integers

     s16result = nl::Weave::max(INT16_MIN, INT16_MAX);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

     s16result = nl::Weave::max(INT16_MAX, INT16_MIN);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

     s16result = nl::Weave::max(INT16_MIN, 0);
     NL_TEST_ASSERT(inSuite, s16result == 0);

     s16result = nl::Weave::max(0, INT16_MIN);
     NL_TEST_ASSERT(inSuite, s16result == 0);

     s16result = nl::Weave::max(0, INT16_MAX);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

     s16result = nl::Weave::max(INT16_MAX, 0);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

     s16result = nl::Weave::max(0, 0);
     NL_TEST_ASSERT(inSuite, s16result == 0);

     s16result = nl::Weave::max(INT16_MIN, INT16_MIN);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

     s16result = nl::Weave::max(INT16_MAX, INT16_MAX);
     NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

     // Test 32-bit signed integers

     s32result = nl::Weave::max(INT32_MIN, INT32_MAX);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

     s32result = nl::Weave::max(INT32_MAX, INT32_MIN);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

     s32result = nl::Weave::max(INT32_MIN, 0);
     NL_TEST_ASSERT(inSuite, s32result == 0);

     s32result = nl::Weave::max(0, INT32_MIN);
     NL_TEST_ASSERT(inSuite, s32result == 0);

     s32result = nl::Weave::max(0, INT32_MAX);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

     s32result = nl::Weave::max(INT32_MAX, 0);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

     s32result = nl::Weave::max(0, 0);
     NL_TEST_ASSERT(inSuite, s32result == 0);

     s32result = nl::Weave::max(INT32_MIN, INT32_MIN);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

     s32result = nl::Weave::max(INT32_MAX, INT32_MAX);
     NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

     // Test 64-bit signed integers

     s64result = nl::Weave::max(INT64_MIN, INT64_MAX);
     NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

     s64result = nl::Weave::max(INT64_MAX, INT64_MIN);
     NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

     s64result = nl::Weave::max(INT64_MIN, static_cast<int64_t>(0));
     NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

     s64result = nl::Weave::max(static_cast<int64_t>(0), INT64_MIN);
     NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

     s64result = nl::Weave::max(static_cast<int64_t>(0), INT64_MAX);
     NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

     s64result = nl::Weave::max(INT64_MAX, static_cast<int64_t>(0));
     NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

     s64result = nl::Weave::max(static_cast<int64_t>(0), static_cast<int64_t>(0));
     NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

     s64result = nl::Weave::max(INT64_MIN, INT64_MIN);
     NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

     s64result = nl::Weave::max(INT64_MAX, INT64_MAX);
     NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

     // Test 8-bit unsigned integers

     u8result = nl::Weave::max(UINT8_MAX, UINT8_MAX);
     NL_TEST_ASSERT(inSuite, u8result == UINT8_MAX);

     u8result = nl::Weave::max(0, UINT8_MAX);
     NL_TEST_ASSERT(inSuite, u8result == UINT8_MAX);

     u8result = nl::Weave::max(UINT8_MAX, 0);
     NL_TEST_ASSERT(inSuite, u8result == UINT8_MAX);

     u8result = nl::Weave::max(0, 0);
     NL_TEST_ASSERT(inSuite, u8result == 0);

     // Test 16-bit unsigned integers

     u16result = nl::Weave::max(UINT16_MAX, UINT16_MAX);
     NL_TEST_ASSERT(inSuite, u16result == UINT16_MAX);

     u16result = nl::Weave::max(0, UINT16_MAX);
     NL_TEST_ASSERT(inSuite, u16result == UINT16_MAX);

     u16result = nl::Weave::max(UINT16_MAX, 0);
     NL_TEST_ASSERT(inSuite, u16result == UINT16_MAX);

     u16result = nl::Weave::max(0, 0);
     NL_TEST_ASSERT(inSuite, u16result == 0);

     // Test 32-bit unsigned integers

     u32result = nl::Weave::max(UINT32_MAX, UINT32_MAX);
     NL_TEST_ASSERT(inSuite, u32result == UINT32_MAX);

     u32result = nl::Weave::max(static_cast<uint32_t>(0), UINT32_MAX);
     NL_TEST_ASSERT(inSuite, u32result == UINT32_MAX);

     u32result = nl::Weave::max(UINT32_MAX, static_cast<uint32_t>(0));
     NL_TEST_ASSERT(inSuite, u32result == UINT32_MAX);

     u32result = nl::Weave::max(static_cast<uint32_t>(0), static_cast<uint32_t>(0));
     NL_TEST_ASSERT(inSuite, u32result == static_cast<uint32_t>(0));

     // Test 64-bit unsigned integers

     u64result = nl::Weave::max(UINT64_MAX, UINT64_MAX);
     NL_TEST_ASSERT(inSuite, u64result == UINT64_MAX);

     u64result = nl::Weave::max(static_cast<uint64_t>(0), UINT64_MAX);
     NL_TEST_ASSERT(inSuite, u64result == UINT64_MAX);

     u64result = nl::Weave::max(UINT64_MAX, static_cast<uint64_t>(0));
     NL_TEST_ASSERT(inSuite, u64result == UINT64_MAX);

     u64result = nl::Weave::max(static_cast<uint64_t>(0), static_cast<uint64_t>(0));
     NL_TEST_ASSERT(inSuite, u64result == static_cast<uint64_t>(0));
 }

 static WEAVE_ERROR GetStatus(bool inFailure)
 {
     return ((inFailure) ? -1 : WEAVE_NO_ERROR);
 }

 static void CheckSuccessOrExitFailure(nlTestSuite *inSuite, void *inContext)
 {
     const bool failure = true;
     int        status;
     bool       sentinel;

     status = GetStatus(failure);
     sentinel = false;

     SuccessOrExit(status);
     sentinel = true;

  exit:
     NL_TEST_ASSERT(inSuite, sentinel == false);
 }

 static void CheckSuccessOrExitSuccess(nlTestSuite *inSuite, void *inContext)
 {
     const bool failure = true;
     int        status;
     bool       sentinel;

     status = GetStatus(!failure);
     sentinel = false;

     SuccessOrExit(status);
     sentinel = true;

  exit:
     NL_TEST_ASSERT(inSuite, sentinel == true);
 }

 static void CheckSuccessOrExitAssignmentFailure(nlTestSuite *inSuite, void *inContext)
 {
     const bool failure = true;
     int        status;
     bool       sentinel;

     sentinel = false;

     SuccessOrExit(status = GetStatus(failure));
     sentinel = true;

  exit:
     NL_TEST_ASSERT(inSuite, sentinel == false);
 }

 static void CheckSuccessOrExitAssignmentSuccess(nlTestSuite *inSuite, void *inContext)
 {
     const bool failure = true;
     int        status;
     bool       sentinel;

     sentinel = false;

     SuccessOrExit(status = GetStatus(!failure));
     sentinel = true;

  exit:
     NL_TEST_ASSERT(inSuite, sentinel == true);
 }

 static void CheckSuccessOrExit(nlTestSuite *inSuite, void *inContext)
 {
     CheckSuccessOrExitFailure(inSuite, inContext);
     CheckSuccessOrExitSuccess(inSuite, inContext);
     CheckSuccessOrExitAssignmentFailure(inSuite, inContext);
     CheckSuccessOrExitAssignmentSuccess(inSuite, inContext);
 }

 static void CheckVerifyOrExitFailure(nlTestSuite *inSuite, void *inContext)
 {
     bool status;
     bool sentinel;
     bool action;

     status = false;
     sentinel = false;
     action = false;

     VerifyOrExit(status, action = true);
     sentinel = true;

  exit:
     NL_TEST_ASSERT(inSuite, sentinel == false);
     NL_TEST_ASSERT(inSuite, action == true);
 }

 static void CheckVerifyOrExitSuccess(nlTestSuite *inSuite, void *inContext)
 {
     bool status;
     bool sentinel;
     bool action;

     status = true;
     sentinel = false;
     action = false;

     VerifyOrExit(status, action = true);
     sentinel = true;

  exit:
     NL_TEST_ASSERT(inSuite, sentinel == true);
     NL_TEST_ASSERT(inSuite, action == false);
 }

 static void CheckVerifyOrExit(nlTestSuite *inSuite, void *inContext)
 {
     CheckVerifyOrExitFailure(inSuite, inContext);
     CheckVerifyOrExitSuccess(inSuite, inContext);
 }

 static void CheckExitNow(nlTestSuite *inSuite, void *inContext)
 {
     bool action;
     bool sentinel;

     sentinel = false;
     action = false;

     ExitNow(action = true);
     sentinel = true;

  exit:
     NL_TEST_ASSERT(inSuite, sentinel == false);
     NL_TEST_ASSERT(inSuite, action == true);
 }

 static void TestWeaveDie(void)
 {
     sContext.mDidDie = true;
 }

 static void CheckVerifyOrDieFailure(nlTestSuite *inSuite, void *inContext)
 {
     struct TestVerifyOrDieContext *theContext = static_cast<struct TestVerifyOrDieContext *>(inContext);
     bool status;

     status = false;

     theContext->mShouldDie = true;
     theContext->mDidDie = false;

     VerifyOrDie(status);

     NL_TEST_ASSERT(inSuite, theContext->mShouldDie == theContext->mDidDie);
 }

 static void CheckVerifyOrDieSuccess(nlTestSuite *inSuite, void *inContext)
 {
     struct TestVerifyOrDieContext *theContext = static_cast<struct TestVerifyOrDieContext *>(inContext);
     bool status;

     status = true;

     theContext->mShouldDie = false;
     theContext->mDidDie = false;

     VerifyOrDie(status);

     NL_TEST_ASSERT(inSuite, theContext->mShouldDie == theContext->mDidDie);
 }

 static void CheckVerifyOrDie(nlTestSuite *inSuite, void *inContext)
 {
     CheckVerifyOrDieFailure(inSuite, inContext);
     CheckVerifyOrDieSuccess(inSuite, inContext);
 }

 static void CheckLogFileLineFunc(nlTestSuite *inSuite, void *inContext)
 {

 }

 static const nlTest sTests[] = {
     NL_TEST_DEF("min",                CheckMin),
     NL_TEST_DEF("max",                CheckMax),
     NL_TEST_DEF("success-or-exit",    CheckSuccessOrExit),
     NL_TEST_DEF("verify-or-exit",     CheckVerifyOrExit),
     NL_TEST_DEF("exit-now",           CheckExitNow),
     NL_TEST_DEF("verify-or-die",      CheckVerifyOrDie),
     NL_TEST_DEF("log-file-line-func", CheckLogFileLineFunc),
     NL_TEST_SENTINEL()
 };

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

     nl_test_set_output_style(OUTPUT_CSV);

     nlTestRunner(&theSuite, &sContext);

     return nlTestRunnerStats(&theSuite);
 }
	/*
	*
	* 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
	* code utilities templates and macros.
	*
	*/

	#ifndef __STDC_LIMIT_MACROS
	#define __STDC_LIMIT_MACROS
	#endif

	#include <stdint.h>

	#include <nltest.h>

	static void TestWeaveDie(void);

	#define WeaveDie() TestWeaveDie()

	#include <Weave/Support/CodeUtils.h>

	struct TestVerifyOrDieContext
	{
	bool mShouldDie;
	bool mDidDie;
	};

	static struct TestVerifyOrDieContext sContext;

	static void CheckMin(nlTestSuite inSuite, void inContext)
	{
	int8_t s8result;
	int16_t s16result;
	int32_t s32result;
	int64_t s64result;
	uint8_t u8result;
	uint16_t u16result;
	uint32_t u32result;
	uint64_t u64result;

	// Test 8-bit signed integers

	s8result = nl::Weave::min(INT8_MIN, INT8_MAX);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

	s8result = nl::Weave::min(INT8_MAX, INT8_MIN);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

	s8result = nl::Weave::min(INT8_MIN, 0);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

	s8result = nl::Weave::min(0, INT8_MIN);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

	s8result = nl::Weave::min(0, INT8_MAX);
	NL_TEST_ASSERT(inSuite, s8result == 0);

	s8result = nl::Weave::min(INT8_MAX, 0);
	NL_TEST_ASSERT(inSuite, s8result == 0);

	s8result = nl::Weave::min(0, 0);
	NL_TEST_ASSERT(inSuite, s8result == 0);

	s8result = nl::Weave::min(INT8_MIN, INT8_MIN);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

	s8result = nl::Weave::min(INT8_MAX, INT8_MAX);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

	// Test 16-bit signed integers

	s16result = nl::Weave::min(INT16_MIN, INT16_MAX);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

	s16result = nl::Weave::min(INT16_MAX, INT16_MIN);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

	s16result = nl::Weave::min(INT16_MIN, 0);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

	s16result = nl::Weave::min(0, INT16_MIN);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

	s16result = nl::Weave::min(0, INT16_MAX);
	NL_TEST_ASSERT(inSuite, s16result == 0);

	s16result = nl::Weave::min(INT16_MAX, 0);
	NL_TEST_ASSERT(inSuite, s16result == 0);

	s16result = nl::Weave::min(0, 0);
	NL_TEST_ASSERT(inSuite, s16result == 0);

	s16result = nl::Weave::min(INT16_MIN, INT16_MIN);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

	s16result = nl::Weave::min(INT16_MAX, INT16_MAX);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

	// Test 32-bit signed integers

	s32result = nl::Weave::min(INT32_MIN, INT32_MAX);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

	s32result = nl::Weave::min(INT32_MAX, INT32_MIN);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

	s32result = nl::Weave::min(INT32_MIN, 0);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

	s32result = nl::Weave::min(0, INT32_MIN);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

	s32result = nl::Weave::min(0, INT32_MAX);
	NL_TEST_ASSERT(inSuite, s32result == 0);

	s32result = nl::Weave::min(INT32_MAX, 0);
	NL_TEST_ASSERT(inSuite, s32result == 0);

	s32result = nl::Weave::min(0, 0);
	NL_TEST_ASSERT(inSuite, s32result == 0);

	s32result = nl::Weave::min(INT32_MIN, INT32_MIN);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

	s32result = nl::Weave::min(INT32_MAX, INT32_MAX);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

	// Test 64-bit signed integers

	s64result = nl::Weave::min(INT64_MIN, INT64_MAX);
	NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

	s64result = nl::Weave::min(INT64_MAX, INT64_MIN);
	NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

	s64result = nl::Weave::min(INT64_MIN, static_cast<int64_t>(0));
	NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

	s64result = nl::Weave::min(static_cast<int64_t>(0), INT64_MIN);
	NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

	s64result = nl::Weave::min(static_cast<int64_t>(0), INT64_MAX);
	NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

	s64result = nl::Weave::min(INT64_MAX, static_cast<int64_t>(0));
	NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

	s64result = nl::Weave::min(static_cast<int64_t>(0), static_cast<int64_t>(0));
	NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

	s64result = nl::Weave::min(INT64_MIN, INT64_MIN);
	NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

	s64result = nl::Weave::min(INT64_MAX, INT64_MAX);
	NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

	// Test 8-bit unsigned integers

	u8result = nl::Weave::min(UINT8_MAX, UINT8_MAX);
	NL_TEST_ASSERT(inSuite, u8result == UINT8_MAX);

	u8result = nl::Weave::min(0, UINT8_MAX);
	NL_TEST_ASSERT(inSuite, u8result == 0);

	u8result = nl::Weave::min(UINT8_MAX, 0);
	NL_TEST_ASSERT(inSuite, u8result == 0);

	u8result = nl::Weave::min(0, 0);
	NL_TEST_ASSERT(inSuite, u8result == 0);

	// Test 16-bit unsigned integers

	u16result = nl::Weave::min(UINT16_MAX, UINT16_MAX);
	NL_TEST_ASSERT(inSuite, u16result == UINT16_MAX);

	u16result = nl::Weave::min(0, UINT16_MAX);
	NL_TEST_ASSERT(inSuite, u16result == 0);

	u16result = nl::Weave::min(UINT16_MAX, 0);
	NL_TEST_ASSERT(inSuite, u16result == 0);

	u16result = nl::Weave::min(0, 0);
	NL_TEST_ASSERT(inSuite, u16result == 0);

	// Test 32-bit unsigned integers

	u32result = nl::Weave::min(UINT32_MAX, UINT32_MAX);
	NL_TEST_ASSERT(inSuite, u32result == UINT32_MAX);

	u32result = nl::Weave::min(static_cast<uint32_t>(0), UINT32_MAX);
	NL_TEST_ASSERT(inSuite, u32result == static_cast<uint32_t>(0));

	u32result = nl::Weave::min(UINT32_MAX, static_cast<uint32_t>(0));
	NL_TEST_ASSERT(inSuite, u32result == static_cast<uint32_t>(0));

	u32result = nl::Weave::min(static_cast<uint32_t>(0), static_cast<uint32_t>(0));
	NL_TEST_ASSERT(inSuite, u32result == static_cast<uint32_t>(0));

	// Test 64-bit unsigned integers

	u64result = nl::Weave::min(UINT64_MAX, UINT64_MAX);
	NL_TEST_ASSERT(inSuite, u64result == UINT64_MAX);

	u64result = nl::Weave::min(static_cast<uint64_t>(0), UINT64_MAX);
	NL_TEST_ASSERT(inSuite, u64result == static_cast<uint64_t>(0));

	u64result = nl::Weave::min(UINT64_MAX, static_cast<uint64_t>(0));
	NL_TEST_ASSERT(inSuite, u64result == static_cast<uint64_t>(0));

	u64result = nl::Weave::min(static_cast<uint64_t>(0), static_cast<uint64_t>(0));
	NL_TEST_ASSERT(inSuite, u64result == static_cast<uint64_t>(0));
	}

	static void CheckMax(nlTestSuite inSuite, void inContext)
	{
	int8_t s8result;
	int16_t s16result;
	int32_t s32result;
	int64_t s64result;
	uint8_t u8result;
	uint16_t u16result;
	uint32_t u32result;
	uint64_t u64result;

	// Test 8-bit signed integers

	s8result = nl::Weave::max(INT8_MIN, INT8_MAX);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

	s8result = nl::Weave::max(INT8_MAX, INT8_MIN);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

	s8result = nl::Weave::max(INT8_MIN, 0);
	NL_TEST_ASSERT(inSuite, s8result == 0);

	s8result = nl::Weave::max(0, INT8_MIN);
	NL_TEST_ASSERT(inSuite, s8result == 0);

	s8result = nl::Weave::max(0, INT8_MAX);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

	s8result = nl::Weave::max(INT8_MAX, 0);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

	s8result = nl::Weave::max(0, 0);
	NL_TEST_ASSERT(inSuite, s8result == 0);

	s8result = nl::Weave::max(INT8_MIN, INT8_MIN);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MIN);

	s8result = nl::Weave::max(INT8_MAX, INT8_MAX);
	NL_TEST_ASSERT(inSuite, s8result == INT8_MAX);

	// Test 16-bit signed integers

	s16result = nl::Weave::max(INT16_MIN, INT16_MAX);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

	s16result = nl::Weave::max(INT16_MAX, INT16_MIN);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

	s16result = nl::Weave::max(INT16_MIN, 0);
	NL_TEST_ASSERT(inSuite, s16result == 0);

	s16result = nl::Weave::max(0, INT16_MIN);
	NL_TEST_ASSERT(inSuite, s16result == 0);

	s16result = nl::Weave::max(0, INT16_MAX);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

	s16result = nl::Weave::max(INT16_MAX, 0);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

	s16result = nl::Weave::max(0, 0);
	NL_TEST_ASSERT(inSuite, s16result == 0);

	s16result = nl::Weave::max(INT16_MIN, INT16_MIN);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MIN);

	s16result = nl::Weave::max(INT16_MAX, INT16_MAX);
	NL_TEST_ASSERT(inSuite, s16result == INT16_MAX);

	// Test 32-bit signed integers

	s32result = nl::Weave::max(INT32_MIN, INT32_MAX);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

	s32result = nl::Weave::max(INT32_MAX, INT32_MIN);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

	s32result = nl::Weave::max(INT32_MIN, 0);
	NL_TEST_ASSERT(inSuite, s32result == 0);

	s32result = nl::Weave::max(0, INT32_MIN);
	NL_TEST_ASSERT(inSuite, s32result == 0);

	s32result = nl::Weave::max(0, INT32_MAX);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

	s32result = nl::Weave::max(INT32_MAX, 0);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

	s32result = nl::Weave::max(0, 0);
	NL_TEST_ASSERT(inSuite, s32result == 0);

	s32result = nl::Weave::max(INT32_MIN, INT32_MIN);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MIN);

	s32result = nl::Weave::max(INT32_MAX, INT32_MAX);
	NL_TEST_ASSERT(inSuite, s32result == INT32_MAX);

	// Test 64-bit signed integers

	s64result = nl::Weave::max(INT64_MIN, INT64_MAX);
	NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

	s64result = nl::Weave::max(INT64_MAX, INT64_MIN);
	NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

	s64result = nl::Weave::max(INT64_MIN, static_cast<int64_t>(0));
	NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

	s64result = nl::Weave::max(static_cast<int64_t>(0), INT64_MIN);
	NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

	s64result = nl::Weave::max(static_cast<int64_t>(0), INT64_MAX);
	NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

	s64result = nl::Weave::max(INT64_MAX, static_cast<int64_t>(0));
	NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

	s64result = nl::Weave::max(static_cast<int64_t>(0), static_cast<int64_t>(0));
	NL_TEST_ASSERT(inSuite, s64result == static_cast<int64_t>(0));

	s64result = nl::Weave::max(INT64_MIN, INT64_MIN);
	NL_TEST_ASSERT(inSuite, s64result == INT64_MIN);

	s64result = nl::Weave::max(INT64_MAX, INT64_MAX);
	NL_TEST_ASSERT(inSuite, s64result == INT64_MAX);

	// Test 8-bit unsigned integers

	u8result = nl::Weave::max(UINT8_MAX, UINT8_MAX);
	NL_TEST_ASSERT(inSuite, u8result == UINT8_MAX);

	u8result = nl::Weave::max(0, UINT8_MAX);
	NL_TEST_ASSERT(inSuite, u8result == UINT8_MAX);

	u8result = nl::Weave::max(UINT8_MAX, 0);
	NL_TEST_ASSERT(inSuite, u8result == UINT8_MAX);

	u8result = nl::Weave::max(0, 0);
	NL_TEST_ASSERT(inSuite, u8result == 0);

	// Test 16-bit unsigned integers

	u16result = nl::Weave::max(UINT16_MAX, UINT16_MAX);
	NL_TEST_ASSERT(inSuite, u16result == UINT16_MAX);

	u16result = nl::Weave::max(0, UINT16_MAX);
	NL_TEST_ASSERT(inSuite, u16result == UINT16_MAX);

	u16result = nl::Weave::max(UINT16_MAX, 0);
	NL_TEST_ASSERT(inSuite, u16result == UINT16_MAX);

	u16result = nl::Weave::max(0, 0);
	NL_TEST_ASSERT(inSuite, u16result == 0);

	// Test 32-bit unsigned integers

	u32result = nl::Weave::max(UINT32_MAX, UINT32_MAX);
	NL_TEST_ASSERT(inSuite, u32result == UINT32_MAX);

	u32result = nl::Weave::max(static_cast<uint32_t>(0), UINT32_MAX);
	NL_TEST_ASSERT(inSuite, u32result == UINT32_MAX);

	u32result = nl::Weave::max(UINT32_MAX, static_cast<uint32_t>(0));
	NL_TEST_ASSERT(inSuite, u32result == UINT32_MAX);

	u32result = nl::Weave::max(static_cast<uint32_t>(0), static_cast<uint32_t>(0));
	NL_TEST_ASSERT(inSuite, u32result == static_cast<uint32_t>(0));

	// Test 64-bit unsigned integers

	u64result = nl::Weave::max(UINT64_MAX, UINT64_MAX);
	NL_TEST_ASSERT(inSuite, u64result == UINT64_MAX);

	u64result = nl::Weave::max(static_cast<uint64_t>(0), UINT64_MAX);
	NL_TEST_ASSERT(inSuite, u64result == UINT64_MAX);

	u64result = nl::Weave::max(UINT64_MAX, static_cast<uint64_t>(0));
	NL_TEST_ASSERT(inSuite, u64result == UINT64_MAX);

	u64result = nl::Weave::max(static_cast<uint64_t>(0), static_cast<uint64_t>(0));
	NL_TEST_ASSERT(inSuite, u64result == static_cast<uint64_t>(0));
	}

	static WEAVE_ERROR GetStatus(bool inFailure)
	{
	return ((inFailure) ? -1 : WEAVE_NO_ERROR);
	}

	static void CheckSuccessOrExitFailure(nlTestSuite inSuite, void inContext)
	{
	const bool failure = true;
	int status;
	bool sentinel;

	status = GetStatus(failure);
	sentinel = false;

	SuccessOrExit(status);
	sentinel = true;

	exit:
	NL_TEST_ASSERT(inSuite, sentinel == false);
	}

	static void CheckSuccessOrExitSuccess(nlTestSuite inSuite, void inContext)
	{
	const bool failure = true;
	int status;
	bool sentinel;

	status = GetStatus(!failure);
	sentinel = false;

	SuccessOrExit(status);
	sentinel = true;

	exit:
	NL_TEST_ASSERT(inSuite, sentinel == true);
	}

	static void CheckSuccessOrExitAssignmentFailure(nlTestSuite inSuite, void inContext)
	{
	const bool failure = true;
	int status;
	bool sentinel;

	sentinel = false;

	SuccessOrExit(status = GetStatus(failure));
	sentinel = true;

	exit:
	NL_TEST_ASSERT(inSuite, sentinel == false);
	}

	static void CheckSuccessOrExitAssignmentSuccess(nlTestSuite inSuite, void inContext)
	{
	const bool failure = true;
	int status;
	bool sentinel;

	sentinel = false;

	SuccessOrExit(status = GetStatus(!failure));
	sentinel = true;

	exit:
	NL_TEST_ASSERT(inSuite, sentinel == true);
	}

	static void CheckSuccessOrExit(nlTestSuite inSuite, void inContext)
	{
	CheckSuccessOrExitFailure(inSuite, inContext);
	CheckSuccessOrExitSuccess(inSuite, inContext);
	CheckSuccessOrExitAssignmentFailure(inSuite, inContext);
	CheckSuccessOrExitAssignmentSuccess(inSuite, inContext);
	}

	static void CheckVerifyOrExitFailure(nlTestSuite inSuite, void inContext)
	{
	bool status;
	bool sentinel;
	bool action;

	status = false;
	sentinel = false;
	action = false;

	VerifyOrExit(status, action = true);
	sentinel = true;

	exit:
	NL_TEST_ASSERT(inSuite, sentinel == false);
	NL_TEST_ASSERT(inSuite, action == true);
	}

	static void CheckVerifyOrExitSuccess(nlTestSuite inSuite, void inContext)
	{
	bool status;
	bool sentinel;
	bool action;

	status = true;
	sentinel = false;
	action = false;

	VerifyOrExit(status, action = true);
	sentinel = true;

	exit:
	NL_TEST_ASSERT(inSuite, sentinel == true);
	NL_TEST_ASSERT(inSuite, action == false);
	}

	static void CheckVerifyOrExit(nlTestSuite inSuite, void inContext)
	{
	CheckVerifyOrExitFailure(inSuite, inContext);
	CheckVerifyOrExitSuccess(inSuite, inContext);
	}

	static void CheckExitNow(nlTestSuite inSuite, void inContext)
	{
	bool action;
	bool sentinel;

	sentinel = false;
	action = false;

	ExitNow(action = true);
	sentinel = true;

	exit:
	NL_TEST_ASSERT(inSuite, sentinel == false);
	NL_TEST_ASSERT(inSuite, action == true);
	}

	static void TestWeaveDie(void)
	{
	sContext.mDidDie = true;
	}

	static void CheckVerifyOrDieFailure(nlTestSuite inSuite, void inContext)
	{
	struct TestVerifyOrDieContext theContext = static_cast<struct TestVerifyOrDieContext >(inContext);
	bool status;

	status = false;

	theContext->mShouldDie = true;
	theContext->mDidDie = false;

	VerifyOrDie(status);

	NL_TEST_ASSERT(inSuite, theContext->mShouldDie == theContext->mDidDie);
	}

	static void CheckVerifyOrDieSuccess(nlTestSuite inSuite, void inContext)
	{
	struct TestVerifyOrDieContext theContext = static_cast<struct TestVerifyOrDieContext >(inContext);
	bool status;

	status = true;

	theContext->mShouldDie = false;
	theContext->mDidDie = false;

	VerifyOrDie(status);

	NL_TEST_ASSERT(inSuite, theContext->mShouldDie == theContext->mDidDie);
	}

	static void CheckVerifyOrDie(nlTestSuite inSuite, void inContext)
	{
	CheckVerifyOrDieFailure(inSuite, inContext);
	CheckVerifyOrDieSuccess(inSuite, inContext);
	}

	static void CheckLogFileLineFunc(nlTestSuite inSuite, void inContext)
	{

	}

	static const nlTest sTests[] = {
	NL_TEST_DEF("min", CheckMin),
	NL_TEST_DEF("max", CheckMax),
	NL_TEST_DEF("success-or-exit", CheckSuccessOrExit),
	NL_TEST_DEF("verify-or-exit", CheckVerifyOrExit),
	NL_TEST_DEF("exit-now", CheckExitNow),
	NL_TEST_DEF("verify-or-die", CheckVerifyOrDie),
	NL_TEST_DEF("log-file-line-func", CheckLogFileLineFunc),
	NL_TEST_SENTINEL()
	};

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

	nl_test_set_output_style(OUTPUT_CSV);

	nlTestRunner(&theSuite, &sContext);

	return nlTestRunnerStats(&theSuite);
	}