c++ - Probar un tipo de excepción específico lanzado Y la excepción tiene las propiedades correctas

unit-testing exception

Question

Quiero probar que MyException se arroja en un caso determinado. EXPECT_THROW es bueno aquí. Pero también quiero comprobar que la excepción tiene un estado específico, por ejemplo, e.msg() == "Cucumber overflow" .

¿Cómo se implementa mejor en GTest?

Answer 1

Como necesito hacer varias de esas pruebas, escribí una macro que básicamente incluye la respuesta de Mike Kinghan pero "elimina" todo el código repetitivo:

#define ASSERT_THROW_KEEP_AS_E(statement, expected_exception) /
    std::exception_ptr _exceptionPtr; /
    try /
    { /
        (statement);/
        FAIL() << "Expected: " #statement " throws an exception of type " /
          #expected_exception "./n  Actual: it throws nothing."; /
    } /
    catch (expected_exception const &) /
    { /
        _exceptionPtr = std::current_exception(); /
    } /
    catch (...) /
    { /
        FAIL() << "Expected: " #statement " throws an exception of type " /
          #expected_exception "./n  Actual: it throws a different type."; /
    } /
    try /
    { /
        std::rethrow_exception(_exceptionPtr); /
    } /
    catch (expected_exception const & e)

Uso:

ASSERT_THROW_KEEP_AS_E(foo(), MyException)
{
    ASSERT_STREQ("Cucumber overflow", e.msg());
}

Advertencias:

• Como la macro define una variable en el alcance actual, por lo que solo se puede usar una vez.
• C ++ 11 es necesario para std::exception_ptr

Answer 2

Jeff Langr describe un buen enfoque en su libro, Modern C ++ Programming with Test-Driven Development :

Si su marco de [prueba] no admite una afirmación declarativa de una sola línea que garantice que se lanza una excepción, puede usar la siguiente estructura en su prueba:

    TEST(ATweet, RequiresUserNameToStartWithAnAtSign) {
        string invalidUser("notStartingWith@");
        try {
            Tweet tweet("msg", invalidUser);
            FAIL();
        }
        catch(const InvalidUserException& expected) {}
    }

[...] También es posible que necesite utilizar la estructura try-catch si debe verificar cualquier condición posterior después de lanzar la excepción. Por ejemplo, es posible que desee verificar el texto asociado con el objeto de excepción arrojado.

    TEST(ATweet, RequiresUserNameToStartWithAtSign) {
        string invalidUser("notStartingWith@");
        try {
            Tweet tweet("msg", invalidUser);
            FAIL();
        }
        catch(const InvalidUserException& expected) {
            ASSERT_STREQ("notStartingWith@", expected.what());
        }
    }

(p.95)

Este es el enfoque que he usado y he visto en práctica en otros lugares.

Editar: como ha señalado @MikeKinghan, esto no coincide con la funcionalidad proporcionada por EXPECT_THROW ; la prueba no falla si se lanza la excepción incorrecta. Se podría agregar una cláusula de catch adicional para abordar esto:

catch(...) {
    FAIL();
}

Answer 3

Me gusta la mayoría de las respuestas. Sin embargo, dado que parece que GoogleTest proporciona EXPECT_PRED_FORMAT que ayuda a facilitar esto, me gustaría agregar esta opción a la lista de respuestas:

MyExceptionCreatingClass testObject; // implements TriggerMyException()

EXPECT_PRED_FORMAT2(ExceptionChecker, testObject, "My_Expected_Exception_Text");

donde ExceptionChecker se define como:

