山闻愚
山闻愚

Java单元测试之模拟利器-使用PowerMock进行Mock测试

原文：http://www.w2bc.com/article/111452

简介

mock是模拟对象，用于模拟真实对象的行为。

Powermock主要用于打桩。比如：方法A的参数需要传入实例B，方法A需要调用B的某个方法B.C()。方法C因为耗时长或者根本没有实现或者其他不方便在单元测试中实现等原因，需要伪造返回，此时Powermock即可派上用场。

PowerMock扩展了EasyMock和Mockito框架，增加了对static和final方法mock支持等功能。这里主要基于PowerMock Mockito API进行介绍。

PowerMock支持JUnit和TestNG，这里基于JUnit。

安装

    下载地址：https://github.com/jayway/powermock/wiki/Downloads。下载" Mockito and JUnit including dependencies"版本。当前版本为”powermock-mockito-junit-1.6.3.zip"。 

    IntelliJ IDEA的设置如下：

    右击工程，选择“Open Module Settings”

    

    

    按下“ALT + Insert”，选择“Jars or directories...", 插入jar包：

    

    点击OK。

    在”Module Settings”对话框中点击“Sources”标签，右击右边底部面板，选择“New Folder...", 命名为test。

    在”Module Settings”对话框中选择test，标识为Test Sources，关闭”Module Settings”对话框。

    Eclipse中只需要上述jar包放在工程下的lib目录即可。

    Maven在pom.xml添加如下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
     < dependency >
         < groupId >junit groupId >
         < artifactId >junit artifactId >
         < version >4.12 version >
         < scope >test scope >
     dependency >
     < dependency >
         < groupId >org.powermock groupId >
         < artifactId >powermock-module-junit4 artifactId >
         < version >1.6.3 version >
         < scope >test scope >
     dependency >    
     < dependency >    
         < groupId >org.powermock groupId >    
         < artifactId >powermock-api-mockito artifactId >    
         < version >1.6.3 version >    
         < scope >test scope >    
     dependency >        
   dependencies >

快速入门

    下面创建EmployeeController类用于给Employee类执行Create, Read, Update, and Delete (CRUD)。实际工作由EmployeeService完成。getProjectedEmployeeCount方法预计公司员工每年增加20%，并返回近似取整。

     

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public  class  EmployeeController {
     
     private  EmployeeService employeeService;
     
     public  EmployeeController(EmployeeService employeeService) {
     
         this .employeeService = employeeService;
     }
     
     public  int  getProjectedEmployeeCount() {
     
         final  int  actualEmployeeCount = employeeService.getEmployeeCount();
         return  ( int ) Math.ceil(actualEmployeeCount *  1.2 );
     }
     
     public  void  saveEmployee(Employee employee) {
     
         employeeService.saveEmployee(employee);
     }    
}

1
2
3
4
5
6
7
8
9
10
public  class  EmployeeService {
     
     public  int  getEmployeeCount() {
         throw  new  UnsupportedOperationException();
     }
     
     public  void  saveEmployee(Employee employee) {
         throw  new  UnsupportedOperationException();
     }    
}

     

    由于getEmployeeCount等方法没有真正实现，我们需要mock：

1
2
3
public  class  Employee {
 
}

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
import  static  org.junit.Assert.*;
 
import  org.junit.Test;
import  org.mockito.Mockito;
import  org.powermock.api.mockito.PowerMockito;
 
public  class  EmployeeControllerTest {
 
     @Test
     public  void  shouldReturnProjectedCountOfEmployeesFromTheService() {
         
         EmployeeService mock = PowerMockito.mock(EmployeeService. class );
         PowerMockito.when(mock.getEmployeeCount()).thenReturn( 8 );
         EmployeeController employeeController =  new  EmployeeController(mock);
         assertEquals( 10 , employeeController.getProjectedEmployeeCount());
     }
     
     @Test
     public  void
     shouldInvokeSaveEmployeeOnTheServiceWhileSavingTheEmployee() {
         
         EmployeeService mock = PowerMockito.mock(EmployeeService. class );    
         EmployeeController employeeController =  new  EmployeeController(mock);
         Employee employee =  new  Employee();
         employeeController.saveEmployee(employee);
         Mockito.verify(mock).saveEmployee(employee);
     }        
}

    

     注意如果上述代码出现莫名其妙的错误，建议先确认所有文件已经保存，再不行重启Eclipse。

    上面的saveEmployee(Employee)没有返回值，我们只需要用verify确认有调用即可。如果注释掉employeeController.saveEmployee(employee);就会有如下报错：

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
     Wanted but  not  invoked:
