return &CRIRuntime{
		impl:      &defaultImpl{},
		criSocket: criSocket,
	}
}

// SetImpl can be used to set the internal implementation for testing purposes.
func (runtime *CRIRuntime) SetImpl(impl impl) {
	runtime.impl = impl
}

// Connect establishes a connection with the CRI runtime.
func (runtime *CRIRuntime) Connect() error {

import org.eclipse.aether.impl.ArtifactResolver;
import org.eclipse.aether.impl.DependencyCollector;
import org.eclipse.aether.impl.Deployer;
import org.eclipse.aether.impl.Installer;
import org.eclipse.aether.impl.LocalRepositoryProvider;
import org.eclipse.aether.impl.MetadataGeneratorFactory;
import org.eclipse.aether.impl.MetadataResolver;
import org.eclipse.aether.impl.OfflineController;

        // Classpath
        def classpath = classpath
        classpath.assertHasLibs('lib2-impl-2.0.jar', 'lib1-impl-1.0.jar', 'lib1-api-1.0.jar')
        classpath.lib('lib1-api-1.0.jar').assertIsDeployedTo('/lib')
        classpath.lib('lib1-impl-1.0.jar').assertIsDeployedTo('/lib')
        classpath.lib('lib2-impl-2.0.jar').assertIsDeployedTo('/')

        // Facets
        def facets = wtpFacets

  };

TF_ENUM_VALUE_OF(impl::Capsule, CAPSULE);
TF_ENUM_VALUE_OF(impl::Float32, FLOAT32);
TF_ENUM_VALUE_OF(impl::Int64, INT64);
TF_ENUM_VALUE_OF(impl::List, LIST);
TF_ENUM_VALUE_OF(impl::ListPtr, LIST);
TF_ENUM_VALUE_OF(impl::Tuple, TUPLE);
TF_ENUM_VALUE_OF(impl::TuplePtr, TUPLE);
TF_ENUM_VALUE_OF(impl::Dict, DICT);
TF_ENUM_VALUE_OF(impl::DictPtr, DICT);
TF_ENUM_VALUE_OF(impl::None, NONE);

 */

package org.gradle.internal.cc.impl.inputs.process

import org.gradle.internal.cc.impl.fixtures.ExternalProcessFixture.Snippets
import org.gradle.internal.cc.impl.fixtures.ExternalProcessFixture.SnippetsFactory
import org.gradle.internal.cc.impl.fixtures.TransformFixture
import org.gradle.process.ExecOperations

import javax.inject.Inject

import static org.gradle.internal.cc.impl.fixtures.ExternalProcessFixture.exec

// Matches a node with a boolean typed attribute named `name` and with value
// `value`.
template <typename ValueTy>
impl::NodeMatcherProperties Attr(const string& name, ValueTy value) {
  return impl::Attr({impl::AttrLiteralHelper({name, value})});
}

inline impl::NodeMatcherProperties Attr(const string& name) {
  return impl::Attr(name);
}

// Matches a node with inputs `inputs`.
//

                }""",
        ]

        impl.snapshot { run("impl:${language.compileTaskName}") }

        when:
        source api: ["class A { public static final int EVIL = 0; void blah() { /* avoid flakiness by changing compiled file length*/ } }"]
        run("impl:${language.compileTaskName}")

        then:
        impl.recompiledClasses('B', 'C', 'C$Inner', 'D', 'D$Inner', 'E', 'E$1', 'F', 'F$Inner')

    def "resolving project dependency triggers configuration of the target project"() {
        createDirs("impl")
        settingsFile << "include 'impl'"
        buildFile << """
            apply plugin: 'java'
            dependencies {
                implementation project(":impl")
            }
            repositories {
                //resolving project must declare the repo

	RemoveCheckpoint(checkpointKey string) error
	// ListCheckpoint returns the list of existing checkpoints.
	ListCheckpoints() ([]string, error)
}

// impl is an implementation of CheckpointManager. It persists checkpoint in CheckpointStore
type impl struct {
	path  string
	store utilstore.Store
	mutex sync.Mutex
}

// NewCheckpointManager returns a new instance of a checkpoint manager

        mavenRepo.module("org.utils", "impl", '1.5').dependsOn('org.utils', 'api', '1.5').publish()
        createDirs("impl", "test")
        settingsFile << 'include "impl", "test"'

        buildFile << """
            $common

            project(":test") {
                dependencies {
                    conf (group: "org.utils", name: "impl", version: "1.5") { transitive = false }
                }