diff options
Diffstat (limited to 'util/test/util/test_thread.c')
| -rw-r--r-- | util/test/util/test_thread.c | 345 |
1 files changed, 345 insertions, 0 deletions
diff --git a/util/test/util/test_thread.c b/util/test/util/test_thread.c new file mode 100644 index 0000000..e10b5b7 --- /dev/null +++ b/util/test/util/test_thread.c @@ -0,0 +1,345 @@ + +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <stdio.h> +#include <string.h> +#include <axutil_error_default.h> +#include <axutil_log.h> +#include <axutil_log_default.h> +#include <axutil_allocator.h> +#include <axutil_utils.h> +#include "test_thread.h" +#include <unistd.h> + +const axutil_env_t *env = NULL; +static axutil_thread_mutex_t *thread_lock = NULL; +static axutil_thread_once_t *control = NULL; +static int x = 0; +static int value = 0; + +static axutil_thread_t *t1 = NULL; +static axutil_thread_t *t2 = NULL; + +/*for detach tests*/ +static axutil_thread_t *t3 = NULL; +static axutil_thread_t *t4 = NULL; + +void +init_func( + void) +{ + value++; +} + +void +thread_init( + const axutil_env_t * env) +{ + axutil_allocator_t *allocator = NULL; + + allocator = env->allocator; + + control = axutil_thread_once_init(allocator); + + if (control) + printf("success - thread_init - axutil_thread_once_init \n"); + else + printf("failure - thread_init - axutil_thread_once_init \n"); + + thread_lock = + axutil_thread_mutex_create(allocator, AXIS2_THREAD_MUTEX_DEFAULT); + + if (thread_lock) + printf("success - thread_init - axutil_thread_mutex_create \n"); + else + printf("failure - thread_init - axutil_thread_mutex_create \n"); +} + +void *AXIS2_CALL +test_function( + axutil_thread_t * td, + void *param) +{ + int i; + i = *((int *) param); + printf("thread data = %d \n", i); + + axutil_thread_once(control, init_func); + + axutil_thread_mutex_lock(thread_lock); + printf("x = %d \n", ++x); + axutil_thread_mutex_unlock(thread_lock); + + /*axutil_thread_exit(td, env->allocator); */ + + return (void *) 1; +} + +void +test_axutil_thread_create( + const axutil_env_t * env) +{ + axis2_status_t rv = AXIS2_FAILURE; + axutil_allocator_t *allocator = NULL; + int *i = NULL, + *j = NULL; + + allocator = env->allocator; + i = AXIS2_MALLOC(allocator, sizeof(int)); + *i = 5; + t1 = axutil_thread_create(allocator, NULL, test_function, (void *) i); + + if (t1) + printf("success - test_axutil_thread_create - axutil_thread_create \n"); + else + printf("failure - test_axutil_thread_create - axutil_thread_create \n"); + + j = AXIS2_MALLOC(allocator, sizeof(int)); + *j = 25; + + t2 = axutil_thread_create(allocator, NULL, test_function, (void *) j); + + if (t2) + printf("success - test_axutil_thread_create - axutil_thread_create \n"); + else + printf("failure - test_axutil_thread_create - axutil_thread_create \n"); + + rv = axutil_thread_join(t1); + + if (AXIS2_SUCCESS == rv) + printf("success - test_axutil_thread_create - axutil_thread_join \n"); + else + printf + ("failure - thread_init - test_axutil_thread_create - axutil_thread_join \n"); + + rv = axutil_thread_join(t2); + + if (AXIS2_SUCCESS == rv) + printf("success - test_axutil_thread_create - axutil_thread_join \n"); + else + printf + ("failure - thread_init - test_axutil_thread_create - axutil_thread_join \n"); + +} + +void *AXIS2_CALL +test_function2( + axutil_thread_t * td, + void *param) +{ + printf("thread \n"); + /*axutil_thread_exit(td, env->allocator); */ + + return (void *) 1; +} + +void +test_axutil_thread_detach( + const axutil_env_t * env) +{ + axutil_threadattr_t *attr = NULL; + axutil_allocator_t *allocator = NULL; + axis2_status_t rv = AXIS2_FAILURE; + + allocator = env->allocator; + attr = axutil_threadattr_create(allocator); + if (!attr) + { + printf("failure - test_axutil_thread_detach\n"); + return; + } + rv = axutil_threadattr_detach_set(attr, 1); + + if (AXIS2_SUCCESS != rv) + { + printf("failure - test_axutil_thread_detach\n"); + return; + } + t3 = axutil_thread_create(allocator, attr, test_function2, NULL); + + if (!t3) + { + printf("failure - test_axutil_thread_detach\n"); + return; + } + + /* + * thread is already detached - should return AXIS2_FAILURE + */ + rv = axutil_thread_detach(t3); + + if (AXIS2_FAILURE != rv) + { + printf("failure - test_axutil_thread_detach\n"); + return; + } + + /* + * thread is already detached - should return AXIS2_FAILURE + * cannot join detached threads + */ + /*rv = axutil_thread_join(t3); */ + if (AXIS2_FAILURE != rv) + { + printf("failure - test_axutil_thread_detach\n"); + return; + } + printf("success - test_axutil_thread_detach\n"); +} + +void +test_axutil_thread_detach2( + const axutil_env_t * env) +{ + axutil_threadattr_t *attr = NULL; + axutil_allocator_t *allocator = NULL; + axis2_status_t rv = AXIS2_FAILURE; + + allocator = env->allocator; + attr = axutil_threadattr_create(allocator); + if (!attr) + { + printf("failure - test_axutil_thread_detach2\n"); + return; + } + + t4 = axutil_thread_create(allocator, attr, test_function2, NULL); + + if (!t4) + { + printf("failure - test_axutil_thread_detach2\n"); + return; + } + + /* + * thread is not detached yet - should return AXIS2_SUCCESS + */ + rv = axutil_thread_detach(t4); + + if (AXIS2_SUCCESS != rv) + { + printf("failure - test_axutil_thread_detach\n"); + return; + } + + /* + * thread is already detached - should return AXIS2_FAILURE + * cannot join detached threads + */ + /*rv = axutil_thread_join(t4); */ + if (AXIS2_FAILURE != rv) + { + printf("failure - test_axutil_thread_detach2\n"); + return; + } + printf("success - test_axutil_thread_detach2\n"); +} + +void +check_locks( + ) +{ + if (2 == x) + printf("success - check_locks \n"); + else + printf("failure - check_locks \n"); + +} + +void +check_thread_once( + ) +{ + if (1 == value) + printf("success - check_thread_once \n"); + else + printf("failure - check_thread_once \n"); +} + +void +run_test_thread( + const axutil_env_t * env) +{ + thread_init(env); + test_axutil_thread_create(env); + check_locks(); + check_thread_once(); + test_axutil_thread_detach(env); + test_axutil_thread_detach2(env); + +#if defined (WIN32) + Sleep(1000); /*to give time for detached threads to execute */ +#else + sleep(2); +#endif + + axutil_thread_mutex_destroy(thread_lock); +} + +const axutil_env_t * +create_env_with_error_log( + ) +{ + axutil_error_t *error = NULL; + axutil_log_t *log22 = NULL; + const axutil_env_t *env = NULL; + axutil_allocator_t *allocator = axutil_allocator_init(NULL); + if (!allocator) + { + printf("allocator is NULL\n"); + return NULL; + } + error = axutil_error_create(allocator); + if (!error) + { + printf("cannot create error\n"); + return NULL; + } + + log22 = axutil_log_create(allocator, NULL, "test123.log"); + if (!log22) + { + printf("cannot create log\n"); + return NULL; + } + /* + * allow all types of logs + */ + log22->level = AXIS2_LOG_LEVEL_DEBUG; + /* log22->enabled = 0; */ + env = axutil_env_create_with_error_log(allocator, error, log22); + if (!env) + { + printf("cannot create env with error and log\n"); + return NULL; + } + return env; +} + +int +main( + void) +{ + env = create_env_with_error_log(); + + if (!env) + return -1; + run_test_thread(env); + + return 0; +} |