Tests for various special declaration types.

Author: MDoerner

RubberduckTests/Symbols/ConstantDeclarationTests.cs

@@ -0,0 +1,26 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.VBEditor;
+
+namespace RubberduckTests.Symbols
+{
+    [TestClass]
+    public class ConstantDeclarationTests
+    {
+        [TestMethod]
+        public void ExpressionReturnsTheContructorInjectedValue()
+        {
+            var value = "testtest";
+            var constantName =  new QualifiedMemberName(StubQualifiedModuleName(),"testConstant");
+            var constantDeclaration = new ConstantDeclaration(constantName, null, "test", "test", null, "test", null, Accessibility.Implicit, DeclarationType.Constant, value, null, Selection.Home, false);
+
+            Assert.AreEqual<string>(value, constantDeclaration.Expression);
+        }
+            
+            private static QualifiedModuleName StubQualifiedModuleName()
+            {
+                return new QualifiedModuleName("dummy", "dummy", "dummy");
+            }
+    }
+}

RubberduckTests/Symbols/ExternalProcedureDeclarationTests.cs

@@ -0,0 +1,50 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Linq;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.VBEditor;
+
+namespace RubberduckTests.Symbols
+{
+    [TestClass]
+    public class ExternalProcedureDeclarationTests
+    {
+        [TestMethod]
+        public void ByDefaultExternalProceduresDoNotHaveParameters()
+        {
+            var externalProcedure = GetTestExternalProcedure("testProcedure");
+
+            Assert.IsFalse(externalProcedure.Parameters.Any());
+        }
+
+            private static ExternalProcedureDeclaration GetTestExternalProcedure(string name)
+            {
+                var qualifiedProcedureName = new QualifiedMemberName(StubQualifiedModuleName(), name);
+                return new ExternalProcedureDeclaration(qualifiedProcedureName, null, null, DeclarationType.Procedure, "test", null, Accessibility.Public, null, Selection.Home, false, null);
+            }
+
+                private static QualifiedModuleName StubQualifiedModuleName()
+                {
+                    return new QualifiedModuleName("dummy", "dummy", "dummy");
+                }
+
+
+        [TestMethod]
+        public void ParametersReturnsTheParametersAddedViaAddParameters()
+        {
+            var externalProcedure = GetTestExternalProcedure("testProcedure");
+            var inputParameter = GetTestParameter("testParameter", false, false, false);
+            externalProcedure.AddParameter(inputParameter);
+            var returnedParameter = externalProcedure.Parameters.SingleOrDefault();
+
+            Assert.AreEqual(returnedParameter, inputParameter);
+        }
+
+            private static ParameterDeclaration GetTestParameter(string name, bool isOptional, bool isByRef, bool isParamArray)
+            {
+                var qualifiedParameterName = new QualifiedMemberName(StubQualifiedModuleName(), name);
+                return new ParameterDeclaration(qualifiedParameterName, null, "test", null, "test", isOptional, isByRef, false, isParamArray);
+            }
+
+    }
+}

RubberduckTests/Symbols/FunctionDeclarationTests.cs

