}

  @Override
  public HashCode hashInt(int input) {
    return hashBytes(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(input).array());
  }

  @Override
  public HashCode hashLong(long input) {
    return hashBytes(ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).putLong(input).array());
  }

  @Override
  public HashCode hashUnencodedChars(CharSequence input) {

    private final HashCode implementationHash;
    private final byte[] serializedValue;

    public JavaSerializedValueSnapshot(@Nullable HashCode implementationHash, byte[] serializedValue) {
        this.implementationHash = implementationHash;
        this.serializedValue = serializedValue;
    }

    @Nullable
    public HashCode getImplementationHash() {
        return implementationHash;

    private final TypeWrapper[] upperBounds;
    private final TypeWrapper[] lowerBounds;
    private final int hashCode;

    public WildcardTypeWrapper(TypeWrapper[] upperBounds, TypeWrapper[] lowerBounds, int hashCode) {
        this.upperBounds = upperBounds;
        this.lowerBounds = lowerBounds;
        this.hashCode = hashCode;
    }

    @Override
    public Class<?> getRawClass() {
        if (upperBounds.length > 0) {

        return type == other.type && Objects.equal(value, other.value) && arguments.equals(other.arguments);
    }

    @Override
    public int hashCode() {
        return super.hashCode() ^ type.hashCode() ^ (value == null ? 0 : value.hashCode()) ^ arguments.hashCode();
    }

import org.gradle.internal.hash.HashCode;

import java.io.File;
import java.io.Serializable;
import java.util.Collections;
import java.util.List;

public class DefaultCachedArtifact implements CachedArtifact, Serializable {
    private final File cachedFile;
    private final long cachedAt;
    private final HashCode descriptorHash;
    private final List<String> attemptedLocations;

    private final FileType type;
    private final HashCode normalizedContentHash;

    public static IgnoredPathFileSystemLocationFingerprint create(FileType type, HashCode contentHash) {
        switch (type) {
            case Directory:
                return DIRECTORY;
            case Missing:
                return MISSING_FILE;

    }

    @Override
    public int hashCode() {
        return hashCode;
    }

    private int computeHashCode() {
        int result = artifactName.hashCode();
        result = 31 * result + checksums.hashCode();
        result = 31 * result + trustedPgpKeys.hashCode();
        result = 31 * result + ignoredPgpKeys.hashCode();
        return result;
    }

        !n1.is(n2)

        n1.name == "a"
        n2.name == "b"

        Matchers.strictlyEquals(n1, n1)
        n2 != n1
        !n2.equals(n1)

        n1.hashCode() == n1.hashCode()
        n1.hashCode() != n2.hashCode()

        n1.toString() == "a"
        n2.toString() == "b"

        n1.is(factory.named(Named, "a"))
        n2.is(factory.named(Named, "b"))
    }

            writeClassPath(scope.exportClassPath)
        }
    }

    private
    fun WriteContext.writeHashCode(hashCode: HashCode?) {
        if (hashCode == null) {
            writeBoolean(false)
        } else {
            writeBoolean(true)
            writeBinary(hashCode.toByteArray())
        }
    }

        return name.equals(that.name) && Objects.equals(parent, that.parent);
    }

    @Override
    public int hashCode() {
        int result = Objects.hashCode(parent);
        result = 31 * result + name.hashCode();
        return result;
    }

    String getPath() {
        Deque<String> names = new ArrayDeque<>();
        names.add(name);