if (refererMetaData == this.referringClass) {
            return this
        }
        return new MethodDoc(refererMetaData, metaData, comment)
    }

    String getId() {
        return id
    }

    String getName() {
        return metaData.name
    }

    MethodMetaData getMetaData() {
        return metaData
    }

    boolean isDeprecated() {

            result.setCollectionErrors(e.getResult().getExceptions());

            throw new DependencyResolutionException(
                    result, "Could not collect dependencies for project " + project.getId(), e);
        }

        depRequest.setRoot(node);

        if (logger.isWarnEnabled()) {
            for (DependencyNode child : node.getChildren()) {
                if (!child.getRelocations().isEmpty()) {

    private static String createMessage(Plugin plugin, String descriptorLocation, Throwable e) {
        String message = "Failed to parse plugin descriptor";

        if (plugin != null) {
            message += " for " + plugin.getId();
        }

        if (descriptorLocation != null) {
            message += " (" + descriptorLocation + ")";
        }

        if (e != null) {
            message += ": " + e.getMessage();
        }

@pytest.fixture(name="app")
def app_fixture(call_counter: dict[str, int]):
    def get_db():
        call_counter["count"] += 1
        return f"db_{call_counter['count']}"

    def get_user(db: Annotated[str, Depends(get_db)]):
        return "user"

    app = FastAPI()

    @app.get("/")
    def endpoint(
        db: Annotated[str, Depends(get_db)],
        user: Annotated[str, Security(get_user, scopes=["read"])],
    ):

                // Contributor
                visit((Contributor) developer);
                // Distribution
                org = developer.getId();
                val = interpolate(org);
                if (org != val) {
                    developer.setId(val);
                }
            }
        }

        private void visit(Contributor contributor) {
            if (contributor != null) {

    private final CoreExtension extension;

    public ExtensionResolutionException(CoreExtension extension, Throwable cause) {
        super(
                "Extension " + extension.getId() + " or one of its dependencies could not be resolved: "
                        + cause.getMessage(),
                cause);
        this.extension = extension;
    }

    public CoreExtension getExtension() {

    }

    /** {@inheritDoc} */
    @Override
    public String getRoleHint() {
        return getId();
    }

    /**
     * @return the id of the mojo, based on the goal name
     */
    public String getId() {
        return getPluginDescriptor().getId() + ":" + getGoal();
    }

    /**
     * @return the full goal name
     * @see PluginDescriptor#getGoalPrefix()

        if (!model.getMixins().isEmpty() && !flattenEnabled && !model.isPreserveModelVersion()) {
            throw new MavenException("The consumer POM for "
                    + project.getId()
                    + " cannot be created because the POM contains mixins. "
                    + "Mixins are not supported in the default consumer POM format. "

        String message;

        if (mojoExecution != null) {
            message = "Execution " + mojoExecution.getExecutionId() + " of goal "
                    + mojoExecution.getMojoDescriptor().getId() + " failed";
        } else {
            message = "Mojo execution failed";
        }

        if (cause != null && cause.getMessage() != null && !cause.getMessage().isEmpty()) {

            hash = hash * 31 + Objects.hashCode(dependencyFilter);
            this.hashCode = hash;
        }

        @Override
        public String toString() {
            return plugin.getId();
        }

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

        @Override
        public boolean equals(Object o) {
            if (o == this) {