blob: 7b4c2f6c98bbb5669766a3a387b2a33ca6f74f88 [file] [log] [blame]
Ronald Cron4b8b1992020-06-09 13:52:23 +02001/**
2 * \file macros.h
3 *
4 * \brief This file contains generic macros for the purpose of testing.
5 */
6
Bence Szépkúti86974652020-06-15 11:59:37 +02007/*
Bence Szépkúti1e148272020-08-07 13:07:28 +02008 * Copyright The Mbed TLS Contributors
Ronald Cron4b8b1992020-06-09 13:52:23 +02009 * 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.
Ronald Cron4b8b1992020-06-09 13:52:23 +020022 */
23
24#ifndef TEST_MACROS_H
25#define TEST_MACROS_H
26
27#if !defined(MBEDTLS_CONFIG_FILE)
28#include "mbedtls/config.h"
29#else
30#include MBEDTLS_CONFIG_FILE
31#endif
32
Ronald Cron849930a2020-06-03 08:06:47 +020033#include <stdlib.h>
34
35#if defined(MBEDTLS_PLATFORM_C)
36#include "mbedtls/platform.h"
37#else
38#include <stdio.h>
39#define mbedtls_fprintf fprintf
40#define mbedtls_snprintf snprintf
41#define mbedtls_calloc calloc
42#define mbedtls_free free
43#define mbedtls_exit exit
44#define mbedtls_time time
45#define mbedtls_time_t time_t
46#define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
47#define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
48#endif
49
50#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
51#include "mbedtls/memory_buffer_alloc.h"
52#endif
53
Chris Jonesa6d155f2021-02-09 12:09:33 +000054/**
55 * \brief This macro tests the expression passed to it as a test step or
56 * individual test in a test case.
57 *
58 * It allows a library function to return a value and return an error
59 * code that can be tested.
60 *
61 * When MBEDTLS_CHECK_PARAMS is enabled, calls to the parameter failure
62 * callback, MBEDTLS_PARAM_FAILED(), will be assumed to be a test
63 * failure.
64 *
65 * This macro is not suitable for negative parameter validation tests,
66 * as it assumes the test step will not create an error.
67 *
68 * Failing the test means:
69 * - Mark this test case as failed.
70 * - Print a message identifying the failure.
71 * - Jump to the \c exit label.
72 *
73 * This macro expands to an instruction, not an expression.
74 * It may jump to the \c exit label.
75 *
76 * \param TEST The test expression to be tested.
77 */
78#define TEST_ASSERT( TEST ) \
79 do { \
80 if( ! (TEST) ) \
81 { \
82 mbedtls_test_fail( #TEST, __LINE__, __FILE__ ); \
83 goto exit; \
84 } \
85 } while( 0 )
86
Gilles Peskineb4366492021-04-29 20:28:54 +020087/** Evaluate two integer expressions and fail the test case if they have
88 * different values.
Chris Jonesa6d155f2021-02-09 12:09:33 +000089 *
Gilles Peskineb4366492021-04-29 20:28:54 +020090 * The two expressions should have the same signedness, otherwise the
91 * comparison is not meaningful if the signed value is negative.
92 *
93 * \param expr1 An integral-typed expression to evaluate.
94 * \param expr2 Another integral-typed expression to evaluate.
Chris Jonesa6d155f2021-02-09 12:09:33 +000095 */
Gilles Peskineb4366492021-04-29 20:28:54 +020096#define TEST_EQUAL( expr1, expr2 ) \
97 do { \
98 if( ! mbedtls_test_equal( #expr1 " == " #expr2, __LINE__, __FILE__, \
99 expr1, expr2 ) ) \
100 goto exit; \
101 } while( 0 )
Chris Jonesa6d155f2021-02-09 12:09:33 +0000102
103/** Allocate memory dynamically and fail the test case if this fails.
104 * The allocated memory will be filled with zeros.
105 *
106 * You must set \p pointer to \c NULL before calling this macro and
107 * put `mbedtls_free( pointer )` in the test's cleanup code.
108 *
109 * If \p length is zero, the resulting \p pointer will be \c NULL.
110 * This is usually what we want in tests since API functions are
111 * supposed to accept null pointers when a buffer size is zero.
112 *
113 * This macro expands to an instruction, not an expression.
114 * It may jump to the \c exit label.
115 *
116 * \param pointer An lvalue where the address of the allocated buffer
117 * will be stored.
118 * This expression may be evaluated multiple times.
119 * \param length Number of elements to allocate.
120 * This expression may be evaluated multiple times.
121 *
122 */
123#define ASSERT_ALLOC( pointer, length ) \
124 do \
125 { \
126 TEST_ASSERT( ( pointer ) == NULL ); \
127 if( ( length ) != 0 ) \
128 { \
129 ( pointer ) = mbedtls_calloc( sizeof( *( pointer ) ), \
130 ( length ) ); \
131 TEST_ASSERT( ( pointer ) != NULL ); \
132 } \
133 } \
134 while( 0 )
135
136/** Allocate memory dynamically. If the allocation fails, skip the test case.
137 *
138 * This macro behaves like #ASSERT_ALLOC, except that if the allocation
139 * fails, it marks the test as skipped rather than failed.
140 */
141#define ASSERT_ALLOC_WEAK( pointer, length ) \
142 do \
143 { \
144 TEST_ASSERT( ( pointer ) == NULL ); \
145 if( ( length ) != 0 ) \
146 { \
147 ( pointer ) = mbedtls_calloc( sizeof( *( pointer ) ), \
148 ( length ) ); \
149 TEST_ASSUME( ( pointer ) != NULL ); \
150 } \
151 } \
152 while( 0 )
153
154/** Compare two buffers and fail the test case if they differ.
155 *
156 * This macro expands to an instruction, not an expression.
157 * It may jump to the \c exit label.
158 *
159 * \param p1 Pointer to the start of the first buffer.
160 * \param size1 Size of the first buffer in bytes.
161 * This expression may be evaluated multiple times.
162 * \param p2 Pointer to the start of the second buffer.
163 * \param size2 Size of the second buffer in bytes.
164 * This expression may be evaluated multiple times.
165 */
166#define ASSERT_COMPARE( p1, size1, p2, size2 ) \
167 do \
168 { \
169 TEST_ASSERT( ( size1 ) == ( size2 ) ); \
170 if( ( size1 ) != 0 ) \
171 TEST_ASSERT( memcmp( ( p1 ), ( p2 ), ( size1 ) ) == 0 ); \
172 } \
173 while( 0 )
174
175/**
176 * \brief This macro tests the expression passed to it and skips the
177 * running test if it doesn't evaluate to 'true'.
178 *
179 * \param TEST The test expression to be tested.
180 */
181#define TEST_ASSUME( TEST ) \
182 do { \
183 if( ! (TEST) ) \
184 { \
185 mbedtls_test_skip( #TEST, __LINE__, __FILE__ ); \
186 goto exit; \
187 } \
188 } while( 0 )
189
190#if defined(MBEDTLS_CHECK_PARAMS) && !defined(MBEDTLS_PARAM_FAILED_ALT)
191/**
192 * \brief This macro tests the statement passed to it as a test step or
193 * individual test in a test case. The macro assumes the test will fail
194 * and will generate an error.
195 *
196 * It allows a library function to return a value and tests the return
197 * code on return to confirm the given error code was returned.
198 *
199 * When MBEDTLS_CHECK_PARAMS is enabled, calls to the parameter failure
200 * callback, MBEDTLS_PARAM_FAILED(), are assumed to indicate the
201 * expected failure, and the test will pass.
202 *
203 * This macro is intended for negative parameter validation tests,
204 * where the failing function may return an error value or call
205 * MBEDTLS_PARAM_FAILED() to indicate the error.
206 *
207 * \param PARAM_ERROR_VALUE The expected error code.
208 *
209 * \param TEST The test expression to be tested.
210 */
211#define TEST_INVALID_PARAM_RET( PARAM_ERR_VALUE, TEST ) \
212 do { \
213 mbedtls_test_param_failed_expect_call( ); \
214 if( ( ( TEST ) != ( PARAM_ERR_VALUE ) ) || \
215 ( mbedtls_test_param_failed_check_expected_call( ) != 0 ) ) \
216 { \
217 mbedtls_test_fail( #TEST, __LINE__, __FILE__ ); \
218 goto exit; \
219 } \
220 mbedtls_test_param_failed_check_expected_call( ); \
221 } while( 0 )
222
223/**
224 * \brief This macro tests the statement passed to it as a test step or
225 * individual test in a test case. The macro assumes the test will fail
226 * and will generate an error.
227 *
228 * It assumes the library function under test cannot return a value and
229 * assumes errors can only be indicated byt calls to
230 * MBEDTLS_PARAM_FAILED().
231 *
232 * When MBEDTLS_CHECK_PARAMS is enabled, calls to the parameter failure
233 * callback, MBEDTLS_PARAM_FAILED(), are assumed to indicate the
234 * expected failure. If MBEDTLS_CHECK_PARAMS is not enabled, no test
235 * can be made.
236 *
237 * This macro is intended for negative parameter validation tests,
238 * where the failing function can only return an error by calling
239 * MBEDTLS_PARAM_FAILED() to indicate the error.
240 *
241 * \param TEST The test expression to be tested.
242 */
243#define TEST_INVALID_PARAM( TEST ) \
244 do { \
245 memcpy( jmp_tmp, mbedtls_test_param_failed_get_state_buf( ), \
246 sizeof( jmp_tmp ) ); \
247 if( setjmp( mbedtls_test_param_failed_get_state_buf( ) ) == 0 ) \
248 { \
249 TEST; \
250 mbedtls_test_fail( #TEST, __LINE__, __FILE__ ); \
251 goto exit; \
252 } \
253 mbedtls_test_param_failed_reset_state( ); \
254 } while( 0 )
255#endif /* MBEDTLS_CHECK_PARAMS && !MBEDTLS_PARAM_FAILED_ALT */
256
257/**
258 * \brief This macro tests the statement passed to it as a test step or
259 * individual test in a test case. The macro assumes the test will not fail.
260 *
261 * It assumes the library function under test cannot return a value and
262 * assumes errors can only be indicated by calls to
263 * MBEDTLS_PARAM_FAILED().
264 *
265 * When MBEDTLS_CHECK_PARAMS is enabled, calls to the parameter failure
266 * callback, MBEDTLS_PARAM_FAILED(), are assumed to indicate the
267 * expected failure. If MBEDTLS_CHECK_PARAMS is not enabled, no test
268 * can be made.
269 *
270 * This macro is intended to test that functions returning void
271 * accept all of the parameter values they're supposed to accept - eg
272 * that they don't call MBEDTLS_PARAM_FAILED() when a parameter
273 * that's allowed to be NULL happens to be NULL.
274 *
275 * Note: for functions that return something other that void,
276 * checking that they accept all the parameters they're supposed to
277 * accept is best done by using TEST_ASSERT() and checking the return
278 * value as well.
279 *
280 * Note: this macro is available even when #MBEDTLS_CHECK_PARAMS is
281 * disabled, as it makes sense to check that the functions accept all
282 * legal values even if this option is disabled - only in that case,
283 * the test is more about whether the function segfaults than about
284 * whether it invokes MBEDTLS_PARAM_FAILED().
285 *
286 * \param TEST The test expression to be tested.
287 */
288#define TEST_VALID_PARAM( TEST ) \
289 TEST_ASSERT( ( TEST, 1 ) );
290
Ronald Cron849930a2020-06-03 08:06:47 +0200291#define TEST_HELPER_ASSERT(a) if( !( a ) ) \
292{ \
293 mbedtls_fprintf( stderr, "Assertion Failed at %s:%d - %s\n", \
294 __FILE__, __LINE__, #a ); \
295 mbedtls_exit( 1 ); \
296}
297
Gilles Peskinec86a1652021-02-15 12:17:00 +0100298/** \def ARRAY_LENGTH
299 * Return the number of elements of a static or stack array.
300 *
301 * \param array A value of array (not pointer) type.
302 *
303 * \return The number of elements of the array.
304 */
305/* A correct implementation of ARRAY_LENGTH, but which silently gives
306 * a nonsensical result if called with a pointer rather than an array. */
307#define ARRAY_LENGTH_UNSAFE( array ) \
308 ( sizeof( array ) / sizeof( *( array ) ) )
309
Ronald Cron849930a2020-06-03 08:06:47 +0200310#if defined(__GNUC__)
311/* Test if arg and &(arg)[0] have the same type. This is true if arg is
312 * an array but not if it's a pointer. */
313#define IS_ARRAY_NOT_POINTER( arg ) \
314 ( ! __builtin_types_compatible_p( __typeof__( arg ), \
315 __typeof__( &( arg )[0] ) ) )
Ronald Cron849930a2020-06-03 08:06:47 +0200316/* A compile-time constant with the value 0. If `const_expr` is not a
317 * compile-time constant with a nonzero value, cause a compile-time error. */
318#define STATIC_ASSERT_EXPR( const_expr ) \
makise-homurae74f3722020-08-18 23:57:48 +0300319 ( 0 && sizeof( struct { unsigned int STATIC_ASSERT : 1 - 2 * ! ( const_expr ); } ) )
Gilles Peskinec86a1652021-02-15 12:17:00 +0100320
Ronald Cron849930a2020-06-03 08:06:47 +0200321/* Return the scalar value `value` (possibly promoted). This is a compile-time
322 * constant if `value` is. `condition` must be a compile-time constant.
323 * If `condition` is false, arrange to cause a compile-time error. */
324#define STATIC_ASSERT_THEN_RETURN( condition, value ) \
325 ( STATIC_ASSERT_EXPR( condition ) ? 0 : ( value ) )
326
Ronald Cron849930a2020-06-03 08:06:47 +0200327#define ARRAY_LENGTH( array ) \
328 ( STATIC_ASSERT_THEN_RETURN( IS_ARRAY_NOT_POINTER( array ), \
329 ARRAY_LENGTH_UNSAFE( array ) ) )
330
Gilles Peskinec86a1652021-02-15 12:17:00 +0100331#else
332/* If we aren't sure the compiler supports our non-standard tricks,
333 * fall back to the unsafe implementation. */
334#define ARRAY_LENGTH( array ) ARRAY_LENGTH_UNSAFE( array )
335#endif
336
Ronald Cron849930a2020-06-03 08:06:47 +0200337/** Return the smaller of two values.
338 *
339 * \param x An integer-valued expression without side effects.
340 * \param y An integer-valued expression without side effects.
341 *
342 * \return The smaller of \p x and \p y.
343 */
344#define MIN( x, y ) ( ( x ) < ( y ) ? ( x ) : ( y ) )
345
346/** Return the larger of two values.
347 *
348 * \param x An integer-valued expression without side effects.
349 * \param y An integer-valued expression without side effects.
350 *
351 * \return The larger of \p x and \p y.
352 */
353#define MAX( x, y ) ( ( x ) > ( y ) ? ( x ) : ( y ) )
354
355/*
356 * 32-bit integer manipulation macros (big endian)
357 */
358#ifndef GET_UINT32_BE
359#define GET_UINT32_BE(n,b,i) \
360{ \
361 (n) = ( (uint32_t) (b)[(i) ] << 24 ) \
362 | ( (uint32_t) (b)[(i) + 1] << 16 ) \
363 | ( (uint32_t) (b)[(i) + 2] << 8 ) \
364 | ( (uint32_t) (b)[(i) + 3] ); \
365}
366#endif
367
368#ifndef PUT_UINT32_BE
369#define PUT_UINT32_BE(n,b,i) \
370{ \
371 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
372 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
373 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
374 (b)[(i) + 3] = (unsigned char) ( (n) ); \
375}
376#endif
377
Ronald Cron4b8b1992020-06-09 13:52:23 +0200378#endif /* TEST_MACROS_H */