ActionScriptHighlightingTest.java

package com.intellij.flex.highlighting;

import com.intellij.codeInsight.daemon.DaemonCodeAnalyzerSettings;
import com.intellij.codeInsight.daemon.impl.HighlightInfo;
import com.intellij.codeInsight.intention.IntentionAction;
import com.intellij.codeInsight.lookup.Lookup;
import com.intellij.codeInsight.lookup.LookupElement;
import com.intellij.codeInsight.lookup.LookupEx;
import com.intellij.codeInsight.lookup.LookupManager;
import com.intellij.codeInsight.lookup.impl.LookupImpl;
import com.intellij.codeInsight.template.impl.TemplateManagerImpl;
import com.intellij.codeInspection.htmlInspections.HtmlUnknownAttributeInspection;
import com.intellij.codeInspection.htmlInspections.HtmlUnknownBooleanAttributeInspection;
import com.intellij.codeInspection.htmlInspections.HtmlUnknownTagInspection;
import com.intellij.flex.model.bc.LinkageType;
import com.intellij.flex.model.bc.OutputType;
import com.intellij.flex.model.bc.TargetPlatform;
import com.intellij.flex.parser.FlexImporterTest;
import com.intellij.flex.util.ActionScriptDaemonAnalyzerTestCase;
import com.intellij.flex.util.FlexTestUtils;
import com.intellij.ide.highlighter.HighlighterFactory;
import com.intellij.javascript.flex.css.FlexStylesIndexableSetContributor;
import com.intellij.javascript.flex.mxml.schema.FlexSchemaHandler;
import com.intellij.javascript.flex.resolve.ActionScriptClassResolver;
import com.intellij.lang.javascript.*;
import com.intellij.lang.javascript.dialects.JSDialectSpecificHandlersFactory;
import com.intellij.lang.javascript.flex.FlexModuleType;
import com.intellij.lang.javascript.flex.projectStructure.model.FlexBuildConfigurationManager;
import com.intellij.lang.javascript.flex.projectStructure.model.ModifiableFlexBuildConfiguration;
import com.intellij.lang.javascript.formatter.JSCodeStyleSettings;
import com.intellij.lang.javascript.highlighting.JavaScriptLineMarkerProvider;
import com.intellij.lang.javascript.inspections.JSMethodCanBeStaticInspection;
import com.intellij.lang.javascript.inspections.JSUnusedAssignmentInspection;
import com.intellij.lang.javascript.inspections.JSUnusedGlobalSymbolsInspection;
import com.intellij.lang.javascript.inspections.JSUnusedLocalSymbolsInspection;
import com.intellij.lang.javascript.inspections.actionscript.JSImplicitlyInternalDeclarationInspection;
import com.intellij.lang.javascript.inspections.actionscript.JSUntypedDeclarationInspection;
import com.intellij.lang.javascript.psi.JSFunction;
import com.intellij.lang.javascript.psi.JSNamedElement;
import com.intellij.lang.javascript.psi.JSReferenceExpression;
import com.intellij.lang.javascript.psi.ecmal4.JSClass;
import com.intellij.lang.javascript.psi.resolve.JSClassResolver;
import com.intellij.lang.javascript.validation.fixes.CreateClassOrInterfaceFix;
import com.intellij.openapi.actionSystem.IdeActions;
import com.intellij.openapi.command.WriteCommandAction;
import com.intellij.openapi.editor.highlighter.EditorHighlighter;
import com.intellij.openapi.editor.highlighter.HighlighterIterator;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.fileEditor.FileEditor;
import com.intellij.openapi.fileEditor.FileEditorManager;
import com.intellij.openapi.fileEditor.TextEditor;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.module.ModuleType;
import com.intellij.openapi.projectRoots.Sdk;
import com.intellij.openapi.projectRoots.SdkModificator;
import com.intellij.openapi.roots.*;
import com.intellij.openapi.util.Ref;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VfsUtilCore;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess;
import com.intellij.psi.*;
import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.spellchecker.inspections.SpellCheckingInspection;
import com.intellij.testFramework.ExpectedHighlightingData;
import com.intellij.testFramework.PlatformTestUtil;
import com.intellij.testFramework.PsiTestUtil;
import com.intellij.util.IncorrectOperationException;
import com.sixrr.inspectjs.validity.BadExpressionStatementJSInspection;
import com.sixrr.inspectjs.validity.FunctionWithInconsistentReturnsJSInspection;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;

import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import static com.intellij.openapi.vfs.VfsUtilCore.convertFromUrl;
import static com.intellij.openapi.vfs.VfsUtilCore.urlToPath;

public class ActionScriptHighlightingTest extends ActionScriptDaemonAnalyzerTestCase {
  @NonNls private static final String BASE_PATH = "/js2_highlighting/";

  private Runnable myAfterCommitRunnable = null;

  @Override
  protected String getTestDataPath() {
    return FlexTestUtils.getTestDataPath("");
  }

  @Override
  protected void setUp() throws Exception {
    VfsRootAccess.allowRootAccess(getTestRootDisposable(),
                                  urlToPath(convertFromUrl(FlexSchemaHandler.class.getResource("z.xsd"))),
                                  urlToPath(convertFromUrl(FlexStylesIndexableSetContributor.class.getResource("FlexStyles.as"))));
    super.setUp();
    myAfterCommitRunnable = null;
  }

  @Override
  protected void setUpJdk() {
    FlexTestUtils.setupFlexSdk(myModule, getTestName(false), getClass());
  }

  protected ModuleType getModuleType() {
    return FlexModuleType.getInstance();
  }

  @Override
  protected void doCommitModel(@NotNull ModifiableRootModel rootModel) {
    super.doCommitModel(rootModel);
    if (myAfterCommitRunnable != null) {
      myAfterCommitRunnable.run();
    }
  }

  public void testScriptHighlightingInE4X() throws Exception {
    //                       10        20         30           40         50
    //             01234567890123456789012 34567890123456 7 89012 34567890123456789
    String text = "var a = <xml>{ c }</xml>";
    configureByFile(BASE_PATH + getTestName(false) + ".js2");
    EditorHighlighter highlighter = HighlighterFactory.createHighlighter(myProject, getFile().getVirtualFile());
    highlighter.setText(text);
    HighlighterIterator iterator = highlighter.createIterator(15);
    assertEquals(JSTokenTypes.IDENTIFIER, iterator.getTokenType());
  }

  public void testNsOrModifierNotUnderClass() throws Exception {
    Collection<HighlightInfo> infoCollection = defaultTest();
    IntentionAction action =
      findIntentionAction(infoCollection, JSBundle.message("javascript.fix.remove.access.modifier"), myEditor, myFile);
    assertNotNull(action);

    action = findIntentionAction(infoCollection, JSBundle.message("javascript.fix.remove.namespace.reference"), myEditor, myFile);
    assertNotNull(action);
  }

