@Override
  protected void doRefactoringAction() {
    final boolean needToRegenerate = myRegenerateLanguage.getModel().isSelected();

    final String fqName = getCurrentValue();
    if (MPSModuleRepository.getInstance().getModuleByFqName(fqName) != null) {
      setErrorText("Duplicate language name");
      return;
    }
    if (!((SourceVersion.isName(fqName)))) {
      setErrorText("Language namespace should be valid Java package");
      return;
    }
    final LanguageRenamer renamer = new LanguageRenamer(myProject, myLanguage, fqName);
    ModelAccess modelAccess = myProject.getRepository().getModelAccess();
    modelAccess.executeCommand(
        new Runnable() {
          public void run() {
            renamer.rename(needToRegenerate);
            renamer.update();
          }
        });
    if (needToRegenerate) {
      final Map<SModule, List<SModel>> langs = new LinkedHashMap<SModule, List<SModel>>();
      modelAccess.runReadAction(
          new Runnable() {
            public void run() {
              RefactoringUtil.fillLanguageAndItsExtendingLanguageModels(myLanguage, langs);
            }
          });
      for (final List<SModel> models : langs.values()) {
        ModuleContext context = new ModuleContext(myLanguage, myProject);
        MakeSession sess = new MakeSession(context);
        if (IMakeService.INSTANCE.get().openNewSession(sess)) {
          IMakeService.INSTANCE
              .get()
              .make(sess, new ModelsToResources(context, models).resources(false));
        }
        //         GeneratorUIFacade.getInstance().generateModels(new ModuleContext(myLanguage,
        // myProject), params.getModelDescriptors(),
        // GeneratorUIFacade.getInstance().getDefaultGenerationHandler(), true, false);
      }
    }
    super.doRefactoringAction();
  }
  @Override
  public boolean testRefactoring(
      final Project project,
      final SModel sandbox1,
      final SModel sandbox2,
      final Language testRefactoringLanguage,
      final Language testRefactoringTargetLanguage) {
    final String newConceptName = "MyVeryGoodConcept2";
    final ModelAccess modelAccess = project.getRepository().getModelAccess();
    final Wrappers._T<IRefactoring> refactoring = new Wrappers._T<IRefactoring>();
    modelAccess.runReadAction(
        new Runnable() {
          public void run() {
            refactoring.value =
                RefactoringUtil.getRefactoringByClassName(
                    BehaviorReflection.invokeVirtual(
                        String.class,
                        SNodeOperations.getNode(
                            "r:de5b7214-45ee-4f6d-89bf-acde59cdb050(jetbrains.mps.lang.structure.refactorings)",
                            "1347577327951781517"),
                        "virtual_getFqName_1213877404258",
                        new Object[] {}));
          }
        });

    final RefactoringContext refactoringContext =
        new RefactoringContext(project, refactoring.value);
    refactoringContext.setCurrentOperationContext(new ProjectOperationContext(project));

    modelAccess.runReadAction(
        new Runnable() {
          public void run() {
            final SModel structureModelDescriptor =
                testRefactoringLanguage.getStructureModelDescriptor();
            refactoringContext.setParameter(
                RenameConceptRefactoringTester.STRMD, structureModelDescriptor);
            SModel model = structureModelDescriptor;
            SNode concept = SModelOperations.getRootByName(model, "MyVeryGoodConcept1");
            refactoringContext.setSelectedNode(concept);
            refactoringContext.setSelectedModel(structureModelDescriptor);
            refactoringContext.setParameter("newName", newConceptName);
          }
        });
    new RefactoringTestFacade().doExecuteInTest(refactoringContext);
    final boolean[] result = new boolean[] {false};
    ThreadUtils.runInUIThreadAndWait(
        new Runnable() {
          @Override
          public void run() {
            modelAccess.runReadAction(
                new Runnable() {
                  public void run() {
                    try {
                      if (sandbox1.isLoaded()) {
                        System.err.println(
                            "test environment is invalid: model sandbox1 is already initialized, should be not");
                        result[0] = false;
                        return;
                      }
                      SModel sModel = sandbox1;
                      String conceptFqName =
                          sModel.getRootNodes().iterator().next().getConcept().getConceptId();
                      SModel structureModelDescriptor =
                          (SModel)
                              refactoringContext.getParameter(RenameConceptRefactoringTester.STRMD);
                      result[0] =
                          conceptFqName.equals(
                              structureModelDescriptor.getReference().getModelName()
                                  + "."
                                  + newConceptName);
                    } catch (Throwable t) {
                      t.printStackTrace();
                      result[0] = false;
                    }
                  }
                });
          }
        });
    return result[0];
  }
 public void doExecute(@NotNull final AnActionEvent event, final Map<String, Object> _params) {
   try {
     final Wrappers._T<List<String>> packages = new Wrappers._T<List<String>>();
     final Wrappers._T<String> oldPackage = new Wrappers._T<String>();
     ModelAccess modelAccess =
         ((MPSProject) MapSequence.fromMap(_params).get("project"))
             .getRepository()
             .getModelAccess();
     modelAccess.runReadAction(
         new Runnable() {
           public void run() {
             packages.value =
                 SetNodePackage_Action.this.fetchExistingPackages(
                     ((List<SNode>) MapSequence.fromMap(_params).get("nodes")), _params);
             oldPackage.value =
                 SPropertyOperations.getString(
                     ListSequence.fromList(
                             ((List<SNode>) MapSequence.fromMap(_params).get("nodes")))
                         .first(),
                     "virtualPackage");
           }
         });
     final SetNodePackageDialog dialog =
         new SetNodePackageDialog(
             ((MPSProject) MapSequence.fromMap(_params).get("project")), packages.value);
     dialog.setPackage(oldPackage.value);
     dialog.show();
     if (dialog.isCancelled()) {
       return;
     }
     modelAccess.executeCommandInEDT(
         new Runnable() {
           public void run() {
             for (SNode node :
                 ListSequence.fromList(
                     ((List<SNode>) MapSequence.fromMap(_params).get("nodes")))) {
               SPropertyOperations.set(node, "virtualPackage", dialog.getPackage());
               if (SNodeOperations.isInstanceOf(
                   node, "jetbrains.mps.lang.structure.structure.AbstractConceptDeclaration")) {
                 for (SNode aspect :
                     ListSequence.fromList(
                         BehaviorReflection.invokeNonVirtual(
                             (Class<List<SNode>>) ((Class) Object.class),
                             SNodeOperations.cast(
                                 node,
                                 "jetbrains.mps.lang.structure.structure.AbstractConceptDeclaration"),
                             "jetbrains.mps.lang.structure.structure.AbstractConceptDeclaration",
                             "call_findAllAspects_7754459869734028917",
                             new Object[] {}))) {
                   SPropertyOperations.set(
                       ((SNode) aspect), "virtualPackage", dialog.getPackage());
                 }
               }
             }
           }
         });
   } catch (Throwable t) {
     if (LOG.isEnabledFor(Level.ERROR)) {
       LOG.error("User's action execute method failed. Action:" + "SetNodePackage", t);
     }
   }
 }