hierarchyByName.put(attribute.getName(), this);
        this.hierarchyByName = ImmutableMap.copyOf(hierarchyByName);
        int hashCode = parent.hashCode();
        hashCode = 31 * hashCode + attribute.hashCode();
        hashCode = 31 * hashCode + value.hashCode();
        this.hashCode = hashCode;
        if (hierarchyByName.size() == 1) {

    @Nullable
    @Override
    public HashCode hash(RegularFileSnapshotContext snapshotContext) throws IOException {
        return Optional.of(snapshotContext)
            .filter(this::filter)
            .flatMap(path -> tryHash(snapshotContext))
            .orElseGet(IoSupplier.wrap(() -> delegate.hash(snapshotContext)));
    }

    @Nullable
    @Override
    public HashCode hash(ZipEntryContext zipEntryContext) throws IOException {

    sink.putByte((byte) 7);
    sink.putBytes(new byte[] {});
    sink.putBytes(new byte[] {8});
    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(expected);
  }

  public void testShort() {
    Sink sink = new Sink(4);
    sink.putShort((short) 0x0201);
    HashCode unused = sink.hash();
    sink.assertInvariants(2);
    sink.assertBytes(new byte[] {1, 2, 0, 0}); // padded with zeros

    /**
     * Hash the given bytes using the hash function.
     */
    HashCode hashBytes(byte[] bytes);

    /**
     * Hash the given string using the hash function.
     */
    HashCode hashString(CharSequence string);

    /**
     * Hash the contents of the given {@link java.io.InputStream}.
     */
    HashCode hashStream(InputStream stream) throws IOException;

    /**

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

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

        def id2 = newProjectId(projectPath)
        strictlyEquals(id1, id2) == equality
        (id1.hashCode() == id2.hashCode()) == hashCode
        (id1.toString() == id2.toString()) == stringRepresentation

        where:
        projectPath       | equality | hashCode | stringRepresentation
        ':myProjectPath1' | true     | true     | true
        ':myProjectPath2' | false    | false    | false
    }

        }
        if (version != that.version) {
            return false
        }

        return true
    }

    int hashCode() {
        int result
        result = vendor.hashCode()
        result = 31 * result + version.hashCode()
        result = 31 * result + gc.hashCode()
        return result
    }


    @Override
    public String toString() {
        return "FullyQualifiedGarbageCollector{" +

        encoder.writeByte((byte) accessType.ordinal());
    }

    private static HashCode readHashCode(Decoder decoder) throws IOException {
        return HashCode.fromBytes(decoder.readBinary());
    }

    private static void writeHashCode(Encoder encoder, HashCode hashCode) throws IOException {
        encoder.writeBinary(hashCode.toByteArray());
    }

    private static class SnapshotStack {

import java.util.Set;

final class DefaultModuleSetExclude implements ModuleSetExclude {
    private final Set<String> modules;
    private final int hashCode;

    DefaultModuleSetExclude(Set<String> modules) {
        this.modules = modules;
        this.hashCode = modules.hashCode();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

    this.validator = validator;
    this.errorMessage = errorMessage;
  }

  // Override hashCode() to access delegate directly (so that it doesn't trigger the validate() call
  // via delegate()); it seems inappropriate to throw ISE on this method.
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  private void validate() {