public void JsSerializedScriptCanBeParsedWithCallbacks()
        {
            if (CommonWindowsEngine == null)
            {
                return;
            }

            var    script    = "(()=>{return 6*7;})()";
            string sourceUrl = "[eval code]";

            bool loaded   = false;
            bool unloaded = false;

            using (var runtimeHandle = Engine.JsCreateRuntime(JavaScriptRuntimeAttributes.None, null))
            {
                using (var contextHandle = Engine.JsCreateContext(runtimeHandle))
                {
                    Engine.JsSetCurrentContext(contextHandle);

                    byte[] buffer     = new byte[1024];
                    uint   bufferSize = (uint)buffer.Length;

                    CommonWindowsEngine.JsSerializeScript(script, buffer, ref bufferSize);

                    JavaScriptSerializedScriptLoadSourceCallback loadCallback = (JavaScriptSourceContext sourceContext, out StringBuilder scriptBuffer) =>
                    {
                        loaded       = true;
                        scriptBuffer = new StringBuilder(script);
                        return(true);
                    };

                    JavaScriptSerializedScriptUnloadCallback unloadCallback = (JavaScriptSourceContext sourceContext) =>
                    {
                        unloaded = true;
                    };

                    var fnHandle = CommonWindowsEngine.JsParseSerializedScriptWithCallback(loadCallback, unloadCallback, buffer, JavaScriptSourceContext.GetNextSourceContext(), sourceUrl);
                    Assert.NotEqual(JavaScriptValueSafeHandle.Invalid, fnHandle);

                    var handleType = Engine.JsGetValueType(fnHandle);
                    Assert.True(handleType == JsValueType.Function);

                    //Get the string representation of the function. This triggers the load callback.
                    var fnStringHandle = Engine.JsConvertValueToString(fnHandle);
                    var stringPtr      = CommonWindowsEngine.JsStringToPointer(fnStringHandle, out ulong length);
                    Assert.True(stringPtr != IntPtr.Zero);
                    Assert.True(length > 0);

                    fnStringHandle.Dispose();
                    fnHandle.Dispose();
                }
                Engine.JsCollectGarbage(runtimeHandle);
            }

            Assert.True(loaded);
            Assert.True(unloaded);
        }
Exemple #2
0
        public static string GetStringUtf8(this IJavaScriptEngine jsrt, JavaScriptValueSafeHandle stringHandle, bool autoConvert = false)
        {
            bool stringHandleWasCreated = false;

            if (stringHandle == null || stringHandle == JavaScriptValueSafeHandle.Invalid)
            {
                throw new ArgumentNullException(nameof(stringHandle));
            }

            //If Auto Convert is specified, ensure that the type is a string, otherwise convert it.
            if (autoConvert)
            {
                var handleValueType = jsrt.JsGetValueType(stringHandle);

                if (handleValueType != JsValueType.String)
                {
                    var convertedToStringHandle = jsrt.JsConvertValueToString(stringHandle);

                    stringHandle           = convertedToStringHandle;
                    stringHandleWasCreated = true;
                }
            }

            //Get the size
            var size = jsrt.JsCopyString(stringHandle, null, 0);

            if ((int)size > int.MaxValue)
            {
                throw new OutOfMemoryException("Exceeded maximum string length.");
            }

            byte[] result  = new byte[(int)size];
            var    written = jsrt.JsCopyString(stringHandle, result, (ulong)result.Length);

            var strResult = Encoding.UTF8.GetString(result, 0, result.Length);

            if (stringHandleWasCreated)
            {
                stringHandle.Dispose();
            }

            return(strResult);
        }