if (hashCode != that.hashCode) {
            return false;
        }
        if (!moduleIdentifier.equals(that.moduleIdentifier)) {
            return false;
        }
        return version.equals(that.version);
    }

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

    @Override
    public String toString() {

    def "delegates equals and hashCode to project"() {
        given:
        def project = Mock(ProjectInternal)
        def subject = new DefaultIsolatedProject(project, project)

        when:
        def hashCode = subject.hashCode()
        def equality = subject.equals(new DefaultIsolatedProject(project, project))

        then:
        hashCode == 42
        equality
        1 * project.hashCode() >> 42

import org.gradle.internal.hash.HashCode;
import org.gradle.internal.serialize.HashCodeSerializer;

import java.io.Closeable;

public class UserHomeScopedCompileCaches implements GeneralCompileCaches, Closeable {
    private final Cache<HashCode, ClassSetAnalysisData> classpathEntrySnapshotCache;
    private final PersistentCache cache;
    private final Cache<HashCode, ClassAnalysis> classAnalysisCache;

        }

        @Override
        public void putHash(HashCode hashCode) {
            hashCode.appendToHasher(this);
        }

        @Override
        public HashCode hash() {
            byte[] bytes = getDigest().digest();
            digest = null;
            return HashCode.fromBytes(bytes, SAFE_TO_REUSE_BYTES);
        }
    }

import org.gradle.internal.hash.HashCode;
import org.gradle.internal.io.IoConsumer;

import java.io.Closeable;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.function.Consumer;

public interface LocalBuildCache extends Closeable {
    boolean load(HashCode key, IoConsumer<InputStream> reader);

    void loadLocally(HashCode key, Consumer<? super File> reader);

        this.version = version;
        this.hashCode = 31 * id.hashCode() ^ version.hashCode();
    }

    private DefaultModuleVersionIdentifier(ModuleIdentifier id, String version) {
        assert version != null : "version cannot be null";
        this.id = id;
        this.version = version;
        // pre-compute the hashcode as it's going to be used anyway, and this object

    }

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

    private int computeHashCode() {
        int result = name.hashCode();
        result = 31 * result + type.hashCode();
        result = 31 * result + (extension != null ? extension.hashCode() : 0);
        result = 31 * result + (classifier != null ? classifier.hashCode() : 0);
        return result;
    }

    @Override

        }
    }

    private Optional<HashCode> loadInstrumentedSuperTypesHash() {
        return loadHashCodeFromResource(INSTRUMENTED_SUPER_TYPES_FILE);
    }

    private Optional<HashCode> loadUpgradedPropertiesHash() {
        return loadHashCodeFromResource(UPGRADED_PROPERTIES_FILE);
    }

    private Optional<HashCode> loadHashCodeFromResource(String resourceFile) {

        HashCode hash = fileSystemAccess.read(absolutePath).getHash();

        return new DefaultSnapshot(hash);
    }

    private static class DefaultSnapshot implements Snapshot {

        private final HashCode hashCode;

        public DefaultSnapshot(HashCode hashCode) {
            this.hashCode = hashCode;
        }

        @Override

    }

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

  static class SameIntegerInstance {
    private final Integer i;

    public SameIntegerInstance(Integer i) {
      this.i = checkNotNull(i);
    }

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

    @Override