Java 类org.eclipse.lsp4j.TextDocumentPositionParams 实例源码

@Test
public void testProvideDocumentationOnHover() throws Exception {
    CamelLanguageServer camelLanguageServer = initializeLanguageServer("<from uri=\"ahc:httpUri\" xmlns=\"http://camel.apache.org/schema/spring\"></from>\n");

    TextDocumentPositionParams position = new TextDocumentPositionParams(new TextDocumentIdentifier(DUMMY_URI), new Position(0, 13));
    CompletableFuture<Hover> hover = camelLanguageServer.getTextDocumentService().hover(position);

    assertThat(hover.get().getContents().get(0).getLeft()).isEqualTo(AHC_DOCUMENTATION);
}

private SignatureHelp doHelp(String file, int row, int column) throws IOException {
    TextDocumentIdentifier document = new TextDocumentIdentifier();

    document.setUri(FindResource.uri(file).toString());

    Position position = new Position();

    position.setLine(row - 1);
    position.setCharacter(column - 1);

    TextDocumentPositionParams p = new TextDocumentPositionParams();

    p.setTextDocument(document);
    p.setPosition(position);

    try {
        return server.getTextDocumentService().signatureHelp(p).get();
    } catch (InterruptedException | ExecutionException e) {
        throw new RuntimeException(e);
    }
}

Either<List<CompletionItem>, CompletionList> completion(TextDocumentPositionParams position,
        IProgressMonitor monitor) {
    List<CompletionItem> completionItems = null;
    try {
        ICompilationUnit unit = JDTUtils.resolveCompilationUnit(position.getTextDocument().getUri());
        completionItems = this.computeContentAssist(unit,
                position.getPosition().getLine(),
                position.getPosition().getCharacter(), monitor);
    } catch (OperationCanceledException ignorable) {
        // No need to pollute logs when query is cancelled
        monitor.setCanceled(true);
    } catch (Exception e) {
        JavaLanguageServerPlugin.logException("Problem with codeComplete for " +  position.getTextDocument().getUri(), e);
        monitor.setCanceled(true);
    }
    CompletionList $ = new CompletionList();
    if (monitor.isCanceled()) {
        $.setIsIncomplete(true);
        completionItems = null;
        JavaLanguageServerPlugin.logInfo("Completion request cancelled");
    } else {
        JavaLanguageServerPlugin.logInfo("Completion request completed");
    }
    $.setItems(completionItems == null ? Collections.emptyList() : completionItems);
    return Either.forRight($);
}

@Override
public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completion(TextDocumentPositionParams position) {
    logInfo(">> document/completion");
    CompletionHandler handler = new CompletionHandler();
    final IProgressMonitor[] monitors = new IProgressMonitor[1];
    CompletableFuture<Either<List<CompletionItem>, CompletionList>> result = computeAsync((cc) -> {
        monitors[0] = toMonitor(cc);
        if (Boolean.getBoolean(JAVA_LSP_JOIN_ON_COMPLETION)) {
            try {
                Job.getJobManager().join(DocumentLifeCycleHandler.DOCUMENT_LIFE_CYCLE_JOBS, monitors[0]);
            } catch (OperationCanceledException ignorable) {
                // No need to pollute logs when query is cancelled
            } catch (InterruptedException e) {
                JavaLanguageServerPlugin.logException(e.getMessage(), e);
            }
        }
        return handler.completion(position, monitors[0]);
    });
    result.join();
    if (monitors[0].isCanceled()) {
        result.cancel(true);
    }
    return result;
}

@Override
public CompletableFuture<List<? extends Location>> definition(TextDocumentPositionParams position) {
    logInfo(">> document/definition");
    NavigateToDefinitionHandler handler = new NavigateToDefinitionHandler(this.preferenceManager);
    return computeAsync((cc) -> {
        IProgressMonitor monitor = toMonitor(cc);
        try {
            Job.getJobManager().join(DocumentLifeCycleHandler.DOCUMENT_LIFE_CYCLE_JOBS, monitor);
        } catch (OperationCanceledException ignorable) {
            // No need to pollute logs when query is cancelled
        } catch (InterruptedException e) {
            JavaLanguageServerPlugin.logException(e.getMessage(), e);
        }
        return handler.definition(position, toMonitor(cc));
    });
}

