@GwtCompatible(emulated = true)
@SuppressWarnings("serial") // uses writeReplace, not default serialization
@ElementTypesAreNonnullByDefault
class RegularImmutableAsList<E> extends ImmutableAsList<E> {
  private final ImmutableCollection<E> delegate;
  private final ImmutableList<? extends E> delegateList;

  RegularImmutableAsList(ImmutableCollection<E> delegate, ImmutableList<? extends E> delegateList) {
    this.delegate = delegate;

 */
@CacheableTask
public abstract class ExtractGradleApiInfoTask extends DefaultTask {

    private static final String GRADLE_API_INFO_JAR = "gradle-runtime-api-info";
    private static final String UPGRADED_PROPERTIES_FILE = "upgraded-properties.json";

    public ExtractGradleApiInfoTask() {
        getGradleApiInfoJarPrefix().convention(GRADLE_API_INFO_JAR);
    }

    public abstract void overriddenAndAnnotatedInSubclass(Object o);
  }

  static class SubClass extends SuperClass {
    final List<Object> overriddenInSubclassNowhereAnnotatedEvents = Lists.newArrayList();
    final List<Object> overriddenAndAnnotatedInSubclassEvents = Lists.newArrayList();

    @Override
    public void overriddenInSubclassNowhereAnnotated(Object o) {

 *
 * @author Nishant Thakkar
 */
public class FuturesTransformTest extends AbstractChainedListenableFutureTest<String> {
  private static final String RESULT_DATA = "SUCCESS";
  private static final UndeclaredThrowableException WRAPPED_EXCEPTION =
      new UndeclaredThrowableException(EXCEPTION);

  @Override

 * @param <N> Node parameter type
 * @since 20.0
 */
@Beta
@ElementTypesAreNonnullByDefault
public abstract class AbstractGraph<N> extends AbstractBaseGraph<N> implements Graph<N> {

  @Override
  public final boolean equals(@CheckForNull Object obj) {
    if (obj == this) {
      return true;
    }
    if (!(obj instanceof Graph)) {
      return false;
    }
    Graph<?> other = (Graph<?>) obj;

    public void testFileToFile() throws Exception {
        final byte[] bytes = readBytes(inputFile);
        assertThat(bytes, is("あいうえお".getBytes("UTF-8")));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testReadUTF8() throws Exception {
        assertThat(FileUtil.readUTF8(getPath("hoge_utf8.txt")), is("あ"));
    }

    private String getPath(final String fileName) {

        assertEquals("file", URLUtil.toCanonicalProtocol("file"));
    }

    /**
     * @throws Exception
     */
    public void testToFile() throws Exception {
        final File file = new File("Program Files/hoge.txt");
        final URL url = file.toURI().toURL();
        assertEquals(file.getAbsoluteFile(), URLUtil.toFile(url));
        assertEquals(file.getAbsoluteFile(), URLUtil.toFile(new URL("file:Program%20Files/hoge.txt")));

 */
@Deprecated(since = "4.0.0")
class DefaultModelBuildingEvent implements ModelBuildingEvent {

    private Model model;

    private final ModelBuildingRequest request;

    private final ModelProblemCollector problems;

    DefaultModelBuildingEvent(Model model, ModelBuildingRequest request, ModelProblemCollector problems) {
        this.model = model;
        this.request = request;

import gradlebuild.docs.dsl.docbook.model.ClassDoc;
import gradlebuild.docs.dsl.source.model.ClassMetaData;

import java.util.List;

public class ClassDocSuperTypeBuilder {
    private final DslDocModel model;
    private final GenerationListener listener;

    public ClassDocSuperTypeBuilder(DslDocModel model, GenerationListener listener) {
        this.model = model;
        this.listener = listener;
    }

    /**

import java.io.Reader;

/**
 * A char source for testing that has configurable options.
 *
 * @author Colin Decker
 */
public class TestCharSource extends CharSource implements TestStreamSupplier {

  private final TestByteSource byteSource;

  public TestCharSource(String content, TestOption... options) {
    this.byteSource = new TestByteSource(content.getBytes(UTF_8), options);
  }

  @Override