Change AsSuccessResult() to return the RemoteValue directly.

RenderMichael · RenderMichael · commit 11d4c7d01baa · 2025-04-02T23:53:17.000-04:00
diff --git a/dotnet/src/webdriver/BiDi/Modules/BrowsingContext/BrowsingContextScriptModule.cs b/dotnet/src/webdriver/BiDi/Modules/BrowsingContext/BrowsingContextScriptModule.cs
@@ -60,7 +60,7 @@ public Task<EvaluateResult> EvaluateAsync(string expression, bool awaitPromise,
     {
         var result = await EvaluateAsync(expression, awaitPromise, options, targetOptions).ConfigureAwait(false);
 
-        return result.AsSuccessResult().Result.ConvertTo<TResult>();
+        return result.AsSuccessResult().ConvertTo<TResult>();
     }
 
     public Task<EvaluateResult> CallFunctionAsync(string functionDeclaration, bool awaitPromise, CallFunctionOptions? options = null, ContextTargetOptions? targetOptions = null)
@@ -79,6 +79,6 @@ public Task<EvaluateResult> CallFunctionAsync(string functionDeclaration, bool a
     {
         var result = await CallFunctionAsync(functionDeclaration, awaitPromise, options, targetOptions).ConfigureAwait(false);
 
-        return result.AsSuccessResult().Result.ConvertTo<TResult>();
+        return result.AsSuccessResult().ConvertTo<TResult>();
     }
 }
diff --git a/dotnet/src/webdriver/BiDi/Modules/Script/EvaluateCommand.cs b/dotnet/src/webdriver/BiDi/Modules/Script/EvaluateCommand.cs
@@ -41,11 +41,11 @@ public record EvaluateOptions : CommandOptions
 //[JsonDerivedType(typeof(EvaluateResultException), "exception")]
 public abstract record EvaluateResult
 {
-    public EvaluateResultSuccess AsSuccessResult()
+    public RemoteValue AsSuccessResult()
     {
         if (this is EvaluateResultSuccess success)
         {
-            return success;
+            return success.Result;
         }
 
         var exceptionResult = (EvaluateResultException)this;
diff --git a/dotnet/src/webdriver/BiDi/Modules/Script/ScriptModule.cs b/dotnet/src/webdriver/BiDi/Modules/Script/ScriptModule.cs
@@ -38,7 +38,7 @@ public async Task<EvaluateResult> EvaluateAsync(string expression, bool awaitPro
     {
         var result = await EvaluateAsync(expression, awaitPromise, target, options).ConfigureAwait(false);
 
-        return result.AsSuccessResult().Result.ConvertTo<TResult>();
+        return result.AsSuccessResult().ConvertTo<TResult>();
     }
 
     public async Task<EvaluateResult> CallFunctionAsync(string functionDeclaration, bool awaitPromise, Target target, CallFunctionOptions? options = null)
@@ -54,7 +54,7 @@ public async Task<EvaluateResult> CallFunctionAsync(string functionDeclaration,
     {
         var result = await CallFunctionAsync(functionDeclaration, awaitPromise, target, options).ConfigureAwait(false);
 
-        return result.AsSuccessResult().Result.ConvertTo<TResult>();
+        return result.AsSuccessResult().ConvertTo<TResult>();
     }
 
     public async Task<GetRealmsResult> GetRealmsAsync(GetRealmsOptions? options = null)
diff --git a/dotnet/test/common/BiDi/Script/CallFunctionParameterTest.cs b/dotnet/test/common/BiDi/Script/CallFunctionParameterTest.cs
@@ -31,8 +31,8 @@ public async Task CanCallFunctionWithDeclaration()
         var res = await context.Script.CallFunctionAsync("() => { return 1 + 2; }", false);
 
         Assert.That(res, Is.Not.Null);
-        Assert.That(res.AsSuccessResult().Realm, Is.Not.Null);
-        Assert.That((res.AsSuccessResult().Result as NumberRemoteValue).Value, Is.EqualTo(3));
+        Assert.That(((EvaluateResultSuccess)res).Realm, Is.Not.Null);
+        Assert.That((res.AsSuccessResult() as NumberRemoteValue).Value, Is.EqualTo(3));
     }
 
     [Test]
@@ -75,9 +75,9 @@ public async Task CanCallFunctionWithArguments()
             Arguments = ["abc", 42]
         });
 
-        Assert.That(res.AsSuccessResult().Result, Is.AssignableFrom<ArrayRemoteValue>());
-        Assert.That((string)(res.AsSuccessResult().Result as ArrayRemoteValue).Value[0], Is.EqualTo("abc"));
-        Assert.That((int)(res.AsSuccessResult().Result as ArrayRemoteValue).Value[1], Is.EqualTo(42));
+        Assert.That(res.AsSuccessResult(), Is.AssignableFrom<ArrayRemoteValue>());
+        Assert.That((string)(res.AsSuccessResult() as ArrayRemoteValue).Value[0], Is.EqualTo("abc"));
+        Assert.That((int)(res.AsSuccessResult() as ArrayRemoteValue).Value[1], Is.EqualTo(42));
     }
 
     [Test]
@@ -90,8 +90,8 @@ public async Task CanCallFunctionToGetIFrameBrowsingContext()
             """, false);
 
         Assert.That(res, Is.Not.Null);
-        Assert.That(res.AsSuccessResult().Result, Is.AssignableFrom<WindowProxyRemoteValue>());
-        Assert.That((res.AsSuccessResult().Result as WindowProxyRemoteValue).Value, Is.Not.Null);
+        Assert.That(res.AsSuccessResult(), Is.AssignableFrom<WindowProxyRemoteValue>());
+        Assert.That((res.AsSuccessResult() as WindowProxyRemoteValue).Value, Is.Not.Null);
     }
 
     [Test]
@@ -104,8 +104,8 @@ public async Task CanCallFunctionToGetElement()
             """, false);
 
         Assert.That(res, Is.Not.Null);
