}
    final CyclicBarrier barrier =
        new CyclicBarrier(
            6 // for the setter threads
                + 50 // for the listeners
                + 50 // for the blocking get threads,
                + 1); // for the main thread
    final ExecutorService executor = Executors.newFixedThreadPool(barrier.getParties());

 *
 * <p>The {@code ProjectBuilder} implementation bundled with Gradle 3.0 and 3.1 suffers from a
 * binary compatibility issue exposed by applying plugins compiled with Gradle 2.7 and earlier.
 * Applying those pre-compiled plugins in a ProjectBuilder context will result in a {@link ClassNotFoundException}.</p>
 */
public class ProjectBuilder {

    private File projectDir;
    private File gradleUserHomeDir;

 * limitations under the License.
 */

package org.gradle.test.fixtures.server.http;

import java.time.Duration;
import java.util.Collection;
import java.util.concurrent.locks.Lock;

/**
 * A cyclic barrier for {@link BlockingHttpServer} where expectations are optional.
 */
class MaybeNConcurrentRequests extends ExpectMaxNConcurrentRequests {

        // We have to add these after the system properties so they can override any system properties
        // (identical properties later in the command line override earlier ones)

        return ImmutableList.<String>builder()
            .addAll(args)
            .addAll(getAllImmutableJvmArgs())
            .build();
    }

        return new IllegalStateException(String.format(
            "Received invalid response from the daemon: '%s' is a result of a type we don't have a strategy to handle. "
                + "Earlier, '%s' request was sent to the daemon. Diagnostics:\n%s", response, command, diagnosticsMessage));
    }

        }

        private static String buildDisabledRepositoryErrorMessage(String repositoryName) {
            return String.format("Repository %s is disabled due to earlier error below:", repositoryName);
        }

        private <E extends Throwable, R extends ErroringResolveResult<E>> void performOperationWithRetries(R result,

            // TODO: This is very suspicious. We should always fail here.
            // `strict` was added because file dependencies' components are never included in the graph.
            // We should detect this earlier and return no dependencies there to avoid `strict`.
            if (strict) {
                throw new AssertionError("Could not find component " + componentIdentifier + " in provided results.");
            } else {

      }

      message += "delay)";
    }
    // It's confusing to see a completed future in a timeout message; if isDone() returns false,
    // then we know it must have given a pending toString value earlier. If not, then the future
    // completed after the timeout expired, and the message might be success.
    if (isDone()) {
      throw new TimeoutException(message + " but future completed as timeout expired");
    }

      }

      message += "delay)";
    }
    // It's confusing to see a completed future in a timeout message; if isDone() returns false,
    // then we know it must have given a pending toString value earlier. If not, then the future
    // completed after the timeout expired, and the message might be success.
    if (isDone()) {
      throw new TimeoutException(message + " but future completed as timeout expired");
    }

   *
   * <p>When the underlying delegate throws an exception then this memoizing supplier will keep
   * delegating calls until it returns valid data.
   *
   * <p>If {@code delegate} is an instance created by an earlier call to {@code memoize}, it is
   * returned directly.
   */
  public static <T extends @Nullable Object> Supplier<T> memoize(Supplier<T> delegate) {
    if (delegate instanceof NonSerializableMemoizingSupplier