Est-il possible de rendre les fonctions simulées "intéressantes" avec ON_CALL?

Donné:

#include "gmock/gmock.h"
#include <string>

using namespace testing; //tsk, tsk

//-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

struct Mockable {
    virtual std::string ify(int x) const;
};

std::string Mockable::ify(int x) const
{
    return std::to_string(x);
}

//-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

struct Mocked : public Mockable {
    MOCK_CONST_METHOD1(ify, std::string(int));
};

//-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

std::string tested(Mockable const& u, int x)
{
    return u.ify(x);
}

TEST(TC,T42)
{
    Mocked mock;
    ON_CALL(mock, ify(Eq(42)))
    .WillByDefault(Return("33"));

    std::string const& ret = tested(mock, 42);
    EXPECT_EQ("42", ret);
}

TEST(TC,T33)
{
    Mocked mock;
    ON_CALL(mock, ify(Eq(33)))
    .WillByDefault(Return("333"));

    std::string const& ret = tested(mock, 42);
    EXPECT_EQ("42", ret);
}

int main(int argc, char *argv[])
{
    ::testing::InitGoogleTest(&argc, argv);
    //::testing::FLAGS_gmock_verbose = "info";

    return RUN_ALL_TESTS();
}

La sortie est:

$ ./mocktest 
[==========] Running 2 tests from 1 test case.
[----------] Global test environment set-up.
[----------] 2 tests from TC
[ RUN      ] TC.T42

GMOCK WARNING:
Uninteresting mock function call - taking default action specified at:
mocktest.cc:40:
    Function call: ify(42)
          Returns: "33"
Stack trace:
mocktest.cc:44: Failure
Value of: ret
  Actual: "33"
Expected: "42"
[  FAILED  ] TC.T42 (0 ms)
[ RUN      ] TC.T33

GMOCK WARNING:
Uninteresting mock function call - returning default value.
    Function call: ify(42)
          Returns: ""
Stack trace:
mocktest.cc:54: Failure
Value of: ret
  Actual: ""
Expected: "42"
[  FAILED  ] TC.T33 (1 ms)
[----------] 2 tests from TC (1 ms total)

[----------] Global test environment tear-down
[==========] 2 tests from 1 test case ran. (1 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 2 tests, listed below:
[  FAILED  ] TC.T42
[  FAILED  ] TC.T33

Dans les deux cas, Gmock se comporte correctement w.r.t. appliquant le comportement (ou pas, dans TC33). Mais pourquoi dire "sans intérêt de se moquer de l'appel de fonction" dans les deux cas? Sont se moquer des appels de fonction intéressante que lorsqu'elle est spécifiée avec EXPECT_CALL ?

source d'informationauteur Bulletmagnet

  1. 17

    "Sont se moquer des appels de fonction intéressante que lorsqu'elle est spécifiée avec EXPECT_CALL ?"

    En bref, oui.

    Le ON_CALL() macro influe seulement sur la prise de mesures sur une maquette d'un appel de méthode, mais pas à l'appel des attentes définies sur l'objet fantaisie.

    Vous pouvez utiliser le NiceMock<> modèle bien que, pour supprimer ces mises en garde en général.

    Pour citer à partir de google se moque de "livre de cuisine"

    Supposons que votre test utilise une maquette de la classe MockFoo:

    TEST(...) {
  MockFoo mock_foo;
  EXPECT_CALL(mock_foo, DoThis());
  ... code that uses mock_foo ...
}

    Si une méthode de mock_foo autre que Suivre() est appelée, elle sera signalée par Google se Moquer comme un avertissement. Toutefois, si vous réécrivez votre test NiceMock au lieu de cela, l'avertissement aura disparu, résultant en un produit de nettoyage de sortie de test:

    using ::testing::NiceMock;

TEST(...) {
  NiceMock<MockFoo> mock_foo;
  EXPECT_CALL(mock_foo, DoThis());
  ... code that uses mock_foo ...
}

    NiceMock<MockFoo> est une sous-classe de MockFoode sorte qu'il peut être utilisé partout où MockFoo est acceptée.