dnc8371
dnc8371

cks32和stm32_cks子，间谍，局部Mo子和短管

cks32和stm32

本文是我们名为“ 用Mockito测试 ”的学院课程的一部分。

在本课程中，您将深入了解Mockito的魔力。 您将了解有关“模拟”，“间谍”和“部分模拟”的信息，以及它们相应的存根行为。 您还将看到使用测试双打和对象匹配器进行验证的过程。 最后，讨论了使用Mockito的测试驱动开发（TDD），以了解该库如何适合TDD的概念。 在这里查看 ！

目录

1.简介
2.模拟，存根，间谍–名称是什么？
3.存根方法
4.存根返回值
4.1。 使用答案
4.2。 有关行为驱动开发测试约定的说明
4.3。 在Eclipse中使用Mockito静态方法的提示
4.4。 使用多个模拟
4.5。 测试自己！ 测试更新！
5.参数匹配器
6.间谍和部分存根
7.结论
8.下载源代码

1.简介

在本教程中，我们将深入研究使用Mockito存根类和接口。

2.模拟，存根，间谍–名称是什么？

嘲笑中的许多术语可以互换使用，也可以作为动词和名词使用。 我们现在将对这些术语进行定义，以避免将来造成混淆。

  • 模拟（名词） –一个对象，充当另一个对象的双精度对象。
  • 模拟（动词） –创建模拟对象或对方法进行存根。
  • 间谍（名词） –装饰现有对象并允许对该对象的方法进行存根和对该对象的调用进行验证的对象。
  • 间谍（动词） –创建和使用间谍对象。
  • 存根（名词） –可以在调用方法时提供“罐头答案”的对象。
  • 存根（动词） –创建固定答案。
  • Partial Mock，Partial Stub（动词） –间谍的另一种术语，其中某些方法已被禁用。

从技术上讲，Mockito是一个测试间谍框架，而不是模拟框架，因为它使我们能够创建间谍和验证行为，以及创建具有存根行为的模拟对象。

正如在上一教程中所看到的，我们可以使用when().thenReturn()方法对给定接口或类的行为进行存根。 现在，我们将研究为Mocks和Spies提供存根的所有方法。

3.存根方法

给定以下界面： 

public interface Printer {

	void printTestPage();

}

以下是使用它的基于字符串缓冲区的简单化“文字处理器”类： 

public class StringProcessor {

	private Printer printer;
	private String currentBuffer;

	public StringProcessor(Printer printer) {
		this.printer = printer;
	}

	public Optional statusAndTest() {
		printer.printTestPage();
		return Optional.ofNullable(currentBuffer);
	}

}

我们要编写一个测试方法，该方法将测试构造后是否缺少当前缓冲区并处理测试页的打印。

这是我们的测试课程： 

public class StringProcessorTest {

	private Printer printer;

	@Test
	public void internal_buffer_should_be_absent_after_construction() {
		// Given
		StringProcessor processor = new StringProcessor(printer);

		// When
		Optional actualBuffer = processor.statusAndTest();

		// Then
		assertFalse(actualBuffer.isPresent());
	}
}

我们知道statusAndTest()将涉及对Printer的printTestPage()方法的调用，并且printer引用未初始化，因此如果执行此测试，我们将以NullPointerException结尾。 为了避免这种情况，我们只需要注释测试类以告诉JUnit使用Mockito运行它，并注释Printer作为一个模拟，以告诉mockito为此创建一个模拟。 

@RunWith(MockitoJUnitRunner.class)
public class StringProcessorTest {

	@Mock
	private Printer printer;

	@Test
	public void internal_buffer_should_be_absent_after_construction() {
		// Given
		StringProcessor processor = new StringProcessor(printer);

		// When
		Optional actualBuffer = processor.statusAndTest();

		// Then
		assertFalse(actualBuffer.isPresent());
	}

}

现在我们可以执行测试，Mockito将为我们创建Printer的实现，并将其实例分配给printer变量。 我们将不再获得NullPointerException。

但是，如果Printer是一类实际完成某些工作的类，例如打印物理测试页，该怎么办？ 如果我们选择了@Spy而不是创建@Mock怎么办？ 记住，除非被侦听，否则间谍会在类上调用间谍的真实方法。 我们希望避免在调用该方法时做任何实际的事情。 让我们做一个简单的Printer实现： 

public class SysoutPrinter implements Printer {

	@Override
	public void printTestPage() {
		System.out.println("This is a test page");
	}

}

并将其作为间谍添加到我们的测试类中，并添加一个新方法来测试使用它： 

@Spy
	private SysoutPrinter sysoutPrinter;

@Test
	public void internal_buffer_should_be_absent_after_construction_sysout() {
		// Given
		StringProcessor processor = new StringProcessor(sysoutPrinter);

		// When
		Optional actualBuffer = processor.statusAndTest();

		// Then
		assertFalse(actualBuffer.isPresent());
	}

如果现在执行此测试，您将在控制台上看到以下输出： 

This is a test page

这确认我们的测试用例实际上是在执行SysoutPrinter类的真实方法，这是因为它是Spy而不是Mock。 如果该类实际执行了测试页的实际物理打印，那将是非常不希望的！

当我们执行部分模拟或Spy时，可以使用org.mockito.Mockito.doNothing()调用的方法进行存根，以确保其中没有任何org.mockito.Mockito.doNothing() 。

让我们添加以下导入和测试： 

import static org.mockito.Mockito.*;

@Test
	public void internal_buffer_should_be_absent_after_construction_sysout_with_donothing() {
		// Given
		StringProcessor processor = new StringProcessor(sysoutPrinter);
		doNothing().when(sysoutPrinter).printTestPage();

		// When
		Optional actualBuffer = processor.statusAndTest();

		// Then
		assertFalse(actualBuffer.isPresent());
	}

注意方法doNothing.when(sysoutPrinter).printTestPage() ：这告诉Mockito当调用@Spy sysoutPrinter的void方法printTestPage ，不应执行真正的方法，而应执行任何操作。 现在，当我们执行此测试时，屏幕上看不到任何输出。

如果未连接物理打印机，如果我们扩展打印机接口以引发新的PrinterNotConnectedException异常，该怎么办？ 我们如何测试这种情况？

首先，让我们创建一个非常简单的新异常类。 

public class PrinterNotConnectedException extends Exception {

	private static final long serialVersionUID = -6643301294924639178L;

}

并修改我们的界面以将其抛出： 

void printTestPage() throws PrinterNotConnectedException;

如果抛出异常，我们还需要修改StringProcessor以执行某些操作。 为了简单起见，我们只将异常抛出给调用类。 

public Optional statusAndTest() throws PrinterNotConnectedException

现在我们要测试异常是否传递给调用类，因此我们必须强制打印机抛出异常。 与doNothing()类似，我们可以使用doThrow强制执行异常。

让我们添加以下测试： 

@Test(expected = PrinterNotConnectedException.class)
	public void printer_not_connected_exception_should_be_thrown_up_the_stack() throws Exception {
		// Given
		StringProcessor processor = new StringProcessor(printer);
		doThrow(new PrinterNotConnectedException()).when(printer).printTestPage();

		// When
		Optional actualBuffer = processor.statusAndTest();

		// Then
		assertFalse(actualBuffer.isPresent());
	}

在这里，我们看到可以使用doThrow()抛出所需的任何异常。 在这种情况下，我们将抛出满足我们测试要求的PrinterNotConnectedException 。

现在我们已经学习了如何对void方法进行存根，让我们看一下返回一些数据。

4.存根返回值

让我们开始创建一个数据访问对象，以从数据库中持久化和检索客户对象。 该DAO将使用内部的企业java EntityManager接口进行实际的数据库交互。

为了使用EntityManager我们将使用JPA 2.0的Hibernate实现，将以下依赖项添加到pom.xml中： 


			org.hibernate.javax.persistence
			hibernate-jpa-2.0-api
			1.0.1.Final

现在，我们将创建一个简单的Customer实体来表示要保留的Customer。 

@Entity
public class Customer {

	@Id @GeneratedValue
	private long id;
	private String name;
	private String address;

	public Customer() {

	}

	public Customer(long id, String name, String address) {
		super();
		this.id = id;
		this.name = name;
		this.address = address;
	}

	public long getId() {
		return id;
	}

