BaseTransformationTest.java

package jetbrains.mps.lang.test.runtime;

/*Generated by MPS */

import jetbrains.mps.project.Project;
import org.jetbrains.mps.openapi.model.SModel;
import jetbrains.mps.RuntimeFlags;
import jetbrains.mps.TestMode;
import org.jetbrains.annotations.NotNull;
import jetbrains.mps.tool.environment.Environment;
import jetbrains.mps.tool.environment.IdeaEnvironment;
import jetbrains.mps.tool.environment.EnvironmentConfig;
import jetbrains.mps.lang.test.util.MpsTestRunListener;
import jetbrains.mps.lang.test.util.RunEventsDispatcher;
import jetbrains.mps.smodel.tempmodel.TemporaryModels;
import jetbrains.mps.smodel.tempmodel.TempModuleOptions;
import jetbrains.mps.generator.impl.CloneUtil;

public abstract class BaseTransformationTest implements TransformationTest {
  private Project myProject;
  private SModel myModel;
  private SModel myTransientModel;
  private TestRunner myRunner;

  /*package*/ static final TestModelSaver CACHE = new TestModelSaver();

  public static boolean isExecutionInProcess() {
    return RuntimeFlags.getTestMode() == TestMode.IN_PROCESS;
  }

  @NotNull
  private static TestRunner defaultTestRunner() {
    if (isExecutionInProcess()) {
      return new TransformationTestLightRunner();
    } else {
      Environment ideaEnv = IdeaEnvironment.getOrCreate(EnvironmentConfig.defaultConfigNoPluginsSpecified());
      return new TransformationTestRunner(ideaEnv);
    }
  }

  public BaseTransformationTest() {
  }

  public BaseTransformationTest(@NotNull TestRunner runner) {
    setTestRunner(runner);
  }

  public BaseTransformationTest(Project project, SModel modelDescriptor) {
    myProject = project;
    myModel = modelDescriptor;
  }

  public void beforeTests() {
  }

  public void afterTests() {
  }

  @Override
  public void setTestRunner(TestRunner runner) {
    myRunner = runner;
  }

  @Override
  public TestRunner getTestRunner() {
    return myRunner;
  }

  public void initTest(@NotNull String projectName, final String model) throws Exception {
    initTest(projectName, model, false);
  }

  public void initTest(@NotNull String projectName, final String model, boolean reOpenProject) throws Exception {
    if (myRunner == null) {
      initTests();
    }
    myRunner.initTest(this, projectName, model, reOpenProject);
  }

  private void initTests() {
    setTestRunner(defaultTestRunner());
    registerTestsListener();
  }

  private void registerTestsListener() {
    MpsTestRunListener listener = new MpsTestRunListener() {
      @Override
      public void testRunFinished() {
        CACHE.clean();
        afterTests();
        RunEventsDispatcher.getInstance().removeListener(this);
      }

      @Override
      public void testRunStarted() {
        beforeTests();
      }
    };
    RunEventsDispatcher.getInstance().addListener(listener);
  }

  public void runTest(String className, final String methodName, final boolean runInCommand) throws Throwable {
    myRunner.runTest(this, className, methodName, runInCommand);
  }

  @Override
  public void init() {
    this.myTransientModel = TemporaryModels.getInstance().create(false, TempModuleOptions.forDefaultModule());
    new CloneUtil(this.myModel, this.myTransientModel).cloneModelWithAllImports();
  }

  @Override
  public void dispose() {
    TemporaryModels.getInstance().dispose(myTransientModel);
    myTransientModel = null;
  }

  @Override
  public SModel getModelDescriptor() {
    return myModel;
  }

  @Override
  public void setModelDescriptor(SModel descriptor) {
    myModel = descriptor;
  }

  @Override
  public void setTransientModelDescriptor(SModel descriptor) {
    myTransientModel = descriptor;
  }

  @Override
  public SModel getTransientModelDescriptor() {
    return myTransientModel;
  }

  @Override
  public Project getProject() {
    return myProject;
  }

  @Override
  public void setProject(Project project) {
    myProject = project;
  }
}