-#include <runner.h>
-#include <units.h>
-#include <error.h>
-
-#include <errno.h> /* for error code */
-#include <stdlib.h> /* for calloc() */
-#include <stdio.h>
-
-XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(tesh);
-
-/* the unique tesh runner */
-static runner_t
-runner = NULL;
-
-/* wait for the tesh runner terminaison */
-static void
-runner_wait(void);
-
-static void*
-runner_start_routine(void* p);
-
-
-/* check the syntax of the tesh files if
- * the want_check_syntax is specified. Returns
- * 0 if the syntax is clean.
- */
-static int
-check_syntax(void);
-
-#ifdef WIN32
-
-static HANDLE
-timer_handle = NULL;
-
-static void*
-runner_start_routine(void* p)
-{
-
- LARGE_INTEGER li;
-
- li.QuadPart=- runner->timeout * 10000000; /* 10000000 = 10 000 000 * 100 nanoseconds = 1 second */
-
- /* create the waitable timer */
- timer_handle = CreateWaitableTimer(NULL, TRUE, NULL);
-
- /* set a timer to wait for timeout seconds */
- SetWaitableTimer(timer_handle, &li, 0, NULL, NULL, 0);
-
- /* wait for the timer */
- WaitForSingleObject(timer_handle, INFINITE);
-
- if(runner->waiting)
- {
- exit_code = ELEADTIME;
- runner->timeouted = 1;
- xbt_os_sem_release(units_sem);
- }
-
- return NULL;
-}
-
-#else
-static void*
-runner_start_routine(void* p)
-{
- struct timespec ts;
-
- ts.tv_sec = runner->timeout;
- ts.tv_nsec = 0L;
-
- do
- {
- nanosleep(&ts, &ts);
- }while(EINTR == errno);
-
- if(errno)
- {
- /* TODO process the error */
- }
- else
- {
- if(runner->waiting)
- {
- exit_code = ELEADTIME;
- runner->timeouted = 1;
- xbt_os_sem_release(units_sem);
- }
- }
-
- return NULL;
-}
-#endif
-
-
-int
-runner_init(int want_check_syntax, int timeout, fstreams_t fstreams)
-{
-
- if(runner)
- {
- ERROR0("Runner is already initialized");
- return EEXIST;
- }
-
-
- runner = xbt_new0(s_runner_t, 1);
-
- if(!(runner->units = units_new(runner, fstreams)))
- {
- ERROR0("Runner initialization failed");
-
- free(runner);
- runner = NULL;
- return errno;
- }
-
- runner->timeout = timeout;
- runner->timeouted = 0;
- runner->interrupted = 0;
- runner->number_of_ended_units = 0;
- runner->number_of_runned_units = 0;
- runner->waiting = 0;
-
- if(want_check_syntax)
- {
- if((errno = check_syntax()))
- return errno;
- }
-
- return 0;
-
-}
-
-void
-runner_destroy(void)
-{
- units_free((void**)(&(runner->units)));
-
- #ifdef WIN32
- CloseHandle(timer_handle);
- #endif
-
- if(runner->thread)
- xbt_os_thread_join(runner->thread, NULL);
-
- free(runner);
-
- runner = NULL;
-}
-
-void
-runner_run(void)
-{
- xbt_os_mutex_t mutex;
-
- mutex = xbt_os_mutex_init();
-
- units_run_all(runner->units, mutex);
-
- if(!interrupted)
- runner_wait();
-
- /* if the runner is timeouted or receive a interruption request
- * , interrupt all the active units.
- */
- if(runner->timeouted || interrupted)
- runner_interrupt();
-
- units_join_all(runner->units);
-
- xbt_os_mutex_destroy(mutex);
-
-}
-
-static void
-runner_wait(void)
-{
- if(runner->timeout > 0)
- runner->thread = xbt_os_thread_create("", runner_start_routine, NULL);
- /* signal that the runner is waiting */
- runner->waiting = 1;
-
- /* wait for the end of all the units */
- xbt_os_sem_acquire(units_sem);
-
- runner->waiting = 0;
-}
-
-
-
-/*
- * interrupt all the active units.
- * this function is called when the lead time of the execution is reached
- * or when a failed unit requests an interruption of the execution.
- */
-void
-runner_interrupt(void)
-{
- units_interrupt_all(runner->units);
-}
-
-void
-runner_display_status(void)
-{
- if(!want_dry_run)
- {
-
- /*unit_t unit;*/
-
- printf("Runner\n");
- printf("Status informations :\n");
-
- printf(" number of units %d\n",units_get_size(runner->units));
- printf(" exit code %d (%s)\n",exit_code, exit_code ? error_to_string(exit_code) : "success");
-
- units_verbose(runner->units);
- }
- else
- {
- if(exit_code)
- ERROR0("Syntax error detected");
- else if(exit_code == 0)
- INFO0("Syntax 0K");
- }
-}
-
-static int
-check_syntax(void)
-{
- if(!want_dry_run)
- {
- want_dry_run = 1;
-
- runner_run();
-
- want_dry_run = 0;
-
- if(0 == exit_code)
- {
- if(!want_silent)
- INFO0("syntax checked (OK)");
-
- units_reset_all(runner->units);
-
- }
-
- }
- else
- {
- WARN0("mismatch in the syntax : --just-check-syntax and --check-syntax options at same time");
- }
-
- return exit_code;
-}
+/*\r
+ * src/runner.c - type representing the runner.\r
+ *\r
+ * Copyright 2008,2009 Martin Quinson, Malek Cherier All right reserved. \r
+ *\r
+ * This program is free software; you can redistribute it and/or modify it \r
+ * under the terms of the license (GNU LGPL) which comes with this package.\r
+ *\r
+ * Purpose:\r
+ * This file contains all the definitions of the functions related with\r
+ * the tesh runner type.\r
+ *\r
+ */\r
+#include <runner.h>\r
+#include <units.h>\r
+#include <unit.h>\r
+#include <xerrno.h>\r
+#include <variable.h>\r
+\r
+#include <errno.h> /* for error code */\r
+#include <stdlib.h> /* for calloc() */\r
+#include <stdio.h>\r
+\r
+#include <readline.h>\r
+#include <explode.h>\r
+\r
+#ifndef WIN32\r
+#include <sys/resource.h>\r
+#endif\r
+\r
+\r
+\r
+\r
+\r
+#define _RUNNER_HASHCODE 0xFEFEAAAA \r
+\r
+XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(tesh);\r
+\r
+#if (!defined(__BUILTIN) && defined(__CHKCMD) && !defined(WIN32))\r
+static const char* builtin[] =\r
+{\r
+ "alias",\r
+ "bind",\r
+ "builtin",\r
+ "caller",\r
+ "cd",\r
+ "command",\r
+ "compgen",\r
+ "complete",\r
+ "declare",\r
+ "disown",\r
+ "echo",\r
+ "enable",\r
+ "eval",\r
+ "exec",\r
+ "export",\r
+ "false",\r
+ "fc",\r
+ "function",\r
+ "getopts",\r
+ "hash",\r
+ "history",\r
+ "jobs",\r
+ "let",\r
+ "logout",\r
+ "printf",\r
+ "pwd",\r
+ "readonly",\r
+ "shift",\r
+ "shopt",\r
+ "source",\r
+ "suspend",\r
+ "test",\r
+ "time",\r
+ "times",\r
+ "trap",\r
+ "true",\r
+ "type",\r
+ "typeset",\r
+ "ulimit",\r
+ "umask",\r
+ "unalias",\r
+ "unset",\r
+ NULL\r
+};\r
+\r
+#define __BUILTIN_MAX ((size_t)42)\r
+#endif\r
+\r
+\r
+# ifdef __APPLE__\r
+/* under darwin, the environment gets added to the process at startup time. So, it's not defined at library link time, forcing us to extra tricks */\r
+# include <crt_externs.h>\r
+# define environ (*_NSGetEnviron())\r
+# elif !defined(WIN32)\r
+ /* the environment, as specified by the opengroup, used to initialize the process properties */\r
+ extern char **environ;\r
+# endif\r
+\r
+#ifndef WIN32\r
+extern char**\r
+environ;\r
+#endif\r
+\r
+/* the unique tesh runner */\r
+static runner_t\r
+runner = NULL;\r
+\r
+/* wait for the tesh runner terminaison */\r
+static void\r
+runner_wait(void);\r
+\r
+static void*\r
+runner_start_routine(void* p);\r
+\r
+\r
+/* check the syntax of the tesh files if \r
+ * the check_syntax_flag is specified. Returns\r
+ * 0 if the syntax is clean.\r
+ */\r
+/*static void\r
+check_syntax(void);*/\r
+\r
+#ifdef WIN32\r
+\r
+static HANDLE \r
+timer_handle = NULL;\r
+\r
+\r
+static void*\r
+runner_start_routine(void* p)\r
+{\r
+ \r
+ LARGE_INTEGER li;\r
+\r
+ li.QuadPart=- runner->timeout * 10000000; /* 10000000 = 10 000 000 * 100 nanoseconds = 1 second */\r
+\r
+ /* create the waitable timer */\r
+ timer_handle = CreateWaitableTimer(NULL, TRUE, NULL);\r
+\r
+ /* set a timer to wait for timeout seconds */\r
+ SetWaitableTimer(timer_handle, &li, 0, NULL, NULL, 0);\r
+ \r
+ /* wait for the timer */\r
+ WaitForSingleObject(timer_handle, INFINITE);\r
+\r
+ if(runner->waiting)\r
+ {\r
+ exit_code = ELEADTIME;\r
+ err_kind = 1;\r
+ runner->timeouted = 1;\r
+ xbt_os_sem_release(units_sem);\r
+ }\r
+\r
+ return NULL;\r
+}\r
+\r
+#else\r
+static void*\r
+runner_start_routine(void* p)\r
+{\r
+ struct timespec ts;\r
+ int timeout = runner->timeout;\r
+ \r
+ \r
+ while(timeout-- && runner->waiting)\r
+ {\r
+ ts.tv_sec = 1;\r
+ ts.tv_nsec = 0L;\r
+\r
+ do\r
+ {\r
+ nanosleep(&ts, &ts);\r
+ }while(EINTR == errno);\r
+ }\r
+ \r
+ if(errno)\r
+ {\r
+ /* TODO process the error */\r
+ }\r
+ else\r
+ {\r
+ if(runner->waiting)\r
+ {\r
+ exit_code = ELEADTIME;\r
+ err_kind = 1;\r
+ runner->timeouted = 1;\r
+ xbt_os_sem_release(units_sem);\r
+ }\r
+ }\r
+ \r
+ return NULL;\r
+}\r
+#endif\r
+\r
+\r
+int\r
+runner_init(/*int check_syntax_flag, */int timeout, fstreams_t fstreams)\r
+{\r
+ \r
+ int i;\r
+ char* val;\r
+ char buffer[PATH_MAX + 1] = {0};\r
+\r
+ int code;\r
+ const char* cstr;\r
+ variable_t variable;\r
+ \r
+ #if (defined(__CHKCMD) && defined(__BUILTIN) && !defined(WIN32))\r
+ FILE* s;\r
+ int n = 0;\r
+ size_t len;\r
+ char* line = NULL;\r
+ int is_blank;\r
+ #endif\r
+ \r
+ \r
+ if(runner)\r
+ {\r
+ ERROR0("The runner is already initialized");\r
+ return -1;\r
+ }\r
+ \r
+ runner = xbt_new0(s_runner_t, 1);\r
+ \r
+ runner->path = NULL;\r
+ runner->builtin = NULL;\r
+ \r
+ if(!(runner->units = units_new(runner, fstreams)))\r
+ {\r
+ free(runner);\r
+ runner = NULL;\r
+ return -1;\r
+ }\r
+\r
+ runner->timeout = timeout;\r
+ runner->timeouted = 0;\r
+ runner->interrupted = 0;\r
+ runner->number_of_ended_units = 0;\r
+ runner->number_of_runned_units = 0;\r
+ runner->waiting = 0;\r
+ \r
+ runner->total_of_tests = 0;\r
+ runner->total_of_successeded_tests = 0;\r
+ runner->total_of_failed_tests = 0;\r
+ runner->total_of_interrupted_tests = 0;\r
+ \r
+ runner->total_of_units = 0;\r
+ runner->total_of_successeded_units = 0;\r
+ runner->total_of_failed_units = 0;\r
+ runner->total_of_interrupted_units = 0;\r
+ \r
+ runner->total_of_suites = 0;\r
+ runner->total_of_successeded_suites = 0;\r
+ runner->total_of_failed_suites = 0;\r
+ runner->total_of_interrupted_suites = 0;\r
+ \r
+ /* initialize the vector of variables */\r
+ runner->variables = xbt_dynar_new(sizeof(variable_t), (void_f_pvoid_t)variable_free);\r
+ \r
+ /* add the environment variables in the vector */\r
+ for(i = 0; environ[i] != NULL; i++)\r
+ {\r
+ val = strchr(environ[i], '=');\r
+ \r
+ if(val)\r
+ {\r
+ val++;\r
+ \r
+ if(val[0] != '\0')\r
+ strncpy(buffer, environ[i], (val - environ[i] -1));\r
+ \r
+ if(!strcmp("TESH_PPID", buffer))\r
+ is_tesh_root = 0;\r
+ \r
+ variable = variable_new(buffer, val);\r
+ variable->env = 1;\r
+ xbt_dynar_push(runner->variables, &variable);\r
+ \r
+ #ifndef WIN32\r
+ if(!strcmp("PATH", buffer))\r
+ #else\r
+ if(!strcmp("Path", buffer) || !strcmp("PATH", buffer))\r
+ #endif\r
+ {\r
+ char* p;\r
+ size_t j,k, len;\r
+ \r
+ /* get the list of paths */\r
+ \r
+ #ifdef WIN32\r
+ runner->path = explode(';', val);\r
+ #else\r
+ runner->path = explode(':', val);\r
+ #endif\r
+\r
+ /* remove spaces and backslahes at the end of the path */\r
+ for (k = 0; runner->path[k] != NULL; k++)\r
+ {\r
+ p = runner->path[k];\r
+ \r
+ len = strlen(p);\r
+ \r
+ #ifndef WIN32\r
+ for(j = len - 1; p[j] == '/' || p[j] == ' '; j--)\r
+ #else\r
+ for(j = len - 1; p[j] == '\\' || p[j] == ' '; j--)\r
+ #endif\r
+ p[j] = '\0';\r
+ }\r
+ }\r
+ \r
+ \r
+ memset(buffer, 0, PATH_MAX + 1);\r
+ }\r
+ }\r
+ \r
+ if(is_tesh_root)\r
+ {\r
+ char* tesh_dir = getcwd(NULL, 0);\r
+ \r
+ sprintf(buffer,"%d",getpid());\r
+ \r
+ #ifndef WIN32\r
+ setenv("TESH_PPID", buffer, 0);\r
+ setenv("TESH_DIR", tesh_dir, 0);\r
+ #else\r
+ SetEnvironmentVariable("TESH_PPID", buffer);\r
+ SetEnvironmentVariable("TESH_DIR", tesh_dir);\r
+ #endif\r
+ \r
+ variable = variable_new("TESH_PPID", buffer);\r
+ variable->err = 1;\r
+ \r
+ xbt_dynar_push(runner->variables, &variable);\r
+\r
+ variable = variable_new("TESH_DIR", tesh_dir);\r
+ variable->err = 1;\r
+ \r
+ xbt_dynar_push(runner->variables, &variable);\r
+ \r
+ free(tesh_dir);\r
+ }\r
+ \r
+ variable = variable_new("EXIT_SUCCESS", "0");\r
+ variable->err = 1;\r
+ \r
+ xbt_dynar_push(runner->variables, &variable);\r
+\r
+ variable = variable_new("EXIT_FAILURE", "1");\r
+ variable->err = 1;\r
+ \r
+ xbt_dynar_push(runner->variables, &variable);\r
+\r
+ variable = variable_new("TRUE", "0");\r
+ variable->err = 1;\r
+ \r
+ xbt_dynar_push(runner->variables, &variable);\r
+\r
+ variable = variable_new("FALSE", "1");\r
+ variable->err = 1;\r
+ \r
+ xbt_dynar_push(runner->variables, &variable);\r
+\r
+ i = 0;\r
+ \r
+ /* add the errors variables */\r
+ while((cstr = error_get_at(i++, &code)))\r
+ {\r
+ sprintf(buffer,"%d",code);\r
+ variable = variable_new(cstr, buffer);\r
+ variable->err = 1;\r
+ xbt_dynar_push(runner->variables, &variable);\r
+ }\r
+ \r
+ /* if the user want check the syntax, check it */\r
+ /*if(check_syntax_flag)\r
+ check_syntax();\r
+ */\r
+ \r
+ #if (!defined(WIN32) && defined(__CHKCMD))\r
+ #if defined(__BUILTIN)\r
+ \r
+ if(!is_tesh_root)\r
+ {\r
+ /* compute the full path the builtin.def file */\r
+ sprintf(buffer,"%s/builtin.def",getenv("TESH_DIR"));\r
+ \r
+ if(!(s = fopen(buffer, "r"))) \r
+ {\r
+ ERROR1("File `(%s)' not found", buffer);\r
+ return -1;\r
+ }\r
+ \r
+ }\r
+ else\r
+ {\r
+ if(!(s = fopen("builtin.def", "r"))) \r
+ {\r
+ ERROR0("File `(builtin.def)' not found");\r
+ return -1;\r
+ }\r
+ }\r
+ \r
+ if(s)\r
+ {\r
+ fpos_t begin;\r
+\r
+ fgetpos(s, &begin);\r
+\r
+ while(readline(s, &line, &len) != -1)\r
+ {\r
+ i = 0;\r
+ is_blank = 1;\r
+ \r
+\r
+ while(line[i] != '\0') \r
+ {\r
+ if (line[i] != ' ' && line[i] != '\t' && line[i]!='\n' && line[i]!='\r')\r
+ {\r
+ is_blank = 0;\r
+ break;\r
+ }\r
+ \r
+ i++;\r
+ }\r
+\r
+ if(!is_blank)\r
+ n++;\r
+ }\r
+\r
+ fsetpos(s, &begin);\r
+ free(line);\r
+ line = NULL;\r
+\r
+ if(n)\r
+ {\r
+ char* l;\r
+ \r
+ runner->builtin = xbt_new0(char*, n + 1); /* (char**) calloc(n + 1, sizeof(char*));*/\r
+ \r
+ n = 0;\r
+ \r
+ while(readline(s, &line, &len) != -1)\r
+ {\r
+ i = 0;\r
+ is_blank = 1;\r
+\r
+ while(line[i] != '\0') \r
+ {\r
+ if (line[i] != ' ' && line[i] != '\t' && line[i]!='\n' && line[i]!='\r')\r
+ {\r
+ is_blank = 0;\r
+ break;\r
+ }\r
+ \r
+ i++;\r
+ }\r
+\r
+ if(!is_blank)\r
+ {\r
+ l = strdup(line);\r
+\r
+ l[strlen(l) - 1] = '\0';\r
+\r
+ (runner->builtin)[n++] = l;\r
+ \r
+ }\r
+ }\r
+ \r
+ }\r
+ else\r
+ {\r
+ WARN0("The file `(builtin.def)' is empty");\r
+ free(runner->builtin);\r
+ runner->builtin = NULL;\r
+ }\r
+ \r
+\r
+ fclose(s);\r
+ \r
+ if(line)\r
+ free(line);\r
+ \r
+ }\r
+ \r
+ #else\r
+ runner->builtin = xbt_new0(char*, __BUILTIN_MAX + 1); /* (char**) calloc(__BUILTIN_MAX + 1, sizeof(char*));*/\r
+ \r
+ for(i = 0; i < __BUILTIN_MAX; i++)\r
+ runner->builtin[i] = strdup(builtin[i]); \r
+ #endif\r
+ #endif\r
+\r
+ return exit_code ? -1 : 0;\r
+}\r
+\r
+void\r
+runner_destroy(void)\r
+{\r
+ int i;\r
+ \r
+ if(runner->units)\r
+ units_free((void**)(&(runner->units)));\r
+ \r
+ if(runner->variables)\r
+ xbt_dynar_free(&runner->variables);\r
+ \r
+ #ifdef WIN32\r
+ CloseHandle(timer_handle);\r
+ #endif\r
+\r
+ if(runner->thread)\r
+ xbt_os_thread_join(runner->thread, NULL);\r
+ \r
+ if(runner->path)\r
+ {\r
+ for (i = 0; runner->path[i] != NULL; i++)\r
+ free(runner->path[i]);\r
+ \r
+ free(runner->path);\r
+ }\r
+\r
+ if(runner->builtin)\r
+ {\r
+ for (i = 0; runner->builtin[i] != NULL; i++)\r
+ free(runner->builtin[i]);\r
+ \r
+ free(runner->builtin);\r
+ }\r
+\r
+ free(runner);\r
+ \r
+\r
+ runner = NULL;\r
+}\r
+\r
+void\r
+runner_run(void)\r
+{\r
+ /* allocate the mutex used by the units to asynchronously access \r
+ * to the properties of the runner.\r
+ */\r
+ xbt_os_mutex_t mutex = xbt_os_mutex_init();\r
+ \r
+ /* run all the units */\r
+ units_run_all(runner->units, mutex);\r
+ \r
+ \r
+ if(!interrupted)\r
+ runner_wait();\r
+\r
+ \r
+ /* if the runner is timeouted or receive a interruption request\r
+ * , interrupt all the active units.\r
+ */\r
+ if(runner->timeouted || interrupted)\r
+ runner_interrupt();\r
+ \r
+ /* joins all the units */\r
+ units_join_all(runner->units);\r
+ \r
+ /* release the mutex resource */\r
+ xbt_os_mutex_destroy(mutex);\r
+\r
+}\r
+\r
+static void\r
+runner_wait(void)\r
+{\r
+ if(runner->timeout > 0)\r
+ runner->thread = xbt_os_thread_create("", runner_start_routine, NULL);\r
+ \r
+ /* signal that the runner is waiting */\r
+ runner->waiting = 1;\r
+ \r
+ /* wait for the end of all the units */\r
+ xbt_os_sem_acquire(units_sem);\r
+\r
+ \r
+ runner->waiting = 0;\r
+}\r
+\r
+\r
+\r
+/*\r
+ * interrupt all the active units.\r
+ * this function is called when the lead time of the execution is reached\r
+ * or when a failed unit requests an interruption of the execution.\r
+ */\r
+void\r
+runner_interrupt(void)\r
+{\r
+ units_interrupt_all(runner->units);\r
+}\r
+\r
+void\r
+runner_summarize(void)\r
+{\r
+ \r
+ if(!dry_run_flag)\r
+ {\r
+ #ifndef WIN32\r
+ struct rusage r_usage;\r
+ #else\r
+ FILETIME start_time;\r
+ FILETIME exit_time;\r
+ FILETIME kernel_time;\r
+ FILETIME user_time;\r
+ SYSTEMTIME si;\r
+ #endif\r
+ \r
+ printf("\n TEst SHell utility - mini shell specialized in running test units.\n");\r
+ printf(" =============================================================================\n");\r
+ \r
+ units_summuarize(runner->units);\r
+ \r
+ printf(" =====================================================================%s\n",\r
+ runner->total_of_failed_tests ? "== FAILED": (runner->total_of_interrupted_tests || runner->total_of_interrupted_units) ? "==== INTR" : "====== OK");\r
+ \r
+ printf(" TOTAL : Suite(s): %.0f%% ok (%d suite(s): %d ok",\r
+ (runner->total_of_suites ? (1-((double)runner->total_of_failed_suites + (double)runner->total_of_interrupted_suites)/(double)runner->total_of_suites)*100.0 : 100.0),\r
+ runner->total_of_suites, runner->total_of_successeded_suites);\r
+ \r
+ if(runner->total_of_failed_suites > 0)\r
+ printf(", %d failed", runner->total_of_failed_suites);\r
+ \r
+ if(runner->total_of_interrupted_suites > 0)\r
+ printf(", %d interrupted)", runner->total_of_interrupted_suites);\r
+ \r
+ printf(")\n"); \r
+ \r
+ printf(" Unit(s): %.0f%% ok (%d unit(s): %d ok",\r
+ (runner->total_of_units ? (1-((double)runner->total_of_failed_units + (double)runner->total_of_interrupted_units)/(double)runner->total_of_units)*100.0 : 100.0),\r
+ runner->total_of_units, runner->total_of_successeded_units);\r
+ \r
+ if(runner->total_of_failed_units > 0)\r
+ printf(", %d failed", runner->total_of_failed_units);\r
+ \r
+ if(runner->total_of_interrupted_units > 0)\r
+ printf(", %d interrupted)", runner->total_of_interrupted_units);\r
+ \r
+ printf(")\n");\r
+ \r
+ printf(" Test(s): %.0f%% ok (%d test(s): %d ok",\r
+ (runner->total_of_tests ? (1-((double)runner->total_of_failed_tests + (double)runner->total_of_interrupted_tests)/(double)runner->total_of_tests)*100.0 : 100.0),\r
+ runner->total_of_tests, runner->total_of_successeded_tests);\r
+ \r
+ if(runner->total_of_failed_tests > 0)\r
+ printf(", %d failed", runner->total_of_failed_tests);\r
+ \r
+ if(runner->total_of_interrupted_tests > 0)\r
+ printf(", %d interrupted)", runner->total_of_interrupted_tests);\r
+ \r
+ printf(")\n\n");\r
+ \r
+ #ifndef WIN32\r
+ if(!getrusage(RUSAGE_SELF, &r_usage))\r
+ {\r
+ \r
+ printf(" Total tesh user time used: %ld second(s) %ld microsecond(s)\n", r_usage.ru_utime.tv_sec, r_usage.ru_utime.tv_usec);\r
+ printf(" Total tesh system time used: %ld second(s) %ld microsecond(s)\n\n", r_usage.ru_stime.tv_sec, r_usage.ru_stime.tv_usec);\r
+ \r
+ if(!getrusage(RUSAGE_CHILDREN, &r_usage))\r
+ {\r
+ printf(" Total children user time used: %ld second(s) %ld microsecond(s)\n", r_usage.ru_utime.tv_sec, r_usage.ru_utime.tv_usec);\r
+ printf(" Total children system time used: %ld second(s) %ld microsecond(s)\n\n", r_usage.ru_stime.tv_sec, r_usage.ru_stime.tv_usec);\r
+ \r
+ } \r
+ }\r
+ #else\r
+ \r
+ if(GetProcessTimes(GetCurrentProcess(), &start_time, &exit_time, &kernel_time, &user_time))\r
+ {\r
+ FileTimeToSystemTime(&user_time, &si);\r
+ \r
+ printf(" User time used: %2u Hour(s) %2u Minute(s) %2u Second(s) %3u Millisecond(s)\n", si.wHour, si.wMinute, si.wSecond, si.wMilliseconds );\r
+ \r
+ FileTimeToSystemTime(&kernel_time, &si);\r
+ \r
+ printf(" Kernel time used: %2u Hour(s) %2u Minute(s) %2u Second(s) %3u Millisecond(s)\n", si.wHour, si.wMinute, si.wSecond, si.wMilliseconds );\r
+ }\r
+\r
+\r
+\r
+ #endif\r
+ }\r
+ else\r
+ {\r
+ if(exit_code)\r
+ ERROR0("Syntax NOK");\r
+ else if(!exit_code)\r
+ INFO0("Syntax 0K");\r
+ }\r
+}\r
+\r
+int\r
+runner_is_timedout(void)\r
+{\r
+ return runner->timeouted;\r
+}\r
+\r