Class Initialize inheritance #143

src/Adapter/MSTest.CoreAdapter/Execution/TestClassInfo.cs

@@ -8,6 +8,7 @@ namespace Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Execution
     using System.Diagnostics;
     using System.Diagnostics.CodeAnalysis;
     using System.Globalization;
+    using System.Linq;
     using System.Reflection;
     using Extensions;
     using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -48,6 +49,8 @@ internal TestClassInfo(
             this.ClassType = type;
             this.Constructor = constructor;
             this.TestContextProperty = testContextProperty;
+            this.BaseClassCleanupMethodsStack = new Stack<MethodInfo>();
+            this.BaseClassInitAndCleanupMethods = new Queue<Tuple<MethodInfo, MethodInfo>>();
             this.BaseTestInitializeMethodsQueue = new Queue<MethodInfo>();
             this.BaseTestCleanupMethodsQueue = new Queue<MethodInfo>();
             this.Parent = parent;
@@ -107,6 +110,11 @@ internal set
         /// </summary>
         public bool IsClassInitializeExecuted { get; internal set; }
 
+        /// <summary>
+        /// Gets a stack of class cleanup methods to be executed.
+        /// </summary>
+        public Stack<MethodInfo> BaseClassCleanupMethodsStack { get; internal set; }
+
         /// <summary>
         /// Gets the exception thrown during <see cref="ClassInitializeAttribute"/> method invocation.
         /// </summary>
@@ -157,6 +165,11 @@ public bool HasExecutableCleanupMethod
             }
         }
 
+        /// <summary>
+        /// Gets a tuples' queue of class initialize/cleanup methods to call for this type.
+        /// </summary>
+        public Queue<Tuple<MethodInfo, MethodInfo>> BaseClassInitAndCleanupMethods { get; private set; }
+
         /// <summary>
         /// Gets the test initialize method.
         /// </summary>
