JMockit: Overriding @Mocked class

Question

I have an internal StreamGobbler class that has 7 methods in it. I'm looking for a quick way to mock all the methods by default, but override one method named getOutput() (e.g. Partial Mocking).

(full code not shown for clarity)

public class StreamGobbler extends Thread
{
    public String getOutput() 
    public void run()
}

What I would like is to use something like the @Mocked annotation in combination with MockUp to partially mock the getOutput method, but retain all the "default" mocking code on all the other methods. In the docs on partial mocking, it makes the point that if you use MockUp, all non @Mock methods retain their normal functionality. Sometimes that is great, but that isn't what I want in this case.

This is similar to the question JMockit: @Mocke and MockUp combination in the same test, but I can't get away with just looking at method counts.

If I have a test setup like this:

@Test
public void execute(@Mocked StreamGobbler sg)
{
    new MockUp<StreamGobbler>()
    {
        String type = null;

        @Mock
        void $init(String type)
        {
            this.type = type;
        }

        @Mock
        String getOutput()
        {
            if ("OUTPUT".equals(type))
            {
                return "test output";
            }
            else 
            {
                return "";
            }
        }
     }
 }

I get this error java.lang.IllegalArgumentException: Class already mocked

If I try to add the @Override annotation in the MockUp, it doesn't help (and Eclipse complains about it)

What is the best way to handle this? Use a static class outside this test method?

Using JMockit 1.17, and TestNG

In summary, how do I get every method in StreamGobbler mocked (as with @Mocked), but partially override one method (without manually doing it myself inside the MockUp?)

Answer 1

Full example code which meets the given constraints:

public static class StreamGobbler extends Thread {
    public StreamGobbler(String type) {}
    public String getOutput() { return null; }
    @Override public void run() {}
}

public static class TestedClass {
    public String doSomething() throws InterruptedException {
        StreamGobbler sg1 = new StreamGobbler("OUTPUT");
        sg1.start();

        StreamGobbler sg2 = new StreamGobbler("ERROR");
        sg2.start();

        sg1.join(5000);
        sg2.join(5000);

        String output1 = sg1.getOutput();
        String output2 = sg2.getOutput();
        return output1 + '|' + output2;
    }
}

@Test
public void useStreamGobbler(@Mocked StreamGobbler sg) throws Exception {
    new Expectations() {{
        new StreamGobbler("OUTPUT").getOutput(); result = "test output";
        new StreamGobbler("ERROR").getOutput(); result = "";
    }};

    String output = new TestedClass().doSomething();

    assertEquals("test output|", output);
}