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

/*
 * Copyright 2017-2021 The OpenSSL Project Authors. All Rights Reserved.
 * Copyright (c) 2017, Oracle and/or its affiliates.  All rights reserved.
 *
 * Licensed under the Apache License 2.0 (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
 */

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

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

#include "internal/nelem.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(int reserve)
{
    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;

    if (!TEST_ptr(s)
        || (reserve > 0 && !TEST_true(sk_sint_reserve(s, 5 * reserve))))
        goto end;

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

    /* check the values */
    for (i = 0; i < n; i++)
        if (!TEST_ptr_eq(sk_sint_value(s, i), v + i)) {
            TEST_info("int value %d", 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 (!TEST_int_eq(sk_sint_find(s, val), finds[i].unsorted)) {
            TEST_info("int unsorted find %d", 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 (!TEST_int_eq(sk_sint_find_ex(s, val), finds[i].unsorted)) {
            TEST_info("int unsorted find_ex %d", i);
            goto end;
        }
    }

    /* sorting */
    if (!TEST_false(sk_sint_is_sorted(s)))
        goto end;
    (void)sk_sint_set_cmp_func(s, &int_compare);
    sk_sint_sort(s);
    if (!TEST_true(sk_sint_is_sorted(s)))
        goto end;

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

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

    /* shift */
    if (!TEST_ptr_eq(sk_sint_shift(s), v + 6))
        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(int reserve)
{
    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;

    if (!TEST_ptr(s)
        || (reserve > 0 && !TEST_true(sk_uchar_reserve(s, 5 * reserve))))
        goto end;

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

    /* dup */
    r = sk_uchar_dup(NULL);
    if (sk_uchar_num(r) != 0)
        goto end;
    sk_uchar_free(r);
    r = sk_uchar_dup(s);
    if (!TEST_int_eq(sk_uchar_num(r), n))
        goto end;
    sk_uchar_sort(r);

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

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

    /* dup again */
    if (!TEST_int_eq(sk_uchar_num(r), n))
        goto end;

    /* zero */
    sk_uchar_zero(r);
    if (!TEST_int_eq(sk_uchar_num(r), 0))
        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 (!TEST_ptr_eq(sk_uchar_value(r, i), v + i)) {
            TEST_info("uchar insert %d", i);
            goto end;
        }

    /* delete */
    if (!TEST_ptr_null(sk_uchar_delete(r, 12)))
        goto end;
    if (!TEST_ptr_eq(sk_uchar_delete(r, 1), v + 1))
        goto end;

    /* set */
    (void)sk_uchar_set(r, 1, v + 1);
    for (i = 0; i < 2; i++)
        if (!TEST_ptr_eq(sk_uchar_value(r, i), v + i)) {
            TEST_info("uchar set %d", 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 (!TEST_ptr(v[i]))
            goto end;
        v[i]->n = i;
        v[i]->c = 'A' + i;
        if (!TEST_int_eq(sk_SS_num(s), i)) {
            TEST_info("SS stack size %d", i);
            goto end;
        }
        sk_SS_push(s, v[i]);
    }
    if (!TEST_int_eq(sk_SS_num(s), n))
        goto end;

    /* deepcopy */
    r = sk_SS_deep_copy(NULL, &SS_copy, &SS_free);
    if (sk_SS_num(r) != 0)
        goto end;
    sk_SS_free(r);
    r = sk_SS_deep_copy(s, &SS_copy, &SS_free);
    if (!TEST_ptr(r))
        goto end;
    for (i = 0; i < n; i++) {
        p = sk_SS_value(r, i);
        if (!TEST_ptr_ne(p, v[i])) {
            TEST_info("SS deepcopy non-copy %d", i);
            goto end;
        }
        if (!TEST_int_eq(p->n, v[i]->n)) {
            TEST_info("test SS deepcopy int %d", i);
            goto end;
        }
        if (!TEST_char_eq(p->c, v[i]->c)) {
            TEST_info("SS deepcopy char %d", 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 */
    p = sk_SS_delete_ptr(s, v[3]);
    if (!TEST_ptr(p))
        goto end;
    SS_free(p);
    if (!TEST_int_eq(sk_SS_num(s), n - 1))
        goto end;
    for (i = 0; i < n-1; i++)
        if (!TEST_ptr_eq(sk_SS_value(s, i), v[i<3 ? i : 1+i])) {
            TEST_info("SS delete ptr item %d", 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 (!TEST_int_eq(sk_SU_num(s), i)) {
            TEST_info("SU stack size %d", i);
            goto end;
        }
        sk_SU_push(s, v + i);
    }
    if (!TEST_int_eq(sk_SU_num(s), n))
        goto end;

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

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

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