fix managed portions of runtime info

Author: Max Charlamb

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Abstractions/Contracts/IRuntimeInfo.cs

@@ -10,7 +10,7 @@ public enum RuntimeInfoArchitecture : uint
     Unknown = 0,
     X86,
     Arm32,
-    Amd64,
+    X64,
     Arm64,
     LoongArch64,
     RISCV,
@@ -19,7 +19,7 @@ public enum RuntimeInfoArchitecture : uint
 public enum RuntimeInfoOperatingSystem : uint
 {
     Unknown = 0,
-    Windows,
+    Win,
     Unix,
 }
 
@@ -32,6 +32,5 @@ public interface IRuntimeInfo : IContract
 
 public readonly struct RuntimeInfo : IRuntimeInfo
 {
-    RuntimeInfoArchitecture IRuntimeInfo.GetTargetArchitecture() => RuntimeInfoArchitecture.Unknown;
-    RuntimeInfoOperatingSystem IRuntimeInfo.GetTargetOperatingSystem() => RuntimeInfoOperatingSystem.Unknown;
+
 }

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/RuntimeInfo_1.cs

@@ -14,26 +14,26 @@ public RuntimeInfo_1(Target target)
         _target = target;
     }
 
-    RuntimeInfoArchitecture IRuntimeInfo.GetTargetArchitecture()
+    readonly RuntimeInfoArchitecture IRuntimeInfo.GetTargetArchitecture()
     {
-        if (_target.TryReadGlobal(Constants.Globals.Architecture, out uint? arch))
+        if (_target.TryReadGlobalString(Constants.Globals.Architecture, out string? arch))
         {
-            if (Enum.IsDefined(typeof(RuntimeInfoArchitecture), arch))
+            if (Enum.TryParse(arch, ignoreCase: true, out RuntimeInfoArchitecture parsedArch))
             {
-                return (RuntimeInfoArchitecture)arch;
+                return parsedArch;
             }
         }
 
         return RuntimeInfoArchitecture.Unknown;
     }
 
