Costruttori delegati di derisione

Sono nuovo nel test delle unità in C ++. Devo scrivere un test unitario per il mio codice e sto utilizzando Google Mock per lo stesso. Ho attraversato il loro esempio di tartaruga. Ma sono ancora confuso su come deridere un costruttore delegato.

Mi è stato chiesto di utilizzare un costruttore delegato da un anziano che mi consigliava di utilizzare un costruttore delegato in modo che l'unità test lo chiamasse per evitare di creare oggetti e di iniettare mock.

Attualmente il codice principale ha un aspetto simile a questo

BaseClass::BaseClass(SomeClassA* obj_a)
  : BaseClass(obj_a, MakeUnique<SomeClassB>()) {
}


BaseClass::BaseClass(SomeClassA* obj_a,std::unique_ptr<SomeClassB> obj_b)
  : a_obj(CHECK_IFNULL(obj_a)),
    b_obj(std::move(obj_b)) {
}

CHECK_IFNULL è una macro utilizzata per verificare la presenza di un puntatore nullo.

Ora nel test dell'unità dovrei prendere in giro il costruttore delegato in modo che non crei oggetti per SomeClassA e B e invece lo deride.

Dopo aver letto il tutorial su tartaruga, ho provato questo:

class BaseClass_Mock : public BaseClass {
  BaseClass_Mock(
      SomeClassA* obj_a,
      std::unique_ptr<SomeClassB> obj_b)
      : BaseClass(a_obj_mock, b_obj_mock) {

      }


    MOCK_METHOD2(Somefunction,
                 string(const string& name,
                        const string& type)); 
};

Dopo aver provato a compilare questo codice, ho ricevuto un errore che diceva che a_obj_mock e b_obj_mock non sono definiti.

Ora se li definisco come - per esempio:

SomeClassA *a_obj_mock and
SomeClassB *b_obj_mock

quindi sto creando un nuovo oggetto giusto? Ciò vanificherebbe lo scopo di utilizzare un costruttore delegato in primo luogo. Quindi, come faccio a prendere in giro gli oggetti di SomeClassA e SomeClassB in modo da poter eseguire il test delle unità per le funzioni di BaseClass senza creare nuovi oggetti.