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

//go:build windows

// Package sysdll is an internal leaf package that records and reports
// which Windows DLL names are used by Go itself. These DLLs are then
// only loaded from the System32 directory. See Issue 14959.
package sysdll

// IsSystemDLL reports whether the named dll key (a base name, like
// "foo.dll") is a system DLL which should only be loaded from the
// Windows SYSTEM32 directory.

plugins {
    id('java')
    id('jacoco')
}

// Do not generate reports for individual projects
tasks.jacocoTestReport.configure {
    enabled = false
}

// Share sources folder with other projects for aggregated JaCoCo reports
configurations.create('transitiveSourcesElements') {
    visible = false
    canBeResolved = false
    extendsFrom(configurations.implementation)
    attributes {

        then:
        def ex = thrown IOException
        ex.message == "Unable to delete file '$target'"
        ex.suppressed.collect { it.message } == ["ROOT CAUSE"]
    }

    def "reports failed to delete child files and reports a reasonable number of retries after failure to delete directory"() {

        given:
        def targetDir = tmpDir.createDir("target")
        def deletable = targetDir.createFile("delete.yes")

            </thead>
            <tr>
                <td>reports</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>reports</td>
            </tr>
            <tr>

		}
		return fi < fj
	})
}

// ModIsValid reports whether vers is a valid version syntax for the module with the given path.
func ModIsValid(path, vers string) bool {
	if IsToolchain(path) {
		if path == "toolchain" {
			return IsValid(FromToolchain(vers))
		}
		return IsValid(vers)
	}
	return semver.IsValid(vers)
}

import org.gradle.integtests.fixtures.UnsupportedWithConfigurationCache


@UnsupportedWithConfigurationCache(because = "uses task event listener")
class TaskEventsErrorIntegrationTest extends AbstractIntegrationSpec {
    def "reports task as failed when beforeTask closure fails"() {
        when:
        buildFile << """
    gradle.taskGraph.beforeTask {
        throw new RuntimeException("beforeTask failure")
    }
    task test
"""

        assertHasNoProblems()
    }

    /**
     * Asserts that the cache entry was written with no problems.
     *
     * Also asserts that the appropriate console logging, reports and build operations are generated.
     */
    void assertStateStored(@DelegatesTo(StateStoreDetails) Closure closure = {}) {
        def details = new StateStoreDetails()
        closure.delegate = details
        closure()

		}
	}

	return false
}

// hasBasicType reports whether x's type is a types.Basic with the given kind.
func hasBasicType(info *types.Info, x ast.Expr, kind types.BasicKind) bool {
	t := info.Types[x].Type
	if t != nil {
		t = t.Underlying()
	}
	b, ok := t.(*types.Basic)
	return ok && b.Kind() == kind
}

// isReflectHeader reports whether t is reflect.SliceHeader or reflect.StringHeader.

        }
    }

    def "does not report transform progress events when TRANSFORM operations are not requested"() {
        given:
        withFileSizerTransform()

        when:
        runBuild("resolve", EnumSet.complementOf(EnumSet.of(OperationType.TRANSFORM)))

        then:
        events.operations.findAll { it.transform }.empty
    }

    def "reports dependencies of transform operations"() {

        buildFile << """
            task verifyTestResultConventions {
                def junitXmlOutputLocation = provider { ${testTaskName}.reports.junitXml.outputLocation }
                def htmlOutputLocation = provider { ${testTaskName}.reports.html.outputLocation }
                def binaryResultsDirectory = provider { ${testTaskName}.binaryResultsDirectory }
                def buildDir = layout.buildDirectory