Java ExpectedException类代码示例

import org.junit.rules.ExpectedException; //导入依赖的package包/类
@Test
public void noValueForSize() throws IOException {
    thrown = ExpectedException.none();
    // Basic division by zero.
    final Token token = def("a", div(con(1), con(0)));
    assertFalse(token.parse(env(stream(1))).isPresent());
    // Try to negate division by zero.
    final Token token2 = def("a", neg(div(con(1), con(0))));
    assertFalse(token2.parse(env(stream(1))).isPresent());
    // Add one to division by zero.
    final Token token3 = def("a", add(div(con(1), con(0)), con(1)));
    assertFalse(token3.parse(env(stream(1))).isPresent());
    // Add division by zero to one.
    final Token token4 = def("a", add(con(1), div(con(1), con(0))));
    assertFalse(token4.parse(env(stream(1))).isPresent());
}
 

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包/类
@Test
public void testAnnotationBasedParser() {
    expectedEx = ExpectedException.none();

    MyMapper mapper = new MyMapper();

    TestRecord record = new TestRecord("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) " +
        "Chrome/48.0.2564.82 Safari/537.36");

    record = mapper.enrich(record);

    assertEquals("Desktop", record.deviceClass);
    assertEquals("Chrome 48.0.2564.82", record.agentNameVersion);
}
 

import org.junit.rules.ExpectedException; //导入依赖的package包/类
@After
public void tearDown() throws Exception {
    //单个测试案例执行完之后，引用置空，防止数据污染
    tEmployee = null;
    tEmployeeExample = null;
    expectedException = ExpectedException.none();
}
 

import org.junit.rules.ExpectedException; //导入依赖的package包/类
@Test
public void testMakeFromUrlAndPath() throws Exception {
    if (expectedResult == null) {
        expectedException.expect(IllegalArgumentException.class);
    } else {
        expectedException = ExpectedException.none();
    }

    assertThat(UrlHelper.makeFromUrlAndPath(url, path)).isEqualTo(expectedResult);
}
 

import org.junit.rules.ExpectedException; //导入依赖的package包/类
private TypeSpec classTest(ClassName className, List<MethodSpec> methodSpecs) {
  String methodName = Introspector
      .decapitalize(className.simpleName());

  MethodSpec abstractMethodInstanceToTest = methodBuilder(methodName)
      .addModifiers(Modifier.ABSTRACT, Modifier.PROTECTED)
      .returns(className)
      .build();

  FieldSpec exception = FieldSpec.builder(ExpectedException.class, "exception")
      .addAnnotation(Rule.class)
      .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
      .initializer("$T.none()", ExpectedException.class)
      .build();

  return TypeSpec.classBuilder(className.simpleName() + "Test_")
      .addModifiers(Modifier.ABSTRACT, Modifier.PUBLIC)
      .addMethod(abstractMethodInstanceToTest)
      .addField(exception)
      .addAnnotation(AnnotationSpec.builder(Generated.class)
          .addMember("value", "$S", MockeryProcessor.class.getCanonicalName())
          .addMember("comments", "$S", CMessages.codeGenerateWarning())
          .build())
      .addAnnotation(AnnotationSpec.builder(RunWith.class)
          .addMember("value", "$T.class", OrderedRunner.class)
          .build())
      .addMethods(methodSpecs)
      .build();
}
 

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 nsdManagementOnboardTest()
    throws NotFoundException, BadFormatException, NetworkServiceIntegrityException,
        CyclicDependenciesException, EntityInUseException, BadRequestException, IOException,
        AlreadyExistingException, PluginException, IncompatibleVNFPackage, VimException,
        InterruptedException, EntityUnreachableException {

  NetworkServiceDescriptor nsd_exp = createNetworkServiceDescriptor();

  when(vnfmManagerEndpointRepository.findAll())
      .thenReturn(
          new ArrayList<VnfmManagerEndpoint>() {
            {
              VnfmManagerEndpoint vnfmManagerEndpoint = new VnfmManagerEndpoint();
              vnfmManagerEndpoint.setEndpoint("test");
              vnfmManagerEndpoint.setType("test");
              vnfmManagerEndpoint.setActive(true);
              vnfmManagerEndpoint.setEnabled(true);
              add(vnfmManagerEndpoint);
            }
          });

  when(nsdRepository.save(nsd_exp)).thenReturn(nsd_exp);
  exception = ExpectedException.none();
  nsdManagement.onboard(nsd_exp, projectId);
  assertEqualsNSD(nsd_exp);
}
 

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包/类
@Test
public void outputIsIdentical() throws IOException, InterruptedException, ExecutionException {
  if (!ToolHelper.artSupported()) {
    return;
  }

  String original = getOriginalDexFile().toString();

  File generated;
  // Collect the generated dex files.
  File[] outputFiles =
      temp.getRoot().listFiles((File file) -> file.getName().endsWith(".dex"));
  if (outputFiles.length == 1) {
    // Just run Art on classes.dex.
    generated = outputFiles[0];
  } else {
    // Run Art on JAR file with multiple dex files.
    generated = temp.getRoot().toPath().resolve(pkg + ".jar").toFile();
    JarBuilder.buildJar(outputFiles, generated);
  }

  ToolHelper.ProcessResult javaResult =
      ToolHelper.runJava(ImmutableList.of(getOriginalJarFile().toString()), mainClass);
  if (javaResult.exitCode != 0) {
    fail("JVM failed for: " + mainClass);
  }

  // TODO(ager): Once we have a bot running using dalvik (version 4.4.4) we should remove
  // this explicit loop to get rid of repeated testing on the buildbots.
  for (DexVm version : artVersions) {
    TestCondition condition = failingRun.get(mainClass);
    if (condition != null && condition.test(tool, compiler, version, mode)) {
      thrown.expect(Throwable.class);
    } else {
      thrown = ExpectedException.none();
    }

    // Check output against Art output on original dex file.
    String output =
        ToolHelper.checkArtOutputIdentical(original, generated.toString(), mainClass, version);

    // Check output against JVM output.
    if (shouldMatchJVMOutput(version)) {
      String javaOutput = javaResult.stdout;
      assertEquals(
          "JVM and Art output differ:\n" + "JVM:\n" + javaOutput + "\nArt:\n" + output,
          output,
          javaOutput);
    }
  }
}
 

import org.junit.rules.ExpectedException; //导入依赖的package包/类
public ExpectedException thrown() {
    return thrown;
}
 

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");
}