Assertion and Check Macros - SeqAn API Documentation

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

#### Dox Sources

    /*!
     * @defgroup AssertMacros Assertion and Check Macros
     *
     * @brief The assertion and check macros provided by SeqAn.
     *
     * Assertions are checks performed at runtime when debugging is enabled.
     * Debugging is enabled by defining the preprocessor symbol
     * <tt>SEQAN_ENABLE_DEBUG</tt> as <tt>1</tt>.
     *
     * The SEQAN_CHECK and SEQAN_FAIL macro always lead to an exit of the program
     * with a non-0 return value.
     *
     * @macro AssertMacros#SEQAN_FAIL
     *
     * @headerfile <seqan/basic.h>
     *
     * @brief Force abortion of program, regardless of debugging settings.
     *
     * @signature SEQAN_FAIL(msg[, args]);
     *
     * @param[in] msg A format string.
     * @param[in] args An optional list of arguments that are used for filling msg.
     *
     * @section 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.
     *
     * @section Examples
     *
     * In the following example, the <tt>SEQAN_FAIL</tt> is there if a possible
     * value is added to <tt>MyEnum</tt> but the function <tt>foo</tt> is not
     * updated accordingly.
     *
     * @code{.cpp}
     * 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;
     * }
     * @endcode
     *
     *
     * @macro AssertMacros#SEQAN_CHECK
     *
     * @headerfile <seqan/basic.h>
     *
     * @brief Force abortion of program if a condition is not met, regardless of
     *        debugging settings.
     *
     * @signature SEQAN_CHECK(condition, msg[, args]);
     *
     * @param[in] condition An expression that is checked.
     * @param[in] msg A format string.
     * @param[in] args An optional list of arguments.
     *
     * @section 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.
     *
     * @section Examples
     *
     * In the following example, the <tt>SEQAN_CHECK</tt> stops program execution if
     * a value is added to <tt>MyEnum</tt> but the function <tt>foo</tt> is not
     * updated accordingly.
     *
     * @code{.cpp}
     * 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.
     * }
     * @endcode
     *
     *
     * @macro AssertMacros#SEQAN_ASSERT
     *
     * @headerfile <seqan/basic.h>
     *
     * @brief Test that the given expression can be coerced to <tt>true</tt>.
     *
     * @signature SEQAN_ASSERT(expression);
     * @signature SEQAN_ASSERT_MSG(expression, message[, parameters]);
     *
     * @param[in] expression An expression to check for being true.
     * @param[in] message A format string.
     * @param[in] parameters An optional list of parameters.
     *
     * @section Remarks
     *
     * The main advantage of this macro is that it prints the values of its argument
     * on failures. Note that the <tt>operator&lt;&lt;</tt> to the type of
     * <tt>std::cerr</tt> 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.
     *
     * @section Examples
     *
     * @code{.cpp}
     * SEQAN_ASSERT(0);  // will fail
     * SEQAN_ASSERT(1);  // will run through
     * SEQAN_ASSERT_MSG(0, "message %d", 2);  // Will fail with message.
     * @endcode
     *
     *
     * @macro AssertMacros#SEQAN_ASSERT_NOT
     *
     * @headerfile <seqan/basic.h>
     *
     * @brief Test that the given expression can be coerced to <tt>false</tt>.
     *
     * @signature SEQAN_ASSERT_NOT(expression)
     * @signature SEQAN_ASSERT_NOT_MSG(expression, message[, parameters])
     *
     * @param[in] expression An expression to check for being false.
     * @param[in] message A format string.
     * @param[in] parameters An optional list of parameters.
     *
     * @section Remarks
     *
     * The main advantage of this macro is that it prints the values of its argument
     * on failures. Note that the <tt>operator&lt;&lt;</tt> to the type of
     * <tt>std::cerr</tt> 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.
     *
     * @section Examples
     *
     * @code{.cpp}
     * 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
     * @endcode
     *
     *
     * @macro AssertMacros#SEQAN_ASSERT_EQ
     *
     * @headerfile <seqan/basic.h>
     *
     * @brief Test that two given expressions are equal, as defined by the matching
     *        call to the <tt>operator=(,)</tt>.
     *
     * @signature SEQAN_ASSERT_EQ(expression1, expression2);
     * @signature SEQAN_ASSERT_EQ_MSG(expression1, expression2, comment[,
     *            parameters]);
     *
     * @param[in] expression1 The first expression.
     * @param[in] expression2 The second expression.
     * @param[in] comment A C-string (<tt>char const *</tt>) to use as a format
     *                    string for printing a message on failure.
     * @param[in] parameters An optional parameter that is put into
     *                       <tt>printf()</tt> with format string <tt>comment</tt>.
     *
     * The main advantage of this macro is that it prints the values of its argument
     * on failures. Note that the <tt>operator&lt;&lt;</tt> to the type of
     * <tt>std::cerr</tt> 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.
     *
     * @section Examples
     *
     * @code{.cpp}
     * 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
     * @endcode
     *
     *
     * @macro AssertMacros#SEQAN_ASSERT_NEQ
     *
     * @headerfile <seqan/basic.h>
     *
     * @brief Test that two given expressions are not equal, as defined by the
     *        matching call to the <tt>operator!=(,)</tt>.
     *
     * @signature SEQAN_ASSERT_NEQ(expression1, expression2);
     * @signature SEQAN_ASSERT_NEQ_MSG(expression1, expression2, comment[,
     *            parameters]);
     *
     * @param[in] expression1 The first expression.
     * @param[in] expression2 The second expression.
     * @param[in] comment A C-string (<tt>char const *</tt>) to use as a format
     *                    string for printing a message on failure.
     * @param[in] parameters An optional parameter that is put into
     *                       <tt>printf()</tt> with format string <tt>comment</tt>.
     *
     * The main advantage of this macro is that it prints the values of its argument
     * on failures. Note that the <tt>operator&lt;&lt;</tt> to the type of
     * <tt>std::cerr</tt> 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.
     *
     * @section Examples
     *
     * @code{.cpp}
     * 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
     * @endcode
     *
     *
     * @macro AssertMacros#SEQAN_ASSERT_LT
     *
     * @headerfile <seqan/basic.h>
     *
     * @brief Test that the two given expressions are in the less-than relation as
     *        defined by the matching call to operator<(,).
     *
     * @signature SEQAN_ASSERT_LT(expression1, expression2);
     * @signature SEQAN_ASSERT_LT(expression1, expression2, comment[, parameters]);
     *
     * @param[in] expression1 The first expression.
     * @param[in] expression2 The second expression.
     * @param[in] comment A C-string (<tt>char const *</tt>) to use as a format
     *                    string for printing a message on failure.
     * @param[in] parameters An optional parameter that is put into
     *                       <tt>printf()</tt> with format string <tt>comment</tt>.
     *
     * The main advantage of this macro is that it prints the values of its argument
     * on failures. Note that the <tt>operator&lt;&lt;</tt> to the type of
     * <tt>std::cerr</tt> 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.
     *
     * @section Examples
     *
     * @code{.cpp}
     * 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
     * @endcode
     *
     *
     * @macro AssertMacros#SEQAN_ASSERT_LEQ
     *
     * @brief Test that the two given expressions are in the less-than-or-equal
     *        relation as defined by the matching call to operator<=(,).
     *
     * @signature SEQAN_ASSERT_LEQ(expression1, expression2)
     * @signature SEQAN_ASSERT_LEQ_MSG(expression1, expression2, comment[,
     *            parameters])
     *
     * @param[in] expression1 The first expression.
     * @param[in] expression2 The second expression.
     * @param[in] comment A C-string (<tt>char const *</tt>) to use as a format
     *                    string for printing a message on failure.
     * @param[in] parameters An optional parameter that is put into
     *                       <tt>printf()</tt> with format string <tt>comment</tt>.
     *
     * The main advantage of this macro is that it prints the values of its argument
     * on failures. Note that the <tt>operator&lt;&lt;</tt> to the type of
     * <tt>std::cerr</tt> 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.
     *
     * @section Examples
     *
     * @code{.cpp}
     * 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
     * @endcode
     *
     *
     * @macro AssertMacros#SEQAN_ASSERT_GT
     *
     * @brief Test that the two given expressions are in the greather-than relation
     *        as defined by the matching call to operator>(,).
     *
     * @signature SEQAN_ASSERT_GT(expression1, expression2);
     * @signature SEQAN_ASSERT_GT_MSG(expression1, expression2, comment[,
     *            parameters]);
     *
     * @param[in] expression1 The first expression.
     * @param[in] expression2 The second expression.
     * @param[in] comment A C-string (<tt>char const *</tt>) to use as a format
     *                    string for printing a message on failure.
     * @param[in] parameters An optional parameter that is put into
     *                       <tt>printf()</tt> with format string <tt>comment</tt>.
     *
     * The main advantage of this macro is that it prints the values of its argument
     * on failures. Note that the <tt>operator&lt;&lt;</tt> to the type of
     * <tt>std::cerr</tt> 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.
     *
     * @section Examples
     *
     * @code{.cpp}
     * 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
     * @endcode
     *
     *
     * @macro AssertMacros#SEQAN_ASSERT_GEQ
     *
     * @brief Test that the two given expressions are in the greater-than-or-equal
     *        relation as defined by the matching call to operator>=(,).
     *
     * @signature SEQAN_ASSERT_GEQ(expression1, expression2);
     * @signature SEQAN_ASSERT_GEQ_MSG(expression1, expression2, comment[,
     *            parameters]);
     *
     * @param[in] expression1 The first expression.
     * @param[in] expression2 The second expression.
     * @param[in] comment A C-string (<tt>char const *</tt>) to use as a format
     *                    string for printing a message on failure.
     * @param[in] parameters An optional parameter that is put into
     *                       <tt>printf()</tt> with format string <tt>comment</tt>.
     *
     * The main advantage of this macro is that it prints the values of its argument
     * on failures. Note that the <tt>operator&lt;&lt;</tt> to the type of
     * <tt>std::cerr</tt> 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.
     *
     * @section Examples
     *
     * @code{.cpp}
     * 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
     * @endcode
     *
     *
     * @macro AssertMacros#SEQAN_ASSERT_IN_DELTA
     *
     * @brief Test that a value <tt>y</tt> lies within an <tt>delta</tt> environment
     *        of a value <tt>x</tt>.
     *
     * @signature SEQAN_ASSERT_IN_DELTA(x, y, delta);
     * @signature SEQAN_ASSERT_IN_DELTA_MSG(x, y, delta, comment[, parameters]);
     *
     * @param[in] x The value to center the environment in.
     * @param[in] y The value to check whether it falls within the environment.
     * @param[in] delta The environment size.
     * @param[in] comment A C-string (<tt>char const *</tt>) to use as a format
     *                    string for printing a message on failure.
     * @param[in] parameters An optional parameter that is put into
     *                       <tt>printf()</tt> with format string <tt>comment</tt>.
     *
     * The main advantage of this macro is that it prints the values of its argument
     * on failures. Note that the <tt>operator&lt;&lt;</tt> to the type of
     * <tt>std::cerr</tt> 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.
     *
     * @section Examples
     *
     * @code{.cpp}
     * 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
     * @endcode
     */