public Task<bool> ExecuteAsync(ITaskCoverageManager taskCoverageManager, IVsSolutionTestCoverage vsSolutionTestCoverage, IDocumentProvider documentProvider)
        {
            string methodName = Method.Identifier.ValueText;
            RaiseTaskStartedEvent(taskCoverageManager);

            var documentSyntaxTree = documentProvider.GetSyntaxNodeFromTextSnapshot(TextBuffer.CurrentSnapshot);

            var methodNode = documentSyntaxTree.DescendantNodes()
                .OfType<MethodDeclarationSyntax>()
                .FirstOrDefault(x => x.Identifier.ValueText == methodName);

            if (methodNode == null)
                return Task.FromResult(false);

            Task<bool> task = vsSolutionTestCoverage.CalculateForSelectedMethodAsync(ProjectName, methodNode);

            var finalTask = task.ContinueWith((x, y) =>
            {
                if(!x.Result)
                    taskCoverageManager.ReportTaskToRetry(this);

                RaiseTasCompletedEvent(taskCoverageManager);
                return x.Result;

            }, null, TaskSchedulerManager.Current.FromSynchronizationContext());

            return finalTask;
        }
 public RoslynSolutionWatcher(DTE dte, Workspace workspace, ICoverageStore coverageStore, IRewrittenDocumentsStorage rewrittenDocumentsStorage, ITaskCoverageManager taskCoverageManager)
 {
     _dte = dte;
     _workspace = workspace;
     _coverageStore = coverageStore;
     _rewrittenDocumentsStorage = rewrittenDocumentsStorage;
     _taskCoverageManager = taskCoverageManager;
 }
        public Task<bool> ExecuteAsync(ITaskCoverageManager taskCoverageManager, IVsSolutionTestCoverage vsSolutionTestCoverage,
            IDocumentProvider documentProvider)
        {
            taskCoverageManager.RaiseEvent(new ResyncAllStarted());
            var task = vsSolutionTestCoverage.CalculateForAllDocumentsAsync();

            var finalTask = task.ContinueWith((finishedTask, y) =>
            {
                taskCoverageManager.RaiseEvent(new ResyncAllCompleted());

                return finishedTask.Result;
            }, null, TaskSchedulerManager.Current.FromSynchronizationContext());

            return finalTask;
        }
        public Task<bool> ExecuteAsync(ITaskCoverageManager taskCoverageManager, IVsSolutionTestCoverage vsSolutionTestCoverage,
            IDocumentProvider documentProvider)
        {
            taskCoverageManager.RaiseEvent(new DocumentCoverageTaskStartedArgs(DocumentPath));

            string documentContent = TextBuffer.CurrentSnapshot.GetText();
            var task = vsSolutionTestCoverage.CalculateForDocumentAsync(ProjectName, DocumentPath, documentContent);

            var finalTask = task.ContinueWith((finishedTask, y) =>
            {
                if (finishedTask.Result)
                    taskCoverageManager.Tasks.RemoveAll(t => IsTaskInDocument(t, DocumentPath));
                else
                    taskCoverageManager.ReportTaskToRetry(this);

                taskCoverageManager.RaiseEvent(new DocumentCoverageTaskCompletedArgs(DocumentPath));

                return finishedTask.Result;
            }, null, TaskSchedulerManager.Current.FromSynchronizationContext());

            return finalTask;
        }
        public TestDotsCoverageVsPlugin(VsSolutionTestCoverage vsSolutionTestCoverage,
            ITaskCoverageManager taskCoverageManager,
            IWpfTextView textView,
            IVsStatusbar statusBar,
            Solution solution)
        {
            _vsSolutionTestCoverage = vsSolutionTestCoverage;
            _taskCoverageManager = taskCoverageManager;

            _canvas = new Canvas();
            _textView = textView;
            _statusBar = statusBar;
            _solution = solution;

            _textView.ViewportHeightChanged += (s, e) => Redraw();
            _textView.LayoutChanged += LayoutChanged;
            this.Width = 20;
            this.ClipToBounds = true;
            this.Background = new SolidColorBrush(Colors.White);
            Children.Add(_canvas);
            textView.TextBuffer.Changed += TextBuffer_Changed;

            _taskCoverageManager.CoverageTaskEvent += TaskCoverageManagerCoverageTaskEvent;
        }
        private void RaiseTaskStartedEvent(ITaskCoverageManager taskCoverageManager)
        {
            var args=new MethodCoverageTaskStartedArgs(DocumentPath, MethodName);

            taskCoverageManager.RaiseEvent(args);
        }
        private void InitSolutionCoverageEngine()
        {
            InitMyWorkspace(_serviceProvider);
            string solutionPath = _dte.Solution.FullName;

            if (_vsSolutionTestCoverage != null && _vsSolutionTestCoverage.MyWorkspace == _myWorkspace)
                return;

            Config.SetSolution(solutionPath);

            var sqlCompactCoverageStore = new SqlCompactCoverageStore();
            var rewrittenDocumentsStorage = new RewrittenDocumentsStorage();

            _vsSolutionTestCoverage = VsSolutionTestCoverage.CreateInstanceIfDoesNotExist(_myWorkspace,
                new SolutionCoverageEngine(),
                sqlCompactCoverageStore);

            _taskCoverageManager = new TaskCoverageManager(new VsDispatchTimer(), new RoslynDocumentProvider(), _vsSolutionTestCoverage);
            _roslynSolutionWatcher = new RoslynSolutionWatcher(_dte, _myWorkspace,
                sqlCompactCoverageStore, rewrittenDocumentsStorage, _taskCoverageManager);
            _roslynSolutionWatcher.DocumentRemoved += _roslynSolutionWatcher_DocumentRemoved;
            _roslynSolutionWatcher.Start();
        }