Sé que esta es una práctica debatida, pero supongamos que esta es la mejor opción para mí. Me pregunto cuál es la técnica real para hacer esto. El enfoque que veo es este:
1) Haz que una clase de amigo sea la de la clase cuyo método quiero probar.
2) En la clase amigo, cree uno o varios métodos públicos que llamen a los métodos privados de la clase probada.
3) Prueba los métodos públicos de la clase de amigos.
Aquí hay un ejemplo simple para ilustrar los pasos anteriores:
#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;
}Editar:
Veo que en la discusión que sigue a una de las respuestas la gente se pregunta sobre mi código base.
Mi clase tiene métodos que son llamados por otros métodos; ninguno de estos métodos debería llamarse fuera de la clase, por lo que deberían ser privados. Por supuesto, se podrían poner en un método, pero lógicamente están mucho mejor separados. Estos métodos son lo suficientemente complicados como para justificar las pruebas unitarias y, debido a problemas de rendimiento, es muy probable que tenga que volver a factorizar estos métodos, por lo tanto, sería bueno tener una prueba para asegurarme de que mi refactorización no rompa nada. No soy el único que trabaja en el equipo, aunque soy el único que está trabajando en este proyecto, incluidas las pruebas.
Habiendo dicho lo anterior, mi pregunta no era sobre si es una buena práctica escribir pruebas unitarias para métodos privados, aunque agradezco los comentarios.