}

    def "cannot hash unknown implementation snapshot"() {
        def snapshot = ImplementationSnapshot.of("SomeClass", null)
        when:
        snapshot.appendToHasher(Mock(Hasher))

        then:
        thrown(UnsupportedOperationException)
        0 * _
    }

    def "implementation snapshots are equal for classes created #description"() {
        expect:

        this.implMethodName = implMethodName;
        this.implMethodSignature = implMethodSignature;
        this.implMethodKind = implMethodKind;
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        hasher.putString(LambdaImplementationSnapshot.class.getName());
        hasher.putString(classIdentifier);
        hasher.putHash(classLoaderHash);
        hasher.putString(functionalInterfaceClass);

            if (fingerprints.isEmpty()) {
                return null;
            }
            Hasher hasher = Hashing.newHasher();
            FingerprintHashingStrategy.SORT.appendToHasher(hasher, fingerprints);
            return hasher.hash();
        } catch (Exception e) {
            hashingExceptionReporter.report(zipFileSnapshot, e);
            if (fallbackZipHasher != null) {

            putBytes(value.toString().getBytes(Charsets.UTF_8));
        }

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

        @Override
        public HashCode hash() {
            byte[] bytes = getDigest().digest();
            digest = null;

        Hasher hasher = Hashing.newHasher();
        identityInputs.values().forEach(value -> requireNonNull(value).appendToHasher(hasher));
        String identity = hasher.hash().toString();
        return () -> identity;
    }

    @Override
    @OverridingMethodsMustInvokeSuper

        def id = DefaultModuleVersionIdentifier.newId('org', 'foo', '1.0')
        def inputsSnapshot = new StringValueSnapshot("1")
        def hasher = Hashing.newHasher()
        inputsSnapshot.appendToHasher(hasher)
        def keyHash = hasher.hash()
        def cachedResult = Mock(ComponentMetadata)
        Multimap<String, ImplicitInputRecord<?, ?>> implicits = HashMultimap.create()

        def key = Mock(ModuleComponentResolveMetadata)
        def inputsSnapshot = new StringValueSnapshot("1")
        def hasher = Hashing.newHasher()
        inputsSnapshot.appendToHasher(hasher)
        def keyHash = hasher.hash()
        def cachedResult = Mock(ModuleComponentResolveMetadata)
        Multimap<String, ImplicitInputRecord<?, ?>> implicits = HashMultimap.create()

            && primitiveType.equals(array, other.array);
    }

    @Override
    public String toString() {
        return primitiveType.toString(array);
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        primitiveType.appendTo(hasher, array);
    }

    @Override
    public ValueSnapshot snapshot(@Nullable Object value, ValueSnapshotter snapshotter) {

        val hasher = Hashing.newHasher()
        requireNotNull(identityInputs[TARGET_SCHEMA_INPUT_PROPERTY]).appendToHasher(hasher)
        hasher.putHash(requireNotNull(identityFileInputs[CLASSPATH_INPUT_PROPERTY]).hash)
        val identityHash = hasher.hash().toString()
        return UnitOfWork.Identity { identityHash }
    }

            return () -> {
                Hasher hasher = Hashing.sha1().newHasher();
                identityInputs.values().forEach(s -> s.appendToHasher(hasher));
                return hasher.hash().toString();
            };
        }

        @Override
        public ImmutableWorkspaceProvider getWorkspaceProvider() {
            return workspace;