	public void setId(long id) {
		this.id = id;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

现在，我们将创建一个骨架DAO，该骨架使用@PersistenceContext配置注入的EntityManager 。 我们不必担心使用Java持久性体系结构（JPA）或它如何工作-我们将使用Mockito完全绕过它，但这是Mockito实际应用的一个很好的实例。 

public class CustomerDAO {

	@PersistenceContext
	EntityManager em;

	public CustomerDAO(EntityManager em) {
		this.em = em;
	}

}

我们将在DAO中添加基本的“检索和更新”功能，并使用Mockito对其进行测试。

首先使用Retrieve方法-我们将传递一个ID并从数据库中返回适当的Customer（如果存在）。 

public Optional findById(long id) throws Exception {
		return Optional.ofNullable(em.find(Customer.class, id));
	}

在这里，我们使用Java Optional来避免对结果进行空检查。

现在，我们可以添加测试以在找到客户但找不到客户的地方测试此方法–我们将使用Mockito方法org.mockito.Mockito.when对find()方法进行存根处理以在每种情况下返回适当的Optional。然后thenReturn()

让我们如下创建Test类（为Mockito方法import static org.mockito.Mockito.*; ）： 

@RunWith(MockitoJUnitRunner.class)
public class CustomerDAOTest {

	private CustomerDAO dao;

	@Mock
	private EntityManager mockEntityManager;

	@Before
	public void setUp() throws Exception {
		dao = new CustomerDAO(mockEntityManager);
	}

	@Test
	public void finding_existing_customer_should_return_customer() throws Exception {
		// Given
		long expectedId = 10;
		String expectedName = "John Doe";
		String expectedAddress = "21 Main Street";
		Customer expectedCustomer = new Customer(expectedId, expectedName, expectedAddress);

		when(mockEntityManager.find(Customer.class, expectedId)).thenReturn(expectedCustomer);

		// When
		Optional actualCustomer = dao.findById(expectedId);

		// Then
		assertTrue(actualCustomer.isPresent());
		assertEquals(expectedId, actualCustomer.get().getId());
		assertEquals(expectedName, actualCustomer.get().getName());
		assertEquals(expectedAddress, actualCustomer.get().getAddress());
	}
}

我们看到了用于启用模仿，模仿EntityManger并将其注入到测试中的类的常用样板。 让我们看一下测试方法。

第一行涉及创建具有已知期望值的Customer ，然后我们看到对Mockito的调用告诉我们，当使用我们提供的特定输入参数调用EntityManager.find()方法时，该客户将返回此客户。 然后，我们执行findById()方法和一组断言的实际执行，以确保我们获得了期望的值。

让我们剖析Mockito调用： 

when(mockEntityManager.find(Customer.class, expectedId)).thenReturn(expectedCustomer);

这演示了Mockito强大而优雅的语法。 读起来几乎像普通的英语。 当find()的方法mockEntityManager对象被称为与特定输入Customer.class和expectedId ，然后返回expectedCustomer对象。

如果您使用未告知其期望的参数调用Mock，则它将仅返回null，如以下测试所示： 

@Test
	public void invoking_mock_with_unexpected_argument_returns_null() throws Exception {
		// Given
		long expectedId = 10L;
		long unexpectedId = 20L;
		String expectedName = "John Doe";
		String expectedAddress = "21 Main Street";
		Customer expectedCustomer = new Customer(expectedId, expectedName, expectedAddress);

		when(mockEntityManager.find(Customer.class, expectedId)).thenReturn(expectedCustomer);

		// When
		Optional actualCustomer = dao.findById(unexpectedId);

		// Then
		assertFalse(actualCustomer.isPresent());
	}

您还可以在不同的时间对Mock进行存根，以实现不同的行为，具体取决于输入。 让我们让Mock根据输入的ID返回其他客户： 

@Test
	public void invoking_mock_with_different_argument_returns_different_customers() throws Exception {
		// Given
		long expectedId1 = 10L;
		String expectedName1 = "John Doe";
		String expectedAddress1 = "21 Main Street";
		Customer expectedCustomer1 = new Customer(expectedId1, expectedName1, expectedAddress1);

		long expectedId2 = 20L;
		String expectedName2 = "Jane Deer";
		String expectedAddress2 = "46 High Street";
		Customer expectedCustomer2 = new Customer(expectedId2, expectedName2, expectedAddress2);

		when(mockEntityManager.find(Customer.class, expectedId1)).thenReturn(expectedCustomer1);
		when(mockEntityManager.find(Customer.class, expectedId2)).thenReturn(expectedCustomer2);

		// When
		Optional actualCustomer1 = dao.findById(expectedId1);
		Optional actualCustomer2 = dao.findById(expectedId2);

		// Then
		assertEquals(expectedName1, actualCustomer1.get().getName());
		assertEquals(expectedName2, actualCustomer2.get().getName());
	}

您甚至可以链接返回，以使模拟在每次调用时执行不同的操作。 请注意，如果您调用模拟程序的次数超过了您的存根行为，那么它将永远永远根据最后一个存根行为。 

@Test
	public void invoking_mock_with_chained_stubs_returns_different_customers() throws Exception {
		// Given
		long expectedId1 = 10L;
		String expectedName1 = "John Doe";
		String expectedAddress1 = "21 Main Street";
		Customer expectedCustomer1 = new Customer(expectedId1, expectedName1, expectedAddress1);

		long expectedId2 = 20L;
		String expectedName2 = "Jane Deer";
		String expectedAddress2 = "46 High Street";
		Customer expectedCustomer2 = new Customer(expectedId2, expectedName2, expectedAddress2);

		when(mockEntityManager.find(Customer.class, expectedId1))
			.thenReturn(expectedCustomer1).thenReturn(expectedCustomer2);

		// When
		Optional actualCustomer1 = dao.findById(expectedId1);
		Optional actualCustomer2 = dao.findById(expectedId1);

		// Then
		assertEquals(expectedName1, actualCustomer1.get().getName());
		assertEquals(expectedName2, actualCustomer2.get().getName());
	}

请注意，我们输入了相同的ID到两个电话，不同的行为是由第二goverened theReturn()方法，这只能是因为when()存根的一部分明确预期和输入expectedId1 ，如果我们通过expectedId2我们由于它不是存根中的期望值，因此会从模拟中获得空响应。

现在让我们测试一下缺少客户的情况。 

@Test
	public void finding_missing_customer_should_return_null() throws Exception {
		// Given
		long expectedId = 10L;
		when(mockEntityManager.find(Customer.class, expectedId)).thenReturn(null);

		// When
		Optional actualCustomer = dao.findById(expectedId);

		// Then
		assertFalse(actualCustomer.isPresent());
	}

在这里我们可以看到我们使用相同的语法，但是这次使用它来返回null。

允许的Mockito您使用的可变参数thenReturn存根连续调用，所以如果我们想我们可以在前面的两个测试擀成一个如下： 

@Test
	public void finding_customer_should_respond_appropriately() throws Exception {
		// Given
		long expectedId = 10L;
		String expectedName = "John Doe";
		String expectedAddress = "21 Main Street";
		Customer expectedCustomer1 = new Customer(expectedId, expectedName, expectedAddress);
		Customer expectedCustomer2 = null;

		when(mockEntityManager.find(Customer.class, expectedId)).thenReturn(expectedCustomer1, expectedCustomer2);

		// When
		Optional actualCustomer1 = dao.findById(expectedId);
		Optional actualCustomer2 = dao.findById(expectedId);

		// Then
		assertTrue(actualCustomer1.isPresent());
		assertFalse(actualCustomer2.isPresent());
	}

如果我们的find方法由于某些持久性问题而引发异常怎么办？ 让我们测试一下！ 

@Test(expected=IllegalArgumentException.class)
	public void finding_customer_should_throw_exception_up_the_stack() throws Exception {
		// Given
		long expectedId = 10L;

		when(mockEntityManager.find(Customer.class, expectedId)).thenThrow(new IllegalArgumentException());

		// When
		dao.findById(expectedId);

		// Then
		fail("Exception should be thrown.");
	}

我们使用了thenThrow()方法引发异常。 在对无效方法进行存根时，将此语法与我们对doThrow()使用进行doThrow() 。 这是两个相似但不同的方法– thenThrow()将不适用于void方法。

使用答案

上面我们看到我们创建了一个具有某些期望值的客户。 如果我们想创建一些已知的测试用户并以id为基础返回他们，则可以使用Answer ，可以从when()调用中返回。 Answer是Mockito提供的通用类型，用于提供“罐头响应”。 它的answer()方法采用一个InvocationOnMock对象，该对象包含有关当前模拟方法调用的某些信息。

让我们创建3个客户和一个Answer，根据输入的ID选择要退回的客户。

首先，将3个客户添加为测试类的私有成员。 

private Customer homerSimpson, bruceWayne, tyrionLannister;

然后添加一个专用的setupCustomers方法以对其进行初始化，然后从@Before方法进行调用。 

@Before
	public void setUp() throws Exception {
		dao = new CustomerDAO(mockEntityManager);
		setupCustomers();
	}

	private void setupCustomers() {
		homerSimpson = new Customer(1, "Homer Simpson", "Springfield");
		bruceWayne = new Customer(2, "Bruce Wayne", "Gotham City");
		tyrionLannister = new Customer(2, "Tyrion Lannister", "Kings Landing");
	}

现在，我们可以基于在运行时传递给传递给模拟EntityManager的find()方法的ID创建一个Answer来返回适当的Customer。 

private Answer withCustomerById = new Answer() {
		@Override
		public Customer answer(InvocationOnMock invocation) throws Throwable {
			Object[] args = invocation.getArguments();
			int id = ((Long)args[1]).intValue(); // Cast to int for switch.
			switch (id) {
			case 1 : return homerSimpson;
			case 2 : return bruceWayne;
			case 3 : return tyrionLannister;
			default : return null;
			}
		}
	};

我们可以看到我们使用InvocationOnMock提取了传递到Mock方法调用中的参数。 我们知道第二个参数是ID，因此我们可以读取该参数并确定要返回的适当客户。 稍后，带有withCustomerById的答案的名称将与我们的模拟语法匹配。

现在，让我们编写一个测试来证明此答案的实际效果。 

@Test
	public void finding_customer_by_id_returns_appropriate_customer() throws Exception {
		// Given
		long[] expectedId = {1, 2, 3};

		when(mockEntityManager.find(eq(Customer.class), anyLong())).thenAnswer(withCustomerById);

		// When
		Optional actualCustomer0 = dao.findById(expectedId[0]);
		Optional actualCustomer1 = dao.findById(expectedId[1]);
		Optional actualCustomer2 = dao.findById(expectedId[2]);

		// Then
		assertEquals("Homer Simpson", actualCustomer0.get().getName());
		assertEquals("Bruce Wayne", actualCustomer1.get().getName());
		assertEquals("Tyrion Lannister", actualCustomer2.get().getName());
	}

让我们详细了解一下存根线。 

when(mockEntityManager.find(eq(Customer.class), anyLong())).thenAnswer(withCustomerById);

在这里，我们看到了一些新事物。 第一件事是，我们不执行when().thenReturn()而是执行when().thenAnswer()并提供withCustomerById Answer作为要给出的答案。 第二件事是我们不对传递给mockEntityManager.find()的ID使用真实值，而是使用静态的org.mockito.Matchers.anyLong() 。 这是一个Matcher ，用于使Mockito发出Answer，而无需检查是否已传入特定的Long值。Matchers让我们忽略模拟调用的参数，而只专注于返回值。

我们还用eq() Matcher装饰了Customer.class –这是由于您不能在Mock方法调用中混合使用实值和Matchers，您要么必须将所有参数都作为Matchers，要么必须将所有参数都作为实值。 eq()提供了一个Matcher，仅当运行时参数等于存根中的指定参数时才匹配。 让我们继续仅在输入类类型为Customer.class类型时不指定特定ID的情况下才返回Answer。

什么这一切意味着，三个调用mockEntityManager.find()用不同的ID是所有产生相同的答案报错，并且我们已经编码的答案与不同的ID相应的客户对象响应是我们已经成功地嘲笑一个EntityManager能力模仿现实行为。

有关行为驱动开发测试约定的说明

您可能已经注意到，我们在单元测试中采用了约定，将测试分为三部分– //给定，//时间和//然后。 该约定称为行为驱动开发，是设计单元测试的一种非常合乎逻辑的方法。

  • // 给定的是设置阶段，在该阶段我们初始化数据和存根模拟类。 它与陈述“给定以下初始条件”相同。
  • //什么时候是执行阶段，在该阶段我们执行被测方法并捕获所有返回的对象。
  • //然后是验证阶段，在此阶段我们放置断言逻辑，该逻辑将检查该方法是否表现出预期的行为。

Mockito在org.mockito.BDDMockito类中开箱即用地支持BDD。 它用BDD doppelgangers – given() ， willReturn() ， willThrow() ， willAnswer()替换了常规的存根方法– when() ， thenReturn() ， thenThrow() ， thenAnswer()等。 这样可以避免在// //给定部分中使用when() ，因为这可能会造成混淆。

因为我们在测试中使用BDD约定，所以我们还将使用BDDMockito提供的方法。

让我们使用BDDMockito语法重写finding_existing_customer_should_return_customer() 。 

import static org.mockito.BDDMockito.*;

@Test
	public void finding_existing_customer_should_return_customer_bdd() throws Exception {
		// Given
		long expectedId = 10L;
		String expectedName = "John Doe";
		String expectedAddress = "21 Main Street";
		Customer expectedCustomer = new Customer(expectedId, expectedName, expectedAddress);

		given(mockEntityManager.find(Customer.class, expectedId)).willReturn(expectedCustomer);

		// When
		Optional actualCustomer = dao.findById(expectedId);

		// Then
		assertTrue(actualCustomer.isPresent());
		assertEquals(expectedId, actualCustomer.get().getId());
		assertEquals(expectedName, actualCustomer.get().getName());
		assertEquals(expectedAddress, actualCustomer.get().getAddress());
	}

测试的逻辑没有改变，只是以BDD格式可读。

在Eclipse中使用Mockito静态方法的提示

如果要避免导入org.mockito.Mockito.*等，为各种Mockito静态方法手动添加静态导入可能会很org.mockito.Mockito.*为了在Eclipse中为这些方法启用内容辅助，您只需启动org.mockito.Mockito.* > Preferences并转到左侧导航栏中的Java / Editor / Content Assist / Favorites。 然后，按照图1添加以下内容作为“ New Type…”。

  • org.mockito.Mockito
  • org.mockito.Matchers
  • org.mockito.BDDMockito

这会将Mockito静态方法添加到Eclipse Content Assist中，使您可以在使用它们时自动完成并导入它们。

cks32和stm32_cks子，间谍，局部Mo子和短管_第1张图片

图1 – Content Assist收藏夹

使用多个模拟

现在，我们将结合在一起使用多个模拟。 让我们向DAO中添加一个方法以返回所有可用客户的列表。 

public List findAll() throws Exception {
		TypedQuery query = em.createQuery("select * from CUSTOMER", Customer.class);
		return query.getResultList();
	}

在这里，我们看到EntityManager的createQuery()方法返回一个通用类型TypedQuery 。 它接受一个SQL String和一个作为返回类型的类作为参数。 TypedQuery本身公开了几种方法，包括List getResultList() ，这些方法可用于执行返回多个值的查询，例如上面的select * from CUSTOMER查询中的select * from CUSTOMER 。

为了对此方法编写测试，我们将要创建一个TypedQuery的Mock。 

@Mock
private TypedQuery mockQuery;

现在，我们可以对这个模拟查询进行存根以返回已知客户的列表。 让我们创建一个答案来做到这一点，并重用我们先前创建的已知客户。 您可能已经注意到Answer是一个功能接口，只有一种方法。 我们正在使用Java 8，因此我们可以创建一个lambda表达式来表示我们的内联Answer，而不是像前面的Answer示例中那样创建一个匿名内部类。 

given(mockQuery.getResultList()).willAnswer(i -> Arrays.asList(homerSimpson, bruceWayne, tyrionLannister));

当然我们也可以将上面的存根编码为 

given(mockQuery.getResultList()).willReturn(Arrays.asList(homerSimpson, bruceWayne, tyrionLannister));given

这展示了Mockito的灵活性–总是有几种不同的方式来做相同的事情。

现在我们已经对模拟TypedQuery的行为进行了存根，我们可以对模拟EntityManager进行存根以在请求时返回它。 与其将SQL引入我们的测试用例中， anyString()仅使用anyString()匹配器来触发模拟createQuery() ，当然，我们还将用eq()匹配器包围该类参数。

完整的测试如下所示： 

@Test
	public void finding_all_customers_should_return_all_customers() throws Exception {
		// Given
		given(mockQuery.getResultList()).willAnswer(i -> Arrays.asList(homerSimpson, bruceWayne, tyrionLannister));
		given(mockEntityManager.createQuery(anyString(), eq(Customer.class))).willReturn(mockQuery);

		// When
		List actualCustomers = dao.findAll();

		// Then
		assertEquals(actualCustomers.size(), 3);
	}

测试更新！

让我们添加Update() DAO方法： 

public Customer update(Customer customer) throws Exception {
		return em.merge(customer);
	}

现在查看是否可以为其创建测试。 本教程随附的示例代码项目中已编写了可能的解决方案。 记住，在Mockito中有很多方法可以做相同的事情，看看是否能想到其中的几种！

5.参数匹配器

Mocktio的自然行为是使用对象的equals()方法作为参数传入，以查看是否存在特定的存根行为。 但是，如果对我们来说不重要的是那些值，则可以在存根时避免使用真实的对象和变量。 我们通过使用Mockito参数匹配器来实现

我们已经看到了一些运行中的Mockito参数匹配器： anyLong() ， anyString()和eq 。 当我们不特别在意Mock的输入时，我们会使用这些匹配器，我们只对编码它的返回行为感兴趣，并且我们希望它在所有条件下的行为都相同。

如前所述，但需要特别注意的是，当使用参数匹配器时，所有参数都必须是参数匹配器，您不能将实值与参数匹配器混合和匹配，否则会从Mockito中获取运行时错误。

参数匹配器都扩展了org.mockito.ArgumentMatcher ，Mockito包含一个现成的参数匹配器库，可以通过org.mockito.Matchers的静态方法进行org.mockito.Matchers ，要使用它们只需导入org.mockito.Matchers.* ;

您可以查看org.mockito.Matchers的javadoc，以查看Mockito提供的所有Matchers，而以下测试类演示了其中一些用法： 

package com.javacodegeeks.hughwphamill.mockito.stubbing;

import static org.junit.Assert.*;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;

@RunWith(MockitoJUnitRunner.class)
public class MatchersTest {

	public interface TestForMock {

		public boolean usesPrimitives(int i, float f, double d, byte b, boolean bool);

		public boolean usesObjects(String s, Object o, Integer i);

		public boolean usesCollections(List list, Map map, Set set);

		public boolean usesString(String s);

		public boolean usesVarargs(String... s);

		public boolean usesObject(Object o);

	}

	@Mock
	TestForMock test;

	@Test
	public void test() {

		// default behaviour is to return false
		assertFalse(test.usesString("Hello"));

		when(test.usesObjects(any(), any(), any())).thenReturn(true);
		assertTrue(test.usesObjects("Hello", new Thread(), 17));
		Mockito.reset(test);

		when(test.usesObjects(anyString(), anyObject(), anyInt())).thenReturn(true);
		assertTrue(test.usesObjects("Hi there", new Float(18), 42));
		Mockito.reset(test);

		when(test.usesPrimitives(anyInt(), anyFloat(), anyDouble(), anyByte(), anyBoolean())).thenReturn(true);
		assertTrue(test.usesPrimitives(1, 43.4f, 3.141592654d, (byte)2, false));
		Mockito.reset(test);

		// Gives unchecked type conversion warning
		when(test.usesCollections(anyList(), anyMap(), anySet())).thenReturn(true);
		assertTrue(test.usesCollections(Arrays.asList("Hello", "World"), Collections.EMPTY_MAP, Collections.EMPTY_SET));
		Mockito.reset(test);

		// Gives no warning
		when(test.usesCollections(anyListOf(String.class), anyMapOf(Integer.class, String.class), anySetOf(Object.class))).thenReturn(true);
		assertTrue(test.usesCollections(Collections.emptyList(), Collections.emptyMap(), Collections.emptySet()));
		Mockito.reset(test);

		// eq() must match exactly
		when(test.usesObjects(eq("Hello World"), any(Object.class),anyInt())).thenReturn(true);
		assertFalse(test.usesObjects("Hi World", new Object(), 360));
		assertTrue(test.usesObjects("Hello World", new Object(), 360));
		Mockito.reset(test);

		when(test.usesString(startsWith("Hello"))).thenReturn(true);
		assertTrue(test.usesString("Hello there"));
		Mockito.reset(test);

		when(test.usesString(endsWith("something"))).thenReturn(true);
		assertTrue(test.usesString("isn't that something"));
		Mockito.reset(test);

		when(test.usesString(contains("second"))).thenReturn(true);
		assertTrue(test.usesString("first, second, third."));
		Mockito.reset(test);

		// Regular Expression
		when(test.usesString(matches("^\\\\w+$"))).thenReturn(true);
		assertTrue(test.usesString("Weak_Password1"));
		assertFalse(test.usesString("@Str0nG!pa$$woR>%42"));
		Mockito.reset(test);

		when(test.usesString((String)isNull())).thenReturn(true);
		assertTrue(test.usesString(null));
		Mockito.reset(test);

		when(test.usesString((String)isNotNull())).thenReturn(true);
		assertTrue(test.usesString("Anything"));
		Mockito.reset(test);

		// Object Reference
		String string1 = new String("hello");
		String string2 = new String("hello");
		when(test.usesString(same(string1))).thenReturn(true);
		assertTrue(test.usesString(string1));
		assertFalse(test.usesString(string2));
		Mockito.reset(test);

		// Compare to eq()
		when(test.usesString(eq(string1))).thenReturn(true);
		assertTrue(test.usesString(string1));
		assertTrue(test.usesString(string2));
		Mockito.reset(test);

		when(test.usesVarargs(anyVararg())).thenReturn(true);
		assertTrue(test.usesVarargs("A","B","C","D","E"));
		assertTrue(test.usesVarargs("ABC", "123"));
		assertTrue(test.usesVarargs("Hello!"));
		Mockito.reset(test);

		when(test.usesObject(isA(String.class))).thenReturn(true);
		assertTrue(test.usesObject("A String Object"));
		assertFalse(test.usesObject(new Integer(7)));
		Mockito.reset(test);

		// Field equality using reflection
		when(test.usesObject(refEq(new SomeBeanWithoutEquals("abc", 123)))).thenReturn(true);
		assertTrue(test.usesObject(new SomeBeanWithoutEquals("abc", 123)));
		Mockito.reset(test);

		// Compare to eq()
		when(test.usesObject(eq(new SomeBeanWithoutEquals("abc", 123)))).thenReturn(true);
		assertFalse(test.usesObject(new SomeBeanWithoutEquals("abc", 123)));
		Mockito.reset(test);

		when(test.usesObject(eq(new SomeBeanWithEquals("abc", 123)))).thenReturn(true);
		assertTrue(test.usesObject(new SomeBeanWithEquals("abc", 123)));
		Mockito.reset(test);
	}

	public class SomeBeanWithoutEquals {
		private String string;
		private int number;

		public SomeBeanWithoutEquals(String string, int number) {
			this.string = string;
			this.number = number;
		}
	}

	public class SomeBeanWithEquals {
		private String string;
		private int number;

		public SomeBeanWithEquals(String string, int number) {
			this.string = string;
			this.number = number;
		}

		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + getOuterType().hashCode();
			result = prime * result + number;
			result = prime * result
					+ ((string == null) ? 0 : string.hashCode());
			return result;
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			SomeBeanWithEquals other = (SomeBeanWithEquals) obj;
			if (!getOuterType().equals(other.getOuterType()))
				return false;
			if (number != other.number)
				return false;
			if (string == null) {
				if (other.string != null)
					return false;
			} else if (!string.equals(other.string))
				return false;
			return true;
		}

		private MatchersTest getOuterType() {
			return MatchersTest.this;
		}
	}
}

