root
/
openssl
mirror of https://github.com/openssl/openssl.git
1
0
Fork 0
Code Issues Actions 7 Packages Projects Releases Wiki Activity

Update threadstest to use the test framework 

Reviewed-by: Matt Caswell <matt@openssl.org>
Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3196)
This commit is contained in:
Pauli 2017-04-12 14:24:21 +10:00 committed by Richard Levitte
parent bea4ac2b2e
commit ee25dd45cb
2 changed files with 27 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
test/build.info
View File

@ -231,7 +231,7 @@ IF[{- !$disabled{tests} -}]
INCLUDE[ct_test]=../crypto/include ../include INCLUDE[ct_test]=../crypto/include ../include
DEPEND[ct_test]=../libcrypto DEPEND[ct_test]=../libcrypto
SOURCE[threadstest]=threadstest.c SOURCE[threadstest]=threadstest.c testutil.c test_main.c
INCLUDE[threadstest]=.. ../include INCLUDE[threadstest]=.. ../include
DEPEND[threadstest]=../libcrypto DEPEND[threadstest]=../libcrypto

105
test/threadstest.c
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2016 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2016-2017 The OpenSSL Project Authors. All Rights Reserved.
* *
* Licensed under the OpenSSL license (the "License"). You may not use * Licensed under the OpenSSL license (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy * this file except in compliance with the License. You can obtain a copy
@ -11,9 +11,9 @@
# include <windows.h> # include <windows.h>
#endif #endif
#include <stdio.h>
#include <openssl/crypto.h> #include <openssl/crypto.h>
#include "test_main.h"
#include "testutil.h"
#if !defined(OPENSSL_THREADS) || defined(CRYPTO_TDEBUG) #if !defined(OPENSSL_THREADS) || defined(CRYPTO_TDEBUG)
@ -85,15 +85,9 @@ static int test_lock(void)
{ {
CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new(); CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();
if (!CRYPTO_THREAD_read_lock(lock)) { if (!TEST_true(CRYPTO_THREAD_read_lock(lock))
fprintf(stderr, "CRYPTO_THREAD_read_lock() failed\n"); || !TEST_true(CRYPTO_THREAD_unlock(lock)))
return 0; return 0;
}
if (!CRYPTO_THREAD_unlock(lock)) {
fprintf(stderr, "CRYPTO_THREAD_unlock() failed\n");
return 0;
}
CRYPTO_THREAD_lock_free(lock); CRYPTO_THREAD_lock_free(lock);
@ -116,23 +110,12 @@ static void once_run_thread_cb(void)
static int test_once(void) static int test_once(void)
{ {
thread_t thread; thread_t thread;
if (!run_thread(&thread, once_run_thread_cb) ||
!wait_for_thread(thread))
{
fprintf(stderr, "run_thread() failed\n");
return 0;
}
if (!CRYPTO_THREAD_run_once(&once_run, once_do_run)) { if (!TEST_true(run_thread(&thread, once_run_thread_cb))
fprintf(stderr, "CRYPTO_THREAD_run_once() failed\n"); || !TEST_true(wait_for_thread(thread))
|| !CRYPTO_THREAD_run_once(&once_run, once_do_run)
|| !TEST_int_eq(once_run_count, 1))
return 0; return 0;
}
if (once_run_count != 1) {
fprintf(stderr, "once run %u times\n", once_run_count);
return 0;
}
return 1; return 1;
} }
@ -157,21 +140,14 @@ static void thread_local_thread_cb(void)
void *ptr; void *ptr;
ptr = CRYPTO_THREAD_get_local(&thread_local_key); ptr = CRYPTO_THREAD_get_local(&thread_local_key);
if (ptr != NULL) { if (!TEST_ptr_null(ptr)
fprintf(stderr, "ptr not NULL\n"); || !TEST_true(CRYPTO_THREAD_set_local(&thread_local_key,
&destructor_run_count)))
return; return;
}
if (!CRYPTO_THREAD_set_local(&thread_local_key, &destructor_run_count)) {
fprintf(stderr, "CRYPTO_THREAD_set_local() failed\n");
return;
}
ptr = CRYPTO_THREAD_get_local(&thread_local_key); ptr = CRYPTO_THREAD_get_local(&thread_local_key);
if (ptr != &destructor_run_count) { if (!TEST_ptr_eq(ptr, &destructor_run_count))
fprintf(stderr, "invalid ptr\n");
return; return;
}
thread_local_thread_cb_ok = 1; thread_local_thread_cb_ok = 1;
} }
@ -181,66 +157,37 @@ static int test_thread_local(void)
thread_t thread; thread_t thread;
void *ptr = NULL; void *ptr = NULL;
if (!CRYPTO_THREAD_init_local(&thread_local_key, thread_local_destructor)) { if (!TEST_true(CRYPTO_THREAD_init_local(&thread_local_key,
fprintf(stderr, "CRYPTO_THREAD_init_local() failed\n"); thread_local_destructor)))
return 0; return 0;
}
ptr = CRYPTO_THREAD_get_local(&thread_local_key); ptr = CRYPTO_THREAD_get_local(&thread_local_key);
if (ptr != NULL) { if (!TEST_ptr_null(ptr)
fprintf(stderr, "ptr not NULL\n"); || !TEST_true(run_thread(&thread, thread_local_thread_cb))
|| !TEST_true(wait_for_thread(thread))
|| !TEST_int_eq(thread_local_thread_cb_ok, 1))
return 0; return 0;
}
if (!run_thread(&thread, thread_local_thread_cb) ||
!wait_for_thread(thread))
{
fprintf(stderr, "run_thread() failed\n");
return 0;
}
if (thread_local_thread_cb_ok != 1) {
fprintf(stderr, "thread-local thread callback failed\n");
return 0;
}
#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) #if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG)
ptr = CRYPTO_THREAD_get_local(&thread_local_key); ptr = CRYPTO_THREAD_get_local(&thread_local_key);
if (ptr != NULL) { if (!TEST_ptr_null(ptr))
fprintf(stderr, "ptr not NULL\n");
return 0; return 0;
}
# if !defined(OPENSSL_SYS_WINDOWS) # if !defined(OPENSSL_SYS_WINDOWS)
if (destructor_run_count != 1) { if (!TEST_int_eq(destructor_run_count, 1))
fprintf(stderr, "thread-local destructor run %u times\n",
destructor_run_count);
return 0; return 0;
}
# endif # endif
#endif #endif
if (!CRYPTO_THREAD_cleanup_local(&thread_local_key)) { if (!TEST_true(CRYPTO_THREAD_cleanup_local(&thread_local_key)))
fprintf(stderr, "CRYPTO_THREAD_cleanup_local() failed\n");
return 0; return 0;
}
return 1; return 1;
} }
int main(int argc, char **argv) void register_tests(void)
{ {
if (!test_lock()) ADD_TEST(test_lock);
return 1; ADD_TEST(test_once);
ADD_TEST(test_thread_local);
if (!test_once())
return 1;
if (!test_thread_local())
return 1;
printf("PASS\n");
return 0;
} }