public void run() throws Exception {
    File file = new File("README.md");

    Request request = new Request.Builder()
        .url("https://api.github.com/markdown/raw")
        .post(RequestBody.create(file, MEDIA_TYPE_MARKDOWN))
        .build();

    try (Response response = client.newCall(request).execute()) {

        }
        checkArgument(
            fromParameterizedType.getRawType().equals(toParameterizedType.getRawType()),
            "Inconsistent raw type: %s vs. %s",
            fromParameterizedType,
            to);
        Type[] fromArgs = fromParameterizedType.getActualTypeArguments();
        Type[] toArgs = toParameterizedType.getActualTypeArguments();

  private Cache<String, Boolean> mock;

  @SuppressWarnings({"unchecked", "DoNotMock"}) // mock
  @Override
  public void setUp() throws Exception {
    super.setUp();
    /*
     * Class parameters must be raw, so we can't create a proxy with generic
     * type arguments. The created proxy only records calls and returns null, so
     * the type is irrelevant at runtime.
     */
    mock = mock(Cache.class);
    forward =

   * suitable for testing that map entries cannot be modified via a nefarious implementation of
   * equals. This is used for testing unmodifiable collections of map entries; for example, it
   * should not be possible to access the raw (modifiable) map entry via a nefarious equals method.
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      Entry<K, V> nefariousMapEntry(K key, V value) {
    return new Entry<K, V>() {

          if (x * i == n) return factor(x) + " × " + i;
        }
        return Integer.toString(n);
      }
    };

    Request request = new Request.Builder()
        .url("https://api.github.com/markdown/raw")
        .post(requestBody)
        .build();

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

public class EnumsBenchmark {

  @Param({"Small", "Medium", "Large"})
  String enumSize;

  @Param({"0.2", "0.8"})
  float hitRate;

  // We could avoid the raw type here by initializing this with a ternary (? SmallEnum.class : ...).
  // However, we end up needing a raw type in getIfPresent, as discussed there.
  @SuppressWarnings("rawtypes")
  private Class<? extends Enum> enumType;

  private String[] sampleData;

public class EnumsBenchmark {

  @Param({"Small", "Medium", "Large"})
  String enumSize;

  @Param({"0.2", "0.8"})
  float hitRate;

  // We could avoid the raw type here by initializing this with a ternary (? SmallEnum.class : ...).
  // However, we end up needing a raw type in getIfPresent, as discussed there.
  @SuppressWarnings("rawtypes")
  private Class<? extends Enum> enumType;

  private String[] sampleData;

            }
        }
        cookey( kn, KnL );
    }

    private void cookey( int[] raw, int KnL[] )     {
        int raw0, raw1;
        int rawi, KnLi;
        int i;

        for ( i = 0, rawi = 0, KnLi = 0; i < 16; ++i )   {
            raw0 = raw[rawi++];
            raw1 = raw[rawi++];
            KnL[KnLi]  = (raw0 & 0x00fc0000) <<   6;
            KnL[KnLi] |= (raw0 & 0x00000fc0) <<  10;

    }

    static Model transform(Model model, MavenProject project) {
        String packaging = model.getPackaging();
        if (POM_PACKAGING.equals(packaging)) {
            // raw to consumer transform
            model = model.withRoot(false).withModules(null);
            if (model.getParent() != null) {
                model = model.withParent(model.getParent().withRelativePath(null));
            }

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.Text;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Converts raw javadoc comments into docbook.
 */
public class JavadocConverter {
    private static final Pattern HEADER_PATTERN = Pattern.compile("h(\\d)", Pattern.CASE_INSENSITIVE);