Sei que essa é uma prática debatida, mas vamos supor que essa seja a melhor opção para mim. Eu estou pensando sobre qual é a técnica real para fazer isso. A abordagem que vejo é a seguinte:
1) Faça a classe de um amigo a classe que é o método que eu quero testar.
2) Na classe friend, crie um método público que chame o método privado da classe testada.
3) Teste os métodos públicos da classe de amigos.
Aqui está um exemplo simples para ilustrar as etapas acima:
#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:
Vejo que, na discussão a seguir, uma das respostas que as pessoas estão se perguntando sobre minha base de código.
Minha classe possui métodos chamados por outros métodos; nenhum desses métodos deve ser chamado fora da classe, portanto deve ser privado. É claro que eles poderiam ser colocados em um método, mas logicamente eles são muito melhores separados. Esses métodos são complicados o suficiente para justificar o teste de unidade e, devido a problemas de desempenho, provavelmente terei que refazer esses métodos; portanto, seria bom fazer um teste para garantir que minha re-fatoração não quebrasse nada. Não sou o único que trabalha na equipe, embora seja o único que está trabalhando neste projeto, incluindo os testes.
Dito isso, minha pergunta não era sobre se é uma boa prática escrever testes de unidade para métodos privados, embora eu aprecie o feedback.