Example #1
0
        protected override async Task <ExitCode> InvokeInternal(ILogger logger)
        {
            var processManager = ProcessManagerFactory.CreateProcessManager();

            var engineBinary = _arguments.Engine switch
            {
                JavaScriptEngine.V8 => "v8",
                JavaScriptEngine.JavaScriptCore => "jsc",
                JavaScriptEngine.SpiderMonkey => "sm",
                _ => throw new ArgumentException()
            };

            var engineArgs = new List <string>();

            if (_arguments.Engine == JavaScriptEngine.V8)
            {
                // v8 needs this flag to enable WASM support
                engineArgs.Add("--expose_wasm");
            }

            engineArgs.AddRange(_arguments.EngineArgs);
            engineArgs.Add(_arguments.JSFile);

            if (_arguments.Engine == JavaScriptEngine.V8 || _arguments.Engine == JavaScriptEngine.JavaScriptCore)
            {
                // v8/jsc want arguments to the script separated by "--", others don't
                engineArgs.Add("--");
            }

            engineArgs.AddRange(PassThroughArguments);

            var xmlResultsFilePath = Path.Combine(_arguments.OutputDirectory, "testResults.xml");

            File.Delete(xmlResultsFilePath);

            try
            {
                var logProcessor = new WasmTestMessagesProcessor(xmlResultsFilePath, logger);
                var result       = await processManager.ExecuteCommandAsync(
                    engineBinary,
                    engineArgs,
                    log : new CallbackLog(m => logger.LogInformation(m)),
                    stdoutLog : new CallbackLog(logProcessor.Invoke)
                {
                    Timestamp = false                                                   /* we need the plain XML string so disable timestamp */
                },
                    stderrLog : new CallbackLog(m => logger.LogError(m)),
                    _arguments.Timeout);

                return(result.Succeeded ? ExitCode.SUCCESS : (result.TimedOut ? ExitCode.TIMED_OUT : ExitCode.GENERAL_FAILURE));
            }
            catch (Win32Exception e) when(e.NativeErrorCode == 2)
            {
                logger.LogCritical($"The engine binary `{engineBinary}` was not found");
                return(ExitCode.APP_LAUNCH_FAILURE);
            }
        }
    }
Example #2
0
    public async Task ProcessShouldBeKilled()
    {
        var pm = ProcessManagerFactory.CreateProcessManager();

        var process = new Process();

        process.StartInfo.FileName  = "ping";
        process.StartInfo.Arguments = "-t 127.0.0.1";
        var log = new MemoryLog();

        var result = await pm.RunAsync(process, log, TimeSpan.FromSeconds(3));

        Assert.True(result.TimedOut);
    }