I know that this is a debated practice, but let's suppose that this is the best option for me. I am wondering about what is the actual technique to do this. The approach that I see is this:1) Make a friend class that of the class who's method I want to test.2) In the friend class, create a public method(s) that call the private method(s) of the tested class.3) Test the public methods of the friend class.Here is a simple example to illustrate the above steps:#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;}Edit:I see that in the discussion following one of the answers people are wondering about my code base. My class has methods that are called by other methods; none of these methods should be called outside the class, so they should be private. Of course they could be put into one method, but logically they are much better separate. These methods are complicated enough to warrant unit testing, and due to performance issues I will very likely have to re-factor these methods, hence it would be nice to have a test to make sure that my re-factoring didn't break anything. I am not the only one working on the team, though I am the only one who is working on this project including the tests. Having said the above, my question was not about whether it is a good practice to write unit tests for private methods, though I appreciate the feedback.
Unit test private method in c++ using a friend class
c++;unit testing;class;c++11
An alternative to friend (well, in a sense) that I use frequently is a pattern that I've come to know as access_by. It's pretty simple:class A {  void priv_method(){}; public:  template <class T> struct access_by;  template <class T> friend struct access_by;}Now, suppose class B is involved in testing A. You can write this:template <> struct access_by<B> {  call_priv_method(A & a) {a.priv_method();}}You can then use this specialization of access_by to call private methods of A. Basically, what this does is put the onus of declaring friendship into the header file of the class that wants to call A's private methods. It also lets you add friends to A without changing A's source. Idiomatically, it also indicates to whoever reads the source of A that A does not indicate B a true friend in the sense of extending its interface. Rather, the interface of A is complete as given and B needs special access into A (testing being a good example, I've also used this pattern when implementing boost python bindings, sometimes a function that needs to be private in C++ is handy to expose into the python layer for the implementation).