Group Assertion and Check Macros
The assertion and check macros provided by SeqAn.

Grouped Macros Overview

SEQAN_ASSERT(expression);
Test that the given expression can be coerced to true.
SEQAN_ASSERT_EQ(expression1, expression2);
Test that two given expressions are equal, as defined by the matching call to the operator=(,).
SEQAN_ASSERT_GEQ(expression1, expression2);
Test that the two given expressions are in the greater-than-or-equal relation as defined by the matching call to operator>=(,).
SEQAN_ASSERT_GT(expression1, expression2);
Test that the two given expressions are in the greather-than relation as defined by the matching call to operator>(,).
SEQAN_ASSERT_IN_DELTA(x, y, delta);
Test that a value y lies within an delta environment of a value x.
SEQAN_ASSERT_LEQ(expression1, expression2)
Test that the two given expressions are in the less-than-or-equal relation as defined by the matching call to operator<=(,).
SEQAN_ASSERT_LT(expression1, expression2);
Test that the two given expressions are in the less-than relation as defined by the matching call to operator<(,).
SEQAN_ASSERT_NEQ(expression1, expression2);
Test that two given expressions are not equal, as defined by the matching call to the operator!=(,).
SEQAN_ASSERT_NOT(expression)
Test that the given expression can be coerced to false.
SEQAN_CHECK(condition, msg[, args]);
Force abortion of program if a condition is not met, regardless of debugging settings.
SEQAN_FAIL(msg[, args]);
Force abortion of program, regardless of debugging settings.

Detailed Description

Assertions are checks performed at runtime when debugging is enabled. Debugging is enabled by defining the preprocessor symbol SEQAN_ENABLE_DEBUG as 1.

The SEQAN_CHECK and SEQAN_FAIL macro always lead to an exit of the program with a non-0 return value.

Grouped Macros Detail

AssertMacros#SEQAN_ASSERT

Defined in
<seqan/basic.h>
SEQAN_ASSERT(expression); SEQAN_ASSERT_MSG(expression, message[, parameters]);
Test that the given expression can be coerced to true.
Parameters
expression (in) - An expression to check for being true.
message (in) - A format string.
parameters (in) - An optional list of parameters.
Data Races
Thread safety unknown!

Remarks

The main advantage of this macro is that it prints the values of its argument on failures. Note that the operator<< to the type of std::cerr has to be defined for the type of both expression parameters. Otherwise, simply use the equivalent SEQAN_ASSERT @call.

See SEQAN_CHECK and SEQAN_FAIL for (conditionally) aborting your program regardless of debug settings.

Examples

SEQAN_ASSERT(0);  // will fail
SEQAN_ASSERT(1);  // will run through
SEQAN_ASSERT_MSG(0, "message %d", 2);  // Will fail with message.

AssertMacros#SEQAN_ASSERT_EQ

Defined in
<seqan/basic.h>
SEQAN_ASSERT_EQ(expression1, expression2); SEQAN_ASSERT_EQ_MSG(expression1, expression2, comment[, parameters]);
Test that two given expressions are equal, as defined by the matching call to the operator=(,).
Parameters
expression1 (in) - The first expression.
expression2 (in) - The second expression.
comment (in) - A C-string (char const *) to use as a format string for printing a message on failure.
parameters (in) - An optional parameter that is put into printf() with format string comment.
Data Races
Thread safety unknown!

The main advantage of this macro is that it prints the values of its argument on failures. Note that the operator<< to the type of std::cerr has to be defined for the type of both expression parameters. Otherwise, simply use the equivalent SEQAN_ASSERT call.

See SEQAN_CHECK and SEQAN_FAIL for (conditionally) aborting your program regardless of debug settings.

Examples

SEQAN_ASSERT_EQ(0, false);  // will run through
SEQAN_ASSERT_EQ(1, false);  // will fail
SEQAN_ASSERT_EQ(1, "foo");  // will not compile
SEQAN_ASSERT_EQ_MSG(1, false, "msg");  // will fail with message

AssertMacros#SEQAN_ASSERT_GEQ

SEQAN_ASSERT_GEQ(expression1, expression2); SEQAN_ASSERT_GEQ_MSG(expression1, expression2, comment[, parameters]);
Test that the two given expressions are in the greater-than-or-equal relation as defined by the matching call to operator>=(,).
Parameters
expression1 (in) - The first expression.
expression2 (in) - The second expression.
comment (in) - A C-string (char const *) to use as a format string for printing a message on failure.
parameters (in) - An optional parameter that is put into printf() with format string comment.
Data Races
Thread safety unknown!

The main advantage of this macro is that it prints the values of its argument on failures. Note that the operator<< to the type of std::cerr has to be defined for the type of both expression parameters. Otherwise, simply use the equivalent SEQAN_ASSERT call.

