PowerMockMockito test runs under Junit but not under TestNG

Am trying to run this baseline unit test from Powermock. Running the code As-Is off of that link, with both Mockito and Junit and it runs without error. Unfortunately, I need Mockito and TestNG and that gives me errors on 6 out of the 10 tests: ``` Mockito cannot mock this class: class replica.java.util.UUID$$PowerMock5 Mockito can only mock visible & non-final classes. ``` Sorry this is a long code post, but I wanted to be complete. The first test passes, the second, 5th, 6th, 7th, 9th and 10th all fail. Can this be made to work under TestNG? EDIT - add version numbers These results occur with Mockito V1.9.0, Powermock V1.4.12, and TestNG v6.8 (all running under Java 1.7) Here is the code with my minor modifications: ``` /* * Copyright 2008 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import static org.mockito.BDDMockito.given; import static org.mockito.Matchers.anyLong; import static org.mockito.Mockito.times; import static org.powermock.api.mockito.PowerMockito.doNothing; import static org.powermock.api.mockito.PowerMockito.mock; import static org.powermock.api.mockito.PowerMockito.mockStatic; import static org.powermock.api.mockito.PowerMockito.spy; import static org.powermock.api.mockito.PowerMockito.verifyStatic; import static org.powermock.api.mockito.PowerMockito.when; import java.net.URL; import java.net.URLConnection; import java.net.URLEncoder; import java.util.Collections; import java.util.LinkedList; import java.util.List; import java.util.UUID; import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.testng.PowerMockObjectFactory; import org.testng.Assert; import org.testng.IObjectFactory; import org.testng.annotations.ObjectFactory; import org.testng.annotations.Test; /** * Demonstrates PowerMockito's ability to mock non-final and final system * classes. To mock a system class you need to prepare the calling class for * testing. I.e. let's say you're testing class A which interacts with * URLEncoder then you would do: * * <pre> * * &#064;PrepareForTest({A.class}) * * </pre> */ // @RunWith(PowerMockRunner.class) @PrepareForTest({ SystemClassUser.class }) public class SystemClassUserTest { @ObjectFactory public IObjectFactory getObjectFactory() { return new PowerMockObjectFactory(); } @Test public void assertThatMockingOfNonFinalSystemClassesWorks() throws Exception { mockStatic(URLEncoder.class); when(URLEncoder.encode("string", "enc")).thenReturn("something"); Assert.assertEquals("something", new SystemClassUser().performEncode()); } @Test public void assertThatMockingOfTheRuntimeSystemClassWorks() throws Exception { mockStatic(Runtime.class); Runtime runtimeMock = mock(Runtime.class); Process processMock = mock(Process.class); when(Runtime.getRuntime()).thenReturn(runtimeMock); when(runtimeMock.exec("command")).thenReturn(processMock); Assert.assertSame(processMock, new SystemClassUser().executeCommand()); } @Test public void assertThatMockingOfFinalSystemClassesWorks() throws Exception { mockStatic(System.class); when(System.getProperty("property")).thenReturn("my property"); Assert.assertEquals("my property", new SystemClassUser().getSystemProperty()); } @Test public void assertThatPartialMockingOfFinalSystemClassesWorks() throws Exception { spy(System.class); when(System.nanoTime()).thenReturn(2L); new SystemClassUser().doMoreComplicatedStuff(); Assert.assertEquals("2", System.getProperty("nanoTime")); } @Test public void assertThatMockingOfCollectionsWork() throws Exception { List<?> list = new LinkedList<Object>(); mockStatic(Collections.class); Collections.shuffle(list); new SystemClassUser().shuffleCollection(list); verifyStatic(times(2)); Collections.shuffle(list); } @Test public void assertThatPartialMockingOfFinalSystemClassesWorksForNonVoidMethods() throws Exception { spy(System.class); when(System.getProperty("property")).thenReturn("my property"); final SystemClassUser systemClassUser = new SystemClassUser(); systemClassUser.copyProperty("to", "property"); } @Test public void assertThatMockingStringWorks() throws Exception { mockStatic(String.class); final String string = "string"; final String args = "args"; final String returnValue = "returnValue"; when(String.format(string, args)).thenReturn(returnValue); final SystemClassUser systemClassUser = new SystemClassUser(); Assert.assertEquals(systemClassUser.format(string, args), returnValue); } @Test public void mockingStaticVoidMethodWorks() throws Exception { mockStatic(Thread.class); doNothing().when(Thread.class); Thread.sleep(anyLong()); long startTime = System.currentTimeMillis(); final SystemClassUser systemClassUser = new SystemClassUser(); systemClassUser.threadSleep(); long endTime = System.currentTimeMillis(); Assert.assertTrue(endTime - startTime < 5000); } @Test public void mockingURLWorks() throws Exception { URL url = mock(URL.class); URLConnection urlConnectionMock = mock(URLConnection.class); when(url.openConnection()).thenReturn(urlConnectionMock); URLConnection openConnection = url.openConnection(); Assert.assertSame(openConnection, urlConnectionMock); } @Test public void mockingUUIDWorks() throws Exception { // given final UUID mock = mock(UUID.class); mockStatic(UUID.class); given(UUID.randomUUID()).willReturn(mock); // when String actual = new SystemClassUser().generatePerishableToken(); // then Assert.assertEquals("00000000000000000000000000000000", actual); } } ``` If it helps out, here is a stripped down version that executes one of the failing tests: [I wasn't sure if I should have edited the question, I'm sorry if that is what I should have done, but where it was already too long, this approach seemed to make a bit more sense.] ``` import static org.powermock.api.mockito.PowerMockito.mockStatic; import static org.powermock.api.mockito.PowerMockito.when; import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.testng.PowerMockObjectFactory; import org.testng.Assert; import org.testng.IObjectFactory; import org.testng.annotations.ObjectFactory; import org.testng.annotations.Test; @PrepareForTest({ SystemClassUser.class }) public class SystemClassUserTest { @ObjectFactory public IObjectFactory getObjectFactory() { return new PowerMockObjectFactory(); } @Test public void assertThatMockingOfFinalSystemClassesWorks() throws Exception { mockStatic(System.class); when(System.getProperty("property")).thenReturn("my property"); Assert.assertEquals("my property", new SystemClassUser().getSystemProperty()); } } ``` Now here is the SystemClassUser class similarly stripped down: ``` import java.io.IOException; public class SystemClassUser { public String getSystemProperty() throws IOException { return System.getProperty("property"); } } ``` Running results in this Exception: FAILED: assertThatMockingOfFinalSystemClassesWorks org.mockito.exceptions.base.MockitoException: Mockito cannot mock this class: class replica.java.lang.System$$PowerMock0 Mockito can only mock visible & non-final classes.