How to use

LightVirtualFile

in

com.intellij.testFramework

private void doTest(File resource) {
  try {
    String name = resource.getName().replace("." + myFileExt, EMPTY_STRING);
    // Retrieves relative path of the file since loadFile() uses "myFullDataPath" as the source root.
    String relativeFilePath = resource.getPath().replace(getTestDataPath(), EMPTY_STRING);
    String text = loadFile(relativeFilePath);
    myFile = createPsiFile(name, text);
    ensureParsed(myFile);
    assertEquals("light virtual file text mismatch", text,
        ((LightVirtualFile) myFile.getVirtualFile()).getContent().toString());
    assertEquals("virtual file text mismatch", text, LoadTextUtil.loadText(myFile.getVirtualFile()));
    assertEquals("doc text mismatch", text, myFile.getViewProvider().getDocument().getText());
    assertEquals("psi text mismatch", text, myFile.getText());
    ensureCorrectReparse(myFile);
    checkResult(relativeFilePath, myFile);
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
}

@Nullable
protected PsiFile createFile(@NotNull String name, @NotNull String text, @NotNull ParserDefinition definition) {
 Language language = definition.getFileNodeType().getLanguage();
 Init.addKeyedExtension(LanguageParserDefinitions.INSTANCE, language, definition, getProject());
 return ((PsiFileFactoryImpl)PsiFileFactory.getInstance(myProject)).trySetupPsiForFile(new LightVirtualFile(name, language, text), language, true, false);
}

/**
 * Returns real containing virtual file, not the Light one
 *
 * @return virtual file or null
 */
@Nullable
public static VirtualFile getContainingVirtualFile(PsiFile psiFile) {
 VirtualFile originalFile = psiFile.getViewProvider().getVirtualFile();
 if (originalFile instanceof LightVirtualFile) {
  if (psiFile.getUserData(IndexingDataKeys.VIRTUAL_FILE) != null) {
   originalFile = psiFile.getUserData(IndexingDataKeys.VIRTUAL_FILE);
  }
  else if (((LightVirtualFile)originalFile).getOriginalFile() != null) {
   originalFile = ((LightVirtualFile)originalFile).getOriginalFile();
  }
 }
 return originalFile instanceof LightVirtualFile || originalFile == null || !originalFile.exists() ? null : originalFile;
}

@NotNull
@Override
public SyntaxHighlighter getSyntaxHighlighter(@Nullable final Project project, @Nullable VirtualFile virtualFile) {
 final Language language = virtualFile instanceof LightVirtualFile ? ((LightVirtualFile)virtualFile).getLanguage() : null;
 if (!(language instanceof LivePreviewLanguage)) return new PlainSyntaxHighlighter();
 return new SyntaxHighlighterBase() {

 private static PsiFile createDummyFile(Project myProject, String text) {
  final PsiFileFactory factory = PsiFileFactory.getInstance(myProject);
  final String name = "dummy." + MonkeyFileType.INSTANCE.getDefaultExtension();
  final LightVirtualFile virtualFile = new LightVirtualFile(name, MonkeyFileType.INSTANCE, text);
  final PsiFile psiFile = ((PsiFileFactoryImpl) factory).trySetupPsiForFile(virtualFile, MonkeyLanguage.INSTANCE, false, true);
  assert psiFile != null;
  return psiFile;
 }
}

 public static Language calcTemplateLanguage(PsiManager manager, VirtualFile file) {
  while (file instanceof LightVirtualFile) {
   VirtualFile originalFile = ((LightVirtualFile)file).getOriginalFile();
   if (originalFile == null || originalFile == file) {
    break;
   }
   file = originalFile;
  }

  Language result = TemplateDataLanguageMappings.getInstance(manager.getProject()).getMapping(file);
  return result == null ? StdLanguages.HTML : result;
 }
}

@Nullable
public static PsiFile parseFile(BnfFile bnfFile, String text) {
 Language language = getLanguageFor(bnfFile);
 String fileName = bnfFile.getName() + ".preview";
 LightVirtualFile virtualFile = new LightVirtualFile(fileName, language, text);
 final Project project = bnfFile.getProject();
 return PsiManager.getInstance(project).findFile(virtualFile);
}

  @NotNull
  private PsiFile root() {
    String name = getTestName(false);
    PsiFile root;

    try {
      String text = loadFile(name + "." + myFileExt);
      myFile = createPsiFile(name, text);
      ensureParsed(myFile);
      assertEquals("light virtual file text mismatch", text, ((LightVirtualFile) myFile.getVirtualFile()).getContent().toString());
      assertEquals("virtual file text mismatch", text, LoadTextUtil.loadText(myFile.getVirtualFile()));
      assertEquals("doc text mismatch", text, myFile.getViewProvider().getDocument().getText());
      assertEquals("psi text mismatch", text, myFile.getText());
      FileViewProvider fileViewProvider = myFile.getViewProvider();
      root = fileViewProvider.getPsi(ElixirLanguage.INSTANCE);

      assertNotNull(root);
    } catch (IOException exception) {
      throw new RuntimeException(exception);
    }

    return root;
  }
}

