import org.w3c.dom.Element
import gradlebuild.docs.dsl.source.model.TypeMetaData

class BlockDoc implements DslElementDoc {
    private final MethodDoc blockMethod
    private final PropertyDoc blockProperty
    private final TypeMetaData type
    private boolean multiValued

    BlockDoc(MethodDoc blockMethod, PropertyDoc blockProperty, TypeMetaData type, boolean multiValued) {
        this.blockMethod = blockMethod

    // after some period of time the runner thread should become blocked on the task because it is
    // waiting for the slow interrupting thread to complete Thread.interrupt
    awaitBlockedOnInstanceOf(runner, InterruptibleTask.Blocker.class);

    Blocker blocker = (Blocker) LockSupport.getBlocker(runner);
    Thread owner = blocker.getOwner();
    assertThat(owner).isSameInstanceAs(interrupter);

    // after some period of time the runner thread should become blocked on the task because it is
    // waiting for the slow interrupting thread to complete Thread.interrupt
    awaitBlockedOnInstanceOf(runner, InterruptibleTask.Blocker.class);

    Blocker blocker = (Blocker) LockSupport.getBlocker(runner);
    Thread owner = blocker.getOwner();
    assertThat(owner).isSameInstanceAs(interrupter);

        this.listener = listener;
    }

    public void renderTo(BlockDoc blockDoc, Element parent) {
        Document document = parent.getOwnerDocument();

        Element section = document.createElement("section");
        parent.appendChild(section);
        section.setAttribute("id", blockDoc.getId());
        section.setAttribute("role", "detail");

            td.appendChild(link);
            link.setAttribute("linkend", blockDoc.getId());
            Element literal = document.createElement("literal");
            link.appendChild(literal);
            literal.appendChild(document.createTextNode(blockDoc.getName()));

            td = document.createElement("td");
            tr.appendChild(td);
            if (blockDoc.isDeprecated()) {

            for (BlockDoc blockDoc : classDoc.getClassBlocks()) {
                blockDetailRenderer.renderTo(blockDoc, detailsSection);
            }
            for (ClassExtensionDoc extensionDoc : classDoc.getClassExtensions()) {
                for (BlockDoc blockDoc : extensionDoc.getExtensionBlocks()) {
                    blockDetailRenderer.renderTo(blockDoc, detailsSection);
                }
            }

    void addClassMethod(MethodDoc methodDoc) {
        classMethods.add(methodDoc.forClass(this))
    }

    Collection<BlockDoc> getClassBlocks() { return classBlocks }

    void addClassBlock(BlockDoc blockDoc) {
        classBlocks.add(blockDoc.forClass(this))
    }

    Collection<ClassExtensionDoc> getClassExtensions() { return classExtensions }

*/
import "C"
import (
	"os"
	"os/signal"
	"syscall"
	"testing"
)

var blocked bool

//export IntoGoAndBack
func IntoGoAndBack() {
	// Verify that SIGIO stays blocked on the C thread
	// even when unblocked for signal.Notify().
	signal.Notify(make(chan os.Signal), syscall.SIGIO)
	blocked = C.CheckBlocked() != 0
}

func testSigprocmask(t *testing.T) {
	if r := C.RunSigThread(); r != 0 {

                methods << method.forClass(targetClass)
            }
        }
        return methods.sort { it.metaData.overrideSignature }
    }

    List<BlockDoc> getExtensionBlocks() {
        List<BlockDoc> blocks = []
        mixinClasses.each { mixin ->
            mixin.classBlocks.each { block ->
                blocks << block.forClass(targetClass)
            }
        }

		gp.m.blocked = true
		if *cgo_yield != nil && ns > 10e6 {
			ns = 10e6
		}
		if semasleep(ns) >= 0 {
			gp.m.blocked = false
			// Acquired semaphore, semawakeup unregistered us.
			// Done.
			return true
		}
		if *cgo_yield != nil {
			asmcgocall(*cgo_yield, nil)
		}
		gp.m.blocked = false
		// Interrupted or timed out. Still registered. Semaphore not acquired.
		ns = deadline - nanotime()