So che questa è una pratica dibattuta, ma supponiamo che questa sia l'opzione migliore per me. Mi chiedo quale sia la tecnica effettiva per farlo. L'approccio che vedo è questo:
1) Fai una classe di amici quella della classe che è il metodo che voglio testare.
2) Nella classe friend, crea un metodo pubblico che chiama i metodi privati della classe testata.
3) Testare i metodi pubblici della classe di amici.
Ecco un semplice esempio per illustrare i passaggi precedenti:
#include <iostream>
class MyClass
{
friend class MyFriend; // Step 1
private:
int plus_two(int a)
{
return a + 2;
}
};
class MyFriend
{
public:
MyFriend(MyClass *mc_ptr_1)
{
MyClass *mc_ptr = mc_ptr_1;
}
int plus_two(int a) // Step 2
{
return mc_ptr->plus_two(a);
}
private:
MyClass *mc_ptr;
};
int main()
{
MyClass mc;
MyFriend mf(&mc);
if (mf.plus_two(3) == 5) // Step 3
{
std::cout << "Passed" << std::endl;
}
else
{
std::cout << "Failed " << std::endl;
}
return 0;
}
Modificare:
Vedo che nella discussione che segue una delle risposte le persone si chiedono quale sia la mia base di codice.
La mia classe ha metodi che sono chiamati da altri metodi; nessuno di questi metodi dovrebbe essere chiamato al di fuori della classe, quindi dovrebbe essere privato. Ovviamente potrebbero essere inseriti in un metodo, ma logicamente sono molto meglio separati. Questi metodi sono abbastanza complicati da giustificare i test unitari e, a causa di problemi di prestazioni, molto probabilmente dovrò ripensare questi metodi, quindi sarebbe bello fare un test per assicurarsi che il mio re-factoring non abbia rotto nulla. Non sono l'unico a lavorare nel team, anche se sono l'unico a lavorare a questo progetto, inclusi i test.
Detto questo, la mia domanda non riguardava se sia una buona pratica scrivere test unitari per metodi privati, anche se apprezzo il feedback.