*/
      return;
    }

    /*
     * Only under Windows (or hypothetically when running with some other non-POSIX, ACL-based
     * filesystem) does our prod code look up the username. Thus, this test doesn't necessarily test
     * anything interesting under most environments. Still, we can run it (except for Android, at
     * least old versions), so we mostly do. This is useful because we don't actually run our CI on

        fails ':a:pingServer'

        then:
        failure.assertHasCause('b failed')
        failure.assertHasCause('c failed')
    }

    def "tasks are executed when they are ready and not necessarily alphabetically"() {
        buildFile << """
            tasks.getByPath(':b:pingA').dependsOn(':a:pingA')
            tasks.getByPath(':b:pingC').dependsOn([':b:pingA', ':b:pingB'])
        """

        expect:

            }
        }
    }

    private static boolean isPresent(@Nullable Object value) {
        if (value instanceof Provider) {
            // carefully check for presence without necessarily resolving
            return ((Provider<?>) value).isPresent();
        }
        return value != null;
    }

    private static boolean hasConfigurableValue(@Nullable Object value) {

     */
    public interface PlannedNode {

        NodeIdentity getNodeIdentity();

        /**
         * Returns the dependencies of this node.
         * <p>
         * Note that dependencies are not necessarily located in the same execution plan.
         */
        List<? extends NodeIdentity> getNodeDependencies();

    }

    /**
     * Identity of a local task node in the execution graph.
     *

            return model;
        }
        model = new DefaultGradleBuild();
        all.put(targetBuild, model);

        // Make sure the project tree has been loaded and can be queried (but not necessarily configured)
        targetBuild.ensureProjectsLoaded();

        GradleInternal gradle = targetBuild.getMutableModel();
        addProjects(targetBuild, model);
        addIncludedBuilds(gradle, model, all);

   * leaking resources callers must [close the response body][ResponseBody] or the response.
   *
   * Note that transport-layer success (receiving a HTTP response code, headers and body) does not
   * necessarily indicate application-layer success: `response` may still indicate an unhappy HTTP
   * response code like 404 or 500.
   *
   * @throws IOException if the request could not be executed due to cancellation, a connectivity

type Port struct {
	// Name ascribes a human readable name for the port object. When a
	// service has multiple ports, the name field is mandatory
	Name string

	// Port number where the service can be reached. Does not necessarily
	// map to the corresponding port numbers for the instances behind the
	// service.
	Port int

	// Protocol to be used for the port.
	Protocol protocol.Instance

	// TLS determines if the port will use TLS.

                "Test class OkTest -> after class out\n" +
                "Test class OkTest -> after class err\n"
            )

            // This test covers current behaviour, not necessarily desired behaviour

            def xmlReport = new JUnitXmlTestExecutionResult(testDirectory)
            def classResult = xmlReport.testClass("OkTest")
            classResult.assertTestCaseStdout("ok", is(

        }
        InetEndpoint address = (InetEndpoint) destinationAddress;
        LOGGER.debug("Attempting to connect to {}.", address);

        // Try each address in turn. Not all of them are necessarily reachable (eg when socket option IPV6_V6ONLY
        // is on - the default for debian and others), so we will try each of them until we can connect
        List<InetAddress> candidateAddresses = address.getCandidates();

 * stub-indexing binary libraries). And in general, querying the symbol names provider might be faster since its sets are cached, which is
 * not necessarily the case for declaration providers (e.g. the IDE declaration provider hitting the index without caching).
 *