import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
/**
 * Thread safe utility method to parse a FDate with {@link #userDateFormats} first, then
 * {@link #DEFAULT_DATE_FORMATS}.
 * <p>
 * Returns <code>null</code> if dateAsString parameter is <code>null</code>.
 *
 * @param dateAsString
 *            the string to parse as a FDate with {@link #userDateFormats}
 * @return the corresponding FDate, null if dateAsString parameter is null.
 * @throws AssertionError
 *             if the string can't be parsed as a FDate
 */
@VisibleForTesting
FDate parse(final String dateAsString) {
    if (dateAsString == null) {
        return null;
    }
    // parse with date format specified by user if any, otherwise use default formats
    // no synchronization needed as userCustomDateFormat is thread local
    FDate date = parseFDateWith(dateAsString, userDateFormats.get());
    if (date != null) {
        return date;
    }
    // no matching user date format, let's try default format
    date = parseFDateWithDefaultDateFormats(dateAsString);
    if (date != null) {
        return date;
    }
    // no matching date format, throw an error
    throw new AssertionError("Failed to parse " + dateAsString + " with any of these date formats: "
            + info.representation().toStringOf(dateFormatsInOrderOfUsage()));
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
protected GetAliasesResponse doParse(BytesReference bytesReference) {
    try (XContentParser parser = XContentHelper.createParser(bytesReference)) {
        ListMultimap<String, AliasMetaData> metaDatas = ArrayListMultimap.create();

        XContentParser.Token token;
        String currentFieldName = null;
        while ((token = parser.nextToken()) != END_OBJECT) {
            if (token == XContentParser.Token.FIELD_NAME) {
                currentFieldName = parser.currentName();
            } else if (token == START_OBJECT) {
                if (currentFieldName != null) { // we are at an index metadata start
                    List<AliasMetaData> aliasMetaDatas = parseAliases(parser);
                    metaDatas.putAll(currentFieldName, aliasMetaDatas);
                }
            }
        }
        Map<String, List<AliasMetaData>> map = Multimaps.asMap(metaDatas);
        aliases = ImmutableOpenMap.<String, List<AliasMetaData>>builder().putAll(map).build();
        return this;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
protected static List<AliasMetaData> parseAliases(XContentParser parser) {
    assert parser.currentToken() == START_OBJECT;
    try {
        List<AliasMetaData> result = new ArrayList<>();
        XContentParser.Token token;
        String currentFieldName = null;
        while ((token = parser.nextToken()) != END_OBJECT) {
            if (token == XContentParser.Token.FIELD_NAME) {
                currentFieldName = parser.currentName();
            } else if (token == START_OBJECT) {
                if ("aliases".equals(currentFieldName)) {
                    while (parser.nextToken() != XContentParser.Token.END_OBJECT) {
                        AliasMetaData metaData = parseAlias(parser);
                        result.add(metaData);
                    }
                }
            }
        }
        return result;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
public BinaryDiffResult diff(Path actual, byte[] expected) throws IOException {
  InputStream expectedStream = new ByteArrayInputStream(expected);
  InputStream actualStream = null;
  boolean threw = true;
  try {
    actualStream = Files.newInputStream(actual);
    BinaryDiffResult result = diff(actualStream, expectedStream);
    threw = false;
    return result;
  } finally {
    try {
      if (actualStream != null) actualStream.close();
    } catch (IOException e) {
      // Only rethrow if it doesn't shadow an exception thrown from the inner try block
      if (!threw) throw e;
    }
  }
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
void customize(Undertow.Builder builder) {
  builder
      .setServerOption(UndertowOptions.ENABLE_HTTP2, true)
      .setServerOption(UndertowOptions.HTTP2_SETTINGS_ENABLE_PUSH, true)
      .addHttpListener(httpPort, "0.0.0.0");
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
/**
 * Create a PushBuilder for the given request an perform a push.
 *
 * @param request the request from which to get the PushBuilder
 */
@VisibleForTesting
void jettyServerPush(ServletRequest request) {
  org.eclipse.jetty.server.PushBuilder jettyPushBuilder = Request
      .getBaseRequest(request)
      .getPushBuilder();
  jettyPushBuilder
      .path("/push-greeting?name=push")
      .push();
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
protected HTTPArtifactBinding createDefaultArtifactBinding(ServiceProviderBuilder builder) {
    HttpClientParams params = new HttpClientParams();
    params.setIntParameter(HttpConnectionParams.CONNECTION_TIMEOUT, 60000);
    HttpClient httpClient = new HttpClient(params, new MultiThreadedHttpConnectionManager());
    ArtifactResolutionProfileImpl artifactResolutionProfile = new ArtifactResolutionProfileImpl(httpClient);
    builder.setSharedObject(ArtifactResolutionProfile.class, artifactResolutionProfile);
    HTTPSOAP11Binding soapBinding = new HTTPSOAP11Binding(parserPool);
    artifactResolutionProfile.setProcessor(new SAMLProcessorImpl(soapBinding));
    return new HTTPArtifactBinding(parserPool, getVelocityEngine(), artifactResolutionProfile);
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@Override
@VisibleForTesting
public Comparator<?> getComparator() {
    if (comparisonStrategy instanceof ComparatorBasedComparisonStrategy) {
        return ((ComparatorBasedComparisonStrategy) comparisonStrategy).getComparator();
    }
    return null;
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
protected static AliasMetaData parseAlias(XContentParser parser) {
    assert parser.currentToken() == FIELD_NAME : "expected a FIELD_NAME token but was " + parser.currentToken();
    try {
        return AliasMetaData.Builder.fromXContent(parser);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
protected BulkResponse doParse(BytesReference bytesReference) {
    try (XContentParser parser = XContentHelper.createParser(bytesReference)) {
        List<BulkItem> items = new ArrayList<>();

        this.items = items;
        XContentParser.Token token;
        String currentFieldName = null;
        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
            if (token == XContentParser.Token.FIELD_NAME) {
                currentFieldName = parser.currentName();
            } else if (token.isValue()) {
                if ("took".equals(currentFieldName)) {
                    took = parser.longValue();
                } else if ("errors".equals(currentFieldName)) {
                    errors = parser.booleanValue();
                }
            } else if (token == XContentParser.Token.START_ARRAY) {
                parser.nextToken();
                if ("items".equals(currentFieldName)) {
                    while (parser.currentToken() != XContentParser.Token.END_ARRAY) {
                        BulkItem bulkItem = new BulkItem().parse(parser);
                        items.add(bulkItem);
                    }
                }
            }
        }
        return this;
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
ShouldBeEqual(Object actual, Object expected, ComparisonStrategy comparisonStrategy, Representation representation) {
  this.actual = actual;
  this.expected = expected;
  this.comparisonStrategy = comparisonStrategy;
  this.representation = representation;
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
/**
 * Thread safe utility method to parse a Date with {@link #userDateFormats} first, then {@link #DEFAULT_DATE_FORMATS}.
 * <p>
 * Returns <code>null</code> if dateAsString parameter is <code>null</code>.
 *
 * @param dateAsString the string to parse as a Date with {@link #userDateFormats}
 * @return the corresponding Date, null if dateAsString parameter is null.
 * @throws AssertionError if the string can't be parsed as a Date
 */
@VisibleForTesting
Date parse(String dateAsString) {
  if (dateAsString == null) return null;
  // parse with date format specified by user if any, otherwise use default formats
  // no synchronization needed as userCustomDateFormat is thread local
  Date date = parseDateWith(dateAsString, userDateFormats.get());
  if (date != null) return date;
  // no matching user date format, let's try default format
  date = parseDateWithDefaultDateFormats(dateAsString);
  if (date != null) return date;
  // no matching date format, throw an error
  throw new AssertionError(String.format("Failed to parse %s with any of these date formats:%n   %s", dateAsString,
                                         info.representation().toStringOf(dateFormatsInOrderOfUsage())));
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
public Comparator<?> getComparator() {
  if (comparisonStrategy instanceof ComparatorBasedComparisonStrategy) {
    return ((ComparatorBasedComparisonStrategy) comparisonStrategy).getComparator();
  }
  return null;
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
public void assertContains(AssertionInfo info, Failures failures, Object actual, Object values) {
  if (commonChecks(info, actual, values)) return;
  Set<Object> notFound = new LinkedHashSet<>();
  int valueCount = sizeOf(values);
  for (int i = 0; i < valueCount; i++) {
    Object value = Array.get(values, i);
    if (!arrayContains(actual, value)) notFound.add(value);
  }
  if (!notFound.isEmpty())
    throw failures.failure(info, shouldContain(actual, values, notFound, comparisonStrategy));
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void class_soft_assertions_should_report_errors_on_final_methods() {
  // GIVEN
  Class<AnnotatedClass> actual = AnnotatedClass.class;
  // WHEN
  softly.assertThat(actual)
        .hasAnnotations(MyAnnotation.class, AnotherAnnotation.class)
        .hasAnnotations(SafeVarargs.class, VisibleForTesting.class);
  // THEN
  List<Throwable> errorsCollected = softly.errorsCollected();
  assertThat(errorsCollected).hasSize(1);
  assertThat(errorsCollected.get(0)).hasMessageContaining("SafeVarargs")
                                    .hasMessageContaining("VisibleForTesting");
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void class_soft_assertions_should_report_errors_on_final_methods() {
  // GIVEN
  Class<AnnotatedClass> actual = AnnotatedClass.class;
  // WHEN
  softly.then(actual)
        .hasAnnotations(MyAnnotation.class, AnotherAnnotation.class)
        .hasAnnotations(SafeVarargs.class, VisibleForTesting.class);
  // THEN
  List<Throwable> errorsCollected = softly.errorsCollected();
  assertThat(errorsCollected).hasSize(1);
  assertThat(errorsCollected.get(0)).hasMessageContaining("SafeVarargs")
                                    .hasMessageContaining("VisibleForTesting");
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Parameters
public static Object[][] provideAssumptionsRunners() {
  return new AssumptionRunner[][] {
      run(AnnotatedClass.class,
          value -> assumeThat(value).hasAnnotations(MyAnnotation.class, AnotherAnnotation.class),
          value -> assumeThat(value).hasAnnotations(SafeVarargs.class, VisibleForTesting.class))
  };
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
/**
 * Configure the http2 server.
 *
 * @param server the server
 * @return the server
 */
@VisibleForTesting
Server configureServerForHttp2(Server server) {
  // HTTP Configuration
  HttpConfiguration http11Config = new HttpConfiguration();
  http11Config.setSecureScheme("https");
  http11Config.setSecurePort(httpsPort);

  // SSL Context Factory for HTTPS and HTTP/2
  SslContextFactory sslContextFactory = new SslContextFactory();
  sslContextFactory.setKeyStoreResource(newClassPathResource("sample.jks"));
  sslContextFactory.setKeyStorePassword("secret");
  sslContextFactory.setKeyManagerPassword("secret");
  sslContextFactory.setCipherComparator(HTTP2Cipher.COMPARATOR);
  sslContextFactory.setUseCipherSuitesOrder(true);

  // HTTPS Configuration
  HttpConfiguration httpsConfig = new HttpConfiguration(http11Config);
  httpsConfig.addCustomizer(new SecureRequestCustomizer());

  // HTTP/2 Connection Factory
  HTTP2ServerConnectionFactory h2 = new HTTP2ServerConnectionFactory(httpsConfig);

  NegotiatingServerConnectionFactory.checkProtocolNegotiationAvailable();
  ALPNServerConnectionFactory alpnServerConnectionFactory = new ALPNServerConnectionFactory();
  alpnServerConnectionFactory.setDefaultProtocol("h2");
  alpnServerConnectionFactory.getALPNProcessor();

  // SSL Connection Factory
  SslConnectionFactory sslConnectionFactory =
      new SslConnectionFactory(sslContextFactory,
          alpnServerConnectionFactory.getProtocol());

  // HTTP/2 Connector
  ServerConnector http2Connector =
      new ServerConnector(server, sslConnectionFactory, alpnServerConnectionFactory, h2,
          new HttpConnectionFactory(httpsConfig));
  http2Connector.setPort(httpPort);
  server.addConnector(http2Connector);

  return server;
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
protected static void setPropertyKeysPickup(PropertyKeysPickup propertyKeysPickup) {
    PropertiesToJsonParser.propertyKeysPickup = propertyKeysPickup;
}
 

import org.assertj.core.util.VisibleForTesting; //导入依赖的package包/类
@VisibleForTesting
protected SAMLContextProvider createDefaultSamlContextProvider() {
    return new SAMLContextProviderImpl();
}