Java单元测试的一些方法

发表于
字数统计: 62k | 阅读时长 ≈ 1:02

  • 最近项目中考察单元测试覆盖率，一段探索后用到了mock工具。PowerMock是一个集成了其他mock方法的强大框架。PowerMock使用一个自定义类加载器和字节码操作来模拟静态方法、构造方法、final类和方法、私有方法、去除静态初始化器等等。

  • 简单列一下项目中用到的方法。

  • 声明： 

  • 1
    T PowerMockito.mock(Class clazz);

  • 用途：
    可以用于模拟指定类的对象实例。
    当模拟非final类（接口、普通类、[虚基类]的非final方法时，不必使用@RunWith和@PrepareForTest注解。

  • 当模拟final类或final方法时，必须使用@RunWith和@PrepareForTest注解。注解形如：
    @RunWith(PowerMockRunner.class)
    @PrepareForTest({TargetClass.class})

  • 常用注解

  • @RunWith注解

    @RunWith(PowerMockRunner.class)

    指定JUnit 使用 PowerMock 框架中的单元测试运行器。

  • @PrepareForTest注解

    @PrepareForTest({ TargetClass.class })

    当需要模拟final类、final方法或静态方法时，需要添加@PrepareForTest注解，并指定方法所在的类。如果需要指定多个类，在{}中添加多个类并用逗号隔开即可。

  • @Mock注解

    @Mock注解创建了一个全部Mock的实例，所有属性和方法全被置空（0或者null）。

  • @Spy注解

    @Spy注解创建了一个没有Mock的实例，所有成员方法都会按照原方法的逻辑执行，直到被Mock返回某个具体的值为止。

    注意：@Spy注解的变量需要被初始化，否则执行时会抛出异常。

  • @InjectMocks注解

    @InjectMocks注解创建一个实例，这个实例可以调用真实代码的方法，其余用@Mock或@Spy注解创建的实例将被注入到用该实例中。

  • 常用方法

  • List

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    用List举例模拟一个不存在的列表,但是返回的列表大小为100。

    public class ListTest {
        @Test
        public void testSize() {
            Integer expected = 100;
            List list = PowerMockito.mock(List.class);
            PowerMockito.when(list.size()).thenReturn(expected);
            Integer actual  = list.size();
            Assert.assertEquals("返回值不相等", expected, actual);
        }

  • 非final类

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    @Getter
    @Setter
    @ToString
    public class Rectangle implements Sharp {
        private double width;
        private double height;
        @Override
        public double getArea() {
            return width * height;
        }
    }
     
    public class RectangleTest {
        @Test
        public void testGetArea() {
            double expectArea = 100.0D;
            Rectangle rectangle = PowerMockito.mock(Rectangle.class);
            PowerMockito.when(rectangle.getArea()).thenReturn(expectArea);
            double actualArea = rectangle.getArea();
            Assert.assertEquals("返回值不相等", expectArea, actualArea, 1E-6D);
        }
    }

  • final类

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    @Getter
    @Setter
    @ToString
    public final class Circle {
        private double radius;
        public double getArea() {
            return Math.PI * Math.pow(radius, 2);
        }
    }
     
    @RunWith(PowerMockRunner.class)
    @PrepareForTest({Circle.class})
    public class CircleTest {
        @Test
        public void testGetArea() {
            double expectArea = 3.14D;
            Circle circle = PowerMockito.mock(Circle.class);
            PowerMockito.when(circle.getArea()).thenReturn(expectArea);
            double actualArea = circle.getArea();
            Assert.assertEquals("返回值不相等", expectArea, actualArea, 1E-6D);
        }
    }

  • mockStatic模拟静态方法

  • 声明： 

  • 1
    PowerMockito.mockStatic(Class clazz);

  • 可以用于模拟类的静态方法，必须使用“@RunWith”和“@PrepareForTest”注解。 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @RunWith(PowerMockRunner.class)
    @PrepareForTest({StringUtils.class})
    public class StringUtilsTest {
        @Test
        public void testIsEmpty() {
            String string = "abc";
            boolean expected = true;
            PowerMockito.mockStatic(StringUtils.class);
            PowerMockito.when(StringUtils.isEmpty(string)).thenReturn(expected);
            boolean actual = StringUtils.isEmpty(string);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

  • Spy

  • spy可模拟部分方法，其他方法和原有保持一致。

  • 对类处理： 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    PowerMockito.spy(Class clazz)；

    用于模拟类的部分方法。

    public class StringUtils {
        public static boolean isNotEmpty(final CharSequence cs) {
            return !isEmpty(cs);
        }
        public static boolean isEmpty(final CharSequence cs) {
            return cs == null || cs.length() == 0;
        }
    }
     
    @RunWith(PowerMockRunner.class)
    @PrepareForTest({StringUtils.class})
    public class StringUtilsTest {
        @Test
        public void testIsNotEmpty() {
            String string = null;
            boolean expected = true;
            PowerMockito.spy(StringUtils.class);
            PowerMockito.when(StringUtils.isEmpty(string)).thenReturn(!expected);
            boolean actual = StringUtils.isNotEmpty(string);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

  • 对对象处理： 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    T PowerMockito.spy(T object)；

    用于模拟对象的部分方法。

    public class UserService {
        private Long superUserId;
        public boolean isNotSuperUser(Long userId) {
            return !isSuperUser(userId);
        }
        public boolean isSuperUser(Long userId) {
            return Objects.equals(userId, superUserId);
        }
    }
     
    @RunWith(PowerMockRunner.class)
    public class UserServiceTest {
        @Test
        public void testIsNotSuperUser() {
            Long userId = 1L;
            boolean expected = false;
            UserService userService = PowerMockito.spy(new UserService());
            PowerMockito.when(userService.isSuperUser(userId)).thenReturn(!expected);
            boolean actual = userService.isNotSuperUser(userId);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

  • 两种mock模式

  • 1.when().thenReturn()模式

  • 2.doReturn().when()模式

  • when().thenReturn()模式

  • 1
    2
    3
    4
    5
    6
    PowerMockito.when(mockObject.someMethod(someArgs)).thenReturn(expectedValue);
    PowerMockito.when(mockObject.someMethod(someArgs)).thenThrow(expectedThrowable);
    PowerMockito.when(mockObject.someMethod(someArgs)).thenAnswer(expectedAnswer);
    PowerMockito.when(mockObject.someMethod(someArgs)).thenCallRealMethod();

    用于模拟对象方法，先执行原始方法，再返回期望的值、异常、应答，或调用真实的方法。
  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    返回期望值

    public class ListTest {
        @Test
        public void testGet() {
            int index = 0;
            Integer expected = 100;
            List<Integer> mockList = PowerMockito.mock(List.class);
            PowerMockito.when(mockList.get(index)).thenReturn(expected);
            Integer actual = mockList.get(index);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

    返回期望异常

    public class ListTest {
        @Test(expected = IndexOutOfBoundsException.class)
        public void testGet() {
            int index = -1;
            Integer expected = 100;
            List<Integer> mockList = PowerMockito.mock(List.class);
            PowerMockito.when(mockList.get(index)).thenThrow(new IndexOutOfBoundsException());
            Integer actual = mockList.get(index);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

    返回期望应答

    public class ListTest {
        @Test
        public void testGet() {
            int index = 1;
            Integer expected = 100;
            List<Integer> mockList = PowerMockito.mock(List.class);
            PowerMockito.when(mockList.get(index)).thenAnswer(invocation -> {
                Integer value = invocation.getArgument(0);
                return value * 100;
            });
            Integer actual = mockList.get(index);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

    返回真实方法

    public class ListTest {
        @Test
        public void testGet() {
            int index = 0;
            Integer expected = 100;
            List<Integer> oldList = new ArrayList<>();
            oldList.add(expected);
            List<Integer> spylist = PowerMockito.spy(oldList);
            PowerMockito.when(spylist.get(index)).thenCallRealMethod();
            Integer actual = spylist.get(index);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

  • doReturn().when()模式

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    声明：
    PowerMockito.doReturn(expectedValue).when(mockObject).someMethod(someArgs);
    PowerMockito.doThrow(expectedThrowable).when(mockObject).someMethod(someArgs);
    PowerMockito.doAnswer(expectedAnswer).when(mockObject).someMethod(someArgs);
    PowerMockito.doNothing().when(mockObject).someMethod(someArgs);
    PowerMockito.doCallRealMethod().when(mockObject).someMethod(someArgs);
    用途：
    用于模拟对象方法，直接返回期望的值、异常、应答，或调用真实的方法，无需执行原始方法。
    注意：
    千万不要使用以下语法：
    PowerMockito.doReturn(expectedValue).when(mockObject.someMethod(someArgs));
    PowerMockito.doThrow(expectedThrowable).when(mockObject.someMethod(someArgs));
    PowerMockito.doAnswer(expectedAnswer).when(mockObject.someMethod(someArgs));
    PowerMockito.doNothing().when(mockObject.someMethod(someArgs));
    PowerMockito.doCallRealMethod().when(mockObject.someMethod(someArgs));
    虽然不会出现编译错误，但是在执行时会抛出UnfinishedStubbingException异常。
  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    返回期望值

    public class ListTest {
        @Test
        public void testGet() {
            int index = 0;
            Integer expected = 100;
            List<Integer> mockList = PowerMockito.mock(List.class);
            PowerMockito.doReturn(expected).when(mockList).get(index);
            Integer actual = mockList.get(index);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

    返回期望异常

    public class ListTest {
        @Test(expected = IndexOutOfBoundsException.class)
        public void testGet() {
            int index = -1;
            Integer expected = 100;
            List<Integer> mockList = PowerMockito.mock(List.class);
            PowerMockito.doThrow(new IndexOutOfBoundsException()).when(mockList).get(index);
            Integer actual = mockList.get(index);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

    返回期望应答

    public class ListTest {
        @Test
        public void testGet() {
            int index = 1;
            Integer expected = 100;
            List<Integer> mockList = PowerMockito.mock(List.class);
            PowerMockito.doAnswer(invocation -> {
                Integer value = invocation.getArgument(0);
                return value * 100;
            }).when(mockList).get(index);
            Integer actual = mockList.get(index);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

    无返回值

    public class ListTest {
        @Test
        public void testClear() {
            List<Integer> mockList = PowerMockito.mock(List.class);
            PowerMockito.doNothing().when(mockList).clear();
            mockList.clear();
            Mockito.verify(mockList).clear();
        }
    }

    调用真实方法

    public class ListTest {
        @Test
        public void testGet() {
            int index = 0;
            Integer expected = 100;
            List<Integer> oldList = new ArrayList<>();
            oldList.add(expected);
            List<Integer> spylist = PowerMockito.spy(oldList);
            PowerMockito.doCallRealMethod().when(spylist).get(index);
            Integer actual = spylist.get(index);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

  • 两种模式主要区别

    • 两种模式都用于模拟对象方法，在mock实例下使用时，基本上是没有差别的。但是，在spy实例下使用时，when().thenReturn()模式会执行原方法，而doReturn().when()模式不会执行原方法。

  • eg: 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    @Slf4j
     
    @Service
    public class UserService {
        public long getUserCount() {
            log.info("调用获取用户数量方法");
            return 0L;
        }
    }

  • when().thenReturn() 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @RunWith(PowerMockRunner.class)
    public class UserServiceTest {
        @Test
        public void testGetUserCount() {
            Long expected = 1000L;
            UserService userService = PowerMockito.spy(new UserService());
            PowerMockito.when(userService.getUserCount()).thenReturn(expected);
            Long actual = userService.getUserCount();
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

    //将会打印出"调用获取用户数量方法"日志

  • doReturn().when() 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @RunWith(PowerMockRunner.class)
    public class UserServiceTest {
        @Test
        public void testGetUserCount() {
            Long expected = 1000L;
            UserService userService = PowerMockito.spy(new UserService());
            PowerMockito.doReturn(expected).when(userService).getUserCount();
            Long actual = userService.getUserCount();
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }
    //不会打印

  • whenNew模拟构造方法

  • 1
    2
    PowerMockito.whenNew(MockClass.class).withNoArguments().thenReturn(expectedObject);
    PowerMockito.whenNew(MockClass.class).withArguments(someArgs).thenReturn(expectedObject);

  • 需要加上注解@PrepareForTest({FileUtils.class})，否则模拟方法不生效。 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public final class FileUtils {
        public static boolean isFile(String fileName) {
            return new File(fileName).isFile();
        }
    }
     
    @RunWith(PowerMockRunner.class)
    @PrepareForTest({FileUtils.class})
    public class FileUtilsTest {
        @Test
        public void testIsFile() throws Exception {
            String fileName = "test.txt";
            File file = PowerMockito.mock(File.class);
            PowerMockito.whenNew(File.class).withArguments(fileName).thenReturn(file);
            PowerMockito.when(file.isFile()).thenReturn(true);
            Assert.assertTrue("返回值为假", FileUtils.isFile(fileName));
        }
    }

  • 参数匹配器

  • 参数匹配器(any)

    Mockito提供Mockito.anyInt()、Mockito.anyString、Mockito.any(Class clazz)等来表示任意值。 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public class ListTest {
        @Test
        public void testGet() {
            int index = 1;
            Integer expected = 100;
            List<Integer> mockList = PowerMockito.mock(List.class);
            PowerMockito.when(mockList.get(Mockito.anyInt())).thenReturn(expected);
            Integer actual = mockList.get(index);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

  • 参数匹配器(eq)

  • 当我们使用参数匹配器时，所有参数都应使用匹配器。 如果要为某一参数指定特定值时，就需要使用Mockito.eq()方法。 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    @RunWith(PowerMockRunner.class)
    @PrepareForTest({StringUtils.class})
    public class StringUtilsTest {
        @Test
        public void testStartWith() {
            String string = "abc";
            String prefix = "b";
            boolean expected = true;
            PowerMockito.spy(StringUtils.class);
            PowerMockito.when(StringUtils.startsWith(Mockito.anyString(), Mockito.eq(prefix))).thenReturn(expected);
            boolean actual = StringUtils.startsWith(string, prefix);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

  • verify语句

    验证是确认在模拟过程中，被测试方法是否已按预期方式与其任何依赖方法进行了交互。 

    1
    Mockito.verify(mockObject[,times(int)]).someMethod(somgArgs);

    用于模拟对象方法，直接返回期望的值、异常、应答，或调用真实的方法，无需执行原始方法。

  • 验证调用方法

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    public class ListTest {
        @Test
        public void testGet() {
            List<Integer> mockList = PowerMockito.mock(List.class);
            PowerMockito.doNothing().when(mockList).clear();
            mockList.clear();
            Mockito.verify(mockList).clear();
        }
    }

  • 验证调用次数

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class ListTest {
        @Test
        public void testGet() {
            List<Integer> mockList = PowerMockito.mock(List.class);
            PowerMockito.doNothing().when(mockList).clear();
            mockList.clear();
            Mockito.verify(mockList, Mockito.times(1)).clear();
        }
    }
    //除times外，Mockito还支持atLeastOnce、atLeast、only、atMostOnce、atMost等次数验证器。

  • 验证调用顺序

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public class ListTest {
        @Test
        public void testAdd() {
               List<Integer> mockedList = PowerMockito.mock(List.class);
            PowerMockito.doReturn(true).when(mockedList).add(Mockito.anyInt());
            mockedList.add(1);
            mockedList.add(2);
            mockedList.add(3);
            InOrder inOrder = Mockito.inOrder(mockedList);
            inOrder.verify(mockedList).add(1);
            inOrder.verify(mockedList).add(2);
            inOrder.verify(mockedList).add(3);
        }
    }

  • 验证调用参数

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public class ListTest {
        @Test
        public void testArgumentCaptor() {
            Integer[] expecteds = new Integer[] {1, 2, 3};
            List<Integer> mockedList = PowerMockito.mock(List.class);
            PowerMockito.doReturn(true).when(mockedList).add(Mockito.anyInt());
            for (Integer expected : expecteds) {
                mockedList.add(expected);
            }
            ArgumentCaptor<Integer> argumentCaptor = ArgumentCaptor.forClass(Integer.class);
            Mockito.verify(mockedList, Mockito.times(3)).add(argumentCaptor.capture());
            Integer[] actuals = argumentCaptor.getAllValues().toArray(new Integer[0]);
            Assert.assertArrayEquals("返回值不相等", expecteds, actuals);
        }
    }

  • 验证调用完毕

  • Mockito提供Mockito.verifyNoMoreInteractions方法，在所有验证方法之后可以使用此方法，以确保所有调用都得到验证。如果模拟对象上存在任何未验证的调用，将会抛出NoInteractionsWanted异常。 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    public class ListTest {
        @Test
        public void testVerifyNoMoreInteractions() {
            List<Integer> mockedList = PowerMockito.mock(List.class);
            Mockito.verifyNoMoreInteractions(mockedList); // 执行正常
            mockedList.isEmpty();
            Mockito.verifyNoMoreInteractions(mockedList); // 抛出异常
        }
    }

  • 验证静态方法

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    @RunWith(PowerMockRunner.class)
    @PrepareForTest({StringUtils.class})
    public class StringUtilsTest {
        @Test
        public void testVerifyStatic() {
            PowerMockito.mockStatic(StringUtils.class);
            String expected = "abc";
            StringUtils.isEmpty(expected);
            PowerMockito.verifyStatic(StringUtils.class);
            ArgumentCaptor<String> argumentCaptor = ArgumentCaptor.forClass(String.class);
            StringUtils.isEmpty(argumentCaptor.capture());
            Assert.assertEquals("参数不相等", argumentCaptor.getValue(), expected);
        }
    }

  • private属性处理

  • ReflectionTestUtils.setField方法

    在用原生JUnit进行单元测试时，我们一般采用ReflectionTestUtils.setField方法设置私有属性值 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    @Service
    public class UserService {
        @Value("${system.userLimit}")
        private Long userLimit;
        public Long getUserLimit() {
            return userLimit;
        }
    }
     
    public class UserServiceTest {
        @Autowired
        private UserService userService;
        @Test
        public void testGetUserLimit() {
            Long expected = 1000L;
            ReflectionTestUtils.setField(userService, "userLimit", expected);
            Long actual = userService.getUserLimit();
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

  • Whitebox.setInternalState方法

    现在使用PowerMock进行单元测试时，可以采用Whitebox.setInternalState方法设置私有属性值。

  • 需要加上注解@RunWith(PowerMockRunner.class)。 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    @Service
    public class UserService {
        @Value("${system.userLimit}")
        private Long userLimit;
        public Long getUserLimit() {
            return userLimit;
        }
    }
     
    @RunWith(PowerMockRunner.class)
    public class UserServiceTest {
        @InjectMocks
        private UserService userService;
        @Test
        public void testGetUserLimit() {
            Long expected = 1000L;
            Whitebox.setInternalState(userService, "userLimit", expected);
            Long actual = userService.getUserLimit();
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

  • 私有方法

  • when方式

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    public class UserService {
        private Long superUserId;
        public boolean isNotSuperUser(Long userId) {
            return !isSuperUser(userId);
        }
        private boolean isSuperUser(Long userId) {
            return Objects.equals(userId, superUserId);
        }
    }
     
    @RunWith(PowerMockRunner.class)
    @PrepareForTest({UserService.class})
    public class UserServiceTest {
        @Test
        public void testIsNotSuperUser() throws Exception {
            Long userId = 1L;
            boolean expected = false;
            UserService userService = PowerMockito.spy(new UserService());
            PowerMockito.when(userService, "isSuperUser", userId).thenReturn(!expected);
            boolean actual = userService.isNotSuperUser(userId);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

  • stub实现

    通过模拟方法stub(存根)，也可以实现模拟私有方法。但是，只能模拟整个方法的返回值，而不能模拟指定参数的返回值。 

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @RunWith(PowerMockRunner.class)
    @PrepareForTest({UserService.class})
    public class UserServiceTest {
        @Test
        public void testIsNotSuperUser() throws Exception {
            Long userId = 1L;
            boolean expected = false;
            UserService userService = PowerMockito.spy(new UserService());
            PowerMockito.stub(PowerMockito.method(UserService.class, "isSuperUser", Long.class)).toReturn(!expected);
            boolean actual = userService.isNotSuperUser(userId);
            Assert.assertEquals("返回值不相等", expected, actual;
        }
    }

  • 测试私有方法

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @RunWith(PowerMockRunner.class)
    public class UserServiceTest9 {
        @Test
        public void testIsSuperUser() throws Exception {
            Long userId = 1L;
            boolean expected = false;
            UserService userService = new UserService();
            Method method = PowerMockito.method(UserService.class, "isSuperUser", Long.class);
            Object actual = method.invoke(userService, userId);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }

  • 验证私有方法

  • 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    @RunWith(PowerMockRunner.class)
    @PrepareForTest({UserService.class})
    public class UserServiceTest10 {
        @Test
        public void testIsNotSuperUser() throws Exception {
            Long userId = 1L;
            boolean expected = false;
            UserService userService = PowerMockito.spy(new UserService());
            PowerMockito.when(userService, "isSuperUser", userId).thenReturn(!expected);
            boolean actual = userService.isNotSuperUser(userId);
            PowerMockito.verifyPrivate(userService).invoke("isSuperUser", userId);
            Assert.assertEquals("返回值不相等", expected, actual);
        }
    }