public void Search2()
{
var mode = _factory.Create <INormalMode>();
_vimBuffer.NormalModeImpl = mode.Object;
_vimBuffer.ModeKindImpl = ModeKind.Normal;
var data = new SearchData("cat", SearchKind.Backward, SearchOptions.None);
_search.SetupGet(x => x.InSearch).Returns(true).Verifiable();
_search.SetupGet(x => x.CurrentSearchData).Returns(FSharpOption.Create(data)).Verifiable();
SimulatKeystroke();
Assert.AreEqual("?cat", _marginControl.StatusLine);
_factory.Verify();
}
public void RaiseEvent()
{
Create("hello world");
_asyncTagger.CachedOverarchingRequestSpan = FSharpOption.Create(_textBuffer.GetLine(0).Extent);
var didRun = false;
_asyncTaggerInterface.TagsChanged += delegate
{
didRun = true;
};
_asyncTaggerSource.RaiseChanged(null);
Assert.True(didRun);
}
public LoadSessionDataTest()
{
_stream = new MemoryStream();
_fileSystem
.Setup(x => x.Read(It.IsAny <string>()))
.Returns(() => FSharpOption.Create(GetStreamCopy()));
_fileSystem
.Setup(x => x.Write(It.IsAny <string>(), It.IsAny <Stream>()))
.Callback <string, Stream>((_, stream) => stream.CopyTo(_stream))
.Returns(true);
_fileSystem
.Setup(x => x.CreateDirectory(It.IsAny <string>()))
.Returns(true);
}
private void Create(params string[] lines)
{
_textView = EditorUtil.CreateTextView(lines);
_visualBuffer = _textView.TextViewModel.VisualBuffer;
_adhocOutliner = EditorUtil.FactoryService.AdhocOutlinerFactory.GetAdhocOutliner(_textView.TextBuffer);
_outliningeManager = EditorUtil.FactoryService.OutliningManagerService.GetOutliningManager(_textView);
_statusUtil = new Mock <IStatusUtil>(MockBehavior.Strict);
_foldData = EditorUtil.FactoryService.FoldManagerFactory.GetFoldData(_textView.TextBuffer);
_foldManagerRaw = new FoldManager(
_textView,
_foldData,
_statusUtil.Object,
FSharpOption.Create(EditorUtil.FactoryService.OutliningManagerService.GetOutliningManager(_textView)));
_foldManager = _foldManagerRaw;
}
public static void AddMark(
this Mock <IMarkMap> map,
ITextBuffer buffer,
char mark,
VirtualSnapshotPoint?point = null)
{
if (point.HasValue)
{
map.Setup(x => x.GetMark(buffer, mark)).Returns(FSharpOption.Create(point.Value));
}
else
{
map.Setup(x => x.GetMark(buffer, mark)).Returns(FSharpOption <VirtualSnapshotPoint> .None);
}
}
public void Create(bool haveRealTransaction = true)
{
_factory = new MockRepository(MockBehavior.Strict);
_editorOperations = _factory.Create <IEditorOperations>();
if (haveRealTransaction)
{
_realTransaction = _factory.Create <ITextUndoTransaction>();
_transactionRaw = new UndoTransaction(FSharpOption.Create(_realTransaction.Object), FSharpOption.Create(_editorOperations.Object));
}
else
{
_transactionRaw = new UndoTransaction(FSharpOption <ITextUndoTransaction> .None, FSharpOption <IEditorOperations> .None);
}
_transaction = _transactionRaw;
}
public void ShellCommand_BangReplacement()
{
Create("");
Vim.VimData.LastShellCommand = FSharpOption.Create("cat");
var didRun = false;
VimHost.RunCommandFunc =
(command, args, _) =>
{
Assert.Equal("/c git status cat", args);
didRun = true;
return("");
};
ParseAndRun(@"!git status !");
Assert.True(didRun);
}
public void SwitchMode_OldModeIsNotExternalThenSaveNothing()
{
Setup("cat", "tree", "dog");
var span = _textBuffer.GetLineRange(0).Extent;
SetupMarkers(15, span);
SetupAdapterCreateMarkerAsSnippet();
var mode = _factory.Create <IMode>();
mode.SetupGet(x => x.ModeKind).Returns(ModeKind.Normal).Verifiable();
_buffer.Raise(x => x.SwitchedMode += null, null, new SwitchModeEventArgs(FSharpOption.Create(mode.Object), null));
var list = _monitor.IgnoredMarkers.ToList();
Assert.AreEqual(0, list.Count);
_factory.Verify();
}
public void LoadVimRc3()
{
// Setup the VimRc contents
var contents = new FileContents(
"foo",
new[] { "set ai" });
_fileSystem.Setup(x => x.GetVimRcDirectories()).Returns(new string[] { "" }).Verifiable();
_fileSystem.Setup(x => x.LoadVimRcContents()).Returns(FSharpOption.Create(contents)).Verifiable();
_vimHost.Setup(x => x.CreateHiddenTextView()).Returns(CreateTextView());
Assert.True(_vim.LoadVimRc());
Assert.True(_vim.VimRcLocalSettings.AutoIndent);
_fileSystem.Verify();
}
public void GetTags_DontReplaceBetterRequest()
{
Create("cat", "dog", "bear");
var cancellationTokenSource = new CancellationTokenSource();
_asyncTagger.AsyncBackgroundRequest = FSharpOption.Create(CreateAsyncBackgroundRequest(
_textBuffer.GetExtent(),
cancellationTokenSource,
new Task(() => { })));
var tags = _asyncTagger.GetTags(_textBuffer.GetLine(0).Extent).ToList();
Assert.AreEqual(0, tags.Count);
Assert.AreSame(cancellationTokenSource, _asyncTagger.AsyncBackgroundRequest.Value.CancellationTokenSource);
}
internal static ICommonOperations CreateCommonOperations(
ITextView textView,
IVimLocalSettings localSettings,
IOutliningManager outlining = null,
IStatusUtil statusUtil = null,
ISearchService searchService = null,
IUndoRedoOperations undoRedoOperations = null,
IVimData vimData = null,
IVimHost vimHost = null,
ITextStructureNavigator navigator = null,
IClipboardDevice clipboardDevice = null,
IFoldManager foldManager = null)
{
var editorOperations = EditorUtil.GetOperations(textView);
var editorOptions = EditorUtil.FactoryService.EditorOptionsFactory.GetOptions(textView);
var jumpList = new JumpList(new TrackingLineColumnService());
var keyMap = new KeyMap();
foldManager = foldManager ?? new FoldManager(textView.TextBuffer);
statusUtil = statusUtil ?? new StatusUtil();
searchService = searchService ?? CreateSearchService(localSettings.GlobalSettings);
undoRedoOperations = undoRedoOperations ??
new UndoRedoOperations(statusUtil, FSharpOption <ITextUndoHistory> .None, editorOperations);
vimData = vimData ?? new VimData();
vimHost = vimHost ?? new MockVimHost();
navigator = navigator ?? CreateTextStructureNavigator(textView.TextBuffer);
clipboardDevice = clipboardDevice ?? new MockClipboardDevice();
var operationsData = new OperationsData(
editorOperations,
editorOptions,
foldManager,
jumpList,
keyMap,
localSettings,
outlining != null ? FSharpOption.Create(outlining) : FSharpOption <IOutliningManager> .None,
CreateRegisterMap(clipboardDevice),
searchService,
statusUtil,
textView,
undoRedoOperations,
vimData,
vimHost,
navigator);
return(new CommonOperations(operationsData));
}
public void Create(bool haveRealTransaction = true)
{
_factory = new MockRepository(MockBehavior.Strict);
var undoRedoOperations = new UndoRedoOperations(VimHost, new StatusUtil(), FSharpOption <ITextUndoHistory> .None, EditorOperationsFactoryService);
if (haveRealTransaction)
{
_realTransaction = _factory.Create <ITextUndoTransaction>();
_transactionRaw = new NormalUndoTransaction("Undo", FSharpOption.Create(_realTransaction.Object), undoRedoOperations);
}
else
{
_transactionRaw = new NormalUndoTransaction("Undo", FSharpOption <ITextUndoTransaction> .None, undoRedoOperations);
}
_transaction = _transactionRaw;
}
public void UseRequestSpan()
{
Create("cat", "dog");
var span = _textBuffer.GetSpan(0, 2);
_basicTagger.CachedRequestSpan = FSharpOption.Create(span);
var didRun = false;
_basicTaggerInterface.TagsChanged += (e, args) =>
{
didRun = true;
Assert.Equal(span, args.Span);
};
_basicTaggerSource.RaiseChanged();
Assert.True(didRun);
}
int IVsSelectionEvents.OnElementValueChanged(uint elementid, object varValueOld, object varValueNew)
{
var id = (VSConstants.VSSELELEMID)elementid;
if (id == VSConstants.VSSELELEMID.SEID_WindowFrame)
{
ITextView getTextView(object obj)
{
var vsWindowFrame = obj as IVsWindowFrame;
if (vsWindowFrame == null)
{
return(null);
}
var vsCodeWindow = vsWindowFrame.GetCodeWindow();
if (vsCodeWindow.IsError)
{
return(null);
}
var lastActiveTextView = vsCodeWindow.Value.GetLastActiveView(_vsAdapter.EditorAdapter);
if (lastActiveTextView.IsError)
{
return(null);
}
return(lastActiveTextView.Value);
}
ITextView oldView = getTextView(varValueOld);
ITextView newView = null;
if (ErrorHandler.Succeeded(_vsMonitorSelection.GetCurrentElementValue((uint)VSConstants.VSSELELEMID.SEID_WindowFrame, out object value)))
{
newView = getTextView(value);
}
RaiseActiveTextViewChanged(
oldView == null ? FSharpOption <ITextView> .None : FSharpOption.Create <ITextView>(oldView),
newView == null ? FSharpOption <ITextView> .None : FSharpOption.Create <ITextView>(newView));
}
return(VSConstants.S_OK);
}
public void LoadVimRc3()
{
// Setup the VimRc contents
var fileName = "foo";
var contents = new string[] { "set ai" };
var tuple = Tuple.Create(fileName, contents);
_fileSystem.Setup(x => x.GetVimRcDirectories()).Returns(new string[] { "" }).Verifiable();
_fileSystem.Setup(x => x.LoadVimRc()).Returns(FSharpOption.Create(tuple)).Verifiable();
Func <ITextView> createViewFunc = () => EditorUtil.CreateTextView();
Assert.IsTrue(_vim.LoadVimRc(createViewFunc.ToFSharpFunc()));
Assert.IsTrue(_vim.VimRcLocalSettings.AutoIndent);
_fileSystem.Verify();
}
public void GetTags_ReplaceWhenSnapshotChanges()
{
Create("cat", "dog", "bear");
var cancellationTokenSource = new CancellationTokenSource();
_asyncTagger.AsyncBackgroundRequest = FSharpOption.Create(CreateAsyncBackgroundRequest(
_textBuffer.GetExtent(),
cancellationTokenSource,
new Task(() => { })));
_textBuffer.Replace(new Span(0, 3), "bat");
var tags = _asyncTagger.GetTags(_textBuffer.GetExtent()).ToList();
Assert.AreEqual(0, tags.Count);
Assert.AreNotSame(cancellationTokenSource, _asyncTagger.AsyncBackgroundRequest.Value.CancellationTokenSource);
Assert.IsTrue(cancellationTokenSource.IsCancellationRequested);
Assert.AreEqual(_textBuffer.GetExtent(), _asyncTagger.AsyncBackgroundRequest.Value.Span);
}
private void VeriyCurrentMatchChanged(Action action, Func <SnapshotSpan?> expectedFunc)
{
var didSee = false;
FSharpOption <SnapshotSpan> saw = FSharpOption <SnapshotSpan> .None;
_mode.CurrentMatchChanged += (sender, e) =>
{
didSee = true;
saw = e;
};
action();
var expected = expectedFunc();
var expectedOption = expected.HasValue
? FSharpOption.Create(expected.Value)
: FSharpOption <SnapshotSpan> .None;
Assert.True(didSee);
Assert.Equal(expectedOption, _mode.CurrentMatch);
}
public void Create(HistoryKind historyKind = HistoryKind.Mock)
{
_factory = new MockRepository(MockBehavior.Strict);
_statusUtil = _factory.Create <IStatusUtil>();
_textView = CreateTextView();
_textBuffer = _textView.TextBuffer;
var editorOperationsFactoryService = _factory.Create <IEditorOperationsFactoryService>();
FSharpOption <ITextUndoHistory> textUndoHistory;
switch (historyKind)
{
case HistoryKind.Mock:
_mockUndoHistory = _factory.Create <ITextUndoHistory>();
_mockUndoHistory.Setup(x => x.Undo(It.IsAny <int>())).Callback <int>(count => { _undoCount += count; });
_mockUndoHistory.Setup(x => x.Redo(It.IsAny <int>())).Callback <int>(count => { _redoCount += count; });
textUndoHistory = FSharpOption.Create(_mockUndoHistory.Object);
break;
case HistoryKind.Basic:
textUndoHistory = FSharpOption.Create(BasicUndoHistoryRegistry.TextUndoHistoryRegistry.RegisterHistory(_textBuffer));
break;
case HistoryKind.None:
textUndoHistory = FSharpOption.CreateForReference <ITextUndoHistory>(null);
break;
default:
Assert.True(false);
textUndoHistory = null;
break;
}
_undoRedoOperationsRaw = new UndoRedoOperations(
VimHost,
_statusUtil.Object,
textUndoHistory,
editorOperationsFactoryService.Object);
_undoRedoOperations = _undoRedoOperationsRaw;
}
private void Create(params string[] lines)
{
_textView = EditorUtil.CreateView(lines);
_factory = new MockRepository(MockBehavior.Strict);
_editOpts = _factory.Create <IEditorOperations>();
_editOpts.Setup(x => x.AddAfterTextBufferChangePrimitive());
_editOpts.Setup(x => x.AddBeforeTextBufferChangePrimitive());
_host = _factory.Create <IVimHost>();
_jumpList = _factory.Create <IJumpList>();
_registerMap = MockObjectFactory.CreateRegisterMap(factory: _factory);
_globalSettings = _factory.Create <IVimGlobalSettings>();
_globalSettings.SetupGet(x => x.Magic).Returns(true);
_globalSettings.SetupGet(x => x.SmartCase).Returns(false);
_globalSettings.SetupGet(x => x.IgnoreCase).Returns(true);
_settings = MockObjectFactory.CreateLocalSettings(global: _globalSettings.Object);
_keyMap = _factory.Create <IKeyMap>();
_statusUtil = _factory.Create <IStatusUtil>();
_outlining = _factory.Create <IOutliningManager>();
_undoRedoOperations = VimUtil.CreateUndoRedoOperations(_statusUtil.Object);
_searchService = VimUtil.CreateSearchService(_globalSettings.Object);
var data = new OperationsData(
vimData: new VimData(),
vimHost: _host.Object,
textView: _textView,
editorOperations: _editOpts.Object,
outliningManager: FSharpOption.Create(_outlining.Object),
statusUtil: _statusUtil.Object,
jumpList: _jumpList.Object,
localSettings: _settings.Object,
keyMap: _keyMap.Object,
undoRedoOperations: _undoRedoOperations,
editorOptions: null,
navigator: null,
foldManager: null,
registerMap: _registerMap.Object,
searchService: _searchService);
_operationsRaw = new DefaultOperations(data);
_operations = _operationsRaw;
}
public void Create(bool haveHistory = true)
{
_factory = new MockRepository(MockBehavior.Strict);
_editorOperations = _factory.Create <IEditorOperations>();
_statusUtil = _factory.Create <IStatusUtil>();
if (haveHistory)
{
_history = _factory.Create <ITextUndoHistory>();
_operationsRaw = new UndoRedoOperations(
_statusUtil.Object,
FSharpOption.Create(_history.Object),
_editorOperations.Object);
}
else
{
_operationsRaw = new UndoRedoOperations(
_statusUtil.Object,
FSharpOption <ITextUndoHistory> .None,
_editorOperations.Object);
}
_operations = _operationsRaw;
}
/// <summary>
/// With Resharper installed we need to special certain keys like Escape. They need to
/// process it in order for them to dismiss their custom intellisense but their processing
/// will swallow the event and not propagate it to us. So handle, return and account
/// for the double stroke in exec
/// </summary>
private CommandAction?QueryStatusInResharper(KeyInput keyInput)
{
CommandAction?action = null;
if (_buffer.ModeKind == ModeKind.Insert && keyInput == KeyInputUtil.EscapeKey)
{
// Have to special case Escape here for insert mode. R# is typically ahead of us on the IOleCommandTarget
// chain. If a completion window is open and we wait for Exec to run R# will be ahead of us and run
// their Exec call. This will lead to them closing the completion window and not calling back into
// our exec leaving us in insert mode.
action = CommandAction.Enable;
}
else if (_buffer.ModeKind == ModeKind.ExternalEdit && keyInput == KeyInputUtil.EscapeKey)
{
// Have to special case Escape here for external edit mode because we want escape to get us back to
// normal mode
action = CommandAction.Enable;
}
else if (_adapter.InDebugMode && (keyInput == KeyInputUtil.EnterKey || keyInput.Key == VimKey.Back))
{
// In debug mode R# will intercept Enter and Back
action = CommandAction.Enable;
}
else if (keyInput == KeyInputUtil.EnterKey && _buffer.ModeKind != ModeKind.Insert && _buffer.ModeKind != ModeKind.Replace)
{
// R# will intercept the Enter key when we are in the middle of an XML doc comment presumable
// to do some custom formatting. If we're not insert mode we need to handle that here and
// suppress the command to keep them from running it
action = CommandAction.Disable;
}
if (action.HasValue && _buffer.Process(keyInput))
{
SwallowIfNextExecMatches = FSharpOption.Create(keyInput);
}
return(action);
}
public override FSharpOption <int> GetNewLineIndent(ITextView textView, ITextSnapshotLine contextLine, ITextSnapshotLine newLine)
{
if (_vimApplicationSettings.UseEditorIndent)
{
var indent = _smartIndentationService.GetDesiredIndentation(textView, newLine);
if (indent.HasValue)
{
return(FSharpOption.Create(indent.Value));
}
else
{
// If the user wanted editor indentation but the editor doesn't support indentation
// even though it proffers an indentation service then fall back to what auto
// indent would do if it were enabled (don't care if it actually is)
//
// Several editors like XAML offer the indentation service but don't actually
// provide information. User clearly wants indent there since the editor indent
// is enabled. Do a best effort and us Vim style indenting
return(FSharpOption.Create(EditUtil.GetAutoIndent(contextLine)));
}
}
return(FSharpOption <int> .None);
}
public override FSharpOption <ITextView> LoadFileIntoNewWindow(string filePath, FSharpOption <int> line, FSharpOption <int> column)
{
try
{
var textDocument = TextDocumentFactoryService.CreateAndLoadTextDocument(filePath, TextBufferFactoryService.TextContentType);
var wpfTextView = MainWindow.CreateTextView(textDocument.TextBuffer);
MainWindow.AddNewTab(System.IO.Path.GetFileName(filePath), wpfTextView);
if (line.IsSome())
{
// Move the caret to its initial position.
if (column.IsSome())
{
wpfTextView.MoveCaretToLine(line.Value, column.Value);
}
else
{
// Default column implies moving to the first non-blank.
wpfTextView.MoveCaretToLine(line.Value);
var editorOperations = EditorOperationsFactoryService.GetEditorOperations(wpfTextView);
editorOperations.MoveToStartOfLineAfterWhiteSpace(false);
}
}
// Give the focus to the new buffer.
var point = wpfTextView.Caret.Position.VirtualBufferPosition;
NavigateTo(point);
return(FSharpOption.Create <ITextView>(wpfTextView));
}
catch (Exception ex)
{
_vim.ActiveStatusUtil.OnError(ex.Message);
return(FSharpOption <ITextView> .None);
}
}
public void BackslashLiteral()
{
AssertSingle(@"\", new KeyInput(VimKey.RawCharacter, VimKeyModifiers.None, FSharpOption.Create('\\')));
}
private void SetRcContents(params string[] lines)
{
var contents = new FileContents("foo", lines);
_fileSystem.Setup(x => x.LoadVimRcContents()).Returns(FSharpOption.Create(contents)).Verifiable();
}
private static FSharpOption <MotionResult> CreateMotionResultSome()
{
return(FSharpOption.Create(CreateMotionResult()));
}
FSharpOption <ITextView> IVimHost.GetFocusedTextView()
{
return(TryGetFocusedTextView(out ITextView textView)
? FSharpOption.Create(textView)
: FSharpOption <ITextView> .None);
}
public void HandleCommandKey()
{
Map("<D-k>", "gk");
var ki = new KeyInput(VimKey.RawCharacter, VimKeyModifiers.Command, FSharpOption.Create('k'));
var kiSet = new KeyInputSet(ki);
AssertPartialMapping(kiSet, "g", "k");
}
/// <summary>
/// With Resharper installed we need to special certain keys like Escape. They need to
/// process it in order for them to dismiss their custom intellisense but their processing
/// will swallow the event and not propagate it to us. So handle, return and account
/// for the double stroke in exec
/// </summary>
private CommandStatus?QueryStatusInResharper(KeyInput keyInput)
{
CommandStatus?status = null;
var passToResharper = true;
if (_buffer.ModeKind.IsAnyInsert() && keyInput == KeyInputUtil.EscapeKey)
{
// Have to special case Escape here for insert mode. R# is typically ahead of us on the IOleCommandTarget
// chain. If a completion window is open and we wait for Exec to run R# will be ahead of us and run
// their Exec call. This will lead to them closing the completion window and not calling back into
// our exec leaving us in insert mode.
status = CommandStatus.Enable;
}
else if (_buffer.ModeKind == ModeKind.ExternalEdit && keyInput == KeyInputUtil.EscapeKey)
{
// Have to special case Escape here for external edit mode because we want escape to get us back to
// normal mode. However we do want this key to make it to R# as well since they may need to dismiss
// intellisense
status = CommandStatus.Enable;
}
else if ((keyInput.Key == VimKey.Back || keyInput == KeyInputUtil.EnterKey) && _buffer.ModeKind != ModeKind.Insert)
{
// R# special cases both the Back and Enter command in various scenarios
//
// - Enter is special cased in XML doc comments presumably to do custom formatting
// - Enter is supressed during debugging in Exec. Presumably this is done to avoid the annoying
// "Invalid ENC Edit" dialog during debugging.
// - Back is special cased to delete matched parens in Exec.
//
// In all of these scenarios if the Enter or Back key is registered as a valid Vim
// command we want to process it as such and prevent R# from seeing the command. If
// R# is allowed to see the command they will process it often resulting in double
// actions
status = CommandStatus.Enable;
passToResharper = false;
}
// Only process the KeyInput if we are enabling the value. When the value is Enabled
// we return Enabled from QueryStatus and Visual Studio will push the KeyInput back
// through the event chain where either of the following will happen
//
// 1. R# will handle the KeyInput
// 2. R# will not handle it, it will come back to use in Exec and we will ignore it
// because we mark it as silently handled
if (status.HasValue && status.Value == CommandStatus.Enable && _buffer.Process(keyInput).IsAnyHandled)
{
// We've broken the rules a bit by handling the command in QueryStatus and we need
// to silently handle this command if it comes back to us again either through
// Exec or through the VsKeyProcessor
_bufferCoordinator.DiscardedKeyInput = FSharpOption.Create(keyInput);
// If we need to cooperate with R# to handle this command go ahead and pass it on
// to them. Else mark it as Disabled.
//
// Marking it as Disabled will cause the QueryStatus call to fail. This means the
// KeyInput will be routed to the KeyProcessor chain for the ITextView eventually
// making it to our VsKeyProcessor. That component respects the SilentlyHandled
// statu of KeyInput and will siently handle it
status = passToResharper ? CommandStatus.Enable : CommandStatus.Disable;
}
return(status);
}
internal static MotionData CreateMotionData(
Motion motion,
int count)
{
return(CreateMotionData(motion, new MotionArgument(MotionContext.AfterOperator, FSharpOption.Create(count), FSharpOption <int> .None)));
}