  public void testCreateParameter() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Create parameter");
  }

  public void testCreateParameter_2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Create parameter");
  }

  public void testCreateParameter_3() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Create parameter");
  }

  public void testCreateParameter2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Create parameter");
  }

  public void testReferencingPrivatesAndIncludeMembers() throws Exception {
    doTestFor(true, getTestName(false) + ".js2", getTestName(false) + "_2.js2");
  }

  public void testHighlightExtends() throws Exception {
    doTestFor(true, null, () -> {
      JSTestUtils.HighlightUsagesInfo handler = JSTestUtils.getFindUsagesHandlerHighlights(myEditor, myFile);
      List<PsiElement> targets = handler.targets;
      assertEquals(1, targets.size());
      assertTrue(targets.get(0).getText().contains("class Foo"));
      List<String> readUsages = handler.readUsages;
      assertEquals(1, readUsages.size());
      assertEquals("foo", readUsages.get(0));
    }, getTestName(false) + ".js2");
  }

  public void testHighlightImplements() throws Exception {
    doTestFor(true, null, () -> {
      JSTestUtils.HighlightUsagesInfo handler = JSTestUtils.getFindUsagesHandlerHighlights(myEditor, myFile);
      assertNotNull(handler);
      List<PsiElement> targets = handler.targets;
      assertEquals(2, targets.size());
      assertTrue(targets.get(0).getText().contains("interface IFoo"));
      assertTrue(targets.get(1).getText().contains("interface IBar"));
      List<String> readUsages = handler.readUsages;
      assertEquals(2, readUsages.size());
      assertEquals("foo", readUsages.get(0));
      assertEquals("baz", readUsages.get(1));
    }, getTestName(false) + ".js2");
  }

  public void testParsleyAndRobotlegsMetadata() throws Exception {
    defaultTest();
  }

  public void testSwizMetadata() throws Exception {
    defaultTest();
  }

  public void testSpringActionScriptMetadata() throws Exception {
    defaultTest();
  }

  @JSTestOptions({JSTestOption.WithUnusedImports})
  public void testReferencingNameInE4X() throws Exception {
    defaultTest();
  }

  public void testMethodCanBeStatic() throws Exception {
    enableInspectionTool(new JSMethodCanBeStaticInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make 'static'");
  }

  public void testMethodCanBeStatic2() throws Exception {
    enableInspectionTool(new JSMethodCanBeStaticInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make 'static'");
  }

  public void testMethodCanBeStatic3() throws Exception {
    enableInspectionTool(new JSMethodCanBeStaticInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make 'static'");
  }

  public void testMethodCanBeStatic4() throws Exception {
    enableInspectionTool(new JSMethodCanBeStaticInspection());
    defaultTest();
  }

  @JSTestOptions({JSTestOption.WithGumboSdk})
  public void testMethodCanBeStaticImplicitVars() throws Exception {
    enableInspectionTool(new JSMethodCanBeStaticInspection());
    doTestFor(true, getTestName(false) + ".mxml");
  }

  @JSTestOptions({JSTestOption.WithUnusedImports})
  public void testCDATAInE4X() throws Exception {
    defaultTest();
  }

  @JSTestOptions({JSTestOption.WithUnusedImports, JSTestOption.WithFlexSdk})
  public void testReferencingNameInE4X2() throws Exception {
    defaultTest();
  }

  @JSTestOptions({JSTestOption.WithFlexSdk, JSTestOption.WithUnusedImports})
  public void testQNameProblem() throws Exception {
    defaultTest();
  }

  public void testReferencingInternalClass() throws Exception {
    String testName = getTestName(false);
    doTestFor(true, testName + ".js2", testName + "_2.js2");
  }

  public void testSpellChecker() throws Exception {
    enableInspectionTool(new SpellCheckingInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Typo: Rename to...");
  }

  public void testSpellChecker_2() throws Exception {
    runRenameSpellcheckerFixWithChooseVariant("typo");
  }

  private void runRenameSpellcheckerFixWithChooseVariant(String variantName) throws Exception {
    TemplateManagerImpl.setTemplateTesting(getProject(), getTestRootDisposable());
    enableInspectionTool(new SpellCheckingInspection());

    doSimpleHighlightingWithInvokeFixAndCheckResult("Typo: Rename to...");

    final LookupEx lookup = LookupManager.getActiveLookup(myEditor);
    assertNotNull(lookup);
    boolean selected = false;

    for (LookupElement l : lookup.getItems()) {
      if (variantName.equals(l.getLookupString())) {
        selected = true;
        ((LookupImpl)lookup).finishLookup(Lookup.AUTO_INSERT_SELECT_CHAR, l);
      }
    }

    assertTrue(selected);

    LookupManager.getInstance(myProject).hideActiveLookup();

    checkResultByFile(BASE_PATH + getTestName(false) + "_after2.js2");
  }

  public void testSpellChecker2() throws Exception {
    runRenameSpellcheckerFixWithChooseVariant("xxix");
  }

  @JSTestOptions({JSTestOption.WithFlexFacet})
  public void testProxy() throws Exception {
    defaultTest();
  }

  @JSTestOptions({JSTestOption.WithUnusedImports})
  public void testAnyAttrInE4X() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    defaultTest();
  }

  public void testCheckingCast() throws Exception {
    defaultTest();
  }

  public void testE4XPredefines() throws Exception {
    defaultTest();
  }

  public void testGetObjectAndOtherMethodsWithPropertyRefs() throws Exception {
    defaultTest();
  }

  public void testPrivateMethodForInterfaceImplementation() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make method bar public");
  }

  public void testDefaultProperty() throws Exception {
    defaultTest();
  }

  public void testAS3NsOpenedByDefault() throws Exception {
    String testName = getTestName(false);
    doTestFor(true, testName + ".js2", testName + "_2.js2");
  }

  public void testVirtualKeyword() throws Exception {
    defaultTest();
  }

  public void testDeprecated() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Replace deprecated code with ResourceManager.getInstance().getResourceBundle()");
  }

  public void testDeprecated2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Replace deprecated code with Bar.yyy");
  }

  public void testObjectMembers() throws Exception {
    defaultTest();
  }

  public void testCircularDependency() throws Exception {
    defaultTest();
  }

  public void testNestedClass() throws Exception {
    defaultTest();
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testTypeEvalFails() throws Exception {
    defaultTest();
  }

  public void testClassRefsInArrayElementType() throws Exception {
    defaultTest();
  }

  public void testCreateClassAccessingProperty() throws Exception {
    defaultTest();
  }

  public void testTypeReferenceInAs() throws Exception {
    defaultTest();
  }

  public void testTypedArray() throws Exception {
    defaultTest();
  }

  public void testNamespaceReferencedWithoutImport() throws Exception {
    defaultTest();
  }

  public void testReportAboutUsingInterfaceInNew() throws Exception {
    defaultTest();
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testBindableClassImplicitlyImplementsIEventDispatcher() throws Exception {
    defaultTest();
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testBindableClassImplicitlyImplementsIEventDispatcher2() throws Exception {
    doTestFor(true, new File(getTestDataPath() + BASE_PATH + getTestName(false)), (Runnable)null, getTestName(false) + "/Main.js2");
    final JSClassResolver resolver =
      JSDialectSpecificHandlersFactory.forLanguage(JavaScriptSupportLoader.ECMA_SCRIPT_L4).getClassResolver();
    assertNotNull(((JSClass)resolver.findClassByQName("OtherClass", myModule.getModuleScope())).getStub());
    assertNotNull(((JSClass)resolver.findClassByQName("OtherClass2", myModule.getModuleScope())).getStub());
  }

  public void testImplicitGetSet() throws Exception {
    defaultTest();
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testHighlightQualifiedNameWithoutImport() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("mx.messaging.messages.AbstractMessage?");
  }

  public void testUsingFunctionDeclarations() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    defaultTest();
  }

  public void testReportAccessorProblems() throws Exception {
    defaultTest();
  }

  public void testReportAccessorProblems2() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck(JSBundle.message("javascript.fix.set.element.visibility", "getter foo", "internal"), "as",
                                         infoCollection);
  }

  public void testReportAccessorProblems3() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck(JSBundle.message("javascript.fix.set.element.visibility", "setter foo", "public"), "as",
                                         infoCollection);
  }

  public void testReportAccessorProblems4() throws Exception {
    doTestFor(true, getTestName(false) + ".as");
  }

  public void testTypeReferenceInNewWithFunExpr() throws Exception {
    defaultTest();
  }

  public void testAssignmentToConst() throws Exception {
    defaultTest();
  }

  public void testIncludedMembers() throws Exception {
    final String testName = getTestName(false);
    doTestFor(true, testName + ".js2", testName + "_2.js2");
  }

  @JSTestOptions(JSTestOption.WithGumboSdk)
  public void testIncompatibleOverride() throws Exception {
    final String testName = getTestName(false);
    doTestFor(true, testName + ".js2");
  }

  public void testIncompatibleOverrideFix() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change return type to expected");
  }

  public void testIncompatibleOverrideFix2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change parameters to expected");
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testIncompatibleOverrideFix3() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change return type to expected");
  }

  public void testIncompatibleOverrideFix4() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change return type to expected");
  }

  public void testIncompatibleOverrideFix5() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change Base.foo() signature");
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testIncompatibleOverrideFix6() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change parameters to expected");
  }

  public void testNoSuperConstructorCall() throws Exception {
    final String testName = getTestName(false);
    final Collection<HighlightInfo> infoCollection = doTestFor(true, testName + ".js2");
    findAndInvokeIntentionAction(infoCollection, "Create constructor matching super", myEditor, myFile);
    checkResultByFile(BASE_PATH + testName + "_after.js2");
  }

  public void testNoSuperConstructorCall2() throws Exception {
    doHighlightingWithInvokeFixAndCheckResult("Insert super class constructor invocation", "js2");
  }

  public void testNoSuperConstructorCall3() throws Exception {
    doHighlightingWithInvokeFixAndCheckResult("Remove initializer", "js2");
  }

  public void testNoSuperConstructorCall4() throws Exception {
    final String testName = getTestName(false);
    final Collection<HighlightInfo> infoCollection = doTestFor(true, testName + ".js2", testName + "_2.js2");
    findAndInvokeIntentionAction(infoCollection, "Create constructor matching super", myEditor, myFile);
    checkResultByFile(BASE_PATH + testName + "_after.js2");
  }

  public void testRemoveMethodWithAsdoc() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doHighlightingWithInvokeFixAndCheckResult("Remove unused method 'Unused'", "js2");
  }

  public void testSuperConstructorCall() throws Exception {
    defaultTest();
  }

  public void testDefaultConstructorVisibility() throws Exception {
    defaultTest();
  }

  public void testFinalModifiers() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Remove final modifier");
  }

  public void testFinalModifiers2() throws Exception {
    defaultTest();
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testImportBeforePackage() throws Exception {
    final String testName = getTestName(false);
    doTestFor(true, testName + ".js2");
  }

  @JSTestOptions({JSTestOption.WithUnusedImports})
  public void testIncompatibleImplementation() throws Exception {
    final String testName = getTestName(false);
    doTestFor(true, testName + ".js2", testName + "_2.js2");
  }

  public void testIncompatibleImplementationFix() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change return type to expected");
  }

  public void testIncompatibleImplementationFix2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change parameters to expected");
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testIncompatibleImplementationFix3() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change return type to expected");
  }

  public void testIncompatibleImplementationFix4() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change return type to expected");
  }

  public void testIncompatibleImplementationFix5() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change Int1.foo() signature");
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testIncompatibleImplementationFix6() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change parameters to expected");
  }

  public void testJSDoc() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    final String testName = getTestName(false);
    doTestFor(true, testName + ".js2", testName + "_2.js2");
  }

  public void testJSDoc2() throws Exception {
    defaultTest();
  }

  public void testDuplicates() throws Exception {
    defaultTest();
  }

  public void testDuplicatesSmall() throws Exception {
    defaultTest();
  }

  public void testFunctionSignatureMismatch() throws Exception {
    defaultTest();
  }

  public void testFunctionSignatureMismatch2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch2.foo() signature");
  }

  public void testFunctionSignatureMismatch3() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change Base.foo() signature");
  }

  public void testFunctionSignatureMismatch4() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change Base.foo() signature");
  }

  public void testFunctionSignatureMismatch5() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch5.foo() signature");
  }

  public void testFunctionSignatureMismatch6() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch6.foo() signature");
  }

  public void testFunctionSignatureMismatch7() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch7.foo() signature");
  }

  public void testFunctionSignatureMismatch8() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch8.foo() signature");
  }

  public void testFunctionSignatureMismatch9() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch9.foo() signature");
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testFunctionSignatureMismatch10() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch10.foo() signature");
  }

  public void testFunctionSignatureMismatch11() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch11.foo() signature");
  }

  public void testFunctionSignatureMismatch12() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch12.say() signature");
  }

  public void testFunctionSignatureMismatch13() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch13.say() signature");
  }

  public void testFunctionSignatureMismatch14() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch14.zz() signature");
  }

  public void testFunctionSignatureMismatch15() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch15.foo() signature");
  }

  public void testFunctionSignatureMismatch16() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatch16.foo() signature");
  }

  public void testFunctionSignatureMismatchRemoveParam1() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatchRemoveParam1.foo() signature");
  }

  public void testFunctionSignatureMismatchRemoveParam2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatchRemoveParam2.foo() signature");
  }

  public void testFunctionSignatureMismatchRemoveParam3() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatchRemoveParam3.foo() signature");
  }

  public void testFunctionSignatureMismatchRemoveParam4() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatchRemoveParam4.foo() signature");
  }

  public void testFunctionSignatureMismatchChangeParam1() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatchChangeParam1.foo() signature");
  }

  public void testFunctionSignatureMismatchFixInaccessible1() throws Exception {
    final Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".js2");
    assertInaccessible(infos, "Change FunctionSignatureMismatchFixInaccessible1.foo() signature");
  }

  public void testFunctionSignatureMismatchAddParam1() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatchAddParam1.foo() signature");
  }

  public void testFunctionSignatureMismatchAddParam2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FunctionSignatureMismatchAddParam2.foo() signature");
  }

  public void testFieldPrefix() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change FieldPrefix.ee() signature");
  }

  public void testPropertyPrefix() throws Exception {
    JSCodeStyleSettings jsCodeStyleSettings = CodeStyleSettingsManager.getSettings(myProject).getCustomSettings(JSCodeStyleSettings.class);
    String prefix = jsCodeStyleSettings.PROPERTY_PREFIX;
    jsCodeStyleSettings.PROPERTY_PREFIX = "prop";
    try {
      doSimpleHighlightingWithInvokeFixAndCheckResult("Change PropertyPrefix.ee() signature");
    }
    finally {
      jsCodeStyleSettings.PROPERTY_PREFIX = prefix;
    }
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testQualifyReferencesInArguments() throws Exception {
    String testName = getTestName(false);
    String root = getTestDataPath() + getBasePath() + "/" + testName;
    Collection<HighlightInfo> infoCollection =
      doTestFor(true, new File(root + "/before"), (Runnable)null, testName + "/before/" + "Ref1.as");
    findAndInvokeIntentionAction(infoCollection, "Change Foo.func() signature", myEditor, myFile);
    FileDocumentManager.getInstance().saveAllDocuments();
    VirtualFile dirAfter = LocalFileSystem.getInstance().findFileByIoFile(new File(root + "/after"));
    VirtualFile actualDir = ProjectRootManager.getInstance(myProject).getFileIndex().getContentRootForFile(myFile.getVirtualFile());
    PlatformTestUtil.assertDirectoriesEqual(dirAfter, actualDir);
  }

  public void testConstructorSignatureMismatch1() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Create constructor 'ConstructorSignatureMismatch1'");
  }

  private void setActiveEditor(String relativePath) {
    VirtualFile file = myFile.getVirtualFile().findFileByRelativePath(relativePath);
    FileEditor[] editors = FileEditorManager.getInstance(myProject).getEditors(file);
    assertEquals(1, editors.length);
    FileEditor fileEditor = editors[0];
    assertTrue(fileEditor instanceof TextEditor);
    setActiveEditor(((TextEditor)fileEditor).getEditor());
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testConstructorSignatureMismatch2() throws Exception {
    Collection<HighlightInfo> infoCollection = defaultTestForTwoFiles();
    findAndInvokeIntentionAction(infoCollection, "Create constructor 'Foo'", myEditor, myFile);
    setActiveEditor("../" + getTestName(false) + "_2." + getExtension());
    checkResultByFile(BASE_PATH + getTestName(false) + "_after.js2");
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testConstructorSignatureMismatch3() throws Exception {
    Collection<HighlightInfo> infoCollection = defaultTestForTwoFiles();
    findAndInvokeIntentionAction(infoCollection, "Create constructor 'Foo'", myEditor, myFile);
    setActiveEditor("../" + getTestName(false) + "_2." + getExtension());
    checkResultByFile(BASE_PATH + getTestName(false) + "_after.js2");
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testCreateConstructor1() throws Exception {
    doTestCreateConstructor("Subclass1.js2", "SuperClass");
  }

  private void doTestCreateConstructor(String filename, String superClassName) throws IOException {
    String testName = getTestName(false);
    String root = getTestDataPath() + getBasePath() + "/" + testName;
    Collection<HighlightInfo> infoCollection =
      doTestFor(true, new File(root + "/before"), (Runnable)null, testName + "/before/" + filename);
    findAndInvokeIntentionAction(infoCollection, "Create constructor '" + superClassName + "'", myEditor, myFile);
    FileDocumentManager.getInstance().saveAllDocuments();
    VirtualFile dirAfter = LocalFileSystem.getInstance().findFileByIoFile(new File(root + "/after"));
    VirtualFile actualDir = ProjectRootManager.getInstance(myProject).getFileIndex().getContentRootForFile(myFile.getVirtualFile());
    PlatformTestUtil.assertDirectoriesEqual(dirAfter, actualDir);
  }

  public void testUnresolvedMembers2() throws Exception {
    doTestFor(true, getTestName(false) + ".js2", getTestName(false) + "_2.js2");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testRegress() throws Exception {
    defaultTest();
  }

  public void testRegress2() throws Exception {
    defaultTest();
    final PsiReference ref = myFile.findReferenceAt(myEditor.getCaretModel().getOffset());
    assertTrue(ref instanceof PsiPolyVariantReference);
    final ResolveResult[] resolveResults = ((PsiPolyVariantReference)ref).multiResolve(false);
    assertTrue(2 == resolveResults.length);
  }

  public void testDynamicAttribute() throws Exception {
    defaultTest();
  }

  public void testSeveralVisibilityModifiers() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Remove visibility modifier");
  }

  public void testQualifiedThings() throws Exception {
    String testName = getTestName(false);
    doTestFor(true, testName + ".js2", testName + "_2.js2");
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testThisTypeIsDynamic() throws Exception {
    defaultTest();
  }

  public void testAssignmentTypeMismatch() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Insert cast");
  }

  public void testAssignmentTypeMismatch_2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Insert cast");
  }

  public void testAssignmentTypeMismatch_3() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Insert cast");
  }

  public void testAssignmentTypeMismatch_4() throws Exception {
    checkActionAvailable("Insert cast", false);
  }

  public void testAssignmentTypeMismatch_5() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Insert cast");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testAssignmentTypeMismatch2() throws Exception {
    defaultTest();
  }

  public void testAssignmentTypeMismatch3() throws Exception {
    defaultTest();
  }

  public void testBinaryArgTypeMismatch() throws Exception {
    defaultTest();
  }

  public void testReportingVoidTypeIssues() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Remove return value");
  }

  public void testCheckAnnotationAttributes() throws Exception {
    defaultTest();
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testForInTypeMismatch() throws Exception {
    defaultTest();
  }

  public void testReturnTypeMismatch() throws Exception {
    defaultTest();
  }

  public void testInvokedVariableTypeMismatch() throws Exception {
    defaultTest();
  }

  public void testMissingReturnArgument() throws Exception {
    defaultTest();
  }

  @JSTestOptions({JSTestOption.WithUnusedImports})
  public void testCorrectScopeOfImports() throws Exception {
    doTestFor(true, getTestName(false) + ".js2", getTestName(false) + "_2.js2");
  }

  @JSTestOptions({JSTestOption.WithUnusedImports, JSTestOption.WithFlexSdk})
  public void testCorrectScopeOfImports2() throws Exception {
    defaultTest();
  }

  public void testUsingPropertyAsFunctionCall() throws Exception {
    Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".js2");
    findAndInvokeIntentionAction(infoCollection, "Remove argument list", myEditor, myFile);
    checkResultByFile(BASE_PATH + getTestName(false) + "_after.js2");
  }

  public void testImplicitlyDefined() throws Exception {
    defaultTest();
  }

  public void testNSDeclarationUnderPackage() throws Exception {
    defaultTest();
  }

  public void testVariableUnderPackage() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Rename variable 'Foo' to 'VariableUnderPackage'");
  }

  // TODO now stubs are created for variable in package
  //@JSTestOptions({/*JSTestOption.WithoutSourceRoot*/})
  //public void testUnresolvedMembers() throws Exception {
  //  doTestFor(true, getTestName(false) + ".js2");
  //}

  @JSTestOptions({JSTestOption.WithoutSourceRoot})
  public void testNoSourceRoot() throws Exception {
    defaultTest();
  }

  public void testCheckReadWrite() throws Exception {
    defaultTest();
  }

  public void testNamespaceElementReferences() throws Exception {
    defaultTest();
  }

  public void testNamespaceElementReferences2() throws Exception {
    defaultTest();
    JSReferenceExpression expr =
      PsiTreeUtil.getParentOfType(myFile.findElementAt(myEditor.getCaretModel().getOffset()), JSReferenceExpression.class);
    assertNotNull(expr);
    PsiElement exprResolve = expr.resolve();
    assertTrue(exprResolve instanceof JSFunction);

    JSClass clazz = PsiTreeUtil.getParentOfType(exprResolve, JSClass.class);
    assertNotNull(clazz);
    assertEquals("Foo", clazz.getQualifiedName());
  }

  public void testRefsInIncludes() throws Exception {
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".js2");
    findAndInvokeIntentionAction(infos, "Create File RefsInIncludesz.js2", myEditor, myFile);
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testUnusedSymbols() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    defaultTest();
  }

  public void testUnusedSymbols2() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    defaultTest();
  }

  public void testUnusedSymbols3() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    defaultTest();
  }

  @JSTestOptions(JSTestOption.WithLineMarkers)
  public void testUnusedSymbols4() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Remove unused class 'Foo'");
  }

  public void testUnusedSymbols4_2() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Remove unused namespace 'baz'");
  }

  public void testUnusedGlobalSymbols() throws Exception {
    globalUnusedTestWith2Files();
  }

  public void testUnusedGlobalSymbols2() throws Exception {
    globalUnusedTestWith2Files();
  }

  public void testUnusedGlobalSymbols3() throws Exception {
    globalUnusedTestWith2Files();
  }

  public void testUnusedGlobalSymbols4() throws Exception {
    enableInspectionTool(new JSUnusedGlobalSymbolsInspection());
    defaultTest();
  }

  public void testUnusedGlobalSymbols5() throws Exception {
    enableInspectionTool(new JSUnusedGlobalSymbolsInspection());
    doTestFor(true, getTestName(false) + ".as");
  }

  private void globalUnusedTestWith2Files() throws IOException {
    enableInspectionTool(new JSUnusedGlobalSymbolsInspection());
    String testName = getTestName(false);
    doTestFor(true, testName + ".js2", testName + "_2.js2");
  }

  public void testUnusedParameterHasCreateFieldQuickFix() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Create Field 'xxx'");
  }

  public void testUnusedParameterHasCreateFieldQuickFix_2() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Create Field '_bar'");
  }

  public void testUnusedParameterHasCreateFieldQuickFix_3() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Create Field 'value'");
  }

  public void testUnusedParameterHasCreateFieldQuickFix_4() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Create Field '_value'");
  }

  public void testUnusedParameterHasCreateFieldQuickFix_5() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Create Field '_bar'");
  }

  public void testUnusedParameterHasAssignToFieldQuickFix() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Assign parameter 'xxx' to field");
  }

  public void testUnusedParameterHasAssignToFieldQuickFix_2() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Assign parameter 'xxx' to field");
  }

  public void testUnusedParameterHasAssignToFieldQuickFix_3() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Assign parameter 'xxx' to field");
  }

  public void testDuplicatedSymbols() throws Exception {
    defaultTest();
  }

  public void testThisInStaticFunction() throws Exception {
    defaultTest();
  }

  public void testDynamicUsageNoTypeCheck() throws Exception {
    String testName = getTestName(false);
    doTestFor(true, testName + ".js2", testName + "_2.js2");
  }

  public void testParametersInStatics() throws Exception {
    defaultTest();
  }

  public void testRestParameterIsNotMarkedAsHavingNoType() throws Exception {
    enableInspectionTool(new JSUntypedDeclarationInspection());
    doHighlightingWithInvokeFixAndCheckResult("Remove type reference", "js2");
  }

  public void testImplicitlyInternalDeclaration() throws Exception {
    enableInspectionTool(new JSImplicitlyInternalDeclarationInspection());
    doHighlightingWithInvokeFixAndCheckResult("Add explicit internal modifier", "js2");
  }

  public void testImplicitlyInternalDeclaration2() throws Exception {
    enableInspectionTool(new JSImplicitlyInternalDeclarationInspection());
    doHighlightingWithInvokeFixAndCheckResult("Add explicit internal modifier", "js2");
  }

  public void testImplicitlyInternalDeclaration3() throws Exception {
    enableInspectionTool(new JSImplicitlyInternalDeclarationInspection());
    defaultTest();
  }

  public void testUntypedDeclarationForFunExpr() throws Exception {
    String fileName = getTestName(false);
    runUntypedDeclarationInspectionTestWithFix(fileName, new String[]{fileName + ".js2"}, "js2");
  }

  public void testUntypedDeclarationForFunExpr_2() throws Exception {
    String fileName = getTestName(false);
    runUntypedDeclarationInspectionTestWithFix(fileName, new String[]{fileName + ".js2"}, "js2");
  }

  public void testUntypedDeclarationForFun() throws Exception {
    String fileName = getTestName(false);
    runUntypedDeclarationInspectionTestWithFix(fileName, new String[]{fileName + ".js2"}, "js2");
  }

  public void testUntypedDeclarationForFun2() throws Exception {
    String fileName = getTestName(false);
    runUntypedDeclarationInspectionTestWithFix(fileName, new String[]{fileName + ".js2"}, "js2");
  }

  public void testUntypedDeclarationForFun2_2() throws Exception {
    String fileName = getTestName(false);
    runUntypedDeclarationInspectionTestWithFix(fileName, new String[]{fileName + ".js2"}, "js2");
  }

  public void testUntypedDeclarationForFun2_3() throws Exception {
    String fileName = getTestName(false);
    runUntypedDeclarationInspectionTestWithFix(fileName, new String[]{fileName + ".js2"}, "js2");
  }

  public void testAllowReferenceAnyFieldFromObjectType() throws Exception {
    defaultTest();
  }

  public void testValidateClassAndPackageName() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".js2");
    IntentionAction action = findIntentionAction(infoCollection, "Rename File", myEditor, myFile);
    assertNotNull(action);

    findAndInvokeActionWithExpectedCheck("Rename class 'XXX' to 'ValidateClassAndPackageName'", "js2", infoCollection);
  }

  public void testImportClass() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("yyy.XXX?");
  }

  public void testDoNotImportJSDefinition() throws Exception {
    final Collection<HighlightInfo> infos = defaultTestForTwoFiles();
    assertNull(findIntentionAction(infos, "foo.A.Bar?", getEditor(), getFile()));
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testImportClass_2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("mypackage.Alert?");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testImportClass_3() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("mypackage.Alert?");
  }

  public void testImportNsAddsUseNamespace() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("foo.Foo?");
  }

  public void testNoImportClass() throws Exception {
    configureByFile(getBasePath() + "/" + getTestName(false) + ".js");
    List<HighlightInfo> infoList = doHighlighting();
    IntentionAction intentionAction = findIntentionAction(infoList, "show?", myEditor, myFile);
    assertNull(intentionAction);
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testImportFunction() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("mypackage.getDefinitionByName?");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testNoImportFunction() throws Exception {
    Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".js2");
    IntentionAction action = findIntentionAction(infoCollection, "Bar.foo?", myEditor, myFile);
    assertNull(action);
    infoCollection = doTestFor(true, getTestName(false) + "_2.js2");
    action = findIntentionAction(infoCollection, "Bar.foo?", myEditor, myFile);
    assertNull(action);
  }

  public void testCreateClassOrInterfaceAction() throws Exception {
    doCreateClassOrInterfaceTest("YYY", true, true, true);
  }

  public void testCreateClassOrInterfaceAction2() throws Exception {
    doCreateClassOrInterfaceTest("YYY", false, true, true);
  }

  public void testCreateClassOrInterfaceAction3() throws Exception {
    doCreateClassOrInterfaceTest("Abc", true, false, true);
  }

  public void testCreateClassOrInterfaceAction4() throws Exception {
    doCreateClassOrInterfaceTest("Abc", false, false, true);
  }

  public void testCreateClassOrInterfaceAction5() throws Exception {
    doCreateClassOrInterfaceTest("Abc", false, false, true);
  }

  @SuppressWarnings({"ConstantConditions"})
  private void doCreateClassOrInterfaceTestWithCheck(String name, boolean assertNoErrors) throws Exception {
    JSTestUtils.disableFileHeadersInTemplates(getProject());
    doCreateClassOrInterfaceTest(name, true, false, assertNoErrors);
    setActiveEditor("../foo/" + name + ".as");
    checkResultByFile(BASE_PATH + getTestName(false) + "_created.js2");
  }

  public void testCreateClassOrInterfaceAction6() throws Exception {
    doCreateClassOrInterfaceTestWithCheck("Abc", true);
  }

  public void testCreateClassOrInterfaceAction7() throws Exception {
    String newText = "package ${PACKAGE_NAME}#if (${PACKAGE_NAME} != \"\") #end{\n" +
                     "${Access_modifier} class ${NAME} #if (${Super_class_name} != \"\")extends ${Super_class_name}#end #if (${Implemented_interface_name} != \"\")implements ${Implemented_interface_name}#end{\n" +
                     " \n" +
                     "}\n" +
                     "}";
    String prevText =
      JSTestUtils.modifyTemplate(CreateClassOrInterfaceFix.ACTION_SCRIPT_CLASS_WITH_SUPERS_TEMPLATE_NAME, newText, getProject());
    try {
      doCreateClassOrInterfaceTestWithCheck("Abc", true);
    }
    finally {
      JSTestUtils.modifyTemplate(CreateClassOrInterfaceFix.ACTION_SCRIPT_CLASS_WITH_SUPERS_TEMPLATE_NAME, prevText, getProject());
    }
  }

  public void testCreateClassOrInterfaceAction8() throws Exception {
    String newText = "package ${PACKAGE_NAME}#if (${PACKAGE_NAME} != \"\") #end{\n" +
                     "${Access_modifier} class ${NAME} #if (${Super_class_name} != \"\")extends ${Super_class_name}#end #if (${Implemented_interface_name} != \"\")implements ${Implemented_interface_name}#end{\n" +
                     " \n" +
                     "/**\n" +
                     "* constr\n" +
                     "*/\n" +
                     "    public function ${NAME}() {\n" +
                     "        #if (${Super_class_name} != \"\")super();#end\n" +
                     "        // body\n" +
                     "    }" +
                     "}\n" +
                     "}";
    String prevText =
      JSTestUtils.modifyTemplate(CreateClassOrInterfaceFix.ACTION_SCRIPT_CLASS_WITH_SUPERS_TEMPLATE_NAME, newText, getProject());
    try {
      doCreateClassOrInterfaceTestWithCheck("Abc", false);
    }
    finally {
      JSTestUtils.modifyTemplate(CreateClassOrInterfaceFix.ACTION_SCRIPT_CLASS_WITH_SUPERS_TEMPLATE_NAME, prevText, getProject());
    }
  }

  public void testCreateClassOrInterfaceAction9() throws Exception {
    doCreateClassOrInterfaceTestWithCheck("Abc", true);
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testCreateClassOrInterfaceAction10() throws Exception {
    doCreateClassOrInterfaceTestWithCheck("Abc", true);
  }

  public void testCreateClassOrInterfaceAction11() throws Exception {
    doCreateClassOrInterfaceTestWithCheck("Abc", false);
  }

  private void doCreateClassOrInterfaceTest(final String name,
                                            boolean classNotInterface,
                                            boolean complementaryAvailable,
                                            boolean assertNoErrors)
    throws IOException, IncorrectOperationException {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".js2");
    String classIntentionName = "Create class '" + name + "'";
    String interfaceIntentionName = "Create interface '" + name + "'";
    String actionName = classNotInterface ? classIntentionName : interfaceIntentionName;
    final IntentionAction action = findIntentionAction(infoCollection, actionName, myEditor, myFile);

    assertNotNull(actionName, action);

    String complementaryActionName = classNotInterface ? interfaceIntentionName : classIntentionName;
    IntentionAction complementaryAction = findIntentionAction(infoCollection, complementaryActionName, myEditor, myFile);
    if (complementaryAvailable) {
      assertNotNull(complementaryActionName, complementaryAction);
    }
    else {
      assertNull(complementaryActionName, complementaryAction);
    }

    WriteCommandAction.runWriteCommandAction(null, () -> action.invoke(myProject, myEditor, myFile));

    JSTestUtils.initJSIndexes(getProject());

    if (assertNoErrors) {
      assertEquals(0, JSDaemonAnalyzerTestCase.filterUnwantedInfos(doHighlighting(), this).size());
    }
  }

  @JSTestOptions({JSTestOption.WithLineMarkers})
  public void testHighlightStaticInstanceMembers() throws Exception {
    defaultTest();
  }

  @JSTestOptions({JSTestOption.WithLineMarkers})
  public void testGenerics() throws Exception {
    defaultTest();
  }

  public void testGenerics2() throws Exception {
    defaultTest();
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testVectorLiteral() throws Exception {
    defaultTest();
  }

  public void testFunctionWithModifierNotUnderClass() throws Exception {
    defaultTest();
  }

  public void testReportMissingReturn() throws Exception {
    enableInspectionTool(new FunctionWithInconsistentReturnsJSInspection());
    defaultTest();
  }

  public void testReportMissingReturnFix() throws Exception {
    enableInspectionTool(new FunctionWithInconsistentReturnsJSInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Set return type to void");
  }

  public void testReportMissingReturnFix_2() throws Exception {
    enableInspectionTool(new FunctionWithInconsistentReturnsJSInspection());
    doSimpleHighlightingWithInvokeFixAndCheckResult("Add return statement");
  }

  public void testValidateFunctionAndPackageName() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Set package name to ''");
  }

  public void testValidateFunctionAndPackageName2() throws Exception {
    final String testName = getTestName(false);
    final Collection<HighlightInfo> infoCollection =
      doTestFor(true, new File(getTestDataPath() + getBasePath() + File.separatorChar + testName), (Runnable)null,
                testName + "/aaa/" + testName + ".js2");
    findAndInvokeActionWithExpectedCheck("Set package name to 'aaa'", "js2", infoCollection);
  }

  public void testMissingOverrideWithFix() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Add override modifier");
  }

  public void testMissingOverride_2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Remove override modifier");
  }

  public void testMissingOverrideWithFix2() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".js2");

    IntentionAction action = findIntentionAction(infoCollection, "Add override modifier", myEditor, myFile);
    assertNull(action);

    findAndInvokeActionWithExpectedCheck("Remove access modifier", "js2", infoCollection);
  }

  @JSTestOptions({JSTestOption.WithJsSupportLoader})
  public void testOverridingMarkers() throws Exception {
    doTestFor(true, () -> {
      final PsiElement at = invokeGotoSuperMethodAction("AAA");
      invokeShowImplementations(JSFunction.class, at);
    }, getTestName(false) + ".js2");
  }

  @JSTestOptions({JSTestOption.WithLineMarkers, JSTestOption.WithJsSupportLoader})
  public void testOverridingMarkersWithLineMarkers() throws Exception {
    //enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    defaultTest();
  }

  public void testOverrideTest() throws Exception {
    doOverrideMethodTestWithResultFileCheck();
  }

  public void testOverrideTestCustomNs() throws Exception {
    doOverrideMethodTestWithResultFileCheck();
  }

  public void testOverrideTestCustomNs_2() throws Exception {
    doOverrideMethodTestWithResultFileCheck();
  }

  @JSTestOptions({JSTestOption.WithLineMarkers})
  public void testNoOverrideForInternal() throws Exception {
    DaemonCodeAnalyzerSettings myDaemonCodeAnalyzerSettings = DaemonCodeAnalyzerSettings.getInstance();
    myDaemonCodeAnalyzerSettings.SHOW_METHOD_SEPARATORS = true;
    try {
      defaultTest();
    }
    finally {
      myDaemonCodeAnalyzerSettings.SHOW_METHOD_SEPARATORS = false;
    }
  }

  public void testOverrideInInterface() throws Exception {
    defaultTest();
  }

  public void testOverrideInInterfaceFix() throws Exception {
    configureByFiles(null, BASE_PATH + getTestName(false) + ".js2");
    JSTestUtils.checkThatActionDisabled("OverrideMethods");
    JSTestUtils.checkThatActionDisabled("ImplementMethods");
  }

  public void testOverridePackageLocal() throws Exception {
    doOverrideMethodTestWithResultFileCheck();
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testOverrideFunWithRestParameter() throws Exception {
    doOverrideMethodTestWithResultFileCheck();
  }

  private void doOverrideMethodTestWithResultFileCheck() throws Exception {
    configureByFiles(null, BASE_PATH + getTestName(false) + ".js2");
    invokeNamedActionWithExpectedFileCheck(getTestName(false), "OverrideMethods", "js2");
  }

  public void testOverrideInInterfaceFix2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Add override modifier");
  }

  public void testImplementTest() throws Exception {
    configureByFiles(null, BASE_PATH + getTestName(false) + ".js2");
    invokeNamedActionWithExpectedFileCheck(getTestName(false), "ImplementMethods", "js2");
  }

  @JSTestOptions({JSTestOption.WithLineMarkers, JSTestOption.WithJsSupportLoader})
  public void testOverridingMarkers2() throws Exception {
    //enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doTestFor(true, () -> {
      checkSetProperty(myFile.findElementAt(myEditor.getCaretModel().getOffset()));
      PsiElement at = invokeGotoSuperMethodAction("AAA");
      checkSetProperty(at);
      at = invokeShowImplementations(JSFunction.class, at);
      checkSetProperty(at);
      at = invokeGotoSuperMethodAction("IAAA");
      checkSetProperty(at);
    }, getTestName(false) + ".js2");
  }

  @JSTestOptions({JSTestOption.WithLineMarkers, JSTestOption.WithJsSupportLoader})
  public void testOverridingMarkers3() throws Exception {
    //enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doTestFor(true, () -> {
      checkGetProperty(myFile.findElementAt(myEditor.getCaretModel().getOffset()));
      PsiElement at = invokeGotoSuperMethodAction("AAA");
      checkGetProperty(at);
      at = invokeShowImplementations(JSFunction.class, at);
      checkGetProperty(at);
      at = invokeGotoSuperMethodAction("IAAA");
      checkGetProperty(at);
    }, getTestName(false) + ".js2");
  }

  @JSTestOptions(JSTestOption.WithJsSupportLoader)
  public void testShowImplementationsForStatic() throws Exception {
    doTestFor(true, () -> JSTestUtils
                .invokeShowImplementations(JSFunction.class, myFile.findElementAt(myEditor.getCaretModel().getOffset()), 0, true),
              getTestName(false) + ".js2");
  }

  private static void checkSetProperty(final PsiElement at) {
    final JSFunction parentOfType = PsiTreeUtil.getParentOfType(at, JSFunction.class, false);
    assertNotNull(parentOfType);
    assertTrue(parentOfType.isSetProperty());
  }

  private static void checkGetProperty(final PsiElement at) {
    final JSFunction parentOfType = PsiTreeUtil.getParentOfType(at, JSFunction.class, false);
    assertNotNull(parentOfType);
    assertTrue(parentOfType.isGetProperty());
  }

  @JSTestOptions({JSTestOption.WithJsSupportLoader})
  public void testLocalClasses() throws Exception {
    final String fileName = getTestName(false) + ".js2";
    doTestFor(true, () -> {
      PsiElement at = myFile.findElementAt(myEditor.getCaretModel().getOffset());
      invokeShowImplemenationsForLineMarker(at, 1);
      PsiElement elt = JSTestUtils.invokeShowImplementations(JSClass.class, at, 1, false);

      assertNull(ActionScriptClassResolver.findClassByQNameStatic("BaseType", elt));
      PsiElement byQName = JSClassResolver.findClassFromNamespace("BaseType", elt);
      assertEquals(fileName, byQName.getContainingFile().getName());

      byQName = JSClassResolver.findClassFromNamespace("DerivedType", elt);
      assertEquals(fileName, byQName.getContainingFile().getName());
    }, fileName, getTestName(false) + "_2.js2");
  }

  @JSTestOptions({JSTestOption.WithJsSupportLoader})
  public void testGotoSuperWorksFromClass() throws Exception {
    doTestFor(true, () -> {
      final PsiElement at = invokeGotoSuperMethodAction("AAA");
      JSTestUtils.invokeShowImplementations(JSClass.class, at, 1, false);
      invokeShowImplemenationsForLineMarker(at, 1);
    }, getTestName(false) + ".js2");
  }

  @JSTestOptions({JSTestOption.WithJsSupportLoader, JSTestOption.WithLineMarkers})
  public void testImplementsAndImplementedMarkers() throws Exception {
    //enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    doTestFor(true, () -> {
      PsiElement at = invokeGotoSuperMethodAction("SecondInterface");
      JSTestUtils.invokeShowImplementations(JSFunction.class, at, 3, false);
      invokeShowImplemenationsForLineMarker(at, 5);
    }, getTestName(false) + ".js2");
  }

  @JSTestOptions({JSTestOption.WithJsSupportLoader})
  public void testShowImplementationsFromInterface() throws Exception {
    doTestFor(true, () -> {
      final PsiElement at = myFile.findElementAt(myEditor.getCaretModel().getOffset());
      JSTestUtils.invokeShowImplementations(JSClass.class, at, 3, false);
      invokeShowImplemenationsForLineMarker(at, 3);
    }, getTestName(false) + ".js2");
  }

  @JSTestOptions({JSTestOption.WithJsSupportLoader, JSTestOption.WithLineMarkers})
  public void testShowImplementationsFromInterface2() throws Exception {
    doTestFor(true, () -> {
      final PsiElement at = myFile.findElementAt(myEditor.getCaretModel().getOffset());
      JSTestUtils.invokeShowImplementations(JSClass.class, at, 2, false);
      invokeShowImplemenationsForLineMarker(at, 2);
    }, getTestName(false) + ".js2");
  }

  @JSTestOptions({JSTestOption.WithJsSupportLoader})
  public void testShowImplementationsFromInterfaceCall() throws Exception {
    doTestFor(true, () -> {
      final PsiElement at = myFile.findElementAt(myEditor.getCaretModel().getOffset());
      JSTestUtils.invokeShowImplementations(JSFunction.class, at, 1, false);
    }, getTestName(false) + ".js2");
  }

  private PsiElement invokeGotoSuperMethodAction(@NonNls String destinationClassName) {
    return invokeActionWithCheck(destinationClassName, IdeActions.ACTION_GOTO_SUPER);
  }

  private PsiElement invokeActionWithCheck(@NonNls String destinationClassName, @NonNls final String actionName) {
    PlatformTestUtil.invokeNamedAction(actionName);
    final PsiElement at = myFile.findElementAt(myEditor.getCaretModel().getOffset());
    JSClass clazz = PsiTreeUtil.getParentOfType(at, JSClass.class);

    assertEquals(destinationClassName, clazz.getName());

    return at;
  }

  private static PsiElement invokeShowImplementations(final Class<? extends JSNamedElement> destinationClazz, final PsiElement at) {
    return JSTestUtils.invokeShowImplementations(destinationClazz, at, 1, true);
  }

  private static void invokeShowImplemenationsForLineMarker(PsiElement at, int num) {
    JSClass c = PsiTreeUtil.getParentOfType(at, JSClass.class);
    int items = (c.isInterface()
                 ? JavaScriptLineMarkerProvider.ourInterfaceImplementationsNavHandler
                 : JavaScriptLineMarkerProvider.ourClassInheritorsNavHandler).search(c).findAll().size();
    assertEquals(num, items);
  }

  @JSTestOptions(JSTestOption.WithoutWarnings)
  public void testMoreThanOneTopLevelSymbolDeclared() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(false);
    final IntentionAction action = findIntentionAction(infoCollection, "Remove externally visible symbol", myEditor, myFile);
    assertNotNull(action);
  }

  @JSTestOptions({/*JSTestOption.WithoutSourceRoot,*/ JSTestOption.WithFlexSdk})
  public void testMoreThanOneTopLevelSymbolDeclared2() throws Exception {
    doTestFor(true);
  }

  @JSTestOptions({JSTestOption.WithUnusedImports})
  public void testImportInClass() throws Exception {
    enableInspectionTool(new BadExpressionStatementJSInspection());
    doTestFor(true);
  }

  @JSTestOptions({JSTestOption.WithJsSupportLoader, JSTestOption.WithFlexSdk})
  public void testImplementingInterface() throws Exception {
    final String testName = getTestName(false);
    doTestFor(true, (Runnable)null, testName + ".js2", testName + "_2.js2");
    invokeNamedActionWithExpectedFileCheck(testName, "ImplementMethods", "js2");
  }

  @JSTestOptions({JSTestOption.WithJsSupportLoader, JSTestOption.WithFlexSdk})
  public void testImplementingInterface2() throws Exception {
    final String testName = getTestName(false);
    doTestFor(true, (Runnable)null, testName + ".js2", testName + "_2.js2");
    invokeNamedActionWithExpectedFileCheck(testName, "ImplementMethods", "js2");
  }

  @JSTestOptions({JSTestOption.WithJsSupportLoader, JSTestOption.WithFlexFacet, JSTestOption.WithGumboSdk})
  public void testImplementingInterfaceVector() throws Exception {
    final String testName = getTestName(false);
    doTestFor(true, (Runnable)null, testName + ".js2", testName + "_2.js2");
    invokeNamedActionWithExpectedFileCheck(testName, "ImplementMethods", "js2");
  }

  @JSTestOptions({JSTestOption.WithJsSupportLoader, JSTestOption.WithFlexSdk, JSTestOption.WithUnusedImports})
  public void testOptimizeImports() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    final String testName = getTestName(false);
    Collection<HighlightInfo> infos = doTestFor(true, (Runnable)null, testName + ".js2", testName + "_2.js2");
    findAndInvokeIntentionAction(infos, "Optimize imports", myEditor, myFile);
    checkResultByFile(BASE_PATH + getTestName(false) + "_after.js2");
  }

  public void testNonImplementedInterface() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(false);
    findAndInvokeIntentionAction(infoCollection, "Implement Methods", myEditor, myFile);
    checkResultByFile(BASE_PATH + getTestName(false) + "_after.js2");
    JSTestUtils.initJSIndexes(getProject());

    final Collection<HighlightInfo> infoCollection1 = filterUnwantedInfos(doHighlighting(), this);
    assertEquals(infoCollection.size() - 1, infoCollection1.size());
  }

  public void testNonImplementedInterface2() throws Exception {
    doTestFor(false, () -> {
      final int offset = myEditor.getCaretModel().getOffset();
      invokeGotoSuperMethodAction("FirstClass");
      myEditor.getCaretModel().moveToOffset(offset);
      invokeActionWithCheck("FirstInterface", "GotoTypeDeclaration");
    });
  }

  public void testNonImplementedInterface3() throws Exception {
    final String testName = getTestName(false);

    doTestFor(false, testName + ".js2", testName + "_2.js2");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testUnresolvedThisInCallback() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    final String testName = getTestName(false);

    doTestFor(true, testName + ".js2");
  }

  public void testThisTypeInTopLevelFunction() throws Exception {
    defaultTest();
  }

  public void testHighlightThingsFromUnopenedNamespaces() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    final String testName = getTestName(false);

    doTestFor(true, testName + ".js2");
  }

  public void testDoNotResolveStuffFromObject() throws Exception {
    defaultTest();
  }

  public void testHighlightInternalThingsFromOtherPackage() throws Exception {
    defaultTest();
  }

  public void testImportWithStar() throws Exception {
    doTest(BASE_PATH + getTestName(false) + ".js2", true, false, true);
  }

  public void testWithStatement() throws Exception {
    doTest(BASE_PATH + getTestName(false) + ".js2", true, false, true);
  }

  public void testStringMethodsBug() throws Exception {
    defaultTest();
  }

  public void testDynamicResolve() throws Exception {
    defaultTest();
  }

  @JSTestOptions(JSTestOption.WithFlexFacet)
  public void testConditionalBlocks() throws Exception {
    FlexTestUtils.modifyBuildConfiguration(myModule, bc -> bc.getCompilerOptions()
      .setAllOptions(Collections.singletonMap("compiler.define", "CONFIG::debugging\t")));

    enableInspectionTool(new BadExpressionStatementJSInspection());
    defaultTest();
  }

  public void testConstWithBindAnnotation() throws Exception {
    defaultTest();
  }

  public void testGetMethod() throws Exception {
    defaultTest();
  }

  public void testHighlightInternalThingsFromOtherFiles() throws Exception {
    enableInspectionTool(new JSUnusedLocalSymbolsInspection());
    final String testName = getTestName(false);

    doTestFor(true, testName + ".js2", testName + "_2.js2");
  }

  @Override
  protected String getBasePath() {
    return BASE_PATH.substring(0, BASE_PATH.length() - 1);
  }

  @Override
  @NonNls
  protected String getExtension() {
    return "js2";
  }

  public void testUsingNonPublicNamespace() throws Exception {
    doTestFor(true, getTestName(false) + ".as", getTestName(false) + "_2.as");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk, JSTestOption.WithUnusedImports})
  public void testMethodFromNamespace() throws Exception {
    doTestFor(true, getTestName(false) + ".as");
  }

  public void testNumberToString() throws Exception {
    doTestFor(true, getTestName(false) + ".as");
  }

  @JSTestOptions({JSTestOption.WithGumboSdk})
  public void testVectorElementTypeIncompatible() throws Exception {
    doTestFor(true, getTestName(false) + ".as");
  }

  @JSTestOptions({JSTestOption.WithLineMarkers})
  public void testImplementingMarkerFromSwc() throws Exception {
    myAfterCommitRunnable =
      () -> FlexTestUtils.addLibrary(myModule, "Lib", getTestDataPath() + BASE_PATH, "ImplementingMarkerFromSwc.swc", null, null);
    doTestFor(true, getTestName(false) + ".as");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk, JSTestOption.WithUnusedImports})
  public void testNoFqnReplaceInsideNamesake() throws Exception { // IDEADEV-37712
    doTestFor(true, getTestName(false) + ".as", getTestName(false) + "_2.as");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk, JSTestOption.WithLineMarkers})
  public void testImplicitImplementMarker() throws Exception {
    doTestFor(true, getTestName(false) + ".as");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testImplicitImplementMarker_() throws Exception {
    doTestFor(true, () -> {
      final PsiElement element =
        JSTestUtils.invokeShowImplementations(JSFunction.class, myFile.findElementAt(myEditor.getCaretModel().getOffset()), 1, false);
      assertTrue(element instanceof JSFunction);
      assertTrue(element.getParent() instanceof JSClass);
      assertEquals("Base", ((JSClass)element.getParent()).getQualifiedName());
    }, getTestName(false) + ".as");
  }


  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testQualified() throws Exception {
    doTestFor(true, getTestName(false) + ".as", getTestName(false) + "_2.as");
  }

  public void testResolveToPackage() throws Exception {
    doTestFor(true, getTestName(false) + ".js2", getTestName(false) + "_2.js2");
  }

  @JSTestOptions({JSTestOption.WithUnusedImports})
  public void testEmptyImport() throws Exception {
    doTestFor(true, getTestName(false) + ".as", getTestName(false) + "_2.as");
  }

  public void testCastAmbiguousType() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".js2", getTestName(false) + "_2.js2");
    findAndInvokeActionWithExpectedCheck("Insert cast", "js2", infoCollection);
  }

  public void testStaticMethodInInterface() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck(JSBundle.message("javascript.fix.remove.static.modifier"), "as", infoCollection);
  }

  public void testMultipleVarsInPackage() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck(JSBundle.message("javascript.fix.remove.externally.visible.symbol"), "as", infoCollection);
  }

  public void testFieldCannotOverride() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck(JSBundle.message("javascript.fix.remove.override.modifier"), "as", infoCollection);
  }

  public void testNoStaticFunctionWithoutClass() throws Exception {
    defaultTest();
  }

  public void testInaccessibleRefsReported() throws Exception {
    Collection<HighlightInfo> highlightInfos = defaultTest();
    assertInaccessible(highlightInfos, "foo.InaccessibleRefsReported?");
    assertInaccessible(highlightInfos, "Create class 'InaccessibleRefsReported'");
  }

  public void testNamespaceDeclarationIsImplicitlyStatic() throws Exception {
    defaultTest();
  }

  public void testStaticMethodCannotBeFinal() throws Exception {
    defaultTest();
  }

  public void testReportWarningWhenUsingFieldOrMethodOnSomeDynamicClassInstance() throws Exception {
    defaultTest();
  }

  public void testReportMultipleDynamicModifiers() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Remove dynamic modifier");
  }

  public void testAs2() throws Exception {
    defaultTest();
  }

  public void testOverrideVisibility() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as", getTestName(false) + "_2.as");
    findAndInvokeActionWithExpectedCheck(JSBundle.message("javascript.fix.set.element.visibility", "method foo", "protected"), "as",
                                         infoCollection);
  }

  public void testOverrideVisibility2() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as", getTestName(false) + "_2.as");
    findAndInvokeActionWithExpectedCheck(JSBundle.message("javascript.fix.set.element.visibility", "method foo", "public"), "as",
                                         infoCollection);
  }

  @JSTestOptions(JSTestOption.WithUnusedImports)
  public void testNoPackageNameReplacement() throws Exception {
    final String testName = getTestName(false);
    doTestFor(true, new File(getTestDataPath() + getBasePath() + File.separatorChar + testName), (Runnable)null,
              testName + "/com/view/Test.as",
              testName + "/com/view.as");
  }

  @JSTestOptions(JSTestOption.WithUnusedImports)
  public void testNoPackageNameReplacement2() throws Exception {
    final String testName = getTestName(false);
    doTestFor(true, new File(getTestDataPath() + getBasePath() + File.separatorChar + testName), (Runnable)null,
              testName + "/com/zzz/Foo.as", testName + "/com/view/Test.as", testName + "/com/view.as");
  }

  @JSTestOptions(JSTestOption.WithoutSourceRoot)
  public void testNoCreateClassFixWithNoSourceRoots() throws Exception {
    Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    IntentionAction intentionAction = findIntentionAction(infoCollection, "Create class Base", myEditor, myFile);
    assertNull(intentionAction);
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testConditionalCompileBlock() throws Exception {
    Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck("flash.events.KeyboardEvent?", "as", infoCollection);
  }

  public void testStaticBlock() throws Exception {
    doTestFor(true, getTestName(false) + ".as");
  }

  @JSTestOptions({JSTestOption.WithLineMarkers})
  public void testNullQualifiedName() throws Exception {
    doTestFor(true, getTestName(false) + ".as");
  }

  // IDEA-56342
  @JSTestOptions({JSTestOption.WithFlexFacet})
  public void testMultinamesInDecompiledSwc() throws Exception {
    myAfterCommitRunnable =
      () -> FlexTestUtils.addLibrary(myModule, "playerglobal", FlexImporterTest.getTestDataPath(), "PlayerGlobal10.swc", null, null);
    doTestFor(true, getTestName(false) + ".as");
  }

  public void testSetterOptionalParam() throws Exception {
    Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck("Remove parameter default value", "as", infoCollection);
  }

  public void testDelegateMethodsDisabled() throws Exception {
    configureByFiles(null, BASE_PATH + getTestName(false) + ".js2");
    JSTestUtils.checkThatActionDisabled("DelegateMethods");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testDelegateMethods() throws Exception {
    String testName = getTestName(false);
    configureByFiles(null, BASE_PATH + testName + ".js2", BASE_PATH + testName + "_2.js2");
    invokeNamedActionWithExpectedFileCheck(testName, "DelegateMethods", "js2");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testDelegateMethods2() throws Exception {
    String testName = getTestName(false);
    configureByFiles(null, BASE_PATH + testName + ".js2", BASE_PATH + testName + "_2.js2");
    invokeNamedActionWithExpectedFileCheck(testName, "DelegateMethods", "js2");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testDelegateMethods3() throws Exception {
    String testName = getTestName(false);
    configureByFiles(null, BASE_PATH + testName + ".js2", BASE_PATH + testName + "_2.js2");
    invokeNamedActionWithExpectedFileCheck(testName, "DelegateMethods", "js2");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testDelegateMethods4() throws Exception {
    String testName = getTestName(false);
    configureByFiles(null, BASE_PATH + testName + ".js2", BASE_PATH + testName + "_2.js2", BASE_PATH + testName + "_3.js2");
    invokeNamedActionWithExpectedFileCheck(testName, "DelegateMethods", "js2");
  }

  public void testDelegateMethods5() throws Exception {
    String testName = getTestName(false);
    configureByFiles(null, BASE_PATH + testName + ".js2", BASE_PATH + testName + "_2.js2");
    invokeNamedActionWithExpectedFileCheck(testName, "DelegateMethods", "js2");
  }

  public void testRemoveGetterParameter() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck(JSBundle.message("javascript.fix.remove.parameter"), "as", infoCollection);
  }

  public void testRemoveGetterParameters() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck(JSBundle.message("javascript.fix.remove.parameters"), "as", infoCollection);
  }

  public void testImportForNeighbourClass() throws Exception {
    doTestFor(true, getTestName(false) + ".as", getTestName(false) + "_2.as");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testInvalidAttribute() throws Exception {
    doTestFor(true, getTestName(false) + ".as");
  }

  @JSTestOptions(JSTestOption.WithLineMarkers)
  public void testStaticMethodDoesNotImplement() throws Exception {
    final Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    invokeGotoSuperMethodAction("Impl");
    findAndInvokeActionWithExpectedCheck(JSBundle.message("javascript.fix.implement.methods"), "as", infos);
  }

  @JSTestOptions({JSTestOption.WithLineMarkers, JSTestOption.WithoutSourceRoot})
  public void testLineMarkersInLibrarySource() throws Exception {
    myAfterCommitRunnable = new Runnable() {
      @Override
      public void run() {
        VirtualFile file = ModuleRootManager.getInstance(myModule).getContentEntries()[0].getFile();
        VirtualFile fakeClassFile = getVirtualFile(BASE_PATH + "/" + getTestName(false) + "_2.js2");
        try {
          VirtualFile classesDir = file.createChildDirectory(this, "classes");
          VfsUtilCore.copyFile(this, fakeClassFile, classesDir);
        }
        catch (IOException e) {
          throw new RuntimeException(e);
        }
        FlexTestUtils.addFlexLibrary(true, myModule, "lib", true, file.getPath(), "classes", "", null);

        ModifiableRootModel model = ModuleRootManager.getInstance(myModule).getModifiableModel();
        model.removeContentEntry(model.getContentEntries()[0]);
        model.commit();
      }
    };

    doTestFor(true, getTestName(false) + ".js2");
  }

  public void testNoTypeGuessFromAsdoc() throws Exception {
    final Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck("Create Field 'aa'", "as", infos);
  }

  public void testNoTypeGuessFromAsdoc2() throws Exception {
    final Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck("Create Field 'aa'", "as", infos);
  }

  public void testNoImportSuggestForTestClass() throws Exception {
    myAfterCommitRunnable = () -> {
      final VirtualFile testsRoot = getVirtualFile(BASE_PATH + getTestName(false) + "_2");
      PsiTestUtil.addSourceContentToRoots(myModule, testsRoot, true);
    };
    final Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    assertInaccessible(infos, "a.TestClass?");
  }

  public void testImportSuggestForProductionClass() throws Exception {
    myAfterCommitRunnable = () -> {
      final ContentEntry[] contentEntries = ModuleRootManager.getInstance(myModule).getContentEntries();
      final VirtualFile file = contentEntries[0].getFile();
      PsiTestUtil.removeContentEntry(myModule, contentEntries[0].getFile());
      PsiTestUtil.addSourceContentToRoots(myModule, file, true);
      final VirtualFile productionRoot = getVirtualFile(BASE_PATH + getTestName(false) + "_2");
      PsiTestUtil.addSourceContentToRoots(myModule, productionRoot, false);
    };
    final Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    assertNotNull(findIntentionAction(infos, "a.ProductionClass?", myEditor, myFile));
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testExtraEmptyLineInImport() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as", getTestName(false) + "_2.as");
    findAndInvokeActionWithExpectedCheck("cocoa.plaf.LookAndFeelUtil?", "as", infoCollection);
  }

  @JSTestOptions(JSTestOption.WithGumboSdk)
  public void testNoChangeSignatureForLibraryMethod() throws Exception {
    final Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".js2");
    assertInaccessible(infos, "Change decodeURI() signature");
  }

  public void testStripQuotes1() throws Exception {
    checkActionAvailable("Insert cast", true);
  }

  public void testStripQuotes2() throws Exception {
    checkActionAvailable("Insert cast", true);
  }

  public void testStripQuotes3() throws Exception {
    checkActionAvailable("Insert cast", true);
  }

  public void testStripQuotes4() throws Exception {
    checkActionAvailable("Insert cast", true);
  }

  public void testStripQuotes5() throws Exception {
    checkActionAvailable("Insert cast", false);
  }

  public void testStripQuotes6() throws Exception {
    checkActionAvailable("Insert cast", false);
  }

  public void testStripQuotes7() throws Exception {
    checkActionAvailable("Insert cast", false);
  }

  private void checkActionAvailable(String name, boolean available) throws IOException {
    Collection<HighlightInfo> infos = defaultTest();
    IntentionAction action = findIntentionAction(infos, name, myEditor, myFile);
    if (available) {
      assertNotNull(action);
    }
    else {
      assertNull(action);
    }
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testNoCreateFieldInSdkClass() throws Exception {
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    assertInaccessible(infos, "Create field 'foo'");
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testNoCreateMethodInLibraryClass() throws Exception {
    myAfterCommitRunnable =
      () -> FlexTestUtils.addLibrary(myModule, "Lib", getTestDataPath() + BASE_PATH, "ImplementingMarkerFromSwc.swc", null, null);
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    assertInaccessible(infos, "Create Method 'bar'");
  }

  public void testInternalClassFromFileLocal() throws Exception {
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    assertInaccessible(infos, "Create Method 'z'");
    findAndInvokeActionWithExpectedCheck("Make method z public", "as", infos);
  }

  public void testInternalClassFromFileLocal2() throws Exception {
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck("Make class InternalClassFromFileLocal2 public", "as", infos);
  }

  public void testRelaxVisibilityFix() throws Exception {
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    assertInaccessible(infos, "Create Field 'v'");
    assertInaccessible(infos, "Create Constant Field 'v'");
    findAndInvokeActionWithExpectedCheck("Make field v internal", "as", infos);
  }

  public void testRelaxVisibilityFix2() throws Exception {
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    assertInaccessible(infos, "Create Method 'foo'");
    findAndInvokeActionWithExpectedCheck("Make method foo public", "as", infos);
  }

  public void testRelaxVisibilityFix3() throws Exception {
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck("Make field foo internal", "as", infos);
  }

  public void testRelaxVisibilityFix4() throws Exception {
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck("Make field foo protected", "as", infos);
  }

  public void testRelaxVisibilityFix5() throws Exception {
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck("Make field foo protected", "as", infos);
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testChangeVarTypeFix1() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change 'v2' type to 'flash.display.Sprite'");
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testChangeVarTypeFix2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change 'v' type to 'mypackage.IResourceManager'");
  }

  @JSTestOptions({JSTestOption.WithFlexFacet, JSTestOption.WithGumboSdk})
  public void testChangeVarTypeFix3() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change 'v2' type to 'Vector.<String>'");
  }

  public void testChangeParamTypeFix() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".js2");
    assertInaccessible(infoCollection, "Change 'i' type to 'ChangeParamTypeFix'");
    findAndInvokeActionWithExpectedCheck("Change ChangeParamTypeFix.foo() signature", "js2", infoCollection);
  }

  public void testChangeReturnTypeFix1() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make 'foo' return 'String'");
  }

  public void testChangeReturnTypeFix2() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".js2");
    assertInaccessible(infoCollection, "Make 'foo' return 'String'");
    findAndInvokeActionWithExpectedCheck("Change Foo123.foo() signature", "js2", infoCollection);
  }

  public void testChangeReturnTypeFix3() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make 'foo' return 'ChangeReturnTypeFix3'");
  }

  public void testCreateImplementsFix1() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make 'CreateImplementsFix1' implement 'com.foo.MyInt'");
  }

  public void testCreateImplementsFix2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make 'CreateImplementsFix2' implement 'com.foo.MyInt'");
  }

  public void testCreateExtendsFix1() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make 'CreateExtendsFix1' extend 'C'");
  }

  public void testCreateExtendsFix2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make 'CreateExtendsFix2' extend 'C'");
  }

  public void testCreateExtendsFix3() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make 'C' extend 'com.D'");
  }

  public void testCreateExtendsFix4() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Make 'I2' extend 'I1'");
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testChangeSignatureFixForIncompatibleReturnType1() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change ChangeSignatureFixForIncompatibleReturnType1.foo() signature");
  }

  public void testChangeSignatureFixForIncompatibleReturnType2() throws Exception {
    doSimpleHighlightingWithInvokeFixAndCheckResult("Change ChangeSignatureFixForIncompatibleReturnType2.foo() signature");
  }

  public void testNoChangeSignatureFixForVoidType() throws Exception {
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    assertInaccessible(infos, "Change NoChangeSignatureFixForVoidType.bar() signature");
  }

  public void testNoChangeTypeFixForVoidType() throws Exception {
    Collection<HighlightInfo> infos = doTestFor(true, getTestName(false) + ".as");
    assertInaccessible(infos, "Change 'v' type to 'void'");
  }

  private void assertInaccessible(Collection<HighlightInfo> infos, String actionName) {
    assertNull("Action '" + actionName + "' should not be available", findIntentionAction(infos, actionName, myEditor, myFile));
  }

  public void testBadResolveOfSuperclass() throws Exception {
    final Module module2 = doCreateRealModuleIn("module2", myProject, FlexModuleType.getInstance());
    final Ref<VirtualFile> fileFromModule2 = new Ref<>();
    final Ref<Sdk> sdk1 = new Ref<>();
    final Ref<Sdk> sdk2 = new Ref<>();
    myAfterCommitRunnable = () -> {
      sdk1.set(FlexTestUtils.createSdk(getTestDataPath() + BASE_PATH + "fake_sdk", "4.0.0"));
      {
        SdkModificator m = sdk1.get().getSdkModificator();
        m.removeAllRoots();
        m.addRoot(sdk1.get().getHomeDirectory().findChild("common_root"), OrderRootType.CLASSES);
        m.addRoot(sdk1.get().getHomeDirectory().findChild("flex_root"), OrderRootType.CLASSES);
        m.commitChanges();
      }
      sdk2.set(FlexTestUtils.createSdk(getTestDataPath() + BASE_PATH + "fake_sdk", "4.0.0"));
      {
        SdkModificator m = sdk2.get().getSdkModificator();
        m.removeAllRoots();
        m.addRoot(sdk2.get().getHomeDirectory().findChild("common_root"), OrderRootType.CLASSES);
        m.addRoot(sdk2.get().getHomeDirectory().findChild("air_root"), OrderRootType.CLASSES);
        m.commitChanges();
      }
      fileFromModule2.set(copyFileToModule(module2, getTestDataPath() + BASE_PATH + getTestName(false) + "2.as"));
    };
    configureByFile(BASE_PATH + getTestName(false) + "1.as");

    FlexTestUtils.modifyConfigs(myProject, e -> {
      FlexTestUtils.setSdk(e.getConfigurations(myModule)[0], sdk1.get());
      FlexTestUtils.setSdk(e.getConfigurations(module2)[0], sdk2.get());
    });

    checkHighlighting(new ExpectedHighlightingData(myEditor.getDocument(), true, true, false, myFile));

    myFile = PsiManager.getInstance(myProject).findFile(fileFromModule2.get());
    myEditor = createEditor(fileFromModule2.get());
    checkHighlighting(new ExpectedHighlightingData(myEditor.getDocument(), true, true, false, myFile));
  }

  private VirtualFile copyFileToModule(Module module, String filePath) {
    try {
      VirtualFile dir = myProject.getBaseDir().createChildDirectory(this, "module2");
      PsiTestUtil.addSourceRoot(module, dir);
      VirtualFile f = LocalFileSystem.getInstance().findFileByPath(filePath);
      return VfsUtilCore.copyFile(this, f, dir);
    }
    catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  public void testUnusedVariableValues() throws Exception {
    enableInspectionTool(new JSUnusedAssignmentInspection());
    enableInspectionTool(new JSUnusedGlobalSymbolsInspection());

    defaultTest();
  }

  public void testUnusedVariableValues2() throws Exception {
    enableInspectionTool(new JSUnusedAssignmentInspection());

    defaultTest();
  }

  public void testUnresolvedReferencePattern() throws Exception {
    defaultTest();
  }

  public void testImplicitImplementationByPublicBindableProperty() throws Exception {
    defaultTest();
  }

  public void testInitializeParameterFix() throws Exception {
    doHighlightingWithInvokeFixAndCheckResult("Initialize parameter", "as");
  }

  public void testSuperclassResolveMixedRoots() throws Exception {
    // we need two SDKs so that flash.net.FileReference from SDK 4.6/playerglobal.swc
    // has more recent timestamp than its brother from SDK 4.5/airglobal.swc
    final Sdk sdk45 = FlexTestUtils.createSdk(FlexTestUtils.getPathToCompleteFlexSdk("4.5"), null, true);
    final Sdk sdk46 = FlexTestUtils.createSdk(FlexTestUtils.getPathToCompleteFlexSdk("4.6"), null, false);
    FlexTestUtils.modifyConfigs(myProject, e -> {
      ModifiableFlexBuildConfiguration bc1 = e.getConfigurations(myModule)[0];
      bc1.setTargetPlatform(TargetPlatform.Desktop);
      FlexTestUtils.setSdk(bc1, sdk45);

      ModifiableFlexBuildConfiguration bc2 = e.createConfiguration(myModule);
      bc2.setName("2");
      bc1.setTargetPlatform(TargetPlatform.Mobile);
      FlexTestUtils.setSdk(bc2, sdk46);
    });
    defaultTest();
  }

  public void testFieldResolveMixedRoots() throws Exception {
    // same as testSuperclassResolveMixedRoots()
    final Sdk sdk45 = FlexTestUtils.createSdk(FlexTestUtils.getPathToCompleteFlexSdk("4.5"), null, true);
    final Sdk sdk46 = FlexTestUtils.createSdk(FlexTestUtils.getPathToCompleteFlexSdk("4.6"), null, false);
    FlexTestUtils.modifyConfigs(myProject, e -> {
      ModifiableFlexBuildConfiguration bc1 = e.getConfigurations(myModule)[0];
      bc1.setTargetPlatform(TargetPlatform.Desktop);
      FlexTestUtils.setSdk(bc1, sdk45);

      ModifiableFlexBuildConfiguration bc2 = e.createConfiguration(myModule);
      bc2.setName("2");
      bc1.setTargetPlatform(TargetPlatform.Mobile);
      FlexTestUtils.setSdk(bc2, sdk46);
    });
    defaultTest();
  }

  public void testHangingCommaInRefList() throws Exception {
    defaultTest();
  }

  public void testAddOverrideModifierWithMetadata() throws Exception {
    doHighlightingWithInvokeFixAndCheckResult("Add override modifier", "as");
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testFileLocalClassInheritance() throws Exception {
    defaultTest();
  }

  @JSTestOptions({JSTestOption.WithFlexSdk})
  public void testCorrectScopeForSuperclassCheck() throws Exception {
    doTestFor(true, getTestName(false) + ".js2", getTestName(false) + "_2.js2");
  }

  public void testSameClassAndPackage() throws Exception {
    doTestFor(true, getTestName(false) + ".js2", getTestName(false) + "_2.js2");
  }

  public void testNonExistingMethodAfterNew() throws Exception {
    doHighlightingWithInvokeFixAndCheckResult("Create Method 'zzz'", "js2");
  }

  public void testCorrectScopeForSuperclassCheck2() throws Exception { //
    final Sdk sdk46 = FlexTestUtils.createSdk(FlexTestUtils.getPathToCompleteFlexSdk("4.6"), null, false);
    FlexTestUtils.modifyConfigs(myProject, e -> {
      ModifiableFlexBuildConfiguration bc1 = e.getConfigurations(myModule)[0];
      bc1.setName("web");
      bc1.setTargetPlatform(TargetPlatform.Web);
      FlexTestUtils.setSdk(bc1, sdk46);

      ModifiableFlexBuildConfiguration bc2 = e.createConfiguration(myModule);
      bc2.setName("air");
      bc1.setTargetPlatform(TargetPlatform.Desktop);
      FlexTestUtils.setSdk(bc2, sdk46);
    });
    FlexBuildConfigurationManager m = FlexBuildConfigurationManager.getInstance(myModule);
    m.setActiveBuildConfiguration(m.findConfigurationByName("air"));
    defaultTest();
  }

  public void testCorrectScopeForSuperclassCheck3() throws Exception { // IDEA-91539
    final Sdk sdk46 = FlexTestUtils.createSdk(FlexTestUtils.getPathToCompleteFlexSdk("4.6"), null, false);
    FlexTestUtils.modifyConfigs(myProject, e -> {
      ModifiableFlexBuildConfiguration bc1 = e.getConfigurations(myModule)[0];
      bc1.setTargetPlatform(TargetPlatform.Desktop);
      FlexTestUtils.setSdk(e.getConfigurations(myModule)[0], sdk46);
    });
    doTestFor(true, getTestName(false) + ".js2", getTestName(false) + "_2.mxml");
  }

  public void testCorrectScopeForSuperclassCheck4() throws Exception {
    // two dependent modules, different SDKs
    final Module module2 = doCreateRealModuleIn("module2", myProject, FlexModuleType.getInstance());
    final Sdk sdk45 = FlexTestUtils.createSdk(FlexTestUtils.getPathToCompleteFlexSdk("4.5"), null, false);
    final Sdk sdk46 = FlexTestUtils.createSdk(FlexTestUtils.getPathToCompleteFlexSdk("4.6"), null, false);
    FlexTestUtils.modifyConfigs(myProject, e -> {
      ModifiableFlexBuildConfiguration bc1 = e.getConfigurations(myModule)[0];
      FlexTestUtils.setSdk(bc1, sdk46);

      ModifiableFlexBuildConfiguration bc2 = e.getConfigurations(module2)[0];
      bc2.setOutputType(OutputType.Library);
      FlexTestUtils.setSdk(bc2, sdk45);

      bc1.getDependencies().getModifiableEntries().add(e.createBcEntry(bc1.getDependencies(), bc2, null));
    });

    myAfterCommitRunnable = () -> copyFileToModule(module2, getTestDataPath() + BASE_PATH + getTestName(false) + "_2.js2");
    doTestFor(true, getTestName(false) + ".js2");
  }

  public void testCorrectScopeForSuperclassCheck5() throws Exception {
    // same fqn in SDK and library:
    // Module depends on an swc that has SDK classes compiled in.
    // Library classes (swc compiled with SDK 4.6) have newer timestamp than classes of SDK that module depends on (SDK 4.5)
    // SDK should have no sources attached (otherwise getNavigationElement() for both classes will bring us to the same file)
    // see testData\js2_highlighting\CorrectScopeForSuperclassCheck5_src.zip

    final Sdk sdk45 = FlexTestUtils.createSdk(FlexTestUtils.getPathToCompleteFlexSdk("4.5"), null, false);
    FlexTestUtils.addFlexLibrary(false, myModule, "foobar", true, getTestDataPath(), BASE_PATH + getTestName(false) + ".swc", null, null,
                                 LinkageType.Merged);

    FlexTestUtils.modifyConfigs(myProject, e -> {
      ModifiableFlexBuildConfiguration bc1 = e.getConfigurations(myModule)[0];
      FlexTestUtils.setSdk(bc1, sdk45);
    });
    doTestFor(true, getTestName(false) + ".js2");
  }

  public void testCorrectScopeForSuperclassCheck6() throws Exception {
    // monkey patching SDK class
    final Sdk sdk45 = FlexTestUtils.createSdk(FlexTestUtils.getPathToCompleteFlexSdk("4.5"), null, false);

    FlexTestUtils.modifyConfigs(myProject, e -> {
      ModifiableFlexBuildConfiguration bc1 = e.getConfigurations(myModule)[0];
      FlexTestUtils.setSdk(bc1, sdk45);
    });
    doTestFor(true, getTestName(false) + ".js2", getTestName(false) + "_2.js2");
  }

  public void testCorrectScopeForSuperclassCheck7() throws Exception {
    // same FQNs in different modules
    final Module module2 = doCreateRealModuleIn("module2", myProject, FlexModuleType.getInstance());

    myAfterCommitRunnable = () -> copyFileToModule(module2, getTestDataPath() + BASE_PATH + getTestName(false) + "_2.js2");

    configureByFiles(null, BASE_PATH + getTestName(false) + ".js2");
    final JSClassResolver resolver =
      JSDialectSpecificHandlersFactory.forLanguage(JavaScriptSupportLoader.ECMA_SCRIPT_L4).getClassResolver();
    final PsiElement class1 = resolver.findClassByQName("com.foo.Foo", myModule.getModuleScope());
    assertNotNull(class1);
    final PsiElement class2 = resolver.findClassByQName("com.foo.Foo", module2.getModuleScope());
    assertNotNull(class2);
    assertFalse(class1.isEquivalentTo(class2));
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testCreateVarOfArrayType() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck("Create Variable 'x'", "as", infoCollection);
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testCreateObjectVar() throws Exception {
    final Collection<HighlightInfo> infoCollection = doTestFor(true, getTestName(false) + ".as");
    findAndInvokeActionWithExpectedCheck("Create Variable 'foo'", "as", infoCollection);
  }

  public void testVectorWithSdk() throws Exception {
    final Sdk sdk45 = FlexTestUtils.createSdk(FlexTestUtils.getPathToCompleteFlexSdk("4.5"), null, true);
    FlexTestUtils.modifyConfigs(myProject, editor -> {
      ModifiableFlexBuildConfiguration bc1 = editor.getConfigurations(myModule)[0];
      FlexTestUtils.setSdk(bc1, sdk45);
    });
    doTestFor(true, getTestName(false) + ".as");
  }

  public void testOptionalParams() throws Exception {
    doTestFor(true, getTestName(false) + ".as");
  }

  public void testAccessInternalMemberFromProperty() throws Exception {
    // IDEA-139240
    doTestFor(true, getTestName(false) + ".as", getTestName(false) + "_2.as");
  }

  public void testDoNotResolveClassMemberWhereXmlTagExpected() throws Exception {
    // IDEA-138900
    defaultTest();
  }

  @JSTestOptions(JSTestOption.WithFlexSdk)
  public void testProtectedMembersWithImplicitInheritance() throws Exception {
    defaultTest(); // IDEA-146722
  }

  public void testArgumentsInParenthesis() throws Exception {
    defaultTest(); // IDEA-153275
  }

  @JSTestOptions({JSTestOption.WithLineMarkers, JSTestOption.WithSemanticKeywords})
  public void testSemanticHighlighting() throws Exception {
    defaultTest(); // IDEA-110040
  }

  public void testNoHtmlInspectionsForXmlLiteral() throws Exception {
    enableInspectionTools(new HtmlUnknownTagInspection(),
                          new HtmlUnknownAttributeInspection(),
                          new HtmlUnknownBooleanAttributeInspection());
    defaultTest();
  }
}