employeeService.saveEmployee(
     Employee@ 51081592
);
- > at EmployeeControllerTest.shouldInvokeSaveEmployeeOnTheServiceWhileSavingTheEmployee(EmployeeControllerTest.java: 27 )
Actually, there were zero interactions with this mock.
     at EmployeeControllerTest.shouldInvokeSaveEmployeeOnTheServiceWhileSavingTheEmployee(EmployeeControllerTest.java: 27 )
     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
     at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
     at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
     at java.lang.reflect.Method.invoke(Unknown Source)
     at org.junit.runners.model.FrameworkMethod$ 1.runReflectiveCall (FrameworkMethod.java: 50 )
     at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java: 12 )
     at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java: 47 )
     at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java: 17 )
     at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java: 325 )
     at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java: 78 )
     at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java: 57 )
     at org.junit.runners.ParentRunner$ 3.run (ParentRunner.java: 290 )
     at org.junit.runners.ParentRunner$ 1.schedule (ParentRunner.java: 71 )
     at org.junit.runners.ParentRunner.runChildren(ParentRunner.java: 288 )
     at org.junit.runners.ParentRunner.access$ 000 (ParentRunner.java: 58 )
     at org.junit.runners.ParentRunner$ 2.evaluate (ParentRunner.java: 268 )
     at org.junit.runners.ParentRunner.run(ParentRunner.java: 363 )
     at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java: 86 )
     at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java: 38 )
     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java: 459 )
     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java: 675 )
     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java: 382 )
     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java: 192 )

    另外有个非常用的MockSettings功能，用于设置mock名、实现额外接口(参见https://groups.google.com/forum/?fromgroups=#!topic/mockito/YM5EF0x90_4)、开启详细日志、注册listener用于mock时通知消息调用。比如：

1
     EmployeeService mock = PowerMockito.mock(EmployeeService. class , Mockito.withSettings().name( "EmployeeServiceMock" ).verboseLogging());

从上面例子可以看出，mock常用于参数，如果是方法内部的局部变量偏多、逻辑过于复杂，mock将是比较痛苦的过程，甚至无从下手。    

注意：Eclipse如果看不到lib，请选中工程目录，按F5刷新。lib中的每个jar，需要右键点击，选择"Build Path"->"Add to Build Path", 添加完毕的效果图如下：

   

模拟静态方法

    修改类Employee:

1
2
3
4
5
6
public  class  Employee {
     
     public  static  int  count() {
         throw  new  UnsupportedOperationException();
     }
}

    修改EmployeeService类的方法：

1
2
3
     public  int  getEmployeeCount() {    
         return  Employee.count();
     }

    新建EmployeeServiceTest类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import  static  org.junit.Assert.*;
 
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.powermock.api.mockito.PowerMockito;
import  org.powermock.core.classloader.annotations.PrepareForTest;
import  org.powermock.modules.junit4.PowerMockRunner;
 
@RunWith (PowerMockRunner. class )
@PrepareForTest (Employee. class )
public  class  EmployeeServiceTest {
 
     @Test
     public  void  shouldReturnTheCountOfEmployeesUsingTheDomainClass() {
         
         PowerMockito.mockStatic(Employee. class );
         PowerMockito.when(Employee.count()).thenReturn( 900 );
         
         EmployeeService employeeService =  new  EmployeeService();
         assertEquals( 900 , employeeService.getEmployeeCount());
         
     }
}

@RunWith(PowerMockRunner.class)语句告诉JUnit用PowerMockRunner来执行测试。
@PrepareForTest(Employee.class)语句告诉PowerMock准备Employee类进行测试。适用于模拟final类或有final, private, static, native方法的类。

    
注意这里使用的是mockStatic而不是上面的mock。

    下面我们模拟下返回void的静态方法。在Employee添加加薪方法：

1
2
3
     public  static  void  giveIncrementOf( int  percentage) {
         throw  new  UnsupportedOperationException();
     }

    

    EmployeeService添加相应方法：

1
2
3
4
5
6
7
8
     public  boolean  giveIncrementToAllEmployeesOf( int  percentage) {
         try {
             Employee.giveIncrementOf(percentage);
             return  true ;
         }  catch (Exception e) {
             return  false ;
         }
     }

    

    修改EmployeeServiceTest类

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
import  static  org.junit.Assert.*;
 
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.powermock.api.mockito.PowerMockito;
import  org.powermock.core.classloader.annotations.PrepareForTest;
import  org.powermock.modules.junit4.PowerMockRunner;
  
@RunWith (PowerMockRunner. class )
@PrepareForTest (Employee. class )
public  class  EmployeeServiceTest {
  
     @Test
     public  void  shouldReturnTrueWhenIncrementOf10PercentageIsGivenSuccessfully() {
         
         PowerMockito.mockStatic(Employee. class );
         PowerMockito.doNothing().when(Employee. class );
         Employee.giveIncrementOf( 10 );
         EmployeeService employeeService =  new  EmployeeService();
         assertTrue(employeeService.giveIncrementToAllEmployeesOf( 10 ));
         
     }
     
     @Test
     public  void  shouldReturnFalseWhenIncrementOf10PercentageIsNotGivenSuccessfully() {
         
         PowerMockito.mockStatic(Employee. class );
         PowerMockito.doThrow( new  IllegalStateException()).when(Employee. class );
         Employee.giveIncrementOf( 10 );
         EmployeeService employeeService =  new  EmployeeService();
         assertFalse(employeeService.giveIncrementToAllEmployeesOf( 10 ));
     }    
}

    

    PowerMockito.doNothing方法告诉PowerMock下一个方法调用时什么也不做。

    PowerMockito.doThrow方法告诉PowerMock下一个方法调用时产生异常。

    PowerMock使用自定义类加载器和字节码操作来模拟静态方法。对于实例中没有mock的方法，也有默认返回值，比如返回int类型的方法，默认返回0。

    
PowerMockito.doNothing和PowerMockito.doThrow的语法可用于实例方法。

    先在Employee类添加方法save:

1
2
3
     public  void  save() {
         throw  new  UnsupportedOperationException();
     }

    

    创建测试EmployeeTest 类：

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
import  static  org.junit.Assert.*;
 
import  org.junit.Test;
import  org.powermock.api.mockito.PowerMockito;
 
public  class  EmployeeTest {
     
     @Test ()
     public  void  shouldNotDoAnythingIfEmployeeWasSaved() {
     
         Employee employee = PowerMockito.mock(Employee. class );
         PowerMockito.doNothing().when(employee).save();
         try  {
             employee.save();
         }  catch (Exception e) {
             fail( "Should not have thrown an exception" );
         }
     }
     
     @Test (expected = IllegalStateException. class )
     public  void  shouldThrowAnExceptionIfEmployeeWasNotSaved() {
     
         Employee employee = PowerMockito.mock(Employee. class );
         PowerMockito.doThrow( new  IllegalStateException()).when(employee).save();
         employee.save();
     }
}

    注意这里doThrow和doNothing方法不会对下一行产生影响。

验证方法调用

    验证断言方法是否调用。

    修改EmployeeService类的saveEmployee方法。

1
2
3
4
5
6
7
     public  void  saveEmployee(Employee employee) {
         if (employee.isNew()) {
             employee.create();
             return ;
         }
         employee.update();
     }

修改Employee类，新增如下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
     public  boolean  isNew() {
         throw  new  UnsupportedOperationException();
     }
     
     public  void  update() {
         throw  new  UnsupportedOperationException();
     }
     
     public  void  create() {
         throw  new  UnsupportedOperationException();
     }
     
     public  static  void  giveIncrementOf( int  percentage) {
         throw  new  UnsupportedOperationException();
     }

在EmployeeServiceTest类中新增shouldCreateNewEmployeeIfEmployeeIsNew方法, 并新增导入import org.mockito.Mockito;：

1
2
3
4
5
6
7
8
9
10
     @Test
     public  void  shouldCreateNewEmployeeIfEmployeeIsNew() {
     
         Employee mock = PowerMockito.mock(Employee. class );
         PowerMockito.when(mock.isNew()).thenReturn( true );
         EmployeeService employeeService =  new  EmployeeService();
         employeeService.saveEmployee(mock);
         Mockito.verify(mock).create();
         Mockito.verify(mock, Mockito.never()).update();
     }

 Mockito.verify(mock).create()验证调用了create方法。 Mockito.verify(mock, Mockito.never()).update();验证没有调用update方法。

 

下面验证静态方法，在EmployeeServiceTest类添加shouldInvoke_giveIncrementOfMethodOnEmployeeWhileGivingIncrement方法：

   

1
2
3
4
5
6
7
8
9
10
11
     @Test
     public  void  shouldInvoke_giveIncrementOfMethodOnEmployeeWhileGivingIncrement() {
     
         PowerMockito.mockStatic(Employee. class );
         PowerMockito.doNothing().when(Employee. class );
         Employee.giveIncrementOf( 9 );
         EmployeeService employeeService =  new  EmployeeService();
         employeeService.giveIncrementToAllEmployeesOf( 9 );
         PowerMockito.verifyStatic();
         Employee.giveIncrementOf( 9 );
     }

同样，静态验证也要分两步走。

其他验证模式可以验证调用次数：

  • Mockito.times(int n) : This verification mode asserts that the mocked method was invoked exactly 'n' times

  • Mockito.atLeastOnce() : This verification mode asserts that the mocked method was invoked at least once

  • Mockito.atLeast(int n) : This verification mode asserts that the mocked method was invoked at least 'n' times

  • Mockito.atMost(int n) : This verification mode asserts that the mocked method was invoked at most 'n' times

使用Mockito.inOrder还可以验证调用的顺序，注意要导入import org.mockito.InOrder;

   

1
2
3
4
5
6
7
8
9
10
11
12
     @Test
     public  void  shouldInvokeIsNewBeforeInvokingCreate() {
         
         Employee mock = PowerMockito.mock(Employee. class );
         PowerMockito.when(mock.isNew()).thenReturn( true );
         EmployeeService employeeService =  new  EmployeeService();
         employeeService.saveEmployee(mock);
         InOrder inOrder = Mockito.inOrder(mock);
         inOrder.verify(mock).isNew();
         Mockito.verify(mock).create();
         Mockito.verify(mock, Mockito.never()).update();
     }


模拟final类或方法

新增EmployeeIdGenerator类：

1
2
3
4
5
6
public  final  class  EmployeeIdGenerator {
 
     public  final  static  int  getNextId() {
         throw  new  UnsupportedOperationException();
     }
}


在Employee类新增方法：

1
2
3
4
     public  void  setEmployeeId( int  nextId) {
 
         throw  new  UnsupportedOperationException();        
     }


修改EmployeeService类的saveEmployee方法：

1
2
3
4
5
6
7
8
     public  void  saveEmployee(Employee employee) {
         if (employee.isNew()) {
             employee.setEmployeeId(EmployeeIdGenerator.getNextId());
             employee.create();
             return ;
         }
         employee.update();
     }

修改EmployeeServiceTest类：

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
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.mockito.Mockito;
import  org.powermock.api.mockito.PowerMockito;
import  org.powermock.core.classloader.annotations.PrepareForTest;
import  org.powermock.modules.junit4.PowerMockRunner;
  
@RunWith (PowerMockRunner. class )
@PrepareForTest (EmployeeIdGenerator. class )
public  class  EmployeeServiceTest {
     
     @Test
     public  void  shouldGenerateEmployeeIdIfEmployeeIsNew() {
         
         Employee mock = PowerMockito.mock(Employee. class );
         PowerMockito.when(mock.isNew()).thenReturn( true );
         PowerMockito.mockStatic(EmployeeIdGenerator. class );
         PowerMockito.when(EmployeeIdGenerator.getNextId()).thenReturn( 90 );
         EmployeeService employeeService =  new
         EmployeeService();
         employeeService.saveEmployee(mock);
         PowerMockito.verifyStatic();
         EmployeeIdGenerator.getNextId();
         Mockito.verify(mock).setEmployeeId( 90 );
         Mockito.verify(mock).create();
     }
}

可见final和static的在类头部处理方法类似, 在测试方法中final和普通方法类似。

 处理构造方法

现在创建新职员的时候要发送欢迎邮件。

新增类WelcomeEmail：

1
2
3
4
5
6
7
8
9
10
public  class  WelcomeEmail {
 
     public  WelcomeEmail( final  Employee employee,  final  String message) {
         throw  new  UnsupportedOperationException();
     }
     
     public  void  send() {
         throw  new  UnsupportedOperationException();
     }
}

 

修改EmployeeService类的saveEmployee方法：

1
2
3
4
5
6
7
8
9
10
11
     public  void  saveEmployee(Employee employee) {
         if (employee.isNew()) {
             employee.setEmployeeId(EmployeeIdGenerator.getNextId());
             employee.create();
             WelcomeEmail emailSender =  new  WelcomeEmail(employee,
             "Welcome to Mocking with PowerMock How-to!" );
             emailSender.send();
             return ;
         }
         employee.update();
     }

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
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.mockito.Mockito;
import  org.powermock.api.mockito.PowerMockito;
import  org.powermock.core.classloader.annotations.PrepareForTest;
import  org.powermock.modules.junit4.PowerMockRunner;
  
@RunWith (PowerMockRunner. class )
@PrepareForTest ({EmployeeIdGenerator. class , EmployeeService. class })
public  class  EmployeeServiceTest {
 
     @Test
     public  void  shouldSendWelcomeEmailToNewEmployees() throws  Exception {
         
         Employee employeeMock =PowerMockito.mock(Employee. class );
         PowerMockito.when(employeeMock.isNew()).thenReturn( true );
         PowerMockito.mockStatic(EmployeeIdGenerator. class );
         WelcomeEmail welcomeEmailMock = PowerMockito.mock(WelcomeEmail. class );
         PowerMockito.whenNew(WelcomeEmail. class ).withArguments(employeeMock,  "Welcome to Mocking with PowerMock How-to!" ).thenReturn(welcomeEmailMock);
         EmployeeService employeeService =  new  EmployeeService();
         employeeService.saveEmployee(employeeMock);
 
         PowerMockito.verifyNew(WelcomeEmail. class ).withArguments(employeeMock,  "Welcome to Mocking with PowerMock How-to!" );
         Mockito.verify(welcomeEmailMock).send();
     }
}

注意PowerMockito.verifyNew的第2个参数支持前面提到的验证模式。PowerMockito.whenNew().withArguments(...).thenReturn()是对构造方法的mock模式，PowerMockito.verifyNew().withArguments()是验证模式。

参数匹配

 PowerMock使用equals方法验证参数。matcher可更加灵活的处理参数。

为EmployeeController类添加如下方法：

   

1
2
3
4
5
6
7
8
     public  Employee findEmployeeByEmail(String email) {    
         return  employeeService.findEmployeeByEmail(email);
     }
         
     public  boolean  isEmployeeEmailAlreadyTaken(String email) {
         Employee employee =  new  Employee();
         return  employeeService.employeeExists(employee);
     }

为EmployeeService类添加如下方法：

   

1
2
3
4
5
6
7
     public  Employee findEmployeeByEmail(String email) {
         throw  new  UnsupportedOperationException();
     }
     
     public  boolean  employeeExists(Employee employee) {
         throw  new  UnsupportedOperationException();
     }

  

为EmployeeControllerTest类新增测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
     @Test
     public  void  shouldFindEmployeeByEmail() {
     
         final  EmployeeService mock = PowerMockito.mock(EmployeeService. class );
         final  Employee employee =  new  Employee();
         PowerMockito.when(mock.findEmployeeByEmail(Mockito.startsWith( "deep" ))).thenReturn(employee);
         final  EmployeeController employeeController =  new  EmployeeController(mock);
         assertSame(employee, employeeController.findEmployeeByEmail( "[email protected]" ));
         assertSame(employee, employeeController.findEmployeeByEmail( "[email protected]" ));
         assertNull(employeeController.findEmployeeByEmail( "[email protected]" ));
     }
     
     @Test
     public  void  shouldReturnNullIfNoEmployeeFoundByEmail() {
         
         final  EmployeeService mock = PowerMockito.mock(EmployeeService. class );
         PowerMockito.when(mock.findEmployeeByEmail(Mockito.anyString())).thenReturn( null );
         final  EmployeeController employeeController =  new  EmployeeController(mock);
         assertNull(employeeController.findEmployeeByEmail( "[email protected]" ));
         assertNull(employeeController.findEmployeeByEmail( "[email protected]" ));
         assertNull(employeeController.findEmployeeByEmail( "[email protected]" ));        
     }

 后面还有个基于argThat例子，因为没有搞到源码，意思暂时没有揣度出来。先不涉及。

另外其他类似的内置匹配器如下：Mockito.eq、Mockito.matches、Mockito.any(anyBoolean , anyByte , anyShort , anyChar , anyInt ,anyLong , anyFloat , anyDouble , anyList , anyCollection , anyMap , anySet等等)、Mockito.isNull、Mockito.isNotNull、Mockito.endsWith、Mockito.isA。

 

回答(Answer)

在某些边缘的情况下不可能通过简单地通过PowerMockito.when().thenReturn()模拟，这时可以使用Answer接口。

在EmployeeControllerTest类中增加如下方法：

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
import  org.mockito.stubbing.Answer;
   
public  class  EmployeeControllerTest {
   
     @Test
     public  void  shouldFindEmployeeByEmailUsingTheAnswerInterface() {
          
         final  EmployeeService mock = PowerMockito.mock(EmployeeService. class );
         final  Employee employee =  new  Employee();
         
         PowerMockito.when(mock.findEmployeeByEmail(Mockito.anyString())).then( new  Answer() {
 
             public  Employee answer(InvocationOnMock invocation)  throws  Throwable {
                 final  String email = (String) invocation.getArguments()[ 0 ];
                 if (email ==  null )  return  null ;
                 if (email.startsWith( "deep" ))  return  employee;
                 if (email.endsWith( "packtpub.com" ))  return  employee;
                 return  null ;
             }
         });
         
         final  EmployeeController employeeController =  new  EmployeeController(mock);
         assertSame(employee, employeeController.findEmployeeByEmail( "[email protected]" ));
         assertSame(employee, employeeController.findEmployeeByEmail( "[email protected]" ));
         assertNull(employeeController.findEmployeeByEmail( "[email protected]" ));
     }
          
     @Test
     public  void  shouldReturnCountOfEmployeesFromTheServiceWithDefaultAnswer() {
          
         EmployeeService mock = PowerMockito.mock(EmployeeService. class ,  new  Answer() {
             
             public  Object answer(InvocationOnMock invocation) {
                 return  10 ;
             }
         });
         
         EmployeeController employeeController =  new  EmployeeController(mock);
         assertEquals( 12 , employeeController.getProjectedEmployeeCount());
     }
}


Answer接口指定执行的action和返回值执。 Answer的参数是InvocationOnMock的实例，支持：

  • callRealMethod()：调用真正的方法

  • getArguments()：获取所有参数

  • getMethod()：返回mock实例调用的方法

  • getMock()：获取mock实例

第一个测试方法根据不同情况构造不同返回。第2个测试方法设定调用返回的默认值。

使用spy进行部分模拟

现在调整类EmployeeService，拆分saveEmployee为方法：saveEmployee和createEmployee：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
     public  void  saveEmployee(Employee employee) {
         if (employee.isNew()) {
             createEmployee(employee);
             return ;
         }
         employee.update();
     }  
     
     void  createEmployee(Employee employee) {
         employee.setEmployeeId(EmployeeIdGenerator.getNextId());
         employee.create();
         WelcomeEmail emailSender =  new  WelcomeEmail(employee,
         "Welcome to Mocking with PowerMock How-to!" );
         emailSender.send();
     }

EmployeeServiceTest类添加测试方法shouldInvokeTheCreateEmployeeMethodWhileSavingANewEmployee：

1
2
3
4
5
6
7
8
9
10
     @Test
     public  void  shouldInvokeTheCreateEmployeeMethodWhileSavingANewEmployee() {
         
         final  EmployeeService spy = PowerMockito.spy( new  EmployeeService());
         final  Employee employeeMock = PowerMockito.mock(Employee. class );
         PowerMockito.when(employeeMock.isNew()).thenReturn( true );
         PowerMockito.doNothing().when(spy).createEmployee(employeeMock);
         spy.saveEmployee(employeeMock);
         Mockito.verify(spy).createEmployee(employeeMock);      
     }

注意spy只能使用PowerMockito.doNothing()/doReturn()/doThrow()。

模拟私有方法

现在我们修改EmployeeService.createEmployee为private，在EmployeeServiceTest类添加如下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.powermock.api.mockito.PowerMockito;
import  org.powermock.core.classloader.annotations.PrepareForTest;
import  org.powermock.modules.junit4.PowerMockRunner;
  
@RunWith (PowerMockRunner. class )
@PrepareForTest ({EmployeeIdGenerator. class , EmployeeService. class })
public  class  EmployeeServiceTest {
     
     @Test
     public  void  shouldInvokeTheCreateEmployeeMethodWhileSavingANewEmployee()  throws  Exception {
          
         final  EmployeeService spy = PowerMockito.spy( new  EmployeeService());
         final  Employee employeeMock = PowerMockito.mock(Employee. class );
         PowerMockito.when(employeeMock.isNew()).thenReturn( true );
         PowerMockito.doNothing().when(spy,  "createEmployee" , employeeMock);
         spy.saveEmployee(employeeMock);
         PowerMockito.verifyPrivate(spy).invoke( "createEmployee" , employeeMock);
     }
}

模拟私有方法还有另外一种相对较复杂的方法，这里不做介绍了。

 

查看封装内容

添加 Department类

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
import  java.util.ArrayList;
import  java.util.List;
 
public  class  Department {
     
     private  List employees =  new  ArrayList();    
     private  long  maxSalaryOffered;
     public  void  addEmployee( final  Employee employee) {
         employees.add(employee);
         updateMaxSalaryOffered();
     }
     
     /**
     * The private method that keeps track of
     * max salary offered by this department.
     */
     private  void  updateMaxSalaryOffered() {
         maxSalaryOffered =  0 ;
         for  (Employee employee : employees) {
             if (employee.getSalary() > maxSalaryOffered) {
                 maxSalaryOffered = employee.getSalary();
             }
         }
     }
}

修改Employee类的如下方法：

1
2
3
4
5
6
7
     public  long  getSalary() {
         return  salary;      
     }
     
     public  void  setSalary( int  i) {
         salary = i;        
     }

新建DepartmentTest类，添加如下测试方法：

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
import  static  org.junit.Assert.*;
import  java.util.ArrayList;
import  java.util.List;
import  org.junit.Test;
import  org.powermock.reflect.Whitebox;
 
public  class  DepartmentTest {
     @Test
     public  void  shouldVerifyThatNewEmployeeIsAddedToTheDepartment() {
         
         final  Department department =  new  Department();
         final  Employee employee =  new  Employee();
         department.addEmployee(employee);
         final  List employees = Whitebox.getInternalState(department,  "employees" );
         assertTrue(employees.contains(employee));
     }
     
     
     @Test
     public  void  shouldAddNewEmployeeToTheDepartment() {
         
         final  Department department =  new  Department();
         final  Employee employee =  new  Employee();
         final  ArrayList employees =  new  ArrayList();
         Whitebox.setInternalState(department,  "employees" , employees);
         department.addEmployee(employee);
         assertTrue(employees.contains(employee));
     }
     
     @Test
     public  void  shouldVerifyThatMaxSalaryOfferedForADepartmentIsCalculatedCorrectly()  throws  Exception
     {
         
         final  Department department =  new  Department();
         final  Employee employee1 =  new  Employee();
         final  Employee employee2 =  new  Employee();
         employee1.setSalary( 60000 );
         employee2.setSalary( 65000 );
         //Adding two employees to the test employees list.
         final  ArrayList employees =  new  ArrayList();
         employees.add(employee1);
         employees.add(employee2);
         Whitebox.setInternalState(department,  "employees" , employees);
         Whitebox.invokeMethod(department, "updateMaxSalaryOffered" );
         final  long  maxSalary = Whitebox.getInternalState(department,  "maxSalaryOffered" );
         assertEquals( 65000 , maxSalary);
     }
}

 Whitebox.getInternalState(department, "employees")类似堆栈，查看变量的值。Whitebox.setInternalState(department, "employees",

employees)设置变量的值。 Whitebox.invokeMethod(department, "updateMaxSalaryOffered")调用方法。

更多参考：http://powermock.googlecode.com/svn/docs/powermock-1.5/apidocs/org/powermock/reflect/Whitebox.html。


ads_sms中测试手机号码发送短信

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
package  com.oppo.os.ads.sms.sevice;
 
import  static  org.junit.Assert.*;
 
import  org.junit.After;
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.powermock.reflect.Whitebox;
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.test.context.ContextConfiguration;
import  org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
 
@RunWith (SpringJUnit4ClassRunner. class ) 
@ContextConfiguration (locations= "classpath:dubbo/ads-sms-svc.xml" ) 
public  class  SmsTaskTest {
     
     @Autowired
     SmsTask svc;
 
     @After
     public  void  tearDown()  throws  Exception {
     }
 
     @Test
     public  void  checkLimitOk()  throws  Exception {
         System.out.println( "initAccUser" );
         boolean  result = Whitebox.invokeMethod(svc, "checkLimit" ,  6 ,  "13246680798" ,  3 ,  20160121 ,  20160121 );
         assertEquals( true , result);
     }
 
     @Test
     public  void  checkLimitFail()  throws  Exception {
         System.out.println( "initAccUser" );
         boolean  result = Whitebox.invokeMethod(svc, "checkLimit" ,  0 ,  "13246680998" ,  3 ,  20160121 ,  20160121 );
         assertEquals( false , result);
     }
}


ads_ad 中的pom.xml配置：

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
         < dependency >    
             < groupId >org.powermock groupId >    
             < artifactId >powermock-module-junit4 artifactId >    
             < version >1.6.3 version >    
             < scope >test scope >    
         dependency >        
         < dependency >    
             < groupId >org.powermock groupId >    
             < artifactId >powermock-api-mockito artifactId >    
             < version >1.6.3 version >    
             < scope >test scope >    
         dependency >    
         < dependency >
               < groupId >org.powermock groupId >
               < artifactId >powermock-module-junit4-rule artifactId >
               < version >1.6.3 version >
               < scope >test scope >
         dependency >        
         
         < dependency >
               < groupId >org.powermock groupId >
               < artifactId >powermock-classloading-xstream artifactId >
               < version >1.6.3 version >
               < scope >test scope >
         dependency >

测试文件：

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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
package  com.oppo.os.ads.ad.cpd.app.service;
 
import  org.junit.Rule;
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.powermock.core.classloader.annotations.PrepareForTest;
import  org.powermock.modules.junit4.rule.PowerMockRule;
import  org.powermock.reflect.Whitebox;
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.test.context.ContextConfiguration;
import  org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import  static  org.mockito.Matchers.*;
 
import  com.oppo.os.ads.ad.cpd.app.entity.AdsAdBid;
 
@RunWith (SpringJUnit4ClassRunner. class ) 
@ContextConfiguration (locations= "classpath:dubbo/ad-cpd-app-svc.xml" )
public  class  AdsAdAppBidSrvTest {
     
     //@Rule
     //public PowerMockRule rule = new PowerMockRule();
 
     @Autowired
     AdsAdAppBidSrv appSrvImpl;
     
     @Test
     public  void  testAccOutDayBudgetString() {
         appSrvImpl.accOutDayBudget( "2839488" );
     }
 
     @Test
     public  void  testAccOutDayBudgetInt() {
         appSrvImpl.accOutDayBudget( 2839488 );
     }
 
     @Test
     public  void  testOutDayBudget() {
         appSrvImpl.outDayBudget( 5160 );
     }
 
     @Test
     public  void  testBalanceInsufficientString() {
         appSrvImpl.balanceInsufficient( "2839488" );
     }
 
     @Test
     public  void  testBalanceInsufficientLong() {
         appSrvImpl.balanceInsufficient( 2839488 );
     }
 
     @Test
     public  void  testAddAd() {
         AdsAdBid bid =  new  AdsAdBid();
         bid.setId(5160L);
         appSrvImpl.addAd(bid);
     }
 
     @Test
     public  void  testUpdateAd() {
         AdsAdBid bid =  new  AdsAdBid();
         bid.setId(5160L);
         bid.setName( "789798" );
         appSrvImpl.updateAd(bid);
     }
     
 
     @Test
     public  void  testStartAd() {
         appSrvImpl.startAd( 5160 );
     }
 
     @Test
     public  void  testPauseAd() {
         AdsAdBid bid =  new  AdsAdBid();
         bid.setId(5160L);
         appSrvImpl.pauseAd(bid);
     }
     
     @Test
     public  void  testDeleteAdCache()  throws  Exception {
 
         Whitebox.invokeMethod(appSrvImpl, "deleteAdCache" ,  "1001" );
     }
 
 
}



禁用非预期行为

新增类BaseEntity：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public  class  BaseEntity {
 
     static  {
         String x =  null ;
         x.toString();
     }
     
     public  BaseEntity() {
         throw  new  UnsupportedOperationException();
     }
     
     protected  void  performAudit(String auditInformation) {
         throw  new  UnsupportedOperationException();
     }
}

修改类Department：

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
public  class  Department  extends  BaseEntity {
 
     private  int  departmentId;
     private  String name;
     
     public  Department( int  departmentId) {
         super ();
         this .departmentId = departmentId;
     }
     
     public  void  setName(String name) {
         this .name = name;
         super .performAudit( this .name);
     }    
     
     protected  void  performAudit(String auditInformation) {
         throw  new  UnsupportedOperationException();
     }
     
     public  Object getDepartmentId() {
         return  departmentId;
     }
     
     public  Object getName() {
         return  name;
     }
}

修改类DepartmentTest：

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
import  static  org.junit.Assert.*;
 
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.mockito.Mockito;
import  org.powermock.api.mockito.PowerMockito;
import  org.powermock.core.classloader.annotations.PrepareForTest;
import  org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;
import  org.powermock.modules.junit4.PowerMockRunner;
 
 
@RunWith (PowerMockRunner. class )
@PrepareForTest (Department. class )
@SuppressStaticInitializationFor ( "BaseEntity" )
public  class  DepartmentTest {
     
     @Test
     public  void  shouldSuppressTheBaseConstructorOfDepartment() {
         PowerMockito.suppress(PowerMockito.constructor(BaseEntity. class ));
         assertEquals( 10 ,  new  Department( 10 ).getDepartmentId());
     }
     
     @Test
     public  void  shouldSuppressThePerformAuditMethodOfBaseEntity() {
         PowerMockito.suppress(PowerMockito.constructor(BaseEntity. class ));
         PowerMockito.suppress(PowerMockito.method(BaseEntity. class ,  "performAudit" , String. class ));
         final  Department department =  new  Department( 18 );
         department.setName( "Mocking with PowerMock" );
         assertEquals( "Mocking with PowerMock" , department.getName());
     }
     
     @Test
         public  void  shouldSuppressTheInitializerForBaseEntity() {
         
             PowerMockito.suppress(PowerMockito.constructor(BaseEntity. class ));
             assertNotNull( new  Department( 18 ));
     }
}

注意测试代码并未试验成功。

PowerMockito.suppress(PowerMockito.constructor(BaseEntity.class));表示禁用BaseEntity的构造函数。PowerMockito.suppress(PowerMockito.constructor(BaseEntity.class, String.class, Integer.class))后面表示带字符串和整数参数。

PowerMockito.suppress(PowerMockito.method(BaseEntity.class, "performAudit", String.class))表示禁用BaseEntity的performAudit方法。

@SuppressStaticInitializationFor("BaseEntity")表示禁用BaseEntity的静态初始化。注意引号部分通常需要全名，比如"com.gitshah.powermock.BaseEntity"。

PowerMockito.suppress(PowerMockito.field(BaseEntity.class,"identifier"))：禁用域。

参考资料

简明教程： https://github.com/jayway/powermock

https://github.com/jayway/powermock/wiki/MockitoUsage

https://www.ibm.com/developerworks/cn/java/j-lo-powermock/

 书籍：Instant Mock Testing with PowerMock

你可能感兴趣的:(单元测试)

  • Python 课程10-单元测试 可愛小吉 Python教學python单元测试开发语言TDDunittest
    前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
  • 228.第一个错误的版本 vbuer
    你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有n个版本[1,2,...,n]，你想找出导致之后所有版本出错的第一个错误的版本。你可以通过调用boolisBadVersion(version)接口来判断版本号version是否在单元测试中出错。实现一个函数来查找第一个错
  • 5-【JavaWeb】JUnit 单元测试及JUL 日志系统 weixin_44329069 JavaWebjunit单元测试
    1.使用JUnit进行单元测试JUnit是Java中非常流行的单元测试框架，MyBatis与JUnit可以很好地结合，来测试持久层代码的正确性。1.1添加JUnit依赖在使用JUnit之前，需要在pom.xml中引入JUnit依赖。junitjunit4.13.2test1.2单元测试基本结构假设我们要测试UserMapper中的getUserById方法，测试代码如下：importorg.apa
  • 关于测试的个人理解 低调_0c1d
    针对测试，专业的知识可以自行百度我只谈谈我目前的理解：我目前理解的测试包含两方面：单元测试和集成测试我理解的单元测试是，以一个类的一个方法的单元测试为例，我只关心方法是要干什么的，输入是什么，预期输出是什么，将预期输出和实际的输出进行比对（用志勇哥说的断言），想必有些同学可能会说如果这方法依赖了其他的类，那么此时就可以使用睿哥说的mockito了，我理解的mock就是伪造处一个被依赖的类的方法的输
  • 深入理解单元测试 元闰子 单元测试log4j
    荐语本文要介绍的是2020年O’Reilly出版的书籍UnitTestingPrinciples,Practices,andPatterns，一本在豆瓣评分高达9.9的好书。作为一名软件开发工程师，你应该对单元测试（unittest）很熟悉，但单元测试的目的、Mock的正确用法、单元测试和集成测试的区别等等，你真的懂吗？书中对这些内容都做了深入的介绍，并通过实际案例教你如何写出好的单元测试。读完这
  • 手撸vue3核心源码——响应式原理(isRef和unRef) 前端不是渣男 前端vue.js
    今天来实现一下ref的功能函数，isRef与unRefisRefisRef和isReactive一样，都是用于检测数据类型，isRef是检测是不是一个ref对象,跟isReactive函数实现起来一样,我们先来写一个单元测试这里要实现的功能是，检测ref对象肯定就通过返回true，检测普通类型数据以及reactive对象都是falseit("itshouldreturnaboolean",()=>
  • 编程小技巧 风的低语
    40条真言，希望对进阶中的程序朋友有所帮助。1、重构是程序员的主力技能。2、工作日志能提升脑容量。3、先用profiler调查，才有脸谈优化。4、注释贵精不贵多。杜绝大姨妈般的“例注”。漫山遍野的碎碎念注释，实际就是背景噪音。5、普通程序员+google=超级程序员。6、单元测试总是合算的。7、不要先写框架再写实现。最好反过来，从原型中提炼框架。8、代码结构清晰，其它问题都不算事儿。9、好的项目作
  • 测者的测试技术手册：Junit执行单元测试用例成功，mvn test却失败的问题和解决方法 Criss陈磊
    今天遇见了一个奇怪的问题，在IDE中rununittest，全部cases都成功了，但是后来通过mvntest运行case确保错了。在寻求原因的同时也找到了对应的解决方法。RunUnitTest和Maventest的区别差异1：在IDE中通过选中单元测试路径，点击右键选择runtest和点击maven中的test是有区别的。在Maven执行测试的过程中，是不允许测试cases访问其他项目的测试类和
  • 2021-04-06笔试 嘿_叫我小王
    1.用图画出产品研发周期中软件测试的不同阶段，并加以适当描述单元测试、集成测试、系统测试、验收测试单元测试：系统最小可测试的单元集成测试：将各个单元连接起来，穿插接口数据是否受到影响系统测试:范围包括--功能测试，ui测试，性能测试，兼容性测试，用户体验测试，安装测试，文档测试，稳定性测试验收测试:在UAT测试之前，指定测试方案，选用基线测试，即最高级别的测试。在UAT测试环境上进行测试，如果通过
  • Delta3D（3）教程介绍 deverwh Delta3DDelta3D
    从这里开始，按照官方的英文文档开始了Delta3D的教程部分。这部分的教程将会通过很多Delta3D工程的方方面面指导你学习Delta3D。这些教程的主要目的是指导那些具备基本C++知识的人，怎么使用基于游戏的仿真引擎-Delta3D来开发虚拟的仿真应用。更多的例程在delta3d/examples中，并且还有超过20000行的单元测试代码。怎么开始由于项目里有很多教程、Demo应用、测试示例等，
  • 【时时三省】tessy 单元测试 && 集成测试 专栏 文章阅读说明 时时三省 &&集成测试集成测试单元测试
    目录1，关于更新2，关于文章阅读3，关于文章分类1，单元测试2，集成测试3，通用便捷操作4，编译问题集锦5，需求管理6，CTE的使用7，tessy自动化执行用例----通过bat命令行接口山不在高，有仙则名。水不在深，有龙则灵。----CSDN时时三省1，关于更新tessy专栏里面的文章，会持续更新。更新时，目录也会同步更新。所以此专栏的读者如果遇到在此专栏中未介绍的问题，或者此专栏对于哪些方面，
  • 常用C语言单元测试工具介绍 不安分的小女孩博客 c语言单元测试开发语言
    常用C语言单元测试工具介绍单元测试准则C/C++怎么做好单元测试最完整的自动化测试流程软件测试用例自动生成技术研究论文单元测试是保证软件质量非常有效的手段，无论是从测试理论早期介入测试的理念来看或是从单元测试不受UI影响可以高速批量验证的特性，所以业界所倡导的测试驱动开发，这个里面提到的测试驱动更多的就是指单元测试驱动。但一般开发团队还是很少的系统化的执行单元测试，针对应用软件的测试更多是由专业测
  • 编写单元测试 纣王家子迎新 java单元测试java学习JUnitMockito
    编写单元测试是Java开发中一个非常重要的环节，它有助于确保代码的正确性和稳定性。JUnit在Java中，JUnit是最常用的单元测试框架之一。下面我将为你概述如何使用JUnit来编写单元测试。1.添加JUnit依赖首先，确保你的项目中已经添加了JUnit的依赖。如果你使用的是Maven项目，可以在pom.xml文件中添加如下依赖（以JUnit5为例）：org.junit.jupiterjunit
  • 软件测试题(1) 妙舞汉宫人 软件测试软件测试
    1.有关"测试驱动开发"，下列说法正确的有？正确答案:ABCDA.TDD的原理是在开发功能代码之前，先编写单元测试用例代码，测试代码确定需要编写什么产品代码B.TDD的基本思路就是通过测试来推动整个开发得进行，但测试驱动开发并不只是单纯的测试工作，而是把需求分析，设计，质量控制量化的过程。C.TDD的重要目的不仅仅是测试软件，测试工作保证代码质量仅仅是其中一部分，而且是在开发过程中帮助客户和程序员
  • 软件工程实践第二次作业——个人实战 Veteran_C 随笔链表指针数据结构
    这个作业属于哪个课程2022福大-软件工程、实践-W班这个作业要求在哪里软件工程实践第二次作业——个人实战这个作业的目标实现一个命令行程序，根据一定的运行格式可以输出22年冬奥会的奖牌总榜以及每日赛程，自行设计单元测试，填写PSP表格，按照要求将文件上传到gitcode上，同时为这次的作业编写对应的博客，做好总结和反思。其他参考文献Git入门，邹欣老师的单元测试和回归测试一、Gitcode项目地址
  • unittest | 使用unittest模块来测试logging日志模块功能 胜天半月子 Python基础及应用unittestdanyuanlogging单元测试
    我们在这篇文章实现了在项目工程中编写一个logging模块，但是我们如何确定我们编写的模块功能的是否正常?你可能想到将全部代码写完后运行测试，但这是一个非常不好的习惯。❌最好的方式，是每写出来一个功能或者方法就对它进行测试，这样可以确保，当你完成代码后并运行，可以很少出现Bug,能直接运行成功。可以使用Python自带的unittest模块来做✔单元测试unittestlogging单元测试log
  • maven工程使用sonar tommyhxh
    maven项目配置maven的setting.xml文件Maven插件会自动把所需数据（如单元测试结果、静态检测结果等）上传到Sonar服务器上，Sonar的配置并不在每个工程的pom.xml文件里，而是在Maven的配置文件settings.xml里。在标签添加：sonartruejdbc:mysql://10.16.8.96:3306/sonar?useUnicode=true&cha
  • 如何使用Spring Boot进行单元测试 好哈优学编程 springboot单元测试java
    1.添加依赖:确保pom.xml中包含spring-boot-starter-test依赖。它包括JUnit、AssertJ、Hamcrest等测试框架。org.springframework.bootspring-boot-starter-testtest2.编写测试类:在src/test/java目录下创建一个测试类。确保该类位于与待测试类相同的包或其子包中。@SpringBootTestpu
  • 【如何预防商城系统BUG？】 启山智软 商城 源码 bug
    前言预防商城系统BUG的关键在于采取一系列的质量控制和风险管理措施。以下是一些策略：1需求分析与规划：在开发之前，彻底分析需求，创建详细的设计和开发计划。2代码标准与审查：制定编码标准，并通过团队内部的代码审查来确保代码质量。3单元测试：编写单元测试来验证代码的每个部分是否按预期工作。4集成测试：整合不同模块后，进行全面的接口和交互测试。5功能测试：测试软件的所有功能是否按照业务要求执行。6性能测
  • Springboot 项目中引入WebSocket后，单元测试出现错误，前端开发揭秘 杭州湾Java仔 2024年前端程序员springbootwebsocket单元测试
    java.lang.IllegalStateException:FailedtoloadApplicationContextatorg.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(DefaultCacheAwareContextLoaderDelegate.java:12
  • IDEA 常用插件推荐，美观又实用！ 攀小黑 intellij-ideajavaide
    1、TONGYlLingma-YourAlCodingAssistant.Typeless,Codemore.通义灵码，是一款基于通义大模型的智能编码辅助工具，提供行级/函数级实时续写、自然语言生成代码、单元测试生成、代码注释生成、代码解释、研发智能问答、异常报错排查等能力，并针对阿里云SDK/API的使用场景调优，为开发者带来高效、流畅的编码体验。兼容VisualStudioCode、Visua
  • 使用 Visual Studio 通过 .NET 测试 .NET 类库 51Aspx源码服务专家 VisualStudioVisualStudio云原生开发挑战赛51Aspx
    本教程演示如何通过将测试项目添加到解决方案来自动执行单元测试。先决条件本教程适用于在使用VisualStudio创建.NET类库源社区中创建的解决方案。创建单元测试项目单元测试在开发和发布期间提供自动化的软件测试。MSTest是可供选择的三个测试框架之一。其他两个是xUnit和nUnit。启动VisualStudio。打开在ClassLibraryProjects中创建的ClassLibraryP
  • C++，如何写单元测试用例？ 智驾 C/C++c++测试用例单元测试googletest
    文章目录1.概述1.1什么是单元测试？1.2为什么要做单元测试？2.写测试用例的方法3.编写测试用例的通用原则3.1目的性原则3.2独立性原则3.3可重复性原则3.4小规模原则3.5一致性原则3.6自动化原则3.7边界条件原则3.8错误检测原则3.9性能原则3.10代码覆盖原则3.11数据驱动原则3.12安全原则参考1.概述1.1什么是单元测试？单元测试是软件开发过程中的一种重要测试方法，它专注于
  • SpringData JPA之Respository接口的使用 OVA_Won SpringDatamysqljavaspring
    SpringDataJPA之Respository接口的使用Respository：最顶层的接口也是标志接口，目的是为了统一所有Repository的类型，且能让组件扫描的时候自动识别。准备工作导入JAR包：别忘了导入Junit测试包，否则后面没法单元测试编写Spring和数据库配置文件applicationContext.xml文件com.OVA.pojojdbc.propertiesjdbc.
  • SpringBoot学习（12）测试打包部署 星河漫漫l springboot学习开发语言运维开发java
    开发阶段单元测试在开发阶段的时候最重要的是单元测试了，SpringBoot对单元测试的支持已经很完善了。1、在pom包中添加spring-boot-starter-test包引用org.springframework.bootspring-boot-starter-testtest2、开发测试类以最简单的helloworld为例，在测试类的类头部需要添加：@RunWith(SpringRunner
  • sap 项目总结 weixin_34405332 测试
    SAP项目实施总结(转)项目还没结束，但很多经验已经可以开始总结了。对于这个项目，不完善的地方有很多，有我们自己的问题，也有用户的问题。从顾问自己的角度去看――我们可以做的更好。我们的SAP的项目包括以下的部分：项目前期调研SAP产品入门培训企业需求确定（蓝图）系统配置顾问内部测试用户操作培训用户单元测试用户集成测试项目最终培训系统交付与支持从我参与的情况来看，有几个部分是需要所有SAP实施顾问尤
  • linux项目实施总结,[转载]SAP项目实施总结 lucyjones linux项目实施总结
    项目还没结束，但很多经验已经可以开始总结了。对于这个项目，不完善的地方有很多，有我们自己的问题，也有用户的问题。从顾问自己的角度去看――我们可以做的更好。我们的SAP的项目包括以下的部分：项目前期调研SAP产品入门培训企业需求确定(蓝图)系统配置顾问内部测试用户操作培训用户单元测试用户集成测试项目最终培训系统交付与支持从我参与的情况来看，有几个部分是需要所有SAP实施顾问尤其是初级顾问应该注意的：
  • 记一次spring boot自带的tomcat与websocket冲突 listenFeng. JAVA
    记一次springboot自带的tomcat与websocket冲突问题解决方式问题项目新集成了websocket，然后在执行单元测试时报错，报错如下Causedby:org.springframework.beans.factory.BeanCreationException:Errorcreatingbeanwithname'serverEndpointExporter'definedincl
  • 软件测试单元测试题库 FCC998 软件测试单元测试
    一、2023年国赛赛题题目1：任意输入2个正整数值分别存入x、y中，据此完成下述分析：若x≤0或y≤0，则提示：“输入不符合要求。”；若2值相同，则提示“可以构建圆形或正方形”；若25，则提示“可以构建矩形”；若0=5){result="可以构建椭矩形";}else{result="可以构建长方形";}returnresult;}}测试代码：publicclassTestCs01{Cs01cs01
  • 通义灵码怎么样？分为哪些版本，看看基础能力多少分？ 阿里云云原生 阿里云云原生通义灵码
    通义灵码，是一款基于通义大模型的智能编码辅助工具，提供行级/函数级实时续写、自然语言生成代码、单元测试生成、代码优化、注释生成、代码解释、研发智能问答、异常报错排查等能力，并针对阿里云的云服务使用场景调优，助力开发者高效、流畅的编码。下载使用通义灵码：https://tongyi.aliyun.com/lingma核心场景代码智能生成经过海量优秀开源代码数据训练，可根据当前代码文件及跨文件的上下文
  • 强大的销售团队背后 竟然是大数据分析的身影 蓝儿唯美 数据分析
    Mark Roberge是HubSpot的首席财务官，在招聘销售职位时使用了大量数据分析。但是科技并没有挤走直觉。 大家都知道数理学家实际上已经渗透到了各行各业。这些热衷数据的人们通过处理数据理解商业流程的各个方面，以重组弱点，增强优势。 Mark Roberge是美国HubSpot公司的首席财务官，HubSpot公司在构架集客营销现象方面出过一份力——因此他也是一位数理学家。他使用数据分析
  • Haproxy+Keepalived高可用双机单活 bylijinnan 负载均衡keepalivedhaproxy高可用
    我们的应用MyApp不支持集群，但要求双机单活（两台机器：master和slave）： 1.正常情况下，只有master启动MyApp并提供服务 2.当master发生故障时，slave自动启动本机的MyApp，同时虚拟IP漂移至slave，保持对外提供服务的IP和端口不变 F5据说也能满足上面的需求，但F5的通常用法都是双机双活，单活的话还没研究过 服务器资源 10.7
  • eclipse编辑器中文乱码问题解决 0624chenhong eclipse乱码
    使用Eclipse编辑文件经常出现中文乱码或者文件中有中文不能保存的问题，Eclipse提供了灵活的设置文件编码格式的选项，我们可以通过设置编码 格式解决乱码问题。在Eclipse可以从几个层面设置编码格式：Workspace、Project、Content Type、File 本文以Eclipse 3.3（英文）为例加以说明： 1. 设置Workspace的编码格式： Windows-&g
  • 基础篇--resources资源 不懂事的小屁孩 android
    最近一直在做java开发，偶尔敲点android代码，突然发现有些基础给忘记了，今天用半天时间温顾一下resources的资源。 String.xml    字符串资源   涉及国际化问题  http://www.2cto.com/kf/201302/190394.html   string-array
  • 接上篇补上window平台自动上传证书文件的批处理问卷 酷的飞上天空 window
    @echo off : host=服务器证书域名或ip，需要和部署时服务器的域名或ip一致 ou=公司名称, o=公司名称 set host=localhost set ou=localhost set o=localhost set password=123456 set validity=3650 set salias=s
  • 企业物联网大潮涌动：如何做好准备？ 蓝儿唯美 企业
    物联网的可能性也许是无限的。要找出架构师可以做好准备的领域然后利用日益连接的世界。 尽管物联网（IoT）还很新，企业架构师现在也应该为一个连接更加紧密的未来做好计划，而不是跟上闸门被打开后的集成挑战。“问题不在于物联网正在进入哪些领域，而是哪些地方物联网没有在企业推进，” Gartner研究总监Mike Walker说。 Gartner预测到2020年物联网设备安装量将达260亿，这些设备在全
  • spring学习——数据库（mybatis持久化框架配置） a-john mybatis
    Spring提供了一组数据访问框架，集成了多种数据访问技术。无论是JDBC，iBATIS(mybatis)还是Hibernate，Spring都能够帮助消除持久化代码中单调枯燥的数据访问逻辑。可以依赖Spring来处理底层的数据访问。 mybatis是一种Spring持久化框架，要使用mybatis，就要做好相应的配置： 1，配置数据源。有很多数据源可以选择，如：DBCP，JDBC，aliba
  • Java静态代理、动态代理实例 aijuans Java静态代理
    采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。 按照代理类的创建时期，可以分为：静态代理和动态代理。 所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。 所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。   一、静态代理类实例： 1、Serivce.ja
  • Struts1与Struts2的12点区别 asia007 Struts1与Struts2
    1) 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的P
  • 初学者要多看看帮助文档 不要用js来写Jquery的代码 百合不是茶 jqueryjs
    解析json数据的时候需要将解析的数据写到文本框中,  出现了用js来写Jquery代码的问题;   1, JQuery的赋值  有问题    代码如下: data.username 表示的是:  网易            $("#use
  • 经理怎么和员工搞好关系和信任 bijian1013 团队项目管理管理
            产品经理应该有坚实的专业基础，这里的基础包括产品方向和产品策略的把握，包括设计，也包括对技术的理解和见识，对运营和市场的敏感，以及良好的沟通和协作能力。换言之，既然是产品经理，整个产品的方方面面都应该能摸得出门道。这也不懂那也不懂，如何让人信服？如何让自己懂？就是不断学习，不仅仅从书本中，更从平时和各种角色的沟通
  • 如何为rich:tree不同类型节点设置右键菜单 sunjing contextMenutreeRichfaces
    组合使用target和targetSelector就可以啦，如下： <rich:tree id="ruleTree" value="#{treeAction.ruleTree}" var="node" nodeType="#{node.type}" selectionChangeListener=&qu
  • 【Redis二】Redis2.8.17搭建主从复制环境 bit1129 redis
    开始使用Redis2.8.17 Redis第一篇在Redis2.4.5上搭建主从复制环境，对它的主从复制的工作机制，真正的惊呆了。不知道Redis2.8.17的主从复制机制是怎样的，Redis到了2.4.5这个版本，主从复制还做成那样，Impossible is nothing! 本篇把主从复制环境再搭一遍看看效果，这次在Unbuntu上用官方支持的版本。   Ubuntu上安装Red
  • JSONObject转换JSON--将Date转换为指定格式 白糖_ JSONObject
    项目中，经常会用JSONObject插件将JavaBean或List<JavaBean>转换为JSON格式的字符串，而JavaBean的属性有时候会有java.util.Date这个类型的时间对象，这时JSONObject默认会将Date属性转换成这样的格式：   {"nanos":0,"time":-27076233600000,
  • JavaScript语言精粹读书笔记 braveCS JavaScript
    【经典用法】：   //①定义新方法 Function .prototype.method=function(name, func){ this.prototype[name]=func; return this; } //②给Object增加一个create方法，这个方法创建一个使用原对
  • 编程之美-找符合条件的整数 用字符串来表示大整数避免溢出 bylijinnan 编程之美
    import java.util.LinkedList; public class FindInteger { /** * 编程之美 找符合条件的整数 用字符串来表示大整数避免溢出 * 题目：任意给定一个正整数N，求一个最小的正整数M(M>1)，使得N*M的十进制表示形式里只含有1和0 * * 假设当前正在搜索由0，1组成的K位十进制数
  • 读书笔记 chengxuyuancsdn 读书笔记
    1、Struts访问资源 2、把静态参数传递给一个动作 3、<result>type属性 4、s:iterator、s:if c:forEach 5、StringBuilder和StringBuffer 6、spring配置拦截器 1、访问资源 (1)通过ServletActionContext对象和实现ServletContextAware,ServletReque
  • [通讯与电力]光网城市建设的一些问题 comsci 问题
          信号防护的问题,前面已经说过了,这里要说光网交换机与市电保障的关系       我们过去用的ADSL线路,因为是电话线,在小区和街道电力中断的情况下,只要在家里用笔记本电脑+蓄电池,连接ADSL,同样可以上网........     
  • oracle 空间RESUMABLE daizj oracle空间不足RESUMABLE错误挂起
    空间RESUMABLE操作  转 Oracle从9i开始引入这个功能，当出现空间不足等相关的错误时，Oracle可以不是马上返回错误信息，并回滚当前的操作，而是将操作挂起，直到挂起时间超过RESUMABLE TIMEOUT，或者空间不足的错误被解决。 这一篇简单介绍空间RESUMABLE的例子。 第一次碰到这个特性是在一次安装9i数据库的过程中，在利用D
  • 重构第一次写的线程池 dieslrae 线程池 python
    最近没有什么学习欲望,修改之前的线程池的计划一直搁置,这几天比较闲,还是做了一次重构,由之前的2个类拆分为现在的4个类. 1、首先是工作线程类:TaskThread,此类为一个工作线程,用于完成一个工作任务,提供等待(wait),继续(proceed),绑定任务(bindTask)等方法 #!/usr/bin/env python # -*- coding:utf8 -*-
  • C语言学习六指针 dcj3sjt126com c
    初识指针，简单示例程序： /* 指针就是地址，地址就是指针 地址就是内存单元的编号 指针变量是存放地址的变量 指针和指针变量是两个不同的概念 但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样 */ # include <stdio.h> int main(void) { int * p; // p是变量的名字， int *
  • yii2 beforeSave afterSave beforeDelete dcj3sjt126com delete
    public function afterSave($insert, $changedAttributes) { parent::afterSave($insert, $changedAttributes); if($insert) { //这里是新增数据 } else { //这里是更新数据 } }  
  • timertask shuizhaosi888 timertask
    java.util.Timer timer = new java.util.Timer(true); // true 说明这个timer以daemon方式运行（优先级低， // 程序结束timer也自动结束），注意，javax.swing // 包中也有一个Timer类，如果import中用到swing包， // 要注意名字的冲突。 TimerTask task = new
  • Spring Security（13）——session管理 234390216 sessionSpring Security攻击保护超时
    session管理 目录   1.1     检测session超时 1.2     concurrency-control 1.3     session 固定攻击保护         
  • 公司项目NODEJS实践0.3[ mongo / session ...] 逐行分析JS源代码 mongodbsessionnodejs
        http://www.upopen.cn   一、前言         书接上回，我们搭建了WEB服务端路由、模板等功能，完成了register 通过ajax与后端的通信，今天主要完成数据与mongodb的存取，实现注册 / 登录 /
  • pojo.vo.po.domain区别 LiaoJuncai javaVOPOJOjavabeandomain
    　　POJO = "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者 SessionBean。POJO不但当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB， JDBC等等。 　　 　　即POJO是一个简单的普通的Java对象，它包含业务逻辑
  • Windows Error Code OhMyCC windows
    0 操作成功完成. 1 功能错误. 2 系统找不到指定的文件. 3 系统找不到指定的路径. 4 系统无法打开文件. 5 拒绝访问. 6 句柄无效. 7 存储控制块被损坏. 8 存储空间不足, 无法处理此命令. 9 存储控制块地址无效. 10 环境错误. 11 试图加载格式错误的程序. 12 访问码无效. 13 数据无效. 14 存储器不足, 无法完成此操作. 15 系
  • 在storm集群环境下发布Topology roadrunners 集群stormtopologyspoutbolt
    storm的topology设计和开发就略过了。本章主要来说说如何在storm的集群环境中，通过storm的管理命令来发布和管理集群中的topology。   1、打包 打包插件是使用maven提供的maven-shade-plugin，详细见maven-shade-plugin。 <plugin> <groupId>org.apache.maven.
  • 为什么不允许代码里出现“魔数” tomcat_oracle java
    　　在一个新项目中，我最先做的事情之一，就是建立使用诸如Checkstyle和Findbugs之类工具的准则。目的是制定一些代码规范，以及避免通过静态代码分析就能够检测到的bug。 　　迟早会有人给出案例说这样太离谱了。其中的一个案例是Checkstyle的魔数检查。它会对任何没有定义常量就使用的数字字面量给出警告，除了-1、0、1和2。 　　很多开发者在这个检查方面都有问题，这可以从结果
  • zoj 3511 Cake Robbery(线段树) 阿尔萨斯 线段树
    题目链接：zoj 3511 Cake Robbery 题目大意：就是有一个N边形的蛋糕，切M刀，从中挑选一块边数最多的，保证没有两条边重叠。 解题思路：有多少个顶点即为有多少条边，所以直接按照切刀切掉点的个数排序，然后用线段树维护剩下的还有哪些点。 #include <cstdio> #include <cstring> #include <vector&
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他