mirror of
https://github.com/ThrowTheSwitch/Unity.git
synced 2025-08-06 13:50:49 +08:00
Change comments style in unity and test runner to compile with std=c89
This commit is contained in:
Andrzej Bieniek
@ -13,10 +13,10 @@
|
||||
|
||||
#include <setjmp.h>
|
||||
|
||||
// Unity Attempts to Auto-Detect Integer Types
|
||||
// Attempt 1: UINT_MAX, ULONG_MAX, etc in <stdint.h>
|
||||
// Attempt 2: UINT_MAX, ULONG_MAX, etc in <limits.h>
|
||||
// Attempt 3: Deduced from sizeof() macros
|
||||
/* Unity Attempts to Auto-Detect Integer Types
|
||||
* Attempt 1: UINT_MAX, ULONG_MAX, etc in <stdint.h>
|
||||
* Attempt 2: UINT_MAX, ULONG_MAX, etc in <limits.h>
|
||||
* Attempt 3: Deduced from sizeof() macros */
|
||||
#ifndef UNITY_EXCLUDE_STDINT_H
|
||||
#include <stdint.h>
|
||||
#endif
|
||||
@ -33,7 +33,7 @@
|
||||
#define ULONG_MAX (sizeof(unsigned long) * 256 - 1)
|
||||
#endif
|
||||
#ifndef UINTPTR_MAX
|
||||
//apparently this is not a constant expression: (sizeof(unsigned int *) * 256 - 1) so we have to just let this fall through
|
||||
/* apparently this is not a constant expression: (sizeof(unsigned int *) * 256 - 1) so we have to just let this fall through */
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -41,14 +41,14 @@
|
||||
#include <math.h>
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Guess Widths If Not Specified
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Guess Widths If Not Specified
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
// Determine the size of an int, if not already specificied.
|
||||
// We cannot use sizeof(int), because it is not yet defined
|
||||
// at this stage in the trnslation of the C program.
|
||||
// Therefore, infer it from UINT_MAX if possible.
|
||||
/* Determine the size of an int, if not already specificied.
|
||||
* We cannot use sizeof(int), because it is not yet defined
|
||||
* at this stage in the trnslation of the C program.
|
||||
* Therefore, infer it from UINT_MAX if possible. */
|
||||
#ifndef UNITY_INT_WIDTH
|
||||
#ifdef UINT_MAX
|
||||
#if (UINT_MAX == 0xFFFF)
|
||||
@ -64,9 +64,9 @@
|
||||
#define UNITY_INT_WIDTH (32)
|
||||
#endif
|
||||
|
||||
// Determine the size of a long, if not already specified,
|
||||
// by following the process used above to define
|
||||
// UNITY_INT_WIDTH.
|
||||
/* Determine the size of a long, if not already specified,
|
||||
* by following the process used above to define
|
||||
* UNITY_INT_WIDTH. */
|
||||
#ifndef UNITY_LONG_WIDTH
|
||||
#ifdef ULONG_MAX
|
||||
#if (ULONG_MAX == 0xFFFF)
|
||||
@ -82,9 +82,9 @@
|
||||
#define UNITY_LONG_WIDTH (32)
|
||||
#endif
|
||||
|
||||
// Determine the size of a pointer, if not already specified,
|
||||
// by following the process used above to define
|
||||
// UNITY_INT_WIDTH.
|
||||
/* Determine the size of a pointer, if not already specified,
|
||||
* by following the process used above to define
|
||||
* UNITY_INT_WIDTH. */
|
||||
#ifndef UNITY_POINTER_WIDTH
|
||||
#ifdef UINTPTR_MAX
|
||||
#if (UINTPTR_MAX+0 <= 0xFFFF)
|
||||
@ -111,9 +111,9 @@
|
||||
#define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Int Support (Define types based on detected sizes)
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Int Support (Define types based on detected sizes)
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
#if (UNITY_INT_WIDTH == 32)
|
||||
typedef unsigned char _UU8;
|
||||
@ -133,9 +133,9 @@
|
||||
#error Invalid UNITY_INT_WIDTH specified! (16 or 32 are supported)
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// 64-bit Support
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* 64-bit Support
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
#ifndef UNITY_SUPPORT_64
|
||||
#if UNITY_LONG_WIDTH > 32
|
||||
@ -150,13 +150,13 @@
|
||||
|
||||
#ifndef UNITY_SUPPORT_64
|
||||
|
||||
//No 64-bit Support
|
||||
/* No 64-bit Support */
|
||||
typedef _UU32 _U_UINT;
|
||||
typedef _US32 _U_SINT;
|
||||
|
||||
#else
|
||||
|
||||
//64-bit Support
|
||||
/* 64-bit Support */
|
||||
#if (UNITY_LONG_WIDTH == 32)
|
||||
typedef unsigned long long _UU64;
|
||||
typedef signed long long _US64;
|
||||
@ -171,9 +171,9 @@ typedef _US64 _U_SINT;
|
||||
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Pointer Support
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Pointer Support
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
#if (UNITY_POINTER_WIDTH == 32)
|
||||
typedef _UU32 _UP;
|
||||
@ -194,16 +194,16 @@ typedef _US64 _U_SINT;
|
||||
|
||||
#ifndef UNITY_INTERNAL_PTR
|
||||
#define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const void*
|
||||
//#define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const _UU8*
|
||||
/* #define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const _UU8* */
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Float Support
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Float Support
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
#ifdef UNITY_EXCLUDE_FLOAT
|
||||
|
||||
//No Floating Point Support
|
||||
/* No Floating Point Support */
|
||||
#undef UNITY_INCLUDE_FLOAT
|
||||
#undef UNITY_FLOAT_PRECISION
|
||||
#undef UNITY_FLOAT_TYPE
|
||||
@ -215,7 +215,7 @@ typedef _US64 _U_SINT;
|
||||
#define UNITY_INCLUDE_FLOAT
|
||||
#endif
|
||||
|
||||
//Floating Point Support
|
||||
/* Floating Point Support */
|
||||
#ifndef UNITY_FLOAT_PRECISION
|
||||
#define UNITY_FLOAT_PRECISION (0.00001f)
|
||||
#endif
|
||||
@ -243,11 +243,11 @@ typedef UNITY_FLOAT_TYPE _UF;
|
||||
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Double Float Support
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Double Float Support
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
//unlike FLOAT, we DON'T include by default
|
||||
/* unlike FLOAT, we DON'T include by default */
|
||||
#ifndef UNITY_EXCLUDE_DOUBLE
|
||||
#ifndef UNITY_INCLUDE_DOUBLE
|
||||
#define UNITY_EXCLUDE_DOUBLE
|
||||
@ -256,7 +256,7 @@ typedef UNITY_FLOAT_TYPE _UF;
|
||||
|
||||
#ifdef UNITY_EXCLUDE_DOUBLE
|
||||
|
||||
//No Floating Point Support
|
||||
/* No Floating Point Support */
|
||||
#undef UNITY_DOUBLE_PRECISION
|
||||
#undef UNITY_DOUBLE_TYPE
|
||||
#undef UNITY_DOUBLE_VERBOSE
|
||||
@ -267,7 +267,7 @@ typedef UNITY_FLOAT_TYPE _UF;
|
||||
|
||||
#else
|
||||
|
||||
//Double Floating Point Support
|
||||
/* Double Floating Point Support */
|
||||
#ifndef UNITY_DOUBLE_PRECISION
|
||||
#define UNITY_DOUBLE_PRECISION (1e-12f)
|
||||
#endif
|
||||
@ -284,26 +284,26 @@ typedef UNITY_DOUBLE_TYPE _UD;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Output Method: stdout (DEFAULT)
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Output Method: stdout (DEFAULT)
|
||||
*-------------------------------------------------------*/
|
||||
#ifndef UNITY_OUTPUT_CHAR
|
||||
//Default to using putchar, which is defined in stdio.h
|
||||
/* Default to using putchar, which is defined in stdio.h */
|
||||
#include <stdio.h>
|
||||
#define UNITY_OUTPUT_CHAR(a) (void)putchar(a)
|
||||
#else
|
||||
//If defined as something else, make sure we declare it here so it's ready for use
|
||||
/* If defined as something else, make sure we declare it here so it's ready for use */
|
||||
#ifndef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION
|
||||
extern void UNITY_OUTPUT_CHAR(int);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef UNITY_OUTPUT_FLUSH
|
||||
//Default to using putchar, which is defined in stdio.h
|
||||
/* Default to using putchar, which is defined in stdio.h */
|
||||
#include <stdio.h>
|
||||
#define UNITY_OUTPUT_FLUSH() (void)fflush(stdout)
|
||||
#else
|
||||
//If defined as something else, make sure we declare it here so it's ready for use
|
||||
/* If defined as something else, make sure we declare it here so it's ready for use */
|
||||
#ifndef UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION
|
||||
extern void UNITY_OUTPUT_FLUSH(void);
|
||||
#endif
|
||||
@ -321,9 +321,9 @@ extern void UNITY_OUTPUT_FLUSH(void);
|
||||
#define UNITY_OUTPUT_COMPLETE()
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Footprint
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Footprint
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
#ifndef UNITY_LINE_TYPE
|
||||
#define UNITY_LINE_TYPE _U_UINT
|
||||
@ -333,11 +333,11 @@ extern void UNITY_OUTPUT_FLUSH(void);
|
||||
#define UNITY_COUNTER_TYPE _U_UINT
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Language Features Available
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Language Features Available
|
||||
*-------------------------------------------------------*/
|
||||
#if !defined(UNITY_WEAK_ATTRIBUTE) && !defined(UNITY_WEAK_PRAGMA)
|
||||
# ifdef __GNUC__ // includes clang
|
||||
# ifdef __GNUC__ /* includes clang */
|
||||
# if !(defined(__WIN32__) && defined(__clang__))
|
||||
# define UNITY_WEAK_ATTRIBUTE __attribute__((weak))
|
||||
# endif
|
||||
@ -350,9 +350,9 @@ extern void UNITY_OUTPUT_FLUSH(void);
|
||||
#endif
|
||||
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Internal Structs Needed
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Internal Structs Needed
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
typedef void (*UnityTestFunction)(void);
|
||||
|
||||
@ -433,18 +433,18 @@ struct _Unity
|
||||
|
||||
extern struct _Unity Unity;
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Test Suite Management
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Test Suite Management
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
void UnityBegin(const char* filename);
|
||||
int UnityEnd(void);
|
||||
void UnityConcludeTest(void);
|
||||
void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum);
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Details Support
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Details Support
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
#ifdef UNITY_EXCLUDE_DETAILS
|
||||
#define UNITY_CLR_DETAILS()
|
||||
@ -464,9 +464,9 @@ void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Test Output
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Test Output
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
void UnityPrint(const char* string);
|
||||
void UnityPrintMask(const _U_UINT mask, const _U_UINT number);
|
||||
@ -479,13 +479,13 @@ void UnityPrintNumberHex(const _U_UINT number, const char nibbles);
|
||||
void UnityPrintFloat(const _UF number);
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Test Assertion Fuctions
|
||||
//-------------------------------------------------------
|
||||
// Use the macros below this section instead of calling
|
||||
// these directly. The macros have a consistent naming
|
||||
// convention and will pull in file and line information
|
||||
// for you.
|
||||
/*-------------------------------------------------------
|
||||
* Test Assertion Fuctions
|
||||
*-------------------------------------------------------
|
||||
* Use the macros below this section instead of calling
|
||||
* these directly. The macros have a consistent naming
|
||||
* convention and will pull in file and line information
|
||||
* for you. */
|
||||
|
||||
void UnityAssertEqualNumber(const _U_SINT expected,
|
||||
const _U_SINT actual,
|
||||
@ -579,23 +579,23 @@ void UnityAssertDoubleSpecial(const _UD actual,
|
||||
const UNITY_FLOAT_TRAIT_T style);
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Error Strings We Might Need
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Error Strings We Might Need
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
extern const char UnityStrErrFloat[];
|
||||
extern const char UnityStrErrDouble[];
|
||||
extern const char UnityStrErr64[];
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Test Running Macros
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Test Running Macros
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0)
|
||||
|
||||
#define TEST_ABORT() {longjmp(Unity.AbortFrame, 1);}
|
||||
|
||||
//This tricky series of macros gives us an optional line argument to treat it as RUN_TEST(func, num=__LINE__)
|
||||
/* This tricky series of macros gives us an optional line argument to treat it as RUN_TEST(func, num=__LINE__) */
|
||||
#ifndef RUN_TEST
|
||||
#ifdef __STDC_VERSION__
|
||||
#if __STDC_VERSION__ >= 199901L
|
||||
@ -608,7 +608,7 @@ extern const char UnityStrErr64[];
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//If we can't do the tricky version, we'll just have to require them to always include the line number
|
||||
/* If we can't do the tricky version, we'll just have to require them to always include the line number */
|
||||
#ifndef RUN_TEST
|
||||
#ifdef CMOCK
|
||||
#define RUN_TEST(func, num) UnityDefaultTestRun(func, #func, num)
|
||||
@ -634,16 +634,16 @@ extern const char UnityStrErr64[];
|
||||
|
||||
#define UNITY_UNUSED(x) (void)(sizeof(x))
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Basic Fail and Ignore
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Basic Fail and Ignore
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
#define UNITY_TEST_FAIL(line, message) UnityFail( (message), (UNITY_LINE_TYPE)(line))
|
||||
#define UNITY_TEST_IGNORE(line, message) UnityIgnore( (message), (UNITY_LINE_TYPE)(line))
|
||||
|
||||
//-------------------------------------------------------
|
||||
// Test Asserts
|
||||
//-------------------------------------------------------
|
||||
/*-------------------------------------------------------
|
||||
* Test Asserts
|
||||
*-------------------------------------------------------*/
|
||||
|
||||
#define UNITY_TEST_ASSERT(condition, line, message) if (condition) {} else {UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), (message));}
|
||||
#define UNITY_TEST_ASSERT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) == NULL), (UNITY_LINE_TYPE)(line), (message))
|
||||
@ -768,5 +768,5 @@ extern const char UnityStrErr64[];
|
||||
#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((_UD)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET)
|
||||
#endif
|
||||
|
||||
//End of UNITY_INTERNALS_H
|
||||
/* End of UNITY_INTERNALS_H */
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user