static int testctx_eq(SSL_TEST_CTX *ctx, SSL_TEST_CTX *ctx2) { if (!TEST_int_eq(ctx->method, ctx2->method) || !TEST_int_eq(ctx->handshake_mode, ctx2->handshake_mode) || !TEST_int_eq(ctx->app_data_size, ctx2->app_data_size) || !TEST_int_eq(ctx->max_fragment_size, ctx2->max_fragment_size) || !extraconf_eq(&ctx->extra, &ctx2->extra) || !extraconf_eq(&ctx->resume_extra, &ctx2->resume_extra) || !TEST_int_eq(ctx->expected_result, ctx2->expected_result) || !TEST_int_eq(ctx->expected_client_alert, ctx2->expected_client_alert) || !TEST_int_eq(ctx->expected_server_alert, ctx2->expected_server_alert) || !TEST_int_eq(ctx->expected_protocol, ctx2->expected_protocol) || !TEST_int_eq(ctx->expected_servername, ctx2->expected_servername) || !TEST_int_eq(ctx->session_ticket_expected, ctx2->session_ticket_expected) || !TEST_int_eq(ctx->compression_expected, ctx2->compression_expected) || !TEST_str_eq(ctx->expected_npn_protocol, ctx2->expected_npn_protocol) || !TEST_str_eq(ctx->expected_alpn_protocol, ctx2->expected_alpn_protocol) || !TEST_int_eq(ctx->resumption_expected, ctx2->resumption_expected)) return 0; return 1; }
static int test_v3(void) { STACK_OF(SSL_CIPHER) *sk = NULL, *scsv = NULL; /* ECDHE-ECDSA-AES256GCM, ECDHE-ECDSA-CHACHAPOLY, DHE-RSA-AES256GCM, * EMPTY-RENEGOTIATION-INFO-SCSV, FALLBACK-SCSV */ const unsigned char bytes[] = {0x00, 0x2f, 0x00, 0x33, 0x00, 0x9f, 0x00, 0xff, 0x56, 0x00}; int ret = 0; if (!SSL_bytes_to_cipher_list(s, bytes, sizeof(bytes), 0, &sk, &scsv) || !TEST_ptr(sk) || !TEST_int_eq(sk_SSL_CIPHER_num(sk), 3) || !TEST_ptr(scsv) || !TEST_int_eq(sk_SSL_CIPHER_num(scsv), 2) || !TEST_str_eq(SSL_CIPHER_get_name(sk_SSL_CIPHER_value(sk, 0)), "AES128-SHA") || !TEST_str_eq(SSL_CIPHER_get_name(sk_SSL_CIPHER_value(sk, 1)), "DHE-RSA-AES128-SHA") || !TEST_str_eq(SSL_CIPHER_get_name(sk_SSL_CIPHER_value(sk, 2)), "DHE-RSA-AES256-GCM-SHA384") || !TEST_str_eq(SSL_CIPHER_get_name(sk_SSL_CIPHER_value(scsv, 0)), "TLS_EMPTY_RENEGOTIATION_INFO_SCSV") || !TEST_str_eq(SSL_CIPHER_get_name(sk_SSL_CIPHER_value(scsv, 1)), "TLS_FALLBACK_SCSV")) goto err; ret = 1; err: sk_SSL_CIPHER_free(sk); sk_SSL_CIPHER_free(scsv); return ret; }
static int check_alpn(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx) { int ret = 1; if (!TEST_str_eq(result->client_alpn_negotiated, result->server_alpn_negotiated)) ret = 0; if (!TEST_str_eq(test_ctx->expected_alpn_protocol, result->client_alpn_negotiated)) ret = 0; return ret; }
static int clientconf_eq(SSL_TEST_CLIENT_CONF *conf1, SSL_TEST_CLIENT_CONF *conf2) { if (!TEST_int_eq(conf1->verify_callback, conf2->verify_callback) || !TEST_int_eq(conf1->servername, conf2->servername) || !TEST_str_eq(conf1->npn_protocols, conf2->npn_protocols) || !TEST_str_eq(conf1->alpn_protocols, conf2->alpn_protocols) || !TEST_int_eq(conf1->ct_validation, conf2->ct_validation)) return 0; return 1; }
static int serverconf_eq(SSL_TEST_SERVER_CONF *serv, SSL_TEST_SERVER_CONF *serv2) { if (!TEST_int_eq(serv->servername_callback, serv2->servername_callback) || !TEST_str_eq(serv->npn_protocols, serv2->npn_protocols) || !TEST_str_eq(serv->alpn_protocols, serv2->alpn_protocols) || !TEST_int_eq(serv->broken_session_ticket, serv2->broken_session_ticket) || !TEST_int_eq(serv->cert_status, serv2->cert_status)) return 0; return 1; }
static int test_PACKET_strndup() { char buf1[10], buf2[10]; char *data = NULL; PACKET pkt; int result = 0; memset(buf1, 'x', 10); memset(buf2, 'y', 10); buf2[5] = '\0'; if (!TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf1, 10)) || !TEST_true(PACKET_strndup(&pkt, &data)) || !TEST_size_t_eq(strlen(data), 10) || !TEST_strn_eq(data, buf1, 10) || !TEST_true(PACKET_buf_init(&pkt, (unsigned char*)buf2, 10)) || !TEST_true(PACKET_strndup(&pkt, &data)) || !TEST_size_t_eq(strlen(data), 5) || !TEST_str_eq(data, buf2)) goto end; result = 1; end: OPENSSL_free(data); return result; }
static int dofptest(int test, double val, const char *width, int prec) { static const char *fspecs[] = { "e", "f", "g", "E", "G" }; char format[80], result[80]; int ret = 1, i; for (i = 0; i < nelem(fspecs); i++) { const char *fspec = fspecs[i]; if (prec >= 0) BIO_snprintf(format, sizeof(format), "%%%s.%d%s", width, prec, fspec); else BIO_snprintf(format, sizeof(format), "%%%s%s", width, fspec); BIO_snprintf(result, sizeof(result), format, val); if (justprint) { if (i == 0) printf(" /* %d */ { \"%s\"", test, result); else printf(", \"%s\"", result); } else if (!TEST_str_eq(fpexpected[test][i], result)) { TEST_info("test %d format=|%s| exp=|%s|, ret=|%s|", test, format, fpexpected[test][i], result); ret = 0; } } if (justprint) printf(" },\n"); return ret; }
static int test_j(int i) { const j_data *data = &jf_data[i]; char bio_buf[80]; BIO_snprintf(bio_buf, sizeof(bio_buf) - 1, data->format, data->value); if (!TEST_str_eq(bio_buf, data->expected)) return 0; return 1; }
static int client_setup_sni_after_state(void) { SSL_CTX *ctx; SSL *con = NULL; BIO *rbio; BIO *wbio; char *hostname = NULL; int ret = 0; /* use TLS_method to blur 'side' */ ctx = SSL_CTX_new(TLS_method()); if (!TEST_ptr(ctx)) goto end; con = SSL_new(ctx); if (!TEST_ptr(con)) goto end; rbio = BIO_new(BIO_s_mem()); wbio = BIO_new(BIO_s_mem()); if (!TEST_ptr(rbio)|| !TEST_ptr(wbio)) { BIO_free(rbio); BIO_free(wbio); goto end; } SSL_set_bio(con, rbio, wbio); SSL_set_connect_state(con); /* set SNI after 'client side' is set */ SSL_set_tlsext_host_name(con, host); if (!TEST_int_le(SSL_connect(con), 0)) /* This shouldn't succeed because we don't have a server! */ goto end; if (!TEST_true(get_sni_from_client_hello(wbio, &hostname))) /* no SNI in client hello */ goto end; if (!TEST_str_eq(hostname, host)) /* incorrect SNI value */ goto end; ret = 1; end: OPENSSL_free(hostname); SSL_free(con); SSL_CTX_free(ctx); return ret; }
static int test_md2(int n) { char buf[80]; unsigned char md[MD2_DIGEST_LENGTH]; int i; if (!TEST_true(EVP_Digest((unsigned char *)test[n], strlen(test[n]), md, NULL, EVP_md2(), NULL))) return 0; for (i = 0; i < MD2_DIGEST_LENGTH; i++) sprintf(&(buf[i * 2]), "%02x", md[i]); if (!TEST_str_eq(buf, ret[n])) return 0; return 1; }
/* Test of UI. This uses the UI method defined in apps/apps.c */ static int test_new_ui(void) { PW_CB_DATA cb_data = { "password", "prompt" }; char pass[16]; int ok = 0; setup_ui_method(); if (TEST_int_gt(password_callback(pass, sizeof(pass), 0, &cb_data), 0) && TEST_str_eq(pass, cb_data.password)) ok = 1; destroy_ui_method(); return ok; }
static int test_provider(OSSL_PROVIDER *prov, const char *expected_greeting) { const char *greeting = NULL; int ret = 0; ret = TEST_true(ossl_provider_activate(prov)) && TEST_true(ossl_provider_get_params(prov, greeting_request)) && TEST_ptr(greeting = greeting_request[0].data) && TEST_size_t_gt(greeting_request[0].data_size, 0) && TEST_str_eq(greeting, expected_greeting); TEST_info("Got this greeting: %s\n", greeting); ossl_provider_free(prov); return ret; }
static int test_provider(const char *name) { OSSL_PROVIDER *prov = NULL; const char *greeting = NULL; char expected_greeting[256]; BIO_snprintf(expected_greeting, sizeof(expected_greeting), "Hello OpenSSL %.20s, greetings from %s!", OPENSSL_VERSION_STR, name); return TEST_ptr(prov = OSSL_PROVIDER_load(NULL, name)) && TEST_true(OSSL_PROVIDER_get_params(prov, greeting_request)) && TEST_ptr(greeting = greeting_request[0].data) && TEST_size_t_gt(greeting_request[0].data_size, 0) && TEST_str_eq(greeting, expected_greeting) && TEST_true(OSSL_PROVIDER_unload(prov)); }
static int check_session_ticket_app_data(HANDSHAKE_RESULT *result, SSL_TEST_CTX *test_ctx) { size_t result_len = 0; size_t expected_len = 0; /* consider empty and NULL strings to be the same */ if (result->result_session_ticket_app_data != NULL) result_len = strlen(result->result_session_ticket_app_data); if (test_ctx->expected_session_ticket_app_data != NULL) expected_len = strlen(test_ctx->expected_session_ticket_app_data); if (result_len == 0 && expected_len == 0) return 1; if (!TEST_str_eq(result->result_session_ticket_app_data, test_ctx->expected_session_ticket_app_data)) return 0; return 1; }
/* * Test wrapping old style PEM password callback in a UI method through the * use of UI utility functions */ static int test_old(void) { UI_METHOD *ui_method = NULL; UI *ui = NULL; char defpass[] = "password"; char pass[16]; int ok = 0; if (!TEST_ptr(ui_method = UI_UTIL_wrap_read_pem_callback( test_pem_password_cb, 0)) || !TEST_ptr(ui = UI_new_method(ui_method))) goto err; /* The wrapper passes the UI userdata as the callback userdata param */ UI_add_user_data(ui, defpass); if (!UI_add_input_string(ui, "prompt", UI_INPUT_FLAG_DEFAULT_PWD, pass, 0, sizeof(pass) - 1)) goto err; switch (UI_process(ui)) { case -2: TEST_info("test_old: UI process interrupted or cancelled"); /* fall through */ case -1: goto err; default: break; } if (TEST_str_eq(pass, defpass)) ok = 1; err: UI_free(ui); UI_destroy_method(ui_method); return ok; }
static int test_unsupported(void) { STACK_OF(SSL_CIPHER) *sk, *scsv; /* ECDH-RSA-AES256 (unsupported), ECDHE-ECDSA-AES128, <unassigned> */ const unsigned char bytes[] = {0xc0, 0x0f, 0x00, 0x2f, 0x01, 0x00}; int ret = 0; if (!TEST_true(SSL_bytes_to_cipher_list(s, bytes, sizeof(bytes), 0, &sk, &scsv)) || !TEST_ptr(sk) || !TEST_int_eq(sk_SSL_CIPHER_num(sk), 1) || !TEST_ptr(scsv) || !TEST_int_eq(sk_SSL_CIPHER_num(scsv), 0) || !TEST_str_eq(SSL_CIPHER_get_name(sk_SSL_CIPHER_value(sk, 0)), "AES128-SHA")) goto err; ret = 1; err: sk_SSL_CIPHER_free(sk); sk_SSL_CIPHER_free(scsv); return ret; }
static int test_sparse_array(void) { static const struct { size_t n; char *v; } cases[] = { { 22, "a" }, { 0, "z" }, { 1, "b" }, { 290, "c" }, { INT_MAX, "m" }, { 6666666, "d" }, { (size_t)-1, "H" }, { 99, "e" } }; SPARSE_ARRAY_OF(char) *sa; size_t i, j; int res = 0; if (!TEST_ptr(sa = ossl_sa_char_new()) || !TEST_ptr_null(ossl_sa_char_get(sa, 3)) || !TEST_ptr_null(ossl_sa_char_get(sa, 0)) || !TEST_ptr_null(ossl_sa_char_get(sa, UINT_MAX))) goto err; for (i = 0; i < OSSL_NELEM(cases); i++) { if (!TEST_true(ossl_sa_char_set(sa, cases[i].n, cases[i].v))) { TEST_note("iteration %zu", i + 1); goto err; } for (j = 0; j <= i; j++) if (!TEST_str_eq(ossl_sa_char_get(sa, cases[j].n), cases[j].v)) { TEST_note("iteration %zu / %zu", i + 1, j + 1); goto err; } } res = 1; err: ossl_sa_char_free(sa); return res; }
static int test_cipher_name(void) { SSL_CTX *ctx = NULL; SSL *ssl = NULL; const SSL_CIPHER *c; STACK_OF(SSL_CIPHER) *sk = NULL; const char *ciphers = "ALL:eNULL", *p, *q, *r; int i, id = 0, ret = 0; /* tests for invalid input */ p = SSL_CIPHER_standard_name(NULL); if (!TEST_str_eq(p, "(NONE)")) { TEST_info("test_cipher_name(std) failed: NULL input doesn't return \"(NONE)\"\n"); goto err; } p = OPENSSL_cipher_name(NULL); if (!TEST_str_eq(p, "(NONE)")) { TEST_info("test_cipher_name(ossl) failed: NULL input doesn't return \"(NONE)\"\n"); goto err; } p = OPENSSL_cipher_name("This is not a valid cipher"); if (!TEST_str_eq(p, "(NONE)")) { TEST_info("test_cipher_name(ossl) failed: invalid input doesn't return \"(NONE)\"\n"); goto err; } /* tests for valid input */ ctx = SSL_CTX_new(TLS_server_method()); if (ctx == NULL) { TEST_info("test_cipher_name failed: internal error\n"); goto err; } if (!SSL_CTX_set_cipher_list(ctx, ciphers)) { TEST_info("test_cipher_name failed: internal error\n"); goto err; } ssl = SSL_new(ctx); if (ssl == NULL) { TEST_info("test_cipher_name failed: internal error\n"); goto err; } sk = SSL_get_ciphers(ssl); if (sk == NULL) { TEST_info("test_cipher_name failed: internal error\n"); goto err; } for (i = 0; i < sk_SSL_CIPHER_num(sk); i++) { c = sk_SSL_CIPHER_value(sk, i); id = SSL_CIPHER_get_id(c) & 0xFFFF; if ((id == 0xFF85) || (id == 0xFF87)) /* skip GOST2012-GOST8912-GOST891 and GOST2012-NULL-GOST12 */ continue; p = SSL_CIPHER_standard_name(c); q = get_std_name_by_id(id); if (!TEST_ptr(p)) { TEST_info("test_cipher_name failed: expected %s, got NULL, cipher %x\n", q, id); goto err; } /* check if p is a valid standard name */ if (!TEST_str_eq(p, q)) { TEST_info("test_cipher_name(std) failed: expected %s, got %s, cipher %x\n", q, p, id); goto err; } /* test OPENSSL_cipher_name */ q = SSL_CIPHER_get_name(c); r = OPENSSL_cipher_name(p); if (!TEST_str_eq(r, q)) { TEST_info("test_cipher_name(ossl) failed: expected %s, got %s, cipher %x\n", q, r, id); goto err; } } ret = 1; err: SSL_CTX_free(ctx); SSL_free(ssl); return ret; }
static int test_param_construct(void) { static const char *int_names[] = { "int", "long", "int32", "int64" }; static const char *uint_names[] = { "uint", "ulong", "uint32", "uint64", "size_t" }; static const unsigned char bn_val[16] = { 0xac, 0x75, 0x22, 0x7d, 0x81, 0x06, 0x7a, 0x23, 0xa6, 0xed, 0x87, 0xc7, 0xab, 0xf4, 0x73, 0x22 }; OSSL_PARAM params[20]; char buf[100], buf2[100], *bufp, *bufp2; unsigned char ubuf[100]; void *vp, *vpn = NULL, *vp2; OSSL_PARAM *p; const OSSL_PARAM *cp; static const OSSL_PARAM pend = OSSL_PARAM_END; int i, n = 0, ret = 0; unsigned int u; long int l; unsigned long int ul; int32_t i32; uint32_t u32; int64_t i64; uint64_t u64; size_t j, k, s, sz; double d, d2; BIGNUM *bn = NULL, *bn2 = NULL; params[n++] = OSSL_PARAM_construct_int("int", &i, &sz); params[n++] = OSSL_PARAM_construct_uint("uint", &u, &sz); params[n++] = OSSL_PARAM_construct_long("long", &l, &sz); params[n++] = OSSL_PARAM_construct_ulong("ulong", &ul, &sz); params[n++] = OSSL_PARAM_construct_int32("int32", &i32, &sz); params[n++] = OSSL_PARAM_construct_int64("int64", &i64, &sz); params[n++] = OSSL_PARAM_construct_uint32("uint32", &u32, &sz); params[n++] = OSSL_PARAM_construct_uint64("uint64", &u64, &sz); params[n++] = OSSL_PARAM_construct_size_t("size_t", &s, &sz); params[n++] = OSSL_PARAM_construct_double("double", &d, &sz); params[n++] = OSSL_PARAM_construct_BN("bignum", ubuf, sizeof(ubuf), &sz); params[n++] = OSSL_PARAM_construct_utf8_string("utf8str", buf, sizeof(buf), &sz); params[n++] = OSSL_PARAM_construct_octet_string("octstr", buf, sizeof(buf), &sz); params[n++] = OSSL_PARAM_construct_utf8_ptr("utf8ptr", &bufp, &sz); params[n++] = OSSL_PARAM_construct_octet_ptr("octptr", &vp, &sz); params[n] = pend; /* Search failure */ if (!TEST_ptr_null(OSSL_PARAM_locate(params, "fnord"))) goto err; /* All signed integral types */ for (j = 0; j < OSSL_NELEM(int_names); j++) { if (!TEST_ptr(cp = OSSL_PARAM_locate(params, int_names[j])) || !TEST_true(OSSL_PARAM_set_int32(cp, (int32_t)(3 + j))) || !TEST_true(OSSL_PARAM_get_int64(cp, &i64)) || !TEST_size_t_eq(cp->data_size, sz) || !TEST_size_t_eq((size_t)i64, 3 + j)) { TEST_note("iteration %zu var %s", j + 1, int_names[j]); goto err; } } /* All unsigned integral types */ for (j = 0; j < OSSL_NELEM(uint_names); j++) { if (!TEST_ptr(cp = OSSL_PARAM_locate(params, uint_names[j])) || !TEST_true(OSSL_PARAM_set_uint32(cp, (uint32_t)(3 + j))) || !TEST_true(OSSL_PARAM_get_uint64(cp, &u64)) || !TEST_size_t_eq(cp->data_size, sz) || !TEST_size_t_eq((size_t)u64, 3 + j)) { TEST_note("iteration %zu var %s", j + 1, uint_names[j]); goto err; } } /* Real */ if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "double")) || !TEST_true(OSSL_PARAM_set_double(cp, 3.14)) || !TEST_true(OSSL_PARAM_get_double(cp, &d2)) || !TEST_size_t_eq(sz, sizeof(double)) || !TEST_double_eq(d, d2)) goto err; /* UTF8 string */ bufp = NULL; if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "utf8str")) || !TEST_true(OSSL_PARAM_set_utf8_string(cp, "abcdef")) || !TEST_size_t_eq(sz, sizeof("abcdef")) || !TEST_true(OSSL_PARAM_get_utf8_string(cp, &bufp, 0)) || !TEST_str_eq(bufp, "abcdef")) goto err; OPENSSL_free(bufp); bufp = buf2; if (!TEST_true(OSSL_PARAM_get_utf8_string(cp, &bufp, sizeof(buf2))) || !TEST_str_eq(buf2, "abcdef")) goto err; /* UTF8 pointer */ bufp = buf; sz = 0; if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "utf8ptr")) || !TEST_true(OSSL_PARAM_set_utf8_ptr(cp, "tuvwxyz")) || !TEST_size_t_eq(sz, sizeof("tuvwxyz")) || !TEST_str_eq(bufp, "tuvwxyz") || !TEST_true(OSSL_PARAM_get_utf8_ptr(cp, (const char **)&bufp2)) || !TEST_ptr_eq(bufp2, bufp)) goto err; /* OCTET string */ if (!TEST_ptr(p = locate(params, "octstr")) || !TEST_true(OSSL_PARAM_set_octet_string(p, "abcdefghi", sizeof("abcdefghi"))) || !TEST_size_t_eq(sz, sizeof("abcdefghi"))) goto err; /* Match the return size to avoid trailing garbage bytes */ p->data_size = *p->return_size; if (!TEST_true(OSSL_PARAM_get_octet_string(p, &vpn, 0, &s)) || !TEST_size_t_eq(s, sizeof("abcdefghi")) || !TEST_mem_eq(vpn, sizeof("abcdefghi"), "abcdefghi", sizeof("abcdefghi"))) goto err; vp = buf2; if (!TEST_true(OSSL_PARAM_get_octet_string(p, &vp, sizeof(buf2), &s)) || !TEST_size_t_eq(s, sizeof("abcdefghi")) || !TEST_mem_eq(vp, sizeof("abcdefghi"), "abcdefghi", sizeof("abcdefghi"))) goto err; /* OCTET pointer */ vp = &l; sz = 0; if (!TEST_ptr(p = locate(params, "octptr")) || !TEST_true(OSSL_PARAM_set_octet_ptr(p, &ul, sizeof(ul))) || !TEST_size_t_eq(sz, sizeof(ul)) || !TEST_ptr_eq(vp, &ul)) goto err; /* Match the return size to avoid trailing garbage bytes */ p->data_size = *p->return_size; if (!TEST_true(OSSL_PARAM_get_octet_ptr(p, (const void **)&vp2, &k)) || !TEST_size_t_eq(k, sizeof(ul)) || !TEST_ptr_eq(vp2, vp)) goto err; /* BIGNUM */ if (!TEST_ptr(p = locate(params, "bignum")) || !TEST_ptr(bn = BN_lebin2bn(bn_val, (int)sizeof(bn_val), NULL)) || !TEST_true(OSSL_PARAM_set_BN(p, bn)) || !TEST_size_t_eq(sz, sizeof(bn_val))) goto err; /* Match the return size to avoid trailing garbage bytes */ p->data_size = *p->return_size; if(!TEST_true(OSSL_PARAM_get_BN(p, &bn2)) || !TEST_BN_eq(bn, bn2)) goto err; ret = 1; err: OPENSSL_free(vpn); BN_free(bn); BN_free(bn2); return ret; }
static int test_property(void) { static const struct { int nid; const char *prop; char *impl; } impls[] = { { 1, "fast=no, colour=green", "a" }, { 1, "fast, colour=blue", "b" }, { 1, "", "-" }, { 9, "sky=blue, furry", "c" }, { 3, NULL, "d" }, { 6, "sky.colour=blue, sky=green, old.data", "e" }, }; static struct { int nid; const char *prop; char *expected; } queries[] = { { 1, "fast", "b" }, { 1, "fast=yes", "b" }, { 1, "fast=no, colour=green", "a" }, { 1, "colour=blue, fast", "b" }, { 1, "colour=blue", "b" }, { 9, "furry", "c" }, { 6, "sky.colour=blue", "e" }, { 6, "old.data", "e" }, { 9, "furry=yes, sky=blue", "c" }, { 1, "", "a" }, { 3, "", "d" }, }; OSSL_METHOD_STORE *store; size_t i; int ret = 0; void *result; if (!TEST_ptr(store = ossl_method_store_new(NULL)) || !add_property_names("fast", "colour", "sky", "furry", NULL)) goto err; for (i = 0; i < OSSL_NELEM(impls); i++) if (!TEST_true(ossl_method_store_add(store, impls[i].nid, impls[i].prop, impls[i].impl, NULL))) { TEST_note("iteration %zd", i + 1); goto err; } for (i = 0; i < OSSL_NELEM(queries); i++) { OSSL_PROPERTY_LIST *pq = NULL; if (!TEST_true(ossl_method_store_fetch(store, queries[i].nid, queries[i].prop, &result)) || !TEST_str_eq((char *)result, queries[i].expected)) { TEST_note("iteration %zd", i + 1); ossl_property_free(pq); goto err; } ossl_property_free(pq); } ret = 1; err: ossl_method_store_free(store); return ret; }