*/
package org.gradle.kotlin.dsl

import org.gradle.api.reflect.TypeOf


/**
 * Creates an instance of [TypeOf] for the given parameterized type.
 *
 * @param T the type
 * @return the [TypeOf] that captures the generic type of the given parameterized type
 */
inline fun <reified T> typeOf(): TypeOf<T> =

        <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.

import static com.google.common.base.Preconditions.checkArgument;

import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import javax.annotation.CheckForNull;

/**
 * Captures a free type variable that can be used in {@link TypeToken#where}. For example:
 *
 * <pre>{@code
 * static <T> TypeToken<List<T>> listOf(Class<T> elementType) {
 *   return new TypeToken<List<T>>() {}

            assertNotOutput("STDERR from plugins block")
            // TODO logging is not captured yet
            assertOutputContains("LIFECYCLE")
            assertOutputContains("WARN")
            assertHasErrorOutput("ERROR")
        }
    }

    @Test
    @Issue("https://github.com/gradle/gradle/issues/12955")
    fun `captures output of schema collection but not of concurrent tasks`() {

        val repeatOutput = 50

package org.gradle.internal.execution.history;

import com.google.common.collect.ImmutableSortedMap;
import org.gradle.internal.fingerprint.CurrentFileCollectionFingerprint;
import org.gradle.internal.hash.HashCode;

/**
 * Captures the state of a {@link org.gradle.internal.execution.UnitOfWork} after it has been executed.
 *
 * Execution here might also mean being up-to-date or loaded from cache.
 */

type Event int

const (
	// EventAdd is sent when an object is added
	EventAdd Event = iota

	// EventUpdate is sent when an object is modified
	// Captures the modified object
	EventUpdate

	// EventDelete is sent when an object is deleted
	// Captures the object at the last known state
	EventDelete
)

func (event Event) String() string {
	out := "unknown"
	switch event {
	case EventAdd:

                reports.junitXml.outputPerTestCase = true
                onOutput { test, event -> print "\$test -> \$event.message" }
            }
        """
    }

    @Issue("GRADLE-2841")
    def "captures output from logging frameworks"() {
        buildFile << """
            dependencies { implementation "org.slf4j:slf4j-simple:1.7.10", "org.slf4j:slf4j-api:1.7.10" }
"""
        file("src/test/java/FooTest.java") << """

import org.gradle.internal.fingerprint.FileCollectionFingerprint;
import org.gradle.internal.snapshot.ValueSnapshot;
import org.gradle.internal.snapshot.impl.ImplementationSnapshot;

/**
 * Captures the state of the inputs of a {@link org.gradle.internal.execution.UnitOfWork}.
 */
public interface ExecutionInputState {
    /**
     * The main implementation snapshots.
     */

	"sync/atomic"
	"time"
)

const (
	// betaBucket is the weight used to calculate exponential moving average
	betaBucket = 0.1 // Number of averages considered = 1/(1-betaObject)
)

// bucketMeasurement captures the bandwidth details for one bucket
type bucketMeasurement struct {
	lock                 sync.Mutex
	bytesSinceLastWindow uint64    // Total bytes since last window was processed

 */
package org.gradle.vcs;

import org.gradle.api.Action;
import org.gradle.api.Describable;
import org.gradle.api.initialization.definition.InjectedPluginDependencies;

/**
 * Captures user-provided information about a version control repository.
 *
 * @since 4.4
 */
public interface VersionControlSpec extends Describable {
    /**