1 /** 2 * \file macros.h 3 * 4 * \brief This file contains generic macros for the purpose of testing. 5 */ 6 7 /* 8 * Copyright The Mbed TLS Contributors 9 * SPDX-License-Identifier: Apache-2.0 10 * 11 * Licensed under the Apache License, Version 2.0 (the "License"); you may 12 * not use this file except in compliance with the License. 13 * You may obtain a copy of the License at 14 * 15 * http://www.apache.org/licenses/LICENSE-2.0 16 * 17 * Unless required by applicable law or agreed to in writing, software 18 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 19 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 20 * See the License for the specific language governing permissions and 21 * limitations under the License. 22 */ 23 24 #ifndef TEST_MACROS_H 25 #define TEST_MACROS_H 26 27 #include "mbedtls/build_info.h" 28 29 #include <stdlib.h> 30 31 #if defined(MBEDTLS_PLATFORM_C) 32 #include "mbedtls/platform.h" 33 #else 34 #include <stdio.h> 35 #define mbedtls_fprintf fprintf 36 #define mbedtls_snprintf snprintf 37 #define mbedtls_calloc calloc 38 #define mbedtls_free free 39 #define mbedtls_exit exit 40 #define mbedtls_time time 41 #define mbedtls_time_t time_t 42 #define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS 43 #define MBEDTLS_EXIT_FAILURE EXIT_FAILURE 44 #endif 45 46 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) 47 #include "mbedtls/memory_buffer_alloc.h" 48 #endif 49 50 /** 51 * \brief This macro tests the expression passed to it as a test step or 52 * individual test in a test case. 53 * 54 * It allows a library function to return a value and return an error 55 * code that can be tested. 56 * 57 * Failing the test means: 58 * - Mark this test case as failed. 59 * - Print a message identifying the failure. 60 * - Jump to the \c exit label. 61 * 62 * This macro expands to an instruction, not an expression. 63 * It may jump to the \c exit label. 64 * 65 * \param TEST The test expression to be tested. 66 */ 67 #define TEST_ASSERT( TEST ) \ 68 do { \ 69 if( ! (TEST) ) \ 70 { \ 71 mbedtls_test_fail( #TEST, __LINE__, __FILE__ ); \ 72 goto exit; \ 73 } \ 74 } while( 0 ) 75 76 /** Evaluate two integer expressions and fail the test case if they have 77 * different values. 78 * 79 * The two expressions should have the same signedness, otherwise the 80 * comparison is not meaningful if the signed value is negative. 81 * 82 * \param expr1 An integral-typed expression to evaluate. 83 * \param expr2 Another integral-typed expression to evaluate. 84 */ 85 #define TEST_EQUAL( expr1, expr2 ) \ 86 do { \ 87 if( ! mbedtls_test_equal( #expr1 " == " #expr2, __LINE__, __FILE__, \ 88 expr1, expr2 ) ) \ 89 goto exit; \ 90 } while( 0 ) 91 92 /** Allocate memory dynamically and fail the test case if this fails. 93 * The allocated memory will be filled with zeros. 94 * 95 * You must set \p pointer to \c NULL before calling this macro and 96 * put `mbedtls_free( pointer )` in the test's cleanup code. 97 * 98 * If \p length is zero, the resulting \p pointer will be \c NULL. 99 * This is usually what we want in tests since API functions are 100 * supposed to accept null pointers when a buffer size is zero. 101 * 102 * This macro expands to an instruction, not an expression. 103 * It may jump to the \c exit label. 104 * 105 * \param pointer An lvalue where the address of the allocated buffer 106 * will be stored. 107 * This expression may be evaluated multiple times. 108 * \param length Number of elements to allocate. 109 * This expression may be evaluated multiple times. 110 * 111 */ 112 #define ASSERT_ALLOC( pointer, length ) \ 113 do \ 114 { \ 115 TEST_ASSERT( ( pointer ) == NULL ); \ 116 if( ( length ) != 0 ) \ 117 { \ 118 ( pointer ) = mbedtls_calloc( sizeof( *( pointer ) ), \ 119 ( length ) ); \ 120 TEST_ASSERT( ( pointer ) != NULL ); \ 121 } \ 122 } \ 123 while( 0 ) 124 125 /** Allocate memory dynamically. If the allocation fails, skip the test case. 126 * 127 * This macro behaves like #ASSERT_ALLOC, except that if the allocation 128 * fails, it marks the test as skipped rather than failed. 129 */ 130 #define ASSERT_ALLOC_WEAK( pointer, length ) \ 131 do \ 132 { \ 133 TEST_ASSERT( ( pointer ) == NULL ); \ 134 if( ( length ) != 0 ) \ 135 { \ 136 ( pointer ) = mbedtls_calloc( sizeof( *( pointer ) ), \ 137 ( length ) ); \ 138 TEST_ASSUME( ( pointer ) != NULL ); \ 139 } \ 140 } \ 141 while( 0 ) 142 143 /** Compare two buffers and fail the test case if they differ. 144 * 145 * This macro expands to an instruction, not an expression. 146 * It may jump to the \c exit label. 147 * 148 * \param p1 Pointer to the start of the first buffer. 149 * \param size1 Size of the first buffer in bytes. 150 * This expression may be evaluated multiple times. 151 * \param p2 Pointer to the start of the second buffer. 152 * \param size2 Size of the second buffer in bytes. 153 * This expression may be evaluated multiple times. 154 */ 155 #define ASSERT_COMPARE( p1, size1, p2, size2 ) \ 156 do \ 157 { \ 158 TEST_ASSERT( ( size1 ) == ( size2 ) ); \ 159 if( ( size1 ) != 0 ) \ 160 TEST_ASSERT( memcmp( ( p1 ), ( p2 ), ( size1 ) ) == 0 ); \ 161 } \ 162 while( 0 ) 163 164 /** 165 * \brief This macro tests the expression passed to it and skips the 166 * running test if it doesn't evaluate to 'true'. 167 * 168 * \param TEST The test expression to be tested. 169 */ 170 #define TEST_ASSUME( TEST ) \ 171 do { \ 172 if( ! (TEST) ) \ 173 { \ 174 mbedtls_test_skip( #TEST, __LINE__, __FILE__ ); \ 175 goto exit; \ 176 } \ 177 } while( 0 ) 178 179 #define TEST_HELPER_ASSERT(a) if( !( a ) ) \ 180 { \ 181 mbedtls_fprintf( stderr, "Assertion Failed at %s:%d - %s\n", \ 182 __FILE__, __LINE__, #a ); \ 183 mbedtls_exit( 1 ); \ 184 } 185 186 /** \def ARRAY_LENGTH 187 * Return the number of elements of a static or stack array. 188 * 189 * \param array A value of array (not pointer) type. 190 * 191 * \return The number of elements of the array. 192 */ 193 /* A correct implementation of ARRAY_LENGTH, but which silently gives 194 * a nonsensical result if called with a pointer rather than an array. */ 195 #define ARRAY_LENGTH_UNSAFE( array ) \ 196 ( sizeof( array ) / sizeof( *( array ) ) ) 197 198 #if defined(__GNUC__) 199 /* Test if arg and &(arg)[0] have the same type. This is true if arg is 200 * an array but not if it's a pointer. */ 201 #define IS_ARRAY_NOT_POINTER( arg ) \ 202 ( ! __builtin_types_compatible_p( __typeof__( arg ), \ 203 __typeof__( &( arg )[0] ) ) ) 204 /* A compile-time constant with the value 0. If `const_expr` is not a 205 * compile-time constant with a nonzero value, cause a compile-time error. */ 206 #define STATIC_ASSERT_EXPR( const_expr ) \ 207 ( 0 && sizeof( struct { unsigned int STATIC_ASSERT : 1 - 2 * ! ( const_expr ); } ) ) 208 209 /* Return the scalar value `value` (possibly promoted). This is a compile-time 210 * constant if `value` is. `condition` must be a compile-time constant. 211 * If `condition` is false, arrange to cause a compile-time error. */ 212 #define STATIC_ASSERT_THEN_RETURN( condition, value ) \ 213 ( STATIC_ASSERT_EXPR( condition ) ? 0 : ( value ) ) 214 215 #define ARRAY_LENGTH( array ) \ 216 ( STATIC_ASSERT_THEN_RETURN( IS_ARRAY_NOT_POINTER( array ), \ 217 ARRAY_LENGTH_UNSAFE( array ) ) ) 218 219 #else 220 /* If we aren't sure the compiler supports our non-standard tricks, 221 * fall back to the unsafe implementation. */ 222 #define ARRAY_LENGTH( array ) ARRAY_LENGTH_UNSAFE( array ) 223 #endif 224 225 /** Return the smaller of two values. 226 * 227 * \param x An integer-valued expression without side effects. 228 * \param y An integer-valued expression without side effects. 229 * 230 * \return The smaller of \p x and \p y. 231 */ 232 #define MIN( x, y ) ( ( x ) < ( y ) ? ( x ) : ( y ) ) 233 234 /** Return the larger of two values. 235 * 236 * \param x An integer-valued expression without side effects. 237 * \param y An integer-valued expression without side effects. 238 * 239 * \return The larger of \p x and \p y. 240 */ 241 #define MAX( x, y ) ( ( x ) > ( y ) ? ( x ) : ( y ) ) 242 243 /* 244 * 32-bit integer manipulation macros (big endian) 245 */ 246 #ifndef GET_UINT32_BE 247 #define GET_UINT32_BE(n,b,i) \ 248 { \ 249 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \ 250 | ( (uint32_t) (b)[(i) + 1] << 16 ) \ 251 | ( (uint32_t) (b)[(i) + 2] << 8 ) \ 252 | ( (uint32_t) (b)[(i) + 3] ); \ 253 } 254 #endif 255 256 #ifndef PUT_UINT32_BE 257 #define PUT_UINT32_BE(n,b,i) \ 258 { \ 259 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \ 260 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \ 261 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \ 262 (b)[(i) + 3] = (unsigned char) ( (n) ); \ 263 } 264 #endif 265 266 #endif /* TEST_MACROS_H */ 267