Today even if classInit wasnt called we used to call class cleanup. f…

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

@@ -103,10 +103,15 @@ internal set
         }
 
         /// <summary>
-        /// Gets a value indicating whether is class initialize executed.
+        /// Gets a value indicating whether class initialize has executed.
         /// </summary>
         public bool IsClassInitializeExecuted { get; internal set; }
 
+        /// <summary>
+        /// Gets a value indicating whether class cleanup has executed.
+        /// </summary>
+        public bool IsClassCleanupExecuted { get; private set; }
+
         /// <summary>
         /// Gets the exception thrown during <see cref="ClassInitializeAttribute"/> method invocation.
         /// </summary>
@@ -306,40 +311,52 @@ public string RunClassCleanup()
                 return null;
             }
 
-            lock (this.testClassExecuteSyncObject)
+            if (this.IsClassInitializeExecuted)
             {
-                try
-                {
-                    this.ClassCleanupMethod.InvokeAsSynchronousTask(null);
-
-                    return null;
-                }
-                catch (Exception exception)
+                lock (this.testClassExecuteSyncObject)
                 {
-                    var realException = exception.InnerException ?? exception;
-
-                    string errorMessage;
-
-                    // special case AssertFailedException to trim off part of the stack trace
-                    if (realException is AssertFailedException ||
-                        realException is AssertInconclusiveException)
-                    {
-                        errorMessage = realException.Message;
-                    }
-                    else
+                    if (this.IsClassInitializeExecuted)
                     {
-                        errorMessage = StackTraceHelper.GetExceptionMessage(realException);
-                    }
+                        try
+                        {
+                            this.ClassCleanupMethod.InvokeAsSynchronousTask(null);
 
-                    return string.Format(
-                        CultureInfo.CurrentCulture,
-                        Resource.UTA_ClassCleanupMethodWasUnsuccesful,
-                        this.ClassType.Name,
-                        this.ClassCleanupMethod.Name,
-                        errorMessage,
-                        StackTraceHelper.GetStackTraceInformation(realException)?.ErrorStackTrace);
+                            return null;
+                        }
+                        catch (Exception exception)
+                        {
+                            var realException = exception.InnerException ?? exception;
+
+                            string errorMessage;
+
+                            // special case AssertFailedException to trim off part of the stack trace
+                            if (realException is AssertFailedException ||
+                                realException is AssertInconclusiveException)
+                            {
+                                errorMessage = realException.Message;
+                            }
+                            else
+                            {
+                                errorMessage = StackTraceHelper.GetExceptionMessage(realException);
+                            }
+
+                            return string.Format(
+                                CultureInfo.CurrentCulture,
+                                Resource.UTA_ClassCleanupMethodWasUnsuccesful,
+                                this.ClassType.Name,
+                                this.ClassCleanupMethod.Name,
+                                errorMessage,
+                                StackTraceHelper.GetStackTraceInformation(realException)?.ErrorStackTrace);
+                        }
+                        finally
+                        {
+                            this.IsClassCleanupExecuted = true;
+                        }
+                    }
                 }
             }
+
+            return null;
         }
     }
 }

test/UnitTests/MSTest.CoreAdapter.Unit.Tests/Execution/TestClassInfoTests.cs

@@ -111,6 +111,18 @@ public void TestClassInfoClassCleanupMethodSetShouldThrowForMultipleClassCleanup
             ActionUtility.ActionShouldThrowExceptionOfType(action, typeof(TypeInspectionException));
         }
 
+        [TestMethod]
+        public void TestClassInfoClassCleanupMethodShouldNotInvokeWhenNoTestClassInitializedIsCalled()
+        {
+            this.testClassInfo.ClassCleanupMethod = this.testClassType.GetMethods().First();
+            this.testClassInfo.ClassInitializeMethod = this.testClassType.GetMethods()[1];
+
+            var ret = this.testClassInfo.RunClassCleanup(); // call cleanup without calling init
+
+            Assert.AreEqual(null, ret);
+            Assert.AreEqual(false, this.testClassInfo.IsClassCleanupExecuted);
+        }
+
         [TestMethod]
         public void TestClassInfoHasExecutableCleanupMethodShouldReturnFalseIfClassDoesNotHaveCleanupMethod()
         {