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) Crea una classe di amica con quella della classe con il metodo che voglio testare.
2) Nella classe friend, crea un metodo pubblico che chiama i metodi privati della classe testata.
3) Prova i metodi pubblici della classe friend.
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;
}
Modifica:
Vedo che nella discussione che segue una delle risposte la gente si interroga sulla mia base di codice.
La mia classe ha metodi che vengono chiamati con altri metodi; nessuno di questi metodi dovrebbe essere chiamato al di fuori della classe, quindi dovrebbero essere privati. Naturalmente potrebbero essere messi in un unico metodo, ma logicamente sono molto meglio separati. Questi metodi sono abbastanza complicati da giustificare il collaudo delle unità e, a causa di problemi di prestazioni, molto probabilmente dovrò ridimensionare questi metodi, quindi sarebbe bello fare un test per assicurarsi che il mio re-factoring non abbia infranto nulla. Non sono l'unico a lavorare nel team, anche se sono l'unico a lavorare su questo progetto, inclusi i test.
Detto questo, la mia domanda non riguardava il fatto che sia una buona pratica scrivere test unitari per metodi privati, anche se apprezzo il feedback.