*
     * This hackery is to prevent Jansi from creating a shared lib in a tmp dir which is deleted when
     * the Java process finishes. To avoid performance impacts caused by Jansi's default behavior the
     * library is proactively extracted into a known directory and reused by subsequent invocations.
     *
     * @param storageDir where to store the Jansi library
     */
    public void configure(File storageDir) {

        expect:
        10.times {
            println("Run $it")
            succeeds("clean", "assemble", "-Pcounter="+it)
        }
    }

    def "can recompile many times in a row with a reused compiler daemon"() {
        expect:
        10.times {
            println("Run $it")
            succeeds("clean", "assemble", "-Pcounter=0")
        }
    }

                    private final String projectName = getProject().getName();

                    @TaskAction
                    void printValue() {
                        // When ClassLoaders are reused
                        // the 1st run should print `<project name>.value = 1`
                        // the 2nd run should print `<project name>.value = 2`
                        // and so on.

     */
    boolean hasMutableState();

    /**
     * Creates a new container for a value that is calculated from the mutable state of this container, and then reused by multiple threads.
     */
    <S> CalculatedModelValue<S> newCalculatedValue(@Nullable S initialValue);

	"strings"
	"testing"
)

// Test_ServiceSpecRemovedFieldProtobufNumberReservation tests that the reserved protobuf field numbers
// for removed fields are not re-used. DO NOT remove this test for any reason, this ensures that tombstoned
// protobuf field numbers are not accidentally reused by other fields.
func Test_ServiceSpecRemovedFieldProtobufNumberReservation(t *testing.T) {
	obj := reflect.ValueOf(ServiceSpec{}).Type()

            problemsWithStackTraceCount = 0
        }
        outputContains("Configuration cache entry reused with 4 problems.")
    }

    def "configuration time problems are reported and fail the build by default only when configuration is executed invalidating the cache"() {
        given:

 */
public interface FileContentCacheFactory {
    /**
     * Creates or locates a cache. The contents of the cache are reused across builds, where possible.
     *
     * @param name An identifier for the cache, used to identify the cache across builds. All instances created using the same identifier will share the same backing store.

// Tests a G being created from within a syscall.
//
// Specifically, it tests a scenerio wherein a C
// thread is calling into Go, creating a goroutine in
// a syscall (in the tracer's model). Because the actual
// m can be reused, it's possible for that m to have never
// had its P (in _Psyscall) stolen if the runtime doesn't
// model the scenario correctly. Make sure we reject such
// traces.

package main

import (
	"internal/trace"

/**
 * A deeply immutable implementation of {@link CapabilitiesMetadata}.
 *
 * This type will ensure that all contents are immutable upon construction,
 * in order to allow instances of this type to be safely reused whenever possible
 * to avoid unnecessary memory allocations.
 *
 * Note that while this class is not itself {@code final}, all fields are private, so
 * subclassing should not break the immutability contract.
 */

import javax.annotation.concurrent.ThreadSafe;
import java.util.List;

/**
 * A specialized {@link ComponentGraphResolveState} for local components (ie project dependencies).
 *
 * <p>Instances of this type are cached and reused for multiple graph resolutions, possibly in parallel. This means that the implementation must be thread-safe.
 */
@ThreadSafe
public interface LocalComponentGraphResolveState extends ComponentGraphResolveState {