Jmock单元测试代码

package com.test.mock;


import java.lang.reflect.Field;
import org.junit.Test;
import static org.mockito.Mockito.*;  
import static org.junit.Assert.*;  
import mockit.Deencapsulation;
import mockit.Expectations;
import mockit.Mock;
import mockit.MockUp;
import mockit.Mocked;
import mockit.Mockit;
import mockit.NonStrictExpectations;
import mockit.Verifications;


public class MyServiceTest {



    //    模拟方法返回值
    @Test
    public void testFetchData() throws Exception{
        MyService service = mock(MyService.class);
        when(service.fetchData(anyString())).thenReturn("123456789");
        System.out.println(service.fetchData("test"));
        service.setUrl("www.baidu.com");
        System.out.println(service.getUrl());
        //anyString 任意值
    }

    //    用反射 设置属性值
    @Test
    public void testFetch() throws Exception {
        MyService service =  new MyService();
        Field field = service.getClass().getDeclaredField("url");
        field.setAccessible(true);
        field.set(service, "1111");
        System.out.println(service.getUrl());
    }


    //    模拟属性返回值
    @Test
    public void testFetchData1() {
        MyService service =  new MyService();
        new Expectations() {
            {
                Deencapsulation.invoke(MyService.class, "fetchData", "Unmi");
                result = "http://unmi.cc";
            }
        };
        String actual = service.fetchData("Unmi");
        System.out.println(actual);
        System.out.println(service.getUrl());

    }

    @Mocked  //用@Mocked标注的对象，不需要赋值，jmockit自动mock  
    MyService obj;  

    @Test  
    public void testHello() {  
        new NonStrictExpectations() {//录制预期模拟行为  
            {  
                obj.fetchData("Zhangsan");  
                returns("Hello Zhangsan");  
                //也可以使用：result = "Hello Zhangsan";  
            }  
        };  
        assertEquals("Hello Zhangsan", obj.fetchData("Zhangsan"));//调用测试方法  
        new Verifications() {//验证预期Mock行为被调用  
            {  
                obj.fetchData("Hello Zhangsan");  
                times = 1;  
            }  
        };  
    }  



    @Test  
    public void testMockNormalMethodContent() throws Exception {  
        MyService obj = new MyService();  
        new MockUp<MyService>() {//使用MockUp修改被测试方法内部逻辑  
            @Mock  
            public String fetchData(String i) {  
                return "00";  
            }  
        };  
        System.out.println(obj.fetchData("1"));
        System.out.println(obj.getUrl());
        assertEquals("00", obj.fetchData("1"));  
        assertEquals("00", obj.fetchData("1"));  
        Mockit.tearDownMocks();//注意：在JMockit1.5之后已经没有Mockit这个类，使用MockUp代替，mockUp和tearDown方法在MockUp类中  
    }  





    @Mocked
    private  MyService mt= null;
    @Test
    public void testJmocked1(){
        new Expectations(){
            {
                mt.getUrl();  
                result = "www.baidu.com";  
                mt.fetchData("dd");
                result="fafa";
            }
        };
        System.out.println(mt.getUrl());
        System.out.println(mt.fetchData("dd"));
    }

    @Test
    public void testJmocked2(){
        new NonStrictExpectations(){
            {
                mt.test();
                result=true;
                mt.getUrl();  
                result = "www.baidu.com";  
                
            }
        };
        System.out.println(mt.getUrl());
        System.out.println(mt.fetchData("dd"));
        System.out.println(mt.test());
    }
    
     @Mocked(methods = { "test" }, inverse = false)  
        // 声明的方法可以使用正则表达式  
        // methods 代表只有声明的方法才会进行mock, inverse  
        // 代表是否反转声明，如果inverse=true，那么就是除了声明的方法不mock  
     private MyService myMethod=new MyService();
    
    @Test
    public void testPrivateMethodMock() {
        new NonStrictExpectations(new MyService()) {
            {
                myMethod.test();
                result=true;
            }
        };
        System.out.println(myMethod.test());
        System.out.println(myMethod.fetchData(""));
    }

