if len(namedRule.ResourceNames) == 0 {
			return true, matchResource, matchKind, nil
		}
		// TODO: GetName() can return an empty string if the user is relying on
		// the API server to generate the name... figure out what to do for this edge case
		name := attr.GetName()
		for _, matchedName := range namedRule.ResourceNames {
			if name == matchedName {
				return true, matchResource, matchKind, nil
			}

    public DefaultIsolatedProject(ProjectInternal project, ProjectInternal rootProject) {
        this.project = project;
        this.rootProject = rootProject;
    }

    @Override
    public String getName() {
        return project.getName();
    }

    @Override
    public String getPath() {
        return project.getPath();
    }

    @Override
    public String getBuildTreePath() {

            throw new InvalidUserCodeException("Cannot add artifacts during filtering");
        }

        @Override
        public String getName() {
            return outgoingConfiguration.getName();
        }

        @Override
        public Optional<String> getDescription() {
            return Optional.ofNullable(outgoingConfiguration.getDescription());
        }

import org.apache.catalina.WebResource;
import org.apache.catalina.webresources.StandardRoot;

public class FessWebResourceRoot extends StandardRoot {
    private static final Logger logger = Logger.getLogger(FessWebResourceRoot.class.getName());

    public FessWebResourceRoot(final Context context) {
        super(context);
    }

    @Override
    protected void processWebInfLib() throws LifecycleException {
        super.processWebInfLib();

                                    return properties;
                                } else if ("getUserProperties".equals(method.getName())) {
                                    return Map.of();
                                } else if ("getService".equals(method.getName())) {
                                    if (args[0] == ToolchainsXmlFactory.class) {
                                        return toolchainsXmlFactory;

 */

package org.gradle.performance.results.report;

import java.math.BigDecimal;

import static org.gradle.performance.results.report.Tag.FixedTag.UNTAGGED;

public interface Tag {
    String getName();

    String getClassAttr();

    String getTitle();

    String getUrl();

    default boolean isValid() {
        return this != UNTAGGED;
    }

    enum FixedTag implements Tag {

    @Override
    public String toString() {
        return "Test " + getName() + "(" + className + ")";
    }

    @Override
    public boolean isComposite() {
        return false;
    }

    @Override
    public String getClassName() {
        return className;
    }

    @Override
    public String getMethodName() {
        return getName();
    }

    @Override
    public String getDisplayName() {

        TarArchiveOutputStream tarOutput = new TarArchiveOutputStream(output.openOutput());
        for (DataSource input : inputs) {
            TarArchiveEntry entry = new TarArchiveEntry(input.getName());
            entry.setSize(input.getLength());
            tarOutput.putArchiveEntry(entry);
            PackerUtils.packEntry(input, tarOutput, buffer);
            tarOutput.closeArchiveEntry();
        }

    }

    private static <T extends BuildOperationType<?, ?>> Class<?> extract(Class<T> type, int index) {
        assert BuildOperationType.class.isAssignableFrom(type) : type.getName() + " is not a " + BuildOperationType.class.getName();

        for (Type superType : type.getGenericInterfaces()) {
            if (superType instanceof ParameterizedType && ((ParameterizedType) superType).getRawType().equals(BuildOperationType.class)) {

    public DefaultProblemId(String id, String displayName, ProblemGroup parent) {
        this.id = id;
        this.displayName = displayName;
        this.parent = parent;
    }

    @Override
    public String getName() {
        return id;
    }

    @Override
    public String getDisplayName() {
        return displayName;
    }

    @Override
    public ProblemGroup getGroup() {
        return parent;
    }