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,8 +49,11 @@ internal TestClassInfo(
             this.ClassType = type;
             this.Constructor = constructor;
             this.TestContextProperty = testContextProperty;
+            this.BaseClassInitializeMethodsDict = new Dictionary<MethodInfo, bool>();
             this.BaseTestInitializeMethodsQueue = new Queue<MethodInfo>();
             this.BaseTestCleanupMethodsQueue = new Queue<MethodInfo>();
+            this.BaseClassInitializeMethodsQueue = new Queue<MethodInfo>();
+            this.BaseClassCleanupMethodsQueue = new Queue<MethodInfo>();
             this.Parent = parent;
             this.ClassAttribute = classAttribute;
             this.testClassExecuteSyncObject = new object();
@@ -107,6 +111,11 @@ internal set
         /// </summary>
         public bool IsClassInitializeExecuted { get; internal set; }
 
+        /// <summary>
+        /// Gets a dictionary of test initialize methods indicating if they have been executed.
+        /// </summary>
+        public Dictionary<MethodInfo, bool> BaseClassInitializeMethodsDict { get; internal set; }
+
         /// <summary>
         /// Gets the exception thrown during <see cref="ClassInitializeAttribute"/> method invocation.
         /// </summary>
@@ -157,6 +166,16 @@ public bool HasExecutableCleanupMethod
             }
         }
 
+        /// <summary>
+        /// Gets a queue of test initialize methods to call for this type.
+        /// </summary>
+        public Queue<MethodInfo> BaseClassInitializeMethodsQueue { get; private set; }
+
+        /// <summary>
+        /// Gets a queue of class cleanup methods to call for this type.
+        /// </summary>
+        public Queue<MethodInfo> BaseClassCleanupMethodsQueue { get; private set; }
+
         /// <summary>
         /// Gets the test initialize method.
         /// </summary>
@@ -219,19 +238,47 @@ 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)
             {
-                return;
+                if (this.BaseClassInitializeMethodsQueue.Count == 0)
+                {
+                    return;
+                }
             }
 
             if (testContext == null)
             {
                 throw new NullReferenceException(Resource.TestContextIsNull);
             }
 
-            // If class initialization is not done, then do it.
-            if (!this.IsClassInitializeExecuted)
+            MethodInfo initializeMethod = null;
+            try
+            {
+                // ClassInitialize methods for base classes are called in reverse order of discovery
+                // Base -> Child TestClass
+                var baseClassInitializeStack = new Stack<MethodInfo>(this.BaseClassInitializeMethodsQueue);
+                while (baseClassInitializeStack.Count > 0)
+                {
+                    initializeMethod = baseClassInitializeStack.Pop();
+                    if (initializeMethod.GetCustomAttribute<ClassInitializeAttribute>().InheritanceBehavior
+                        is ClassInitializeInheritance.BeforeEachDerivedClass)
+                    {
+                        initializeMethod?.InvokeAsSynchronousTask(null, testContext);
+                        if (!this.BaseClassInitializeMethodsDict.ContainsKey(initializeMethod))
+                        {
+                            this.BaseClassInitializeMethodsDict.Add(initializeMethod, true);
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                this.ClassInitializationException = ex;
+            }
+
+            // If class initialization is not done and class initialize method is not null, then do it.
+            if (!this.IsClassInitializeExecuted && this.classInitializeMethod != 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.
@@ -271,15 +318,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,
+                    this.ClassInitializeMethod?.Name ?? initializeMethod.Name,
                     realException.GetType().ToString(),
                     StackTraceHelper.GetExceptionMessage(realException));
 
@@ -298,19 +343,33 @@ 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)
             {
-                return null;
+                if (this.BaseClassCleanupMethodsQueue.Count == 0)
+                {
+                    return null;
+                }
             }
 
-            if (this.IsClassInitializeExecuted || this.ClassInitializeMethod == null)
+            if (this.IsClassInitializeExecuted || this.ClassInitializeMethod is null || this.BaseClassInitializeMethodsDict.ContainsValue(true))
             {
+                var classCleanupMethod = this.classCleanupMethod;
                 try
                 {
-                    this.ClassCleanupMethod.InvokeAsSynchronousTask(null);
+                    classCleanupMethod?.InvokeAsSynchronousTask(null);
+                    var baseClassCleanupQueue = new Queue<MethodInfo>(this.BaseClassCleanupMethodsQueue);
+                    while (baseClassCleanupQueue.Count > 0)
+                    {
+                        classCleanupMethod = baseClassCleanupQueue.Dequeue();
+                        if (this.BaseClassInitializeMethodsDict.Any(method => method.Key.DeclaringType
+                                == classCleanupMethod.DeclaringType && method.Value))
+                        {
+                            classCleanupMethod?.InvokeAsSynchronousTask(null);
+                        }
+                    }
 
                     return null;
                 }

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

@@ -308,6 +308,24 @@ private TestClassInfo CreateClassInfo(Type classType, TestMethod testMethod)
                         // Update test initialize/cleanup method from base type.
                         this.UpdateInfoIfTestInitializeOrCleanupMethod(classInfo, methodInfo, true, instanceMethods, testInitializeAttributeType, testCleanupAttributeType);
                     }
+
+                    if (this.IsAssemblyOrClassInitializeMethod(methodInfo, classInitializeAttributeType))
+                    {
+                        if (methodInfo.GetCustomAttribute<ClassInitializeAttribute>().InheritanceBehavior == ClassInitializeInheritance.None)
+                        {
+                            // if the ClassInitializeInheritance is None, means
+                            // it will pick only the derived class initalize method
+                            break;
+                        }
+
+                        // update class initialize queue with new method
+                        classInfo.BaseClassInitializeMethodsQueue.Enqueue(methodInfo);
+                    }
+                    else if (this.IsAssemblyOrClassCleanupMethod(methodInfo, classCleanupAttributeType))
+                    {
+                        // update class cleanup queue with new method
+                        classInfo.BaseClassCleanupMethodsQueue.Enqueue(methodInfo);
+                    }
                 }
 
                 baseType = baseType.GetTypeInfo().BaseType;

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,24 @@ public enum TestTimeout
         Infinite = int.MaxValue
     }
 
+    /// <summary>
+    /// Enumeration for class initialize, that can be used with the <see cref="ClassInitializeAttribute"/> class.
+    /// Defines the behavior of the ClassInitialize methods of base classes.
+    /// The type of the enumeration must match
+    /// </summary>
+    public enum ClassInitializeInheritance
+    {
+        /// <summary>
+        /// None.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// Before each derived class.
+        /// </summary>
+        BeforeEachDerivedClass
+    }
+
     /// <summary>
     /// The test class attribute.
     /// </summary>
@@ -156,6 +172,20 @@ 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>
+        /// <param name="inheritanceBehavior">none</param>
+        public ClassInitializeAttribute(ClassInitializeInheritance inheritanceBehavior = ClassInitializeInheritance.None)
+        {
+            this.InheritanceBehavior = inheritanceBehavior;
+        }
+
+        /// <summary>
+        /// Gets InheritanceBehavior
+        /// </summary>
+        public ClassInitializeInheritance InheritanceBehavior { get; private set; }
     }
 
     /// <summary>