} catch (final Exception e) {
            throw new GsaConfigException("Failed to parse XML file.", e);
        }
    }

    @Override
    public void startDocument() throws SAXException {
        tagQueue = new LinkedList<>();
        labelList = new ArrayList<>();
        labelType = null;
    }

    @Override
    public void endDocument() throws SAXException {
        globalParams.clear();

            throws ToolchainManagerException {
        MavenSession s = InternalMavenSession.from(session).getMavenSession();
        return Optional.ofNullable(toolchainManagerPrivate.getToolchainFromBuildContext(type, s))
                .map(this::toToolchain);
    }

    @Override
    public List<Toolchain> getToolchainsForType(Session session, String type) throws ToolchainManagerException {
        try {

        "retry:".encodeUtf8(),
      )

    private val CRLF = "\r\n".encodeUtf8()

    @Throws(IOException::class)
    private fun BufferedSource.readData(data: Buffer) {
      data.writeByte('\n'.code)
      readFully(data, indexOfElement(CRLF))
      select(options) // Skip the newline bytes.
    }

    @Throws(IOException::class)
    private fun BufferedSource.readRetryMs(): Long {

   *     removed
   * @return this {@code CacheBuilder} instance (for chaining)
   * @throws IllegalArgumentException if {@code duration} is negative
   * @throws IllegalStateException if {@link #expireAfterWrite} was already set
   * @throws ArithmeticException for durations greater than +/- approximately 292 years
   * @since 25.0 (but only since 33.3.0 in the Android <a

 * the License.
 */

package com.google.common.eventbus;

import static com.google.common.base.Preconditions.checkNotNull;

import java.lang.reflect.Method;

/**
 * Context for an exception thrown by a subscriber.
 *
 * @since 16.0
 */
@ElementTypesAreNonnullByDefault
public class SubscriberExceptionContext {
  private final EventBus eventBus;
  private final Object event;
  private final Object subscriber;

    private static final TimeZone DEFAULT_SNAPSHOT_TIME_ZONE = TimeZone.getTimeZone("Etc/UTC");

    private String deploymentTimestamp;

    public void transformForResolve(Artifact artifact, RepositoryRequest request) throws ArtifactResolutionException {
        // Only select snapshots that are unresolved (eg 1.0-SNAPSHOT, not 1.0-20050607.123456)
        if (artifact.isSnapshot() && artifact.getBaseVersion().equals(artifact.getVersion())) {

    }

    public ArtifactRepository createDefaultLocalRepository() throws InvalidRepositoryException {
        return createLocalRepository(RepositorySystem.defaultUserLocalRepository);
    }

    public ArtifactRepository createLocalRepository(File localRepository) throws InvalidRepositoryException {
        return createRepository(

/**
 * @author shinsuke
 *
 */
public class FtpClientTest extends PlainTestCase {
    private static final int FTP_PORT = 10021;

    public FtpClient ftpClient;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        StandardCrawlerContainer container = new StandardCrawlerContainer().singleton("mimeTypeHelper", MimeTypeHelperImpl.class)//
                .singleton("ftpClient", FtpClient.class);

        this.pluginArtifact = pluginArtifact;
    }

    public Lifecycle getLifecycleMapping(String lifecycleId) throws IOException, XMLStreamException {
        return getLifecycleMappings().get(lifecycleId);
    }

    public Map<String, Lifecycle> getLifecycleMappings() throws IOException, XMLStreamException {
        if (lifecycleMappings == null) {
            LifecycleConfiguration lifecycleConfiguration;

    @Override
    public int previousIndex() {
      return nextIndex - 1;
    }

    @Override
    public void set(Entry<K, V> e) {
      throw new UnsupportedOperationException();
    }

    @Override
    public void add(Entry<K, V> e) {
      throw new UnsupportedOperationException();
    }

    void setValue(@ParametricNullness V value) {
      checkState(current != null);