Fix variable name

RenderMichael · RenderMichael · commit d7c58f7c513e · 2025-03-10T15:02:45.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 arg = new LocalValue.Undefined();
+        var undefined = 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 = [arg] });
+            """, false, new() { Arguments = [undefined] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNull()
     {
-        var arg = new LocalValue.Null();
+        var @null = 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 = [arg] });
+            """, false, new() { Arguments = [@null] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentEmptyString()
     {
-        var arg = new LocalValue.String(string.Empty);
+        var empty = 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 = [arg] });
+            """, false, new() { Arguments = [empty] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNonEmptyString()
     {
-        var arg = new LocalValue.String("whoa");
+        var whoaString = 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 = [arg] });
+            """, false, new() { Arguments = [whoaString] });
         }, Throws.Nothing);
     }
 
@@ -93,7 +93,7 @@ public void CanCallFunctionWithArgumentRecentDate()
     {
         const string PinnedDateTimeString = "2025-03-09T00:30:33.083Z";
 
-        var arg = new LocalValue.Date(PinnedDateTimeString);
+        var date = new LocalValue.Date(PinnedDateTimeString);
 
         Assert.That(async () =>
         {
@@ -103,7 +103,7 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [arg] });
+            """, false, new() { Arguments = [date] });
         }, Throws.Nothing);
     }
 
@@ -112,7 +112,7 @@ public void CanCallFunctionWithArgumentEpochDate()
     {
         const string EpochString = "1970-01-01T00:00:00.000Z";
 
-        var arg = new LocalValue.Date(EpochString);
+        var epochDate = 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 = [arg] });
+            """, false, new() { Arguments = [epochDate] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumber5()
     {
-        var arg = new LocalValue.Number(5);
+        var number5 = new LocalValue.Number(5);
 
         Assert.That(async () =>
         {
@@ -139,14 +139,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [arg] });
+            """, false, new() { Arguments = [number5] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumberNegative5()
     {
-        var arg = new LocalValue.Number(-5);
+        var numberMinus5 = new LocalValue.Number(-5);
 
         Assert.That(async () =>
         {
@@ -156,14 +156,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [arg] });
+            """, false, new() { Arguments = [numberMinus5] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumber0()
     {
-        var arg = new LocalValue.Number(0);
+        var number0 = new LocalValue.Number(0);
 
         Assert.That(async () =>
         {
@@ -173,14 +173,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [arg] });
+            """, false, new() { Arguments = [number0] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumberNegative0()
     {
-        var arg = new LocalValue.Number(double.NegativeZero);
+        var minus0 = new LocalValue.Number(double.NegativeZero);
 
         Assert.That(async () =>
         {
@@ -190,14 +190,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg.toLocaleString());
               }
             }
-            """, false, new() { Arguments = [arg] });
+            """, false, new() { Arguments = [minus0] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumberPositiveInfinity()
     {
-        var arg = new LocalValue.Number(double.PositiveInfinity);
+        var infinity = new LocalValue.Number(double.PositiveInfinity);
 
         Assert.That(async () =>
         {
@@ -207,14 +207,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [arg] });
+            """, false, new() { Arguments = [infinity] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumberNegativeInfinity()
     {
-        var arg = new LocalValue.Number(double.NegativeInfinity);
+        var minusInfinity = new LocalValue.Number(double.NegativeInfinity);
 
         Assert.That(async () =>
         {
@@ -224,14 +224,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [arg] });
+            """, false, new() { Arguments = [minusInfinity] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentNumberNaN()
     {
-        var arg = new LocalValue.Number(double.NaN);
+        var nan = new LocalValue.Number(double.NaN);
         Assert.That(async () =>
         {
             await context.Script.CallFunctionAsync($$"""
@@ -240,14 +240,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [arg] });
+            """, false, new() { Arguments = [nan] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentRegExp()
     {
-        var arg = new LocalValue.RegExp(new LocalValue.RegExp.RegExpValue("foo*") { Flags = "g" });
+        var regex = new LocalValue.RegExp(new LocalValue.RegExp.RegExpValue("foo*") { Flags = "g" });
 
         Assert.That(async () =>
         {
@@ -257,14 +257,14 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [arg] });
+            """, false, new() { Arguments = [regex] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentArray()
     {
-        var arg = new LocalValue.Array([new LocalValue.String("hi")]);
+        var hiString = new LocalValue.Array([new LocalValue.String("hi")]);
 
         Assert.That(async () =>
         {
@@ -274,37 +274,37 @@ await context.Script.CallFunctionAsync($$"""
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [arg] });
+            """, false, new() { Arguments = [hiString] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentObject()
     {
-        var arg = new LocalValue.Object([[new LocalValue.String("key"), new LocalValue.String("value")]]);
+        var obj = new LocalValue.Object([[new LocalValue.String("objKey"), new LocalValue.String("objValue")]]);
 
         Assert.That(async () =>
         {
             await context.Script.CallFunctionAsync($$"""
             (arg) => {
-              if (arg.key !== 'value' || Object.keys(arg).length !== 1) {
+              if (arg.objKey !== 'objValue' || Object.keys(arg).length !== 1) {
                 throw new Error("Assert failed: " + arg);
               }
             }
-            """, false, new() { Arguments = [arg] });
+            """, false, new() { Arguments = [obj] });
         }, Throws.Nothing);
     }
 
     [Test]
     public void CanCallFunctionWithArgumentMap()
     {
-        var arg = new LocalValue.Map([[new LocalValue.String("key"), new LocalValue.String("value")]]);
+        var arg = new LocalValue.Map([[new LocalValue.String("mapKey"), new LocalValue.String("mapValue")]]);
 
         Assert.That(async () =>
         {
             await context.Script.CallFunctionAsync($$"""
             (arg) => {
-              if (arg.get('key') !== 'value' || arg.size !== 1) {
+              if (arg.get('mapKey') !== 'mapValue' || arg.size !== 1) {
                 throw new Error("Assert failed: " + arg);
               }
             }
@@ -315,13 +315,13 @@ await context.Script.CallFunctionAsync($$"""
     [Test]
     public void CanCallFunctionWithArgumentSet()
     {
-        var argument = new LocalValue.Set([new LocalValue.String("key")]);
+        var argument = new LocalValue.Set([new LocalValue.String("setKey")]);
 
         Assert.That(async () =>
         {
             await context.Script.CallFunctionAsync($$"""
             (arg) => {
-              if (!arg.has('key') || arg.size !== 1) {
+              if (!arg.has('setKey') || arg.size !== 1) {
                 throw new Error("Assert failed: " + arg);
               }
             }

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 arg = new LocalValue.Undefined();`
	`30`	`+ var undefined = 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 = [arg] });`
	`39`	`+ """, false, new() { Arguments = [undefined] });`
`40`	`40`	`}, Throws.Nothing);`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`[Test]`
`44`	`44`	`public void CanCallFunctionWithArgumentNull()`
`45`	`45`	`{`
`46`		`- var arg = new LocalValue.Null();`
	`46`	`+ var @null = 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 = [arg] });`
	`55`	`+ """, false, new() { Arguments = [@null] });`
`56`	`56`	`}, Throws.Nothing);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`[Test]`
`60`	`60`	`public void CanCallFunctionWithArgumentEmptyString()`
`61`	`61`	`{`
`62`		`- var arg = new LocalValue.String(string.Empty);`
	`62`	`+ var empty = 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 = [arg] });`
	`71`	`+ """, false, new() { Arguments = [empty] });`
`72`	`72`	`}, Throws.Nothing);`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`[Test]`
`76`	`76`	`public void CanCallFunctionWithArgumentNonEmptyString()`
`77`	`77`	`{`
`78`		`- var arg = new LocalValue.String("whoa");`
	`78`	`+ var whoaString = 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 = [arg] });`
	`87`	`+ """, false, new() { Arguments = [whoaString] });`
`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 arg = new LocalValue.Date(PinnedDateTimeString);`
	`96`	`+ var date = 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 = [arg] });`
	`106`	`+ """, false, new() { Arguments = [date] });`
`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 arg = new LocalValue.Date(EpochString);`
	`115`	`+ var epochDate = 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 = [arg] });`
	`125`	`+ """, false, new() { Arguments = [epochDate] });`
`126`	`126`	`}, Throws.Nothing);`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`[Test]`
`130`	`130`	`public void CanCallFunctionWithArgumentNumber5()`
`131`	`131`	`{`
`132`		`- var arg = new LocalValue.Number(5);`
	`132`	`+ var number5 = 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 = [arg] });`
	`142`	`+ """, false, new() { Arguments = [number5] });`
`143`	`143`	`}, Throws.Nothing);`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`[Test]`
`147`	`147`	`public void CanCallFunctionWithArgumentNumberNegative5()`
`148`	`148`	`{`
`149`		`- var arg = new LocalValue.Number(-5);`
	`149`	`+ var numberMinus5 = 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 = [arg] });`
	`159`	`+ """, false, new() { Arguments = [numberMinus5] });`
`160`	`160`	`}, Throws.Nothing);`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`[Test]`
`164`	`164`	`public void CanCallFunctionWithArgumentNumber0()`
`165`	`165`	`{`
`166`		`- var arg = new LocalValue.Number(0);`
	`166`	`+ var number0 = new LocalValue.Number(0);`
`167`	`167`
`168`	`168`	`Assert.That(async () =>`
`169`	`169`	`{`
`@@ -173,14 +173,14 @@ await context.Script.CallFunctionAsync($$"""`
`173`	`173`	`throw new Error("Assert failed: " + arg);`
`174`	`174`	`}`
`175`	`175`	`}`
`176`		`- """, false, new() { Arguments = [arg] });`
	`176`	`+ """, false, new() { Arguments = [number0] });`
`177`	`177`	`}, Throws.Nothing);`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`[Test]`
`181`	`181`	`public void CanCallFunctionWithArgumentNumberNegative0()`
`182`	`182`	`{`
`183`		`- var arg = new LocalValue.Number(double.NegativeZero);`
	`183`	`+ var minus0 = new LocalValue.Number(double.NegativeZero);`
`184`	`184`
`185`	`185`	`Assert.That(async () =>`
`186`	`186`	`{`
`@@ -190,14 +190,14 @@ await context.Script.CallFunctionAsync($$"""`
`190`	`190`	`throw new Error("Assert failed: " + arg.toLocaleString());`
`191`	`191`	`}`
`192`	`192`	`}`
`193`		`- """, false, new() { Arguments = [arg] });`
	`193`	`+ """, false, new() { Arguments = [minus0] });`
`194`	`194`	`}, Throws.Nothing);`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`[Test]`
`198`	`198`	`public void CanCallFunctionWithArgumentNumberPositiveInfinity()`
`199`	`199`	`{`
`200`		`- var arg = new LocalValue.Number(double.PositiveInfinity);`
	`200`	`+ var infinity = new LocalValue.Number(double.PositiveInfinity);`
`201`	`201`
`202`	`202`	`Assert.That(async () =>`
`203`	`203`	`{`
`@@ -207,14 +207,14 @@ await context.Script.CallFunctionAsync($$"""`
`207`	`207`	`throw new Error("Assert failed: " + arg);`
`208`	`208`	`}`
`209`	`209`	`}`
`210`		`- """, false, new() { Arguments = [arg] });`
	`210`	`+ """, false, new() { Arguments = [infinity] });`
`211`	`211`	`}, Throws.Nothing);`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`[Test]`
`215`	`215`	`public void CanCallFunctionWithArgumentNumberNegativeInfinity()`
`216`	`216`	`{`
`217`		`- var arg = new LocalValue.Number(double.NegativeInfinity);`
	`217`	`+ var minusInfinity = new LocalValue.Number(double.NegativeInfinity);`
`218`	`218`
`219`	`219`	`Assert.That(async () =>`
`220`	`220`	`{`
`@@ -224,14 +224,14 @@ await context.Script.CallFunctionAsync($$"""`
`224`	`224`	`throw new Error("Assert failed: " + arg);`
`225`	`225`	`}`
`226`	`226`	`}`
`227`		`- """, false, new() { Arguments = [arg] });`
	`227`	`+ """, false, new() { Arguments = [minusInfinity] });`
`228`	`228`	`}, Throws.Nothing);`
`229`	`229`	`}`
`230`	`230`
`231`	`231`	`[Test]`
`232`	`232`	`public void CanCallFunctionWithArgumentNumberNaN()`
`233`	`233`	`{`
`234`		`- var arg = new LocalValue.Number(double.NaN);`
	`234`	`+ var nan = new LocalValue.Number(double.NaN);`
`235`	`235`	`Assert.That(async () =>`
`236`	`236`	`{`
`237`	`237`	`await context.Script.CallFunctionAsync($$"""`
`@@ -240,14 +240,14 @@ await context.Script.CallFunctionAsync($$"""`
`240`	`240`	`throw new Error("Assert failed: " + arg);`
`241`	`241`	`}`
`242`	`242`	`}`
`243`		`- """, false, new() { Arguments = [arg] });`
	`243`	`+ """, false, new() { Arguments = [nan] });`
`244`	`244`	`}, Throws.Nothing);`
`245`	`245`	`}`
`246`	`246`
`247`	`247`	`[Test]`
`248`	`248`	`public void CanCallFunctionWithArgumentRegExp()`
`249`	`249`	`{`
`250`		`- var arg = new LocalValue.RegExp(new LocalValue.RegExp.RegExpValue("foo*") { Flags = "g" });`
	`250`	`+ var regex = new LocalValue.RegExp(new LocalValue.RegExp.RegExpValue("foo*") { Flags = "g" });`
`251`	`251`
`252`	`252`	`Assert.That(async () =>`
`253`	`253`	`{`
`@@ -257,14 +257,14 @@ await context.Script.CallFunctionAsync($$"""`
`257`	`257`	`throw new Error("Assert failed: " + arg);`
`258`	`258`	`}`
`259`	`259`	`}`
`260`		`- """, false, new() { Arguments = [arg] });`
	`260`	`+ """, false, new() { Arguments = [regex] });`
`261`	`261`	`}, Throws.Nothing);`
`262`	`262`	`}`
`263`	`263`
`264`	`264`	`[Test]`
`265`	`265`	`public void CanCallFunctionWithArgumentArray()`
`266`	`266`	`{`
`267`		`- var arg = new LocalValue.Array([new LocalValue.String("hi")]);`
	`267`	`+ var hiString = new LocalValue.Array([new LocalValue.String("hi")]);`
`268`	`268`
`269`	`269`	`Assert.That(async () =>`
`270`	`270`	`{`
`@@ -274,37 +274,37 @@ await context.Script.CallFunctionAsync($$"""`
`274`	`274`	`throw new Error("Assert failed: " + arg);`
`275`	`275`	`}`
`276`	`276`	`}`
`277`		`- """, false, new() { Arguments = [arg] });`
	`277`	`+ """, false, new() { Arguments = [hiString] });`
`278`	`278`	`}, Throws.Nothing);`
`279`	`279`	`}`
`280`	`280`
`281`	`281`	`[Test]`
`282`	`282`	`public void CanCallFunctionWithArgumentObject()`
`283`	`283`	`{`
`284`		`- var arg = new LocalValue.Object([[new LocalValue.String("key"), new LocalValue.String("value")]]);`
	`284`	`+ var obj = new LocalValue.Object([[new LocalValue.String("objKey"), new LocalValue.String("objValue")]]);`
`285`	`285`
`286`	`286`	`Assert.That(async () =>`
`287`	`287`	`{`
`288`	`288`	`await context.Script.CallFunctionAsync($$"""`
`289`	`289`	`(arg) => {`
`290`		`- if (arg.key !== 'value' \|\| Object.keys(arg).length !== 1) {`
	`290`	`+ if (arg.objKey !== 'objValue' \|\| Object.keys(arg).length !== 1) {`
`291`	`291`	`throw new Error("Assert failed: " + arg);`
`292`	`292`	`}`
`293`	`293`	`}`
`294`		`- """, false, new() { Arguments = [arg] });`
	`294`	`+ """, false, new() { Arguments = [obj] });`
`295`	`295`	`}, Throws.Nothing);`
`296`	`296`	`}`
`297`	`297`
`298`	`298`	`[Test]`
`299`	`299`	`public void CanCallFunctionWithArgumentMap()`
`300`	`300`	`{`
`301`		`- var arg = new LocalValue.Map([[new LocalValue.String("key"), new LocalValue.String("value")]]);`
	`301`	`+ var arg = new LocalValue.Map([[new LocalValue.String("mapKey"), new LocalValue.String("mapValue")]]);`
`302`	`302`
`303`	`303`	`Assert.That(async () =>`
`304`	`304`	`{`
`305`	`305`	`await context.Script.CallFunctionAsync($$"""`
`306`	`306`	`(arg) => {`
`307`		`- if (arg.get('key') !== 'value' \|\| arg.size !== 1) {`
	`307`	`+ if (arg.get('mapKey') !== 'mapValue' \|\| arg.size !== 1) {`
`308`	`308`	`throw new Error("Assert failed: " + arg);`
`309`	`309`	`}`
`310`	`310`	`}`
`@@ -315,13 +315,13 @@ await context.Script.CallFunctionAsync($$"""`
`315`	`315`	`[Test]`
`316`	`316`	`public void CanCallFunctionWithArgumentSet()`
`317`	`317`	`{`
`318`		`- var argument = new LocalValue.Set([new LocalValue.String("key")]);`
	`318`	`+ var argument = new LocalValue.Set([new LocalValue.String("setKey")]);`
`319`	`319`
`320`	`320`	`Assert.That(async () =>`
`321`	`321`	`{`
`322`	`322`	`await context.Script.CallFunctionAsync($$"""`
`323`	`323`	`(arg) => {`
`324`		`- if (!arg.has('key') \|\| arg.size !== 1) {`
	`324`	`+ if (!arg.has('setKey') \|\| arg.size !== 1) {`
`325`	`325`	`throw new Error("Assert failed: " + arg);`
`326`	`326`	`}`
`327`	`327`	`}`