Mock 测试技术详解及高级特性，你不得不会的技能！

最新推荐文章于 2024-09-11 14:01:32 发布

大家都说我身材好

最新推荐文章于 2024-09-11 14:01:32 发布

阅读量5.4k

点赞数 3

分类专栏： Java高级文章标签： junit 单元测试 java

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/u012581020/article/details/130841773

版权

Java高级专栏收录该内容

70 篇文章 13 订阅

订阅专栏

Mock 是软件测试中常用的一种技术，它可以模拟外部依赖的行为和状态，以便进行更全面、准确和可靠的测试覆盖。Java 中的 Mock 框架是一个功能强大、易用的工具，可以帮助开发者快速、轻松地创建和配置 Mock 对象，并支持各种灵活的测试场景和需求。

本文将详细介绍 Java 中的 Mock 测试技术，包括 Mock 框架的基本概念和使用方法、Mockito 框架的高级特性和扩展技巧等内容。

一、Mock 测试的基本概念和原理

1.1 Mock 测试的定义和目的

Mock 测试是一种软件测试技术，它可以模拟外部依赖组件的行为和状态，以便进行独立、稳定和快速的测试。在实际软件开发中，我们常常需要依赖其他组件或服务来完成某些业务逻辑，例如数据库、网络连接、消息队列等等。这些外部依赖可能存在各种问题，例如不稳定、缺乏数据、难以模拟等等，从而影响我们对代码逻辑的测试、调试和优化。

Mock 测试可以解决这些问题，它通过构造和配置 Mock 对象来模拟外部依赖的行为和状态，从而使得测试变得独立、稳定和准确。Mock 测试的目的是隔离被测代码和外部依赖，消除随机性和不可控性，提高测试覆盖和质量，加速软件开发和迭代。

1.2 Mock 测试的原理和实现方式

Mock 测试的核心原理是基于模拟对象（Mock Object）的概念来实现的。模拟对象是一种特殊的对象，它可以模拟外部组件的行为和状态，以便进行测试。在 Java 中，我们可以使用 Mock 框架来创建和配置模拟对象，并使用相关 API 和工具进行断言和验证。

在实现时，Mock 测试通常分为三个阶段：定义 Mock 对象、设置 Mock 行为、执行测试和验证结果。首先，我们需要定义需要 Mock 的对象，并使用 Mock 框架的 API 创建 Mock 对象。其次，我们需要设置 Mock 对象的行为，包括返回值、抛出异常、执行逻辑等等。最后，我们通过测试代码调用 Mock 对象，并使用断言和验证方法来验证测试结果是否符合预期。

Mock 测试的实现方式主要有两种：手动编码和自动化工具。手动编码需要程序员自己编写 Mock 对象和相关代码，相对较为复杂和繁琐；而自动化工具可以帮助程序员快速、轻松地创建和配置 Mock 对象，并提供丰富的 API 和工具，例如 Mockito 等。

二、Java 中的 Mock 框架

2.1 Mock 框架的分类和特点

Java 中存在多种 Mock 框架，它们各有特点和适用场景。根据实现方式和功能特性，Java 中的 Mock 框架可以分为手动编码 Mock 和自动化 Mock 两类。

手动编码 Mock 是指程序员通过手动编写 Mock 对象和相关代码实现外部依赖的模拟，例如使用匿名内部类或桩对象等方式。手动编码 Mock 的优点是灵活、可控，可以满足各种特定的测试需求，但缺点是编码繁琐、维护成本高、可读性差等。

自动化 Mock 是指使用自动化工具和库来创建和配置 Mock 对象，例如 Mockito、EasyMock、PowerMock 等。自动化 Mock 的优点是方便、易用，可以大幅降低编码工作量和技术难度，同时提供丰富的 API 和工具支持，可以轻松应对各种复杂测试场景和需求。

在自动化 Mock 框架中，Mockito 是一种主流和优秀的测试工具，它提供了丰富的 Mock API 和工具，可以帮助程序员快速、轻松地创建和配置 Mock 对象，并支持各种灵活的测试场景和需求。下面我们将重点介绍 Mockito 框架的使用方法和高级特性。

