GMock: EXPECT_CALL pas appelé comme prévu pour le fichier *

Question

Je tentais cet exemple et la except_call ne répond pas comme il est ci-dessous, mais la même chose fonctionne si je ne donne pas de paramètre comme cela -

EXPECT_CALL(fio, Open(_, _)) 
    .WillOnce(Return(test_file)); 
EXPECT_CALL(fio, Write(_, _, _, test_file)) 
    .WillOnce(Return(sizeof(data))); 
EXPECT_CALL(fio, Close(test_file)) 
    .WillOnce(Return(0)); 

Toute aide appréciée, merci !! J'ai posté le "message d'erreur que je reçois ci-dessous"

Voici l'intégralité du code.

//Interface 

#include <cstdio> 
#include <cstddef> 


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

    virtual FILE* Open(const char* filename, const char* mode) = 0; 
    virtual size_t Write(const void* data, size_t size, size_t num, FILE* file) = 0; 
    virtual int Close(FILE* file) = 0; 
}; 


//Implementation 
#include <cstdio> 

#include "IFileInputOutput.h" 

class ImplFileInputOutput : public IFileInputOutput { 
public: 

    ImplFileInputOutput() {} 

    virtual ~ImplFileInputOutput() {} 

    virtual FILE* Open(const char* filename, const char* mode) { 
     return fopen(filename, mode); 
    } 

    virtual size_t Write(const void* data, size_t size, size_t num, FILE* file) { 
     return fwrite(data, size, num, file); 
    } 


    virtual int Close(FILE* file) { 
     return fclose(file); 
    } 
}; 

//class under test Writer.h 

#include "IFileInputOutput.h" 


class Writer { 
public: 
    Writer(IFileInputOutput &objfile); 
    virtual ~Writer(); 
    bool WriteBlog(const char* filename, const void* data, size_t size); 
    //void WriteNovel(); 

private: 
    IFileInputOutput &objFileInputOutput; 
}; 

//Writer.cpp 
#include "Writer.h" 



Writer::Writer(IFileInputOutput &objfile):objFileInputOutput(objfile) { } 

Writer::~Writer() { } 

// Writes a file, returns true on success. 
bool Writer::WriteBlog(const char* filename, const void* data, size_t size) { 


    FILE* file = objFileInputOutput.Open(filename, "w+"); 

    if (!file) { 
    return false; 
    } 

    if (objFileInputOutput.Write(data, 1, size, file) != size) { 
    return false; 
    } 

    if (objFileInputOutput.Close(file) != 0) { 
    //if (obj.Close(file) != 0) { 
    return false; 
    } 

    return true; 
} 

//Mock class 
#include <cstddef> 
#include <cstdio> 

#include <gmock/gmock.h> 

#include "IFileInputOutput.h" 

class FileInputOutputMock : public IFileInputOutput { 

public: 

    MOCK_METHOD2(Open, FILE*(const char * filename, const char* mode)); 
    MOCK_METHOD4(Write, size_t(const void* data, size_t size, size_t num, FILE* file)); 
    MOCK_METHOD1(Close, int(FILE* file)); 

}; 


//Tests 



class FileInputOutputTest : public ::testing::Test 
{ 
public: 
    void SetUp(){}; 
    void TearDown(){}; 

    FileInputOutputTest(){}; 
    virtual ~FileInputOutputTest(){}; 


}; 


TEST_F(FileInputOutputTest, SuccessWorks) { 

    FileInputOutputMock fio; 
    Writer _objWriter(fio); 

    static char data[] = "hello"; 
    const char* kName = "test.txt"; 

    FILE* test_file; 

    EXPECT_CALL(fio, Open(kName, "w+")) 
     .WillOnce(Return(test_file)); 
    EXPECT_CALL(fio, Write(&data, 1, sizeof(data), test_file)) 
     .WillOnce(Return(sizeof(data))); 
    EXPECT_CALL(fio, Close(test_file)) 
     .WillOnce(Return(0)); 


    bool ret = _objWriter.WriteBlog(kName, &data, sizeof(data)); 

    EXPECT_EQ(true, ret); 
} 


Error 

* [----------] 1 test from FileInputOutputTest 
[ RUN  ] FileInputOutputTest.SuccessWorks 
unknown file: Failure 

Unexpected mock function call - returning default value. 
    Function call: Open(0x47a829 pointing to "test.txt", 0x47ec23 pointing to "w+") 
      Returns: NULL 
Google Mock tried the following 1 expectation, but it didn't match: 

../test/Unit/FileInputOutputTest.cpp:58: EXPECT_CALL(fio, Open(kName, "w+"))... 
    Expected arg #1: is equal to 0x47a832 pointing to "w+" 
      Actual: 0x47ec23 pointing to "w+" 
     Expected: to be called once 
      Actual: never called - unsatisfied and active 
../test/Unit/FileInputOutputTest.cpp:77: Failure 
Value of: ret 
    Actual: false 
Expected: true 
../test/Unit/FileInputOutputTest.cpp:62: Failure 
Actual function call count doesn't match EXPECT_CALL(fio, Close(test_file))... 
     Expected: to be called once 
      Actual: never called - unsatisfied and active 
../test/Unit/FileInputOutputTest.cpp:60: Failure 
Actual function call count doesn't match EXPECT_CALL(fio, Write(&data, 1, sizeof(data), test_file))... 
     Expected: to be called once 
      Actual: never called - unsatisfied and active 
../test/Unit/FileInputOutputTest.cpp:58: Failure 
Actual function call count doesn't match EXPECT_CALL(fio, Open(kName, "w+"))... 
     Expected: to be called once 
      Actual: never called - unsatisfied and active 
[ FAILED ] FileInputOutputTest.SuccessWorks (1 ms) 

Answer 1

La raison de cette erreur est que les arguments pour la fonction Open sont de type char *, donc quand vous spécifiez des arguments à être adaptés, vous demandez en fait une mise en correspondance de pointeurs. Depuis vous avez créé le premier argument demandé kName à l'intérieur du corps du test et passez le à la fonction, ce pointeur correspond correctement (notez que, bien que cette vérification réussisse, ce n'est pas une façon correcte de faire correspondre les littéraux de chaîne). Cependant, lors de l'appariement du deuxième argument, vous devez correspondre effectivement aux adresses du premier élément d'une chaîne littérale définie dans le corps du test et une autre qui est définie à l'intérieur de la fonction. Bien qu'ils pointent vers la même chaîne littérale, ce sont deux adresses distinctes et c'est pourquoi la correspondance échoue.

Pour correspondre correctement au littéral de chaîne, utilisez StrEq matcher de gmock. Voici comment faire:

EXPECT_CALL(fio, Open(StrEq(kName), StrEq("w+"))) 
    .WillOnce(Return(test_file));