-        Assert.That(res.AsSuccessResult().Result, Is.AssignableFrom<NodeRemoteValue>());
-        Assert.That((res.AsSuccessResult().Result as NodeRemoteValue).Value, Is.Not.Null);
+        Assert.That(res.AsSuccessResult(), Is.AssignableFrom<NodeRemoteValue>());
+        Assert.That((res.AsSuccessResult() as NodeRemoteValue).Value, Is.Not.Null);
     }
 
     [Test]
@@ -132,7 +132,7 @@ async function() {
             """, awaitPromise: false);
 
         Assert.That(res, Is.Not.Null);
-        Assert.That(res.AsSuccessResult().Result, Is.AssignableFrom<PromiseRemoteValue>());
+        Assert.That(res.AsSuccessResult(), Is.AssignableFrom<PromiseRemoteValue>());
     }
 
     [Test]
@@ -156,9 +156,9 @@ public async Task CanCallFunctionWithOwnershipRoot()
         });
 
         Assert.That(res, Is.Not.Null);
-        Assert.That((res.AsSuccessResult().Result as ObjectRemoteValue).Handle, Is.Not.Null);
-        Assert.That((string)(res.AsSuccessResult().Result as ObjectRemoteValue).Value[0][0], Is.EqualTo("a"));
-        Assert.That((int)(res.AsSuccessResult().Result as ObjectRemoteValue).Value[0][1], Is.EqualTo(1));
+        Assert.That((res.AsSuccessResult() as ObjectRemoteValue).Handle, Is.Not.Null);
+        Assert.That((string)(res.AsSuccessResult() as ObjectRemoteValue).Value[0][0], Is.EqualTo("a"));
+        Assert.That((int)(res.AsSuccessResult() as ObjectRemoteValue).Value[0][1], Is.EqualTo(1));
     }
 
     [Test]
@@ -170,9 +170,9 @@ public async Task CanCallFunctionWithOwnershipNone()
         });
 
         Assert.That(res, Is.Not.Null);
-        Assert.That((res.AsSuccessResult().Result as ObjectRemoteValue).Handle, Is.Null);
-        Assert.That((string)(res.AsSuccessResult().Result as ObjectRemoteValue).Value[0][0], Is.EqualTo("a"));
-        Assert.That((int)(res.AsSuccessResult().Result as ObjectRemoteValue).Value[0][1], Is.EqualTo(1));
+        Assert.That((res.AsSuccessResult() as ObjectRemoteValue).Handle, Is.Null);
+        Assert.That((string)(res.AsSuccessResult() as ObjectRemoteValue).Value[0][0], Is.EqualTo("a"));
+        Assert.That((int)(res.AsSuccessResult() as ObjectRemoteValue).Value[0][1], Is.EqualTo(1));
     }
 
     [Test]
@@ -192,16 +192,16 @@ public async Task CanCallFunctionInASandBox()
 
         var res = await context.Script.CallFunctionAsync("() => window.foo", true, targetOptions: new() { Sandbox = "sandbox" });
 
-        Assert.That(res.AsSuccessResult().Result, Is.AssignableFrom<UndefinedRemoteValue>());
+        Assert.That(res.AsSuccessResult(), Is.AssignableFrom<UndefinedRemoteValue>());
 
         // Make changes in the sandbox
         await context.Script.CallFunctionAsync("() => { window.foo = 2; }", true, targetOptions: new() { Sandbox = "sandbox" });
 
         // Check if the changes are present in the sandbox
         res = await context.Script.CallFunctionAsync("() => window.foo", true, targetOptions: new() { Sandbox = "sandbox" });
 
-        Assert.That(res.AsSuccessResult().Result, Is.AssignableFrom<NumberRemoteValue>());
-        Assert.That((res.AsSuccessResult().Result as NumberRemoteValue).Value, Is.EqualTo(2));
+        Assert.That(res.AsSuccessResult(), Is.AssignableFrom<NumberRemoteValue>());
+        Assert.That((res.AsSuccessResult() as NumberRemoteValue).Value, Is.EqualTo(2));
     }
 
     [Test]
diff --git a/dotnet/test/common/BiDi/Script/CallFunctionRemoteValueTest.cs b/dotnet/test/common/BiDi/Script/CallFunctionRemoteValueTest.cs
@@ -30,33 +30,33 @@ public async Task CanCallFunctionAndReturnUndefined()
     {
         var response = await context.Script.CallFunctionAsync("() => { return undefined; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<UndefinedRemoteValue>());
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<UndefinedRemoteValue>());
     }
 
     [Test]
     public async Task CanCallFunctionAndReturnNull()
     {
         var response = await context.Script.CallFunctionAsync("() => { return null; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NullRemoteValue>());
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<NullRemoteValue>());
     }
 
     [Test]
     public async Task CanCallFunctionAndReturnTrue()
     {
         var response = await context.Script.CallFunctionAsync("() => { return true; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<BooleanRemoteValue>());
-        Assert.That(((BooleanRemoteValue)response.AsSuccessResult().Result).Value, Is.True);
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<BooleanRemoteValue>());
+        Assert.That(((BooleanRemoteValue)response.AsSuccessResult()).Value, Is.True);
     }
 
     [Test]
     public async Task CanCallFunctionAndReturnFalse()
     {
         var response = await context.Script.CallFunctionAsync("() => { return false; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<BooleanRemoteValue>());
-        Assert.That(((BooleanRemoteValue)response.AsSuccessResult().Result).Value, Is.False);
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<BooleanRemoteValue>());
+        Assert.That(((BooleanRemoteValue)response.AsSuccessResult()).Value, Is.False);
     }
 
 
@@ -65,17 +65,17 @@ public async Task CanCallFunctionAndReturnEmptyString()
     {
         var response = await context.Script.CallFunctionAsync("() => { return ''; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<StringRemoteValue>());
-        Assert.That(((StringRemoteValue)response.AsSuccessResult().Result).Value, Is.Empty);
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<StringRemoteValue>());
+        Assert.That(((StringRemoteValue)response.AsSuccessResult()).Value, Is.Empty);
     }
 
     [Test]
     public async Task CanCallFunctionAndReturnNonEmptyString()
     {
         var response = await context.Script.CallFunctionAsync("() => { return 'whoa'; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<StringRemoteValue>());
-        Assert.That(((StringRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo("whoa"));
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<StringRemoteValue>());
+        Assert.That(((StringRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo("whoa"));
     }
 
     [Test]
@@ -85,8 +85,8 @@ public async Task CanCallFunctionAndReturnRecentDate()
 
         var response = await context.Script.CallFunctionAsync($$"""() => { return new Date('{{PinnedDateTimeString}}'); }""", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<DateRemoteValue>());
-        Assert.That(response.AsSuccessResult().Result, Is.EqualTo(new DateRemoteValue(PinnedDateTimeString)));
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<DateRemoteValue>());
+        Assert.That(response.AsSuccessResult(), Is.EqualTo(new DateRemoteValue(PinnedDateTimeString)));
     }
 
     [Test]
@@ -96,45 +96,45 @@ public async Task CanCallFunctionAndReturnUnixEpoch()
 
         var response = await context.Script.CallFunctionAsync($$"""() => { return new Date('{{EpochString}}'); }""", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<DateRemoteValue>());
-        Assert.That(response.AsSuccessResult().Result, Is.EqualTo(new DateRemoteValue(EpochString)));
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<DateRemoteValue>());
+        Assert.That(response.AsSuccessResult(), Is.EqualTo(new DateRemoteValue(EpochString)));
     }
 
     [Test]
     public async Task CanCallFunctionAndReturnNumberFive()
     {
         var response = await context.Script.CallFunctionAsync("() => { return 5; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());
-        Assert.That(((NumberRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(5));
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());
+        Assert.That(((NumberRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(5));
     }
 
     [Test]
     public async Task CanCallFunctionAndReturnNumberNegativeFive()
     {
         var response = await context.Script.CallFunctionAsync("() => { return -5; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());
-        Assert.That(((NumberRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(-5));
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());
+        Assert.That(((NumberRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(-5));
     }
 
     [Test]
     public async Task CanCallFunctionAndReturnNumberZero()
     {
         var response = await context.Script.CallFunctionAsync("() => { return 0; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());
-        Assert.That(((NumberRemoteValue)response.AsSuccessResult().Result).Value, Is.Zero);
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());
+        Assert.That(((NumberRemoteValue)response.AsSuccessResult()).Value, Is.Zero);
     }
 
     [Test]
     public async Task CanCallFunctionAndReturnNumberNegativeZero()
     {
         var response = await context.Script.CallFunctionAsync("() => { return -0; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());
 
-        var actualNumberValue = ((NumberRemoteValue)response.AsSuccessResult().Result).Value;
+        var actualNumberValue = ((NumberRemoteValue)response.AsSuccessResult()).Value;
         Assert.That(actualNumberValue, Is.Zero);
         Assert.That(double.IsNegative(actualNumberValue), Is.True);
     }
@@ -144,9 +144,9 @@ public async Task CanCallFunctionAndReturnNumberPositiveInfinity()
     {
         var response = await context.Script.CallFunctionAsync("() => { return Number.POSITIVE_INFINITY; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());
 
-        var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult().Result).Value;
+        var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult()).Value;
         Assert.That(double.IsPositiveInfinity(expectedInfinity));
     }
 
@@ -155,9 +155,9 @@ public async Task CanCallFunctionAndReturnNumberNegativeInfinity()
     {
         var response = await context.Script.CallFunctionAsync("() => { return Number.NEGATIVE_INFINITY; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());
 
-        var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult().Result).Value;
+        var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult()).Value;
         Assert.That(double.IsNegativeInfinity(expectedInfinity));
     }
 
@@ -166,8 +166,8 @@ public async Task CanCallFunctionAndReturnNumberNaN()
     {
         var response = await context.Script.CallFunctionAsync("() => { return NaN; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());
-        var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult().Result).Value;
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());
+        var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult()).Value;
         Assert.That(double.IsNaN(expectedInfinity));
     }
 
@@ -176,8 +176,8 @@ public async Task CanCallFunctionAndReturnRegExp()
     {
         var response = await context.Script.CallFunctionAsync("() => { return /foo*/g; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<RegExpRemoteValue>());
-        Assert.That(response.AsSuccessResult().Result, Is.EqualTo(new RegExpRemoteValue(new RegExpValue("foo*") { Flags = "g" })));
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<RegExpRemoteValue>());
+        Assert.That(response.AsSuccessResult(), Is.EqualTo(new RegExpRemoteValue(new RegExpValue("foo*") { Flags = "g" })));
     }
 
     [Test]
@@ -186,22 +186,22 @@ public async Task CanCallFunctionAndReturnArray()
         var response = await context.Script.CallFunctionAsync("() => { return ['hi']; }", false);
 
         var expectedArray = new ArrayRemoteValue { Value = [new StringRemoteValue("hi")] };
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<ArrayRemoteValue>());
-        Assert.That(((ArrayRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(expectedArray.Value));
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<ArrayRemoteValue>());
+        Assert.That(((ArrayRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(expectedArray.Value));
     }
 
     [Test]
     public async Task CanCallFunctionAndReturnObject()
     {
         var response = await context.Script.CallFunctionAsync("() => { return { objKey: 'objValue' }; }", false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<ObjectRemoteValue>());
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<ObjectRemoteValue>());
 
         var expected = new ObjectRemoteValue
         {
             Value = [[new StringRemoteValue("objKey"), new StringRemoteValue("objValue")]]
         };
-        Assert.That(((ObjectRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(expected.Value));
+        Assert.That(((ObjectRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(expected.Value));
     }
 
     [Test]
@@ -220,8 +220,8 @@ public async Task CanCallFunctionAndReturnMap()
             }
             """, false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<MapRemoteValue>());
