Comment se moquer des méthodes utilisant Google Mock basé sur un modèle?

Question

Je suis en train de se moquer d'une méthode templated.

Voici la classe qui contient la méthode de Mock:

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

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

Comment puis-je railler la méthode maméthode avec Google Mock?

Answer 1

Dans la version précédente de Google Mock vous ne pouvez fonctions maquette virtuelle, voir le documentation dans la page du projet.

Les versions les plus récentes a permis de maquette méthodes non virtuelles , en utilisant ce qu'ils appellent injection de dépendance salut-perf .

Etats congusbongus:

  

Google Mock repose sur l'ajout de variables membres à l'appui moqueur de la méthode, et puisque vous ne pouvez pas créer des variables membres de modèle, il est impossible de fonctions de modèle simulacres

Une solution de contournement, par Michael Harrington dans le lien des Google Groupes commentaires, est de faire spécialisé les méthodes de modèle qui appelleront une fonction normale qui peut être moqué. Il ne résout pas le cas général, mais cela fonctionnera pour les tests.

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

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

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

Answer 2

Voici le message original à nouveau avec des commentaires pour aider à comprendre:

    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 ); 
        } 
    };