[NativeAot] Start running 8 more libs tests (#73283)

MichalStrehovsky · web-flow · commit 5cdb32284a70 · 2022-08-05T13:34:47.000+09:00
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Reflection/Extensions/NonPortable/CustomAttributeInheritanceRules.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Reflection/Extensions/NonPortable/CustomAttributeInheritanceRules.cs
@@ -233,7 +233,16 @@ public sealed override ParameterInfo GetParent(ParameterInfo e)
                 MethodInfo? methodParent = new MethodCustomAttributeSearcher().GetParent(method);
                 if (methodParent == null)
                     return null;
-                return methodParent.GetParametersNoCopy()[e.Position];
+
+                if (e.Position >= 0)
+                {
+                    return methodParent.GetParametersNoCopy()[e.Position];
+                }
+                else
+                {
+                    Debug.Assert(e.Position == -1);
+                    return methodParent.ReturnParameter;
+                }
             }
 
             public static readonly ParameterCustomAttributeSearcher Default = new ParameterCustomAttributeSearcher();
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/TypeInfos/RuntimeTypeInfo.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/TypeInfos/RuntimeTypeInfo.cs
@@ -187,38 +187,38 @@ public sealed override MemberInfo[] GetDefaultMembers()
             return defaultMemberName != null ? GetMember(defaultMemberName) : Array.Empty<MemberInfo>();
         }
 
-        public sealed override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type interfaceType)
+        public sealed override InterfaceMapping GetInterfaceMap([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type ifaceType)
         {
             // restrictions and known limitations compared to CoreCLR:
             // - only interface.GetMethods() reflection visible interface methods are returned
             // - all visible members of the interface must be reflection invokeable
-            // - this type and interfaceType must not be an open generic type
+            // - this type and ifaceType must not be an open generic type
             // - if this type and the method implementing the interface method are abstract, an exception is thrown
 
             if (IsGenericParameter)
                 throw new InvalidOperationException(SR.Arg_GenericParameter);
 
-            if (interfaceType is null)
-                throw new ArgumentNullException(nameof(interfaceType));
+            if (ifaceType is null)
+                throw new ArgumentNullException(nameof(ifaceType));
 
-            if (!(interfaceType is RuntimeTypeInfo))
-                throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(interfaceType));
+            if (!(ifaceType is RuntimeTypeInfo))
+                throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(ifaceType));
 
-            RuntimeTypeHandle interfaceTypeHandle = interfaceType.TypeHandle;
+            RuntimeTypeHandle interfaceTypeHandle = ifaceType.TypeHandle;
 
             ReflectionCoreExecution.ExecutionEnvironment.VerifyInterfaceIsImplemented(TypeHandle, interfaceTypeHandle);
-            Debug.Assert(interfaceType.IsInterface);
+            Debug.Assert(ifaceType.IsInterface);
             Debug.Assert(!IsInterface);
 
             // SZArrays implement the methods on IList`1, IEnumerable`1, and ICollection`1 with
             // runtime magic. We don't have accurate interface maps for them.
-            if (IsSZArray && interfaceType.IsGenericType)
+            if (IsSZArray && ifaceType.IsGenericType)
                 throw new ArgumentException(SR.Argument_ArrayGetInterfaceMap);
 
-            ReflectionCoreExecution.ExecutionEnvironment.GetInterfaceMap(this, interfaceType, out MethodInfo[] interfaceMethods, out MethodInfo[] targetMethods);
+            ReflectionCoreExecution.ExecutionEnvironment.GetInterfaceMap(this, ifaceType, out MethodInfo[] interfaceMethods, out MethodInfo[] targetMethods);
 
             InterfaceMapping im;
-            im.InterfaceType = interfaceType;
+            im.InterfaceType = ifaceType;
             im.TargetType = this;
             im.InterfaceMethods = interfaceMethods;
             im.TargetMethods = targetMethods;
diff --git a/src/coreclr/tools/Common/TypeSystem/IL/Stubs/ValueTypeGetFieldHelperMethodOverride.cs b/src/coreclr/tools/Common/TypeSystem/IL/Stubs/ValueTypeGetFieldHelperMethodOverride.cs
@@ -142,19 +142,21 @@ public override bool IsVirtual
             }
         }
 
