Java ExpectedException.expect方法代码示例

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
@Test
public void testExceptionThrownWhenMisConfigured() throws Exception {
  Configuration conf = new Configuration(TEST_UTIL.getConfiguration());
  conf.set("hbase.thrift.security.qop", "privacy");
  conf.setBoolean("hbase.thrift.ssl.enabled", false);

  ThriftServerRunner runner = null;
  ExpectedException thrown = ExpectedException.none();
  try {
    thrown.expect(IllegalArgumentException.class);
    thrown.expectMessage("Thrift HTTP Server's QoP is privacy, " +
        "but hbase.thrift.ssl.enabled is false");
    runner = new ThriftServerRunner(conf);
    fail("Thrift HTTP Server starts up even with wrong security configurations.");
  } catch (Exception e) {
  }

  assertNull(runner);
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
/** Tests trying to call add after calling sort. Should throw an exception. */
public static void testAddAfterSort(Sorter sorter, ExpectedException thrown) throws Exception {
  thrown.expect(IllegalStateException.class);
  thrown.expectMessage(is("Records can only be added before sort()"));
  KV<byte[], byte[]> kv = KV.of(new byte[] {4, 7}, new byte[] {1, 2});
  sorter.add(kv);
  sorter.sort();
  sorter.add(kv);
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
/** Tests trying to calling sort twice. Should throw an exception. */
public static void testSortTwice(Sorter sorter, ExpectedException thrown) throws Exception {
  thrown.expect(IllegalStateException.class);
  thrown.expectMessage(is("sort() can only be called once."));
  KV<byte[], byte[]> kv = KV.of(new byte[] {4, 7}, new byte[] {1, 2});
  sorter.add(kv);
  sorter.sort();
  sorter.sort();
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
@Test
public void testHTTPError() {
	ExpectedException exception = ExpectedException.none();
	try {
		exception.expect(CandybeanException.class);
		response = WS.request(WS.OP.POST, uri + "/get", headers, "", ContentType.DEFAULT_TEXT);
		Assert.fail();
	} catch (CandybeanException e) {
		Assert.assertEquals("HTTP request received HTTP code: 405",
				e.getMessage().split("\n")[0]);
	}
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
@Test
@Ignore("This test should pass, but takes a full minute to do so because it" +
		"waits for the response to time out.")
public void testResponseError() {
	ExpectedException exception = ExpectedException.none();
	try {
		exception.expect(CandybeanException.class);
		// Send to an IP address that does not exist
		response = WS.request(WS.OP.POST, "http://240.0.0.0", headers, "", ContentType.DEFAULT_TEXT);
		Assert.fail();
	} catch (CandybeanException e) {
		Assert.assertEquals("Connect to 240.0.0.0:80 [/240.0.0.0] failed: Operation timed out", e.getMessage());
	}
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
public static void expectInvalidSyntaxUsageForClassInsteadOfInterface(ExpectedException thrown, Class<?> nonInterface) {
    thrown.expect(InvalidSyntaxUsageException.class);
    thrown.expectMessage(nonInterface.getName());
    thrown.expectMessage("interface");
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
public static void expectInvalidSyntaxUsageForRetentionSource(ExpectedException thrown) {
    thrown.expect(InvalidSyntaxUsageException.class);
    thrown.expectMessage(Retention.class.getSimpleName());
    thrown.expectMessage(RetentionPolicy.SOURCE.name());
    thrown.expectMessage("useless");
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
public static void assertNullPointerExceptionThrown(ExpectedException expectedException, String expectMessage) {
	expectedException.expect(NullPointerException.class);
	expectedException.expectMessage(expectMessage);
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
/**
 * Checks the GET operation fails when the downloaded file (from HA store)
 * is corrupt, i.e. its content's hash does not match the {@link BlobKey}'s hash.
 *
 * @param config
 * 		blob server configuration (including HA settings like {@link HighAvailabilityOptions#HA_STORAGE_PATH}
 * 		and {@link HighAvailabilityOptions#HA_CLUSTER_ID}) used to set up <tt>blobStore</tt>
 * @param blobStore
 * 		shared HA blob store to use
 * @param expectedException
 * 		expected exception rule to use
 */
public static void testGetFailsFromCorruptFile(
		Configuration config, BlobStore blobStore, ExpectedException expectedException)
		throws IOException {

	Random rnd = new Random();
	JobID jobId = new JobID();

	try (BlobServer server = new BlobServer(config, blobStore)) {

		server.start();

		byte[] data = new byte[2000000];
		rnd.nextBytes(data);

		// put content addressable (like libraries)
		BlobKey key = put(server, jobId, data, PERMANENT_BLOB);
		assertNotNull(key);

		// delete local file to make sure that the GET requests downloads from HA
		File blobFile = server.getStorageLocation(jobId, key);
		assertTrue(blobFile.delete());

		// change HA store file contents to make sure that GET requests fail
		byte[] data2 = Arrays.copyOf(data, data.length);
		data2[0] ^= 1;
		File tmpFile = Files.createTempFile("blob", ".jar").toFile();
		try {
			FileUtils.writeByteArrayToFile(tmpFile, data2);
			blobStore.put(tmpFile, jobId, key);
		} finally {
			//noinspection ResultOfMethodCallIgnored
			tmpFile.delete();
		}

		// issue a GET request that fails
		expectedException.expect(IOException.class);
		expectedException.expectMessage("data corruption");

		get(server, jobId, key);
	}
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
protected void expect404NotFoundCallfireApiException(ExpectedException ex) {
    ex.expect(CallfireApiException.class);
    ex.expect(hasProperty("apiErrorMessage", hasProperty("httpStatusCode", Matchers.is(404))));
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public static void setExpectedExceptions(ExpectedException exception, Class<?> type, String message) {
    exception.expect((Class<? extends Throwable>) type);
    exception.expectMessage(message);
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public static void setExpectedExceptions(Class<?> type, ExpectedException exception, String message) {
    exception.expect((Class<? extends Throwable>) type);
    exception.expectMessage(message);
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
/**
 * Statement that a unit should throw a specific exception for a particular case
 *
 * @param throwable the class of the expected exception type
 * @param forCase   a description of the case in which it should be thrown
 * @param testCase  an implementation of the case in which is should be thrown
 * @param <T>       the expected exception type
 * @return a Specification representing the single description
 */
default <T extends Throwable> SpecificationNode itThrows(Class<T> throwable, String forCase, Test testCase) {
    ExpectedException expectedException = ExpectedException.none();
    expectedException.expect(throwable);
    return SpecificationNode.leaf(
        String.format("throws %s %s", throwable.getSimpleName(), forCase),
        testCase).withRule(expectedException);
}
 

import org.junit.rules.ExpectedException; //导入方法依赖的package包/类
/**
 * Convenience method to match message without arguments
 * on our custom BusinessValidationException.
 *
 * NOTE: expectMessage with equalTo() instead of the standard hamcrest contains()
 *
 * @param thrown ExpectedException to attach to
 * @param message that is expected
 */
public static void expect(String message, ExpectedException thrown)
{
    thrown.expect(BusinessValidationException.class);
    thrown.expectMessage(equalTo(message));
}