What C++ design pattern is available for swapping behavior of a function template between production code and testing code?

Question

I am refactoring a component to make it more unit testable. A first step is to enable unit testing for some core component code. Unfortunately, this core component code calls some in-component utility functions that directly interact with other components' concrete classes, which are hard to instantiate without the production environment. For the normal utility functions, I can leverage dependency injection to wrap them as virtual functions inside a utility interface and swap in overrides during unit testing. However, there are also utility function templates, which I couldn't apply the same technique, because we can't have virtual function template. Is there a known pattern to handle this?

To give a concrete example, consider the code that follows. Is there a way to switch behavior of the utilIsNameValid function template during unit testing? Some constraints apply:

1. I need to directly isolate the logic in utilIsNameValid from testing its using code. This prevents me from just switching the behavior of utilGetNames with dependency injection, and hope that it would indirectly steer utilIsNameValid the way I want it.
2. I cannot change MyClasss interface because it is a legacy API with wide impact. @Jarod42's answer is near perfect but requires MyClass to become a template, which could lead to callsite adaptation changes.

mycomponent/util/MyUtil.hpp (in-component utility code)

#include <string>
class TheirClassA;
class TheirClassB;

std::string utilGetName(TheirClassA* a); // a normal utility function

std::string utilGetName(TheirClassB* b); // a normal utility function

template<class T>
bool utilIsNameValid(T obj) {            // a utility function template
    auto name = utilGetName(obj);
    // ... perform the generic name checking ...
}

mycomponent/util/MyUtil.cpp (in-component utility code)

#include "MyUtil.hpp"
#include "theircomponent/TheirClassA.hpp"
#include "theircomponent/TheirClassB.hpp"

std::string utilGetName(TheirClassA* a) {
    return std::string{a->getNameInAsWayThatReturnsCharPtr()};
}
std::string utilGetName(TheirClassB* b) {
    return b->getNameInBsWayThatReturnsString();
}

mycomponent/core/MyClass.hpp (core component code)

class TheirClassA;
class TheirClassB;
class MyClass {
    public:
    bool canProcess(TheirClassA* a) const;
    bool canProcess(TheirClassB* b) const;
};

mycomponent/core/MyClass.cpp (core component code)

#include "MyClass.hpp"
#include "mycomponent/util/MyUtil.hpp"
bool MyClass::canProcess(TheirClassA* a) const {
    return utilIsNameValid(a) && /* some other conditions for TheirClassA objects*/;
}
bool MyClass::canProcess(TheirClassB* b) const {
    return utilIsNameValid(b) && /* some other conditions for TheirClassB objects*/;
}

production/main.cpp

#include "mycomponent/core/MyClass.hpp"
#include "theircomponent/TheirClassA.hpp"
#include "theircomponent/TheirClassB.hpp"
int main (){
    // ... tedious steps to set up TheirClassA and TheirClassB objects ...
    MyClass processor;
    if (processor.canProcess(a)) {
        // ... process a ....
    }
    if (processor.canProcess(b)) {
        // ... process b ....
    }
}

mycomponent/unittest/Test.cpp

#include "mycomponent/core/MyClass.hpp"
#include "theircomponent/TheirClassA.hpp"
#include "theircomponent/TheirClassB.hpp"
int main (){
    // ... cannot afford instantiating actual objects ...
    TheirClassA* a = nullptr;
    TheirClassB* b = nullptr;

    // ... need someway for utilIsNameValid to simply return 
    //     true or false to test out the rest of the code in
    //     MyClass::canProcess(...) ...
    MyClass processor;
    if (processor.canProcess(a)) {
        // ... process a ....
    }
    if (processor.canProcess(b)) {
        // ... process b ....
    }
}

Answer 1

You can make your class template, something like:

// myclass.hpp
template <typename Utility>
class MyClassT {
    public:
    bool canProcess(TheirClassA* a) const;
    bool canProcess(TheirClassB* b) const;
};

class UtilityProd; // Class where you have your static methods
using MyClass = MyClassT<UtilityProd>;

// myclass.inl
template <typename Utility>
bool MyClassT::canProcess(TheirClassA* a) const
{
    return Utility::utilIsNameValid(a) && /* some other conditions for TheirClassA objects*/;
}
template <typename Utility>
bool MyClassT::canProcess(TheirClassB* b) const
{
    return Utility::utilIsNameValid(b) && /* some other conditions for TheirClassB objects*/;
}

// myclass.cpp
#include "MyClass.hpp"
#include "MyClass.inl"
#include "UtilityProd.h"


// explicit instantiation to keep separation header/cpp 
template class MyClassT<UtilityProd>;

// test.cpp
#include "MyClass.hpp"
#include "MyClass.inl"
#include "UtilityTest.h"

using MyClassTest = class MyClassT<class UtilityTest>;

int main (){
    // ... cannot afford instantiating actual objects ...
    TheirClassA* a = nullptr;
    TheirClassB* b = nullptr;


    MyClassTest processor;

    UtilityTest::setResult(..); // ...

    if (processor.canProcess(a)) {
        // ... process a ....
    }
    if (processor.canProcess(b)) {
        // ... process b ....
    }
}

production/main.cpp (and all production case) stay unchanged.