[thirdparty/openssl.git] / test / stack_test.c

/*
 * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

/* ====================================================================
 * Copyright (c) 2017 Oracle and/or its affiliates.  All rights reserved.
 */

#include <stdio.h>
#include <string.h>

#include <openssl/opensslconf.h>
#include <openssl/safestack.h>
#include <openssl/err.h>
#include <openssl/crypto.h>

#include "e_os.h"
#include "test_main.h"
#include "testutil.h"

/* The macros below generate unused functions which error out one of the clang
 * builds.  We disable this check here.
 */
#ifdef __clang__
#pragma clang diagnostic ignored "-Wunused-function"
#endif

typedef struct {
    int n;
    char c;
} SS;

typedef union {
    int n;
    char c;
} SU;

DEFINE_SPECIAL_STACK_OF(sint, int)
DEFINE_SPECIAL_STACK_OF_CONST(uchar, unsigned char)
DEFINE_STACK_OF(SS)
DEFINE_STACK_OF_CONST(SU)

static int int_compare(const int *const *a, const int *const *b)
{
    if (**a < **b)
        return -1;
    if (**a > **b)
        return 1;
    return 0;
}

static int test_int_stack(void)
{
    static int v[] = { 1, 2, -4, 16, 999, 1, -173, 1, 9 };
    static int notpresent = -1;
    const int n = OSSL_NELEM(v);
    static struct {
        int value;
        int unsorted;
        int sorted;
        int ex;
    } finds[] = {
        { 2,    1,  5,  5   },
        { 9,    7,  6,  6   },
        { -173, 5,  0,  0   },
        { 999,  3,  8,  8   },
        { 0,   -1, -1,  1   }
    };
    const int n_finds = OSSL_NELEM(finds);
    static struct {
        int value;
        int ex;
    } exfinds[] = {
        { 3,    5   },
        { 1000, 8   },
        { 20,   8   },
        { -999, 0   },
        { -5,   0   },
        { 8,    5   }
    };
    const int n_exfinds = OSSL_NELEM(exfinds);
    STACK_OF(sint) *s = sk_sint_new_null();
    int i;
    int testresult = 0;

    /* Check push and num */
    for (i = 0; i < n; i++) {
        if (sk_sint_num(s) != i) {
            fprintf(stderr, "test int stack size %d\n", i);
            goto end;
        }
        sk_sint_push(s, v + i);
    }
    if (sk_sint_num(s) != n) {
        fprintf(stderr, "test int stack size %d\n", n);
        goto end;
    }

    /* check the values */
    for (i = 0; i < n; i++)
        if (sk_sint_value(s, i) != v + i) {
            fprintf(stderr, "test int value %d\n", i);
            goto end;
        }

    /* find unsorted -- the pointers are compared */
    for (i = 0; i < n_finds; i++) {
        int *val = (finds[i].unsorted == -1) ? &notpresent
                                             : v + finds[i].unsorted;

        if (sk_sint_find(s, val) != finds[i].unsorted) {
            fprintf(stderr, "test int unsorted find %d\n", i);
            goto end;
        }
    }

    /* find_ex unsorted */
    for (i = 0; i < n_finds; i++) {
        int *val = (finds[i].unsorted == -1) ? &notpresent
                                             : v + finds[i].unsorted;

        if (sk_sint_find_ex(s, val) != finds[i].unsorted) {
            fprintf(stderr, "test int unsorted find_ex %d\n", i);
            goto end;
        }
    }

    /* sorting */
    if (sk_sint_is_sorted(s)) {
        fprintf(stderr, "test int unsorted\n");
        goto end;
    }
    sk_sint_set_cmp_func(s, &int_compare);
    sk_sint_sort(s);
    if (!sk_sint_is_sorted(s)) {
        fprintf(stderr, "test int sorted\n");
        goto end;
    }

    /* find sorted -- the value is matched so we don't need to locate it */
    for (i = 0; i < n_finds; i++)
        if (sk_sint_find(s, &finds[i].value) != finds[i].sorted) {
            fprintf(stderr, "test int sorted find %d\n", i);
            goto end;
        }

    /* find_ex sorted */
    for (i = 0; i < n_finds; i++)
        if (sk_sint_find_ex(s, &finds[i].value) != finds[i].ex) {
            fprintf(stderr, "test int sorted find_ex present %d\n", i);
            goto end;
        }
    for (i = 0; i < n_exfinds; i++)
        if (sk_sint_find_ex(s, &exfinds[i].value) != exfinds[i].ex) {
            fprintf(stderr, "test int sorted find_ex absent %d\n", i);
            goto end;
        }

    /* shift */
    if (sk_sint_shift(s) != v + 6) {
        fprintf(stderr, "test int shift\n");
        goto end;
    }

    testresult = 1;
end:
    sk_sint_free(s);
    return testresult;
}