private void setupFileSpecificEditor(Project project, VirtualFile cypherFile) {
  if (project == null || cypherFile == null) return;
  try {
    String params = FileUtil.getParams(cypherFile);
    LightVirtualFile lightVirtualFile = new LightVirtualFile("", JsonFileType.INSTANCE, params);
    Document document = FileDocumentManager.getInstance().getDocument(lightVirtualFile);
    fileSpecificParamEditor = createEditor(project, document);
    VirtualFileManager.getInstance().addVirtualFileListener(new VirtualFileListener() {
      @Override
      public void contentsChanged(@NotNull VirtualFileEvent event) {
        if (event.getFile().equals(cypherFile) && document != null)
          FileUtil.setParams(cypherFile, document.getText());
      }
    });
    JLabel jLabel = new JLabel("<html>Parameters for data source <b>" +
        getTabTitle(cypherFile) + "</b>:</html>");
    jLabel.setIcon(ICON_HELP);
    jLabel.setToolTipText("Enter parameters in JSON format. Will be applied to <b>" + getTabTitle(cypherFile) +
        "</b> data source when executed");
    fileSpecificParamEditor.setHeaderComponent(jLabel);
    if (document != null) setInitialContent(document);
    graphConsoleView.getFileSpecificParametersTab().add(fileSpecificParamEditor.getComponent(), BorderLayout.CENTER);
  } catch (Throwable e) {
    Throwables.throwIfUnchecked(e);
    throw new RuntimeException(e);
  }
}

/**
 * 重置
 *
 * @param name    模板名称
 * @param content 文本内容
 */
public void reset(String name, String content) {
  if (content != null && this.editor != null) {
    // 重置语法高亮
    ((EditorEx) editor).setHighlighter(EditorHighlighterFactory.getInstance().createEditorHighlighter(project, new LightVirtualFile(name + ".ft")));
    // 重置文本内容
    WriteCommandAction.runWriteCommandAction(project, () -> this.editor.getDocument().setText(content));
  }
}

@Override
protected void doTest(String grammarFile) throws IOException {
 File grammarIOFile = new File(myFullDataPath, grammarFile);
 assertNotNull(grammarFile + "not found", grammarIOFile.exists());
 LightVirtualFile grammarVFile = new LightVirtualFile(grammarFile, FileUtil.loadFile(grammarIOFile));
 myLanguage = BnfLanguage.INSTANCE;
 BnfFile grammarPsi = (BnfFile) createFile(grammarVFile);
 myLanguage = LivePreviewHelper.getLanguageFor(grammarPsi);
 try {
  super.doTest(true);
 }
 finally {
  LivePreviewHelper.unregisterLanguageExtensions((LivePreviewLanguage) myLanguage);
 }
}

public SourceTuple(@NonNls @NotNull String name, @NonNls @NotNull CharSequence source) {
  this.name = name;
  PsiElement[] children = { null };
  psi = new MockSoyFile(children, new MyFileViewProvider());
  root = source == SOURCE_AS_RESOURCE
           ? SoyTestUtil.getPsiTreeFor(psi, name)
           : SoyTestUtil.getPsiTreeFor(psi, name, source);
  children[0] = root;
  String text = source == SOURCE_AS_RESOURCE
         ? loadSource(name)
         : source.toString();
  file = new LightVirtualFile(name,
                SoyFileType.INSTANCE,
                text,
                Charset.defaultCharset(),
                System.currentTimeMillis());
  fileUrl = file.getUrl();
  document = new MockDocument(text);
}

((EditorEx) editor).setHighlighter(EditorHighlighterFactory.getInstance().createEditorHighlighter(project, new LightVirtualFile(name + ".ft")));

 VirtualFile newFile = new LightVirtualFile("Deparsed " + file.getName(), file.getFileType(), deparsed);
 OpenFileAction.openFile(newFile, project);
}));

((EditorEx) editor).setHighlighter(EditorHighlighterFactory.getInstance().createEditorHighlighter(project, new LightVirtualFile(fileName)));