@@ -0,0 +1,79 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Linq;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.VBEditor;
+using Rubberduck.Parsing.VBA;
+
+namespace RubberduckTests.Symbols
+{
+    [TestClass]
+    public class FunctionDeclarationTests
+    {
+        [TestMethod]
+        public void FunctionsHaveDeclarationTypeFunction()
+        {
+            var function = GetTestFunction("testFoo", null);
+
+            Assert.IsTrue(function.DeclarationType.HasFlag(DeclarationType.Function));
+        }
+
+            private static FunctionDeclaration GetTestFunction(string name, Attributes attributes)
+            {
+                var qualifiedName = new QualifiedMemberName(StubQualifiedModuleName(), name);
+                return new FunctionDeclaration(qualifiedName, null, null, "test", null, "test", Accessibility.Implicit, null, Selection.Home, false, false, null, attributes);
+            }
+
+                private static QualifiedModuleName StubQualifiedModuleName()
+                {
+                    return new QualifiedModuleName("dummy", "dummy", "dummy");
+                }
+
+
+        [TestMethod]
+        public void ByDefaultFunctionsDoNotHaveParameters()
+        {
+            var function = GetTestFunction("testFoo", null);
+
+            Assert.IsFalse(function.Parameters.Any());
+        }
+
+
+        [TestMethod]
+        public void ParametersReturnsTheParametersAddedViaAddParameters()
+        {
+            var function = GetTestFunction("testFoo", null);
+            var inputParameter = GetTestParameter("testParameter", false, false, false);
+            function.AddParameter(inputParameter);
+            var returnedParameter = function.Parameters.SingleOrDefault();
+
+            Assert.AreEqual(returnedParameter, inputParameter);
+        }
+
+            private static ParameterDeclaration GetTestParameter(string name, bool isOptional, bool isByRef, bool isParamArray)
+            {
+                var qualifiedParameterName = new QualifiedMemberName(StubQualifiedModuleName(), name);
+                return new ParameterDeclaration(qualifiedParameterName, null, "test", null, "test", isOptional, isByRef, false, isParamArray);
+            }
+
+
+        [TestMethod]
+        public void ByDefaultFunctionsAreNotDefaultMembers()
+        {
+            var function = GetTestFunction("testFoo", null);
+
+            Assert.IsFalse(function.IsDefaultMember);
+        }
+
+
+        [TestMethod]
+        public void FunctionsAreDefaultMembersIfTheyHaveTheDefaultMemberAttribute()
+        {
+            var attributes = new Attributes();
+            attributes.AddDefaultMemberAttribute("testFoo");
+            var function = GetTestFunction("testFoo", attributes);
+
+            Assert.IsTrue(function.IsDefaultMember);
+        }
+    }
+}

RubberduckTests/Symbols/ParameterDeclarationTests.cs

@@ -0,0 +1,50 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.VBEditor;
+
+namespace RubberduckTests.Symbols
+{
+    [TestClass]
+    public class ParameterDeclarationTests
+    {
+        [TestMethod]
+        public void ParametersHaveDeclarationTypeParameter()
+        {
+            var paramter = GetTestParameter("testParam", false, false, false);
+
+            Assert.IsTrue(paramter.DeclarationType.HasFlag(DeclarationType.Parameter));
+        }
+
+            private static ParameterDeclaration GetTestParameter(string name, bool isOptional, bool isByRef, bool isParamArray)
+            {
+                var qualifiedParameterName = new QualifiedMemberName(StubQualifiedModuleName(), name);
+                return new ParameterDeclaration(qualifiedParameterName, null, "test", null,"test", isOptional,isByRef, false, isParamArray);
+            }
+
+                private static QualifiedModuleName StubQualifiedModuleName()
+                {
+                    return new QualifiedModuleName("dummy", "dummy", "dummy");
+                }
+
+
+        [TestMethod]
+        public void ParametersHaveImpliciteAccessibility()
+        {
+            var paramter = GetTestParameter("testParam", false, false, false);
+
+            Assert.IsTrue(paramter.Accessibility.HasFlag(Accessibility.Implicit));
+        }
+
+
+        [TestMethod]
+        public void IsParamArrayCanBeSetPublicly()
+        {
+            var paramter = GetTestParameter("testParam", false, false, false);
+            paramter.IsParamArray = true;
+
+            Assert.IsTrue(paramter.IsParamArray);
+        }
+
+    }
+}

RubberduckTests/Symbols/ProceduralModuleDeclarationTests.cs

