RemoteObject.webDriverValue

Running test: PrimitiveValue
testing expression: undefined
Runtime.evaluate
{
    type : undefined
}
Runtime.callFunctionOn
{
    type : undefined
}
testing expression: null
Runtime.evaluate
{
    type : null
}
Runtime.callFunctionOn
{
    type : null
}
testing expression: 'foo'
Runtime.evaluate
{
    type : string
    value : foo
}
Runtime.callFunctionOn
{
    type : string
    value : foo
}
testing expression: [true, false]
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : boolean
            value : true
        }
        [1] : {
            type : boolean
            value : false
        }
    ]
}
Runtime.callFunctionOn
{
    type : array
    value : [
        [0] : {
            type : boolean
            value : true
        }
        [1] : {
            type : boolean
            value : false
        }
    ]
}

Running test: Number
testing expression: [123, 0.56, -0, +Infinity, -Infinity, NaN]
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : number
            value : 123
        }
        [1] : {
            type : number
            value : 0.56
        }
        [2] : {
            type : number
            value : -0
        }
        [3] : {
            type : number
            value : Infinity
        }
        [4] : {
            type : number
            value : -Infinity
        }
        [5] : {
            type : number
            value : NaN
        }
    ]
}
Runtime.callFunctionOn
{
    type : array
    value : [
        [0] : {
            type : number
            value : 123
        }
        [1] : {
            type : number
            value : 0.56
        }
        [2] : {
            type : number
            value : -0
        }
        [3] : {
            type : number
            value : Infinity
        }
        [4] : {
            type : number
            value : -Infinity
        }
        [5] : {
            type : number
            value : NaN
        }
    ]
}

Running test: BigInt
testing expression: [123n, 1234567890n]
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : bigint
            value : 123n
        }
        [1] : {
            type : bigint
            value : 1234567890n
        }
    ]
}
Runtime.callFunctionOn
{
    type : array
    value : [
        [0] : {
            type : bigint
            value : 123n
        }
        [1] : {
            type : bigint
            value : 1234567890n
        }
    ]
}

Running test: Symbol
testing expression: Symbol('foo')
Runtime.evaluate
{
    type : symbol
}
Runtime.callFunctionOn
{
    type : symbol
}

Running test: Function
testing expression: [function qwe(){}, ()=>{}]
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : function
        }
        [1] : {
            type : function
        }
    ]
}
Runtime.callFunctionOn
{
    type : array
    value : [
        [0] : {
            type : function
        }
        [1] : {
            type : function
        }
    ]
}

Running test: Array
testing expression: [1,2]
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : number
            value : 1
        }
        [1] : {
            type : number
            value : 2
        }
    ]
}
Runtime.callFunctionOn
{
    type : array
    value : [
        [0] : {
            type : number
            value : 1
        }
        [1] : {
            type : number
            value : 2
        }
    ]
}
testing expression: new Array(1,2)
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : number
            value : 1
        }
        [1] : {
            type : number
            value : 2
        }
    ]
}
Runtime.callFunctionOn
{
    type : array
    value : [
        [0] : {
            type : number
            value : 1
        }
        [1] : {
            type : number
            value : 2
        }
    ]
}

Running test: RegExp
testing expression: [new RegExp('ab+c'), new RegExp('ab+c', 'ig')]
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : regexp
            value : {
                pattern : ab+c
            }
        }
        [1] : {
            type : regexp
            value : {
                flags : gi
                pattern : ab+c
            }
        }
    ]
}
Runtime.callFunctionOn
{
    type : array
    value : [
        [0] : {
            type : regexp
            value : {
                pattern : ab+c
            }
        }
        [1] : {
            type : regexp
            value : {
                flags : gi
                pattern : ab+c
            }
        }
    ]
}

Running test: Date
testing date: Thu Apr 07 2022 16:16:25 GMT+1100
Expected date in GMT: Thu, 07 Apr 2022 05:16:25 GMT
Date type as expected: true
Date value as expected: true
testing date: Thu Apr 07 2022 16:16:25 GMT-1100
Expected date in GMT: Fri, 08 Apr 2022 03:16:25 GMT
Date type as expected: true
Date value as expected: true

Running test: Error
testing expression: [new Error(), new Error('qwe')]
Runtime.evaluate
{
    type : array
    value : [
        [0] : {
            type : error
        }
        [1] : {
            type : error
        }
    ]
}
Runtime.callFunctionOn
{
    type : array
    value : [
        [0] : {
            type : error
        }
        [1] : {
            type : error
        }
    ]
}

