PR test feedback

RenderMichael · RenderMichael · commit 1a7c7f3f64fa · 2025-03-12T16:03:52.000-04:00
diff --git a/dotnet/test/common/BiDi/Script/CallFunctionLocalValueTest.cs b/dotnet/test/common/BiDi/Script/CallFunctionLocalValueTest.cs
@@ -27,7 +27,7 @@ class CallFunctionLocalValueTest : BiDiTestFixture
     [Test]
     public void CanCallFunctionWithArgumentUndefined()
     {
-        var undefined = new LocalValue.Undefined();
+        var arg = new LocalValue.Undefined();
         Assert.That(async () =>
         {
             await context.Script.CallFunctionAsync($$"""
@@ -36,14 +36,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [undefined] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNull()
     {
-        var @null = new LocalValue.Null();
+        var arg = new LocalValue.Null();
         Assert.That(async () =>
         {
             await context.Script.CallFunctionAsync($$"""
@@ -52,14 +52,14 @@ await context.Script.CallFunctionAsync($$"""
               throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [@null] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentEmptyString()
     {
-        var empty = new LocalValue.String(string.Empty);
+        var arg = new LocalValue.String(string.Empty);
         Assert.That(async () =>
         {
             await context.Script.CallFunctionAsync($$"""
@@ -68,14 +68,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [empty] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNonEmptyString()
     {
-        var whoaString = new LocalValue.String("whoa");
+        var arg = new LocalValue.String("whoa");
         Assert.That(async () =>
         {
             await context.Script.CallFunctionAsync($$"""
@@ -84,7 +84,7 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [whoaString] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
@@ -93,7 +93,7 @@ public void CanCallFunctionWithArgumentRecentDate()
     {
         const string PinnedDateTimeString = "2025-03-09T00:30:33.083Z";
 
-        var date = new LocalValue.Date(PinnedDateTimeString);
+        var arg = new LocalValue.Date(PinnedDateTimeString);
 
         Assert.That(async () =>
         {
@@ -103,7 +103,7 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [date] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
@@ -112,7 +112,7 @@ public void CanCallFunctionWithArgumentEpochDate()
     {
         const string EpochString = "1970-01-01T00:00:00.000Z";
 
-        var epochDate = new LocalValue.Date(EpochString);
+        var arg = new LocalValue.Date(EpochString);
 
         Assert.That(async () =>
         {
@@ -122,14 +122,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg.toISOString());
               }
             }
-            """, false, new() { Arguments = [epochDate] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumberFive()
     {
-        var number5 = new LocalValue.Number(5);
+        var arg = new LocalValue.Number(5);
 
         Assert.That(async () =>
         {
@@ -139,14 +139,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [number5] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumberNegativeFive()
     {
-        var numberMinus5 = new LocalValue.Number(-5);
+        var arg = new LocalValue.Number(-5);
 
         Assert.That(async () =>
         {
@@ -156,14 +156,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [numberMinus5] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumberZero()
     {
-        var number0 = new LocalValue.Number(0);
+        var arg = new LocalValue.Number(0);
 
         Assert.That(async () =>
         {
@@ -173,7 +173,7 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [number0] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
@@ -182,7 +182,7 @@ await context.Script.CallFunctionAsync($$"""
     [IgnoreBrowser(Selenium.Browser.Chrome, "Chromium can't handle -0 argument as a number: https://github.com/w3c/webdriver-bidi/issues/887")]
     public void CanCallFunctionWithArgumentNumberNegativeZero()
     {
-        var minus0 = new LocalValue.Number(double.NegativeZero);
+        var arg = new LocalValue.Number(double.NegativeZero);
 
         Assert.That(async () =>
         {
@@ -192,14 +192,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg.toLocaleString());
               }
             }
-            """, false, new() { Arguments = [minus0] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumberPositiveInfinity()
     {
-        var infinity = new LocalValue.Number(double.PositiveInfinity);
+        var arg = new LocalValue.Number(double.PositiveInfinity);
 
         Assert.That(async () =>
         {
@@ -209,14 +209,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [infinity] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumberNegativeInfinity()
     {
-        var minusInfinity = new LocalValue.Number(double.NegativeInfinity);
+        var arg = new LocalValue.Number(double.NegativeInfinity);
 
         Assert.That(async () =>
         {
@@ -226,14 +226,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [minusInfinity] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumberNaN()
     {
-        var nan = new LocalValue.Number(double.NaN);
+        var arg = new LocalValue.Number(double.NaN);
         Assert.That(async () =>
         {
             await context.Script.CallFunctionAsync($$"""
@@ -242,14 +242,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [nan] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentRegExp()
     {
-        var regex = new LocalValue.RegExp(new LocalValue.RegExp.RegExpValue("foo*") { Flags = "g" });
+        var arg = new LocalValue.RegExp(new LocalValue.RegExp.RegExpValue("foo*") { Flags = "g" });
 
         Assert.That(async () =>
         {
@@ -259,14 +259,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [regex] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentArray()
     {
-        var hiString = new LocalValue.Array([new LocalValue.String("hi")]);
+        var arg = new LocalValue.Array([new LocalValue.String("hi")]);
 
         Assert.That(async () =>
         {
@@ -276,14 +276,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [hiString] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentObject()
     {
-        var obj = new LocalValue.Object([[new LocalValue.String("objKey"), new LocalValue.String("objValue")]]);
+        var arg = new LocalValue.Object([[new LocalValue.String("objKey"), new LocalValue.String("objValue")]]);
 
         Assert.That(async () =>
         {
@@ -293,7 +293,7 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [obj] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 
@@ -317,7 +317,7 @@ await context.Script.CallFunctionAsync($$"""
     [Test]
     public void CanCallFunctionWithArgumentSet()
     {
-        var argument = new LocalValue.Set([new LocalValue.String("setKey")]);
+        var arg = new LocalValue.Set([new LocalValue.String("setKey")]);
 
         Assert.That(async () =>
         {
@@ -327,7 +327,7 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [argument] });
+            """, false, new() { Arguments = [arg] });
         }, Throws.Nothing);
     }
 }
diff --git a/dotnet/test/common/BiDi/Script/CallFunctionRemoteValueTest.cs b/dotnet/test/common/BiDi/Script/CallFunctionRemoteValueTest.cs
@@ -182,13 +182,13 @@ public async Task CanCallFunctionAndReturnArray()
     [Test]
     public async Task CanCallFunctionAndReturnObject()
     {
-        var response = await context.Script.CallFunctionAsync("() => { return { key: 'value' }; }", false);
+        var response = await context.Script.CallFunctionAsync("() => { return { objKey: 'objValue' }; }", false);
 
         Assert.That(response.Result, Is.AssignableTo<RemoteValue.Object>());
 
         var expected = new RemoteValue.Object
         {
-            Value = [[new RemoteValue.String("key"), new RemoteValue.String("value")]]
+            Value = [[new RemoteValue.String("objKey"), new RemoteValue.String("objValue")]]
         };
         Assert.That(((RemoteValue.Object)response.Result).Value, Is.EqualTo(expected.Value));
     }
@@ -198,13 +198,13 @@ public async Task CanCallFunctionAndReturnMap()
     {
         var expected = new RemoteValue.Map
         {
-            Value = [[new RemoteValue.String("key"), new RemoteValue.String("value")]]
+            Value = [[new RemoteValue.String("mapKey"), new RemoteValue.String("mapValue")]]
         };
 
         var response = await context.Script.CallFunctionAsync($$"""
             () => {
               const map = new Map();
-              map.set('key', 'value');
+              map.set('mapKey', 'mapValue');
               return map;
             }
             """, false);
@@ -216,11 +216,11 @@ public async Task CanCallFunctionAndReturnMap()
     [Test]
     public async Task CanCallFunctionAndReturnSet()
     {
-        var expected = new RemoteValue.Set { Value = [new RemoteValue.String("key")] };
+        var expected = new RemoteValue.Set { Value = [new RemoteValue.String("setKey")] };
         var response = await context.Script.CallFunctionAsync($$"""
             () => {
               const set = new Set();
-              set.add('key');
+              set.add('setKey');
               return set;
             }
             """, false);

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ class CallFunctionLocalValueTest : BiDiTestFixture`
`27`	`27`	`[Test]`
`28`	`28`	`public void CanCallFunctionWithArgumentUndefined()`
`29`	`29`	`{`
`30`		`- var undefined = new LocalValue.Undefined();`
	`30`	`+ var arg = new LocalValue.Undefined();`
`31`	`31`	`Assert.That(async () =>`
`32`	`32`	`{`
`33`	`33`	`await context.Script.CallFunctionAsync($$"""`
`@@ -36,14 +36,14 @@ await context.Script.CallFunctionAsync($$"""`
`36`	`36`	`throw new Error("Assert failed: " + arg);`
`37`	`37`	`}`
`38`	`38`	`}`
`39`		`- """, false, new() { Arguments = [undefined] });`
	`39`	`+ """, false, new() { Arguments = [arg] });`
`40`	`40`	`}, Throws.Nothing);`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`[Test]`
`44`	`44`	`public void CanCallFunctionWithArgumentNull()`
`45`	`45`	`{`
`46`		`- var @null = new LocalValue.Null();`
	`46`	`+ var arg = new LocalValue.Null();`
`47`	`47`	`Assert.That(async () =>`
`48`	`48`	`{`
`49`	`49`	`await context.Script.CallFunctionAsync($$"""`
`@@ -52,14 +52,14 @@ await context.Script.CallFunctionAsync($$"""`
`52`	`52`	`throw new Error("Assert failed: " + arg);`
`53`	`53`	`}`
`54`	`54`	`}`
`55`		`- """, false, new() { Arguments = [@null] });`
	`55`	`+ """, false, new() { Arguments = [arg] });`
`56`	`56`	`}, Throws.Nothing);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`[Test]`
`60`	`60`	`public void CanCallFunctionWithArgumentEmptyString()`
`61`	`61`	`{`
`62`		`- var empty = new LocalValue.String(string.Empty);`
	`62`	`+ var arg = new LocalValue.String(string.Empty);`
`63`	`63`	`Assert.That(async () =>`
`64`	`64`	`{`
`65`	`65`	`await context.Script.CallFunctionAsync($$"""`
`@@ -68,14 +68,14 @@ await context.Script.CallFunctionAsync($$"""`
`68`	`68`	`throw new Error("Assert failed: " + arg);`
`69`	`69`	`}`
`70`	`70`	`}`
`71`		`- """, false, new() { Arguments = [empty] });`
	`71`	`+ """, false, new() { Arguments = [arg] });`
`72`	`72`	`}, Throws.Nothing);`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`[Test]`
`76`	`76`	`public void CanCallFunctionWithArgumentNonEmptyString()`
`77`	`77`	`{`
`78`		`- var whoaString = new LocalValue.String("whoa");`
	`78`	`+ var arg = new LocalValue.String("whoa");`
`79`	`79`	`Assert.That(async () =>`
`80`	`80`	`{`
`81`	`81`	`await context.Script.CallFunctionAsync($$"""`
`@@ -84,7 +84,7 @@ await context.Script.CallFunctionAsync($$"""`
`84`	`84`	`throw new Error("Assert failed: " + arg);`
`85`	`85`	`}`
`86`	`86`	`}`
`87`		`- """, false, new() { Arguments = [whoaString] });`
	`87`	`+ """, false, new() { Arguments = [arg] });`
`88`	`88`	`}, Throws.Nothing);`
`89`	`89`	`}`
`90`	`90`
`@@ -93,7 +93,7 @@ public void CanCallFunctionWithArgumentRecentDate()`
`93`	`93`	`{`
`94`	`94`	`const string PinnedDateTimeString = "2025-03-09T00:30:33.083Z";`
`95`	`95`
`96`		`- var date = new LocalValue.Date(PinnedDateTimeString);`
	`96`	`+ var arg = new LocalValue.Date(PinnedDateTimeString);`
`97`	`97`
`98`	`98`	`Assert.That(async () =>`
`99`	`99`	`{`
`@@ -103,7 +103,7 @@ await context.Script.CallFunctionAsync($$"""`
`103`	`103`	`throw new Error("Assert failed: " + arg);`
`104`	`104`	`}`
`105`	`105`	`}`
`106`		`- """, false, new() { Arguments = [date] });`
	`106`	`+ """, false, new() { Arguments = [arg] });`
`107`	`107`	`}, Throws.Nothing);`
`108`	`108`	`}`
`109`	`109`
`@@ -112,7 +112,7 @@ public void CanCallFunctionWithArgumentEpochDate()`
`112`	`112`	`{`
`113`	`113`	`const string EpochString = "1970-01-01T00:00:00.000Z";`
`114`	`114`
`115`		`- var epochDate = new LocalValue.Date(EpochString);`
	`115`	`+ var arg = new LocalValue.Date(EpochString);`
`116`	`116`
`117`	`117`	`Assert.That(async () =>`
`118`	`118`	`{`
`@@ -122,14 +122,14 @@ await context.Script.CallFunctionAsync($$"""`
`122`	`122`	`throw new Error("Assert failed: " + arg.toISOString());`
`123`	`123`	`}`
`124`	`124`	`}`
`125`		`- """, false, new() { Arguments = [epochDate] });`
	`125`	`+ """, false, new() { Arguments = [arg] });`
`126`	`126`	`}, Throws.Nothing);`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`[Test]`
`130`	`130`	`public void CanCallFunctionWithArgumentNumberFive()`
`131`	`131`	`{`
`132`		`- var number5 = new LocalValue.Number(5);`
	`132`	`+ var arg = new LocalValue.Number(5);`
`133`	`133`
`134`	`134`	`Assert.That(async () =>`
`135`	`135`	`{`
`@@ -139,14 +139,14 @@ await context.Script.CallFunctionAsync($$"""`
`139`	`139`	`throw new Error("Assert failed: " + arg);`
`140`	`140`	`}`
`141`	`141`	`}`
`142`		`- """, false, new() { Arguments = [number5] });`
	`142`	`+ """, false, new() { Arguments = [arg] });`
`143`	`143`	`}, Throws.Nothing);`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`[Test]`
`147`	`147`	`public void CanCallFunctionWithArgumentNumberNegativeFive()`
`148`	`148`	`{`
`149`		`- var numberMinus5 = new LocalValue.Number(-5);`
	`149`	`+ var arg = new LocalValue.Number(-5);`
`150`	`150`
`151`	`151`	`Assert.That(async () =>`
`152`	`152`	`{`
`@@ -156,14 +156,14 @@ await context.Script.CallFunctionAsync($$"""`
`156`	`156`	`throw new Error("Assert failed: " + arg);`
`157`	`157`	`}`
`158`	`158`	`}`
`159`		`- """, false, new() { Arguments = [numberMinus5] });`
	`159`	`+ """, false, new() { Arguments = [arg] });`
`160`	`160`	`}, Throws.Nothing);`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`[Test]`
`164`	`164`	`public void CanCallFunctionWithArgumentNumberZero()`
`165`	`165`	`{`
`166`		`- var number0 = new LocalValue.Number(0);`
	`166`	`+ var arg = new LocalValue.Number(0);`
`167`	`167`
`168`	`168`	`Assert.That(async () =>`
`169`	`169`	`{`
`@@ -173,7 +173,7 @@ await context.Script.CallFunctionAsync($$"""`
`173`	`173`	`throw new Error("Assert failed: " + arg);`
`174`	`174`	`}`
`175`	`175`	`}`
`176`		`- """, false, new() { Arguments = [number0] });`
	`176`	`+ """, false, new() { Arguments = [arg] });`
`177`	`177`	`}, Throws.Nothing);`
`178`	`178`	`}`
`179`	`179`
`@@ -182,7 +182,7 @@ await context.Script.CallFunctionAsync($$"""`
`182`	`182`	`[IgnoreBrowser(Selenium.Browser.Chrome, "Chromium can't handle -0 argument as a number: https://github.com/w3c/webdriver-bidi/issues/887")]`
`183`	`183`	`public void CanCallFunctionWithArgumentNumberNegativeZero()`
`184`	`184`	`{`
`185`		`- var minus0 = new LocalValue.Number(double.NegativeZero);`
	`185`	`+ var arg = new LocalValue.Number(double.NegativeZero);`
`186`	`186`
`187`	`187`	`Assert.That(async () =>`
`188`	`188`	`{`
`@@ -192,14 +192,14 @@ await context.Script.CallFunctionAsync($$"""`
`192`	`192`	`throw new Error("Assert failed: " + arg.toLocaleString());`
`193`	`193`	`}`
`194`	`194`	`}`
`195`		`- """, false, new() { Arguments = [minus0] });`
	`195`	`+ """, false, new() { Arguments = [arg] });`
`196`	`196`	`}, Throws.Nothing);`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`[Test]`
`200`	`200`	`public void CanCallFunctionWithArgumentNumberPositiveInfinity()`
`201`	`201`	`{`
`202`		`- var infinity = new LocalValue.Number(double.PositiveInfinity);`
	`202`	`+ var arg = new LocalValue.Number(double.PositiveInfinity);`
`203`	`203`
`204`	`204`	`Assert.That(async () =>`
`205`	`205`	`{`
`@@ -209,14 +209,14 @@ await context.Script.CallFunctionAsync($$"""`
`209`	`209`	`throw new Error("Assert failed: " + arg);`
`210`	`210`	`}`
`211`	`211`	`}`
`212`		`- """, false, new() { Arguments = [infinity] });`
	`212`	`+ """, false, new() { Arguments = [arg] });`
`213`	`213`	`}, Throws.Nothing);`
`214`	`214`	`}`
`215`	`215`
`216`	`216`	`[Test]`
`217`	`217`	`public void CanCallFunctionWithArgumentNumberNegativeInfinity()`
`218`	`218`	`{`
`219`		`- var minusInfinity = new LocalValue.Number(double.NegativeInfinity);`
	`219`	`+ var arg = new LocalValue.Number(double.NegativeInfinity);`
`220`	`220`
`221`	`221`	`Assert.That(async () =>`
`222`	`222`	`{`
`@@ -226,14 +226,14 @@ await context.Script.CallFunctionAsync($$"""`
`226`	`226`	`throw new Error("Assert failed: " + arg);`
`227`	`227`	`}`
`228`	`228`	`}`
`229`		`- """, false, new() { Arguments = [minusInfinity] });`
	`229`	`+ """, false, new() { Arguments = [arg] });`
`230`	`230`	`}, Throws.Nothing);`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`[Test]`
`234`	`234`	`public void CanCallFunctionWithArgumentNumberNaN()`
`235`	`235`	`{`
`236`		`- var nan = new LocalValue.Number(double.NaN);`
	`236`	`+ var arg = new LocalValue.Number(double.NaN);`
`237`	`237`	`Assert.That(async () =>`
`238`	`238`	`{`
`239`	`239`	`await context.Script.CallFunctionAsync($$"""`
`@@ -242,14 +242,14 @@ await context.Script.CallFunctionAsync($$"""`
`242`	`242`	`throw new Error("Assert failed: " + arg);`
`243`	`243`	`}`
`244`	`244`	`}`
`245`		`- """, false, new() { Arguments = [nan] });`
	`245`	`+ """, false, new() { Arguments = [arg] });`
`246`	`246`	`}, Throws.Nothing);`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`[Test]`
`250`	`250`	`public void CanCallFunctionWithArgumentRegExp()`
`251`	`251`	`{`
`252`		`- var regex = new LocalValue.RegExp(new LocalValue.RegExp.RegExpValue("foo*") { Flags = "g" });`
	`252`	`+ var arg = new LocalValue.RegExp(new LocalValue.RegExp.RegExpValue("foo*") { Flags = "g" });`
`253`	`253`
`254`	`254`	`Assert.That(async () =>`
`255`	`255`	`{`
`@@ -259,14 +259,14 @@ await context.Script.CallFunctionAsync($$"""`
`259`	`259`	`throw new Error("Assert failed: " + arg);`
`260`	`260`	`}`
`261`	`261`	`}`
`262`		`- """, false, new() { Arguments = [regex] });`
	`262`	`+ """, false, new() { Arguments = [arg] });`
`263`	`263`	`}, Throws.Nothing);`
`264`	`264`	`}`
`265`	`265`
`266`	`266`	`[Test]`
`267`	`267`	`public void CanCallFunctionWithArgumentArray()`
`268`	`268`	`{`
`269`		`- var hiString = new LocalValue.Array([new LocalValue.String("hi")]);`
	`269`	`+ var arg = new LocalValue.Array([new LocalValue.String("hi")]);`
`270`	`270`
`271`	`271`	`Assert.That(async () =>`
`272`	`272`	`{`
`@@ -276,14 +276,14 @@ await context.Script.CallFunctionAsync($$"""`
`276`	`276`	`throw new Error("Assert failed: " + arg);`
`277`	`277`	`}`
`278`	`278`	`}`
`279`		`- """, false, new() { Arguments = [hiString] });`
	`279`	`+ """, false, new() { Arguments = [arg] });`
`280`	`280`	`}, Throws.Nothing);`
`281`	`281`	`}`
`282`	`282`
`283`	`283`	`[Test]`
`284`	`284`	`public void CanCallFunctionWithArgumentObject()`
`285`	`285`	`{`
`286`		`- var obj = new LocalValue.Object([[new LocalValue.String("objKey"), new LocalValue.String("objValue")]]);`
	`286`	`+ var arg = new LocalValue.Object([[new LocalValue.String("objKey"), new LocalValue.String("objValue")]]);`
`287`	`287`
`288`	`288`	`Assert.That(async () =>`
`289`	`289`	`{`
`@@ -293,7 +293,7 @@ await context.Script.CallFunctionAsync($$"""`
`293`	`293`	`throw new Error("Assert failed: " + arg);`
`294`	`294`	`}`
`295`	`295`	`}`
`296`		`- """, false, new() { Arguments = [obj] });`
	`296`	`+ """, false, new() { Arguments = [arg] });`
`297`	`297`	`}, Throws.Nothing);`
`298`	`298`	`}`
`299`	`299`
`@@ -317,7 +317,7 @@ await context.Script.CallFunctionAsync($$"""`
`317`	`317`	`[Test]`
`318`	`318`	`public void CanCallFunctionWithArgumentSet()`
`319`	`319`	`{`
`320`		`- var argument = new LocalValue.Set([new LocalValue.String("setKey")]);`
	`320`	`+ var arg = new LocalValue.Set([new LocalValue.String("setKey")]);`
`321`	`321`
`322`	`322`	`Assert.That(async () =>`
`323`	`323`	`{`
`@@ -327,7 +327,7 @@ await context.Script.CallFunctionAsync($$"""`
`327`	`327`	`throw new Error("Assert failed: " + arg);`
`328`	`328`	`}`
`329`	`329`	`}`
`330`		`- """, false, new() { Arguments = [argument] });`
	`330`	`+ """, false, new() { Arguments = [arg] });`
`331`	`331`	`}, Throws.Nothing);`
`332`	`332`	`}`
`333`	`333`	`}`
Original file line number	Diff line number	Diff line change
`@@ -182,13 +182,13 @@ public async Task CanCallFunctionAndReturnArray()`
`182`	`182`	`[Test]`
`183`	`183`	`public async Task CanCallFunctionAndReturnObject()`
`184`	`184`	`{`
`185`		`- var response = await context.Script.CallFunctionAsync("() => { return { key: 'value' }; }", false);`
	`185`	`+ var response = await context.Script.CallFunctionAsync("() => { return { objKey: 'objValue' }; }", false);`
`186`	`186`
`187`	`187`	`Assert.That(response.Result, Is.AssignableTo<RemoteValue.Object>());`
`188`	`188`
`189`	`189`	`var expected = new RemoteValue.Object`
`190`	`190`	`{`
`191`		`- Value = [[new RemoteValue.String("key"), new RemoteValue.String("value")]]`
	`191`	`+ Value = [[new RemoteValue.String("objKey"), new RemoteValue.String("objValue")]]`
`192`	`192`	`};`
`193`	`193`	`Assert.That(((RemoteValue.Object)response.Result).Value, Is.EqualTo(expected.Value));`
`194`	`194`	`}`
`@@ -198,13 +198,13 @@ public async Task CanCallFunctionAndReturnMap()`
`198`	`198`	`{`
`199`	`199`	`var expected = new RemoteValue.Map`
`200`	`200`	`{`
`201`		`- Value = [[new RemoteValue.String("key"), new RemoteValue.String("value")]]`
	`201`	`+ Value = [[new RemoteValue.String("mapKey"), new RemoteValue.String("mapValue")]]`
`202`	`202`	`};`
`203`	`203`
`204`	`204`	`var response = await context.Script.CallFunctionAsync($$"""`
`205`	`205`	`() => {`
`206`	`206`	`const map = new Map();`
`207`		`- map.set('key', 'value');`
	`207`	`+ map.set('mapKey', 'mapValue');`
`208`	`208`	`return map;`
`209`	`209`	`}`
`210`	`210`	`""", false);`
`@@ -216,11 +216,11 @@ public async Task CanCallFunctionAndReturnMap()`
`216`	`216`	`[Test]`
`217`	`217`	`public async Task CanCallFunctionAndReturnSet()`
`218`	`218`	`{`
`219`		`- var expected = new RemoteValue.Set { Value = [new RemoteValue.String("key")] };`
	`219`	`+ var expected = new RemoteValue.Set { Value = [new RemoteValue.String("setKey")] };`
`220`	`220`	`var response = await context.Script.CallFunctionAsync($$"""`
`221`	`221`	`() => {`
`222`	`222`	`const set = new Set();`
`223`		`- set.add('key');`
	`223`	`+ set.add('setKey');`
`224`	`224`	`return set;`
`225`	`225`	`}`
`226`	`226`	`""", false);`