+        internal const string MetadataName = "__GetFieldHelper";
+
         public override string Name
         {
             get
             {
-                return "__GetFieldHelper";
+                return MetadataName;
             }
         }
 
         public override string DiagnosticName
         {
             get
             {
-                return "__GetFieldHelper";
+                return MetadataName;
             }
         }
     }
diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/NoMetadataBlockingPolicy.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/NoMetadataBlockingPolicy.cs
@@ -51,6 +51,11 @@ public override bool IsBlocked(MethodDesc method)
                 if (ecmaMethod.OwningType == GetArrayOfTType(ecmaMethod))
                     return true;
 
+                // Also don't expose the ValueType.__GetFieldOverride method.
+                if (ecmaMethod.Name == Internal.IL.Stubs.ValueTypeGetFieldHelperMethodOverride.MetadataName
+                    && ecmaMethod.OwningType.IsWellKnownType(WellKnownType.ValueType))
+                    return true;
+
                 return false;
             }
 
diff --git a/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Proxy.cs b/src/libraries/Common/tests/System/Net/Http/HttpClientHandlerTest.Proxy.cs
@@ -499,14 +499,15 @@ public async Task MultiProxy_PAC_Failover_Succeeds()
             string proxyConfigString = $"{failingEndPoint.Address}:{failingEndPoint.Port} {succeedingProxyServer.Uri.Host}:{succeedingProxyServer.Uri.Port}";
 
             // Create a WinInetProxyHelper and override its values with our own.
-            object winInetProxyHelper = Activator.CreateInstance(typeof(HttpClient).Assembly.GetType("System.Net.Http.WinInetProxyHelper", true), true);
-            winInetProxyHelper.GetType().GetField("_autoConfigUrl", Reflection.BindingFlags.Instance | Reflection.BindingFlags.NonPublic).SetValue(winInetProxyHelper, null);
-            winInetProxyHelper.GetType().GetField("_autoDetect", Reflection.BindingFlags.Instance | Reflection.BindingFlags.NonPublic).SetValue(winInetProxyHelper, false);
-            winInetProxyHelper.GetType().GetField("_proxy", Reflection.BindingFlags.Instance | Reflection.BindingFlags.NonPublic).SetValue(winInetProxyHelper, proxyConfigString);
-            winInetProxyHelper.GetType().GetField("_proxyBypass", Reflection.BindingFlags.Instance | Reflection.BindingFlags.NonPublic).SetValue(winInetProxyHelper, null);
+            Type winInetProxyHelperType = Type.GetType("System.Net.Http.WinInetProxyHelper, System.Net.Http", true);
+            object winInetProxyHelper = Activator.CreateInstance(winInetProxyHelperType, true);
+            winInetProxyHelperType.GetField("_autoConfigUrl", Reflection.BindingFlags.Instance | Reflection.BindingFlags.NonPublic).SetValue(winInetProxyHelper, null);
+            winInetProxyHelperType.GetField("_autoDetect", Reflection.BindingFlags.Instance | Reflection.BindingFlags.NonPublic).SetValue(winInetProxyHelper, false);
+            winInetProxyHelperType.GetField("_proxy", Reflection.BindingFlags.Instance | Reflection.BindingFlags.NonPublic).SetValue(winInetProxyHelper, proxyConfigString);
+            winInetProxyHelperType.GetField("_proxyBypass", Reflection.BindingFlags.Instance | Reflection.BindingFlags.NonPublic).SetValue(winInetProxyHelper, null);
 
             // Create a HttpWindowsProxy with our custom WinInetProxyHelper.
-            IWebProxy httpWindowsProxy = (IWebProxy)Activator.CreateInstance(typeof(HttpClient).Assembly.GetType("System.Net.Http.HttpWindowsProxy", true), Reflection.BindingFlags.NonPublic | Reflection.BindingFlags.Instance, null, new[] { winInetProxyHelper, null }, null);
+            IWebProxy httpWindowsProxy = (IWebProxy)Activator.CreateInstance(Type.GetType("System.Net.Http.HttpWindowsProxy, System.Net.Http", true), Reflection.BindingFlags.NonPublic | Reflection.BindingFlags.Instance, null, new[] { winInetProxyHelper, null }, null);
 
             Task<bool> nextFailedConnection = null;
 
