}

func (fr *regFileReader) WriteTo(w io.Writer) (int64, error) {
	return io.Copy(w, struct{ io.Reader }{fr})
}

// logicalRemaining implements fileState.logicalRemaining.
func (fr regFileReader) logicalRemaining() int64 {
	return fr.nb
}

// physicalRemaining implements fileState.physicalRemaining.
func (fr regFileReader) physicalRemaining() int64 {
	return fr.nb
}

  /**
   * This Iterator claims to have more elements than the underlying iterable, but when you try to
   * fetch the extra elements, it throws an unchecked exception.
   */
  static class ThrowsAtEndIterator<E> implements Iterator<E> {
    Iterator<E> iterator;

    public ThrowsAtEndIterator(Iterable<E> iterable) {
      this.iterator = iterable.iterator();
    }

    @Override
    public boolean hasNext() {

 * collected, and this class can detect when the main class loader has been garbage collected and
 * stop itself.
 */
public class Finalizer implements Runnable {

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

  /**
   * Starts the Finalizer thread. FinalizableReferenceQueue calls this method reflectively.
   *

            public void destroy() {
            }
        };
        ComponentUtil.register(mockJobManager, JobManager.class.getCanonicalName());
    }

    private abstract static class MockLaScheduledJob implements LaScheduledJob {
        @Override
        public void stopNow() {
        }

        @Override

 *
 * @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

import jcifs.Configuration;

/**
 * Configuration implementation reading the classic jcifs settings from properties
 *
 * @author mbechler
 */
public final class PropertyConfiguration extends BaseConfiguration implements Configuration {

    private boolean useMultiChannelExplicitlySet = false;
    private boolean channelBindingPolicyExplicitlySet = false;

    /**
     * Create a configuration backed by properties
     *

         */
        Set<T1> set();

        /**
         * @return Map
         */
        Map<T1, T2> map();
    }

    /**
     *
     */
    public static abstract class Hoge implements Bar, Baz<String, Boolean> {
    }

    /**
     *
     */
    public interface Fuga {
        /**
         * @param <T>
         * @return T
         */
        <T> T getFuga();
    }

        Wagon wagon = wagonManager.getWagon(protocol);

        assertNotNull(wagon, "Check wagon, protocol=" + protocol);
    }

    private final class ArtifactRepositoryLayoutStub implements ArtifactRepositoryLayout {
        @Override
        public String getId() {
            return "test";
        }

        @Override

                        .get("key"));
        assertNotNull(result.getProblems());
        assertEquals(0, result.getProblems().size());
    }

    static class TestEnvVarSource implements OperatingSystemUtils.EnvVarSource {
        private final Map<String, String> envVarMap;

        TestEnvVarSource(Map<String, String> envVarMap) {
            this.envVarMap = envVarMap;
        }

 * thread-safe, even when all of the methods that they depend on are thread-safe.
 *
 * @author Louis Wasserman
 */
public abstract class ForwardingSortedMultiset<E extends @Nullable Object>
    extends ForwardingMultiset<E> implements SortedMultiset<E> {
  /** Constructor for use by subclasses. */
  protected ForwardingSortedMultiset() {}

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

  @Override