1
2 /*
3 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License").
6 * You may not use this file except in compliance with the License.
7 * A copy of the License is located at
8 *
9 * http://aws.amazon.com/apache2.0
10 *
11 * or in the "license" file accompanying this file. This file is distributed
12 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied. See the License for the specific language governing
14 * permissions and limitations under the License.
15 */
16
17 #include "s2n_test.h"
18
19 #include "utils/s2n_safety.h"
20
21 /**
22 * DO NOT DIRECTLY MODIFY THIS FILE:
23 *
24 * The code in this file is generated from scripts/s2n_safety_macros.py and any modifications
25 * should be in there.
26 */
27
28 /* harnesses */
29
RESULT_BAIL_harness()30 static s2n_result RESULT_BAIL_harness()
31 {
32 RESULT_BAIL(S2N_ERR_SAFETY);
33 return S2N_RESULT_OK;
34 }
35
RESULT_ENSURE_harness(bool is_ok)36 static s2n_result RESULT_ENSURE_harness(bool is_ok)
37 {
38 RESULT_ENSURE(is_ok, S2N_ERR_SAFETY);
39 return S2N_RESULT_OK;
40 }
41
RESULT_DEBUG_ENSURE_harness(bool is_ok)42 static s2n_result RESULT_DEBUG_ENSURE_harness(bool is_ok)
43 {
44 RESULT_DEBUG_ENSURE(is_ok, S2N_ERR_SAFETY);
45 return S2N_RESULT_OK;
46 }
47
RESULT_ENSURE_OK_harness(bool is_ok)48 static s2n_result RESULT_ENSURE_OK_harness(bool is_ok)
49 {
50 RESULT_ENSURE_OK(RESULT_ENSURE_harness(is_ok), S2N_ERR_IO);
51 return S2N_RESULT_OK;
52 }
53
RESULT_ENSURE_GTE_harness_uint32(uint32_t a,uint32_t b)54 static s2n_result RESULT_ENSURE_GTE_harness_uint32(uint32_t a, uint32_t b)
55 {
56 RESULT_ENSURE_GTE(a, b);
57 /* test the inverse */
58 RESULT_ENSURE_LTE(b, a);
59 return S2N_RESULT_OK;
60 }
61
RESULT_ENSURE_GTE_harness_int32(int32_t a,int32_t b)62 static s2n_result RESULT_ENSURE_GTE_harness_int32(int32_t a, int32_t b)
63 {
64 RESULT_ENSURE_GTE(a, b);
65 /* test the inverse */
66 RESULT_ENSURE_LTE(b, a);
67 return S2N_RESULT_OK;
68 }
69
RESULT_ENSURE_LTE_harness_uint32(uint32_t a,uint32_t b)70 static s2n_result RESULT_ENSURE_LTE_harness_uint32(uint32_t a, uint32_t b)
71 {
72 RESULT_ENSURE_LTE(a, b);
73 /* test the inverse */
74 RESULT_ENSURE_GTE(b, a);
75 return S2N_RESULT_OK;
76 }
77
RESULT_ENSURE_LTE_harness_int32(int32_t a,int32_t b)78 static s2n_result RESULT_ENSURE_LTE_harness_int32(int32_t a, int32_t b)
79 {
80 RESULT_ENSURE_LTE(a, b);
81 /* test the inverse */
82 RESULT_ENSURE_GTE(b, a);
83 return S2N_RESULT_OK;
84 }
85
RESULT_ENSURE_GT_harness_uint32(uint32_t a,uint32_t b)86 static s2n_result RESULT_ENSURE_GT_harness_uint32(uint32_t a, uint32_t b)
87 {
88 RESULT_ENSURE_GT(a, b);
89 /* test the inverse */
90 RESULT_ENSURE_LT(b, a);
91 return S2N_RESULT_OK;
92 }
93
RESULT_ENSURE_GT_harness_int32(int32_t a,int32_t b)94 static s2n_result RESULT_ENSURE_GT_harness_int32(int32_t a, int32_t b)
95 {
96 RESULT_ENSURE_GT(a, b);
97 /* test the inverse */
98 RESULT_ENSURE_LT(b, a);
99 return S2N_RESULT_OK;
100 }
101
RESULT_ENSURE_LT_harness_uint32(uint32_t a,uint32_t b)102 static s2n_result RESULT_ENSURE_LT_harness_uint32(uint32_t a, uint32_t b)
103 {
104 RESULT_ENSURE_LT(a, b);
105 /* test the inverse */
106 RESULT_ENSURE_GT(b, a);
107 return S2N_RESULT_OK;
108 }
109
RESULT_ENSURE_LT_harness_int32(int32_t a,int32_t b)110 static s2n_result RESULT_ENSURE_LT_harness_int32(int32_t a, int32_t b)
111 {
112 RESULT_ENSURE_LT(a, b);
113 /* test the inverse */
114 RESULT_ENSURE_GT(b, a);
115 return S2N_RESULT_OK;
116 }
117
RESULT_ENSURE_EQ_harness_uint32(uint32_t a,uint32_t b)118 static s2n_result RESULT_ENSURE_EQ_harness_uint32(uint32_t a, uint32_t b)
119 {
120 RESULT_ENSURE_EQ(a, b);
121 RESULT_ENSURE_EQ(b, a);
122 return S2N_RESULT_OK;
123 }
124
RESULT_ENSURE_EQ_harness_int32(int32_t a,int32_t b)125 static s2n_result RESULT_ENSURE_EQ_harness_int32(int32_t a, int32_t b)
126 {
127 RESULT_ENSURE_EQ(a, b);
128 RESULT_ENSURE_EQ(b, a);
129 return S2N_RESULT_OK;
130 }
131
RESULT_ENSURE_NE_harness_uint32(uint32_t a,uint32_t b)132 static s2n_result RESULT_ENSURE_NE_harness_uint32(uint32_t a, uint32_t b)
133 {
134 RESULT_ENSURE_NE(a, b);
135 RESULT_ENSURE_NE(b, a);
136 return S2N_RESULT_OK;
137 }
138
RESULT_ENSURE_NE_harness_int32(int32_t a,int32_t b)139 static s2n_result RESULT_ENSURE_NE_harness_int32(int32_t a, int32_t b)
140 {
141 RESULT_ENSURE_NE(a, b);
142 RESULT_ENSURE_NE(b, a);
143 return S2N_RESULT_OK;
144 }
145
RESULT_ENSURE_INCLUSIVE_RANGE_harness_uint32(uint32_t a,uint32_t b,uint32_t c)146 static s2n_result RESULT_ENSURE_INCLUSIVE_RANGE_harness_uint32(uint32_t a, uint32_t b, uint32_t c)
147 {
148 RESULT_ENSURE_INCLUSIVE_RANGE(a, b, c);
149 return S2N_RESULT_OK;
150 }
151
RESULT_ENSURE_INCLUSIVE_RANGE_harness_int32(int32_t a,int32_t b,int32_t c)152 static s2n_result RESULT_ENSURE_INCLUSIVE_RANGE_harness_int32(int32_t a, int32_t b, int32_t c)
153 {
154 RESULT_ENSURE_INCLUSIVE_RANGE(a, b, c);
155 return S2N_RESULT_OK;
156 }
157
RESULT_ENSURE_EXCLUSIVE_RANGE_harness_uint32(uint32_t a,uint32_t b,uint32_t c)158 static s2n_result RESULT_ENSURE_EXCLUSIVE_RANGE_harness_uint32(uint32_t a, uint32_t b, uint32_t c)
159 {
160 RESULT_ENSURE_EXCLUSIVE_RANGE(a, b, c);
161 return S2N_RESULT_OK;
162 }
163
RESULT_ENSURE_EXCLUSIVE_RANGE_harness_int32(int32_t a,int32_t b,int32_t c)164 static s2n_result RESULT_ENSURE_EXCLUSIVE_RANGE_harness_int32(int32_t a, int32_t b, int32_t c)
165 {
166 RESULT_ENSURE_EXCLUSIVE_RANGE(a, b, c);
167 return S2N_RESULT_OK;
168 }
169
RESULT_ENSURE_REF_harness(const char * str)170 static s2n_result RESULT_ENSURE_REF_harness(const char* str)
171 {
172 RESULT_ENSURE_REF(str);
173 return S2N_RESULT_OK;
174 }
175
RESULT_ENSURE_MUT_harness(uint32_t * v)176 static s2n_result RESULT_ENSURE_MUT_harness(uint32_t* v)
177 {
178 RESULT_ENSURE_MUT(v);
179 return S2N_RESULT_OK;
180 }
181
RESULT_PRECONDITION_harness_check(bool is_ok)182 static S2N_RESULT RESULT_PRECONDITION_harness_check(bool is_ok)
183 {
184 RESULT_ENSURE(is_ok, S2N_ERR_SAFETY);
185 return S2N_RESULT_OK;
186 }
187
RESULT_PRECONDITION_harness(s2n_result result)188 static s2n_result RESULT_PRECONDITION_harness(s2n_result result)
189 {
190 RESULT_PRECONDITION(result);
191 return S2N_RESULT_OK;
192 }
193
RESULT_POSTCONDITION_harness_check(bool is_ok)194 static S2N_RESULT RESULT_POSTCONDITION_harness_check(bool is_ok)
195 {
196 RESULT_ENSURE(is_ok, S2N_ERR_SAFETY);
197 return S2N_RESULT_OK;
198 }
199
RESULT_POSTCONDITION_harness(s2n_result result)200 static s2n_result RESULT_POSTCONDITION_harness(s2n_result result)
201 {
202 RESULT_POSTCONDITION(result);
203 return S2N_RESULT_OK;
204 }
205
RESULT_CHECKED_MEMCPY_harness(uint32_t * dest,uint32_t * source,size_t len)206 static s2n_result RESULT_CHECKED_MEMCPY_harness(uint32_t* dest, uint32_t* source, size_t len)
207 {
208 RESULT_CHECKED_MEMCPY(dest, source, len);
209 return S2N_RESULT_OK;
210 }
211
RESULT_CHECKED_MEMSET_harness(uint32_t * dest,uint8_t value,size_t len)212 static s2n_result RESULT_CHECKED_MEMSET_harness(uint32_t* dest, uint8_t value, size_t len)
213 {
214 RESULT_CHECKED_MEMSET(dest, value, len);
215 return S2N_RESULT_OK;
216 }
217
RESULT_GUARD_harness(s2n_result result)218 static s2n_result RESULT_GUARD_harness(s2n_result result)
219 {
220 RESULT_GUARD(result);
221 return S2N_RESULT_OK;
222 }
223
RESULT_GUARD_OSSL_harness(int result,int error)224 static s2n_result RESULT_GUARD_OSSL_harness(int result, int error)
225 {
226 RESULT_GUARD_OSSL(result, error);
227 return S2N_RESULT_OK;
228 }
229
POSIX_BAIL_harness()230 static int POSIX_BAIL_harness()
231 {
232 POSIX_BAIL(S2N_ERR_SAFETY);
233 return S2N_SUCCESS;
234 }
235
POSIX_ENSURE_harness(bool is_ok)236 static int POSIX_ENSURE_harness(bool is_ok)
237 {
238 POSIX_ENSURE(is_ok, S2N_ERR_SAFETY);
239 return S2N_SUCCESS;
240 }
241
POSIX_DEBUG_ENSURE_harness(bool is_ok)242 static int POSIX_DEBUG_ENSURE_harness(bool is_ok)
243 {
244 POSIX_DEBUG_ENSURE(is_ok, S2N_ERR_SAFETY);
245 return S2N_SUCCESS;
246 }
247
POSIX_ENSURE_OK_harness(bool is_ok)248 static int POSIX_ENSURE_OK_harness(bool is_ok)
249 {
250 POSIX_ENSURE_OK(POSIX_ENSURE_harness(is_ok), S2N_ERR_IO);
251 return S2N_SUCCESS;
252 }
253
POSIX_ENSURE_GTE_harness_uint32(uint32_t a,uint32_t b)254 static int POSIX_ENSURE_GTE_harness_uint32(uint32_t a, uint32_t b)
255 {
256 POSIX_ENSURE_GTE(a, b);
257 /* test the inverse */
258 POSIX_ENSURE_LTE(b, a);
259 return S2N_SUCCESS;
260 }
261
POSIX_ENSURE_GTE_harness_int32(int32_t a,int32_t b)262 static int POSIX_ENSURE_GTE_harness_int32(int32_t a, int32_t b)
263 {
264 POSIX_ENSURE_GTE(a, b);
265 /* test the inverse */
266 POSIX_ENSURE_LTE(b, a);
267 return S2N_SUCCESS;
268 }
269
POSIX_ENSURE_LTE_harness_uint32(uint32_t a,uint32_t b)270 static int POSIX_ENSURE_LTE_harness_uint32(uint32_t a, uint32_t b)
271 {
272 POSIX_ENSURE_LTE(a, b);
273 /* test the inverse */
274 POSIX_ENSURE_GTE(b, a);
275 return S2N_SUCCESS;
276 }
277
POSIX_ENSURE_LTE_harness_int32(int32_t a,int32_t b)278 static int POSIX_ENSURE_LTE_harness_int32(int32_t a, int32_t b)
279 {
280 POSIX_ENSURE_LTE(a, b);
281 /* test the inverse */
282 POSIX_ENSURE_GTE(b, a);
283 return S2N_SUCCESS;
284 }
285
POSIX_ENSURE_GT_harness_uint32(uint32_t a,uint32_t b)286 static int POSIX_ENSURE_GT_harness_uint32(uint32_t a, uint32_t b)
287 {
288 POSIX_ENSURE_GT(a, b);
289 /* test the inverse */
290 POSIX_ENSURE_LT(b, a);
291 return S2N_SUCCESS;
292 }
293
POSIX_ENSURE_GT_harness_int32(int32_t a,int32_t b)294 static int POSIX_ENSURE_GT_harness_int32(int32_t a, int32_t b)
295 {
296 POSIX_ENSURE_GT(a, b);
297 /* test the inverse */
298 POSIX_ENSURE_LT(b, a);
299 return S2N_SUCCESS;
300 }
301
POSIX_ENSURE_LT_harness_uint32(uint32_t a,uint32_t b)302 static int POSIX_ENSURE_LT_harness_uint32(uint32_t a, uint32_t b)
303 {
304 POSIX_ENSURE_LT(a, b);
305 /* test the inverse */
306 POSIX_ENSURE_GT(b, a);
307 return S2N_SUCCESS;
308 }
309
POSIX_ENSURE_LT_harness_int32(int32_t a,int32_t b)310 static int POSIX_ENSURE_LT_harness_int32(int32_t a, int32_t b)
311 {
312 POSIX_ENSURE_LT(a, b);
313 /* test the inverse */
314 POSIX_ENSURE_GT(b, a);
315 return S2N_SUCCESS;
316 }
317
POSIX_ENSURE_EQ_harness_uint32(uint32_t a,uint32_t b)318 static int POSIX_ENSURE_EQ_harness_uint32(uint32_t a, uint32_t b)
319 {
320 POSIX_ENSURE_EQ(a, b);
321 POSIX_ENSURE_EQ(b, a);
322 return S2N_SUCCESS;
323 }
324
POSIX_ENSURE_EQ_harness_int32(int32_t a,int32_t b)325 static int POSIX_ENSURE_EQ_harness_int32(int32_t a, int32_t b)
326 {
327 POSIX_ENSURE_EQ(a, b);
328 POSIX_ENSURE_EQ(b, a);
329 return S2N_SUCCESS;
330 }
331
POSIX_ENSURE_NE_harness_uint32(uint32_t a,uint32_t b)332 static int POSIX_ENSURE_NE_harness_uint32(uint32_t a, uint32_t b)
333 {
334 POSIX_ENSURE_NE(a, b);
335 POSIX_ENSURE_NE(b, a);
336 return S2N_SUCCESS;
337 }
338
POSIX_ENSURE_NE_harness_int32(int32_t a,int32_t b)339 static int POSIX_ENSURE_NE_harness_int32(int32_t a, int32_t b)
340 {
341 POSIX_ENSURE_NE(a, b);
342 POSIX_ENSURE_NE(b, a);
343 return S2N_SUCCESS;
344 }
345
POSIX_ENSURE_INCLUSIVE_RANGE_harness_uint32(uint32_t a,uint32_t b,uint32_t c)346 static int POSIX_ENSURE_INCLUSIVE_RANGE_harness_uint32(uint32_t a, uint32_t b, uint32_t c)
347 {
348 POSIX_ENSURE_INCLUSIVE_RANGE(a, b, c);
349 return S2N_SUCCESS;
350 }
351
POSIX_ENSURE_INCLUSIVE_RANGE_harness_int32(int32_t a,int32_t b,int32_t c)352 static int POSIX_ENSURE_INCLUSIVE_RANGE_harness_int32(int32_t a, int32_t b, int32_t c)
353 {
354 POSIX_ENSURE_INCLUSIVE_RANGE(a, b, c);
355 return S2N_SUCCESS;
356 }
357
POSIX_ENSURE_EXCLUSIVE_RANGE_harness_uint32(uint32_t a,uint32_t b,uint32_t c)358 static int POSIX_ENSURE_EXCLUSIVE_RANGE_harness_uint32(uint32_t a, uint32_t b, uint32_t c)
359 {
360 POSIX_ENSURE_EXCLUSIVE_RANGE(a, b, c);
361 return S2N_SUCCESS;
362 }
363
POSIX_ENSURE_EXCLUSIVE_RANGE_harness_int32(int32_t a,int32_t b,int32_t c)364 static int POSIX_ENSURE_EXCLUSIVE_RANGE_harness_int32(int32_t a, int32_t b, int32_t c)
365 {
366 POSIX_ENSURE_EXCLUSIVE_RANGE(a, b, c);
367 return S2N_SUCCESS;
368 }
369
POSIX_ENSURE_REF_harness(const char * str)370 static int POSIX_ENSURE_REF_harness(const char* str)
371 {
372 POSIX_ENSURE_REF(str);
373 return S2N_SUCCESS;
374 }
375
POSIX_ENSURE_MUT_harness(uint32_t * v)376 static int POSIX_ENSURE_MUT_harness(uint32_t* v)
377 {
378 POSIX_ENSURE_MUT(v);
379 return S2N_SUCCESS;
380 }
381
POSIX_PRECONDITION_harness_check(bool is_ok)382 static S2N_RESULT POSIX_PRECONDITION_harness_check(bool is_ok)
383 {
384 RESULT_ENSURE(is_ok, S2N_ERR_SAFETY);
385 return S2N_RESULT_OK;
386 }
387
POSIX_PRECONDITION_harness(s2n_result result)388 static int POSIX_PRECONDITION_harness(s2n_result result)
389 {
390 POSIX_PRECONDITION(result);
391 return S2N_SUCCESS;
392 }
393
POSIX_POSTCONDITION_harness_check(bool is_ok)394 static S2N_RESULT POSIX_POSTCONDITION_harness_check(bool is_ok)
395 {
396 RESULT_ENSURE(is_ok, S2N_ERR_SAFETY);
397 return S2N_RESULT_OK;
398 }
399
POSIX_POSTCONDITION_harness(s2n_result result)400 static int POSIX_POSTCONDITION_harness(s2n_result result)
401 {
402 POSIX_POSTCONDITION(result);
403 return S2N_SUCCESS;
404 }
405
POSIX_CHECKED_MEMCPY_harness(uint32_t * dest,uint32_t * source,size_t len)406 static int POSIX_CHECKED_MEMCPY_harness(uint32_t* dest, uint32_t* source, size_t len)
407 {
408 POSIX_CHECKED_MEMCPY(dest, source, len);
409 return S2N_SUCCESS;
410 }
411
POSIX_CHECKED_MEMSET_harness(uint32_t * dest,uint8_t value,size_t len)412 static int POSIX_CHECKED_MEMSET_harness(uint32_t* dest, uint8_t value, size_t len)
413 {
414 POSIX_CHECKED_MEMSET(dest, value, len);
415 return S2N_SUCCESS;
416 }
417
POSIX_GUARD_harness(int result)418 static int POSIX_GUARD_harness(int result)
419 {
420 POSIX_GUARD(result);
421 return S2N_SUCCESS;
422 }
423
POSIX_GUARD_OSSL_harness(int result,int error)424 static int POSIX_GUARD_OSSL_harness(int result, int error)
425 {
426 POSIX_GUARD_OSSL(result, error);
427 return S2N_SUCCESS;
428 }
429
PTR_BAIL_harness()430 static const char* PTR_BAIL_harness()
431 {
432 PTR_BAIL(S2N_ERR_SAFETY);
433 return "ok";
434 }
435
PTR_ENSURE_harness(bool is_ok)436 static const char* PTR_ENSURE_harness(bool is_ok)
437 {
438 PTR_ENSURE(is_ok, S2N_ERR_SAFETY);
439 return "ok";
440 }
441
PTR_DEBUG_ENSURE_harness(bool is_ok)442 static const char* PTR_DEBUG_ENSURE_harness(bool is_ok)
443 {
444 PTR_DEBUG_ENSURE(is_ok, S2N_ERR_SAFETY);
445 return "ok";
446 }
447
PTR_ENSURE_OK_harness(bool is_ok)448 static const char* PTR_ENSURE_OK_harness(bool is_ok)
449 {
450 PTR_ENSURE_OK(PTR_ENSURE_harness(is_ok), S2N_ERR_IO);
451 return "ok";
452 }
453
PTR_ENSURE_GTE_harness_uint32(uint32_t a,uint32_t b)454 static const char* PTR_ENSURE_GTE_harness_uint32(uint32_t a, uint32_t b)
455 {
456 PTR_ENSURE_GTE(a, b);
457 /* test the inverse */
458 PTR_ENSURE_LTE(b, a);
459 return "ok";
460 }
461
PTR_ENSURE_GTE_harness_int32(int32_t a,int32_t b)462 static const char* PTR_ENSURE_GTE_harness_int32(int32_t a, int32_t b)
463 {
464 PTR_ENSURE_GTE(a, b);
465 /* test the inverse */
466 PTR_ENSURE_LTE(b, a);
467 return "ok";
468 }
469
PTR_ENSURE_LTE_harness_uint32(uint32_t a,uint32_t b)470 static const char* PTR_ENSURE_LTE_harness_uint32(uint32_t a, uint32_t b)
471 {
472 PTR_ENSURE_LTE(a, b);
473 /* test the inverse */
474 PTR_ENSURE_GTE(b, a);
475 return "ok";
476 }
477
PTR_ENSURE_LTE_harness_int32(int32_t a,int32_t b)478 static const char* PTR_ENSURE_LTE_harness_int32(int32_t a, int32_t b)
479 {
480 PTR_ENSURE_LTE(a, b);
481 /* test the inverse */
482 PTR_ENSURE_GTE(b, a);
483 return "ok";
484 }
485
PTR_ENSURE_GT_harness_uint32(uint32_t a,uint32_t b)486 static const char* PTR_ENSURE_GT_harness_uint32(uint32_t a, uint32_t b)
487 {
488 PTR_ENSURE_GT(a, b);
489 /* test the inverse */
490 PTR_ENSURE_LT(b, a);
491 return "ok";
492 }
493
PTR_ENSURE_GT_harness_int32(int32_t a,int32_t b)494 static const char* PTR_ENSURE_GT_harness_int32(int32_t a, int32_t b)
495 {
496 PTR_ENSURE_GT(a, b);
497 /* test the inverse */
498 PTR_ENSURE_LT(b, a);
499 return "ok";
500 }
501
PTR_ENSURE_LT_harness_uint32(uint32_t a,uint32_t b)502 static const char* PTR_ENSURE_LT_harness_uint32(uint32_t a, uint32_t b)
503 {
504 PTR_ENSURE_LT(a, b);
505 /* test the inverse */
506 PTR_ENSURE_GT(b, a);
507 return "ok";
508 }
509
PTR_ENSURE_LT_harness_int32(int32_t a,int32_t b)510 static const char* PTR_ENSURE_LT_harness_int32(int32_t a, int32_t b)
511 {
512 PTR_ENSURE_LT(a, b);
513 /* test the inverse */
514 PTR_ENSURE_GT(b, a);
515 return "ok";
516 }
517
PTR_ENSURE_EQ_harness_uint32(uint32_t a,uint32_t b)518 static const char* PTR_ENSURE_EQ_harness_uint32(uint32_t a, uint32_t b)
519 {
520 PTR_ENSURE_EQ(a, b);
521 PTR_ENSURE_EQ(b, a);
522 return "ok";
523 }
524
PTR_ENSURE_EQ_harness_int32(int32_t a,int32_t b)525 static const char* PTR_ENSURE_EQ_harness_int32(int32_t a, int32_t b)
526 {
527 PTR_ENSURE_EQ(a, b);
528 PTR_ENSURE_EQ(b, a);
529 return "ok";
530 }
531
PTR_ENSURE_NE_harness_uint32(uint32_t a,uint32_t b)532 static const char* PTR_ENSURE_NE_harness_uint32(uint32_t a, uint32_t b)
533 {
534 PTR_ENSURE_NE(a, b);
535 PTR_ENSURE_NE(b, a);
536 return "ok";
537 }
538
PTR_ENSURE_NE_harness_int32(int32_t a,int32_t b)539 static const char* PTR_ENSURE_NE_harness_int32(int32_t a, int32_t b)
540 {
541 PTR_ENSURE_NE(a, b);
542 PTR_ENSURE_NE(b, a);
543 return "ok";
544 }
545
PTR_ENSURE_INCLUSIVE_RANGE_harness_uint32(uint32_t a,uint32_t b,uint32_t c)546 static const char* PTR_ENSURE_INCLUSIVE_RANGE_harness_uint32(uint32_t a, uint32_t b, uint32_t c)
547 {
548 PTR_ENSURE_INCLUSIVE_RANGE(a, b, c);
549 return "ok";
550 }
551
PTR_ENSURE_INCLUSIVE_RANGE_harness_int32(int32_t a,int32_t b,int32_t c)552 static const char* PTR_ENSURE_INCLUSIVE_RANGE_harness_int32(int32_t a, int32_t b, int32_t c)
553 {
554 PTR_ENSURE_INCLUSIVE_RANGE(a, b, c);
555 return "ok";
556 }
557
PTR_ENSURE_EXCLUSIVE_RANGE_harness_uint32(uint32_t a,uint32_t b,uint32_t c)558 static const char* PTR_ENSURE_EXCLUSIVE_RANGE_harness_uint32(uint32_t a, uint32_t b, uint32_t c)
559 {
560 PTR_ENSURE_EXCLUSIVE_RANGE(a, b, c);
561 return "ok";
562 }
563
PTR_ENSURE_EXCLUSIVE_RANGE_harness_int32(int32_t a,int32_t b,int32_t c)564 static const char* PTR_ENSURE_EXCLUSIVE_RANGE_harness_int32(int32_t a, int32_t b, int32_t c)
565 {
566 PTR_ENSURE_EXCLUSIVE_RANGE(a, b, c);
567 return "ok";
568 }
569
PTR_ENSURE_REF_harness(const char * str)570 static const char* PTR_ENSURE_REF_harness(const char* str)
571 {
572 PTR_ENSURE_REF(str);
573 return "ok";
574 }
575
PTR_ENSURE_MUT_harness(uint32_t * v)576 static const char* PTR_ENSURE_MUT_harness(uint32_t* v)
577 {
578 PTR_ENSURE_MUT(v);
579 return "ok";
580 }
581
PTR_PRECONDITION_harness_check(bool is_ok)582 static S2N_RESULT PTR_PRECONDITION_harness_check(bool is_ok)
583 {
584 RESULT_ENSURE(is_ok, S2N_ERR_SAFETY);
585 return S2N_RESULT_OK;
586 }
587
PTR_PRECONDITION_harness(s2n_result result)588 static const char* PTR_PRECONDITION_harness(s2n_result result)
589 {
590 PTR_PRECONDITION(result);
591 return "ok";
592 }
593
PTR_POSTCONDITION_harness_check(bool is_ok)594 static S2N_RESULT PTR_POSTCONDITION_harness_check(bool is_ok)
595 {
596 RESULT_ENSURE(is_ok, S2N_ERR_SAFETY);
597 return S2N_RESULT_OK;
598 }
599
PTR_POSTCONDITION_harness(s2n_result result)600 static const char* PTR_POSTCONDITION_harness(s2n_result result)
601 {
602 PTR_POSTCONDITION(result);
603 return "ok";
604 }
605
PTR_CHECKED_MEMCPY_harness(uint32_t * dest,uint32_t * source,size_t len)606 static const char* PTR_CHECKED_MEMCPY_harness(uint32_t* dest, uint32_t* source, size_t len)
607 {
608 PTR_CHECKED_MEMCPY(dest, source, len);
609 return "ok";
610 }
611
PTR_CHECKED_MEMSET_harness(uint32_t * dest,uint8_t value,size_t len)612 static const char* PTR_CHECKED_MEMSET_harness(uint32_t* dest, uint8_t value, size_t len)
613 {
614 PTR_CHECKED_MEMSET(dest, value, len);
615 return "ok";
616 }
617
PTR_GUARD_harness(const char * result)618 static const char* PTR_GUARD_harness(const char* result)
619 {
620 PTR_GUARD(result);
621 return "ok";
622 }
623
PTR_GUARD_OSSL_harness(int result,int error)624 static const char* PTR_GUARD_OSSL_harness(int result, int error)
625 {
626 PTR_GUARD_OSSL(result, error);
627 return "ok";
628 }
629
main(int argc,char ** argv)630 int main(int argc, char **argv)
631 {
632 BEGIN_TEST();
633
634 /* RESULT_BAIL(error) */
635 EXPECT_ERROR_WITH_ERRNO(RESULT_BAIL_harness(), S2N_ERR_SAFETY);
636
637 /* RESULT_ENSURE(condition, error) */
638 EXPECT_OK(RESULT_ENSURE_harness(true));
639 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_harness(false), S2N_ERR_SAFETY);
640
641 /* RESULT_DEBUG_ENSURE(condition, error) */
642 EXPECT_OK(RESULT_DEBUG_ENSURE_harness(true));
643 #ifdef NDEBUG
644 EXPECT_OK(RESULT_DEBUG_ENSURE_harness(false));
645 #else
646 EXPECT_ERROR_WITH_ERRNO(RESULT_DEBUG_ENSURE_harness(false), S2N_ERR_SAFETY);
647 #endif
648
649 /* RESULT_ENSURE_OK(result, error) */
650 EXPECT_OK(RESULT_ENSURE_OK_harness(true));
651 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_OK_harness(false), S2N_ERR_IO);
652
653 /* RESULT_ENSURE_GTE(a, b) */
654 EXPECT_OK(RESULT_ENSURE_GTE_harness_uint32(0, 0));
655 EXPECT_OK(RESULT_ENSURE_GTE_harness_uint32(1, 0));
656 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_GTE_harness_uint32(0, 1), S2N_ERR_SAFETY);
657 EXPECT_OK(RESULT_ENSURE_GTE_harness_int32(-1, -2));
658 EXPECT_OK(RESULT_ENSURE_GTE_harness_int32(-1, -1));
659 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_GTE_harness_int32(-2, -1), S2N_ERR_SAFETY);
660
661 /* RESULT_ENSURE_LTE(a, b) */
662 EXPECT_OK(RESULT_ENSURE_LTE_harness_uint32(0, 0));
663 EXPECT_OK(RESULT_ENSURE_LTE_harness_uint32(0, 1));
664 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_LTE_harness_uint32(1, 0), S2N_ERR_SAFETY);
665 EXPECT_OK(RESULT_ENSURE_LTE_harness_int32(-2, -1));
666 EXPECT_OK(RESULT_ENSURE_LTE_harness_int32(-1, -1));
667 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_LTE_harness_int32(-1, -2), S2N_ERR_SAFETY);
668
669 /* RESULT_ENSURE_GT(a, b) */
670 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_GT_harness_uint32(0, 0), S2N_ERR_SAFETY);
671 EXPECT_OK(RESULT_ENSURE_GT_harness_uint32(1, 0));
672 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_GT_harness_uint32(0, 1), S2N_ERR_SAFETY);
673 EXPECT_OK(RESULT_ENSURE_GT_harness_int32(-1, -2));
674 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_GT_harness_int32(-1, -1), S2N_ERR_SAFETY);
675 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_GT_harness_int32(-2, -1), S2N_ERR_SAFETY);
676
677 /* RESULT_ENSURE_LT(a, b) */
678 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_LT_harness_uint32(0, 0), S2N_ERR_SAFETY);
679 EXPECT_OK(RESULT_ENSURE_LT_harness_uint32(0, 1));
680 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_LT_harness_uint32(1, 0), S2N_ERR_SAFETY);
681 EXPECT_OK(RESULT_ENSURE_LT_harness_int32(-2, -1));
682 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_LT_harness_int32(-1, -1), S2N_ERR_SAFETY);
683 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_LT_harness_int32(-1, -2), S2N_ERR_SAFETY);
684
685 /* RESULT_ENSURE_EQ(a, b) */
686 EXPECT_OK(RESULT_ENSURE_EQ_harness_uint32(0, 0));
687 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_EQ_harness_uint32(1, 0), S2N_ERR_SAFETY);
688 EXPECT_OK(RESULT_ENSURE_EQ_harness_int32(-1, -1));
689 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_EQ_harness_int32(-2, -1), S2N_ERR_SAFETY);
690
691 /* RESULT_ENSURE_NE(a, b) */
692 EXPECT_OK(RESULT_ENSURE_NE_harness_uint32(1, 0));
693 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_NE_harness_uint32(0, 0), S2N_ERR_SAFETY);
694 EXPECT_OK(RESULT_ENSURE_NE_harness_int32(-2, -1));
695 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_NE_harness_int32(-1, -1), S2N_ERR_SAFETY);
696
697 /* RESULT_ENSURE_INCLUSIVE_RANGE(min, n, max) */
698 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 0, 2), S2N_ERR_SAFETY);
699 EXPECT_OK(RESULT_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 1, 2));
700 EXPECT_OK(RESULT_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 2, 2));
701 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 3, 2), S2N_ERR_SAFETY);
702 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, -3, -1), S2N_ERR_SAFETY);
703 EXPECT_OK(RESULT_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, -2, -1));
704 EXPECT_OK(RESULT_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, -1, -1));
705 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, 0, -1), S2N_ERR_SAFETY);
706
707 /* RESULT_ENSURE_EXCLUSIVE_RANGE(min, n, max) */
708 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 0, 3), S2N_ERR_SAFETY);
709 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 1, 3), S2N_ERR_SAFETY);
710 EXPECT_OK(RESULT_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 2, 3));
711 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 3, 3), S2N_ERR_SAFETY);
712 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 4, 3), S2N_ERR_SAFETY);
713 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -4, -1), S2N_ERR_SAFETY);
714 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -3, -1), S2N_ERR_SAFETY);
715 EXPECT_OK(RESULT_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -2, -1));
716 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -1, -1), S2N_ERR_SAFETY);
717 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, 0, -1), S2N_ERR_SAFETY);
718
719 /* RESULT_ENSURE_REF(x) */
720 EXPECT_OK(RESULT_ENSURE_REF_harness(""));
721 EXPECT_OK(RESULT_ENSURE_REF_harness("ok"));
722 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_REF_harness(NULL), S2N_ERR_NULL);
723
724 /* RESULT_ENSURE_MUT(x) */
725 uint32_t RESULT_ensure_mut_test = 0;
726 EXPECT_OK(RESULT_ENSURE_MUT_harness(&RESULT_ensure_mut_test));
727 RESULT_ensure_mut_test = 1;
728 EXPECT_OK(RESULT_ENSURE_MUT_harness(&RESULT_ensure_mut_test));
729 EXPECT_ERROR_WITH_ERRNO(RESULT_ENSURE_MUT_harness(NULL), S2N_ERR_NULL);
730
731 /* RESULT_PRECONDITION(result) */
732 EXPECT_OK(RESULT_PRECONDITION_harness(RESULT_PRECONDITION_harness_check(true)));
733 EXPECT_ERROR_WITH_ERRNO(RESULT_PRECONDITION_harness(RESULT_PRECONDITION_harness_check(false)), S2N_ERR_SAFETY);
734
735 /* RESULT_POSTCONDITION(result) */
736 EXPECT_OK(RESULT_POSTCONDITION_harness(RESULT_POSTCONDITION_harness_check(true)));
737 #ifdef NDEBUG
738 EXPECT_OK(RESULT_POSTCONDITION_harness(RESULT_POSTCONDITION_harness_check(false)));
739 #else
740 EXPECT_ERROR_WITH_ERRNO(RESULT_POSTCONDITION_harness(RESULT_POSTCONDITION_harness_check(false)), S2N_ERR_SAFETY);
741 #endif
742
743 /* RESULT_CHECKED_MEMCPY(destination, source, len) */
744 uint32_t RESULT__checked_memcpy_dest = 1;
745 uint32_t RESULT__checked_memcpy_source = 2;
746 EXPECT_OK(RESULT_CHECKED_MEMCPY_harness(&RESULT__checked_memcpy_dest, &RESULT__checked_memcpy_source, 0));
747 EXPECT_EQUAL(RESULT__checked_memcpy_dest, 1);
748 EXPECT_ERROR_WITH_ERRNO(RESULT_CHECKED_MEMCPY_harness(NULL, &RESULT__checked_memcpy_source, 4), S2N_ERR_NULL);
749 EXPECT_ERROR_WITH_ERRNO(RESULT_CHECKED_MEMCPY_harness(&RESULT__checked_memcpy_dest, NULL, 4), S2N_ERR_NULL);
750 EXPECT_OK(RESULT_CHECKED_MEMCPY_harness(&RESULT__checked_memcpy_dest, &RESULT__checked_memcpy_source, 4));
751 EXPECT_EQUAL(RESULT__checked_memcpy_dest, RESULT__checked_memcpy_source);
752
753 /* RESULT_CHECKED_MEMSET(destination, value, len) */
754 uint32_t RESULT__checked_memset_dest = 1;
755 EXPECT_OK(RESULT_CHECKED_MEMSET_harness(&RESULT__checked_memset_dest, 0x42, 0));
756 EXPECT_EQUAL(RESULT__checked_memset_dest, 1);
757 EXPECT_ERROR_WITH_ERRNO(RESULT_CHECKED_MEMSET_harness(NULL, 0x42, 1), S2N_ERR_NULL);
758 EXPECT_OK(RESULT_CHECKED_MEMSET_harness(&RESULT__checked_memset_dest, 0x42, 4));
759 EXPECT_EQUAL(RESULT__checked_memset_dest, 0x42424242);
760
761 /* RESULT_GUARD(result) */
762 EXPECT_OK(RESULT_GUARD_harness(RESULT_ENSURE_harness(true)));
763 EXPECT_ERROR_WITH_ERRNO(RESULT_GUARD_harness(RESULT_ENSURE_harness(false)), S2N_ERR_SAFETY);
764
765 /* RESULT_GUARD_OSSL(result, error) */
766 EXPECT_OK(RESULT_GUARD_OSSL_harness(1, S2N_ERR_SAFETY));
767 EXPECT_ERROR_WITH_ERRNO(RESULT_GUARD_OSSL_harness(0, S2N_ERR_SAFETY), S2N_ERR_SAFETY);
768
769 /* POSIX_BAIL(error) */
770 EXPECT_FAILURE_WITH_ERRNO(POSIX_BAIL_harness(), S2N_ERR_SAFETY);
771
772 /* POSIX_ENSURE(condition, error) */
773 EXPECT_SUCCESS(POSIX_ENSURE_harness(true));
774 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_harness(false), S2N_ERR_SAFETY);
775
776 /* POSIX_DEBUG_ENSURE(condition, error) */
777 EXPECT_SUCCESS(POSIX_DEBUG_ENSURE_harness(true));
778 #ifdef NDEBUG
779 EXPECT_SUCCESS(POSIX_DEBUG_ENSURE_harness(false));
780 #else
781 EXPECT_FAILURE_WITH_ERRNO(POSIX_DEBUG_ENSURE_harness(false), S2N_ERR_SAFETY);
782 #endif
783
784 /* POSIX_ENSURE_OK(result, error) */
785 EXPECT_SUCCESS(POSIX_ENSURE_OK_harness(true));
786 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_OK_harness(false), S2N_ERR_IO);
787
788 /* POSIX_ENSURE_GTE(a, b) */
789 EXPECT_SUCCESS(POSIX_ENSURE_GTE_harness_uint32(0, 0));
790 EXPECT_SUCCESS(POSIX_ENSURE_GTE_harness_uint32(1, 0));
791 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_GTE_harness_uint32(0, 1), S2N_ERR_SAFETY);
792 EXPECT_SUCCESS(POSIX_ENSURE_GTE_harness_int32(-1, -2));
793 EXPECT_SUCCESS(POSIX_ENSURE_GTE_harness_int32(-1, -1));
794 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_GTE_harness_int32(-2, -1), S2N_ERR_SAFETY);
795
796 /* POSIX_ENSURE_LTE(a, b) */
797 EXPECT_SUCCESS(POSIX_ENSURE_LTE_harness_uint32(0, 0));
798 EXPECT_SUCCESS(POSIX_ENSURE_LTE_harness_uint32(0, 1));
799 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_LTE_harness_uint32(1, 0), S2N_ERR_SAFETY);
800 EXPECT_SUCCESS(POSIX_ENSURE_LTE_harness_int32(-2, -1));
801 EXPECT_SUCCESS(POSIX_ENSURE_LTE_harness_int32(-1, -1));
802 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_LTE_harness_int32(-1, -2), S2N_ERR_SAFETY);
803
804 /* POSIX_ENSURE_GT(a, b) */
805 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_GT_harness_uint32(0, 0), S2N_ERR_SAFETY);
806 EXPECT_SUCCESS(POSIX_ENSURE_GT_harness_uint32(1, 0));
807 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_GT_harness_uint32(0, 1), S2N_ERR_SAFETY);
808 EXPECT_SUCCESS(POSIX_ENSURE_GT_harness_int32(-1, -2));
809 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_GT_harness_int32(-1, -1), S2N_ERR_SAFETY);
810 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_GT_harness_int32(-2, -1), S2N_ERR_SAFETY);
811
812 /* POSIX_ENSURE_LT(a, b) */
813 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_LT_harness_uint32(0, 0), S2N_ERR_SAFETY);
814 EXPECT_SUCCESS(POSIX_ENSURE_LT_harness_uint32(0, 1));
815 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_LT_harness_uint32(1, 0), S2N_ERR_SAFETY);
816 EXPECT_SUCCESS(POSIX_ENSURE_LT_harness_int32(-2, -1));
817 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_LT_harness_int32(-1, -1), S2N_ERR_SAFETY);
818 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_LT_harness_int32(-1, -2), S2N_ERR_SAFETY);
819
820 /* POSIX_ENSURE_EQ(a, b) */
821 EXPECT_SUCCESS(POSIX_ENSURE_EQ_harness_uint32(0, 0));
822 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_EQ_harness_uint32(1, 0), S2N_ERR_SAFETY);
823 EXPECT_SUCCESS(POSIX_ENSURE_EQ_harness_int32(-1, -1));
824 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_EQ_harness_int32(-2, -1), S2N_ERR_SAFETY);
825
826 /* POSIX_ENSURE_NE(a, b) */
827 EXPECT_SUCCESS(POSIX_ENSURE_NE_harness_uint32(1, 0));
828 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_NE_harness_uint32(0, 0), S2N_ERR_SAFETY);
829 EXPECT_SUCCESS(POSIX_ENSURE_NE_harness_int32(-2, -1));
830 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_NE_harness_int32(-1, -1), S2N_ERR_SAFETY);
831
832 /* POSIX_ENSURE_INCLUSIVE_RANGE(min, n, max) */
833 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 0, 2), S2N_ERR_SAFETY);
834 EXPECT_SUCCESS(POSIX_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 1, 2));
835 EXPECT_SUCCESS(POSIX_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 2, 2));
836 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 3, 2), S2N_ERR_SAFETY);
837 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, -3, -1), S2N_ERR_SAFETY);
838 EXPECT_SUCCESS(POSIX_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, -2, -1));
839 EXPECT_SUCCESS(POSIX_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, -1, -1));
840 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, 0, -1), S2N_ERR_SAFETY);
841
842 /* POSIX_ENSURE_EXCLUSIVE_RANGE(min, n, max) */
843 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 0, 3), S2N_ERR_SAFETY);
844 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 1, 3), S2N_ERR_SAFETY);
845 EXPECT_SUCCESS(POSIX_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 2, 3));
846 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 3, 3), S2N_ERR_SAFETY);
847 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 4, 3), S2N_ERR_SAFETY);
848 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -4, -1), S2N_ERR_SAFETY);
849 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -3, -1), S2N_ERR_SAFETY);
850 EXPECT_SUCCESS(POSIX_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -2, -1));
851 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -1, -1), S2N_ERR_SAFETY);
852 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, 0, -1), S2N_ERR_SAFETY);
853
854 /* POSIX_ENSURE_REF(x) */
855 EXPECT_SUCCESS(POSIX_ENSURE_REF_harness(""));
856 EXPECT_SUCCESS(POSIX_ENSURE_REF_harness("ok"));
857 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_REF_harness(NULL), S2N_ERR_NULL);
858
859 /* POSIX_ENSURE_MUT(x) */
860 uint32_t POSIX_ensure_mut_test = 0;
861 EXPECT_SUCCESS(POSIX_ENSURE_MUT_harness(&POSIX_ensure_mut_test));
862 POSIX_ensure_mut_test = 1;
863 EXPECT_SUCCESS(POSIX_ENSURE_MUT_harness(&POSIX_ensure_mut_test));
864 EXPECT_FAILURE_WITH_ERRNO(POSIX_ENSURE_MUT_harness(NULL), S2N_ERR_NULL);
865
866 /* POSIX_PRECONDITION(result) */
867 EXPECT_SUCCESS(POSIX_PRECONDITION_harness(POSIX_PRECONDITION_harness_check(true)));
868 EXPECT_FAILURE_WITH_ERRNO(POSIX_PRECONDITION_harness(POSIX_PRECONDITION_harness_check(false)), S2N_ERR_SAFETY);
869
870 /* POSIX_POSTCONDITION(result) */
871 EXPECT_SUCCESS(POSIX_POSTCONDITION_harness(POSIX_POSTCONDITION_harness_check(true)));
872 #ifdef NDEBUG
873 EXPECT_SUCCESS(POSIX_POSTCONDITION_harness(POSIX_POSTCONDITION_harness_check(false)));
874 #else
875 EXPECT_FAILURE_WITH_ERRNO(POSIX_POSTCONDITION_harness(POSIX_POSTCONDITION_harness_check(false)), S2N_ERR_SAFETY);
876 #endif
877
878 /* POSIX_CHECKED_MEMCPY(destination, source, len) */
879 uint32_t POSIX__checked_memcpy_dest = 1;
880 uint32_t POSIX__checked_memcpy_source = 2;
881 EXPECT_SUCCESS(POSIX_CHECKED_MEMCPY_harness(&POSIX__checked_memcpy_dest, &POSIX__checked_memcpy_source, 0));
882 EXPECT_EQUAL(POSIX__checked_memcpy_dest, 1);
883 EXPECT_FAILURE_WITH_ERRNO(POSIX_CHECKED_MEMCPY_harness(NULL, &POSIX__checked_memcpy_source, 4), S2N_ERR_NULL);
884 EXPECT_FAILURE_WITH_ERRNO(POSIX_CHECKED_MEMCPY_harness(&POSIX__checked_memcpy_dest, NULL, 4), S2N_ERR_NULL);
885 EXPECT_SUCCESS(POSIX_CHECKED_MEMCPY_harness(&POSIX__checked_memcpy_dest, &POSIX__checked_memcpy_source, 4));
886 EXPECT_EQUAL(POSIX__checked_memcpy_dest, POSIX__checked_memcpy_source);
887
888 /* POSIX_CHECKED_MEMSET(destination, value, len) */
889 uint32_t POSIX__checked_memset_dest = 1;
890 EXPECT_SUCCESS(POSIX_CHECKED_MEMSET_harness(&POSIX__checked_memset_dest, 0x42, 0));
891 EXPECT_EQUAL(POSIX__checked_memset_dest, 1);
892 EXPECT_FAILURE_WITH_ERRNO(POSIX_CHECKED_MEMSET_harness(NULL, 0x42, 1), S2N_ERR_NULL);
893 EXPECT_SUCCESS(POSIX_CHECKED_MEMSET_harness(&POSIX__checked_memset_dest, 0x42, 4));
894 EXPECT_EQUAL(POSIX__checked_memset_dest, 0x42424242);
895
896 /* POSIX_GUARD(result) */
897 EXPECT_SUCCESS(POSIX_GUARD_harness(POSIX_ENSURE_harness(true)));
898 EXPECT_FAILURE_WITH_ERRNO(POSIX_GUARD_harness(POSIX_ENSURE_harness(false)), S2N_ERR_SAFETY);
899
900 /* POSIX_GUARD_OSSL(result, error) */
901 EXPECT_SUCCESS(POSIX_GUARD_OSSL_harness(1, S2N_ERR_SAFETY));
902 EXPECT_FAILURE_WITH_ERRNO(POSIX_GUARD_OSSL_harness(0, S2N_ERR_SAFETY), S2N_ERR_SAFETY);
903
904 /* PTR_BAIL(error) */
905 EXPECT_NULL_WITH_ERRNO(PTR_BAIL_harness(), S2N_ERR_SAFETY);
906
907 /* PTR_ENSURE(condition, error) */
908 EXPECT_NOT_NULL(PTR_ENSURE_harness(true));
909 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_harness(false), S2N_ERR_SAFETY);
910
911 /* PTR_DEBUG_ENSURE(condition, error) */
912 EXPECT_NOT_NULL(PTR_DEBUG_ENSURE_harness(true));
913 #ifdef NDEBUG
914 EXPECT_NOT_NULL(PTR_DEBUG_ENSURE_harness(false));
915 #else
916 EXPECT_NULL_WITH_ERRNO(PTR_DEBUG_ENSURE_harness(false), S2N_ERR_SAFETY);
917 #endif
918
919 /* PTR_ENSURE_OK(result, error) */
920 EXPECT_NOT_NULL(PTR_ENSURE_OK_harness(true));
921 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_OK_harness(false), S2N_ERR_IO);
922
923 /* PTR_ENSURE_GTE(a, b) */
924 EXPECT_NOT_NULL(PTR_ENSURE_GTE_harness_uint32(0, 0));
925 EXPECT_NOT_NULL(PTR_ENSURE_GTE_harness_uint32(1, 0));
926 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_GTE_harness_uint32(0, 1), S2N_ERR_SAFETY);
927 EXPECT_NOT_NULL(PTR_ENSURE_GTE_harness_int32(-1, -2));
928 EXPECT_NOT_NULL(PTR_ENSURE_GTE_harness_int32(-1, -1));
929 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_GTE_harness_int32(-2, -1), S2N_ERR_SAFETY);
930
931 /* PTR_ENSURE_LTE(a, b) */
932 EXPECT_NOT_NULL(PTR_ENSURE_LTE_harness_uint32(0, 0));
933 EXPECT_NOT_NULL(PTR_ENSURE_LTE_harness_uint32(0, 1));
934 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_LTE_harness_uint32(1, 0), S2N_ERR_SAFETY);
935 EXPECT_NOT_NULL(PTR_ENSURE_LTE_harness_int32(-2, -1));
936 EXPECT_NOT_NULL(PTR_ENSURE_LTE_harness_int32(-1, -1));
937 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_LTE_harness_int32(-1, -2), S2N_ERR_SAFETY);
938
939 /* PTR_ENSURE_GT(a, b) */
940 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_GT_harness_uint32(0, 0), S2N_ERR_SAFETY);
941 EXPECT_NOT_NULL(PTR_ENSURE_GT_harness_uint32(1, 0));
942 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_GT_harness_uint32(0, 1), S2N_ERR_SAFETY);
943 EXPECT_NOT_NULL(PTR_ENSURE_GT_harness_int32(-1, -2));
944 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_GT_harness_int32(-1, -1), S2N_ERR_SAFETY);
945 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_GT_harness_int32(-2, -1), S2N_ERR_SAFETY);
946
947 /* PTR_ENSURE_LT(a, b) */
948 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_LT_harness_uint32(0, 0), S2N_ERR_SAFETY);
949 EXPECT_NOT_NULL(PTR_ENSURE_LT_harness_uint32(0, 1));
950 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_LT_harness_uint32(1, 0), S2N_ERR_SAFETY);
951 EXPECT_NOT_NULL(PTR_ENSURE_LT_harness_int32(-2, -1));
952 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_LT_harness_int32(-1, -1), S2N_ERR_SAFETY);
953 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_LT_harness_int32(-1, -2), S2N_ERR_SAFETY);
954
955 /* PTR_ENSURE_EQ(a, b) */
956 EXPECT_NOT_NULL(PTR_ENSURE_EQ_harness_uint32(0, 0));
957 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_EQ_harness_uint32(1, 0), S2N_ERR_SAFETY);
958 EXPECT_NOT_NULL(PTR_ENSURE_EQ_harness_int32(-1, -1));
959 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_EQ_harness_int32(-2, -1), S2N_ERR_SAFETY);
960
961 /* PTR_ENSURE_NE(a, b) */
962 EXPECT_NOT_NULL(PTR_ENSURE_NE_harness_uint32(1, 0));
963 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_NE_harness_uint32(0, 0), S2N_ERR_SAFETY);
964 EXPECT_NOT_NULL(PTR_ENSURE_NE_harness_int32(-2, -1));
965 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_NE_harness_int32(-1, -1), S2N_ERR_SAFETY);
966
967 /* PTR_ENSURE_INCLUSIVE_RANGE(min, n, max) */
968 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 0, 2), S2N_ERR_SAFETY);
969 EXPECT_NOT_NULL(PTR_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 1, 2));
970 EXPECT_NOT_NULL(PTR_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 2, 2));
971 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_INCLUSIVE_RANGE_harness_uint32(1, 3, 2), S2N_ERR_SAFETY);
972 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, -3, -1), S2N_ERR_SAFETY);
973 EXPECT_NOT_NULL(PTR_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, -2, -1));
974 EXPECT_NOT_NULL(PTR_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, -1, -1));
975 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_INCLUSIVE_RANGE_harness_int32(-2, 0, -1), S2N_ERR_SAFETY);
976
977 /* PTR_ENSURE_EXCLUSIVE_RANGE(min, n, max) */
978 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 0, 3), S2N_ERR_SAFETY);
979 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 1, 3), S2N_ERR_SAFETY);
980 EXPECT_NOT_NULL(PTR_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 2, 3));
981 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 3, 3), S2N_ERR_SAFETY);
982 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_EXCLUSIVE_RANGE_harness_uint32(1, 4, 3), S2N_ERR_SAFETY);
983 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -4, -1), S2N_ERR_SAFETY);
984 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -3, -1), S2N_ERR_SAFETY);
985 EXPECT_NOT_NULL(PTR_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -2, -1));
986 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, -1, -1), S2N_ERR_SAFETY);
987 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_EXCLUSIVE_RANGE_harness_int32(-3, 0, -1), S2N_ERR_SAFETY);
988
989 /* PTR_ENSURE_REF(x) */
990 EXPECT_NOT_NULL(PTR_ENSURE_REF_harness(""));
991 EXPECT_NOT_NULL(PTR_ENSURE_REF_harness("ok"));
992 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_REF_harness(NULL), S2N_ERR_NULL);
993
994 /* PTR_ENSURE_MUT(x) */
995 uint32_t PTR_ensure_mut_test = 0;
996 EXPECT_NOT_NULL(PTR_ENSURE_MUT_harness(&PTR_ensure_mut_test));
997 PTR_ensure_mut_test = 1;
998 EXPECT_NOT_NULL(PTR_ENSURE_MUT_harness(&PTR_ensure_mut_test));
999 EXPECT_NULL_WITH_ERRNO(PTR_ENSURE_MUT_harness(NULL), S2N_ERR_NULL);
1000
1001 /* PTR_PRECONDITION(result) */
1002 EXPECT_NOT_NULL(PTR_PRECONDITION_harness(PTR_PRECONDITION_harness_check(true)));
1003 EXPECT_NULL_WITH_ERRNO(PTR_PRECONDITION_harness(PTR_PRECONDITION_harness_check(false)), S2N_ERR_SAFETY);
1004
1005 /* PTR_POSTCONDITION(result) */
1006 EXPECT_NOT_NULL(PTR_POSTCONDITION_harness(PTR_POSTCONDITION_harness_check(true)));
1007 #ifdef NDEBUG
1008 EXPECT_NOT_NULL(PTR_POSTCONDITION_harness(PTR_POSTCONDITION_harness_check(false)));
1009 #else
1010 EXPECT_NULL_WITH_ERRNO(PTR_POSTCONDITION_harness(PTR_POSTCONDITION_harness_check(false)), S2N_ERR_SAFETY);
1011 #endif
1012
1013 /* PTR_CHECKED_MEMCPY(destination, source, len) */
1014 uint32_t PTR__checked_memcpy_dest = 1;
1015 uint32_t PTR__checked_memcpy_source = 2;
1016 EXPECT_NOT_NULL(PTR_CHECKED_MEMCPY_harness(&PTR__checked_memcpy_dest, &PTR__checked_memcpy_source, 0));
1017 EXPECT_EQUAL(PTR__checked_memcpy_dest, 1);
1018 EXPECT_NULL_WITH_ERRNO(PTR_CHECKED_MEMCPY_harness(NULL, &PTR__checked_memcpy_source, 4), S2N_ERR_NULL);
1019 EXPECT_NULL_WITH_ERRNO(PTR_CHECKED_MEMCPY_harness(&PTR__checked_memcpy_dest, NULL, 4), S2N_ERR_NULL);
1020 EXPECT_NOT_NULL(PTR_CHECKED_MEMCPY_harness(&PTR__checked_memcpy_dest, &PTR__checked_memcpy_source, 4));
1021 EXPECT_EQUAL(PTR__checked_memcpy_dest, PTR__checked_memcpy_source);
1022
1023 /* PTR_CHECKED_MEMSET(destination, value, len) */
1024 uint32_t PTR__checked_memset_dest = 1;
1025 EXPECT_NOT_NULL(PTR_CHECKED_MEMSET_harness(&PTR__checked_memset_dest, 0x42, 0));
1026 EXPECT_EQUAL(PTR__checked_memset_dest, 1);
1027 EXPECT_NULL_WITH_ERRNO(PTR_CHECKED_MEMSET_harness(NULL, 0x42, 1), S2N_ERR_NULL);
1028 EXPECT_NOT_NULL(PTR_CHECKED_MEMSET_harness(&PTR__checked_memset_dest, 0x42, 4));
1029 EXPECT_EQUAL(PTR__checked_memset_dest, 0x42424242);
1030
1031 /* PTR_GUARD(result) */
1032 EXPECT_NOT_NULL(PTR_GUARD_harness(PTR_ENSURE_harness(true)));
1033 EXPECT_NULL_WITH_ERRNO(PTR_GUARD_harness(PTR_ENSURE_harness(false)), S2N_ERR_SAFETY);
1034
1035 /* PTR_GUARD_OSSL(result, error) */
1036 EXPECT_NOT_NULL(PTR_GUARD_OSSL_harness(1, S2N_ERR_SAFETY));
1037 EXPECT_NULL_WITH_ERRNO(PTR_GUARD_OSSL_harness(0, S2N_ERR_SAFETY), S2N_ERR_SAFETY);
1038
1039
1040 END_TEST();
1041 return S2N_SUCCESS;
1042 }
1043