Java PlatformTestUtil.registerExtension方法代码示例

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
public void testRemappingToInstalledPluginExtension() throws WriteExternalException, InvalidDataException {
  ApplicationManager.getApplication().runWriteAction(new Runnable() {
    @Override
    public void run() {
      myFileTypeManager.associatePattern(PlainTextFileType.INSTANCE, "*.fromPlugin");
    }
  });

  Element element = myFileTypeManager.getState();
  String s = JDOMUtil.writeElement(element);

  final AbstractFileType typeFromPlugin = new AbstractFileType(new SyntaxTable());
  PlatformTestUtil.registerExtension(FileTypeFactory.FILE_TYPE_FACTORY_EP, new FileTypeFactory() {
    @Override
    public void createFileTypes(@NotNull FileTypeConsumer consumer) {
      consumer.consume(typeFromPlugin, "fromPlugin");
    }
  }, getTestRootDisposable());
  myFileTypeManager.initStandardFileTypes();
  myFileTypeManager.loadState(element);

  myFileTypeManager.initComponent();
  Map<FileNameMatcher, Pair<FileType, Boolean>> mappings = myFileTypeManager.getRemovedMappings();
  assertEquals(1, mappings.size());
  assertEquals(typeFromPlugin, mappings.values().iterator().next().first);
}
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
public void testOpenRecentEditorTab() throws Exception {
  PlatformTestUtil.registerExtension(FileEditorProvider.EP_FILE_EDITOR_PROVIDER, new MyFileEditorProvider(), getTestRootDisposable());

  openFiles("  <component name=\"FileEditorManager\">\n" +
      "    <leaf>\n" +
      "      <file leaf-file-name=\"foo.xsd\" pinned=\"false\" current=\"true\" current-in-tab=\"true\">\n" +
      "        <entry selected=\"true\" file=\"file://$PROJECT_DIR$/src/1.txt\">\n" +
      "          <provider editor-type-id=\"mock\" selected=\"true\">\n" +
      "            <state />\n" +
      "          </provider>\n" +
      "          <provider editor-type-id=\"text-editor\">\n" +
      "            <state/>\n" +
      "          </provider>\n" +
      "        </entry>\n" +
      "      </file>\n" +
      "    </leaf>\n" +
      "  </component>\n");
  FileEditor[] selectedEditors = myManager.getSelectedEditors();
  assertEquals(1, selectedEditors.length);
  assertEquals("mockEditor", selectedEditors[0].getName());
}
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
public void testOpenInDumbMode() throws Exception {
  PlatformTestUtil.registerExtension(FileEditorProvider.EP_FILE_EDITOR_PROVIDER, new MyFileEditorProvider(), getTestRootDisposable());
  PlatformTestUtil.registerExtension(FileEditorProvider.EP_FILE_EDITOR_PROVIDER, new DumbAwareProvider(), getTestRootDisposable());
  try {
    DumbServiceImpl.getInstance(getProject()).setDumb(true);
    VirtualFile file = getFile("/src/foo.bar");
    assertEquals(1, myManager.openFile(file, false).length);
    DumbServiceImpl.getInstance(getProject()).setDumb(false);
    UIUtil.dispatchAllInvocationEvents();
    assertEquals(2, myManager.getAllEditors(file).length);
    //assertFalse(FileEditorManagerImpl.isDumbAware(editors[0]));
  }
  finally {
    DumbServiceImpl.getInstance(getProject()).setDumb(false);
  }
}
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
private Set<VirtualFile> registerWriteAccessProvider(final VirtualFile... filesToDeny) {
  final Set<VirtualFile> requested = new LinkedHashSet<VirtualFile>();
  PlatformTestUtil.registerExtension(Extensions.getArea(getProject()), WritingAccessProvider.EP_NAME, new WritingAccessProvider() {
    @NotNull
    @Override
    public Collection<VirtualFile> requestWriting(VirtualFile... files) {
      Collections.addAll(requested, files);
      HashSet<VirtualFile> denied = new HashSet<VirtualFile>(Arrays.asList(filesToDeny));
      denied.retainAll(Arrays.asList(files));
      return denied;
    }

    @Override
    public boolean isPotentiallyWritable(@NotNull VirtualFile file) {
      return true;
    }
  }, myTestRootDisposable);
  return requested;
}
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
public void testInfoTestAttributes() throws Exception {
  LanguageExtensionPoint<Annotator> extension = new LanguageExtensionPoint<Annotator>();
  extension.language="TEXT";
  extension.implementationClass = TestAnnotator.class.getName();
  PlatformTestUtil.registerExtension(ExtensionPointName.create(LanguageAnnotators.EP_NAME), extension, getTestRootDisposable());
  myFixture.configureByText(PlainTextFileType.INSTANCE, "foo");
  EditorColorsScheme scheme = new EditorColorsSchemeImpl(new DefaultColorsScheme()){{initFonts();}};
  scheme.setAttributes(HighlighterColors.TEXT, new TextAttributes(Color.black, Color.white, null, null, Font.PLAIN));
  ((EditorEx)myFixture.getEditor()).setColorsScheme(scheme);
  myFixture.doHighlighting();
  MarkupModel model = DocumentMarkupModel.forDocument(myFixture.getEditor().getDocument(), getProject(), false);
  RangeHighlighter[] highlighters = model.getAllHighlighters();
  assertEquals(1, highlighters.length);
  TextAttributes attributes = highlighters[0].getTextAttributes();
  assertNotNull(attributes);
  assertNull(attributes.getBackgroundColor());
  assertNull(attributes.getForegroundColor());
}
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
public void testVcsCheckoutProcessor() throws IOException {

    final List<Pair<String, String>> pairs = new ArrayList<Pair<String, String>>();
    PlatformTestUtil.registerExtension(VcsCheckoutProcessor.EXTENSION_POINT_NAME, new VcsCheckoutProcessor() {
      @NotNull
      @Override
      public String getId() {
        return "schema";
      }

      @Override
      public boolean checkout(@NotNull Map<String, String> parameters,
                              @NotNull VirtualFile parentDirectory, @NotNull String directoryName) {
        pairs.add(Pair.create(parameters.get("url"), directoryName));
        return true;
      }
    }, myTestRootDisposable);

    ProjectSetProcessor.Context context = new ProjectSetProcessor.Context();
    context.directoryName = "newDir";
    context.directory = getSourceRoot();
    readDescriptor(new File(getTestDataPath() + "vcs.json"), context);
    Collections.sort(pairs, new Comparator<Pair<String, String>>() {
      @Override
      public int compare(@NotNull Pair<String, String> o1, @NotNull Pair<String, String> o2) {
        return o2.first.compareTo(o1.first);
      }
    });
    assertEquals(Pair.create("schema://foo.bar/path", "test"), pairs.get(1));
    assertEquals(Pair.create("schema://foo.bar1/path1", "test/custom"), pairs.get(0));
  }
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
public void testTrackSelectedEditor() throws Exception {
  PlatformTestUtil.registerExtension(FileEditorProvider.EP_FILE_EDITOR_PROVIDER, new MyFileEditorProvider(), getTestRootDisposable());
  VirtualFile file = getFile("/src/1.txt");
  assertNotNull(file);
  FileEditor[] editors = myManager.openFile(file, true);
  assertEquals(2, editors.length);
  assertEquals("Text", myManager.getSelectedEditor(file).getName());
  myManager.setSelectedEditor(file, "mock");
  assertEquals("mockEditor", myManager.getSelectedEditor(file).getName());

  VirtualFile file1 = getFile("/src/2.txt");
  myManager.openFile(file1, true);
  assertEquals("mockEditor", myManager.getSelectedEditor(file).getName());
}
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
private void registerAccessCheckExtension(final Collection<VirtualFile> filesToAllow) {
  PlatformTestUtil.registerExtension(Extensions.getArea(getProject()), NonProjectFileWritingAccessExtension.EP_NAME,
                                     new NonProjectFileWritingAccessExtension() {
                                       @Override
                                       public boolean isWritable(@NotNull VirtualFile file) {
                                         return filesToAllow.contains(file);
                                       }
                                     },
                                     myTestRootDisposable);
}
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
public void testBackNavigationBetweenEditors() throws Exception {
  PlatformTestUtil.registerExtension(FileEditorProvider.EP_FILE_EDITOR_PROVIDER, new FileEditorManagerTest.MyFileEditorProvider(), getTestRootDisposable());
  VirtualFile file = getFile("/src/1.txt");
  assertNotNull(file);
  FileEditor[] editors = myManager.openFile(file, true);
  assertEquals(2, editors.length);
  assertEquals("Text", myManager.getSelectedEditor(file).getName());
  myManager.setSelectedEditor(file, "mock");
  assertEquals("mockEditor", myManager.getSelectedEditor(file).getName());
  myManager.closeAllFiles();

  myHistory.back();
  assertEquals("mockEditor", myManager.getSelectedEditor(file).getName());
}
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
public void testDomExtension() throws Exception {
  DomExtenderEP ep = new DomExtenderEP();
  ep.domClassName = Bar.class.getName();
  ep.extenderClassName = TestExtender.class.getName();
  PlatformTestUtil.registerExtension(Extensions.getRootArea(), DomExtenderEP.EP_NAME, ep, myTestRootDisposable);

  doBuilderTest("extender.xml", "File:foo\n" +
                                "  Element:foo\n" +
                                "    Element:bar\n" +
                                "      Attribute:extend:xxx\n" +
                                "    Element:bar\n");
}
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
public void testLombokVal() {
  PlatformTestUtil.registerExtension(PsiAugmentProvider.EP_NAME, new PsiAugmentProvider() {
    @NotNull
    @Override
    public <Psi extends PsiElement> List<Psi> getAugments(@NotNull PsiElement element, @NotNull Class<Psi> type) {
      return Collections.<Psi>emptyList();
    }

    @Nullable
    @Override
    protected PsiType inferType(PsiTypeElement typeElement) {
      final PsiElement parent = typeElement.getParent();
      if (parent instanceof PsiLocalVariable && ((PsiLocalVariable)parent).getInitializer() != null || 
          parent instanceof PsiParameter && ((PsiParameter)parent).getDeclarationScope() instanceof PsiForeachStatement) {
        final String text = typeElement.getText();
        if (LOMBOK_VAL_SHORT_NAME.equals(text) || LOMBOK_VAL_FQN.equals(text)) {
          final PsiJavaCodeReferenceElement referenceElement = typeElement.getInnermostComponentReferenceElement();
          if (referenceElement != null) {
            final PsiElement resolve = referenceElement.resolve();
            if (resolve instanceof PsiClass) {
              if (parent instanceof PsiLocalVariable) {
                final PsiExpression initializer = ((PsiVariable)parent).getInitializer();
                assertNotNull(initializer);
                final PsiType initializerType = initializer.getType();
                if (initializer instanceof PsiNewExpression) {
                  final PsiJavaCodeReferenceElement reference = ((PsiNewExpression)initializer).getClassOrAnonymousClassReference();
                  if (reference != null) {
                    final PsiReferenceParameterList parameterList = reference.getParameterList();
                    if (parameterList != null) {
                      final PsiTypeElement[] elements = parameterList.getTypeParameterElements();
                      if (elements.length == 1 && elements[0].getType() instanceof PsiDiamondType) {
                        return TypeConversionUtil.erasure(initializerType);
                      }
                    }
                  }
                }
                return initializerType;
              }
              final PsiForeachStatement foreachStatement = (PsiForeachStatement)((PsiParameter)parent).getDeclarationScope();
              assertNotNull(foreachStatement);
              final PsiExpression iteratedValue = foreachStatement.getIteratedValue();
              if (iteratedValue != null) {
                return JavaGenericsUtil.getCollectionItemType(iteratedValue);
              }
            }
          }
        }
      }
      return null;
    }
  }, myTestRootDisposable);
  myFixture.addClass("package lombok; public @interface val{}");
  myFixture.testHighlighting(false, false, false, getTestName(false) + ".java");
}
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
public <T extends DomElement> void registerDomExtender(final Class<T> domClass, final Class<? extends DomExtender<T>> extenderClass) {
  final DomExtenderEP extenderEP = new DomExtenderEP();
  extenderEP.domClassName = domClass.getName();
  extenderEP.extenderClassName = extenderClass.getName();
  PlatformTestUtil.registerExtension(Extensions.getRootArea(), DomExtenderEP.EP_NAME, extenderEP, myTestRootDisposable);
}
 

import com.intellij.testFramework.PlatformTestUtil; //导入方法依赖的package包/类
private void registerExtender(final Class elementClass, final Class extenderClass) {
  final DomExtenderEP extenderEP = new DomExtenderEP();
  extenderEP.domClassName = elementClass.getName();
  extenderEP.extenderClassName = extenderClass.getName();
  PlatformTestUtil.registerExtension(Extensions.getRootArea(), DomExtenderEP.EP_NAME, extenderEP, myTestRootDisposable);
}