cgoCallers    *cgoCallers   // cgo traceback if crashing in cgo call
	park          note
	alllink       *m // on allm
	schedlink     muintptr
	lockedg       guintptr
	createstack   [32]uintptr // stack that created this thread, it's used for StackRecord.Stack0, so it must align with it.
	lockedExt     uint32      // tracking for external LockOSThread

	for mp := first; mp != nil; mp = mp.alllink {
		n++
	}
	if n <= size {
		ok = true
		for mp := first; mp != nil; mp = mp.alllink {
			r := profilerecord.StackRecord{Stack: mp.createstack[:]}
			copyFn(r)
		}
	}
	return
}

//go:linkname pprof_threadCreateInternal
func pprof_threadCreateInternal(p []profilerecord.StackRecord) (n int, ok bool) {

        task.name == TEST_TASK_NAME
        (task as TaskInternal).taskIdentity == identity
    }

    def "dependsOn() works"() {
        given:
        def dependsOnTask = createTask(project, "somename")
        def task = createTask(project, TEST_TASK_NAME)
        project.getTasks().create("path1")
        project.getTasks().create("path2")

        when:
        task.dependsOn(Project.PATH_SEPARATOR + "path1")

    abstract DefaultTask getTask()

    def <T extends DefaultTask> T createTask(Class<T> type) {
        return createTask(type, project, TEST_TASK_NAME)
    }

    Task createTask(ProjectInternal project, String name) {
        return createTask(getTask().getClass(), project, name)
    }

    def <T extends DefaultTask> T createTask(Class<T> type, ProjectInternal project, String name) {

    }

    TestTask createTask(String name) {
        def task = TestUtil.create(temporaryFolder).createTask(TestTask, project, name)
        assertTrue(TestTask.isAssignableFrom(task.getClass()))
        return task
    }

    def "can add action to a task via Task.getActions() List"() {
        setup:
        def task = createTask("task")
        when:
        def actions = task.actions

    abstract DefaultTask getTask()

    def <T extends DefaultTask> T createTask(Class<T> type) {
        return createTask(type, project, TEST_TASK_NAME)
    }

    Task createTask(ProjectInternal project, String name) {
        return createTask(getTask().getClass(), project, name)
    }

    def <T extends DefaultTask> T createTask(Class<T> type, ProjectInternal project, String name) {

class ZipTest extends AbstractArchiveTaskTest {
    Zip zip

    def setup()  {
        zip = createTask(Zip)
        configure(zip)
    }

    @Override
    AbstractArchiveTask getArchiveTask() {
        zip
    }

    def "test Zip"() {
        given:
        zip = createTask(Zip)

        expect:
        zip.archiveExtension.get() == Zip.ZIP_EXTENSION
        checkConstructor()
    }

    }

    @Issue("GRADLE-3166")
    def "multiple should run after declarations are removed if causing circular reference"() {
        Task a = createTask("a")
        Task b = createTask("b")
        Task c = createTask("c")

        relationships(a, dependsOn: [c])
        relationships(b, dependsOn: [a, c])
        relationships(c, shouldRunAfter: [b, a])

        when:

 * limitations under the License.
 */

package org.gradle.api.tasks

class SyncTest extends AbstractCopyTaskContractTest {
    private Sync task

    def setup() {
        task = createTask(Sync)
    }

    @Override
    AbstractCopyTask getTask() {
        task
    }

        staticLib.linkFileProducer >> linkFileTasKProp
        staticLib.createTask >> createTaskProp

        given:
        project.pluginManager.apply(NativeBasePlugin)
        project.components.add(staticLib)

        expect:
        def createTask = project.tasks['createWindowsDebug']
        createTask instanceof CreateStaticLibrary
        createTask.binaryFile.get().asFile == projectDir.file("build/lib/windows/debug/test_lib.lib")