[LTP] [PATCH]pthread_join:4-1.c: clean up code

[lidan <li.dan@cn.fujitsu.com>]

code cleanup for pthread_join/4-1.c


Signed-off-by: DAN LI <li.dan@cn.fujitsu.com>
---
 .../conformance/interfaces/pthread_join/4-1.c      |  134 +++++++++-----------
 1 files changed, 58 insertions(+), 76 deletions(-)

diff --git a/testcases/open_posix_testsuite/conformance/interfaces/pthread_join/4-1.c b/testcases/open_posix_testsuite/conformance/interfaces/pthread_join/4-1.c
index baf0992..7ee4870 100644
--- a/testcases/open_posix_testsuite/conformance/interfaces/pthread_join/4-1.c
+++ b/testcases/open_posix_testsuite/conformance/interfaces/pthread_join/4-1.c
@@ -16,7 +16,8 @@
 
 * This sample test aims to check the following assertion:
 *
-* If the thread calling pthread_join is canceled, the joined thread remains joinable.
+* If the thread calling pthread_join is canceled, the joined thread
+* remains joinable.
 
 * The steps are:
 * -> create a thread blocked on a mutex.
@@ -31,9 +32,9 @@
 /* We are testing conformance to IEEE Std 1003.1, 2003 Edition */
 #define _POSIX_C_SOURCE 200112L
 
-/********************************************************************************************/
-/****************************** standard includes *****************************************/
-/********************************************************************************************/
+/**************************************************************/
+/********************** standard includes *********************/
+/**************************************************************/
 #include <pthread.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -44,14 +45,15 @@
 
 #include <errno.h>
 
-/********************************************************************************************/
-/******************************   Test framework   *****************************************/
-/********************************************************************************************/
+/***************************************************************/
+/*********************   Test framework   **********************/
+/***************************************************************/
 #include "../testfrmw/testfrmw.h"
 #include "../testfrmw/testfrmw.c"
 /* This header is responsible for defining the following macros:
  * UNRESOLVED(ret, descr);
- *    where descr is a description of the error and ret is an int (error code for example)
+ *    where descr is a description of the error and ret is an int
+ *    (error code for example)
  * FAILED(descr);
  *    where descr is a short text saying why the test has failed.
  * PASSED();
@@ -67,16 +69,16 @@
  * Those may be used to output information.
  */
 
-/********************************************************************************************/
-/********************************** Configuration ******************************************/
-/********************************************************************************************/
+/***************************************************************/
+/************************ Configuration ************************/
+/***************************************************************/
 #ifndef VERBOSE
 #define VERBOSE 1
 #endif
 
-/********************************************************************************************/
-/***********************************     Helper     *****************************************/
-/********************************************************************************************/
+/***************************************************************/
+/***********************     Helper     ************************/
+/***************************************************************/
 #include "../testfrmw/threads_scenarii.c"
 /* this file defines:
 * scenarii: array of struct __scenario type.
@@ -85,14 +87,14 @@
 * scenar_fini(): function to call after end of use of the scenarii array.
 */
 
-/********************************************************************************************/
-/***********************************    Test case   *****************************************/
-/********************************************************************************************/
+/***************************************************************/
+/***********************    Test case   ************************/
+/***************************************************************/
 
 pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
 
 /* 1st thread function */
-void * threaded (void * arg)
+void *threaded(void *arg)
 {
 	int ret = 0;
 
@@ -101,22 +103,18 @@ void * threaded (void * arg)
 	ret = pthread_mutex_lock(&mtx);
 
 	if (ret != 0)
-	{
 		UNRESOLVED(ret, "Failed to lock mutex");
-	}
 
 	ret = pthread_mutex_unlock(&mtx);
 
 	if (ret != 0)
-	{
 		UNRESOLVED(ret, "Failed to unlock mutex");
-	}
 
 	return NULL;
 }
 
 /* Canceled thread */
