import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@Parameters(method = proxyInterfaceDataProvider)
@TestCaseName("should_unwrap_{0}_from_spied_on_instance")
public void should_unwrap_proxy_from_spied_on_instance(String proxyProviderName, boolean proxyTargetClass) throws ClassNotFoundException {
	//given
	final IService rawService = new Service();
	final String serviceName = "service";
	final DoubleDefinition definition = DoubleDefinition.builder()
			.doubleClass(IService.class)
			.name(serviceName)
			.build();
	final TestContextBuilder.TestContext testContext = new TestContextBuilder()
			.withBean(serviceName, createProxyFactoryBean(rawService, proxyTargetClass))
			.withSpy(definition)
			.build();

	//when
	final Object bean = testContext.applicationContext.getBean(serviceName);
	testContext.toSpyReplacingProcessor.postProcessAfterInitialization(bean, serviceName);

	//then
	assertTrue(AopUtils.isAopProxy(bean));
	Mockito.verify(doubleFactory).createSpy(
			argThat(not(isProxy())),
			eq(definition));
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@Parameters(source = BinaryDecimalArgumentProvider.class)
@TestCaseName("hashCode check: [{0}, {1}]")
public void equalDecimalsHaveEqualHashCodes(
		final Decimal<ScaleMetrics> first,
		final Decimal<ScaleMetrics> second) {
	// given
	assertEquals(first, second);

	// when
	final int hashCodeFirst = first.hashCode();
	final int hashCodeSecond = second.hashCode();

	// then
	assertEquals(hashCodeFirst, hashCodeSecond);
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@Parameters(source = BinaryDecimalArgumentProvider.class)
@TestCaseName("toString() check: [{0}, {1}]")
public void equalDecimalsHaveSameStringRepresentation(
		final Decimal<ScaleMetrics> first,
		final Decimal<ScaleMetrics> second) {
	// given
	assertEquals(first, second);

	// when
	final String stringFirst = first.toString();
	final String stringSecond = second.toString();

	// then
	assertEquals(stringFirst, stringSecond);
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@Parameters(method = "getTestCases")
@TestCaseName("'getKeysReadOnly' for implementation type: {1}, {2}")
public void getKeysReadOnly(ConfigSource configSource,
                            Class<? extends ConfigSource> configSourceType,
                            String instanceDescription) {

  Set<String> keys = configSource.getKeys();
  try {
    keys.add("abc");
    fail("Expected exception not thrown: " + UnsupportedOperationException.class);
  }
  catch (UnsupportedOperationException ex) {
    // do nothing
  }
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test(expected = ConfigIOException.class)
@Parameters(method = "failedCallCases")
@TestCaseName("writeConfigWhenOutputStreamThrowsException with : {1}")
public void writeConfigWhenOutputStreamThrowsException(ConfigIO configIO, String description)
    throws Exception {

  Config config = ConfigFactory.newMutableConfig()
      .setString("test.key", "test value")
      .get();
  OutputStream outputStream = spy(new ByteArrayOutputStream());
  doThrow(new RuntimeException("Test Exception")).when(outputStream).write(anyInt());
  doThrow(new RuntimeException("Test Exception")).when(outputStream).write(any(byte[].class));
  doThrow(new RuntimeException("Test Exception")).when(outputStream).write(any(byte[].class), anyInt(), anyInt());

  configIO.writeConfig(config, outputStream);
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@Parameters(method = "expectedCases")
@TestCaseName("writeConfigExpected with {2}")
public void writeConfigExpected(ConfigIO configIO, String fixturePath, String description)
    throws Exception {

  ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
  Config config = ConfigFixture.getConfigFixture();

  configIO.writeConfig(config, outputStream);

  String actual = new String(outputStream.toByteArray()).trim().replaceAll("\n", "").replaceAll("\r", "");
  InputStream inputStream = getClass().getResourceAsStream(fixturePath);
  String expected = readAll(inputStream).trim().replaceAll("\n", "").replaceAll("\r", "");
  inputStream.close();
  assertThat(actual).isEqualTo(expected);
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@Parameters(method = "expectedCases")
@TestCaseName("readConfigExpected with {2}")
public void readConfigExpected(ConfigIO configIO, String fixturePath, String description)
    throws Exception {

  InputStream inputStream = getClass().getResourceAsStream(fixturePath);
  Config actual = configIO.readConfig(inputStream);
  inputStream.close();
  Config expected = ConfigFixture.getConfigFixture();

  assertThat(actual.getKeys()).hasSize(expected.getKeys().size());
  assertThat(actual.getKeys()).containsAll(expected.getKeys());
  for (String key : expected.getKeys()) {
    assertThat(actual.getString(key)).isEqualTo(expected.getString(key));
  }
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@TestCaseName("{method}: input \"{0}\" splits to {1}")
@Parameters
public void splitOnSpace(String input, String[] expected) {
    String[] result = StringUtil.splitOnSpaceWithEscape(input);
    assertEquals(expected.length, result.length);
    for (int j = 0; j < expected.length; j++) {
        assertEquals(expected[j],result[j]);
    }
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@TestCaseName("{method}: max({0},{1}) = {2}, {0} >= {1} ? {3}")
@Parameters
public void versionChecks(String versionA, String versionB, String largerVersion, boolean isGreaterOrEquals) {
    assertEquals(largerVersion, StringUtil.extractLargerVersion(versionA,versionB));
    assertEquals(isGreaterOrEquals, StringUtil.greaterOrEqualsVersion(versionA,versionB));
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@TestCaseName("{method}:{0}")
@Parameters(method = "featureDescription_multipleTextsInBlock," +
		             "featureDescription_singleTextInBlock," +
		             "featureDescription_whereBlockIgnoring," +
		             "featureDescription_noBlocks" )
public void buildFeatureDescription(String testDescription, FeatureInfo featureInfo, String expectedResult) {
	String actualDescription = NodeInfoUtils.buildFeatureDescription(featureInfo);

	assertThat(testDescription, actualDescription, equalTo(expectedResult));
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@TestCaseName("{method}(inherited={1})")
@Parameters(method = "parametersForFixtureDescription")
public void getFixtureDisplayName(MethodInfo methodInfo, boolean inherited, String expectedDisplayName) {
	String actualName = NodeInfoUtils.getFixtureDisplayName(methodInfo, inherited);

	assertThat(actualName, equalTo(expectedDisplayName));
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@Parameters(method = "parameters")
@TestCaseName("{method}[{index}] - {0}")
public void annotationDiffer(String testName, AnnotationInfo previous, AnnotationInfo next, List<Diff> expected) throws Exception {
    AnnotationDiffer differ = AnnotationDiffer.annotationDiffer(previous, next);
    Collection<Diff> actual = differ.diff();
    assertThat(actual, equalTo(expected));
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@Parameters(method = "classStructure")
@TestCaseName("{method}[{index}] - {0}")
public void classesDifferInStructure(String testName, ClassInfo previous, ClassInfo next, Collection<Diff> expected) {
    ClassDiffer differ = classDiffer(previous, next);
    Collection<Diff> actual = differ.diff();
    assertThat(actual, hasSize(greaterThan(0)));
    assertThat(actual, equalTo(expected));
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@Parameters(method = "parameters")
@TestCaseName("{method}[{index}] - {0}")
public void methodsDiffer(String testName, MethodInfo previous, MethodInfo next, Collection<Diff> expected) {
    MethodDiffer differ = methodDiffer(previous, next);
    Collection<Diff> actual = differ.diff();
    assertThat(actual, hasSize(greaterThan(0)));
    assertThat(actual, equalTo(expected));
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@Parameters(method = "parameters")
@TestCaseName("{method}[{index}] - {0}")
public void fieldsDiffer(String testName, FieldInfo previous, FieldInfo next, Collection<Diff> expected) {
    FieldDiffer differ = fieldDiffer(previous, next);
    Collection<Diff> actual = differ.diff();
    assertThat(actual, hasSize(greaterThan(0)));
    assertThat(actual, equalTo(expected));
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
@Test
@Parameters(method = "parameters")
@TestCaseName("{constructor}[{index}] - {0}")
public void constructorsDiffer(String testName, ConstructorInfo previous, ConstructorInfo next, Collection<Diff> expected) {
    ConstructorDiffer differ = constructorDiffer(previous, next);
    Collection<Diff> actual = differ.diff();
    assertThat(actual, hasSize(greaterThan(0)));
    assertThat(actual, equalTo(expected));
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
/**
 * Checks that natural ordering given on {@link Decimal} implementations is
 * consistent with <code>equals<code>.
 * 
 * Note: (x.compareTo(y)==0) == (x.equals(y) is not strictly required by the contract, but {@link Decimal} implementations fulfill it
 * 
 * @param first the first argument of the comparison
 * @param second the second argument of the comparison
 */
@Test
@Parameters(source = BinaryDecimalArgumentProvider.class)
@TestCaseName("{0}.compareTo({1}) == 0]")
public void compareToIsConsistentWithEquals(
		final Decimal<ScaleMetrics> first,
		final Decimal<ScaleMetrics> second) {
	// given
	assertEquals(first, second);

	// then
	assertTrue(first.compareTo(second) == 0);
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
/**
 * Checks the reflexivity requirement of {@link Object#equals(Object)} in
 * case of different {@link Decimal} implementations.
 * 
 * @param first the first argument of the equality comparison with itself
 */
@Test
@Parameters(source = UnaryDecimalArgumentProvider.class)
@TestCaseName("reflexivity check: {0}")
public void equalsIsReflexive(final Decimal<ScaleMetrics> first) {
	assertEquals(first, first);
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
/**
 * Checks the symmetry requirement of {@link Object#equals(Object)} in case
 * of different {@link Decimal} implementations.
 * 
 * @param first the first argument of the equality comparison
 * @param second the second argument of the equality comparison
 */
@Test
@Parameters(source = BinaryDecimalArgumentProvider.class)
@TestCaseName("symmetry check: [{0}, {1}]")
public void equalsIsSymmetric(final Decimal<ScaleMetrics> first,
		final Decimal<ScaleMetrics> second) {
	// given
	assertEquals(first, second);

	// then
	assertEquals(second, first);
}
 

import junitparams.naming.TestCaseName; //导入依赖的package包/类
/**
 * Checks the transitivity requirement of {@link Object#equals(Object)} in
 * case of different {@link Decimal} implementations.
 * 
 * @param first the first argument of the equality comparison
 * @param second the second argument of the equality comparison
 * @param third the third argument of the equality comparison
 */
@Test
@Parameters(source = TernaryDecimalArgumentProvider.class)
@TestCaseName("transitivity check: [{0}, {1}, {2}]")
public void equalsIsTransitive(final Decimal<ScaleMetrics> first,
		final Decimal<ScaleMetrics> second,
		final Decimal<ScaleMetrics> third) {
	// given
	assertEquals(first, second);
	assertEquals(second, third);

	// then
	assertEquals(first, third);
}