import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class XslTransformer {
    public static void main(String[] args) throws TransformerException, IOException {
        if (args.length < 3 || args.length > 4) {
            throw new IllegalArgumentException("USAGE: <style-sheet> <source-file> <dest-file> [dest-dir]");
        }
        File stylesheet = new File(args[0]);

    for (int i = 0; i < reps; ++i) {
      if (javaImpl.compare(ba1, ba2) != 0) {
        throw new Error(); // deoptimization
      }
    }
  }

  @Benchmark
  void longEqualUnsafe(int reps) {
    for (int i = 0; i < reps; ++i) {
      if (unsafeImpl.compare(ba1, ba2) != 0) {
        throw new Error(); // deoptimization
      }
    }
  }

  @Benchmark
  void diffLastJava(int reps) {

@GwtCompatible
public enum MapFeature implements Feature<Map> {
  /**
   * The map does not throw {@code NullPointerException} on calls such as {@code containsKey(null)},
   * {@code get(null)}, {@code keySet().contains(null)} or {@code remove(null)}.
   */
  ALLOWS_NULL_KEY_QUERIES,
  ALLOWS_NULL_KEYS(ALLOWS_NULL_KEY_QUERIES),
  /**
   * The map does not throw {@code NullPointerException} on calls such as {@code

      // nowrap (omits zlib header):
      true,
    )

  private val inflaterSource = InflaterSource(deflatedBytes, inflater)

  /** Inflates [buffer] in place as described in RFC 7692 section 7.2.2. */
  @Throws(IOException::class)
  fun inflate(buffer: Buffer) {
    require(deflatedBytes.size == 0L)

    if (noContextTakeover) {
      inflater.reset()
    }

    deflatedBytes.writeAll(buffer)

     * @param pomFile the pom file, cannot be null
     * @param context the context, cannot be null
     * @param  model the model to transform
     * @throws TransformerException if the transformation fails
     */
    void transform(Path pomFile, TransformerContext context, Model model) throws TransformerException;

    if (key == null) {
      throw new NullPointerException("null key in entry: null=" + value);
    } else if (value == null) {
      throw new NullPointerException("null value in entry: " + key + "=null");
    }
  }

  @CanIgnoreReturnValue
  static int checkNonnegative(int value, String name) {
    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);

       *
       * A note on exception types:
       *
       * Android API level 10 throws ExceptionInInitializerError the first time and
       * ClassNotFoundException thereafter.
       *
       * Android API level 26 and JVM8 both let our Error propagate directly the first time and
       * throw NoClassDefFoundError thereafter. This is the proper behavior according to the spec.

        }
    }

    public DefaultEncryptInvoker(ProtoLookup protoLookup) {
        super(protoLookup);
    }

    @Override
    protected int execute(LocalContext context) throws Exception {
        return doExecute(context);
    }

    @Override
    protected LocalContext createContext(EncryptInvokerRequest invokerRequest) {
        return new LocalContext(this, invokerRequest);
    }

class QueueDispatcher : Dispatcher() {
  internal val delegate = QueueDispatcher()

  @Throws(InterruptedException::class)
  override fun dispatch(request: RecordedRequest): MockResponse {
    throw UnsupportedOperationException("unexpected call")
  }

  override fun peek(): MockResponse {
    throw UnsupportedOperationException("unexpected call")
  }

  fun enqueueResponse(response: MockResponse) {

 */
@GwtCompatible
public class CacheBuilderGwtTest extends TestCase {

  private FakeTicker fakeTicker;

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    fakeTicker = new FakeTicker();
  }

  public void testLoader() throws ExecutionException {

    final Cache<Integer, Integer> cache = CacheBuilder.newBuilder().build();

    Callable<Integer> loader =