@Test
public void testHover() throws Exception {
    //given
    //Hovers on the System.out
    String payload = createHoverRequest("src/java/Foo.java", 5, 15);
    TextDocumentPositionParams position = getParams(payload);

    //when
    Hover hover = handler.hover(position, monitor);

    //then
    assertNotNull(hover);
    assertNotNull(hover.getContents());
    MarkedString signature = hover.getContents().get(0).getRight();
    assertEquals("Unexpected hover " + signature, "java", signature.getLanguage());
    assertEquals("Unexpected hover " + signature, "java.Foo", signature.getValue());
    String doc = hover.getContents().get(1).getLeft();
    assertEquals("Unexpected hover " + doc, "This is foo", doc);
}

@Test
public void testHoverStandalone() throws Exception {
    //given
    //Hovers on the System.out
    URI standalone = Paths.get("projects","maven","salut","src","main","java","java","Foo.java").toUri();
    String payload = createHoverRequest(standalone, 10, 71);
    TextDocumentPositionParams position = getParams(payload);

    //when
    Hover hover = handler.hover(position, monitor);

    //then
    assertNotNull(hover);
    assertNotNull(hover.getContents());
    MarkedString signature = hover.getContents().get(0).getRight();
    assertEquals("Unexpected hover " + signature, "java", signature.getLanguage());
    assertEquals("Unexpected hover " + signature, "java.Foo", signature.getValue());
    String doc = hover.getContents().get(1).getLeft();
    assertEquals("Unexpected hover "+doc, "This is foo", doc);
}

@Test
public void testHoverPackage() throws Exception {
    // given
    // Hovers on the java.internal package
    String payload = createHoverRequest("src/java/Baz.java", 2, 16);
    TextDocumentPositionParams position = getParams(payload);

    // when
    Hover hover = handler.hover(position, monitor);

    // then
    assertNotNull(hover);
    String signature = hover.getContents().get(0).getRight().getValue();//
    assertEquals("Unexpected signature ", "java.internal", signature);
    String result = hover.getContents().get(1).getLeft();//
    assertEquals("Unexpected hover ", "this is a **bold** package!", result);
}

@Test
public void testEmptyHover() throws Exception {
    //given
    //Hovers on the System.out
    URI standalone = Paths.get("projects","maven","salut","src","main","java","java","Foo.java").toUri();
    String payload = createHoverRequest(standalone, 1, 2);
    TextDocumentPositionParams position = getParams(payload);

    //when
    Hover hover = handler.hover(position, monitor);

    //then
    assertNotNull(hover);
    assertNotNull(hover.getContents());
    assertEquals(1, hover.getContents().size());
    assertEquals("Should find empty hover for " + payload, "", hover.getContents().get(0).getLeft());
}

@Test
public void testHoverVariable() throws Exception {
    //given
    //Hover on args parameter
    String argParam = createHoverRequest("src/java/Foo.java", 7, 37);
    TextDocumentPositionParams position = getParams(argParam);

    //when
    Hover hover = handler.hover(position, monitor);

    //then
    assertNotNull(hover);
    assertNotNull(hover.getContents());
    MarkedString signature = hover.getContents().get(0).getRight();
    assertEquals("Unexpected hover " + signature, "java", signature.getLanguage());
    assertEquals("Unexpected hover " + signature, "String[] args - java.Foo.main(String[])", signature.getValue());
}

@Test
public void testHoverOnPackageWithJavadoc() throws Exception {
    importProjects("maven/salut2");
    project = WorkspaceHelper.getProject("salut2");
    handler = new HoverHandler(preferenceManager);
    //given
    //Hovers on the org.apache.commons import
    String payload = createHoverRequest("src/main/java/foo/Bar.java", 2, 22);
    TextDocumentPositionParams position = getParams(payload);

    //when
    Hover hover = handler.hover(position, monitor);
    assertNotNull(hover);
    String result = hover.getContents().get(0).getRight().getValue();//
    assertEquals("Unexpected hover ", "org.apache.commons", result);

    assertEquals(logListener.getErrors().toString(), 0, logListener.getErrors().size());
}

