broken := netpollBroken
	netpollBroken = true
	if !broken {
		notewakeup(&netpollNote)
	}
	unlock(&netpollBrokenLock)
}

// Polls for ready network connections.
// Returns list of goroutines that become runnable.
func netpoll(delay int64) (gList, int32) {
	// Implementation for platforms that do not support
	// integrated network poller.
	if delay != 0 {
		// This lock ensures that only one goroutine tries to use

package org.gradle.language.nativeplatform.internal;

import org.gradle.api.component.ComponentWithVariants;
import org.gradle.api.component.SoftwareComponent;
import org.gradle.api.provider.Provider;

/**
 * This should become public at some point.
 */
public interface PublicationAwareComponent extends SoftwareComponent {
    Provider<String> getBaseName();

    ComponentWithVariants getMainPublication();

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

// The escape analyzer needs to run till its root set settles
// (this is not that often, it turns out).
// This test is likely to become stale because the leak depends
// on a spurious-escape bug -- return an interface as a named
// output parameter appears to cause the called closure to escape,
// where returning it as a regular type does not.

package main

  }

  /**
   * Waits for the {@link ServiceManager} to become {@linkplain #isHealthy() healthy}. The manager
   * will become healthy after all the component services have reached the {@linkplain State#RUNNING
   * running} state.
   *
   * @throws IllegalStateException if the service manager reaches a state from which it cannot
   *     become {@linkplain #isHealthy() healthy}.
   */
  public void awaitHealthy() {

			roundTripped := spec.Schema{}
			if err := json.Unmarshal(data, &roundTripped); err != nil {
				t.Error(err)
				return
			}

			// Remove the embedded v2 schema if it presents.
			// The v2 schema either become the schema (when serving v2) or get pruned (v3)
			// and it is never round-tripped.
			delete(roundTripped.Extensions, common.ExtensionV2Schema)
			delete(value.Schema.Extensions, common.ExtensionV2Schema)

 * which is a performance optimization. <p>
 *
 * Upon an invocation of {@link InstrumentableClosure#makeEffectivelyInstrumented} the instance must perform
 * all the delayed work and become "effectively instrumented".
 *
 * @see CallInterceptionClosureInstrumentingClassVisitor
 */
@NonNullApi
public interface InstrumentableClosure {
    void makeEffectivelyInstrumented();

            ]
        }(constructor, new InterceptorTestReceiver())

        then:
        modifiedMetaClasses.every()
    }

    def 'closure does not erroneously become effectively instrumented after it threw an exception'() {
        given:
        def transformedThrowingClosure = instrumentedClasses.instrumentedClosure {
            throw new RuntimeException()
        }

		o := strings.Join(testdata.marker_to_output[m], "; ")
		e := strings.Join(testdata.marker_to_expected[m], "; ")
		if o != e {
			if o == i {
				t.Errorf("%s was unchanged; should have become %s", i, e)
			} else {
				t.Errorf("%s became %s; should have become %s", i, o, e)
			}
		} else if i != e {
			t.Logf("%s correctly became %s", i, o)
		}
	}

import org.gradle.nativeplatform.tasks.LinkSharedLibrary;
import org.gradle.nativeplatform.toolchain.internal.PlatformToolProvider;

/**
 * A configurable view of a component that produces a shared library. This should become public in some form.
 */
public interface ConfigurableComponentWithSharedLibrary extends ComponentWithSharedLibrary, ComponentWithObjectFiles, ComponentWithOutputs, ComponentWithNames {

dependencies {
    // The following dependencies will be the ear modules and
    // will be placed in the ear root
    deploy project(path: ':war', configuration: 'war')

    // The following dependencies will become ear libs and will
    // be placed in a dir configured via the libDirName property
    earlib group: 'log4j', name: 'log4j', version: '1.2.15', ext: 'jar'
}

tasks.named('ear') {