* @author Chris Povirk
 */
@NullUnmarked
final class InterruptionUtil {
  private static final Logger logger = Logger.getLogger(InterruptionUtil.class.getName());

  /** Runnable which will interrupt the target thread repeatedly when run. */
  private static final class Interruptenator implements Runnable {
    private final long everyMillis;
    private final Thread interruptee;
    private volatile boolean shouldStop = false;

import java.io.*;
import java.nio.channels.*;
import java.util.Properties;

public class MavenWrapperDownloader {

    private static final String WRAPPER_VERSION = "0.5.6";
    /**
     * Default URL to download the maven-wrapper.jar from, if no 'downloadUrl' is provided.
     */
    private static final String DEFAULT_DOWNLOAD_URL = "https://repo.maven.apache.org/maven2/io/takari/maven-wrapper/"

     */
    public Deferred<T>.Promise execute(final Client client) {
        final String error = getValidationError();
        if (!Strings.isNullOrEmpty(error)) {
            throw new IllegalArgumentException(error);
        }

        final Deferred<T> deferred = new Deferred<>();
        try {
            processRequest(client, deferred);
        } catch (final Exception e) {
            throw new SuggesterException(e);

public class ScriptExecutor extends JobExecutor {

    /**
     * Constructor.
     */
    public ScriptExecutor() {
        super();
    }

    @Override
    public Object execute(final String scriptType, final String script) {
        final Map<String, Object> params = new HashMap<>();
        params.put("executor", this);

        return ComponentUtil.getScriptEngineFactory().getScriptEngine(scriptType).evaluate(script, params);
    }

import java.util.List;

/**
 * GWT emulated version of {@link SingletonImmutableList}.
 *
 * @author Hayward Chan
 */
final class SingletonImmutableList<E> extends ForwardingImmutableList<E> {
  private final transient List<E> delegate;
  private final E element;

  SingletonImmutableList(E element) {
    this.delegate = singletonList(checkNotNull(element));
    this.element = element;
  }

    public static final WithPublicConstructorAndConstant INSTANCE =
        new WithPublicConstructorAndConstant();

    public WithPublicConstructorAndConstant() {}
  }

  private static class WithPublicConstants {
    @Keep public static final WithPublicConstants FIRST = new WithPublicConstants();

    // To test that we pick the first constant alphabetically

   *       key1=[A, B]&key2=C}.
   * </ul>
   *
   * @since 2.0
   */
  public static final class MapJoiner {
    private final Joiner joiner;
    private final String keyValueSeparator;

    private MapJoiner(Joiner joiner, String keyValueSeparator) {
      this.joiner = joiner; // only "this" is ever passed, so don't checkNotNull

@NullUnmarked
public class BaseEncodingBenchmark {
  private static final int INPUTS_COUNT = 0x1000;
  private static final int INPUTS_MASK = 0xFFF;

  enum EncodingOption {
    BASE64(BaseEncoding.base64()),
    BASE64_URL(BaseEncoding.base64Url()),
    BASE32(BaseEncoding.base32()),
    BASE32_HEX(BaseEncoding.base32Hex()),
    BASE16(BaseEncoding.base16());

    final BaseEncoding encoding;

    EncodingOption(BaseEncoding encoding) {

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.allocationSize = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

     * Constructs a new RequestHeader with the specified name and value.
     *
     * @param name  the name of the request header
     * @param value the value of the request header
     */
    public RequestHeader(final String name, final String value) {
        this.name = name;
        this.value = value;
    }

    /**
     * Returns the name of the request header.
     * @return The name of the request header.
     */