コード例 #1
0
        private static void TestQuickInfo(MockVs vs, string code, int start, int end, params string[] expected)
        {
            using (var view = new PythonEditor(code, vs: vs)) {
                var snapshot = view.CurrentSnapshot;

                for (int i = start; i < end; i++)
                {
                    var analysis = snapshot.AnalyzeExpression(
                        vs.ServiceProvider,
                        snapshot.CreateTrackingSpan(i, i == snapshot.Length ? 0 : 1, SpanTrackingMode.EdgeInclusive),
                        false
                        );

                    List <object> quickInfo = new List <object>();
                    ITrackingSpan span;
                    QuickInfoSource.AugmentQuickInfoWorker(
                        analysis,
                        quickInfo,
                        out span
                        );

                    Assert.AreEqual(expected.Length, quickInfo.Count);
                    for (int j = 0; j < expected.Length; j++)
                    {
                        Assert.AreEqual(expected[j], quickInfo[j]);
                    }
                }
            }
        }
コード例 #2
0
        public void DisableAutoCompletions()
        {
            using (var vs = new MockVs()) {
                var options = vs.GetPyService().AdvancedOptions;
                var oldALM  = options.AutoListMembers;
                var oldALI  = options.AutoListIdentifiers;
                options.AutoListMembers     = false;
                options.AutoListIdentifiers = false;
                vs.OnDispose(() => {
                    options.AutoListMembers     = oldALM;
                    options.AutoListIdentifiers = oldALI;
                });

                var view = CreateViewAndAnalyze(vs);

                foreach (var t in new[] { "a", "a.", "import " })
                {
                    Console.WriteLine("Typed " + t);
                    view.Type(t);

                    view.AssertNoIntellisenseSession();

                    view.Clear();
                }
            }
        }
コード例 #3
0
ファイル: CompletionTests.cs プロジェクト: sunsure/PTVS
 public void FromOSPathImportCompletions3x()
 {
     using (var vs = new MockVs()) {
         var factory = vs.Invoke(() => vs.GetPyService().InterpreterRegistryService.Interpreters.LastOrDefault(p => p.Configuration.Version.Major == 3));
         OSPathImportTest(vs, factory);
     }
 }
コード例 #4
0
        public static PythonToolsService GetPyService(this MockVs session)
        {
            var service = session.ServiceProvider.GetPythonToolsService();

            Assert.IsNotNull(service, "PythonToolsService is unavailable");
            return(service);
        }
コード例 #5
0
ファイル: CompletionTests.cs プロジェクト: xNUTs/PTVS
        private static void OSPathImportTest(MockVs vs, MockCompletionDB db)
        {
            var code = "from ";

            AssertUtil.ContainsAtLeast(GetCompletions(vs, -1, code, db.Factory), "os", "sys");

            code = "from o";
            var completions = GetCompletions(vs, -1, code, db.Factory);

            AssertUtil.ContainsAtLeast(completions, "os");
            AssertUtil.DoesntContain(completions, "sys");

            code = "from os ";
            AssertUtil.ContainsExactly(GetCompletions(vs, -1, code, db.Factory), "import");

            code = "from os import";
            AssertUtil.ContainsExactly(GetCompletions(vs, -1, code, db.Factory), "import");

            code = "from os import ";
            AssertUtil.ContainsAtLeast(GetCompletions(vs, -1, code, db.Factory), "path");

            code = "from os.";
            AssertUtil.ContainsExactly(GetCompletions(vs, -1, code, db.Factory), "path");

            code = "from os.path import ";
            AssertUtil.ContainsAtLeast(GetCompletions(vs, -1, code, db.Factory), "abspath", "relpath");

            var allNames = new HashSet <string>();

            allNames.UnionWith(GetCompletions(vs, -1, "from ntpath import ", db.Factory));
            allNames.UnionWith(GetCompletions(vs, -1, "from posixpath import ", db.Factory));

            code = "from os.path import ";
            AssertUtil.ContainsAtLeast(GetCompletions(vs, -1, code, db.Factory), allNames);
        }
コード例 #6
0
ファイル: CompletionTests.cs プロジェクト: xNUTs/PTVS
 public void FromOSPathImportCompletions3x()
 {
     using (var vs = new MockVs())
         using (var db = MockCompletionDB.Create(PythonLanguageVersion.V33, "os", "ntpath", "posixpath", "os2emxpath")) {
             OSPathImportTest(vs, db);
         }
 }
コード例 #7
0
ファイル: CompletionTests.cs プロジェクト: xNUTs/PTVS
        public void GotoDefinition()
        {
            using (var vs = new MockVs()) {
                string code = @"
class C:
    def fff(self): pass

C().fff";

                //var emptyAnalysis = AnalyzeExpression(0, code);
                //AreEqual(emptyAnalysis.Expression, "");

                for (int i = -1; i >= -3; i--)
                {
                    var analysis = AnalyzeExpression(vs, i, code);
                    Assert.AreEqual("C().fff", analysis.Expression);
                }

                var classAnalysis = AnalyzeExpression(vs, -6, code);
                Assert.AreEqual("C()", classAnalysis.Expression);

                var defAnalysis = AnalyzeExpression(vs, code.IndexOf("def fff") + 4, code);
                Assert.AreEqual("fff", defAnalysis.Expression);
            }
        }
コード例 #8
0
ファイル: CompletionTests.cs プロジェクト: xNUTs/PTVS
        public void OverridesWithMismatchedAnalysis()
        {
            // Here we create a buffer and analyze. We then add some newlines
            // and a def, expecting completions from A (int). Because the def
            // has moved down into class B, GetCompletions() rolls it back
            // to find out where in the analysis to look - without this, we
            // would get completions for dict rather than int.
            var code = @"
class A(int):
    pass

class B(dict):
    pass

";

            using (var vs = new MockVs()) {
                var editText    = "\r\n\r\n\r\n    def ";
                var editInsert  = code.IndexOf("pass") + 4;
                var completions = EditAndGetCompletions(vs, code, editText, editInsert, "def ");

                AssertUtil.ContainsAtLeast(completions, "bit_length", "conjugate");
                AssertUtil.DoesntContain(completions, "keys");

                editText    = "\r\n\r\n\r\n\r\n\r\n    def ";
                editInsert  = code.IndexOf("pass", editInsert) + 4;
                completions = EditAndGetCompletions(vs, code, editText, editInsert, "def ");

                AssertUtil.ContainsAtLeast(completions, "keys", "__contains__");
                AssertUtil.DoesntContain(completions, "bit_length");
            }
        }
