X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali-toolkit%2Fdali-toolkit-test-utils%2Ftest-harness.cpp;h=0b814e722ab9b4ac2e0c7ec07158bc8414c0b461;hp=c4a27d19fa7dd2c2d38caf7e79f3035a7a65e20b;hb=8a647e87a01c5c78451653c1264a9eea81ac9b20;hpb=a0424ec129d3799ee0dab4a46600d167b2b7c71c

diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-harness.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-harness.cpp
index c4a27d1..0b814e7 100644
--- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-harness.cpp
+++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-harness.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,40 +15,56 @@
  */
 
 #include "test-harness.h"
+
+#include <fcntl.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/wait.h>
+#include <testcase.h>
 #include <unistd.h>
-#include <vector>
-#include <map>
+
 #include <cstring>
-#include <testcase.h>
+#include <map>
+#include <vector>
 
 namespace TestHarness
 {
-
 typedef std::map<int32_t, TestCase> RunningTestCases;
 
 const char* basename(const char* path)
 {
-  const char* ptr=path;
-  const char* slash=NULL;
-  for( ; *ptr != '\0' ; ++ptr )
+  const char* ptr   = path;
+  const char* slash = NULL;
+  for(; *ptr != '\0'; ++ptr)
   {
-    if(*ptr == '/') slash=ptr;
+    if(*ptr == '/') slash = ptr;
   }
   if(slash != NULL) ++slash;
   return slash;
 }
 
-int32_t RunTestCase( struct ::testcase_s& testCase )
+void SuppressLogOutput()
+{
+  // Close stdout and stderr to suppress the log output
+  close(STDOUT_FILENO); // File descriptor number for stdout is 1
+  close(STDERR_FILENO); // File descriptor number for stderr is 2
+
+  // The POSIX specification requires that /dev/null must be provided,
+  // The open function always chooses the lowest unused file descriptor
+  // It is sufficient for stdout to be writable.
+  open("/dev/null", O_WRONLY); // Redirect file descriptor number 1 (i.e. stdout) to /dev/null
+  // When stderr is opened it must be both readable and writable.
+  open("/dev/null", O_RDWR); // Redirect file descriptor number 2 (i.e. stderr) to /dev/null
+}
+
+int32_t RunTestCase(struct ::testcase_s& testCase)
 {
   int32_t result = EXIT_STATUS_TESTCASE_FAILED;
 
-// dont want to catch exception as we want to be able to get
-// gdb stack trace from the first error
-// by default tests should all always pass with no exceptions
-  if( testCase.startup )
+  // dont want to catch exception as we want to be able to get
+  // gdb stack trace from the first error
+  // by default tests should all always pass with no exceptions
+  if(testCase.startup)
   {
     testCase.startup();
   }
@@ -56,11 +72,11 @@ int32_t RunTestCase( struct ::testcase_s& testCase )
   {
     result = testCase.function();
   }
-  catch( const char* )
+  catch(const char*)
   {
     // just catch test fail exception, return is already set to EXIT_STATUS_TESTCASE_FAILED
   }
-  if( testCase.cleanup )
+  if(testCase.cleanup)
   {
     testCase.cleanup();
   }
@@ -68,37 +84,35 @@ int32_t RunTestCase( struct ::testcase_s& testCase )
   return result;
 }
 
-
-int32_t RunTestCaseInChildProcess( struct ::testcase_s& testCase, bool suppressOutput )
+int32_t RunTestCaseInChildProcess(struct ::testcase_s& testCase, bool suppressOutput)
 {
   int32_t testResult = EXIT_STATUS_TESTCASE_FAILED;
 
   int32_t pid = fork();
-  if( pid == 0 ) // Child process
+  if(pid == 0) // Child process
   {
-    if( suppressOutput )
+    if(suppressOutput)
     {
-      close(STDOUT_FILENO);
-      close(STDERR_FILENO);
+      SuppressLogOutput();
     }
     else
     {
       printf("\n");
-      for(int32_t i=0; i<80; ++i) printf("#");
+      for(int32_t i = 0; i < 80; ++i) printf("#");
       printf("\nTC: %s\n", testCase.name);
       fflush(stdout);
     }
 
-    int32_t status = RunTestCase( testCase );
+    int32_t status = RunTestCase(testCase);
 
-    if( ! suppressOutput )
+    if(!suppressOutput)
     {
       fflush(stdout);
       fflush(stderr);
       fclose(stdout);
       fclose(stderr);
     }
-    exit( status );
+    exit(status);
   }
   else if(pid == -1)
   {
@@ -107,31 +121,31 @@ int32_t RunTestCaseInChildProcess( struct ::testcase_s& testCase, bool suppressO
   }
   else // Parent process
   {
-    int32_t status = 0;
+    int32_t status   = 0;
     int32_t childPid = waitpid(pid, &status, 0);
-    if( childPid == -1 )
+    if(childPid == -1)
     {
       perror("waitpid");
       exit(EXIT_STATUS_WAITPID_FAILED);
     }
-    if( WIFEXITED(status) )
+    if(WIFEXITED(status))
     {
-      if( childPid > 0 )
+      if(childPid > 0)
       {
         testResult = WEXITSTATUS(status);
-        if( testResult )
+        if(testResult)
         {
           printf("Test case %s failed: %d\n", testCase.name, testResult);
         }
       }
     }
-    else if(WIFSIGNALED(status) )
+    else if(WIFSIGNALED(status))
     {
       int32_t signal = WTERMSIG(status);
-      testResult = EXIT_STATUS_TESTCASE_ABORTED;
-      if( signal == SIGABRT )
+      testResult     = EXIT_STATUS_TESTCASE_ABORTED;
+      if(signal == SIGABRT)
       {
-        printf("Test case %s failed: test case asserted\n", testCase.name );
+        printf("Test case %s failed: test case asserted\n", testCase.name);
       }
       else
       {
@@ -148,43 +162,43 @@ int32_t RunTestCaseInChildProcess( struct ::testcase_s& testCase, bool suppressO
   return testResult;
 }
 
-void OutputStatistics( const char* processName, int32_t numPasses, int32_t numFailures )
+void OutputStatistics(const char* processName, int32_t numPasses, int32_t numFailures)
 {
-  FILE* fp=fopen("summary.xml", "a");
-  if( fp != NULL )
+  FILE* fp = fopen("summary.xml", "a");
+  if(fp != NULL)
   {
-    fprintf( fp,
-             "  <suite name=\"%s\">\n"
-             "    <total_case>%d</total_case>\n"
-             "    <pass_case>%d</pass_case>\n"
-             "    <pass_rate>%5.2f</pass_rate>\n"
-             "    <fail_case>%d</fail_case>\n"
-             "    <fail_rate>%5.2f</fail_rate>\n"
-             "    <block_case>0</block_case>\n"
-             "    <block_rate>0.00</block_rate>\n"
-             "    <na_case>0</na_case>\n"
-             "    <na_rate>0.00</na_rate>\n"
-             "  </suite>\n",
-             basename(processName),
-             numPasses+numFailures,
-             numPasses,
-             (float)numPasses/(numPasses+numFailures),
-             numFailures,
-             (float)numFailures/(numPasses+numFailures) );
+    fprintf(fp,
+            "  <suite name=\"%s\">\n"
+            "    <total_case>%d</total_case>\n"
+            "    <pass_case>%d</pass_case>\n"
+            "    <pass_rate>%5.2f</pass_rate>\n"
+            "    <fail_case>%d</fail_case>\n"
+            "    <fail_rate>%5.2f</fail_rate>\n"
+            "    <block_case>0</block_case>\n"
+            "    <block_rate>0.00</block_rate>\n"
+            "    <na_case>0</na_case>\n"
+            "    <na_rate>0.00</na_rate>\n"
+            "  </suite>\n",
+            basename(processName),
+            numPasses + numFailures,
+            numPasses,
+            (float)numPasses / (numPasses + numFailures),
+            numFailures,
+            (float)numFailures / (numPasses + numFailures));
     fclose(fp);
   }
 }
 
-int32_t RunAll( const char* processName, ::testcase tc_array[] )
+int32_t RunAll(const char* processName, ::testcase tc_array[])
 {
   int32_t numFailures = 0;
-  int32_t numPasses = 0;
+  int32_t numPasses   = 0;
 
   // Run test cases in child process( to kill output/handle signals ), but run serially.
-  for( uint32_t i=0; tc_array[i].name; i++)
+  for(uint32_t i = 0; tc_array[i].name; i++)
   {
-    int32_t result = RunTestCaseInChildProcess( tc_array[i], false );
-    if( result == 0 )
+    int32_t result = RunTestCaseInChildProcess(tc_array[i], false);
+    if(result == 0)
     {
       numPasses++;
     }
@@ -194,37 +208,36 @@ int32_t RunAll( const char* processName, ::testcase tc_array[] )
     }
   }
 
-  OutputStatistics( processName, numPasses, numFailures);
+  OutputStatistics(processName, numPasses, numFailures);
 
   return numFailures;
 }
 
 // Constantly runs up to MAX_NUM_CHILDREN processes
-int32_t RunAllInParallel(  const char* processName, ::testcase tc_array[], bool reRunFailed)
+int32_t RunAllInParallel(const char* processName, ::testcase tc_array[], bool reRunFailed)
 {
   int32_t numFailures = 0;
-  int32_t numPasses = 0;
+  int32_t numPasses   = 0;
 
-  RunningTestCases children;
+  RunningTestCases     children;
   std::vector<int32_t> failedTestCases;
 
   // Fork up to MAX_NUM_CHILDREN processes, then
   // wait. As soon as a proc completes, fork the next.
 
-  int32_t nextTestCase = 0;
+  int32_t nextTestCase       = 0;
   int32_t numRunningChildren = 0;
 
-  while( tc_array[nextTestCase].name || numRunningChildren > 0)
+  while(tc_array[nextTestCase].name || numRunningChildren > 0)
   {
     // Create more children (up to the max number or til the end of the array)
-    while( numRunningChildren < MAX_NUM_CHILDREN && tc_array[nextTestCase].name )
+    while(numRunningChildren < MAX_NUM_CHILDREN && tc_array[nextTestCase].name)
     {
       int32_t pid = fork();
-      if( pid == 0 ) // Child process
+      if(pid == 0) // Child process
       {
-        close(STDOUT_FILENO);
-        close(STDERR_FILENO);
-        exit( RunTestCase( tc_array[nextTestCase] ) );
+        SuppressLogOutput();
+        exit(RunTestCase(tc_array[nextTestCase]));
       }
       else if(pid == -1)
       {
@@ -242,20 +255,20 @@ int32_t RunAllInParallel(  const char* processName, ::testcase tc_array[], bool
 
     // Wait for the next child to finish
 
-    int32_t status=0;
+    int32_t status   = 0;
     int32_t childPid = waitpid(-1, &status, 0);
-    if( childPid == -1 )
+    if(childPid == -1)
     {
       perror("waitpid");
       exit(EXIT_STATUS_WAITPID_FAILED);
     }
 
-    if( WIFEXITED(status) )
+    if(WIFEXITED(status))
     {
-      if( childPid > 0 )
+      if(childPid > 0)
       {
         int32_t testResult = WEXITSTATUS(status);
-        if( testResult )
+        if(testResult)
         {
           printf("Test case %s failed: %d\n", children[childPid].testCaseName, testResult);
           failedTestCases.push_back(children[childPid].testCase);
@@ -269,14 +282,14 @@ int32_t RunAllInParallel(  const char* processName, ::testcase tc_array[], bool
       }
     }
 
-    else if( WIFSIGNALED(status) || WIFSTOPPED(status))
+    else if(WIFSIGNALED(status) || WIFSTOPPED(status))
     {
-      status = WIFSIGNALED(status)?WTERMSIG(status):WSTOPSIG(status);
+      status = WIFSIGNALED(status) ? WTERMSIG(status) : WSTOPSIG(status);
 
-      if( childPid > 0 )
+      if(childPid > 0)
       {
         RunningTestCases::iterator iter = children.find(childPid);
-        if( iter != children.end() )
+        if(iter != children.end())
         {
           printf("Test case %s exited with signal %s\n", iter->second.testCaseName, strsignal(status));
           failedTestCases.push_back(iter->second.testCase);
@@ -292,38 +305,36 @@ int32_t RunAllInParallel(  const char* processName, ::testcase tc_array[], bool
     }
   }
 
-  OutputStatistics( processName, numPasses, numFailures );
+  OutputStatistics(processName, numPasses, numFailures);
 
-  if( reRunFailed )
+  if(reRunFailed)
   {
-    for( uint32_t i=0; i<failedTestCases.size(); i++)
+    for(uint32_t i = 0; i < failedTestCases.size(); i++)
     {
-      char* testCaseStrapline;
-      int32_t numChars = asprintf(&testCaseStrapline, "Test case %s", tc_array[failedTestCases[i]].name );
+      char*   testCaseStrapline;
+      int32_t numChars = asprintf(&testCaseStrapline, "Test case %s", tc_array[failedTestCases[i]].name);
       printf("\n%s\n", testCaseStrapline);
-      for(int32_t j=0; j<numChars; j++)
+      for(int32_t j = 0; j < numChars; j++)
       {
         printf("=");
       }
       printf("\n");
-      RunTestCaseInChildProcess( tc_array[failedTestCases[i] ], false );
+      RunTestCaseInChildProcess(tc_array[failedTestCases[i]], false);
     }
   }
 
   return numFailures;
 }
 
-
-
 int32_t FindAndRunTestCase(::testcase tc_array[], const char* testCaseName)
 {
   int32_t result = EXIT_STATUS_TESTCASE_NOT_FOUND;
 
-  for( int32_t i = 0; tc_array[i].name; i++ )
+  for(int32_t i = 0; tc_array[i].name; i++)
   {
-    if( !strcmp(testCaseName, tc_array[i].name) )
+    if(!strcmp(testCaseName, tc_array[i].name))
     {
-      return RunTestCase( tc_array[i] );
+      return RunTestCase(tc_array[i]);
     }
   }
 
@@ -333,12 +344,16 @@ int32_t FindAndRunTestCase(::testcase tc_array[], const char* testCaseName)
 
 void Usage(const char* program)
 {
-  printf("Usage: \n"
-         "   %s <testcase name>\t\t Execute a test case\n"
-         "   %s \t\t Execute all test cases in parallel\n"
-         "   %s -r\t\t Execute all test cases in parallel, rerunning failed test cases\n"
-         "   %s -s\t\t Execute all test cases serially\n",
-         program, program, program, program);
+  printf(
+    "Usage: \n"
+    "   %s <testcase name>\t\t Execute a test case\n"
+    "   %s \t\t Execute all test cases in parallel\n"
+    "   %s -r\t\t Execute all test cases in parallel, rerunning failed test cases\n"
+    "   %s -s\t\t Execute all test cases serially\n",
+    program,
+    program,
+    program,
+    program);
 }
 
-} // namespace
+} // namespace TestHarness