static int uchar_compare(const unsigned char *const *a,
                         const unsigned char *const *b)
{
    return **a - (signed int)**b;
}

static int test_uchar_stack(void)
{
    static const unsigned char v[] = { 1, 3, 7, 5, 255, 0 };
    const int n = OSSL_NELEM(v);
    STACK_OF(uchar) *s = sk_uchar_new(&uchar_compare), *r = NULL;
    int i;
    int testresult = 0;

    /* unshift and num */
    for (i = 0; i < n; i++) {
        if (sk_uchar_num(s) != i) {
            fprintf(stderr, "test uchar stack size %d\n", i);
            goto end;
        }
        sk_uchar_unshift(s, v + i);
    }
    if (sk_uchar_num(s) != n) {
        fprintf(stderr, "test uchar stack size %d\n", n);
        goto end;
    }

    /* dup */
    r = sk_uchar_dup(s);
    if (sk_uchar_num(r) != n) {
        fprintf(stderr, "test uchar dup size %d\n", n);
        goto end;
    }
    sk_uchar_sort(r);

    /* pop */
    for (i = 0; i < n; i++) 
        if (sk_uchar_pop(s) != v + i) {
            fprintf(stderr, "test uchar pop %d\n", i);
            goto end;
        }

    /* free -- we rely on the debug malloc to detect leakage here */
    sk_uchar_free(s);
    s = NULL;

    /* dup again */
    if (sk_uchar_num(r) != n) {
        fprintf(stderr, "test uchar dup size %d\n", n);
        goto end;
    }

    /* zero */
    sk_uchar_zero(r);
    if (sk_uchar_num(r) != 0) {
        fprintf(stderr, "test uchar zero %d\n", n);
        goto end;
    }

    /* insert */
    sk_uchar_insert(r, v, 0);
    sk_uchar_insert(r, v + 2, -1);
    sk_uchar_insert(r, v + 1, 1);
    for (i = 0; i < 3; i++)
        if (sk_uchar_value(r, i) != v + i) {
            fprintf(stderr, "test uchar insert %d\n", i);
            goto end;
        }

    /* delete */
    if (sk_uchar_delete(r, 12) != NULL) {
        fprintf(stderr, "test uchar delete missing %d\n", n);
        goto end;
    }
    if (sk_uchar_delete(r, 1) != v + 1) {
        fprintf(stderr, "test uchar delete middle %d\n", n);
        goto end;
    }

    /* set */
    sk_uchar_set(r, 1, v + 1);
    for (i = 0; i < 2; i++)
        if (sk_uchar_value(r, i) != v + i) {
            fprintf(stderr, "test uchar set %d\n", i);
            goto end;
        }

    testresult = 1;
end:
    sk_uchar_free(r);
    sk_uchar_free(s);
    return testresult;
}

static SS *SS_copy(const SS *p)
{
    SS *q = OPENSSL_malloc(sizeof(*q));

    if (q != NULL)
        memcpy(q, p, sizeof(*q));
    return q;
}

static void SS_free(SS *p) {
    OPENSSL_free(p);
}