-    RuntimeInfoOperatingSystem IRuntimeInfo.GetTargetOperatingSystem()
+    readonly RuntimeInfoOperatingSystem IRuntimeInfo.GetTargetOperatingSystem()
     {
-        if (_target.TryReadGlobal(Constants.Globals.OperatingSystem, out uint? os))
+        if (_target.TryReadGlobalString(Constants.Globals.OperatingSystem, out string? os))
         {
-            if (Enum.IsDefined(typeof(RuntimeInfoOperatingSystem), os))
+            if (Enum.TryParse(os, ignoreCase: true, out RuntimeInfoOperatingSystem parsedOS))
             {
-                return (RuntimeInfoOperatingSystem)os;
+                return parsedOS;
             }
         }
 

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader.Contracts/Contracts/StackWalk/Context/IPlatformAgnosticContext.cs

@@ -28,7 +28,7 @@ public static IPlatformAgnosticContext GetContextForPlatform(Target target)
         IRuntimeInfo runtimeInfo = target.Contracts.RuntimeInfo;
         return runtimeInfo.GetTargetArchitecture() switch
         {
-            RuntimeInfoArchitecture.Amd64 => new ContextHolder<AMD64Context>(),
+            RuntimeInfoArchitecture.X64 => new ContextHolder<AMD64Context>(),
             RuntimeInfoArchitecture.Arm64 => new ContextHolder<ARM64Context>(),
             RuntimeInfoArchitecture.Unknown => throw new InvalidOperationException($"Processor architecture is required for creating a platform specific context and is not provided by the target"),
             _ => throw new InvalidOperationException($"Unsupported architecture {runtimeInfo.GetTargetArchitecture()}"),

src/native/managed/cdacreader/tests/RuntimeInfoTests.cs

@@ -0,0 +1,102 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.Diagnostics.DataContractReader.Contracts;
+using Moq;
+using Xunit;
+
+namespace Microsoft.Diagnostics.DataContractReader.Tests;
+
+public class RuntimeInfoTests
+{
+    internal static Target CreateTarget(
+        MockTarget.Architecture arch,
+        (string Name, string Value)[] globalStrings)
+    {
+        MockMemorySpace.Builder builder = new MockMemorySpace.Builder(new TargetTestHelpers(arch));
+        TestPlaceholderTarget target = new TestPlaceholderTarget(arch, builder.GetReadContext().ReadFromTarget, [], [], globalStrings);
+
+        IContractFactory<IRuntimeInfo> runtimeInfoFactory = new RuntimeInfoFactory();
+
+        ContractRegistry reg = Mock.Of<ContractRegistry>(
+            c => c.RuntimeInfo == runtimeInfoFactory.CreateContract(target, 1));
+        target.SetContracts(reg);
+        return target;
+    }
+
+    public static IEnumerable<object[]> StdArchAllTargetArchitectures()
+    {
+        foreach(object[] arr in new MockTarget.StdArch())
+        {
+            MockTarget.Architecture arch = (MockTarget.Architecture)arr[0];
+
+            foreach(RuntimeInfoArchitecture targetArch in (RuntimeInfoArchitecture[])Enum.GetValues(typeof(RuntimeInfoArchitecture)))
+            {
+                // Skip Unknown architecture
+                if (targetArch == RuntimeInfoArchitecture.Unknown)
+                    continue;
+
+                yield return new object[] { arch, targetArch.ToString().ToLowerInvariant(), targetArch };
+            }
+
+            yield return new object[] { arch, "notATargetArch", RuntimeInfoArchitecture.Unknown };
+        }
+    }
+
+    [Theory]
+    [MemberData(nameof(StdArchAllTargetArchitectures))]
+    public void GetTargetArchitectureTest(
+        MockTarget.Architecture arch,
+        string architecture,
+        RuntimeInfoArchitecture expectedArchitecture)
+    {
+        var target = CreateTarget(arch, [(Constants.Globals.Architecture, architecture)]);
+
+        // TEST
+
+        var runtimeInfo = target.Contracts.RuntimeInfo;
+        Assert.NotNull(runtimeInfo);
+
+        var actualArchitecture = runtimeInfo.GetTargetArchitecture();
+        Assert.Equal(expectedArchitecture, actualArchitecture);
+    }
+
+    public static IEnumerable<object[]> StdArchAllTargetOS()
+    {
+        foreach(object[] arr in new MockTarget.StdArch())
+        {
+            MockTarget.Architecture arch = (MockTarget.Architecture)arr[0];
+
+            foreach(RuntimeInfoOperatingSystem targetArch in (RuntimeInfoOperatingSystem[])Enum.GetValues(typeof(RuntimeInfoOperatingSystem)))
+            {
+                // Skip Unknown architecture
+                if (targetArch == RuntimeInfoOperatingSystem.Unknown)
+                    continue;
+
+                yield return new object[] { arch, targetArch.ToString().ToLowerInvariant(), targetArch };
+            }
+
+            yield return new object[] { arch, "notAnOperatingSystem", RuntimeInfoOperatingSystem.Unknown };
+        }
+    }
+
+    [Theory]
+    [MemberData(nameof(StdArchAllTargetOS))]
+    public void GetTargetOperatingSystemTest(
+        MockTarget.Architecture arch,
+        string os,
+        RuntimeInfoOperatingSystem expectedOS)
+    {
+        var target = CreateTarget(arch, [(Constants.Globals.OperatingSystem, os)]);
+
+        // TEST
+
+        var runtimeInfo = target.Contracts.RuntimeInfo;
+        Assert.NotNull(runtimeInfo);
+
+        var actualArchitecture = runtimeInfo.GetTargetOperatingSystem();
+        Assert.Equal(expectedOS, actualArchitecture);
+    }
+}