*/

package org.jetbrains.kotlin.analysis.api.symbols.pointers

import org.jetbrains.kotlin.analysis.api.KaSession
import org.jetbrains.kotlin.analysis.api.symbols.KaSymbol
import org.jetbrains.kotlin.analysis.utils.relfection.renderAsDataClassToString

/**
 * [KaSymbol] is valid only during read action it was created in
 * To pass the symbol from one read action to another the KtSymbolPointer should be used
 *
 * We can restore the symbol

    boolean resolveGraphToDetermineTaskDependencies();

    SortOrder getSortOrder();

    @Override
    DependencySubstitutionsInternal getDependencySubstitution();

    /**
     * @return the version selection rules object
     */
    @Override
    ComponentSelectionRulesInternal getComponentSelection();

    /**

        outputContains("1: a")
        outputContains("2: b")
        outputContains("3: c")
        outputContains("Enter selection (default: b) [1..3] ")
        outputContains("result = a")

        where:
        richConsole << VALID_BOOLEAN_CHOICES
    }

    def "use of ctrl-d when selection option returns default option [rich console: #richConsole]"() {
        given:
        withRichConsole(richConsole)

 *          Anything that changes must be in a val with a get() method that recomputes the value each time.
 */
object BuildEnvironment {

    /**
     * A selection of environment variables injected into the environment by the `codeql-env.sh` script.
     */
    private
    val CODEQL_ENVIRONMENT_VARIABLES = arrayOf(
        "CODEQL_JAVA_HOME",

	return &model.WorkloadAuthorization{
		Authorization: &security.Authorization{
			Name:      implicitWaypointPolicyName(&waypoint),
			Namespace: waypoint.Namespace,
			// note: we don't actually use label selection; the names have an internally well-known format
			// workload generation will append a reference to this
			Scope:  security.Scope_WORKLOAD_SELECTOR,
			Action: security.Action_ALLOW,
			Groups: []*security.Group{{

     * This means:
     * * Rescheduling any deferred selection impacted by a constraint coming from this node
     * * Making sure we no longer are registered as pending interest on nodes pointed by constraints
     */
    private void cleanupConstraints() {
        // This part covers constraint that were taken into account between a selection being deferred and this node being scheduled for traversal

 *
 * <ul>
 *   <li>SafeAtomicHelper: uses AtomicReferenceFieldsUpdaters to implement synchronization
 *   <li>SynchronizedHelper: uses {@code synchronized} blocks for synchronization
 * </ul>
 *
 * To force selection of our fallback strategies we load {@link AbstractFuture} (and all of {@code
 * com.google.common.util.concurrent}) in degenerate class loaders which make certain platform

                }
            }
        """

        then:
        createdTasksFor("t1") == [":t1"]
    }

    @UnsupportedWithConfigurationCache
    def "task container is self closed by task selection and can be later graph closed"() {
        when:
        buildFile << '''
            import org.gradle.model.internal.core.*

            model {
                tasks {
                    create("t1")

     *
     * Use attribute matching to choose a single variant when the target component has variants,
     * otherwise revert to legacy selection of target configurations.
     */
    @Override

                getArtifacts()
            );
            return new GraphVariantSelectionResult(Collections.singletonList(selected), true);
        }

        // Fallback to legacy variant selection for target components that don't support attribute matching.
        VariantGraphResolveState selected = variantSelector.selectLegacyVariant(consumerAttributes, targetComponentState, consumerSchema, variantSelector.getFailureHandler());