Frage

Ich versuche, eine Templat-Methode zu verspotten.

Hier ist die Klasse, die die Methode enthält zu verspotten:

class myClass
{
public:
    virtual ~myClass() {}

    template<typename T>
    void myMethod(T param);
}

Wie kann ich die Methode spotten MyMethod mit Google Mock?

War es hilfreich?

Lösung

In früheren Version von Google Mock können Sie nur Mock virtuelle Funktionen finden Sie in der Dokumentation in der Seite des Projekts.

Neuere Versionen erlaubt Mock nicht-virtuelle Methoden , mit was sie nennen hallo-perf Dependency Injection .

Wie congusbongus heißt es:

  

Google Mock setzt auf Membervariablen zur Unterstützung Methode spöttischen Hinzufügen und da Sie nicht Vorlage Membervariablen erstellen können, ist es unmöglich, Mock Template-Funktionen

Eine Abhilfe, die von Michael Harrington in den Google Groups aus den Kommentaren verknüpfen, ist die Template-Methoden machen spezialisiert, die eine normale Funktion aufrufen wird, die verspottet werden kann. Es muss nicht den allgemeinen Fall lösen, aber es wird für die Prüfung arbeiten.

struct Foo
{
    MOCK_METHOD1(GetValueString, void(std::string& value));

    template <typename ValueType>
    void GetValue(ValueType& value); 

    template <>
    void GetValue(std::string& value) {
        GetValueString(value);
    } 
};

Andere Tipps

Hier ist der Original-Beitrag wieder mit Kommentaren zu Hilfe zum Verständnis:

    struct Foo 
    { 
        // Our own mocked method that the templated call will end up calling.
        MOCK_METHOD3(GetNextValueStdString, void(const std::string& name, std::string& value, const unsigned int streamIndex)); 

        // If we see any calls with these two parameter list types throw and error as its unexpected in the unit under test.
        template< typename ValueType > 
        void GetNextValue( const std::string& name, ValueType& value, const unsigned int streamIndex ) 
        { 
            throw "Unexpected call."; 
        } 
        template< typename ValueType > 
        void GetNextValue( const std::string& name, ValueType& value ) 
        { 
            throw "Unexpected call."; 
        } 

        // These are the only two templated calls expected, notice the difference in the method parameter list. Anything outside
        // of these two flavors is considerd an error.
        template<> 
        void GetNextValue< std::string >( const std::string& name, std::string& value, const unsigned int streamIndex ) 
        { 
            GetNextValueStdString( name, value, streamIndex ); 
        } 
        template<> 
        void GetNextValue< std::string >( const std::string& name, std::string& value ) 
        { 
            GetNextValue< std::string >( name, value, 0 ); 
        } 
    }; 
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top