*
   * @param target target to which to append output
   */
  AppendableWriter(Appendable target) {
    this.target = checkNotNull(target);
  }

  /*
   * Abstract methods from Writer
   */

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    checkNotClosed();
    // It turns out that creating a new String is usually as fast, or faster

import static org.junit.jupiter.api.Assertions.assertNotNull;

/**
 * Provides a basis for testing conflict resolvers.
 *
 */
@PlexusTest
@Deprecated
public abstract class AbstractConflictResolverTest {
    // constants --------------------------------------------------------------

    private static final String GROUP_ID = "test";

    val text = "eile oli oliiviõli".encodeToByteArray()
    val body = text.toResponseBody("text/plain; charset=EBCDIC".toMediaType())
    assertThat(body.bytes()).isEqualTo(text)
  }
}

abstract class ForwardingSource(
  val delegate: Source,
) : Source {
  override fun read(
    sink: Buffer,
    byteCount: Long,
  ): Long = delegate.read(sink, byteCount)

import org.eclipse.aether.transfer.TransferCancelledException;
import org.eclipse.aether.transfer.TransferEvent;
import org.eclipse.aether.transfer.TransferResource;

/**
 * AbstractMavenTransferListener
 */
public abstract class AbstractMavenTransferListener extends AbstractTransferListener {
    public static final String STYLE = ".transfer:-faint";

    protected final MessageBuilderFactory messageBuilderFactory;

 *
 * @author Louis Wasserman
 * @since 12.0
 */
@GwtIncompatible
public abstract class ForwardingNavigableSet<E extends @Nullable Object>
    extends ForwardingSortedSet<E> implements NavigableSet<E> {

  /** Constructor for use by subclasses. */
  protected ForwardingNavigableSet() {}

  @Override
  protected abstract NavigableSet<E> delegate();

  @Override
  public @Nullable E lower(@ParametricNullness E e) {

import java.io.IOException;
import java.io.InputStream;

import org.codelibs.core.exception.IORuntimeException;

/**
 * Utility class for {@link InputStream}.
 *
 * @author higa
 */
public abstract class InputStreamUtil {

    /**
     * Do not instantiate.
     */
    protected InputStreamUtil() {
    }

    /** Default buffer size. */
    private static final int BUF_SIZE = 4096;

    /**

import org.codelibs.core.exception.IORuntimeException;
import org.codelibs.core.log.Logger;

/**
 * Utility class for handling {@link java.util.zip.ZipInputStream}.
 *
 * @author koichik
 */
public abstract class ZipInputStreamUtil {

    private static final Logger logger = Logger.getLogger(ZipInputStreamUtil.class);

    /**
     * Do not instantiate.
     */
    protected ZipInputStreamUtil() {
    }

 * non-null bound if possible, let's require a non-null bound here.
 *
 * TODO(cpovirk): Elaborate on "wouldn't behave as users might expect."
 */
public abstract class TypeParameter<T> extends TypeCapture<T> {

  final TypeVariable<?> typeVariable;

  protected TypeParameter() {
    Type type = capture();

package gradlebuild.nullaway

import org.gradle.api.services.BuildService
import org.gradle.api.services.BuildServiceParameters
import java.io.Closeable
import java.util.concurrent.ConcurrentHashMap

internal abstract class NullawayStatusService : BuildService<BuildServiceParameters.None>, Closeable {
    private val projectsWithNullAwayEnabled = ConcurrentHashMap.newKeySet<String>()

      }
    },
    ;

    static final BuilderOp[] values = values();

    static BuilderOp randomOp() {
      return values[random.nextInt(values.length)];
    }

    abstract void doIt(ImmutableLongArray.Builder builder, AtomicLong counter);
  }

  private static final Random random = new Random(42);

  public void testLength() {