diff --git a/src/libraries/Microsoft.NETCore.Platforms/tests/GenerateRuntimeGraphTests.cs b/src/libraries/Microsoft.NETCore.Platforms/tests/GenerateRuntimeGraphTests.cs
@@ -14,6 +14,8 @@
 
 namespace Microsoft.NETCore.Platforms.BuildTasks.Tests
 {
+    // MSBuild engine is not compatible with single file
+    [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.HasAssemblyFiles))]
     public class GenerateRuntimeGraphTests
     {
         private Log _log;
diff --git a/src/libraries/Microsoft.Win32.SystemEvents/tests/SystemEvents.InvokeOnEventsThread.cs b/src/libraries/Microsoft.Win32.SystemEvents/tests/SystemEvents.InvokeOnEventsThread.cs
@@ -52,7 +52,9 @@ public void InvokeOnEventsThreadRunsOnSameThreadAsOtherEvents()
             }
         }
 
-        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotWindowsNanoNorServerCore))]
+        public static bool NotNanoNorServerCoreAndRemoteExecutorSupported => PlatformDetection.IsNotWindowsNanoNorServerCore && RemoteExecutor.IsSupported;
+
+        [ConditionalFact(nameof(NotNanoNorServerCoreAndRemoteExecutorSupported))]
         [SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/34360", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
         public void RegisterFromSTAThreadThatGoesAway_MessageStillDelivered()
diff --git a/src/libraries/System.Globalization.Calendars/tests/CalendarTestWithConfigSwitch/System.Globalization.CalendarsWithConfigSwitch.Tests.csproj b/src/libraries/System.Globalization.Calendars/tests/CalendarTestWithConfigSwitch/System.Globalization.CalendarsWithConfigSwitch.Tests.csproj
@@ -6,4 +6,7 @@
   <ItemGroup>
     <Compile Include="CalendarTests.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <RuntimeHostConfigurationOption Include="Switch.System.Globalization.EnforceJapaneseEraYearRanges" Value="true" />
+  </ItemGroup>
 </Project>
diff --git a/src/libraries/System.Globalization.Calendars/tests/CalendarTestWithConfigSwitch/runtimeconfig.template.json b/src/libraries/System.Globalization.Calendars/tests/CalendarTestWithConfigSwitch/runtimeconfig.template.json
diff --git a/src/libraries/System.Globalization/tests/NlsTests/System.Globalization.Nls.Tests.csproj b/src/libraries/System.Globalization/tests/NlsTests/System.Globalization.Nls.Tests.csproj
@@ -7,6 +7,9 @@
     <TargetFramework>$(NetCoreAppCurrent)-windows</TargetFramework>
     <UnicodeUcdVersion>14.0</UnicodeUcdVersion>
   </PropertyGroup>
+  <ItemGroup>
+    <RdXmlFile Include="..\default.rd.xml" />
+  </ItemGroup>
   <ItemGroup>
     <!-- Include tests from System.Globalization.Tests -->
     <Compile Include="NlsSwitchTests.cs" />
@@ -222,6 +225,9 @@
     <Compile Include="$(CommonTestPath)System\RandomDataGenerator.cs"
              Link="Common\System\RandomDataGenerator.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <RuntimeHostConfigurationOption Include="System.Globalization.UseNls" Value="true" />
+  </ItemGroup>
   <ItemGroup>
     <PackageReference Include="System.Private.Runtime.UnicodeData" Version="$(SystemPrivateRuntimeUnicodeDataVersion)" ExcludeAssets="contentFiles" GeneratePathProperty="true" />
     <EmbeddedResource Include="$(PkgSystem_Private_Runtime_UnicodeData)\contentFiles\any\any\$(UnicodeUcdVersion).0\ucd\UnicodeData.txt">
diff --git a/src/libraries/System.Globalization/tests/NlsTests/runtimeconfig.template.json b/src/libraries/System.Globalization/tests/NlsTests/runtimeconfig.template.json
diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpConnectionKeyTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpConnectionKeyTest.cs
@@ -26,12 +26,10 @@ public static IEnumerable<object[]> KeyComponents()
         [Theory, MemberData(nameof(KeyComponents))]
         public void Equals_DifferentParameters_ReturnsTrueIfAllEqual(string kindString, string host, int port, string sslHostName, Uri proxyUri, string identity, bool expected)
         {
-            Assembly assembly = typeof(HttpClientHandler).Assembly;
-            Type connectionKindType = assembly.GetTypes().Where(t => t.Name == "HttpConnectionKind").First();
-            Type poolManagerType = assembly.GetTypes().Where(t => t.Name == "HttpConnectionPoolManager").First();
-            Type keyType = poolManagerType.GetNestedType("HttpConnectionKey", BindingFlags.NonPublic);
-            dynamic referenceKey = Activator.CreateInstance(keyType, Enum.Parse(connectionKindType, "Http"), "localhost", 80, "localhost-ssl", new Uri("http://localhost"), "domain1/userA");
-            dynamic actualKey = Activator.CreateInstance(keyType, Enum.Parse(connectionKindType, kindString), host, port, sslHostName, proxyUri, identity);
+            Type connectionKindType = Type.GetType("System.Net.Http.HttpConnectionKind, System.Net.Http");
+            Type keyType = Type.GetType("System.Net.Http.HttpConnectionPoolManager+HttpConnectionKey, System.Net.Http");
+            object referenceKey = Activator.CreateInstance(keyType, Enum.Parse(connectionKindType, "Http"), "localhost", 80, "localhost-ssl", new Uri("http://localhost"), "domain1/userA");
+            object actualKey = Activator.CreateInstance(keyType, Enum.Parse(connectionKindType, kindString), host, port, sslHostName, proxyUri, identity);
             Assert.Equal(expected, referenceKey.Equals(actualKey));
         }
     }
diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj b/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj
@@ -11,6 +11,9 @@
   <ItemGroup>
     <Compile Include="AssemblyInfo.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <RdXmlFile Include="default.rd.xml" />
+  </ItemGroup>
   <Import Project="$(CommonTestPath)System\Net\Security\Kerberos\System.Net.Security.Kerberos.Shared.projitems" />
   <ItemGroup Condition="'$(TargetPlatformIdentifier)' != 'Browser'">
     <Compile Include="SslStreamExtensions.cs" />
diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/default.rd.xml b/src/libraries/System.Net.Security/tests/FunctionalTests/default.rd.xml
@@ -0,0 +1,7 @@
+<Directives>
+  <Application>
+    <Assembly Name="System.Private.CoreLib">
+      <Type Name="System.Collections.Generic.List`1[[Kerberos.NET.Configuration.SpakePreAuthGroupType,Kerberos.NET]]" Dynamic="Required All" />
+    </Assembly>
+  </Application>
+</Directives>
diff --git a/src/libraries/System.Reflection.TypeExtensions/tests/FieldInfoTests.cs b/src/libraries/System.Reflection.TypeExtensions/tests/FieldInfoTests.cs
@@ -46,6 +46,10 @@ public void Properties(string name, FieldAttributes attributes, Type fieldType)
 
         public static IEnumerable<object[]> GetValue_TestData()
         {
+            // Trick trimming into keeping the Empty field
+            if (string.Empty.Length > 0)
+                typeof(string).GetField("Empty");
+
             yield return new object[] { typeof(string), "Empty", "abc", "" };
 
             yield return new object[] { typeof(FI_BaseClass), "_privateStringField", new FI_BaseClass(), "2" };
diff --git a/src/libraries/System.Reflection.TypeExtensions/tests/MetadataTokenTests.cs b/src/libraries/System.Reflection.TypeExtensions/tests/MetadataTokenTests.cs
@@ -57,7 +57,7 @@ public static void ReflectionEmitType_HasMetadataToken()
             Assert.NotEqual(0, method.GetMetadataToken());
         }
 
-        public static bool GetMetadataTokenSupported => true;
+        public static bool GetMetadataTokenSupported => PlatformDetection.IsMetadataTokenSupported;
 
         public static bool IsReflectionEmitSupported => PlatformDetection.IsReflectionEmitSupported;
 
