Using PowerMock for Unit Testing in Java: Basics and Advanced Techniques

In a recent work scenario the author faced extremely slow unit tests, sometimes exceeding two and a half hours, causing repeated pipeline runs and even OOM errors.

The article identifies PowerMock as the main cause of the slowdown and proceeds to demonstrate both basic and advanced usage of PowerMock to achieve 100% test coverage for a sample FileParser class.

1. PowerMock Basics

First, a simple business class FileParser is presented, followed by three test cases covering file‑not‑exists, normal loop processing, and exception handling.

public class FileParser {
    private Logger logger = LoggerFactory.getLogger(getClass());
    @Resource
    private UserRepository userRepository;

    public void parseFile(String fileName) {
        File file = new File(fileName);
        if (!file.exists()) {
            return;
        }
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
            String line = null;
            while ((line = bufferedReader.readLine()) != null) {
                User user = userRepository.getUser(line);
                logger.info("user with name{}:{}", line, user);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

Test case for file not existing:

@Test
public void testParseFile_not_exists() throws Exception {
    File file = PowerMockito.mock(File.class);
    PowerMockito.whenNew(File.class).withAnyArguments().thenReturn(file);
    when(file.exists()).thenReturn(false);
    fileParser.parseFile("123");
    Mockito.verify(userRepository, Mockito.times(0)).getUser(anyString());
}

Test case for normal loop processing:

@Test
public void testParseFile_exists() throws Exception {
    File file = PowerMockito.mock(File.class);
    PowerMockito.whenNew(File.class).withAnyArguments().thenReturn(file);
    when(file.exists()).thenReturn(true);

    FileInputStream fileInputStream = PowerMockito.mock(FileInputStream.class);
    PowerMockito.whenNew(FileInputStream.class).withAnyArguments().thenReturn(fileInputStream);

    InputStreamReader inputStreamReader = PowerMockito.mock(InputStreamReader.class);
    PowerMockito.whenNew(InputStreamReader.class).withAnyArguments().thenReturn(inputStreamReader);

    BufferedReader bufferedReader = PowerMockito.mock(BufferedReader.class);
    PowerMockito.whenNew(BufferedReader.class).withAnyArguments().thenReturn(bufferedReader);

    // simulate loop and exit
    when(bufferedReader.readLine()).thenReturn("testUser").thenReturn("user").thenReturn(null);
    User user = PowerMockito.mock(User.class);
    when(userRepository.getUser(anyString())).thenReturn(user);

    fileParser.parseFile("123");

    Mockito.verify(userRepository, Mockito.times(1)).getUser(anyString());
}

Test case for exception handling:

@Test(expected = RuntimeException.class)
public void testParseFile_exception() throws Exception {
    File file = PowerMockito.mock(File.class);
    PowerMockito.whenNew(File.class).withAnyArguments().thenReturn(file);
    when(file.exists()).thenReturn(true);

    FileInputStream fileInputStream = PowerMockito.mock(FileInputStream.class);
    PowerMockito.whenNew(FileInputStream.class).withAnyArguments().thenReturn(fileInputStream);

    InputStreamReader inputStreamReader = PowerMockito.mock(InputStreamReader.class);
    PowerMockito.whenNew(InputStreamReader.class).withAnyArguments().thenReturn(inputStreamReader);

    BufferedReader bufferedReader = PowerMockito.mock(BufferedReader.class);
    PowerMockito.whenNew(BufferedReader.class).withAnyArguments().thenReturn(bufferedReader);

    // simulate exception
    when(bufferedReader.readLine()).thenThrow(new IOException());

    fileParser.parseFile("123");
}

2. PowerMock Advanced

Additional examples show how to mock final classes such as Scanner and static classes like StringUtils .

Mocking a final Scanner class:

@Test
public void testParseFile_scanner() throws Exception {
    File file = PowerMockito.mock(File.class);
    PowerMockito.whenNew(File.class).withAnyArguments().thenReturn(file);
    when(file.exists()).thenReturn(true);

    Scanner scanner = PowerMockito.mock(Scanner.class);
    PowerMockito.whenNew(Scanner.class).withAnyArguments().thenReturn(scanner);

    // simulate loop
    when(scanner.hasNextLine()).thenReturn(true).thenReturn(true).thenReturn(false);
    when(scanner.nextLine()).thenReturn("testUser").thenReturn("user");

    User user = PowerMockito.mock(User.class);
    when(userRepository.getUser(anyString())).thenReturn(user);

    fileParser.parseFileWithScanner("123");

    Mockito.verify(userRepository, Mockito.times(1)).getUser(anyString());
}

Mocking a static StringUtils class requires @PrepareForTest and mockStatic :

@Test
public void testParseFile_StringUtils() throws Exception {
    File file = PowerMockito.mock(File.class);
    PowerMockito.whenNew(File.class).withAnyArguments().thenReturn(file);
    when(file.exists()).thenReturn(true);

    Scanner scanner = PowerMockito.mock(Scanner.class);
    PowerMockito.whenNew(Scanner.class).withAnyArguments().thenReturn(scanner);

    // simulate loop
    when(scanner.hasNextLine()).thenReturn(true).thenReturn(true).thenReturn(false);
    when(scanner.nextLine()).thenReturn("testUser").thenReturn("user");
    when(StringUtils.equals(anyString(), anyString())).thenReturn(false).thenReturn(false);
    User user = PowerMockito.mock(User.class);
    when(userRepository.getUser(anyString())).thenReturn(user);

    fileParser.parseFileWithScanner("123");

    Mockito.verify(userRepository, Mockito.times(0)).getUser(anyString());
}

The test class setup includes the necessary PowerMockRunner and @PrepareForTest annotations:

@RunWith(PowerMockRunner.class)
@PrepareForTest({FileParser.class, StringUtils.class})
public class FileParserTest {
    @Before
    public void before() {
        PowerMockito.mockStatic(StringUtils.class);
    }
    // ... test methods ...
}

3. Analysis

PowerMock uses annotations such as @PrepareForTest , @PowerMockIgnore and @SuppressStaticInitializationFor . These cause each test class to be loaded with a separate class loader, which dramatically increases class‑loading time. When the number of test classes grows (e.g., >600), the overhead becomes noticeable.

Removing PowerMock would require extensive refactoring, making it a difficult optimization target.

4. Conclusion

While PowerMock is convenient for writing unit tests, it is not suitable for large codebases that demand high test coverage because it significantly prolongs test execution time and consumes more memory.