'project.javaexec'        | 'runWithJavaExec'
        'ExecOperations.javaexec' | 'runWithExecOperations'
        // The test does not work with the JavaExec task because the task resolves the executable prior to starting the process.
        // At the same time, all the cases test the same functionality of the ExecHandle implementation.
        // 'JavaExec task'           | 'run'
    }

import org.junit.jupiter.api.Test
import kotlin.test.assertEquals
import kotlin.test.assertIs


object AssignmentResolverTest {
    @Test
    fun `resolves transitive property`() {
        assignmentTrace(
            schema.resolve(
                """
                val myD = newD("shared")
                val c1 = c(1)
                c1.d = myD

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.results.VisitedGraphResults;
import org.gradle.api.internal.tasks.TaskDependencyResolveContext;

/**
 * Resolves a {@link ResolvedArtifactSet} into a {@link SelectedArtifactSet}.
 */
public class DefaultSelectedArtifactSet implements SelectedArtifactSet {
    private final VisitedGraphResults graphResults;

     */
    PotentialConflict registerCandidate(CANDIDATE candidate);

    /**
     * Informs whether there is any conflict at present
     */
    boolean hasConflicts();

    /**
     * Resolves next conflict and trigger provided action after the resolution
     */
    void resolveNextConflict(Action<RESULT> resolutionAction);

    /**
     * Indicates if the identifier is a known participant in a conflict

import org.gradle.test.preconditions.UnitTestPreconditions

@Requires(UnitTestPreconditions.Online)
class MavenCentralDependencyResolveIntegrationTest extends AbstractIntegrationSpec {
    def "resolves a minimal dependency from Maven Central"() {
        given:
        buildFile << """
repositories {
    mavenCentral()
    mavenCentral { // just test this syntax works.
        name = "otherCentral"

	// resource instance is suitable. The language is as defined in
	// https://kubernetes.io/docs/reference/using-api/cel/
	//
	// In addition, for each type NamedResourcesin AttributeValue there is a map that
	// resolves to the corresponding value of the instance under evaluation.
	// For example:
	//
	//    attributes.quantity["a"].isGreaterThan(quantity("0")) &&
	//    attributes.stringslice["b"].isSorted()

import java.io.File;
import java.nio.file.Path;

import org.apache.maven.api.di.Named;
import org.apache.maven.api.di.Singleton;
import org.apache.maven.api.services.model.*;

/**
 * Resolves relative paths against a specific base directory.
 *
 */
@Named
@Singleton
public class DefaultPathTranslator implements PathTranslator {

    @Override

import org.jetbrains.kotlin.fir.types.abbreviatedType
import org.jetbrains.kotlin.fir.types.toRegularClassSymbol

/**
 * Returns whether [subClass] is a strict subtype of [superClass]. Resolves [subClass] to [FirResolvePhase.SUPER_TYPES].
 */
fun isSubClassOf(subClass: FirClass, superClass: FirClass, useSiteSession: FirSession, allowIndirectSubtyping: Boolean = true): Boolean {

    def changes = Mock(ExecutionStateChanges)
    def optionalChanges = Optional.of(changes)
    def inputChanges = Mock(InputChangesInternal)
    def result = Mock(Result)


    def "resolves input changes when required"() {
        when:
        def returnedResult = step.execute(work, context)
        then:
        _ * work.executionBehavior >> UnitOfWork.ExecutionBehavior.INCREMENTAL

import org.gradle.plugin.management.internal.PluginRequests;

import javax.annotation.Nullable;

@ServiceScope(Scope.Build.class)
public interface PluginRequestApplicator {

    /**
     * Resolves the given {@link PluginRequests} into the given {@link ScriptHandlerInternal#getScriptClassPath()},
     * exports the resulting classpath into the given {@link ClassLoaderScope}, closes it and then applies
     * the requested plugins.