task buildInBuild(type:GradleBuild) {
                dir = 'other'
                startParameter.projectProperties['foo'] = true // not a String
            }
        """
        file('other/settings.gradle').createFile()
        file('other/build.gradle') << 'assert foo==true'

        when:
        run 'buildInBuild'

        then:
        noExceptionThrown()
    }

    def "can set build path"() {
        given:

          ${GITHUB_WORKSPACE}/.github/workflows/run-mint.sh "erasure" "minio" "minio123" "${{ steps.vars.outputs.sha_short }}"

      # FIXME: renable this back when we have a valid way to add deadlines for PUT()s (internode CreateFile)
      # - name: resiliency
      #   run: |
      #     ${GITHUB_WORKSPACE}/.github/workflows/run-mint.sh "resiliency" "minio" "minio123" "${{ steps.vars.outputs.sha_short }}"

      - name: The job must cleanup

        val ktPsiFactory = KtPsiFactory.contextual(mainFile, markGenerated = true, eventSystemEnabled = true)
        val fakeKtFile = ktPsiFactory.createFile("fake.kt", mainFile.text)

        if (mainModule.testModule.directives.contains(Directives.COPY_RESOLUTION_MODE)) {
            fakeKtFile.originalFile = mainFile
        }

 * limitations under the License.
 */

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Contains the Application plugin, and its supporting classes.  This plugin is used for creating runnable Java application projects."

dependencies {
    api(project(":core"))
    api(project(":core-api"))

    api(libs.inject)
    api(libs.jsr305)

    implementation(projects.stdlibJavaExtensions)

/**
 * An extension point to provide additional symbols for a KDoc reference. KDoc link resolution will use symbols returned by this EP
 * only if the real resolution was unsuccessful. You can use this EP by creating a class implementing this interface.
 * For example, let's assume that you want to return symbol `fun foo() = 3` for the following KDoc resolution:
 *
 * ```
 *   package com.example
 *   fun foo() = 3
 *   /**

		if err != nil {
			return fmt.Errorf("failed creating intermediate CA for cluster %s: %v", c.Name(), err)
		}

		// Create the CA secret for this cluster. Istio will use these certs for its CA rather
		// than its autogenerated self-signed root.
		secret, err := clusterCA.NewIstioCASecret()
		if err != nil {
			return fmt.Errorf("failed creating intermediate CA secret for cluster %s: %v", c.Name(), err)
		}

		return fmt.Errorf("error parsing profile: %w", err)
	}

	var out *os.File
	if outputFile == "" {
		out = os.Stdout
	} else {
		out, err = os.Create(outputFile)
		if err != nil {
			return fmt.Errorf("error creating output file: %w", err)
		}
		defer out.Close()
	}

	w := bufio.NewWriter(out)
	if _, err := d.WriteTo(w); err != nil {
		return fmt.Errorf("error writing output file: %w", err)
	}

	return nil
}

// license that can be found in the LICENSE file.

// Tests a G being created from within a syscall.
//
// Specifically, it tests a scenerio wherein a C
// thread is calling into Go, creating a goroutine in
// a syscall (in the tracer's model). Because the actual
// m can be reused, it's possible for that m to have never
// had its P (in _Psyscall) stolen if the runtime doesn't

			t.Errorf("Case %d: Got wrong result: %v", i, string(b))
		}
	}
}

func TestSameFile(t *testing.T) {
	f, err := os.CreateTemp("", "")
	if err != nil {
		t.Errorf("Error creating tmp file: %v", err)
	}
	tmpFile := f.Name()
	f.Close()
	defer os.Remove(f.Name())
	fi1, err := os.Stat(tmpFile)
	if err != nil {
		t.Fatalf("Error Stat(): %v", err)
	}
	fi2, err := os.Stat(tmpFile)

	// Create a file whose name contains unpaired surrogates.
	// Use syscall.CreateFile instead of os.Create to simulate a file that is created by
	// a non-Go program so the file name hasn't gone through syscall.UTF16FromString.
	dirw := utf16.Encode([]rune(dir))
	pathw := append(dirw, namew...)
	fd, err := syscall.CreateFile(&pathw[0], syscall.GENERIC_ALL, 0, nil, syscall.CREATE_NEW, 0, 0)
	if err != nil {
		t.Fatal(err)