ExecutingJavascriptTest.cs

// <copyright file="ExecutingJavascriptTest.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 System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Threading.Tasks;

namespace OpenQA.Selenium
{
    [TestFixture]
    public class ExecutingJavascriptTest : DriverTestFixture
    {
        [Test]
        public void ShouldBeAbleToExecuteSimpleJavascriptAndReturnAString()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = xhtmlTestPage;

            object result = ExecuteScript("return document.title;");

            Assert.That(result, Is.InstanceOf<string>());
            Assert.That(result, Is.EqualTo("XHTML Test Page"));
        }

        [Test]
        public void ShouldBeAbleToExecuteSimpleJavascriptAndReturnALong()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = xhtmlTestPage;

            object result = ExecuteScript("return document.title.length;");

            Assert.That(result, Is.InstanceOf<long>());
            Assert.That((long)result, Is.EqualTo((long)"XHTML Test Page".Length));
        }

        [Test]
        public void ShouldBeAbleToExecuteSimpleJavascriptAndReturnAWebElement()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = xhtmlTestPage;

            object result = ExecuteScript("return document.getElementById('id1');");

            Assert.That(result, Is.Not.Null);
            Assert.That(result, Is.InstanceOf<IWebElement>());
        }

        [Test]
        public void ShouldBeAbleToExecuteSimpleJavascriptAndReturnABoolean()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = xhtmlTestPage;

            object result = ExecuteScript("return true;");

            Assert.That(result, Is.Not.Null);
            Assert.That(result, Is.InstanceOf<bool>());
            Assert.That((bool)result, Is.True);
        }

        [Test]
        public void ShouldBeAbleToExecuteSimpleJavascriptAndReturnAStringArray()
        {
            if (!(driver is IJavaScriptExecutor))
            {
                return;
            }

            driver.Url = javascriptPage;
            List<object> expectedResult = new List<object>();
            expectedResult.Add("zero");
            expectedResult.Add("one");
            expectedResult.Add("two");
            object result = ExecuteScript("return ['zero', 'one', 'two'];");
            Assert.That(result, Is.InstanceOf<ReadOnlyCollection<object>>());
            ReadOnlyCollection<object> list = (ReadOnlyCollection<object>)result;
            Assert.That(list, Is.EqualTo(expectedResult.AsReadOnly()));
        }

        [Test]
        public void ShouldBeAbleToExecuteSimpleJavascriptAndReturnAnArray()
        {
            if (!(driver is IJavaScriptExecutor))
            {
                return;
            }

            driver.Url = javascriptPage;
            List<object> expectedResult = new List<object>();
            expectedResult.Add("zero");
            List<object> subList = new List<object>();
            subList.Add(true);
            subList.Add(false);
            expectedResult.Add(subList.AsReadOnly());
            object result = ExecuteScript("return ['zero', [true, false]];");
            Assert.That(result, Is.InstanceOf<ReadOnlyCollection<object>>());
            ReadOnlyCollection<object> list = (ReadOnlyCollection<object>)result;
            Assert.That(result, Is.EqualTo(expectedResult.AsReadOnly()));
        }

        [Test]
        public void ShouldBeAbleToExecuteJavascriptAndReturnABasicObjectLiteral()
        {
            if (!(driver is IJavaScriptExecutor))
            {
                return;
            }

            driver.Url = javascriptPage;

            object result = ExecuteScript("return {abc: '123', tired: false};");
            Assert.That(result, Is.InstanceOf<Dictionary<string, object>>());
            Dictionary<string, object> map = (Dictionary<string, object>)result;

            Dictionary<string, object> expected = new Dictionary<string, object>();
            expected.Add("abc", "123");
            expected.Add("tired", false);

            Assert.That(map, Has.Count.EqualTo(expected.Count), "Expected:<" + expected.Count + ">, but was:<" + map.Count + ">");
            foreach (string expectedKey in expected.Keys)
            {
                Assert.That(map, Does.ContainKey(expectedKey));
                Assert.That(map[expectedKey], Is.EqualTo(expected[expectedKey]));
            }
        }

        [Test]
        public void ShouldBeAbleToExecuteSimpleJavascriptAndReturnAnObjectLiteral()
        {
            if (!(driver is IJavaScriptExecutor))
            {
                return;
            }

            driver.Url = javascriptPage;

            Dictionary<string, object> expectedPerson = new Dictionary<string, object>();
            expectedPerson.Add("first", "John");
            expectedPerson.Add("last", "Doe");
            Dictionary<string, object> expectedResult = new Dictionary<string, object>();
            expectedResult.Add("foo", "bar");
            List<object> subList = new List<object>() { "a", "b", "c" };
            expectedResult.Add("baz", subList.AsReadOnly());
            expectedResult.Add("person", expectedPerson);

            object result = ExecuteScript(
                "return {foo:'bar', baz: ['a', 'b', 'c'], " +
                    "person: {first: 'John',last: 'Doe'}};");
            Assert.That(result, Is.InstanceOf<Dictionary<string, object>>());

            Dictionary<string, object> map = (Dictionary<string, object>)result;
            Assert.That(map, Has.Count.EqualTo(3));
            foreach (string expectedKey in expectedResult.Keys)
            {
                Assert.That(map, Does.ContainKey(expectedKey));
            }

            Assert.That(map["foo"], Is.EqualTo("bar"));
            Assert.That((ReadOnlyCollection<object>)map["baz"], Is.EqualTo((ReadOnlyCollection<object>)expectedResult["baz"]));

            Dictionary<string, object> person = (Dictionary<string, object>)map["person"];
            Assert.That(person, Has.Count.EqualTo(2));
            Assert.That(person["first"], Is.EqualTo("John"));
            Assert.That(person["last"], Is.EqualTo("Doe"));
        }

        [Test]
        public void ShouldBeAbleToExecuteSimpleJavascriptAndReturnAComplexObject()
        {
            driver.Url = javascriptPage;

            object result = ExecuteScript("return window.location;");

            Assert.That(result, Is.InstanceOf<Dictionary<string, object>>());
            Dictionary<string, object> map = (Dictionary<string, object>)result;
            Assert.That(map["protocol"], Is.EqualTo("http:"));
            Assert.That(map["href"], Is.EqualTo(javascriptPage));
        }

        [Test]
        public void PassingAndReturningALongShouldReturnAWholeNumber()
        {
            if (!(driver is IJavaScriptExecutor))
            {
                return;
            }

            driver.Url = javascriptPage;
            long expectedResult = 1L;
            object result = ExecuteScript("return arguments[0];", expectedResult);
            Assert.That(result, Is.InstanceOf<int>().Or.InstanceOf<long>());
            Assert.That(result, Is.EqualTo((long)expectedResult));
        }

        [Test]
        public void PassingAndReturningADoubleShouldReturnADecimal()
        {
            if (!(driver is IJavaScriptExecutor))
            {
                return;
            }

            driver.Url = javascriptPage;
            double expectedResult = 1.2;
            object result = ExecuteScript("return arguments[0];", expectedResult);
            Assert.That(result, Is.InstanceOf<float>().Or.InstanceOf<double>());
            Assert.That(result, Is.EqualTo((double)expectedResult));
        }

        [Test]
        public void ShouldThrowAnExceptionWhenTheJavascriptIsBad()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = xhtmlTestPage;
            Assert.That(() => ExecuteScript("return squiggle();"), Throws.InstanceOf<WebDriverException>());
        }

        [Test]
        [IgnoreBrowser(Browser.Chrome, ".NET language bindings do not properly parse JavaScript stack trace")]
        [IgnoreBrowser(Browser.Edge, ".NET language bindings do not properly parse JavaScript stack trace")]
        [IgnoreBrowser(Browser.Firefox, ".NET language bindings do not properly parse JavaScript stack trace")]
        [IgnoreBrowser(Browser.IE, ".NET language bindings do not properly parse JavaScript stack trace")]
        [IgnoreBrowser(Browser.Safari, ".NET language bindings do not properly parse JavaScript stack trace")]
        public void ShouldThrowAnExceptionWithMessageAndStacktraceWhenTheJavascriptIsBad()
        {
            driver.Url = xhtmlTestPage;
            string js = "function functionB() { throw Error('errormessage'); };"
                        + "function functionA() { functionB(); };"
                        + "functionA();";

            Assert.That(
               () => ExecuteScript(js),
               Throws.InstanceOf<WebDriverException>()
               .With.Message.Contains("errormessage")
               .And.Property(nameof(WebDriverException.StackTrace)).Contains("functionB"));
        }

        [Test]
        public void ShouldBeAbleToCallFunctionsDefinedOnThePage()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;
            ExecuteScript("displayMessage('I like cheese');");
            string text = driver.FindElement(By.Id("result")).Text;

            Assert.That(text.Trim(), Is.EqualTo("I like cheese"));
        }

        [Test]
        public void ShouldBeAbleToPassAStringAsAnArgument()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;

            string text = (string)ExecuteScript("return arguments[0] == 'Hello!' ? 'Hello!' : 'Goodbye!';", "Hello!");
            Assert.That(text, Is.EqualTo("Hello!"));
        }

        [Test]
        public void ShouldBeAbleToPassABooleanAsAnArgument()
        {

            string function = "return arguments[0] == true ? true : false;";

            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;

            bool result = (bool)ExecuteScript(function, true);
            Assert.That(result, Is.True);

            result = (bool)ExecuteScript(function, false);
            Assert.That(result, Is.False);
        }

        [Test]
        public void ShouldBeAbleToPassANumberAsAnArgument()
        {
            string functionTemplate = "return arguments[0] == {0} ? {0} : 0;";

            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;

            string function = string.Format(functionTemplate, 3);
            long result = (long)ExecuteScript(function, 3);
            Assert.That(result, Is.EqualTo(3));

            function = string.Format(functionTemplate, -3);
            result = (long)ExecuteScript(function, -3);
            Assert.That(result, Is.EqualTo(-3));

            function = string.Format(functionTemplate, 2147483647);
            result = (long)ExecuteScript(function, 2147483647);
            Assert.That(result, Is.EqualTo(2147483647));

            function = string.Format(functionTemplate, -2147483647);
            result = (long)ExecuteScript(function, -2147483647);
            Assert.That(result, Is.EqualTo(-2147483647));
        }

        [Test]

        public void ShouldBeAbleToPassAWebElementAsArgument()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;
            IWebElement button = driver.FindElement(By.Id("plainButton"));
            string value = (string)ExecuteScript("arguments[0]['flibble'] = arguments[0].getAttribute('id'); return arguments[0]['flibble'];", button);

            Assert.That(value, Is.EqualTo("plainButton"));
        }

        [Test]
        public void PassingArrayAsOnlyArgumentShouldFlattenArray()
        {
            if (!(driver is IJavaScriptExecutor))
            {
                return;
            }

            driver.Url = javascriptPage;
            object[] array = new object[] { "zero", 1, true, 3.14159 };
            long length = (long)ExecuteScript("return arguments[0].length", array);
            Assert.That(length, Is.EqualTo(array.Length));
        }

        [Test]
        public void ShouldBeAbleToPassAnArrayAsAdditionalArgument()
        {
            if (!(driver is IJavaScriptExecutor))
            {
                return;
            }

            driver.Url = javascriptPage;
            object[] array = new object[] { "zero", 1, true, 3.14159, false };
            long length = (long)ExecuteScript("return arguments[1].length", "string", array);
            Assert.That(length, Is.EqualTo(array.Length));
        }

        [Test]
        public void ShouldBeAbleToPassACollectionAsArgument()
        {
            if (!(driver is IJavaScriptExecutor))
            {
                return;
            }

            driver.Url = javascriptPage;
            List<object> collection = new List<object>();
            collection.Add("Cheddar");
            collection.Add("Brie");
            collection.Add(7);
            long length = (long)ExecuteScript("return arguments[0].length", collection);
            Assert.That(length, Is.EqualTo(collection.Count));
        }

        [Test]
        public void ShouldThrowAnExceptionIfAnArgumentIsNotValid()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;

            Assert.That(
                () => ExecuteScript("return arguments[0];", driver),
                Throws.ArgumentException.With.Message.StartsWith("Argument is of an illegal type: "));
        }

        [Test]
        public void ShouldBeAbleToPassInMoreThanOneArgument()
        {
            if (!(driver is IJavaScriptExecutor))
            {
                return;
            }

            driver.Url = javascriptPage;
            string result = (string)ExecuteScript("return arguments[0] + arguments[1];", "one", "two");

            Assert.That(result, Is.EqualTo("onetwo"));
        }

        [Test]
        public void ShouldBeAbleToGrabTheBodyOfFrameOnceSwitchedTo()
        {
            driver.Url = richTextPage;

            driver.SwitchTo().Frame("editFrame");
            IWebElement body = (IWebElement)((IJavaScriptExecutor)driver).ExecuteScript("return document.body");

            Assert.That(body.Text, Is.Empty);
        }

        // This is a duplicate test of ShouldBeAbleToExecuteScriptAndReturnElementsList.
        // It's here and commented only to make comparison with the Java language bindings
        // tests easier.
        //[Test]
        //public void testShouldBeAbleToReturnAnArrayOfWebElements()
        //{
        //    driver.Url = formsPage;

        //    ReadOnlyCollection<IWebElement> items = (ReadOnlyCollection<IWebElement>)((IJavaScriptExecutor)driver)
        //        .ExecuteScript("return document.getElementsByName('snack');");

        //    Assert.That(items.Count, Is.Not.EqualTo(0));
        //}

        [Test]
        public void JavascriptStringHandlingShouldWorkAsExpected()
        {
            driver.Url = javascriptPage;

            string value = (string)ExecuteScript("return '';");
            Assert.That(value, Is.Empty);

            value = (string)ExecuteScript("return undefined;");
            Assert.That(value, Is.Null);

            value = (string)ExecuteScript("return ' '");
            Assert.That(value, Is.EqualTo(" "));
        }

        [Test]
        public void ShouldBeAbleToExecuteABigChunkOfJavascriptCode()
        {
            driver.Url = javascriptPage;
            string path = System.IO.Path.Combine(Environment.EnvironmentManager.Instance.CurrentDirectory, ".." + System.IO.Path.DirectorySeparatorChar + "..");
            string[] fileList = System.IO.Directory.GetFiles(path, "jquery-1.2.6.min.js", System.IO.SearchOption.AllDirectories);
            if (fileList.Length > 0)
            {
                string jquery = System.IO.File.ReadAllText(fileList[0]);
                Assert.That(jquery, Has.Length.GreaterThan(50000));
                ExecuteScript(jquery, null);
            }
        }

        [Test]
        [IgnoreBrowser(Selenium.Browser.IE, "IE does not support Chrome DevTools Protocol")]
        [IgnoreBrowser(Selenium.Browser.Firefox, "Firefox does not support Chrome DevTools Protocol")]
        [IgnoreBrowser(Selenium.Browser.Safari, "Safari does not support Chrome DevTools Protocol")]
        public async Task ShouldBeAbleToPinJavascriptCodeAndExecuteRepeatedly()
        {
            using IJavaScriptEngine jsEngine = new JavaScriptEngine(driver);

            driver.Url = xhtmlTestPage;

            PinnedScript script = await jsEngine.PinScript("return document.title;");
            for (int i = 0; i < 5; i++)
            {
                object result = ((IJavaScriptExecutor)driver).ExecuteScript(script);

                Assert.That(result, Is.InstanceOf<string>());
                Assert.That(result, Is.EqualTo("XHTML Test Page"));
            }

            await jsEngine.UnpinScript(script);

            Assert.That(
                () => ((IJavaScriptExecutor)driver).ExecuteScript(script),
                Throws.TypeOf<JavaScriptException>());
        }

        [Test]
        [NeedsFreshDriver(IsCreatedAfterTest = true)]
        [IgnoreBrowser(Selenium.Browser.IE, "IE does not support Chrome DevTools Protocol")]
        [IgnoreBrowser(Selenium.Browser.Firefox, "Firefox does not support Chrome DevTools Protocol")]
        [IgnoreBrowser(Selenium.Browser.Safari, "Safari does not support Chrome DevTools Protocol")]
        public async Task ShouldBeAbleToAddInitializationScriptAndExecuteOnNewDocument()
        {
            const string ScriptValue = "alert('notice')";
            const string ScriptName = "AlertScript";

            using IJavaScriptEngine jsEngine = new JavaScriptEngine(driver);

            var initScript = await jsEngine.AddInitializationScript(ScriptName, ScriptValue);

            Assert.That(initScript, Is.Not.Null);
            Assert.That(initScript.ScriptSource, Is.EqualTo(ScriptValue));
            Assert.That(initScript.ScriptName, Is.EqualTo(ScriptName));
            Assert.That(initScript.ScriptId, Is.Not.Null);

            await jsEngine.StartEventMonitoring();

            driver.Navigate().Refresh();
            driver.SwitchTo().Alert().Accept();

            Assert.That(jsEngine.InitializationScripts, Does.Contain(initScript));
            await jsEngine.RemoveInitializationScript(ScriptName);

            driver.Navigate().Refresh();
            Assert.That(() => driver.SwitchTo().Alert().Accept(), Throws.TypeOf<NoAlertPresentException>());

            Assert.That(jsEngine.InitializationScripts, Does.Not.Contain(initScript));

            await jsEngine.AddInitializationScript(ScriptName, ScriptValue);

            driver.Navigate().Refresh();
            driver.SwitchTo().Alert().Accept();
            Assert.That(jsEngine.InitializationScripts, Does.Contain(initScript));

            await jsEngine.ClearInitializationScripts();

            driver.Navigate().Refresh();
            Assert.That(() => driver.SwitchTo().Alert().Accept(), Throws.TypeOf<NoAlertPresentException>());
            Assert.That(jsEngine.InitializationScripts, Is.Empty);

            await jsEngine.AddInitializationScript(ScriptName, ScriptValue);
            driver.Navigate().Refresh();
            driver.SwitchTo().Alert().Accept();

            await jsEngine.ClearAll();
            driver.Navigate().Refresh();
            Assert.That(() => driver.SwitchTo().Alert().Accept(), Throws.TypeOf<NoAlertPresentException>());
            Assert.That(jsEngine.InitializationScripts, Is.Empty);
        }

        [Test]
        [NeedsFreshDriver(IsCreatedAfterTest = true)]
        [IgnoreBrowser(Selenium.Browser.IE, "IE does not support Chrome DevTools Protocol")]
        [IgnoreBrowser(Selenium.Browser.Firefox, "Firefox does not support Chrome DevTools Protocol")]
        [IgnoreBrowser(Selenium.Browser.Safari, "Safari does not support Chrome DevTools Protocol")]
        public async Task ShouldBeAbleToAddAndRemoveScriptCallbackBinding()
        {
            const string ScriptValue = "alert('Hello world')";
            const string ScriptName = "alert";

            using IJavaScriptEngine jsEngine = new JavaScriptEngine(driver);

            var executedBindings = new List<string>();
            jsEngine.JavaScriptCallbackExecuted += AddToList;
            await jsEngine.AddInitializationScript(ScriptName, ScriptValue);
            await jsEngine.StartEventMonitoring();

            driver.Navigate().Refresh();
            driver.SwitchTo().Alert().Accept();

            await jsEngine.AddScriptCallbackBinding(ScriptName);

            driver.Navigate().Refresh();
            Assert.That(() => driver.SwitchTo().Alert().Accept(), Throws.TypeOf<NoAlertPresentException>());

            Assert.That(executedBindings, Does.Contain(ScriptName));
            int oldCount = executedBindings.Count;
            driver.Navigate().Refresh();

            Assert.That(executedBindings, Has.Count.GreaterThan(oldCount));
            Assert.That(jsEngine.ScriptCallbackBindings, Does.Contain(ScriptName));
            oldCount = executedBindings.Count;

            await jsEngine.RemoveScriptCallbackBinding(ScriptName);
            Assert.That(jsEngine.ScriptCallbackBindings, Is.Empty);
            await jsEngine.AddScriptCallbackBinding(ScriptName);
            Assert.That(jsEngine.ScriptCallbackBindings, Does.Contain(ScriptName));
            await jsEngine.ClearScriptCallbackBindings();
            Assert.That(jsEngine.ScriptCallbackBindings, Is.Empty);

            jsEngine.JavaScriptCallbackExecuted -= AddToList;
            driver.Navigate().Refresh();
            Assert.That(executedBindings, Has.Count.EqualTo(oldCount));

            void AddToList(object sender, JavaScriptCallbackExecutedEventArgs e) => executedBindings.Add(e.BindingName);
        }

        [Test]
        public void ShouldBeAbleToExecuteScriptAndReturnElementsList()
        {
            driver.Url = formsPage;
            String scriptToExec = "return document.getElementsByName('snack');";

            object resultObject = ((IJavaScriptExecutor)driver).ExecuteScript(scriptToExec);

            ReadOnlyCollection<IWebElement> resultsList = (ReadOnlyCollection<IWebElement>)resultObject;

            Assert.That(resultsList, Is.Not.Empty);
        }

        [Test]
        public void ShouldBeAbleToCreateAPersistentValue()
        {
            driver.Url = formsPage;

            ExecuteScript("document.alerts = []");
            ExecuteScript("document.alerts.push('hello world');");
            string text = (string)ExecuteScript("return document.alerts.shift()");

            Assert.That(text, Is.EqualTo("hello world"));
        }

        [Test]
        public void ShouldBeAbleToHandleAnArrayOfElementsAsAnObjectArray()
        {
            driver.Url = formsPage;

            ReadOnlyCollection<IWebElement> forms = driver.FindElements(By.TagName("form"));
            object[] args = new object[] { forms };

            string name = (string)((IJavaScriptExecutor)driver).ExecuteScript("return arguments[0][0].tagName", args);

            Assert.That(name, Is.EqualTo("form").IgnoreCase);
        }

        [Test]
        public void ShouldBeAbleToPassADictionaryAsAParameter()
        {
            driver.Url = simpleTestPage;

            List<int> nums = new List<int>() { 1, 2 };
            Dictionary<string, object> args = new Dictionary<string, object>();
            args["bar"] = "test";
            args["foo"] = nums;

            object res = ((IJavaScriptExecutor)driver).ExecuteScript("return arguments[0]['foo'][1]", args);

            Assert.That((long)res, Is.EqualTo(2));
        }

        [Test]
        public void ShouldThrowAnExceptionWhenArgumentsWithStaleElementPassed()
        {
            IJavaScriptExecutor executor = driver as IJavaScriptExecutor;
            if (executor == null)
            {
                return;
            }

            driver.Url = simpleTestPage;

            IWebElement el = driver.FindElement(By.Id("oneline"));

            driver.Url = simpleTestPage;

            Dictionary<string, object> args = new Dictionary<string, object>();
            args["key"] = new object[] { "a", new object[] { "zero", 1, true, 3.14159, false, el }, "c" };
            Assert.That(
                () => executor.ExecuteScript("return undefined;", args),
                Throws.TypeOf<StaleElementReferenceException>());
        }

        [Test]
        [IgnoreBrowser(Browser.Chrome, "Browser does not return Date object.")]
        [IgnoreBrowser(Browser.Edge, "Browser does not return Date object.")]
        public void ShouldBeAbleToReturnADateObject()
        {
            driver.Url = simpleTestPage;

            string date = (string)ExecuteScript("return new Date();");
            DateTime.Parse(date);
        }

        [Test]
        [IgnoreBrowser(Browser.Chrome, "Driver returns object that allows getting text.")]
        [IgnoreBrowser(Browser.Edge, "Driver returns object that allows getting text.")]
        [IgnoreBrowser(Browser.Firefox, "Driver does not return the documentElement object.")]
        [IgnoreBrowser(Browser.IE, "Driver does not return the documentElement object.")]
        [IgnoreBrowser(Browser.Safari, "Driver does not return the documentElement object.")]
        public void ShouldReturnDocumentElementIfDocumentIsReturned()
        {
            driver.Url = simpleTestPage;

            object value = ExecuteScript("return document");

            Assert.That(value, Is.InstanceOf<IWebElement>());
            Assert.That(((IWebElement)value).Text, Does.Contain("A single line of text"));
        }

        [Test]
        public void ShouldHandleObjectThatThatHaveToJSONMethod()
        {
            driver.Url = simpleTestPage;

            object value = ExecuteScript("return window.performance.timing");

            Assert.That(value, Is.InstanceOf<Dictionary<string, object>>());
        }

        [Test]
        public void ShouldHandleRecursiveStructures()
        {
            driver.Url = simpleTestPage;

            Assert.That(
                () => ExecuteScript(
                    """
                    var obj1 = {};
                    var obj2 = {};
                    obj1['obj2'] = obj2;
                    obj2['obj1'] = obj1;
                    return obj1
                    """
                    ),
                Throws.TypeOf<JavaScriptException>());
        }

        //------------------------------------------------------------------
        // Tests below here are not included in the Java test suite
        //------------------------------------------------------------------
        [Test]
        [NeedsFreshDriver(IsCreatedBeforeTest = true, IsCreatedAfterTest = true)]
        [Ignore("Reason for ignore: Failure indicates hang condition, which would break the test suite. Really needs a timeout set.")]
        public void ShouldThrowExceptionIfExecutingOnNoPage()
        {
            Assert.That(
                () => ((IJavaScriptExecutor)driver).ExecuteScript("return 1;"),
                Throws.InstanceOf<WebDriverException>());
        }

        [Test]
        public void ExecutingLargeJavaScript()
        {
            string script = """
                // stolen from injectableSelenium.js in WebDriver
                var browserbot = {

                    triggerEvent: function(element, eventType, canBubble, controlKeyDown, altKeyDown, shiftKeyDown, metaKeyDown) {
                        canBubble = (typeof(canBubble) == undefined) ? true : canBubble;

                        if (element.fireEvent && element.ownerDocument && element.ownerDocument.createEventObject) {
                            // IE
                            var evt = this.createEventObject(element, controlKeyDown, altKeyDown, shiftKeyDown, metaKeyDown);
                            element.fireEvent('on' + eventType,evt);
                        } else {
                            var evt = document.createEvent('HTMLEvents');

                            try {
                                evt.shiftKey = shiftKeyDown;
                                evt.metaKey = metaKeyDown;
                                evt.altKey = altKeyDown;
                                evt.ctrlKey = controlKeyDown;
                            } catch(e) {
                                // Nothing sane to do
                            }

                            evt.initEvent(eventType, canBubble, true);
                            return element.dispatchEvent(evt);
                        }
                    },

                    getVisibleText: function() {
                        var selection = getSelection();
                        var range = document.createRange();
                        range.selectNodeContents(document.documentElement);
                        selection.addRange(range);

                        var string = selection.toString();
                        selection.removeAllRanges();

                        return string;
                    },

                    getOuterHTML: function(element) {
                        if(element.outerHTML) {
                            return element.outerHTML;
                        } else if(typeof(XMLSerializer) != undefined) {
                            return new XMLSerializer().serializeToString(element);
                        } else {
                            throw "can't get outerHTML in this browser";
                        }
                    }
                };

                return browserbot.getOuterHTML.apply(browserbot, arguments);
                """;

            driver.Url = javascriptPage;
            IWebElement element = driver.FindElement(By.TagName("body"));
            object x = ExecuteScript(script, element);
        }

        [Test]

        public void ShouldBeAbleToPassMoreThanOneStringAsArguments()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;
            string text = (string)ExecuteScript("return arguments[0] + arguments[1] + arguments[2] + arguments[3];", "Hello,", " ", "world", "!");

            Assert.That(text, Is.EqualTo("Hello, world!"));
        }

        [Test]
        public void ShouldBeAbleToPassMoreThanOneBooleanAsArguments()
        {

            string function = "return (arguments[0] ? 'True' : 'False') + (arguments[1] ? 'True' : 'False');";

            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;

            string text = (string)ExecuteScript(function, true, true);
            Assert.That(text, Is.EqualTo("TrueTrue"));

            text = (string)ExecuteScript(function, false, true);
            Assert.That(text, Is.EqualTo("FalseTrue"));

            text = (string)ExecuteScript(function, true, false);
            Assert.That(text, Is.EqualTo("TrueFalse"));

            text = (string)ExecuteScript(function, false, false);
            Assert.That(text, Is.EqualTo("FalseFalse"));
        }

        [Test]
        public void ShouldBeAbleToPassMoreThanOneNumberAsArguments()
        {
            string function = "return arguments[0]+arguments[1];";

            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;

            long result = (long)ExecuteScript(function, 30, 12);
            Assert.That(result, Is.EqualTo(42));

            result = (long)ExecuteScript(function, -30, -12);
            Assert.That(result, Is.EqualTo(-42));

            result = (long)ExecuteScript(function, 2147483646, 1);
            Assert.That(result, Is.EqualTo(2147483647));

            result = (long)ExecuteScript(function, -2147483646, -1);
            Assert.That(result, Is.EqualTo(-2147483647));

        }

        [Test]
        public void ShouldBeAbleToPassADoubleAsAnArgument()
        {
            string function = "return arguments[0];";

            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;

            double result = (double)ExecuteScript(function, (double)4.2);
            Assert.That(result, Is.EqualTo(4.2));

            result = (double)ExecuteScript(function, (double)-4.2);
            Assert.That(result, Is.EqualTo(-4.2));

            result = (double)ExecuteScript(function, (float)4.2);
            Assert.That(result, Is.EqualTo(4.2));

            result = (double)ExecuteScript(function, (float)-4.2);
            Assert.That(result, Is.EqualTo(-4.2));

            result = (long)ExecuteScript(function, (double)4.0);
            Assert.That(result, Is.EqualTo(4));

            result = (long)ExecuteScript(function, (double)-4.0);
            Assert.That(result, Is.EqualTo(-4));
        }

        [Test]
        public void ShouldBeAbleToPassMoreThanOneDoubleAsArguments()
        {
            String function = "return arguments[0]+arguments[1];";

            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;

            double result = (double)ExecuteScript(function, 30.1, 12.1);
            Assert.That(result, Is.EqualTo(42.2));

            result = (double)ExecuteScript(function, -30.1, -12.1);
            Assert.That(result, Is.EqualTo(-42.2));

            result = (double)ExecuteScript(function, 2147483646.1, 1.0);
            Assert.That(result, Is.EqualTo(2147483647.1));

            result = (double)ExecuteScript(function, -2147483646.1, -1.0);
            Assert.That(result, Is.EqualTo(-2147483647.1));

        }

        [Test]
        public void ShouldBeAbleToPassMoreThanOneWebElementAsArguments()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;
            IWebElement button = driver.FindElement(By.Id("plainButton"));
            IWebElement dynamo = driver.FindElement(By.Id("dynamo"));
            string value = (string)ExecuteScript("arguments[0]['flibble'] = arguments[0].getAttribute('id'); return arguments[0]['flibble'] + arguments[1].innerHTML;", button, dynamo);

            Assert.That(value, Is.EqualTo("plainButtonWhat's for dinner?"));
        }

        [Test]
        public void ShouldBeAbleToPassInMixedArguments()
        {
            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;

            IWebElement dynamo = driver.FindElement(By.Id("dynamo"));
            string result = (string)ExecuteScript("return arguments[0].innerHTML + arguments[1].toString() + arguments[2].toString() + arguments[3] + arguments[4]",
                dynamo,
                42,
                4.2,
                "Hello, World!",
                true);

            Assert.That(result, Is.EqualTo("What's for dinner?424.2Hello, World!true"));

        }

        [Test]
        public void ShouldBeAbleToPassInAndRetrieveDates()
        {
            string function = "displayMessage(arguments[0]);";

            if (!(driver is IJavaScriptExecutor))
                return;

            driver.Url = javascriptPage;

            ExecuteScript(function, "2014-05-20T20:00:00+08:00");
            IWebElement element = driver.FindElement(By.Id("result"));
            string text = element.Text;
            Assert.That(text, Is.EqualTo("2014-05-20T20:00:00+08:00"));
        }

        private object ExecuteScript(String script, params Object[] args)
        {
            object toReturn = ((IJavaScriptExecutor)driver).ExecuteScript(script, args);
            return toReturn;
        }
    }
}