: library(OpRegistry::Global(), FunctionDefLibrary()) {
    session_options.env = Env::Default();
  }

  // Create GraphOptimizationPassOptions with a graph passed in constructor and
  // sensible options.
  GraphOptimizationPassOptions CreateGraphOptimizationPassOptions(
      std::unique_ptr<Graph>* graph) {
    GraphOptimizationPassOptions options;
    options.session_options = &session_options;

            executer.withTasks("b", "a").withArguments("-x", ":a").run().assertTasksExecuted(":b", ":sub:a")
        }
    }

    def "sensible error message for circular task dependency"() {
        buildFile << """
            task a(dependsOn: 'b')
            task b(dependsOn: 'a')
        """
        expect:
        2.times {

 */
public interface KotlinPlatformComponent

/**
 * An optional [KotlinPlatformComponent]. The Analysis API engine does not require an optional platform component to be implemented and
 * will use sensible fallbacks or disable/avoid certain behaviors instead.
 */

     *
     * @since 6.0
     */
    public abstract Property<Boolean> getGenerateDeploymentDescriptor();

    /**
     * A custom deployment descriptor configuration.
     * Default is an "application.xml" with sensible defaults.
     */
    public abstract DeploymentDescriptor getDeploymentDescriptor();

    public abstract void setDeploymentDescriptor(DeploymentDescriptor deploymentDescriptor);

    /**

    @Rule
    public TestNameTestDirectoryProvider temporaryFolder = TestNameTestDirectoryProvider.newInstance(getClass())

    def testUtil = TestUtil.create(temporaryFolder)

    def "provides sensible default values for quite empty archive tasks"() {
        def quiteEmptyJar = testUtil.task(DummyJar)
        quiteEmptyJar.destinationDirectory.set(temporaryFolder.testDirectory)

        when:

go doc x/y
! stdout 'Package y is.*GOPATH'
stdout 'Package y is.*alphabet'
go doc rsc.io/quote
! stdout 'Package quote is located in a GOPATH workspace.'
stdout 'Package quote collects pithy sayings.'

# Check that a sensible error message is printed when a package is not found.
env GOPROXY=off
! go doc example.com/hello
stderr '^doc: cannot find module providing package example.com/hello: module lookup disabled by GOPROXY=off$'

        return BaseComponentFixtures.create(publicType, implType, componentId)
    }

    def "library has name, path and sensible display name"() {
        when:
        def component = create(SampleComponent, MySampleComponent)

        then:
        component instanceof SampleComponent
        component.name == componentId.name

                .get()
        }

        then:
        env.java.javaHome
        env.java.jvmArguments.contains "-Xms13m"
        env.java.jvmArguments.contains "-Xmx333m"
    }

    def "uses sensible java defaults if nulls configured"() {
        when:
        BuildEnvironment env = withConnection {
            def model = it.model(BuildEnvironment.class)
            model
                .setJvmArguments(null)

                    builder.defaultImplementation(DefaultSampleBinary)
                }
            }

            apply plugin:MySamplePlugin
        """
    }

    def "produces sensible error when there are component binaries and all are not buildable" () {
        withLibBinaries("notBuildableBinary1", "notBuildableBinary2")
        withStandaloneBinaries("ignoreMe")

        when:
        fails "assemble"

func (op *PortAllocationOperation) AllocateNext() (int, error) {
	if op.dryRun {
		// Find the max element of the allocated ports array.
		// If no ports are already being allocated by this operation,
		// then choose a sensible guess for a dummy port number
		var lastPort int
		for _, allocatedPort := range op.allocated {
			if allocatedPort > lastPort {
				lastPort = allocatedPort
			}
		}
		if len(op.allocated) == 0 {