 还可以通过扩展org.mockito.ArgumentMatcher来创建自己的org.mockito.ArgumentMatcher 。 让我们创建一个匹配器，如果列表包含特定元素，该匹配器将触发。 我们还将创建一个用于创建Matcher的静态便利方法，该方法使用argThat将Matcher转换为List，以便在存根调用中使用。 我们将实现matches()方法来调用List的contains方法来进行实际的contains检查。 


public class ListContainsMatcher extends ArgumentMatcher> {

	private T element;

	public ListContainsMatcher(T element) {
		this.element = element;
	}

	@Override
	public boolean matches(Object argument) {
		@SuppressWarnings("unchecked")
		List list = (List) argument;
		return list.contains(element);
	}

	public static  List contains(T element) {
		return argThat(new ListContainsMatcher<>(element));
	}
}


 现在进行一次测试，以展示我们的新Matcher！ 


@RunWith(MockitoJUnitRunner.class)
public class ListContainsMatcherTest {

	public interface TestClass {
		public boolean usesStrings(List list);
		public boolean usesIntegers(List list);
	}

	private List stringList = Arrays.asList("Hello", "Java", "Code", "Geek");
	private List integerList = Arrays.asList(1, 2, 3, 4, 5);

	@Mock
	TestClass test;

	@Test
	public void test() throws Exception {
		when(test.usesStrings(contains("Java"))).thenReturn(true);
		when(test.usesIntegers(contains(5))).thenReturn(true);
		assertTrue(test.usesIntegers(integerList));
		assertTrue(test.usesStrings(stringList));
		Mockito.reset(test);

		when(test.usesStrings(contains("Something Else"))).thenReturn(true);
		when(test.usesIntegers(contains(42))).thenReturn(true);
		assertFalse(test.usesStrings(stringList));
		assertFalse(test.usesIntegers(integerList));
		Mockito.reset(test);
	}
}


