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 #include "mbedtls/platform.h" 32 33 #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) 34 #include "mbedtls/memory_buffer_alloc.h" 35 #endif 36 37 /** 38 * \brief This macro tests the expression passed to it as a test step or 39 * individual test in a test case. 40 * 41 * It allows a library function to return a value and return an error 42 * code that can be tested. 43 * 44 * Failing the test means: 45 * - Mark this test case as failed. 46 * - Print a message identifying the failure. 47 * - Jump to the \c exit label. 48 * 49 * This macro expands to an instruction, not an expression. 50 * It may jump to the \c exit label. 51 * 52 * \param TEST The test expression to be tested. 53 */ 54 #define TEST_ASSERT(TEST) \ 55 do { \ 56 if (!(TEST)) \ 57 { \ 58 mbedtls_test_fail( #TEST, __LINE__, __FILE__); \ 59 goto exit; \ 60 } \ 61 } while (0) 62 63 /** Evaluate two integer expressions and fail the test case if they have 64 * different values. 65 * 66 * The two expressions should have the same signedness, otherwise the 67 * comparison is not meaningful if the signed value is negative. 68 * 69 * \param expr1 An integral-typed expression to evaluate. 70 * \param expr2 Another integral-typed expression to evaluate. 71 */ 72 #define TEST_EQUAL(expr1, expr2) \ 73 do { \ 74 if (!mbedtls_test_equal( #expr1 " == " #expr2, __LINE__, __FILE__, \ 75 expr1, expr2)) \ 76 goto exit; \ 77 } while (0) 78 79 /** Evaluate two unsigned integer expressions and fail the test case 80 * if they are not in increasing order (left <= right). 81 * 82 * \param expr1 An integral-typed expression to evaluate. 83 * \param expr2 Another integral-typed expression to evaluate. 84 */ 85 #define TEST_LE_U(expr1, expr2) \ 86 do { \ 87 if (!mbedtls_test_le_u( #expr1 " <= " #expr2, __LINE__, __FILE__, \ 88 expr1, expr2)) \ 89 goto exit; \ 90 } while (0) 91 92 /** Evaluate two signed integer expressions and fail the test case 93 * if they are not in increasing order (left <= right). 94 * 95 * \param expr1 An integral-typed expression to evaluate. 96 * \param expr2 Another integral-typed expression to evaluate. 97 */ 98 #define TEST_LE_S(expr1, expr2) \ 99 do { \ 100 if (!mbedtls_test_le_s( #expr1 " <= " #expr2, __LINE__, __FILE__, \ 101 expr1, expr2)) \ 102 goto exit; \ 103 } while (0) 104 105 /** Allocate memory dynamically and fail the test case if this fails. 106 * The allocated memory will be filled with zeros. 107 * 108 * You must set \p pointer to \c NULL before calling this macro and 109 * put `mbedtls_free( pointer )` in the test's cleanup code. 110 * 111 * If \p length is zero, the resulting \p pointer will be \c NULL. 112 * This is usually what we want in tests since API functions are 113 * supposed to accept null pointers when a buffer size is zero. 114 * 115 * This macro expands to an instruction, not an expression. 116 * It may jump to the \c exit label. 117 * 118 * \param pointer An lvalue where the address of the allocated buffer 119 * will be stored. 120 * This expression may be evaluated multiple times. 121 * \param length Number of elements to allocate. 122 * This expression may be evaluated multiple times. 123 * 124 */ 125 #define ASSERT_ALLOC(pointer, length) \ 126 do \ 127 { \ 128 TEST_ASSERT((pointer) == NULL); \ 129 if ((length) != 0) \ 130 { \ 131 (pointer) = mbedtls_calloc(sizeof(*(pointer)), \ 132 (length)); \ 133 TEST_ASSERT((pointer) != NULL); \ 134 } \ 135 } \ 136 while (0) 137 138 /** Allocate memory dynamically. If the allocation fails, skip the test case. 139 * 140 * This macro behaves like #ASSERT_ALLOC, except that if the allocation 141 * fails, it marks the test as skipped rather than failed. 142 */ 143 #define ASSERT_ALLOC_WEAK(pointer, length) \ 144 do \ 145 { \ 146 TEST_ASSERT((pointer) == NULL); \ 147 if ((length) != 0) \ 148 { \ 149 (pointer) = mbedtls_calloc(sizeof(*(pointer)), \ 150 (length)); \ 151 TEST_ASSUME((pointer) != NULL); \ 152 } \ 153 } \ 154 while (0) 155 156 /** Compare two buffers and fail the test case if they differ. 157 * 158 * This macro expands to an instruction, not an expression. 159 * It may jump to the \c exit label. 160 * 161 * \param p1 Pointer to the start of the first buffer. 162 * \param size1 Size of the first buffer in bytes. 163 * This expression may be evaluated multiple times. 164 * \param p2 Pointer to the start of the second buffer. 165 * \param size2 Size of the second buffer in bytes. 166 * This expression may be evaluated multiple times. 167 */ 168 #define ASSERT_COMPARE(p1, size1, p2, size2) \ 169 do \ 170 { \ 171 TEST_EQUAL((size1), (size2)); \ 172 if ((size1) != 0) \ 173 TEST_ASSERT(memcmp((p1), (p2), (size1)) == 0); \ 174 } \ 175 while (0) 176 177 /** 178 * \brief This macro tests the expression passed to it and skips the 179 * running test if it doesn't evaluate to 'true'. 180 * 181 * \param TEST The test expression to be tested. 182 */ 183 #define TEST_ASSUME(TEST) \ 184 do { \ 185 if (!(TEST)) \ 186 { \ 187 mbedtls_test_skip( #TEST, __LINE__, __FILE__); \ 188 goto exit; \ 189 } \ 190 } while (0) 191 192 #define TEST_HELPER_ASSERT(a) if (!(a)) \ 193 { \ 194 mbedtls_fprintf(stderr, "Assertion Failed at %s:%d - %s\n", \ 195 __FILE__, __LINE__, #a); \ 196 mbedtls_exit(1); \ 197 } 198 199 /** \def ARRAY_LENGTH 200 * Return the number of elements of a static or stack array. 201 * 202 * \param array A value of array (not pointer) type. 203 * 204 * \return The number of elements of the array. 205 */ 206 /* A correct implementation of ARRAY_LENGTH, but which silently gives 207 * a nonsensical result if called with a pointer rather than an array. */ 208 #define ARRAY_LENGTH_UNSAFE(array) \ 209 (sizeof(array) / sizeof(*(array))) 210 211 #if defined(__GNUC__) 212 /* Test if arg and &(arg)[0] have the same type. This is true if arg is 213 * an array but not if it's a pointer. */ 214 #define IS_ARRAY_NOT_POINTER(arg) \ 215 (!__builtin_types_compatible_p(__typeof__(arg), \ 216 __typeof__(&(arg)[0]))) 217 /* A compile-time constant with the value 0. If `const_expr` is not a 218 * compile-time constant with a nonzero value, cause a compile-time error. */ 219 #define STATIC_ASSERT_EXPR(const_expr) \ 220 (0 && sizeof(struct { unsigned int STATIC_ASSERT : 1 - 2 * !(const_expr); })) 221 222 /* Return the scalar value `value` (possibly promoted). This is a compile-time 223 * constant if `value` is. `condition` must be a compile-time constant. 224 * If `condition` is false, arrange to cause a compile-time error. */ 225 #define STATIC_ASSERT_THEN_RETURN(condition, value) \ 226 (STATIC_ASSERT_EXPR(condition) ? 0 : (value)) 227 228 #define ARRAY_LENGTH(array) \ 229 (STATIC_ASSERT_THEN_RETURN(IS_ARRAY_NOT_POINTER(array), \ 230 ARRAY_LENGTH_UNSAFE(array))) 231 232 #else 233 /* If we aren't sure the compiler supports our non-standard tricks, 234 * fall back to the unsafe implementation. */ 235 #define ARRAY_LENGTH(array) ARRAY_LENGTH_UNSAFE(array) 236 #endif 237 238 /** Return the smaller of two values. 239 * 240 * \param x An integer-valued expression without side effects. 241 * \param y An integer-valued expression without side effects. 242 * 243 * \return The smaller of \p x and \p y. 244 */ 245 #define MIN(x, y) ((x) < (y) ? (x) : (y)) 246 247 /** Return the larger of two values. 248 * 249 * \param x An integer-valued expression without side effects. 250 * \param y An integer-valued expression without side effects. 251 * 252 * \return The larger of \p x and \p y. 253 */ 254 #define MAX(x, y) ((x) > (y) ? (x) : (y)) 255 256 #endif /* TEST_MACROS_H */ 257