internal static void Dump <T>(VirtualConsole console, IEnumerable <T> enumerable, IEnumerable <Column <T> > columns) { var fmt = ""; var tit = new List <object>(); var i = 0; foreach (var column in columns) { fmt += "{" + i + "," + column.Width + "}"; tit.Add(column.Title); i++; } console.WriteLine(string.Format(fmt, tit.ToArray())); foreach (var item in enumerable) { var l = new List <object>(); foreach (var column in columns) { l.Add(column.m(item)); } console.WriteLine(string.Format(fmt, l.ToArray())); } }
public static async ValueTask <(int exitCode, MemoryStreamWriter stdOut, MemoryStreamWriter stdErr)> BuildAndRunTestAsync(this CliApplicationBuilder applicationBuilder, ITestOutputHelper testOutput, IReadOnlyList <string> commandLineArguments, IReadOnlyDictionary <string, string> environmentVariables, bool isInputRedirected = true, string?input = null) { var(console, stdIn, stdOut, stdErr) = VirtualConsole.CreateBufferedWithInput(isInputRedirected: isInputRedirected); CliApplication application = applicationBuilder.UseConsole(console) .Build(); if (input is not null) { stdIn.WriteString(input.TrimEnd('\r') + "\rexit\r"); } int exitCode = await application.RunAsync(commandLineArguments, environmentVariables); testOutput.WriteLine("Exit Code: {0}", exitCode); testOutput.Print(stdOut, stdErr); return(exitCode, stdOut, stdErr); }
public async Task Default_command_is_executed_if_provided_arguments_do_not_match_any_named_command() { // Arrange await using var stdOut = new MemoryStream(); var console = new VirtualConsole(output: stdOut); var application = new CliApplicationBuilder() .AddCommand(typeof(DefaultCommand)) .AddCommand(typeof(ConcatCommand)) .AddCommand(typeof(DivideCommand)) .UseConsole(console) .Build(); // Act var exitCode = await application.RunAsync( Array.Empty <string>(), new Dictionary <string, string>()); var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd(); // Assert exitCode.Should().Be(0); stdOutData.Should().Be("Hello world!"); }
public void Application_can_be_created_with_VirtualConsole_MemoryStreamWriter() { // Arrange IConsole console = new VirtualConsole(output: new MemoryStreamWriter(), isOutputRedirected: false, error: new MemoryStreamWriter(Encoding.UTF8), isErrorRedirected: true); // Act var app = new CliApplicationBuilder() .AddCommand <DefaultCommand>() .AddCommandsFrom(typeof(DefaultCommand).Assembly) .AddCommands(new[] { typeof(DefaultCommand) }) .AddCommandsFrom(new[] { typeof(DefaultCommand).Assembly }) .AddCommandsFromThisAssembly() .AddDirectivesFrom(new[] { typeof(DefaultCommand).Assembly }) .AddDirective <DebugDirective>() .AddDirective <PreviewDirective>() .AddDirective <CustomInteractiveModeOnlyDirective>() .AddDirective <CustomDirective>() .UseConsole(console) .Build(); // Assert app.Should().NotBeNull(); }
public async Task Help_text_is_printed_if_provided_arguments_contain_the_help_option() { // Arrange var(console, stdOut, _) = VirtualConsole.CreateBuffered(); var application = new CliApplicationBuilder() .AddCommand <DefaultCommand>() .AddCommand <NamedCommand>() .AddCommand <NamedSubCommand>() .UseConsole(console) .Build(); // Act int exitCode = await application.RunAsync(new[] { "--help" }); // Assert exitCode.Should().Be(ExitCodes.Success); stdOut.GetString().Should().ContainAll( "Default command description", "Usage" ); _output.WriteLine(stdOut.GetString()); }
public async Task Help_text_is_printed_if_no_arguments_were_provided_and_default_command_is_not_defined() { // Arrange await using var stdOut = new MemoryStream(); var console = new VirtualConsole(output: stdOut); var application = new CliApplicationBuilder() .AddCommand(typeof(ConcatCommand)) .AddCommand(typeof(DivideCommand)) .UseConsole(console) .UseDescription("This will be visible in help") .Build(); // Act var exitCode = await application.RunAsync( Array.Empty <string>(), new Dictionary <string, string>()); var stdOutData = console.Output.Encoding.GetString(stdOut.ToArray()).TrimEnd(); // Assert exitCode.Should().Be(0); stdOutData.Should().Contain("This will be visible in help"); }
static void Main(string[] args) { Console.Title = "Simple Curses Example"; Console.CursorVisible = false; Console.OutputEncoding = System.Text.Encoding.UTF8; var virtualConsole = VirtualConsole.Create(); currentController = new HomeController(); while (!virtualConsole.Ended) { virtualConsole.Update(currentController.CurrentView().GetRenderable()); if (Console.KeyAvailable) { currentController.CurrentView().HandleKeyPress(Console.ReadKey(true)); } Thread.Sleep(1); } Console.ReadKey(); }
public async Task Named_command_should_execute_even_when_default_takes_a_parameter() { // Arrange var(console, stdOut, _) = VirtualConsole.CreateBuffered(); var application = new CliApplicationBuilder() .AddCommand <DefaultCommandWithParameter>() .AddCommand <NamedCommand>() .UseConsole(console) .AddDirective <DefaultDirective>() .Build(); // Act int exitCode = await application.RunAsync( new[] { "named" }, new Dictionary <string, string>()); // Assert exitCode.Should().Be(ExitCodes.Success); stdOut.GetString().Should().NotBeNullOrWhiteSpace(); stdOut.GetString().Should().Contain(NamedCommand.ExpectedOutputText); _output.WriteLine(stdOut.GetString()); }
protected internal abstract void Draw(VirtualConsole console);
public void FileSystem_IsAtty_ReflectsContextState() { Assert.AreEqual(MainApplicationContext.Current.IsAtty, VirtualConsole.IsAtty()); }
private void DrawCards() { VirtualConsole.DrawBox(0, 0, VirtualConsole.instance.width - 1, 15); DrawIndividualCards(); }
private void DrawLog() { VirtualConsole.DrawBox(47, 16, VirtualConsole.instance.width - 48, 7); DrawLogMessages(); }
protected ExampleBase() { Console = new VirtualConsole(); }
protected virtual void TaskComplete() { VirtualConsole.Log("Task completed"); running = false; }
/***************************************************************************************************** * Session 1 Touchpanel Events setup, adding page flips and basic logic *****************************************************************************************************/ // This is where our Touchpanel Signal changes are processed. Digitals, Analogs, and Serials All end up here. private void MyXpanel_SigChange(BasicTriList currentDevice, SigEventArgs args) { VirtualConsole.Send(String.Format("TP Sig Change Type={0} Number={1} State={2}", args.Sig.Type, args.Sig.Number, args.Sig.BoolValue), true); // Question: What is all this? What does {0} mean? // and yes a line can be on 2 lines // Answer: Look up String.Format and read up on the specifier string. This is like the Trace and MakeString in Simpl Plus. // Important to split it like this for more flexibility. Check if it's a digital, then anything below is for digitals if (args.Sig.Type == eSigType.Bool) // Is it a digital? { //SESSION 1: Create a Momentary Button (This has to be outside the check if true below) if (args.Sig.Number == 11) { // This passes the button events back to the feedback myXpanel.BooleanInput[11].BoolValue = args.Sig.BoolValue; // we want both the press and release here } //SESSION 1: Check if it is pressed if (args.Sig.BoolValue == true) // Look for only pressed button events { // Page Navigation Session 1: Instructor put in the first page nav code The rest are student lab switch (args.Sig.Number) { case 1: myXpanel.BooleanInput[1].BoolValue = true; // Traditional way of setting it high then low myXpanel.BooleanInput[1].BoolValue = false; myXpanel.StringInput[1].StringValue = "Front Page"; break; case 2: myXpanel.BooleanInput[2].Pulse(); // using the built in method to pulse it myXpanel.StringInput[1].StringValue = "Projector"; break; case 3: myXpanel.BooleanInput[3].Pulse(); myXpanel.StringInput[1].StringValue = "Phone Book"; break; } /****************************************************************************************** * Session 1 Lab work below (Momentary is above outside the "true" check for boolvalue) ******************************************************************************************/ // Create a Toggle Button if (args.Sig.Number == 10) { // We read the current feedback and use the compliment or NOT by using ! to toggle between states myXpanel.BooleanInput[10].BoolValue = !myXpanel.BooleanInput[10].BoolValue; // Invert The Feedback } // Interlock with simple Logic. Pay attention to the join numbers used /* * switch(args.Sig.Number) * { * case 12: * myXpanel.BooleanInput[13].BoolValue = false; * myXpanel.BooleanInput[14].BoolValue = false; * myXpanel.BooleanInput[12].BoolValue = true; * break; * * case 13: * myXpanel.BooleanInput[12].BoolValue = false; * myXpanel.BooleanInput[14].BoolValue = false; * myXpanel.BooleanInput[13].BoolValue = true; * break; * * case 14: * myXpanel.BooleanInput[12].BoolValue = false; * myXpanel.BooleanInput[13].BoolValue = false; * myXpanel.BooleanInput[14].BoolValue = true; * break; * } */ //Interlock leveraging the power of a method if (args.Sig.Number >= 12 && args.Sig.Number <= 14) // We only want joins 12,13,14 { Interlock(myXpanel.BooleanInput, 12, 14, args.Sig.Number); // Look for this custom method below } /********************************************************************************************** * Session 2 **********************************************************************************************/ // #### Projector Button Press Logic // #### All of this SHOULD exist in a method or even another class to make the code more manageable and organized // // We are still inside the pair of IF statements for "was this a boolean(digital) and was it true(pressed) // Nested If statements can get complex and hard to navigate quickly. ProjectorButtonPress(args.Sig.Number); // Call our method below // Hidden Challenge: Make the projector Connect when it is on the projector Page, // and Disconnect when the user leaves the projector page. // Second hidden Challenge: Do not use join numbers but instead use an enum with names // so you can easily remap to different buttons /******************************************************************************************** * Session 3 ********************************************************************************************/ // File Read and Sort button management Methods start down near line 370 switch (args.Sig.Number) { case 30: LoadFile(); // Call our method to load the file and display the contents break; case 31: SortFile(); // Call our method to sort the strings and present them break; } } } }
public ColorConsoleTraceListener(int identLevel) { _console = new VirtualConsole(22, Console.WindowHeight); _il = identLevel; }
public void ColorBlock(int x, int y, float r, float g, float b) { VirtualConsole.ColorBlock(x - instance.posX + VirtualConsole.instance.width / 2, y - instance.posY + ((VirtualConsole.instance.height - 15) / 2) + 15, r, g, b); }
// Start is called before the first frame update void Start() { instance = this; backgroundBlocks = new SpriteRenderer[width, height]; letters = new TextMesh[width, height]; for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { float xPos = (xOffset * 2 * (x + 1) / (width + 1)) - xOffset; float yPos = (yOffset * 2 * (y + 1) / (height + 1)) - yOffset; var go = Instantiate(bgPrefab); go.GetComponent <MapBlockMouseControls>().x = x; go.GetComponent <MapBlockMouseControls>().y = y; go.transform.position = new Vector3(xPos, yPos, -0.25f); go.transform.SetParent(letterCollection.transform); backgroundBlocks[x, y] = go.GetComponent <SpriteRenderer>(); if (testMode) { float randomR = Random.Range(0f, 1f); float randomG = Random.Range(0f, 1f); float randomB = Random.Range(0f, 1f); backgroundBlocks[x, y].color = new Color(randomR, randomG, randomB); } else { backgroundBlocks[x, y].color = new Color(0, 0, 0); } var go2 = Instantiate(textPrefab); go2.transform.position = new Vector3(xPos, yPos, -0.25f); go2.transform.SetParent(letterCollection.transform); letters[x, y] = go2.GetComponent <TextMesh>(); if (testMode) { int randomLetter = Random.Range(0, 52); if (randomLetter < 26) { letters[x, y].text = ((char)('a' + randomLetter)).ToString(); } else { letters[x, y].text = ((char)('A' + randomLetter - 26)).ToString(); } } else { letters[x, y].text = " "; } if (testMode) { float randomR = Random.Range(0f, 1f); float randomG = Random.Range(0f, 1f); float randomB = Random.Range(0f, 1f); letters[x, y].color = new Color(randomR, randomG, randomB); } else { letters[x, y].color = new Color(1, 1, 1); } } } }
protected void GenerateOutputs(float[] variableValues) { //VirtualConsole.Log ("Executing code..."); string codeToRun = (inTestMode) ? testCodeText : code; compiler = new VirtualCompiler(codeToRun); compiler.availableFuncsWthoutReturnV.Add("testMethod", testMethod); compiler.AddOutputFunction("testMethod2"); for (int i = 0; i < taskInfo.outputs.Length; i++) { compiler.AddOutputFunction(taskInfo.outputs[i].name); } for (int i = 0; i < taskInfo.constants.Length; i++) { compiler.AddInput(taskInfo.constants[i].name, taskInfo.constants[i].value); } for (int i = 0; i < variableValues.Length; i++) { compiler.AddInput(taskInfo.variables[i], variableValues[i]); } //VirtualConsole.LogInputs (inputNames, inputValues); List <VirtualFunction> outputs = compiler.Run(); if (outputs.Count > 0) { foreach (VirtualFunction vFunc in outputs) { //object[] mParams = new object[vFunc.values.Count]; //Array.Copy(vFunc.values.ToArray(), mParams, vFunc.values.Count); if (vFunc.delFunc != null) { vFunc.delFunc.Invoke(this, null); } if (vFunc.FunctionWithoutParam != null && vFunc.FunctionWithParam != null) { if (vFunc.values.Count <= 1) { vFunc.FunctionWithoutParam.Invoke(); } else { string vFuncReturnValue = vFunc.FunctionWithParam.Invoke(vFunc.values[0].ToString()); } } } float val = 0; if (outputs[0].values.Count > 0 && outputs[0].values[0] is float) { val = (float)outputs[0].values[0]; } var func = new Function() { name = outputs[0].name, value = val }; outputQueue.Enqueue(func); VirtualConsole.LogOutput(func.name, func.value); } }
public void StartTask(string code) { this.code = code; StartCoroutine(StartTaskRoutine()); VirtualConsole.Clear(); }
public int Execute(string argString) { using (MainApplicationContext.AcquireCurrentThread()) { var envp = VirtualEnvironment.GetEnvironmentVariables(); var args = CommandLine.PreprocessSingleQuotes(argString); int status = 1; // The very first thing we do is handle some very special command-line // options, since they affect how the environment is setup: // // --verify ; turns on memory tracing // --verbose ; turns on logging // --debug CATEGORY ; turns on debug logging // --trace LEVEL ; turns on trace logging // --memory ; turns on memory usage tracing // --init-file ; directs ledger to use a different init file GlobalScope.HandleDebugOptions(args); // initialize_memory_tracing - [DM] #memory-tracing Logger.Current.Info(() => LedgerStarting); // ::textdomain("ledger"); - [DM] #localization GlobalScope globalScope = null; try { // Create the session object, which maintains nearly all state relating to // this invocation of Ledger; and register all known journal parsers. globalScope = new GlobalScope(envp); globalScope.Session.FlushOnNextDataFile = true; // Look for options and a command verb in the command-line arguments BindScope boundScope = new BindScope(globalScope, globalScope.Report); args = globalScope.ReadCommandArguments(boundScope, args); if (globalScope.ScriptHandler.Handled) { // Ledger is being invoked as a script command interpreter globalScope.Session.ReadJournalFiles(); status = 0; using (StreamReader sr = FileSystem.GetStreamReader(globalScope.ScriptHandler.Str())) { while (status == 0 && !sr.EndOfStream) { string line = sr.ReadLine().Trim(); if (!line.StartsWith("#")) { status = globalScope.ExecuteCommandWrapper(StringExtensions.SplitArguments(line), true); } } } } else if (args.Any()) { // User has invoke a verb at the interactive command-line status = globalScope.ExecuteCommandWrapper(args, false); } else { // Commence the REPL by displaying the current Ledger version VirtualConsole.Output.WriteLine(globalScope.ShowVersionInfo()); globalScope.Session.ReadJournalFiles(); bool exitLoop = false; VirtualConsole.ReadLineName = "Ledger"; string p; while ((p = VirtualConsole.ReadLine(globalScope.PromptString())) != null) { string expansion = null; int result = VirtualConsole.HistoryExpand(p.Trim(), ref expansion); if (result < 0 || result == 2) { throw new LogicError(String.Format(LogicError.ErrorMessageFailedToExpandHistoryReference, p)); } else if (expansion != null) { VirtualConsole.AddHistory(expansion); } CancellationManager.CheckForSignal(); if (!String.IsNullOrWhiteSpace(p) && p != "#") { if (String.Compare(p, "quit", true) == 0) { exitLoop = true; } else { globalScope.ExecuteCommandWrapper(StringExtensions.SplitArguments(p), true); } } if (exitLoop) { break; } } status = 0; // report success } } catch (CountError errors) { // used for a "quick" exit, and is used only if help text (such as // --help) was displayed status = errors.Count; } catch (Exception err) { if (globalScope != null) { globalScope.ReportError(err); } else { VirtualConsole.Error.WriteLine(String.Format(ExceptionDuringInitialization, err.Message)); } } if (globalScope != null) { globalScope.QuickClose(); globalScope.Dispose(); // {DM] It is the most appropriate place to call Dispose for the global scope. } Logger.Current.Info(() => LedgerEnded); // let global_scope leak! // Return the final status to the operating system, either 1 for error or 0 // for a successful completion. return(status); } }
// This is how you create a Virtual Console Command Method: This is a freebie that is not a part of the Masters Session private string TestFunc(string s) { VirtualConsole.Send(string.Format("Test Command line Called and after it was sent {0}", s)); return(""); //return an empty string. }
protected virtual void TestFailed() { running = false; VirtualConsole.LogTaskFailed(); }
public static void Main(string[] args) { var idbuf = new byte[16]; new Random().NextBytes(idbuf); var id = new BotIdentifier(idbuf); var listenPort = 33333; var peers = new List <PeerInfo>(); foreach (var arg in args) { var v = arg.Substring(1); switch (arg[0]) { case 'p': int.TryParse(v, out listenPort); break; case 'c': foreach (var peerInfo in v.Split(new[] { ';' })) { peers.Add(PeerInfo.Parse(peerInfo)); } break; case 'i': id = BotIdentifier.Parse(v); break; } } agent = new Agent(listenPort, id); agent.Run(); agent.Bootstrap(peers); var console = new VirtualConsole(0, 20); ConsolesManager.Instance.SetFocus(console); Console.SetCursorPosition(0, 21); Console.Write(new string('=', Console.BufferWidth)); var repl = new CommandLineReader(console); var suite = new CommandSet("vicha", null, console, console) { "usage: COMMAND [OPTIONS]+.", "Available commands are:", "", // { "v:", "verbosity", (int? v) => Verbosity = v.HasValue ? v.Value : Verbosity+1 }, // Commands may also be specified new DDoSStartCommand(agent, repl), new DDoSStopCommand(agent, repl), new ExecuteCommand(agent, repl), new BackdoorCommand(agent, repl), new AddNodeCommand(agent, repl), new DebugCommand(agent, repl), new Command("clear", "Clear the screen") { Run = x => repl.Clear() }, new Command("exit", "Finished the control seesion and close the agent") { Run = x => Environment.Exit(0) } }; repl.NewCommand += (sender, eventArgs) => suite.Run(eventArgs.Command.Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries)); repl.Run(); }
static void Main(string[] args) { string[] inputs; inputs = VirtualConsole.ReadLine().Split(' '); int R = int.Parse(inputs[0]); // number of rows. int C = int.Parse(inputs[1]); // number of columns. int A = int.Parse(inputs[2]); // number of rounds between the time the alarm countdown is activated and the time the alarm goes off. RoundEndCounter = A; MapNode searchNode; string dir = ""; // game loop while (true) { inputs = VirtualConsole.ReadLine().Split(' '); int pY = int.Parse(inputs[0]); // row where Kirk is located. int pX = int.Parse(inputs[1]); // column where Kirk is located. MapNode.resetNodes(); for (int y = 0; y < R; y++) { string ROW = VirtualConsole.ReadLine(); // C of the characters in '#.TC?' (i.e. one line of the ASCII maze). for (int x = 0; x < C; x++) { new MapNode(x, y, ROW[x].ToString()); } } MapNode.connectNodes(); var startingNode = MapNode.MapNodes.Find(item => item.value == "T"); var playerNode = MapNode.MapNodes.Find(item => item.x == pX && item.y == pY); if (playerNode.value == Solution.Goal)//we standing on the goal, alarm must of gone off, new goal to get back { Solution.Goal = "T"; } var goalNodeConnected = MapNode.checkIfGoalConnected(startingNode); if (goalNodeConnected == null) //goal is not connected so we keep exploring map { var closestNode = MapNode.findClosestHiddenNode(playerNode); MapNode.resetVistedNodes(); searchNode = closestNode; } else { searchNode = goalNodeConnected; } var nextConnectedNodeInPath = playerNode.FindNextNodeToPath(searchNode); MapNode.resetVistedNodes(); dir = playerNode.DirectionOfConnectedNode(nextConnectedNodeInPath); VirtualConsole.WriteLine(dir); // Kirk's next move (UP DOWN LEFT or RIGHT). } }