-        Assert.That(((MapRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(expected.Value));
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<MapRemoteValue>());
+        Assert.That(((MapRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(expected.Value));
     }
 
     [Test]
@@ -236,7 +236,7 @@ public async Task CanCallFunctionAndReturnSet()
             }
             """, false);
 
-        Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<SetRemoteValue>());
-        Assert.That(((SetRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(expected.Value));
+        Assert.That(response.AsSuccessResult(), Is.AssignableTo<SetRemoteValue>());
+        Assert.That(((SetRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(expected.Value));
     }
 }
diff --git a/dotnet/test/common/BiDi/Script/EvaluateParametersTest.cs b/dotnet/test/common/BiDi/Script/EvaluateParametersTest.cs
diff --git a/dotnet/test/common/BiDi/Script/ScriptCommandsTest.cs b/dotnet/test/common/BiDi/Script/ScriptCommandsTest.cs

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ public Task<EvaluateResult> EvaluateAsync(string expression, bool awaitPromise,`
`60`	`60`	`{`
`61`	`61`	`var result = await EvaluateAsync(expression, awaitPromise, options, targetOptions).ConfigureAwait(false);`
`62`	`62`
`63`		`- return result.AsSuccessResult().Result.ConvertTo<TResult>();`
	`63`	`+ return result.AsSuccessResult().ConvertTo<TResult>();`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`public Task<EvaluateResult> CallFunctionAsync(string functionDeclaration, bool awaitPromise, CallFunctionOptions? options = null, ContextTargetOptions? targetOptions = null)`
`@@ -79,6 +79,6 @@ public Task<EvaluateResult> CallFunctionAsync(string functionDeclaration, bool a`
`79`	`79`	`{`
`80`	`80`	`var result = await CallFunctionAsync(functionDeclaration, awaitPromise, options, targetOptions).ConfigureAwait(false);`
`81`	`81`
`82`		`- return result.AsSuccessResult().Result.ConvertTo<TResult>();`
	`82`	`+ return result.AsSuccessResult().ConvertTo<TResult>();`
`83`	`83`	`}`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,11 +41,11 @@ public record EvaluateOptions : CommandOptions`
`41`	`41`	`//[JsonDerivedType(typeof(EvaluateResultException), "exception")]`
`42`	`42`	`public abstract record EvaluateResult`
`43`	`43`	`{`
`44`		`- public EvaluateResultSuccess AsSuccessResult()`
	`44`	`+ public RemoteValue AsSuccessResult()`
`45`	`45`	`{`
`46`	`46`	`if (this is EvaluateResultSuccess success)`
`47`	`47`	`{`
`48`		`- return success;`
	`48`	`+ return success.Result;`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`var exceptionResult = (EvaluateResultException)this;`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public async Task<EvaluateResult> EvaluateAsync(string expression, bool awaitPro`
`38`	`38`	`{`
`39`	`39`	`var result = await EvaluateAsync(expression, awaitPromise, target, options).ConfigureAwait(false);`
`40`	`40`
`41`		`- return result.AsSuccessResult().Result.ConvertTo<TResult>();`
	`41`	`+ return result.AsSuccessResult().ConvertTo<TResult>();`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public async Task<EvaluateResult> CallFunctionAsync(string functionDeclaration, bool awaitPromise, Target target, CallFunctionOptions? options = null)`
`@@ -54,7 +54,7 @@ public async Task<EvaluateResult> CallFunctionAsync(string functionDeclaration,`
`54`	`54`	`{`
`55`	`55`	`var result = await CallFunctionAsync(functionDeclaration, awaitPromise, target, options).ConfigureAwait(false);`
`56`	`56`
`57`		`- return result.AsSuccessResult().Result.ConvertTo<TResult>();`
	`57`	`+ return result.AsSuccessResult().ConvertTo<TResult>();`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`public async Task<GetRealmsResult> GetRealmsAsync(GetRealmsOptions? options = null)`
Original file line number	Diff line number	Diff line change
`@@ -30,33 +30,33 @@ public async Task CanCallFunctionAndReturnUndefined()`
`30`	`30`	`{`
`31`	`31`	`var response = await context.Script.CallFunctionAsync("() => { return undefined; }", false);`
`32`	`32`
`33`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<UndefinedRemoteValue>());`
	`33`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<UndefinedRemoteValue>());`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`[Test]`
`37`	`37`	`public async Task CanCallFunctionAndReturnNull()`
`38`	`38`	`{`
`39`	`39`	`var response = await context.Script.CallFunctionAsync("() => { return null; }", false);`
`40`	`40`
`41`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NullRemoteValue>());`
	`41`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<NullRemoteValue>());`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`[Test]`
`45`	`45`	`public async Task CanCallFunctionAndReturnTrue()`
`46`	`46`	`{`
`47`	`47`	`var response = await context.Script.CallFunctionAsync("() => { return true; }", false);`
`48`	`48`
`49`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<BooleanRemoteValue>());`
`50`		`- Assert.That(((BooleanRemoteValue)response.AsSuccessResult().Result).Value, Is.True);`
	`49`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<BooleanRemoteValue>());`
	`50`	`+ Assert.That(((BooleanRemoteValue)response.AsSuccessResult()).Value, Is.True);`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`[Test]`
`54`	`54`	`public async Task CanCallFunctionAndReturnFalse()`
`55`	`55`	`{`
`56`	`56`	`var response = await context.Script.CallFunctionAsync("() => { return false; }", false);`
`57`	`57`
`58`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<BooleanRemoteValue>());`
`59`		`- Assert.That(((BooleanRemoteValue)response.AsSuccessResult().Result).Value, Is.False);`
	`58`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<BooleanRemoteValue>());`
	`59`	`+ Assert.That(((BooleanRemoteValue)response.AsSuccessResult()).Value, Is.False);`
`60`	`60`	`}`
`61`	`61`
`62`	`62`
`@@ -65,17 +65,17 @@ public async Task CanCallFunctionAndReturnEmptyString()`
`65`	`65`	`{`
`66`	`66`	`var response = await context.Script.CallFunctionAsync("() => { return ''; }", false);`
`67`	`67`
`68`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<StringRemoteValue>());`
`69`		`- Assert.That(((StringRemoteValue)response.AsSuccessResult().Result).Value, Is.Empty);`
	`68`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<StringRemoteValue>());`
	`69`	`+ Assert.That(((StringRemoteValue)response.AsSuccessResult()).Value, Is.Empty);`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`[Test]`
`73`	`73`	`public async Task CanCallFunctionAndReturnNonEmptyString()`
`74`	`74`	`{`
`75`	`75`	`var response = await context.Script.CallFunctionAsync("() => { return 'whoa'; }", false);`
`76`	`76`
`77`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<StringRemoteValue>());`
`78`		`- Assert.That(((StringRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo("whoa"));`
	`77`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<StringRemoteValue>());`
	`78`	`+ Assert.That(((StringRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo("whoa"));`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`[Test]`
`@@ -85,8 +85,8 @@ public async Task CanCallFunctionAndReturnRecentDate()`
`85`	`85`
`86`	`86`	`var response = await context.Script.CallFunctionAsync($$"""() => { return new Date('{{PinnedDateTimeString}}'); }""", false);`
`87`	`87`
`88`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<DateRemoteValue>());`
`89`		`- Assert.That(response.AsSuccessResult().Result, Is.EqualTo(new DateRemoteValue(PinnedDateTimeString)));`
	`88`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<DateRemoteValue>());`
	`89`	`+ Assert.That(response.AsSuccessResult(), Is.EqualTo(new DateRemoteValue(PinnedDateTimeString)));`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`[Test]`
`@@ -96,45 +96,45 @@ public async Task CanCallFunctionAndReturnUnixEpoch()`
`96`	`96`
`97`	`97`	`var response = await context.Script.CallFunctionAsync($$"""() => { return new Date('{{EpochString}}'); }""", false);`
`98`	`98`
`99`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<DateRemoteValue>());`
`100`		`- Assert.That(response.AsSuccessResult().Result, Is.EqualTo(new DateRemoteValue(EpochString)));`
	`99`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<DateRemoteValue>());`
	`100`	`+ Assert.That(response.AsSuccessResult(), Is.EqualTo(new DateRemoteValue(EpochString)));`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`[Test]`
`104`	`104`	`public async Task CanCallFunctionAndReturnNumberFive()`
`105`	`105`	`{`
`106`	`106`	`var response = await context.Script.CallFunctionAsync("() => { return 5; }", false);`
`107`	`107`
`108`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());`
`109`		`- Assert.That(((NumberRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(5));`
	`108`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());`
	`109`	`+ Assert.That(((NumberRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(5));`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`[Test]`
`113`	`113`	`public async Task CanCallFunctionAndReturnNumberNegativeFive()`
`114`	`114`	`{`
`115`	`115`	`var response = await context.Script.CallFunctionAsync("() => { return -5; }", false);`
`116`	`116`
`117`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());`
`118`		`- Assert.That(((NumberRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(-5));`
	`117`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());`
	`118`	`+ Assert.That(((NumberRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(-5));`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`[Test]`
`122`	`122`	`public async Task CanCallFunctionAndReturnNumberZero()`
`123`	`123`	`{`
`124`	`124`	`var response = await context.Script.CallFunctionAsync("() => { return 0; }", false);`
`125`	`125`
`126`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());`
`127`		`- Assert.That(((NumberRemoteValue)response.AsSuccessResult().Result).Value, Is.Zero);`
	`126`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());`
	`127`	`+ Assert.That(((NumberRemoteValue)response.AsSuccessResult()).Value, Is.Zero);`
`128`	`128`	`}`
`129`	`129`
`130`	`130`	`[Test]`
`131`	`131`	`public async Task CanCallFunctionAndReturnNumberNegativeZero()`
`132`	`132`	`{`
`133`	`133`	`var response = await context.Script.CallFunctionAsync("() => { return -0; }", false);`
`134`	`134`
`135`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());`
	`135`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());`
`136`	`136`
`137`		`- var actualNumberValue = ((NumberRemoteValue)response.AsSuccessResult().Result).Value;`
	`137`	`+ var actualNumberValue = ((NumberRemoteValue)response.AsSuccessResult()).Value;`
`138`	`138`	`Assert.That(actualNumberValue, Is.Zero);`
`139`	`139`	`Assert.That(double.IsNegative(actualNumberValue), Is.True);`
`140`	`140`	`}`
`@@ -144,9 +144,9 @@ public async Task CanCallFunctionAndReturnNumberPositiveInfinity()`
`144`	`144`	`{`
`145`	`145`	`var response = await context.Script.CallFunctionAsync("() => { return Number.POSITIVE_INFINITY; }", false);`
`146`	`146`
`147`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());`
	`147`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());`
`148`	`148`
`149`		`- var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult().Result).Value;`
	`149`	`+ var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult()).Value;`
`150`	`150`	`Assert.That(double.IsPositiveInfinity(expectedInfinity));`
`151`	`151`	`}`
`152`	`152`
`@@ -155,9 +155,9 @@ public async Task CanCallFunctionAndReturnNumberNegativeInfinity()`
`155`	`155`	`{`
`156`	`156`	`var response = await context.Script.CallFunctionAsync("() => { return Number.NEGATIVE_INFINITY; }", false);`
`157`	`157`
`158`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());`
	`158`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());`
`159`	`159`
`160`		`- var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult().Result).Value;`
	`160`	`+ var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult()).Value;`
`161`	`161`	`Assert.That(double.IsNegativeInfinity(expectedInfinity));`
`162`	`162`	`}`
`163`	`163`
`@@ -166,8 +166,8 @@ public async Task CanCallFunctionAndReturnNumberNaN()`
`166`	`166`	`{`
`167`	`167`	`var response = await context.Script.CallFunctionAsync("() => { return NaN; }", false);`
`168`	`168`
`169`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<NumberRemoteValue>());`
`170`		`- var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult().Result).Value;`
	`169`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<NumberRemoteValue>());`
	`170`	`+ var expectedInfinity = ((NumberRemoteValue)response.AsSuccessResult()).Value;`
`171`	`171`	`Assert.That(double.IsNaN(expectedInfinity));`
`172`	`172`	`}`
`173`	`173`
`@@ -176,8 +176,8 @@ public async Task CanCallFunctionAndReturnRegExp()`
`176`	`176`	`{`
`177`	`177`	`var response = await context.Script.CallFunctionAsync("() => { return /foo*/g; }", false);`
`178`	`178`
`179`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<RegExpRemoteValue>());`
`180`		`- Assert.That(response.AsSuccessResult().Result, Is.EqualTo(new RegExpRemoteValue(new RegExpValue("foo*") { Flags = "g" })));`
	`179`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<RegExpRemoteValue>());`
	`180`	`+ Assert.That(response.AsSuccessResult(), Is.EqualTo(new RegExpRemoteValue(new RegExpValue("foo*") { Flags = "g" })));`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`[Test]`
`@@ -186,22 +186,22 @@ public async Task CanCallFunctionAndReturnArray()`
`186`	`186`	`var response = await context.Script.CallFunctionAsync("() => { return ['hi']; }", false);`
`187`	`187`
`188`	`188`	`var expectedArray = new ArrayRemoteValue { Value = [new StringRemoteValue("hi")] };`
`189`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<ArrayRemoteValue>());`
`190`		`- Assert.That(((ArrayRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(expectedArray.Value));`
	`189`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<ArrayRemoteValue>());`
	`190`	`+ Assert.That(((ArrayRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(expectedArray.Value));`
`191`	`191`	`}`
`192`	`192`
`193`	`193`	`[Test]`
`194`	`194`	`public async Task CanCallFunctionAndReturnObject()`
`195`	`195`	`{`
`196`	`196`	`var response = await context.Script.CallFunctionAsync("() => { return { objKey: 'objValue' }; }", false);`
`197`	`197`
`198`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<ObjectRemoteValue>());`
	`198`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<ObjectRemoteValue>());`
`199`	`199`
`200`	`200`	`var expected = new ObjectRemoteValue`
`201`	`201`	`{`
`202`	`202`	`Value = [[new StringRemoteValue("objKey"), new StringRemoteValue("objValue")]]`
`203`	`203`	`};`
`204`		`- Assert.That(((ObjectRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(expected.Value));`
	`204`	`+ Assert.That(((ObjectRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(expected.Value));`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`[Test]`
`@@ -220,8 +220,8 @@ public async Task CanCallFunctionAndReturnMap()`
`220`	`220`	`}`
`221`	`221`	`""", false);`
`222`	`222`
`223`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<MapRemoteValue>());`
`224`		`- Assert.That(((MapRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(expected.Value));`
	`223`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<MapRemoteValue>());`
	`224`	`+ Assert.That(((MapRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(expected.Value));`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`[Test]`
`@@ -236,7 +236,7 @@ public async Task CanCallFunctionAndReturnSet()`
`236`	`236`	`}`
`237`	`237`	`""", false);`
`238`	`238`
`239`		`- Assert.That(response.AsSuccessResult().Result, Is.AssignableTo<SetRemoteValue>());`
`240`		`- Assert.That(((SetRemoteValue)response.AsSuccessResult().Result).Value, Is.EqualTo(expected.Value));`
	`239`	`+ Assert.That(response.AsSuccessResult(), Is.AssignableTo<SetRemoteValue>());`
	`240`	`+ Assert.That(((SetRemoteValue)response.AsSuccessResult()).Value, Is.EqualTo(expected.Value));`
`241`	`241`	`}`
`242`	`242`	`}`