Add new features, tests, and refactor exceptions

- Refactored `RemoteException` in `Dtos.cs` to handle stack traces differently for .NET Core and other frameworks.
- Implemented the `DivideByZero` operation in `SystemService` to test exceptions.
- Added `RemoteExceptionStackTrace_ShouldAlsoIncludeClientFrames` test to validate stack trace inclusion of client and server frames.
- Added `ShouldPartiallyContainInOrder` method in `ShouldlyHelpers.cs` for enumerable validation with logging.
- Removed unused namespaces and improved exception handling for clarity.

Author: eduard-dumitru

src/UiPath.CoreIpc.Tests/Helpers/ShouldlyHelpers.cs

@@ -1,4 +1,6 @@
 using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
 
 namespace UiPath.Ipc.Tests;
 
@@ -75,7 +77,7 @@ public static async Task ShouldStallForAtLeastAsync<T>(this Task<T> task, TimeSp
             throw new ShouldAssertException($"The task {taskExpression} should stall for at least {lease} but it completed faster.");
         }
         catch (OperationCanceledException ex) when (ex.CancellationToken == cts.Token)
-        {            
+        {
         }
     }
 
@@ -114,4 +116,45 @@ private static async Task<T> Return<T>(this Task task, T value = default!)
         await task;
         return value;
     }
+
+    public static void ShouldPartiallyContainInOrder(this IEnumerable<string> haystack, IEnumerable<string> needles, [CallerArgumentExpression(nameof(haystack))] string? supersetExpression = null, [CallerArgumentExpression(nameof(needles))] string? subsetExpression = null)
+    {
+        StringBuilder log = new();
+
+        if (!Is())
+        {
+            throw new ShouldAssertException($"The enumerable `{supersetExpression}`\r\n\tshould be an ordered superset of the \r\n{subsetExpression}\r\n\tsubset.\r\n{log}");
+        }
+
+        bool Is()
+        {
+            using var super = haystack.GetEnumerator();
+            using var sub = needles.GetEnumerator();
+
+            int superIndex = -1;
+            int subIndex = -1;
+
+            while (sub.MoveNext())
+            {
+                subIndex++;
+
+            advanceSuper:
+                if (!super.MoveNext())
+                {
+                    log.AppendLine($"ERROR: token[{subIndex}]=\"{sub.Current}\" not found");
+                    return false;
+                }
+                superIndex++;
+
+                if (!super.Current.Contains(sub.Current))
+                {
+                    goto advanceSuper;
+                }
+
+                log.AppendLine($"INFO: token[{subIndex}]=\"{sub.Current}\" found at haystack[{superIndex}](=\"{super.Current}\")");
+            }
+
+            return true;
+        }
+    }
 }

src/UiPath.CoreIpc.Tests/Services/ISystemService.cs

@@ -47,6 +47,8 @@ public interface ISystemService
     Task<string> DanishNameOfDay(DayOfWeek day, CancellationToken ct);
 
     Task<byte[]> ReverseBytes(byte[] bytes, CancellationToken ct = default);
+
+    Task<bool> DivideByZero();
 }
 
 public interface IUnregisteredCallback

src/UiPath.CoreIpc.Tests/Services/SystemService.cs

@@ -1,6 +1,6 @@
-using Castle.Core;
-using System.Buffers;
+using System.Buffers;
 using System.Globalization;
+using System.Runtime.CompilerServices;
 using System.Text;
 
 namespace UiPath.Ipc.Tests;
@@ -102,4 +102,15 @@ public Task<byte[]> ReverseBytes(byte[] bytes, CancellationToken ct = default)
         }
         return Task.FromResult(bytes);
     }
+
+    public async Task<bool> DivideByZero()
+    {
+        ServerFrame1();
+        return true;
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void ServerFrame1() => ServerFrame2();
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void ServerFrame2() => throw new DivideByZeroException();
 }

src/UiPath.CoreIpc.Tests/SystemTests.cs

@@ -1,7 +1,9 @@
 using AutoFixture;
 using AutoFixture.Xunit2;
 using Microsoft.Extensions.Hosting;
+using System.Runtime.CompilerServices;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Threading.Channels;
 using Xunit.Abstractions;
 
@@ -337,6 +339,28 @@ public async Task IpcServerDispose_ShouldBeIdempotent(Guid guid)
         await infiniteTask.ShouldThrowAsync<IOException>().ShouldCompleteInAsync(Timeouts.IpcRoundtrip);
     }
 
+    [Fact]
+    public async Task RemoteExceptionStackTrace_ShouldAlsoIncludeClientFrames()
+    {
+        var act = ClientFrame1;
+
+        (await act.ShouldThrowAsync<RemoteException>())
+            .StackTrace.ShouldNotBeNull()
+            .Split('\n')
+            .ShouldPartiallyContainInOrder([
+                nameof(SystemService.ServerFrame2),
+                nameof(SystemService.ServerFrame1),
+                nameof(ClientFrame2),
+                nameof(ClientFrame1)]);
+
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        async Task ClientFrame1() => await ClientFrame2();
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        async Task ClientFrame2() => _ = await Proxy.DivideByZero();
+    }
+
     private sealed class UploadStream : StreamBase
     {
         private readonly Channel<ReadCall> _readCalls = Channel.CreateUnbounded<ReadCall>();

src/UiPath.CoreIpc/Wire/Dtos.cs

@@ -1,6 +1,7 @@
-using System.Diagnostics.CodeAnalysis;
+using Newtonsoft.Json;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.ExceptionServices;
 using System.Text;
-using Newtonsoft.Json;
 
 namespace UiPath.Ipc;
 
@@ -66,13 +67,22 @@ public record Error(string Message, string StackTrace, string Type, Error? Inner
 
 public class RemoteException : Exception
 {
+
     public RemoteException(Error error) : base(error.Message, error.InnerError == null ? null : new RemoteException(error.InnerError))
     {
         Type = error.Type;
-        StackTrace = error.StackTrace;
+        SetRemoteStackTrace(error.StackTrace);
     }
+#if NETCOREAPP
+    private void SetRemoteStackTrace(string stackTrace) => _ = ExceptionDispatchInfo.SetRemoteStackTrace(this, stackTrace);
+#else
+    private const string StackTraceSeparator = "--- End of stack trace from previous location ---";
+    private string _remoteStackTrace = null!;
+
+    private void SetRemoteStackTrace(string stackTrace) => _remoteStackTrace = stackTrace?.TrimEnd('\r', '\n') ?? "";
+    public override string StackTrace => $"{_remoteStackTrace}\r\n{StackTraceSeparator}\r\n{base.StackTrace}";
+#endif
     public string Type { get; }
-    public override string StackTrace { get; }
     public new RemoteException? InnerException => base.InnerException as RemoteException;
     public override string ToString()
     {