2020-06-06 10:46:18

c400f7bf · wizardforcel · 802cb491 · c400f7bf · c400f7bf · c400f7bf
7 changed file
--- a/docs/misc/207.md
+++ b/docs/misc/207.md
@@ -21,9 +21,9 @@ Mockito 是一个开放源代码框架，可让您轻松创建[测试双打](htt

 在模拟中，我们通常使用以下类型的测试双打。

-*   **Stubs** –是一个对象，该对象对测试期间执行的方法执行具有预定义的返回值。
-*   **Spies** –与 Stubs 相似的对象，但它们另外记录了它们的执行方式。
-*   **模拟** –是在测试期间对方法执行返回值并记录了对这些执行的期望的对象。 如果模拟人收到了他们不期望的电话，并且在验证过程中对其进行了检查，以确保他们收到了所有期望的电话，它们可能会引发异常。
+*   **Stub** – 是一个对象，该对象对测试期间执行的方法执行具有预定义的返回值。
+*   **Spy** – 与 Stub 相似的对象，但它们另外记录了它们的执行方式。
+*   **Mock** – 是在测试期间对方法执行返回值并记录了对这些执行的期望的对象。 如果模拟人收到了他们不期望的电话，并且在验证过程中对其进行了检查，以确保他们收到了所有期望的电话，它们可能会引发异常。

 我们可以在测试类中模拟接口和类。 Mockito 还可以在使用 Mockito 注解时帮助产生最少的样板代码。

@@ -78,18 +78,18 @@ testCompile group: 'org.mockito', name: 'mockito-core', version: '2.23.4'

 在敲键盘来编写应用和单元测试之前，让我们快速概述有用的 Mockito 注解。

-*   **@Mock** 用于模拟创建。 它使测试类更具可读性。
-*   **@Spy** 用于创建 Spies 实例。 我们可以使用它代替`spy(Object)`方法。
-*   **@InjectMocks** 用于自动实例化测试对象，并将所有 *@Mock* 或 *@Spy* 带注解的字段依赖项注入其中（如果适用）。
-*   **@Captor** 用于创建参数捕获器
+*   `@Mock`用于模拟创建。 它使测试类更具可读性。
+*   `@Spy`用于创建 Spy 实例。 我们可以使用它代替`spy(Object)`方法。
+*   `@InjectMock`用于自动实例化测试对象，并将所有`@Mock`或`@Spy`带注解的字段依赖项注入其中（如果适用）。
+*   `@Captor`用于创建参数捕获器

-> 阅读更多： [@Mock 和@InitMocks 注解之间的区别](https://howtodoinjava.com/mockito/mockito-mock-initmocks/)
+> 阅读更多： [`@Mock`和`@InitMock`注解之间的区别](https://howtodoinjava.com/mockito/mockito-mock-initMock/)

-要处理所有上述注解，请 **MockitoAnnotations.initMocks（testClass）;** 必须至少使用一次。 要处理注解，我们可以使用内置运行器 **MockitoJUnitRunner** 或规则 **MockitoRule** 。 我们还可以在`@Before`带注解的 Junit 方法中显式调用`initMocks()`方法。
+要处理所有上述注解，`MockitoAnnotations.initMock(testClass);`必须至少使用一次。 要处理注解，我们可以使用内置运行器`MockitoJUnitRunner`或规则`MockitoRule`。 我们还可以在`@Before`带注解的 Junit 方法中显式调用`initMock()`方法。

+```java
 //1

-```java
 @RunWith(MockitoJUnitRunner.class)
 public class ApplicationTest {
 	//code
@@ -97,24 +97,25 @@ public class ApplicationTest {

 ```

-//2

 ```java
+//2
+
 public class ApplicationTest {
-	@Rule public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS);
+	@Rule public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_Stub);

 	//code
 }

 ```

+```java
 //3

-```java
 public class ApplicationTest {
 	@Before
 	public void init() {
-		MockitoAnnotations.initMocks(this);
+		MockitoAnnotations.initMock(this);
 	}
 }

@@ -170,7 +171,7 @@ public class RecordService

 请记住，如果我们使用诸如 Spring 之类的任何 DI 框架，那么我们可能已经使用了注解`@Autowired`。

-要测试这个 RecordService 类，让我们创建一个单元测试。
+要测试这个`RecordService`类，让我们创建一个单元测试。

 ```java
 import static org.junit.Assert.assertEquals;
@@ -179,7 +180,7 @@ import static org.mockito.Mockito.verify;

 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
+import org.mockito.InjectMock;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;

@@ -190,7 +191,7 @@ import com.howtodoinjava.demo.mockito.RecordService;
 @RunWith(MockitoJUnitRunner.class)
 public class ApplicationTest 
 {
-	@InjectMocks
+	@InjectMock
 	RecordService recordService;

 	@Mock
@@ -215,10 +216,10 @@ public class ApplicationTest
 让我们逐步了解以上测试类：

 *   用`@RunWith(MockitoJUnitRunner.class)`注解测试，以便 Mockito 可以处理注解。
-*   使用@Mock 注解对 dao 字段进行注解，以为它们两个实例化一个 Mocks 对象。
-*   使用@InjectMocks 注解对服务字段进行注解，以首先实例化然后注入两个模拟的依赖项。
-*   在要测试的类上调用方法进行测试，即。 *recordService* 。
-*   验证 Mocks 对象中的方法已被调用。
+*   使用`@Mock`注解对 dao 字段进行注解，以为它们两个实例化一个 Mock 对象。
+*   使用`@InjectMock`注解对服务字段进行注解，以首先实例化然后注入两个模拟的依赖项。
+*   在要测试的类上调用方法进行测试，即`recordService`。
+*   验证 Mock 对象中的方法已被调用。

 还有许多其他方法可以测试方法和模拟的依赖项，我们将在以后的文章中介绍。


--- a/docs/misc/208.md
+++ b/docs/misc/208.md
-# Mockito 注解– @ Mock，@ Spy，@ Captor，@ InjectMocks
+# Mockito 注解– `@Mock`，`@Spy`，`@Captor`，`@InjectMock`

 > 原文： [https://howtodoinjava.com/mockito/mockito-annotations/](https://howtodoinjava.com/mockito/mockito-annotations/)

-在此 Mockito 教程中，了解 **Mockito 注解**，例如 **@Mock** ， **@Spy** ， **@Captor** ， **@InjectMocks [** 。 学习使用模仿注解为行为测试编写单元测试。
+在此 Mockito 教程中，了解 **Mockito 注解**，例如`@Mock`，`@Spy`，`@Captor`，`@InjectMock`。 学习使用模仿注解为行为测试编写单元测试。

 ## 1\. Mockito 注解

-#### 1.1 @嘲笑
+#### 1.1 `@Mock`

-**@Mock** 注解用于创建和注入模拟实例。 我们不创建真实的对象，而是要求嘲笑为类创建一个嘲笑。
+`@Mock`注解用于创建和注入模拟实例。 我们不创建真实的对象，而是要求 Mock 为类创建一个 Mock。

-`@Mock`注解是`Mockito.mock(classToMock)`的替代方法。 它们都达到相同的结果。 通常认为使用`@Mock`是“ **清洁剂**”，因为我们没有用看起来都一样的样板分配填充测试。
+`@Mock`注解是`Mockito.mock(classToMock)`的替代方法。 它们都达到相同的结果。 通常认为使用`@Mock`是“**清洁器**”，因为我们没有用看起来都一样的样板分配填充测试。

 使用`@Mock`注解：

 *   允许快速创建测试所需的对象。
 *   最小化重复的模拟创建代码。
 *   使测试类更具可读性。
-*   由于使用`field name`来识别模拟，因此使验证错误更易于阅读。
+*   由于使用字段名称来识别模拟，因此使验证错误更易于阅读。

 在给定的示例中，我们模拟了`HashMap`类。 在实际测试中，我们将模拟实际的应用类。 我们在映射中放置了一个键值对，然后验证了对模拟映射实例执行了方法调用。

@@ -38,9 +38,9 @@ public void saveTest()

 ```

-#### 1.2 @Spies
+#### 1.2 `@Spy`

-**@Spy** 注解用于**创建真实对象并监视该真实对象**。 Spies 程序可以帮助调用对象的所有常规方法，同时仍可以跟踪每次交互，就像使用模拟一样。
+`@Spy`注解用于**创建真实对象并监视该真实对象**。 Spy 程序可以帮助调用对象的所有常规方法，同时仍可以跟踪每次交互，就像使用模拟一样。

 请注意，在给定的示例中，由于我们向其中添加了一个键值对，因此映射的大小如何保持为 1。 我们还可以使用它的键取回添加到映射的值。 在模拟实例中是不可能的。

@@ -97,13 +97,13 @@ public void saveTest()

 ```

-#### 1.4 @InjectMocks
+#### 1.4 @InjectMock

-在嘲笑中，我们需要创建要测试的类的对象，然后插入其依赖项（*模拟*）以完全测试行为。 为此，我们使用 **@InjectMocks** 注解。
+在Mock中，我们需要创建要测试的类的对象，然后插入其依赖项（*模拟*）以完全测试行为。 为此，我们使用 **@InjectMock** 注解。

-@InjectMocks 标记应在其上执行注射的字段。 Mockito 将尝试仅通过构造器注入，setter 注入或属性注入按此顺序注入模拟。 如果任何给定的注射策略失败，则 Mockito 不会报告失败。
+@InjectMock 标记应在其上执行注射的字段。 Mockito 将尝试仅通过构造器注入，setter 注入或属性注入按此顺序注入模拟。 如果任何给定的注射策略失败，则 Mockito 不会报告失败。

-> 阅读更多： [@Mock 和@InitMocks 注解之间的区别](https://howtodoinjava.com/mockito/mockito-mock-initmocks/)
+> 阅读更多： [@Mock 和@InitMock 注解之间的区别](https://howtodoinjava.com/mockito/mockito-mock-initMock/)

 ## 2\. 如何初始化 Mockito 注解

@@ -126,7 +126,7 @@ public void saveTest()

    ```

-2.  在单元测试类的 **@Before** 方法中使用`MockitoAnnotations.initMocks(this)`。
+2.  在单元测试类的 **@Before** 方法中使用`MockitoAnnotations.initMock(this)`。

    ```java
    public class ExampleTest {
@@ -136,7 +136,7 @@ public void saveTest()

        @Before
        public void setup() {
-            MockitoAnnotations.initMocks(this);
+            MockitoAnnotations.initMock(this);
        }

        @Test
@@ -173,6 +173,6 @@ public void saveTest()
 参考文献：

 [模拟 Java Doc](https://static.javadoc.io/org.mockito/mockito-core/2.23.4/org/mockito/Mock.html)
-[Spies Java Doc](https://static.javadoc.io/org.mockito/mockito-core/2.23.4/org/mockito/Spy.html)
+[Spy Java Doc](https://static.javadoc.io/org.mockito/mockito-core/2.23.4/org/mockito/Spy.html)
 [Captor Java Doc](https://static.javadoc.io/org.mockito/mockito-core/2.23.4/org/mockito/Captor.html)
-[InjectMocks Java Doc](https://static.javadoc.io/org.mockito/mockito-core/2.23.4/org/mockito/InjectMocks.html)
\ No newline at end of file
+[InjectMock Java Doc](https://static.javadoc.io/org.mockito/mockito-core/2.23.4/org/mockito/InjectMock.html)
\ No newline at end of file
--- a/docs/misc/209.md
+++ b/docs/misc/209.md
-# Mockito – @Mock 和@InjectMocks 注解之间的区别
+# Mockito – @Mock 和@InjectMock 注解之间的区别

-> 原文： [https://howtodoinjava.com/mockito/mockito-mock-injectmocks/](https://howtodoinjava.com/mockito/mockito-mock-injectmocks/)
+> 原文： [https://howtodoinjava.com/mockito/mockito-mock-injectMock/](https://howtodoinjava.com/mockito/mockito-mock-injectMock/)

-在使用 [junit](https://howtodoinjava.com/junit-4/) 和 Mockito 进行[单元测试](https://howtodoinjava.com/best-practices/unit-testing-best-practices-junit-reference-guide/)的过程中，我们使用 **@Mock** 和 **@InjectMocks** 注解来创建要测试的对象和依赖项。 了解 mockito 中@Mock 和@InjectMocks 注解之间的*区别。*
+在使用 [junit](https://howtodoinjava.com/junit-4/) 和 Mockito 进行[单元测试](https://howtodoinjava.com/best-practices/unit-testing-best-practices-junit-reference-guide/)的过程中，我们使用`@Mock`和`@InjectMock`注解来创建要测试的对象和依赖项。 了解 mockito 中@Mock 和@InjectMock 注解之间的*区别。*

-## 1\. Mocks 对象与 Stubs 对象之间的区别
+## 1\. Mock 对象与 Stub 对象之间的区别

-重要的是要了解 Mocks 对象与[对象](https://howtodoinjava.com/java/basics/how-to-create-a-class-in-java/)之间的区别。 对象是类的实际实例，使用对象引用调用的任何方法都将执行类文件中定义的方法主体。
+重要的是要了解 Mock 对象与[对象](https://howtodoinjava.com/java/basics/how-to-create-a-class-in-java/)之间的区别。 对象是类的实际实例，使用对象引用调用的任何方法都将执行类文件中定义的方法主体。

-Mocks 对象是用于隐藏无法在测试环境中测试的依赖项的接口。 数据库，网络位置等。使用模拟引用调用的方法不会执行类文件中定义的方法主体，而是使用 **when-thenReturn** 方法组合来配置方法行为。
+Mock 对象是用于隐藏无法在测试环境中测试的依赖项的接口。 数据库，网络位置等。使用模拟引用调用的方法不会执行类文件中定义的方法主体，而是使用 **when-thenReturn** 方法组合来配置方法行为。

 在 junit 测试中，我们为需要测试的类和要调用的方法创建对象。 我们为依赖项创建了模拟，这些依赖项不会出现在测试环境中，并且对象依赖于该依赖项来完成方法调用。

-## 2\. @Mock 和@InjectMocks 之间的区别
+## 2\. @Mock 和@InjectMock 之间的区别

-在基于 Mockito 的 junit 测试中， **@Mock 注解创建模拟，而@InjectMocks 创建类对象**。
+在基于 Mockito 的 junit 测试中， **@Mock 注解创建模拟，而@InjectMock 创建类对象**。

 > @Mock –创建模拟
-> @InjectMocks –创建对象并注入模拟的依赖项
+> @InjectMock –创建对象并注入模拟的依赖项

-*   使用@InjectMocks 创建需要在测试类中进行测试的类实例。
-*   当需要为给定类执行实际方法主体时，请使用@InjectMocks。
-*   当我们需要使用 Mocks 对象初始化的所有内部依赖项以正常工作方法时，请使用@InjectMocks。
+*   使用@InjectMock 创建需要在测试类中进行测试的类实例。
+*   当需要为给定类执行实际方法主体时，请使用@InjectMock。
+*   当我们需要使用 Mock 对象初始化的所有内部依赖项以正常工作方法时，请使用@InjectMock。
 *   使用@Mock 创建模拟，以支持要测试的类的测试。
 *   带有@Mock 注解的带注解的类（待测试）依赖项。
-*   我们必须为 Mocks 对象定义 when-thenRetrun 方法，在实际测试执行期间将调用哪些类方法。
+*   我们必须为 Mock 对象定义 when-thenRetrun 方法，在实际测试执行期间将调用哪些类方法。

-## 3\. @Mock 和@InjectMocks 示例
+## 3\. @Mock 和@InjectMock 示例

-让我们通过示例来了解@Mock 和@InjectMocks 之间的区别。 在此示例中，我们具有类`MainClass`，其类具有方法 **save()**。
+让我们通过示例来了解@Mock 和@InjectMock 之间的区别。 在此示例中，我们具有类`MainClass`，其类具有方法 **save()**。

 `MainClass`依赖于`DatabaseDAO`和`NetworkDAO`。 当我们调用`MainClass.save()`方法时，它在内部调用两个相关对象的保存方法。

@@ -83,13 +83,13 @@ import static org.junit.Assert.assertEquals;

 import org.junit.Before;
 import org.junit.Test;
-import org.mockito.InjectMocks;
+import org.mockito.InjectMock;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;

 public class ApplicationTest 
 {
-	@InjectMocks
+	@InjectMock
 	MainClass mainClass;

 	@Mock
@@ -100,7 +100,7 @@ public class ApplicationTest

 	@Before
 	public void init() {
-		MockitoAnnotations.initMocks(this);
+		MockitoAnnotations.initMock(this);
 	}

 	@Test
@@ -121,11 +121,11 @@ Saved in network in Main class

 ```

-在上面的测试中，将打印用 MainClass.save()方法编写的语句，但不打印从属类。 它证明了方法主体仅针对 MainClass 的 save()方法执行，因为我们使用`@InjectMocks`注解创建了 MainClass 的实际对象。 对于依赖类，我们使用了模拟。
+在上面的测试中，将打印用 MainClass.save()方法编写的语句，但不打印从属类。 它证明了方法主体仅针对 MainClass 的 save()方法执行，因为我们使用`@InjectMock`注解创建了 MainClass 的实际对象。 对于依赖类，我们使用了模拟。

 #### 3.3 验证模拟的方法调用

-要验证是否已调用模拟方法，我们必须使用嘲笑提供的实用程序方法 **verify()**。 它有助于验证在执行实际的测试类方法时是否已执行了模拟方法。
+要验证是否已调用模拟方法，我们必须使用Mock提供的实用程序方法 **verify()**。 它有助于验证在执行实际的测试类方法时是否已执行了模拟方法。

 ```java
 @Test
@@ -142,7 +142,7 @@ public void validateTest()

 ## 4 结论

-在此 mockito 教程中，我们了解了@Mock 和@InjectMocks 注解之间的*区别。 我们了解了在 junit 测试中将这些注解应用于类时发生了什么。*
+在此 mockito 教程中，我们了解了@Mock 和@InjectMock 注解之间的*区别。 我们了解了在 junit 测试中将这些注解应用于类时发生了什么。*

 学习愉快！


--- a/docs/misc/211.md
+++ b/docs/misc/211.md
@@ -48,13 +48,13 @@

 #### 2.1 MockitoJUnitRunner 类

-**MockitoJUnitRunner** 类自动初始化所有带有`@Mock`和`@InjectMocks`注解的对象。
+**MockitoJUnitRunner** 类自动初始化所有带有`@Mock`和`@InjectMock`注解的对象。

 ```java
 @RunWith(MockitoJUnitRunner.class)
 public class TestEmployeeManager {

-	@InjectMocks
+	@InjectMock
 	EmployeeManager manager;

 	@Mock
@@ -65,14 +65,14 @@ public class TestEmployeeManager {

 ```

-#### 2.2 MockitoAnnotations.initMocks()方法
+#### 2.2 MockitoAnnotations.initMock()方法

-如果我们不使用 MockitoJUnitRunner 类方法，则可以使用静态方法`MockitoAnnotations.initMocks()`。 在初始化 junit 测试时，该方法还会初始化 Mocks 对象。
+如果我们不使用 MockitoJUnitRunner 类方法，则可以使用静态方法`MockitoAnnotations.initMock()`。 在初始化 junit 测试时，该方法还会初始化 Mock 对象。

 ```java
 public class TestEmployeeManager {

-	@InjectMocks
+	@InjectMock
 	EmployeeManager manager;

 	@Mock
@@ -80,7 +80,7 @@ public class TestEmployeeManager {

 	@Before
 	public void init() {
-		MockitoAnnotations.initMocks(this);
+		MockitoAnnotations.initMock(this);
 	}

 	//tests	
@@ -88,16 +88,16 @@ public class TestEmployeeManager {

 ```

-#### 2.3 @模拟 vs @InjectMocks
+#### 2.3 @模拟 vs @InjectMock

 *   **@Mock** 注解会为其注解的类创建一个模拟实现。
-*   **@InjectMocks** 还将创建模拟实现，另外将标有注解`@Mock`的从属模拟注入其中。
+*   **@InjectMock** 还将创建模拟实现，另外将标有注解`@Mock`的从属模拟注入其中。

-在上面的示例中，我们用`@InjectMocks`注解了`EmployeeManager`类，因此模仿者将为`EmployeeManager`类创建模仿对象，并将`EmployeeDao`的模仿依赖项注入其中。
+在上面的示例中，我们用`@InjectMock`注解了`EmployeeManager`类，因此模仿者将为`EmployeeManager`类创建模仿对象，并将`EmployeeDao`的模仿依赖项注入其中。

 ## 3\. 使用 Mockito 进行 JUnit 测试

-让我们看几个例子，这些例子编写了 junit 测试，以使用通过嘲讽创建的 Mocks 对象对服务层方法进行单元测试。
+让我们看几个例子，这些例子编写了 junit 测试，以使用通过嘲讽创建的 Mock 对象对服务层方法进行单元测试。

 很少有示例方法是`getAllEmployees()`，该方法将返回`EmployeeVO`对象的列表，`getEmployeeById(int id)`以给定 id 返回雇员。 和`createEmployee()`将添加一个雇员对象并返回`void`。

@@ -117,7 +117,7 @@ import java.util.List;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
+import org.mockito.InjectMock;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.mockito.junit.MockitoJUnitRunner;
@@ -128,7 +128,7 @@ import com.howtodoinjava.demo.service.EmployeeManager;

 public class TestEmployeeManager {

-	@InjectMocks
+	@InjectMock
 	EmployeeManager manager;

 	@Mock
@@ -136,7 +136,7 @@ public class TestEmployeeManager {

 	@Before
 	public void init() {
-		MockitoAnnotations.initMocks(this);
+		MockitoAnnotations.initMock(this);
 	}

 	@Test
@@ -277,6 +277,6 @@ public class EmployeeDao {

 在此**mockito 教程**中，我们学习了使用 JUnit 和 Mockito 对 Spring Boot 应用中的服务层进行单元测试。 我们学习了如何设置测试类并编写 JUnit 测试。

-我们还了解了@Mock 和@InjectMocks 注解之间的**区别。**
+我们还了解了@Mock 和@InjectMock 注解之间的**区别。**

 学习愉快！
\ No newline at end of file
--- a/docs/misc/213.md
+++ b/docs/misc/213.md
@@ -138,7 +138,7 @@ public void firstMockTest()

 ```

-以上测试将成功执行。 在此，当调用`employeeController.getProjectedEmployeeCount()`时，它依次从 Mocks 对象中调用方法`getEmployeeCount()`，该方法返回值 8。控制器将其乘以 2，返回值为 16。该返回值等于 assert 语句中的期望值， 因此测试通过了。
+以上测试将成功执行。 在此，当调用`employeeController.getProjectedEmployeeCount()`时，它依次从 Mock 对象中调用方法`getEmployeeCount()`，该方法返回值 8。控制器将其乘以 2，返回值为 16。该返回值等于 assert 语句中的期望值， 因此测试通过了。

 ## 验证是否真的调用了模拟方法？

@@ -188,11 +188,11 @@ Actually, there were zero interactions with this mock.

 ## 使用模拟设置获取有关测试运行的更多信息

-这些模拟设置很少使用，但在某些情况下很有用。 如果您想为模拟命名，以供将来调试之用，请使用它们。 或者您想启用详细日志记录以获取更多信息。 当您要注册一个监听器来通知该模拟方法的调用时，可以使用它。 甚至在尚未实现实际对象的 Mocks 对象上实现一些额外的接口。
+这些模拟设置很少使用，但在某些情况下很有用。 如果您想为模拟命名，以供将来调试之用，请使用它们。 或者您想启用详细日志记录以获取更多信息。 当您要注册一个监听器来通知该模拟方法的调用时，可以使用它。 甚至在尚未实现实际对象的 Mock 对象上实现一些额外的接口。

 ```java
 @Test
-public void mockSettingsTest() {
+public void MockettingsTest() {
 	EmployeeService mock =PowerMockito.mock(EmployeeService.class, Mockito
 		.withSettings()
 		.name("EmployeeServiceMock")
@@ -224,7 +224,7 @@ employeeService.saveEmployee(
 employeeService.saveEmployee(
    com.howtodoinjava.powermock.examples.model.Employee@c9131c
 );
-   invoked: -> at com.howtodoinjava.powermock.examples.test.EmployeeControllerTestOne.mockSettingsTest(EmployeeControllerTestOne.java:64)
+   invoked: -> at com.howtodoinjava.powermock.examples.test.EmployeeControllerTestOne.MockettingsTest(EmployeeControllerTestOne.java:64)
   has returned: "null"

 ```

--- a/docs/misc/267.md
+++ b/docs/misc/267.md
@@ -13,7 +13,7 @@ Table of Contents
 4\. Jasmine Describe Blocks
 5\. Jasmine Matchers 
 6\. Disable Suites and Specs
-7\. Working with Jasmine Spies
+7\. Working with Jasmine Spy
 8\. Final Thoughts

 ```
@@ -337,11 +337,11 @@ describe("MathUtils", function() {

 ```

-## 7\. 与茉莉花 Spies 一起工作
+## 7\. 与茉莉花 Spy 一起工作

-茉莉具有双重测试功能，称为 Spies。 Spies 可以对任何函数进行 Stubs，并跟踪对该函数和所有参数的调用。 Spies 仅存在于定义它的`describe`或`it`块中，并且在每个规范后都会被删除。 要使用任何方法创建 Spies，请使用`spyOn(object, 'methodName')`调用。
+茉莉具有双重测试功能，称为 Spy。 Spy 可以对任何函数进行 Stub，并跟踪对该函数和所有参数的调用。 Spy 仅存在于定义它的`describe`或`it`块中，并且在每个规范后都会被删除。 要使用任何方法创建 Spy，请使用`spyOn(object, 'methodName')`调用。

-有两个匹配器`toHaveBeenCalled`和`toHaveBeenCalledWith`应该与 Spies 一起使用。 如果调用了 Spies，则`toHaveBeenCalled`匹配器将返回 true；否则，将返回 true。 如果参数列表与对 Spies 的任何记录调用匹配，则`toHaveBeenCalledWith`匹配器将返回 true。
+有两个匹配器`toHaveBeenCalled`和`toHaveBeenCalledWith`应该与 Spy 一起使用。 如果调用了 Spy，则`toHaveBeenCalled`匹配器将返回 true；否则，将返回 true。 如果参数列表与对 Spy 的任何记录调用匹配，则`toHaveBeenCalledWith`匹配器将返回 true。

 ```java
 describe("MathUtils", function() {
@@ -369,9 +369,9 @@ describe("MathUtils", function() {

 ```

-上面的示例本质上是最基本的，您也可以使用 Spies 来验证对内部方法的调用。 例如。 如果在任何对象上调用方法`calculateInterest()`，则可能需要检查是否必须在该对象内调用`getPrincipal()`，`getROI()`和`getTime()`。 Spies 将帮助您验证这些假设。
+上面的示例本质上是最基本的，您也可以使用 Spy 来验证对内部方法的调用。 例如。 如果在任何对象上调用方法`calculateInterest()`，则可能需要检查是否必须在该对象内调用`getPrincipal()`，`getROI()`和`getTime()`。 Spy 将帮助您验证这些假设。

-当没有要监视的功能时，`jasmine.createSpy`可以创建裸露的 Spies。 该 Spies 的行为与其他任何 Spies 一样-跟踪调用，参数等。但是它背后没有实现。 Spies 是 JavaScript 对象，可以这样使用。 通常，这些 Spies 在需要时用作其他函数的回调函数。
+当没有要监视的功能时，`jasmine.createSpy`可以创建裸露的 Spy。 该 Spy 的行为与其他任何 Spy 一样-跟踪调用，参数等。但是它背后没有实现。 Spy 是 JavaScript 对象，可以这样使用。 通常，这些 Spy 在需要时用作其他函数的回调函数。

 ```java
 var callback = jasmine.createSpy('callback');
@@ -392,17 +392,17 @@ tape.play();

 ```

-在`calls`属性上跟踪并公开了对 Spies 的每次调用。 让我们看看如何使用这些属性来跟踪 Spies。
+在`calls`属性上跟踪并公开了对 Spy 的每次调用。 让我们看看如何使用这些属性来跟踪 Spy。

 | 追踪属性 | Purpose |
-| .calls.any() | 如果根本没有调用过该 Spies，则返回 false；如果至少发生一次调用，则返回 true。 |
-| .calls.count() | 返回 Spies 被调用的次数 |
+| .calls.any() | 如果根本没有调用过该 Spy，则返回 false；如果至少发生一次调用，则返回 true。 |
+| .calls.count() | 返回 Spy 被调用的次数 |
 | .calls.argsFor（index） | 返回传递给电话号码索引的参数 |
 | .calls.allArgs() | 返回所有调用的参数 |
 | .calls.all() | 返回上下文（`this`），并且参数传递了所有调用 |
 | .calls.mostRecent() | 返回上下文（`this`）和最近一次调用的参数 |
 | .calls.first() | 返回第一次调用的上下文（`this`）和参数 |
-| .calls.reset() | 清除所有跟踪以发现 Spies |
+| .calls.reset() | 清除所有跟踪以发现 Spy |

 ## 8\. 茉莉花教程–最终想法


--- a/docs/misc/273.md
+++ b/docs/misc/273.md
@@ -24,7 +24,7 @@ Android app project structure

 ## 2）Java 源代码

-创建项目时（例如，通过 android create project），您为应用（例如`com.howtodoinjava.DemoApp`）提供了“ **main** ”活动的全限定类名。 然后，您会发现项目的 src /树已经安装了包的目录树，还有代表您的主要活动的 Stubs Activity 子类（例如 **`src/com/howtodoinjava/DemoAppMainActivity.java`** ）。 欢迎您修改此文件，并根据需要将其他文件添加到 src /树中，以实现您的应用。
+创建项目时（例如，通过 android create project），您为应用（例如`com.howtodoinjava.DemoApp`）提供了“ **main** ”活动的全限定类名。 然后，您会发现项目的 src /树已经安装了包的目录树，还有代表您的主要活动的 Stub Activity 子类（例如 **`src/com/howtodoinjava/DemoAppMainActivity.java`** ）。 欢迎您修改此文件，并根据需要将其他文件添加到 src /树中，以实现您的应用。

 首次在项目包的目录中编译该项目时，Android 构建链将创建`R.java`。 它包含许多与您在 res /目录树中放置的各种资源相关联的常量。