diff --git a/NuGet.config b/NuGet.config
index 8c879770d5df4..513b93df1e591 100644
--- a/NuGet.config
+++ b/NuGet.config
@@ -7,6 +7,7 @@
     <add key="dotnet-tools" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json" />
     <add key="dotnet5" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet5/nuget/v3/index.json" />
     <add key="dotnet6" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet6/nuget/v3/index.json" />
+    <add key="dotnet7" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet7/nuget/v3/index.json" />
     <add key="dotnet-public" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public/nuget/v3/index.json" />
     <add key="nuget-build" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/nuget-build/nuget/v3/index.json" />
     <add key="vssdk" value="https://pkgs.dev.azure.com/azure-public/vside/_packaging/vssdk/nuget/v3/index.json" />
diff --git a/eng/Versions.props b/eng/Versions.props
index bb7a9a0e7202f..7867b0fd57899 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -37,6 +37,7 @@
          but not higher than our minimum dogfoodable Visual Studio version, or else
          the generators we build would load on the command line but not load in IDEs. -->
     <SourceGeneratorMicrosoftCodeAnalysisVersion>3.8.0</SourceGeneratorMicrosoftCodeAnalysisVersion>
+    <MicrosoftILVerificationVersion>7.0.0-alpha.1.22060.1</MicrosoftILVerificationVersion>
   </PropertyGroup>
   <!--
     Dependency versions
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAwaitForeachTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAwaitForeachTests.cs
index baf85196a56ef..5c0f881569023 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAwaitForeachTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAwaitForeachTests.cs
@@ -6161,7 +6161,7 @@ public static async IAsyncEnumerator<int> GetAsyncEnumerator(this Range range)
                 options: TestOptions.DebugExe,
                 parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics();
-            CompileAndVerify(comp, expectedOutput: "123");
+            CompileAndVerify(comp, expectedOutput: "123", verify: Verification.FailsILVerify);
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDeconstructTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDeconstructTests.cs
index 2fb646126d46b..b465d43b10ca1 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDeconstructTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDeconstructTests.cs
@@ -7614,7 +7614,7 @@ static void Main()
         }
 
         [Fact]
-        void InvokeVarForLvalueInParens()
+        public void InvokeVarForLvalueInParens()
         {
             var source = @"
 class Program
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDynamicTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDynamicTests.cs
index ddc6a79b2f120..9b17e3e838e61 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDynamicTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenDynamicTests.cs
@@ -9603,7 +9603,7 @@ .locals init (int V_0, //a
   IL_0066:  callvirt   ""void <>A{00000004}<System.Runtime.CompilerServices.CallSite, int, object>.Invoke(System.Runtime.CompilerServices.CallSite, ref int, object)""
   IL_006b:  ret
 }
-");
+", verify: Verification.FailsILVerify); // ILVerify doesn't support TypedReference
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenExprLambdaTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenExprLambdaTests.cs
index 5769b9b9b15c8..5c5fe23f13644 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenExprLambdaTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenExprLambdaTests.cs
@@ -3117,9 +3117,10 @@ public static void Main()
     }
 }";
 
+            // PEVerify: [ : Test::Main][mdToken=0x6000001][offset 0x00000009][found Native Int][expected unmanaged pointer] Unexpected type on the stack.
             var c = CompileAndVerifyUtil(text,
                 options: TestOptions.UnsafeReleaseDll,
-                verify: Verification.Fails);
+                verify: Verification.FailsPEVerify);
 
             c.VerifyDiagnostics();
         }
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenForEachTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenForEachTests.cs
index 4ebd2028fb9b0..7d6b40bc72af5 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenForEachTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenForEachTests.cs
@@ -1384,7 +1384,8 @@ ref struct DisposableEnumerator
     public bool MoveNext() { return ++x < 4; }
     public void Dispose() { System.Console.WriteLine(""Done with DisposableEnumerator""); }
 }";
-            var compilation = CompileAndVerify(source, expectedOutput: @"
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            var compilation = CompileAndVerify(source, verify: Verification.FailsILVerify, expectedOutput: @"
 1
 2
 3
@@ -1447,7 +1448,8 @@ ref struct DisposableEnumerator
     public bool MoveNext() { return ++x < 4; }
     public void Dispose(params object[] args) { System.Console.WriteLine($""Done with DisposableEnumerator. args was {args}, length {args.Length}""); }
 }";
-            var compilation = CompileAndVerify(source, expectedOutput: @"
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            var compilation = CompileAndVerify(source, verify: Verification.FailsILVerify, expectedOutput: @"
 1
 2
 3
@@ -1481,7 +1483,8 @@ ref struct DisposableEnumerator
     public bool MoveNext() { return ++x < 4; }
     public void Dispose(int arg = 1) { System.Console.WriteLine($""Done with DisposableEnumerator. arg was {arg}""); }
 }";
-            var compilation = CompileAndVerify(source, expectedOutput: @"
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            var compilation = CompileAndVerify(source, verify: Verification.FailsILVerify, expectedOutput: @"
 1
 2
 3
@@ -1521,7 +1524,8 @@ static class DisposeExtension
 }
 ";
             // extension methods do not contribute to disposal
-            CompileAndVerify(source, expectedOutput: @"123");
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            CompileAndVerify(source, verify: Verification.FailsILVerify, expectedOutput: @"123");
         }
 
         [Fact]
@@ -1561,7 +1565,8 @@ static class DisposeExtension2
 }
 ";
             // extension methods do not contribute to disposal
-            CompileAndVerify(source, expectedOutput: @"123");
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            CompileAndVerify(source, verify: Verification.FailsILVerify, expectedOutput: @"123");
         }
 
         [Fact]
@@ -1597,7 +1602,8 @@ static class DisposeExtension
 }
 ";
             // extension methods do not contribute to disposal
-            CompileAndVerify(source, expectedOutput: @"123");
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            CompileAndVerify(source, verify: Verification.FailsILVerify, expectedOutput: @"123");
         }
 
         [Fact]
@@ -1633,7 +1639,8 @@ static class DisposeExtension
 }
 ";
             // extension methods do not contribute to disposal
-            CompileAndVerify(source, expectedOutput: @"123");
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            CompileAndVerify(source, verify: Verification.FailsILVerify, expectedOutput: @"123");
         }
 
         [Fact]
@@ -1729,7 +1736,8 @@ ref struct DisposableEnumerator
     public bool MoveNext() { return ++x < 4; }
     public void Dispose() { System.Console.WriteLine(""Done with DisposableEnumerator""); }
 }";
-            var compilation = CompileAndVerify(source, parseOptions: TestOptions.Regular7_3, expectedOutput: @"
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            var compilation = CompileAndVerify(source, parseOptions: TestOptions.Regular7_3, verify: Verification.FailsILVerify, expectedOutput: @"
 1
 2
 3");
@@ -4725,7 +4733,8 @@ ref struct Enumerator
     public bool MoveNext() => Current++ != 3;
     public void Dispose() { Console.Write(""Disposed""); }
 }";
-            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: @"123Disposed")
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, verify: Verification.FailsILVerify, expectedOutput: @"123Disposed")
                 .VerifyIL("C.Main", @"
 {
   // Code size       45 (0x2d)
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenInParametersTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenInParametersTests.cs
index 45924d6644e79..dd613b96384d8 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenInParametersTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenInParametersTests.cs
@@ -3982,7 +3982,8 @@ private void Test2(in int y, ref int f)
 
             var compilation = CreateCompilation(code, options: TestOptions.ReleaseExe);
 
-            var verifier = CompileAndVerify(compilation, expectedOutput: "0011", verify: Verification.Fails);
+            // PEVerify: Cannot change initonly field outside its .ctor.
+            var verifier = CompileAndVerify(compilation, expectedOutput: "0011", verify: Verification.FailsPEVerify);
 
             verifier.VerifyIL("Test..ctor()", @"
 {
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenIncrementTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenIncrementTests.cs
index e8db263011cda..2bf3cc671acbd 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenIncrementTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenIncrementTests.cs
@@ -7,6 +7,7 @@
 using System;
 using System.Globalization;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
 
@@ -1033,7 +1034,7 @@ public static void Main()
     }
 }
 ";
-            base.CompileAndVerify(source, expectedOutput: "12").
+            base.CompileAndVerify(source, verify: Verification.FailsILVerify, expectedOutput: "12").
                 VerifyIL("Test.Main",
 @"
 {
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenIterators.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenIterators.cs
index 5b00142ccda9c..ffae592642cbb 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenIterators.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenIterators.cs
@@ -2387,7 +2387,8 @@ public System.Collections.IEnumerable SomeNumbers()
 }";
             // The compilation succeeds even though CompilerGeneratedAttribute and DebuggerNonUserCodeAttribute are not available.
             var compilation = CreateEmptyCompilation(new[] { Parse(source), Parse(corlib) });
-            var verifier = CompileAndVerify(compilation, verify: Verification.Fails);
+            // PEVerify: System.Enum must extend System.ValueType.
+            var verifier = CompileAndVerify(compilation, verify: Verification.FailsPEVerify);
             verifier.VerifyDiagnostics(
                 // warning CS8021: No value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options.
                 Diagnostic(ErrorCode.WRN_NoRuntimeMetadataVersion).WithLocation(1, 1));
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenMscorlib.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenMscorlib.cs
index e84776630d9aa..2ebf0906ce15c 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenMscorlib.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenMscorlib.cs
@@ -744,6 +744,12 @@ void Main()
             //IMPORTANT: we should NOT delegate E1.GetHashCode() to int.GetHashCode()
             //           it is entirely possible that Enum.GetHashCode and int.GetHashCode 
             //           have different implementations
+
+            // PEVerify:
+            // Error: Token 0x02000009 following ELEMENT_TYPE_CLASS (_VALUETYPE) in signature is a ValueType (Class,respectively).
+            // Error: Token 0x02000009 following ELEMENT_TYPE_CLASS(_VALUETYPE) in signature is a ValueType (Class, respectively).
+            // Type load failed.
+            // ILVerify: Failed to load type 'System.String' from assembly ... 
             CompileAndVerify(comp, verify: Verification.Fails).
                 VerifyIL("program.Main()",
 @"
@@ -871,6 +877,8 @@ void Main()
             //           but see the bug see VSW #396011, JIT needs references when loading
             //           fields of certain clr-ambiguous structs (only possible when building mscorlib)
 
+            // PEVerify: Type load failed.
+            // ILVerify: Failed to load type 'System.String' from assembly ... 
             CompileAndVerify(comp, verify: Verification.Fails).
                 VerifyIL("System.IntPtr..ctor(int)", @"
 {
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenOverridingAndHiding.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenOverridingAndHiding.cs
index 2a4e0a2776d79..985e7a6f2ccf5 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenOverridingAndHiding.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenOverridingAndHiding.cs
@@ -2557,7 +2557,7 @@ public static void Main()
             // from assembly 'Dev10, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'
             // is overriding a method that is not visible from that assembly.
 
-            CompileAndVerify(outerCompilation, verify: Verification.Fails).VerifyIL("Test.Main", @"
+            CompileAndVerify(outerCompilation, verify: Verification.FailsPEVerify).VerifyIL("Test.Main", @"
 {
   // Code size       65 (0x41)
   .maxstack  4
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadonlyStructTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadonlyStructTests.cs
index 11765060fecc6..179cdbc13fb3a 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadonlyStructTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenReadonlyStructTests.cs
@@ -185,7 +185,7 @@ public override string ToString()
 }
 ";
 
-            var comp = CompileAndVerify(text, parseOptions: TestOptions.Regular, verify: Verification.Fails, expectedOutput: @"12");
+            var comp = CompileAndVerify(text, parseOptions: TestOptions.Regular, verify: Verification.FailsPEVerify, expectedOutput: @"12");
 
             comp.VerifyIL("Program.Main", @"
 {
@@ -258,7 +258,8 @@ public override string ToString()
 }
 ";
 
-            var comp = CompileAndVerify(text, parseOptions: TestOptions.Regular, verify: Verification.Fails, expectedOutput: @"hello2");
+            // PEVerify: Cannot change initonly field outside its .ctor.
+            var comp = CompileAndVerify(text, parseOptions: TestOptions.Regular, verify: Verification.FailsPEVerify, expectedOutput: @"hello2");
 
             comp.VerifyIL("Program.Main", @"
 {
@@ -338,7 +339,8 @@ static void Main()
 }
 ";
 
-            var comp = CompileAndVerify(text, new[] { ref1 }, parseOptions: TestOptions.Regular, verify: Verification.Fails, expectedOutput: @"hello2");
+            // PEVerify: Cannot change initonly field outside its .ctor.
+            var comp = CompileAndVerify(text, new[] { ref1 }, parseOptions: TestOptions.Regular, verify: Verification.FailsPEVerify, expectedOutput: @"hello2");
 
             comp.VerifyIL("Program.Main", @"
 {
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenRefConditionalOperatorTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenRefConditionalOperatorTests.cs
index 2c8ebf7061d4a..92b6ac0126c69 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenRefConditionalOperatorTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenRefConditionalOperatorTests.cs
@@ -1060,7 +1060,8 @@ public static void RoExtension(in this S1 self)
     }
 ";
 
-            var comp = CompileAndVerifyWithMscorlib40(source, references: new[] { TestMetadata.Net40.System, ValueTupleRef, TestMetadata.Net40.SystemCore }, expectedOutput: "00", verify: Verification.Fails);
+            // PEVerify: Cannot change initonly field outside its .ctor.
+            var comp = CompileAndVerifyWithMscorlib40(source, references: new[] { TestMetadata.Net40.System, ValueTupleRef, TestMetadata.Net40.SystemCore }, expectedOutput: "00", verify: Verification.FailsPEVerify);
             comp.VerifyDiagnostics();
 
             comp.VerifyIL("Program.Main", @"
@@ -1147,8 +1148,8 @@ public override string ToString()
         }
     }
 ";
-
-            var comp = CompileAndVerify(source, expectedOutput: "00", verify: Verification.Fails);
+            // PEVerify: Cannot change initonly field outside its .ctor.
+            var comp = CompileAndVerify(source, expectedOutput: "00", verify: Verification.FailsPEVerify);
             comp.VerifyDiagnostics();
 
             comp.VerifyIL("Program.Test", @"
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenScriptTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenScriptTests.cs
index cee3c4346e82d..27a58c250f995 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenScriptTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenScriptTests.cs
@@ -554,7 +554,7 @@ public void SubmissionEntryPoint()
                 "s0.dll",
                 SyntaxFactory.ParseSyntaxTree(source0, options: TestOptions.Script),
                 references);
-            var verifier = CompileAndVerify(s0, verify: Verification.Fails);
+            var verifier = CompileAndVerify(s0, verify: Verification.FailsPEVerify);
             var methodData = verifier.TestData.GetMethodData("<Initialize>");
             Assert.Equal("System.Threading.Tasks.Task<object>", ((MethodSymbol)methodData.Method).ReturnType.ToDisplayString());
             methodData.VerifyIL(
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenShortCircuitOperatorTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenShortCircuitOperatorTests.cs
index e2fedf4e12ac4..5a37f18a486d1 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenShortCircuitOperatorTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenShortCircuitOperatorTests.cs
@@ -5233,7 +5233,8 @@ public RefLike M()
     public ref struct RefLike{}
 }
 ";
-            var verifier = CompileAndVerify(source, options: TestOptions.DebugExe.WithAllowUnsafe(true), expectedOutput: @"---
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            var verifier = CompileAndVerify(source, verify: Verification.FailsILVerify, options: TestOptions.DebugExe.WithAllowUnsafe(true), expectedOutput: @"---
 M
 ---
 ---");
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStackAllocInitializerTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStackAllocInitializerTests.cs
index 418c3a0778b2b..24ca4f31d8f1c 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStackAllocInitializerTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStackAllocInitializerTests.cs
@@ -488,10 +488,11 @@ static void Main()
     }
 }
 ";
+            // PEVerify: [ : C::Main][mdToken=0x6000002][offset 0x00000002][found Native Int][expected unmanaged pointer] Unexpected type on the stack.
             CompileAndVerify(text,
                 parseOptions: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_3),
                 options: TestOptions.UnsafeReleaseExe,
-                verify: Verification.Fails).VerifyIL("C.Main",
+                verify: Verification.FailsPEVerify).VerifyIL("C.Main",
 @"{
   // Code size        8 (0x8)
   .maxstack  1
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStructsAndEnum.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStructsAndEnum.cs
index ae686f82fbf74..de064bf35c7ba 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStructsAndEnum.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenStructsAndEnum.cs
@@ -259,7 +259,8 @@ static void Main(string[] args)
     }
 }
 ";
-            var compilation = CompileAndVerify(source, expectedOutput: @"");
+            // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of '[...]S1', Expected = address of '[...]S1' }
+            var compilation = CompileAndVerify(source, verify: Verification.FailsILVerify, expectedOutput: @"");
 
             compilation.VerifyIL("S1.Equals(object)",
 @"
@@ -448,7 +449,8 @@ static void Main()
     }
 }
 ";
-            var compilation = CompileAndVerify(source, expectedOutput: @"
+            // ILVerify: Unexpected type on the stack. { Offset = 31, Found = readonly address of '[...]NS.N2.S`2<string,uint8>', Expected = address of '[...]NS.N2.S`2<string,uint8>' }
+            var compilation = CompileAndVerify(source, verify: Verification.FailsILVerify, expectedOutput: @"
 Abc
 255
 q");
@@ -2365,8 +2367,8 @@ static void Main(string[] args)
     }
 
 ";
-
-            var compilation = CompileAndVerify(source, expectedOutput: "0");
+            // ILVerify: Unexpected type on the stack. { Offset = 10, Found = readonly address of '[...]C1', Expected = address of '[...]C1' }
+            var compilation = CompileAndVerify(source, verify: Verification.FailsILVerify, expectedOutput: "0");
 
             compilation.VerifyIL("Program.Main",
 @"
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs
index fe49890a36633..e6b1ef80892f5 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs
@@ -77,7 +77,8 @@ static void Main(object[] args)
         Console.WriteLine((((DoubleAndStruct)args[0]).y).x);
     }
 }";
-            var result = CompileAndVerify(source, options: TestOptions.DebugDll);
+            // ILVerify: Unexpected type on the stack. { Offset = 59, Found = readonly address of '[...]DoubleAndStruct', Expected = address of '[...]DoubleAndStruct' }
+            var result = CompileAndVerify(source, verify: Verification.FailsILVerify, options: TestOptions.DebugDll);
 
             result.VerifyIL("Program.Main(object[])",
 @"
@@ -164,7 +165,8 @@ static void Main(object[] args)
         Console.WriteLine(((((OuterStruct)args[0]).z).y).x);
     }
 }";
-            var result = CompileAndVerify(source, options: TestOptions.DebugDll);
+            // ILVerify: Unexpected type on the stack. { Offset = 34, Found = readonly address of '[...]OuterStruct', Expected = address of '[...]OuterStruct' }
+            var result = CompileAndVerify(source, verify: Verification.FailsILVerify, options: TestOptions.DebugDll);
 
             result.VerifyIL("Program.Main(object[])",
 @"
@@ -4359,7 +4361,7 @@ public static void M<T>()
         Callee3<T>(default(T), default(T));
     }
 }
-", verify: Verification.Fails, options: TestOptions.ReleaseExe);
+", verify: Verification.FailsPEVerify, options: TestOptions.ReleaseExe);
             verifier.VerifyIL("Program.M<T>()",
 @"{
   // Code size      297 (0x129)
@@ -4492,7 +4494,7 @@ public static void M<T>()
         Callee3<string>();
     }
 }
-", verify: Verification.Fails, options: TestOptions.ReleaseExe);
+", verify: Verification.FailsPEVerify, options: TestOptions.ReleaseExe);
             verifier.VerifyIL("Program.M<T>()",
 @"{
   // Code size       34 (0x22)
@@ -5259,6 +5261,12 @@ static void Test<T>(in T r)
         }
     }";
 
+            // PEVerify:
+            // [ : Program::GetElementRef[T]][mdToken=0x6000004][offset 0x00000009][found readonly address of ref ][expected address of ref ] Unexpected type on the stack.
+            // [ : Program::GetElementRef[T]][mdToken= 0x6000004][offset 0x00000017][found readonly address of ref ][expected address of ref ] Unexpected type on the stack.
+            // ILVerify:
+            // Unexpected type on the stack. { Offset = 9, Found = readonly address of 'T', Expected = address of 'T' }
+            // Unexpected type on the stack. { Offset = 23, Found = readonly address of 'T', Expected = address of 'T' }
             var compilation = CompileAndVerify(source, expectedOutput: @"hihi", verify: Verification.Fails);
 
             var expectedIL = @"
@@ -10458,7 +10466,7 @@ static void Main()
                 Diagnostic(ErrorCode.WRN_ExternMethodNoImplementation, "Goo").WithArguments("Test.Goo()"));
 
             // NOTE: the resulting IL is unverifiable, but not an error for compat reasons
-            CompileAndVerify(comp, verify: Verification.Fails).VerifyIL("Test.Main",
+            CompileAndVerify(comp, verify: Verification.FailsPEVerify).VerifyIL("Test.Main",
                 @"
 {
   // Code size       11 (0xb)
@@ -12280,7 +12288,8 @@ public MyManagedStruct(int x)
         n.n.num = x;
     }
 }";
-            var comp = CompileAndVerify(source, expectedOutput: @"42", parseOptions: TestOptions.Regular7_2, verify: Verification.Fails);
+            // PEVerify: Cannot change initonly field outside its .ctor.
+            var comp = CompileAndVerify(source, expectedOutput: @"42", parseOptions: TestOptions.Regular7_2, verify: Verification.FailsPEVerify);
 
             comp.VerifyIL("Program.Main",
 @"
@@ -12433,7 +12442,8 @@ public override string ToString()
             return null;
         }
     }";
-            var comp = CompileAndVerify(source, expectedOutput: @"-10", verify: Verification.Fails);
+            // PEVerify: Cannot change initonly field outside its .ctor.
+            var comp = CompileAndVerify(source, expectedOutput: @"-10", verify: Verification.FailsPEVerify);
 
             comp.VerifyIL("Program.Main",
 @"
@@ -13322,7 +13332,6 @@ private void PrintArgList(ArgIterator args)
             }
         }
     }
