utilities/test/test_ascSignal.c

/*
 *  Unit test functions for ASCEND: utilities/ascSignal.c
 *
 *  Copyright (C) 2005 Jerry St.Clair
 *
 *  This file is part of the Ascend Environment.
 *
 *  The Ascend Environment is free software; you can redistribute it
 *  and/or modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of the
 *  License, or (at your option) any later version.
 *
 *  The Ascend Environment is distributed in hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with the program; if not, write to the Free Software Foundation,
 *  Inc., 675 Mass Ave, Cambridge, MA 02139 USA.  Check the file named
 *  COPYING.
 */

#include <stdio.h>
#ifdef __WIN32__
#include <io.h>
#endif
#include "utilities/ascConfig.h"
#include "utilities/ascMalloc.h"
#include "utilities/ascSignal.h"
#include "CUnit/CUnit.h"
#include "test_ascSignal.h"

static jmp_buf my_jmp_buf1;

static int f_handler1_called;
static int f_handler1_sigval;
/*
 *  Signal handler for unit tests.
 *  Resets the signal handlers and sets f_handler1_called to
 *  TRUE and f_handler1_sigval to the signal type code (-1 if
 *  an unsupported sigval).  Then longjmp's using
 *  my_jmp_buf1 and the sigval.
 */
void my_handler1(int sigval)
{
  f_handler1_called = TRUE;
  Asc_SignalRecover(FALSE);
  switch (sigval)
  {
    case SIGFPE:
      f_handler1_sigval = SIGFPE;
      FPRESET;
      break;
    case SIGINT:
      f_handler1_sigval = SIGINT;
      break;
    case SIGSEGV:
      f_handler1_sigval = SIGSEGV;
      break;
    default:
      f_handler1_sigval = -1;
      break;
  }
  longjmp(my_jmp_buf1, sigval);
}

static jmp_buf my_jmp_buf2;

static int f_handler2_called;
static int f_handler2_sigval;
/*
 *  Signal handler for unit tests.
 *  Resets the signal handlers and sets f_handler1_called to
 *  TRUE and f_handler1_sigval to the signal type code (-1 if
 *  an unsupported sigval).  Then longjmp's using
 *  my_jmp_buf1 and the sigval.
 */
void my_handler2(int sigval)
{
  f_handler2_called = TRUE;
  Asc_SignalRecover(FALSE);
  switch (sigval)
  {
    case SIGFPE:
      f_handler2_sigval = SIGFPE;
      FPRESET;
      break;
    case SIGINT:
      f_handler2_sigval = SIGINT;
      break;
    case SIGSEGV:
      f_handler2_sigval = SIGSEGV;
      break;
    default:
      f_handler2_sigval = -1;
      break;
  }
  longjmp(my_jmp_buf2, sigval);
}


