Unify behavior across platforms

Author: jkotas

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.Unix.cs

@@ -88,8 +88,15 @@ public static IntPtr ReAllocHGlobal(IntPtr pv, IntPtr cb)
         {
             nuint cbNative = (nuint)(nint)cb;
 
-            // Match Windows behavior by always allocating at least one byte and only when the original pointer is non-zero
-            IntPtr pNewMem = (pv != IntPtr.Zero) ? Interop.Sys.MemReAlloc(pv, (cbNative != 0) ? cbNative : 1) : IntPtr.Zero;
+            if (cbNative == 0)
+            {
+                // ReAllocHGlobal never returns null, even for 0 size (different from standard C/C++ realloc)
+
+                // Avoid undefined realloc behavior by always allocating at least one byte
+                cbNative = 1;
+            }
+
+            IntPtr pNewMem = Interop.Sys.MemReAlloc(pv, cbNative);
             if (pNewMem == IntPtr.Zero)
             {
                 throw new OutOfMemoryException();

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.Windows.cs

@@ -147,6 +147,13 @@ public static void FreeHGlobal(IntPtr hglobal)
 
         public static IntPtr ReAllocHGlobal(IntPtr pv, IntPtr cb)
         {
+            if (pv == IntPtr.Zero)
+            {
+                // LocalReAlloc fails for pv == IntPtr.Zero. Call AllocHGlobal instead for better fidelity
+                // with standard C/C++ realloc behavior.
+                return AllocHGlobal(cb);
+            }
+
             IntPtr pNewMem = Interop.Kernel32.LocalReAlloc(pv, (nuint)(nint)cb, Interop.Kernel32.LMEM_MOVEABLE);
             if (pNewMem == IntPtr.Zero)
             {

src/libraries/System.Runtime.InteropServices/tests/System/Runtime/InteropServices/Marshal/ReAllocCoTaskMemTests.cs

@@ -43,7 +43,6 @@ public void ReAllocCoTaskMem_Invoke_DataCopied()
         [InlineData(1)]
         [InlineData(100)]
         [Theory]
-        [SkipOnMono("Behavior differences on Mono")]
         public void ReAllocCoTaskMem_PositiveSize(int size)
         {
             IntPtr p = Marshal.ReAllocCoTaskMem(IntPtr.Zero, size);
@@ -53,22 +52,11 @@ public void ReAllocCoTaskMem_PositiveSize(int size)
             Assert.NotEqual(IntPtr.Zero, p1);
 
             IntPtr p2 = Marshal.ReAllocCoTaskMem(p1, 0);
-
-            // TODO: Behavior differs between platforms currently
-            if (PlatformDetection.IsWindows)
-            {
-                Assert.Equal(IntPtr.Zero, p2);
-            }
-            else
-            {
-                Assert.NotEqual(IntPtr.Zero, p2);
-                Marshal.FreeCoTaskMem(p2);
-            }
+            Assert.Equal(IntPtr.Zero, p2);
         }
 
         [Fact]
         [OuterLoop]
-        [SkipOnMono("Behavior differences on Mono")]
         public void ReAllocCoTaskMem_NegativeSize_ThrowsOutOfMemoryException()
         {
             // -1 is treated as (uint)-1 by ReAllocCoTaskMem. The allocation may succeed on 64-bit machines.

src/libraries/System.Runtime.InteropServices/tests/System/Runtime/InteropServices/Marshal/ReAllocHGlobalTests.cs

@@ -44,19 +44,9 @@ public void ReAllocHGlobal_Invoke_DataCopied()
         [InlineData(1)]
         [InlineData(100)]
         [Theory]
-        [SkipOnMono("Behavior differences on Mono")]
         public void ReAllocHGlobal_PositiveSize(int size)
         {
-            IntPtr p;
-            // TODO: Behavior differs between platforms currently
-            if (PlatformDetection.IsWindows)
-            {
-                p = Marshal.AllocHGlobal(size);
-            }
-            else
-            {
-                p = Marshal.ReAllocHGlobal(IntPtr.Zero, (IntPtr)size);
-            }
+            IntPtr p = Marshal.ReAllocHGlobal(IntPtr.Zero, (IntPtr)size);
             Assert.NotEqual(IntPtr.Zero, p);
 
             IntPtr p1 = Marshal.ReAllocHGlobal(p, (IntPtr)(size + 1));
@@ -70,16 +60,8 @@ public void ReAllocHGlobal_PositiveSize(int size)
         }
 
         [Fact]
-        [SkipOnMono("Behavior differences on Mono")]
         public void ReAllocHGlobal_NegativeSize_ThrowsOutOfMemoryException()
         {
-            // TODO: Behavior differs between platforms currently
-            if (PlatformDetection.IsWindows)
-            {
-                // ReAllocHGlobal always throws when the original pointer is null (different from standard C/C++ realloc)
-                Assert.Throws<OutOfMemoryException>(() => Marshal.ReAllocHGlobal(IntPtr.Zero, IntPtr.Zero));
-                Assert.Throws<OutOfMemoryException>(() => Marshal.ReAllocHGlobal(IntPtr.Zero, (IntPtr)1));
-            }
             Assert.Throws<OutOfMemoryException>(() => Marshal.ReAllocHGlobal(IntPtr.Zero, (IntPtr)(-1)));
 
             IntPtr p = Marshal.AllocHGlobal((IntPtr)1);