}
	for i, want := range files {
		got := r.File[i]
		if got.Name != want.name {
			t.Errorf("got Name %s; want %s", got.Name, want.name)
		}
		if got.Method != want.method {
			t.Errorf("%s: got Method %#x; want %#x", want.name, got.Method, want.method)
		}
		if got.Flags != want.flags {
			t.Errorf("%s: got Flags %#x; want %#x", want.name, got.Flags, want.flags)
		}
		if got.CRC32 != want.crc32 {

class FreshValueGenerator {

  private static final ImmutableMap<Class<?>, Method> GENERATORS;

  static {
    ImmutableMap.Builder<Class<?>, Method> builder = ImmutableMap.builder();
    for (Method method : FreshValueGenerator.class.getDeclaredMethods()) {
      if (method.isAnnotationPresent(Generates.class)) {
        builder.put(method.getReturnType(), method);
      }
    }
    GENERATORS = builder.buildOrThrow();
  }

    /**
     * {@return all enabled sources that provide files in the given language for the given scope}.
     * If the given scope is {@code null}, then this method returns the enabled sources for all scopes.
     * If the given language is {@code null}, then this method returns the enabled sources for all languages.
     * An arbitrary number of source roots may exist for the same scope and language.

    // -----------/
    // - Methods -/
    // -----------/

    /**
     * Method setFileComment.
     *
     * @param fileComment a fileComment object.
     */
    public void setFileComment(String fileComment) {
        this.fileComment = fileComment;
    } // -- void setFileComment( String )

    /**
     * Method write.
     *
     * @param writer a writer object.

                }
            """
        ) {
            assertHasErrors(
                "Method com.example.Source.foo(): From non-null returning to null returning breaking change.",
                "Method com.example.Source.getSomeVal(): From non-null returning to null returning breaking change.",
                "Method com.example.Source.getSomeVar(): From non-null returning to null returning breaking change."
            )

    return emptySet();
  }

  protected Collection<Method> suppressForHashSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForLinkedHashSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForEnumSet() {
    return emptySet();
  }

  protected Collection<Method> suppressForSynchronizedNavigableSet() {

    }
  }

  /**
   * Inserts the specified element into this priority queue. As the queue is unbounded this method
   * will never block.
   *
   * @param e the element to add
   * @param timeout This parameter is ignored as the method never blocks
   * @param unit This parameter is ignored as the method never blocks
   * @return {@code true}

  }

  return RequestLine(
    method = parts[0],
    target = parts[1],
    version = parts[2],
  )
}

internal class RequestLine(
  val method: String,
  val target: String,
  val version: String,
) {
  override fun toString() = "$method $target $version"
}

internal val DEFAULT_REQUEST_LINE_HTTP_1 =
  RequestLine(
    method = "GET",
    target = "/",
    version = "HTTP/1.1",

  protected AbstractExecutionThreadService() {}

  /**
   * Start the service. This method is invoked on the execution thread.
   *
   * <p>By default this method does nothing.
   */
  protected void startUp() throws Exception {}

  /**
   * Run the service. This method is invoked on the execution thread. Implementations must respond

        method = Hoge.class.getMethod("list");
        assertThat(GenericsUtil.getActualClass(method.getGenericReturnType(), map), is(sameClass(List.class)));

        method = Hoge.class.getMethod("set");
        assertThat(GenericsUtil.getActualClass(method.getGenericReturnType(), map), is(sameClass(Set.class)));

        method = Hoge.class.getMethod("map");