 作为练习，尝试编写自己的Matcher，如果Map包含特定的键/值对，则Matcher将匹配。 


6.间谍和部分存根 


 如前所述，可以使用@Spy批注对类进行部分存根。 部分存根允许我们在测试中使用真实的类，而仅存根与我们有关的特定行为。 Mockito准则告诉我们，在处理遗留代码时，通常应谨慎偶尔使用间谍。 最佳实践不是使用Spy部分模拟受测类，而是部分模拟依赖项。 被测类应始终是真实对象。 


 假设我们正在处理一个在java.awt.BufferedImage上工作的图像处理类。 此类将BufferedImage放入其构造函数中，并公开一个方法，该方法使用随机彩色的垂直条纹填充图像，并根据输入的缩略图高度返回图像的缩略图。 


public class ImageProcessor {

	private BufferedImage image;

	public ImageProcessor(BufferedImage image) {
		this.image = image;
	}

	public Image overwriteImageWithStripesAndReturnThumbnail(int thumbHeight) {
		debugOutputColorSpace();

		Random random = new Random();
		Color color = new Color(random.nextInt(255), random.nextInt(255), random.nextInt(255));

		for (int x = 0; x < image.getWidth(); x++) {
			if (x % 20 == 0) {
				color = new Color(random.nextInt(255), random.nextInt(255), random.nextInt(255));
				for (int y = 0; y < image.getHeight(); y++) {
					image.setRGB(x, y, color.getRGB());
				}
			}
		}

		Image thumbnail = image.getScaledInstance(-1, thumbHeight, Image.SCALE_FAST);

		Image microScale = image.getScaledInstance(-1, 5, Image.SCALE_DEFAULT);
		debugOutput(microScale);
		return thumbnail;
	}