-void * joiner_func(void * arg)
+void *joiner_func(void *arg)
 {
 	(void) pthread_join(*(pthread_t *) arg, NULL);
 
@@ -139,70 +137,64 @@ int main(int argc, char *argv[])
 	/* Initialize thread attribute objects */
 	scenar_init();
 
-	for (sc = 0; sc < NSCENAR; sc++)
-	{
+	for (sc = 0; sc < NSCENAR; sc++) {
 #if VERBOSE > 0
 		output("-----\n");
-		output("Starting test with scenario (%i): %s\n", sc, scenarii[ sc ].descr);
+		output("Starting test with scenario (%i): %s\n",
+					sc, scenarii[sc].descr);
 #endif
 
 		/* Lock the mutex */
 		ret = pthread_mutex_lock(&mtx);
 
 		if (ret != 0)
-		{
 			UNRESOLVED(ret, "failed to lock the mutex");
-		}
-
-		ret = pthread_create(&child, &scenarii[ sc ].ta, threaded, NULL);
 
-		switch (scenarii[ sc ].result)
-		{
-				case 0:                                       /* Operation was expected to succeed */
+		ret = pthread_create(&child, &scenarii[sc].ta, threaded,
+									NULL);
 
-				if (ret != 0)
-				{
-					UNRESOLVED(ret, "Failed to create this thread");
-				}
+		switch (scenarii[sc].result) {
+		/* Operation was expected to succeed */
+		case 0:
 
-				break;
-
-				case 1:                                       /* Operation was expected to fail */
+			if (ret != 0)
+				UNRESOLVED(ret, "Failed to create this thread");
 
-				if (ret == 0)
-				{
-					UNRESOLVED(-1, "An error was expected but the thread creation succeeded");
-				}
+			break;
+		/* Operation was expected to fail */
+		case 1:
 
-				break;
+			if (ret == 0)
+				UNRESOLVED(-1, "An error was expected \
+					but the thread creation succeeded");
 
-				case 2:                                       /* We did not know the expected result */
-				default:
+			break;
+		/* We did not know the expected result */
+		case 2:
+		default:
 #if VERBOSE > 0
 
-				if (ret == 0)
-				{
-					output("Thread has been created successfully for this scenario\n");
-				}
-				else
-				{
-					output("Thread creation failed with the error: %s\n", strerror(ret));
-				}
+			if (ret == 0) {
+				output("Thread has been created \
+					successfully for this scenario\n");
+			} else {
+				output("Thread creation failed with the error:\
+							%s\n", strerror(ret));
+			}
 
 #endif
 
 		}
-
-		if (ret == 0)                                       /* The new thread is running */
-		{
+		/* The new thread is running */
+		if (ret == 0) {
 
 			/* Now create the joiner thread */
-			ret = pthread_create(&joiner, NULL, joiner_func, &child);
+			ret = pthread_create(&joiner, NULL, joiner_func,
+								&child);
 
 			if (ret != 0)
-			{
-				UNRESOLVED(ret, "Failed to create the joiner thread");
-			}
+				UNRESOLVED(ret, "Failed to create the \
+								joiner thread");
 
 			/* Let it enter pthread_join */
 			sched_yield();
@@ -211,44 +203,34 @@ int main(int argc, char *argv[])
 			ret = pthread_cancel(joiner);
 
 			if (ret != 0)
-			{
 				UNRESOLVED(ret, "Failed to cancel the thread");
-			}
 
 			/* Join the canceled thread */
 			ret = pthread_join(joiner, NULL);
 
 			if (ret != 0)
-			{
-				UNRESOLVED(ret, "Failed to join the canceled thread");
-			}
+				UNRESOLVED(ret, "Failed to join \
+							the canceled thread");
 
 			/* Unblock the child thread */
 			ret = pthread_mutex_unlock(&mtx);
 
 			if (ret != 0)
-			{
 				UNRESOLVED(ret, "Failed to unlock the mutex");
-			}
 
 			/* Check the first thread is still joinable */
 			ret = pthread_join(child, NULL);
 
-			if (ret != 0)
-			{
+			if (ret != 0) {
 				output("Error returned: %d\n");
 				FAILED("The thread is no more joinable");
 			}
 
-		}
-		else
-		{
+		} else {
 			ret = pthread_mutex_unlock(&mtx);
 
 			if (ret != 0)
-			{
 				UNRESOLVED(ret, "Failed to unlock the mutex");
-			}
 		}
 	}
 
-- 
1.7.7.2


------------------------------------------------------------------------------
This SF email is sponsosred by:
Try Windows Azure free for 90 days Click Here 
http://p.sf.net/sfu/sfd2d-msazure
_______________________________________________
Ltp-list mailing list
Ltp-list@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/ltp-list