static int test_SS_stack(void)
{
    STACK_OF(SS) *s = sk_SS_new_null();
    STACK_OF(SS) *r = NULL;
    SS *v[10], *p;
    const int n = OSSL_NELEM(v);
    int i;
    int testresult = 0;

    /* allocate and push */
    for (i = 0; i < n; i++) {
        v[i] = OPENSSL_malloc(sizeof(*v[i]));

        if (v[i] == NULL) {
            fprintf(stderr, "test SS memory allocation failure\n");
            goto end;
        }
        v[i]->n = i;
        v[i]->c = 'A' + i;
        if (sk_SS_num(s) != i) {
            fprintf(stderr, "test SS stack size %d\n", i);
            goto end;
        }
        sk_SS_push(s, v[i]);
    }
    if (sk_SS_num(s) != n) {
        fprintf(stderr, "test SS size %d\n", n);
        goto end;
    }

    /* deepcopy */
    r = sk_SS_deep_copy(s, &SS_copy, &SS_free);
    if (r == NULL) {
        fprintf(stderr, "test SS deepcopy failure\n");
        goto end;
    }
    for (i = 0; i < n; i++) {
        p = sk_SS_value(r, i);
        if (p == v[i]) {
            fprintf(stderr, "test SS deepcopy non-copy %d\n", i);
            goto end;
        }
        if (p->n != v[i]->n || p->c != v[i]->c) {
            fprintf(stderr, "test SS deepcopy values %d\n", i);
            goto end;
        }
    }

    /* pop_free - we rely on the malloc debug to catch the leak */
    sk_SS_pop_free(r, &SS_free);
    r = NULL;

    /* delete_ptr */
    if ((p = sk_SS_delete_ptr(s, v[3])) == NULL) {
        fprintf(stderr, "test SS delete ptr not found\n");
        goto end;
    }
    SS_free(p);
    if (sk_SS_num(s) != n-1) {
        fprintf(stderr, "test SS delete ptr size\n");
        goto end;
    }
    for (i = 0; i < n-1; i++)
        if (sk_SS_value(s, i) != v[i<3 ? i : 1+i]) {
            fprintf(stderr, "test SS delete ptr item %d\n", i);
            goto end;
        }

    testresult = 1;
end:
    sk_SS_pop_free(r, &SS_free);
    sk_SS_pop_free(s, &SS_free);
    return testresult;
}

static int test_SU_stack(void)
{
    STACK_OF(SU) *s = sk_SU_new_null();
    SU v[10];
    const int n = OSSL_NELEM(v);
    int i;
    int testresult = 0;

    /* allocate and push */
    for (i = 0; i < n; i++) {
        if ((i & 1) == 0)
            v[i].n = i;
        else
            v[i].c = 'A' + i;
        if (sk_SU_num(s) != i) {
            fprintf(stderr, "test SU stack size %d\n", i);
            goto end;
        }
        sk_SU_push(s, v + i);
    }
    if (sk_SU_num(s) != n) {
        fprintf(stderr, "test SU size %d\n", n);
        goto end;
    }

    /* check the pointers are correct */
    for (i = 0; i < n; i++)
        if (sk_SU_value(s, i) != v + i) {
            fprintf(stderr, "test SU pointer check %d\n", i);
            goto end;
        }

    testresult = 1;
end:
    sk_SU_free(s);
    return testresult;
}

