[dotnet] [bidi] Align Scipt.LocalValue.Map with spec, enable negative zero

dotnet/src/webdriver/BiDi/Communication/Broker.cs

@@ -64,6 +64,7 @@ internal Broker(BiDi bidi, ITransport transport)
             PropertyNameCaseInsensitive = true,
             PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
             DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+            NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals | JsonNumberHandling.AllowReadingFromString,
             Converters =
             {
                 new BrowsingContextConverter(_bidi),

dotnet/src/webdriver/BiDi/Modules/Script/LocalValue.cs

@@ -103,7 +103,7 @@ public record Array(IEnumerable<LocalValue> Value) : LocalValue;
 
     public record Date(string Value) : LocalValue;
 
-    public record Map(IDictionary<string, LocalValue> Value) : LocalValue; // seems to implement IDictionary
+    public record Map(IEnumerable<IEnumerable<LocalValue>> Value) : LocalValue;
 
     public record Object(IEnumerable<IEnumerable<LocalValue>> Value) : LocalValue;
 

dotnet/src/webdriver/BiDi/Modules/Script/RemoteValue.cs

@@ -158,7 +158,7 @@ public record Map : RemoteValue
 
         public InternalId? InternalId { get; set; }
 
-        public IDictionary<string, RemoteValue>? Value { get; set; }
+        public IReadOnlyList<IReadOnlyList<RemoteValue>>? Value { get; set; }
     }
 
     public record Set : RemoteValue

dotnet/test/common/BiDi/Script/CallFunctionLocalValueTest.cs

@@ -0,0 +1,331 @@
+// <copyright file="CallFunctionLocalValueTest.cs" company="Selenium Committers">
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+// </copyright>
+
+using NUnit.Framework;
+using OpenQA.Selenium.BiDi.Modules.Script;
+
+namespace OpenQA.Selenium.BiDi.Script;
+
+class CallFunctionLocalValueTest : BiDiTestFixture
+{
+    [Test]
+    public void CanCallFunctionWithArgumentUndefined()
+    {
+        var arg = new LocalValue.Undefined();
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (typeof arg !== 'undefined') {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentNull()
+    {
+        var arg = new LocalValue.Null();
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg !== null) {
+              throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentEmptyString()
+    {
+        var arg = new LocalValue.String(string.Empty);
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg !== '') {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentNonEmptyString()
+    {
+        var arg = new LocalValue.String("whoa");
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg !== 'whoa') {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentRecentDate()
+    {
+        const string PinnedDateTimeString = "2025-03-09T00:30:33.083Z";
+
+        var arg = new LocalValue.Date(PinnedDateTimeString);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg.toISOString() !== '{{PinnedDateTimeString}}') {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentEpochDate()
+    {
+        const string EpochString = "1970-01-01T00:00:00.000Z";
+
+        var arg = new LocalValue.Date(EpochString);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg.toISOString() !== '{{EpochString}}') {
+                throw new Error("Assert failed: " + arg.toISOString());
+              } 
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentNumber5()
+    {
+        var arg = new LocalValue.Number(5);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg !== 5) {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentNumberNegative5()
+    {
+        var arg = new LocalValue.Number(-5);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg !== -5) {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentNumber0()
+    {
+        var arg = new LocalValue.Number(0);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg !== 0) {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentNumberNegative0()
+    {
+        var arg = new LocalValue.Number(double.NegativeZero);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg !== -0) {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentNumberPositiveInfinity()
+    {
+        var arg = new LocalValue.Number(double.PositiveInfinity);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg !== Number.POSITIVE_INFINITY) {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentNumberNegativeInfinity()
+    {
+        var arg = new LocalValue.Number(double.NegativeInfinity);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg !== Number.NEGATIVE_INFINITY) {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentNumberNaN()
+    {
+        var arg = new LocalValue.Number(double.NaN);
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (!isNaN(arg)) {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentRegExp()
+    {
+        var arg = new LocalValue.RegExp(new LocalValue.RegExp.RegExpValue("foo*") { Flags = "g" });
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (!arg.test('foo') || arg.source !== 'foo*' || !arg.global) {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentArray()
+    {
+        var arg = new LocalValue.Array([new LocalValue.String("hi")]);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg.length !== 1 || arg[0] !== 'hi') {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentObject()
+    {
+        var arg = new LocalValue.Object([[new LocalValue.String("key"), new LocalValue.String("value")]]);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg.key !== 'value' || Object.keys(arg).length !== 1) {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentMap()
+    {
+        var arg = new LocalValue.Map([[new LocalValue.String("key"), new LocalValue.String("value")]]);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (arg.get('key') !== 'value' || arg.size !== 1) {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [arg] });
+        }, Throws.Nothing);
+    }
+
+    [Test]
+    public void CanCallFunctionWithArgumentSet()
+    {
+        var argument = new LocalValue.Set([new LocalValue.String("key")]);
+
+        Assert.That(async () =>
+        {
+            await context.Script.CallFunctionAsync($$"""
+            (arg) => {
+              if (!arg.has('key') || arg.size !== 1) {
+                throw new Error("Assert failed: " + arg);
+              }
+            }
+            """, false, new() { Arguments = [argument] });
+        }, Throws.Nothing);
+    }
+}