return fileSnapshotContext.getSnapshot().getHash();
    }

    @Override
    public HashCode hash(ZipEntryContext zipEntryContext) throws IOException {
        return zipEntryContext.getEntry().withInputStream(Hashing::hashStream);
    }

    @Override
    public void appendConfigurationToHasher(Hasher hasher) {
        hasher.putString(getClass().getName());
    }

                // single entry in the classpath, populated from itself
                ArtifactMetadata amd = cleanGraph.getEntry().getMd();
                cpc.add(amd);
            } else {
                ClasspathGraphVisitor v = new ClasspathGraphVisitor(cleanGraph, cpc);
                MetadataGraphVertex entry = cleanGraph.getEntry();
                // entry point
                v.visit(entry);
            }

            return cpc;

		return -1
	}
	if int(x) < s.first {
		return -1
	}
	if int(x) >= s.cap() {
		return -1
	}
	return s.s.get(ID(int(x) - s.first))
}

// getEntry returns the i'th key and value stored in s,
// where 0 <= i < s.size()
func (s *biasedSparseMap) getEntry(i int) (x uint, v int32) {
	e := s.s.contents()[i]
	x = uint(int(e.key) + s.first)
	v = e.val
	return
}

            noRelocationResources.each { resourceName ->
                assert jar.getEntry(resourceName)
            }
            onlyRelocatedResources.each { resourceName ->
                assert jar.getEntry("org/gradle/internal/impldep/$resourceName")
            }
            generatedFiles.each { resourceName ->
                assert jar.getEntry(resourceName)
            }
        }
    }

 */

package org.gradle.internal.fingerprint.hashing;

import org.gradle.api.internal.file.archive.ZipEntry;

import java.util.function.Supplier;

public interface ZipEntryContext {
    ZipEntry getEntry();

    String getFullName();

    String getRootParentName();

    Supplier<String[]> getRelativePathSegments();

    boolean filter(RegularFileSnapshotContext context) {
        return matchesAnyFilters(context.getRelativePathSegments());
    }

    @Override
    boolean filter(ZipEntryContext context) {
        return !context.getEntry().isDirectory() && matchesAnyFilters(context.getRelativePathSegments());
    }

    @Override
    public Optional<HashCode> tryHash(RegularFileSnapshotContext snapshotContext) {

        def zipEntry = Mock(ZipEntry)
        def classContent = bytesOf(String.class)

        when:
        def hash = resourceHasher.hash(zipEntryContext)

        then:
        1 * zipEntryContext.getEntry() >> zipEntry
        2 * zipEntry.getName() >> 'String.class'
        1 * zipEntry.getContent() >> classContent
        1 * apiClassExtractor.extractApiClassFrom(_) >> { args -> throw new Exception("Boom!") }

  public int count(@Nullable Object element) {
    throw new AssertionError();
  }

  @Override
  public ImmutableSet<E> elementSet() {
    throw new AssertionError();
  }

  @Override
  Entry<E> getEntry(int index) {
    throw new AssertionError();
  }

  @Override
  boolean isPartialView() {
    throw new AssertionError();
  }

  @Override
  public int size() {
    throw new AssertionError();
  }

            }
        }

        MetadataGraphNode node = new MetadataGraphNode(md);
        addNode(node);
        return node;
    }

    /**
     * getter
     */
    public MetadataGraphNode getEntry() {
        return entry;
    }

    /**
     * getter
     */
    public Collection<MetadataGraphNode> getNodes() {
        return nodes;
    }

     * @param scope - which classpath to extract
     * @param resolve - whether to resolve artifacts.
     * @return Collection of metadata objects in the linked subgraph of the graph which
     *             contains the graph.getEntry() vertice
     */
    ClasspathContainer transform(MetadataGraph dirtyGraph, ArtifactScopeEnum scope, boolean resolve)
            throws MetadataGraphTransformationException;