--- /dev/null
+//==========================================================================
+//
+// tassert3.cxx
+//
+// Assertion test case
+//
+//==========================================================================
+//####COPYRIGHTBEGIN####
+//
+// ----------------------------------------------------------------------------
+// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
+//
+// This file is part of the eCos host tools.
+//
+// This program 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.
+//
+// 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.,
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// ----------------------------------------------------------------------------
+//
+//####COPYRIGHTEND####
+//==========================================================================
+//#####DESCRIPTIONBEGIN####
+//
+// Author(s): bartv
+// Contributors: bartv
+// Date: 1998-12-21
+// Purpose:
+// Description: Check the host extensions.
+//
+//####DESCRIPTIONEND####
+//==========================================================================
+
+// -------------------------------------------------------------------------
+// The host-side assertion support has three extensions to the generic
+// assertion support:
+//
+// 1) cyg_assert_install_failure_handler()
+// Provide an alternative handler that gets invoked when an
+// assertion fails.
+//
+// 2) cyg_assert_install_failure_callback()
+// Provide an additional callback that should get invoked when an
+// assertion triggers to provide additional information.
+//
+// 3) cyg_assert_failure_invoke_callbacks()
+// Used by (1) to call the functions installed via (2).
+//
+// The tests make use of setjmp()/longjmp() buffer to avoid having to
+// do lots of output parsing in the DejaGnu driver.
+
+#define CYG_DECLARE_HOST_ASSERTION_SUPPORT
+#define CYGDBG_USE_ASSERTS
+#define CYGDBG_INFRA_DEBUG_PRECONDITIONS
+#define CYGDBG_INFRA_DEBUG_POSTCONDITIONS
+#define CYGDBG_INFRA_DEBUG_LOOP_INVARIANTS
+#define CYGDBG_INFRA_DEBUG_INVARIANTS
+
+#include <cyg/infra/testcase.h>
+#include <cyg/infra/cyg_ass.h>
+#include <cstdlib>
+#include <csetjmp>
+#include <cstring>
+
+// Forward declarations of some integers to allow the line number to be
+// checked.
+extern cyg_uint32 main_start, main_end;
+
+// This is used to "recover" from an assertion failure
+static jmp_buf setjmp_buffer;
+
+// A constant string useful for comparisons.
+static const char message[] = "fail";
+
+// Some state information to make sure that the world is in the expected
+// state
+bool expecting_failure1 = false;
+bool expecting_failure2 = false;
+bool expecting_failure3 = false;
+
+// -------------------------------------------------------------------------
+// The first assertion handler. This is used to check that the arguments
+// make sense.
+
+extern "C"
+bool
+failure_handler1(const char* fn, const char* file, cyg_uint32 line, const char* msg)
+{
+ if (!expecting_failure1) {
+ CYG_TEST_FAIL("assertion failure handler1 invoked unexpectedly");
+ }
+ expecting_failure1 = false;
+ // The function should be 0 or contain main
+ if (0 != fn) {
+ if (0 == strstr(fn, "main")) {
+ CYG_TEST_FAIL("invalid function name passed to assertion failure handler");
+ }
+ }
+ // The file name should always be valid and contain tassert3.cxx.
+ // It may contain path information as well.
+ if ( (0 == file) || (0 == strstr(file, "tassert3.cxx"))) {
+ CYG_TEST_FAIL("invalid file name passed to assertion failure handler");
+ }
+ // The line number can be validated against some globals.
+ if ((line <= main_start) || (line >= main_end)) {
+ CYG_TEST_FAIL("invalid line number passed to assertion failure handler");
+ }
+ // The message passed is known.
+ if (0 != strcmp(msg, message)) {
+ CYG_TEST_FAIL("invalid message passed to assertion failure handler");
+ }
+ CYG_TEST_PASS("application-specific assertion failure handler");
+
+ // Everything OK, back to main()
+ longjmp(setjmp_buffer, 1);
+ CYG_TEST_FAIL_FINISH("longjmp() is not functional");
+ return false;
+}
+
+// -------------------------------------------------------------------------
+// A second assertion handler. This is used to make sure that assertion
+// failure handlers can be overwritten.
+
+extern "C"
+bool
+failure_handler2(const char* fn, const char* file, cyg_uint32 line, const char* msg)
+{
+ if (!expecting_failure2) {
+ CYG_TEST_FAIL("assertion failure handler2 invoked incorrectly");
+ }
+ expecting_failure2 = false;
+ CYG_TEST_PASS("assertion failure handlers can be replaced");
+ longjmp(setjmp_buffer, 1);
+ CYG_TEST_FAIL_FINISH("longjmp() is not functional");
+ return false;
+}
+// -------------------------------------------------------------------------
+// The third assertion handler. This time a couple of output callbacks are
+// installed and the main failure handler has to invoke the output callbacks.
+// A number of statics are used to make sure everything works ok.
+
+static const char callback1_title[] = "callback1_header";
+static const char callback2_title[] = "callback2_header";
+static const char callback2_data[] = "callback2 data\n";
+static bool seen_callback1_title = false;
+static bool seen_callback2_title = false;
+static bool callback1_done = false;
+static bool callback2_done = false;
+static int number_of_headers = 0;
+static bool callback1_invoked = false;
+static bool callback2_invoked = false;
+static int number_of_lines_seen = 0;
+const int callback2_lines = 16;
+static int callback2_lines_seen = 0;
+static int number_of_trailers = 0;
+
+extern "C"
+void
+callback1(void (*outputfn)(const char*))
+{
+ if (callback1_invoked) {
+ CYG_TEST_FAIL("callback1 invoked multiple times");
+ }
+ callback1_invoked = true;
+
+ // This callback does nothing.
+}
+
+extern "C"
+void
+callback2(void (*outputfn)(const char*))
+{
+ if (callback2_invoked) {
+ CYG_TEST_FAIL("callback2 invoked multiple times");
+ }
+ callback2_invoked = true;
+ for (int i = 0; i < callback2_lines; i++) {
+ (*outputfn)(callback2_data);
+ }
+}
+
+// handle_callback_header() should be invoked at least twice,
+// once with callback1_header and once with callback2_header
+extern "C"
+void
+handle_callback_header(const char* name)
+{
+ number_of_headers++;
+ if (0 == strcmp(name, callback1_title)) {
+ if (seen_callback1_title) {
+ CYG_TEST_FAIL("callback1 title seen multiple times");
+ } else {
+ seen_callback1_title = true;
+ }
+ }
+ if (0 == strcmp(name, callback2_title)) {
+ if (seen_callback2_title) {
+ CYG_TEST_FAIL("callback2 title seen multiple times");
+ } else {
+ seen_callback2_title = true;
+ }
+ }
+}
+
+// The body output function should be invoked zero times for
+// callback1 and a fixed number of times for callback2.
+extern "C"
+void
+handle_callback_body(const char* data)
+{
+ number_of_lines_seen++;
+
+ if (seen_callback1_title && !callback1_done) {
+ CYG_TEST_FAIL("callback1 should not perform any output");
+ }
+ if (seen_callback2_title && !callback2_done) {
+ callback2_lines_seen++;
+ if (0 != strcmp(data, callback2_data)) {
+ CYG_TEST_FAIL("callback2 has generated incorrect data");
+ }
+ }
+}
+
+// The trailer output function should be invoked at least twice, once
+// for each callback.
+extern "C"
+void
+handle_callback_trailer(void)
+{
+ if (0 == number_of_headers) {
+ CYG_TEST_FAIL("callback trailer seen before header");
+ }
+ number_of_trailers++;
+ if (seen_callback1_title && !callback1_done) {
+ callback1_done = true;
+ }
+ if (seen_callback2_title && !callback2_done) {
+ callback2_done = true;
+ }
+}
+
+// This is the failure handler. It causes the various callbacks to run, then
+// checks the resulting values of the statics.
+extern "C"
+bool
+failure_handler3(const char* fn, const char* file, cyg_uint32 line, const char* msg)
+{
+ if (!expecting_failure3) {
+ CYG_TEST_FAIL("assertion failure handler3 invoked incorrectly");
+ }
+ expecting_failure3 = false;
+
+ cyg_assert_failure_invoke_callbacks(
+ &handle_callback_header,
+ &handle_callback_body,
+ &handle_callback_trailer);
+
+ bool all_ok = true;
+ if (!seen_callback1_title) {
+ CYG_TEST_FAIL("callback1's title not seen");
+ all_ok = false;
+ }
+ if (!seen_callback2_title) {
+ CYG_TEST_FAIL("callback2's title not seen");
+ all_ok = false;
+ }
+ if (number_of_headers != number_of_trailers) {
+ CYG_TEST_FAIL("headers and trailers do not match up");
+ all_ok = false;
+ }
+ if (!callback1_done) {
+ CYG_TEST_FAIL("callback1 did not finish");
+ all_ok = false;
+ }
+ if (!callback2_done) {
+ CYG_TEST_FAIL("callback2 did not finish");
+ all_ok = false;
+ }
+ if (number_of_lines_seen < callback2_lines) {
+ CYG_TEST_FAIL("total number of output lines is less than expected");
+ all_ok = false;
+ }
+ if (callback2_lines_seen != callback2_lines) {
+ CYG_TEST_FAIL("callback2 generated the wrong number of lines");
+ all_ok = false;
+ }
+
+ if (all_ok) {
+ CYG_TEST_PASS("assertion callbacks");
+ }
+
+ longjmp(setjmp_buffer, 1);
+ CYG_TEST_FAIL_FINISH("longjmp() is not functional");
+ return false;
+}
+
+// ----------------------------------------------------------------------------
+// main(). Perform the various assertion tests in order.
+
+cyg_uint32 main_start = (cyg_uint32) __LINE__;
+int
+main(int argc, char** argv)
+{
+ expecting_failure1 = true;
+ // First check, a very basic assertion invocation.
+ if (setjmp(setjmp_buffer) == 0) {
+ cyg_assert_install_failure_handler(&failure_handler1);
+ CYG_FAIL(message);
+ CYG_TEST_FAIL("assertion did not trigger");
+ }
+ expecting_failure1 = false;
+ expecting_failure2 = true;
+
+ // Now try installing a different assertion handler.
+ if (setjmp(setjmp_buffer) == 0) {
+ cyg_assert_install_failure_handler(&failure_handler2);
+ CYG_FAIL(message);
+ CYG_TEST_FAIL("assertion did not trigger");
+ }
+ expecting_failure2 = false;
+ expecting_failure3 = true;
+
+ if (setjmp(setjmp_buffer) == 0) {
+ cyg_assert_install_failure_callback(callback1_title, &callback1);
+ cyg_assert_install_failure_callback(callback2_title, &callback2);
+ cyg_assert_install_failure_handler(&failure_handler3);
+ CYG_FAIL(message);
+ CYG_TEST_FAIL("assertion did not trigger");
+ }
+ expecting_failure3 = false;
+
+ return 0;
+}
+cyg_uint32 main_end = (cyg_uint32) __LINE__;
+
projects / karo-tx-redboot.git / blobdiff