libfocunit.h

/* **************************************************************
 Copyright (C) 2011 Hewlett-Packard Development Company, L.P.

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License along
 with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
************************************************************** */
#ifndef LIBFOCUNIT_H
#define LIBFOCUNIT_H

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <getopt.h>
#include "CUnit/CUnit.h"
#include "CUnit/Automated.h"

int focunit_main(int argc, char **argv, char *test_name, CU_SuiteInfo *suites);

#define FO_PASS(msg) CU_PASS(msg)

#define FO_ASSERT(value) CU_ASSERT(value)

#define FO_ASSERT_FATAL(value)  CU_ASSERT_FATAL(value) 

#define FO_TEST(value) CU_TEST(value)

#define FO_TEST_FATAL(value) CU_TEST_FATAL(value)

#define FO_FAIL(msg) CU_FAIL(msg)

#define FO_FAIL_FATAL(msg) CU_FAIL_FATAL(msg)

#define FO_ASSERT_TRUE(value) CU_ASSERT_TRUE(value)

#define FO_ASSERT_TRUE_FATAL(value) CU_ASSERT_TRUE_FATAL(value)

#define FO_ASSERT_FALSE(value) CU_ASSERT_FALSE(value)

#define FO_ASSERT_FALSE_FATAL(value) CU_ASSERT_FALSE_FATAL(value)

