/// <summary> /// Allows the game to perform any initialization it needs to before starting to run. /// This is where it can query for any required services and load any non-graphic /// related content. Calling base.Initialize will enumerate through any components /// and initialize them as well. /// </summary> protected override void Initialize() { Client.ServiceLocator.RegisterService(new GraphicsDeviceService(this.GraphicsDevice)); Client.ServiceLocator.RegisterService(new ContentManagerService(this.Content)); Client.ServiceLocator.RegisterService(new LightManagerService(new PenumbraComponent(this))); Client.ServiceLocator.RegisterService(new NetHandler()); Client.ServiceLocator.RegisterService(new SceneManager()); Client.ServiceLocator.GetService <LightManagerService>().Component.Initialize(); _camera = new Camera(new Rectangle(0, 0, Settings.ResolutionX, Settings.ResolutionY)); EventInput.Initialize(this.Window); this.InitalizeScenes(); _consoleComponent = new ConsoleComponent(this); this.Components.Add(_consoleComponent); this.InitalizeCommands(); _consoleRedirector = new ConsoleRedirector(_consoleComponent); Console.SetOut(_consoleRedirector); Window.Title = Settings.GameName; base.Initialize(); }
/// <summary> /// Runs an execution analyzer in <see cref="AnalysisMode"/>. /// </summary> /// <param name="buildA"> /// The scheduler run to analyze /// </param> /// <param name="buildB"> /// Optional second scheduler run to analyze for modes that /// compare execution logs /// </param> /// <param name="additionalArgs"> /// Additional options applicable to only this particular analyzer run /// </param> /// <returns> /// string path to results file /// </returns> public AnalyzerResult RunAnalyzer(ScheduleRunResult buildA, ScheduleRunResult buildB = null, IEnumerable <Option> additionalArgs = null) { // The test class must set an analysis mode in the constructor XAssert.IsTrue(AnalysisMode != AnalysisMode.None); // The test class must set the default command line args in the constructor XAssert.IsTrue(ModeSpecificDefaultArgs != null); string[] commandLineArgs = BuildCommandLineArgs(buildA, buildB: buildB, additionalArgs: additionalArgs); // Run the analyzer with console output redirected to analyzer result var result = new AnalyzerResult(); using (var console = new ConsoleRedirector(ref result.StandardOutput)) { result.ExitCode = Program.Main(commandLineArgs); } if (ResultFileToRead != null) { XAssert.IsTrue(File.Exists(ResultFileToRead)); result.FileOutput = File.ReadAllText(ResultFileToRead); } return(result); }
/// <summary> /// Allows the game to perform any initialization it needs to before starting to run. /// This is where it can query for any required services and load any non-graphic /// related content. Calling base.Initialize will enumerate through any components /// and initialize them as well. /// </summary> protected override void Initialize() { Window.Title = Settings.GameName; Engine.Services.Register(new GraphicsDeviceService(this.GraphicsDevice)); Engine.Services.Register(new ContentManagerService(this.Content)); Engine.Services.Register(new LightManagerService(new PenumbraComponent(this))); Engine.Services.Register(new NetHandler()); Engine.Services.Register(new SceneManager()); Engine.Services.Get <LightManagerService>().Component.Initialize(); _camera = new Camera(new Rectangle(0, 0, Settings.ResolutionX, Settings.ResolutionY)); EventInput.Initialize(this.Window); this.InitalizeScenes(); _consoleComponent = new ConsoleComponent(this); _consoleComponent.FontColor = Color.Wheat; this.Components.Add(_consoleComponent); this.InitalizeCommands(); _consoleRedirector = new ConsoleRedirector(_consoleComponent); Console.SetOut(_consoleRedirector); GraphicsDevice.SamplerStates[0] = SamplerState.PointClamp; base.Initialize(); }
public void Setup() { Redirector = new ConsoleRedirector(); radius = 200; x = 150; y = 150; }
void Start() { ConsoleRedirector.Apply(); directoryViewButton.onClick.AddListener(OnClick); if (DebugCanvas) { DebugPanelText = DebugCanvas.transform.Find("DebugPanel").Find("Text").GetComponent <Text>(); } vertexSelector = UserObject.GetComponent <VertexSelector>(); }
//[DataRow(LinuxMuslX64)] //[DataRow(LinuxArm)] //[DataRow(LinuxArm64)] //[DataRow(WinArm64)] public async Task DefaultCliWorks(string rid) { using var console = new ConsoleRedirector(); var code = await MainEntry.Main(Array.Empty <string>()); Assert.AreEqual(2, code); this.AssertContainsCopyright(console.Lines); this.AssertContainsGitHashAndVersion(console.Lines); }
public void OneIsOne() { using (var cr = new ConsoleRedirector()) { Assert.IsFalse(cr.ToString().Contains("New text")); /* call some method that writes "New text" to stdout */ Console.Write("New text"); Assert.IsTrue(cr.GetString().Contains("New text")); } }
//[DataRow(LinuxArm)] //[DataRow(LinuxArm64)] //[DataRow(WinArm64)] public async Task DefaultHelpWorks(string rid) { using var console = new ConsoleRedirector(); var code = await MainEntry.Main(new[] { "--help" }); Assert.AreEqual(0, code); this.AssertContainsCopyright(console.Lines); this.AssertContainsGitHashAndVersion(console.Lines); StringAssert.StartsWith(console.Lines[6], Meta.Description); }
//[DataRow(LinuxMuslX64)] //[DataRow(LinuxArm)] //[DataRow(LinuxArm64)] //[DataRow(WinArm64)] public async Task DefaultVersionWorks(string rid) { using var console = new ConsoleRedirector(); var code = await MainEntry.Main(new[] { "--version" }); Assert.AreEqual(0, code); this.AssertContainsCopyright(console.Lines); this.AssertContainsGitHashAndVersion(console.Lines); StringAssert.StartsWith(console.Lines[3], BuildMetadata.VersionString); }
public MainFrame() { var consoleWriter = new ConsoleRedirector(); consoleWriter.TextWritten += (o, e) => ConsoleOutputTextBox.Dispatcher.Invoke(() => ConsoleOutputTextBox.AppendText(e.Text + "\n")); Console.SetOut(consoleWriter); InitializeComponent(); DataContext = this; }
public async Task CheckEnvironmentWorks() { using (var console = new ConsoleRedirector()) { var code = await MainEntry.Main(new[] { "CheckEnvironment" }); Assert.AreEqual(0, code); this.AssertContainsCopyright(console.Lines); this.AssertContainsGitHashAndVersion(console.Lines); StringAssert.Contains(console.Lines[4], "SUCCESS - Valid environment"); } }
protected void Start() { ConsoleRedirector.Apply(); string filename = string.Format("{0}/{1}", FLTPath, FLTFile); var flt = gameObject.AddComponent <OpenFlightRecordSet>(); flt.Init(filename, transform); flt.Parse(); flt.Finish(); //string filename = string.Format("{0}/{1}", FBXPath, FBXFile); //var fbx = FbxIO.ReadAscii(filename); }
private static void SegmentsCorrectly( string filename, string mimetype, TimeSpan start, TimeSpan end, TimeSpan maxVariance) { foreach (var util in new[] { TestHelper.GetAudioUtility() }) { var dir = PathHelper.GetTempDir(); var destMimeType = mimetype; if (mimetype == MediaTypes.MediaTypeWavpack) { destMimeType = MediaTypes.MediaTypeWav; } var output = new FileInfo( Path.Combine( dir.FullName, Path.GetFileNameWithoutExtension(filename) + "_segmented." + MediaTypes.GetExtension(destMimeType))); var audioUtilRequest = new AudioUtilityRequest { OffsetStart = start, OffsetEnd = end }; var input = PathHelper.GetTestAudioFile(filename); util.Modify(input, mimetype, output, destMimeType, audioUtilRequest); var utilInfoInput = util.Info(input); var utilInfoOutput = util.Info(output); var infoInput = GetDurationInfo(utilInfoInput); var infoOutput = GetDurationInfo(utilInfoOutput); var compareResult = "Expected duration " + (end - start) + " actual duration " + utilInfoOutput.Duration.Value + " expected max variation " + maxVariance + " actual variation " + (end - start).Subtract(utilInfoOutput.Duration.Value).Duration(); using (var cr = new ConsoleRedirector()) { LoggedConsole.WriteLine(compareResult); } Assert.IsTrue( TestHelper.CompareTimeSpans(utilInfoOutput.Duration.Value, end - start, maxVariance), compareResult + ". Info input: " + infoInput + "." + Environment.NewLine + "Info output: " + infoOutput); PathHelper.DeleteTempDir(dir); } }
//[DataRow(LinuxMuslX64)] //[DataRow(LinuxArm)] //[DataRow(LinuxArm64)] //[DataRow(WinArm64)] public async Task CheckEnvironmentWorks(string rid) { using var console = new ConsoleRedirector(); var code = await MainEntry.Main(new[] { "CheckEnvironment" }); Trace.WriteLine(console.Lines.Join(Environment.NewLine)); Assert.AreEqual(0, code); this.AssertContainsCopyright(console.Lines); this.AssertContainsGitHashAndVersion(console.Lines); if (IsMacOsX) { StringAssert.Contains(console.Lines[4], SoxAudioUtility.Mp3NotSupportedOnOSX); } StringAssert.Contains(console.Lines[^ 2], "SUCCESS - Valid environment");
static int Main(string[] args) { ScriptContext context = new ScriptContext(); using (ConsoleWithColors cout = new ConsoleWithColors(Environment.GetEnvironmentVariable("XSH_COLORS"))) using (ConsoleRedirector redir = new ConsoleRedirector(context)) using (CtrlCInterceptor ctrl = new CtrlCInterceptor()) { context.Output += cout.OnOutput; ctrl.Output = context.Error; ctrl.Abort += delegate { context.Abort(); }; cout.DebugMode = true; // context.Progress=console.OnOutputProgress; int exitCode = 0; try { var script = new Generated.$safeprojectname$().Script; ctrl.IgnoreCtrlC = script.IgnoreCtrlC; ctrl.AbortDelay = Utils.ToTimeSpan(script.AbortDelay) ?? ctrl.AbortDelay; ctrl.ExitDelay = Utils.ToTimeSpan(script.ExitDelay) ?? ctrl.ExitDelay; object o = context.ExecuteScript(script, args); if (o != null) { exitCode = Utils.To <int>(o); } } catch (ScriptTerminateException te) { exitCode = te.ExitCode; if (te.InnerException != null) { context.WriteException(te.InnerException); } } catch (Exception e) { context.WriteException(e); exitCode = -1; } return(exitCode); } }
private static void CalculatesCorrectDurationTest( string filename, string mediatype, TimeSpan expectedDuration, TimeSpan range) { foreach (var combined in new[] { TestHelper.GetAudioUtility() }) { var utilInfo = combined.Info(PathHelper.GetTestAudioFile(filename)); var info = GetDurationInfo(utilInfo); var compareResult = "Expected duration " + expectedDuration + " actual duration " + utilInfo.Duration + " expected max variation " + range + " actual variation " + expectedDuration.Subtract(utilInfo.Duration.HasValue ? utilInfo.Duration.Value : TimeSpan.Zero).Duration(); using (ConsoleRedirector cr = new ConsoleRedirector()) { LoggedConsole.WriteLine(compareResult); } Assert.IsTrue( TestHelper.CompareTimeSpans( utilInfo.Duration.HasValue ? utilInfo.Duration.Value : TimeSpan.Zero, expectedDuration, range), compareResult + ". Info: " + info); } }
public void Setup() { SUT = new Circle(); Redirector = new ConsoleRedirector(); }
private void Awake() { ConsoleRedirector.Redirect(); this.Simulation.Name = this.name; }
public static void Run(string[] args) { if (args.Length == 0 || !args[0].EndsWith(".game") || !File.Exists(args[0])) { Console.WriteLine("Could not load Game File: " + (args.Length == 0 ? "" : Path.GetFullPath(args[0]))); return; } SetUpDirectoryStructure(); IPackageManifest pm = null; try { pm = Creator.ReadManifest(args[0]); Console.Title = pm.Title; string path = pm.Version; if (EnginePlayerConsole.EngineVersion != null) { path = EnginePlayerConsole.EngineVersion; } LoadEngine(path); //Load Game LoadGame(args[0], pm); } catch (Exception e) { Directory.Delete(EnginePlayerConsole.GameTempDir, true); Directory.Delete(EnginePlayerConsole.GameDir, true); Console.WriteLine("Error Unpacking File."); Console.WriteLine(e); } string startCommand = "-c \"" + pm.StartCommand + "\""; string cli = "/bin/bash"; if (Type.GetType("Mono.Runtime") == null) //Not Running Mono = Windows, Running Mono = Linux { startCommand = "/C " + pm.StartCommand; cli = "cmd.exe"; } _p = new Process(); ProcessStartInfo psi = new ProcessStartInfo { FileName = cli, RedirectStandardError = true, RedirectStandardOutput = true, UseShellExecute = false, CreateNoWindow = true, Arguments = startCommand, WorkingDirectory = EnginePlayerConsole.GameDir }; _p.StartInfo = psi; _p.Start(); ConsoleRedirector crd = ConsoleRedirector.CreateRedirector(_p.StandardOutput, _p.StandardError, _p, Console.WriteLine); crd.StartThreads(); while (!_p.HasExited) { Thread.Sleep(150); } crd.StopThreads(); Console.WriteLine(crd.GetRemainingLogs()); Directory.Delete(EnginePlayerConsole.GameDir, true); }
public static void detatch() { _instance.Dispose(); _instance = null; }
public void Setup() { SUT = new Rectangle(); Redirector = new ConsoleRedirector(); }
public void Setup() { Redirector = new ConsoleRedirector(); }
protected void Start() { ConsoleRedirector.Apply(); //var userObject = GameObject.Find("UserObject"); string databasePath = YemenCDB; var databaseGameObject = Instantiate(DatabasePrefab); Database = databaseGameObject.GetComponent <Database>(); Database.Path = databasePath; modelManager = Database.ModelManager; materialManager = Database.MaterialManager; meshManager = Database.MeshManager; var path = databasePath + "/GTModel/500_GTModelGeometry"; //var path = databasePath + "/Tiles"; var di = new DirectoryInfo(path); WalkDirectoryTree(di, LoadFLT); int count = gameObjects.Count; if (count >= 1) { int width = (int)Mathf.Sqrt(count); int length = count / width; int remainder = count % width; int separation = 100; if (randomPlacement) { foreach (var gameObject in gameObjects) { gameObject.transform.position = new Vector3(Random.Range(-width * separation / 2, width * separation / 2), Random.Range(-separation / 2f, separation / 2f), Random.Range(-length * separation / 2, length * separation / 2)); } } else { for (int w = 0; w < width; ++w) { for (int h = 0; h < length; ++h) { gameObjects[w * length + h].transform.position = new Vector3(w * separation, 0f, h * separation); } } for (int r = 0; r < remainder; ++r) { gameObjects[width * length + r].transform.position = new Vector3(width * separation, 0f, r * separation); } } } foreach (var gameObject in gameObjects) { modelManager.Add(gameObject.GetComponent <Model>()); } //userObject.transform.position = new Vector3(-100f, 100f, -100f); //userObject.transform.rotation = Quaternion.LookRotation(new Vector3(1f, -1f, 1f), Vector3.up); }
public static void attach(ProgressChangedEventHandler handler, bool forceConsoleRedirection) { Debug.Assert(null == _instance); _instance = new ConsoleRedirector(handler, forceConsoleRedirection); }
private static void ConvertsCorrectly( string filename, string mimetype, string outputMimeType, TimeSpan expectedDuration, TimeSpan maxVariance, AudioUtilityRequest customRequest = null) { foreach (var util in new[] { TestHelper.GetAudioUtility() }) { var dir = PathHelper.GetTempDir(); var output = dir.CombineFile( Path.GetFileNameWithoutExtension(filename) + "_converted." + MediaTypes.GetExtension(outputMimeType)); var audioUtilRequest = customRequest ?? new AudioUtilityRequest { }; var input = PathHelper.GetTestAudioFile(filename); util.Modify(input, mimetype, output, outputMimeType, audioUtilRequest); var utilInfoOutput = util.Info(output); var infoOutput = GetDurationInfo(util.Info(output)); var compareResult = "Expected duration " + expectedDuration + " actual duration " + utilInfoOutput.Duration + " expected max variation " + maxVariance + " actual variation " + expectedDuration.Subtract( utilInfoOutput.Duration.HasValue ? utilInfoOutput.Duration.Value : TimeSpan.Zero) .Duration(); using (ConsoleRedirector cr = new ConsoleRedirector()) { LoggedConsole.WriteLine(compareResult); } var message = $"{compareResult}.{Environment.NewLine}Info output: {infoOutput}"; Assert.IsTrue( TestHelper.CompareTimeSpans(expectedDuration, utilInfoOutput.Duration.Value, maxVariance), message); var info = util.Info(output); PathHelper.DeleteTempDir(dir); /* * var sb = new StringBuilder(); * foreach (var item in info) * { * sb.AppendLine(item.Key + ": " + item.Value); * } */ if (info?.RawData != null && info.RawData.ContainsKey("STREAM codec_long_name")) { var codec = info.RawData["STREAM codec_long_name"]; if (outputMimeType == MediaTypes.MediaTypeWav) { Assert.IsTrue(codec == MediaTypes.CodecWavPcm16BitLe); } else if (outputMimeType == MediaTypes.MediaTypeOggAudio) { Assert.IsTrue(codec == MediaTypes.CodecVorbis); } else if (outputMimeType == MediaTypes.MediaTypeMp3) { Assert.IsTrue(codec == MediaTypes.CodecMp3); } else if (outputMimeType == MediaTypes.MediaTypeWebMAudio) { Assert.IsTrue(codec == MediaTypes.CodecVorbis); } else { Assert.IsTrue(codec == MediaTypes.ExtUnknown); } } } }
static int MainWithContext(ScriptContext context, string[] args) { CommandLineParameters xsParams = getXsParams(); int exitCode = 0; ConsoleRedirector redir = null; AppDomainLoader.progress("MainWithContext: Entering --------------------"); bool utf8 = false; foreach (string arg in args) { if (arg.Equals(xs.utf8.Replace("xs.", "//"), StringComparison.OrdinalIgnoreCase)) { utf8 = true; } } using (ConsoleWithColors cout = new ConsoleWithColors(Environment.GetEnvironmentVariable("XSH_COLORS"), utf8)) using (CtrlCInterceptor ctrl = new CtrlCInterceptor()) { context.Output += cout.OnOutput; ctrl.Output = context.Error; ctrl.Abort += delegate { context.Abort(); }; Stopwatch w = Stopwatch.StartNew(); try { // Parse arguments var usage = new UsageGenerator() { Options = UsageOptions.None }; xsParams.Parse(context, args, false); setOutputOptions(context, cout); if (context.IsSet(xs.path)) { context.ScriptPath = context.GetString(xs.path); } // Load references List <IScriptAction> preScript = getCommandlineReferences(context); // Print help if (args.Length == 0 || context.IsSet(xs.help)) { loadReferences(context, preScript); exitCode = HelpHelper.Help(context, usage, xsParams); goto end; } // Handle upgrade if (context.GetBool(xs.upgrade, false)) { return(upgrade(context)); } if (context.IsSet(xs.updateStage)) { return(updateStage(context, context.GetStringArray(xs.updateStage))); } AppDomainLoader.progress("MainWithContext: Processing options"); // Process the remaining options context.Compiler.AddRequireAdmin(Utils.To <RequireAdminMode>(context.GetStr(xs.requireAdmin, RequireAdminMode.User.ToString()))); if (context.IsSet(xs.codeout)) { context.CodeOutputDirectory = Path.GetFullPath(context.GetString(xs.codeout)); } if (context.IsSet(xs.genconfig) || context.IsSet(xs.gensample)) { genDemoConfig(cout, context); } if (context.IsSet(xs.forcenet20)) { context.Compiler.DefaultNETVersion = new Version(2, 0); } AppDomainLoader.progress("MainWithContext: Processing options, continuing"); List <string> filteredArgs = new List <string>(); if (context.IsSet(xs.scriptargs)) { filteredArgs.AddRange(context.GetStringArray(xs.scriptargs)); } // Run utilities, like //download etc Script script = getInlineScript(context, filteredArgs); string scriptName = context.GetString(xs.script, null); if (script == null) { // Load the script if (scriptName == "/?" || scriptName == "-?") { for (int i = 0; i < args.Length; ++i) { if (args[i] == "/?" || args[i] == "-?") { if (i != args.Length - 1) { context[xs.help] = args[i + 1]; } break; } } loadReferences(context, preScript); return(HelpHelper.Help(context, usage, xsParams)); } if (scriptName != null) { AppDomainLoader.progress("MainWithContext: Loading script " + scriptName); script = loadScript(scriptName, context); AppDomainLoader.progress("MainWithContext: Loading completed"); } } AppDomainLoader.progress("MainWithContext: About to initialize"); // Attach script if (script != null) { // Insert pre-script before the script body int n = 0; foreach (var list in preScript) { script.Items.Insert(n++, list); } AppDomainLoader.BaseDirectory = script.DirectoryName; RequireAdminMode mode = context.Compiler.RequireAdmin; if ((!context.IsAdministrator || context.GetBool(xs.testElevation, false)) && !isCodeGeneration(context) && mode != RequireAdminMode.User) { return(restartAsAdmin(context, args, mode == RequireAdminMode.Hidden && !(context.GetBool(xs.testElevation, false)))); } AppDomainLoader.progress("MainWithContext: Before script initialization"); if (isCodeGeneration(context)) { if (!context.EnableCodePrecompilation && (context.IsSet(xs.genexe) || context.IsSet(xs.genwinexe) || context.IsSet(xs.genlibrary) || context.IsSet(xs.gencs))) { throw new ParsingException("One of the loaded scripts has precompilation disabled. Executable cannot be generated from this script."); } context.EnableCodePrecompilation = false; } ctrl.IgnoreCtrlC = script.IgnoreCtrlC; ctrl.AbortDelay = Utils.ToTimeSpan(script.AbortDelay) ?? ctrl.AbortDelay; ctrl.ExitDelay = Utils.ToTimeSpan(script.ExitDelay) ?? ctrl.ExitDelay; context.Initialize(script); AppDomainLoader.progress("MainWithContext: Script initialization completed"); } // After precompilation we're ready to write .exe, if requested if (isCodeGeneration(context)) { doCodeGeneration(context, script); } else if (script != null) { // Run the script AppDomainLoader.progress("MainWithContext: Before script execution"); redir = new ConsoleRedirector(context); try { object r = context.ExecuteScript(script, filteredArgs.ToArray(), CallIsolation.High); if (r != null) { int.TryParse(r.ToString(), out exitCode); } } finally { ctrl.KillAbortTimer(); redir.Dispose(); redir = null; } AppDomainLoader.progress("MainWithContext: Script execution completed"); } } catch (ThreadAbortException ae) { AppDomainLoader.progress("MainWithContext: ThreadAbortException is being aborted"); resetAbort(context); context.WriteException(ae); exitCode = -1; } catch (ScriptTerminateException te) { exitCode = te.ExitCode; resetAbort(context); if (te.InnerException != null) { context.WriteException(te.InnerException); AppDomainLoader.progress("MainWithContext: " + te.InnerException); } AppDomainLoader.progress("MainWithContext: Terminating with exit code " + exitCode); } catch (Exception e) { exitCode = -1; resetAbort(context); context.WriteException(e); AppDomainLoader.progress("MainWithContext: " + e); } finally { resetAbort(context); AppDomainLoader.BaseDirectory = null; } end: // Display how long did it take w.Stop(); if (context.GetBool(xs.wait, false)) { cout.WriteLine(OutputType.Info, string.Format("Completed in {0} with exit code={1}. Press Enter to close...", w.Elapsed, exitCode)); Console.ReadLine(); } } AppDomainLoader.progress("MainWithContext: Exiting with code " + exitCode); return(exitCode); }