-
 }
 ";
             var compilation = CompileAndVerify(
@@ -17216,7 +17225,7 @@ static async Task<object> MethodAsync()
 System.Threading.Tasks.Task`1[System.Object]
 Success
 True
-").VerifyDiagnostics();
+", verify: Verification.FailsILVerify).VerifyDiagnostics();
         }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
index 5f384747cd4e3..8aecc95ee2f20 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTupleTest.cs
@@ -21,9 +21,8 @@
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;
-using static TestResources.NetFX.ValueTuple;
 using static Roslyn.Test.Utilities.TestMetadata;
-using System.Runtime.CompilerServices;
+using static TestResources.NetFX.ValueTuple;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.CodeGen
 {
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/DestructorTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/DestructorTests.cs
index 97dafd8064f78..de3165b242819 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/DestructorTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/DestructorTests.cs
@@ -698,7 +698,7 @@ public class B : A
                 Diagnostic(ErrorCode.WRN_FinalizeMethod, "Finalize"));
 
             // We produce unverifiable code here as per bug resolution (compat concerns, not common case).
-            CompileAndVerify(compilation, verify: Verification.Fails).VerifyIL("B.Finalize",
+            CompileAndVerify(compilation, verify: Verification.FailsPEVerify).VerifyIL("B.Finalize",
 
                 @"
 {
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
index 8791b07a346fe..23a68895a0263 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
@@ -4106,8 +4106,10 @@ static void Main()
                 source: new[] { Parse(text) },
                 references: new[] { AacorlibRef });
 
-
-            var verifier = CompileAndVerify(comp, verify: Verification.Fails);
+            // PEVerify:
+            // Error: Assembly name contains leading spaces or path or extension.
+            // Type load failed.
+            var verifier = CompileAndVerify(comp, verify: Verification.FailsPEVerify);
             verifier.VerifyIL("Program.Main", @"
 {
   // Code size      223 (0xdf)
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/UnsafeTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/UnsafeTests.cs
index adf112f0795f9..01018e8121e39 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/UnsafeTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/UnsafeTests.cs
@@ -5812,7 +5812,7 @@ void M(int* pi, void* pv, sbyte sb, byte b, short s, ushort us, int i, uint ui,
     }
 }
 ";
-            CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll, verify: Verification.Fails).VerifyIL("C.M", @"
+            CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll, verify: Verification.FailsPEVerify).VerifyIL("C.M", @"
 {
   // Code size       79 (0x4f)
   .maxstack  1
@@ -5902,7 +5902,7 @@ void M(int* pi, void* pv, sbyte sb, byte b, short s, ushort us, int i, uint ui,
     }
 }
 ";
-            CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll, verify: Verification.Fails).VerifyIL("C.M", @"
+            CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll, verify: Verification.FailsPEVerify).VerifyIL("C.M", @"
 {
   // Code size       79 (0x4f)
   .maxstack  1
@@ -6499,7 +6499,7 @@ static void Main()
     }
 }
 ";
-            CompileAndVerify(text, options: TestOptions.UnsafeReleaseExe, expectedOutput: "1234", verify: Verification.Fails).VerifyIL("C.Main", @"
+            CompileAndVerify(text, options: TestOptions.UnsafeReleaseExe, expectedOutput: "1234", verify: Verification.FailsPEVerify).VerifyIL("C.Main", @"
 {
   // Code size      120 (0x78)
   .maxstack  5
@@ -9784,7 +9784,7 @@ public static implicit operator C(int* p)
     }
 }
 ";
-            CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll, verify: Verification.Fails).VerifyIL("C.M", @"
+            CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll, verify: Verification.FailsPEVerify).VerifyIL("C.M", @"
 {
   // Code size       12 (0xc)
   .maxstack  1
@@ -10146,8 +10146,11 @@ No overflow from (S15*)0 + sizeof(S15)
 No overflow from (S15*)0 + sizeof(S16)
 No overflow from (S16*)0 + sizeof(S15)";
             }
-
-            CompileAndVerify(text, options: TestOptions.UnsafeReleaseExe, expectedOutput: expectedOutput, verify: Verification.Fails);
+            // PEVerify:
+            // [ : C+<>c__DisplayClass0_0::<Main>b__0][mdToken=0x6000005][offset 0x00000012][found Native Int][expected unmanaged pointer] Unexpected type on the stack.
+            // [ : C+<> c__DisplayClass0_0::< Main > b__1][mdToken= 0x6000006][offset 0x00000012][found Native Int][expected unmanaged pointer] Unexpected type on the stack.
+            // [ : C +<> c__DisplayClass0_0::< Main > b__2][mdToken = 0x6000007][offset 0x00000012][found Native Int][expected unmanaged pointer] Unexpected type on the stack.
+            CompileAndVerify(text, options: TestOptions.UnsafeReleaseExe, expectedOutput: expectedOutput, verify: Verification.FailsPEVerify);
         }
 
         [Fact]
@@ -10328,7 +10331,10 @@ public static void Main()
     }
 }
 ";
-            CompileAndVerify(text, options: TestOptions.UnsafeReleaseExe, verify: Verification.Fails).VerifyDiagnostics();
+            // PEVerify:
+            // [ : ChannelServices::.cctor][mdToken=0x6000005][offset 0x0000000C][found unmanaged pointer][expected unmanaged pointer] Unexpected type on the stack.
+            // [ : ChannelServices::GetPrivateContextsPerfCounters][mdToken= 0x6000002][offset 0x00000002][found Native Int][expected unmanaged pointer] Unexpected type on the stack.
+            CompileAndVerify(text, options: TestOptions.UnsafeReleaseExe, verify: Verification.FailsPEVerify).VerifyDiagnostics();
         }
 
         [WorkItem(545026, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545026")]
@@ -10342,7 +10348,9 @@ class C
     unsafe int* p = (int*)2;
 }
 ";
-            CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll, verify: Verification.Fails).VerifyDiagnostics(
+            // PEVerify:
+            // [ : C::.ctor][mdToken=0x6000001][offset 0x0000000A][found Native Int][expected unmanaged pointer] Unexpected type on the stack.
+            CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll, verify: Verification.FailsPEVerify).VerifyDiagnostics(
                 // (4,9): warning CS0414: The field 'C.x' is assigned but its value is never used
                 //     int x = 1;
                 Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "x").WithArguments("C.x"));
@@ -10359,7 +10367,9 @@ class C
     int x = 1;
 }
 ";
-            CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll, verify: Verification.Fails).VerifyDiagnostics(
+            // PEVerify:
+            // [ : C::.ctor][mdToken=0x6000001][offset 0x00000003][found Native Int][expected unmanaged pointer] Unexpected type on the stack.
+            CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll, verify: Verification.FailsPEVerify).VerifyDiagnostics(
                 // (5,9): warning CS0414: The field 'C.x' is assigned but its value is never used
                 //     int x = 1;
                 Diagnostic(ErrorCode.WRN_UnreferencedFieldAssg, "x").WithArguments("C.x"));
@@ -10844,7 +10854,7 @@ unsafe struct S1
 
 ";
 
-            var verifier = CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll.WithConcurrentBuild(false), verify: Verification.Fails);
+            var verifier = CompileAndVerify(text, options: TestOptions.UnsafeReleaseDll.WithConcurrentBuild(false), verify: Verification.FailsPEVerify);
         }
 
         [Fact, WorkItem(748530, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/748530")]
@@ -11360,7 +11370,10 @@ public static unsafe int Test(params int*[] types)
        return types.Length;
    }
 }";
-            var comp = CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, expectedOutput: "0", verify: Verification.Fails);
+            // PEVerify:
+            // [ : Program::Main][mdToken= 0x6000001][offset 0x00000001] Unmanaged pointers are not a verifiable type.
+            // [ : Program::Main][mdToken = 0x6000001][offset 0x00000001] Unable to resolve token.
+            var comp = CompileAndVerify(source, options: TestOptions.UnsafeReleaseExe, expectedOutput: "0", verify: Verification.FailsPEVerify);
             comp.VerifyIL("Program.Main", @"
 {
   // Code size       17 (0x11)
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
index 58eda81e723ad..8ef70a205e535 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/CompilationEmitTests.cs
@@ -5027,6 +5027,8 @@ public void Bug769741()
         {
             var comp = CreateEmptyCompilation("", new[] { TestReferences.SymbolsTests.netModule.x64COFF }, options: TestOptions.DebugDll);
             // modules not supported in ref emit
+            // PEVerify: [HRESULT 0x8007000B] - An attempt was made to load a program with an incorrect format.
+            // ILVerify: Internal.IL.VerifierException : No system module specified
             CompileAndVerify(comp, verify: Verification.Fails);
             Assert.NotSame(comp.Assembly.CorLibrary, comp.Assembly);
             comp.GetSpecialType(SpecialType.System_Int32);
@@ -5532,7 +5534,8 @@ public void CompileAndVerifyModuleIncludesAllModules()
             var modRef = CreateCompilation("public class A { }", options: TestOptions.ReleaseModule, assemblyName: "refMod").EmitToImageReference();
             var comp = CreateCompilation("public class B : A { }", references: new[] { modRef }, assemblyName: "sourceMod");
 
-            CompileAndVerify(comp, symbolValidator: module =>
+            // ILVerify: Assembly or module not found: refMod
+            CompileAndVerify(comp, verify: Verification.FailsILVerify, symbolValidator: module =>
             {
                 var b = module.GlobalNamespace.GetTypeMember("B");
                 Assert.Equal("B", b.Name);
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.cs
index 068ba6382dc68..3bba6ef768d64 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.cs
@@ -481,7 +481,8 @@ class C
             var compilation0 = CreateEmptyCompilation(src0, new[] { MscorlibRef, ref01, ref11 }, assemblyName: "C", options: TestOptions.DebugDll);
             var compilation1 = compilation0.WithSource(src1).WithReferences(new[] { MscorlibRef, ref02, ref12 });
 
-            var v0 = CompileAndVerify(compilation0);
+            // ILVerify: Multiple modules named 'Lib' were found
+            var v0 = CompileAndVerify(compilation0, verify: Verification.FailsILVerify);
 
             var f0 = compilation0.GetMember<MethodSymbol>("C.F");
             var f1 = compilation1.GetMember<MethodSymbol>("C.F");
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.cs
index 60340749e9788..4db804c90174b 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.cs
@@ -5107,7 +5107,7 @@ public async Task<int> F()
             Assert.Null(compilation0.GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_AsyncStateMachineAttribute__ctor));
             Assert.Null(compilation0.GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_IteratorStateMachineAttribute__ctor));
 
-            var v0 = CompileAndVerify(compilation0, verify: Verification.Fails);
+            var v0 = CompileAndVerify(compilation0, verify: Verification.FailsPEVerify);
             var md0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
 
             var f0 = compilation0.GetMember<MethodSymbol>("C.F");
@@ -5166,7 +5166,7 @@ public async Task<int> F()
             // older versions of mscorlib don't contain IteratorStateMachineAttribute
             Assert.Null(compilation0.GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_AsyncStateMachineAttribute__ctor));
 
-            var v0 = CompileAndVerify(compilation0, verify: Verification.Fails);
+            var v0 = CompileAndVerify(compilation0, verify: Verification.FailsPEVerify);
             v0.VerifyDiagnostics();
             var md0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
 
@@ -5230,7 +5230,7 @@ public async Task<int> F()
 
             Assert.NotNull(compilation0.GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_AsyncStateMachineAttribute__ctor));
 
-            var v0 = CompileAndVerify(compilation0, verify: Verification.Fails);
+            var v0 = CompileAndVerify(compilation0, verify: Verification.FailsPEVerify);
             v0.VerifyDiagnostics();
             var md0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
 
@@ -5331,7 +5331,7 @@ public async Task<int> F()
 
             Assert.Null(compilation0.GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_AsyncStateMachineAttribute__ctor));
 
-            var v0 = CompileAndVerify(compilation0, verify: Verification.Fails);
+            var v0 = CompileAndVerify(compilation0, verify: Verification.FailsPEVerify);
             var md0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData);
 
             var f0 = compilation0.GetMember<MethodSymbol>("C.F");
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EmitCustomModifiers.cs b/src/Compilers/CSharp/Test/Emit/Emit/EmitCustomModifiers.cs
index 57b74980239f0..a005d98afe66b 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EmitCustomModifiers.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EmitCustomModifiers.cs
@@ -705,7 +705,7 @@ static void Main()
 }";
             var compilation = CreateCompilationWithILAndMscorlib40(source, ilSource, options: TestOptions.UnsafeReleaseExe);
             compilation.VerifyDiagnostics();
-            CompileAndVerify(compilation, verify: Verification.Fails);
+            CompileAndVerify(compilation, verify: Verification.FailsPEVerify);
         }
 
         [Fact]
@@ -739,7 +739,7 @@ static void Main()
 }";
             var compilation = CreateCompilationWithILAndMscorlib40(source, ilSource, options: TestOptions.UnsafeReleaseExe);
             compilation.VerifyDiagnostics();
-            CompileAndVerify(compilation, verify: Verification.Fails);
+            CompileAndVerify(compilation, verify: Verification.FailsPEVerify);
         }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EmitErrorTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EmitErrorTests.cs
index 3a559fcdc2531..aa1f4128b5f91 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EmitErrorTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EmitErrorTests.cs
@@ -110,6 +110,8 @@ public static void Main()
     }
 }
 ";
+            // ILVerify null ref
+            // Tracked by https://github.com/dotnet/roslyn/issues/58652
             var compilation2 = CompileAndVerify(
                 source2,
                 new[] { new CSharpCompilationReference(compilation1) },
@@ -142,6 +144,8 @@ public static void Main()
     }
 }
 ";
+            // ILVerify null ref
+            // Tracked by https://github.com/dotnet/roslyn/issues/58652
             var compilation2 = CompileAndVerify(
                 source2,
                 new[] { new CSharpCompilationReference(compilation1) },
@@ -179,6 +183,8 @@ public static void Main()
 }
 ";
 
+            // ILVerify null ref
+            // Tracked by https://github.com/dotnet/roslyn/issues/58652
             var compilation2 = CompileAndVerify(
                 source2,
                 new[] { new CSharpCompilationReference(compilation1) },
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EmitMetadataTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EmitMetadataTests.cs
index 9800cc0faa0d2..2e90f86ad4ce2 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EmitMetadataTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EmitMetadataTests.cs
@@ -206,7 +206,7 @@ public class Test : Class2
 {
 }
 ";
-            CompileAndVerifyWithMscorlib40(sources, new[] { TestReferences.SymbolsTests.MultiModule.Assembly }, assemblyValidator: (assembly) =>
+            CompileAndVerifyWithMscorlib40(sources, new[] { TestReferences.SymbolsTests.MultiModule.Assembly }, verify: Verification.FailsILVerify, assemblyValidator: (assembly) =>
             {
                 var refs2 = assembly.Modules[0].ReferencedAssemblies.Select(r => r.Name);
                 Assert.Equal(2, refs2.Count());
@@ -242,7 +242,8 @@ public class Test : Class1
 }
 ";
             // modules not supported in ref emit
-            CompileAndVerify(source, new[] { netModule1, netModule2 }, assemblyValidator: (assembly) =>
+            // ILVerify: Assembly or module not found: netModule1
+            CompileAndVerify(source, new[] { netModule1, netModule2 }, verify: Verification.FailsILVerify, assemblyValidator: (assembly) =>
             {
                 Assert.Equal(3, assembly.Modules.Length);
 
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/NoPiaEmbedTypes.cs b/src/Compilers/CSharp/Test/Emit/Emit/NoPiaEmbedTypes.cs
index 542afad36bf62..a9b901390c2ec 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/NoPiaEmbedTypes.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/NoPiaEmbedTypes.cs
@@ -1779,9 +1779,9 @@ interface UsePia5 : ITest29
                     Assert.Equal(VarianceKind.None, t7.Variance);
                 };
 
-            CompileAndVerify(compilation1, symbolValidator: metadataValidator, verify: Verification.Fails);
+            CompileAndVerify(compilation1, symbolValidator: metadataValidator, verify: Verification.FailsPEVerify);
 
-            CompileAndVerify(compilation2, symbolValidator: metadataValidator, verify: Verification.Fails);
+            CompileAndVerify(compilation2, symbolValidator: metadataValidator, verify: Verification.FailsPEVerify);
         }
 
         [Fact]
@@ -4708,11 +4708,11 @@ public void M1()
 
             var compilation3 = CreateCompilation(consumer, options: TestOptions.DebugExe,
                 references: new MetadataReference[] { new CSharpCompilationReference(piaCompilation2) });
-            CompileAndVerify(compilation3, verify: Verification.Fails);
+            CompileAndVerify(compilation3, verify: Verification.FailsPEVerify);
 
             var compilation4 = CreateCompilation(consumer, options: TestOptions.DebugExe,
                 references: new MetadataReference[] { MetadataReference.CreateFromStream(piaCompilation2.EmitToStream()) });
-            CompileAndVerify(compilation4, verify: Verification.Fails);
+            CompileAndVerify(compilation4, verify: Verification.FailsPEVerify);
         }
 
         [Fact]
@@ -5185,11 +5185,11 @@ public void M1()
 
             var compilation3 = CreateCompilation(consumer, options: TestOptions.DebugExe,
                 references: new MetadataReference[] { new CSharpCompilationReference(piaCompilation2) });
-            CompileAndVerify(compilation3, verify: Verification.Fails);
+            CompileAndVerify(compilation3, verify: Verification.FailsPEVerify);
 
             var compilation4 = CreateCompilation(consumer, options: TestOptions.DebugExe,
                 references: new MetadataReference[] { MetadataReference.CreateFromStream(piaCompilation2.EmitToStream()) });
-            CompileAndVerify(compilation4, verify: Verification.Fails);
+            CompileAndVerify(compilation4, verify: Verification.FailsPEVerify);
         }
 
         [ConditionalFact(typeof(ClrOnly), Reason = ConditionalSkipReason.NoPiaNeedsDesktop)]
diff --git a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Assembly.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Assembly.cs
index fd168d2486b92..e7a3b0e0ddf60 100644
--- a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Assembly.cs
+++ b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Assembly.cs
@@ -22,8 +22,6 @@ namespace Microsoft.CodeAnalysis.CSharp.UnitTests
 {
     public class AssemblyAttributeTests : CSharpTestBase
     {
-        private readonly string _netModuleName = GetUniqueName() + ".netmodule";
-
         [Fact]
         public void VersionAttribute()
         {
@@ -300,7 +298,9 @@ public void MismatchedSurrogateInAssemblyCultureAttribute()
             string s = @"[assembly: System.Reflection.AssemblyCultureAttribute(""\uD800"")]";
             var comp = CreateCompilation(s, options: TestOptions.ReleaseDll);
 
-            CompileAndVerify(comp, verify: Verification.Fails, symbolValidator: m =>
+            // PEVerify:
+            // Warning: Invalid locale string.
+            CompileAndVerify(comp, verify: Verification.FailsPEVerify, symbolValidator: m =>
             {
                 var utf8 = new System.Text.UTF8Encoding(false, false);
                 Assert.Equal(utf8.GetString(utf8.GetBytes("\uD800")), m.ContainingAssembly.Identity.CultureName);
@@ -543,7 +543,9 @@ void M(Test x) {}
 }
 ", options: TestOptions.ReleaseDll, references: new[] { hash_module });
 
+            // ILVerify: Assembly or module not found: hash_module
             CompileAndVerify(compilation,
+                verify: Verification.FailsILVerify,
                 manifestResources: hash_resources,
                 validator: (peAssembly) =>
                 {
@@ -572,7 +574,9 @@ void M(Test x) {}
 }
 ", options: TestOptions.ReleaseDll, references: new[] { hash_module });
 
+            // ILVerify: Assembly or module not found: hash_module
             CompileAndVerify(compilation,
+                verify: Verification.FailsILVerify,
                 manifestResources: hash_resources,
                 validator: (peAssembly) =>
                 {
@@ -602,6 +606,7 @@ void M(Test x) {}
 ", options: TestOptions.ReleaseDll, references: new[] { hash_module });
 
             CompileAndVerify(compilation,
+                verify: Verification.FailsILVerify,
                 manifestResources: hash_resources,
                 validator: (peAssembly) =>
                 {
@@ -631,6 +636,7 @@ void M(Test x) {}
 ", options: TestOptions.ReleaseDll, references: new[] { hash_module });
 
             CompileAndVerify(compilation,
+                verify: Verification.FailsILVerify,
                 manifestResources: hash_resources,
                 validator: (peAssembly) =>
                 {
@@ -761,6 +767,7 @@ void M(Test x) {}
 ", options: TestOptions.ReleaseDll, references: new[] { hash_module_Comp.EmitToImageReference() });
 
             CompileAndVerify(compilation,
+                verify: Verification.FailsILVerify,
                 validator: (peAssembly) =>
                 {
                     var peReader = peAssembly.ManifestModule.GetMetadataReader();
diff --git a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Dynamic.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Dynamic.cs
index ceb4255b1e26f..f77709947667b 100644
--- a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Dynamic.cs
+++ b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Dynamic.cs
@@ -1155,6 +1155,8 @@ static void Main()
             comp = CreateEmptyCompilation(source1, references: new[] { ref0, SystemCoreRef });
             comp.VerifyDiagnostics();
             // Make sure we emit without errors when System.Boolean is missing.
+            // PEVerify: Type load failed.
+            // ILVerify: Failed to load type 'System.String' from assembly ...
             CompileAndVerify(comp, verify: Verification.Fails);
         }
 
@@ -1189,6 +1191,8 @@ static void Main()
             comp = CreateEmptyCompilation(source1, references: new[] { ref0, SystemCoreRef });
             comp.VerifyDiagnostics();
             // Make sure we emit without errors when System.Boolean is missing.
+            // PEVerify: Type load failed.
+            // ILVerify: Internal.TypeSystem.TypeSystemException+TypeLoadException : Failed to load type 'System.String' from assembly ...
             CompileAndVerify(comp, verify: Verification.Fails);
         }
 
diff --git a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_IsByRefLike.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_IsByRefLike.cs
index d020c19a854ae..6cf7d507d903d 100644
--- a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_IsByRefLike.cs
+++ b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_IsByRefLike.cs
@@ -957,7 +957,8 @@ public ref struct NotTypedReference { }
 }";
             var compilation1 = CreateEmptyCompilation(source1, assemblyName: GetUniqueName());
 
-            CompileAndVerify(compilation1, verify: Verification.Fails, symbolValidator: module =>
+            // PEVerify: Type load failed.
+            CompileAndVerify(compilation1, verify: Verification.FailsPEVerify, symbolValidator: module =>
             {
                 var type = module.ContainingAssembly.GetTypeByMetadataName("System.TypedReference");
                 AssertReferencedIsByRefLike(type, hasObsolete: false);
diff --git a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_ReadOnlyStruct.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_ReadOnlyStruct.cs
index 159326acfd8e6..2a148fe1f4794 100644
--- a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_ReadOnlyStruct.cs
+++ b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_ReadOnlyStruct.cs
@@ -427,6 +427,8 @@ public class Test
     public readonly struct S1{}
 }";
 
+            // PEVerify: The module  was expected to contain an assembly manifest.
+            // ILVerify: The format of a DLL or executable being loaded is invalid
             CompileAndVerify(code, verify: Verification.Fails, references: new[] { reference }, options: TestOptions.ReleaseModule, symbolValidator: module =>
             {
                 var type = module.ContainingAssembly.GetTypeByMetadataName("Test").GetTypeMember("S1");
diff --git a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_StructLayout.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_StructLayout.cs
index a064579a50c2e..b4f3391d0c35a 100644
--- a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_StructLayout.cs
+++ b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_StructLayout.cs
@@ -215,10 +215,10 @@ class Structs
             };
 
             CompileAndVerify(verifiable, assemblyValidator: validator);
-            CompileAndVerify(unverifiable, assemblyValidator: validator, verify: Verification.Fails);
+            CompileAndVerify(unverifiable, assemblyValidator: validator, verify: Verification.FailsPEVerify);
 
             // CLR limitation on type size, not a RefEmit bug:
-            CompileAndVerify(unloadable, assemblyValidator: validator, verify: Verification.Fails);
+            CompileAndVerify(unloadable, assemblyValidator: validator, verify: Verification.FailsPEVerify);
         }
 
         [Fact]
@@ -336,7 +336,7 @@ public class C : B
 }
 ";
             // type C can't be loaded
-            CompileAndVerify(source, verify: Verification.Fails);
+            CompileAndVerify(source, verify: Verification.FailsPEVerify);
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Synthesized.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Synthesized.cs
index b99215174c3e9..af7b2e03ac0c7 100644
--- a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Synthesized.cs
+++ b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_Synthesized.cs
@@ -954,7 +954,13 @@ public void MissingWellKnownAttributesNoDiagnosticsAndNoSynthesizedAttributes(Ou
             }
             else
             {
-                CompileAndVerify(compilation, verify: outputKind.IsNetModule() ? Verification.Skipped : Verification.Passes, symbolValidator: module =>
+                // ILVerify: Failed to load type 'System.String' from assembly
+                // ILVerify: The format of a DLL or executable being loaded is invalid
+                var verify = outputKind.IsNetModule()
+                    ? Verification.Fails
+                    : Verification.FailsILVerify;
+
+                CompileAndVerify(compilation, verify: verify, symbolValidator: module =>
                 {
                     var assemblyAttributes = module.ContainingAssembly.GetAttributes();
                     Assert.Equal(0, assemblyAttributes.Length);
diff --git a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_WellKnownAttributes.cs b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_WellKnownAttributes.cs
index 4db1f333beb88..8715f52c9b56d 100644
--- a/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_WellKnownAttributes.cs
+++ b/src/Compilers/CSharp/Test/Emit2/Attributes/AttributeTests_WellKnownAttributes.cs
@@ -3606,7 +3606,7 @@ public static int Main ()
 
             // the resulting code does not need to verify
             // This is consistent with Dev10 behavior
-            CompileAndVerify(source, options: TestOptions.ReleaseDll, verify: Verification.Fails, sourceSymbolValidator: sourceValidator, symbolValidator: metadataValidator);
+            CompileAndVerify(source, options: TestOptions.ReleaseDll, verify: Verification.FailsPEVerify, sourceSymbolValidator: sourceValidator, symbolValidator: metadataValidator);
         }
 
         [Fact, WorkItem(544507, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544507")]
@@ -5553,7 +5553,7 @@ public static void Main() {}
             // Dev10 Runtime Exception:
             // Unhandled Exception: System.TypeLoadException: Windows Runtime types can only be declared in Windows Runtime assemblies.
 
-            var verifier = CompileAndVerify(source, sourceSymbolValidator: sourceValidator, symbolValidator: metadataValidator, verify: Verification.Fails, targetFramework: TargetFramework.Mscorlib40);
+            var verifier = CompileAndVerify(source, sourceSymbolValidator: sourceValidator, symbolValidator: metadataValidator, verify: Verification.FailsPEVerify, targetFramework: TargetFramework.Mscorlib40);
         }
 
         #endregion
diff --git a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenMethodGroupConversionCachingTests.cs b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenMethodGroupConversionCachingTests.cs
index 50cc12f67f61a..74c56ba932660 100644
--- a/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenMethodGroupConversionCachingTests.cs
+++ b/src/Compilers/CSharp/Test/Emit2/CodeGen/CodeGenMethodGroupConversionCachingTests.cs
@@ -7,6 +7,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;
 
@@ -146,7 +147,8 @@ static class E
     public static void Target(this C that) { Console.WriteLine(""FAIL""); }
 }
 ";
-        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("C"));
+        // ILVerify: Unrecognized arguments for delegate .ctor. { Offset = 14 }
+        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("C"), verify: Verification.FailsILVerify);
         verifier.VerifyIL("C.Main", @"
 {
   // Code size       37 (0x25)
@@ -188,7 +190,8 @@ static class E
     public static void Target(this C that) { Console.WriteLine(""FAIL""); }
 }
 ";
-        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("C"));
+        // ILVerify: Unrecognized arguments for delegate .ctor. { Offset = 14 }
+        var verifier = CompileAndVerify(source, expectedOutput: PASS, symbolValidator: VerifyNoCacheContainersIn("C"), verify: Verification.FailsILVerify);
         verifier.VerifyIL("C.Main", @"
 {
   // Code size       37 (0x25)
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/ArglistTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/ArglistTests.cs
index 7b23e2a17ae05..80447d7cba237 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/ArglistTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/ArglistTests.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -189,7 +190,7 @@ .locals init (int V_0) //i
   IL_0013:  ret
 }";
 
-            var verifier = CompileAndVerify(source: text, expectedOutput: "System.Int32");
+            var verifier = CompileAndVerify(source: text, expectedOutput: "System.Int32", verify: Verification.FailsILVerify);
             verifier.VerifyIL("C.Main", expectedIL);
         }
 
@@ -357,7 +358,7 @@ .maxstack  1
   IL_0008:  ret
 }";
 
-            var verifier = CompileAndVerify(source: text, expectedOutput: "System.String");
+            var verifier = CompileAndVerify(source: text, expectedOutput: "System.String", verify: Verification.FailsILVerify);
             verifier.VerifyIL("C.M", expectedIL);
         }
 
@@ -672,7 +673,7 @@ .maxstack  2
   IL_000c:  ret
 }";
 
-            var verifier = CompileAndVerify(source: text, expectedOutput: "1123");
+            var verifier = CompileAndVerify(source: text, expectedOutput: "1123", verify: Verification.FailsILVerify);
             verifier.VerifyIL("C.Get", expectedGetIL);
             verifier.VerifyIL("C.Set", expectedSetIL);
             verifier.VerifyIL("C.Ref", expectedRefIL);
@@ -794,7 +795,7 @@ .locals init (int V_0, //x
 42
 333
 0
-42");
+42", verify: Verification.FailsILVerify);
             verifier.VerifyIL("Program.Main", expectedGetIL);
         }
 
@@ -902,7 +903,7 @@ static void Main()
     }
 }";
 
-            var verifier = CompileAndVerify(source: text, expectedOutput: "4242");
+            var verifier = CompileAndVerify(source: text, expectedOutput: "4242", verify: Verification.FailsILVerify);
             verifier.VerifyIL("C.Main", @"
 {
   // Code size       72 (0x48)
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/BetterCandidates.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/BetterCandidates.cs
index 32280b50301e3..48eaebdb8fa49 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/BetterCandidates.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/BetterCandidates.cs
@@ -862,7 +862,8 @@ public class ExtensionAttribute : System.Attribute {}
                 );
             var compilation = CreateCompilationWithBetterCandidates(source, options: TestOptions.ReleaseExe).VerifyDiagnostics(
                 );
-            CompileAndVerify(compilation, expectedOutput: "2");
+            // ILVerify: Unrecognized arguments for delegate .ctor.
+            CompileAndVerify(compilation, verify: Verification.FailsILVerify, expectedOutput: "2");
         }
 
         // Test suggested by @VSadov
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTasklikeMoreTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTasklikeMoreTests.cs
index fbf712806045b..f7a27e78372fa 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTasklikeMoreTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAsyncTasklikeMoreTests.cs
@@ -1587,11 +1587,12 @@ public static void M(MyResult r)
 
             var compilation = CreateCompilation(source, options: TestOptions.ReleaseExe);
             compilation.VerifyDiagnostics();
-            CompileAndVerify(compilation, expectedOutput: "3");
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            CompileAndVerify(compilation, verify: Verification.FailsILVerify, expectedOutput: "3");
 
             compilation = CreateCompilation(source, options: TestOptions.DebugExe);
             compilation.VerifyDiagnostics();
-            CompileAndVerify(compilation, expectedOutput: "3");
+            CompileAndVerify(compilation, verify: Verification.FailsILVerify, expectedOutput: "3");
         }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAwaitTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAwaitTests.cs
index b6d0a3a64f4aa..a975327fa6590 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAwaitTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingAwaitTests.cs
@@ -2836,7 +2836,8 @@ static void Main()
                 // warning CS1685: The predefined type 'ExtensionAttribute' is defined in multiple assemblies in the global alias; using definition from 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
                 Diagnostic(ErrorCode.WRN_MultiplePredefTypes).WithArguments("System.Runtime.CompilerServices.ExtensionAttribute", "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089").WithLocation(1, 1));
 
-            var compiled = CompileAndVerify(comp, expectedOutput: "dynamic42", verify: Verification.Fails);
+            // PEVerify: Cannot change initonly field outside its .ctor.
+            var compiled = CompileAndVerify(comp, expectedOutput: "dynamic42", verify: Verification.FailsPEVerify);
 
             compiled.VerifyIL("MyAwaiter.OnCompleted(System.Action)", @"
 {
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
index b2f4bbe6f5f4b..a8145b8774058 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
@@ -1298,7 +1298,8 @@ static class B
             var comp = CreateCompilation(new[] { source, s_utils }, parseOptions: TestOptions.RegularPreview, options: TestOptions.ReleaseExe);
             if (expectedDiagnostics is null)
             {
-                CompileAndVerify(comp, expectedOutput: $"{expectedMethod}: {expectedType}");
+                // ILVerify: Unrecognized arguments for delegate .ctor.
+                CompileAndVerify(comp, verify: Verification.FailsILVerify, expectedOutput: $"{expectedMethod}: {expectedType}");
             }
             else
             {
@@ -1392,7 +1393,8 @@ static class B
             var comp = CreateCompilation(new[] { source, s_utils }, parseOptions: TestOptions.RegularPreview, options: TestOptions.ReleaseExe);
             if (expectedDiagnostics is null)
             {
-                CompileAndVerify(comp, expectedOutput: $"{expectedMethod}: {expectedType}");
+                // ILVerify: Unrecognized arguments for delegate .ctor.
+                CompileAndVerify(comp, verify: Verification.FailsILVerify, expectedOutput: $"{expectedMethod}: {expectedType}");
             }
             else
             {
@@ -1767,7 +1769,8 @@ static void Main()
     }
 }";
             var comp = CreateCompilation(new[] { source, s_utils }, parseOptions: TestOptions.RegularPreview, options: TestOptions.ReleaseExe);
-            CompileAndVerify(comp, expectedOutput: "System.Action<System.Int32>, System.Action");
+            // ILVerify: Unrecognized arguments for delegate .ctor.
+            CompileAndVerify(comp, verify: Verification.FailsILVerify, expectedOutput: "System.Action<System.Int32>, System.Action");
 
             var tree = comp.SyntaxTrees[0];
             var model = comp.GetSemanticModel(tree);
@@ -7908,7 +7911,8 @@ static class E
             var comp = CreateCompilation(source, options: TestOptions.ReleaseExe);
             comp.VerifyDiagnostics();
 
-            var verifier = CompileAndVerify(comp, expectedOutput: @"(41, 42)");
+            // ILVerify: Unrecognized arguments for delegate .ctor.
+            var verifier = CompileAndVerify(comp, verify: Verification.FailsILVerify, expectedOutput: @"(41, 42)");
             verifier.VerifyIL("Program.M1",
 @"{
   // Code size       20 (0x14)
@@ -8487,12 +8491,13 @@ static void Main()
             var comp = CreateCompilation(source, options: TestOptions.ReleaseExe);
             comp.VerifyDiagnostics();
 
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator. { Offset = 24 }
             CompileAndVerify(comp, expectedOutput:
 @"0
 System.Object
 <>f__AnonymousDelegate0
 <>f__AnonymousDelegate1
-");
+", verify: Verification.FailsILVerify);
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/DynamicTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/DynamicTests.cs
index 05fb0f4f61bbf..5dccf6ed0710e 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/DynamicTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/DynamicTests.cs
@@ -3603,7 +3603,8 @@ unsafe static void Main()
     static T Goo<T>(Action<T, T> x) { throw null; }
 }
 ";
-            var verifier = CompileAndVerify(source, options: TestOptions.DebugDll.WithAllowUnsafe(true), verify: Verification.Fails).VerifyDiagnostics();
+            // PEVerify: [ : Program::Main][mdToken=0x6000001][offset 0x0000002C][found unmanaged pointer][expected unmanaged pointer] Unexpected type on the stack.
+            var verifier = CompileAndVerify(source, options: TestOptions.DebugDll.WithAllowUnsafe(true), verify: Verification.FailsPEVerify).VerifyDiagnostics();
 
             var tree = verifier.Compilation.SyntaxTrees.Single();
             var model = verifier.Compilation.GetSemanticModel(tree);
@@ -3630,7 +3631,8 @@ unsafe static void Main()
     static T Goo<T>(Action<T, T> x) { throw null; }
 }
 ";
-            var verifier = CompileAndVerify(source, options: TestOptions.DebugDll.WithAllowUnsafe(true), verify: Verification.Fails).VerifyDiagnostics();
+            // PEVerify: [ : Program::Main][mdToken=0x6000001][offset 0x0000002C][found unmanaged pointer][expected unmanaged pointer] Unexpected type on the stack.
+            var verifier = CompileAndVerify(source, options: TestOptions.DebugDll.WithAllowUnsafe(true), verify: Verification.FailsPEVerify).VerifyDiagnostics();
 
             var tree = verifier.Compilation.SyntaxTrees.Single();
             var model = verifier.Compilation.GetSemanticModel(tree);
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/ForEachTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/ForEachTests.cs
index 467d8668094a5..998107a7da954 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/ForEachTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/ForEachTests.cs
@@ -3073,7 +3073,7 @@ static void M(string s)
 }";
 
             var comp = CreateEmptyCompilation(text, new[] { reference1 });
-            CompileAndVerify(comp, verify: Verification.Fails).
+            CompileAndVerify(comp, verify: Verification.FailsPEVerify).
             VerifyIL("C.M", @"
 {
   // Code size       28 (0x1c)
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs
index 8da853f551111..994c3203d2d31 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs
@@ -2832,6 +2832,7 @@ static void Test1<T1, T2>(delegate*<T1, T2>[] func) {}
         [Fact, WorkItem(50096, "https://github.com/dotnet/roslyn/issues/50096")]
         public void FunctionPointerInference_ExactInferenceThroughArray_RefKindMatch()
         {
+            // ILVerify: Unexpected type on the stack. ImportCalli not implemented
             var verifier = CompileAndVerify(@"
 unsafe
 {
@@ -2845,7 +2846,7 @@ static void Test1<T1, T2>(delegate*<ref T1, T2>[] func) {
         System.Console.Write(t);
     }
 }
-", expectedOutput: "11", options: TestOptions.UnsafeReleaseExe, verify: ExecutionConditionUtil.IsMonoOrCoreClr ? Verification.Passes : Verification.Skipped);
+", expectedOutput: "11", options: TestOptions.UnsafeReleaseExe, verify: ExecutionConditionUtil.IsMonoOrCoreClr ? Verification.FailsILVerify : Verification.Skipped);
 
             verifier.VerifyIL("<top-level-statements-entry-point>", @"
 {
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/InitOnlyMemberTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/InitOnlyMemberTests.cs
index 9c3bcbeaf1b2a..650d058df7015 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/InitOnlyMemberTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/InitOnlyMemberTests.cs
@@ -1438,9 +1438,9 @@ public class C
                 options: TestOptions.DebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
             comp.VerifyDiagnostics();
 
-            // PE verification fails:  [ : C::set_Property] Cannot change initonly field outside its .ctor.
+            // PEVerify:  [ : C::set_Property] Cannot change initonly field outside its .ctor.
             CompileAndVerify(comp, sourceSymbolValidator: symbolValidator, symbolValidator: symbolValidator,
-                verify: ExecutionConditionUtil.IsCoreClr ? Verification.Passes : Verification.Fails);
+                verify: Verification.FailsPEVerify);
 
             void symbolValidator(ModuleSymbol m)
             {
@@ -2730,9 +2730,9 @@ public int Property
             var comp = CreateCompilation(new[] { source, IsExternalInitTypeDefinition },
                 options: TestOptions.DebugExe, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics();
-            // [ : C::set_Property] Cannot change initonly field outside its .ctor.
+            // PEVerify: [ : C::set_Property] Cannot change initonly field outside its .ctor.
             CompileAndVerify(comp, expectedOutput: "42 43",
-                verify: ExecutionConditionUtil.IsCoreClr ? Verification.Passes : Verification.Fails);
+                verify: Verification.FailsPEVerify);
         }
 
         [Fact]
@@ -4181,7 +4181,7 @@ public static void Main()
                 targetFramework: TargetFramework.Mscorlib40, options: TestOptions.DebugExe, parseOptions: TestOptions.Regular9);
             // PEVerify: [ : S::set_Property] Cannot change initonly field outside its .ctor.
             CompileAndVerify(comp1, expectedOutput: "42",
-                verify: ExecutionConditionUtil.IsCoreClr ? Verification.Passes : Verification.Fails);
+                verify: Verification.FailsPEVerify);
             var comp1Ref = new[] { comp1.ToMetadataReference() };
 
             var comp7 = CreateCompilation(source2, references: comp1Ref,
@@ -4205,7 +4205,7 @@ public readonly struct S
 {
     public int I { get; init; }
 }
-" }, verify: ExecutionConditionUtil.IsCoreClr ? Verification.Passes : Verification.Fails, expectedOutput: "1");
+" }, verify: Verification.FailsPEVerify, expectedOutput: "1");
 
 
 
@@ -4243,7 +4243,7 @@ public readonly struct S
     private readonly int i;
     public int I { get => i; init => i = value; }
 }
-" }, verify: ExecutionConditionUtil.IsCoreClr ? Verification.Passes : Verification.Fails, expectedOutput: "1");
+" }, verify: Verification.FailsPEVerify, expectedOutput: "1");
 
             var s = verifier.Compilation.GetTypeByMetadataName("S");
             var i = s.GetMember<IPropertySymbol>("I");
@@ -4282,7 +4282,7 @@ public struct S
 {
     public readonly int I { get; init; }
 }
-" }, verify: ExecutionConditionUtil.IsCoreClr ? Verification.Passes : Verification.Fails, expectedOutput: "1");
+" }, verify: Verification.FailsPEVerify, expectedOutput: "1");
 
             var s = verifier.Compilation.GetTypeByMetadataName("S");
             var i = s.GetMember<IPropertySymbol>("I");
@@ -4322,7 +4322,7 @@ public struct S
     private readonly int i;
     public readonly int I { get => i; init => i = value; }
 }
-" }, verify: ExecutionConditionUtil.IsCoreClr ? Verification.Passes : Verification.Fails, expectedOutput: "1");
+" }, verify: Verification.FailsPEVerify, expectedOutput: "1");
 
             var s = verifier.Compilation.GetTypeByMetadataName("S");
             var i = s.GetMember<IPropertySymbol>("I");
@@ -4417,7 +4417,7 @@ public int I2
         }
     }
 }
-" }, verify: ExecutionConditionUtil.IsCoreClr ? Verification.Passes : Verification.Fails, expectedOutput: @"I1 was 1
+" }, verify: Verification.FailsPEVerify, expectedOutput: @"I1 was 1
 I1 is 0");
 
             var s = verifier.Compilation.GetTypeByMetadataName("S");
@@ -4551,7 +4551,7 @@ public record Container(Person Person);
             var comp = CreateCompilation(new[] { IsExternalInitTypeDefinition, source }, options: TestOptions.DebugExe);
             comp.VerifyEmitDiagnostics();
             // PEVerify: Cannot change initonly field outside its .ctor.
-            CompileAndVerify(comp, expectedOutput: "c", verify: ExecutionConditionUtil.IsCoreClr ? Verification.Passes : Verification.Fails);
+            CompileAndVerify(comp, expectedOutput: "c", verify: Verification.FailsPEVerify);
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
index bb0b85555896f..e8f04ab535ec6 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
@@ -3817,7 +3817,8 @@ class C
 
             var comp = CreateCompilation(new[] { source, interpolatedStringBuilder },
                 targetFramework: TargetFramework.NetCoreApp);
-            var verifier = CompileAndVerify(comp, expectedOutput: @"
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            var verifier = CompileAndVerify(comp, verify: Verification.FailsILVerify, expectedOutput: @"
 value:S converted
 value:C");
 
@@ -9420,12 +9421,13 @@ public CustomHandler(int literalLength, int formattedCount," + refness + @" C c)
 
             var handler = GetInterpolatedStringCustomHandlerType("CustomHandler", "partial struct", useBoolReturns: true);
 
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
             var verifier = CompileAndVerify(
                 new[] { code, InterpolatedStringHandlerArgumentAttribute, handler },
                 expectedOutput: "1literal:literal",
                 symbolValidator: validator,
                 sourceSymbolValidator: validator,
-                verify: ExecutionConditionUtil.IsMonoOrCoreClr ? Verification.Passes : Verification.Skipped);
+                verify: ExecutionConditionUtil.IsMonoOrCoreClr ? Verification.FailsILVerify : Verification.Skipped);
             verifier.VerifyIL("<top-level-statements-entry-point>", refness == "in" ? @"
 {
   // Code size       46 (0x2e)
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NamedAndOptionalTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NamedAndOptionalTests.cs
index a6fca5b9c53db..df1b5a1787dc3 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NamedAndOptionalTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NamedAndOptionalTests.cs
@@ -772,7 +772,7 @@ static void Main()
             // default(IntPtr) as "load zero, convert to type", rather than making a stack slot and calling
             // init on it.
 
-            var c = CompileAndVerify(source, options: TestOptions.UnsafeReleaseDll, verify: Verification.Fails);
+            var c = CompileAndVerify(source, options: TestOptions.UnsafeReleaseDll, verify: Verification.FailsPEVerify);
 
             c.VerifyIL("C.Main", @"{
   // Code size       13 (0xd)
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
index 522c906b2ca33..6456143bb87a9 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -112690,7 +112690,7 @@ interface I2
             compilation2.VerifyEmitDiagnostics();
 
             // Verification against a corlib not named exactly mscorlib is expected to fail.
-            CompileAndVerify(compilation2, verify: Verification.Fails);
+            CompileAndVerify(compilation2, verify: Verification.FailsPEVerify);
 
             Assert.Equal(TypeKind.Struct, compilation2.GetTypeByMetadataName("A").TypeKind);
             Assert.Equal(TypeKind.Enum, compilation2.GetTypeByMetadataName("B").TypeKind);
@@ -112701,7 +112701,7 @@ interface I2
             var compilation3 = CreateEmptyCompilation(source2, options: WithNullableEnable(TestOptions.ReleaseDll), references: new[] { compilation1.ToMetadataReference(), MinCorlibRef });
 
             compilation3.VerifyEmitDiagnostics();
-            CompileAndVerify(compilation3, verify: Verification.Fails);
+            CompileAndVerify(compilation3, verify: Verification.FailsPEVerify);
 
             Assert.Equal(TypeKind.Struct, compilation3.GetTypeByMetadataName("A").TypeKind);
             Assert.Equal(TypeKind.Enum, compilation3.GetTypeByMetadataName("B").TypeKind);
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableTests.cs
index 8d4341c8f4666..1c82e2586ee3e 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableTests.cs
@@ -209,7 +209,7 @@ static void Main()
   }
 }";
 
-            verifier = CompileAndVerify(source: source3, expectedOutput: "1", verify: Verification.Fails);
+            verifier = CompileAndVerify(source: source3, expectedOutput: "1", verify: Verification.FailsPEVerify);
             verifier = CompileAndVerify(source: source3, expectedOutput: "1", parseOptions: TestOptions.Regular.WithPEVerifyCompatFeature());
         }
 
@@ -268,7 +268,7 @@ static void F(int line, bool b)
 ";
             foreach (string type in new[] { "int", "ushort", "byte", "long", "float", "decimal" })
             {
-                CompileAndVerify(source: source4.Replace("TYPE", type), expectedOutput: "0", verify: Verification.Fails);
+                CompileAndVerify(source: source4.Replace("TYPE", type), expectedOutput: "0", verify: Verification.FailsPEVerify);
                 CompileAndVerify(source: source4.Replace("TYPE", type), expectedOutput: "0", parseOptions: TestOptions.Regular.WithPEVerifyCompatFeature());
             }
         }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs
index 4fc72d7c33b28..43d63721ece68 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs
@@ -9037,7 +9037,8 @@ public static void RemoveDetail<TMain, TChild>(this TMain main, TChild child)
     }
 }";
             var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe);
-            CompileAndVerify(compilation, expectedOutput:
+            // ILVerify: Unrecognized arguments for delegate .ctor.
+            CompileAndVerify(compilation, verify: Verification.FailsILVerify, expectedOutput:
 @"RemoveDetail
 RemoveDetail
 RemoveDetail
@@ -11292,7 +11293,8 @@ private static bool Contains<T>(this System.Collections.Generic.IEnumerable<T> a
         throw new NotImplementedException();
 }";
 
-            CompileAndVerify(code, expectedOutput: @"2");
+            // ILVerify: Unrecognized arguments for delegate .ctor.
+            CompileAndVerify(code, verify: Verification.FailsILVerify, expectedOutput: @"2");
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests.cs
index 6fe353dc666a5..d2b1da7954173 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests.cs
@@ -6221,7 +6221,7 @@ static int CopyRefInt(ref int z)
             var compilation = CreateCompilation(program, options: TestOptions.DebugExe.WithAllowUnsafe(true));
             compilation.VerifyDiagnostics(
                 );
-            var comp = CompileAndVerify(compilation, expectedOutput: "ok");
+            var comp = CompileAndVerify(compilation, expectedOutput: "ok", verify: Verification.FailsILVerify);
         }
 
         [Fact]
@@ -6517,7 +6517,10 @@ unsafe static void Main()
 False";
             var compilation = CreateCompilation(source, options: TestOptions.UnsafeReleaseExe);
             compilation.VerifyDiagnostics();
-            CompileAndVerify(compilation, expectedOutput: expectedOutput, verify: Verification.Fails);
+            // PEVerify:
+            // [ : Program::Main][mdToken=0x6000001][offset 0x00000002] Unmanaged pointers are not a verifiable type.
+            // [ : Program::Main][mdToken= 0x6000001][offset 0x00000002] Unable to resolve token.
+            CompileAndVerify(compilation, expectedOutput: expectedOutput, verify: Verification.FailsPEVerify);
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests3.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests3.cs
index f0a96415b7ae9..287caaaeb5f78 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests3.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests3.cs
@@ -470,7 +470,8 @@ public static RGBColor FromRainbow(Rainbow colorBand) =>
             var compilation = CreateCompilation(source, options: TestOptions.DebugExe);
             compilation.VerifyDiagnostics(
                 );
-            var comp = CompileAndVerify(compilation, expectedOutput: expectedOutput);
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            var comp = CompileAndVerify(compilation, verify: Verification.FailsILVerify, expectedOutput: expectedOutput);
         }
 
         [Fact, WorkItem(35278, "https://github.com/dotnet/roslyn/issues/35278")]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
index 495602792f55a..706a141ad3dbb 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests_ListPatterns.cs
@@ -278,7 +278,10 @@ static int Test4(int[] x)
     }
 }
 ";
-        var verifier = CompileAndVerify(new[] { source, TestSources.Index, TestSources.Range }, parseOptions: TestOptions.RegularWithListPatterns, options: TestOptions.ReleaseDll).VerifyDiagnostics();
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        var verifier = CompileAndVerify(new[] { source, TestSources.Index, TestSources.Range }, parseOptions: TestOptions.RegularWithListPatterns,
+            options: TestOptions.ReleaseDll, verify: Verification.FailsILVerify);
+        verifier.VerifyDiagnostics();
         AssertEx.Multiple(
             () => verifier.VerifyIL("X.Test1", @"
 {
@@ -2590,9 +2593,10 @@ public static void Main()
     } 
 }
 ";
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
         var compilation = CreateCompilation(new[] { source, TestSources.Index }, options: TestOptions.ReleaseExe);
         compilation.VerifyEmitDiagnostics();
-        CompileAndVerify(compilation, expectedOutput: "123");
+        CompileAndVerify(compilation, expectedOutput: "123", verify: Verification.FailsILVerify);
     }
 
     [Fact]
@@ -3732,7 +3736,8 @@ public class C
 ";
         var compilation = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
         compilation.VerifyDiagnostics();
-        CompileAndVerify(compilation, expectedOutput: expectedOutput);
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        CompileAndVerify(compilation, expectedOutput: expectedOutput, verify: Verification.FailsILVerify);
     }
 
     [Fact]
@@ -5302,7 +5307,8 @@ void M2()
 ";
         var compilation = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
         compilation.VerifyEmitDiagnostics();
-        var verifier = CompileAndVerify(compilation, expectedOutput: "(item value, rest value)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        var verifier = CompileAndVerify(compilation, expectedOutput: "(item value, rest value)", verify: Verification.FailsILVerify);
 
         verifier.VerifyIL("C.M", @"
 {
@@ -5390,7 +5396,8 @@ void M2()
 ";
         var compilation = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
         compilation.VerifyEmitDiagnostics();
-        var verifier = CompileAndVerify(compilation, expectedOutput: "(item value, rest value)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        var verifier = CompileAndVerify(compilation, expectedOutput: "(item value, rest value)", verify: Verification.FailsILVerify);
 
         verifier.VerifyIL("C.M", @"
 {
@@ -5479,7 +5486,8 @@ static void Main()
             Console.Write((x, y));
     }
 }";
-        CompileAndVerify(new[] { src, TestSources.Index, TestSources.Range }, expectedOutput: "Index Range (42, 43)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        CompileAndVerify(new[] { src, TestSources.Index, TestSources.Range }, expectedOutput: "Index Range (42, 43)", verify: Verification.FailsILVerify);
     }
 
     [Fact]
@@ -5518,7 +5526,8 @@ public void SlicePattern_String()
     System.Console.Write((first, rest).ToString());
 }
 ";
-        CompileAndVerify(new[] { src, TestSources.Index, TestSources.Range }, expectedOutput: "(a, bc)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        CompileAndVerify(new[] { src, TestSources.Index, TestSources.Range }, expectedOutput: "(a, bc)", verify: Verification.FailsILVerify);
     }
 
     [Fact]
@@ -7402,7 +7411,8 @@ public string M()
     }
 }
 ";
-        var verifier = CompileAndVerify(new[] { source, TestSources.Index }, options: TestOptions.DebugDll);
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        var verifier = CompileAndVerify(new[] { source, TestSources.Index }, options: TestOptions.DebugDll, verify: Verification.FailsILVerify);
         verifier.VerifyIL("C.M", @"
 {
   // Code size      105 (0x69)
@@ -7499,7 +7509,8 @@ public string M()
     }
 }
 ";
-        var verifier = CompileAndVerify(new[] { source, TestSources.Index });
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        var verifier = CompileAndVerify(new[] { source, TestSources.Index }, verify: Verification.FailsILVerify);
         verifier.VerifyIL("C.M", @"
 {
   // Code size       78 (0x4e)
@@ -7648,7 +7659,8 @@ public void M()
             );
 
         compilation = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
-        var verifier = CompileAndVerify(compilation, expectedOutput: "(2, 3)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        var verifier = CompileAndVerify(compilation, expectedOutput: "(2, 3)", verify: Verification.FailsILVerify);
         verifier.VerifyDiagnostics();
         // Note: no Index or Range involved
         verifier.VerifyIL("C.M", @"
@@ -7894,7 +7906,8 @@ class C
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
         comp.VerifyEmitDiagnostics();
-        CompileAndVerify(comp, expectedOutput: "(42, 42)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        CompileAndVerify(comp, expectedOutput: "(42, 42)", verify: Verification.FailsILVerify);
     }
 
     [Fact]
@@ -7940,7 +7953,8 @@ class C
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
         comp.VerifyEmitDiagnostics();
-        CompileAndVerify(comp, expectedOutput: "(42, 42)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        CompileAndVerify(comp, expectedOutput: "(42, 42)", verify: Verification.FailsILVerify);
     }
 
     [Fact]
@@ -7954,7 +7968,8 @@ public void Simple_String()
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
         comp.VerifyEmitDiagnostics();
-        CompileAndVerify(comp, expectedOutput: "(4, 2)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        CompileAndVerify(comp, expectedOutput: "(4, 2)", verify: Verification.FailsILVerify);
     }
 
     [Fact]
@@ -7969,7 +7984,8 @@ public void Simple_Array()
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
         comp.VerifyEmitDiagnostics();
-        CompileAndVerify(comp, expectedOutput: "(4, 2)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        CompileAndVerify(comp, expectedOutput: "(4, 2)", verify: Verification.FailsILVerify);
     }
 
     [Theory]
@@ -7990,7 +8006,8 @@ public void Simple_Array_VerifyIndexMaths(string data, string pattern, string el
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
         comp.VerifyEmitDiagnostics();
-        CompileAndVerify(comp, expectedOutput: "(4, 4)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        CompileAndVerify(comp, expectedOutput: "(4, 4)", verify: Verification.FailsILVerify);
     }
 
     [Fact]
@@ -8011,7 +8028,8 @@ class C
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
         comp.VerifyEmitDiagnostics();
-        CompileAndVerify(comp, expectedOutput: "(42, 42)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        CompileAndVerify(comp, expectedOutput: "(42, 42)", verify: Verification.FailsILVerify);
     }
 
     [Fact]
@@ -8032,7 +8050,8 @@ class C
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
         comp.VerifyEmitDiagnostics();
-        CompileAndVerify(comp, expectedOutput: "(42, 42)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        CompileAndVerify(comp, expectedOutput: "(42, 42)", verify: Verification.FailsILVerify);
     }
 
     [Fact]
@@ -8046,7 +8065,8 @@ public void Simple_String_Slice()
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
         comp.VerifyEmitDiagnostics();
-        CompileAndVerify(comp, expectedOutput: "42");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' } 
+        CompileAndVerify(comp, expectedOutput: "42", verify: Verification.FailsILVerify);
     }
 
     [Fact, WorkItem(57728, "https://github.com/dotnet/roslyn/issues/57728")]
@@ -8067,7 +8087,8 @@ public static void Main()
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range, TestSources.GetSubArray }, options: TestOptions.ReleaseExe);
         comp.VerifyEmitDiagnostics();
-        var verifier = CompileAndVerify(comp, expectedOutput: "(4, 2, 4, 2)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        var verifier = CompileAndVerify(comp, expectedOutput: "(4, 2, 4, 2)", verify: Verification.FailsILVerify);
         // we use Array.Length to get the length, but should be using ldlen
         // Tracked by https://github.com/dotnet/roslyn/issues/57728
         verifier.VerifyIL("C.Main", @"
@@ -8159,7 +8180,8 @@ public void Simple_Array_Slice_VerifyRangeMaths(string data, string pattern, str
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range, TestSources.GetSubArray });
         comp.VerifyEmitDiagnostics();
-        CompileAndVerify(comp, expectedOutput: "(4, 2, 2, 4, 2, 2)");
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of 'System.Index', Expected = address of 'System.Index' }
+        CompileAndVerify(comp, expectedOutput: "(4, 2, 2, 4, 2, 2)", verify: Verification.FailsILVerify);
     }
 
     [Fact]
@@ -8180,7 +8202,8 @@ public int M(int[] a)
 }
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range, TestSources.GetSubArray }, options: TestOptions.ReleaseDll);
-        var verifier = CompileAndVerify(comp).VerifyDiagnostics();
+        // ILVerify: Unexpected type on the stack. { Offset = 20, Found = readonly address of '[...]System.Index', Expected = address of '[...]System.Index' }
+        var verifier = CompileAndVerify(comp, verify: Verification.FailsILVerify).VerifyDiagnostics();
 
         verifier.VerifyIL("C.M", @"
 {
@@ -8256,7 +8279,7 @@ class C : Interface
 }
 ";
         var comp = CreateCompilation(new[] { source, TestSources.Index, TestSources.Range });
-        var verifier = CompileAndVerify(comp, expectedOutput: "(42, 43)");
+        var verifier = CompileAndVerify(comp, expectedOutput: "(42, 43)", verify: Verification.FailsILVerify);
         verifier.VerifyDiagnostics();
     }
 
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/RawInterpolationTests_Handler.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/RawInterpolationTests_Handler.cs
index 48a73d6f5e804..5d738b9255dc7 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/RawInterpolationTests_Handler.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/RawInterpolationTests_Handler.cs
@@ -2453,9 +2453,10 @@ class C
 
         var comp = CreateCompilation(new[] { source, interpolatedStringBuilder },
             targetFramework: TargetFramework.NetCoreApp);
+        // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator. { Offset = 10 }
         var verifier = CompileAndVerify(comp, expectedOutput: @"
 value:S converted
-value:C");
+value:C", verify: Verification.FailsILVerify);
 
         verifier.VerifyIL("<top-level-statements-entry-point>", @"
 {
@@ -7940,12 +7941,13 @@ public CustomHandler(int literalLength, int formattedCount," + refness + @" C c)
 
         var handler = GetInterpolatedStringCustomHandlerType("CustomHandler", "partial struct", useBoolReturns: true);
 
+        // Return type is ByRef, TypedReference, ArgHandle, or ArgIterator. { Offset = 1 }
         var verifier = CompileAndVerify(
             new[] { code, InterpolatedStringHandlerArgumentAttribute, handler },
             expectedOutput: "1literal:literal",
             symbolValidator: validator,
             sourceSymbolValidator: validator,
-            verify: ExecutionConditionUtil.IsMonoOrCoreClr ? Verification.Passes : Verification.Skipped);
+            verify: ExecutionConditionUtil.IsMonoOrCoreClr ? Verification.FailsILVerify : Verification.Skipped);
         verifier.VerifyIL("<top-level-statements-entry-point>", refness == "in" ? @"
 {
   // Code size       46 (0x2e)
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/SpanStackSafetyTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/SpanStackSafetyTests.cs
index ec4e43f9fc7ed..4e84a8101b1af 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/SpanStackSafetyTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/SpanStackSafetyTests.cs
@@ -1850,7 +1850,8 @@ static void Main()
 ";
 
             CSharpCompilation comp = CreateCompilationWithMscorlibAndSpan(text, options: TestOptions.DebugExe);
-            CompileAndVerify(comp, expectedOutput: "Done").VerifyDiagnostics();
+            // ILVerify: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            CompileAndVerify(comp, expectedOutput: "Done", verify: Verification.FailsILVerify).VerifyDiagnostics();
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs
index a2ebe9d27a909..91e7494d4c76c 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/TargetTypedDefaultTests.cs
@@ -1922,7 +1922,7 @@ static void Main()
 ";
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular7_1, options: TestOptions.DebugExe);
             comp.VerifyDiagnostics();
-            CompileAndVerify(comp, expectedOutput: "123: True");
+            CompileAndVerify(comp, expectedOutput: "123: True", verify: Verification.FailsILVerify);
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/UseSiteErrorTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/UseSiteErrorTests.cs
index eff9158c26ef9..b24263d3f4952 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/UseSiteErrorTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/UseSiteErrorTests.cs
@@ -2367,7 +2367,8 @@ interface I2
                 // warning CS8021: No value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options.
                 Diagnostic(ErrorCode.WRN_NoRuntimeMetadataVersion).WithLocation(1, 1)
                 );
-            CompileAndVerify(compilation5);
+            // ILVerify: no corlib
+            CompileAndVerify(compilation5, verify: Verification.FailsILVerify);
 
             Assert.Equal(TypeKind.Struct, compilation5.GetTypeByMetadataName("A").TypeKind);
             Assert.Equal(TypeKind.Enum, compilation5.GetTypeByMetadataName("B").TypeKind);
diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
index 6e608104926e4..1dce2da3aa49e 100644
--- a/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Compilation/CompilationAPITests.cs
@@ -1024,7 +1024,8 @@ public static void Main(string[] args) {
 }"
             });
             assembly.VerifyEmitDiagnostics();
-            CompileAndVerify(assembly);
+            // ILVerify: Assembly or module not found: a2
+            CompileAndVerify(assembly, verify: Verification.FailsILVerify);
         }
 
         [WorkItem(713356, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/713356")]
diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/UsedAssembliesTests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/UsedAssembliesTests.cs
index 4e7b87b4dd92b..d1c15f6015ff2 100644
--- a/src/Compilers/CSharp/Test/Symbol/Compilation/UsedAssembliesTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Compilation/UsedAssembliesTests.cs
@@ -32,7 +32,7 @@ interface I1
 }
 ";
             var comp1 = CreateEmptyCompilation(source);
-            CompileAndVerify(comp1);
+            CompileAndVerify(comp1, verify: Verification.FailsILVerify);
 
             Assert.Empty(comp1.GetUsedAssemblyReferences());
 
@@ -53,7 +53,7 @@ public interface I1
 }
 ";
             var comp1 = CreateEmptyCompilation(source);
-            CompileAndVerify(comp1);
+            CompileAndVerify(comp1, verify: Verification.FailsILVerify);
 
             var source2 =
 @"
@@ -411,7 +411,7 @@ public interface I1
 }
 ";
             var comp1 = CreateEmptyCompilation(source);
-            CompileAndVerify(comp1);
+            CompileAndVerify(comp1, verify: Verification.FailsILVerify);
 
             var source2 =
 @"
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/DefaultInterfaceImplementationTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/DefaultInterfaceImplementationTests.cs
index 744421583f648..c2911fa059138 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/DefaultInterfaceImplementationTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/DefaultInterfaceImplementationTests.cs
@@ -48,6 +48,14 @@ private static Verification VerifyOnMonoOrCoreClr
             }
         }
 
+        private static Verification VerifyOnMonoOrCoreClr_FailsIlVerify
+        {
+            get
+            {
+                return ExecutionConditionUtil.IsMonoOrCoreClr ? Verification.FailsILVerify : Verification.Skipped;
+            }
+        }
+
         private void ValidateMethodImplementation_011(string source)
         {
             foreach (string access in new[] { "x.M1();", "new System.Action(x.M1)();" })
@@ -9638,7 +9646,7 @@ static void Main()
 M2
 M3",
                 symbolValidator: validate,
-                verify: VerifyOnMonoOrCoreClr);
+                verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
             validate(compilation1.SourceModule);
 
@@ -9702,7 +9710,7 @@ static void Main()
                 CompileAndVerify(compilation4, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null :
 @"M1
 M2",
-                    verify: VerifyOnMonoOrCoreClr);
+                    verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
                 var compilation5 = CreateCompilation(source4, options: TestOptions.DebugExe,
                                                      references: new[] { reference },
@@ -17954,7 +17962,7 @@ static void Main()
 get_P6
 set_P6",
                 symbolValidator: validate,
-                verify: VerifyOnMonoOrCoreClr);
+                verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
             validate(compilation1.SourceModule);
 
@@ -18063,7 +18071,7 @@ static void Main()
 set_P5
 set_P6
 ",
-                    verify: VerifyOnMonoOrCoreClr);
+                    verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
                 var compilation5 = CreateCompilation(source4, options: TestOptions.DebugExe,
                                                      references: new[] { reference },
@@ -28444,7 +28452,7 @@ static void Main()
 get_P2
 set_P2
 get_P3
-set_P3", symbolValidator: validate, verify: VerifyOnMonoOrCoreClr);
+set_P3", symbolValidator: validate, verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
             validate(compilation1.SourceModule);
 
@@ -28517,7 +28525,7 @@ static void Main()
 set_P1
 get_P2
 set_P2",
-                    verify: VerifyOnMonoOrCoreClr);
+                    verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
                 var compilation5 = CreateCompilation(source4, options: TestOptions.DebugExe,
                                                      references: new[] { reference },
@@ -29259,7 +29267,7 @@ public void M1()
 }
 ";
 
-            ValidateNestedTypes_01(source0 + source1, Accessibility.Protected, targetFramework: TargetFramework.NetCoreApp, execute: ExecutionConditionUtil.IsMonoOrCoreClr, verify: VerifyOnMonoOrCoreClr);
+            ValidateNestedTypes_01(source0 + source1, Accessibility.Protected, targetFramework: TargetFramework.NetCoreApp, execute: ExecutionConditionUtil.IsMonoOrCoreClr, verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
             var compilation1 = CreateCompilation(source0 + source1, options: TestOptions.DebugExe,
                                                  parseOptions: TestOptions.Regular,
@@ -29365,7 +29373,7 @@ public void M1()
 I1+T3
 B
 I1+T5",
-                    verify: VerifyOnMonoOrCoreClr);
+                    verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
                 var compilation5 = CreateCompilation(source2, options: TestOptions.DebugExe,
                                                      references: new[] { reference },
@@ -29500,7 +29508,7 @@ public void M1()
 I1+T3
 B
 I1+T5",
-                    verify: VerifyOnMonoOrCoreClr);
+                    verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
                 var compilation5 = CreateCompilation(source2, options: TestOptions.DebugExe,
                                                      references: new[] { reference },
@@ -29809,7 +29817,7 @@ public void M1()
     }
 }
 ";
-            ValidateNestedTypes_01(source0 + source1, Accessibility.ProtectedAndInternal, targetFramework: TargetFramework.NetCoreApp, execute: ExecutionConditionUtil.IsMonoOrCoreClr, verify: VerifyOnMonoOrCoreClr);
+            ValidateNestedTypes_01(source0 + source1, Accessibility.ProtectedAndInternal, targetFramework: TargetFramework.NetCoreApp, execute: ExecutionConditionUtil.IsMonoOrCoreClr, verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
             var compilation1 = CreateCompilation(source0 + source1, options: TestOptions.DebugExe,
                                                  parseOptions: TestOptions.Regular,
@@ -32819,7 +32827,7 @@ static void Main()
 @"I2.M1
 I4.M1
 ",
-                verify: VerifyOnMonoOrCoreClr,
+                verify: VerifyOnMonoOrCoreClr_FailsIlVerify,
                 symbolValidator: ValidateMethodImplementationInDerived_01);
 
             foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
@@ -33065,7 +33073,7 @@ static void Main()
 @"I2.M1
 I4.M1
 ",
-                verify: VerifyOnMonoOrCoreClr,
+                verify: VerifyOnMonoOrCoreClr_FailsIlVerify,
                 symbolValidator: ValidateMethodImplementationInDerived_01);
 
             foreach (var reference in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
@@ -38928,7 +38936,7 @@ public static void Test()
 @"123
 -2
 ",
-                verify: VerifyOnMonoOrCoreClr, symbolValidator: validate);
+                verify: VerifyOnMonoOrCoreClr_FailsIlVerify, symbolValidator: validate);
 
             var source2 =
 @"
@@ -38950,7 +38958,7 @@ static void Main()
                                                      parseOptions: TestOptions.Regular,
                                                      targetFramework: TargetFramework.NetCoreApp);
 
-                CompileAndVerify(compilation2, expectedOutput: ExecutionConditionUtil.IsMonoOrCoreClr ? "1122" : null, verify: VerifyOnMonoOrCoreClr);
+                CompileAndVerify(compilation2, expectedOutput: ExecutionConditionUtil.IsMonoOrCoreClr ? "1122" : null, verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
             }
 
             var source3 =
@@ -44779,7 +44787,7 @@ static void Main()
             var compilation0 = CreateCompilation(source0 + source1, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetCoreApp);
             compilation0.VerifyDiagnostics();
 
-            CompileAndVerify(compilation0, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : @"M1", verify: VerifyOnMonoOrCoreClr);
+            CompileAndVerify(compilation0, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : @"M1", verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
             var source2 = @"
 interface I2<T> : I3<T>
@@ -44805,7 +44813,7 @@ static void Main()
             var compilation1 = CreateCompilation(source0 + source2, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetCoreApp);
             compilation1.VerifyDiagnostics();
 
-            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : @"M1", verify: VerifyOnMonoOrCoreClr);
+            CompileAndVerify(compilation1, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : @"M1", verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
             var source3 = @"
 interface I2<T> : I3<T>
@@ -44942,8 +44950,7 @@ static void Main()
             var compilation0 = CreateCompilation(source0 + source1, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetCoreApp);
             compilation0.VerifyDiagnostics();
 
-            CompileAndVerify(compilation0, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : @"M1", verify: VerifyOnMonoOrCoreClr);
-
+            CompileAndVerify(compilation0, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : @"M1", verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
 
             var source3 = @"
 class I2<T>
@@ -45003,7 +45010,7 @@ static void Main()
             var compilation0 = CreateCompilation(source0 + source1, options: TestOptions.DebugExe, targetFramework: TargetFramework.NetCoreApp);
             compilation0.VerifyDiagnostics();
 
-            CompileAndVerify(compilation0, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : @"M1", verify: VerifyOnMonoOrCoreClr);
+            CompileAndVerify(compilation0, expectedOutput: !ExecutionConditionUtil.IsMonoOrCoreClr ? null : @"M1", verify: VerifyOnMonoOrCoreClr_FailsIlVerify);
         }
 
         private const string NoPiaAttributes = @"
@@ -45463,6 +45470,7 @@ void ITest33.M1(){}
 
             var piaCompilation = CreateCompilation(pia, options: TestOptions.ReleaseDll, references: new[] { attributesRef }, targetFramework: TargetFramework.NetCoreApp);
 
+            // ILVerify: Missing method 'Void UsePia.Test(ITest33)'
             CompileAndVerify(piaCompilation, verify: VerifyOnMonoOrCoreClr);
 
             string consumer1 = @"
@@ -45516,7 +45524,8 @@ public interface ITest33
                 foreach (var reference2 in new[] { compilation1.ToMetadataReference(), compilation1.EmitToImageReference() })
                 {
                     var compilation2 = CreateCompilation(consumer2, options: TestOptions.ReleaseExe, references: new[] { reference2, pia2Reference }, targetFramework: TargetFramework.StandardLatest);
-                    CompileAndVerify(compilation2, expectedOutput: "Test.M1");
+                    // ILVerify: Missing method 'Void UsePia.Test(ITest33)'
+                    CompileAndVerify(compilation2, expectedOutput: "Test.M1", verify: Verification.Skipped);
                 }
             }
         }
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
index 685720e450387..15c12f5979dd0 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
@@ -290,11 +290,12 @@ static void Goo(this string x)
         Console.WriteLine(x);
     }
 }";
+            // ILVerify: Unrecognized arguments for delegate .ctor. { Offset = 21 }
             CompileAndVerify(source, expectedOutput:
 @"ABC
 123
 123
-xyz");
+xyz", verify: Verification.FailsILVerify);
         }
 
         [WorkItem(541143, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541143")]
@@ -376,7 +377,8 @@ static void Main()
     static void Goo<T>(this T x) { }
 }
 ";
-            CompileAndVerify(source, expectedOutput: "2");
+            // ILVerify: Unrecognized arguments for delegate .ctor. { Offset = 7 }
+            CompileAndVerify(source, expectedOutput: "2", verify: Verification.FailsILVerify);
         }
 
         [WorkItem(528426, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/528426")]
@@ -873,7 +875,8 @@ internal static void F(this object o) { }
     internal static void F(this object x, object y) { }
     internal static void G(this object x, object y) { }
 }";
-            var compilation = CompileAndVerify(source);
+            // ILVerify: Unrecognized arguments for delegate .ctor. { Offset = 8 }
+            var compilation = CompileAndVerify(source, verify: Verification.FailsILVerify);
             compilation.VerifyIL("N.C.M",
 @"{
   // Code size       71 (0x47)
@@ -939,7 +942,8 @@ internal static void F2(this object x, object y) { }
     internal static void F3(this object x, int y) { }
     internal static void F4(this object x, object y) { }
 }";
-            var compilation = CompileAndVerify(source);
+            // ILVerify: Unrecognized arguments for delegate .ctor. { Offset = 8 }
+            var compilation = CompileAndVerify(source, verify: Verification.FailsILVerify);
             compilation.VerifyIL("N.C.M",
 @"
 {
@@ -1923,7 +1927,8 @@ public static void M(this C c, int i)
         System.Console.Write(c.P * i);
     }
 }";
-            CompileAndVerify(source, expectedOutput: "6");
+            // ILVerify: Unrecognized arguments for delegate .ctor. { Offset = 11 }
+            CompileAndVerify(source, expectedOutput: "6", verify: Verification.FailsILVerify);
         }
 
         [Fact]
@@ -2293,11 +2298,12 @@ static void M(Action a)
         a();
     }
 }";
+            // ILVerify: Unrecognized arguments for delegate .ctor.
             var compilation = CompileAndVerify(source, expectedOutput:
 @"F: System.Int32
 F: S
 G: System.Int32
-G: S");
+G: S", verify: Verification.FailsILVerify);
             compilation.VerifyIL("C.Main",
 @"{
   // Code size      105 (0x69)
@@ -2373,12 +2379,13 @@ internal static void M(this object o)
         Console.WriteLine(""{0}"", o.GetType());
     }
 }";
+            // ILVerify: Unrecognized arguments for delegate .ctor. { Offset = 12 }
             var compilation = CompileAndVerify(source, expectedOutput:
 @"System.Object
 System.Object
 System.Int32
 B
-B");
+B", verify: Verification.FailsILVerify);
             compilation.VerifyIL("C.M<T1, T2, T3, T4, T5>",
 @"{
   // Code size      112 (0x70)
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/RecordTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/RecordTests.cs
index b3fb8b3223b8f..1f9edbda43a9d 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/RecordTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/RecordTests.cs
@@ -21,7 +21,7 @@ private CompilationVerifier CompileAndVerify(CSharpTestSource src, string? expec
                 expectedOutput: expectedOutput,
                 parseOptions: TestOptions.Regular9,
                 // init-only fails verification
-                verify: Verification.Skipped);
+                verify: Verification.FailsPEVerify);
 
         [Fact]
         public void GeneratedConstructor()
@@ -749,7 +749,8 @@ public void RecordClone1()
             Assert.Equal(1, ctor.ParameterCount);
             Assert.True(ctor.Parameters[0].Type.Equals(c, TypeCompareKind.ConsiderEverything));
 
-            var verifier = CompileAndVerify(comp, verify: Verification.Fails).VerifyDiagnostics();
+            // PEVerify: Cannot change initonly field outside its .ctor.
+            var verifier = CompileAndVerify(comp, verify: Verification.FailsPEVerify).VerifyDiagnostics();
             verifier.VerifyIL("C." + WellKnownMemberNames.CloneMethodName, @"
 {
   // Code size        7 (0x7)
@@ -801,7 +802,8 @@ public C(C other)
             Assert.Equal(1, ctor.ParameterCount);
             Assert.True(ctor.Parameters[0].Type.Equals(c, TypeCompareKind.ConsiderEverything));
 
-            var verifier = CompileAndVerify(comp, verify: Verification.Fails).VerifyDiagnostics();
+            // PEVerify: Cannot change initonly field outside its .ctor.
+            var verifier = CompileAndVerify(comp, verify: Verification.FailsPEVerify).VerifyDiagnostics();
             verifier.VerifyIL("C." + WellKnownMemberNames.CloneMethodName, @"
 {
   // Code size        7 (0x7)
@@ -897,7 +899,8 @@ public record C(int x, int y)
             Assert.Equal(1, ctor.ParameterCount);
             Assert.True(ctor.Parameters[0].Type.Equals(c, TypeCompareKind.ConsiderEverything));
 
-            var verifier = CompileAndVerify(comp, verify: Verification.Fails).VerifyDiagnostics(
+            // PEVerify: Cannot change initonly field outside its .ctor.
+            var verifier = CompileAndVerify(comp, verify: Verification.FailsPEVerify).VerifyDiagnostics(
                 // (5,25): warning CS0067: The event 'C.E' is never used
                 //     public event Action E;
                 Diagnostic(ErrorCode.WRN_UnreferencedEvent, "E").WithArguments("C.E").WithLocation(5, 25)
@@ -965,7 +968,7 @@ public static void Main()
         Console.WriteLine(c.Equals(c2));
         Console.WriteLine(c.Equals((object)c2));
     }
-}", expectedOutput: @"False
+}", verify: Verification.Passes, expectedOutput: @"False
 False
 True
 True").VerifyDiagnostics(
@@ -1049,7 +1052,7 @@ record C
     public int X { get; }
     public string Y { get; }
     public event Action E;
-}").VerifyDiagnostics(
+}", verify: Verification.Passes).VerifyDiagnostics(
                 // (7,25): warning CS0067: The event 'C.E' is never used
                 //     public event Action E;
                 Diagnostic(ErrorCode.WRN_UnreferencedEvent, "E").WithArguments("C.E").WithLocation(7, 25)
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
index 8460615ecac40..28e5a750d7088 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/SymbolErrorTests.cs
@@ -6072,7 +6072,8 @@ class A<T> {}
                     s_mod2.GetReference(),
                 });
 
-            CompileAndVerify(comp).VerifyDiagnostics();
+            // ILVerify: Assembly or module not found: ErrTestMod02
+            CompileAndVerify(comp, verify: Verification.FailsILVerify).VerifyDiagnostics();
         }
 
         [Fact()]
diff --git a/src/Compilers/Test/Core/CommonTestBase.cs b/src/Compilers/Test/Core/CommonTestBase.cs
index cd7763756c98c..6ebb554eb620a 100644
--- a/src/Compilers/Test/Core/CommonTestBase.cs
+++ b/src/Compilers/Test/Core/CommonTestBase.cs
@@ -23,11 +23,15 @@
 
 namespace Microsoft.CodeAnalysis.Test.Utilities
 {
+    [Flags]
     public enum Verification
     {
-        Passes = 0,
-        Fails,
-        Skipped
+        Skipped = 0,
+        Passes = 1 << 1,
+
+        FailsPEVerify = 1 << 2,
+        FailsILVerify = 1 << 3,
+        Fails = FailsPEVerify | FailsILVerify,
     }
 
     /// <summary>
@@ -159,7 +163,7 @@ internal CompilationVerifier Emit(
             if (assemblyValidator != null || symbolValidator != null)
             {
                 // We're dual-purposing emitters here.  In this context, it
-                // tells the validator the version of Emit that is calling it. 
+                // tells the validator the version of Emit that is calling it.
                 RunValidators(verifier, assemblyValidator, symbolValidator);
             }
 
@@ -621,7 +625,7 @@ private static void VerifyOperationTreeContracts(IOperation root)
                 // all operations from spine should belong to the operation tree set
                 VerifyOperationTreeSpine(semanticModel, set, child.Syntax);
 
-                // operation tree's node must be part of root of semantic model which is 
+                // operation tree's node must be part of root of semantic model which is
                 // owner of operation's lifetime
                 Assert.True(semanticModel.Root.FullSpan.Contains(child.Syntax.FullSpan));
             }
diff --git a/src/Compilers/Test/Core/Compilation/IRuntimeEnvironment.cs b/src/Compilers/Test/Core/Compilation/IRuntimeEnvironment.cs
index 00fc3c69f29cc..062c07931cd62 100644
--- a/src/Compilers/Test/Core/Compilation/IRuntimeEnvironment.cs
+++ b/src/Compilers/Test/Core/Compilation/IRuntimeEnvironment.cs
@@ -9,7 +9,6 @@
 using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Reflection.Metadata;
 using System.Reflection.PortableExecutable;
 using System.Runtime.InteropServices;
@@ -91,7 +90,7 @@ private static IEnumerable<ModuleMetadata> EnumerateModules(Metadata metadata)
         /// <summary>
         /// Emit all of the references which are not directly or indirectly a <see cref="Compilation"/> value.
         /// </summary>
-        internal static void EmitReferences(Compilation compilation, HashSet<string> fullNameSet, List<ModuleData> dependencies, DiagnosticBag diagnostics)
+        internal static void EmitReferences(Compilation compilation, HashSet<string> fullNameSet, List<ModuleData> dependencies, DiagnosticBag diagnostics, AssemblyIdentity corLibIdentity)
         {
             // NOTE: specifically don't need to consider previous submissions since they will always be compilations.
             foreach (var metadataReference in compilation.References)
@@ -115,6 +114,7 @@ internal static void EmitReferences(Compilation compilation, HashSet<string> ful
                     continue;
                 }
 
+                var isCorLib = isManifestModule && corLibIdentity == identity;
                 foreach (var module in EnumerateModules(metadata))
                 {
                     ImmutableArray<byte> bytes = module.Module.PEReaderOpt.GetEntireImage().GetContent();
@@ -126,14 +126,16 @@ internal static void EmitReferences(Compilation compilation, HashSet<string> ful
                                                     OutputKind.DynamicallyLinkedLibrary,
                                                     bytes,
                                                     pdb: default(ImmutableArray<byte>),
-                                                    inMemoryModule: true);
+                                                    inMemoryModule: true,
+                                                    isCorLib);
                     }
                     else
                     {
                         moduleData = new ModuleData(module.Name,
                                                     bytes,
                                                     pdb: default(ImmutableArray<byte>),
-                                                    inMemoryModule: true);
+                                                    inMemoryModule: true,
+                                                    isCorLib: false);
                     }
 
                     dependencies.Add(moduleData);
@@ -194,9 +196,10 @@ private static List<Compilation> FindDirectReferencedCompilations(Compilation co
             List<ModuleData> dependencies,
             DiagnosticBag diagnostics,
             CompilationTestData testData,
-            EmitOptions emitOptions
-        )
+            EmitOptions emitOptions)
         {
+            var corLibIdentity = compilation.GetSpecialType(SpecialType.System_Object).ContainingAssembly.Identity;
+
             // A Compilation can appear multiple times in a dependency graph as both a Compilation and as a MetadataReference
             // value.  Iterate the Compilations eagerly so they are always emitted directly and later references can re-use 
             // the value.  This gives better, and consistent, diagnostic information.
@@ -208,11 +211,13 @@ EmitOptions emitOptions
                 var emitData = EmitCompilationCore(referencedCompilation, null, diagnostics, null, emitOptions);
                 if (emitData.HasValue)
                 {
-                    var moduleData = new ModuleData(referencedCompilation.Assembly.Identity,
+                    var identity = referencedCompilation.Assembly.Identity;
+                    var moduleData = new ModuleData(identity,
                                                     OutputKind.DynamicallyLinkedLibrary,
                                                     emitData.Value.Assembly,
                                                     pdb: default(ImmutableArray<byte>),
-                                                    inMemoryModule: true);
+                                                    inMemoryModule: true,
+                                                    isCorLib: corLibIdentity == identity);
                     fullNameSet.Add(moduleData.Id.FullName);
                     dependencies.Add(moduleData);
                 }
@@ -221,7 +226,7 @@ EmitOptions emitOptions
             // Now that the Compilation values have been emitted, emit the non-compilation references
             foreach (var current in (new[] { compilation }).Concat(referencedCompilations))
             {
-                EmitReferences(current, fullNameSet, dependencies, diagnostics);
+                EmitReferences(current, fullNameSet, dependencies, diagnostics, corLibIdentity);
             }
 
             return EmitCompilationCore(compilation, manifestResources, diagnostics, testData, emitOptions);
diff --git a/src/Compilers/Test/Core/CompilationVerifier.cs b/src/Compilers/Test/Core/CompilationVerifier.cs
index c66e28937356d..1ed7b012db3a8 100644
--- a/src/Compilers/Test/Core/CompilationVerifier.cs
+++ b/src/Compilers/Test/Core/CompilationVerifier.cs
@@ -7,15 +7,17 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Reflection;
+using System.Reflection.PortableExecutable;
 using System.Runtime.CompilerServices;
 using System.Xml.Linq;
 using ICSharpCode.Decompiler.Metadata;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.DiaSymReader.Tools;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -211,6 +213,9 @@ public void Emit(
             string mainModuleName = Emit(testEnvironment, manifestResources, emitOptions);
             _allModuleData = testEnvironment.GetAllModuleData();
             testEnvironment.Verify(peVerify);
+#if NETCOREAPP
+            ILVerify(peVerify);
+#endif
 
             if (expectedSignatures != null)
             {
@@ -228,6 +233,133 @@ public void Emit(
             }
         }
 
+        private sealed class Resolver : ILVerify.ResolverBase
+        {
+            private readonly Dictionary<string, ImmutableArray<byte>> _imagesByName;
+
+            internal Resolver(Dictionary<string, ImmutableArray<byte>> imagesByName)
+            {
+                _imagesByName = imagesByName;
+            }
+
+            protected override PEReader ResolveCore(string simpleName)
+            {
+                if (_imagesByName.TryGetValue(simpleName, out var image))
+                {
+                    return new PEReader(image);
+                }
+
+                throw new Exception($"ILVerify was not able to resolve a module named '{simpleName}'");
+            }
+        }
+
+        private void ILVerify(Verification verification)
+        {
+            if (verification == Verification.Skipped)
+            {
+                return;
+            }
+
+            var imagesByName = new Dictionary<string, ImmutableArray<byte>>(StringComparer.OrdinalIgnoreCase);
+            foreach (var module in _allModuleData)
+            {
+                string name = module.SimpleName;
+                if (imagesByName.ContainsKey(name))
+                {
+                    if ((verification & Verification.FailsILVerify) != 0)
+                    {
+                        return;
+                    }
+
+                    throw new Exception($"Multiple modules named '{name}' were found");
+                }
+                imagesByName.Add(name, module.Image);
+            }
+
+            var resolver = new Resolver(imagesByName);
+            var verifier = new ILVerify.Verifier(resolver);
+            var mscorlibModule = _allModuleData.SingleOrDefault(m => m.IsCorLib);
+            if (mscorlibModule is null)
+            {
+                if ((verification & Verification.FailsILVerify) != 0)
+                {
+                    return;
+                }
+
+                throw new Exception("No corlib found");
+            }
+
+            // Main module is the first one
+            var mainModuleReader = resolver.Resolve(_allModuleData[0].SimpleName);
+
+            var (succeeded, errorMessage) = verify(verifier, mscorlibModule.SimpleName, mainModuleReader);
+
+            switch (succeeded, (verification & Verification.FailsILVerify) == 0)
+            {
+                case (true, true):
+                    return;
+                case (true, false):
+                    throw new Exception("IL Verify succeeded unexpectedly");
+                case (false, false):
+                    return;
+                case (false, true):
+                    throw new Exception("IL Verify failed unexpectedly: \r\n" + errorMessage);
+            }
+
+            static (bool, string) verify(ILVerify.Verifier verifier, string corlibName, PEReader mainModule)
+            {
+                IEnumerable<ILVerify.VerificationResult> result = null;
+                int errorCount = 0;
+                try
+                {
+                    verifier.SetSystemModuleName(new AssemblyName(corlibName));
+                    result = verifier.Verify(mainModule);
+                    errorCount = result.Count();
+                }
+                catch (Exception e)
+                {
+                    return (false, e.Message);
+                }
+
+                if (errorCount > 0)
+                {
+                    return (false, printVerificationResult(result));
+                }
+
+                return (true, string.Empty);
+            }
+
+            static string printVerificationResult(IEnumerable<ILVerify.VerificationResult> result)
+            {
+                return string.Join("\r\n", result.Select(r => r.Message + printErrorArguments(r.ErrorArguments)));
+            }
+
+            static string printErrorArguments(ILVerify.ErrorArgument[] errorArguments)
+            {
+                if (errorArguments is null
+                    || errorArguments.Length == 0)
+                {
+                    return "";
+                }
+
+                var pooledBuilder = PooledStringBuilder.GetInstance();
+                var builder = pooledBuilder.Builder;
+                builder.Append(" { ");
+                var x = errorArguments.Select(a => a.Name + " = " + a.Value.ToString()).ToArray();
+                for (int i = 0; i < x.Length; i++)
+                {
+                    if (i > 0)
+                    {
+                        builder.Append(", ");
+                    }
+                    builder.Append(x[i]);
+                }
+                builder.Append(" }");
+
+                return pooledBuilder.ToStringAndFree();
+            }
+        }
+
         // TODO(tomat): Fold into CompileAndVerify. 
         // Replace bool verify parameter with string[] expectedPeVerifyOutput. If null, no verification. If empty verify have to succeed. Otherwise compare errors.
         public void EmitAndVerify(params string[] expectedPeVerifyOutput)
diff --git a/src/Compilers/Test/Core/ExceptionHelper.cs b/src/Compilers/Test/Core/ExceptionHelper.cs
index c41608a7c7b56..8e1436698777a 100644
--- a/src/Compilers/Test/Core/ExceptionHelper.cs
+++ b/src/Compilers/Test/Core/ExceptionHelper.cs
@@ -25,11 +25,12 @@ internal static string GetMessageFromResult(IEnumerable<Diagnostic> diagnostics,
             return sb.ToString();
         }
 
-        internal static string GetMessageFromResult(string output, string exePath)
+        internal static string GetMessageFromResult(string output, string exePath, bool isIlVerify = false)
         {
             StringBuilder sb = new StringBuilder();
             sb.AppendLine();
-            sb.Append("PeVerify failed for assembly '");
+            string tool = isIlVerify ? "ILVerify" : "PEVerify";
+            sb.Append($"{tool} failed for assembly '");
             sb.Append(exePath);
             sb.AppendLine("':");
             sb.AppendLine(output);
diff --git a/src/Compilers/Test/Core/Metadata/ModuleData.cs b/src/Compilers/Test/Core/Metadata/ModuleData.cs
index 712aaa4ab92e3..ddaa3ef24b9db 100644
--- a/src/Compilers/Test/Core/Metadata/ModuleData.cs
+++ b/src/Compilers/Test/Core/Metadata/ModuleData.cs
@@ -56,36 +56,40 @@ public sealed class ModuleData
         public readonly ImmutableArray<byte> Image;
         public readonly ImmutableArray<byte> Pdb;
         public readonly bool InMemoryModule;
+        public readonly bool IsCorLib;
 
         public string SimpleName => Id.SimpleName;
         public string FullName => Id.FullName;
         public Guid Mvid => Id.Mvid;
 
-        public ModuleData(string netModuleName, ImmutableArray<byte> image, ImmutableArray<byte> pdb, bool inMemoryModule)
+        public ModuleData(string netModuleName, ImmutableArray<byte> image, ImmutableArray<byte> pdb, bool inMemoryModule, bool isCorLib)
         {
             this.Id = new ModuleDataId(netModuleName, netModuleName, GetMvid(image));
             this.Kind = OutputKind.NetModule;
             this.Image = image;
             this.Pdb = pdb;
             this.InMemoryModule = inMemoryModule;
+            this.IsCorLib = isCorLib;
         }
 
-        public ModuleData(AssemblyIdentity identity, OutputKind kind, ImmutableArray<byte> image, ImmutableArray<byte> pdb, bool inMemoryModule)
+        public ModuleData(AssemblyIdentity identity, OutputKind kind, ImmutableArray<byte> image, ImmutableArray<byte> pdb, bool inMemoryModule, bool isCorLib)
         {
             this.Id = new ModuleDataId(identity.Name, identity.GetDisplayName(), GetMvid(image));
             this.Kind = kind;
             this.Image = image;
             this.Pdb = pdb;
             this.InMemoryModule = inMemoryModule;
+            this.IsCorLib = isCorLib;
         }
 
-        public ModuleData(ModuleDataId id, OutputKind kind, ImmutableArray<byte> image, ImmutableArray<byte> pdb, bool inMemoryModule)
+        public ModuleData(ModuleDataId id, OutputKind kind, ImmutableArray<byte> image, ImmutableArray<byte> pdb, bool inMemoryModule, bool isCorLib)
         {
             this.Id = id;
             this.Kind = kind;
             this.Image = image;
             this.Pdb = pdb;
             this.InMemoryModule = inMemoryModule;
+            this.IsCorLib = isCorLib;
         }
 
         private static Guid GetMvid(ImmutableArray<byte> image)
diff --git a/src/Compilers/Test/Core/Microsoft.CodeAnalysis.Test.Utilities.csproj b/src/Compilers/Test/Core/Microsoft.CodeAnalysis.Test.Utilities.csproj
index 25151e909aae4..c7149688b8f4f 100644
--- a/src/Compilers/Test/Core/Microsoft.CodeAnalysis.Test.Utilities.csproj
+++ b/src/Compilers/Test/Core/Microsoft.CodeAnalysis.Test.Utilities.csproj
@@ -105,6 +105,7 @@
     <PackageReference Include="Basic.Reference.Assemblies.NetStandard20" Version="$(BasicReferenceAssembliesNetStandard20Version)" />
     <PackageReference Include="Basic.Reference.Assemblies.Net50" Version="$(BasicReferenceAssembliesNet50Version)" />
     <PackageReference Include="Basic.Reference.Assemblies.Net60" Version="$(BasicReferenceAssembliesNet60Version)" />
+    <PackageReference Include="Microsoft.ILVerification" Version="$(MicrosoftILVerificationVersion)" />
   </ItemGroup>
 
   <Import Project="Generated.targets" />
diff --git a/src/Compilers/Test/Core/Platform/CoreClr/CoreCLRRuntimeEnvironment.cs b/src/Compilers/Test/Core/Platform/CoreClr/CoreCLRRuntimeEnvironment.cs
index 43251be80d894..dbe385dd965c5 100644
--- a/src/Compilers/Test/Core/Platform/CoreClr/CoreCLRRuntimeEnvironment.cs
+++ b/src/Compilers/Test/Core/Platform/CoreClr/CoreCLRRuntimeEnvironment.cs
@@ -6,9 +6,9 @@
 
 #if NETCOREAPP
 using System;
-using System.Linq;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.Emit;
@@ -52,12 +52,15 @@ public void Emit(
             {
                 var mainImage = mainOutput.Value.Assembly;
                 var mainPdb = mainOutput.Value.Pdb;
+                var corLibIdentity = mainCompilation.GetSpecialType(SpecialType.System_Object).ContainingAssembly.Identity;
+                var identity = mainCompilation.Assembly.Identity;
                 _emitData.MainModule = new ModuleData(
-                    mainCompilation.Assembly.Identity,
+                    identity,
                     mainCompilation.Options.OutputKind,
                     mainImage,
                     pdb: usePdbForDebugging ? mainPdb : default(ImmutableArray<byte>),
-                    inMemoryModule: true);
+                    inMemoryModule: true,
+                    isCorLib: corLibIdentity == identity);
                 _emitData.MainModulePdb = mainPdb;
                 _emitData.AllModuleData = dependencies;
 
@@ -107,9 +110,6 @@ public SortedSet<string> GetMemberSignaturesFromMetadata(string fullyQualifiedTy
 
         public void Verify(Verification verification)
         {
-            var emitData = GetEmitData();
-            emitData.RuntimeData.PeverifyRequested = true;
-            // TODO(https://github.com/dotnet/coreclr/issues/295): Implement peverify
         }
 
         public string[] VerifyModules(string[] modulesToVerify)
diff --git a/src/Compilers/Test/Core/Platform/Desktop/DesktopRuntimeEnvironment.cs b/src/Compilers/Test/Core/Platform/Desktop/DesktopRuntimeEnvironment.cs
index bb26095e369d7..dd534dc1963da 100644
--- a/src/Compilers/Test/Core/Platform/Desktop/DesktopRuntimeEnvironment.cs
+++ b/src/Compilers/Test/Core/Platform/Desktop/DesktopRuntimeEnvironment.cs
@@ -9,13 +9,17 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
 using System.Threading;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
@@ -210,12 +214,15 @@ public void Emit(
             {
                 var mainImage = mainOutput.Value.Assembly;
                 var mainPdb = mainOutput.Value.Pdb;
+                var corLibIdentity = mainCompilation.GetSpecialType(SpecialType.System_Object).ContainingAssembly.Identity;
+                var identity = mainCompilation.Assembly.Identity;
                 _emitData.MainModule = new ModuleData(
-                    mainCompilation.Assembly.Identity,
+                    identity,
                     mainCompilation.Options.OutputKind,
                     mainImage,
                     pdb: usePdbForDebugging ? mainPdb : default(ImmutableArray<byte>),
-                    inMemoryModule: true);
+                    inMemoryModule: true,
+                    isCorLib: corLibIdentity == identity);
                 _emitData.MainModulePdb = mainPdb;
                 _emitData.AllModuleData = dependencies;
 
@@ -241,7 +248,7 @@ public int Execute(string moduleName, string[] args, string expectedOutput, bool
             {
                 var emitData = GetEmitData();
                 emitData.RuntimeData.ExecuteRequested = true;
-                var resultCode = emitData.Manager.Execute(moduleName, args, expectedOutput?.Length, out var output);
+                var resultCode = emitData.Manager.Execute(moduleName, args, expectedOutputLength: expectedOutput?.Length, out var output);
 
                 if (expectedOutput != null)
                 {
@@ -309,15 +316,16 @@ public void Verify(Verification verification)
                 return;
             }
 
-            var shouldSucceed = verification == Verification.Passes;
+            var shouldSucceed = (verification & Verification.FailsPEVerify) == 0;
             var emitData = GetEmitData();
+
             try
             {
                 emitData.RuntimeData.PeverifyRequested = true;
                 emitData.Manager.PeVerifyModules(new[] { emitData.MainModule.FullName }, throwOnError: true);
                 if (!shouldSucceed)
                 {
-                    throw new Exception("Verification succeeded unexpectedly");
+                    throw new Exception("PE Verify succeeded unexpectedly");
                 }
             }
             catch (RuntimePeVerifyException ex)
diff --git a/src/Compilers/Test/Core/Platform/Desktop/RuntimeModuleData.cs b/src/Compilers/Test/Core/Platform/Desktop/RuntimeModuleData.cs
index a5d65631049e3..bf6ea756e2ed0 100644
--- a/src/Compilers/Test/Core/Platform/Desktop/RuntimeModuleData.cs
+++ b/src/Compilers/Test/Core/Platform/Desktop/RuntimeModuleData.cs
@@ -67,7 +67,8 @@ private RuntimeModuleData(SerializationInfo info, StreamingContext context)
             var image = info.GetByteArray(nameof(ModuleData.Image));
             var pdb = info.GetByteArray(nameof(ModuleData.Pdb));
             var inMemoryModule = info.GetBoolean(nameof(ModuleData.InMemoryModule));
-            Data = new ModuleData(id.Id, kind, image, pdb, inMemoryModule);
+            var isCorLib = info.GetBoolean(nameof(ModuleData.IsCorLib));
+            Data = new ModuleData(id.Id, kind, image, pdb, inMemoryModule, isCorLib);
         }
 
         public void GetObjectData(SerializationInfo info, StreamingContext context)
@@ -77,6 +78,7 @@ public void GetObjectData(SerializationInfo info, StreamingContext context)
             info.AddByteArray(nameof(ModuleData.Image), Data.Image);
             info.AddByteArray(nameof(ModuleData.Pdb), Data.Pdb);
             info.AddValue(nameof(ModuleData.InMemoryModule), Data.InMemoryModule);
+            info.AddValue(nameof(ModuleData.IsCorLib), Data.IsCorLib);
         }
     }
 }
diff --git a/src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb b/src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb
index 5085180d99d03..77914f0881528 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Attributes/AssemblyAttributes.vb
@@ -566,7 +566,7 @@ end class
                          dependencies:={New ModuleData(en_usRef.Compilation.Assembly.Identity,
                                                        OutputKind.DynamicallyLinkedLibrary,
                                                        en_usRef.Compilation.EmitToArray(),
-                                                       ImmutableArray(Of Byte).Empty, False)}).
+                                                       ImmutableArray(Of Byte).Empty, False, False)}).
             VerifyDiagnostics()
 
         compilation = CreateCompilationWithMscorlib40AndReferences(
@@ -599,11 +599,11 @@ end class
                          dependencies:={New ModuleData(en_UKRef.Compilation.Assembly.Identity,
                                                        OutputKind.DynamicallyLinkedLibrary,
                                                        en_UKRef.Compilation.EmitToArray(),
-                                                       ImmutableArray(Of Byte).Empty, False),
+                                                       ImmutableArray(Of Byte).Empty, False, False),
                                         New ModuleData(neutralRef.Compilation.Assembly.Identity,
                                                        OutputKind.DynamicallyLinkedLibrary,
                                                        neutralRef.Compilation.EmitToArray(),
-                                                       ImmutableArray(Of Byte).Empty, False)},
+                                                       ImmutableArray(Of Byte).Empty, False, False)},
                          sourceSymbolValidator:=Sub(m As ModuleSymbol)
                                                     Assert.Equal(1, m.GetReferencedAssemblySymbols().Length)
 
@@ -764,8 +764,10 @@ end class
     ]]></file>
 </compilation>, options:=TestOptions.ReleaseDll, references:={hash_module})
 
+        ' ILVerify: Assembly or module not found: hash_module
         CompileAndVerify(compilation,
             manifestResources:=hash_resources,
+            verify:=Verification.FailsILVerify,
             validator:=Sub(peAssembly)
                            Dim reader = peAssembly.ManifestModule.GetMetadataReader()
                            Dim assembly As AssemblyDefinition = reader.GetAssemblyDefinition()
@@ -796,6 +798,7 @@ end class
 
         CompileAndVerify(compilation,
             manifestResources:=hash_resources,
+            verify:=Verification.FailsILVerify,
             validator:=Sub(peAssembly)
                            Dim reader = peAssembly.ManifestModule.GetMetadataReader()
                            Dim assembly As AssemblyDefinition = reader.GetAssemblyDefinition()
@@ -826,6 +829,7 @@ end class
 
         CompileAndVerify(compilation,
             manifestResources:=hash_resources,
+            verify:=Verification.FailsILVerify,
             validator:=Sub(peAssembly)
                            Dim reader = peAssembly.ManifestModule.GetMetadataReader()
                            Dim assembly As AssemblyDefinition = reader.GetAssemblyDefinition()
@@ -856,6 +860,7 @@ end class
 
         CompileAndVerify(compilation,
             manifestResources:=hash_resources,
+            verify:=Verification.FailsILVerify,
             validator:=Sub(peAssembly)
                            Dim reader = peAssembly.ManifestModule.GetMetadataReader()
                            Dim assembly As AssemblyDefinition = reader.GetAssemblyDefinition()
@@ -994,6 +999,7 @@ end class
 </compilation>, options:=TestOptions.ReleaseDll, references:={hash_module_Comp.EmitToImageReference()})
 
         CompileAndVerify(compilation,
+            verify:=Verification.FailsILVerify,
             validator:=Sub(peAssembly)
                            Dim metadataReader = peAssembly.ManifestModule.GetMetadataReader()
                            Dim assembly As AssemblyDefinition = metadataReader.GetAssemblyDefinition()
diff --git a/src/Compilers/VisualBasic/Test/Emit/Attributes/AttributeTests_StructLayout.vb b/src/Compilers/VisualBasic/Test/Emit/Attributes/AttributeTests_StructLayout.vb
index 959790bcc981e..01d8b03f30952 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Attributes/AttributeTests_StructLayout.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Attributes/AttributeTests_StructLayout.vb
@@ -389,8 +389,8 @@ End Class
                 End Sub
 
             CompileAndVerify(verifiable, validator:=validator)
-            CompileAndVerify(unverifiable, validator:=validator, verify:=Verification.Fails)
-            CompileAndVerify(unloadable, validator:=validator, verify:=Verification.Fails)
+            CompileAndVerify(unverifiable, validator:=validator, verify:=Verification.FailsPEVerify)
+            CompileAndVerify(unloadable, validator:=validator, verify:=Verification.FailsPEVerify)
         End Sub
 
         <Fact>
@@ -566,7 +566,7 @@ End Class
     </file>
 </compilation>
             ' type C can't be loaded
-            CompileAndVerify(source, verify:=Verification.Fails)
+            CompileAndVerify(source, verify:=Verification.FailsPEVerify)
         End Sub
 
         <Fact>
diff --git a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenForeach.vb b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenForeach.vb
index 088a1e40c2787..b4eb840796ebd 100644
--- a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenForeach.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenForeach.vb
@@ -2,6 +2,7 @@
 ' The .NET Foundation licenses this file to you under the MIT license.
 ' See the LICENSE file in the project root for more information.
 
+Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Roslyn.Test.Utilities
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
@@ -2399,6 +2400,7 @@ End Class
 
         <Fact>
         Public Sub NoObjectCopyForGetCurrent()
+            ' ILVerify: Unexpected type on the stack. { Offset = 25, Found = readonly address of '[...]C2+S1', Expected = address of '[...]C2+S1' }
             Dim TEMP = CompileAndVerify(
 <compilation>
     <file name="a.vb">      
@@ -2435,7 +2437,7 @@ End Class
 </compilation>, expectedOutput:=<![CDATA[
 23
 42
-]]>).VerifyIL("C2.DoStuff", <![CDATA[
+]]>, verify:=Verification.FailsILVerify).VerifyIL("C2.DoStuff", <![CDATA[
 {
   // Code size       66 (0x42)
   .maxstack  1
diff --git a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenScriptTests.vb b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenScriptTests.vb
index 23c7449834924..950f9c14c18db 100644
--- a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenScriptTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenScriptTests.vb
@@ -359,7 +359,8 @@ System.Console.Write("complete")
                 "s0.dll",
                 syntaxTree:=Parse(source0.Value, parseOptions),
                 references:=references)
-            Dim verifier = CompileAndVerify(s0, verify:=Verification.Fails)
+            ' PEVerify: Error: Assembly name contains leading spaces or path or extension.
+            Dim verifier = CompileAndVerify(s0, verify:=Verification.FailsPEVerify)
             Dim methodData = verifier.TestData.GetMethodData("Script.<Initialize>")
             Assert.Equal("System.Threading.Tasks.Task(Of Object)", methodData.Method.ReturnType.ToDisplayString())
             methodData.VerifyIL(
diff --git a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTests.vb b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTests.vb
index 350a25bdf25df..9aaee010a99c0 100644
--- a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTests.vb
@@ -21,6 +21,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
         <WorkItem(776642, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/776642")>
         <Fact()>
         Public Sub Bug776642a()
+            ' ILVerify: Unexpected type on the stack. { Offset = 16, Found = readonly address of '[...]OuterStruct', Expected = address of '[...]OuterStruct' }
             CompileAndVerify(
 <compilation>
     <file name="a.vb">
@@ -51,7 +52,7 @@ Structure OuterStruct
     Public z As DoubleAndStruct
 End Structure
     </file>
-</compilation>).
+</compilation>, verify:=Verification.FailsILVerify).
             VerifyIL("Program.M",
             <![CDATA[
 {
@@ -130,6 +131,7 @@ End Class
 
         <Fact()>
         Public Sub Bug776642a_ref()
+            ' ILVerify: Unexpected type on the stack. { Offset = 30, Found = readonly address of '[...]OuterStruct', Expected = address of '[...]OuterStruct' }
             CompileAndVerify(
 <compilation>
     <file name="a.vb">
@@ -164,7 +166,7 @@ Structure OuterStruct
     Public z As DoubleAndStruct
 End Structure
     </file>
-</compilation>).
+</compilation>, verify:=Verification.FailsILVerify).
             VerifyIL("Program.M",
             <![CDATA[
 {
@@ -6061,7 +6063,8 @@ End Module
         <WorkItem(538865, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538865")>
         <Fact>
         Public Sub TestGetObjectValueCalls()
-
+            ' ILVerify null ref
+            ' Tracked by https//github.com/dotnet/roslyn/issues/58652
             Dim verifier = CompileAndVerify(
 <compilation>
     <file name="a.vb">
@@ -6286,7 +6289,7 @@ Module Program1
 
 End Module
     </file>
-</compilation>, references:={TestReferences.SymbolsTests.PropertiesWithByRef})
+</compilation>, references:={TestReferences.SymbolsTests.PropertiesWithByRef}, verify:=Verification.FailsILVerify)
 
             verifier.VerifyIL("Module1.M",
             <![CDATA[
diff --git a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTryCatchThrow.vb b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTryCatchThrow.vb
index d00b38283ffb9..d718efd23cea2 100644
--- a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTryCatchThrow.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTryCatchThrow.vb
@@ -2,6 +2,7 @@
 ' The .NET Foundation licenses this file to you under the MIT license.
 ' See the LICENSE file in the project root for more information.
 
+Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Roslyn.Test.Utilities
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
@@ -81,6 +82,7 @@ expectedOutput:="TryCatchDivideByZeroExceptionFinally").
 
         <Fact()>
         Public Sub GotoOutOfCatch()
+            ' ILVerify: Leave into try block. { Offset = 55 }
             CompileAndVerify(
 <compilation>
     <file name="a.vb">
@@ -119,6 +121,7 @@ L2:
 End Module
     </file>
 </compilation>,
+verify:=Verification.FailsILVerify,
 expectedOutput:="TryGoToCatchFinally").
             VerifyIL("EmitTest.Main",
             <![CDATA[
diff --git a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTuples.vb b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTuples.vb
index eeb80e41efae9..2b860abe9c77c 100644
--- a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTuples.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenTuples.vb
@@ -5011,7 +5011,7 @@ Class C
 End Class
 
     </file>
-</compilation>, references:={ValueTupleRef, SystemRuntimeFacadeRef, MscorlibRef_v46}, expectedOutput:=<![CDATA[42]]>)
+</compilation>, references:={ValueTupleRef, SystemRuntimeFacadeRef, MscorlibRef_v46}, expectedOutput:=<![CDATA[42]]>, verify:=Verification.FailsILVerify)
 
             verifier.VerifyDiagnostics()
             verifier.VerifyIL("C.VB$StateMachine_2_Test(Of SM$T).MoveNext()", <![CDATA[
@@ -5130,7 +5130,7 @@ Class C
     End Function
 End Class
     </file>
-</compilation>, references:={ValueTupleRef, SystemRuntimeFacadeRef, MscorlibRef_v46}, expectedOutput:=<![CDATA[(42, 42)]]>)
+</compilation>, references:={ValueTupleRef, SystemRuntimeFacadeRef, MscorlibRef_v46}, expectedOutput:=<![CDATA[(42, 42)]]>, verify:=Verification.FailsILVerify)
 
             verifier.VerifyDiagnostics()
             verifier.VerifyIL("C.VB$StateMachine_2_Test(Of SM$T).MoveNext()", <![CDATA[
@@ -5278,7 +5278,10 @@ End Namespace
 
         <Fact>
         Public Sub LongTupleWithSubstitution()
-
+            ' ILVerify:
+            ' Failed to load type 'System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1' from assembly 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
+            ' Failed to load type 'System.Runtime.CompilerServices.YieldAwaitable' from assembly 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
+            ' Failed to load type 'System.Runtime.CompilerServices.IAsyncStateMachine' from assembly 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
             Dim verifier = CompileAndVerify(
 <compilation>
     <file name="a.vb">
@@ -5296,7 +5299,7 @@ Class C
     End Function
 End Class
     </file>
-</compilation>, references:={ValueTupleRef, SystemRuntimeFacadeRef, MscorlibRef_v46}, expectedOutput:=<![CDATA[42]]>)
+</compilation>, references:={ValueTupleRef, SystemRuntimeFacadeRef, MscorlibRef_v46}, expectedOutput:=<![CDATA[42]]>, verify:=Verification.FailsILVerify)
 
             verifier.VerifyDiagnostics()
 
diff --git a/src/Compilers/VisualBasic/Test/Emit/CodeGen/WinRTCollectionTests.vb b/src/Compilers/VisualBasic/Test/Emit/CodeGen/WinRTCollectionTests.vb
index 0ad2dd394ef9d..b423ef412fa05 100644
--- a/src/Compilers/VisualBasic/Test/Emit/CodeGen/WinRTCollectionTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/CodeGen/WinRTCollectionTests.vb
@@ -4207,9 +4207,12 @@ End Class
                     </file>
                 </compilation>
 
+            ' PEVerify:
+            ' [ : AllMembers::ValidateMethod][mdToken=0x6000003]  [HRESULT 0x8000000F] - Typename or Namespace was not found in metadata file.
+            ' [ : AllMembers::TestExpressionTreeCompiler][mdToken=0x6000005][offset 0x00000007] Unable to resolve token.
             Dim verifier = CompileAndVerify(source,
                 references:=LegacyRefs,
-                verify:=Verification.Fails)
+                verify:=Verification.FailsPEVerify)
             AssertNoErrorsOrWarnings(verifier)
             verifier.VerifyIL("AllMembers.TestExpressionTreeCompiler", <![CDATA[
 {
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
index 8d857b7525507..d714a939c4d32 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/CompilationEmitTests.vb
@@ -690,7 +690,8 @@ End Class"
 
             Dim comp = CreateEmptyCompilation({Parse("")})
             comp.MakeMemberMissing(WellKnownMember.System_Runtime_CompilerServices_ReferenceAssemblyAttribute__ctor)
-            CompileAndVerify(comp, emitOptions:=emitRefAssembly, verify:=Verification.Passes, validator:=assemblyValidator)
+            ' ILVerify: Failed to load type 'System.String' from assembly ...
+            CompileAndVerify(comp, emitOptions:=emitRefAssembly, verify:=Verification.FailsILVerify, validator:=assemblyValidator)
         End Sub
 
         <Fact>
@@ -3848,7 +3849,7 @@ End Class
 
             Dim comp = CreateCompilationWithMscorlib40(source1, OutputKind.NetModule)
             Dim metadataRef = comp.EmitToImageReference()
-            CompileAndVerify(source2, references:={metadataRef}, options:=TestOptions.ReleaseModule, verify:=Verification.Fails)
+            CompileAndVerify(source2, references:={metadataRef}, options:=TestOptions.ReleaseModule, verify:=Verification.FailsPEVerify Or Verification.FailsILVerify)
         End Sub
 
         <Fact>
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.vb
index f3be22ee50635..c0b6cca35d6b6 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/AssemblyReferencesTests.vb
@@ -329,7 +329,8 @@ End Class
             Dim compilation0 = CreateCompilationWithMscorlib40({src0}, {ref01, ref11}, assemblyName:="C", options:=TestOptions.DebugDll)
             Dim compilation1 = compilation0.WithSource(src1).WithReferences({MscorlibRef, ref02, ref12})
 
-            Dim v0 = CompileAndVerify(compilation0)
+            ' ILVerify: Failed to load type 'D1' from assembly 'Lib, Version=1.0.0.1, Culture=neutral, PublicKeyToken=ce65828c82a341f2'
+            Dim v0 = CompileAndVerify(compilation0, verify:=Verification.FailsILVerify)
 
             Dim f0 = compilation0.GetMember(Of MethodSymbol)("C.F")
             Dim f1 = compilation1.GetMember(Of MethodSymbol)("C.F")
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.vb
index c2f752b822be3..775da1ebd068d 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/EditAndContinue/EditAndContinueStateMachineTests.vb
@@ -4679,7 +4679,7 @@ End Class
 
             Assert.Null(compilation0.GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_AsyncStateMachineAttribute__ctor))
 
-            Dim v0 = CompileAndVerify(compilation0, verify:=Verification.Fails)
+            Dim v0 = CompileAndVerify(compilation0, verify:=Verification.FailsPEVerify)
             Dim md0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData)
 
             Dim f0 = compilation0.GetMember(Of MethodSymbol)("C.F")
@@ -4756,7 +4756,7 @@ End Class
 
             Assert.Null(compilation0.GetWellKnownTypeMember(WellKnownMember.System_Runtime_CompilerServices_AsyncStateMachineAttribute__ctor))
 
-            Dim v0 = CompileAndVerify(compilation0, verify:=Verification.Fails)
+            Dim v0 = CompileAndVerify(compilation0, verify:=Verification.FailsPEVerify)
             Dim md0 = ModuleMetadata.CreateFromImage(v0.EmittedAssemblyData)
 
             Dim f0 = compilation0.GetMember(Of MethodSymbol)("C.F")
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/EmitMetadata.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/EmitMetadata.vb
index 7f88bb02b0849..9919b6883423f 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/EmitMetadata.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/EmitMetadata.vb
@@ -269,7 +269,8 @@ End Class
                                         {mscorlibRef, multiModule},
                                         TestOptions.ReleaseDll)
 
-            dllImage = CompileAndVerify(c2).EmittedAssemblyData
+            ' ILVerify: The method or operation is not implemented.
+            dllImage = CompileAndVerify(c2, verify:=Verification.FailsILVerify).EmittedAssemblyData
 
             Using metadata = AssemblyMetadata.CreateFromImage(dllImage)
                 Dim emitAssemblyRefs2 As PEAssembly = metadata.GetAssembly
@@ -307,7 +308,8 @@ End Class
             Dim class1 = c1.GlobalNamespace.GetMembers("Class1")
             Assert.Equal(1, class1.Count())
 
-            Dim manifestModule = CompileAndVerify(c1).EmittedAssemblyData
+            ' ILVerify: Assembly or module not found: netModule1
+            Dim manifestModule = CompileAndVerify(c1, verify:=Verification.FailsILVerify).EmittedAssemblyData
 
             Using metadata = AssemblyMetadata.Create(ModuleMetadata.CreateFromImage(manifestModule), netModule1, netModule2)
                 Dim emitAddModule As PEAssembly = metadata.GetAssembly
diff --git a/src/Compilers/VisualBasic/Test/Emit/Emit/NoPiaEmbedTypes.vb b/src/Compilers/VisualBasic/Test/Emit/Emit/NoPiaEmbedTypes.vb
index e6fe80e2af427..e921e126c1fa7 100644
--- a/src/Compilers/VisualBasic/Test/Emit/Emit/NoPiaEmbedTypes.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/Emit/NoPiaEmbedTypes.vb
@@ -1533,7 +1533,8 @@ End Interface
 ]]></file>
                            </compilation>
             Dim compilation0 = CreateCompilationWithMscorlib40(sources0)
-            Dim verifier = CompileAndVerify(compilation0, verify:=Verification.Fails)
+            ' PEVerify: Error: Method cannot be both generic and defined on an imported type.
+            Dim verifier = CompileAndVerify(compilation0, verify:=Verification.FailsPEVerify)
             AssertTheseDiagnostics(verifier, (<errors/>))
             Dim validator As Action(Of ModuleSymbol) = Sub([module])
                                                            DirectCast([module], PEModuleSymbol).Module.PretendThereArentNoPiaLocalTypes()
@@ -1603,13 +1604,13 @@ End Interface
                 sources1,
                 options:=TestOptions.DebugDll,
                 references:={New VisualBasicCompilationReference(compilation0, embedInteropTypes:=True), SystemCoreRef})
-            verifier = CompileAndVerify(compilation1, symbolValidator:=validator, verify:=Verification.Fails)
+            verifier = CompileAndVerify(compilation1, symbolValidator:=validator, verify:=Verification.FailsPEVerify)
             AssertTheseDiagnostics(verifier, (<errors/>))
             compilation1 = CreateCompilationWithMscorlib40AndVBRuntimeAndReferences(
                 sources1,
                 options:=TestOptions.DebugDll,
                 references:={compilation0.EmitToImageReference(embedInteropTypes:=True), SystemCoreRef})
-            verifier = CompileAndVerify(compilation1, symbolValidator:=validator, verify:=Verification.Fails)
+            verifier = CompileAndVerify(compilation1, symbolValidator:=validator, verify:=Verification.FailsPEVerify)
             AssertTheseDiagnostics(verifier, (<errors/>))
         End Sub
 
@@ -3711,12 +3712,12 @@ BC31539: Cannot find the interop type that matches the embedded type 'I1'. Are y
             Dim compilation3 = CreateCompilationWithMscorlib40AndReferences(
                 consumer,
                 references:={New VisualBasicCompilationReference(piaCompilation2)})
-            CompileAndVerify(compilation3, verify:=Verification.Fails)
+            CompileAndVerify(compilation3, verify:=Verification.FailsPEVerify)
 
             Dim compilation4 = CreateCompilationWithMscorlib40AndReferences(
                 consumer,
                 references:={MetadataReference.CreateFromImage(piaCompilation2.EmitToArray())})
-            CompileAndVerify(compilation4, verify:=Verification.Fails)
+            CompileAndVerify(compilation4, verify:=Verification.FailsPEVerify)
         End Sub
 
         <Fact()>
@@ -4128,15 +4129,17 @@ BC36924: Type 'List(Of I1)' cannot be used across assembly boundaries because it
             VerifyEmitDiagnostics(compilation2, errors)
             VerifyEmitMetadataOnlyDiagnostics(compilation2)
 
+            ' PEVerify: [ : C::M][mdToken=0x6000002][offset 0x00000001] Unable to resolve token.
             Dim compilation3 = CreateCompilationWithMscorlib40AndReferences(
                 consumer,
                 references:={New VisualBasicCompilationReference(piaCompilation2)})
-            CompileAndVerify(compilation3, verify:=Verification.Fails)
+            CompileAndVerify(compilation3, verify:=Verification.FailsPEVerify)
 
+            ' PEVerify: [ : C::M][mdToken=0x6000002][offset 0x00000001] Unable to resolve token.
             Dim compilation4 = CreateCompilationWithMscorlib40AndReferences(
                 consumer,
                 references:={MetadataReference.CreateFromImage(piaCompilation2.EmitToArray())})
-            CompileAndVerify(compilation4, verify:=Verification.Fails)
+            CompileAndVerify(compilation4, verify:=Verification.FailsPEVerify)
         End Sub
 
         <Fact(), WorkItem(673546, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/673546")>
diff --git a/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb b/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb
index cd520e863fe3d..54e4c38a1c6e2 100644
--- a/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/ExpressionTrees/CodeGenExprLambda.vb
@@ -1820,7 +1820,8 @@ End Structure
                                                      Optional checked As Boolean = True,
                                                      Optional optimize As Boolean = True,
                                                      Optional latestReferences As Boolean = False,
-                                                     Optional addXmlReferences As Boolean = False) As CompilationVerifier
+                                                     Optional addXmlReferences As Boolean = False,
+                                                     Optional verify As Verification = Verification.Passes) As CompilationVerifier
 
             Debug.Assert(Not latestReferences OrElse Not addXmlReferences) ' NYI
 
@@ -1833,7 +1834,8 @@ End Structure
                 options:=If(optimize, TestOptions.ReleaseExe, TestOptions.DebugExe).WithOverflowChecks(checked),
                 expectedOutput:=If(result IsNot Nothing, result.Trim, Nothing),
                 references:=If(addXmlReferences, Net40XmlReferences, {}),
-                useLatestFramework:=latestReferences)
+                useLatestFramework:=latestReferences,
+                verify:=verify)
         End Function
 
         Private Sub TestExpressionTrees(sourceFile As XElement, result As String,
@@ -1841,9 +1843,10 @@ End Structure
                                         Optional optimize As Boolean = True,
                                         Optional latestReferences As Boolean = False,
                                         Optional addXmlReferences As Boolean = False,
-                                        Optional diagnostics() As DiagnosticDescription = Nothing)
+                                        Optional diagnostics() As DiagnosticDescription = Nothing,
+                                        Optional verify As Verification = Verification.Passes)
 
-            TestExpressionTreesVerifier(sourceFile, result, checked, optimize, latestReferences, addXmlReferences).VerifyDiagnostics(If(diagnostics, {}))
+            TestExpressionTreesVerifier(sourceFile, result, checked, optimize, latestReferences, addXmlReferences, verify).VerifyDiagnostics(If(diagnostics, {}))
         End Sub
 
         Private Sub TestExpressionTrees(sourceFile As XElement, result As XCData,
@@ -3667,6 +3670,7 @@ Lambda(
 
         <Fact>
         Public Sub ExprTree_LegacyTests02_v40()
+            ' ILVerify: Unrecognized arguments for delegate .ctor. { Offset = 1223 }
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
 Imports System
@@ -3707,11 +3711,12 @@ Module Form1
     End Sub
 End Module
 ]]></file>
-            TestExpressionTrees(file, ExpTreeTestResources.ExprTree_LegacyTests02_v40_Result)
+            TestExpressionTrees(file, ExpTreeTestResources.ExprTree_LegacyTests02_v40_Result, verify:=Verification.FailsILVerify)
         End Sub
 
         <Fact>
         Public Sub ExprTree_LegacyTests02_v45()
+            ' ILVerify: Unrecognized arguments for delegate .ctor. { Offset = 1167 }
             Dim file = <file name="expr.vb"><![CDATA[
 Option Strict Off 
 Imports System
@@ -3749,7 +3754,7 @@ Module Form1
     End Sub
 End Module
 ]]></file>
-            TestExpressionTrees(file, ExpTreeTestResources.ExprTree_LegacyTests02_v45_Result, latestReferences:=True)
+            TestExpressionTrees(file, ExpTreeTestResources.ExprTree_LegacyTests02_v45_Result, latestReferences:=True, verify:=Verification.FailsILVerify)
         End Sub
 
         <Fact>
diff --git a/src/Compilers/VisualBasic/Test/Emit/PDB/PDBTests.vb b/src/Compilers/VisualBasic/Test/Emit/PDB/PDBTests.vb
index 032515496a3cf..8039de658d6eb 100644
--- a/src/Compilers/VisualBasic/Test/Emit/PDB/PDBTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/PDB/PDBTests.vb
@@ -691,7 +691,8 @@ End Module
 </file>
 </compilation>
 
-            Dim v = CompileAndVerify(CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.DebugExe))
+            ' ILVerify: Leave into try block. { Offset = 75 }
+            Dim v = CompileAndVerify(CreateCompilationWithMscorlib40AndVBRuntime(source, TestOptions.DebugExe), verify:=Verification.FailsILVerify)
 
             v.VerifyIL("M1.Main", "
 {
diff --git a/src/Compilers/VisualBasic/Test/Emit/XmlLiteralTests.vb b/src/Compilers/VisualBasic/Test/Emit/XmlLiteralTests.vb
index f17c093a1af79..879062699732b 100644
--- a/src/Compilers/VisualBasic/Test/Emit/XmlLiteralTests.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/XmlLiteralTests.vb
@@ -6,6 +6,7 @@ Imports System.IO
 Imports System.Text
 Imports Microsoft.Cci
 Imports Microsoft.CodeAnalysis.PooledObjects
+Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
 Imports Roslyn.Test.Utilities
 
@@ -2915,6 +2916,7 @@ End Module
         <WorkItem(544461, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544461")>
         <Fact()>
         Public Sub ValueExtensionProperty()
+            ' ILVerify: Unexpected type on the stack. { Offset = 117, Found = ref '[mscorlib]System.Collections.Generic.IEnumerable`1<T0>', Expected = ref '[mscorlib]System.Collections.Generic.IEnumerable`1<System.Xml.Linq.XElement>' }
             Dim compilation = CompileAndVerify(
 <compilation>
     <file name="c.vb"><![CDATA[
@@ -2967,7 +2969,7 @@ Module M
     End Sub
 End Module
     ]]></file>
-</compilation>, references:=Net40XmlReferences)
+</compilation>, references:=Net40XmlReferences, verify:=Verification.FailsILVerify)
             compilation.VerifyIL("M.M(Of T)", <![CDATA[
 {
   // Code size      166 (0xa6)
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Compilation/CompilationAPITests.vb b/src/Compilers/VisualBasic/Test/Semantic/Compilation/CompilationAPITests.vb
index f7dcfd92492c2..1d788a7e37974 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Compilation/CompilationAPITests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Compilation/CompilationAPITests.vb
@@ -903,7 +903,8 @@ End Class
 </compilation>, references:={netModule1.EmitToImageReference(), netModule2.EmitToImageReference()})
             assembly.VerifyDiagnostics()
 
-            CompileAndVerify(assembly)
+            ' ILVerify: Assembly or module not found: missing2
+            CompileAndVerify(assembly, verify:=Verification.FailsILVerify)
         End Sub
 
         <WorkItem(713356, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/713356")>
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Semantics/ConditionalAccessTests.vb b/src/Compilers/VisualBasic/Test/Semantic/Semantics/ConditionalAccessTests.vb
index 813cc68418b46..e7d1ea2c9a88b 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Semantics/ConditionalAccessTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Semantics/ConditionalAccessTests.vb
@@ -1203,7 +1203,8 @@ End Class
 
             ' VB seems to allow methods that return TypedReference, likely for compat reasons
             ' that is technically not verifiable, but it is not relevant to this test
-            Dim verifier = CompileAndVerify(compilation, verify:=Verification.Fails, expectedOutput:=
+            ' PEVerify: [ : C1::F][mdToken=0x6000003][offset 0x00000013] Return type is ByRef, TypedReference, ArgHandle, or ArgIterator.
+            Dim verifier = CompileAndVerify(compilation, verify:=Verification.FailsPEVerify, expectedOutput:=
             <![CDATA[
 hi
 ]]>)
@@ -3998,6 +3999,7 @@ BC41999: Implicit conversion from 'I1' to 'C1' in copying the value of 'ByRef' p
         ~
 ]]></expected>)
 
+            ' ILVerify: Unexpected type on the stack. { Offset = 39, Found = readonly address of '[...]S1', Expected = address of '[...]S1' }
             Dim verifier = CompileAndVerify(compilation, expectedOutput:=
             <![CDATA[
  ---------
@@ -4060,7 +4062,7 @@ C1
 Ext4
 C1
 ---------
-]]>)
+]]>, verify:=Verification.FailsILVerify)
         End Sub
 
 
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Semantics/IReadOnlyListAndCollection.vb b/src/Compilers/VisualBasic/Test/Semantic/Semantics/IReadOnlyListAndCollection.vb
index 98d104745cea5..3ccdc37940797 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Semantics/IReadOnlyListAndCollection.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Semantics/IReadOnlyListAndCollection.vb
@@ -2,6 +2,7 @@
 ' The .NET Foundation licenses this file to you under the MIT license.
 ' See the LICENSE file in the project root for more information.
 
+Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Microsoft.CodeAnalysis.Text
 Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
 Imports Microsoft.CodeAnalysis.VisualBasic.Syntax
@@ -115,6 +116,7 @@ End Module
 <expected>
 </expected>)
 
+            ' ILVerify: Unexpected type on the stack. { Offset = 232, Found = ref 'int32[][]', Expected = ref '[mscorlib]System.Collections.Generic.IList`1<System.Collections.Generic.IReadOnlyList`1<int32>>' }
             CompileAndVerify(compilation,
             <![CDATA[
 3
@@ -131,7 +133,7 @@ ProcessReadOnlyList3
 ProcessReadOnlyList3
 ProcessReadOnlyList3
 ProcessReadOnlyListOfObject3
-]]>)
+]]>, verify:=Verification.FailsILVerify)
 
         End Sub
 
@@ -330,6 +332,7 @@ End Module
 <expected>
 </expected>)
 
+            ' ILVerify: Unexpected type on the stack. { Offset = 232, Found = ref 'int32[][]', Expected = ref '[mscorlib]System.Collections.Generic.IList`1<System.Collections.Generic.IReadOnlyCollection`1<int32>>' }
             CompileAndVerify(compilation,
             <![CDATA[
 3
@@ -346,7 +349,7 @@ ProcessReadOnlyCollection3
 ProcessReadOnlyCollection3
 ProcessReadOnlyCollection3
 ProcessReadOnlyCollectionOfObject3
-]]>)
+]]>, verify:=Verification.FailsILVerify)
 
         End Sub
 
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Semantics/UseSiteErrorTests.vb b/src/Compilers/VisualBasic/Test/Semantic/Semantics/UseSiteErrorTests.vb
index fd4065bf7f78e..0ba35cee30ca1 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Semantics/UseSiteErrorTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Semantics/UseSiteErrorTests.vb
@@ -665,7 +665,8 @@ BC30652: Reference required to assembly 'mincorlib, Version=0.0.0.0, Culture=neu
             Dim compilation5 = CreateEmptyCompilationWithReferences(source2, options:=TestOptions.ReleaseDll, references:={compilation1.ToMetadataReference()})
 
             compilation5.VerifyEmitDiagnostics()
-            CompileAndVerify(compilation5)
+            ' ILVerify: no corlib
+            CompileAndVerify(compilation5, verify:=Verification.FailsILVerify)
 
             Assert.Equal(TypeKind.Struct, compilation5.GetTypeByMetadataName("A").TypeKind)
             Assert.Equal(TypeKind.Enum, compilation5.GetTypeByMetadataName("B").TypeKind)
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/DefaultInterfaceImplementationTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/DefaultInterfaceImplementationTests.vb
index 9bda13dc25580..e98e65e6d84cf 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/DefaultInterfaceImplementationTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/DefaultInterfaceImplementationTests.vb
@@ -30,7 +30,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests
                                            compilationOptions:=compilationOptions)
         End Function
 
-        Private Shared ReadOnly Property VerifyOnMonoOrCoreClr As Verification
+        Private Shared ReadOnly Property VerifyFailsOnMonoOrCoreClr As Verification
+            Get
+                Return If(ExecutionConditionUtil.IsMonoOrCoreClr, Verification.Fails, Verification.Skipped)
+            End Get
+        End Property
+
+        Private Shared ReadOnly Property VerifyPassesOnMonoOrCoreClr As Verification
             Get
                 Return If(ExecutionConditionUtil.IsMonoOrCoreClr, Verification.Passes, Verification.Skipped)
             End Get
@@ -108,7 +114,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -191,7 +197,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -268,7 +274,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -345,7 +351,8 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            ' ILVerify: Method is not visible. { Offset = 8 }
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
 
@@ -387,7 +394,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -527,7 +534,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -559,7 +566,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -745,7 +752,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -831,7 +838,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -870,7 +877,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -1380,7 +1387,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -1449,7 +1456,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -1478,7 +1485,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.M1", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -1777,7 +1784,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, verify:=VerifyOnMonoOrCoreClr).VerifyDiagnostics()
+            CompileAndVerify(comp1, verify:=VerifyPassesOnMonoOrCoreClr).VerifyDiagnostics()
         End Sub
 
         <Fact>
@@ -1867,7 +1874,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, verify:=VerifyOnMonoOrCoreClr).VerifyDiagnostics()
+            CompileAndVerify(comp1, verify:=VerifyPassesOnMonoOrCoreClr).VerifyDiagnostics()
         End Sub
 
         Private Const NoPiaAttributes As String = "
@@ -2404,7 +2411,7 @@ public interface ITest33
 
             For Each reference2 In {compilation1.ToMetadataReference(), compilation1.EmitToImageReference()}
                 Dim compilation2 = CreateCompilation(consumer2, options:=TestOptions.ReleaseExe, references:={reference2, pia2Reference})
-                CompileAndVerify(compilation2, expectedOutput:="Test.M1")
+                CompileAndVerify(compilation2, expectedOutput:="Test.M1", verify:=Verification.FailsILVerify)
             Next
         End Sub
 
@@ -2529,7 +2536,7 @@ End Class
 I1+T2
 I1+T3
 B
-I1+T5", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1+T5", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -2753,7 +2760,7 @@ End Class
 I1+T2
 I1+T3
 B
-I1+T5", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1+T5", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -3223,7 +3230,7 @@ End Interface
 I1+T2
 I1+T3
 B
-I1+T5", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1+T5", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -3292,7 +3299,7 @@ End Interface
 I1+T2
 I1+T3
 B
-I1+T5", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1+T5", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -3512,7 +3519,7 @@ End Class
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugDll, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
 
-            CompileAndVerify(comp1, verify:=VerifyOnMonoOrCoreClr).VerifyDiagnostics()
+            CompileAndVerify(comp1, verify:=VerifyPassesOnMonoOrCoreClr).VerifyDiagnostics()
         End Sub
 
         <Fact>
@@ -3666,7 +3673,7 @@ End Class
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugDll, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
 
-            CompileAndVerify(comp1, verify:=VerifyOnMonoOrCoreClr).VerifyDiagnostics()
+            CompileAndVerify(comp1, verify:=VerifyPassesOnMonoOrCoreClr).VerifyDiagnostics()
         End Sub
 
         <Fact>
@@ -3811,7 +3818,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Get
-C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -3894,7 +3901,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Get
-C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -3979,7 +3986,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Get
-C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -4172,7 +4179,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Get
-C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -4221,7 +4228,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Get
-C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -4270,7 +4277,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Get
-C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -4319,7 +4326,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Get
-C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -4368,7 +4375,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Get
-C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -4417,7 +4424,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Get
-C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -4625,10 +4632,10 @@ End Class
                                 Assert.Empty(p1Get.ExplicitInterfaceImplementations)
                             End Sub
 
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
 
             comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All), targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
         End Sub
 
         <Fact>
@@ -4686,10 +4693,10 @@ End Class
                                 Assert.Empty(p1Get.ExplicitInterfaceImplementations)
                             End Sub
 
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
 
             comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All), targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
         End Sub
 
         <Fact>
@@ -4753,10 +4760,10 @@ End Class
                                 Assert.Empty(p1Set.ExplicitInterfaceImplementations)
                             End Sub
 
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
 
             comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All), targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
         End Sub
 
         <Fact>
@@ -4816,10 +4823,10 @@ End Class
                                 Assert.Empty(p1Set.ExplicitInterfaceImplementations)
                             End Sub
 
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
 
             comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All), targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
         End Sub
 
         <Fact>
@@ -4856,10 +4863,10 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
 
             comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All), targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -4897,10 +4904,10 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
 
             comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All), targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -4937,10 +4944,10 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
 
             comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe.WithMetadataImportOptions(MetadataImportOptions.All), targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -5127,7 +5134,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -5157,7 +5164,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -5187,7 +5194,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -5217,7 +5224,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -5247,7 +5254,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -5277,7 +5284,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -5780,7 +5787,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "I1.P1.Get
-I1.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -5957,7 +5964,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "I1.P1.Get
-I1.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -5999,7 +6006,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "I1.P1.Get
-I1.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -6041,7 +6048,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "I1.P1.Get
-I1.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -6083,7 +6090,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "I1.P1.Get
-I1.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -6125,7 +6132,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "I1.P1.Get
-I1.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -6167,7 +6174,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "I1.P1.Get
-I1.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -7460,7 +7467,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -7538,7 +7545,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -7618,7 +7625,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -7708,7 +7715,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -7752,7 +7759,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Get", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -7894,7 +7901,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -7923,7 +7930,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -8103,7 +8110,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Get", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -8187,7 +8194,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Get", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -8226,7 +8233,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Get", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Get", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -8721,7 +8728,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -8798,7 +8805,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -8877,7 +8884,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -8966,7 +8973,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -9009,7 +9016,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -9156,7 +9163,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -9188,7 +9195,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "100", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -9368,7 +9375,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Set", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -9452,7 +9459,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -9491,7 +9498,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Set", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "I1.P1.Set", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -9994,7 +10001,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Add
-C.P1.Remove", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Remove", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -10079,7 +10086,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Add
-C.P1.Remove", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Remove", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -10166,7 +10173,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Add
-C.P1.Remove", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Remove", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -10266,7 +10273,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Add
-C.P1.Remove", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Remove", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -10317,7 +10324,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "C.P1.Add
-C.P1.Remove", Nothing), verify:=VerifyOnMonoOrCoreClr)
+C.P1.Remove", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -10408,7 +10415,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "M1
-M2", Nothing), verify:=VerifyOnMonoOrCoreClr)
+M2", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -10499,7 +10506,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "M1
-M2", Nothing), verify:=VerifyOnMonoOrCoreClr)
+M2", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -10542,7 +10549,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "M1
-M2", Nothing), verify:=VerifyOnMonoOrCoreClr)
+M2", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -10749,7 +10756,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "I1.P1.Add
-I1.P1.Remove", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1.P1.Remove", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -10844,7 +10851,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "I1.P1.Add
-I1.P1.Remove", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1.P1.Remove", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -10887,7 +10894,7 @@ End Class
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
             CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr,
 "I1.P1.Add
-I1.P1.Remove", Nothing), verify:=VerifyOnMonoOrCoreClr)
+I1.P1.Remove", Nothing), verify:=VerifyFailsOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -11407,7 +11414,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -11489,7 +11496,7 @@ End Class
 </compilation>
 
             Dim comp1 = CreateCompilation(source1, options:=TestOptions.DebugExe, targetFramework:=TargetFramework.NetCoreApp, references:={csCompilation})
-            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyOnMonoOrCoreClr)
+            CompileAndVerify(comp1, expectedOutput:=If(ExecutionConditionUtil.IsMonoOrCoreClr, "C.M1", Nothing), verify:=VerifyPassesOnMonoOrCoreClr)
         End Sub
 
         <Fact>
@@ -11878,7 +11885,7 @@ End Class
                                 Assert.Same(i1WinRT.RemoveMethod, i2WinRT.RemoveMethod.ExplicitInterfaceImplementations.Single())
                             End Sub
 
-            CompileAndVerify(comp1, verify:=VerifyOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
+            CompileAndVerify(comp1, verify:=VerifyPassesOnMonoOrCoreClr, sourceSymbolValidator:=validator, symbolValidator:=validator)
         End Sub
 
     End Class
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/ExtensionMethods/AddressOf.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/ExtensionMethods/AddressOf.vb
index ac7b6137f72f3..d5d6701c9c453 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/ExtensionMethods/AddressOf.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/ExtensionMethods/AddressOf.vb
@@ -202,6 +202,7 @@ End Namespace
 </compilation>
 
             CompileAndVerify(compilationDef,
+                             verify:=Verification.FailsILVerify,
                              expectedOutput:=
             <![CDATA[
 -- Test1 --
@@ -632,6 +633,7 @@ End Namespace
 </compilation>
 
             CompileAndVerify(compilationDef,
+                             verify:=Verification.FailsILVerify,
                              expectedOutput:=
             <![CDATA[
 M2.F1
@@ -939,8 +941,9 @@ Namespace System.Runtime.CompilerServices
 End Namespace
     </file>
 </compilation>
-
+            ' ILVerify: Unrecognized arguments for delegate .ctor. { Offset = 8 }
             CompileAndVerify(compilationDef,
+                             verify:=Verification.FailsILVerify,
                              expectedOutput:=
             <![CDATA[
 2
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/NoPia.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/NoPia.vb
index c8027ff848044..0d5e9629e8a30 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/NoPia.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/NoPia.vb
@@ -1241,6 +1241,7 @@ End Class
                                                             OutputKind.DynamicallyLinkedLibrary,
                                                             i3Compilation.EmitToArray(),
                                                             Nothing,
+                                                            False,
                                                             False)},
                              expectedOutput:=
             <![CDATA[
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/TypeForwarders.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/TypeForwarders.vb
index 54f4fad47c548..a8974473d4e65 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/TypeForwarders.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/PE/TypeForwarders.vb
@@ -1047,7 +1047,7 @@ End class
             Assert.True(token.IsNil)   'could the type ref be located? If not then the attribute's not there.
 
             ' Exported types in .NET module cause PEVerify to fail.
-            CompileAndVerify(appCompilation, verify:=Verification.Fails,
+            CompileAndVerify(appCompilation, verify:=Verification.FailsPEVerify,
                 symbolValidator:=Sub(m)
                                      Dim metadataReader1 = DirectCast(m, PEModuleSymbol).Module.GetMetadataReader()
                                      Assert.Equal(1, metadataReader1.GetTableRowCount(TableIndex.ExportedType))
@@ -1225,7 +1225,7 @@ End class
             Assert.Equal({"CF1"}, GetNamesOfForwardedTypes(appCompilation))
 
             ' Exported types in .NET module cause PEVerify to fail.
-            CompileAndVerify(appCompilation, verify:=Verification.Fails,
+            CompileAndVerify(appCompilation, verify:=Verification.FailsPEVerify,
                 symbolValidator:=Sub(m)
                                      Dim peReader1 = DirectCast(m, PEModuleSymbol).Module.GetMetadataReader()
                                      Assert.Equal({"CF1"}, GetNamesOfForwardedTypes(m.ContainingAssembly))
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/WinMdEventTest.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/WinMdEventTest.vb
index b8c8040294fdc..fedcd1480e53b 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/WinMdEventTest.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Metadata/WinMdEventTest.vb
@@ -213,6 +213,7 @@ End Class
                     _eventLibRef},
                 options:=TestOptions.ReleaseModule).EmitToImageReference()
 
+            ' ILVerify: Assembly or module not found: 05ca8eb4-6571-4ba9-8736-a47aa3bc2cc7
             Dim verifier = CompileAndVerifyOnWin8Only(
                 src,
                 allReferences:={
@@ -220,7 +221,8 @@ End Class
                     SystemCoreRef_v4_0_30319_17929,
                     CSharpRef,
                     _eventLibRef,
-                    dynamicCommonRef})
+                    dynamicCommonRef},
+                verify:=Verification.FailsILVerify)
             verifier.VerifyIL("C.Main", <![CDATA[
 {
   // Code size      931 (0x3a3)
@@ -765,7 +767,8 @@ Public Partial Class A
   IL_004b:  ret
 }
                     </output>
-            CompileAndVerify(compilation).VerifyIL("abcdef.goo", expectedIL.Value())
+            ' ILVerify: Missing method 'System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken Windows.UI.Xaml.Application.add_Suspending(Windows.UI.Xaml.SuspendingEventHandler)'
+            CompileAndVerify(compilation, verify:=Verification.FailsILVerify).VerifyIL("abcdef.goo", expectedIL.Value())
         End Sub
 
         <Fact()>
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/NoPia.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/NoPia.vb
index 9d416fc9e17f5..d5a5efb4d870d 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/NoPia.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/NoPia.vb
@@ -1633,7 +1633,8 @@ End Class
                 references:={New VisualBasicCompilationReference(multiModule),
                              New VisualBasicCompilationReference(pia1)})
 
-            CompileAndVerify(consumer)
+            ' ILVerify: The method or operation is not implemented.
+            CompileAndVerify(consumer, verify:=Verification.FailsILVerify)
         End Sub
 
         <Fact, WorkItem(528047, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/528047")>
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/RetargetingTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/RetargetingTests.vb
index b61ce12c60488..2130889a6d0a2 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/RetargetingTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Retargeting/RetargetingTests.vb
@@ -943,7 +943,8 @@ End Namespace
 
             'Retargetted - should result in No additional Errors also and same runtime behavior
             Dim RetargetReference = RetargetCompilationToV2MsCorlib(referenceLibrary_Compilation)
-            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe,
+            ' ILVerify: Multiple modules named 'mscorlib' were found
+            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe, verify:=Verification.FailsILVerify,
                                                  expectedOutput:=<![CDATA[Success
 ]]>)
             Main_Retarget.VerifyDiagnostics()
@@ -1307,7 +1308,8 @@ End Namespace
 
             '//Retargetted - should result in No Errors also and same runtime behavior
             Dim RetargetReference = RetargetCompilationToV2MsCorlib(referenceLibrary_Compilation)
-            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe,
+            ' ILVerify: Multiple modules named 'mscorlib' were found
+            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe, verify:=Verification.FailsILVerify,
                                                  expectedOutput:=<![CDATA[Success
 ]]>)
             Main_Retarget.VerifyDiagnostics()
@@ -1693,7 +1695,8 @@ Imports System
 
             '//Retargetted - should result in No Errors also and same runtime behavior
             Dim RetargetReference = RetargetCompilationToV2MsCorlib(referenceLibrary_Compilation)
-            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe,
+            ' ILVerify: Multiple modules named 'mscorlib' were found
+            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe, verify:=Verification.FailsILVerify,
                                                  expectedOutput:=<![CDATA[11
 12
 13
@@ -1894,7 +1897,8 @@ MethodOverload(Base)
 
             '//Retargetted - should result in No Errors also same runtime behavior
             Dim RetargetReference = RetargetCompilationToV2MsCorlib(referenceLibrary_Compilation)
-            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe,
+            ' ILVerify: Multiple modules named 'mscorlib' were found
+            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe, verify:=Verification.FailsILVerify,
                                                  expectedOutput:=<![CDATA[Sharedmethod
 method(Other)
 MethodOverload(Other)
@@ -2172,7 +2176,8 @@ Success]]>)
 
             '//Retargetted - should result in No Errors also and same runtime behavior
             Dim RetargetReference = RetargetCompilationToV2MsCorlib(referenceLibrary_Compilation)
-            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe,
+            ' ILVerify: Multiple modules named 'mscorlib' were found
+            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe, verify:=Verification.FailsILVerify,
                                                  expectedOutput:=<![CDATA[Success
 Success
 Success
@@ -2365,7 +2370,8 @@ test
 
             '//Retargetted - should result in No Errors also
             Dim RetargetReference = RetargetCompilationToV2MsCorlib(referenceLibrary_Compilation)
-            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe,
+            ' ILVerify: Multiple modules named 'mscorlib' were found
+            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe, verify:=Verification.FailsILVerify,
                                                  expectedOutput:=<![CDATA[1
 test
 ]]>)
@@ -2686,7 +2692,8 @@ End Class
 
             ''//Retargetted - should result in No Errors also
             Dim RetargetReference = RetargetCompilationToV2MsCorlib(referenceLibrary_Compilation)
-            Dim Main_Retarget = CompileAndVerify(sourceMain, references:={RetargetReference}, options:=TestOptions.ReleaseExe)
+            ' ILVerify: Multiple modules named 'mscorlib' were found
+            Dim Main_Retarget = CompileAndVerify(sourceMain, references:={RetargetReference}, options:=TestOptions.ReleaseExe, verify:=Verification.FailsILVerify)
             main_NoRetarget.VerifyDiagnostics()
         End Sub
 
@@ -3081,7 +3088,8 @@ End Namespace
 
             '//Retargetted - should result in No Errors also and same runtime behavior
             Dim RetargetReference = RetargetCompilationToV2MsCorlib(referenceLibrary_Compilation)
-            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe,
+            ' ILVerify: Multiple modules named 'mscorlib' were found
+            Dim Main_Retarget = CompileAndVerify(source, references:={RetargetReference}, options:=TestOptions.ReleaseExe, verify:=Verification.FailsILVerify,
                                                  expectedOutput:=<![CDATA[Success
 ]]>)
             Main_Retarget.VerifyDiagnostics()
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/TypeTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/TypeTests.vb
index 7545421a135de..2592d264fd2c3 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/TypeTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/TypeTests.vb
@@ -3199,7 +3199,7 @@ BC37218: Type 'ns.CF2' forwarded to assembly 'ForwardedTypes1, Version=0.0.0.0,
                 }, TestOptions.ReleaseDll)
 
             ' Exported types in .NET modules cause PEVerify to fail.
-            CompileAndVerify(compilation, verify:=Verification.Fails).VerifyDiagnostics()
+            CompileAndVerify(compilation, verify:=Verification.FailsPEVerify).VerifyDiagnostics()
 
             compilation = CreateCompilationWithMscorlib40AndReferences(emptySource,
                 {
diff --git a/src/Compilers/VisualBasic/Test/Symbol/UsedAssembliesTests.vb b/src/Compilers/VisualBasic/Test/Symbol/UsedAssembliesTests.vb
index 91f9706dc4e0b..55172dbecf44f 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/UsedAssembliesTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/UsedAssembliesTests.vb
@@ -26,7 +26,8 @@ End Interface
     </compilation>
 
             Dim comp1 = CreateEmptyCompilation(source)
-            CompileAndVerify(comp1)
+            ' ILVerify: Failed to load type 'System.String' from assembly ...
+            CompileAndVerify(comp1, verify:=Verification.FailsILVerify)
 
             Assert.Empty(comp1.GetUsedAssemblyReferences())
 
@@ -48,7 +49,7 @@ End Interface
     </compilation>
 
             Dim comp1 = CreateEmptyCompilation(source)
-            CompileAndVerify(comp1)
+            CompileAndVerify(comp1, verify:=Verification.FailsILVerify)
 
             Dim source2 =
     <compilation>
@@ -235,7 +236,7 @@ End Interface
     </compilation>
 
             Dim comp1 = CreateEmptyCompilation(source)
-            CompileAndVerify(comp1)
+            CompileAndVerify(comp1, verify:=Verification.FailsILVerify)
 
             Dim source2 =
     <compilation>