void register_tests(void)
{
    ADD_TEST(test_int_stack);
    ADD_TEST(test_uchar_stack);
    ADD_TEST(test_SS_stack);
    ADD_TEST(test_SU_stack);
}
Commit	Line	Data
98374961 P	1	/*
	2	* Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
	3	*
	4	* Licensed under the OpenSSL license (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
	8	*/
	9
	10	/* ====================================================================
	11	* Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.
	12	*/
	13
	14	#include <stdio.h>
	15	#include <string.h>
	16
	17	#include <openssl/opensslconf.h>
	18	#include <openssl/safestack.h>
	19	#include <openssl/err.h>
	20	#include <openssl/crypto.h>
	21
	22	#include "e_os.h"
	23	#include "test_main.h"
	24	#include "testutil.h"
	25
	26	/* The macros below generate unused functions which error out one of the clang
	27	* builds. We disable this check here.
	28	*/
	29	#ifdef __clang__
	30	#pragma clang diagnostic ignored "-Wunused-function"
	31	#endif
	32
	33	typedef struct {
	34	int n;
	35	char c;
	36	} SS;
	37
	38	typedef union {
	39	int n;
	40	char c;
	41	} SU;
	42
	43	DEFINE_SPECIAL_STACK_OF(sint, int)
	44	DEFINE_SPECIAL_STACK_OF_CONST(uchar, unsigned char)
	45	DEFINE_STACK_OF(SS)
	46	DEFINE_STACK_OF_CONST(SU)
	47
	48	static int int_compare(const int const a, const int const b)
	49	{
	50	if (a < b)
	51	return -1;
	52	if (a > b)
	53	return 1;
	54	return 0;
	55	}
	56
	57	static int test_int_stack(void)
	58	{
	59	static int v[] = { 1, 2, -4, 16, 999, 1, -173, 1, 9 };
3fb2c3e4	60	static int notpresent = -1;
98374961 P	61	const int n = OSSL_NELEM(v);
	62	static struct {
	63	int value;
	64	int unsorted;
	65	int sorted;
	66	int ex;
	67	} finds[] = {
	68	{ 2, 1, 5, 5 },
	69	{ 9, 7, 6, 6 },
	70	{ -173, 5, 0, 0 },
	71	{ 999, 3, 8, 8 },
	72	{ 0, -1, -1, 1 }
	73	};
	74	const int n_finds = OSSL_NELEM(finds);
	75	static struct {
	76	int value;
	77	int ex;
	78	} exfinds[] = {
	79	{ 3, 5 },
	80	{ 1000, 8 },
	81	{ 20, 8 },
	82	{ -999, 0 },
	83	{ -5, 0 },
	84	{ 8, 5 }
	85	};
	86	const int n_exfinds = OSSL_NELEM(exfinds);
	87	STACK_OF(sint) *s = sk_sint_new_null();
	88	int i;
	89	int testresult = 0;
	90
	91	/* Check push and num */
	92	for (i = 0; i < n; i++) {
	93	if (sk_sint_num(s) != i) {
	94	fprintf(stderr, "test int stack size %d\n", i);
	95	goto end;
	96	}
	97	sk_sint_push(s, v + i);
	98	}
	99	if (sk_sint_num(s) != n) {
	100	fprintf(stderr, "test int stack size %d\n", n);
	101	goto end;
	102	}
	103
	104	/* check the values */
	105	for (i = 0; i < n; i++)
	106	if (sk_sint_value(s, i) != v + i) {
	107	fprintf(stderr, "test int value %d\n", i);
	108	goto end;
	109	}
	110
	111	/* find unsorted -- the pointers are compared */
3fb2c3e4 MC	112	for (i = 0; i < n_finds; i++) {
	113	int *val = (finds[i].unsorted == -1) ? &notpresent
	114	: v + finds[i].unsorted;
	115
	116	if (sk_sint_find(s, val) != finds[i].unsorted) {
98374961 P	117	fprintf(stderr, "test int unsorted find %d\n", i);
	118	goto end;
	119	}
3fb2c3e4	120	}
98374961 P	121
98374961 P	122	/* find_ex unsorted */
3fb2c3e4 MC	123	for (i = 0; i < n_finds; i++) {
	124	int *val = (finds[i].unsorted == -1) ? &notpresent
	125	: v + finds[i].unsorted;
	126
	127	if (sk_sint_find_ex(s, val) != finds[i].unsorted) {
98374961 P	128	fprintf(stderr, "test int unsorted find_ex %d\n", i);
	129	goto end;
	130	}
3fb2c3e4	131	}
98374961 P	132
	133	/* sorting */
	134	if (sk_sint_is_sorted(s)) {
	135	fprintf(stderr, "test int unsorted\n");
	136	goto end;
	137	}
	138	sk_sint_set_cmp_func(s, &int_compare);
	139	sk_sint_sort(s);
	140	if (!sk_sint_is_sorted(s)) {
	141	fprintf(stderr, "test int sorted\n");
	142	goto end;
	143	}
	144
	145	/* find sorted -- the value is matched so we don't need to locate it */
	146	for (i = 0; i < n_finds; i++)
	147	if (sk_sint_find(s, &finds[i].value) != finds[i].sorted) {
	148	fprintf(stderr, "test int sorted find %d\n", i);
	149	goto end;
	150	}
	151
	152	/* find_ex sorted */
	153	for (i = 0; i < n_finds; i++)
	154	if (sk_sint_find_ex(s, &finds[i].value) != finds[i].ex) {
	155	fprintf(stderr, "test int sorted find_ex present %d\n", i);
	156	goto end;
	157	}
	158	for (i = 0; i < n_exfinds; i++)
	159	if (sk_sint_find_ex(s, &exfinds[i].value) != exfinds[i].ex) {
	160	fprintf(stderr, "test int sorted find_ex absent %d\n", i);
	161	goto end;
	162	}
	163
	164	/* shift */
	165	if (sk_sint_shift(s) != v + 6) {
	166	fprintf(stderr, "test int shift\n");
	167	goto end;
	168	}
	169
	170	testresult = 1;
	171	end:
	172	sk_sint_free(s);
	173	return testresult;
	174	}
	175
	176	static int uchar_compare(const unsigned char const a,
	177	const unsigned char const b)
	178	{
	179	return a - (signed int)b;
	180	}
	181
	182	static int test_uchar_stack(void)
	183	{
	184	static const unsigned char v[] = { 1, 3, 7, 5, 255, 0 };
	185	const int n = OSSL_NELEM(v);
	186	STACK_OF(uchar) s = sk_uchar_new(&uchar_compare), r = NULL;
	187	int i;
	188	int testresult = 0;
	189
	190	/* unshift and num */
	191	for (i = 0; i < n; i++) {
	192	if (sk_uchar_num(s) != i) {
	193	fprintf(stderr, "test uchar stack size %d\n", i);
	194	goto end;
	195	}
196	sk_uchar_unshift(s, v + i);
197	}
198	if (sk_uchar_num(s) != n) {
199	fprintf(stderr, "test uchar stack size %d\n", n);
200	goto end;
201	}
202
203	/* dup */
204	r = sk_uchar_dup(s);
205	if (sk_uchar_num(r) != n) {
206	fprintf(stderr, "test uchar dup size %d\n", n);
207	goto end;
208	}
209	sk_uchar_sort(r);
210
211	/* pop */
212	for (i = 0; i < n; i++)
213	if (sk_uchar_pop(s) != v + i) {
214	fprintf(stderr, "test uchar pop %d\n", i);
215	goto end;
216	}
217
218	/* free -- we rely on the debug malloc to detect leakage here */
219	sk_uchar_free(s);
220	s = NULL;
221
222	/* dup again */
223	if (sk_uchar_num(r) != n) {
224	fprintf(stderr, "test uchar dup size %d\n", n);
225	goto end;
226	}
227
228	/* zero */
229	sk_uchar_zero(r);
230	if (sk_uchar_num(r) != 0) {
231	fprintf(stderr, "test uchar zero %d\n", n);
232	goto end;
233	}
234
235	/* insert */
236	sk_uchar_insert(r, v, 0);
237	sk_uchar_insert(r, v + 2, -1);
238	sk_uchar_insert(r, v + 1, 1);
239	for (i = 0; i < 3; i++)
240	if (sk_uchar_value(r, i) != v + i) {
241	fprintf(stderr, "test uchar insert %d\n", i);
242	goto end;
243	}
244
245	/* delete */
246	if (sk_uchar_delete(r, 12) != NULL) {
247	fprintf(stderr, "test uchar delete missing %d\n", n);
248	goto end;
249	}
250	if (sk_uchar_delete(r, 1) != v + 1) {
251	fprintf(stderr, "test uchar delete middle %d\n", n);
252	goto end;
253	}
254
255	/* set */
256	sk_uchar_set(r, 1, v + 1);
257	for (i = 0; i < 2; i++)
258	if (sk_uchar_value(r, i) != v + i) {
259	fprintf(stderr, "test uchar set %d\n", i);
260	goto end;
261	}
262
263	testresult = 1;
264	end:
265	sk_uchar_free(r);
266	sk_uchar_free(s);
267	return testresult;
268	}
269
270	static SS SS_copy(const SS p)
271	{
272	SS q = OPENSSL_malloc(sizeof(q));
273
274	if (q != NULL)
275	memcpy(q, p, sizeof(*q));
276	return q;
277	}
278
279	static void SS_free(SS *p) {
280	OPENSSL_free(p);
281	}
282
283	static int test_SS_stack(void)
284	{
285	STACK_OF(SS) *s = sk_SS_new_null();
286	STACK_OF(SS) *r = NULL;
287	SS v[10], p;
288	const int n = OSSL_NELEM(v);
289	int i;
290	int testresult = 0;
291
292	/* allocate and push */
293	for (i = 0; i < n; i++) {
294	v[i] = OPENSSL_malloc(sizeof(*v[i]));
295
296	if (v[i] == NULL) {
297	fprintf(stderr, "test SS memory allocation failure\n");
298	goto end;
299	}
300	v[i]->n = i;
301	v[i]->c = 'A' + i;
302	if (sk_SS_num(s) != i) {
303	fprintf(stderr, "test SS stack size %d\n", i);
304	goto end;
305	}
306	sk_SS_push(s, v[i]);
307	}
308	if (sk_SS_num(s) != n) {
309	fprintf(stderr, "test SS size %d\n", n);
310	goto end;
311	}
312
313	/* deepcopy */
314	r = sk_SS_deep_copy(s, &SS_copy, &SS_free);
315	if (r == NULL) {
316	fprintf(stderr, "test SS deepcopy failure\n");
317	goto end;
318	}
319	for (i = 0; i < n; i++) {
320	p = sk_SS_value(r, i);
321	if (p == v[i]) {
322	fprintf(stderr, "test SS deepcopy non-copy %d\n", i);
323	goto end;
324	}
325	if (p->n != v[i]->n \|\| p->c != v[i]->c) {
326	fprintf(stderr, "test SS deepcopy values %d\n", i);
327	goto end;
328	}
329	}
330
331	/* pop_free - we rely on the malloc debug to catch the leak */
332	sk_SS_pop_free(r, &SS_free);
333	r = NULL;
334
335	/* delete_ptr */
336	if ((p = sk_SS_delete_ptr(s, v[3])) == NULL) {
337	fprintf(stderr, "test SS delete ptr not found\n");
338	goto end;
339	}
340	SS_free(p);
341	if (sk_SS_num(s) != n-1) {
342	fprintf(stderr, "test SS delete ptr size\n");
343	goto end;
344	}
345	for (i = 0; i < n-1; i++)
346	if (sk_SS_value(s, i) != v[i<3 ? i : 1+i]) {
347	fprintf(stderr, "test SS delete ptr item %d\n", i);
348	goto end;
349	}
350
351	testresult = 1;
352	end:
353	sk_SS_pop_free(r, &SS_free);
354	sk_SS_pop_free(s, &SS_free);
355	return testresult;
356	}
357
358	static int test_SU_stack(void)
359	{
360	STACK_OF(SU) *s = sk_SU_new_null();
361	SU v[10];
362	const int n = OSSL_NELEM(v);
363	int i;
364	int testresult = 0;
365
366	/* allocate and push */
367	for (i = 0; i < n; i++) {
368	if ((i & 1) == 0)
369	v[i].n = i;
370	else
371	v[i].c = 'A' + i;
372	if (sk_SU_num(s) != i) {
373	fprintf(stderr, "test SU stack size %d\n", i);
374	goto end;
375	}
376	sk_SU_push(s, v + i);
377	}
378	if (sk_SU_num(s) != n) {
379	fprintf(stderr, "test SU size %d\n", n);
380	goto end;
381	}
382
383	/* check the pointers are correct */
384	for (i = 0; i < n; i++)
385	if (sk_SU_value(s, i) != v + i) {
386	fprintf(stderr, "test SU pointer check %d\n", i);
387	goto end;
388	}
389
390	testresult = 1;
391	end:
392	sk_SU_free(s);
393	return testresult;
394	}
395
396	void register_tests(void)
397	{
398	ADD_TEST(test_int_stack);
399	ADD_TEST(test_uchar_stack);
400	ADD_TEST(test_SS_stack);
401	ADD_TEST(test_SU_stack);
402	}