如何模拟采用已经定义的lambda函数并覆盖lambda函数的函数

最终找到解决方案并将其发布以供参考；

我的解决方案是找到一种方法来在容器中存储我感兴趣的回调方法，为此创建辅助方法并从该向量中获取一些输出。

1. 在包含MOCK_METHODX（）声明的类内部，我首先使用typedef来更轻松地标识我的函数。
2. 然后，在私有块中声明向量和一个void指针，这些指针将用于传递函数。
3. 辅助方法，以在向量的x位置获取内容（在某些情况下，我会在测试中多次运行模拟函数，因此希望了解每个调用的执行方式），添加到向量中，清除内容（为其他测试重置）等等。

4. 类型为MockedFunctions的静态指针，用于在提取所需数据后提供一个对象以“恢复”正常的模拟控件行为。

   //inside my header file.
   #include <gmock/gmock.h>
   #include <vector>
   
   class MockedFunctions {
       public:
          //lets say function L has params (int, void*)
          typedef int (myCb) (int arg_from_cb_L, void* objptr_from_cb_L));
          MockedFunctions(){}
          virtual ~MockedFunctions(){}
   
          //giving C more arguments than just the callback L
          MOCK_METHOD2(C, int(int arg1, int(*L)(int, void*));
       private:
          //note due to namespace limitations, I'm including the std prefix
          std::vector<myCb> callback_storage;
          void *cb_obj_copy;
       public:
          /* Multiple public blocks just for readability purposes.
           * Note the internal usage of vector methods.
           */
          void cb_clear(){
              if(callback_storage.empty())
              {
                  callback_storage.clear();
              }
          }
          void cb_add(myCb callback){
              callback_storage.push_back(callback);
          }
          myCb* cb_result_at(int i){
              return callback_storage.at(i);
          }
          //to store one of the params from the passed callback
          void cb_copy_obj(void* obj){
              cb_obj_cb = obj;
          }
          void cb_get_obj_copy(){
              return cb_obj_copy;
          }
      };
   
      class TestMethods : public ::testing::Test
         {
         public:
             static std::unique_ptr<MockedMethods> testMockedMethods;
             TestMethods(){
                 /* as we call other methods from MockedMethods apart from C,
                  * it would trigger warnings. Using NiceMock hides them for
                  * cleaner output.
                  */
                 testMockedMethods.reset(new ::testing::NiceMock<MockedMethods>());
             }
             ~TestMethods() override{
                 testMockedMethods.reset();
             }
             virtual void SetUp() override {}
             virtual void TearDown() override {}
         };
   

现在，在我的cpp文件中，我定义了C并实例化了指针。

              std::unique_ptr<MockedMethods> TestObject::testMockedMethods(new MockedMethods() );
              int C ( int arg1, int(*L)(int arg1_cb, void* arg2_cb)){
                  TestMethods::testMockedMethods->cb_add(L);
                  TestMethods::testMockedMethods->cb_copy_obj(arg2_cb);
                  /* to avoid complications, took L's return type of int and put a 0
                   * directly, we don't care at this point since we will overload the
                   * method afterwards.
                   */
                  return TestMethods::testMockedMethods->C(arg1, 0);
              }

至于实际测试，请放置在您认为合适的位置：

       class TestCaseClass : public TestMethods
       {
           public:
               TestCaseClass(){}
               ~TestCaseClass(){}
           protected:
               //Here, object is the struct name mentioned previously in the question.
               Object *instance;
               // ...

               virtual void SetUp()
               {
                   instance = new Object();
                   // ...
               }
               virtual void TearDown()
               {
                  delete instance;
               }
       };

       TEST_F(TestCaseClass, test_M)
       {
           // testing method M from struct Object

           /* Run tests normally on C, results will be stored. By our definition, a different object
            * will be the one calling C, so pay attention to it.
            */
           EXPECT_CALL(*testMockedMethods, C(_, _))
               .Times(1)
               .WillOnce(Return(1))
           // I noticed at this point M above did not return anything, suppose it returns store
           EXPECT_EQ(instance->M(), 1);

           // Now to get coverage or data from our callback. First, get the method in cb_obj
           MockedMethods::myObj* cb_method = testMockedMethods->cb_result_at(0);
           // Now get one of its arguments, like that void*. Note we're using our get-ers
           void* mock_object = testMockedMethods->cb_get_obj_copy();
           /* And finally, call our method, finally getting coverage. You can pass 
            * various parameters for branching.
            */
           cb_method(0, mock_object);

           // Don't forget we clear the vector of contents in case we re-use it in another test.
           testMockedMethods->cb_clear();
       }

尽管不是最直接的解决方案，但事实证明它是有效的，我尝试列出一些在创建测试时可能遇到的用例。

祝您编码愉快！