@Test
public void testHoverThrowable() throws Exception {
    String uriString = ClassFileUtil.getURI(project, "java.lang.Exception");
    IClassFile classFile = JDTUtils.resolveClassFile(uriString);
    String contents = JavaLanguageServerPlugin.getContentProviderManager().getSource(classFile, monitor);
    IDocument document = new Document(contents);
    IRegion region = new FindReplaceDocumentAdapter(document).find(0, "Throwable", true, false, false, false);
    int offset = region.getOffset();
    int line = document.getLineOfOffset(offset);
    int character = offset - document.getLineOffset(line);
    TextDocumentIdentifier textDocument = new TextDocumentIdentifier(uriString);
    Position position = new Position(line, character);
    TextDocumentPositionParams params = new TextDocumentPositionParams(textDocument, position);
    Hover hover = handler.hover(params, monitor);
    assertNotNull(hover);
    assertTrue("Unexpected hover ", !hover.getContents().isEmpty());
}

protected Either<List<CompletionItem>, CompletionList> completion(final CancelIndicator origialCancelIndicator, final TextDocumentPositionParams params) {
  final LanguageServerImpl.BufferedCancelIndicator cancelIndicator = new LanguageServerImpl.BufferedCancelIndicator(origialCancelIndicator);
  final URI uri = this._uriExtensions.toUri(params.getTextDocument().getUri());
  final IResourceServiceProvider resourceServiceProvider = this.languagesRegistry.getResourceServiceProvider(uri);
  ContentAssistService _get = null;
  if (resourceServiceProvider!=null) {
    _get=resourceServiceProvider.<ContentAssistService>get(ContentAssistService.class);
  }
  final ContentAssistService contentAssistService = _get;
  if ((contentAssistService == null)) {
    CompletionList _completionList = new CompletionList();
    return Either.<List<CompletionItem>, CompletionList>forRight(_completionList);
  }
  final Function2<Document, XtextResource, CompletionList> _function = (Document document, XtextResource resource) -> {
    return contentAssistService.createCompletionList(document, resource, params, cancelIndicator);
  };
  final CompletionList completionList = this.workspaceManager.<CompletionList>doRead(uri, _function);
  return Either.<List<CompletionItem>, CompletionList>forRight(completionList);
}

protected List<? extends Location> definition(final CancelIndicator cancelIndicator, final TextDocumentPositionParams params) {
  final URI uri = this._uriExtensions.toUri(params.getTextDocument().getUri());
  final IResourceServiceProvider resourceServiceProvider = this.languagesRegistry.getResourceServiceProvider(uri);
  DocumentSymbolService _get = null;
  if (resourceServiceProvider!=null) {
    _get=resourceServiceProvider.<DocumentSymbolService>get(DocumentSymbolService.class);
  }
  final DocumentSymbolService documentSymbolService = _get;
  if ((documentSymbolService == null)) {
    return CollectionLiterals.<Location>emptyList();
  }
  final Function2<Document, XtextResource, List<? extends Location>> _function = (Document document, XtextResource resource) -> {
    return documentSymbolService.getDefinitions(document, resource, params, this.resourceAccess, cancelIndicator);
  };
  return this.workspaceManager.<List<? extends Location>>doRead(uri, _function);
}

