// Because the registers are msan-undefined, the signal handler will
// be invoked with all registers msan-undefined.
__attribute__((noinline))
void msanGoWait(unsigned long a1, unsigned long a2, unsigned long a3, unsigned long a4, unsigned long a5, unsigned long a6) {
	sigset_t mask;

	sigemptyset(&mask);
        sigsuspend(&mask);
}

// msanGoSignalThread is the thread ID of the msanGoLoop thread.

    }

    @Override
    public void stop() {
        cache.close();
    }

    @Override
    public void setLastAccessTime(File file, long millis) {
        store.put(file, millis);
    }

    @Override
    public long getLastAccessTime(File file) {
        Long value = store.getIfPresent(file);
        if (value == null) {
            return Math.max(inceptionTimestamp, file.lastModified());
        }

        start(description: description)
    }

    ProgressStartEvent start(Long id) {
        start(id: id)
    }

    ProgressStartEvent start(Long id, String status) {
        start(id: id, status: status)
    }

    ProgressStartEvent start(Map args) {
        Long parentId = args.containsKey("parentId") ? args.parentId : null

public class GarbageCollectionEvent {
    private final long timestamp;
    private final MemoryUsage usage;
    private final long count;

    public GarbageCollectionEvent(long timestamp, MemoryUsage usage, long count) {
        this.timestamp = timestamp;
        this.usage = usage;
        this.count = count;
    }

    public long getTimestamp() {
        return timestamp;
    }

public class JvmMemoryStatusSnapshot implements JvmMemoryStatus {
    private final long maximumMemory;
    private final long committedMemory;

    public JvmMemoryStatusSnapshot(long maximumMemory, long commitedMemory) {
        this.maximumMemory = maximumMemory;
        this.committedMemory = commitedMemory;
    }

    @Override
    public long getMaxMemory() {
        return maximumMemory;
    }

    @Override

        ruleValidator.validate(Stub(RuleAction) {
            getInputTypes() >> { [ Long ] }
        })

        then:
        def failure = thrown(RuleActionValidationException)
        failure.message == "Rule may not have an input parameter of type: java.lang.Long. Second parameter must be of type: java.lang.Integer."
    }

    def "rejects invalid type when no type configured" () {

  }

  data class ConnectionClosed(
    override val timestampNs: Long,
    override val connection: Connection,
  ) : ConnectionEvent()

  data class ConnectionAcquired(
    override val timestampNs: Long,
    override val connection: Connection,
    val call: Call,
  ) : ConnectionEvent()

  data class ConnectionReleased(
    override val timestampNs: Long,
    override val connection: Connection,
    val call: Call,

    private final Long selected;
    private final ComponentSelectionReason reason;
    private final ModuleVersionResolveException failure;
    private final boolean constraint;
    private final Long fromVariant;
    private final Long targetVariant;

    public DetachedResolvedGraphDependency(ComponentSelector requested,
                                           Long selected,

            }
        });
        return hasOutput[0];
    }

    @Override
    public boolean hasOutput(long classId, long testId, TestOutputEvent.Destination destination) {
        return false;
    }

    @Override
    public void writeAllOutput(final long classId, final TestOutputEvent.Destination destination, final Writer writer) {
        withReader(new Action<TestOutputStore.Reader>() {

    private final long startTime;
    private final long endTime;
    private final String skipMessage;

    public DefaultTaskSkippedResult(long startTime, long endTime, String skipMessage) {
        this.startTime = startTime;
        this.endTime = endTime;
        this.skipMessage = skipMessage;
    }

    @Override
    public long getStartTime() {
        return startTime;
    }