#define FO_ASSERT_EQUAL(actual, expected) \
  { \
    if (actual != expected) printf("%s(%d) Expected %d, got %d\n",\
                 __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_EQUAL(actual, expected)\
  }

#define FO_ASSERT_EQUAL_FATAL(actual, expected) \
  { \
    if (actual != expected) printf("FATAL: %s(%d) Expected %d, got %d\n",\
                 __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_EQUAL_FATAL(actual, expected)\
  }

#define FO_ASSERT_NOT_EQUAL(actual, expected) \
  { \
    if (actual == expected) printf("%s(%d) Expected != %d got %d\n",\
                 __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_NOT_EQUAL(actual, expected)\
  }

#define FO_ASSERT_NOT_EQUAL_FATAL(actual, expected) \
  { \
    if (actual == expected) printf("FATAL: %s(%d) Expected != %d, got %d\n",\
                 __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_NOT_EQUAL_FATAL(actual, expected)\
  }

#define FO_ASSERT_PTR_EQUAL(actual, expected) \
  { \
    if (actual != expected) printf("%s(%d) Expected %p, got %p\n",\
                 __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_PTR_EQUAL(actual, expected)\
  }

#define FO_ASSERT_PTR_EQUAL_FATAL(actual, expected) \
  { \
    if (actual != expected) printf("FATAL: %s(%d) Expected %p, got %p\n",\
                 __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_PTR_EQUAL_FATAL(actual, expected)\
  }

#define FO_ASSERT_PTR_NOT_EQUAL(actual, expected) \
  { \
    if (actual == expected) printf("%s(%d) Expected != %p got %p\n",\
                 __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_PTR_NOT_EQUAL(actual, expected)\
  }

#define FO_ASSERT_PTR_NOT_EQUAL_FATAL(actual, expected) \
  { \
    if (actual == expected) printf("FATAL: %s(%d) Expected != %p, got %p\n",\
                 __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_PTR_NOT_EQUAL_FATAL(actual, expected)\
  }

#define FO_ASSERT_PTR_NULL(value) CU_ASSERT_PTR_NULL(value)

#define FO_ASSERT_PTR_NULL_FATAL(value) CU_ASSERT_PTR_NULL_FATAL(value)

#define FO_ASSERT_PTR_NOT_NULL(value) CU_ASSERT_PTR_NOT_NULL(value)

#define FO_ASSERT_PTR_NOT_NULL_FATAL(value) CU_ASSERT_PTR_NOT_NULL_FATAL(value)

#define FO_ASSERT_STRING_EQUAL(actual, expected) \
  { \
    FO_ASSERT_PTR_NOT_NULL_FATAL(actual); \
    if (0 != (strcmp((const char*)(actual), (const char*)(expected)))) \
      printf("%s(%d) Expected (%s), got (%s)\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_STRING_EQUAL(actual, expected)\
  }

#define FO_ASSERT_STRING_EQUAL_FATAL(actual, expected) \
  { \
    if (0 != (strcmp((const char*)(actual), (const char*)(expected)))) \
       printf("FATAL: %s(%d) Expected (%s), got (%s)\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_STRING_EQUAL_FATAL(actual, expected)\
  }

#define FO_ASSERT_STRING_NOT_EQUAL(actual, expected) \
  { \
    if (0 == strcmp((const char*)(actual), (const char*)(expected))) \
       printf("%s(%d) Expected != (%s), got (%s)\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_STRING_NOT_EQUAL(actual, expected)\
  }

#define FO_ASSERT_STRING_NOT_EQUAL_FATAL(actual, expected) \
  { \
    if (0 == strcmp((const char*)(actual), (const char*)(expected))) \
       printf("FATAL: %s(%d) Expected != (%s), got (%s)\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_STRING_NOT_EQUAL_FATAL(actual, expected)\
  }

#define FO_ASSERT_NSTRING_EQUAL(actual, expected, count) \
  { \
    if (0 != strcmp((const char*)(actual), (const char*)(expected), (size_t)(count))) \
      printf("%s(%d) Expected (%s), got (%s)\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_NSTRING_EQUAL(actual, expected, count)\
  }

#define FO_ASSERT_NSTRING_EQUAL_FATAL(actual, expected, count) \
  { \
    if (0 != strcmp((const char*)(actual), (const char*)(expected), (size_t)(count))) \
      printf("FATAL: %s(%d) Expected (%s), got (%s)\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_NSTRING_EQUAL_FATAL(actual, expected, count)\
  }

#define FO_ASSERT_NSTRING_NOT_EQUAL(actual, expected, count) \
  { \
    if (0 == strcmp((const char*)(actual), (const char*)(expected), (size_t)(count))) \
      printf("%s(%d) Expected (%s), got (%s)\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_NSTRING_NOT_EQUAL(actual, expected, count)\
  }

#define FO_ASSERT_NSTRING_NOT_EQUAL_FATAL(actual, expected, count) \
  { \
    if (0 == strcmp((const char*)(actual), (const char*)(expected), (size_t)(count))) \
      printf("FATAL: %s(%d) Expected (%s), got (%s)\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_NSTRING_NOT_EQUAL_FATAL(actual, expected, count)\
  }

#define FO_ASSERT_DOUBLE_EQUAL(actual, expected, granularity) \
  { \
    if (fabs((double)(actual) - (expected)) >= fabs((double)(granularity))) \
      printf("%s(%d) Expected %f, got %f\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_DOUBLE_EQUAL(actual, expected, granularity)\
  }

#define FO_ASSERT_DOUBLE_EQUAL_FATAL(actual, expected, granularity) \
  { \
    if (fabs((double)(actual) - (expected)) >= fabs((double)(granularity))) \
      printf("FATAL: %s(%d) Expected %f, got %f\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_DOUBLE_EQUAL_FATAL(actual, expected, granularity)\
  }

#define FO_ASSERT_DOUBLE_NOT_EQUAL(actual, expected, granularity) \
  { \
    if (fabs((double)(actual) - (expected)) <= fabs((double)(granularity)))\
      printf("%s(%d) Expected %f, got %f\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_DOUBLE_NOT_EQUAL(actual, expected, granularity)\
  }

#define FO_ASSERT_DOUBLE_NOT_EQUAL_FATAL(actual, expected, granularity) \
  { \
    if (fabs((double)(actual) - (expected)) <= fabs((double)(granularity))) \
      printf("FATAL: %s(%d) Expected %f, got %f\n", __FILE__,__LINE__, expected, actual);\
    CU_ASSERT_DOUBLE_NOT_EQUAL_FATAL(actual, expected, granularity)\
  }

#endif