2.2 Mockito 框架的基本用法

Mockito 框架提供了一系列的静态方法和类来创建和配置 Mock 对象，这些方法包括 mock()、when()、thenReturn()、any() 等等。在使用 Mockito 框架时，我们需要遵循以下几个基本步骤：

（1）创建 Mock 对象：使用 mock() 方法创建 Mock 对象，并指定需要 Mock 的类或接口。例如：

List<String> list = mock(List.class);

（2）设置 Mock 行为：使用 when() 方法设置 Mock 对象的行为，并使用 thenReturn()、thenThrow() 等方法指定返回值或异常。例如：

when(list.get(0)).thenReturn("mock");
when(list.size()).thenThrow(new RuntimeException());

（3）调用 Mock 对象：在测试代码中调用 Mock 对象的方法，并进行断言和验证。例如：

assertEquals("mock", list.get(0));
verify(list, times(1)).get(0);

需要注意的是，在使用 Mockito 框架时，我们应该考虑方法的访问修饰符和参数类型等因素，并尽可能保持被 Mock 对象的行为和状态与实际场景一致。

同时，Mockito 框架还提供了 Mock 注解、Mockito 插件和高级特性等功能，以帮助程序员更好地进行测试和开发。下面我们将详细介绍这些内容。

三、Mockito 框架的高级特性

3.1 Mockito 注解的使用

Mockito 框架提供了多种注解来简化测试代码的编写和维护，包括 @Mock、@InjectMocks、@Spy、@Captor 等等。这些注解可以帮助程序员自动创建和配置 Mock 对象，并解决 Mock 依赖和单元测试等问题。

（1）@Mock 注解

@Mock 注解用于指示需要 Mock 的类或接口，并自动创建 Mock 对象。在使用 @Mock 注解时，我们需要使用 MockitoJUnitRunner 或 MockitoAnnotations.initMocks() 方法来初始化 Mock 对象。

例如：

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    @Mock
    private MyDao myDao;

    @InjectMocks
    private MyServiceImpl myService;

    @Test
    public void testDoSomething() {
        when(myDao.getData()).thenReturn("mock");
        String result = myService.doSomething();
        assertEquals("mock", result);
    }
}

上面的代码中，我们使用 @Mock 注解指示需要 Mock 的 MyDao 接口，并使用 MockitoJUnitRunner 或 MockitoAnnotations.initMocks() 方法初始化 Mock 对象。接着，我们使用 @InjectMocks 注解指示需要注入的 MyServiceImpl 类，并在测试方法中设置 Mock 的行为和执行逻辑。

（2）@InjectMocks 注解

@InjectMocks 注解用于指示需要进行依赖注入的类，以便使用 Mock 对象。在使用 @InjectMocks 注解时，我们需要同时使用 @Mock 或 @Spy 注解来创建 Mock 对象或 Spy 对象。

例如：

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    @Mock
    private MyDao myDao;

    @Spy
    private MyUtils myUtils;

    @InjectMocks
    private MyServiceImpl myService;

    @Test
    public void testDoSomething() {
        when(myDao.getData()).thenReturn("mock");
        doReturn("stubbed").when(myUtils).doSomething();
        String result = myService.doSomething();
        assertEquals("mockstubbed", result);
    }
}

上面的代码中，我们使用 @Mock 和 @Spy 注解创建 MyDao 和 MyUtils 的 Mock 对象和 Spy 对象，并使用 @InjectMocks 注解指示需要注入的 MyServiceImpl 类。接着，我们使用 when() 和 doReturn() 方法指定 Mock 对象和 Spy 对象的行为和返回值，并在测试方法中进行断言和验证。

（3）@Spy 注解

@Spy 注解用于指示需要进行部分模拟的对象，并自动创建 Spy 对象。Spy 对象可以保留对象的原有状态和方法实现，并提供相关的函数和验证功能。

例如：

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    @Spy
    private MyUtils myUtils;

    @InjectMocks
    private MyServiceImpl myService;

    @Test
    public void testDoSomething() {
        doReturn("stubbed").when(myUtils).doSomething();
        String result = myService.doSomething();
        assertEquals("realstubbed", result);
    }
}

