private void _state_StateChanged(object sender, ParserStateEventArgs e)
{
if (_viewModel == null)
{
return;
}
if (_state.Status != ParserState.Error && _state.Status != ParserState.Parsed)
{
return;
}
_uiDispatcher.InvokeAsync(UpdateTab);
}
private void StateChangedHandler(object sender, ParserStateEventArgs e)
{
if (!CanRun || e.IsError)
{
refreshBackoff = false;
}
// CanRun returned true already, only refresh tests if we're not backed off
else if (!refreshBackoff && e.OldState != ParserState.Busy)
{
refreshBackoff = true;
Tests = TestDiscovery.GetAllTests(_state);
_uiDispatcher.InvokeAsync(() => TestsRefreshed?.Invoke(this, EventArgs.Empty));
}
}
private void _state_StateChanged(object sender, ParserStateEventArgs e)
{
if (e.State != ParserState.Ready)
{
return;
}
if (_viewModel == null)
{
return;
}
UiDispatcher.InvokeAsync(UpdateTab);
}
private void State_StateChanged(object sender, ParserStateEventArgs e)
{
if (e.State != ParserState.ResolvedDeclarations)
{
return;
}
_dispatcher.Invoke(() =>
{
var tests = UnitTestUtils.GetAllTests(_vbe, _state).ToList();
var removedTests = Tests.Where(test =>
!tests.Any(t =>
t.Declaration.ComponentName == test.Declaration.ComponentName &&
t.Declaration.IdentifierName == test.Declaration.IdentifierName &&
t.Declaration.ProjectId == test.Declaration.ProjectId)).ToList();
// remove old tests
foreach (var test in removedTests)
{
Tests.Remove(test);
}
// update declarations for existing tests--declarations are immutable
foreach (var test in Tests.Except(removedTests))
{
var declaration = tests.First(t =>
t.Declaration.ComponentName == test.Declaration.ComponentName &&
t.Declaration.IdentifierName == test.Declaration.IdentifierName &&
t.Declaration.ProjectId == test.Declaration.ProjectId).Declaration;
test.SetDeclaration(declaration);
}
// add new tests
foreach (var test in tests)
{
if (!Tests.Any(t =>
t.Declaration.ComponentName == test.Declaration.ComponentName &&
t.Declaration.IdentifierName == test.Declaration.IdentifierName &&
t.Declaration.ProjectId == test.Declaration.ProjectId))
{
Tests.Add(test);
}
}
});
OnTestsRefreshed();
}
private void StateChangedHandler(object sender, ParserStateEventArgs e)
{
if (_testRequested && (e.State == ParserState.Ready))
{
_testRequested = false;
_uiDispatcher.InvokeAsync(() =>
{
RunInternal(_tests);
});
}
if (_testRequested && !e.IsError)
{
_testRequested = false;
}
}
private void OnStateChanged(object sender, ParserStateEventArgs e)
{
if (e.State != ParserState.Ready && e.State != ParserState.Error && e.State != ParserState.ResolverError && e.State != ParserState.UnexpectedError)
{
IsBusy = true;
}
if (e.State == ParserState.Ready)
{
UpdateData();
IsBusy = false;
}
if (e.State == ParserState.Error || e.State == ParserState.ResolverError || e.State == ParserState.UnexpectedError)
{
IsBusy = false;
}
}
private void OnStateChanged(object sender, ParserStateEventArgs e)
{
if (e.State != ParserState.Ready && e.State != ParserState.Error && e.State != ParserState.ResolverError && e.State != ParserState.UnexpectedError)
{
IsBusy = true;
}
if (e.State == ParserState.Ready)
{
ModuleMetrics = new ObservableCollection <ModuleMetricsResult>(_analyst.ModuleMetrics(_state));
IsBusy = false;
}
if (e.State == ParserState.Error || e.State == ParserState.ResolverError || e.State == ParserState.UnexpectedError)
{
IsBusy = false;
}
}
DoesNotActivateAnythingOnNextParseAfterOnRecoverActiveCodePaneOnNextParse_ActiveSelectionDoesNotExist()
{
var selectionServiceMock = TestSelectionServiceMock();
selectionServiceMock.Setup(m => m.ActiveSelection()).Returns((QualifiedSelection?)null);
var parseManagerMock = new Mock <IParseManager>();
var selectionRecoverer = new SelectionRecoverer(selectionServiceMock.Object, parseManagerMock.Object);
selectionRecoverer.SaveActiveCodePane();
selectionRecoverer.RecoverActiveCodePaneOnNextParse();
var stateEventArgs = new ParserStateEventArgs(_stateExpectedToTriggerTheRecovery, ParserState.Pending,
CancellationToken.None);
parseManagerMock.Raise(m => m.StateChanged += null, stateEventArgs);
selectionServiceMock.Verify(m => m.TryActivate(It.IsAny <QualifiedModuleName>()), Times.Never);
}
ActivatesSavedActiveCodePaneOnNextParseAfterOnRecoverActiveCodePaneOnNextParse_ActiveSelectionExists()
{
var selectionServiceMock = TestSelectionServiceMock();
var activeSelection = _testModuleSelections[1];
selectionServiceMock.Setup(m => m.ActiveSelection()).Returns(activeSelection);
var parseManagerMock = new Mock <IParseManager>();
var selectionRecoverer = new SelectionRecoverer(selectionServiceMock.Object, parseManagerMock.Object);
selectionRecoverer.SaveActiveCodePane();
selectionRecoverer.RecoverActiveCodePaneOnNextParse();
var stateEventArgs = new ParserStateEventArgs(_stateExpectedToTriggerTheRecovery, ParserState.Pending,
CancellationToken.None);
parseManagerMock.Raise(m => m.StateChanged += null, stateEventArgs);
selectionServiceMock.Verify(m => m.TryActivate(activeSelection.QualifiedName), Times.Once);
}
private void StateChanged(object sender, ParserStateEventArgs e)
{
if (e.State != ParserState.Ready)
{
return;
}
var stopwatch = new Stopwatch();
_model.ClearLastRun();
_model.IsBusy = true;
stopwatch.Start();
_engine.Run(_model.Tests);
stopwatch.Stop();
_model.IsBusy = false;
_state.StateChanged -= StateChanged;
OnRunCompleted(new TestRunEventArgs(stopwatch.ElapsedMilliseconds));
}
private void StateChangedHandler(object sender, ParserStateEventArgs e)
{
if (e.OldState == ParserState.Started)
{
_uiDispatcher.InvokeAsync(() => TestsRefreshStarted?.Invoke(this, EventArgs.Empty));
return;
}
if (!CanRun || e.IsError)
{
_listening = true;
}
// CanRun returned true already, only refresh tests if we're not backed off
else if (_listening && e.OldState != ParserState.Busy)
{
_listening = false;
var updates = TestDiscovery.GetAllTests(_state).ToList();
var run = new List <TestMethod>();
var known = new Dictionary <TestMethod, TestOutcome>();
foreach (var test in updates)
{
var match = _lastRun.FirstOrDefault(ut => ut.Equals(test));
if (match != null)
{
run.Add(match);
}
if (_knownOutcomes.ContainsKey(test))
{
known.Add(test, _knownOutcomes[test]);
}
}
_tests = updates;
_lastRun = run;
_knownOutcomes = known;
_uiDispatcher.InvokeAsync(() => TestsRefreshed?.Invoke(this, EventArgs.Empty));
}
}
public void SetReplacementSelectionOnNextParseAfterRecoverSelectionsOnNextParse_SelectionNotSavedPreviously_ModuleOpen()
{
var selectionServiceMock = TestSelectionServiceMock();
var parseManagerMock = new Mock <IParseManager>();
var selectionRecoverer = new SelectionRecoverer(selectionServiceMock.Object, parseManagerMock.Object);
var selectionReplacement = new Selection(22, 2, 44, 5);
selectionRecoverer.SaveSelections(_testModuleSelections.Select(qualifiedSelection => qualifiedSelection.QualifiedName).Take(2));
selectionRecoverer.ReplaceSavedSelection(_testModuleSelections[2].QualifiedName, selectionReplacement);
selectionRecoverer.RecoverSavedSelectionsOnNextParse();
var stateEventArgs = new ParserStateEventArgs(_stateExpectedToTriggerTheRecovery, ParserState.Pending,
CancellationToken.None);
parseManagerMock.Raise(m => m.StateChanged += null, stateEventArgs);
selectionServiceMock.Verify(m => m.TrySetSelection(_testModuleSelections[0].QualifiedName, _testModuleSelections[0].Selection), Times.Once);
selectionServiceMock.Verify(m => m.TrySetSelection(_testModuleSelections[1].QualifiedName, _testModuleSelections[1].Selection), Times.Once);
selectionServiceMock.Verify(m => m.TrySetSelection(_testModuleSelections[2].QualifiedName, selectionReplacement), Times.Once);
selectionServiceMock.Verify(m => m.TrySetSelection(_testModuleSelections[3].QualifiedName, It.IsAny <Selection>()), Times.Never);
}
private void _state_StateChanged(object sender, ParserStateEventArgs e)
{
if (e.State != ParserState.Ready)
{
return;
}
QualifiedSelection?oldSelection = null;
var pane = _vbe.ActiveCodePane;
var module = pane.CodeModule;
{
if (!module.IsWrappingNullReference)
{
oldSelection = module.GetQualifiedSelection();
}
var newTarget = _state.AllUserDeclarations.FirstOrDefault(
item => item.ComponentName == _target.ComponentName &&
item.IdentifierName == _target.IdentifierName &&
item.ParentScope == _target.ParentScope &&
item.ProjectId == _target.ProjectId &&
Equals(item.Selection, _target.Selection));
if (newTarget != null)
{
UpdateCallsToOtherModule(newTarget.References.ToList());
RemoveField(newTarget);
}
if (oldSelection.HasValue)
{
pane.Selection = oldSelection.Value.Selection;
}
_state.StateChanged -= _state_StateChanged;
_state.OnParseRequested(this);
}
}
public void ReplacementSelectionOverwritesAdjustmentOnParseAfterRecoverSelectionsOnNextParse()
{
var selectionServiceMock = TestSelectionServiceMock();
var parseManagerMock = new Mock <IParseManager>();
var selectionRecoverer = new SelectionRecoverer(selectionServiceMock.Object, parseManagerMock.Object);
var selectionOffset = new Selection(0, 2, 4, 5);
var selectionReplacement = new Selection(22, 2, 44, 5);
selectionRecoverer.SaveSelections(_testModuleSelections
.Select(qualifiedSelection => qualifiedSelection.QualifiedName).Take(1));
selectionRecoverer.AdjustSavedSelection(_testModuleSelections[0].QualifiedName, selectionOffset);
selectionRecoverer.ReplaceSavedSelection(_testModuleSelections[0].QualifiedName, selectionReplacement);
selectionRecoverer.RecoverSavedSelectionsOnNextParse();
var stateEventArgs = new ParserStateEventArgs(_stateExpectedToTriggerTheRecovery, ParserState.Pending,
CancellationToken.None);
parseManagerMock.Raise(m => m.StateChanged += null, stateEventArgs);
selectionServiceMock.Verify(
m => m.TrySetSelection(_testModuleSelections[0].QualifiedName, selectionReplacement), Times.Once);
}
private void _state_StateChanged(object sender, ParserStateEventArgs e)
{
if (e.State != ParserState.Ready)
{
return;
}
var newTarget = _state.AllUserDeclarations.FirstOrDefault(
item => item.ComponentName == _target.ComponentName &&
item.IdentifierName == _target.IdentifierName &&
item.ParentScope == _target.ParentScope &&
item.Project == _target.Project &&
Equals(item.Selection, _target.Selection));
if (newTarget != null)
{
UpdateCallsToOtherModule(newTarget.References);
RemoveField(newTarget);
}
_state.StateChanged -= _state_StateChanged;
_state.OnParseRequested(this);
}
public void OnNextParseAfterSetupOpenModulesWithSavedOpenStateBeforeSettingSelection()
{
var lastCalledMethod = string.Empty;
var selectionServiceMock = TestSelectionServiceMock();
selectionServiceMock.Setup(m => m.TryActivate(It.IsAny <QualifiedModuleName>()))
.Callback((QualifiedModuleName module) => lastCalledMethod = "TryActivate");
selectionServiceMock.Setup(m => m.TrySetSelection(It.IsAny <QualifiedModuleName>(), It.IsAny <Selection>()))
.Callback((QualifiedModuleName module, Selection selection) => lastCalledMethod = "TrySetSelection");
var openModules = _testModuleSelections.Take(3)
.Select(qualifiedSelection => qualifiedSelection.QualifiedName)
.ToHashSet();
selectionServiceMock.Setup(m => m.OpenModules()).Returns(openModules);
var parseManagerMock = new Mock <IParseManager>();
var selectionRecoverer = new SelectionRecoverer(selectionServiceMock.Object, parseManagerMock.Object);
var modulesForWhichToSaveOpenState = _testModuleSelections.Skip(1)
.Select(qualifiedSelection => qualifiedSelection.QualifiedName)
.ToHashSet();
var selectionRecoveryModules = _testModuleSelections
.Select(qualifiedSelection => qualifiedSelection.QualifiedName).Take(2);
selectionRecoverer.SaveSelections(selectionRecoveryModules);
selectionRecoverer.RecoverSavedSelectionsOnNextParse();
selectionRecoverer.SaveOpenState(modulesForWhichToSaveOpenState);
selectionRecoverer.RecoverOpenStateOnNextParse();
var stateEventArgs = new ParserStateEventArgs(_stateExpectedToTriggerTheRecovery, ParserState.Pending,
CancellationToken.None);
parseManagerMock.Raise(m => m.StateChanged += null, stateEventArgs);
Assert.AreEqual("TrySetSelection", lastCalledMethod);
}
public void SetsExactlySavedSelectionsOnParseAfterRecoverSelectionsOnNextParse()
{
var selectionServiceMock = TestSelectionServiceMock();
var parseManagerMock = new Mock <IParseManager>();
var selectionRecoverer = new SelectionRecoverer(selectionServiceMock.Object, parseManagerMock.Object);
selectionRecoverer.SaveSelections(_testModuleSelections
.Select(qualifiedSelection => qualifiedSelection.QualifiedName).Take(2));
selectionRecoverer.RecoverSavedSelectionsOnNextParse();
var stateEventArgs = new ParserStateEventArgs(_stateExpectedToTriggerTheRecovery, ParserState.Pending,
CancellationToken.None);
parseManagerMock.Raise(m => m.StateChanged += null, stateEventArgs);
foreach (var qualifiedSelection in _testModuleSelections.Take(2))
{
selectionServiceMock.Verify(
m => m.TrySetSelection(qualifiedSelection.QualifiedName, qualifiedSelection.Selection), Times.Once);
}
selectionServiceMock.Verify(
m => m.TrySetSelection(_testModuleSelections[2].QualifiedName, It.IsAny <Selection>()), Times.Never);
}
private void ExecuteRecovery(object sender, ParserStateEventArgs e)
{
if (e.State != ParserStateOnWhichToTriggerRecovery)
{
return;
}
_parseManager.StateChanged -= ExecuteRecovery;
if (_openStateRecoveryPrimed)
{
ExecuteOpenStateRecovery();
}
if (_selectionRecoveryPrimed)
{
ExecuteSelectionRecovery();
}
if (_activeCodePaneRecoveryPrimed)
{
ExecuteActiveCodePaneRecovery();
}
}
