Function TestValueObjectControlAPIs

value_test.go:107–185

(t *testing.T)

}

func TestValueObjectControlAPIs(t *testing.T) {
	useStableOwnerHooksForLegacySubtests(t)

	rt := NewRuntime()
	defer rt.Close()
	ctx := rt.NewContext()
	defer ctx.Close()

	obj := ctx.NewObject()
	defer obj.Free()
	proto := ctx.NewObject()
	defer proto.Free()
	proto.Set("kind", ctx.NewString("proto"))

	require.True(t, obj.SetPrototype(proto))
	actualProto := obj.Prototype()
	require.NotNil(t, actualProto)
	defer actualProto.Free()
	kind := actualProto.Get("kind")
	defer kind.Free()
	require.Equal(t, "proto", kind.ToString())

	require.True(t, obj.IsExtensible())
	require.True(t, obj.PreventExtensions())
	require.False(t, obj.IsExtensible())

	sealed := ctx.Eval("({ a: 1 })")
	defer sealed.Free()
	require.True(t, sealed.Seal())
	require.False(t, sealed.IsExtensible())

	frozen := ctx.Eval("({ a: 1 })")
	defer frozen.Free()
	require.True(t, frozen.Freeze())
	require.False(t, frozen.IsExtensible())

	ctx2 := rt.NewContext()
	defer ctx2.Close()
	otherProto := ctx2.NewObject()
	defer otherProto.Free()
	require.False(t, obj.SetPrototype(otherProto))

	// Hit explicit tri-state exception branches via Proxy traps that throw.
	extensibleThrowProxy := ctx.Eval(`
		new Proxy({}, {
			isExtensible() { throw new Error('isExtensible trap error') }
		})
	`)
	defer extensibleThrowProxy.Free()
	require.False(t, extensibleThrowProxy.IsException())
	require.False(t, extensibleThrowProxy.IsExtensible())

	preventThrowProxy := ctx.Eval(`
		new Proxy({}, {
			preventExtensions() { throw new Error('preventExtensions trap error') }
		})
	`)
	defer preventThrowProxy.Free()