上面的代码中，我们使用 @Spy 注解创建 MyUtils 类的 Spy 对象，并使用 @InjectMocks 注解指示需要注入的 MyServiceImpl 类。接着，我们使用 doReturn() 方法指定 Spy 对象的行为和返回值，并在测试方法中进行断言和验证。

（4）@Captor 注解

@Captor 注解用于捕获 Mock 对象的参数值，以便进一步处理和验证。在使用 @Captor 注解时，我们需要使用 ArgumentCaptor 类来实例化 Captor 对象，并使用 when() 方法设置 Mock 对象的行为和返回值。

例如：

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    @Mock
    private MyDao myDao;

    @InjectMocks
    private MyServiceImpl myService;

    @Captor
    private ArgumentCaptor<String> captor;

    @Test
    public void testDoSomethingWithArgument() {
        when(myDao.getData(anyString())).thenReturn("mock");
        String result = myService.doSomethingWithArgument("test");
        assertEquals("mock", result);
        verify(myDao).getData(captor.capture());
        assertEquals("test", captor.getValue());
    }
}

上面的代码中，我们使用 @Mock 注解创建需要 Mock 的 MyDao 对象，并使用 @InjectMocks 注解注入 MyServiceImpl 对象。接着，我们使用 @Captor 注解创建 ArgumentCaptor 对象来捕获 Mock 方法的参数值，并在测试方法中使用 when() 方法设置 Mock 方法的返回值。最后，我们在测试方法中调用 Mock 方法，并使用 verify() 方法来验证 Mock 方法是否被调用，并使用 getValue() 方法来获取 Captor 对象的参数值。

3.2 Mockito 插件的使用

Mockito 框架通过插件机制来扩展功能和提供新特性，例如 Hamcrest、JUnit、JUnit5 等插件。这些插件可以帮助程序员更好地进行测试和开发，并提供方便的 API 和工具支持。

（1）Hamcrest 插件

Hamcrest 插件是一个框架，它提供了丰富的 Matcher 类和 API，可以帮助程序员方便地进行对象匹配和断言。在使用 Hamcrest 插件时，我们需要使用 assertThat() 方法来进行匹配和断言。

例如：

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    @Mock
    private MyDao myDao;

    @InjectMocks
    private MyServiceImpl myService;

    @Test
    public void testDoSomethingWithMatcher() {
        when(myDao.getData(anyString())).thenReturn("mock");
        String result = myService.doSomethingWithArgument("test");
        assertThat(result, is("mock"));
    }
}

上面的代码中，我们使用 @Mock 注解创建需要 Mock 的 MyDao 对象，并使用 @InjectMocks 注解注入 MyServiceImpl 对象。接着，我们使用 when() 方法设置 Mock 方法的返回值，并在测试方法中调用 doSomethingWithArgument() 方法，并使用 assertThat() 方法进行匹配和断言。

（2）JUnit 插件

JUnit 插件是一个测试框架，它提供了多种测试 API 和工具，包括 Assert、Assume、Parameterized 等类和注解。在使用 JUnit 插件时，我们需要遵循 JUnit 的测试规范和标准，编写符合要求的测试用例。

例如：

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    @Mock
    private MyDao myDao;

    @InjectMocks
    private MyServiceImpl myService;

    @Test
    public void testDoSomethingWithAssert() {
        when(myDao.getData(anyString())).thenReturn("mock");
        String result = myService.doSomethingWithArgument("test");
        assertNotNull(result);
        assertTrue(result.startsWith("m"));
    }
}

上面的代码中，我们使用 @Mock 注解创建需要 Mock 的 MyDao 对象，并使用 @InjectMocks 注解注入 MyServiceImpl 对象。接着，我们使用 when() 方法设置 Mock 方法的返回值，并在测试方法中调用 doSomethingWithArgument() 方法，并使用 JUnit 的 Assert 类进行断言。

（3）JUnit5 插件

JUnit5 插件是 JUnit4 之后的版本，它提供了更丰富、更强大的测试 API 和工具，例如 Test、BeforeAll、AfterAll、ParameterizedTest、Assertions、DisplayName 等注解和接口。在使用 JUnit5 插件时，我们需要遵循 JUnit5 的测试规范和标准，编写符合要求的测试用例。

