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
If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

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
If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

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
If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

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
If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

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
If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

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
If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

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
If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

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
If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

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
If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

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
If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

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
If not stated otherwise, concurrent invocation is not guaranteed to be thread-safe.

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;
}