	private void debugOutput(Image microScale) {
		System.out.println("Runtime type of microScale Image is " + microScale.getClass());

	}

	private void debugOutputColorSpace() {
		for (int i=0; i< image.getColorModel().getColorSpace().getNumComponents(); i++) {
			String componentName = image.getColorModel().getColorSpace().getName(i);
			System.out.println(String.format("Colorspace Component[%d]: %s", i, componentName));
		}
	}
}


 overwriteImageWithStripesAndReturnThumbnail()方法中发生了很多事情。 它要做的第一件事是输出一些有关图像颜色空间的调试信息。 然后，它会使用图像的宽度和高度方法生成一些随机颜色，并将其绘制为整个图像中的水平条纹。 然后，它执行缩放操作以返回代表缩略图的图像。 然后，它执行第二次缩放操作以生成一个小的诊断微映像，并输出此微映像的运行时类类型作为调试信息。 


 我们看到了与BufferedImage的许多交互，其中大多数是完全内部的或随机的。 最终，当我们要验证方法的行为时，对我们来说重要的是对getScaledInstance()的首次调用–如果我们方法的返回值是从getScaledInstance（）返回的对象，则类可以工作。 这是BufferedImage的行为，它对我们来说很重要。 我们面临的问题是对BufferedImages方法还有许多其他调用。 从测试的角度来看，我们并不真正在乎这些方法的返回值，但是如果我们不对它们的行为进行编码，则它们将以某种方式导致NullPointerException并可能导致其他不良行为。 


 为了解决这个问题，我们将为BufferedImage创建一个Spy，并且仅对我们感兴趣的getScaledInstance()方法进行存根处理。 


 让我们创建一个空的测试类，其中包含被测类和Spy类，以及一个用于返回缩略图的Mock。 


@RunWith(MockitoJUnitRunner.class)
public class ImageProcessorTest {

	private ImageProcessor processor;

	@Spy
	private BufferedImage imageSpy = new BufferedImage(800, 600, BufferedImage.TYPE_INT_ARGB);
	@Mock
	Image mockThumbnail;

	@Before
	public void setup() {
		processor = new ImageProcessor(imageSpy);
	}
}


 请注意，BufferedImage没有默认构造函数，因此我们必须使用它的参数化构造函数自行实例化它，如果它具有默认构造函数，我们可以让Mockito为我们实例化它。 


 现在，让我们首先尝试暂存我们感兴趣的行为。忽略输入高度，宽度和模式并继续对所有三个参数使用Argument Matchers是有意义的。 我们最终得到如下内容： 


given(imageSpy.getScaledInstance(anyInt(), anyInt(), anyInt())).willReturn(mockThumbnail);


 通常，这将是对Spy进行存根的最佳方法，但是，在这种情况下会出现问题– imageSpy是真正的BufferedImage，并且传递given() Given given()的存根调用是在存根操作执行时实际执行的真实方法调用由JVM运行。 getScaledInstance要求width和height不为零，因此此调用将导致引发IllegalArgumentException 。 


 一种可能的解决方案是在存根调用中使用实参 


@Test
	public void scale_should_return_internal_image_scaled() throws Exception {
		// Given
		given(imageSpy.getScaledInstance(-1, 100, Image.SCALE_FAST)).willReturn(mockThumbnail);

		// When
		Image actualImage = processor.overwriteImageWithStripesAndReturnThumbnail(100);

		// Then
		assertEquals(actualImage, mockThumbnail);
	}


 该测试成功运行，并在控制台上产生以下输出 


Colorspace Component[0]: Red
Colorspace Component[1]: Green
Colorspace Component[2]: Blue
Runtime type of microScale Image is class sun.awt.image.ToolkitImage


 使用实值的副作用是对getScaledInstance()的第二次调用getScaledInstance()用于创建用于调试的微图像）无法匹配，并且此时执行了BufferedImage中的real方法，而不是我们的存根行为–这就是为什么我们看到真正的输出的微图像的运行时类型，而不是Mockito模拟实现，我们将查看是否将嘲笑缩略图传递给了调试输出方法。 


 但是，如果我们想继续使用参数匹配器怎么办？ 可以使用doReturn()方法（如果您记得，通常用于void方法）对getScaledInstance()方法进行存根，而无需在存根时实际调用它。 


@Test
	public void scale_should_return_internal_image_scaled_doReturn() throws Exception {
		// Given
		doReturn(mockThumbnail).when(imageSpy).getScaledInstance(anyInt(), anyInt(), anyInt());

		// When
		Image actualImage = processor.overwriteImageWithStripesAndReturnThumbnail(100);

		// Then
		assertEquals(actualImage, mockThumbnail);
	}


 这给出以下输出： 


Colorspace Component[0]: Red
Colorspace Component[1]: Green
Colorspace Component[2]: Blue
Runtime type of microScale Image is class $java.awt.Image$$EnhancerByMockitoWithCGLIB$$72355119


 您可以看到微映像的运行时类型现在是Mockito创建的Mock实现。 之所以如此，是因为两个对getScaledInstance调用getScaledInstance与存根参数匹配，因此两个调用都返回了Mock缩略图。 


 有一种方法可以确保在第二个实例中调用Spy的真实方法，方法是使用doCallRealMethod()方法。 像往常一样，Mockito让您将存根方法链接在一起，以便为与存根参数匹配的存根方法的连续调用编写不同的行为。 


@Test
	public void scale_should_return_internal_image_scaled_doReturn_doCallRealMethod() throws Exception {
		// Given
		doReturn(mockThumbnail).doCallRealMethod().when(imageSpy).getScaledInstance(anyInt(), anyInt(), anyInt());

		// When
		Image actualImage = processor.overwriteImageWithStripesAndReturnThumbnail(100);

		// Then
		assertEquals(actualImage, mockThumbnail);
	}


 给出以下输出 


Colorspace Component[0]: Red
Colorspace Component[1]: Green
Colorspace Component[2]: Blue
Runtime type of microScale Image is class sun.awt.image.ToolkitImage


7.结论 


 我们已经研究了许多针对嘲笑和间谍的举止行为的方式，并且暗示了人们可以举止行为的方式几乎无限。 


 Mockito的javadoc是有关Stubbing方法（尤其是Mockito开箱即用提供的ArgumentMatchers）的良好信息来源。 


 我们已经详细介绍了存根行为，在下一个教程中，我们将研究使用Mockito验证框架来验证Mocks的行为。 


8.下载源代码 


 这是关于Mockito Stubbing的课程。 您可以在此处下载源代码： mockito2-stubbing 




翻译自: https://www.javacodegeeks.com/2015/11/mocks-spies-partial-mocks-and-stubbing.html




cks32和stm32


























你可能感兴趣的:(cks32和stm32_cks子，间谍，局部Mo子和短管)






    

  • 美易官方：盘前道指期货涨0.5%，游戏驿站跌逾15%
美股投资
财经人工智能大数据新浪微博微信微信公众平台百度金融

    在股市开盘前的交易时段，道指期货上涨了0.5%，而游戏驿站（GameStop）的股价却出现了大幅下跌，跌幅超过15%。这一市场动态引发了投资者的广泛关注，也反映了当前股市的复杂性和不确定性。美股股指期货周三盘前走强，交易员为季度末的再平衡做准备。本周因假期而缩短，美国将公布关键通胀数据。道指期货涨0.5%，标普500指数期货涨0.6%，纳指期货涨0.5%。德国DAX指数涨0.4%，英国富时100指
    

    • 

  • 2023-02-16
执剑饮烈酒

    1、开心点，反正谁也别想活着离开这个世界。——朱德庸2、我一直以为爱的反义词是不爱，直到现在我才明白，爱的反义词是遗忘。——《寻梦环游记》3、人生的最高境界是佛为心，道为骨，儒为表，大度看世界。技在手，能在身，思在脑，从容过生活。——南怀瑾4、如果一个民族沦落到，只剩下把升官发财当成最终目标和追求的时候，那么这个民族就危险了，一旦金钱和权利成了唯一的信仰，那将是悲哀的。——鲁迅5、人和人如果不在一
    

