/// <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);
}
