Create a common abstract base test class for the test.

abstract class BaseTest{

 @Test
 public void featureX(){
    Type t = createInstance();
    // do something with t
 }

 abstract Type createInstance();
}

ConcreteTest extends BaseTest{

    Type createInstace(){
        return //instantiate concrete type here.
    }
}

I d reuse the code either with inheritance or aggregation.

To have the shortest code, I d move a tested instance creation to a factory method in, say, XmlImplementationTest class, and inherit a TextImplementationTest from it:

XmlImplementationTest extends TestCase
{
  Interface tested = null
  Interface createTested() { return new XmlImplementation() }
  ...
  void setUp() { tested = createTested(); }
}

TextImplementationTest extends XmlImplementationTest
{
  override Interface createTested() { return new TextImplementation() }
}

This is not completely correct OO design, as it s TextImplementationTest is NOT a XmlImplementationTest. But usually you don t need to care about it.

Or readdress the test method calls to some common utility class. This would involve more code and not show proper test class in test reports, but might be easier to debug.

I tend to avoid any relations between test classes. I like to keep testcases (or classes) as atomic as possible. The benefit of using inheritance here doesn t outweight the strong coupling you get by it.

I guess it would be helpful, if you could share the validation of the result of the two classes (Assuming blackbox tests). If both classes are able to let you set an outputstream, you might validate that, while the classes itself write to PrintWriter or FileWriter (or whatever you need in your cases).

Furthermore I would avoid to create files during unit-tests, because it might take too much time (+ it might not work on the build machine) and therefore delay your build.

In C#, I d use a generic helper method to test both cases, something like:

internal static void SerializationTestHelper<T>() where T : IMySerialize
{
    T serialize = new T();
    // do some testing
}

[TestMethod]
public void XmlTest()
{
    SerializationTestHelper<XmlSerialize>();
}

[TestMethod]
public void PlainTextTest()
{
    SerializationTestHelper<PlainTextSerialize>();
}