See SEQAN_CHECK and SEQAN_FAIL for (conditionally) aborting your program regardless of debug settings.

Examples

SEQAN_ASSERT_GEQ(1, 1);  // will run through
SEQAN_ASSERT_GEQ(0, 1);  // will not run through
SEQAN_ASSERT_GEQ_MSG(0, 1, "msg");  // will fail with message

AssertMacros#SEQAN_ASSERT_GT

SEQAN_ASSERT_GT(expression1, expression2); SEQAN_ASSERT_GT_MSG(expression1, expression2, comment[, parameters]);
Test that the two given expressions are in the greather-than relation as defined by the matching call to operator>(,).
Parameters
expression1 (in) - The first expression.
expression2 (in) - The second expression.
comment (in) - A C-string (char const *) to use as a format string for printing a message on failure.
parameters (in) - An optional parameter that is put into printf() with format string comment.
Data Races
Thread safety unknown!

The main advantage of this macro is that it prints the values of its argument on failures. Note that the operator<< to the type of std::cerr has to be defined for the type of both expression parameters. Otherwise, simply use the equivalent SEQAN_ASSERT call.

See SEQAN_CHECK and SEQAN_FAIL for (conditionally) aborting your program regardless of debug settings.

Examples

SEQAN_ASSERT_GT(2, 1);  // will run through
SEQAN_ASSERT_GT(1, 1);  // will not run through
SEQAN_ASSERT_GT_MSG(1, 1, "msg");  // will fail with message

AssertMacros#SEQAN_ASSERT_IN_DELTA

SEQAN_ASSERT_IN_DELTA(x, y, delta); SEQAN_ASSERT_IN_DELTA_MSG(x, y, delta, comment[, parameters]);
Test that a value y lies within an delta environment of a value x.
Parameters
x (in) - The value to center the environment in.
y (in) - The value to check whether it falls within the environment.
delta (in) - The environment size.
comment (in) - A C-string (char const *) to use as a format string for printing a message on failure.
parameters (in) - An optional parameter that is put into printf() with format string comment.
Data Races
Thread safety unknown!

The main advantage of this macro is that it prints the values of its argument on failures. Note that the operator<< to the type of std::cerr has to be defined for the type of both expression parameters. Otherwise, simply use the equivalent SEQAN_ASSERT call.

See SEQAN_CHECK and SEQAN_FAIL for (conditionally) aborting your program regardless of debug settings.

Examples

SEQAN_ASSERT_IN_DELTA(0, 0, 0.1);  // will run through
SEQAN_ASSERT_IN_DELTA(1, -2, 1);  // will fail
SEQAN_ASSERT_IN_DELTA(1, "foo");  // will not compile
SEQAN_ASSERT_IN_DELTA_MSG(1, 0, 0.1, "msg");  // will fail with message

AssertMacros#SEQAN_ASSERT_LEQ

SEQAN_ASSERT_LEQ(expression1, expression2) SEQAN_ASSERT_LEQ_MSG(expression1, expression2, comment[, parameters])
Test that the two given expressions are in the less-than-or-equal relation as defined by the matching call to operator<=(,).
Parameters
expression1 (in) - The first expression.
expression2 (in) - The second expression.
comment (in) - A C-string (char const *) to use as a format string for printing a message on failure.
parameters (in) - An optional parameter that is put into printf() with format string comment.
Data Races
Thread safety unknown!

The main advantage of this macro is that it prints the values of its argument on failures. Note that the operator<< to the type of std::cerr has to be defined for the type of both expression parameters. Otherwise, simply use the equivalent SEQAN_ASSERT call.

See SEQAN_CHECK and SEQAN_FAIL for (conditionally) aborting your program regardless of debug settings.

Examples

SEQAN_ASSERT_LEQ(1, 1);  // will run through
SEQAN_ASSERT_LEQ(1, 2);  // will not run through
SEQAN_ASSERT_LEQ_MSG(1, 2, "msg");  // will fail with message

AssertMacros#SEQAN_ASSERT_LT

Defined in
<seqan/basic.h>
SEQAN_ASSERT_LT(expression1, expression2); SEQAN_ASSERT_LT(expression1, expression2, comment[, parameters]);
Test that the two given expressions are in the less-than relation as defined by the matching call to operator<(,).
Parameters
expression1 (in) - The first expression.
expression2 (in) - The second expression.
comment (in) - A C-string (char const *) to use as a format string for printing a message on failure.
parameters (in) - An optional parameter that is put into printf() with format string comment.
Data Races
Thread safety unknown!

The main advantage of this macro is that it prints the values of its argument on failures. Note that the operator<< to the type of std::cerr has to be defined for the type of both expression parameters. Otherwise, simply use the equivalent SEQAN_ASSERT call.

