How to avoid dupilcation of tests if I have an abstract class

Let’s say I’m writing a car class. It should have the methods configEngine and currentGasolineConsumption beside some other methods. So I refactored out the calculation of the gasoline consumption into an Engine class and use polymorphism to get the current gasoline consumption:

class AbstractEngine()
{
    public:
        virtual int calculateGasolineConsumption()
        {
            //... do calculation ...
            return consumption;
        }

        // some other (pure virtual) methodes
};

class EngineA() : public AbstractEngine
{
    public:                              
        // implementation of the pure virtual methodes
};

class EngineB() : public AbstractEngine
{
    public:                              
        // implementation of the pure virtual methodes
};

class EngineC() : public AbstractEngine
{
    public:                              
        // implementation of the pure virtual methodes
        int calculateGasolineConsumption() override 
        {
             //... do new calculation ...
             return consumption;                                 
        }
};
enum EngineType {
    ENGINE_A,
    ENGINE_B,
    ENGINE_C,
};

void configEngine(EngineType engineType)
{
    m_engine = m_engineFactory.create(engineType);
}

int currentGasolineConsumption()
{
    return m_engine.calculateGasolineConsumption();
}

Now my question is how to unittest this without getting duplication in my unit tests?

If I write three unittests, for configEngine(ENGINE_A) and configEngine(ENGINE_B) would test basically the same code of the abstract superclass and I don’t like that duplication.

Of course there is only one duplicate/unnecessary unittest but this is only a minimal example. In my real code the number of unit test duplication would explode.

One additional thing: I don’t want to move the Engine class outside of the ‘module’ and use dependency injection because I think this ‘internal Engine class’ approach is easier to handle for the client. So the client has only one interface and some enums to use this module. I would like to treat the Engine class as implementation detail.