package org.gradle.tooling;

/**
 * Thrown when the client is trying to acquire a model that is unknown to the Tooling API.
 * <p>
 * The exception extends {@link UnsupportedVersionException} only for backwards compatibility reasons.
 *
 * @since 1.0-milestone-8
 */
public class UnknownModelException extends UnsupportedVersionException {

    public UnknownModelException(String message) {
        super(message);
    }

	model.ClusterUpdate:   pushTriggers.With(typeTag.Value(string(model.ClusterUpdate))),
}

func recordPushTriggers(reasons model.ReasonStats) {
	for r, cnt := range reasons {
		t, f := triggerMetric[r]
		if f {
			t.RecordInt(int64(cnt))
		} else {
			pushTriggers.With(typeTag.Value(string(r))).Increment()
		}
	}
}

                    out.text = tasks.compileDebugCpp.systemIncludes.join('\\n')
                }
            }
        """

        when:
        //TODO this fails in CI (for unknown reasons) with project access checks based on configuration barrier
        executer.withBuildJvmOpts("-Dorg.gradle.configuration-cache.internal.task-execution-access-pre-stable=true")
        succeeds("sysHeaders")

        then:

# limitations under the License.

set -o errexit
set -o nounset
set -o pipefail

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
source "${KUBE_ROOT}/hack/lib/init.sh"

# These are "internal" modules.  For various reasons, we want them to be
# decoupled from their parent modules.
MODULES=()                                                                                                                                                                   

import java.util.function.Consumer;

public interface ConfigurationsProvider {
    /**
     * Returns the number of configurations in this provider.
     * <p>
     * This method is provided for performance reasons. It should be more efficient to call this method
     * than to call {@link #visitAll(Consumer)} and then call {@link Set#size()} on the result.
     *

import org.apache.maven.plugin.MojoExecution;

/**
 * Assists in firing execution events. <strong>Warning:</strong> This is an internal utility interface that is only
 * public for technical reasons, it is not part of the public API. In particular, this interface can be changed or
 * deleted without prior notice.
 *
 */
public interface ExecutionEventCatapult {

            "$it.name=${attributes.getAttribute(it as Attribute<Object>)}"
        }.sort().join(',')
    }

    protected String formatReason(ComponentSelectionReasonInternal reason) {
        def reasons = reason.descriptions.collect {
            def message
            if (it.hasCustomDescription() && it.cause != ComponentSelectionCause.REQUESTED) {

     */
    String[] getImportPackages();

    /**
     * Returns a mapping from simple to qualified class name, derived from
     * the packages returned by {@link #getImportPackages()}. For historical reasons,
     * some simple name match multiple qualified names. In those cases the first match
     * should be used when resolving a name in the DSL.
     */
    Map<String, List<String>> getSimpleNameToFullClassNamesMapping();

     * the compile classpath and the runtime classpath, the version from the
     * compile classpath is going to be used.
     *
     * Unless you have a good reason to, this option should be preferred to
     * {@link #useRuntimeClasspathVersions()} for different reasons:
     *
     * <ul>
     *     <li>As code is compiled first against the given dependencies,
     *     it is expected that the versions at runtime would be the same.

import java.util.ArrayList;
import java.util.List;

/**
 * Provides metadata about a build extension. <strong>Warning:</strong> This is an internal utility class that is only
 * public for technical reasons, it is not part of the public API. In particular, this class can be changed or deleted
 * without prior notice.
 *
 */
public class ExtensionDescriptor {

    private List<String> exportedPackages;