@@ -0,0 +1,49 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.VBEditor;
+using Rubberduck.Parsing.VBA;
+
+namespace RubberduckTests.Symbols
+{
+    [TestClass]
+    public class ProceduralModuleDeclarationTests
+    {
+        [TestMethod]
+        public void ProceduralModulesHaveDeclarationTypeProceduralModule()
+        {
+            var projectDeclaration = GetTestProject("testProject");
+            var proceduralModule = GetTestProceduralModule(projectDeclaration, "testModule", false, null);
+
+            Assert.IsTrue(proceduralModule.DeclarationType.HasFlag(DeclarationType.ProceduralModule));
+        }
+
+            private static ProjectDeclaration GetTestProject(string name)
+            {
+                var qualifiedProjectName = new QualifiedMemberName(StubQualifiedModuleName(), name);
+                return new ProjectDeclaration(qualifiedProjectName, name, false);
+            }
+
+                private static QualifiedModuleName StubQualifiedModuleName()
+                {
+                    return new QualifiedModuleName("dummy", "dummy", "dummy");
+                }
+
+            private static ProceduralModuleDeclaration GetTestProceduralModule(Declaration projectDeclatation, string name, bool isBuiltIn, Attributes attributes)
+            {
+                var qualifiedProceduralModuleMemberName = new QualifiedMemberName(StubQualifiedModuleName(), name);
+                return new ProceduralModuleDeclaration(qualifiedProceduralModuleMemberName, projectDeclatation, name, isBuiltIn, null, attributes);
+            }
+
+
+        [TestMethod]
+        public void ByDefaultProceduralModulesAreNotPrivate()
+        {
+            var projectDeclaration = GetTestProject("testProject");
+            var proceduralModule = GetTestProceduralModule(projectDeclaration, "testModule", false, null);
+
+            Assert.IsFalse(proceduralModule.IsPrivateModule);
+        }
+
+    }
+}

RubberduckTests/Symbols/SubroutineDeclarationTests.cs

@@ -0,0 +1,80 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Linq;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.VBEditor;
+using Rubberduck.Parsing.VBA;
+
+namespace RubberduckTests.Symbols
+{
+    [TestClass]
+    public class SubroutineDeclarationTests
+    {
+        [TestMethod]
+        public void SubroutinesHaveDeclarationTypeProcedure()
+        {
+            var subroutine = GetTestSub("testSub", null);
+
+            Assert.IsTrue(subroutine.DeclarationType.HasFlag(DeclarationType.Procedure));
+        }
+
+            private static SubroutineDeclaration GetTestSub(string name, Attributes attributes)
+            {
+                var qualifiedName = new QualifiedMemberName(StubQualifiedModuleName(), name);
+                return new SubroutineDeclaration(qualifiedName, null, null, "test", Accessibility.Implicit, null, Selection.Home, false, null, attributes);
+            }
+
+                private static QualifiedModuleName StubQualifiedModuleName()
+                {
+                    return new QualifiedModuleName("dummy", "dummy", "dummy");
+                }
+
+
+        [TestMethod]
+        public void ByDefaultSubroutinesDoNotHaveParameters()
+        {
+            var subroutine = GetTestSub("testSub", null);
+
+            Assert.IsFalse(subroutine.Parameters.Any());
+        }
+
+
+        [TestMethod]
+        public void ParametersReturnsTheParametersAddedViaAddParameters()
+        {
+            var subroutine = GetTestSub("testSub", null);
+            var inputParameter = GetTestParameter("testParameter", false, false, false);
+            subroutine.AddParameter(inputParameter);
+            var returnedParameter = subroutine.Parameters.SingleOrDefault();
+
+            Assert.AreEqual(returnedParameter, inputParameter);
+        }
+
+            private static ParameterDeclaration GetTestParameter(string name, bool isOptional, bool isByRef, bool isParamArray)
+            {
+                var qualifiedParameterName = new QualifiedMemberName(StubQualifiedModuleName(), name);
+                return new ParameterDeclaration(qualifiedParameterName, null, "test", null, "test", isOptional, isByRef, false, isParamArray);
+            }
+
+
+        [TestMethod]
+        public void ByDefaultSubroutinesAreNotDefaultMembers()
+        {
+            var subroutine = GetTestSub("testSub", null);
+
+            Assert.IsFalse(subroutine.IsDefaultMember);
+        }
+
+
+        [TestMethod]
+        public void SubroutinesAreDefaultMembersIfTheyHaveTheDefaultMemberAttribute()
+        {
+            var attributes = new Attributes();
+            attributes.AddDefaultMemberAttribute("testSub");
+            var subroutine = GetTestSub("testSub", attributes);
+
+            Assert.IsTrue(subroutine.IsDefaultMember);
+        }
+
+    }
+}