Merge branch 'trunk' into alert_tests

Author: Delta456

dotnet/src/webdriver/BiDi/Modules/BrowsingContext/BrowsingContextScriptModule.cs

@@ -44,7 +44,7 @@ public async Task<IReadOnlyList<RealmInfo>> GetRealmsAsync(GetRealmsOptions? opt
         return await scriptModule.GetRealmsAsync(options).ConfigureAwait(false);
     }
 
-    public Task<EvaluateResultSuccess> EvaluateAsync(string expression, bool awaitPromise, EvaluateOptions? options = null, ContextTargetOptions? targetOptions = null)
+    public Task<EvaluateResult> EvaluateAsync(string expression, bool awaitPromise, EvaluateOptions? options = null, ContextTargetOptions? targetOptions = null)
     {
         var contextTarget = new ContextTarget(context);
 
@@ -60,10 +60,10 @@ public Task<EvaluateResultSuccess> EvaluateAsync(string expression, bool awaitPr
     {
         var result = await EvaluateAsync(expression, awaitPromise, options, targetOptions).ConfigureAwait(false);
 
-        return result.Result.ConvertTo<TResult>();
+        return result.AsSuccessResult().ConvertTo<TResult>();
     }
 
-    public Task<EvaluateResultSuccess> CallFunctionAsync(string functionDeclaration, bool awaitPromise, CallFunctionOptions? options = null, ContextTargetOptions? targetOptions = null)
+    public Task<EvaluateResult> CallFunctionAsync(string functionDeclaration, bool awaitPromise, CallFunctionOptions? options = null, ContextTargetOptions? targetOptions = null)
     {
         var contextTarget = new ContextTarget(context);
 
@@ -79,6 +79,6 @@ public Task<EvaluateResultSuccess> CallFunctionAsync(string functionDeclaration,
     {
         var result = await CallFunctionAsync(functionDeclaration, awaitPromise, options, targetOptions).ConfigureAwait(false);
 
-        return result.Result.ConvertTo<TResult>();
+        return result.AsSuccessResult().ConvertTo<TResult>();
     }
 }

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

@@ -18,6 +18,7 @@
 // </copyright>
 
 using OpenQA.Selenium.BiDi.Communication;
+using System;
 
 namespace OpenQA.Selenium.BiDi.Modules.Script;
 
@@ -39,7 +40,18 @@ public record EvaluateOptions : CommandOptions
 //[JsonPolymorphic(TypeDiscriminatorPropertyName = "type")]
 //[JsonDerivedType(typeof(EvaluateResultSuccess), "success")]
 //[JsonDerivedType(typeof(EvaluateResultException), "exception")]
-public abstract record EvaluateResult : EmptyResult;
+public abstract record EvaluateResult : EmptyResult
+{
+    public RemoteValue AsSuccessResult()
+    {
+        if (this is EvaluateResultSuccess success)
+        {
+            return success.Result;
+        }
+
+        throw new InvalidCastException($"Expected the result to be {nameof(EvaluateResultSuccess)}, but received {this}");
+    }
+}
 
 public record EvaluateResultSuccess(RemoteValue Result, Realm Realm) : EvaluateResult
 {

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

@@ -18,10 +18,12 @@
 // </copyright>
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
 using System.Text.Json.Serialization;
+using System.Text.RegularExpressions;
 
 namespace OpenQA.Selenium.BiDi.Modules.Script;
 
@@ -41,10 +43,11 @@ namespace OpenQA.Selenium.BiDi.Modules.Script;
 [JsonDerivedType(typeof(SetLocalValue), "set")]
 public abstract record LocalValue
 {
-    public static implicit operator LocalValue(bool? value) { return value is bool b ? new BooleanLocalValue(b) : new NullLocalValue(); }
-    public static implicit operator LocalValue(int? value) { return value is int i ? new NumberLocalValue(i) : new NullLocalValue(); }
-    public static implicit operator LocalValue(double? value) { return value is double d ? new NumberLocalValue(d) : new NullLocalValue(); }
-    public static implicit operator LocalValue(string? value) { return value is null ? new NullLocalValue() : new StringLocalValue(value); }
+    public static implicit operator LocalValue(bool? value) { return ConvertFrom(value); }
+    public static implicit operator LocalValue(int? value) { return ConvertFrom(value); }
+    public static implicit operator LocalValue(double? value) { return ConvertFrom(value); }
+    public static implicit operator LocalValue(string? value) { return ConvertFrom(value); }
+    public static implicit operator LocalValue(DateTimeOffset? value) { return ConvertFrom(value); }
 
     // TODO: Extend converting from types
     public static LocalValue ConvertFrom(object? value)
@@ -58,86 +61,222 @@ public static LocalValue ConvertFrom(object? value)
                 return new NullLocalValue();
 
             case bool b:
-                return new BooleanLocalValue(b);
+                return ConvertFrom(b);
 
             case int i:
-                return new NumberLocalValue(i);
+                return ConvertFrom(i);
 
             case double d:
-                return new NumberLocalValue(d);
+                return ConvertFrom(d);
 
             case long l:
-                return new NumberLocalValue(l);
+                return ConvertFrom(l);
 
-            case DateTime dt:
-                return new DateLocalValue(dt.ToString("o"));
+            case DateTimeOffset dt:
+                return ConvertFrom(dt);
 
             case BigInteger bigInt:
-                return new BigIntLocalValue(bigInt.ToString());
+                return ConvertFrom(bigInt);
 
             case string str:
-                return new StringLocalValue(str);
+                return ConvertFrom(str);
 
-            case IDictionary<string, string?> dictionary:
+            case Regex regex:
+                return ConvertFrom(regex);
+
+            case { } when value.GetType().GetInterfaces()
+                .Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(ISet<>)):
                 {
-                    var bidiObject = new List<List<LocalValue>>(dictionary.Count);
-                    foreach (var item in dictionary)
-                    {
-                        bidiObject.Add([new StringLocalValue(item.Key), ConvertFrom(item.Value)]);
-                    }
+                    IEnumerable set = (IEnumerable)value;
 
-                    return new ObjectLocalValue(bidiObject);
-                }
+                    List<LocalValue> setValues = [];
 
-            case IDictionary<string, object?> dictionary:
-                {
-                    var bidiObject = new List<List<LocalValue>>(dictionary.Count);
-                    foreach (var item in dictionary)
+                    foreach (var obj in set)
                     {
-                        bidiObject.Add([new StringLocalValue(item.Key), ConvertFrom(item.Value)]);
+                        setValues.Add(ConvertFrom(obj));
                     }
 
-                    return new ObjectLocalValue(bidiObject);
+                    return new SetLocalValue(setValues);
                 }
 
-            case IDictionary<int, object?> dictionary:
-                {
-                    var bidiObject = new List<List<LocalValue>>(dictionary.Count);
-                    foreach (var item in dictionary)
-                    {
-                        bidiObject.Add([ConvertFrom(item.Key), ConvertFrom(item.Value)]);
-                    }
+            case IDictionary dictionary:
+                return ConvertFrom(dictionary);
 
-                    return new MapLocalValue(bidiObject);
-                }
+            case IEnumerable enumerable:
+                return ConvertFrom(enumerable);
 
-            case IEnumerable<object?> list:
-                return new ArrayLocalValue(list.Select(ConvertFrom).ToList());
+            default:
+                return ReflectionBasedConvertFrom(value);
+        }
+    }
 
-            case object:
-                {
-                    const System.Reflection.BindingFlags Flags = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance;
+    public static LocalValue ConvertFrom(bool? value)
+    {
+        if (value is bool b)
+        {
+            return new BooleanLocalValue(b);
+        }
 
-                    var properties = value.GetType().GetProperties(Flags);
+        return new NullLocalValue();
+    }
 
-                    var values = new List<List<LocalValue>>(properties.Length);
-                    foreach (var property in properties)
-                    {
-                        object? propertyValue;
-                        try
-                        {
-                            propertyValue = property.GetValue(value);
-                        }
-                        catch (Exception ex)
-                        {
-                            throw new BiDiException($"Could not retrieve property {property.Name} from {property.DeclaringType}", ex);
-                        }
-                        values.Add([property.Name, ConvertFrom(propertyValue)]);
-                    }
+    public static LocalValue ConvertFrom(int? value)
+    {
+        if (value is int b)
+        {
+            return new NumberLocalValue(b);
+        }
 
-                    return new ObjectLocalValue(values);
-                }
+        return new NullLocalValue();
+    }
+
+    public static LocalValue ConvertFrom(double? value)
+    {
+        if (value is double b)
+        {
+            return new NumberLocalValue(b);
+        }
+
+        return new NullLocalValue();
+    }
+
+    public static LocalValue ConvertFrom(long? value)
+    {
+        if (value is long b)
+        {
+            return new NumberLocalValue(b);
+        }
+
+        return new NullLocalValue();
+    }
+
+    public static LocalValue ConvertFrom(string? value)
+    {
+        if (value is not null)
+        {
+            return new StringLocalValue(value);
+        }
+
+        return new NullLocalValue();
+    }
+
+    /// <summary>
+    /// Converts a .NET Regex into a BiDi Regex
+    /// </summary>
+    /// <param name="regex">A .NET Regex.</param>
+    /// <returns>A BiDi Regex.</returns>
+    /// <remarks>
+    /// Note that the .NET regular expression engine does not work the same as the JavaScript engine.
+    /// To minimize the differences between the two engines, it is recommended to enabled the <see cref="RegexOptions.ECMAScript"/> option.
+    /// </remarks>
+    public static LocalValue ConvertFrom(Regex? regex)
+    {
+        if (regex is null)
+        {
+            return new NullLocalValue();
         }
+
+        string? flags = RegExpValue.GetRegExpFlags(regex.Options);
+
+        return new RegExpLocalValue(new RegExpValue(regex.ToString()) { Flags = flags });
+    }
+
+    public static LocalValue ConvertFrom(DateTimeOffset? value)
+    {
+        if (value is null)
+        {
+            return new NullLocalValue();
+        }
+
+        return new DateLocalValue(value.Value.ToString("o"));
+    }
+
+    public static LocalValue ConvertFrom(BigInteger? value)
+    {
+        if (value is not null)
+        {
+            return new BigIntLocalValue(value.Value.ToString());
+        }
+
+        return new NullLocalValue();
+    }
+
+    public static LocalValue ConvertFrom(IEnumerable? value)
+    {
+        if (value is null)
+        {
+            return new NullLocalValue();
+        }
+
+        List<LocalValue> list = [];
+
+        foreach (var element in value)
+        {
+            list.Add(ConvertFrom(element));
+        }
+
+        return new ArrayLocalValue(list);
+    }
+
+    public static LocalValue ConvertFrom(IDictionary? value)
+    {
+        if (value is null)
+        {
+            return new NullLocalValue();
+        }
+
+        var bidiObject = new List<List<LocalValue>>(value.Count);
+
+        foreach (var key in value.Keys)
+        {
+            bidiObject.Add([ConvertFrom(key), ConvertFrom(value[key])]);
+        }
+
+        return new MapLocalValue(bidiObject);
+    }
+
+    public static LocalValue ConvertFrom<T>(ISet<T?>? value)
+    {
+        if (value is null)
+        {
+            return new NullLocalValue();
+        }
+
+        LocalValue[] convertedValues = [.. value.Select(x => ConvertFrom(x))];
+
+        return new SetLocalValue(convertedValues);
+    }
+
+    private static LocalValue ReflectionBasedConvertFrom(object? value)
+    {
+        if (value is null)
+        {
+            return new NullLocalValue();
+        }
+
+        const System.Reflection.BindingFlags Flags = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance;
+
+        System.Reflection.PropertyInfo[] properties = value.GetType().GetProperties(Flags);
+
+        var values = new List<List<LocalValue>>(properties.Length);
+
+        foreach (System.Reflection.PropertyInfo? property in properties)
+        {
+            object? propertyValue;
+
+            try
+            {
+                propertyValue = property.GetValue(value);
+            }
+            catch (Exception ex)
+            {
+                throw new BiDiException($"Could not retrieve property {property.Name} from {property.DeclaringType}", ex);
+            }
+
+            values.Add([property.Name, ConvertFrom(propertyValue)]);
+        }
+
+        return new ObjectLocalValue(values);
     }
 }
 
@@ -160,9 +299,9 @@ public record BigIntLocalValue(string Value) : PrimitiveProtocolLocalValue;
 
 public record ChannelLocalValue(ChannelProperties Value) : LocalValue
 {
-    // TODO: Revise why we need it
+    // AddPreloadScript takes arguments typed as ChannelLocalValue but still requires "type":"channel"
     [JsonInclude]
-    internal string type = "channel";
+    internal string Type => "channel";
 }
 
 public record ArrayLocalValue(IEnumerable<LocalValue> Value) : LocalValue;