    /*
     * 对私有成员变量进行设值的示例
     */  
    private @Mocked
    MyService MyPriv=new MyService();
    
    @Test
    public void MockPrivateMethod(){
        // 注意：这里使用了动态部分mock
        new Expectations(MyPriv) {  
            {  
                // 对私有的变量设置值
                this.setField(MyPriv, "name", "哈哈");  
            }  
        };  
        System.out.println(MyPriv.getname());
        System.out.println(MyPriv.getUrl());
    }
    
     @Test  
        /*
         * 对mock类型的私有成员方法进行mock的示例
         */  
        public void privateAccessMethod() {  
            // 注意：这里使用了动态部分mock  
            new Expectations(MyPriv) {  
                {  
                    // 对私有方法进行mock  
                    this.invoke(MyPriv, "getPriName");  
                    result = "测试私有方法";  
                }  
            };  
            System.out.println(MyPriv.testMockPrivateMethod());
        }  



    
    
    
      
     /**
      * 除了使用@MockUp的另一种基于状态的Mock，随穿随脱？
      *  
      * @author Ginge
      *  
      */  
     public static class ConstructorTest2 {  
         @Mocked  
         private MyService constructor = new MyService();  
      
         @Test  
         public void mockConstructor() {  
      
             // 可以在任意时候把Mock装置起来，不用的时候可以脱下来  
             Mockit.setUpMock(MyService.class, new MockedConstructor());  
      
             // 触发构造方法的mock  
             constructor=new MyService();  
             System.out.println(constructor.getname());
             // 注意咯，擦亮眼睛了，现在开始脱了  
             Mockit.tearDownMocks(MyService.class);  
             constructor = new MyService();  
             // 看到了吧，看到真容了  
             System.out.println(constructor.getname());  
         }  
     }  
    
     /**
      * MockedConstructor相当于一个标志，具体名称不重要，重要的要它里面被@Mock注解的方法。如果有方法被注解了@Mock，
      * 并且恰好方法的签名又和Mockit.setUpMock中声明的类型中的某个方法一样，那么对应的方法就被Mock
      * 为了方便才把这个类的声明放到ConstructorTest2里面的，其实这个类可以放到任何地方
      *  
      * @author Ginge
      *  
      */  
     public static class MockedConstructor {  
  
         @Mock  
         public String getname() {  
             return "mock_Constructor";  
         }  
     }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
     /**
      * mock实例中it代表实际的mock对象
      *  mock对象可以访问实体对象
      * @author Ginge
      *  
      */  
     public static class AccessRealInstanceTest {  
         //注意，这里少了@Mocked  
         private MyService constructor = new MyService();  
      
         @Test  
         public void mockConstructor() {  
      
             // 可以在任意时候把Mock装置起来，不用的时候可以脱下来  
             Mockit.setUpMock(MyService.class, new MockedConstructor());  
      
             //参数没有匹配到，直接返回了unknown  
             System.out.println(constructor.getRealInstanceName("2"));  
             //参数匹配到1，返回了实际对象方法调用的结果  
             System.out.println(constructor.getRealInstanceName("1"));
         }  
      
         /**
          * MockedConstructor相当于一个标志，具体名称不重要，重要的是它里面被@Mock注解的方法。如果有方法被注解了@Mock，
          * 并且恰好方法的签名又和Mockit.setUpMock中声明的类型中的某个方法一样，那么对应的方法就被Mock
          * 为了方便才把这个类的声明放到ConstructorTest2里面的，其实这个类可以放到任何地方
          *  
          * @author Ginge
          *  
          */  
         public class MockedConstructor{  
      
             //it属性表示实际对象  
             public MyService it;  
      
             @Mock(reentrant = true)//reentrant表示是否可以访问实际对象  
             public String getRealInstanceName(String m) {  
                 if ("1".equals(m)) {  
                     return it.judgeToOne(m);  
                 } else {  
                     return "unknown";  
                 }  
      
             }  
         }  
      
     }  
}