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>
#include <io.h>
#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 handler1_called;
static int handler1_sigval;
/*
 *  Signal handler for unit tests.
 *  Resets the signal handlers and sets handler1_called to
 *  TRUE and 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)
{
  handler1_called = TRUE;
  Asc_SignalRecover(FALSE);
  switch (sigval)
  {
    case SIGFPE:
      handler1_sigval = SIGFPE;
      FPRESET;
      break;
    case SIGINT:
      handler1_sigval = SIGINT;
      break;
    case SIGSEGV:
      handler1_sigval = SIGSEGV;
      break;
    default:
      handler1_sigval = -1;
      break;
  }
  longjmp(my_jmp_buf1, sigval);
}

static jmp_buf my_jmp_buf2;

static int handler2_called;
static int handler2_sigval;
/*
 *  Signal handler for unit tests.
 *  Resets the signal handlers and sets handler1_called to
 *  TRUE and 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)
{
  handler2_called = TRUE;
  Asc_SignalRecover(FALSE);
  switch (sigval)
  {
    case SIGFPE:
      handler2_sigval = SIGFPE;
      FPRESET;
      break;
    case SIGINT:
      handler2_sigval = SIGINT;
      break;
    case SIGSEGV:
      handler2_sigval = SIGSEGV;
      break;
    default:
      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);

  /* set up pooling & recycling */
  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);

  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 */

  handler1_called = FALSE;                              /* initialize flags for detecting flow */
  handler1_sigval = 0;
  handler2_called = FALSE;
  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(handler1_called == FALSE);
        CU_TEST(handler1_sigval == 0);
        CU_TEST(handler2_called == FALSE);
        CU_TEST(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));
      handler1_called = FALSE;
      handler1_sigval = 0;
      handler2_called = FALSE;
      handler2_sigval = 0;
      signal1_caught = FALSE;
      signal2_caught = FALSE;
      signal3_caught = FALSE;
      raise(SIGFPE);
    }
    else {
      CU_TEST(handler1_called == FALSE);
      CU_TEST(handler1_sigval == 0);
      CU_TEST(handler2_called == TRUE);
      CU_TEST(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));
    handler1_called = FALSE;
    handler1_sigval = 0;
    handler2_called = FALSE;
    handler2_sigval = 0;
    signal1_caught = FALSE;
    signal2_caught = FALSE;
    signal3_caught = FALSE;
    raise(SIGFPE);
  }
  else {
    CU_TEST(handler1_called == TRUE);
    CU_TEST(handler1_sigval == SIGFPE);
    CU_TEST(handler2_called == FALSE);
    CU_TEST(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));

  handler1_called = FALSE;                              /* initialize flags for detecting flow */
  handler1_sigval = 0;
  handler2_called = FALSE;
  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(handler1_called == TRUE);
        CU_TEST(handler1_sigval == SIGINT);
        CU_TEST(handler2_called == FALSE);
        CU_TEST(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));
      handler1_called = FALSE;
      handler1_sigval = 0;
      handler2_called = FALSE;
      handler2_sigval = 0;
      signal1_caught = FALSE;
      signal2_caught = FALSE;
      signal3_caught = FALSE;
      raise(SIGINT);
    }
    else {
      CU_TEST(handler1_called == FALSE);
      CU_TEST(handler1_sigval == 0);
      CU_TEST(handler2_called == FALSE);
      CU_TEST(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));
    handler1_called = FALSE;
    handler1_sigval = 0;
    handler2_called = FALSE;
    handler2_sigval = 0;
    signal1_caught = FALSE;
    signal2_caught = FALSE;
    signal3_caught = FALSE;
    raise(SIGINT);
  }
  else {
    CU_TEST(handler1_called == FALSE);
    CU_TEST(handler1_sigval == 0);
    CU_TEST(handler2_called == TRUE);
    CU_TEST(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));

  handler1_called = FALSE;                              /* initialize flags for detecting flow */
  handler1_sigval = 0;
  handler2_called = FALSE;
  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(handler1_called == TRUE);
        CU_TEST(handler1_sigval == SIGSEGV);
        CU_TEST(handler2_called == FALSE);
        CU_TEST(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));
      handler1_called = FALSE;
      handler1_sigval = 0;
      handler2_called = FALSE;
      handler2_sigval = 0;
      signal1_caught = FALSE;
      signal2_caught = FALSE;
      signal3_caught = FALSE;
      raise(SIGSEGV);
    }
    else {
      CU_TEST(handler1_called == FALSE);
      CU_TEST(handler1_sigval == 0);
      CU_TEST(handler2_called == TRUE);
      CU_TEST(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));
    handler1_called = FALSE;
    handler1_sigval = 0;
    handler2_called = FALSE;
    handler2_sigval = 0;
    signal1_caught = FALSE;
    signal2_caught = FALSE;
    signal3_caught = FALSE;
    raise(SIGSEGV);
  }
  else {
    CU_TEST(handler1_called == FALSE);
    CU_TEST(handler1_sigval == 0);
    CU_TEST(handler2_called == FALSE);
    CU_TEST(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);

#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);

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