@Override
public CompletableFuture<Hover> hover(final TextDocumentPositionParams params) {
  final Function1<CancelIndicator, Hover> _function = (CancelIndicator cancelIndicator) -> {
    final URI uri = this._uriExtensions.toUri(params.getTextDocument().getUri());
    final IResourceServiceProvider resourceServiceProvider = this.languagesRegistry.getResourceServiceProvider(uri);
    IHoverService _get = null;
    if (resourceServiceProvider!=null) {
      _get=resourceServiceProvider.<IHoverService>get(IHoverService.class);
    }
    final IHoverService hoverService = _get;
    if ((hoverService == null)) {
      return IHoverService.EMPTY_HOVER;
    }
    final Function2<Document, XtextResource, Hover> _function_1 = (Document document, XtextResource resource) -> {
      return hoverService.hover(document, resource, params, cancelIndicator);
    };
    return this.workspaceManager.<Hover>doRead(uri, _function_1);
  };
  return this.requestManager.<Hover>runRead(_function);
}

@Override
public CompletableFuture<SignatureHelp> signatureHelp(final TextDocumentPositionParams params) {
  final Function1<CancelIndicator, SignatureHelp> _function = (CancelIndicator cancelIndicator) -> {
    final URI uri = this._uriExtensions.toUri(params.getTextDocument().getUri());
    final IResourceServiceProvider serviceProvider = this.languagesRegistry.getResourceServiceProvider(uri);
    ISignatureHelpService _get = null;
    if (serviceProvider!=null) {
      _get=serviceProvider.<ISignatureHelpService>get(ISignatureHelpService.class);
    }
    final ISignatureHelpService helper = _get;
    if ((helper == null)) {
      return ISignatureHelpService.EMPTY;
    }
    final Function2<Document, XtextResource, SignatureHelp> _function_1 = (Document doc, XtextResource resource) -> {
      return helper.getSignatureHelp(doc, resource, params, cancelIndicator);
    };
    return this.workspaceManager.<SignatureHelp>doRead(uri, _function_1);
  };
  return this.requestManager.<SignatureHelp>runRead(_function);
}

@Override
public CompletableFuture<List<? extends DocumentHighlight>> documentHighlight(final TextDocumentPositionParams params) {
  final Function1<CancelIndicator, List<? extends DocumentHighlight>> _function = (CancelIndicator cancelIndicator) -> {
    final URI uri = this._uriExtensions.toUri(params.getTextDocument().getUri());
    final IResourceServiceProvider serviceProvider = this.languagesRegistry.getResourceServiceProvider(uri);
    IDocumentHighlightService _get = null;
    if (serviceProvider!=null) {
      _get=serviceProvider.<IDocumentHighlightService>get(IDocumentHighlightService.class);
    }
    final IDocumentHighlightService service = _get;
    if ((service == null)) {
      return CollectionLiterals.<DocumentHighlight>emptyList();
    }
    final Function2<Document, XtextResource, List<? extends DocumentHighlight>> _function_1 = (Document doc, XtextResource resource) -> {
      return service.getDocumentHighlights(doc, resource, params, cancelIndicator);
    };
    return this.workspaceManager.<List<? extends DocumentHighlight>>doRead(uri, _function_1);
  };
  return this.requestManager.<List<? extends DocumentHighlight>>runRead(_function);
}

@Test public void testRequest() throws Exception {

    TextDocumentPositionParams p = new TextDocumentPositionParams();
    p.setPosition(new Position(1,1));
    p.setTextDocument(new TextDocumentIdentifier("test/foo.txt"));

    CompletionList result = new CompletionList();
    result.setIsIncomplete(true);
    result.setItems(new ArrayList<>());

    CompletionItem item = new CompletionItem();
    item.setDetail("test");
    item.setDocumentation("doc");
    item.setFilterText("filter");
    item.setInsertText("insert");
    item.setKind(CompletionItemKind.Field);
    result.getItems().add(item);

    server.expectedRequests.put("textDocument/completion", new Pair<>(p, result));
    CompletableFuture<Either<List<CompletionItem>, CompletionList>> future = clientLauncher.getRemoteProxy().getTextDocumentService().completion(p);
    Assert.assertEquals(Either.forRight(result).toString(), future.get(TIMEOUT, TimeUnit.MILLISECONDS).toString());
    client.joinOnEmpty();
}