testing::AssertionResult ExceptionChecker(const char* aExpr1,
                                          const char* aExpr2,
                                          MyExceptionCreatingClass& aExceptionCreatingObject,
                                          const char* aExceptionText)
{
  try
  {
    aExceptionCreatingObject.TriggerMyException();
    // we should not get here since we expect an exception
    return testing::AssertionFailure() << "Exception ''" << aExceptionText << "'' is not thrown.";
  }
  catch (const MyExpectedExceptionType& e)
  {
    // expected this, but verify the exception contains the correct text
    if (strstr(e.what(), aExceptionText) == static_cast<const char*>(NULL))
    {
      return testing::AssertionFailure()
          << "Exception message is incorrect. Expected it to contain ''"
          << aExceptionText << "'', whereas the text is ''" << e.what() << "''./n";
    }
  }
  catch ( ... )
  {
    // we got an exception alright, but the wrong one...
    return testing::AssertionFailure() << "Exception ''" << aExceptionText
    << "'' not thrown with expected type ''MyExpectedExceptionType''.";
  }
  return testing::AssertionSuccess();
}

Answer 4

Principalmente respondí en segundo lugar a Lilshieste, pero agregaría que también debes verificar que no se lanza el tipo de excepción incorrecto :

#include <stdexcept>
#include "gtest/gtest.h"

struct foo
{
    int bar(int i) {
        if (i > 100) {
            throw std::out_of_range("Out of range");
        }
        return i;
    }
};

TEST(foo_test,out_of_range)
{
    foo f;
    try {
        f.bar(111);
        FAIL() << "Expected std::out_of_range";
    }
    catch(std::out_of_range const & err) {
        EXPECT_EQ(err.what(),std::string("Out of range"));
    }
    catch(...) {
        FAIL() << "Expected std::out_of_range";
    }
}

int main(int argc, char **argv) {
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}

Answer 5

Puedes probar la prueba ligera Boost:

#include <boost/detail/lightweight_test.hpp>
#include <stdexcept>

void function_that_would_throw(int x)
{
  if (x > 0) {
    throw std::runtime_error("throw!");
  }
}

int main() {
 BOOST_TEST_THROWS(function_that_would_throw(10), std::runtime_error);
 boost::report_errors();
}

Answer 6

Recomiendo definir una macro nueva basada en el enfoque de Mike Kinghan.

#define ASSERT_EXCEPTION( TRY_BLOCK, EXCEPTION_TYPE, MESSAGE )        /
try                                                                   /
{                                                                     /
    TRY_BLOCK                                                         /
    FAIL() << "exception ''" << MESSAGE << "'' not thrown at all!";     /
}                                                                     /
catch( const EXCEPTION_TYPE& e )                                      /
{                                                                     /
    EXPECT_EQ( MESSAGE, e.what() )                                    /
        << " exception message is incorrect. Expected the following " /
           "message:/n/n"                                             /
        << MESSAGE << "/n";                                           /
}                                                                     /
catch( ... )                                                          /
{                                                                     /
    FAIL() << "exception ''" << MESSAGE                                /
           << "'' not thrown with expected type ''" << #EXCEPTION_TYPE  /
           << "''!";                                                   /
}

El ejemplo de TEST(foo_test,out_of_range) de Mike TEST(foo_test,out_of_range) sería entonces

TEST(foo_test,out_of_range)
{
    foo f;
    ASSERT_EXCEPTION( { f.bar(111); }, std::out_of_range, "Out of range" );
}

que creo que termina siendo mucho más legible

Answer 7

Un colega propuso la solución simplemente volviendo a lanzar la excepción.

La destreza: no se necesitan declaraciones FAIL () adicionales, solo las dos llamadas EXPECT ... que prueban los bits que realmente quiere: la excepción como tal y su valor.

TEST(Exception, HasCertainMessage )
{
    // this tests _that_ the expected exception is thrown
    EXPECT_THROW({
        try
        {
            thisShallThrow();
        }
        catch( const MyException& e )
        {
            // and this tests that it has the correct message
            EXPECT_STREQ( "Cucumber overflow", e.what() );
            throw;
        }
    }, MyException );
}

Answer 8

Utilizo la macro de Matthäus Brandl con la siguiente modificación menor:

Pon la linea

std::exception_ptr _exceptionPtr;

afuera (antes) la definición de macro como

static std::exception_ptr _exceptionPtr;

para evitar la definición múltiple del símbolo _exceptionPtr .