@@ -219,8 +232,8 @@ internal set
         [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Requirement is to handle all kinds of user exceptions and message appropriately.")]
         public void RunClassInitialize(TestContext testContext)
         {
-            // If no class initialize return
-            if (this.ClassInitializeMethod == null)
+            // If no class initialize and no base class initialize, return
+            if (this.ClassInitializeMethod is null && !this.BaseClassInitAndCleanupMethods.Any(p => p.Item1 != null))
             {
                 return;
             }
@@ -230,8 +243,50 @@ public void RunClassInitialize(TestContext testContext)
                 throw new NullReferenceException(Resource.TestContextIsNull);
             }
 
-            // If class initialization is not done, then do it.
-            if (!this.IsClassInitializeExecuted)
+            MethodInfo initializeMethod = null;
+            string failedClassInitializeMethodName = string.Empty;
+
+            // If class initialization is done, just return
+            if (this.IsClassInitializeExecuted)
+            {
+                return;
+            }
+
+            // Aquiring a lock is usually a costly operation which does not need to be
+            // performed every time if the class init is already executed.
+            lock (this.testClassExecuteSyncObject)
+            {
+                // Perform a check again.
+                if (this.IsClassInitializeExecuted)
+                {
+                    return;
+                }
+
+                try
+                {
+                    // ClassInitialize methods for base classes are called in reverse order of discovery
+                    // Base -> Child TestClass
+                    var baseClassInitializeStack = new Stack<Tuple<MethodInfo, MethodInfo>>(
+                            this.BaseClassInitAndCleanupMethods.Where(p => p.Item1 != null));
+
+                    while (baseClassInitializeStack.Count > 0)
+                    {
+                        var baseInitCleanupMethods = baseClassInitializeStack.Pop();
+                        initializeMethod = baseInitCleanupMethods.Item1;
+                        initializeMethod?.InvokeAsSynchronousTask(null, testContext);
+                        this.BaseClassCleanupMethodsStack.Push(baseInitCleanupMethods.Item2);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    this.ClassInitializationException = ex;
+                    failedClassInitializeMethodName = initializeMethod.Name;
+                }
+            }
+
+            // If class initialization is not done and class initialize method is not null,
+            // and class initialization exception is null, then do it.
+            if (!this.IsClassInitializeExecuted && this.classInitializeMethod != null && this.ClassInitializationException == null)
             {
                 // Aquiring a lock is usually a costly operation which does not need to be
                 // performed every time if the class init is already executed.
@@ -247,6 +302,7 @@ public void RunClassInitialize(TestContext testContext)
                         catch (Exception ex)
                         {
                             this.ClassInitializationException = ex;
+                            failedClassInitializeMethodName = this.ClassInitializeMethod.Name;
                         }
                         finally
                         {
@@ -271,15 +327,13 @@ public void RunClassInitialize(TestContext testContext)
             var realException = this.ClassInitializationException.InnerException ?? this.ClassInitializationException;
 
             var outcome = UnitTestOutcome.Failed;
-            string errorMessage = null;
-            StackTraceInformation exceptionStackTraceInfo = null;
-            if (!realException.TryGetUnitTestAssertException(out outcome, out errorMessage, out exceptionStackTraceInfo))
+            if (!realException.TryGetUnitTestAssertException(out outcome, out string errorMessage, out StackTraceInformation exceptionStackTraceInfo))
             {
                 errorMessage = string.Format(
                     CultureInfo.CurrentCulture,
                     Resource.UTA_ClassInitMethodThrows,
                     this.ClassType.FullName,
-                    this.ClassInitializeMethod.Name,
+                    failedClassInitializeMethodName,
                     realException.GetType().ToString(),
                     StackTraceHelper.GetExceptionMessage(realException));
 
@@ -298,19 +352,26 @@ public void RunClassInitialize(TestContext testContext)
         /// <returns>
         /// Any exception that can be thrown as part of a class cleanup as warning messages.
         /// </returns>
-        [SuppressMessageAttribute("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Requirement is to handle all kinds of user exceptions and message appropriately.")]
+        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Requirement is to handle all kinds of user exceptions and message appropriately.")]
         public string RunClassCleanup()
         {
-            if (this.ClassCleanupMethod == null)
+            if (this.ClassCleanupMethod is null && !this.BaseClassInitAndCleanupMethods.Any(p => p.Item2 != null))
             {
                 return null;
             }
 
-            if (this.IsClassInitializeExecuted || this.ClassInitializeMethod == null)
+            if (this.IsClassInitializeExecuted || this.ClassInitializeMethod is null || this.BaseClassCleanupMethodsStack.Any())
             {
+                var classCleanupMethod = this.ClassCleanupMethod;
                 try
                 {
-                    this.ClassCleanupMethod.InvokeAsSynchronousTask(null);
+                    classCleanupMethod?.InvokeAsSynchronousTask(null);
+                    var baseClassCleanupQueue = new Queue<MethodInfo>(this.BaseClassCleanupMethodsStack);
+                    while (baseClassCleanupQueue.Count > 0)
+                    {
+                        classCleanupMethod = baseClassCleanupQueue.Dequeue();
+                        classCleanupMethod?.InvokeAsSynchronousTask(null);
+                    }
 
                     return null;
                 }

src/Adapter/MSTest.CoreAdapter/Execution/TypeCache.cs

@@ -275,6 +275,10 @@ private TestClassInfo CreateClassInfo(Type classType, TestMethod testMethod)
             var classInitializeAttributeType = typeof(ClassInitializeAttribute);
             var classCleanupAttributeType = typeof(ClassCleanupAttribute);
 
+            // List holding the instance of the initialize/cleanup methods
+            // to be passed into the tuples' queue  when updating the class info.
+            var initAndCleanupMethods = new MethodInfo[2];
+
             // List of instance methods present in the type as well its base type
             // which is used to decide whether TestInitialize/TestCleanup methods
             // present in the base type should be used or not. They are not used if
@@ -286,16 +290,8 @@ private TestClassInfo CreateClassInfo(Type classType, TestMethod testMethod)
                 // Update test initialize/cleanup method
                 this.UpdateInfoIfTestInitializeOrCleanupMethod(classInfo, methodInfo, isBase: false, instanceMethods: instanceMethods, testInitializeAttributeType: testInitializeAttributeType, testCleanupAttributeType: testCleanupAttributeType);
 
-                if (this.IsAssemblyOrClassInitializeMethod(methodInfo, classInitializeAttributeType))
-                {
-                    // update class initialize method
-                    classInfo.ClassInitializeMethod = methodInfo;
-                }
-                else if (this.IsAssemblyOrClassCleanupMethod(methodInfo, classCleanupAttributeType))
-                {
-                    // update class cleanup method
-                    classInfo.ClassCleanupMethod = methodInfo;
-                }
+                // Update class initialize/cleanup method
+                this.UpdateInfoIfClassInitializeOrCleanupMethod(classInfo, methodInfo, false, ref initAndCleanupMethods, classInitializeAttributeType, classCleanupAttributeType);
             }
 
             var baseType = classType.GetTypeInfo().BaseType;
@@ -308,8 +304,14 @@ private TestClassInfo CreateClassInfo(Type classType, TestMethod testMethod)
                         // Update test initialize/cleanup method from base type.
                         this.UpdateInfoIfTestInitializeOrCleanupMethod(classInfo, methodInfo, true, instanceMethods, testInitializeAttributeType, testCleanupAttributeType);
                     }
+
+                    if (methodInfo.IsPublic && methodInfo.IsStatic)
+                    {
+                        this.UpdateInfoIfClassInitializeOrCleanupMethod(classInfo, methodInfo, true, ref initAndCleanupMethods, classInitializeAttributeType, classCleanupAttributeType);
+                    }
                 }
 
+                this.UpdateInfoWithInitializeAndCleanupMethods(classInfo, ref initAndCleanupMethods);
                 baseType = baseType.GetTypeInfo().BaseType;
             }
 
@@ -474,6 +476,83 @@ private bool IsAssemblyOrClassCleanupMethod(MethodInfo methodInfo, Type cleanupA
 
         #endregion
 
+        /// <summary>
+        /// Update the classInfo with given initialize and cleanup methods.
+        /// </summary>
+        /// <param name="classInfo"> The Class Info. </param>
+        /// <param name="initAndCleanupMethods"> An array with the Initialize and Cleanup Methods Info. </param>
+        private void UpdateInfoWithInitializeAndCleanupMethods(
+            TestClassInfo classInfo,
+            ref MethodInfo[] initAndCleanupMethods)
+        {
+            if (initAndCleanupMethods is null)
+            {
+                return;
+            }
+
+            classInfo.BaseClassInitAndCleanupMethods.Enqueue(
+                    new Tuple<MethodInfo, MethodInfo>(
+                        initAndCleanupMethods.FirstOrDefault(),
+                        initAndCleanupMethods.LastOrDefault()));
+
+            initAndCleanupMethods = null;
+        }
+
+        /// <summary>
+        /// Update the classInfo if the parameter method is a classInitialize/cleanup method
+        /// </summary>
+        /// <param name="classInfo"> The Class Info. </param>
+        /// <param name="methodInfo"> The Method Info. </param>
+        /// <param name="isBase"> Flag to check whether base class needs to be validated. </param>
+        /// <param name="initAndCleanupMethods"> An array with Initialize/Cleanup methods. </param>
+        /// <param name="classInitializeAttributeType"> The Class Initialize Attribute Type. </param>
+        /// <param name="classCleanupAttributeType"> The Class Cleanup Attribute Type. </param>
+        private void UpdateInfoIfClassInitializeOrCleanupMethod(
+            TestClassInfo classInfo,
+            MethodInfo methodInfo,
+            bool isBase,
+            ref MethodInfo[] initAndCleanupMethods,
+            Type classInitializeAttributeType,
+            Type classCleanupAttributeType)
+        {
+            var isInitializeMethod = this.IsAssemblyOrClassInitializeMethod(methodInfo, classInitializeAttributeType);
+            var isCleanupMethod = this.IsAssemblyOrClassCleanupMethod(methodInfo, classCleanupAttributeType);
+
+            if (isInitializeMethod)
+            {
+                if (isBase)
+                {
+                    if (((ClassInitializeAttribute)this.reflectionHelper.GetCustomAttribute(methodInfo, classInitializeAttributeType))
+                            .InheritanceBehavior == InheritanceBehavior.BeforeEachDerivedClass)
+                    {
+                        initAndCleanupMethods[0] = methodInfo;
+                    }
+                }
+                else
+                {
+                    // update class initialize method
+                    classInfo.ClassInitializeMethod = methodInfo;
+                }
+            }
+
+            if (isCleanupMethod)
+            {
+                if (isBase)
+                {
+                    if (((ClassCleanupAttribute)this.reflectionHelper.GetCustomAttribute(methodInfo, classCleanupAttributeType))
+                            .InheritanceBehavior == InheritanceBehavior.BeforeEachDerivedClass)
+                    {
+                        initAndCleanupMethods[1] = methodInfo;
+                    }
+                }
+                else
+                {
+                    // update class cleanup method
+                    classInfo.ClassCleanupMethod = methodInfo;
+                }
+            }
+        }
+
         /// <summary>
         /// Update the classInfo if the parameter method is a testInitialize/cleanup method
         /// </summary>

src/TestFramework/MSTest.Core/Attributes/VSTestAttributes.cs

@@ -6,8 +6,6 @@ namespace Microsoft.VisualStudio.TestTools.UnitTesting
     using System;
     using System.Collections.Generic;
     using System.Diagnostics.CodeAnalysis;
-    using System.Globalization;
-    using System.Linq;
 
 #pragma warning disable SA1402 // FileMayOnlyContainASingleType
 #pragma warning disable SA1649 // SA1649FileNameMustMatchTypeName
@@ -25,6 +23,25 @@ public enum TestTimeout
         Infinite = int.MaxValue
     }
 
+    /// <summary>
+    /// Enumeration for inheritance behavior, that can be used with both the <see cref="ClassInitializeAttribute"/> class
+    /// and <see cref="ClassCleanupAttribute"/> class.
+    /// Defines the behavior of the ClassInitialize and ClassCleanup methods of base classes.
+    /// The type of the enumeration must match
+    /// </summary>
+    public enum InheritanceBehavior
+    {
+        /// <summary>
+        /// None.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// Before each derived class.
+        /// </summary>
+        BeforeEachDerivedClass
+    }
+
     /// <summary>
     /// The test class attribute.
     /// </summary>
@@ -156,6 +173,31 @@ public TestPropertyAttribute(string name, string value)
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
     public sealed class ClassInitializeAttribute : Attribute
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClassInitializeAttribute"/> class.
+        /// ClassInitializeAttribute
+        /// </summary>
+        public ClassInitializeAttribute()
+        {
+            this.InheritanceBehavior = InheritanceBehavior.None;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClassInitializeAttribute"/> class.
+        /// ClassInitializeAttribute
+        /// </summary>
+        /// <param name="inheritanceBehavior">
+        /// Specifies the ClassInitialize Inheritance Behavior
+        /// </param>
+        public ClassInitializeAttribute(InheritanceBehavior inheritanceBehavior)
+        {
+            this.InheritanceBehavior = inheritanceBehavior;
+        }
+
+        /// <summary>
+        /// Gets the Inheritance Behavior
+        /// </summary>
+        public InheritanceBehavior InheritanceBehavior { get; private set; }
     }
 
     /// <summary>
@@ -164,6 +206,31 @@ public sealed class ClassInitializeAttribute : Attribute
     [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
     public sealed class ClassCleanupAttribute : Attribute
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClassCleanupAttribute"/> class.
+        /// ClassCleanupAttribute
+        /// </summary>
+        public ClassCleanupAttribute()
+        {
+            this.InheritanceBehavior = InheritanceBehavior.None;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClassCleanupAttribute"/> class.
+        /// ClassCleanupAttribute
+        /// </summary>
+        /// <param name="inheritanceBehavior">
+        /// Specifies the ClassCleanup Inheritance Behavior
+        /// </param>
+        public ClassCleanupAttribute(InheritanceBehavior inheritanceBehavior)
+        {
+            this.InheritanceBehavior = inheritanceBehavior;
+        }
+
+        /// <summary>
+        /// Gets the Inheritance Behavior
+        /// </summary>
+        public InheritanceBehavior InheritanceBehavior { get; private set; }
     }
 
     /// <summary>