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);
     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,
         EditorUtil.FactoryService.SmartIndentationService,
         statusUtil,
         textView,
         undoRedoOperations,
         vimData,
         vimHost,
         navigator);
     return new CommonOperations(operationsData);
 }

 public virtual void VimRcLoaded(VimRcState vimRcState, IVimLocalSettings localSettings, IVimWindowSettings windowSettings)
 {
 }

 public override void VimRcLoaded(VimRcState vimRcState, IVimLocalSettings localSettings, IVimWindowSettings windowSettings)
 {
     if (vimRcState.IsLoadFailed)
     {
         // If we failed to load a vimrc file then we should add a couple of sanity
         // settings.  Otherwise the Visual Studio experience wont't be what users expect
         localSettings.AutoIndent = true;
     }
 }

 /// <summary>
 /// Create a Mock over IVimTextBuffer which provides the msot basic functions
 /// </summary>
 public static Mock<IVimTextBuffer> CreateVimTextBuffer(
     ITextBuffer textBuffer,
     IVimLocalSettings localSettings = null,
     IVim vim = null,
     ITextStructureNavigator wordNavigator = null,
     IUndoRedoOperations undoRedoOperations = null,
     MockRepository factory = null)
 {
     factory = factory ?? new MockRepository(MockBehavior.Strict);
     vim = vim ?? CreateVim(factory: factory).Object;
     localSettings = localSettings ?? CreateLocalSettings(factory: factory).Object;
     wordNavigator = wordNavigator ?? factory.Create<ITextStructureNavigator>().Object;
     undoRedoOperations = undoRedoOperations ?? factory.Create<IUndoRedoOperations>().Object;
     var mock = factory.Create<IVimTextBuffer>();
     mock.SetupGet(x => x.TextBuffer).Returns(textBuffer);
     mock.SetupGet(x => x.LocalSettings).Returns(localSettings);
     mock.SetupGet(x => x.GlobalSettings).Returns(localSettings.GlobalSettings);
     mock.SetupGet(x => x.Vim).Returns(vim);
     mock.SetupGet(x => x.WordNavigator).Returns(wordNavigator);
     mock.SetupGet(x => x.ModeKind).Returns(ModeKind.Normal);
     mock.SetupGet(x => x.UndoRedoOperations).Returns(undoRedoOperations);
     mock.SetupProperty(x => x.LastVisualSelection);
     mock.SetupProperty(x => x.LastInsertExitPoint);
     mock.SetupProperty(x => x.LastEditPoint);
     mock.Setup(x => x.SwitchMode(It.IsAny<ModeKind>(), It.IsAny<ModeArgument>()));
     return mock;
 }

 /// <summary>
 /// Create a Mock over IVimTextBuffer which provides the msot basic functions
 /// </summary>
 public static Mock<IVimTextBuffer> CreateVimTextBuffer(
     ITextBuffer textBuffer,
     IVimLocalSettings localSettings = null,
     IVim vim = null,
     MockRepository factory = null)
 {
     factory = factory ?? new MockRepository(MockBehavior.Strict);
     vim = vim ?? CreateVim(factory: factory).Object;
     localSettings = localSettings ?? CreateLocalSettings(factory: factory).Object;
     var mock = factory.Create<IVimTextBuffer>();
     mock.SetupGet(x => x.TextBuffer).Returns(textBuffer);
     mock.SetupGet(x => x.LocalSettings).Returns(localSettings);
     mock.SetupGet(x => x.GlobalSettings).Returns(localSettings.GlobalSettings);
     mock.SetupGet(x => x.Vim).Returns(vim);
     mock.SetupProperty(x => x.LastVisualSelection);
     return mock;
 }

 public static Mock<IVimBuffer> CreateVimBuffer(
     ITextView textView,
     string name = null,
     IVim vim = null,
     IJumpList jumpList = null,
     IVimLocalSettings localSettings = null,
     IIncrementalSearch incrementalSearch = null,
     IMotionUtil motionUtil = null,
     ITextStructureNavigator wordNavigator = null,
     MockRepository factory = null)
 {
     factory = factory ?? new MockRepository(MockBehavior.Strict);
     name = name ?? "test";
     vim = vim ?? CreateVim().Object;
     jumpList = jumpList ?? (factory.Create<IJumpList>().Object);
     motionUtil = motionUtil ?? factory.Create<IMotionUtil>().Object;
     wordNavigator = wordNavigator ?? factory.Create<ITextStructureNavigator>().Object;
     localSettings = localSettings ?? new LocalSettings(vim.GlobalSettings);
     var vimTextBuffer = CreateVimTextBuffer(
         textView.TextBuffer,
         localSettings: localSettings,
         vim: vim,
         factory: factory);
     var mock = factory.Create<IVimBuffer>();
     mock.SetupGet(x => x.TextView).Returns(textView);
     mock.SetupGet(x => x.MotionUtil).Returns(motionUtil);
     mock.SetupGet(x => x.TextBuffer).Returns(() => textView.TextBuffer);
     mock.SetupGet(x => x.TextSnapshot).Returns(() => textView.TextSnapshot);
     mock.SetupGet(x => x.Name).Returns(name);
     mock.SetupGet(x => x.LocalSettings).Returns(localSettings);
     mock.SetupGet(x => x.GlobalSettings).Returns(localSettings.GlobalSettings);
     mock.SetupGet(x => x.MarkMap).Returns(vim.MarkMap);
     mock.SetupGet(x => x.RegisterMap).Returns(vim.RegisterMap);
     mock.SetupGet(x => x.JumpList).Returns(jumpList);
     mock.SetupGet(x => x.Vim).Returns(vim);
     mock.SetupGet(x => x.VimData).Returns(vim.VimData);
     mock.SetupGet(x => x.IncrementalSearch).Returns(incrementalSearch);
     mock.SetupGet(x => x.WordNavigator).Returns(wordNavigator);
     mock.SetupGet(x => x.VimTextBuffer).Returns(vimTextBuffer.Object);
     return mock;
 }

 void IVimHost.VimRcLoaded(VimRcState vimRcState, IVimLocalSettings localSettings, IVimWindowSettings windowSettings)
 {
     VimRcState = vimRcState;
 }

 internal OperationsImpl(ITextView view, IEditorOperations opts, IOutliningManager outlining, IVimHost host, IJumpList jumpList, IVimLocalSettings settings, IUndoRedoOperations undoRedoOpts)
     : base(view, opts, outlining, host, jumpList, settings, undoRedoOpts)
 {
 }

        protected void Create(params string[] lines)
        {
            _vimHost = (MockVimHost)Vim.VimHost;
            _textView = CreateTextView(lines);
            _textBuffer = _textView.TextBuffer;
            _vimTextBuffer = Vim.CreateVimTextBuffer(_textBuffer);
            _localSettings = _vimTextBuffer.LocalSettings;

            var foldManager = CreateFoldManager(_textView);

            _factory = new MockRepository(MockBehavior.Loose);
            _statusUtil = _factory.Create<IStatusUtil>();
            _bulkOperations = new TestableBulkOperations();

            var vimBufferData = CreateVimBufferData(
                _vimTextBuffer,
                _textView,
                statusUtil: _statusUtil.Object);
            _jumpList = vimBufferData.JumpList;
            _windowSettings = vimBufferData.WindowSettings;

            _vimData = Vim.VimData;
            _macroRecorder = Vim.MacroRecorder;
            _globalSettings = Vim.GlobalSettings;

            var operations = CreateCommonOperations(vimBufferData);
            _motionUtil = new MotionUtil(vimBufferData, operations);
            _commandUtil = new CommandUtil(
                vimBufferData,
                _motionUtil,
                operations,
                foldManager,
                new InsertUtil(vimBufferData, operations),
                _bulkOperations);
        }

 private void Create(ITextView textView)
 {
     _textView = textView;
     _textBuffer = textView.TextBuffer;
     _buffer = _textView.TextBuffer;
     _snapshot = _buffer.CurrentSnapshot;
     _buffer.Changed += delegate { _snapshot = _buffer.CurrentSnapshot; };
     _globalSettings = new Vim.GlobalSettings();
     _localSettings = new LocalSettings(_globalSettings, _textView);
     _markMap = new MarkMap(new TrackingLineColumnService());
     _vimData = new VimData();
     _search = VimUtil.CreateSearchService(_globalSettings);
     _jumpList = VimUtil.CreateJumpList();
     _statusUtil = new Mock<IStatusUtil>(MockBehavior.Strict);
     _navigator = VimUtil.CreateTextStructureNavigator(_textView.TextBuffer);
     _motionUtil = new MotionUtil(
         _textView,
         _markMap,
         _localSettings,
         _search,
         _navigator,
         _jumpList,
         _statusUtil.Object,
         _vimData);
 }

 public void SetUp()
 {
     _textView= new Mock<ITextView>(MockBehavior.Strict);
     _global = new Mock<IVimGlobalSettings>(MockBehavior.Strict);
     _localRaw = new LocalSettings(_global.Object, _textView.Object);
     _local = _localRaw;
 }

 private void Create(ITextView textView, IEditorOptions editorOptions = null)
 {
     _textView = textView;
     _textBuffer = textView.TextBuffer;
     _snapshot = _textBuffer.CurrentSnapshot;
     _textBuffer.Changed += delegate { _snapshot = _textBuffer.CurrentSnapshot; };
     _globalSettings = new Vim.GlobalSettings();
     _localSettings = new LocalSettings(_globalSettings, FSharpOption.CreateForReference(editorOptions), FSharpOption.CreateForReference(textView));
     _markMap = new MarkMap(new TrackingLineColumnService());
     _vimData = new VimData();
     _search = VimUtil.CreateSearchService(_globalSettings);
     _jumpList = VimUtil.CreateJumpList();
     _statusUtil = new Mock<IStatusUtil>(MockBehavior.Strict);
     _navigator = VimUtil.CreateTextStructureNavigator(_textView, WordKind.NormalWord);
     _motionUtil = new MotionUtil(
         _textView,
         _markMap,
         _localSettings,
         _search,
         _navigator,
         _jumpList,
         _statusUtil.Object,
         VimUtil.GetWordUtil(textView),
         _vimData);
 }

 public void Setup()
 {
     _synchronizer = new EditorToSettingSynchronizer(EditorUtil.FactoryService.Vim);
     _buffer = EditorUtil.FactoryService.Vim.CreateBuffer(EditorUtil.CreateTextView(""));
     _localSettings = _buffer.LocalSettings;
     _globalSettings = _localSettings.GlobalSettings;
     _editorOptions = _localSettings.EditorOptions.Value;
 }

        public EditorToSettingSynchronizerTest()
        {
            _synchronizer = new EditorToSettingSynchronizer(EditorOptionsFactoryService, Vim);

            _buffer = CreateVimBuffer("");
            _localSettings = _buffer.LocalSettings;
            _globalSettings = _localSettings.GlobalSettings;
            _editorOptions = _buffer.TextView.Options;
        }

        public void Setup()
        {
            _synchronizer = new EditorToSettingSynchronizer(EditorUtil.FactoryService.EditorOptionsFactory, EditorUtil.FactoryService.Vim);

            var textView = EditorUtil.CreateTextView("");
            _buffer = EditorUtil.FactoryService.Vim.CreateVimBuffer(textView);
            _localSettings = _buffer.LocalSettings;
            _globalSettings = _localSettings.GlobalSettings;
            _editorOptions = EditorUtil.FactoryService.EditorOptionsFactory.GetOptions(textView);
        }

 protected void Create(ModeArgument argument, params string[] lines)
 {
     _textView = CreateTextView(lines);
     _textBuffer = _textView.TextBuffer;
     _vimBuffer = Vim.CreateVimBuffer(_textView);
     _vimBuffer.SwitchMode(ModeKind.Insert, argument);
     _register = Vim.RegisterMap.GetRegister('c');
     _globalSettings = Vim.GlobalSettings;
     _localSettings = _vimBuffer.LocalSettings;
 }

 public void Create(ITextView textView)
 {
     _textView = textView;
     _buffer = _textView.TextBuffer;
     _snapshot = _buffer.CurrentSnapshot;
     _buffer.Changed += delegate { _snapshot = _buffer.CurrentSnapshot; };
     _settings = new Vim.GlobalSettings();
     _localSettings = new LocalSettings(_settings, _textView);
     _utilRaw = new TextViewMotionUtil(_textView, _localSettings);
     _util = _utilRaw;
 }

        /// <summary>
        /// Create the IVimBuffer with the given set of lines.  Note that we intentionally don't
        /// set the mode to Insert here because the given commands should work irrespective of the 
        /// mode
        /// </summary>
        /// <param name="lines"></param>
        private void Create(params string[] lines)
        {
            _textView = CreateTextView(lines);
            _textBuffer = _textView.TextBuffer;
            _vimBuffer = Vim.CreateVimBuffer(_textView);
            _globalSettings = _vimBuffer.GlobalSettings;
            _localSettings = _vimBuffer.LocalSettings;

            var operations = CommonOperationsFactory.GetCommonOperations(_vimBuffer.VimBufferData);
            _insertUtilRaw = new InsertUtil(_vimBuffer.VimBufferData, operations);
            _insertUtil = _insertUtilRaw;
        }

        public EditorToSettingSynchronizerTest()
        {
            _synchronizer = new EditorToSettingSynchronizer();

            var textView = CreateTextView();
            var globalSettings = new GlobalSettings();
            _localSettings = new LocalSettings(globalSettings);
            _windowSettings = new WindowSettings(globalSettings);
            _editorOptions = textView.Options;
            _vimBuffer = new Mock<IVimBuffer>(MockBehavior.Strict);
            _vimBuffer.SetupGet(x => x.LocalSettings).Returns(_localSettings);
            _vimBuffer.SetupGet(x => x.WindowSettings).Returns(_windowSettings);
            _vimBuffer.SetupGet(x => x.TextView).Returns(textView);
        }

 public void Create(ITextView textView)
 {
     _textView = textView;
     _buffer = _textView.TextBuffer;
     _snapshot = _buffer.CurrentSnapshot;
     _buffer.Changed += delegate { _snapshot = _buffer.CurrentSnapshot; };
     _settings = new Vim.GlobalSettings();
     _localSettings = new LocalSettings(_settings, _textView);
     _markMap = new MarkMap(new TrackingLineColumnService());
     _utilRaw = new TextViewMotionUtil(
         _textView,
         _markMap,
         _localSettings);
     _util = _utilRaw;
 }