assertBothExistsAndOneIsBeforeOther(hierarchy, middle1, root1);
        assertBothExistsAndOneIsBeforeOther(hierarchy, middle2, root2);
    }

    private static void assertBothExistsAndOneIsBeforeOther(Set<Configuration> hierarchy, Configuration beforeConf, Configuration afterConf) {
        assert hierarchy.contains(beforeConf)
        assert hierarchy.contains(afterConf)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.ide.xcode.internal.xcodeproj;

/**
 * Superclass in Xcode's object hierarchy, has no non-structural functionality here.
 */
public abstract class PBXContainerItem extends PBXObject {

    @Override
    public String isa() {
        return "PBXContainerItem";
    }

 * limitations under the License.
 */

package org.gradle.ide.xcode.internal.xcodeproj;

/**
 * Superclass of all container types. This is here to reflect Xcode's object hierarchy, and does
 * not implement any special functionality.
 */
public abstract class PBXContainer extends PBXObject {
    @Override
    public String isa() {
        return "PBXContainer";
    }

class DefaultFileSystemAccessConcurrencyTest extends AbstractFileSystemAccessTest {

    def "parallel invalidation yields correct results"() {
        def dir = temporaryFolder.createDir("some/deep/hierarchy")
        (1..1000).each {
            def subdir = dir.file(it)
            subdir.file("in-dir.txt").createFile()
        }

        allowFileSystemAccess(true)
        read(dir)

 * limitations under the License.
 */

package org.gradle.tooling.model;

import javax.annotation.Nullable;

/**
 * Represents an element which belongs to some hierarchy.
 *
 * @since 1.0-milestone-5
 */
public interface HierarchicalElement extends Element {

    /**
     * Returns the parent of this element, or {@code null} if there is no parent.
     *

1. We generate interceptors from the annotations declared in the source code 
2. We collect Gradle API type hierarchy

The first one is important for both configuration cache instrumentation and API upgrades while the second one is used just for API upgrades. 
Collecting the Gradle API type hierarchy is fully automatic, while declaring interceptors have to be done by Gradle developers. 

```mermaid
flowchart TB

     *
     * <p>Overriding methods are not folded like in the case of {@link Class#getMethods()}. This allows
     * the caller to identify annotations declared at different levels in the hierarchy, and also to identify all
     * the classes declaring a certain method.</p>
     *
     * <p>Method candidates exclude:</p>
     * <ul>
     *     <li>methods defined by {@link Object} and their overrides</li>

            </tr>
            <tr>
                <td>transitive</td>
            </tr>
            <tr>
                <td>extendsFrom</td>
            </tr>
            <tr>
                <td>hierarchy</td>
            </tr>
            <tr>
                <td>resolvedConfiguration</td>
            </tr>
            <tr>
                <td>buildDependencies</td>
            </tr>
            <tr>

 * limitations under the License.
 */
package org.gradle.api.artifacts;

/**
 * <p>A {@code ExternalModuleDependency} is a {@link Dependency} on a module outside the current project hierarchy.</p>
 */
public interface ExternalModuleDependency extends ExternalDependency {
    /**
     * Returns whether or not Gradle should always check for a change in the remote repository.
     *

 * <p>
 * The {@link ModelMap} type requires that its elements are {@link org.gradle.api.Named}.
 *
 * <h3>Inheritance</h3>
 * <p>
 * Managed types can be arranged into an inheritance hierarchy.
 * Every type in the hierarchy must conform to the constraints of managed types.
 *
 * <h3>Calculated read-only properties</h3>
 * <p>
 * Managed types can contain getter methods that return calculated values, based on other properties.