@Override
public void actionPerformed(ActionEvent e) {
  EditorPartPresenter activeEditor = editorAgent.getActiveEditor();

  TextEditor textEditor = ((TextEditor) activeEditor);
  TextDocumentPositionParams paramsDTO =
      dtoBuildHelper.createTDPP(textEditor.getDocument(), textEditor.getCursorPosition());

  final Promise<List<Location>> promise = client.definition(paramsDTO);
  promise
      .then(
          arg -> {
            if (arg.size() == 1) {
              presenter.onLocationSelected(arg.get(0));
            } else {
              presenter.openLocation(promise);
            }
          })
      .catchError(
          arg -> {
            presenter.showError(arg);
          });
}

@Test
public void testDontProvideDocumentationOnHoverForBadPlaces() throws Exception {
    CamelLanguageServer camelLanguageServer = initializeLanguageServer("<from uri=\"ahc:httpUri\" xmlns=\"http://camel.apache.org/schema/spring\"></from>\n");

    TextDocumentPositionParams position = new TextDocumentPositionParams(new TextDocumentIdentifier(DUMMY_URI), new Position(0, 4));
    CompletableFuture<Hover> hover = camelLanguageServer.getTextDocumentService().hover(position);

    assertThat(hover.get()).isNull();
}

protected CompletableFuture<Either<List<CompletionItem>, CompletionList>> getCompletionFor(CamelLanguageServer camelLanguageServer, Position position) {
    TextDocumentService textDocumentService = camelLanguageServer.getTextDocumentService();

    TextDocumentPositionParams dummyCompletionPositionRequest = new TextDocumentPositionParams(new TextDocumentIdentifier(DUMMY_URI), position);
    CompletableFuture<Either<List<CompletionItem>, CompletionList>> completions = textDocumentService.completion(dummyCompletionPositionRequest);
    return completions;
}

protected List<? extends CompletionItem> items(String file, int row, int column) {
    URI uri = FindResource.uri(file);
    TextDocumentPositionParams position =
            new TextDocumentPositionParams(
                    new TextDocumentIdentifier(uri.toString()),
                    uri.toString(),
                    new Position(row - 1, column - 1));

    try {
        return server.getTextDocumentService().completion(position).get().getRight().getItems();
    } catch (InterruptedException | ExecutionException e) {
        throw new RuntimeException(e);
    }
}

@Override
public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completion(
    final TextDocumentPositionParams position) {
  CompletionList result = som.getCompletions(
      position.getTextDocument().getUri(), position.getPosition().getLine(),
      position.getPosition().getCharacter());
  return CompletableFuture.completedFuture(Either.forRight(result));
}

@Override
public CompletableFuture<List<? extends Location>> definition(
    final TextDocumentPositionParams position) {
  List<? extends Location> result = som.getDefinitions(
      position.getTextDocument().getUri(), position.getPosition().getLine(),
      position.getPosition().getCharacter());
  return CompletableFuture.completedFuture(result);
}

@Override
public CompletableFuture<List<? extends DocumentHighlight>> documentHighlight(
    final TextDocumentPositionParams position) {
  // TODO: this is wrong, it should be something entirely different.
  // this feature is about marking the occurrences of a selected element
  // like a variable, where it is used.
  // so, this should actually return multiple results.
  // The spec is currently broken for that.
  DocumentHighlight result = som.getHighlight(position.getTextDocument().getUri(),
      position.getPosition().getLine() + 1, position.getPosition().getCharacter() + 1);
  ArrayList<DocumentHighlight> list = new ArrayList<>(1);
  list.add(result);
  return CompletableFuture.completedFuture(list);
}

public Hover hover(TextDocumentPositionParams position, IProgressMonitor monitor) {
    ITypeRoot unit = JDTUtils.resolveTypeRoot(position.getTextDocument().getUri());

    List<Either<String, MarkedString>> content = null;
    if (unit != null && !monitor.isCanceled()) {
        content = computeHover(unit, position.getPosition().getLine(), position.getPosition().getCharacter(), monitor);
    }
    Hover $ = new Hover();
    $.setContents(content);
    return $;
}