例如：

@DisplayName("MyServiceTest")
public class MyServiceTest {
    @Mock
    private MyDao myDao;

    @InjectMocks
    private MyServiceImpl myService;

    @Test
    @DisplayName("Test doSomethingWithArgument")
    void testDoSomethingWithArgument() {
        when(myDao.getData(anyString())).thenReturn("mock");
        String result = myService.doSomethingWithArgument("test");
        assertEquals("mock", result);
    }

    @Test
    @DisplayName("Test doSomethingWithNullArgument")
    void testDoSomethingWithNullArgument() {
        when(myDao.getData(null)).thenReturn("null");
        String result = myService.doSomethingWithArgument(null);
        assertEquals("null", result);
    }
}

上面的代码中，我们使用 @Mock 注解创建需要 Mock 的 MyDao 对象，并使用 @InjectMocks 注解注入 MyServiceImpl 对象。接着，我们使用 when() 方法设置 Mock 方法的返回值，并在测试方法中调用 doSomethingWithArgument() 方法，并使用 JUnit5 的 Assertions 类进行断言，同时使用 DisplayName 注解来标识测试用例的名称和描述。

3.3 Mockito 扩展技巧

Mockito 框架提供了多种扩展技巧，可以帮助程序员更好地进行测试和开发，例如策略模式、Spy 对象、连续调用等技巧。

（1）策略模式

策略模式是一种设计模式，它可以将算法的实现与调用解耦，从而提高代码的灵活性和可复用性。在使用 Mockito 框架时，我们可以使用策略模式来实现 Mock 对象的行为和逻辑，从而更好地进行测试和开发。

例如：

interface MyStrategy {
    String doSomething();
}

class MyStrategyImpl implements MyStrategy {
    @Override
    public String doSomething() {
        return "real";
    }
}

class MyService {
    private MyStrategy strategy;

    public MyService(MyStrategy strategy) {
        this.strategy = strategy;
    }

    public String doSomething() {
        return strategy.doSomething();
    }
}

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
    private MyStrategy myStrategy;

    private MyService myService;

    @Before
    public void setUp() throws Exception {
        myService = new MyService(myStrategy);
    }

    @Test
    public void testDoSomethingWithMock() {
        when(myStrategy.doSomething()).thenReturn("mock");
        String result = myService.doSomething();
        assertEquals("mock", result);
    }

    @Test
    public void testDoSomethingWithReal() {
        MyStrategy realStrategy = new MyStrategyImpl();
        MyService realService = new MyService(realStrategy);
        String result = realService.doSomething();
        assertEquals("real", result);
    }
}

上面的代码中，我们定义了一个 MyStrategy 接口和一个 MyStrategyImpl 实现类，用于表示算法的具体实现。接着，我们定义了一个 MyService 类，构造方法中传入 MyStrategy 接口，用于执行具体的算法实现。然后，我们在测试类中通过 @Mock 注解创建 Mock 的 MyStrategy 对象，并使用策略模式将其注入到 MyService 中。最后，在测试方法中使用 when() 方法设置 Mock 对象的返回值，并调用 MyService 的 doSomething() 方法进行测试和断言。

（2）Spy 对象

Spy 对象是 Mockito 框架中的一种机制，它可以对真实对象进行部分 Mock，可以帮助程序员更好地进行测试和调试。在使用 Spy 对象时，我们需要使用 Mockito.spy() 方法创建 Spy 对象，并在测试方法中使用 doReturn()、doThrow() 等方法设置 Spy 对象的行为和返回值。

例如：

class MyServiceImpl implements MyService {
    private MyDao myDao;

    public MyServiceImpl(MyDao myDao) {
        this.myDao = myDao;
    }

