output.replaceAll("(?x)" +
            "# Captures first half of the table\n" +
            "(\\s+\\|\\s+org\\.gradle\\.jvm\\.version\\s+\\|\\s+\\|\\s+)" +
            "# Decides between a single digit + spacing (e.g. '8 '), or two digits (e.g. 17)\n" +
            "# This is the value being replaced.\n" +
            "(?:\\d\\s|\\d{2})" +
            "# Capture the tail end of the table\n" +
            "(\\s+\\|)",

        <span class="badge-text">How to Use Build Scans&nbsp;&nbsp;&nbsp;&gt;</span>
    </a>
</div>
++++

A build scan is a *representation of metadata captured* as you run your build.

image::gradle-basic-1.png[]

== Build Scans
Gradle captures your build metadata and sends it to the link:https://scans.gradle.com/[Build Scan Service].
The service then transforms the metadata into information you can analyze and share with others.

        val signature = value.implMethodSignature
        val paramTypes: Array<Type> = getArgumentTypes(signature)

        // Treat all parameters equally, regardless of whether they are implicit captured parameters or the lambda signature ones.
        // If any of them is of an unsupported type, a build that runs from the serialized state won't be able to provide an instance anyway.
        paramTypes.forEach { paramType ->

			CNIMode:          cfg.CNIMode,
			NetworkNamespace: cfg.NetworkNamespace,
		}
	}

	iptConfigurator := capture.NewIptablesConfigurator(cfg, ext)

	if !cfg.SkipRuleApply {
		if err := iptConfigurator.Run(); err != nil {
			return err
		}
		if err := capture.ConfigureRoutes(cfg); err != nil {
			return fmt.Errorf("failed to configure routes: %v", err)
		}
	}
	return nil

import org.gradle.internal.operations.BuildOperationType
import org.gradle.internal.operations.trace.BuildOperationRecord
import org.gradle.jvm.toolchain.internal.operations.JavaToolchainUsageProgressDetails

/**
 * Captures build operations and allows to make assertions about events related to Java Toolchains.
 * <p>
 * When using this fixture make sure to first call {@link JavaToolchainBuildOperationsFixture#captureBuildOperations captureBuildOperations}

        }

        /**
         * The cache key.
         */
        public BuildCacheKey getKey() {
            return key;
        }

        /**
         * The captured state of the work's inputs.
         */
        public BeforeExecutionState getBeforeExecutionState() {
            return beforeExecutionState;
        }
    }

    /**

    @BeforeEach
    fun setUp() {
        val stepsCapturer = slot<BuildSteps.() -> Unit>()
        every { buildType.steps } returns steps
        every {
            buildType.steps(capture(stepsCapturer))
        } answers {
            stepsCapturer.captured(steps)
            mockk()
        }
    }

    @Test
    fun `can apply defaults to configurations`() {
        applyDefaults(buildModel, buildType, "myTask")

	// 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 {

 *
 * 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";

}

// Stat captures time taken to call os.Stat
func Stat(name string) (info os.FileInfo, err error) {
	defer updateOSMetrics(osMetricStat, name)(err)
	return os.Stat(name)
}

// Create captures time taken to call os.Create
func Create(name string) (f *os.File, err error) {
	defer updateOSMetrics(osMetricCreate, name)(err)
	return os.Create(name)
}

// Fdatasync captures time taken to call Fdatasync