public SignatureHelp signatureHelp(TextDocumentPositionParams position, IProgressMonitor monitor) {

        SignatureHelp help = new SignatureHelp();

        if (!preferenceManager.getPreferences(null).isSignatureHelpEnabled()) {
            return help;
        }

        try {
            ICompilationUnit unit = JDTUtils.resolveCompilationUnit(position.getTextDocument().getUri());
            final int offset = JsonRpcHelpers.toOffset(unit.getBuffer(), position.getPosition().getLine(), position.getPosition().getCharacter());
            int[] contextInfomation = getContextInfomation(unit.getBuffer(), offset);
            if (contextInfomation[0] == -1) {
                return help;
            }
            SignatureHelpRequestor collector = new SignatureHelpRequestor(unit, contextInfomation[0] + 1);

            if (offset > -1 && !monitor.isCanceled()) {
                unit.codeComplete(contextInfomation[0] + 1, collector, monitor);
                help = collector.getSignatureHelp(monitor);

                if (help != null) {
                    int currentParameter = contextInfomation[1];
                    List<SignatureInformation> infos = help.getSignatures();
                    for (int i = 0; i < infos.size(); i++) {
                        if (infos.get(i).getParameters().size() >= currentParameter + 1) {
                            help.setActiveSignature(i);
                            help.setActiveParameter(currentParameter);
                            break;
                        }
                    }
                }
            }
        } catch (CoreException ex) {
            JavaLanguageServerPlugin.logException("Find signatureHelp failure ", ex);
        }
        return help;
    }

@Test
public void testCompletion_javadoc() throws Exception {
    IJavaProject javaProject = JavaCore.create(project);
    ICompilationUnit unit = (ICompilationUnit) javaProject.findElement(new Path("org/sample/TestJavadoc.java"));
    unit.becomeWorkingCopy(null);
    String joinOnCompletion = System.getProperty(JDTLanguageServer.JAVA_LSP_JOIN_ON_COMPLETION);
    try {
        System.setProperty(JDTLanguageServer.JAVA_LSP_JOIN_ON_COMPLETION, "true");
        int[] loc = findCompletionLocation(unit, "inner.");
        TextDocumentPositionParams position = JsonMessageHelper.getParams(createCompletionRequest(unit, loc[0], loc[1]));
        String source = unit.getSource();
        changeDocument(unit, source, 3);
        Job.getJobManager().join(DocumentLifeCycleHandler.DOCUMENT_LIFE_CYCLE_JOBS, new NullProgressMonitor());
        changeDocument(unit, source, 4);
        CompletionList list = server.completion(position).join().getRight();
        for (CompletionItem item : list.getItems()) {
            server.resolveCompletionItem(item);
        }
        CompletionItem resolved = list.getItems().get(0);
        assertEquals("Test ", resolved.getDocumentation());
    } finally {
        unit.discardWorkingCopy();
        if (joinOnCompletion == null) {
            System.clearProperty(JDTLanguageServer.JAVA_LSP_JOIN_ON_COMPLETION);
        } else {
            System.setProperty(JDTLanguageServer.JAVA_LSP_JOIN_ON_COMPLETION, joinOnCompletion);
        }
    }
}

@Test
public void testDocumentHighlightHandler() throws Exception {
    String uri = ClassFileUtil.getURI(project, "org.sample.Highlight");
    TextDocumentIdentifier identifier = new TextDocumentIdentifier(uri);
    TextDocumentPositionParams params = new TextDocumentPositionParams(identifier, new Position(5, 10));

    List<? extends DocumentHighlight> highlights = handler.documentHighlight(params, monitor);
    assertEquals(4, highlights.size());
    assertHighlight(highlights.get(0), 5, 9, 15, DocumentHighlightKind.Write);
    assertHighlight(highlights.get(1), 6, 2, 8, DocumentHighlightKind.Read);
    assertHighlight(highlights.get(2), 7, 2, 8, DocumentHighlightKind.Write);
    assertHighlight(highlights.get(3), 8, 2, 8, DocumentHighlightKind.Read);
}