    @Override
    public String doSomethingWithArgument(String argument) {
        if (argument == null) {
            throw new IllegalArgumentException();
        }
        return myDao.getData(argument);
    }
}

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    private MyDao myDao = Mockito.mock(MyDao.class);

    private MyService spyService = new MyServiceImpl(myDao);

    @Test(expected = IllegalArgumentException.class)
    public void testDoSomethingWithNullArgument() {
        spyService = Mockito.spy(spyService);
        doThrow(new IllegalArgumentException()).when(spyService).doSomethingWithArgument(null);
        spyService.doSomethingWithArgument(null);
    }
}

上面的代码中，我们创建了一个 MyServiceImpl 类和一个 MyDao 接口，并实现了 MyService 的 doSomethingWithArgument() 方法。接着，我们使用 @Mock 注解创建需要 Mock 的 MyDao 对象，并使用构造方法注入到 MyServiceImpl 中，然后将 MyServiceImpl 对象赋值给 SpyService 对象。在测试方法中，我们使用 Mockito.spy() 方法创建 Spy 对象，并使用 doThrow() 方法设置 Spy 对象在接收到 null 参数时抛出 IllegalArgumentException 异常。

（3）连续调用

连续调用是 Mockito 框架中的一个机制，它可以帮助程序员在 Mock 对象的方法调用链中进行多次设置和断言，从而更好地进行测试和验证。在使用连续调用时，我们需要使用 thenReturn()、thenThrow() 等方法来设置连续调用的返回值或异常，并在测试方法中使用 verify()、verifyNoMoreInteractions() 等方法进行断言和验证。

例如：

class MyServiceImpl implements MyService {
    private MyDao myDao;

    public MyServiceImpl(MyDao myDao) {
        this.myDao = myDao;
    }

    @Override
    public String doSomethingWithArgument(String argument) {
        if (argument == null) {
            throw new IllegalArgumentException();
        }
        return myDao.getData(argument);
    }
}

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    private MyDao myDao = Mockito.mock(MyDao.class);

    private MyService myService = new MyServiceImpl(myDao);

    @Test
    public void testDoSomethingWithMultipleCalls() {
        when(myDao.getData(anyString()))
                .thenReturn("first")

                .thenThrow(new RuntimeException())

                .thenReturn("second");

        assertEquals("first", myService.doSomethingWithArgument("test"));
        try {
            myService.doSomethingWithArgument(null);
        } catch (IllegalArgumentException e) {
            // ignore
        }
        assertNull(myService.doSomethingWithArgument("null"));
        assertEquals("second", myService.doSomethingWithArgument("test"));
        verify(myDao, times(4)).getData(anyString());
        verifyNoMoreInteractions(myDao);
    }
}

上面的代码中，我们创建了一个 MyServiceImpl 类和一个 MyDao 接口，并实现了 MyService 的 doSomethingWithArgument() 方法。接着，我们使用 @Mock 注解创建需要 Mock 的 MyDao 对象，并使用构造方法注入到 MyServiceImpl 中，然后创建 MyServiceImpl 对象。在测试方法中，我们使用 when() 方法进行连续调用设置，并使用 try-catch 语句捕获指定方法的异常。最后，我们在测试方法中使用 verify()、verifyNoMoreInteractions() 等方法进行断言和验证。

（4）参数匹配器

参数匹配器是 Mockito 框架中的一个机制，它可以帮助程序员在设置 Mock 对象的方法时，使用特定的参数匹配规则来匹配方法调用的实际参数。在使用参数匹配器时，我们需要使用 any()、eq() 等方法来设置参数匹配器，并在测试方法中使用 verify()、verifyNoMoreInteractions() 等方法进行断言和验证。

例如：

class MyServiceImpl implements MyService {
    private MyDao myDao;

    public MyServiceImpl(MyDao myDao) {
        this.myDao = myDao;
    }

    @Override
    public String doSomethingWithArgument(String argument) {
        if (argument == null) {
            throw new IllegalArgumentException();
        }
        return myDao.getData(argument);
    }
}

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    private MyDao myDao = Mockito.mock(MyDao.class);

    private MyService myService = new MyServiceImpl(myDao);

    @Test
    public void testDoSomethingWithArgumentMatcher() {
        when(myDao.getData(anyString())).thenReturn("mock");
        String result = myService.doSomethingWithArgument("test");
        assertEquals("mock", result);
        verify(myDao, times(1)).getData(anyString());
        verifyNoMoreInteractions(myDao);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDoSomethingWithArgumentNullMatcher() {
        myService.doSomethingWithArgument(null);
    }
}

