Stub和fake是对象，因为它们可以根据输入参数改变响应。它们之间的主要区别是Fake比存根更接近真实世界的实现。存根基本上包含对预期请求的硬编码响应。让我们看一个例子:

public class MyUnitTest {

 @Test
 public void testConcatenate() {
  StubDependency stubDependency = new StubDependency();
  int result = stubDependency.toNumber("one", "two");
  assertEquals("onetwo", result);
 }
}

public class StubDependency() {
 public int toNumber(string param) {
  if (param == “one”) {
   return 1;
  }
  if (param == “two”) {
   return 2;
  }
 }
}

A mock is a step up from fakes and stubs. Mocks provide the same functionality as stubs but are more complex. They can have rules defined for them that dictate in what order methods on their API must be called. Most mocks can track how many times a method was called and can react based on that information. Mocks generally know the context of each call and can react differently in different situations. Because of this, mocks require some knowledge of the class they are mocking. a stub generally cannot track how many times a method was called or in what order a sequence of methods was called. A mock looks like:

public class MockADependency {

 private int ShouldCallTwice;
 private boolean ShouldCallAtEnd;
 private boolean ShouldCallFirst;

 public int StringToInteger(String s) {
  if (s == "abc") {
   return 1;
  }
  if (s == "xyz") {
   return 2;
  }
  return 0;
 }

 public void ShouldCallFirst() {
  if ((ShouldCallTwice > 0) || ShouldCallAtEnd)
   throw new AssertionException("ShouldCallFirst not first thod called");
  ShouldCallFirst = true;
 }

 public int ShouldCallTwice(string s) {
  if (!ShouldCallFirst)
   throw new AssertionException("ShouldCallTwice called before ShouldCallFirst");
  if (ShouldCallAtEnd)
   throw new AssertionException("ShouldCallTwice called after ShouldCallAtEnd");
  if (ShouldCallTwice >= 2)
   throw new AssertionException("ShouldCallTwice called more than twice");
  ShouldCallTwice++;
  return StringToInteger(s);
 }

 public void ShouldCallAtEnd() {
  if (!ShouldCallFirst)
   throw new AssertionException("ShouldCallAtEnd called before ShouldCallFirst");
  if (ShouldCallTwice != 2) throw new AssertionException("ShouldCallTwice not called twice");
  ShouldCallAtEnd = true;
 }

}

你可以得到一些信息:

来自马丁·福勒关于莫克和斯塔克的信

假对象实际上有工作实现，但通常采取一些捷径，这使得它们不适合生产

存根为测试过程中拨打的电话提供了预先准备好的答案，通常不会对测试程序之外的任何内容做出任何回应。存根还可以记录有关通话的信息，例如电子邮件网关存根可以记住它“发送”的消息，或者可能只记住它“发送”了多少消息。

mock就是我们在这里讨论的对象:用期望预编程的对象，这些期望形成了期望它们接收的调用的规范。

从xunitpattern:

Fake:我们获得或构建SUT所依赖的组件所提供的相同功能的非常轻量级的实现，并指示SUT使用它而不是真正的功能。

存根:这个实现被配置为响应来自SUT的调用，使用值(或异常)在SUT中执行未测试的代码(参见第X页的生产bug)。使用测试存根的一个关键指示是由于无法控制SUT的间接输入而导致的未测试代码

模拟对象，它实现了与SUT(被测系统)所依赖的对象相同的接口。当我们需要进行行为验证时，我们可以使用模拟对象作为观察点，以避免由于无法观察在SUT上调用方法的副作用而导致的未测试需求(参见第X页的生产bug)。

就我个人而言

我试图通过使用:Mock和Stub来简化。当它是一个返回被测试类的值的对象时，我使用Mock。我使用Stub来模拟要测试的接口或抽象类。事实上，如何称呼它并不重要，它们都是在生产中不使用的类，而被用作测试的实用程序类。

在Gerard Meszaros所著的《xUnit Test Patterns》一书中，有一个很好的表格给出了关于差异的很好的见解

这是一个让测试富有表现力的问题。如果我想让测试描述两个对象之间的关系，我就在Mock上设置期望。我存根返回值，如果我设置一个支持对象，让我在测试中有趣的行为。

根据Vladimir Khorikov的《单元测试原则、实践和模式》一书:

Mocks: help to emulate and examine outcoming interactions. These interactions are calls the SUT makes to its dependencies to change their state. In other words it helps to examine the interaction (behaviour) of SUT and its dependencies. mocks could be : Spy : created manually Mocks : created using framework Stubs: helps to emulate incoming interactions. These interactions are calls the SUT makes to its dependencies to get input data. IN other words it helps to test the data passed to SUT. It could be 3 types Fake: is usually implemented to replace a dependency that doesn’t yet exist. Dummy: is hard-coded value. Stubs: Fledged dependency that you configure to return different values for different scenarios.

我倾向于使用两个术语-假和Mock。

只有在使用像Moq这样的Mock框架时才使用Mock，因为当它使用new Mock<ISomething>()创建时，将其称为Fake似乎是不正确的-虽然从技术上讲，您可以使用Mock框架创建stub或Fakes，但在这种情况下这样称呼它似乎有点愚蠢-它必须是Mock。

其他都是假的。如果一个Fake可以被总结为一个功能降低的实现，那么我认为一个Stub也可以是一个Fake(如果不是，谁在乎呢，每个人都知道我的意思，而且从来没有人说过“我认为你会发现那是一个Stub”)