@Test
public void testHoverInheritedJavadoc() throws Exception {
    // given
    // Hovers on the overriding foo()
    String payload = createHoverRequest("src/java/Bar.java", 22, 19);
    TextDocumentPositionParams position = getParams(payload);

    // when
    Hover hover = handler.hover(position, monitor);

    // then
    assertNotNull(hover);
    String result = hover.getContents().get(1).getLeft();//
    assertEquals("Unexpected hover ", "This method comes from Foo", result);
}

@Test
public void testHoverUnresolvedType() throws Exception {
    importProjects("eclipse/unresolvedtype");
    project = WorkspaceHelper.getProject("unresolvedtype");
    handler = new HoverHandler(preferenceManager);
    //given
    //Hovers on the IFoo
    String payload = createHoverRequest("src/pckg/Foo.java", 2, 31);
    TextDocumentPositionParams position = getParams(payload);

    // when
    Hover hover = handler.hover(position, monitor);
    assertNotNull(hover);
    assertTrue("Unexpected hover ", hover.getContents().isEmpty());
}

@Test
public void testGetEmptyDefinition() throws Exception {
    List<? extends Location> definitions = handler.definition(
            new TextDocumentPositionParams(new TextDocumentIdentifier("/foo/bar"), new Position(1, 1)), monitor);
    assertNotNull(definitions);
    assertEquals(1, definitions.size());
    assertNotNull("Location has no Range", definitions.get(0).getRange());
}

private void testClass(String className, int line, int column) throws JavaModelException {
    String uri = ClassFileUtil.getURI(project, className);
    TextDocumentIdentifier identifier = new TextDocumentIdentifier(uri);
    List<? extends Location> definitions = handler
            .definition(new TextDocumentPositionParams(identifier, new Position(line, column)), monitor);
    assertNotNull(definitions);
    assertEquals(1, definitions.size());
    assertNotNull(definitions.get(0).getUri());
    assertTrue(definitions.get(0).getRange().getStart().getLine() >= 0);
}

