case INSTRUMENTATION_MARKER:
                // We don't need to do anything with the marker file
                return;
            case TYPE_HIERARCHY_ANALYSIS_DATA:
                // Type hierarchy analysis should never be an input to this transform
            default:
                throw new IllegalStateException("Unexpected input type: " + inputType);
        }
    }

     *
     * A path is contained in the set if it or one of its ancestors has
     * been added to the set.
     */
    public abstract boolean contains(String path);

    /**
     * Whether this hierarchy is empty, i.e. contains no directories.
     */
    public abstract boolean isEmpty();

    /**

    /**
     * Finds the parent symbol of the given [KaSymbol] by traversing back up the symbol hierarchy a certain number of steps,
     * or until the containing class or object symbol is found.
     *
     * @param symbol The [KaSymbol] whose parent symbol needs to be found.
     * @param goBackSteps The number of steps to go back up the symbol hierarchy.
     * @param selectedFqName The fully qualified name of the selected package.

# Build state model

The Gradle daemon tracks state for various elements. These are arranged in a hierarchy:

```mermaid
  graph TD

  process["build process"]
  
  session["build session"]
  process --> session
  
  build_tree["build tree"]
  session --> build_tree
  
  build1["root build"]
  build_tree --> build1
  
  project1["root project"]
  build1 --> project1
  
  project2["project"]
  build1 --> project2

            MutationValidator.MutationType.DEPENDENCY_CONSTRAINT_ATTRIBUTES,
            MutationValidator.MutationType.ARTIFACTS,
            MutationValidator.MutationType.USAGE,
            MutationValidator.MutationType.HIERARCHY
        ]
    }

    def "does not reevaluate component metadata when #mutationType change"() {
        componentIdentifierFactory.createComponentIdentifier(_) >> {

The simpler the problem solved by the tool, the better performance it will get. And most of the benchmarks don't test the additional features provided by the tool.

The hierarchy is like:

* **Uvicorn**: an ASGI server
    * **Starlette**: (uses Uvicorn) a web microframework

        outgoing.getCapabilities() >> Collections.emptySet()

        configuration.isCanBeDeclared() >> true
        configuration.name >> "config"
        configuration.extendsFrom >> []
        configuration.hierarchy >> [configuration]
        configuration.outgoing >> outgoing
        configuration.dependencies >> dependencySet
        configuration.dependencyConstraints >> dependencyConstraintSet

            // A normal gradle build does this by adding the MixInLegacyTypesClassLoader to the class loader hierarchy.
            // In a test run, which is essentially a plain Java application, the classpath is flattened and injected
            // into the system class loader and there exists no Gradle class loader hierarchy in the running test. (See Implementation

	}

	// since we use this container for accounting, we need to ensure its a unified hierarchy.
	if cpu != memory {
		return "", fmt.Errorf("cpu and memory cgroup hierarchy not unified.  cpu: %s, memory: %s", cpu, memory)
	}

	// on systemd, every pid is in a unified cgroup hierarchy (name=systemd as seen in systemd-cgls)

                return;
            case INSTRUMENTATION_MARKER:
            case TYPE_HIERARCHY_ANALYSIS_DATA:
                // We don't need to do anything with the marker file and type hierarchy
                return;
            default:
                throw new IllegalStateException("Unexpected input type: " + inputType);
        }
    }