this.typeFilter = typeFilter;
        this.interner = interner;
        collectRemainingClassDependencies(reader);
    }

    public static ClassAnalysis analyze(String className, ClassReader reader, StringInterner interner) {
        ClassDependenciesVisitor visitor = new ClassDependenciesVisitor(new ClassRelevancyFilter(className), reader, interner);
        reader.accept(visitor, ClassReader.SKIP_FRAMES);

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          xmlns:tools="http://schemas.android.com/tools" package="okhttp.android.test">

  <uses-permission android:name="android.permission.INTERNET" />

  <application android:usesCleartextTraffic="true" tools:targetApi="m"/>

        this.contentHash = contentHash;
        this.metadata = metadata;
    }

    @Override
    protected Optional<RegularFileSnapshot> relocateDirectAccess(String targetPath, String name, Interner<String> interner) {
        return Optional.of(new RegularFileSnapshot(targetPath, name, contentHash, metadata));
    }

    @Override
    public FileType getType() {
        return FileType.RegularFile;
    }

        def problemEmitter = Stub(NoOpProblemEmitter)
        def problems = new DefaultProblems(problemEmitter)
        def builder = new DefaultVersionCatalogBuilder(
            "libs",
            Interners.newStrongInterner(),
            Interners.newStrongInterner(),
            TestUtil.objectFactory(),
            supplier) {
            @Override
            protected InternalProblems getProblemsService() {
                problems

127.0.0.1 test
127.0.0.2 test2.example.com 2.test
127.0.0.3 3.test test3.example.com
127.0.0.4 example.com
127.0.0.5 test4.example.com 4.test 5.test test5.example.com

# must be a non resolvable domain on the internet

#define TENSORFLOW_CC_EXPERIMENTAL_LIBTF_IMPL_STRING_H_

#include <iosfwd>
#include <string>

namespace tf {
namespace libtf {
namespace impl {

/** A string value.
 *  This class wraps an interned, immutable string value. Currently, interned
 *  values are never deleted, so memory usage increases without bound as new
 *  strings are created.
 */
class String final {
 public:
  /** Interning constructor.

    private final Interner<String> stringInterner;

    public ModuleMetadataStore(PathKeyFileStore metaDataStore,
                               ModuleMetadataSerializer moduleMetadataSerializer,
                               ImmutableModuleIdentifierFactory moduleIdentifierFactory,
                               Interner<String> stringInterner) {
        this.metaDataStore = metaDataStore;

    private final Instantiator instantiator;
    private final Class<T> wantedType;
    private final Interner<String> stringInterner;
    private final StrictVersionParser strictVersionParser;

    public DependencyStringNotationConverter(Instantiator instantiator, Class<T> wantedType, Interner<String> stringInterner) {
        this.instantiator = instantiator;
        this.wantedType = wantedType;

import com.google.common.collect.Interner;
import org.gradle.internal.serialize.Decoder;

import javax.annotation.Nullable;
import java.io.Closeable;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;

class StringDeduplicatingDecoder implements Decoder, Closeable {
    private final Decoder delegate;
    private final Interner<String> stringInterner;

        this(absolutePath, PathUtil.getFileName(absolutePath), accessType);
    }

    @Override
    protected Optional<MissingFileSnapshot> relocateDirectAccess(String targetPath, String name, Interner<String> interner) {
        return Optional.of(new MissingFileSnapshot(targetPath, name, getAccessType()));
    }

    @Override
    public FileType getType() {
        return FileType.Missing;
    }

    @Override