Java Mockito：验证（模拟）问题

真的很难解决这个问题，有人能帮我吗

很明显，我做了一些根本错误的事情，我试图验证每个模拟对象，但它似乎不起作用

 org.mockito.exceptions.misusing.UnfinishedVerificationException: 
 Missing method call for verify(mock) here:
 -> at     com.muuves.reservosity.service.TestProductServiceImpl.search_OneHourSlot_TwoBookingAvailable(TestProductServiceImpl.java:86)

 Example of correct verification:
verify(mock).doSomething()

Also, this error might show up because you verify either of: final/private/equals()  /hashCode() methods.
Those methods *cannot* be stubbed/verified.

at com.muuves.reservosity.service.TestProductServiceImpl.setUp(TestProductServiceImpl.java:41)
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:44)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:27)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:76)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

这是我的测试

import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

public class TestProductServiceImpl {    
    ProductServiceImpl instance;
    @Mock
    EntityManager em;
    @Mock
    CriteriaBuilder builder;
    @Mock 
    CriteriaQuery<Product_Details> c;
    @Mock
    Root<Product_Details> productRoot;
    @Mock
    TypedQuery<Product_Details> typedQuery;

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this); 
        instance = new  ProductServiceImpl();
        instance.setEm(em);
        instance.setCriteriaBuilder(builder);
        instance.setQuery(c);
        instance.setProductRoot(productRoot);
        instance.setTypedQuery(typedQuery);
    }

    @Test
    public void search_OneHourSlot_NoBookingAvailable() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("14:00-15:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(0, result.size());
    }
    @Test
    public void search_OneHourSlot_TwoBookingAvailable() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("14:00-17:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(1, result.size());
        Assert.assertEquals("2013-02-09 15:00", result.get(0).getTime());
        Assert.assertEquals("Google", result.get(0).getProductDetails().getProduct_Name());
    }

    @Test
    public void search_OneHourSlot_EndTimeAfterClosing() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("14:00-20:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(1, result.size());
        Assert.assertEquals("2013-02-09 15:00", result.get(0).getTime());
        Assert.assertEquals("Google", result.get(0).getProductDetails().getProduct_Name());
        verify(em);
    }

    @Test
    public void search__StartTimeBeforeOpening() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("08:00-13:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(3, result.size());
        Assert.assertEquals("2013-02-09 09:00", result.get(0).getTime());
        Assert.assertEquals("Google", result.get(0).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 10:00", result.get(1).getTime());
        Assert.assertEquals("Google", result.get(1).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 11:00", result.get(2).getTime());
        Assert.assertEquals("Google", result.get(2).getProductDetails().getProduct_Name());
    }
    @Test
    public void search__StartTimeAndEndTimeBeforeOpening() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("06:00-09:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(0, result.size());
    }
    @Test
    public void search__StartTimeAndEndTimeAfterClosing() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("17:00-21:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(0, result.size());
    }
    @Test
    public void search__StartTimeAndEndTimeExactlyOpeningClosing() {
        List<Product_Details> products = booking(60);
        when(em.getCriteriaBuilder()).thenReturn(builder);
        when(builder.createQuery(Product_Details.class)).thenReturn(c);
        when(c.from(Product_Details.class)).thenReturn(productRoot);
        when(em.createQuery(c)).thenReturn(typedQuery);
        when(typedQuery.getResultList()).thenReturn(products);
        Search search = new Search();
        search.setDate("2013-02-09");
        search.setLocation("Cork");
        search.setPrice("20");
        search.setTime("09:00-17:00");
        search.setType("Football");
        List<Search_Result> result = instance.search(search);
        Assert.assertEquals(5, result.size());
        Assert.assertEquals("2013-02-09 09:00", result.get(0).getTime());
        Assert.assertEquals("Google", result.get(0).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 10:00", result.get(1).getTime());
        Assert.assertEquals("Google", result.get(1).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 11:00", result.get(2).getTime());
        Assert.assertEquals("Google", result.get(2).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 13:00", result.get(3).getTime());
        Assert.assertEquals("Google", result.get(3).getProductDetails().getProduct_Name());
        Assert.assertEquals("2013-02-09 15:00", result.get(4).getTime());
        Assert.assertEquals("Google", result.get(4).getProductDetails().getProduct_Name());
    }
    private List<Product_Details> booking(int slot){
        List<Product_Details> products = new ArrayList<Product_Details>();
        Product_Details product = new Product_Details();
        product.setProduct_Name("Google");
        product.setSaturday_Open("09:00-17:00");
        product.setDates_Closed("2013-12-25");
        product.setTime_Per_Slot(slot);
        List<Booking_Details> bookings = new ArrayList<Booking_Details>();
        Booking_Details booking1 = new Booking_Details();
        booking1.setBooked_Date("2013-02-09 12:00");
        bookings.add(booking1);
        Booking_Details booking2 = new Booking_Details();
        booking2.setBooked_Date("2013-02-09 14:00");
        bookings.add(booking2);
        Booking_Details booking3 = new Booking_Details();
        booking3.setBooked_Date("2013-02-09 16:00");
        bookings.add(booking3);
        product.setBookings(bookings);
        products.add(product);
        return products;
    }
}

导入静态org.mockito.mockito.verify；
导入静态org.mockito.mockito.when；
导入java.util.ArrayList；
导入java.util.List；
导入javax.persistence.EntityManager；
导入javax.persistence.TypedQuery；
导入javax.persistence.criteria.CriteriaBuilder；
导入javax.persistence.criteria.CriteriaQuery；
导入javax.persistence.criteria.Root；
导入org.junit.Assert；
导入org.junit.Before；
导入org.junit.Test；
导入org.mockito.Mock；
导入org.mockito.MockitoAnnotations；
公共类TestProductServiceImpl{
ProductServiceImpl实例；
@嘲弄
实体管理器；
@嘲弄
标准制定者；
@嘲弄
标准查询；
@嘲弄
根产品根；
@嘲弄
类型查询类型查询；
@以前
公共作废设置（）{
initMocks（this）；
实例=新的ProductServiceImpl（）；
实例.setEm（em）；
setCriteriaBuilder（builder）；
setQuery（c）；
setProductRoot（productRoot）；
setTypedQuery（typedQuery）；
}
@试验
公共无效搜索\u一小时地段\u无可用图书（）{
列出产品=预订（60）；
当（em.getCriteriaBuilder（））。然后返回（builder）；
当（builder.createQuery（Product_Details.class）），然后返回（c）；
when（c.from（Product_Details.class）），然后return（productRoot）；
当（em.createQuery（c）），然后返回（typedQuery）；
当（typedQuery.getResultList（））。然后返回（产品）；
搜索=新搜索（）；
搜索设置日期（“2013-02-09”）；
搜索。设置位置（“软木”）；
search.setPrice（“20”）；
搜索设置时间（“14:00-15:00”）；
search.setType（“Football”）；
列表结果=instance.search（搜索）；
Assert.assertEquals（0，result.size（））；
}
@试验
公共无效搜索\u一小时地段\u两次预订可用（）{
列出产品=预订（60）；
当（em.getCriteriaBuilder（））。然后返回（builder）；
当（builder.createQuery（Product_Details.class）），然后返回（c）；
when（c.from（Product_Details.class）），然后return（productRoot）；
当（em.createQuery（c）），然后返回（typedQuery）；
当（typedQuery.getResultList（））。然后返回（产品）；
搜索=新搜索（）；
搜索设置日期（“2013-02-09”）；
搜索。设置位置（“软木”）；
search.setPrice（“20”）；
搜索设置时间（“14:00-17:00”）；
search.setType（“Football”）；
列表结果=instance.search（搜索）；
Assert.assertEquals（1，result.size（））；
Assert.assertEquals（“2013-02-09 15:00”，result.get（0.getTime（））；
Assert.assertEquals（“Google”，result.get（0.getProductDetails（）.getProduct_Name（））；
}
@试验
公共无效搜索\u一小时地段\u结束时间（）{
列出产品=预订（60）；
当（em.getCriteriaBuilder（））。然后返回（builder）；
当（builder.createQuery（Product_Details.class）），然后返回（c）；
when（c.from（Product_Details.class）），然后return（productRoot）；
当（em.createQuery（c）），然后返回（typedQuery）；
当（typedQuery.getResultList（））。然后返回（产品）；
搜索=新搜索（）；
搜索设置日期（“2013-02-09”）；
搜索。设置位置（“软木”）；
search.setPrice（“20”）；
搜索设置时间（“14:00-20:00”）；
search.setType（“Football”）；
列表结果=instance.search（搜索）；
Assert.assertEquals（1，result.size（））；
Assert.assertEquals（“2013-02-09 15:00”，result.get（0.getTime（））；
Assert.assertEquals（“Google”，result.get（0.getProductDetails（）.getProduct_Name（））；
验证（em）；
}
@试验
公开作废搜索\uuuu StartTimeBeforeOpening（）{
列出产品=预订（60）；
当（em.getCriteriaBuilder（））。然后返回（builder）；
当（builder.createQuery（Product_Details.class）），然后返回（c）；
when（c.from（Product_Details.class）），然后return（productRoot）；
当（em.createQuery（c）），然后返回（typedQuery）；
当（typedQuery.getResultList（））。然后返回（产品）；
搜索=新搜索（）；
搜索设置日期（“2013-02-09”）；
搜索。设置位置（“软木”）；
search.setPrice（“20”）；
搜索设置时间（“08:00-13:00”）；
search.setType（“Football”）；
列表结果=instance.search（搜索）；
Assert.assertEquals（3，result.size（））；
Assert.assertEquals（“2013-02-09 09:00”，result.get（0.getTime（））；
Assert.assertEquals（“Google”，result.get（0.getProductDetails（）.getProduct_Name（））；
Assert.assertEquals（“2013-02-09 10:00”，result.get（1.getTime（））；
Assert.assertEquals（“Google”，result.get（1.getProductDetails（）.getProduct_Name（））；
Assert.assertEquals（“2013-02-09 11:00”，result.get（2.getTime（））；
Assert.assertEquals（“Google”，result.get（2.getProductDetails（）.getProduct_Name（））；
}
@试验
公开无效搜索\uuu开始时间平均打开时间（）{
列出产品=预订（60）；
当（em.getCriteriaBuilder（））。然后返回（builder）；
当（builder.createQuery（Product_Details.class）），然后返回（c）；
when（c.from（Product_Details.class）），然后return（productRoot）；
当（em.createQuery（c）），然后返回（typedQuery）；
当（typedQuery.getResultList（））。然后返回（产品）；
搜索=新搜索（）；
搜索设置日期（“2013-02-09”）；
搜索。设置位置（“软木”）；
search.setPrice（“20”）；
搜索设置时间（“06:00-09:00”）；
search.setType（“Football”）；
列表结果=instance.search（搜索）；
Assert.assertEquals（0，result.size（））；
}
@试验
公共无效搜索\uuu StartTimeAndTimeAfterClosing（）{
列出产品=预订（60）；
@RunWith(MockitoJUnitRunner.class)
public class MailSenderTest {

    @Mock
    private JavaMailSender javaMailSender;

    @InjectMocks
    private MailSenderImpl mailSender;

    @Test
    public void testSendMail() {

        String from = "somemail@gmail.com";
        String to = "Danothermail@gmail.com";
        String title = "Test";
        String text = "Hello world!";

        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(from);
        message.setTo(to);
        message.setSubject(title);
        message.setText(text);

        mailSender.sendMail(to, title, text);

        Mockito.verify(javaMailSender).send(message);
    }

}

    verify(em).createQuery(c);
    verify(builder).createQuery(Product_Details.class);
    verify(c).from(Product_Details.class);
    verify(em).createQuery(c);
    verify(typedQuery).getResultList();