import com.google.common.escape.UnicodeEscaper;

/**
 * Testing utilities for {@link UrlEscapers} and {@link LegacyUrlEscapersTest}.
 *
 * @author David Beaumont
 */
@GwtCompatible
final class UrlEscaperTesting {
  /**
   * Helper to assert common expected behaviour of uri escapers. You should call
   * assertBasicUrlEscaper() unless the escaper explicitly does not escape '%'.
   */

    assertThrows(IndexOutOfBoundsException.class, () -> hasher.putBytes(new byte[8], 0, -1));
  }

  private class TestHasher extends AbstractByteHasher {

    private final ByteArrayOutputStream out = new ByteArrayOutputStream();

    @Override
    protected void update(byte b) {
      out.write(b);
    }

    @Override
    protected void update(byte[] b, int off, int len) {

import java.util.TreeMap;

import static org.apache.commons.lang.StringUtils.getLevenshteinDistance;

public class SimpleClassMetaDataRepository<T extends Attachable<T>> implements ClassMetaDataRepository<T> {
    private final Map<String, T> classes = new TreeMap<>();

    @SuppressWarnings("unchecked")
    public void load(File repoFile) {
        try {
            FileInputStream inputStream = new FileInputStream(repoFile);
            try {

who have received copies, or rights, from you under this License will
not have their licenses terminated so long as such parties remain in
full compliance.

5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by

import java.util.function.Supplier;

import org.apache.maven.api.plugin.Log;
import org.slf4j.Logger;

import static java.util.Objects.requireNonNull;

public class DefaultLog implements Log {
    private final Logger logger;

    public DefaultLog(Logger logger) {
        this.logger = requireNonNull(logger);
    }

    public void debug(CharSequence content) {
        if (isDebugEnabled()) {

 * ByteBuffer} and streams all bytes to a sink to compute the hash.
 *
 * @author Colin Decker
 */
@ElementTypesAreNonnullByDefault
abstract class AbstractByteHasher extends AbstractHasher {
  private final ByteBuffer scratch = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);

  /** Updates this hasher with the given byte. */
  protected abstract void update(byte b);

  /** Updates this hasher with the given bytes. */

  private static class MultisetHolder implements Serializable {
    public Multiset<?> member;

    MultisetHolder(Multiset<?> multiset) {
      this.member = multiset;
    }

    private static final long serialVersionUID = 1L;
  }

  @J2ktIncompatible
  @GwtIncompatible // SerializableTester
  public void testSerializationIndirectSelfReference() {
    Multiset<MultisetHolder> multiset = HashMultiset.create();

  SUBSET_VIEW,
  DESCENDING_VIEW,

  /**
   * For documenting collections that support no optional features, such as {@link
   * java.util.Collections#emptySet}
   */
  NONE;

  private final Set<Feature<? super Collection>> implied;

  CollectionFeature(Feature<? super Collection>... implied) {
    this.implied = copyToSet(implied);
  }

  @Override

    @Override
    public int bits() {
      return 32;
    }

    @Override
    public Hasher newHasher() {
      return new AbstractStreamingHasher(4, 4) {
        final ByteArrayOutputStream out = new ByteArrayOutputStream();

        @Override
        protected HashCode makeHash() {
          return HashCode.fromBytes(out.toByteArray());
        }

        @Override

  private @Nullable FinalizableReferenceQueue frq;

  @Override
  protected void tearDown() throws Exception {
    frq = null;
  }


  public void testFinalizeReferentCalled() {
    final MockReference reference = new MockReference(frq = new FinalizableReferenceQueue());

    GcFinalization.awaitDone(
        new GcFinalization.FinalizationPredicate() {
          @Override
          public boolean isDone() {