GoogleMock: wie zu erwarten genau einen Anruf mit einem bestimmten argument, und siehe Diagnose auf Ausfall?

Vielleicht eine finesse Frage, mein problem ist, dass wenn ich Schreibe:

EXPECT_CALL(mock, handleMessage(_)).Times(0);                           //expectation #1
EXPECT_CALL(mock, handleMessage(Pointee(IsLike(aSpecificMessage))));    //expectation #2

... und Methode handleMessage wird einmal aufgerufen, aber mit einem anderen argument (nicht aSpecificMessage), dann ist der Fehler sieht wie folgt aus:

Mock function called more times than expected - returning default value.
    Function call: handleMessage(0x8b5378)
          Returns: false
         Expected: to be never called
           Actual: called once - over-saturated and active

Google Mock drucken nicht die Diagnose, warum das argument nicht entsprechen, das Prädikat in Erwartung #2.
Dies ist vermutlich, weil die Erwartung #1 ist das erste scheitern (?).

Wenn ich das weglasse Erwartung #1, dann wird der Fehler verbose, entlang der Linien von:

Google Mock tried the following 1 expectation, but it didn't match:

../../test/Test.cpp:143: EXPECT_CALL(mock, handleMessage(Pointee(IsLike(aSpecificMessage))))...
  Expected arg #0: points to a value that <....>
           Actual: 0xfeaf18, which points to <.....>

Ich bin mit einem benutzerdefinierten Matcher IsLike und ich ging durch das Problem der Erzeugung von sehr explizite mismatch Gründen möchte ich Sie gedruckt werden. Ich würde auch nicht aufgeben wollen, Erwartung #1 da geht das in einem "Standard" - Abschnitt und standardmäßig will ich keine Anrufe an, die spotten über den rest des tests.

InformationsquelleAutor haelix | 2014-09-26

  1. 3

    Sieht aus wie Sie verwenden sollten,die StrictMock template-modifier. Lassen Sie uns dieses einfach Klasse und mock:

    struct Foo
{
    virtual void function(int) {
    }
};

struct MockFoo: public Foo
{
    MOCK_METHOD1(function, void(int x));
};

    Beginnen wir mit einem grundlegenden test, übungen, Methode:

    TEST(MockTest, basic_one_expectation)
{
    MockFoo foo;
    EXPECT_CALL(foo, function(4));
    Foo& foo1(foo);
    foo1.function(3);
}

    Ausgabe:

    [ AUSFÜHREN ] MockTest.basic_one_expectation 
unbekannte Datei: Fehler 

Unerwartete mock-Funktion Anruf - Rückgabe direkt. 
Funktionsaufruf: function(3) 
Google Mock habe versucht, die folgenden 1 Erwartung, aber es didn ' T match: 

mock-test.cpp:298: EXPECT_CALL(foo, Funktion(4))... 
Erwartet arg #0: ist gleich 4 
Aktuell: 3 
Erwartet: auf einmal aufgerufen werden 
Aktuell: nie genannt - unzufrieden und aktiv 
mock-test.cpp:298: Fehler 
Eigentliche Funktionsaufruf count doesn ' T match EXPECT_CALL(foo, Funktion(4))... 
Erwartet: auf einmal aufgerufen werden 
Aktuell: nie genannt - unzufrieden und aktiv 
[ GESCHEITERT ] MockTest.basic_one_expectation (1 ms)

    Das ist eine der alternativen, die Sie bereits angesehen, aber Sie wollen es nicht, weil Sie noch andere tests, die don ' T haben keine bestimmten Erwartungen darüber, ob die Funktion aufgerufen wird, und Sie möchten, dass diese tests fehlschlagen, wenn die Funktion aufgerufen wird, sowieso. Als Erinnerung, mal sehen, was passiert, wenn wir versuchen, einen solchen test:

    TEST(MockTest, basic_no_expectation)
{
    MockFoo foo;
    Foo& foo1(foo);
    foo1.function(3);
}

    Ausgabe:

    [ AUSFÜHREN ] MockTest.basic_no_expectation 

GMOCK WARNUNG: 
Uninteressant mock-Funktion Anruf - Rückgabe direkt. 
Funktionsaufruf: function(3) 
Stack-trace: 
[ OK ] MockTest.basic_no_expectation (1 ms)

    Erhalten wir eine Warnung, aber der test noch geht. Das ist nicht gut für Sie. Lassen Sie uns sehen, welche Wirkung StrictMock hat:

    TEST(MockTest, strict_no_expectation)
{
    ::testing::StrictMock<MockFoo> foo;
    Foo& foo1(foo);
    foo1.function(3);
}

    Ausgabe:

    [ AUSFÜHREN ] MockTest.strict_no_expectation 
unbekannte Datei: Fehler 
Uninteressant mock-Funktion Anruf - Rückgabe direkt. 
Funktionsaufruf: function(3) 
[ GESCHEITERT ] MockTest.strict_no_expectation (0 ms)

    Hatten wir nicht explizit sagen, dass wir nicht wollen, dass die Funktion, die aufgerufen werden, aber wenn die Funktion aufgerufen wird, wird sowieso der test korrekt ausfällt. Genau das, was Sie wollte.

    Schließlich, schauen wir uns an, was passiert mit StrictMock in dem Fall, wo es sind explizite Erwartungen für die Funktion argument: 

    TEST(MockTest, strict_one_expectation)
{
    ::testing::StrictMock<MockFoo> foo;
    EXPECT_CALL(foo, function(4));
    Foo& foo1(foo);
    foo1.function(3);
}

    Ausgabe:

    [ AUSFÜHREN ] MockTest.strict_one_expectation 
unbekannte Datei: Fehler 

Unerwartete mock-Funktion Anruf - Rückgabe direkt. 
Funktionsaufruf: function(3) 
Google Mock habe versucht, die folgenden 1 Erwartung, aber es didn ' T match: 

mock-test.cpp:307: EXPECT_CALL(foo, Funktion(4))... 
Erwartet arg #0: ist gleich 4 
Aktuell: 3 
Erwartet: auf einmal aufgerufen werden 
Aktuell: nie genannt - unzufrieden und aktiv 
mock-test.cpp:307: Fehler 
Eigentliche Funktionsaufruf count doesn ' T match EXPECT_CALL(foo, Funktion(4))... 
Erwartet: auf einmal aufgerufen werden 
Aktuell: nie genannt - unzufrieden und aktiv 
[ GESCHEITERT ] MockTest.strict_one_expectation (0 ms)

    Diagnostik zeigen den Grund, warum das argument nicht übereinstimmen, genau wie das original basic_one_expectation test oben gezeigt.

    Oh ja!! das war es

    InformationsquelleAutor Rob Kennedy

Schreibe einen Kommentar