v8/test/inspector/debugger/object-preview-internal-properties-expected.txt

Check internal properties reported in object preview.

Running test: boxedObjects
expression: new Number(239)
{
    name : [[PrimitiveValue]]
    type : number
    value : 239
}

expression: new Boolean(false)
{
    name : [[PrimitiveValue]]
    type : boolean
    value : false
}

expression: new String("abc")
{
    name : [[PrimitiveValue]]
    type : string
    value : abc
}

expression: Object(Symbol(42))
{
    name : [[PrimitiveValue]]
    type : symbol
    valuePreview : {
        description : Symbol
        overflow : false
        properties : [
        ]
        type : object
    }
}


Running test: promise
expression: Promise.resolve(42)
{
    name : [[PromiseStatus]]
    type : string
    value : resolved
}
{
    name : [[PromiseValue]]
    type : number
    value : 42
}

expression: new Promise(() => undefined)
{
    name : [[PromiseStatus]]
    type : string
    value : pending
}
{
    name : [[PromiseValue]]
    type : undefined
    value : undefined
}


Running test: generatorObject
expression: (function* foo() { yield 1 })()
{
    name : [[GeneratorStatus]]
    type : string
    value : suspended
}


Running test: entriesInMapAndSet
expression: new Map([[1,2]])
[[Entries]]:
[
    [0] : {
        key : {
            description : 1
            overflow : false
            properties : [
            ]
            type : number
        }
        value : {
            description : 2
            overflow : false
            properties : [
            ]
            type : number
        }
    }
]

expression: new Set([1])
[[Entries]]:
[
    [0] : {
        value : {
            description : 1
            overflow : false
            properties : [
            ]
            type : number
        }
    }
]

expression: new WeakMap([[{}, 42]])
[[Entries]]:
[
    [0] : {
        key : {
            description : Object
            overflow : false
            properties : [
            ]
            type : object
        }
        value : {
            description : 42
            overflow : false
            properties : [
            ]
            type : number
        }
    }
]

expression: new WeakSet([{}])
[[Entries]]:
[
    [0] : {
        value : {
            description : Object
            overflow : false
            properties : [
            ]
            type : object
        }
    }
]


Running test: iteratorObject
expression: (new Map([[1,2]])).entries()
{
    name : [[IteratorHasMore]]
    type : boolean
    value : true
}
{
    name : [[IteratorIndex]]
    type : number
    value : 0
}
{
    name : [[IteratorKind]]
    type : string
    value : entries
}
[[Entries]]:
[
    [0] : {
        value : {
            description : Array[2]
            overflow : false
            properties : [
                [0] : {
                    name : 0
                    type : number
                    value : 1
                }
                [1] : {
                    name : 1
                    type : number
                    value : 2
                }
            ]
            subtype : array
            type : object
        }
    }
]

expression: (new Set([[1,2]])).entries()
{
    name : [[IteratorHasMore]]
    type : boolean
    value : true
}
{
    name : [[IteratorIndex]]
    type : number
    value : 0
}
{
    name : [[IteratorKind]]
    type : string
    value : entries
}
[[Entries]]:
[
    [0] : {
        value : {
            description : Array[2]
            overflow : false
            properties : [
                [0] : {
                    name : 0
                    subtype : array
                    type : object
                    value : Array[2]
                }
                [1] : {
                    name : 1
                    subtype : array
                    type : object
                    value : Array[2]
                }
            ]
            subtype : array
            type : object
        }
    }
]


Running test: noPreviewForFunctionObject
(function foo(){})
{
    id : <messageId>
    result : {
        result : {
            className : Function
            description : function foo(){}
            objectId : <objectId>
            type : function
        }
    }
}

Running test: otherObjects
expression: [1,2,3]

expression: /123/

expression: ({})


Running test: overridenArrayGetter
expression: Promise.resolve(42)