static void test_ascSignal(void)
{
  SigHandler old_fpe_handler = NULL;
  SigHandler old_int_handler = NULL;
  SigHandler old_seg_handler = NULL;
  SigHandler old_handler;
  volatile int signal1_caught;
  volatile int signal2_caught;
  volatile int signal3_caught;
  volatile int i_initialized_lists = FALSE;
  unsigned long prior_meminuse;

  prior_meminuse = ascmeminuse();             /* save meminuse() at start of test function */

#ifdef NO_SIGNAL_TRAPS
  /* no point in testing if the functionality is disabled */
  CU_FAIL("Signal handler manager not enabled.");
#else
  
  old_fpe_handler = signal(SIGFPE, my_handler1);        /* save any pre-existing handlers */
  old_int_handler = signal(SIGINT, my_handler1);
  old_seg_handler = signal(SIGSEGV, my_handler1);

  /* make sure list system is initialized - needed by Asc_SignalInit() */
  if (FALSE == gl_pool_initialized()) {
    gl_init();
    gl_init_pool();
    i_initialized_lists = TRUE;
  }

  signal(SIGFPE, my_handler1);                          /* install some pre-existing handlers */
  signal(SIGINT, SIG_DFL);
  signal(SIGSEGV, my_handler2);

  /* Asc_SignalInit(), Asc_SignalDestroy() - not much to test */

  CU_TEST(0 == Asc_SignalInit());                       /* initialize the signal manager */

  old_handler = signal(SIGFPE, SIG_DFL);                /* previously-installed handlers should still be active */
  CU_TEST(my_handler1 == old_handler);
  old_handler = signal(SIGINT, SIG_DFL);
  CU_TEST(NULL == old_handler);
  old_handler = signal(SIGSEGV, SIG_DFL);
  CU_TEST(my_handler2 == old_handler);

  Asc_SignalRecover(TRUE);

  old_handler = signal(SIGFPE, SIG_DFL);                /* handlers should have been reinstalled */
  CU_TEST(my_handler1 == old_handler);
  old_handler = signal(SIGINT, SIG_DFL);
  CU_TEST(NULL == old_handler);
  old_handler = signal(SIGSEGV, SIG_DFL);
  CU_TEST(my_handler2 == old_handler);

  Asc_SignalRecover(TRUE);

  /* test Asc_SignalPush(), Asc_SignalPop() */

  CU_TEST(0 == Asc_SignalHandlerPush(SIGFPE, Asc_SignalTrap));  /* ok - supported signal, ok func */
  old_handler = signal(SIGFPE, SIG_DFL);
  CU_TEST(Asc_SignalTrap == old_handler);

  CU_TEST(0 == Asc_SignalHandlerPush(SIGINT, my_handler1));     /* ok - supported signal, ok func */
  old_handler = signal(SIGINT, SIG_DFL);
  CU_TEST(my_handler1 == old_handler);

  CU_TEST(0 == Asc_SignalHandlerPush(SIGSEGV, NULL));           /* NULL func - should have no effect */
  old_handler = signal(SIGSEGV, SIG_DFL);
  CU_TEST(my_handler2 == old_handler);                          /* old handler should still be installed */

  CU_TEST(0 != Asc_SignalHandlerPush(SIGILL, Asc_SignalTrap));  /* unsupported signal type */
  CU_TEST(0 != Asc_SignalHandlerPush(SIGABRT, my_handler2));    /* unsupported signal type */

  Asc_SignalRecover(TRUE);

  old_handler = signal(SIGFPE, SIG_DFL);                /* handlers should have been reinstalled */
  CU_TEST(Asc_SignalTrap == old_handler);
  old_handler = signal(SIGINT, SIG_DFL);
  CU_TEST(my_handler1 == old_handler);
  old_handler = signal(SIGSEGV, SIG_DFL);
  CU_TEST(my_handler2 == old_handler);
  Asc_SignalRecover(TRUE);

  CU_TEST(0 == Asc_SignalHandlerPop(SIGINT, my_handler1));
  old_handler = signal(SIGFPE, SIG_DFL);                /* SIGINT should be reset to no handler */
  CU_TEST(Asc_SignalTrap == old_handler);
  old_handler = signal(SIGINT, SIG_DFL);
  CU_TEST(NULL == old_handler);
  old_handler = signal(SIGSEGV, SIG_DFL);
  CU_TEST(my_handler2 == old_handler);
  Asc_SignalRecover(TRUE);

  CU_TEST(0 != Asc_SignalHandlerPop(SIGFPE, my_handler1));  /* wrong handler indicated */
  old_handler = signal(SIGFPE, SIG_DFL);                /* so SIGFPE should be not be reset */
  CU_TEST(Asc_SignalTrap == old_handler);
  old_handler = signal(SIGINT, SIG_DFL);
  CU_TEST(NULL == old_handler);
  old_handler = signal(SIGSEGV, SIG_DFL);
  CU_TEST(my_handler2 == old_handler);
  Asc_SignalRecover(TRUE);

  old_handler = signal(SIGFPE, SIG_DFL);                /* but Asc_SignalRecover should reset it */
  CU_TEST(my_handler1 == old_handler);
  old_handler = signal(SIGINT, SIG_DFL);
  CU_TEST(NULL == old_handler);
  old_handler = signal(SIGSEGV, SIG_DFL);
  CU_TEST(my_handler2 == old_handler);
  Asc_SignalRecover(TRUE);

  CU_TEST(0 != Asc_SignalHandlerPop(SIGILL, my_handler1));     /* unsupported signal type */
  CU_TEST(0 != Asc_SignalHandlerPop(SIGABRT, Asc_SignalTrap)); /* unsupported signal type */

  old_handler = signal(SIGFPE, SIG_DFL);                /* should be no change in handlers */
  CU_TEST(my_handler1 == old_handler);
  old_handler = signal(SIGINT, SIG_DFL);
  CU_TEST(NULL == old_handler);
  old_handler = signal(SIGSEGV, SIG_DFL);
  CU_TEST(my_handler2 == old_handler);
  Asc_SignalRecover(TRUE);

  /* test Asc_SignalTrap() */

  CU_TEST(0 == Asc_SignalHandlerPush(SIGFPE, Asc_SignalTrap));
  CU_TEST(0 == Asc_SignalHandlerPush(SIGINT, Asc_SignalTrap));
  CU_TEST(0 == Asc_SignalHandlerPush(SIGSEGV, Asc_SignalTrap));

  signal1_caught = FALSE;
  if (0 == setjmp(g_fpe_env)) {                         /* raise & catch a SIGFPE */
    raise(SIGFPE);
  }
  else {
    signal1_caught = TRUE;
    CU_PASS("SIGFPE caught.");
  }
  CU_TEST(TRUE == signal1_caught);

  signal1_caught = FALSE;
  if (0 == setjmp(g_int_env)) {                         /* raise & catch a SIGINT */
    raise(SIGINT);
  }
  else {
    signal1_caught = TRUE;
    CU_PASS("SIGINT caught.");
  }
  CU_TEST(TRUE == signal1_caught);

  signal1_caught = FALSE;
  if (0 == setjmp(g_seg_env)) {                         /* raise & catch a SIGSEGV */
    raise(SIGSEGV);
  }
  else {
    signal1_caught = TRUE;
    CU_PASS("SIGSEGV caught.");
  }
  CU_TEST(TRUE == signal1_caught);

Asc_SignalRecover(TRUE);

  CU_TEST(0 == Asc_SignalHandlerPop(SIGFPE, Asc_SignalTrap));
  CU_TEST(0 == Asc_SignalHandlerPop(SIGINT, Asc_SignalTrap));
  CU_TEST(0 == Asc_SignalHandlerPop(SIGSEGV, Asc_SignalTrap));

  old_handler = signal(SIGFPE, SIG_DFL);                /* handlers should be restored at this point */
  CU_TEST(my_handler1 == old_handler);
  old_handler = signal(SIGINT, SIG_DFL);
  CU_TEST(NULL == old_handler);
  old_handler = signal(SIGSEGV, SIG_DFL);
  CU_TEST(my_handler2 == old_handler);
  Asc_SignalRecover(TRUE);

  /* test typical use with nesting of handlers */

  f_handler1_called = FALSE;                              /* initialize flags for detecting flow */
  f_handler1_sigval = 0;
  f_handler2_called = FALSE;
  f_handler2_sigval = 0;
  signal1_caught = FALSE;
  signal2_caught = FALSE;
  signal3_caught = FALSE;

  CU_TEST(0 == Asc_SignalHandlerPush(SIGFPE, my_handler1));   /* test for SIGFPE */
  if (0 == setjmp(my_jmp_buf1)) {
    CU_TEST(0 == Asc_SignalHandlerPush(SIGFPE, my_handler2));
    if (0 == setjmp(my_jmp_buf2)) {
      CU_TEST(0 == Asc_SignalHandlerPush(SIGFPE, Asc_SignalTrap));
      if (0 == setjmp(g_fpe_env)) {
         raise(SIGFPE);
      }
      else {
        CU_TEST(f_handler1_called == FALSE);
        CU_TEST(f_handler1_sigval == 0);
        CU_TEST(f_handler2_called == FALSE);
        CU_TEST(f_handler2_sigval == 0);
        signal3_caught = TRUE;
      }
      CU_TEST(FALSE == signal1_caught);
      CU_TEST(FALSE == signal2_caught);
      CU_TEST(TRUE == signal3_caught);
      CU_TEST(0 == Asc_SignalHandlerPop(SIGFPE, Asc_SignalTrap));
      f_handler1_called = FALSE;
      f_handler1_sigval = 0;
      f_handler2_called = FALSE;
      f_handler2_sigval = 0;
      signal1_caught = FALSE;
      signal2_caught = FALSE;
      signal3_caught = FALSE;
      raise(SIGFPE);
    }
    else {
      CU_TEST(f_handler1_called == FALSE);
      CU_TEST(f_handler1_sigval == 0);
      CU_TEST(f_handler2_called == TRUE);
      CU_TEST(f_handler2_sigval == SIGFPE);
      signal2_caught = TRUE;
    }
    CU_TEST(FALSE == signal1_caught);
    CU_TEST(TRUE == signal2_caught);
    CU_TEST(FALSE == signal3_caught);
    CU_TEST(0 == Asc_SignalHandlerPop(SIGFPE, my_handler2));
    f_handler1_called = FALSE;
    f_handler1_sigval = 0;
    f_handler2_called = FALSE;
    f_handler2_sigval = 0;
    signal1_caught = FALSE;
    signal2_caught = FALSE;
    signal3_caught = FALSE;
    raise(SIGFPE);
  }
  else {
    CU_TEST(f_handler1_called == TRUE);
    CU_TEST(f_handler1_sigval == SIGFPE);
    CU_TEST(f_handler2_called == FALSE);
    CU_TEST(f_handler2_sigval == 0);
    signal1_caught = TRUE;
  }
  CU_TEST(TRUE == signal1_caught);
  CU_TEST(FALSE == signal2_caught);
  CU_TEST(FALSE == signal3_caught);
  CU_TEST(0 == Asc_SignalHandlerPop(SIGFPE, my_handler1));

  f_handler1_called = FALSE;                              /* initialize flags for detecting flow */
  f_handler1_sigval = 0;
  f_handler2_called = FALSE;
  f_handler2_sigval = 0;
  signal1_caught = FALSE;
  signal2_caught = FALSE;
  signal3_caught = FALSE;

  CU_TEST(0 == Asc_SignalHandlerPush(SIGINT, my_handler2));   /* test for SIGINT */
  if (0 == setjmp(my_jmp_buf2)) {
    CU_TEST(0 == Asc_SignalHandlerPush(SIGINT, Asc_SignalTrap));
    if (0 == setjmp(g_int_env)) {
      CU_TEST(0 == Asc_SignalHandlerPush(SIGINT, my_handler1));
      if (0 == setjmp(my_jmp_buf1)) {
         raise(SIGINT);
      }
      else {
        CU_TEST(f_handler1_called == TRUE);
        CU_TEST(f_handler1_sigval == SIGINT);
        CU_TEST(f_handler2_called == FALSE);
        CU_TEST(f_handler2_sigval == 0);
        signal3_caught = TRUE;
      }
      CU_TEST(FALSE == signal1_caught);
      CU_TEST(FALSE == signal2_caught);
      CU_TEST(TRUE == signal3_caught);
      CU_TEST(0 == Asc_SignalHandlerPop(SIGINT, my_handler1));
      f_handler1_called = FALSE;
      f_handler1_sigval = 0;
      f_handler2_called = FALSE;
      f_handler2_sigval = 0;
      signal1_caught = FALSE;
      signal2_caught = FALSE;
      signal3_caught = FALSE;
      raise(SIGINT);
    }
    else {
      CU_TEST(f_handler1_called == FALSE);
      CU_TEST(f_handler1_sigval == 0);
      CU_TEST(f_handler2_called == FALSE);
      CU_TEST(f_handler2_sigval == 0);
      signal2_caught = TRUE;
    }
    CU_TEST(FALSE == signal1_caught);
    CU_TEST(TRUE == signal2_caught);
    CU_TEST(FALSE == signal3_caught);
    CU_TEST(0 == Asc_SignalHandlerPop(SIGINT, Asc_SignalTrap));
    f_handler1_called = FALSE;
    f_handler1_sigval = 0;
    f_handler2_called = FALSE;
    f_handler2_sigval = 0;
    signal1_caught = FALSE;
    signal2_caught = FALSE;
    signal3_caught = FALSE;
    raise(SIGINT);
  }
  else {
    CU_TEST(f_handler1_called == FALSE);
    CU_TEST(f_handler1_sigval == 0);
    CU_TEST(f_handler2_called == TRUE);
    CU_TEST(f_handler2_sigval == SIGINT);
    signal1_caught = TRUE;
  }
  CU_TEST(TRUE == signal1_caught);
  CU_TEST(FALSE == signal2_caught);
  CU_TEST(FALSE == signal3_caught);
  CU_TEST(0 == Asc_SignalHandlerPop(SIGINT, my_handler2));

  f_handler1_called = FALSE;                              /* initialize flags for detecting flow */
  f_handler1_sigval = 0;
  f_handler2_called = FALSE;
  f_handler2_sigval = 0;
  signal1_caught = FALSE;
  signal2_caught = FALSE;
  signal3_caught = FALSE;

  CU_TEST(0 == Asc_SignalHandlerPush(SIGSEGV, Asc_SignalTrap));   /* test for SIGSEGV */
  if (0 == setjmp(g_seg_env)) {
    CU_TEST(0 == Asc_SignalHandlerPush(SIGSEGV, my_handler2));
    if (0 == setjmp(my_jmp_buf2)) {
      CU_TEST(0 == Asc_SignalHandlerPush(SIGSEGV, my_handler1));
      if (0 == setjmp(my_jmp_buf1)) {
         raise(SIGSEGV);
      }
      else {
        CU_TEST(f_handler1_called == TRUE);
        CU_TEST(f_handler1_sigval == SIGSEGV);
        CU_TEST(f_handler2_called == FALSE);
        CU_TEST(f_handler2_sigval == 0);
        signal3_caught = TRUE;
      }
      CU_TEST(FALSE == signal1_caught);
      CU_TEST(FALSE == signal2_caught);
      CU_TEST(TRUE == signal3_caught);
      CU_TEST(0 == Asc_SignalHandlerPop(SIGSEGV, my_handler1));
      f_handler1_called = FALSE;
      f_handler1_sigval = 0;
      f_handler2_called = FALSE;
      f_handler2_sigval = 0;
      signal1_caught = FALSE;
      signal2_caught = FALSE;
      signal3_caught = FALSE;
      raise(SIGSEGV);
    }
    else {
      CU_TEST(f_handler1_called == FALSE);
      CU_TEST(f_handler1_sigval == 0);
      CU_TEST(f_handler2_called == TRUE);
      CU_TEST(f_handler2_sigval == SIGSEGV);
      signal2_caught = TRUE;
    }
    CU_TEST(FALSE == signal1_caught);
    CU_TEST(TRUE == signal2_caught);
    CU_TEST(FALSE == signal3_caught);
    CU_TEST(0 == Asc_SignalHandlerPop(SIGSEGV, my_handler2));
    f_handler1_called = FALSE;
    f_handler1_sigval = 0;
    f_handler2_called = FALSE;
    f_handler2_sigval = 0;
    signal1_caught = FALSE;
    signal2_caught = FALSE;
    signal3_caught = FALSE;
    raise(SIGSEGV);
  }
  else {
    CU_TEST(f_handler1_called == FALSE);
    CU_TEST(f_handler1_sigval == 0);
    CU_TEST(f_handler2_called == FALSE);
    CU_TEST(f_handler2_sigval == 0);
    signal1_caught = TRUE;
  }
  CU_TEST(TRUE == signal1_caught);
  CU_TEST(FALSE == signal2_caught);
  CU_TEST(FALSE == signal3_caught);
  CU_TEST(0 == Asc_SignalHandlerPop(SIGSEGV, Asc_SignalTrap));

  old_handler = signal(SIGFPE, SIG_DFL);                /* handlers should be restored at this point */
  CU_TEST(my_handler1 == old_handler);
  old_handler = signal(SIGINT, SIG_DFL);
  CU_TEST(NULL == old_handler);
  old_handler = signal(SIGSEGV, SIG_DFL);
  CU_TEST(my_handler2 == old_handler);
  Asc_SignalRecover(TRUE);

  Asc_SignalDestroy();

  old_handler = signal(SIGFPE, SIG_DFL);                /* original handlers should still be in place */
  CU_TEST(my_handler1 == old_handler);
  old_handler = signal(SIGINT, SIG_DFL);
  CU_TEST(NULL == old_handler);
  old_handler = signal(SIGSEGV, SIG_DFL);
  CU_TEST(my_handler2 == old_handler);
  Asc_SignalRecover(TRUE);

  if (TRUE == i_initialized_lists) {
    gl_destroy_pool();
  }

#endif  /* NO_SIGNAL_TRAPS */

  if (NULL != old_fpe_handler)                /* restore any pre-existing handlers */
    signal(SIGFPE, old_fpe_handler);
  if (NULL != old_int_handler)
    signal(SIGINT, old_int_handler);
  if (NULL != old_seg_handler)
    signal(SIGSEGV, old_seg_handler);

  CU_TEST(prior_meminuse == ascmeminuse());   /* make sure we cleaned up after ourselves */
}

