Пример #1
0
        public void FromExpressionFollowedByWhitespaceIsImportExpression()
        {
            string text   = "from    ";
            int    offset = text.Length - 1;

            Assert.IsTrue(PythonImportExpression.IsImportExpression(text, offset));
        }
Пример #2
0
        public void EmptyStringIsNotImportExpression()
        {
            string text   = String.Empty;
            int    offset = 0;

            Assert.IsFalse(PythonImportExpression.IsImportExpression(text, offset));
        }
Пример #3
0
        public void IsImportExpressionReturnsFalseWhenOffsetIsMinusOne()
        {
            string text   = "import a";
            int    offset = -1;

            Assert.IsFalse(PythonImportExpression.IsImportExpression(text, offset));
        }
Пример #4
0
        public void IsImportExpressionReturnsTrueWhenExpressionContainsOnlyFromPart()
        {
            string text   = "from a";
            int    offset = text.Length - 1;

            Assert.IsTrue(PythonImportExpression.IsImportExpression(text, offset));
        }
Пример #5
0
        public void ImportSystemIsImportExpression()
        {
            string text   = "import System";
            int    offset = text.Length - 1;

            Assert.IsTrue(PythonImportExpression.IsImportExpression(text, offset));
        }
Пример #6
0
        public void ImportInsideAnotherStringIsNotImportExpression()
        {
            string text   = "Start-import-End";
            int    offset = text.Length - 1;

            Assert.IsFalse(PythonImportExpression.IsImportExpression(text, offset));
        }
Пример #7
0
        public void ImportStringSurroundedByExtraWhitespaceIsImportExpression()
        {
            string text   = "    import    ";
            int    offset = text.Length - 1;

            Assert.IsTrue(PythonImportExpression.IsImportExpression(text, offset));
        }
Пример #8
0
        public void FromModuleNameIsSystemForFromSystemExpressionWithWhitespaceBetweenImportAndSystem()
        {
            PythonImportExpression expression = new PythonImportExpression(engine, "from  \t  System");

            Assert.AreEqual("System", expression.Module);
            Assert.IsFalse(expression.HasFromAndImport);
        }
Пример #9
0
        public void FromModuleNameIsEmptyWhenOnlyFromIsInExpression()
        {
            PythonImportExpression expression = new PythonImportExpression(engine, "from");

            Assert.AreEqual(String.Empty, expression.Module);
            Assert.IsFalse(expression.HasFromAndImport);
        }
        public void Name_ExpressionIsImportFollowedByName_MatchesNameAfterImport()
        {
            PythonImportExpression          expression = new PythonImportExpression("import abc");
            PythonImportModuleResolveResult result     = new PythonImportModuleResolveResult(expression);
            string expectedName = "abc";

            Assert.AreEqual(expectedName, result.Name);
        }
        public void GetCompletionDataReturnsStandardMathPythonModuleWhenImportNameIsEmptyString()
        {
            PythonImportExpression          expression = new PythonImportExpression(String.Empty);
            PythonImportModuleResolveResult result     = new PythonImportModuleResolveResult(expression);
            MockProjectContent projectContent          = new MockProjectContent();

            Assert.Contains("math", result.GetCompletionData(projectContent));
        }
        public void ClonedPythonModuleResultReturnsSameCompletionItems()
        {
            PythonImportExpression          expression = new PythonImportExpression(String.Empty);
            PythonImportModuleResolveResult result     = new PythonImportModuleResolveResult(expression);
            ResolveResult      clonedResult            = result.Clone();
            MockProjectContent projectContent          = new MockProjectContent();

            Assert.Contains("math", clonedResult.GetCompletionData(projectContent));
        }
        public void Init()
        {
            string code = "from math import cos";

            importExpression = new PythonImportExpression(code);
            resolveResult    = new PythonImportModuleResolveResult(importExpression);

            projectContent = new MockProjectContent();
        }
Пример #14
0
        public void Init()
        {
            string code = "from math import";

            importExpression = new PythonImportExpression(code);
            resolveResult    = new PythonImportModuleResolveResult(importExpression);

            projectContent  = new MockProjectContent();
            completionItems = resolveResult.GetCompletionData(projectContent);
        }
        public void GetCompletionData_WhenImportNameIsEmptyString_ReturnsStandardMathPythonModule()
        {
            PythonImportExpression          expression = new PythonImportExpression(String.Empty);
            PythonImportModuleResolveResult result     = new PythonImportModuleResolveResult(expression);
            MockProjectContent projectContent          = new MockProjectContent();

            List <ICompletionEntry> completionItems             = result.GetCompletionData(projectContent);
            NamespaceEntry          mathNamespaceCompletionItem = new NamespaceEntry("math");

            Assert.Contains(mathNamespaceCompletionItem, completionItems);
        }
        public void GetCompletionData_ClonedPythonModuleResult_ReturnsSameCompletionItems()
        {
            PythonImportExpression          expression = new PythonImportExpression(String.Empty);
            PythonImportModuleResolveResult result     = new PythonImportModuleResolveResult(expression);
            ResolveResult      clonedResult            = result.Clone();
            MockProjectContent projectContent          = new MockProjectContent();

            List <ICompletionEntry> completionItems             = clonedResult.GetCompletionData(projectContent);
            NamespaceEntry          mathNamespaceCompletionItem = new NamespaceEntry("math");

            Assert.Contains(mathNamespaceCompletionItem, completionItems);
        }
        public void Init()
        {
            string code = "from System import Console";

            importExpression = new PythonImportExpression(code);
            resolveResult    = new PythonImportModuleResolveResult(importExpression);

            projectContent = new MockProjectContent();
            DefaultCompilationUnit  unit           = new DefaultCompilationUnit(projectContent);
            DefaultClass            c              = new DefaultClass(unit, "Test");
            List <ICompletionEntry> namespaceItems = new List <ICompletionEntry>();

            namespaceItems.Add(c);
            projectContent.AddExistingNamespaceContents("System", namespaceItems);
        }
        public void ModuleNameReturnedIsSystemForImportSystemExpression()
        {
            PythonImportExpression expression = new PythonImportExpression(engine, "import System");

            Assert.AreEqual("System", expression.Module);
        }
        public void Init()
        {
            string text = "import System.Console";

            importExpression = new PythonImportExpression(Python.CreateEngine(), text);
        }
        public void Init()
        {
            string code = "from System import Console";

            importExpression = new PythonImportExpression(code);
        }
        public void HasIdentifierReturnsFalseForFromMathImportWithoutIdentfier()
        {
            PythonImportExpression expression = new PythonImportExpression(engine, "from math import");

            Assert.IsFalse(expression.HasIdentifier);
        }
        public void ModuleNameIsEmptyStringWhenExpressionIsEmptyString()
        {
            PythonImportExpression expression = new PythonImportExpression(engine, String.Empty);

            Assert.AreEqual(String.Empty, expression.Module);
        }
        public void Init()
        {
            string text = "from System import ";

            expression = new PythonImportExpression(Python.CreateEngine(), text);
        }