Bonjour!

Je suis nouvelle sur gtest/gmock et essaye de tester une fonction simple en c++ qui a 2 pointeurs : m_propBsh_p et m_eBsh_p.
Ces pointers deviennent valident après des factory-creations, mais je ne souhaite pas impliquer des complexités factory classes et callbacks.

Voici la fonction pour laquelle je souhaite écrire un test :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
std::string Foo::toString(const std::string &indent) const
    {
    ....
 
    std::string str =
      (m_propBsh_p != nullptr) ? m_propBsh_p -> toString("P-BSH: ") : "-";
    str +=
      (m_eBsh_p != nullptr) ? m_eBsh_p -> toString("E-BSH: ") : "-";
 
    return str;
  }
Je suis juste interessée pour tester cette fonction toString.
C'est pourquoi je souhaite avoir des pointeurs valides pour m_propBsh_p et m_eBsh_p.
Cela ressemblerait à ça :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//Assuming to have mocked class for pointers
  std::shared_ptr<MockedBshClass> m_mockEBsh_p;
  std::shared_ptr<MockedBshClass> m_mockPropBsh_p;
 
  TEST_F(FooTest, toStringBshInfoPass)
  {
    std::string eBshAndpBshStr = "eBshAndpBshStr";
 
    ON_CALL(*m_mockPropBsh_p, toString(_)).WillByDefault(Return(eBshAndpBshStr));
    ON_CALL(*m_mockEBsh_p, toString(_)).WillByDefault(Return(eBshAndpBshStr ));
    //EXPECT_CALL((*m_mockPropBsh_p), toString(_)).Times(1);
    //EXPECT_CALL((*m_mockEBsh_p), toString(_)).Times(1);
 
    //Call mock or some fake function which makes m_propBsh_p & m_eBsh_p valid.
    foo->makePtrValidAgain(); //cependant c'est une fonction complexe qui apporte plus de rappels et complexités, je souhaite à la place avoir des fonctions fake/mocked me donnant juste les pointers valides.
 
    EXPECT_THAT(foo->toString(""),HasSubstr(eBshAndpBshStr+eBshAndpBshStr));
  }

Ci-dessous est le background de Foo class et pointeurs:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 Class Foo : fooParent..
   {
   ...
    void makePtrValidAgain();
    std::string toString();
    ..
    typedef std::shared_ptr<BshClass> m_propBsh_p;
    typedef std::shared_ptr<BshClass> m_eBsh_p; 
   ...
   }; 
 
   void Foo::makePtrValidAgain()
   {
   ...
   auto someFactory = m_dependencyContainer->get<bssh::SomeFactory>();
   assert(someFactory);
 
   auto nextTask = [this](std::uint32_t dummy){runAfterFoo();};
 
   m_propBsh_p = someFactory->create(callback, nextTask);
   m_propBsh_p->execute();
   ...
   //and same happens with m_eBsh_p
 
   return;       
   }
Je ne suis pas sure quel est le meilleur moyen pour éviter de la complexité pour faire un test d'une simple fonction comme celle-ci, en utilisant gmock/gtest.
Le but est d'avoir de pointeurs valides comme mentionné ci-dessus.

Merci par avance pour votre aide qui me serait grandement utile!!