}

    /**
     * Fixture for capturing simple test class requirements.  Note that this class should be used only for simple test classes
     * and should not be enhanced to capture complex test classes with arbitrary features.  Complex test classes should be captured
     * with a raw {@link TestSource} fixture.
     */
    class TestClass {
        final String name
        final String packageName
        final String sourceSet

	// value at pcBuf[0] represents a skip value to apply to the physical stack in
	// pcBuf[1:] after inline expansion.
	logicalStackSentinel = ^uintptr(0)
)

// traceStack captures a stack trace from a goroutine and registers it in the trace
// stack table. It then returns its unique ID. If gp == nil, then traceStack will
// attempt to use the current execution context.
//

	// Lookup DNS nameservers. We only do this if DNS is enabled in case of some obscure theoretical
	// case where reading /etc/resolv.conf could fail.
	// If capture all DNS option is enabled, we don't need to read from the dns resolve conf. All
	// traffic to port 53 will be captured.
	if c.RedirectDNS && !c.CaptureAllDNS {
		dnsConfig, err := dns.ClientConfigFromFile("/etc/resolv.conf")
		if err != nil {

====
<1> `doLast` action captures the references from the enclosing scope. These captured references are also serialized to the configuration cache.
<2> Compare the reference to an object of user-defined class stored in the task field and the reference captured in the `doLast` action.
<3> Compare the reference to `ArrayList` instance stored in the task field and the reference captured in the `doLast` action.

            .where(
                new TypeCapture<Iterable<Map<?, V>>>() {}.capture(),
                new TypeCapture<Iterable<Map<String, Integer>>>() {}.capture());
    assertEquals(
        new TypeCapture<K>() {}.capture(), resolver.resolveType(new TypeCapture<K>() {}.capture()));
    assertEquals(Integer.class, resolver.resolveType(new TypeCapture<V>() {}.capture()));
  }

  public <T> void testWhere_mapFromWildcard() {

 *
 * result.groupedOutput.task(":compileJava")
 *     .assertOutputContains("Compiling with toolchain")
 * </pre>
 */
public class GroupedOutputFixture {
    /**
     * All tasks will start with > Task, captures everything starting with : and going until end of line
     */
    private final static String TASK_HEADER = "> Task (:[\\w:]*) ?(FAILED|FROM-CACHE|UP-TO-DATE|SKIPPED|NO-SOURCE)?\\n";

     *
     * @param type the {@literal Class}
     * @param <T> the parameterized type of the given {@literal Class}
     * @return the {@literal TypeOf} that captures the generic type of the given {@literal Class}
     */
    public static <T> TypeOf<T> typeOf(Class<T> type) {
        return new TypeOf<T>(
            ModelType.of(typeWhichCannotBeNull(type))) {
        };
    }

// end::use-println[]

// tag::capture-stdout[]
logging.captureStandardOutput LogLevel.INFO
println 'A message which is logged at INFO level'
// end::capture-stdout[]

// tag::task-capture-stdout[]
tasks.register('logInfo') {
    logging.captureStandardOutput LogLevel.INFO
    doFirst {
        println 'A task message which is logged at INFO level'
    }
}
// end::task-capture-stdout[]

// tag::use-slf4j[]

    [SingleBlockImplicitTerminator<"ReturnOp">]> {
  let summary = [{
The `tf_device.launch` op launches containing operations on target device.
  }];

  let description = [{
This op captures all needed live-in values.
  }];

  let arguments = (ins
    StrAttr:$device
  );

  let results = (outs
    Variadic<AnyType>:$results
  );

  let regions = (region SizedRegion<1>:$body);

        run("log")
        def captured = file("output.txt").text

        then:
        captured.contains("[DEBUG] [org.gradle.api.Task] debug")
        captured.contains("[INFO] [org.gradle.api.Task] info")
        captured.contains("[LIFECYCLE] [org.gradle.api.Task] lifecycle")
        captured.contains("[WARN] [org.gradle.api.Task] warn")
        captured.contains("[ERROR] [org.gradle.api.Task] error")