diff --git a/src/libraries/System.Reflection.TypeExtensions/tests/MethodBaseTests.cs b/src/libraries/System.Reflection.TypeExtensions/tests/MethodBaseTests.cs
@@ -12,7 +12,7 @@ public static IEnumerable<object[]> ContainsGenericParameters_TestData()
         {
             // Methods
             yield return new object[] { TypeExtensions.GetMethod(typeof(NonGenericClass), nameof(NonGenericClass.TestGenericMethod), Helpers.AllFlags), true };
-            yield return new object[] { TypeExtensions.GetMethod(typeof(NonGenericClass), nameof(NonGenericClass.TestGenericMethod), Helpers.AllFlags).MakeGenericMethod(typeof(int)), false };
+            yield return new object[] { TypeExtensions.GetMethod(typeof(NonGenericClass), nameof(NonGenericClass.TestGenericMethod), Helpers.AllFlags).MakeGenericMethod(typeof(string)), false };
             yield return new object[] { TypeExtensions.GetMethod(typeof(NonGenericClass), nameof(NonGenericClass.TestMethod), Helpers.AllFlags), false };
             yield return new object[] { TypeExtensions.GetMethod(typeof(NonGenericClass), nameof(NonGenericClass.TestPartialGenericMethod), Helpers.AllFlags), true };
             yield return new object[] { TypeExtensions.GetMethod(typeof(NonGenericClass), nameof(NonGenericClass.TestGenericReturnTypeMethod), Helpers.AllFlags), true };
diff --git a/src/libraries/System.Reflection.TypeExtensions/tests/ModuleTests.cs b/src/libraries/System.Reflection.TypeExtensions/tests/ModuleTests.cs
@@ -22,7 +22,8 @@ public void GetModuleVersionId_HasModuleVersionId_BehaveConsistently()
             }
         }
 
