Test spécifique type d'exception est levée ET l'exception a de bonnes propriétés

Je veux tester que MyException est jeté dans un certain cas. EXPECT_THROW est bien ici. Mais je tiens aussi à vérifier l'exception a un état spécifique de l'e.g e.msg() == "Cucumber overflow".

Comment est-ce mieux mis en œuvre dans GTest?

InformationsquelleAutor Mr. Boy | 2014-04-24
  1. 42

    J'ai surtout deuxième Lilshieste de la réponse, mais ajoute que vous devriez également
    vérifiez que le mal type d'exception est levée pas:

    #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();
}
    • Merci! Complètement négligée.
    InformationsquelleAutor Mike Kinghan
  2. 30

    Un collègue est venu avec la solution viens de re-jeter l'exception.

    Le truc: pas besoin de plus de FAIL() les déclarations, les deux ATTENDENT... des appels qui permettent de tester les bits que vous voulez vraiment: l'exception en tant que tel et sa valeur.

    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 );
}
    • Cela devrait être la réponse sélectionnée depuis proprement teste à la fois le bon et le message à l'aide de deux simples s'ATTENDRE à des macros.
    • Il fonctionne pour moi aussi
    • Je pense que c'est la meilleure réponse. Lisible et de ne pas introduire plus de macros.
    InformationsquelleAutor minastaros
  3. 15

    Jeff Langr décrit une bonne approche dans son livre, Modernes de Programmation C++ avec Test-Driven Development:

    Si votre [test] framework ne prend pas en charge une seule ligne déclarative affirmer que assure une exception est lancée, vous pouvez utiliser la structure suivante dans votre fichier de test:

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

    [...] Vous pourriez aussi avoir besoin d'utiliser le try-catch structure si vous devez vérifier toutes les postconditions après l'exception est levée. Par exemple, vous pouvez vouloir vérifier le texte associé à l'exception de l'objet.

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

    (p.95)

    C'est l'approche que j'ai utilisée, et ont vu dans la pratique d'ailleurs.

    Edit: Comme cela a été souligné par @MikeKinghan, ce n'est pas assez correspondre à la fonctionnalité fournie par EXPECT_THROW; le test ne pas échouer si le mauvais exception est levée. Un supplément de catch clause pourrait être ajouté à cette adresse:

    catch(...) {
    FAIL();
}
    • Il n'a pas assez de test que l'exception levée est du type correct, mais - c'est là que GTest de EXPECT_THROW est agréable. Je suppose que l'extension pour ajouter un catch(...){ FAIL(); } est une option?
    • Merci, c'est vraiment un bon point. Je vais mettre à jour ma réponse à inclure ce détail.
    InformationsquelleAutor Lilshieste
  4. 1

    Je recommande la définition d'une nouvelle macro basé sur Mike Kinghan de l'approche.

    #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  \
           << "'!";                                                   \
}

    Mike TEST(foo_test,out_of_range) exemple serait alors

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

    qui, je pense, finit par être beaucoup plus lisible.

    • vous devriez mettre les accolades à droite dans la macro, puis l'appel de macro est beaucoup plus comme l'original appels - au moins, quand vous enquêtez sur une seule commande.
    InformationsquelleAutor redwizard792
  5. 1

    Que j'ai besoin de faire plusieurs de ces tests, j'ai écrit une macro qui comprend essentiellement Mike Kinghan de la réponse, mais on "supprime" tous les code réutilisable:

    #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)

    Utilisation:

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

    Mises en garde:

    • Que la macro définit une variable dans la portée, de sorte qu'il peut être utilisé une seule fois.
    • C++11 est nécessaire pour std::exception_ptr
    InformationsquelleAutor Matthäus Brandl
  6. 0

    J'aime la plupart des réponses. Cependant, puisqu'il semble que GoogleTest fournit EXPECT_PRED_FORMAT qui permet de faciliter cela, je tiens à ajouter cette option à la liste des réponses:

    MyExceptionCreatingClass testObject; //implements TriggerMyException()

EXPECT_PRED_FORMAT2(ExceptionChecker, testObject, "My_Expected_Exception_Text");

    où ExceptionChecker est défini comme:

    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();
}
    InformationsquelleAutor EdS
  7. 0

    - Je utiliser Matthäus Brandl de la macro avec les éléments suivants modification mineure:

    Mettre la ligne

    std::exception_ptr _exceptionPtr;

    à l'extérieur (f.e. avant d') la définition de la macro comme

    static std::exception_ptr _exceptionPtr;

    à éviter la pluralité de définition du symbole _exceptionPtr.

    • Vous pouvez également passer à la macro comme un argument, alors vous pouvez choisir le nom librement.
    InformationsquelleAutor morini
  8. 0

    Étendre sur les réponses précédentes, une macro qui vérifie qu'une exception d'un type donné, il a été jeté et le message qui commence avec la chaîne.

    Le test échoue si aucune exception n'est levée, le type d'exception est mauvaise ou si le message ne démarre pas avec la chaîne.

    #define ASSERT_THROWS_STARTS_WITH(expr, exc, msg) \
    try\
    {\
            (expr);\
            FAIL() << "Exception not thrown";\
    }\
    catch (const exc& ex)\
    {\
            EXPECT_THAT(ex.what(), StartsWith(std::string(msg)));\
    }\
    catch(...)\
    {\
            FAIL() << "Unexpected exception";\
    }

    Exemple d'utilisation:

    ASSERT_THROWS_STARTS_WITH(foo(-2), std::invalid_argument, "Bad argument: -2");
    InformationsquelleAutor Dave
  9. -1

    Vous pouvez essayer de Stimuler léger test:

    #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();
}
    • Ce que cela a à voir avec la question?
    InformationsquelleAutor M310