nih/tests/test_signal.c - chromiumos/third_party/upstart - Git at Google

 /* libnih
  *
  * test_signal.c - test suite for nih/signal.c
  *
  * Copyright © 2009 Scott James Remnant <scott@netsplit.com>.
  * Copyright © 2009 Canonical Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2, as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the 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 this program; if not, write to the Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */

 #include <nih/test.h>

 #if HAVE_VALGRIND_VALGRIND_H
 #include <valgrind/valgrind.h>
 #endif /* HAVE_VALGRIND_VALGRIND_H */

 #include <signal.h>

 #include <nih/macros.h>
 #include <nih/list.h>
 #include <nih/signal.h>


 static void
 my_sig_handler (int signum) {
 }

 void
 test_set_handler (void)
 {
 	struct sigaction act;
 	int              ret, i;

 	TEST_FUNCTION ("nih_signal_set_handler");

 	/* Check that we can install a signal handler, and that the action
 	 * for that signal points to our handler, has the right flags and
 	 * an empty signal mask.
 	 */
 	TEST_FEATURE ("with valid signal");
 	ret = nih_signal_set_handler (SIGUSR1, my_sig_handler);

 	TEST_EQ (ret, 0);

 	sigaction (SIGUSR1, NULL, &act);
 	TEST_EQ_P (act.sa_handler, my_sig_handler);
 	TEST_TRUE (act.sa_flags & SA_RESTART);
 	TEST_FALSE (act.sa_flags & SA_RESETHAND);

 	for (i = 1; i < 32; i++)
 		TEST_FALSE (sigismember (&act.sa_mask, i));


 #if HAVE_VALGRIND_VALGRIND_H
 	/* This test fails when running under valgrind; because for no
 	 * readily apparent reason, that lets us catch SIGKILL!
 	 */
 	if (! RUNNING_ON_VALGRIND) {
 #endif
 	/* Check that attempting to set a handler for SIGKILL results in
 	 * -1 being returned.
 	 */
 	TEST_FEATURE ("with invalid signal");
 	ret = nih_signal_set_handler (SIGKILL, my_sig_handler);

 	TEST_LT (ret, 0);
 #if HAVE_VALGRIND_VALGRIND_H
 	}
 #endif
 }

 void
 test_set_default (void)
 {
 	struct sigaction act;
 	int              ret, i;

 	TEST_FUNCTION ("nih_signal_set_default");

 	/* Check that we can reset a signal to the default handling, which
 	 * should update the action properly.
 	 */
 	TEST_FEATURE ("with valid signal");
 	ret = nih_signal_set_default (SIGUSR1);

 	TEST_EQ (ret, 0);

 	sigaction (SIGUSR1, NULL, &act);
 	TEST_EQ_P (act.sa_handler, SIG_DFL);
 	TEST_FALSE (act.sa_flags & SA_RESTART);
 	TEST_FALSE (act.sa_flags & SA_NOCLDSTOP);

 	for (i = 1; i < 32; i++)
 		TEST_FALSE (sigismember (&act.sa_mask, i));


 #if HAVE_VALGRIND_VALGRIND_H
 	/* This test fails when running under valgrind; because for no
 	 * readily apparent reason, that lets us catch SIGKILL!
 	 */
 	if (! RUNNING_ON_VALGRIND) {
 #endif
 	/* Check that attempting to set a handler for SIGKILL results in
 	 * -1 being returned.
 	 */
 	TEST_FEATURE ("with invalid signal");
 	ret = nih_signal_set_default (SIGKILL);

 	TEST_LT (ret, 0);
 #if HAVE_VALGRIND_VALGRIND_H
 	}
 #endif
 }

 void
 test_set_ignore (void)
 {
 	struct sigaction act;
 	int              ret, i;

 	TEST_FUNCTION ("nih_signal_set_ignore");

 	/* Check that we can set a signal to be ignored, which should update
 	 * the action properly.
 	 */
 	TEST_FEATURE ("with valid signal");
 	ret = nih_signal_set_ignore (SIGUSR1);

 	TEST_EQ (ret, 0);

 	sigaction (SIGUSR1, NULL, &act);
 	TEST_EQ_P (act.sa_handler, SIG_IGN);
 	TEST_FALSE (act.sa_flags & SA_RESTART);
 	TEST_FALSE (act.sa_flags & SA_NOCLDSTOP);

 	for (i = 1; i < 32; i++)
 		TEST_FALSE (sigismember (&act.sa_mask, i));


 #if HAVE_VALGRIND_VALGRIND_H
 	/* This test fails when running under valgrind; because for no
 	 * readily apparent reason, that lets us ignore SIGKILL!
 	 */
 	if (! RUNNING_ON_VALGRIND) {
 #endif
 	/* Check that attempting to set a handler for SIGKILL results in
 	 * -1 being returned.
 	 */
 	TEST_FEATURE ("with invalid signal");
 	ret = nih_signal_set_ignore (SIGKILL);

 	TEST_LT (ret, 0);
 #if HAVE_VALGRIND_VALGRIND_H
 	}
 #endif
 }

 void
 test_reset (void)
 {
 	struct sigaction act;
 	int              i;

 	/* Check that we can reset all signals back to their defaults. */
 	TEST_FUNCTION ("nih_signal_reset");
 	nih_signal_set_ignore (SIGTERM);
 	nih_signal_reset ();

 	sigaction (SIGTERM, NULL, &act);
 	TEST_EQ_P (act.sa_handler, SIG_DFL);
 	TEST_FALSE (act.sa_flags & SA_RESTART);
 	TEST_FALSE (act.sa_flags & SA_NOCLDSTOP);

 	for (i = 1; i < 32; i++)
 		TEST_FALSE (sigismember (&act.sa_mask, i));
 }


 static int handler_called = 0;
 static void *last_data;
 static NihSignal *last_signal;

 static void
 my_handler (void *data, NihSignal *signal)
 {
 	handler_called++;
 	last_data = data;
 	last_signal = signal;
 }

 void
 test_add_handler (void)
 {
 	NihSignal *signal;

 	/* Check that we can add a signal handling callback function, and
 	 * that the structure returned is properly populated and placed in
 	 * the callbacks list.
 	 */
 	TEST_FUNCTION ("nih_signal_add_handler");
 	nih_signal_poll ();
 	TEST_ALLOC_FAIL {
 		signal = nih_signal_add_handler (NULL, SIGUSR1,
 						 my_handler, &signal);

 		if (test_alloc_failed) {
 			TEST_EQ_P (signal, NULL);
 			continue;
 		}

 		TEST_ALLOC_SIZE (signal, sizeof (NihSignal));
 		TEST_LIST_NOT_EMPTY (&signal->entry);
 		TEST_EQ (signal->signum, SIGUSR1);
 		TEST_EQ_P (signal->handler, my_handler);
 		TEST_EQ_P (signal->data, &signal);

 		nih_free (signal);
 	}
 }

 void
 test_poll (void)
 {
 	NihSignal *signal1, *signal2;

 	TEST_FUNCTION ("nih_signal_poll");
 	signal1 = nih_signal_add_handler (NULL, SIGUSR1, my_handler, &signal1);
 	signal2 = nih_signal_add_handler (NULL, SIGUSR2, my_handler, &signal2);

 	/* Check that we can poll for a signal being caught, which should
 	 * result in only the callback for that signal being run.
 	 */
 	TEST_FEATURE ("with one signal");
 	handler_called = 0;
 	last_data = NULL;
 	last_signal = NULL;

 	nih_signal_handler (SIGUSR1);
 	nih_signal_poll ();

 	TEST_EQ (handler_called, 1);
 	TEST_EQ_P (last_signal, signal1);
 	TEST_EQ_P (last_data, &signal1);


 	/* Check that we can poll for only the other signal. */
 	TEST_FEATURE ("with different signal");
 	handler_called = 0;
 	last_data = NULL;
 	last_signal = NULL;

 	nih_signal_handler (SIGUSR2);
 	nih_signal_poll ();

 	TEST_EQ (handler_called, 1);
 	TEST_EQ_P (last_signal, signal2);
 	TEST_EQ_P (last_data, &signal2);


 	/* Check that we can poll for both signals. */
 	TEST_FEATURE ("with multiple signals");
 	handler_called = 0;

 	nih_signal_handler (SIGUSR1);
 	nih_signal_handler (SIGUSR2);
 	nih_signal_poll ();

 	TEST_EQ (handler_called, 2);


 	/* Check what happens if a signal we have no callbacks for is
 	 * caught.  This should run neither callback.
 	 */
 	TEST_FEATURE ("with unknown signal");
 	handler_called = 0;

 	nih_signal_handler (SIGINT);
 	nih_signal_poll ();

 	TEST_EQ (handler_called, 0);
 }


 void
 test_to_name (void)
 {
 	const char *name;

 	TEST_FUNCTION ("nih_signal_to_name");

 	/* Check that we can obtain the name of a common signal. */
 	TEST_FEATURE ("with SIGTERM");
 	name = nih_signal_to_name (SIGTERM);

 	TEST_EQ_STR (name, "TERM");


 	/* Check that we get CHLD for SIGCHLD */
 	TEST_FEATURE ("with SIGCHLD");
 	name = nih_signal_to_name (SIGCHLD);

 	TEST_EQ_STR (name, "CHLD");


 	/* Check that we get IO for SIGIO */
 	TEST_FEATURE ("with SIGIO");
 	name = nih_signal_to_name (SIGIO);

 	TEST_EQ_STR (name, "IO");


 	/* Check that we get NULL for an unknown signal */
 	TEST_FEATURE ("with unknown signal");
 	name = nih_signal_to_name (32);

 	TEST_EQ_P (name, NULL);
 }

 void
 test_from_name (void)
 {
 	int signum;

 	TEST_FUNCTION ("nih_signal_from_name");

 	/* Check that we can convert a common signal into its number. */
 	TEST_FEATURE ("with SIGTERM");
 	signum = nih_signal_from_name ("SIGTERM");

 	TEST_EQ (signum, SIGTERM);


 	/* Check that we can omit the SIG from the front. */
 	TEST_FEATURE ("with TERM");
 	signum = nih_signal_from_name ("TERM");

 	TEST_EQ (signum, SIGTERM);


 	/* Check that we get SIGCHLD for SIGCHLD */
 	TEST_FEATURE ("with SIGCHLD");
 	signum = nih_signal_from_name ("SIGCHLD");

 	TEST_EQ (signum, SIGCHLD);


 	/* Check that we get SIGIO for SIGIO */
 	TEST_FEATURE ("with SIGIO");
 	signum = nih_signal_from_name ("SIGIO");

 	TEST_EQ (signum, SIGIO);


 	/* Check that we get a negative number for an unknown signal */
 	TEST_FEATURE ("with unknown signal");
 	signum = nih_signal_from_name ("SIGSNARF");

 	TEST_LT (signum, 0);
 }


 int
 main (int   argc,
       char *argv[])
 {
 	test_set_handler ();
 	test_set_default ();
 	test_set_ignore ();
 	test_reset ();
 	test_add_handler ();
 	test_poll ();
 	test_to_name ();
 	test_from_name ();

 	return 0;
 }
	/* libnih
	*
	* test_signal.c - test suite for nih/signal.c
	*
	* Copyright © 2009 Scott James Remnant <scott@netsplit.com>.
	* Copyright © 2009 Canonical Ltd.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2, as
	* published by the Free Software Foundation.
	*
	* This program is distributed in the 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 this program; if not, write to the Free Software Foundation, Inc.,
	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	*/

	#include <nih/test.h>

	#if HAVE_VALGRIND_VALGRIND_H
	#include <valgrind/valgrind.h>
	#endif /* HAVE_VALGRIND_VALGRIND_H */

	#include <signal.h>

	#include <nih/macros.h>
	#include <nih/list.h>
	#include <nih/signal.h>


	static void
	my_sig_handler (int signum) {
	}

	void
	test_set_handler (void)
	{
	struct sigaction act;
	int ret, i;

	TEST_FUNCTION ("nih_signal_set_handler");

	/* Check that we can install a signal handler, and that the action
	* for that signal points to our handler, has the right flags and
	* an empty signal mask.
	*/
	TEST_FEATURE ("with valid signal");
	ret = nih_signal_set_handler (SIGUSR1, my_sig_handler);

	TEST_EQ (ret, 0);

	sigaction (SIGUSR1, NULL, &act);
	TEST_EQ_P (act.sa_handler, my_sig_handler);
	TEST_TRUE (act.sa_flags & SA_RESTART);
	TEST_FALSE (act.sa_flags & SA_RESETHAND);

	for (i = 1; i < 32; i++)
	TEST_FALSE (sigismember (&act.sa_mask, i));


	#if HAVE_VALGRIND_VALGRIND_H
	/* This test fails when running under valgrind; because for no
	* readily apparent reason, that lets us catch SIGKILL!
	*/
	if (! RUNNING_ON_VALGRIND) {
	#endif
	/* Check that attempting to set a handler for SIGKILL results in
	* -1 being returned.
	*/
	TEST_FEATURE ("with invalid signal");
	ret = nih_signal_set_handler (SIGKILL, my_sig_handler);

	TEST_LT (ret, 0);
	#if HAVE_VALGRIND_VALGRIND_H
	}
	#endif
	}

	void
	test_set_default (void)
	{
	struct sigaction act;
	int ret, i;

	TEST_FUNCTION ("nih_signal_set_default");

	/* Check that we can reset a signal to the default handling, which
	* should update the action properly.
	*/
	TEST_FEATURE ("with valid signal");
	ret = nih_signal_set_default (SIGUSR1);

	TEST_EQ (ret, 0);

	sigaction (SIGUSR1, NULL, &act);
	TEST_EQ_P (act.sa_handler, SIG_DFL);
	TEST_FALSE (act.sa_flags & SA_RESTART);
	TEST_FALSE (act.sa_flags & SA_NOCLDSTOP);

	for (i = 1; i < 32; i++)
	TEST_FALSE (sigismember (&act.sa_mask, i));


	#if HAVE_VALGRIND_VALGRIND_H
	/* This test fails when running under valgrind; because for no
	* readily apparent reason, that lets us catch SIGKILL!
	*/
	if (! RUNNING_ON_VALGRIND) {
	#endif
	/* Check that attempting to set a handler for SIGKILL results in
	* -1 being returned.
	*/
	TEST_FEATURE ("with invalid signal");
	ret = nih_signal_set_default (SIGKILL);

	TEST_LT (ret, 0);
	#if HAVE_VALGRIND_VALGRIND_H
	}
	#endif
	}

	void
	test_set_ignore (void)
	{
	struct sigaction act;
	int ret, i;

	TEST_FUNCTION ("nih_signal_set_ignore");

	/* Check that we can set a signal to be ignored, which should update
	* the action properly.
	*/
	TEST_FEATURE ("with valid signal");
	ret = nih_signal_set_ignore (SIGUSR1);

	TEST_EQ (ret, 0);

	sigaction (SIGUSR1, NULL, &act);
	TEST_EQ_P (act.sa_handler, SIG_IGN);
	TEST_FALSE (act.sa_flags & SA_RESTART);
	TEST_FALSE (act.sa_flags & SA_NOCLDSTOP);

	for (i = 1; i < 32; i++)
	TEST_FALSE (sigismember (&act.sa_mask, i));


	#if HAVE_VALGRIND_VALGRIND_H
	/* This test fails when running under valgrind; because for no
	* readily apparent reason, that lets us ignore SIGKILL!
	*/
	if (! RUNNING_ON_VALGRIND) {
	#endif
	/* Check that attempting to set a handler for SIGKILL results in
	* -1 being returned.
	*/
	TEST_FEATURE ("with invalid signal");
	ret = nih_signal_set_ignore (SIGKILL);

	TEST_LT (ret, 0);
	#if HAVE_VALGRIND_VALGRIND_H
	}
	#endif
	}

	void
	test_reset (void)
	{
	struct sigaction act;
	int i;

	/* Check that we can reset all signals back to their defaults. */
	TEST_FUNCTION ("nih_signal_reset");
	nih_signal_set_ignore (SIGTERM);
	nih_signal_reset ();

	sigaction (SIGTERM, NULL, &act);
	TEST_EQ_P (act.sa_handler, SIG_DFL);
	TEST_FALSE (act.sa_flags & SA_RESTART);
	TEST_FALSE (act.sa_flags & SA_NOCLDSTOP);

	for (i = 1; i < 32; i++)
	TEST_FALSE (sigismember (&act.sa_mask, i));
	}


	static int handler_called = 0;
	static void *last_data;
	static NihSignal *last_signal;

	static void
	my_handler (void data, NihSignal signal)
	{
	handler_called++;
	last_data = data;
	last_signal = signal;
	}

	void
	test_add_handler (void)
	{
	NihSignal *signal;

	/* Check that we can add a signal handling callback function, and
	* that the structure returned is properly populated and placed in
	* the callbacks list.
	*/
	TEST_FUNCTION ("nih_signal_add_handler");
	nih_signal_poll ();
	TEST_ALLOC_FAIL {
	signal = nih_signal_add_handler (NULL, SIGUSR1,
	my_handler, &signal);

	if (test_alloc_failed) {
	TEST_EQ_P (signal, NULL);
	continue;
	}

	TEST_ALLOC_SIZE (signal, sizeof (NihSignal));
	TEST_LIST_NOT_EMPTY (&signal->entry);
	TEST_EQ (signal->signum, SIGUSR1);
	TEST_EQ_P (signal->handler, my_handler);
	TEST_EQ_P (signal->data, &signal);

	nih_free (signal);
	}
	}

	void
	test_poll (void)
	{
	NihSignal signal1, signal2;

	TEST_FUNCTION ("nih_signal_poll");
	signal1 = nih_signal_add_handler (NULL, SIGUSR1, my_handler, &signal1);
	signal2 = nih_signal_add_handler (NULL, SIGUSR2, my_handler, &signal2);

	/* Check that we can poll for a signal being caught, which should
	* result in only the callback for that signal being run.
	*/
	TEST_FEATURE ("with one signal");
	handler_called = 0;
	last_data = NULL;
	last_signal = NULL;

	nih_signal_handler (SIGUSR1);
	nih_signal_poll ();

	TEST_EQ (handler_called, 1);
	TEST_EQ_P (last_signal, signal1);
	TEST_EQ_P (last_data, &signal1);


	/* Check that we can poll for only the other signal. */
	TEST_FEATURE ("with different signal");
	handler_called = 0;
	last_data = NULL;
	last_signal = NULL;

	nih_signal_handler (SIGUSR2);
	nih_signal_poll ();

	TEST_EQ (handler_called, 1);
	TEST_EQ_P (last_signal, signal2);
	TEST_EQ_P (last_data, &signal2);


	/* Check that we can poll for both signals. */
	TEST_FEATURE ("with multiple signals");
	handler_called = 0;

	nih_signal_handler (SIGUSR1);
	nih_signal_handler (SIGUSR2);
	nih_signal_poll ();

	TEST_EQ (handler_called, 2);


	/* Check what happens if a signal we have no callbacks for is
	* caught. This should run neither callback.
	*/
	TEST_FEATURE ("with unknown signal");
	handler_called = 0;

	nih_signal_handler (SIGINT);
	nih_signal_poll ();

	TEST_EQ (handler_called, 0);
	}


	void
	test_to_name (void)
	{
	const char *name;

	TEST_FUNCTION ("nih_signal_to_name");

	/* Check that we can obtain the name of a common signal. */
	TEST_FEATURE ("with SIGTERM");
	name = nih_signal_to_name (SIGTERM);

	TEST_EQ_STR (name, "TERM");


	/* Check that we get CHLD for SIGCHLD */
	TEST_FEATURE ("with SIGCHLD");
	name = nih_signal_to_name (SIGCHLD);

	TEST_EQ_STR (name, "CHLD");


	/* Check that we get IO for SIGIO */
	TEST_FEATURE ("with SIGIO");
	name = nih_signal_to_name (SIGIO);

	TEST_EQ_STR (name, "IO");


	/* Check that we get NULL for an unknown signal */
	TEST_FEATURE ("with unknown signal");
	name = nih_signal_to_name (32);

	TEST_EQ_P (name, NULL);
	}

	void
	test_from_name (void)
	{
	int signum;

	TEST_FUNCTION ("nih_signal_from_name");

	/* Check that we can convert a common signal into its number. */
	TEST_FEATURE ("with SIGTERM");
	signum = nih_signal_from_name ("SIGTERM");

	TEST_EQ (signum, SIGTERM);


	/* Check that we can omit the SIG from the front. */
	TEST_FEATURE ("with TERM");
	signum = nih_signal_from_name ("TERM");

	TEST_EQ (signum, SIGTERM);


	/* Check that we get SIGCHLD for SIGCHLD */
	TEST_FEATURE ("with SIGCHLD");
	signum = nih_signal_from_name ("SIGCHLD");

	TEST_EQ (signum, SIGCHLD);


	/* Check that we get SIGIO for SIGIO */
	TEST_FEATURE ("with SIGIO");
	signum = nih_signal_from_name ("SIGIO");

	TEST_EQ (signum, SIGIO);


	/* Check that we get a negative number for an unknown signal */
	TEST_FEATURE ("with unknown signal");
	signum = nih_signal_from_name ("SIGSNARF");

	TEST_LT (signum, 0);
	}


	int
	main (int argc,
	char *argv[])
	{
	test_set_handler ();
	test_set_default ();
	test_set_ignore ();
	test_reset ();
	test_add_handler ();
	test_poll ();
	test_to_name ();
	test_from_name ();

	return 0;
	}