See SEQAN_CHECK and SEQAN_FAIL for (conditionally) aborting your program regardless of debug settings.

Examples

SEQAN_ASSERT_LT(0, 1);  // will run through
SEQAN_ASSERT_LT(1, 1);  // will not run through
SEQAN_ASSERT_LT_MSG(1, 1, "msg");  // will fail with message

AssertMacros#SEQAN_ASSERT_NEQ

Defined in
<seqan/basic.h>
SEQAN_ASSERT_NEQ(expression1, expression2); SEQAN_ASSERT_NEQ_MSG(expression1, expression2, comment[, parameters]);
Test that two given expressions are not equal, as defined by the matching call to the operator!=(,).
Parameters
expression1 (in) - The first expression.
expression2 (in) - The second expression.
comment (in) - A C-string (char const *) to use as a format string for printing a message on failure.
parameters (in) - An optional parameter that is put into printf() with format string comment.
Data Races
Thread safety unknown!

The main advantage of this macro is that it prints the values of its argument on failures. Note that the operator<< to the type of std::cerr has to be defined for the type of both expression parameters. Otherwise, simply use the equivalent SEQAN_ASSERT call.

See SEQAN_CHECK and SEQAN_FAIL for (conditionally) aborting your program regardless of debug settings.

Examples

SEQAN_ASSERT_NEQ(0, false);  // will fail
SEQAN_ASSERT_NEQ(1, false);  // will run through
SEQAN_ASSERT_NEQ(1, "foo");  // will not compile
SEQAN_ASSERT_NEQ_MSG(1, false, "msg");  // will fail with message

AssertMacros#SEQAN_ASSERT_NOT

Defined in
<seqan/basic.h>
SEQAN_ASSERT_NOT(expression) SEQAN_ASSERT_NOT_MSG(expression, message[, parameters])
Test that the given expression can be coerced to false.
Parameters
expression (in) - An expression to check for being false.
message (in) - A format string.
parameters (in) - An optional list of parameters.
Data Races
Thread safety unknown!

Remarks

The main advantage of this macro is that it prints the values of its argument on failures. Note that the operator<< to the type of std::cerr has to be defined for the type of both expression parameters. Otherwise, simply use the equivalent SEQAN_ASSERT call.

See SEQAN_CHECK and SEQAN_FAIL for (conditionally) aborting your program regardless of debug settings.

Examples

SEQAN_ASSERT_NOT(0);  // will run through
SEQAN_ASSERT_NOT(1);  // will fail
SEQAN_ASSERT_NOT_MSG(0, "msg %s", "test");  // will fail with message

AssertMacros#SEQAN_CHECK

Defined in
<seqan/basic.h>
SEQAN_CHECK(condition, msg[, args]);
Force abortion of program if a condition is not met, regardless of debugging settings.
Parameters
condition (in) - An expression that is checked.
msg (in) - A format string.
args (in) - An optional list of arguments.
Data Races
Thread safety unknown!

Remarks

Use this if something really unexpected happens inside your functions and there is no way to report this through the API. A good example would be logic errors, e.g. invalid values.

Examples

In the following example, the SEQAN_CHECK stops program execution if a value is added to MyEnum but the function foo is not updated accordingly.

enum MyEnum
{
  VALUE_ONE,
  VALUE_TWO
};

bool foo(MyEnum x)
{
    SEQAN_CHECK((x == VALUE_ONE || x == VALUE_TWO), "Invalid value for x == %d.", x);

    switch (x)
    {
    case VALUE_ONE:
        // do something
        return true;
    case VALUE_TWO:
        // do something
        return true;
    }

    return false;  // Should never reach here, checked above with SEQAN_CHECK.
}

AssertMacros#SEQAN_FAIL

Defined in
<seqan/basic.h>
SEQAN_FAIL(msg[, args]);
Force abortion of program, regardless of debugging settings.
Parameters
msg (in) - A format string.
args (in) - An optional list of arguments that are used for filling msg.
Data Races
Thread safety unknown!

Remarks

Use this if something really unexpected happens inside your functions and there is no way to report this through the API. A good example would be logic errors, e.g. invalid values.

Examples

In the following example, the SEQAN_FAIL is there if a possible value is added to MyEnum but the function foo is not updated accordingly.

enum MyEnum
{
  VALUE_ONE,
  VALUE_TWO
};

bool foo(MyEnum x)
{
    switch (x)
    {
    case VALUE_ONE:
        // do something
        return true;
    case VALUE_TWO:
        // do something
        return true;
    }

    SEQAN_FAIL("Logic error. Should never reach here. x == %d.", x);
    return false;
}