    • 

  • 【Python】一文详细介绍 py格式 文件
高斯小哥
Python基础【高质量合集】python新手入门学习

    【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
    

    • 

  • 《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情
迷影咖啡

    作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
    

    • 

  • Android和IOS应用开发-Flutter应用让屏幕在 app 运行期间保持常亮的方法
江上清风山间明月
FlutterandroidiosflutterKeepAlive屏幕常亮wakelock熄屏

    文章目录Flutter应用让屏幕在app运行期间保持常亮的方法方法一：使用系统插件方法二：使用Widgets注意事项Flutter应用让屏幕在app运行期间保持常亮的方法在Flutter开发中，可以使用以下两种方法让屏幕在app运行期间保持常亮：方法一：使用系统插件Flutter社区中已经有很多相关插件可供使用，比如wakelock:https://pub.dev/packages/wakeloc
    

    • 

  • 我喝醉了，但是与你无关
Z先生的日记本

    2019年04月10号晚上我和一个朋友喝酒了，彻彻底底的喝醉了，喝到短片，事后我问L，我说我喝醉了之后，都发生了什么，L没有告诉我详情，但是跟我说了大致，他说我跟他一直聊天，说自己小的时候的事，说自己爸妈的事，说自己现在过得很苦可能，确实是喝醉了酒，才会毫无防备的跟其他人说这些吧。L还说感觉我过得很苦，很心疼。醉了酒之后还哭了，想想还真是丢人一年前，在宿舍也有一瓶红酒，那是舍友出去拉赞助时候，友商
    

    • 

  • Flink中的SQL Client和SQL Gateway
BigDataMLApplication
flinkflinksqlgateway

    Flink中的SQLClient和SQLGateway对比目录定义基本原理适用场景主要区别常用运维命令示例官方链接正文1.定义SQLClient：FlinkSQLClient是一种用于提交和执行FlinkSQL语句的命令行界面或图形界面工具。SQLGateway：FlinkSQLGateway是一个独立的服务，它允许客户端通过RESTfulAPI将SQL查询提交到Flink集群。2.基本原理SQL
    

    • 

  • 【OpenModelica】4命令行大全
Wumbuk
python开发语言modelica

    命令行大全文章目录命令行大全一、SummaryofCommandsfortheInteractiveSessionHandler二、Runningthecompilerfromcommandline一、SummaryofCommandsfortheInteractiveSessionHandler以下是交互式会话处理器中当前可用命令的完整列表。•simulate(modelname)：翻译一个名为
    

    • 

  • 通俗易懂：MySQL中如何设置只读实例并确保数据一致性？
大龄下岗程序员
mysqljavamysqlspring

    在MySQL中设置只读实例主要应用于构建高可用性和扩展性的数据库环境，通常是为了分担读取负载或者用于备份和灾难恢复。以下是创建MySQL只读实例并确保数据一致性的基本步骤：1.创建并配置只读实例-主从复制设置-首先，你需要有一个主数据库实例（Master）负责接收所有的写操作。-创建一个或多个从数据库实例（Slave），并将它们配置为主数据库的复制品。这通常通过设置主从复制（Replication
    

    • 

  • 拼多多纸巾推荐：品质与性价比的完美结合
氧惠帮朋友一起省

    拼多多纸巾推荐拼多多纸巾返现怎么做在我们的日常生活中，纸巾已经成为不可或缺的用品。无论是在家庭、办公室还是旅途中，纸巾都是我们随时随地需要的物品。随着电商平台的兴起，越来越多的人选择在网上购买纸巾。其中，拼多多作为国内知名的电商平台之一，以其独特的社交电商模式和实惠的价格吸引了大量用户。今天，我们就来探讨如何在拼多多上选择品质优良、性价比高的纸巾，以及如何通过一些小技巧来获取更多的优惠。一、品质与
    

    • 

  • 5月8日盘前提示：维持短期可以操作到下周二左右的判断，重个股轻指数
九命_猫妖

    大盘：消息面。取消境外投资者额度限制，这个长线利好股市，短期影响不大，因为3000亿额度只用了1/3。额度本来就够用。走势看，昨天缩量横盘，走的还算中规中矩，近期一直弱势的次新股走势较强，前期强势股京威股份、光大嘉宝等跌停，由此判断市场还是存量博弈的市场，震荡是市场的主基调。维持短期可以操作到下周二左右的判断。下周后半段震荡回调的概率较高。思路：短期重个股轻指数行业和个股：物联网行业有利好，关注下
    

    • 

  • word字号和mathtype磅值关系及批量修改
小铁匠-Ma
office小技巧经验分享

    word字号和mathtype磅值关系及批量修改1.字号与磅值关系字号「八号」对应磅值5字号「七号」对应磅值5.5字号「小六」对应磅值6.5字号「六号」对应磅值7.5字号「小五」对应磅值9字号「五号」对应磅值10.5字号「小四」对应磅值12字号「四号」对应磅值14字号「小三」对应磅值15字号「三号」对应磅值16字号「小二」对应磅值18字号「二号」对应磅值22字号「小一」对应磅值24字号「一号」对应
    

    • 

  • 现在的婚姻是: 高彩礼和诸多要求让感情越来越淡漠
朦蒙哒

    很多人搞不明白为什么现在的人对婚姻的质量要求那么高可就是维持不了多久时间，有不少人的婚姻是用礼金堆起来的，但恰恰是这些人最容易夫妻感情出问题导致离婚收场。现在的婚姻让年轻人失望，年轻人为什么对婚姻失望甚至没了渴望，无非就是这几个原因01彩礼高了感情淡了我们都知道，结婚要的高彩礼把很多年轻人给搞怕了，搞得很多年轻人都不敢结婚生子了，可以说彩礼高了让很多男女都失去了真感情，就算能在一起也只是男人需要老
    

    • 

  • 美团自动配送车2024春季招聘 | 社招专场
美团技术团队

    关于美团自动配送团队美团自动配送以自研L4级自动驾驶软硬件技术为核心，与美团即时零售业务结合，形成满足公开道路、校园、社区、工业园区等室外全场景下的自动配送整体解决方案。美团自动配送团队成立于2016年，团队成员来自于Waymo、Cruise、Pony.ai、泛亚等自动驾驶行业头部公司，自动驾驶技术团队博士占比高达30%，依靠视觉、激光等传感器，实时感知预测周围环境，通过高精地图定位和智能决策规划
    

    • 

  • 下载Android源码
赛非斯

    repoinit-uhttps://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/manifest-bandroid-10.0.0_r411.首先下载repo：a）终端运行gitclonegit://codeaurora.org/tools/repo.gitb）mkdir~/binc）拷贝repo到~/bin下面，修改repo权限，chmoda+x~
    

    • 

  • 读思001 ‖ 变负能为正能，变压力为动力
你不懂夜的黑

    今天起开始写一个言说文集连载，重点为读写思考收获和感想，也收录生活和工作中开悟到的点滴，仍然是一个碎片式的思考积累。希望这样的思考能启迪我的生活智慧，开悟我的思想境界，也算是一个修心的过程吧。这个连载不定期更新，重在积累生活和工作中的随思碎思，或许也是一厢情愿的一个梦。也或许这个梦是我坚持说下去的一个重要理由。读思001变负能为正能，变压力为动力1从来没有一种哲学能解决一切问题，也从来没有一种药能
    

    • 

  • 信任
饮冰伊乔

    随着社会的发展，微信和支付宝交易给人们带来了极大的方便，越来越多的人出门都只选择拿一部手机即可，方便安全，可昨天我就遇到了一件比较尴尬的事。昨天傍晚，我从公司出来，感觉有点饿，决定索性吃了饭再回去，来到去过几次的一个店里，如往常一样叫了餐，当时店里吃饭的不多，老板麻利的先去做了，正要扫微信付账的时候发现手机没电了，迷之尴尬，我只好跟老板说不用做了，手机没电了，我身上又没现金，付不了帐了。老板娘很热
    

    • 

  • 《对我而言危险的他》：“假千金”归来，携手神秘霸总共破迷局
入骨影评

    由樊治欣李墨之主演的都市悬疑爱情剧《对我而言危险的他》在网上平台一次性播出全集。虽然是个小成本网剧，呈现出来的效果却十分有诚意。剧中从车祸到坠海、再到徒手灭火等惊险场面都是实景拍摄和主演们的无替身上场。说起樊治欣这个名字可能大家都不熟悉，但提起他演过的剧，大家都不陌生。饰演过《暗格里的秘密》中的学长苏柏从的樊治欣在这部剧中饰演霸总严星呈，即便同样戴着眼镜，却给人不一样的观感。该剧主要讲述了女主沈漫
    

    • 

  • 男人请珍惜十六七岁陪在你身边的女孩吧
小朋友嘿哈