コード例 #9
0
        public void TabCommits()
        {
            using (var vs = new MockVs()) {
                var  opts   = vs.GetPyService().AdvancedOptions;
                bool oldECI = opts.EnterCommitsIntellisense;
                bool oldALM = opts.AutoListMembers;
                bool oldALI = opts.AutoListIdentifiers;
                bool oldHAM = opts.HideAdvancedMembers;
                opts.EnterCommitsIntellisense = false;
                opts.AutoListMembers          = true;
                opts.AutoListIdentifiers      = false;
                opts.HideAdvancedMembers      = false;
                vs.OnDispose(() => {
                    opts.EnterCommitsIntellisense = oldECI;
                    opts.AutoListMembers          = oldALM;
                    opts.AutoListIdentifiers      = oldALI;
                    opts.HideAdvancedMembers      = oldHAM;
                });

                var view = CreateViewAndAnalyze(vs);
                view.Type("min.");

                var session = view.TopSession as ICompletionSession;
                Console.WriteLine(string.Join("\n", session.Completions()));
                view.Type("class\t");

                Assert.AreEqual("min.__class__", view.Text);
            }
        }
コード例 #10
0
ファイル: CompletionTests.cs プロジェクト: sunsure/PTVS
        private static IEnumerable <string> EditAndGetCompletions(
            MockVs vs,
            string code,
            string editText,
            int editInsert,
            string completeAfter,
            PythonLanguageVersion version = PythonLanguageVersion.V27
            )
        {
            using (var view = new PythonEditor(code, version, vs)) {
                view.AdvancedOptions.HideAdvancedMembers = false;

                var snapshot = view.CurrentSnapshot;
                using (var evt = view.AnalysisCompleteEvent) {
                    view.View.MoveCaret(new SnapshotPoint(snapshot, editInsert));
                    view.Type(editText);

                    if (!evt.WaitOne(10000))
                    {
                        Assert.Fail("Failed to wait for new analysis");
                    }
                }

                var newSnapshot = view.CurrentSnapshot;
                Assert.AreNotSame(snapshot, newSnapshot);

                return(view.GetCompletionsAfter(completeAfter));
            }
        }
コード例 #11
0
        public void EnterCommitsCompleteNoNewLine()
        {
            using (var vs = new MockVs()) {
                var  opts   = vs.GetPyService().AdvancedOptions;
                bool oldANL = opts.AddNewLineAtEndOfFullyTypedWord;
                bool oldALM = opts.AutoListMembers;
                bool oldALI = opts.AutoListIdentifiers;
                bool oldHAM = opts.HideAdvancedMembers;
                opts.AddNewLineAtEndOfFullyTypedWord = true;
                opts.AutoListMembers     = true;
                opts.AutoListIdentifiers = false;
                opts.HideAdvancedMembers = false;
                vs.OnDispose(() => {
                    opts.AddNewLineAtEndOfFullyTypedWord = oldANL;
                    opts.AutoListMembers     = oldALM;
                    opts.AutoListIdentifiers = oldALI;
                    opts.HideAdvancedMembers = oldHAM;
                });
                var view = CreateViewAndAnalyze(vs);
                view.Type("min.");

                var session = view.TopSession as ICompletionSession;

                view.Type("__class__\r");

                Assert.AreEqual("min.__class__\r\n", view.Text);
            }
        }
コード例 #12
0
        private void AutoListTest(string code, PythonLanguageVersion version, params int[] triggerAtIndex)
        {
            using (var vs = new MockVs()) {
                var interpreterService = vs.GetPyService()._interpreterOptionsService;
                var oldDefault         = interpreterService.DefaultInterpreter;
                interpreterService.DefaultInterpreter = interpreterService.Interpreters
                                                        .First(i => i.Configuration.Version == version.ToVersion());
                vs.OnDispose(() => interpreterService.DefaultInterpreter = oldDefault);

                var options = vs.GetPyService().AdvancedOptions;
                var oldALI  = options.AutoListIdentifiers;
                var oldALM  = options.AutoListMembers;
                options.AutoListIdentifiers = true;
                options.AutoListMembers     = true;
                vs.OnDispose(() => {
                    options.AutoListIdentifiers = oldALI;
                    options.AutoListMembers     = oldALM;
                });

                var view = CreateViewAndAnalyze(vs);

                int    lastStart = 0;
                string text;
                foreach (var _i in triggerAtIndex)
                {
                    bool expectCompletions = _i >= 0;
                    int  expected          = _i > 0 ? _i : -_i;

                    text = code.Substring(lastStart, expected - lastStart);
                    Console.WriteLine("Typing '{0}' [{1}, {2})", text, lastStart, expected);
                    view.Type(text);

                    view.AssertNoIntellisenseSession();
                    lastStart = expected;

                    if (expectCompletions)
                    {
                        text = code.Substring(expected, 1);
                        Console.WriteLine("Typing '{0}' [{1}, {2}) and expect completions", text, expected, expected + 1);
                        view.Type(text);

                        using (var sh = view.WaitForSession <ICompletionSession>()) {
                            sh.Session.Dismiss();
                        }

                        lastStart = expected + 1;
                    }
                }
                text = code.Substring(lastStart);
                if (!string.IsNullOrEmpty(text))
                {
                    Console.WriteLine("Typing '{0}' [{1}, {2})", text, lastStart, code.Length);
                    view.Type(text);

                    view.AssertNoIntellisenseSession();
                }
            }
        }
