Design pattern name for thin wrapper for unit testing purpose

Question

Assuming I'm using a class from third party library that does not implement an interface, for example:

class ThirdPartyLibClass {
    void DoThis() { ... }
    void DoThat() { ... }
}

I want to create a very thin wrapper around it, directly reflecting class' interface and delegating to the ThirdPartyLibClass. The purpose of this is to stub ThirdPartyLibClass in my unit tests. Example:

interface IThirdPartyLibClass {
    void DoThis();
    void DoThat();
}

class DefaultImplementation : IThirdPartyLibClass {
    private ThirdPartyLibClass realImplementation = new ThirdPartyLibClass ();

    void DoThis() {
        realImplementation.DoThis();
    }

    void DoThat() {
        realImplementation.DoThat();
    }      
}

Is there a name for this pattern? Wrapper or Adapter seem to differ slightly, and I don't intend to ever swap the implementation in production code, so the interface is exactly the same as that of ThirdPartyLibClass. Also, how would I call the DefaultImplementation to make the pattern usage clear to the reader?

Thanks in advance.

Answer 1

Creating a wrapper interface and having the default implementation just call into a wrapper type is an example of the delegation pattern.

Answer 2

It's a wrapper, that is all. There is no software problem here that is being solved, so there is no design pattern here. The problem being solved is the bureaucratic problem that testable classes should have an interface and should be accessed through an interface, this one doesn't have an interface and cannot be modified, so you write a wrapper. No pattern.