    你相信那种从校服到婚纱的爱情吗。01朋友阿伟18岁的时候就是一混混，放学不是和这个学校的学生约架，就是那个小弟被欺负了要为此出头，溜冰场上看谁不顺眼，一个字：打。当然，放学蹲点泡妞是常事，看到这个学生妹浓妆艳抹，搭讪，看到那个前凸后翘的，搭讪。阿伟也不例外，他说：“我当时和几个兄弟在学校后门的小卖部抽烟，姗姗背着双肩背包，扎着马尾辫，看到我们几个混混有些害怕的低着头快步走过我们面前，那时候我在想啊
    

    • 

  • 学习JavaEE的日子 Day32 线程池
A 北枝
学习JavaEE学习java-eejava线程池

    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
    

    • 

  • 你之所以胖，可能是因为小时候发生这件事！还不赶快甩锅
周围_5d19

    通常，我们认为，“肥胖”主要是由于饮食不节制、不经常运动等等因素引起的。但最近，我国学者开展的一项针对6到18岁儿童青少年、随访长达十年的代谢综合征研究结果，在权威国际期刊发表。研究发现，儿童的肥胖和超重与睡眠密切相关，儿童、青少年时期睡眠不好，成人后也更容易患心血管疾病。那么，为什么儿童青少年睡眠不足会导致肥胖呢？今天就带大家一探究竟。儿童青少年肥胖的现状如何？近日，一项刊载在医学权威期刊《柳叶
    

    • 

  • 淘宝天猫38节活动时间和玩法，2024年焕新周满减优惠多少
小小编007

    在2024年，淘宝天猫平台即将迎来一年一度的38节活动，这是广大消费者们翘首以待的购物狂欢节。在这篇文章中，我们将为您详细解读淘宝天猫38节活动的时间安排和玩法，以及2024年焕新周的满减优惠力度。一、淘宝天猫38节活动时间2024年淘宝天猫38节活动将于2月28日正式启动，持续至3月8日，为期10天。活动期间，消费者们可以尽情享受各种优惠折扣、满减活动以及限时秒杀，尽情释放购物热情。2024淘宝
    

    • 

  • 感恩日志
圆施

    张新丽2019年8月16日感恩日志：1.感恩天地滋养万物；感恩国家恩惠护佑；感恩父母养育深恩。2.感恩尊重为平台源头付出的所有人事物。3.感恩红斌、孙萍清晨7点开车来接我和小姨去安宁渠采摘。4.感恩小姨和小姨夫亲自采摘还带我们去瓜地品尝，第一次这么吃好甜啊，忘掉了炎热消了暑，拍下了瞬间，分享着快乐，带给大家。4.感恩整理收拾好小姨给大家利用午休蒸苞米。5.感恩去接爸妈参加沙龙。6.感恩祝福两位伙伴
    

    • 

  • llama.cpp 编译安装@Ubuntu
skywalk8163
项目实践人工智能llamaubuntulinux人工智能

    在Kylin和Ubuntu编译llama.cpp，具体参考：llama模型c语言推理@FreeBSD-CSDN博客现在代码并编译：gitclonehttps://github.com/ggerganov/llama.cppcdllama.cppmkdirbuildcdbuildcmake..cmake--build.--configRelease#可选安装makeinstall#或可选添加路径ex
    

    • 

  • 黔东南——苗年（一）
非常道yw

    苗年是雷山县苗族同胞最隆重的民族传统节日，也是苗族人一年中庆祝丰收和最重要的祭祀性的日子，更是雷山苗族一年里劳作的结束和欢乐的开始。如同汉族的春节。节日期间，各村寨都要举行跳芦笙、篮球赛、斗牛、赛马、斗鸟、铜鼓舞、篝火晚会等民间传统娱乐活动。苗年也是最集中地展示苗族服饰、银饰、手工艺美术等有形文化的节日，时间大都在农历十月。苗族认为，一年只有热、冷两个季节，热季和冷季交替的农历十月，既是热季的结束
    

    • 

  • SpringMVC设置全局异常处理器
水岸齐天
javaspring

    文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
    

    • 

  • 为什么说仪式和习惯非常重要？
章鱼老师zy

    这是章鱼姐第【40】篇原创文章，日更计划第【37/100】天。阅读张萌萌姐【精力管理手册】第【6/7】章。一阅读摘要这一章萌姐讲到了习惯的重要性，为什么说养成一个习惯很重要？如何养成一个好习惯？如何建立自己的仪式感？二金句精力管理最重要的是产生什么效果。当你想做却没有动力去做一件事情时，你就应该把它养成习惯。习惯可以帮我们创造稳定框架。对于那些特别考验意志的事情，我们应该先行后思。三思考题，萌姐讲
    

    • 

  • 安神的投资札记——指数跟踪周报（20220602）
echo安神

    本周关键词：缩表上周调整过后，本周又反弹了。最近创业板好活跃，跌的时候跌得凶，涨的时候也涨得猛。底部特征明显。上证50，0.99%；沪深300，2.21%；中证100，1.85%；中证500，3.03%；深证100，3.71%；创业板指数，5.85%；中证1000，3.75%。美联储6月1日开启缩表，每月总计减持475亿美元美国国债和MBS（抵押贷款支持证券），并将在3个月后提高缩表上限至每月95
    

    • 

  • 社交电商是什么意思通俗的说
氧惠好项目

    社交电商是目前电商发展的一个非常热门的领域，它将传统的电商和社交媒体相结合，让用户可以在社交平台上完成购物、支付等操作。社交电商不同于传统电商，它更加注重用户的社交性和互动性，通过社交媒体的传播，吸引用户关注，让产品能够更加快速地传播。京东密令红包：最爱领红包828红包多多148今天给大家分享我长期在做的副业，也在这里赚到人生第3桶金！氧惠APP佣金高，资质靠谱，各大应用市场均可搜索使用。【氧惠】
    

    • 

  • 口才训练的第一个礼物
Leah82

    昨天，看到陶子教练在总结里写的“随机抽，已经是很久远的年代了”，Tom教练在后面回复“久远是多远？不过是几个月罢了！”。看着就想笑。对呀，感觉很久远的事，不过是几个月而已。为什么会有这种感觉呢？因为，在这短短的几个月里，我们都经历了太多太多。成长，蜕变，口才，思想……“那久远的年代里”，曾经让自己心惊胆战的随机抽，已经是过眼云烟了。但是，我们还是记忆犹新。因为，随机抽通关，是我们跨入口才训练大门后
    

    • 

  • scala的option和some
矮蛋蛋
编程scala

    原文地址：
http://blog.sina.com.cn/s/blog_68af3f090100qkt8.html
对于学习 Scala 的 Java™ 开发人员来说，对象是一个比较自然、简单的入口点。在 本系列 前几期文章中，我介绍了 Scala 中一些面向对象的编程方法，这些方法实际上与 Java 编程的区别不是很大。我还向您展示了 Scala 如何重新应用传统的面向对象概念，找到其缺点
    

    • 

  • NullPointerException
Cb123456
androidBaseAdapter

     
  java.lang.NullPointerException: Attempt to invoke virtual method 'int android.view.View.getImportantForAccessibility()' on a null object reference
 
  出现以上异常.然后就在baidu上
    

    • 

  • PHP使用文件和目录
天子之骄
php文件和目录读取和写入php验证文件php锁定文件

    PHP使用文件和目录
1.使用include()包含文件
(1)：使用include()从一个被包含文档返回一个值
(2)：在控制结构中使用include()
 
include_once()函数需要一个包含文件的路径，此外，第一次调用它的情况和include()一样，如果在脚本执行中再次对同一个文件调用，那么这个文件不会再次包含。
 
在php.ini文件中设置
    

    • 

  • SQL SELECT DISTINCT 语句
何必如此
sql

    SELECT DISTINCT 语句用于返回唯一不同的值。
SQL SELECT DISTINCT 语句
在表中，一个列可能会包含多个重复值，有时您也许希望仅仅列出不同（distinct）的值。
DISTINCT 关键词用于返回唯一不同的值。
SQL SELECT DISTINCT 语法
SELECT DISTINCT column_name,column_name
F
    

    • 

  • java冒泡排序
3213213333332132
java冒泡排序

