private void ExtractMethodTest(string input, Func <Span> extract, TestResult expected, string scopeName = null, string targetName = "g", Version version = null, params string[] parameters)
{
var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version ?? new Version(2, 7));
var serviceProvider = PythonToolsTestUtilities.CreateMockServiceProvider();
using (var analyzer = new VsProjectAnalyzer(serviceProvider, fact, new[] { fact })) {
var buffer = new MockTextBuffer(input, "Python", "C:\\fob.py");
var view = new MockTextView(buffer);
buffer.AddProperty(typeof(VsProjectAnalyzer), analyzer);
var extractInput = new ExtractMethodTestInput(true, scopeName, targetName, parameters ?? new string[0]);
view.Selection.Select(
new SnapshotSpan(view.TextBuffer.CurrentSnapshot, extract()),
false
);
new MethodExtractor(serviceProvider, view).ExtractMethod(extractInput);
if (expected.IsError)
{
Assert.AreEqual(expected.Text, extractInput.FailureReason);
Assert.AreEqual(input, view.TextBuffer.CurrentSnapshot.GetText());
}
else
{
Assert.AreEqual(null, extractInput.FailureReason);
Assert.AreEqual(expected.Text, view.TextBuffer.CurrentSnapshot.GetText());
}
}
}
private void DataTipTest(string input, string selectionRegex, string expectedDataTip)
{
var buffer = new MockTextBuffer(input, @"C:\fob.js", "Node.js");
var view = new MockTextView(buffer);
var classifierProvider = new NodejsClassifierProvider(new MockContentTypeRegistryService(NodejsConstants.Nodejs));
classifierProvider._classificationRegistry = new MockClassificationTypeRegistryService();
classifierProvider.GetClassifier(buffer);
var analyzer = new VsProjectAnalyzer();
buffer.AddProperty(typeof(VsProjectAnalyzer), analyzer);
analyzer.AddBuffer(buffer);
analyzer.WaitForCompleteAnalysis();
var m = Regex.Match(input, selectionRegex);
Assert.IsTrue(m.Success);
var startPos = m.Index;
var startLine = buffer.CurrentSnapshot.GetLineFromPosition(startPos);
var endPos = m.Index + m.Length;
var endLine = buffer.CurrentSnapshot.GetLineFromPosition(endPos);
var selectionSpan = new TextSpan {
iStartLine = startLine.LineNumber,
iStartIndex = startPos - startLine.Start.Position,
iEndLine = endLine.LineNumber,
iEndIndex = endPos - endLine.Start.Position
};
var dataTipSpan = DataTipTextViewFilter.GetDataTipSpan(view, selectionSpan);
if (expectedDataTip == null)
{
Assert.IsNull(dataTipSpan);
return;
}
Assert.IsNotNull(dataTipSpan);
var actualSpan = dataTipSpan.Value;
startPos = input.IndexOf(expectedDataTip);
Assert.AreNotEqual(-1, startPos);
startLine = buffer.CurrentSnapshot.GetLineFromPosition(startPos);
endPos = startPos + expectedDataTip.Length;
endLine = buffer.CurrentSnapshot.GetLineFromPosition(endPos);
var expectedSpan = new TextSpan {
iStartLine = startLine.LineNumber,
iStartIndex = startPos - startLine.Start.Position,
iEndLine = endLine.LineNumber,
iEndIndex = endPos - endLine.Start.Position
};
// TextSpan doesn't override ToString, so test output is unusable in case of failure when comparing
// two spans directly - use an anonymous type instead to produce pretty output.
Assert.AreEqual(
new { expectedSpan.iStartLine, expectedSpan.iStartIndex, expectedSpan.iEndLine, expectedSpan.iEndIndex },
new { actualSpan.iStartLine, actualSpan.iStartIndex, actualSpan.iEndLine, actualSpan.iEndIndex });
}
private static void CodeFormattingTest(string input, object selection, string expected, object expectedSelection, CodeFormattingOptions options, bool selectResult = true)
{
var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(new Version(2, 7));
var services = PythonToolsTestUtilities.CreateMockServiceProvider().GetEditorServices();
using (var analyzer = new VsProjectAnalyzer(services, fact)) {
var buffer = new MockTextBuffer(input, PythonCoreConstants.ContentType, "C:\\fob.py");
buffer.AddProperty(typeof(VsProjectAnalyzer), analyzer);
var view = new MockTextView(buffer);
analyzer.MonitorTextBufferAsync(buffer).Wait();
var selectionSpan = new SnapshotSpan(
buffer.CurrentSnapshot,
ExtractMethodTests.GetSelectionSpan(input, selection)
);
view.Selection.Select(selectionSpan, false);
analyzer.FormatCodeAsync(
selectionSpan,
view,
options,
selectResult
).Wait();
Assert.AreEqual(expected, view.TextBuffer.CurrentSnapshot.GetText());
if (expectedSelection != null)
{
Assert.AreEqual(
ExtractMethodTests.GetSelectionSpan(expected, expectedSelection),
view.Selection.StreamSelectionSpan.SnapshotSpan.Span
);
}
}
}
private static async Task <IEnumerable <TrackingTagSpan <ErrorTag> > > AnalyzeTextBufferAsync(
MockTextBuffer buffer,
PythonLanguageVersion version = PythonLanguageVersion.V27
)
{
var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
try {
var serviceProvider = PythonToolsTestUtilities.CreateMockServiceProvider();
var errorProvider = serviceProvider.ComponentModel.GetService <IErrorProviderFactory>();
Assert.IsNotNull(errorProvider, "Error provider factory is not available");
var analyzer = new VsProjectAnalyzer(serviceProvider, fact, new[] { fact });
buffer.AddProperty(typeof(VsProjectAnalyzer), analyzer);
var classifierProvider = new PythonClassifierProvider(new MockContentTypeRegistryService(PythonCoreConstants.ContentType), serviceProvider);
classifierProvider._classificationRegistry = new MockClassificationTypeRegistryService();
classifierProvider.GetClassifier(buffer);
var squiggles = errorProvider.GetErrorTagger(buffer);
var textView = new MockTextView(buffer);
var monitoredBuffer = analyzer.MonitorTextBuffer(textView, buffer);
var tcs = new TaskCompletionSource <object>();
buffer.GetPythonProjectEntry().OnNewAnalysis += (s, e) => tcs.SetResult(null);
await tcs.Task;
var snapshot = buffer.CurrentSnapshot;
// Ensure all tasks have been updated
var taskProvider = (ErrorTaskProvider)serviceProvider.GetService(typeof(ErrorTaskProvider));
var time = await taskProvider.FlushAsync();
Console.WriteLine("TaskProvider.FlushAsync took {0}ms", time.TotalMilliseconds);
var spans = squiggles.GetTaggedSpans(new SnapshotSpan(snapshot, 0, snapshot.Length));
analyzer.StopMonitoringTextBuffer(monitoredBuffer.BufferParser, textView);
return(spans);
} finally {
}
}
private static async Task CodeFormattingTest(string input, object selection, string expected, object expectedSelection, CodeFormattingOptions options, bool selectResult = true)
{
var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(new Version(2, 7));
var services = PythonToolsTestUtilities.CreateMockServiceProvider().GetEditorServices();
using (var analyzer = await VsProjectAnalyzer.CreateForTestsAsync(services, fact)) {
var buffer = new MockTextBuffer(input, PythonCoreConstants.ContentType, Path.Combine(TestData.GetTempPath(), "fob.py"));
buffer.AddProperty(typeof(VsProjectAnalyzer), analyzer);
var view = new MockTextView(buffer);
var bi = services.GetBufferInfo(buffer);
var entry = await analyzer.AnalyzeFileAsync(bi.Filename);
Assert.AreEqual(entry, bi.TrySetAnalysisEntry(entry, null), "Failed to set analysis entry");
entry.GetOrCreateBufferParser(services).AddBuffer(buffer);
var selectionSpan = new SnapshotSpan(
buffer.CurrentSnapshot,
ExtractMethodTests.GetSelectionSpan(input, selection)
);
view.Selection.Select(selectionSpan, false);
await analyzer.FormatCodeAsync(
selectionSpan,
view,
options,
selectResult
);
Assert.AreEqual(expected, view.TextBuffer.CurrentSnapshot.GetText());
if (expectedSelection != null)
{
Assert.AreEqual(
ExtractMethodTests.GetSelectionSpan(expected, expectedSelection),
view.Selection.StreamSelectionSpan.SnapshotSpan.Span
);
}
}
}
public ClassifierHelper(MockTextBuffer buffer, PythonLanguageVersion version)
{
var serviceProvider = PythonToolsTestUtilities.CreateMockServiceProvider();
_contentRegistry = new MockContentTypeRegistryService(PythonCoreConstants.ContentType);
_classificationRegistry = new MockClassificationTypeRegistryService();
_provider1 = new PythonClassifierProvider(_contentRegistry, serviceProvider)
{
_classificationRegistry = _classificationRegistry
};
_provider2 = new PythonAnalysisClassifierProvider(_contentRegistry, serviceProvider)
{
_classificationRegistry = _classificationRegistry
};
_buffer = buffer;
_factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
var analyzer = new VsProjectAnalyzer(serviceProvider, _factory, new[] { _factory });
_buffer.AddProperty(typeof(VsProjectAnalyzer), analyzer);
_view = new MockTextView(_buffer);
}
private static ISmartTagSession GetSmartTagSession(
MockTextBuffer buffer,
int index,
PythonLanguageVersion version = PythonLanguageVersion.V27,
bool assertIfNoSession = true
)
{
if (index < 0)
{
index += buffer.CurrentSnapshot.Length;
}
var fact = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
var sp = PythonToolsTestUtilities.CreateMockServiceProvider();
var analyzer = new VsProjectAnalyzer(sp, fact, new[] { fact });
buffer.AddProperty(typeof(VsProjectAnalyzer), analyzer);
var classifierProvider = new PythonClassifierProvider(
new MockContentTypeRegistryService(PythonCoreConstants.ContentType),
sp
);
classifierProvider._classificationRegistry = new MockClassificationTypeRegistryService();
classifierProvider.GetClassifier(buffer);
var view = new MockTextView(buffer);
var monitoredBuffer = analyzer.MonitorTextBuffer(view, buffer);
analyzer.WaitForCompleteAnalysis(x => true);
while (((IPythonProjectEntry)buffer.GetProjectEntry()).Analysis == null)
{
System.Threading.Thread.Sleep(500);
}
analyzer.StopMonitoringTextBuffer(monitoredBuffer.BufferParser, view);
view.TextViewModel = new MockTextViewModel {
DataBuffer = buffer, EditBuffer = buffer
};
var snapshot = buffer.CurrentSnapshot;
var broker = new MockSmartTagBroker();
broker.SourceProviders.Add(new SmartTagSourceProvider(sp));
var cont = new SmartTagController(broker, view);
view.Caret.MoveTo(new SnapshotPoint(snapshot, index));
cont.ShowSmartTag();
var session = broker.GetSessions(view).FirstOrDefault();
Assert.IsNull(session, "Session should not be active");
var task = Volatile.Read(ref cont._curTask);
if (assertIfNoSession)
{
Assert.IsNotNull(task, "Session should have task running");
}
else if (task == null)
{
// No session and no task means we won't ever get a session here
return(null);
}
// Simulate repeatedly starting a session like the idle loop would
for (int retries = 1000; session == null && retries > 0; --retries)
{
Thread.Sleep(10);
cont.ShowSmartTag();
session = broker.GetSessions(view).FirstOrDefault();
}
if (assertIfNoSession)
{
Assert.IsNotNull(session, "No session is active");
Assert.IsFalse(session.IsDismissed, "Session should not be dismissed");
}
if (session != null)
{
Console.WriteLine("Found session with following tags:");
foreach (var t in session.ActionSets.SelectMany(s => s.Actions).Select(s => s.DisplayText))
{
Console.WriteLine(" {0}", t);
}
}
return(session);
}