Running test: Map
testing expression: new Map([['keyString1', {valueObject1: 1}], [{keyObject2: 2}, 'valueString2'], ['keyString3', new Array()]])
Runtime.evaluate
{
    type : map
    value : [
        [0] : [
            [0] : keyString1
            [1] : {
                type : object
            }
        ]
        [1] : [
            [0] : {
                type : object
            }
            [1] : {
                type : string
                value : valueString2
            }
        ]
        [2] : [
            [0] : keyString3
            [1] : {
                type : array
            }
        ]
    ]
}
Runtime.callFunctionOn
{
    type : map
    value : [
        [0] : [
            [0] : keyString1
            [1] : {
                type : object
            }
        ]
        [1] : [
            [0] : {
                type : object
            }
            [1] : {
                type : string
                value : valueString2
            }
        ]
        [2] : [
            [0] : keyString3
            [1] : {
                type : array
            }
        ]
    ]
}

Running test: WeakMap
testing expression: new WeakMap([[{valueObject1: 1}, 'keyString1'],[{valueObject2: 2}, 'keyString2']])
Runtime.evaluate
{
    type : weakmap
}
Runtime.callFunctionOn
{
    type : weakmap
}

Running test: Set
testing expression: new Set([{valueObject1: 1}, 'valueString2', new Array()])
Runtime.evaluate
{
    type : set
    value : [
        [0] : {
            type : object
        }
        [1] : {
            type : string
            value : valueString2
        }
        [2] : {
            type : array
        }
    ]
}
Runtime.callFunctionOn
{
    type : set
    value : [
        [0] : {
            type : object
        }
        [1] : {
            type : string
            value : valueString2
        }
        [2] : {
            type : array
        }
    ]
}

Running test: Weakset
testing expression: new WeakSet([{valueObject1: 1}, {valueObject2: 2}])
Runtime.evaluate
{
    type : weakset
}
Runtime.callFunctionOn
{
    type : weakset
}

Running test: Proxy
testing expression: new Proxy({}, ()=>{})
Runtime.evaluate
{
    type : proxy
}
Runtime.callFunctionOn
{
    type : proxy
}

Running test: Promise
testing expression: new Promise(()=>{})
Runtime.evaluate
{
    type : promise
}
Runtime.callFunctionOn
{
    type : promise
}

Running test: Typedarray
testing expression: new Uint16Array()
Runtime.evaluate
{
    type : typedarray
}
Runtime.callFunctionOn
{
    type : typedarray
}

Running test: ArrayBuffer
testing expression: new ArrayBuffer()
Runtime.evaluate
{
    type : arraybuffer
}
Runtime.callFunctionOn
{
    type : arraybuffer
}

Running test: Object
testing expression: {nullKey: null, stringKey: 'foo',boolKey: true,numberKey: 123,bigintKey: 123n,symbolKey: Symbol('foo'),functionKey: () => {},arrayKey:[1]}
Runtime.evaluate
{
    type : object
    value : [
        [0] : [
            [0] : nullKey
            [1] : {
                type : null
            }
        ]
        [1] : [
            [0] : stringKey
            [1] : {
                type : string
                value : foo
            }
        ]
        [2] : [
            [0] : boolKey
            [1] : {
                type : boolean
                value : true
            }
        ]
        [3] : [
            [0] : numberKey
            [1] : {
                type : number
                value : 123
            }
        ]
        [4] : [
            [0] : bigintKey
            [1] : {
                type : bigint
                value : 123n
            }
        ]
        [5] : [
            [0] : symbolKey
            [1] : {
                type : symbol
            }
        ]
        [6] : [
            [0] : functionKey
            [1] : {
                type : function
            }
        ]
        [7] : [
            [0] : arrayKey
            [1] : {
                type : array
            }
        ]
    ]
}
Runtime.callFunctionOn
{
    type : object
    value : [
        [0] : [
            [0] : nullKey
            [1] : {
                type : null
            }
        ]
        [1] : [
            [0] : stringKey
            [1] : {
                type : string
                value : foo
            }
        ]
        [2] : [
            [0] : boolKey
            [1] : {
                type : boolean
                value : true
            }
        ]
        [3] : [
            [0] : numberKey
            [1] : {
                type : number
                value : 123
            }
        ]
        [4] : [
            [0] : bigintKey
            [1] : {
                type : bigint
                value : 123n
            }
        ]
        [5] : [
            [0] : symbolKey
            [1] : {
                type : symbol
            }
        ]
        [6] : [
            [0] : functionKey
            [1] : {
                type : function
            }
        ]
        [7] : [
            [0] : arrayKey
            [1] : {
                type : array
            }
        ]
    ]
}
testing expression: {key_level_1: {key_level_2: {key_level_3: 'value_level_3'}}}
Runtime.evaluate
{
    type : object
    value : [
        [0] : [
            [0] : key_level_1
            [1] : {
                type : object
            }
        ]
    ]
}
Runtime.callFunctionOn
{
    type : object
    value : [
        [0] : [
            [0] : key_level_1
            [1] : {
                type : object
            }
        ]
    ]
}