def "default JVM is the current process JVM"() {
        def currentProcess = new CurrentProcess(Mock(FileCollectionFactory))
        expect:
        currentProcess.jvm == Jvm.current()
    }

    def "agent arguments are ignored"() {
        def options = inferJvmOptions(Mock(FileCollectionFactory), ['-Xmx1g', '-javaagent:foo.jar', '-javaagent:' + AgentUtils.AGENT_MODULE_NAME + '.jar'])
        expect:

 */

package org.jetbrains.kotlin.analysis.api.standalone.base.project.structure

import com.intellij.mock.MockApplication
import com.intellij.mock.MockProject
import com.intellij.openapi.Disposable
import com.intellij.psi.PsiElementFinder
import com.intellij.psi.impl.PsiElementFinderImpl
import org.jetbrains.kotlin.analysis.api.KaAnalysisNonPublicApi

    def isolatableFactory = new DefaultIsolatableFactory(null, TestUtil.managedFactoryRegistry())
    def leaseRegistry = Stub(SharedResourceLeaseRegistry)
    def buildIdentifier = Mock(BuildIdentifier)
    def services = TestUtil.createTestServices { registrations ->
        registrations.addProvider(new ServiceRegistrationProvider() {
            @Provides

}

func (m *MockEtcdClient) Endpoints() []string {
	return m.getEndpoints()
}

// Status returns a mock status response.
func (m *MockEtcdClient) Status(ctx context.Context, endpoint string) (*clientv3.StatusResponse, error) {
	version, err := m.getVersion(endpoint)
	if err != nil {
		return nil, err
	}
	// Return a mock status response
	return &clientv3.StatusResponse{
		Version: version,
	}, nil
}

// See the License for the specific language governing permissions and
// limitations under the License.

package nodeagent

import (
	"context"
	"fmt"
	"testing"
	"time"

	"github.com/stretchr/testify/mock"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"

	"istio.io/istio/cni/pkg/util"
	"istio.io/istio/pkg/config/constants"
	"istio.io/istio/pkg/kube"

import com.intellij.ide.plugins.PluginXmlPathResolver
import com.intellij.ide.plugins.RawPluginDescriptor
import com.intellij.ide.plugins.ReadModuleContext
import com.intellij.mock.MockApplication
import com.intellij.mock.MockComponentManager
import com.intellij.mock.MockProject
import com.intellij.openapi.extensions.DefaultPluginDescriptor
import com.intellij.openapi.extensions.PluginDescriptor
import com.intellij.util.containers.ContainerUtil

        def artifactSource = calculatedValueContainerFactory.create(Describables.of("artifact"), new File("pathTo" + name))
        return new DefaultResolvableArtifact(id, artifactStub, Mock(ComponentArtifactIdentifier), Mock(TaskDependencyContainer), artifactSource, calculatedValueContainerFactory).toPublicView()
    }

import spock.lang.Specification
import spock.lang.Subject

class TestOutputRedirectorTest extends Specification {

    TestResultProcessor processor = Mock(TestResultProcessor)
    StandardOutputRedirector redir = Mock(StandardOutputRedirector)

    @Subject redirector = new TestOutputRedirector(processor, redir)

    def "starts redirecting output and error"() {
        when:

 * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
 */

package org.jetbrains.kotlin.analysis.api.fe10.test.configurator

import com.intellij.mock.MockApplication
import com.intellij.mock.MockProject
import com.intellij.openapi.Disposable
import org.jetbrains.kotlin.analysis.api.KaAnalysisApiInternals
import org.jetbrains.kotlin.analysis.api.KaAnalysisNonPublicApi

class DaemonSidePayloadClassLoaderFactoryTest extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def factory = Mock(PayloadClassLoaderFactory)
    def classpathTransformer = Mock(CachedClasspathTransformer)

    def registry = new DaemonSidePayloadClassLoaderFactory(factory, classpathTransformer)

    def "creates ClassLoader for classpath"() {