public void WaitForAnalysis(CancellationToken?cancel = null)
{
if (_analyzer.Queue.Count == 0)
{
return;
}
_analyzer.AnalyzeQueuedEntries(cancel ?? CancellationTokens.After5s);
}
public void WaitForAnalysis(CancellationToken?cancel = null)
{
if (_analyzer.Queue.Count == 0)
{
return;
}
_analyzer.AnalyzeQueuedEntries(cancel ?? CancellationTokens.After5s);
AssertListener.ThrowUnhandled();
}
public IEnumerable <TestCase> GetTestCases()
{
foreach (var entry in _entries)
{
entry.Analyze(CancellationToken.None, true);
}
_analyzer.AnalyzeQueuedEntries(CancellationToken.None);
foreach (var entry in _entries)
{
foreach (var classValue in GetTestCaseClasses(entry))
{
// Check the name of all functions on the class using the
// analyzer. This will return functions defined on this
// class and base classes
foreach (var member in GetTestCaseMembers(entry, classValue))
{
// Find the definition to get the real location of the
// member. Otherwise decorators will confuse us.
var definition = entry.Analysis
.GetVariablesByIndex(classValue.Name + "." + member.Key, 0)
.FirstOrDefault(v => v.Type == VariableType.Definition);
var location = (definition != null) ?
definition.Location :
member.Value.SelectMany(m => m.Locations).FirstOrDefault(loc => loc != null);
yield return(CreateTestCase(
classValue.DeclaringModule.FilePath,
classValue.Name,
member.Key,
location
));
}
}
}
}
private static void RunCommand(
string cmd,
string args,
PythonAnalyzer analyzer,
Dictionary <string, IPythonProjectEntry> modules,
State state
)
{
switch (cmd.ToLower())
{
case "print":
Console.WriteLine(args);
break;
case "module":
foreach (var mod in GetModules(args))
{
IPythonProjectEntry entry;
if (!modules.TryGetValue(mod.ModuleName, out entry))
{
Console.WriteLine("Creating module {0}", mod.ModuleName);
modules[mod.ModuleName] = entry = analyzer.AddModule(mod.ModuleName, mod.SourceFile);
}
else
{
Console.WriteLine("Reusing module {0}", mod.ModuleName);
}
using (var file = File.OpenText(mod.SourceFile)) {
var parser = Parser.CreateParser(
file,
analyzer.LanguageVersion,
new ParserOptions()
{
BindReferences = true
}
);
entry.UpdateTree(parser.ParseFile(), null);
}
}
break;
case "enqueue":
if (args == "*")
{
foreach (var entry in modules.Values)
{
entry.Analyze(CancellationToken.None, true);
}
}
else
{
IPythonProjectEntry entry;
foreach (var modName in args.Split(',').Select(s => s.Trim()).Where(s => !string.IsNullOrEmpty(s)))
{
if (!modules.TryGetValue(modName, out entry))
{
Console.WriteLine("Could not enqueue {0}", modName);
}
else
{
entry.Analyze(CancellationToken.None, true);
}
}
}
break;
case "analyze":
Console.Write("Waiting for complete analysis... ");
analyzer.AnalyzeQueuedEntries(CancellationToken.None);
Console.WriteLine("done!");
break;
case "pause":
Console.Write("Press enter to continue...");
Console.ReadKey(true);
Console.WriteLine();
break;
case "debugbreak":
if (!args.Equals("ifattached", StringComparison.CurrentCultureIgnoreCase) || Debugger.IsAttached)
{
Console.WriteLine("Breaking into the debugger");
Debugger.Break();
}
break;
case "gc":
Console.WriteLine("Collecting garbage");
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
GC.WaitForFullGCComplete();
GC.WaitForPendingFinalizers();
break;
case "dump": {
var fullPath = Path.GetFullPath(args);
var length = WriteDump(Process.GetCurrentProcess(), fullPath, MiniDumpType.FullDump);
Console.WriteLine(
"Dump written to {0} at {1:F1}MB ({2} bytes)",
fullPath,
length / (1024.0 * 1024.0),
length
);
if (state.LastDumpSize > 0 && state.LastDumpSize != length)
{
var delta = Math.Abs(length - state.LastDumpSize);
var direction = (length > state.LastDumpSize) ? "larger" : "smaller";
Console.WriteLine(
"Dump is {0:F1}MB ({1} bytes) {2} than previous",
delta / (1024.0 * 1024.0),
delta,
direction
);
}
state.LastDumpSize = length;
break;
}
default:
Console.WriteLine("Command not available: {0}", cmd);
break;
}
}
private IEnumerable <Task> StartCrossThreadAnalysisCalls(PythonAnalyzer state, CancellationToken cancel)
{
const string testCode = @"from mod{0:000} import test_func as other_test_func, MyClass as other_mc
c = None
def test_func(a, b={1}()):
'''My test function'''
globals c
a = b
a = {1}(a)
b = other_test_func(a)
c = other_mc.fn(b)
return b
class MyClass:
fn = test_func
my_test_func = test_func
my_test_func = other_test_func
my_test_func('abc')
mc = MyClass()
mc.fn([])
";
state.SetSearchPaths(new [] { TestData.GetTestSpecificRootUri().ToAbsolutePath() });
var entries = Enumerable.Range(0, 100)
.Select(i => {
var entry = (ProjectEntry)state.AddModule(string.Format("mod{0:000}", i), TestData.GetTestSpecificPath(string.Format("mod{0:000}.py", i)));
var parser = Parser.CreateParser(new StringReader(testCode.FormatInvariant(i + 1, PythonTypes[i % PythonTypes.Count])), PythonLanguageVersion.V34);
using (var p = entry.BeginParse()) {
p.Tree = parser.ParseFile();
p.Complete();
}
return(entry);
})
.ToList();
// One analysis before we start
foreach (var e in entries)
{
e.Analyze(cancel, true);
}
state.AnalyzeQueuedEntries(cancel);
// Repeatedly re-analyse the code
yield return(Task.Run(() => {
var rnd = new Random();
while (!cancel.IsCancellationRequested)
{
var shufEntries = entries
.Select(e => Tuple.Create(rnd.Next(), e))
.OrderBy(t => t.Item1)
.Take(entries.Count / 2)
.Select(t => t.Item2)
.ToList();
foreach (var e in shufEntries)
{
e.Analyze(cancel, true);
}
state.AnalyzeQueuedEntries(cancel);
Console.WriteLine("Analysis complete");
Thread.Sleep(1000);
}
}, cancel));
// Repeatedly re-parse the code
yield return(Task.Run(() => {
var rnd = new Random();
while (!cancel.IsCancellationRequested)
{
var shufEntries = entries
.Select((e, i) => Tuple.Create(rnd.Next(), e, i))
.OrderBy(t => t.Item1)
.Take(entries.Count / 4)
.ToList();
foreach (var t in shufEntries)
{
var i = t.Item3;
var parser = Parser.CreateParser(new StringReader(testCode.FormatInvariant(i + 1, PythonTypes[i % PythonTypes.Count])), PythonLanguageVersion.V34);
using (var p = t.Item2.BeginParse()) {
p.Tree = parser.ParseFile();
p.Complete();
}
}
Thread.Sleep(1000);
}
}, cancel));
// Repeatedly request signatures
yield return(Task.Run(() => {
var entry = entries[1];
while (!cancel.IsCancellationRequested)
{
var sigs = entry.Analysis.GetSignaturesByIndex("my_test_func", 0).ToList();
if (sigs.Any())
{
foreach (var s in sigs)
{
s.Name.Should().Be("test_func");
s.Parameters.Select(p => p.Name).Should().BeEquivalentTo("a", "b");
}
}
}
}, cancel));
// Repeated request variables and descriptions
yield return(Task.Run(() => {
var entry = entries[1];
while (!cancel.IsCancellationRequested)
{
var descriptions = entry.Analysis.GetDescriptionsByIndex("my_test_func", 0).ToList();
descriptions = entry.Analysis.GetDescriptionsByIndex("c", 0).ToList();
}
}, cancel));
// Repeated request members and documentation
yield return(Task.Run(() => {
var entry = entries[1];
while (!cancel.IsCancellationRequested)
{
var descriptions = entry.Analysis.GetCompletionDocumentationByIndex("mc", "fn", 0).ToList();
}
}, cancel));
}
