import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Timed(millis=2000)
@Test
public void testUsingSpringTimedAnnotationTest() throws InterruptedException {	
	log.debug("Using Spring Test fixtures:");
			
	List<Document> documents = engine.findByType(webType);
	assertNotNull(documents);
	assertTrue(documents.size() == 1);
	assertEquals(webType.getName(),documents.get(0).getType().getName());
	assertEquals(webType.getDesc(),documents.get(0).getType().getDesc());
	assertEquals(webType.getExtension(),documents.get(0).getType().getExtension());
	
	Thread.sleep(500);
	
	documents = engine.listAll();
	assertNotNull(documents);
	assertTrue(documents.size() == 4);
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
/**
 * Runs a <em>timed</em> test via the supplied {@link TestExecutionCallback}
 * , providing support for the {@link Timed &#064;Timed} annotation.
 *
 * @param tec the test execution callback to run
 * @param testMethod the actual test method: used to retrieve the
 * {@code timeout}
 * @throws Throwable if any exception is thrown
 * @see Timed
 * @see #runTest
 */
private void runTestTimed(TestExecutionCallback tec, Method testMethod) throws Throwable {
	Timed timed = testMethod.getAnnotation(Timed.class);
	if (timed == null) {
		runTest(tec, testMethod);
	}
	else {
		long startTime = System.currentTimeMillis();
		try {
			runTest(tec, testMethod);
		}
		finally {
			long elapsed = System.currentTimeMillis() - startTime;
			if (elapsed > timed.millis()) {
				fail("Took " + elapsed + " ms; limit was " + timed.millis());
			}
		}
	}
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
/**
 * test multiple call on update service
 */
@Test
@Timed(millis = 4000)
public void testMultipleUpdate() throws IOException {
	for (final int id : testCreateAll()) {
		testUpdate(id);
	}
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
/**
 * test multiple call on find all service
 */
@Test
@Timed(millis = 8000)
public void testMultipleFindAll() throws IOException {
	testCreateAll();
	for (int loop = NB_ITERATION; loop-- > 0;) {
		testFindAll();
	}
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
/**
 * test multiple call on find by id service
 */
@Test
@Timed(millis = 8000)
public void testMultipleFindById() throws IOException {
	for (final int id : testCreateAll()) {
		testFindById(id);
	}
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
/**
 * test multiple call on delete service
 */
@Test
@Timed(millis = 8000)
public void testMultipleDelete() throws IOException {
	for (final int id : testCreateAll()) {
		testDelete(id);
	}
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@Timed(millis = 10000)
@Repeat(5)
public void notTransactionalWithSpringTimeout() {
	assertInTransaction(false);
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test
@Timed(millis = 10)
@Repeat(1)
public void singleRepetitionExceedsTimeout() throws Exception {
	incrementInvocationCount();
	Thread.sleep(15);
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test
@Timed(millis = 20)
@Repeat(4)
public void firstRepetitionOfManyExceedsTimeout() throws Exception {
	incrementInvocationCount();
	Thread.sleep(25);
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test
@Timed(millis = 100)
@Repeat(10)
public void collectiveRepetitionsExceedTimeout() throws Exception {
	incrementInvocationCount();
	Thread.sleep(11);
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Timed(millis=273)
public void testJdbcTx2() throws InterruptedException {
	//Thread.sleep(2000);
	assertEquals("Any previous tx must have been rolled back", 0, countRowsInTable("person"));
	//insertPerson("foo");
	executeSqlScript("/org/springframework/orm/jpa/insertPerson.sql", false);
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test
@NotTransactional
@Timed(millis = 10000)
@Repeat(5)
public void notTransactionalWithSpringTimeout() {
	assertInTransaction(false);
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test
    @Timed(millis = 10)
    public void testTimedExecution() throws Exception {
        System.out.println("Will fail if method takes longer than 10 millis. " +
                "Will wait for it to finish, unlike JUnit timeout");

//        java.util.concurrent.TimeUnit.MILLISECONDS.sleep(15);

    }
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test()
@Timed(millis = 100)
public void testSpringTimeout() throws InterruptedException {
    Thread.sleep(50);
    // Thread.sleep(120);
    assertThat(true, equalTo(Boolean.TRUE));
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
/**
 * test multiple call on create service
 */
@Test
@Timed(millis = 4000)
public void testMultipleCreate() throws IOException {
	testCreateAll();
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test
@Timed(millis = 10000)
@Repeat(5)
public void transactionalWithSpringTimeout() {
	assertInTransaction(true);
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test
@Timed(millis = 2000)
public void springTimeoutWithNoOp() {
	/* no-op */
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test
@Timed(millis = 100)
public void springTimeoutWithSleep() throws Exception {
	Thread.sleep(200);
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test(timeout = 200)
@Timed(millis = 200)
public void springAndJUnitTimeouts() {
	/* no-op */
}
 

import org.springframework.test.annotation.Timed; //导入依赖的package包/类
@Test
@Timed(millis = 10000)
public void nonAnnotated() throws Exception {
	incrementInvocationCount();
}