Commit ee25dd45 authored by Pauli's avatar Pauli Committed by Richard Levitte
Browse files

Update threadstest to use the test framework 



Reviewed-by: default avatarMatt Caswell <matt@openssl.org>
Reviewed-by: default avatarRichard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/3196)
parent bea4ac2b

test/build.info

+1 −1
Original line number Diff line number Diff line
@@ -231,7 +231,7 @@ IF[{- !$disabled{tests} -}] 
  INCLUDE[ct_test]=../crypto/include ../include

  DEPEND[ct_test]=../libcrypto



  SOURCE[threadstest]=threadstest.c

  SOURCE[threadstest]=threadstest.c testutil.c test_main.c

  INCLUDE[threadstest]=.. ../include

  DEPEND[threadstest]=../libcrypto

test/threadstest.c

+26 −79
Original line number Diff line number Diff line 
/*

 * 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

 * this file except in compliance with the License.  You can obtain a copy
@@ -11,9 +11,9 @@ 
# include <windows.h>

#endif



#include <stdio.h>



#include <openssl/crypto.h>

#include "test_main.h"

#include "testutil.h"



#if !defined(OPENSSL_THREADS) || defined(CRYPTO_TDEBUG)
@@ -85,15 +85,9 @@ static int test_lock(void) 
{

    CRYPTO_RWLOCK *lock = CRYPTO_THREAD_lock_new();



    if (!CRYPTO_THREAD_read_lock(lock)) {

        fprintf(stderr, "CRYPTO_THREAD_read_lock() failed\n");

    if (!TEST_true(CRYPTO_THREAD_read_lock(lock))

        || !TEST_true(CRYPTO_THREAD_unlock(lock)))

        return 0;

    }



    if (!CRYPTO_THREAD_unlock(lock)) {

        fprintf(stderr, "CRYPTO_THREAD_unlock() failed\n");

        return 0;

    }



    CRYPTO_THREAD_lock_free(lock);
@@ -116,23 +110,12 @@ static void once_run_thread_cb(void) 
static int test_once(void)

{

    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)) {

        fprintf(stderr, "CRYPTO_THREAD_run_once() failed\n");

        return 0;

    }



    if (once_run_count != 1) {

        fprintf(stderr, "once run %u times\n", once_run_count);

    if (!TEST_true(run_thread(&thread, once_run_thread_cb))

        || !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 1;

}
@@ -157,21 +140,14 @@ static void thread_local_thread_cb(void) 
    void *ptr;



    ptr = CRYPTO_THREAD_get_local(&thread_local_key);

    if (ptr != NULL) {

        fprintf(stderr, "ptr not NULL\n");

        return;

    }



    if (!CRYPTO_THREAD_set_local(&thread_local_key, &destructor_run_count)) {

        fprintf(stderr, "CRYPTO_THREAD_set_local() failed\n");

    if (!TEST_ptr_null(ptr)

        || !TEST_true(CRYPTO_THREAD_set_local(&thread_local_key,

                                              &destructor_run_count)))

        return;

    }



    ptr = CRYPTO_THREAD_get_local(&thread_local_key);

    if (ptr != &destructor_run_count) {

        fprintf(stderr, "invalid ptr\n");

    if (!TEST_ptr_eq(ptr, &destructor_run_count))

        return;

    }



    thread_local_thread_cb_ok = 1;

}
@@ -181,66 +157,37 @@ static int test_thread_local(void) 
    thread_t thread;

    void *ptr = NULL;



    if (!CRYPTO_THREAD_init_local(&thread_local_key, thread_local_destructor)) {

        fprintf(stderr, "CRYPTO_THREAD_init_local() failed\n");

    if (!TEST_true(CRYPTO_THREAD_init_local(&thread_local_key,

                                            thread_local_destructor)))

        return 0;

    }



    ptr = CRYPTO_THREAD_get_local(&thread_local_key);

    if (ptr != NULL) {

        fprintf(stderr, "ptr not NULL\n");

    if (!TEST_ptr_null(ptr)

        || !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;

    }



    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)



    ptr = CRYPTO_THREAD_get_local(&thread_local_key);

    if (ptr != NULL) {

        fprintf(stderr, "ptr not NULL\n");

    if (!TEST_ptr_null(ptr))

        return 0;

    }



# if !defined(OPENSSL_SYS_WINDOWS)

    if (destructor_run_count != 1) {

        fprintf(stderr, "thread-local destructor run %u times\n",

                destructor_run_count);

    if (!TEST_int_eq(destructor_run_count, 1))

        return 0;

    }

# endif



#endif



    if (!CRYPTO_THREAD_cleanup_local(&thread_local_key)) {

        fprintf(stderr, "CRYPTO_THREAD_cleanup_local() failed\n");

    if (!TEST_true(CRYPTO_THREAD_cleanup_local(&thread_local_key)))

        return 0;

    }



    return 1;

}



int main(int argc, char **argv)

void register_tests(void)

{

    if (!test_lock())

      return 1;



    if (!test_once())

      return 1;



    if (!test_thread_local())

      return 1;



    printf("PASS\n");

    return 0;

    ADD_TEST(test_lock);

    ADD_TEST(test_once);

    ADD_TEST(test_thread_local);

}