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";
    }

    /**
     * Returns the project directory.
     */
    File getProjectDir();

    /**
     * Returns the nesting level of a project in a multi-project hierarchy. For single project builds this is always
     * 0. In a multi-project hierarchy 0 is returned for the root project.
     */
    int getDepth();

    /**
     * Returns the identifier of the default component produced by this project.
     */

 * 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.api.artifacts;

import org.gradle.api.Action;

/**
 * <p>An {@code ExternalDependency} is a {@link Dependency} on a source outside the current project hierarchy.</p>
 */
public interface ExternalDependency extends ModuleDependency, ModuleVersionSelector {

    /**
     * Returns whether or not the version of this dependency should be enforced in the case of version conflicts.

 * 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.
     *

     *
     * <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>

 * <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.