protected void testDefinition(final Procedure1<? super DefinitionTestConfiguration> configurator) {
  try {
    @Extension
    final DefinitionTestConfiguration configuration = new DefinitionTestConfiguration();
    configuration.setFilePath(("MyModel." + this.fileExtension));
    configurator.apply(configuration);
    final String fileUri = this.initializeContext(configuration).getUri();
    TextDocumentPositionParams _textDocumentPositionParams = new TextDocumentPositionParams();
    final Procedure1<TextDocumentPositionParams> _function = (TextDocumentPositionParams it) -> {
      TextDocumentIdentifier _textDocumentIdentifier = new TextDocumentIdentifier(fileUri);
      it.setTextDocument(_textDocumentIdentifier);
      int _line = configuration.getLine();
      int _column = configuration.getColumn();
      Position _position = new Position(_line, _column);
      it.setPosition(_position);
    };
    TextDocumentPositionParams _doubleArrow = ObjectExtensions.<TextDocumentPositionParams>operator_doubleArrow(_textDocumentPositionParams, _function);
    final CompletableFuture<List<? extends Location>> definitionsFuture = this.languageServer.definition(_doubleArrow);
    final List<? extends Location> definitions = definitionsFuture.get();
    Procedure1<? super List<? extends Location>> _assertDefinitions = configuration.getAssertDefinitions();
    boolean _tripleNotEquals = (_assertDefinitions != null);
    if (_tripleNotEquals) {
      configuration.getAssertDefinitions().apply(definitions);
    } else {
      final String actualDefinitions = this.toExpectation(definitions);
      this.assertEquals(configuration.getExpectedDefinitions(), actualDefinitions);
    }
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}

public CompletionList createCompletionList(final Document document, final XtextResource resource, final TextDocumentPositionParams params, final CancelIndicator cancelIndicator) {
  try {
    final CompletionList result = new CompletionList();
    result.setIsIncomplete(true);
    final IdeContentProposalAcceptor acceptor = this.proposalAcceptorProvider.get();
    final int caretOffset = document.getOffSet(params.getPosition());
    final Position caretPosition = params.getPosition();
    final TextRegion position = new TextRegion(caretOffset, 0);
    try {
      this.createProposals(document.getContents(), position, caretOffset, resource, acceptor);
    } catch (final Throwable _t) {
      if (_t instanceof Throwable) {
        final Throwable t = (Throwable)_t;
        boolean _isOperationCanceledException = this.operationCanceledManager.isOperationCanceledException(t);
        boolean _not = (!_isOperationCanceledException);
        if (_not) {
          throw t;
        }
      } else {
        throw Exceptions.sneakyThrow(_t);
      }
    }
    final Procedure2<ContentAssistEntry, Integer> _function = (ContentAssistEntry it, Integer idx) -> {
      final CompletionItem item = this.toCompletionItem(it, caretOffset, caretPosition, document);
      item.setSortText(Strings.padStart(Integer.toString((idx).intValue()), 5, '0'));
      List<CompletionItem> _items = result.getItems();
      _items.add(item);
    };
    IterableExtensions.<ContentAssistEntry>forEach(acceptor.getEntries(), _function);
    return result;
  } catch (Throwable _e) {
    throw Exceptions.sneakyThrow(_e);
  }
}

@Override
public CompletableFuture<Either<List<CompletionItem>, CompletionList>> completion(final TextDocumentPositionParams params) {
  final Function1<CancelIndicator, Either<List<CompletionItem>, CompletionList>> _function = (CancelIndicator origialCancelIndicator) -> {
    return this.completion(origialCancelIndicator, params);
  };
  return this.requestManager.<Either<List<CompletionItem>, CompletionList>>runRead(_function);
}

@Override
public CompletableFuture<List<? extends Location>> definition(final TextDocumentPositionParams params) {
  final Function1<CancelIndicator, List<? extends Location>> _function = (CancelIndicator cancelIndicator) -> {
    return this.definition(cancelIndicator, params);
  };
  return this.requestManager.<List<? extends Location>>runRead(_function);
}

@Test
public void testInvalidCompletion() {
    RequestMessage message = new RequestMessage();
    message.setJsonrpc("2.0");
    message.setId("1");
    message.setMethod(MessageMethods.DOC_COMPLETION);

    TextDocumentPositionParams params = new TextDocumentPositionParams();
    params.setTextDocument(new TextDocumentIdentifier("file:///tmp/foo"));
    message.setParams(params);

    assertIssues(message, "The accessor 'getPosition' must return a non-null value.");
}

public TextDocumentPositionParams createTDPP(Document document, int cursorOffset) {
  TextDocumentPositionParams paramsDTO = dtoFactory.createDto(TextDocumentPositionParams.class);
  TextDocumentIdentifier identifierDTO = dtoFactory.createDto(TextDocumentIdentifier.class);
  identifierDTO.setUri(document.getFile().getLocation().toString());

  Position Position = dtoFactory.createDto(Position.class);
  TextPosition position = document.getPositionFromIndex(cursorOffset);
  Position.setCharacter(position.getCharacter());
  Position.setLine(position.getLine());

  paramsDTO.setUri(document.getFile().getLocation().toString());
  paramsDTO.setTextDocument(identifierDTO);
  paramsDTO.setPosition(Position);
  return paramsDTO;
}

public TextDocumentPositionParams createTDPP(Document document, TextPosition position) {
  TextDocumentPositionParams paramsDTO = dtoFactory.createDto(TextDocumentPositionParams.class);
  TextDocumentIdentifier identifierDTO = dtoFactory.createDto(TextDocumentIdentifier.class);
  identifierDTO.setUri(document.getFile().getLocation().toString());

  Position Position = dtoFactory.createDto(Position.class);
  Position.setCharacter(position.getCharacter());
  Position.setLine(position.getLine());

  paramsDTO.setUri(document.getFile().getLocation().toString());
  paramsDTO.setTextDocument(identifierDTO);
  paramsDTO.setPosition(Position);
  return paramsDTO;
}