}
"""
        expect:
        def block1 = blockingServer.expectAndBlock("block1")
        def block2 = blockingServer.expectAndBlock("block2")

        // Build 1 should download module 1 and check whether it can reuse module 2 files
        mod1.pom.expectGet()
        mod1.artifact.expectGet()
        if (previous.version <= GradleVersion.version("1.8")) {
            mod2.pom.expectGet()
            mod2.artifact.expectGet()

        // TODO:REUSE Refactor after removing reuse
        // This is horrendously bad.
        // We need to set the platform, _before_ the @Defaults rules of NativeBinaryRules assign the toolchain.
        // We can't just assign the toolchain here because the initializer would be closing over the toolchain which is not reusable, and this breaks model reuse.

package org.gradle.internal.resource;

import org.gradle.api.Describable;

/**
 * Represents some resource that may have content.
 *
 * <p>This type is currently pretty much empty. It's here as a place to extract and reuse stuff from the various subtypes, which all stared off as separate hierarchies.
 */
public interface Resource extends Describable {
    /**

package org.gradle.internal.execution;

import org.gradle.internal.execution.workspace.MutableWorkspaceProvider;

/**
 * A unit of work that can be executed multiple times in the same workspace.
 * Such work can reuse outputs from a previous execution.
 */
public interface MutableUnitOfWork extends UnitOfWork {
    /**
     * Returns the {@link MutableWorkspaceProvider} to allocate a workspace to execution this work in.
     */

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

/** Reuse a connection from the pool. */
internal class ReusePlan(
  val connection: RealConnection,
) : RoutePlanner.Plan {
  override val isReady = true

  override fun connectTcp() = error("already connected")

import com.google.common.base.Objects;

/**
 * This abstract class provide a sensible default implementation for {@code Serializer} equality. This equality
 * implementation is required to enable cache instance reuse within the same Gradle runtime. Serializers are used
 * as cache parameter which need to be compared to determine compatible cache.
 */
public abstract class AbstractSerializer<T> implements Serializer<T> {
    @Override

[[share_results_between_ci_builds]]
== Share results between CI builds

)

// TestMain defines the entrypoint for pilot tests using a standard Istio installation.
// If a test requires a custom install it should go into its own package, otherwise it should go
// here to reuse a single install across tests.
func TestMain(m *testing.M) {
	framework.
		NewSuite(m).
		Setup(istio.Setup(nil, func(_ resource.Context, cfg *istio.Config) {
			cfg.ControlPlaneValues = `
values:
  pilot:
    env:

import java.util.UUID;

public class ClassLoaderDetails implements Serializable {
    // TODO:ADAM - using a UUID means we create a ClassLoader hierarchy for each daemon process we talk to. Instead, use the spec to decide whether to reuse a ClassLoader
    public final UUID uuid;
    public final ClassLoaderSpec spec;
    public final List<ClassLoaderDetails> parents = new ArrayList<ClassLoaderDetails>();

	addr = __builtin_frame_address(0) + 4096 - size;
#endif
	pthread_attr_destroy(&attr);

	// bounds points into the Go stack. TSAN can't see the synchronization
	// in Go around stack reuse.
	_cgo_tsan_acquire();
	bounds[0] = (uintptr)addr;
	bounds[1] = (uintptr)addr + size;
	_cgo_tsan_release();