    package com.algorithm;
/**
* @Description 冒泡
* @author FuJianyong
* 2015-1-22上午09:58:39
*/
public class MaoPao {
public static void main(String[] args) {
int[] mao = {17,50,26,18,9,10
    

    • 

  • struts2.18 +json,struts2-json-plugin-2.1.8.1.jar配置及问题！
7454103
DAOspringAjaxjsonqq

    struts2.18  出来有段时间了！ （貌似是 稳定版）
 
闲时研究下下！  貌似 sruts2 搭配 json 做 ajax 很吃香！
 
实践了下下！ 不当之处请绕过！ 呵呵
 
网上一大堆 struts2+json  不过大多的json 插件 都是 jsonplugin.34.jar
 
strut
    

    • 

  • struts2 数据标签说明
darkranger
jspbeanstrutsservletScheme

    数据标签主要用于提供各种数据访问相关的功能，包括显示一个Action里的属性，以及生成国际化输出等功能
数据标签主要包括：
action ：该标签用于在JSP页面中直接调用一个Action，通过指定executeResult参数，还可将该Action的处理结果包含到本页面来。
bean ：该标签用于创建一个javabean实例。如果指定了id属性，则可以将创建的javabean实例放入Sta
    

    • 

  • 链表.简单的链表节点构建
aijuans
编程技巧

    /*编程环境WIN-TC*/ #include "stdio.h" #include "conio.h"
#define NODE(name, key_word, help) \  Node name[1]={{NULL, NULL, NULL, key_word, help}}
typedef struct node {  &nbs
    

    • 

  • tomcat下jndi的三种配置方式
avords
tomcat

    jndi(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。命名服务将名称和对象联系起来，使得我们可以用名称
访问对象。目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。
         tomcat配置
    

    • 

  • 关于敏捷的一些想法
houxinyou
敏捷

    从网上看到这样一句话：“敏捷开发的最重要目标就是：满足用户多变的需求，说白了就是最大程度的让客户满意。”
感觉表达的不太清楚。
感觉容易被人误解的地方主要在“用户多变的需求”上。
第一种多变，实际上就是没有从根本上了解了用户的需求。用户的需求实际是稳定的，只是比较多，也比较混乱，用户一般只能了解自己的那一小部分，所以没有用户能清楚的表达出整体需求。而由于各种条件的，用户表达自己那一部分时也有
    

    • 

  • 富养还是穷养，决定孩子的一生
bijian1013
教育人生

     是什么决定孩子未来物质能否丰盛？为什么说寒门很难出贵子，三代才能出贵族？真的是父母必须有钱，才能大概率保证孩子未来富有吗？-----作者：@李雪爱与自由
事实并非由物质决定，而是由心灵决定。一朋友富有而且修养气质很好，兄弟姐妹也都如此。她的童年时代，物质上大家都很贫乏，但妈妈总是保持生活中的美感，时不时给孩子们带回一些美好小玩意，从来不对孩子传递生活艰辛、金钱来之不易、要懂得珍惜
    

    • 

  • oracle 日期时间格式转化
征客丶
oracle

    oracle 系统时间有 SYSDATE 与 SYSTIMESTAMP；
SYSDATE：不支持毫秒，取的是系统时间；
SYSTIMESTAMP：支持毫秒，日期，时间是给时区转换的，秒和毫秒是取的系统的。
日期转字符窜：
一、不取毫秒：
TO_CHAR(SYSDATE, 'YYYY-MM-DD HH24:MI:SS')
简要说明，
YYYY 年
MM   月
    

    • 

  • 【Scala六】分析Spark源代码总结的Scala语法四
bit1129
scala

    1. apply语法
 
FileShuffleBlockManager中定义的类ShuffleFileGroup，定义：
 
private class ShuffleFileGroup(val shuffleId: Int, val fileId: Int, val files: Array[File]) {
...
def apply(bucketId
    

    • 

  • Erlang中有意思的bug
bookjovi
erlang

     
代码中常有一些很搞笑的bug，如下面的一行代码被调用两次（Erlang beam）
commit f667e4a47b07b07ed035073b94d699ff5fe0ba9b
Author: Jovi Zhang <[email protected]>
Date: Fri Dec 2 16:19:22 2011 +0100
erts:
    

    • 

  • 移位打印10进制数转16进制-2008-08-18
ljy325
java基础

    
/**
* Description 移位打印10进制的16进制形式
* Creation Date 15-08-2008 9:00
* @author 卢俊宇
* @version 1.0
*
*/
public class PrintHex {
// 备选字符
static final char di
    

    • 

  • 读《研磨设计模式》-代码笔记-组合模式
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
import java.util.ArrayList;
import java.util.List;
abstract class Component {
public abstract void printStruct(Str
    

    • 

  • 利用cmd命令将.class文件打包成jar
chenyu19891124
cmdjar

    cmd命令打jar是如下实现：
在运行里输入cmd，利用cmd命令进入到本地的工作盘符。(如我的是D盘下的文件有此路径 D:\workspace\prpall\WEB-INF\classes)
现在是想把D:\workspace\prpall\WEB-INF\classes路径下所有的文件打包成prpall.jar。然后继续如下操作：
cd D: 回车
cd workspace/prpal
    

    • 

  • [原创]JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明
comsci
eclipse设计模式算法工作swing

        
                  JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明
    &nb
    

    • 

  • SecureCRT右键粘贴的设置
daizj
secureCRT右键粘贴

    一般都习惯鼠标右键自动粘贴的功能，对于SecureCRT6.7.5 ，这个功能也已经是默认配置了。
老版本的SecureCRT其实也有这个功能，只是不是默认设置，很多人不知道罢了。
菜单：
Options->Global Options ...->Terminal
右边有个Mouse的选项块。
Copy on Select
Paste on Right/Middle
    

    • 

  • Linux 软链接和硬链接
dongwei_6688
linux

    1.Linux链接概念Linux链接分两种，一种被称为硬链接（Hard Link），另一种被称为符号链接（Symbolic Link）。默认情况下，ln命令产生硬链接。
【硬连接】硬连接指通过索引节点来进行连接。在Linux的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，称为索引节点号(Inode Index)。在Linux中，多个文件名指向同一索引节点是存在的。一般这种连
    

    • 

  • DIV底部自适应
dcj3sjt126com
JavaScript

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml&q
    

    • 

  • Centos6.5使用yum安装mysql——快速上手必备
dcj3sjt126com
mysql

    第1步、yum安装mysql
[root@stonex ~]#  yum -y install mysql-server
安装结果：
Installed:
    mysql-server.x86_64 0:5.1.73-3.el6_5                   &nb
    

    • 

  • 如何调试JDK源码
frank1234
jdk

    相信各位小伙伴们跟我一样，想通过JDK源码来学习Java，比如collections包，java.util.concurrent包。
可惜的是sun提供的jdk并不能查看运行中的局部变量，需要重新编译一下rt.jar。
下面是编译jdk的具体步骤：
        1.把C:\java\jdk1.6.0_26\sr
    

    • 

  • Maximal Rectangle
hcx2013
max

    Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area.
 
public class Solution {
public int maximalRectangle(char[][] matrix)
    

    • 

  • Spring MVC测试框架详解——服务端测试
jinnianshilongnian
spring mvc test

    随着RESTful Web Service的流行，测试对外的Service是否满足期望也变的必要的。从Spring 3.2开始Spring了Spring Web测试框架，如果版本低于3.2，请使用spring-test-mvc项目（合并到spring3.2中了）。
 
Spring MVC测试框架提供了对服务器端和客户端（基于RestTemplate的客户端）提供了支持。
&nbs
    

    • 

  • Linux64位操作系统（CentOS6.6）上如何编译hadoop2.4.0
liyong0802
hadoop

    一、准备编译软件
  1.在官网下载jdk1.7、maven3.2.1、ant1.9.4，解压设置好环境变量就可以用。
    环境变量设置如下：
 
（1）执行vim /etc/profile
（2）在文件尾部加入:
export JAVA_HOME=/home/spark/jdk1.7
export MAVEN_HOME=/ho
    

    • 

  • StatusBar 字体白色
pangyulei
status

    
[[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleLightContent];
/*you'll also need to set UIViewControllerBasedStatusBarAppearance to NO in the plist file if you use this method
    

    • 

  • 如何分析Java虚拟机死锁
sesame
javathreadoracle虚拟机jdbc

    英文资料：
Thread Dump and Concurrency Locks
 
Thread dumps are very useful for diagnosing synchronization related problems such as deadlocks on object monitors. Ctrl-\ on Solaris/Linux or Ctrl-B
    

    • 

  • 位运算简介及实用技巧（一）：基础篇
tw_wangzhengquan
位运算

    http://www.matrix67.com/blog/archives/263
   去年年底写的关于位运算的日志是这个Blog里少数大受欢迎的文章之一，很多人都希望我能不断完善那篇文章。后来我看到了不少其它的资料，学习到了更多关于位运算的知识，有了重新整理位运算技巧的想法。从今天起我就开始写这一系列位运算讲解文章，与其说是原来那篇文章的follow-up，不如说是一个r
    

    • 

  • jsearch的索引文件结构
yangshangchuan
搜索引擎jsearch全文检索信息检索word分词

    jsearch是一个高性能的全文检索工具包，基于倒排索引，基于java8，类似于lucene，但更轻量级。
 
jsearch的索引文件结构定义如下：
    1、一个词的索引由=分割的三部分组成：        第一部分是词        第二部分是这个词在多少
    

    •