* the compile classpath and the runtime classpath, the version from the
     * runtime classpath is going to be used.
     *
     * In addition, the test runtime classpath is going to be configured to
     * be consistent with the main runtime classpath.
     *
     * Prefer {@link #useCompileClasspathVersions()} unless you have special
     * requirements at runtime.
     */

	var wg sync.WaitGroup
	const nFast = 10

	t.Run("slow", func(t *testing.T) {
		t.Parallel()
		wg.Wait()
		for i := 0; i < nFast; i++ {
			// If the subtest goroutines are going to park on the channel
			// send, allow them to park now. If they're not going to park,
			// make sure they have had a chance to run to completion so
			// that they aren't spuriously parked when we panic.
			runtime.Gosched()
		}
		panic("slow failure")
	})

}
// end::declare-configuration[]

// tag::concrete-classpath[]
configurations {
    // declare a configuration that is going to resolve the compile classpath of the application
    compileClasspath.extendsFrom(someConfiguration)

    // declare a configuration that is going to resolve the runtime classpath of the application
    runtimeClasspath.extendsFrom(someConfiguration)
}
// end::concrete-classpath[]

}
// end::declare-configuration[]

// tag::concrete-classpath[]
configurations {
    // declare a configuration that is going to resolve the compile classpath of the application
    compileClasspath {
        extendsFrom(someConfiguration)
    }

    // declare a configuration that is going to resolve the runtime classpath of the application
    runtimeClasspath {
        extendsFrom(someConfiguration)
    }
}

	AlpnOverrideMetadataKey = "alpn_override"
)

// ALPNH2Only advertises that Proxy is going to use HTTP/2 when talking to the cluster.
var ALPNH2Only = pm.ALPNH2Only

// ALPNInMeshH2 advertises that Proxy is going to use HTTP/2 when talking to the in-mesh cluster.
// The custom "istio" value indicates in-mesh traffic and it's going to be used for routing decisions.

     * <p>
     * The job should not throw exceptions.
     * Any exceptions thrown are going to fail the build and may prevent the {@code buildFinished} callback from firing.
     * <p>
     * The build configuration inputs are not recorded for the job.
     * For example, changes to the environment variables read by the job are not going to invalidate the configuration cache.
     * The job is also allowed to freely start external processes.

# If an import declaration is an absolute path, most commands should report
# an error instead of going into an infinite loop.
# Verifies golang.org/issue/42891.
go list .
stdout '^m$'

-- go.mod --
module m

go 1.16
-- m.go --
package m

// Issue 20174: failure to typecheck contents of *T in the frontend.

package p

func f() {
	_ = (*interface{})(nil) // interface{} here used to not have its width calculated going into backend
	select {
	case _ = <-make(chan interface {
		M()
	}, 1):
	}

 * @param <RESULT> the result of executing the rule, which may be the same as the DETAILS, but will often be
 * a different type that the caller can use to reproduce the execution of the rule. This object is the one
 * that is going to be cached, and most likely the thing the caller really cares about
 */
public interface CachingRuleExecutor<KEY, DETAILS, RESULT> {
    /**

        ModuleComponentRepository<?> sourceRepository = findSourceRepository(component.getSources());
        // First try to determine the artifacts locally before going remote
        sourceRepository.getLocalAccess().resolveArtifactsWithType(component, artifactType, result);
        if (!result.hasResult()) {