上面的代码中，我们创建了一个 MyServiceImpl 类和一个 MyDao 接口，并实现了 MyService 的 doSomethingWithArgument() 方法。接着，我们使用 @Mock 注解创建需要 Mock 的 MyDao 对象，并使用构造方法注入到 MyServiceImpl 中，然后创建 MyServiceImpl 对象。在测试方法中，我们使用 anyString() 方法设置参数匹配器，并使用 when() 方法进行 Mock 设置。最后，我们在测试方法中使用 verify()、verifyNoMoreInteractions() 等方法进行断言和验证。

（5）MockitoAnnotations 和 InjectMocks

MockitoAnnotations 和 InjectMocks 是 Mockito 框架中的两个注解，它们可以帮助程序员更轻松地创建 Mock 对象和将 Mock 对象注入到需要测试的对象中。在使用 MockitoAnnotations 和 InjectMocks 时，我们需要在测试类中使用这两个注解，并在需要创建 Mock 对象和注入 Mock 对象的属性和方法上使用 @Mock 和 @InjectMocks 注解。

例如：

class MyServiceImpl implements MyService {
    private MyDao myDao;

    public MyServiceImpl(MyDao myDao) {
        this.myDao = myDao;
    }

    @Override
    public String doSomethingWithArgument(String argument) {
        if (argument == null) {
            throw new IllegalArgumentException();
        }
        return myDao.getData(argument);
    }
}

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    @Mock
    private MyDao myDao;

    @InjectMocks
    private MyService myService = new MyServiceImpl(myDao);

    @Test
    public void testDoSomethingWithArgument() {
        when(myDao.getData(anyString())).thenReturn("mock");
        String result = myService.doSomethingWithArgument("test");
        assertEquals("mock", result);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDoSomethingWithArgumentNull() {
        myService.doSomethingWithArgument(null);
    }
}

上面的代码中，我们创建了一个 MyServiceImpl 类和一个 MyDao 接口，并实现了 MyService 的 doSomethingWithArgument() 方法。接着，我们在测试类中使用 @Mock 和 @InjectMocks 注解来创建 Mock 对象和将 Mock 对象注入到 MyServiceImpl 中，然后在测试方法中使用 when() 方法进行 Mock 以及调用 MyService 的方法进行测试和断言。

（6）Mockito.reset()

Mockito.reset() 方法可以帮助程序员重置 Mock 对象的状态，并清除之前设置的 Mock 和 Stub。在进行单元测试时，我们有时候需要重置 Mock 对象的状态，以便在多个测试方法中反复使用同一个 Mock 对象。

例如：

java

class MyServiceImpl implements MyService {
    private MyDao myDao;

    public MyServiceImpl(MyDao myDao) {
        this.myDao = myDao;
    }

    @Override
    public String doSomethingWithArgument(String argument) {
        if (argument == null) {
            throw new IllegalArgumentException();
        }
        return myDao.getData(argument);
    }
}

@RunWith(MockitoJUnitRunner.class)
public class MyServiceTest {
    private MyDao myDao = Mockito.mock(MyDao.class);

    private MyService myService = new MyServiceImpl(myDao);

    @Test
    public void testDoSomethingWithArgument() {
        when(myDao.getData(anyString())).thenReturn("mock");
        String result = myService.doSomethingWithArgument("test");
        assertEquals("mock", result);
        verify(myDao, times(1)).getData(anyString());
    }

    @Test
    public void testDoSomethingWithArgumentReset() {
        Mockito.reset(myDao);
        String result = myService.doSomethingWithArgument("test");
        assertNull(result);
        verify(myDao, times(1)).getData(anyString());
    }
}

上面的代码中，我们在第一个测试方法中设置了 Mock 和 Stub，并进行了测试和验证。在第二个测试方法中，我们使用 Mockito.reset() 方法重置了 MyDao 的状态，然后再次调用 MyService 的 doSomethingWithArgument() 方法进行测试，并验证对 MyDao 的调用次数。