コード例 #13
0
ファイル: CompletionTests.cs プロジェクト: sunsure/PTVS
 private static void AnalyzeAndValidateExpression(MockVs vs, int start, int charCount, string code, string expectedExpr)
 {
     // We check charCount + 1 positions to ensure that go to definition
     // works when caret is on the left AND right of identifier (and in between)
     for (int i = 0; i <= charCount; i++)
     {
         var defAnalysis = AnalyzeExpression(vs, start + i, code);
         Assert.AreEqual(expectedExpr, defAnalysis?.Expression);
     }
 }
コード例 #14
0
ファイル: CompletionTests.cs プロジェクト: sunsure/PTVS
        public void ExceptionCompletions()
        {
            using (var vs = new MockVs()) {
                foreach (var ver in new[] { PythonLanguageVersion.V36, PythonLanguageVersion.V27 })
                {
                    foreach (string code in new[] {
                        @"import sys
raise |",
                        @"import sys
raise (|",
                        @"import sys
try:
    pass
except |",
                        @"import sys
try:
    pass
except (|",
                        @"import sys
try:
    pass
except (ValueError, |"
                    })
                    {
                        Console.WriteLine($"{ver}:: {code}");

                        var completionList = GetCompletions(vs, code.IndexOf("|"), code.Replace("|", ""), ver);

                        AssertUtil.CheckCollection(completionList,
                                                   new[] { "Exception", "KeyboardInterrupt", "GeneratorExit", "StopIteration", "SystemExit", "sys", "Warning" },
                                                   new[] { "str", "int" }
                                                   );
                    }

                    foreach (string code in new[] {
                        @"import sys
raise (sys.",
                        @"import sys
try:
    pass
except (sys."
                    })
                    {
                        var completionList = GetCompletions(vs, code.IndexOfEnd("sys."), code, ver);

                        AssertUtil.CheckCollection(
                            completionList,
                            new[] { "modules", "path", "version" },
                            new[] { "Exception", "KeyboardInterrupt", "GeneratorExit", "StopIteration", "SystemExit" }
                            );
                    }
                }
            }
        }
コード例 #15
0
        private static void TestSignature(MockVs vs, int location, string sourceCode, string expectedExpression, int paramIndex, PythonLanguageVersion version, bool analyze, out SignatureAnalysis sigs)
        {
            if (location < 0)
            {
                location = sourceCode.Length + location;
            }

            sigs = GetSignatureAnalysis(vs, location, sourceCode, version);
            Assert.AreEqual(expectedExpression, sigs.Text, sourceCode);
            Assert.AreEqual(paramIndex, sigs.ParameterIndex, sourceCode);
        }
コード例 #16
0
        private static SignatureAnalysis GetSignatureAnalysis(MockVs vs, int index, string code, PythonLanguageVersion version = PythonLanguageVersion.V27)
        {
            using (var view = new PythonEditor(code, version, vs)) {
                var snapshot = view.CurrentSnapshot;

                return(snapshot.GetSignatures(
                           vs.ServiceProvider,
                           snapshot.CreateTrackingSpan(index, 1, SpanTrackingMode.EdgeInclusive)
                           ));
            }
        }
コード例 #17
0
        public void SignatureHelpStarArgs()
        {
            SignatureAnalysis sigResult;

            using (var vs = new MockVs()) {
                TestSignature(vs, -1, @"def f(a, *b, c=None): pass
f(1, 2, 3, 4,", "f", 4, PythonLanguageVersion.V27, true, out sigResult);
                Assert.IsTrue(sigResult.Signatures.Count >= 1, "No signature analysis results");
                Assert.AreEqual("*b", sigResult.Signatures[0].CurrentParameter.Name);
            }
        }
コード例 #18
0
        public void QuickInfo()
        {
            string code = @"
x = ""ABCDEFGHIJKLMNOPQRSTUVWYXZ""
cls._parse_block(ast.expr)


f(a,
(b, c, d),
e)


def f():
    """"""helpful information
    
    
""""""

while True:
    pass

lambda larg1, larg2: None";


            using (var vs = new MockVs()) {
                // we get the appropriate subexpression
                TestQuickInfo(vs, code, code.IndexOf("cls."), code.IndexOf("cls.") + 4, "cls: <unknown type>");
                TestQuickInfo(vs, code, code.IndexOf("cls.") + 4 + 1, code.IndexOf("cls.") + 4 + 1 + 11, "cls._parse_block: <unknown type>");
                TestQuickInfo(vs, code, code.IndexOf("cls.") + 4 + 1 + 11 + 1, code.IndexOf("cls.") + 4 + 1 + 11 + 1 + 4, "ast: <unknown type>");
                TestQuickInfo(vs, code, code.IndexOf("cls.") + 4 + 1 + 11 + 1 + 4 + 1, code.IndexOf("cls.") + 4 + 1 + 11 + 1 + 4 + 1 + 3, "ast.expr: <unknown type>");
                TestQuickInfo(vs, code, code.IndexOf("cls.") + 4 + 1 + 11 + 1 + 4 + 1 + 3 + 1, code.IndexOf("cls.") + 4 + 1 + 11 + 1 + 5 + 3 + 1 + 1, "cls._parse_block(ast.expr): <unknown type>");

                // the whole string shows up in quick info
                TestQuickInfo(vs, code, code.IndexOf("x = ") + 4, code.IndexOf("x = ") + 4 + 28, "\"ABCDEFGHIJKLMNOPQRSTUVWYXZ\": str");

                // trailing new lines don't show up in quick info
                TestQuickInfo(vs, code, code.IndexOf("def f") + 4, code.IndexOf("def f") + 5, "f: def f()\r\nhelpful information");

                // keywords don't show up in quick info
                TestQuickInfo(vs, code, code.IndexOf("while True:"), code.IndexOf("while True:") + 5);

                // 'lambda' keyword doesn't show up in quick info
                TestQuickInfo(vs, code, code.IndexOf("lambda"), code.IndexOf("lambda") + 6);
                // but its arguments do
                TestQuickInfo(vs, code, code.IndexOf("larg1"), code.IndexOf("larg1") + 5, "larg1: <unknown type>");
                TestQuickInfo(vs, code, code.IndexOf("larg2"), code.IndexOf("larg2") + 5, "larg2: <unknown type>");

                // multiline function, hover at the close paren
                TestQuickInfo(vs, code, code.IndexOf("e)") + 1, code.IndexOf("e)") + 2, @"f(a,
(b, c, d),
e): <unknown type>");
            }
        }
コード例 #19
0
ファイル: CompletionTests.cs プロジェクト: xNUTs/PTVS
        public void CompletionWithLongDocString()
        {
            using (var vs = new MockVs()) {
                var    docString = GenerateText(100, 72, "    ").ToArray();
                string code      = @"
def func(a):
    '''" + string.Join(Environment.NewLine, docString) + @"'''
    pass

";

                // Because there is an extra line added for the Quick Info we only
                // want the first 29 lines of the docstring. For signature docs,
                // we'll cut to 15 lines.
                var expected1 = string.Join(Environment.NewLine, docString.Take(29)) + Environment.NewLine + "...";
                var expected2 = string.Join(Environment.NewLine, docString.Take(15)).TrimStart() + Environment.NewLine + "...";

                using (var view = new PythonEditor(code)) {
                    TestQuickInfo(view, code.IndexOf("func"), code.IndexOf("func") + 4, "func: def func(a)\r\n" + expected1);

                    SignatureAnalysis sigs;
                    view.Text += "func(";
                    TestSignature(view, -1, "func", 0, out sigs);
                    Assert.AreEqual(1, sigs.Signatures.Count);
                    Assert.AreEqual(1, sigs.Signatures[0].Parameters.Count);
                    Assert.AreEqual(expected2, sigs.Signatures[0].Documentation);
                }

                docString = GenerateText(100, 250, "    ").ToArray();
                code      = @"
def func(a):
    '''" + string.Join(Environment.NewLine, docString) + @"'''
    pass

";

                using (var view = new PythonEditor(code)) {
                    // The long lines cause us to truncate sooner.
                    expected1 = string.Join(Environment.NewLine, docString.Take(15)) + Environment.NewLine + "...";
                    expected2 = string.Join(Environment.NewLine, docString.Take(8)).TrimStart() + Environment.NewLine + "...";

                    TestQuickInfo(view, code.IndexOf("func"), code.IndexOf("func") + 4, "func: def func(a)\r\n" + expected1);

                    SignatureAnalysis sigs;
                    view.Text += "func(";
                    TestSignature(view, -1, "func", 0, out sigs);
                    Assert.AreEqual(1, sigs.Signatures.Count);
                    Assert.AreEqual(1, sigs.Signatures[0].Parameters.Count);
                    Assert.AreEqual(expected2, sigs.Signatures[0].Documentation);
                }
            }
        }
コード例 #20
0
        public static IVisualStudioInstance ToMockVs(this SolutionFile self)
        {
            MockVs vs = new MockVs();

            vs.Invoke(() =>
            {
                // HACK: The default targets files require a function that we don't provide
                // The tests are mostly still broken, but they get further now. We should probably
                // move them into UI tests, as we can't emulate the MSBuild environment well enough
                // to open projects from here.
                Microsoft.Build.Evaluation.ProjectCollection.GlobalProjectCollection.SetGlobalProperty("NugetRestoreTargets", "false");
                ErrorHandler.ThrowOnFailure(vs.Solution.OpenSolutionFile(0, self.Filename));
            });
            return(vs);
        }
コード例 #21
0
ファイル: CompletionTests.cs プロジェクト: sunsure/PTVS
        private static ExpressionAnalysis AnalyzeExpression(MockVs vs, int location, string code, PythonLanguageVersion version = PythonLanguageVersion.V27)
        {
            if (location < 0)
            {
                location += code.Length + 1;
            }

            using (var view = new PythonEditor(code, version, vs)) {
                var snapshot = view.CurrentSnapshot;
                return(vs.InvokeTask(() => view.Analyzer.AnalyzeExpressionAsync(
                                         (AnalysisEntry)view.GetAnalysisEntry(),
                                         new SnapshotPoint(snapshot, location)
                                         )));
            }
        }
コード例 #22
0
        public void EnterDismisses()
        {
            var vs = new MockVs();

            vs.GetPyService().AdvancedOptions.EnterCommitsIntellisense = false;
            vs.GetPyService().AdvancedOptions.AutoListMembers = true;
            var view = CreateViewAndAnalyze(vs);

            view.Type("min.");

            var session = view.TopSession as ICompletionSession;

            view.Type("class\r");

            Assert.AreEqual("min.class\r\n", view.Text);
        }
コード例 #23
0
ファイル: CompletionTests.cs プロジェクト: xNUTs/PTVS
        private static ExpressionAnalysis AnalyzeExpression(MockVs vs, int location, string code, PythonLanguageVersion version = PythonLanguageVersion.V27)
        {
            if (location < 0)
            {
                location += code.Length + 1;
            }

            using (var view = new PythonEditor(code, version, vs)) {
                var snapshot = view.CurrentSnapshot;
                return(snapshot.AnalyzeExpression(
                           vs.ServiceProvider,
                           snapshot.CreateTrackingSpan(location, location < snapshot.Length ? 1 : 0, SpanTrackingMode.EdgeInclusive),
                           false
                           ));
            }
        }
コード例 #24
0
ファイル: CompletionTests.cs プロジェクト: xNUTs/PTVS
        public void CtrlSpaceAfterKeyword()
        {
            // http://pytools.codeplex.com/workitem/560
            string code = @"
def h():
    return 

print 

";

            using (var vs = new MockVs()) {
                AssertUtil.ContainsAtLeast(GetCompletions(vs, code.IndexOfEnd("return "), code), "any");
                AssertUtil.ContainsAtLeast(GetCompletions(vs, code.IndexOfEnd("print "), code), "any");
            }
        }
コード例 #25
0
ファイル: CompletionTests.cs プロジェクト: xNUTs/PTVS
        public void CtrlSpaceAfterNumber()
        {
            // http://pytools.codeplex.com/workitem/2323
            string code = @"
2
2.
2..
2.0.
";

            using (var vs = new MockVs()) {
                AssertUtil.ContainsExactly(GetCompletions(vs, code.IndexOfEnd("2"), code));
                AssertUtil.ContainsExactly(GetCompletions(vs, code.IndexOfEnd("2."), code));
                AssertUtil.ContainsAtLeast(GetCompletions(vs, code.IndexOfEnd("2.."), code), "real", "imag");
                AssertUtil.ContainsAtLeast(GetCompletions(vs, code.IndexOfEnd("2.0."), code), "real", "imag");
            }
        }
コード例 #26
0
ファイル: CompletionTests.cs プロジェクト: sunsure/PTVS
        public void GotoDefinition()
        {
            using (var vs = new MockVs()) {
                string code = @"
class C:
    def fff(self): pass
i=1+2
C().fff";

                AnalyzeAndValidateExpression(vs, code.IndexOf("fff("), 3, code, "fff");
                AnalyzeAndValidateExpression(vs, code.IndexOf("self)"), 4, code, "self");
                AnalyzeAndValidateExpression(vs, code.IndexOf("C:"), 1, code, "C");
                AnalyzeAndValidateExpression(vs, code.IndexOf("1"), 1, code, "1");
                AnalyzeAndValidateExpression(vs, code.IndexOf("2"), 1, code, "2");
                AnalyzeAndValidateExpression(vs, code.IndexOf("C()."), 1, code, "C");
                AnalyzeAndValidateExpression(vs, code.IndexOf(".fff") + 2, 2, code, "C().fff");
            }
        }
コード例 #27
0
ファイル: ClassifierTests.cs プロジェクト: gilbertw/PTVS
            public ClassifierHelper(string code, PythonLanguageVersion version)
            {
                _vs = new MockVs();

                var reg       = _vs.ContentTypeRegistry;
                var providers = _vs.ComponentModel.GetExtensions <IClassifierProvider>().ToArray();

                _provider1 = providers.OfType <PythonClassifierProvider>().Single();
                _provider2 = providers.OfType <PythonAnalysisClassifierProvider>().Single();

                var factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());

                _analyzer = new VsProjectAnalyzer(_vs.ServiceProvider, factory, new[] { factory });

                _view = _vs.CreateTextView(PythonCoreConstants.ContentType, code, v => {
                    v.TextView.TextBuffer.Properties.AddProperty(typeof(VsProjectAnalyzer), _analyzer);
                });
            }
コード例 #28
0
        private static MockVsTextView CreateViewAndAnalyze(MockVs vs = null)
        {
            if (vs == null)
            {
                vs = new MockVs();
                // Ensure these options are set correctly if we're creating the
                // instance. Otherwise, the caller is responsible.
                var opts = vs.GetPyService().AdvancedOptions;
                opts.AutoListMembers     = true;
                opts.AutoListIdentifiers = false;
            }
            var view = vs.CreateTextView(
                PythonCoreConstants.ContentType,
                Path.Combine(Environment.CurrentDirectory, Path.GetRandomFileName(), "foo.py")
                );

            view.View.GetAnalyzer(vs.ServiceProvider).WaitForCompleteAnalysis(x => true);
            return(view);
        }
コード例 #29
0
        public MockVsTextManager(MockVs vs)
        {
            _vs = vs;
            foreach (var langService in MockVs.CachedInfo.LangServicesByGuid)
            {
                var type = langService.Value.Attribute;

                _langPrefs[langService.Key] = new LANGPREFERENCES2()
                {
                    guidLang                     = langService.Key,
                    fDropdownBar                 = (uint)(type.ShowDropDownOptions ? 1 : 0),
                    fInsertTabs                  = (uint)(type.DefaultToInsertSpaces ? 0 : 1),
                    fShowCompletion              = (uint)(type.ShowCompletion ? 1 : 0),
                    fShowSmartIndent             = (uint)(type.ShowSmartIndent ? 1 : 0),
                    fHideAdvancedAutoListMembers = (uint)(type.HideAdvancedMembersByDefault ? 1 : 0),
                    fAutoListMembers             = 1,
                    fAutoListParams              = 1,
                    IndentStyle                  = type.ShowSmartIndent ? vsIndentStyle.vsIndentStyleSmart : vsIndentStyle.vsIndentStyleDefault
                };
            }
        }
コード例 #30
0
        public void AutoListIdentifierCompletions()
        {
            using (var vs = new MockVs()) {
                var options = vs.GetPyService().AdvancedOptions;
                var oldALI  = options.AutoListIdentifiers;
                options.AutoListIdentifiers = true;
                vs.OnDispose(() => options.AutoListIdentifiers = oldALI);

                var view = CreateViewAndAnalyze(vs);
                view.Type("a = ");

                foreach (var c in "abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ")
                {
                    // x<space> should bring up a completion session
                    Console.WriteLine("Typing {0}", c);
                    view.Type(c.ToString());

                    using (var sh = view.WaitForSession <ICompletionSession>()) {
                        sh.Session.Dismiss();
                    }

                    view.Backspace();
                }

                view.AssertNoIntellisenseSession();

                // x<space> should not bring up a completion session
                // Don't check too many items, since asserting that no session
                // starts is slow.
                foreach (var c in "1234567890([{")
                {
                    Console.WriteLine("Typing {0}", c);
                    view.Type(c.ToString());

                    view.AssertNoIntellisenseSession();

                    view.Backspace();
                }
            }
        }
コード例 #31
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
        private static ExpressionAnalysis AnalyzeExpression(MockVs vs, int location, string code, PythonLanguageVersion version = PythonLanguageVersion.V27) {
            if (location < 0) {
                location += code.Length + 1;
            }

            using (var view = new PythonEditor(code, version, vs)) {
                var snapshot = view.CurrentSnapshot;
                return snapshot.AnalyzeExpression(
                    vs.ServiceProvider,
                    snapshot.CreateTrackingSpan(location, location < snapshot.Length ? 1 : 0, SpanTrackingMode.EdgeInclusive),
                    false
                );
            }
        }
コード例 #32
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
 private static IEnumerable<string> GetCompletions(MockVs vs, int index, string code, IPythonInterpreterFactory factory) {
     using (var view = new PythonEditor(code, vs: vs, factory: factory)) {
         return view.GetCompletions(index);
     }
 }
コード例 #33
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
 private static IEnumerable<string> GetCompletions(MockVs vs, int index, string code, PythonLanguageVersion version = PythonLanguageVersion.V27) {
     using (var view = new PythonEditor(code, version, vs)) {
         return view.GetCompletions(index);
     }
 }
コード例 #34
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
        public void CtrlSpaceAfterKeyword() {
            // http://pytools.codeplex.com/workitem/560
            string code = @"
def h():
    return 

print 

";

            using (var vs = new MockVs()) {
                AssertUtil.ContainsAtLeast(GetCompletions(vs, code.IndexOfEnd("return "), code), "any");
                AssertUtil.ContainsAtLeast(GetCompletions(vs, code.IndexOfEnd("print "), code), "any");
            }
        }
コード例 #35
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
        public void OverridesWithMismatchedAnalysis() {
            // Here we create a buffer and analyze. We then add some newlines
            // and a def, expecting completions from A (int). Because the def
            // has moved down into class B, GetCompletions() rolls it back
            // to find out where in the analysis to look - without this, we
            // would get completions for dict rather than int.
            var code = @"
class A(int):
    pass

class B(dict):
    pass

";

            using (var vs = new MockVs()) {
                var editText = "\r\n\r\n\r\n    def ";
                var editInsert = code.IndexOf("pass") + 4;
                var completions = EditAndGetCompletions(vs, code, editText, editInsert, "def ");

                AssertUtil.ContainsAtLeast(completions, "bit_length", "conjugate");
                AssertUtil.DoesntContain(completions, "keys");

                editText = "\r\n\r\n\r\n\r\n\r\n    def ";
                editInsert = code.IndexOf("pass", editInsert) + 4;
                completions = EditAndGetCompletions(vs, code, editText, editInsert, "def ");

                AssertUtil.ContainsAtLeast(completions, "keys", "__contains__");
                AssertUtil.DoesntContain(completions, "bit_length");
            }
        }
コード例 #36
0
ファイル: MockTreeNode.cs プロジェクト: omnimark/PTVS
 public MockTreeNode(MockVs mockVs, HierarchyItem res) {
     _mockVs = mockVs;
     _item = res;
 }
コード例 #37
0
ファイル: MockVsServiceProvider.cs プロジェクト: wenh123/PTVS
 public MockVsServiceProvider(MockVs mockVs) {
     _vs = mockVs;
     _servicesByType.Add(typeof(IOleServiceProvider), this);
 }
コード例 #38
0
ファイル: MockVsServiceProvider.cs プロジェクト: zooba/PTVS
 public MockVsServiceProvider(MockVs mockVs) {
     _vs = mockVs;
     _servicesByGuid.Add(typeof(IOleServiceProvider).GUID, this);
 }
コード例 #39
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
        public void CtrlSpaceAfterNumber() {
            // http://pytools.codeplex.com/workitem/2323
            string code = @"
2
2.
2..
2.0.
";

            using (var vs = new MockVs()) {
                AssertUtil.ContainsExactly(GetCompletions(vs, code.IndexOfEnd("2"), code));
                AssertUtil.ContainsExactly(GetCompletions(vs, code.IndexOfEnd("2."), code));
                AssertUtil.ContainsAtLeast(GetCompletions(vs, code.IndexOfEnd("2.."), code), "real", "imag");
                AssertUtil.ContainsAtLeast(GetCompletions(vs, code.IndexOfEnd("2.0."), code), "real", "imag");
            }
        }
コード例 #40
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
        public void ExceptionCompletions() {
            using (var vs = new MockVs()) {
                foreach (string code in new[] { 
                @"import sys
raise |", 
                @"import sys
raise (|", 
                @"import sys
try:
    pass
except |",
                @"import sys
try:
    pass
except (|",
            @"import sys
try:
    pass
except (ValueError, |"}) {
                    var completionList = GetCompletions(vs, code.IndexOf("|"), code.Replace("|", "")).ToArray();

                    AssertUtil.ContainsAtLeast(completionList,
                        "Exception",
                        "KeyboardInterrupt",
                        "GeneratorExit",
                        "StopIteration",
                        "SystemExit",
                        "sys"
                    );

                    AssertUtil.DoesntContain(completionList, "Warning");
                    AssertUtil.DoesntContain(completionList, "str");
                    AssertUtil.DoesntContain(completionList, "int");
                }

                foreach (string code in new[] { 
                @"import sys
raise (sys.", 
                @"import sys
try:
    pass
except (sys."}) {
                    var completionList = GetCompletions(vs, code.IndexOfEnd("sys."), code).ToArray();

                    AssertUtil.DoesntContain(completionList, "Exception");
                    AssertUtil.DoesntContain(completionList, "KeyboardInterrupt");
                    AssertUtil.DoesntContain(completionList, "GeneratorExit");
                    AssertUtil.DoesntContain(completionList, "StopIteration");
                    AssertUtil.DoesntContain(completionList, "SystemExit");

                    AssertUtil.ContainsAtLeast(completionList,
                        "modules",
                        "path",
                        "version"
                    );
                }
            }
        }
コード例 #41
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
 public void FromOSPathImportCompletions3x() {
     using (var vs = new MockVs())
     using (var db = MockCompletionDB.Create(PythonLanguageVersion.V33, "os", "ntpath", "posixpath", "os2emxpath")) {
         OSPathImportTest(vs, db);
     }
 }
コード例 #42
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
        private static void OSPathImportTest(MockVs vs, MockCompletionDB db) {
            var code = "from ";
            AssertUtil.ContainsAtLeast(GetCompletions(vs, -1, code, db.Factory), "os", "sys");

            code = "from o";
            var completions = GetCompletions(vs, -1, code, db.Factory);
            AssertUtil.ContainsAtLeast(completions, "os");
            AssertUtil.DoesntContain(completions, "sys");

            code = "from os ";
            AssertUtil.ContainsExactly(GetCompletions(vs, -1, code, db.Factory), "import");

            code = "from os import";
            AssertUtil.ContainsExactly(GetCompletions(vs, -1, code, db.Factory), "import");

            code = "from os import ";
            AssertUtil.ContainsAtLeast(GetCompletions(vs, -1, code, db.Factory), "path");

            code = "from os.";
            AssertUtil.ContainsExactly(GetCompletions(vs, -1, code, db.Factory), "path");

            code = "from os.path import ";
            AssertUtil.ContainsAtLeast(GetCompletions(vs, -1, code, db.Factory), "abspath", "relpath");

            var allNames = new HashSet<string>();
            allNames.UnionWith(GetCompletions(vs, -1, "from ntpath import ", db.Factory));
            allNames.UnionWith(GetCompletions(vs, -1, "from posixpath import ", db.Factory));

            code = "from os.path import ";
            AssertUtil.ContainsAtLeast(GetCompletions(vs, -1, code, db.Factory), allNames);
        }
コード例 #43
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
        private static IEnumerable<string> EditAndGetCompletions(
            MockVs vs,
            string code,
            string editText,
            int editInsert,
            string completeAfter,
            PythonLanguageVersion version = PythonLanguageVersion.V27
        ) {
            using (var view = new PythonEditor(code, version, vs)) {
                view.AdvancedOptions.HideAdvancedMembers = false;

                var snapshot = view.CurrentSnapshot;
                view.View.MoveCaret(new SnapshotPoint(snapshot, editInsert));
                view.Type(editText);

                var newSnapshot = view.CurrentSnapshot;
                Assert.AreNotSame(snapshot, newSnapshot);

                return view.GetCompletionsAfter(completeAfter);
            }
        }
コード例 #44
0
ファイル: CompletionTests.cs プロジェクト: jsschultz/PTVS
        private static ExpressionAnalysis AnalyzeExpression(MockVs vs, int location, string code, PythonLanguageVersion version = PythonLanguageVersion.V27) {
            if (location < 0) {
                location += code.Length + 1;
            }

            using (var view = new PythonEditor(code, version, vs)) {
                var snapshot = view.CurrentSnapshot;
                ExpressionAnalysis expr = null;
                vs.InvokeSync(() => {
                    expr = vs.GetPyService().AnalyzeExpression(
                        view.View.TextView,
                        snapshot,
                        snapshot.CreateTrackingSpan(location, location < snapshot.Length ? 1 : 0, SpanTrackingMode.EdgeInclusive),
                        false
                    );
                });
                return expr;
            }
        }
コード例 #45
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
        public void CompletionWithLongDocString() {
            using (var vs = new MockVs()) {
                var docString = GenerateText(100, 72, "    ").ToArray();
                string code = @"
def func(a):
    '''" + string.Join(Environment.NewLine, docString) + @"'''
    pass

";

                // Because there is an extra line added for the Quick Info we only
                // want the first 29 lines of the docstring. For signature docs,
                // we'll cut to 15 lines.
                var expected1 = string.Join(Environment.NewLine, docString.Take(29)) + Environment.NewLine + "...";
                var expected2 = string.Join(Environment.NewLine, docString.Take(15)).TrimStart() + Environment.NewLine + "...";

                using (var view = new PythonEditor(code)) {
                    TestQuickInfo(view, code.IndexOf("func"), code.IndexOf("func") + 4, "func: def func(a)\r\n" + expected1);

                    SignatureAnalysis sigs;
                    view.Text += "func(";
                    TestSignature(view, -1, "func", 0, out sigs);
                    Assert.AreEqual(1, sigs.Signatures.Count);
                    Assert.AreEqual(1, sigs.Signatures[0].Parameters.Count);
                    Assert.AreEqual(expected2, sigs.Signatures[0].Documentation);
                }

                docString = GenerateText(100, 250, "    ").ToArray();
                code = @"
def func(a):
    '''" + string.Join(Environment.NewLine, docString) + @"'''
    pass

";

                using (var view = new PythonEditor(code)) {
                    // The long lines cause us to truncate sooner.
                    expected1 = string.Join(Environment.NewLine, docString.Take(15)) + Environment.NewLine + "...";
                    expected2 = string.Join(Environment.NewLine, docString.Take(8)).TrimStart() + Environment.NewLine + "...";

                    TestQuickInfo(view, code.IndexOf("func"), code.IndexOf("func") + 4, "func: def func(a)\r\n" + expected1);

                    SignatureAnalysis sigs;
                    view.Text += "func(";
                    TestSignature(view, -1, "func", 0, out sigs);
                    Assert.AreEqual(1, sigs.Signatures.Count);
                    Assert.AreEqual(1, sigs.Signatures[0].Parameters.Count);
                    Assert.AreEqual(expected2, sigs.Signatures[0].Documentation);
                }
            }
        }
コード例 #46
0
ファイル: RefactorRenameTests.cs プロジェクト: jsschultz/PTVS
 public void TestInit() {
     MockPythonToolsPackage.SuppressTaskProvider = true;
     _vs = new MockVs();
 }
コード例 #47
0
ファイル: RefactorRenameTests.cs プロジェクト: sadapple/PTVS
 public void TestInit() {
     _vs = new MockVs();
 }
コード例 #48
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
        public void FromImportMultilineCompletions() {
            using (var vs = new MockVs()) {
                var code = "from sys import (";
                var completions = GetCompletions(vs, -1, code);
                AssertUtil.ContainsAtLeast(completions, "settrace", "api_version");
                AssertUtil.DoesntContain(completions, "*");

                code = "from nt import (\r\n    ";
                completions = GetCompletions(vs, -1, code);
                AssertUtil.ContainsAtLeast(completions, "abort", "W_OK");
                AssertUtil.DoesntContain(completions, "*");

                code = "from nt import (getfilesystemencoding,\r\n    ";
                completions = GetCompletions(vs, -1, code);
                AssertUtil.ContainsAtLeast(completions, "abort", "W_OK");
                AssertUtil.DoesntContain(completions, "*");

                // Need a comma for more completions
                code = "from sys import (settrace\r\n    ";
                AssertUtil.ContainsExactly(GetCompletions(vs, -1, code), "as");
            }
        }
コード例 #49
0
ファイル: PythonEditor.cs プロジェクト: RussBaz/PTVS
        public PythonEditor(
            string content = null,
            PythonLanguageVersion version = PythonLanguageVersion.V27,
            MockVs vs = null,
            IPythonInterpreterFactory factory = null,
            VsProjectAnalyzer analyzer = null,
            string filename = null
        ) {
            if (vs == null) {
                _disposeVS = true;
                vs = new MockVs();
            }
            MockVsTextView view = null;
            try {
                AdvancedOptions = vs.GetPyService().AdvancedOptions;
                AdvancedOptions.AutoListMembers = true;
                AdvancedOptions.AutoListIdentifiers = false;

                if (factory == null) {
                    _disposeFactory = true;
                    factory = InterpreterFactoryCreator.CreateAnalysisInterpreterFactory(version.ToVersion());
                }
                if (analyzer == null) {
                    _disposeAnalyzer = true;
                    analyzer = new VsProjectAnalyzer(vs.ServiceProvider, factory);
                    var task = analyzer.ReloadTask;
                    if (task != null) {
                        task.WaitAndUnwrapExceptions();
                    }
                }

                var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
                using (var mre = new ManualResetEventSlim()) {
                    EventHandler evt = (s, e) => mre.Set();
                    analyzer.AnalysisStarted += evt;
                    view = vs.CreateTextView(PythonCoreConstants.ContentType, content ?? "", v => {
                        v.TextView.TextBuffer.Properties.AddProperty(typeof(VsProjectAnalyzer), analyzer);
                    }, filename);

                    try {
                        mre.Wait(cts.Token);
                        analyzer.WaitForCompleteAnalysis(x => !cts.IsCancellationRequested);
                    } catch (OperationCanceledException) {
                    } finally {
                        analyzer.AnalysisStarted -= evt;
                    }
                    if (cts.IsCancellationRequested) {
                        Assert.Fail("Timed out waiting for code analysis");
                    }
                }

                View = view;
                view = null;
                Analyzer = analyzer;
                analyzer = null;
                Factory = factory;
                factory = null;
                VS = vs;
                vs = null;
            } finally {
                if (view != null) {
                    view.Dispose();
                }
                if (analyzer != null && _disposeAnalyzer) {
                    analyzer.Dispose();
                }
                if (factory != null && _disposeFactory) {
                    var disp = factory as IDisposable;
                    if (disp != null) {
                        disp.Dispose();
                    }
                }
                if (vs != null && _disposeVS) {
                    vs.Dispose();
                }
            }
        }
コード例 #50
0
ファイル: MockVsTestExtensions.cs プロジェクト: omnimark/PTVS
 public static IVisualStudioInstance ToMockVs(this SolutionFile self) {
     MockVs vs = new MockVs();
     vs.Invoke(() => ErrorHandler.ThrowOnFailure(vs.Solution.OpenSolutionFile(0, self.Filename)));
     return vs;
 }
コード例 #51
0
ファイル: CompletionTests.cs プロジェクト: RussBaz/PTVS
        private static IEnumerable<string> EditAndGetCompletions(
            MockVs vs,
            string code,
            string editText,
            int editInsert,
            string completeAfter,
            PythonLanguageVersion version = PythonLanguageVersion.V27
        ) {
            using (var view = new PythonEditor(code, version, vs)) {
                view.AdvancedOptions.HideAdvancedMembers = false;

                var snapshot = view.CurrentSnapshot;
                ITextVersion afterEditVersion = null;
                ManualResetEvent mre = new ManualResetEvent(false);
                view.View.TextView.TextBuffer.RegisterForNewAnalysis(entry => {
                    if (afterEditVersion != null &&
                    entry.BufferParser.GetAnalysisVersion(snapshot.TextBuffer).VersionNumber >= afterEditVersion.VersionNumber) {
                        mre.Set();
                    }
                });
                view.View.MoveCaret(new SnapshotPoint(snapshot, editInsert));
                view.Type(editText);
                afterEditVersion = view.CurrentSnapshot.Version;

                if (!mre.WaitOne(10000)) {
                    Assert.Fail("Failed to wait for new analysis");
                }
                var newSnapshot = view.CurrentSnapshot;
                Assert.AreNotSame(snapshot, newSnapshot);

                return view.GetCompletionsAfter(completeAfter);
            }
        }
コード例 #52
0
 public MockDTE(MockVs vs) {
     _vs = vs;
 }
コード例 #53
0
 public MockVsUIHierarchyWindow(MockVs vs) {
     _mockVs = vs;
 }
コード例 #54
0
ファイル: MockDialog.cs プロジェクト: lioaphy/nodejstools
 public MockDialog(MockVs vs, string title) {
     Title = title;
     Vs = vs;
 }
コード例 #55
0
 public MockVsRunningDocumentTable(MockVs vs) {
     _vs = vs;
 }
コード例 #56
0
ファイル: CompletionTests.cs プロジェクト: sadapple/PTVS
        public void GotoDefinition() {
            using (var vs = new MockVs()) {
                string code = @"
class C:
    def fff(self): pass

C().fff";

                //var emptyAnalysis = AnalyzeExpression(0, code);
                //AreEqual(emptyAnalysis.Expression, "");

                for (int i = -1; i >= -3; i--) {
                    var analysis = AnalyzeExpression(vs, i, code);
                    Assert.AreEqual("C().fff", analysis.Expression);
                }

                var classAnalysis = AnalyzeExpression(vs, -6, code);
                Assert.AreEqual("C()", classAnalysis.Expression);

                var defAnalysis = AnalyzeExpression(vs, code.IndexOf("def fff") + 4, code);
                Assert.AreEqual("fff", defAnalysis.Expression);
            }
        }
コード例 #57
0
ファイル: MockMessageBox.cs プロジェクト: lioaphy/nodejstools
 public MockMessageBox(MockVs vs, string title, string text) : base(vs, title) {
     Text = text;
 }
コード例 #58
0
 public MockVsMonitorSelection(MockVs vs) {
     _vs = vs;
     _emptyCtx = new MockVsTrackSelectionEx(this);
 }