-        [Fact]
+        // This calls Assembly.Load, but xUnit turn is into a LoadFrom because TinyAssembly is just a Content item in the project.
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsAssemblyLoadingSupported))]
         public void GetModuleVersionId_KnownAssembly_ReturnsExpected()
         {
             Module module = Assembly.Load(new AssemblyName("TinyAssembly")).ManifestModule;
diff --git a/src/libraries/System.Reflection.TypeExtensions/tests/PropertyInfoTests.cs b/src/libraries/System.Reflection.TypeExtensions/tests/PropertyInfoTests.cs
@@ -9,10 +9,19 @@ namespace System.Reflection.Tests
 {
     public class PropertyInfoTests
     {
+        public static IEnumerable<object[]> Properties_TestData()
+        {
+            yield return new object[] { typeof(PI_BaseClass), nameof(PI_BaseClass.PublicGetPublicSetStaticProperty) };
+            yield return new object[] { typeof(PI_BaseClass), nameof(PI_BaseClass.PublicGetPublicSetProperty) };
+
+            // trick trimming into keeping the Length property
+            if (string.Empty.Length > 0)
+                typeof(string).GetProperty("Length");
+            yield return new object[] { typeof(string), nameof(string.Length) };
+        }
+
         [Theory]
-        [InlineData(typeof(PI_BaseClass), nameof(PI_BaseClass.PublicGetPublicSetStaticProperty))]
-        [InlineData(typeof(PI_BaseClass), nameof(PI_BaseClass.PublicGetPublicSetProperty))]
-        [InlineData(typeof(string), nameof(string.Length))]
+        [MemberData(nameof(Properties_TestData))]
         public void Properties(Type type, string name)
         {
             PropertyInfo property = TypeExtensions.GetProperty(type, name, Helpers.AllFlags);
diff --git a/src/libraries/System.Threading.RateLimiting/tests/Infrastructure/Utils.cs b/src/libraries/System.Threading.RateLimiting/tests/Infrastructure/Utils.cs
@@ -15,7 +15,7 @@ internal static class Utils
         // Creates a DefaultPartitionedRateLimiter with the timer effectively disabled
         internal static PartitionedRateLimiter<TResource> CreatePartitionedLimiterWithoutTimer<TResource, TKey>(Func<TResource, RateLimitPartition<TKey>> partitioner)
         {
-            var limiterType = Assembly.GetAssembly(typeof(PartitionedRateLimiter<>)).GetType("System.Threading.RateLimiting.DefaultPartitionedRateLimiter`2");
+            var limiterType = Type.GetType("System.Threading.RateLimiting.DefaultPartitionedRateLimiter`2, System.Threading.RateLimiting");
             Assert.NotNull(limiterType);
 
             var genericLimiterType = limiterType.MakeGenericType(typeof(TResource), typeof(TKey));
@@ -30,10 +30,17 @@ internal static PartitionedRateLimiter<TResource> CreatePartitionedLimiterWithou
         // Gets and runs the Heartbeat function on the DefaultPartitionedRateLimiter
         internal static Task RunTimerFunc<T>(PartitionedRateLimiter<T> limiter)
         {
-            var innerTimer = limiter.GetType().GetField("_timer", BindingFlags.NonPublic | BindingFlags.Instance);
+            // Use Type.GetType so that trimming can see what type we're reflecting on, but assert it's the one we got
+            var limiterTypeDef = Type.GetType("System.Threading.RateLimiting.DefaultPartitionedRateLimiter`2, System.Threading.RateLimiting");
+            var limiterType = limiter.GetType();
+            Assert.Equal(limiterTypeDef, limiterType.GetGenericTypeDefinition());
+            if (string.Empty.Length > 0)
+                limiterType = limiterTypeDef;
+
+            var innerTimer = limiterType.GetField("_timer", BindingFlags.NonPublic | BindingFlags.Instance);
             Assert.NotNull(innerTimer);
 
-            var timerLoopMethod = limiter.GetType().GetMethod("Heartbeat", BindingFlags.NonPublic | BindingFlags.Instance);
+            var timerLoopMethod = limiterType.GetMethod("Heartbeat", BindingFlags.NonPublic | BindingFlags.Instance);
             Assert.NotNull(timerLoopMethod);
 
             return (Task)timerLoopMethod.Invoke(limiter, Array.Empty<object>());
diff --git a/src/libraries/tests.proj b/src/libraries/tests.proj

Original file line number	Diff line number	Diff line change
`@@ -142,19 +142,21 @@ public override bool IsVirtual`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
	`145`	`+ internal const string MetadataName = "__GetFieldHelper";`
	`146`	`+`
`145`	`147`	`public override string Name`
`146`	`148`	`{`
`147`	`149`	`get`
`148`	`150`	`{`
`149`		`- return "__GetFieldHelper";`
	`151`	`+ return MetadataName;`
`150`	`152`	`}`
`151`	`153`	`}`
`152`	`154`
`153`	`155`	`public override string DiagnosticName`
`154`	`156`	`{`
`155`	`157`	`get`
`156`	`158`	`{`
`157`		`- return "__GetFieldHelper";`
	`159`	`+ return MetadataName;`
`158`	`160`	`}`
`159`	`161`	`}`
`160`	`162`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,8 @@`
`14`	`14`
`15`	`15`	`namespace Microsoft.NETCore.Platforms.BuildTasks.Tests`
`16`	`16`	`{`
	`17`	`+ // MSBuild engine is not compatible with single file`
	`18`	`+ [ConditionalClass(typeof(PlatformDetection), nameof(PlatformDetection.HasAssemblyFiles))]`
`17`	`19`	`public class GenerateRuntimeGraphTests`
`18`	`20`	`{`
`19`	`21`	`private Log _log;`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,9 @@ public void InvokeOnEventsThreadRunsOnSameThreadAsOtherEvents()`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`- [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotWindowsNanoNorServerCore))]`
	`55`	`+ public static bool NotNanoNorServerCoreAndRemoteExecutorSupported => PlatformDetection.IsNotWindowsNanoNorServerCore && RemoteExecutor.IsSupported;`
	`56`	`+`
	`57`	`+ [ConditionalFact(nameof(NotNanoNorServerCoreAndRemoteExecutorSupported))]`
`56`	`58`	`[SkipOnTargetFramework(TargetFrameworkMonikers.NetFramework)]`
`57`	`59`	`[ActiveIssue("https://github.com/dotnet/runtime/issues/34360", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]`
`58`	`60`	`public void RegisterFromSTAThreadThatGoesAway_MessageStillDelivered()`