public async Task R_SignatureParametersMatch()
{
using (var script = await _editorHost.StartScript(_coreShell, string.Empty, "file", RContentTypeDefinition.ContentType, _sessionProvider)) {
await _editorHost.FunctionIndex.GetFunctionInfoAsync("lm");
script.Type("x <- lm(");
script.DoIdle(2000);
ISignatureHelpSession session = script.GetSignatureSession();
session.Should().NotBeNull();
IParameter parameter = session.SelectedSignature.CurrentParameter;
parameter.Should().NotBeNull();
parameter.Name.Should().Be("formula");
script.Type("sub");
script.DoIdle(500);
script.Type("{TAB}");
script.DoIdle(1000);
parameter = session.SelectedSignature.CurrentParameter;
parameter.Name.Should().Be("subset");
string actual = script.EditorText;
actual.Should().Be("x <- lm(subset = )");
session = script.GetSignatureSession();
parameter = session.SelectedSignature.CurrentParameter;
}
}
public async Task R_ErrorTags()
{
using (var script = await _editorHost.StartScript(_services, RContentTypeDefinition.ContentType)) {
// Force tagger creation
var tagSpans = script.GetErrorTagSpans();
script.Type("x <- {");
script.Delete(); // two delete b/c of autoformat to { }
script.Delete();
script.DoIdle(500);
tagSpans = script.GetErrorTagSpans();
var errorTags = script.WriteErrorTags(tagSpans);
errorTags.Should().Be("[5 - 6] } expected\r\n");
var item = tagSpans[0].Tag as IEditorTaskListItem;
item.Line.Should().Be(1);
item.Column.Should().Be(6);
item.FileName.Should().Be("filename");
item.HelpKeyword.Should().Be("vs.r.validationerror");
script.Type("}");
script.DoIdle(500);
tagSpans = script.GetErrorTagSpans();
tagSpans.Should().BeEmpty();
}
}
public async Task R_ProvisionalText01()
{
using (var script = await _editorHost.StartScript(_exportProvider, RContentTypeDefinition.ContentType)) {
script.Type("{");
script.Type("(");
script.Type("[");
script.Type("\"");
string expected = "{([\"\"])}";
string actual = script.EditorText;
actual.Should().Be(expected);
REditorSettings.AutoFormat = false;
script.Type("\"");
script.Type("]");
script.Type(")");
script.Type("}");
script.DoIdle(1000);
expected = "{([\"\"])}";
actual = script.EditorText;
actual.Should().Be(expected);
}
}
public async Task R_SignatureParametersMatch()
{
using (var script = await _editorHost.StartScript(_exportProvider, RContentTypeDefinition.ContentType)) {
IntelliSenseRSession.HostStartTimeout = 10000;
using (new RHostScript(_exportProvider)) {
var functionIndex = PrepareFunctionIndex();
PackageIndexUtility.GetFunctionInfoAsync(functionIndex, "lm").Wait(3000);
script.Type("x <- lm(");
script.DoIdle(2000);
ISignatureHelpSession session = script.GetSignatureSession();
session.Should().NotBeNull();
IParameter parameter = session.SelectedSignature.CurrentParameter;
parameter.Should().NotBeNull();
parameter.Name.Should().Be("formula");
script.Type("sub");
script.DoIdle(500);
script.Type("{TAB}");
script.DoIdle(1000);
parameter = session.SelectedSignature.CurrentParameter;
parameter.Name.Should().Be("subset");
string actual = script.EditorText;
actual.Should().Be("x <- lm(subset = )");
session = script.GetSignatureSession();
parameter = session.SelectedSignature.CurrentParameter;
}
}
}
public async Task TypeRBlock()
{
using (var script = await _editorHost.StartScript(_exportProvider, MdContentTypeDefinition.ContentType)) {
script.Type("```{r}{ENTER}{ENTER}```");
script.MoveUp();
script.Type("x");
script.DoIdle(200);
script.Type("<-");
script.DoIdle(200);
script.Type("funct");
script.DoIdle(200);
script.Type("{TAB}(){");
script.DoIdle(200);
script.Type("{ENTER}abbr{TAB}(");
string expected =
@"```{r}
x <- function() {
abbreviate()
}
```";
string actual = script.EditorText;
actual.Should().Be(expected);
}
}
public async Task R_SignatureParametersMatch()
{
using (var script = await _editorHost.StartScript(_services, RContentTypeDefinition.ContentType, _sessionProvider)) {
await _editorHost.FunctionIndex.GetPackageNameAsync("lm");
script.Type("x <- lm(");
script.DoIdle(2000);
var session = script.GetSignatureSession();
session.Should().NotBeNull();
var parameter = session.SelectedSignature.CurrentParameter;
parameter.Should().NotBeNull();
parameter.Name.Should().Be("formula");
script.Type("sub");
script.DoIdle(500);
script.Type("{TAB}");
script.DoIdle(1000);
parameter = session.SelectedSignature.CurrentParameter;
parameter.Name.Should().Be("subset");
var actual = script.EditorText;
actual.Should().Be("x <- lm(subset = )");
}
}
public async Task TypeRBlock()
{
using (var script = await _editorHost.StartScript(_services, string.Empty, "filename", MdContentTypeDefinition.ContentType, _sessionProvider)) {
var packageName = await _editorHost.FunctionIndex.GetPackageNameAsync("abbreviate");
packageName.Should().NotBeNull();
script.Type("```{r}{ENTER}{ENTER}```");
script.MoveUp();
script.Type("x");
script.DoIdle(200);
script.Type("<-");
script.DoIdle(200);
script.Type("funct");
script.DoIdle(200);
script.Type("{TAB}(){");
script.DoIdle(200);
script.Type("{ENTER}abbr{TAB}(");
var expected =
@"```{r}
x <- function() {
abbreviate()
}
```";
var actual = script.EditorText;
actual.Should().Be(expected);
}
}
public async Task R_SmartIndentTest01()
{
using (var script = await _editorHost.StartScript(_coreShell, string.Empty, RContentTypeDefinition.ContentType)) {
_settings.FormatOptions.BracesOnNewLine = false;
script.MoveRight();
script.Type("{{ENTER}a");
script.DoIdle(300);
var expected = "{\r\n a\r\n}";
var actual = script.EditorText;
actual.Should().Be(expected);
}
}
public async Task InsertRoxygenBlock()
{
string content =
@"
x <- function(a,b,c) { }
";
string expected =
@"#' Title
#'
#' @param a
#' @param b
#' @param c
#'
#' @return
#' @export
#'
#' @examples
x <- function(a,b,c) { }
";
using (var script = await _editorHost.StartScript(_exportProvider, content, RContentTypeDefinition.ContentType)) {
script.Type("###");
var actual = script.TextBuffer.CurrentSnapshot.GetText();
actual.Should().Be(expected);
}
}
public async Task FormatDocument()
{
const string content =
@"Text
```{r echo=FALSE}
x<-1
```
Text
```{r }
x<-function(a,b) {
}
```
";
using (var script = await _editorHost.StartScript(_services, content, MdContentTypeDefinition.ContentType)) {
script.Execute(VSConstants.VSStd2KCmdID.FORMATDOCUMENT, 50);
var expected =
@"Text
```{r echo=FALSE}
x <- 1
```
Text
```{r }
x <- function(a, b) {
}
```
";;
var actual = script.EditorText;
actual.Should().Be(expected);
}
}
public async Task R_FormatDocument(string original, string expected)
{
using (var script = await _editorHost.StartScript(_services, original, RContentTypeDefinition.ContentType)) {
script.Execute(VSConstants.VSStd2KCmdID.FORMATDOCUMENT, 50);
string actual = script.EditorText;
actual.Should().Be(expected);
}
}
public async Task RColors(string fileName)
{
string content = _files.LoadDestinationFile(fileName);
using (var script = await _editorHost.StartScript(_exportProvider, content, fileName, null)) {
script.DoIdle(500);
var spans = script.GetClassificationSpans();
var actual = ClassificationWriter.WriteClassifications(spans);
VerifyClassifications(fileName, actual);
}
}
public async Task RColors(string fileName)
{
var content = _files.LoadDestinationFile(fileName);
using (var script = await _editorHost.StartScript(_services, content, fileName, MdContentTypeDefinition.ContentType, null)) {
script.DoIdle(500);
var spans = script.GetClassificationSpans();
var actual = ClassificationWriter.WriteClassifications(spans);
VerifyClassifications(fileName, actual);
}
}
public async Task ScopeIndent()
{
using (var script = await _editorHost.StartScript(_services, string.Empty, MdContentTypeDefinition.ContentType)) {
script.Type("```{r}{ENTER}{ENTER}```");
script.MoveUp();
script.Type("if(true){");
script.DoIdle(200);
script.Enter();
script.DoIdle(200);
script.Type("a");
var expected =
@"```{r}
if (TRUE) {
a
}
```";
var actual = script.EditorText;
actual.Should().Be(expected);
}
}
public async Task R_LibrarySuggestedActions()
{
using (var script = await _editorHost.StartScript(_services, " library(base)", RContentTypeDefinition.ContentType)) {
IEnumerable <SuggestedActionSet> sets = null;
ILightBulbSession session = null;
var svc = _services.GetService <ISuggestedActionCategoryRegistryService>();
script.Invoke(() => {
var broker = _services.GetService <ILightBulbBroker2>();
broker.CreateSession(svc.AllCodeFixes, script.View, svc.AllCodeFixes);
session = script.GetLightBulbSession();
session.Should().NotBeNull();
session.Expand();
session.TryGetSuggestedActionSets(out sets);
});
sets.Should().NotBeNull();
sets.Should().BeEmpty();
script.Invoke(() => session.Dismiss());
script.DoIdle(200);
script.MoveRight(2);
script.DoIdle(200);
sets = null;
script.Invoke(() => {
var broker = _services.GetService <ILightBulbBroker2>();
broker.DismissSession(script.View);
broker.CreateSession(svc.Any, script.View, svc.AllCodeFixes);
session = script.GetLightBulbSession();
session.Should().NotBeNull();
session.Expand();
session.TryGetSuggestedActionSets(out sets);
});
script.DoIdle(3000);
sets = null;
script.Invoke(() => {
session.TryGetSuggestedActionSets(out sets);
});
sets.Should().NotBeNull();
sets.Should().HaveCount(1);
var set = sets.First();
set.Actions.Should().HaveCount(2);
var actions = set.Actions.ToArray();
actions[0].Should().BeOfType(typeof(InstallPackageSuggestedAction));
actions[1].Should().BeOfType(typeof(LoadLibrarySuggestedAction));
}
}
public async Task R_FormatSelection01()
{
string content = "\nwhile (TRUE) {\n if(x>1) {\n }\n}";
string expected = "\nwhile (TRUE) {\n if (x > 1) {\n }\n}";
using (var script = await _editorHost.StartScript(_coreShell, content, RContentTypeDefinition.ContentType)) {
script.Select(20, 18);
script.Execute(VSConstants.VSStd2KCmdID.FORMATSELECTION, 50);
string actual = script.EditorText;
actual.Should().Be(expected);
}
}
public async Task R_SelectWord01()
{
using (var script = await _editorHost.StartScript(_exportProvider, "\r\nabc$def['test test']", RContentTypeDefinition.ContentType)) {
script.MoveDown();
script.Execute(Languages.Editor.Controller.Constants.VSConstants.VSStd2KCmdID.SELECTCURRENTWORD);
var span = script.View.Selection.StreamSelectionSpan;
var selectedWord = span.GetText();
selectedWord.Should().Be("abc");
script.MoveRight(2);
script.Execute(Languages.Editor.Controller.Constants.VSConstants.VSStd2KCmdID.SELECTCURRENTWORD);
span = script.View.Selection.StreamSelectionSpan;
selectedWord = span.GetText();
selectedWord.Should().Be("def");
script.MoveRight(3);
script.Execute(Languages.Editor.Controller.Constants.VSConstants.VSStd2KCmdID.SELECTCURRENTWORD);
span = script.View.Selection.StreamSelectionSpan;
selectedWord = span.GetText();
selectedWord.Should().Be("test");
}
}
public async Task R_OutlineToggleAll()
{
string text = _files.LoadDestinationFile("lsfit.r");
using (var script = await _editorHost.StartScript(_exportProvider, text, "filename", RContentTypeDefinition.ContentType, null)) {
script.DoIdle(500);
IOutliningManagerService svc = _exportProvider.GetExportedValue <IOutliningManagerService>();
IOutliningManager mgr = svc.GetOutliningManager(script.View);
var snapshot = script.TextBuffer.CurrentSnapshot;
var viewLines = script.View.TextViewLines;
viewLines.Count.Should().Be(22);
script.DoIdle(500);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_ALL);
script.DoIdle(1000);
IEnumerable <ICollapsed> collapsed = mgr.GetCollapsedRegions(new SnapshotSpan(snapshot, new Span(0, snapshot.Length)));
collapsed.Count().Should().Be(20);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_ALL);
script.DoIdle(500);
viewLines = script.View.TextViewLines;
viewLines.Count.Should().Be(22);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_STOP_HIDING_ALL);
script.DoIdle(200);
mgr.Enabled.Should().Be(false);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_START_AUTOHIDING);
script.DoIdle(200);
mgr.Enabled.Should().Be(true);
script.MoveDown(9);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_CURRENT);
script.DoIdle(500);
collapsed = mgr.GetCollapsedRegions(new SnapshotSpan(snapshot, new Span(0, snapshot.Length)));
collapsed.Count().Should().Be(1);
script.Execute(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.OUTLN_TOGGLE_CURRENT);
script.DoIdle(200);
collapsed = mgr.GetCollapsedRegions(new SnapshotSpan(snapshot, new Span(0, snapshot.Length)));
collapsed.Count().Should().Be(0);
}
}
public async Task PreviewAutomatic(string sourceFile)
{
_settings.AutomaticSync = true;
var content = _files.LoadDestinationFile(sourceFile);
var baselinePath = Path.Combine(_files.DestinationPath, sourceFile) + ".html";
using (var script = await _editorHost.StartScript(_services, content, sourceFile, MdContentTypeDefinition.ContentType, _sessionProvider)) {
script.DoIdle(500);
var margin = script.View.Properties.GetProperty <PreviewMargin>(typeof(PreviewMargin));
var control = margin?.Browser?.Control;
control.Should().NotBeNull();
await _services.MainThread().SwitchToAsync();
var htmlDoc = (HTMLDocument)control.Document;
var actual = htmlDoc.documentElement.outerHTML.Replace("\n", "\r\n");
TestFiles.CompareToBaseLine(baselinePath, actual);
}
}
/// <summary>
/// Opens file in an editor window
/// </summary>
/// <param name="fileName">File name</param>
/// <param name="contentType">File content type</param>
private async Task <string> TypeFileInEditor(string fileName, string contentType)
{
using (var script = await _editorHost.StartScript(_exportProvider, contentType)) {
string text = _files.LoadDestinationFile(fileName);
string[] lines = text.Split(CharExtensions.LineBreakChars);
for (int i = 0; i < lines.Length; i++)
{
string lineText = lines[i];
if (!lineText.TrimStart().StartsWith("#", System.StringComparison.Ordinal))
{
lineText = lineText.Replace(" ", string.Empty);
}
script.Type(lineText, idleTime: 10);
script.Enter();
script.DoIdle(300);
}
return(script.EditorText);
}
}
public async Task R_LibrarySuggestedActions()
{
using (var script = await _editorHost.StartScript(_services, " library(base)", RContentTypeDefinition.ContentType)) {
VerifySession(script, 1, s => { });
script.DoIdle(200);
script.MoveRight(2);
script.DoIdle(200);
VerifySession(script, 1, s => { });
script.DoIdle(3000);
VerifySession(script, 1, s => {
var set = s.First();
set.Actions.Should().HaveCount(2);
var actions = set.Actions.ToArray();
actions[0].Should().BeOfType(typeof(InstallPackageSuggestedAction));
actions[1].Should().BeOfType(typeof(LoadLibrarySuggestedAction));
});
}
}
public async Task R_KeywordIntellisense()
{
using (var script = await _editorHost.StartScript(_exportProvider, RContentTypeDefinition.ContentType)) {
script.Type("funct");
script.DoIdle(100);
script.Type("{TAB}");
string expected = "function";
string actual = script.EditorText;
actual.Should().Be(expected);
}
}
public async Task R_AutoFormatFunctionBraces()
{
using (var script = await _editorHost.StartScript(_exportProvider, RContentTypeDefinition.ContentType)) {
script.Type("function(a,b){");
script.DoIdle(300);
script.Type("{ENTER}a");
string expected = "function(a, b) {\r\n a\r\n}";
string actual = script.EditorText;
actual.Should().Be(expected);
}
}
public async Task R_AutoFormatFunctionBraces()
{
using (var script = await _editorHost.StartScript(_services, RContentTypeDefinition.ContentType)) {
script.Type("function(a1,b1){");
script.DoIdle(300);
script.Type("{ENTER}a1");
var expected = "function(a1, b1) {\r\n a1\r\n}";
var actual = script.EditorText;
actual.Should().Be(expected);
}
}