/*===========================================================================*/
/* Registration information */

static CU_TestInfo ascSignal_test_list[] = {
  {"test_ascSignal", test_ascSignal},
  CU_TEST_INFO_NULL
};

static CU_SuiteInfo suites[] = {
  {"test_utilities_ascSignal", NULL, NULL, ascSignal_test_list},
  CU_SUITE_INFO_NULL
};

/*-------------------------------------------------------------------*/
CU_ErrorCode test_register_utilities_ascSignal(void)
{
  return CU_register_suites(suites);
}
1	jds	59	/*
2			* Unit test functions for ASCEND: utilities/ascSignal.c
3			*
4			* Copyright (C) 2005 Jerry St.Clair
5			*
6			* This file is part of the Ascend Environment.
7			*
8			* The Ascend Environment is free software; you can redistribute it
9			* and/or modify it under the terms of the GNU General Public License as
10			* published by the Free Software Foundation; either version 2 of the
11			* License, or (at your option) any later version.
12			*
13			* The Ascend Environment is distributed in hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16			* General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with the program; if not, write to the Free Software Foundation,
20			* Inc., 675 Mass Ave, Cambridge, MA 02139 USA. Check the file named
21			* COPYING.
22			*/
23
24			#include <stdio.h>
25	jds	60	#ifdef __WIN32__
26	jds	59	#include <io.h>
27	jds	60	#endif
28	jds	59	#include "utilities/ascConfig.h"
29			#include "utilities/ascMalloc.h"
30			#include "utilities/ascSignal.h"
31			#include "CUnit/CUnit.h"
32			#include "test_ascSignal.h"
33
34			static jmp_buf my_jmp_buf1;
35
36	jds	61	static int f_handler1_called;
37			static int f_handler1_sigval;
38	jds	59	/*
39			* Signal handler for unit tests.
40	jds	61	* Resets the signal handlers and sets f_handler1_called to
41			* TRUE and f_handler1_sigval to the signal type code (-1 if
42	jds	59	* an unsupported sigval). Then longjmp's using
43			* my_jmp_buf1 and the sigval.
44			*/
45			void my_handler1(int sigval)
46			{
47	jds	61	f_handler1_called = TRUE;
48	jds	59	Asc_SignalRecover(FALSE);
49			switch (sigval)
50			{
51			case SIGFPE:
52	jds	61	f_handler1_sigval = SIGFPE;
53	jds	59	FPRESET;
54			break;
55			case SIGINT:
56	jds	61	f_handler1_sigval = SIGINT;
57	jds	59	break;
58			case SIGSEGV:
59	jds	61	f_handler1_sigval = SIGSEGV;
60	jds	59	break;
61			default:
62	jds	61	f_handler1_sigval = -1;
63	jds	59	break;
64			}
65			longjmp(my_jmp_buf1, sigval);
66			}
67
68			static jmp_buf my_jmp_buf2;
69
70	jds	61	static int f_handler2_called;
71			static int f_handler2_sigval;
72	jds	59	/*
73			* Signal handler for unit tests.
74	jds	61	* Resets the signal handlers and sets f_handler1_called to
75			* TRUE and f_handler1_sigval to the signal type code (-1 if
76	jds	59	* an unsupported sigval). Then longjmp's using
77			* my_jmp_buf1 and the sigval.
78			*/
79			void my_handler2(int sigval)
80			{
81	jds	61	f_handler2_called = TRUE;
82	jds	59	Asc_SignalRecover(FALSE);
83			switch (sigval)
84			{
85			case SIGFPE:
86	jds	61	f_handler2_sigval = SIGFPE;
87	jds	59	FPRESET;
88			break;
89			case SIGINT:
90	jds	61	f_handler2_sigval = SIGINT;
91	jds	59	break;
92			case SIGSEGV:
93	jds	61	f_handler2_sigval = SIGSEGV;
94	jds	59	break;
95			default:
96	jds	61	f_handler2_sigval = -1;
97	jds	59	break;
98			}
99			longjmp(my_jmp_buf2, sigval);
100			}
101
102
103			static void test_ascSignal(void)
104			{
105			SigHandler old_fpe_handler = NULL;
106			SigHandler old_int_handler = NULL;
107			SigHandler old_seg_handler = NULL;
108			SigHandler old_handler;
109			volatile int signal1_caught;
110			volatile int signal2_caught;
111			volatile int signal3_caught;
112			volatile int i_initialized_lists = FALSE;
113			unsigned long prior_meminuse;
114
115			prior_meminuse = ascmeminuse(); /* save meminuse() at start of test function */
116
117			#ifdef NO_SIGNAL_TRAPS
118			/* no point in testing if the functionality is disabled */
119			CU_FAIL("Signal handler manager not enabled.");
120			#else
121	jds	61
122	jds	59	old_fpe_handler = signal(SIGFPE, my_handler1); /* save any pre-existing handlers */
123			old_int_handler = signal(SIGINT, my_handler1);
124			old_seg_handler = signal(SIGSEGV, my_handler1);
125
126	jds	61	/* make sure list system is initialized - needed by Asc_SignalInit() */
127	jds	59	if (FALSE == gl_pool_initialized()) {
128			gl_init();
129			gl_init_pool();
130			i_initialized_lists = TRUE;
131			}
132
133			signal(SIGFPE, my_handler1); /* install some pre-existing handlers */
134			signal(SIGINT, SIG_DFL);
135			signal(SIGSEGV, my_handler2);
136
137			/* Asc_SignalInit(), Asc_SignalDestroy() - not much to test */
138
139			CU_TEST(0 == Asc_SignalInit()); /* initialize the signal manager */
140
141			old_handler = signal(SIGFPE, SIG_DFL); /* previously-installed handlers should still be active */
142			CU_TEST(my_handler1 == old_handler);
143			old_handler = signal(SIGINT, SIG_DFL);
144			CU_TEST(NULL == old_handler);
145			old_handler = signal(SIGSEGV, SIG_DFL);
146			CU_TEST(my_handler2 == old_handler);
147
148			Asc_SignalRecover(TRUE);
149
150			old_handler = signal(SIGFPE, SIG_DFL); /* handlers should have been reinstalled */
151			CU_TEST(my_handler1 == old_handler);
152			old_handler = signal(SIGINT, SIG_DFL);
153			CU_TEST(NULL == old_handler);
154			old_handler = signal(SIGSEGV, SIG_DFL);
155			CU_TEST(my_handler2 == old_handler);
156
157			Asc_SignalRecover(TRUE);
158
159			/* test Asc_SignalPush(), Asc_SignalPop() */
160
161			CU_TEST(0 == Asc_SignalHandlerPush(SIGFPE, Asc_SignalTrap)); /* ok - supported signal, ok func */
162			old_handler = signal(SIGFPE, SIG_DFL);
163			CU_TEST(Asc_SignalTrap == old_handler);
164
165			CU_TEST(0 == Asc_SignalHandlerPush(SIGINT, my_handler1)); /* ok - supported signal, ok func */
166			old_handler = signal(SIGINT, SIG_DFL);
167			CU_TEST(my_handler1 == old_handler);
168
169			CU_TEST(0 == Asc_SignalHandlerPush(SIGSEGV, NULL)); /* NULL func - should have no effect */
170			old_handler = signal(SIGSEGV, SIG_DFL);
171			CU_TEST(my_handler2 == old_handler); /* old handler should still be installed */
172
173			CU_TEST(0 != Asc_SignalHandlerPush(SIGILL, Asc_SignalTrap)); /* unsupported signal type */
174			CU_TEST(0 != Asc_SignalHandlerPush(SIGABRT, my_handler2)); /* unsupported signal type */
175
176			Asc_SignalRecover(TRUE);
177
178			old_handler = signal(SIGFPE, SIG_DFL); /* handlers should have been reinstalled */
179			CU_TEST(Asc_SignalTrap == old_handler);
180			old_handler = signal(SIGINT, SIG_DFL);
181			CU_TEST(my_handler1 == old_handler);
182			old_handler = signal(SIGSEGV, SIG_DFL);
183			CU_TEST(my_handler2 == old_handler);
184			Asc_SignalRecover(TRUE);
185
186			CU_TEST(0 == Asc_SignalHandlerPop(SIGINT, my_handler1));
187			old_handler = signal(SIGFPE, SIG_DFL); /* SIGINT should be reset to no handler */
188			CU_TEST(Asc_SignalTrap == old_handler);
189			old_handler = signal(SIGINT, SIG_DFL);
190			CU_TEST(NULL == old_handler);
191			old_handler = signal(SIGSEGV, SIG_DFL);
192			CU_TEST(my_handler2 == old_handler);
193			Asc_SignalRecover(TRUE);
194
195			CU_TEST(0 != Asc_SignalHandlerPop(SIGFPE, my_handler1)); /* wrong handler indicated */
196			old_handler = signal(SIGFPE, SIG_DFL); /* so SIGFPE should be not be reset */
197			CU_TEST(Asc_SignalTrap == old_handler);
198			old_handler = signal(SIGINT, SIG_DFL);
199			CU_TEST(NULL == old_handler);
200			old_handler = signal(SIGSEGV, SIG_DFL);
201			CU_TEST(my_handler2 == old_handler);
202			Asc_SignalRecover(TRUE);
203
204			old_handler = signal(SIGFPE, SIG_DFL); /* but Asc_SignalRecover should reset it */
205			CU_TEST(my_handler1 == old_handler);
206			old_handler = signal(SIGINT, SIG_DFL);
207			CU_TEST(NULL == old_handler);
208			old_handler = signal(SIGSEGV, SIG_DFL);
209			CU_TEST(my_handler2 == old_handler);
210			Asc_SignalRecover(TRUE);
211
212			CU_TEST(0 != Asc_SignalHandlerPop(SIGILL, my_handler1)); /* unsupported signal type */
213			CU_TEST(0 != Asc_SignalHandlerPop(SIGABRT, Asc_SignalTrap)); /* unsupported signal type */
214
215			old_handler = signal(SIGFPE, SIG_DFL); /* should be no change in handlers */
216			CU_TEST(my_handler1 == old_handler);
217			old_handler = signal(SIGINT, SIG_DFL);
218			CU_TEST(NULL == old_handler);
219			old_handler = signal(SIGSEGV, SIG_DFL);
220			CU_TEST(my_handler2 == old_handler);
221			Asc_SignalRecover(TRUE);
222
223			/* test Asc_SignalTrap() */
224
225			CU_TEST(0 == Asc_SignalHandlerPush(SIGFPE, Asc_SignalTrap));
226			CU_TEST(0 == Asc_SignalHandlerPush(SIGINT, Asc_SignalTrap));
227			CU_TEST(0 == Asc_SignalHandlerPush(SIGSEGV, Asc_SignalTrap));
228
229			signal1_caught = FALSE;
230			if (0 == setjmp(g_fpe_env)) { /* raise & catch a SIGFPE */
231			raise(SIGFPE);
232			}
233			else {
234			signal1_caught = TRUE;
235			CU_PASS("SIGFPE caught.");
236			}
237			CU_TEST(TRUE == signal1_caught);
238
239			signal1_caught = FALSE;
240			if (0 == setjmp(g_int_env)) { /* raise & catch a SIGINT */
241			raise(SIGINT);
242			}
243			else {
244			signal1_caught = TRUE;
245			CU_PASS("SIGINT caught.");
246			}
247			CU_TEST(TRUE == signal1_caught);
248
249			signal1_caught = FALSE;
250			if (0 == setjmp(g_seg_env)) { /* raise & catch a SIGSEGV */
251			raise(SIGSEGV);
252			}
253			else {
254			signal1_caught = TRUE;
255			CU_PASS("SIGSEGV caught.");
256			}
257			CU_TEST(TRUE == signal1_caught);
258
259	jds	61	Asc_SignalRecover(TRUE);
260
261	jds	59	CU_TEST(0 == Asc_SignalHandlerPop(SIGFPE, Asc_SignalTrap));
262			CU_TEST(0 == Asc_SignalHandlerPop(SIGINT, Asc_SignalTrap));
263			CU_TEST(0 == Asc_SignalHandlerPop(SIGSEGV, Asc_SignalTrap));
264
265			old_handler = signal(SIGFPE, SIG_DFL); /* handlers should be restored at this point */
266			CU_TEST(my_handler1 == old_handler);
267			old_handler = signal(SIGINT, SIG_DFL);
268			CU_TEST(NULL == old_handler);
269			old_handler = signal(SIGSEGV, SIG_DFL);
270			CU_TEST(my_handler2 == old_handler);
271			Asc_SignalRecover(TRUE);
272
273			/* test typical use with nesting of handlers */
274
275	jds	61	f_handler1_called = FALSE; /* initialize flags for detecting flow */
276			f_handler1_sigval = 0;
277			f_handler2_called = FALSE;
278			f_handler2_sigval = 0;
279	jds	59	signal1_caught = FALSE;
280			signal2_caught = FALSE;
281			signal3_caught = FALSE;
282
283			CU_TEST(0 == Asc_SignalHandlerPush(SIGFPE, my_handler1)); /* test for SIGFPE */
284			if (0 == setjmp(my_jmp_buf1)) {
285			CU_TEST(0 == Asc_SignalHandlerPush(SIGFPE, my_handler2));
286			if (0 == setjmp(my_jmp_buf2)) {
287			CU_TEST(0 == Asc_SignalHandlerPush(SIGFPE, Asc_SignalTrap));
288			if (0 == setjmp(g_fpe_env)) {
289			raise(SIGFPE);
290			}
291			else {
292	jds	61	CU_TEST(f_handler1_called == FALSE);
293			CU_TEST(f_handler1_sigval == 0);
294			CU_TEST(f_handler2_called == FALSE);
295			CU_TEST(f_handler2_sigval == 0);
296	jds	59	signal3_caught = TRUE;
297			}
298			CU_TEST(FALSE == signal1_caught);
299			CU_TEST(FALSE == signal2_caught);
300			CU_TEST(TRUE == signal3_caught);
301			CU_TEST(0 == Asc_SignalHandlerPop(SIGFPE, Asc_SignalTrap));
302	jds	61	f_handler1_called = FALSE;
303			f_handler1_sigval = 0;
304			f_handler2_called = FALSE;
305			f_handler2_sigval = 0;
306	jds	59	signal1_caught = FALSE;
307			signal2_caught = FALSE;
308			signal3_caught = FALSE;
309			raise(SIGFPE);
310			}
311			else {
312	jds	61	CU_TEST(f_handler1_called == FALSE);
313			CU_TEST(f_handler1_sigval == 0);
314			CU_TEST(f_handler2_called == TRUE);
315			CU_TEST(f_handler2_sigval == SIGFPE);
316	jds	59	signal2_caught = TRUE;
317			}
318			CU_TEST(FALSE == signal1_caught);
319			CU_TEST(TRUE == signal2_caught);
320			CU_TEST(FALSE == signal3_caught);
321			CU_TEST(0 == Asc_SignalHandlerPop(SIGFPE, my_handler2));
322	jds	61	f_handler1_called = FALSE;
323			f_handler1_sigval = 0;
324			f_handler2_called = FALSE;
325			f_handler2_sigval = 0;
326	jds	59	signal1_caught = FALSE;
327			signal2_caught = FALSE;
328			signal3_caught = FALSE;
329			raise(SIGFPE);
330			}
331			else {
332	jds	61	CU_TEST(f_handler1_called == TRUE);
333			CU_TEST(f_handler1_sigval == SIGFPE);
334			CU_TEST(f_handler2_called == FALSE);
335			CU_TEST(f_handler2_sigval == 0);
336	jds	59	signal1_caught = TRUE;
337			}
338			CU_TEST(TRUE == signal1_caught);
339			CU_TEST(FALSE == signal2_caught);
340			CU_TEST(FALSE == signal3_caught);
341			CU_TEST(0 == Asc_SignalHandlerPop(SIGFPE, my_handler1));
342
343	jds	61	f_handler1_called = FALSE; /* initialize flags for detecting flow */
344			f_handler1_sigval = 0;
345			f_handler2_called = FALSE;
346			f_handler2_sigval = 0;
347	jds	59	signal1_caught = FALSE;
348			signal2_caught = FALSE;
349			signal3_caught = FALSE;
350
351			CU_TEST(0 == Asc_SignalHandlerPush(SIGINT, my_handler2)); /* test for SIGINT */
352			if (0 == setjmp(my_jmp_buf2)) {
353			CU_TEST(0 == Asc_SignalHandlerPush(SIGINT, Asc_SignalTrap));
354			if (0 == setjmp(g_int_env)) {
355			CU_TEST(0 == Asc_SignalHandlerPush(SIGINT, my_handler1));
356			if (0 == setjmp(my_jmp_buf1)) {
357			raise(SIGINT);
358			}
359			else {
360	jds	61	CU_TEST(f_handler1_called == TRUE);
361			CU_TEST(f_handler1_sigval == SIGINT);
362			CU_TEST(f_handler2_called == FALSE);
363			CU_TEST(f_handler2_sigval == 0);
364	jds	59	signal3_caught = TRUE;
365			}
366			CU_TEST(FALSE == signal1_caught);
367			CU_TEST(FALSE == signal2_caught);
368			CU_TEST(TRUE == signal3_caught);
369			CU_TEST(0 == Asc_SignalHandlerPop(SIGINT, my_handler1));
370	jds	61	f_handler1_called = FALSE;
371			f_handler1_sigval = 0;
372			f_handler2_called = FALSE;
373			f_handler2_sigval = 0;
374	jds	59	signal1_caught = FALSE;
375			signal2_caught = FALSE;
376			signal3_caught = FALSE;
377			raise(SIGINT);
378			}
379			else {
380	jds	61	CU_TEST(f_handler1_called == FALSE);
381			CU_TEST(f_handler1_sigval == 0);
382			CU_TEST(f_handler2_called == FALSE);
383			CU_TEST(f_handler2_sigval == 0);
384	jds	59	signal2_caught = TRUE;
385			}
386			CU_TEST(FALSE == signal1_caught);
387			CU_TEST(TRUE == signal2_caught);
388			CU_TEST(FALSE == signal3_caught);
389			CU_TEST(0 == Asc_SignalHandlerPop(SIGINT, Asc_SignalTrap));
390	jds	61	f_handler1_called = FALSE;
391			f_handler1_sigval = 0;
392			f_handler2_called = FALSE;
393			f_handler2_sigval = 0;
394	jds	59	signal1_caught = FALSE;
395			signal2_caught = FALSE;
396			signal3_caught = FALSE;
397			raise(SIGINT);
398			}
399			else {
400	jds	61	CU_TEST(f_handler1_called == FALSE);
401			CU_TEST(f_handler1_sigval == 0);
402			CU_TEST(f_handler2_called == TRUE);
403			CU_TEST(f_handler2_sigval == SIGINT);
404	jds	59	signal1_caught = TRUE;
405			}
406			CU_TEST(TRUE == signal1_caught);
407			CU_TEST(FALSE == signal2_caught);
408			CU_TEST(FALSE == signal3_caught);
409			CU_TEST(0 == Asc_SignalHandlerPop(SIGINT, my_handler2));
410
411	jds	61	f_handler1_called = FALSE; /* initialize flags for detecting flow */
412			f_handler1_sigval = 0;
413			f_handler2_called = FALSE;
414			f_handler2_sigval = 0;
415	jds	59	signal1_caught = FALSE;
416			signal2_caught = FALSE;
417			signal3_caught = FALSE;
418
419			CU_TEST(0 == Asc_SignalHandlerPush(SIGSEGV, Asc_SignalTrap)); /* test for SIGSEGV */
420			if (0 == setjmp(g_seg_env)) {
421			CU_TEST(0 == Asc_SignalHandlerPush(SIGSEGV, my_handler2));
422			if (0 == setjmp(my_jmp_buf2)) {
423			CU_TEST(0 == Asc_SignalHandlerPush(SIGSEGV, my_handler1));
424			if (0 == setjmp(my_jmp_buf1)) {
425			raise(SIGSEGV);
426			}
427			else {
428	jds	61	CU_TEST(f_handler1_called == TRUE);
429			CU_TEST(f_handler1_sigval == SIGSEGV);
430			CU_TEST(f_handler2_called == FALSE);
431			CU_TEST(f_handler2_sigval == 0);
432	jds	59	signal3_caught = TRUE;
433			}
434			CU_TEST(FALSE == signal1_caught);
435			CU_TEST(FALSE == signal2_caught);
436			CU_TEST(TRUE == signal3_caught);
437			CU_TEST(0 == Asc_SignalHandlerPop(SIGSEGV, my_handler1));
438	jds	61	f_handler1_called = FALSE;
439			f_handler1_sigval = 0;
440			f_handler2_called = FALSE;
441			f_handler2_sigval = 0;
442	jds	59	signal1_caught = FALSE;
443			signal2_caught = FALSE;
444			signal3_caught = FALSE;
445			raise(SIGSEGV);
446			}
447			else {
448	jds	61	CU_TEST(f_handler1_called == FALSE);
449			CU_TEST(f_handler1_sigval == 0);
450			CU_TEST(f_handler2_called == TRUE);
451			CU_TEST(f_handler2_sigval == SIGSEGV);
452	jds	59	signal2_caught = TRUE;
453			}
454			CU_TEST(FALSE == signal1_caught);
455			CU_TEST(TRUE == signal2_caught);
456			CU_TEST(FALSE == signal3_caught);
457			CU_TEST(0 == Asc_SignalHandlerPop(SIGSEGV, my_handler2));
458	jds	61	f_handler1_called = FALSE;
459			f_handler1_sigval = 0;
460			f_handler2_called = FALSE;
461			f_handler2_sigval = 0;
462	jds	59	signal1_caught = FALSE;
463			signal2_caught = FALSE;
464			signal3_caught = FALSE;
465			raise(SIGSEGV);
466			}
467			else {
468	jds	61	CU_TEST(f_handler1_called == FALSE);
469			CU_TEST(f_handler1_sigval == 0);
470			CU_TEST(f_handler2_called == FALSE);
471			CU_TEST(f_handler2_sigval == 0);
472	jds	59	signal1_caught = TRUE;
473			}
474			CU_TEST(TRUE == signal1_caught);
475			CU_TEST(FALSE == signal2_caught);
476			CU_TEST(FALSE == signal3_caught);
477			CU_TEST(0 == Asc_SignalHandlerPop(SIGSEGV, Asc_SignalTrap));
478
479			old_handler = signal(SIGFPE, SIG_DFL); /* handlers should be restored at this point */
480			CU_TEST(my_handler1 == old_handler);
481			old_handler = signal(SIGINT, SIG_DFL);
482			CU_TEST(NULL == old_handler);
483			old_handler = signal(SIGSEGV, SIG_DFL);
484			CU_TEST(my_handler2 == old_handler);
485			Asc_SignalRecover(TRUE);
486
487			Asc_SignalDestroy();
488
489			old_handler = signal(SIGFPE, SIG_DFL); /* original handlers should still be in place */
490			CU_TEST(my_handler1 == old_handler);
491			old_handler = signal(SIGINT, SIG_DFL);
492			CU_TEST(NULL == old_handler);
493			old_handler = signal(SIGSEGV, SIG_DFL);
494			CU_TEST(my_handler2 == old_handler);
495			Asc_SignalRecover(TRUE);
496
497	jds	61	if (TRUE == i_initialized_lists) {
498			gl_destroy_pool();
499			}
500
501	jds	59	#endif /* NO_SIGNAL_TRAPS */
502
503			if (NULL != old_fpe_handler) /* restore any pre-existing handlers */
504			signal(SIGFPE, old_fpe_handler);
505			if (NULL != old_int_handler)
506			signal(SIGINT, old_int_handler);
507			if (NULL != old_seg_handler)
508			signal(SIGSEGV, old_seg_handler);
509
510			CU_TEST(prior_meminuse == ascmeminuse()); /* make sure we cleaned up after ourselves */
511			}
512
513			/===========================================================================/
514			/* Registration information */
515
516			static CU_TestInfo ascSignal_test_list[] = {
517			{"test_ascSignal", test_ascSignal},
518			CU_TEST_INFO_NULL
519			};
520
521			static CU_SuiteInfo suites[] = {
522			{"test_utilities_ascSignal", NULL, NULL, ascSignal_test_list},
523			CU_SUITE_INFO_NULL
524			};
525
526			/-------------------------------------------------------------------/
527			CU_ErrorCode test_register_utilities_ascSignal(void)
528			{
529			return CU_register_suites(suites);
530			}