public void ParseInputTest() { string input = $"5 5{Environment.NewLine}1 2 N{Environment.NewLine}LMLMLMLMM{Environment.NewLine}3 3 E{Environment.NewLine}MMRMMRMRRM{Environment.NewLine}"; string output = string.Empty; string expectedOutput = $"1 3 N{Environment.NewLine}5 1 E{Environment.NewLine}"; //poor man's dependency injection IInstructionParser parser = new InstructionParser(); IRoverFactory factory = new RoverFactory(); IRoverService service = new RoverService(factory, parser); var response = service.ParseInput(new Domain.Parser.Messages.ExecuteRequest() { Input = input }); //if no exceptions encountered if (response.Exception == null) { //get the output output = response.Output; } else { output = response.Exception.Message; } Console.WriteLine(output); Assert.AreEqual(expectedOutput, output); }
public void DecompileCommand(UInt160 contractHash) { var script = _scriptTable.GetScript(contractHash.ToArray(), false); if (script == null) { throw (new ArgumentNullException("Contract not found")); } var parser = new InstructionParser(); foreach (var i in parser.Parse(script)) { _consoleWriter.Write(i.Location.ToString() + " ", ConsoleOutputStyle.Information); if (i is InstructionWithPayload ip) { _consoleWriter.Write(i.OpCode.ToString() + " "); _consoleWriter.WriteLine("{" + ip.Payload.ToHexString(true) + "}", ConsoleOutputStyle.DarkGray); } else { _consoleWriter.WriteLine(i.OpCode.ToString()); } } }
public void ExecuteInstructions() { var stringWriter = new StringWriter(); Console.SetOut(stringWriter); var instructions = new List <string> { "6 3", "1 2 N", "LMLMLMLMM", "3 3 E", "MMRMMRMRRM", "1 2 N", "LMLMLMLMM", "1 9 N", "LRLRMMMRL" }; var roverPaths = InstructionParser.Parse(instructions); InstructionParser.Execute(roverPaths); Plateau.RoverAtPosition(new Position(1, 3)).Should().Be(true); /* * stringWriter.ToString().Should().Be( * "1 3 N\r\n" + * "5 1 E\r\n" + * "1 3 N CRASHED\r\n" + * "1 9 N CRASHED\r\n"); */ }
/// <summary> /// Executes the translation. /// </summary> /// <param name="paths">The paths.</param> /// <param name="extensionProgress">If <c>true</c>, periodically write progress to console /// if the input binaries are adequately large.</param> /// <returns>The computed cfg and type environment.</returns> public static (Cfg, TypeEnvironment) ExecuteTranslation(string[] paths, bool extensionProgress = false) { (var assemblies, var totalSize) = GetAssemblies(paths); InstructionParser.RegisterAllKnownParsers(); var reportProgressExtension = totalSize > 1e7 && extensionProgress; var decompilationService = new DecompilationService(assemblies, reportProgressExtension); var tenvParser = new TenvParserService(reportProgressExtension); var cfgParser = new CfgParserService(reportProgressExtension); var result = decompilationService .Execute() .ThenExecute(tenvParser) .ThenExecute(cfgParser); var tenv = result.GetResult <TenvParserResult>().TypeEnvironment; var cfg = result.GetResult <CfgParserResult>().Cfg; Log.PrintAllUnknownInstruction(); Log.WriteLine(); Log.PrintCoverageStats(result.GetResult <CfgParserResult>().Methods); return(cfg, tenv); }
private void btnSendCommands_Click(object sender, EventArgs e) { StringBuilder allResults = new StringBuilder(); try { var builder = new PlanetBuilder(); IParser parser = new InstructionParser(); PlanetDescription planetDescription = parser.Parse(tbCommands.Text); Queue<Robot> robots = builder.BuildPlanet(planetDescription); while (robots.Count > 0) { Robot robot = robots.Dequeue(); robot.ExecuteCommands(); string result = String.Format("{0} {1} {2}{3}", robot.CurrentPosition.X, robot.CurrentPosition.Y, robot.CurrentOrientation.ToString()[0], ((robot.IsLost) ? " LOST" : "")); allResults.Append(result.Trim() + "\r\n"); } } catch (MartianException ex) { allResults.Append(ex.Message + "\r\n"); } catch (Exception ex) { allResults.Append("Unhandled Exception: " + ex.Message + "\r\n"); } tbResult.Text = allResults.ToString(); }
/// <summary> /// Executes the translation. /// </summary> /// <param name="paths">The paths.</param> /// <param name="printprocs">The printprocs.</param> /// <returns></returns> public static (Cfg, TypeEnvironment) ExecuteTranslation(string[] paths, string printprocs = null) { var assemblies = GetAssemblies(paths); InstructionParser.RegisterAllKnownParsers(); var decompilationService = new DecompilationService(assemblies); var tenvParser = new TenvParserService(); var cfgParser = new CfgParserService(); var result = decompilationService .Execute() .ThenExecute(tenvParser) .ThenExecute(cfgParser); var tenv = result.GetResult <TenvParserResult>().TypeEnvironment; var cfg = result.GetResult <CfgParserResult>().Cfg; if (printprocs != null) { PrintCfg(cfg, printprocs); } Log.PrintAllUnknownInstruction(); Log.WriteLine(); Log.PrintCoverageStats(result.GetResult <CfgParserResult>().Methods); return(cfg, tenv); }
public void SamplePart2() { var program = InstructionParser.ParseProgram(_programTest1); Day08 day8 = new Day08(); day8.ExecutePart2(program).Should().Be(8); }
public void Part2_WithSampleInput_ShouldReturn8() { string sampleInput = @"nop +0 acc +1 jmp +4 acc +3 jmp -3 acc -99 acc +1 jmp -4 acc +6"; string[] programData = new List <string>( sampleInput.Split(Environment.NewLine, StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries ) ) .ToArray(); Computer computer = new Computer(new string[0]); for (int i = 0; i < programData.Length; i++) { programData = new List <string>( sampleInput.Split(Environment.NewLine, StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries ) ) .ToArray(); InstructionParser parser = new InstructionParser(programData[i]); string newInstruction = string.Empty; if (parser.Command == "nop") { newInstruction = "jmp " + parser.Value.ToString("+#;-#;+0"); } else if (parser.Command == "jmp") { newInstruction = "nop " + parser.Value.ToString("+#;-#;+0"); } else { continue; } programData[i] = newInstruction; computer = new Computer(programData); computer.Run(); if (!computer.IsInfiniteLoop) { break; } } Assert.Equal(8, computer.Accumulator); }
public string Solve(string[] input) { var parser = new InstructionParser(); var instructions = input.Select(line => parser.Parse(line)); var layout = new SwarmScript(instructions).Compile(); return((layout.Outputs[0] * layout.Outputs[1] * layout.Outputs[2]).ToString()); }
public void Parse_ShouldParseCharacterToEnum(char inputValue, Instruction expectedValue) { var parser = new InstructionParser(); var result = parser.Parse(inputValue); result.Should().Be(expectedValue); }
public void RowRotationGetsParsed() { var parser = new InstructionParser(); var parsed = parser.Parse("rotate row y=0 by 4"); var proper = new Instruction(Instruction.Operation.RowRotation, 0, 4); Assert.Equal(proper, parsed); }
public void RectangleGetsParsed() { var parser = new InstructionParser(); var parsed = parser.Parse("rect 3x2"); var proper = new Instruction(Instruction.Operation.Rectangle, 3, 2); Assert.Equal(proper, parsed); }
public void SamplePart1() { var program = InstructionParser.ParseProgram(_programTest1); Computer p = new Computer(program); p.ExecuteStopWhenLoop(); p.GetAcc().Should().Be(5); }
public void TestParser(string input, Direction expectedDirection, int expectedNumber) { var instructions = InstructionParser.ParseInstructions(input); var(direction, number) = Assert.Single(instructions) !; Assert.Equal(expectedDirection, direction); Assert.Equal(expectedNumber, number); }
public void ColumnRotationGetsParsed() { var parser = new InstructionParser(); var parsed = parser.Parse("rotate column x=14 by 31"); var proper = new Instruction(Instruction.Operation.ColRotation, 14, 31); Assert.Equal(proper, parsed); }
void TestParseInstruction <T>(byte[] byteCode, IComparable <T> expected) where T : class { Int16 instructionCode = BitConverter.ToInt16(byteCode); InstructionConfiguratorStub configurator = new InstructionConfiguratorStub(); InstructionParser parser = new InstructionParser(configurator); var parsed = parser.Parse(instructionCode) as T; Assert.Equal(0, expected.CompareTo(parsed)); }
public string Solve(string[] input) { var parser = new InstructionParser(); var instructions = input.Select(line => parser.Parse(line)); var layout = new SwarmScript(instructions).Compile(); var bot = layout.Bots.Values.Single(b => b.Values.Max() == 61 && b.Values.Min() == 17); return(bot.Id.ToString()); }
void TestInvalidInstructionCall(byte[] byteCode) { Int16 instructionCode = BitConverter.ToInt16(byteCode); InstructionConfiguratorStub configurator = new InstructionConfiguratorStub(); InstructionParser parser = new InstructionParser(configurator); parser.UnknownInstructionFoundEvent += (Int16 code) => throw new InvalidInstructionException(); Assert.Throws <InvalidInstructionException>(() => parser.Parse(instructionCode)); }
public string Solve(string[] input) { var registers = new RegisterMap(new[] { 'a', 'b', 'c', 'd' }); var parser = new InstructionParser(registers); var interpret = new Interpreter(registers); interpret.Execute(input.Select(i => parser.Parse(i)).ToArray()); return(interpret.Registers[0].ToString()); }
private IEnumerable <Instruction> ConvertToNodes(Stream stream) { var reader = new XmlCompatibilityReader(stream); var runtimeTypeSource = RuntimeTypeSource; var pullParser = new InstructionParser(runtimeTypeSource); var protoParser = new ProtoInstructionParser(runtimeTypeSource); return(pullParser.Parse(protoParser.Parse(reader)).ToList()); }
private ICentralProcessingUnit BuildCPU(IArithmeticLogicUnit alu, IMemoryManagementUnit mmu, ISystemBridge bridge) { IInstructionConfigurator configurator = new InstructionConfigurator(bridge); IInstructionParser parser = new InstructionParser(configurator); InstructionReader reader = new InstructionReader(mmu, alu.IP); ICentralProcessingUnit cpu = new CentralProcessingUnit(alu, parser, reader); return(cpu); }
public string Solve(string[] input) { var parser = new InstructionParser(); var instructions = input.Select(parser.Parse); var simulator = new ScreenSimulator(50, 6); var endState = instructions.Aggregate(simulator.InitialState(), (state, instruction) => simulator.Simulate(instruction, state)); return(endState.ToString()); }
private ICollection <Instruction> ExtractNodesFromPullParser(string xml) { var pullParser = new InstructionParser(RuntimeTypeSource); using (var stream = new StringReader(xml)) { var reader = new XmlCompatibilityReader(stream); return(pullParser.Parse(new ProtoInstructionParser(RuntimeTypeSource).Parse(reader)).ToList()); } }
void EnsureInstructionsParsed() { if (m_instructions == null && m_pRow->RVA != 0) { var header = GetMethodHeader(); var instructions = InstructionParser.Parse(new BufferWrapper(header.RawHeader + header.Size, header.CodeSize), this); #pragma warning disable 420 Interlocked.CompareExchange(ref m_instructions, instructions, null); #pragma warning restore 420 } }
public void Part2ReturnsExpectedResult(string[] puzzleInput, int expectedResult) { // Arrange InstructionParser sut = new InstructionParser(); // Act int stepsToEscape = sut.Part2(puzzleInput); // Assert Assert.That(stepsToEscape, Is.EqualTo(expectedResult)); }
public Property InputInstructionGetsParsed() { var inputInstructions = from value in Arb.Generate <byte>() from bot in Arb.Generate <byte>() select new { value, bot, instruction = $"value {value} goes to bot {bot}" }; var parser = new InstructionParser(); var parsing = inputInstructions.Select(i => new { original = i, parsed = parser.Parse(i.instruction) as InputInstruction }); return(Prop.ForAll(parsing.ToArbitrary(), p => p.parsed != null && p.parsed.Value == p.original.value && p.parsed.Bot == p.original.bot)); }
public string Solve(string[] input) { var parser = new InstructionParser(); var instructions = input.Select(parser.Parse); var simulator = new ScreenSimulator(50, 6); var endState = instructions.Aggregate(simulator.InitialState(), (state, instruction) => simulator.Simulate(instruction, state)); int pixelsLit = endState.Pixels.Cast <bool>().Count(pixel => pixel); return(pixelsLit.ToString()); }
public void Example1(string input, int distance) { var instructions = InstructionParser.ParseInstructions(input.Replace("|", Environment.NewLine)); var ship = new Ship(FacingDirection.East, new Position()); foreach (var instruction in instructions) { ship = ship.PerformInstruction(instruction); } Assert.Equal(distance, ship.GetManhanttanDistance()); }
public void SolvePuzzle1() { var input = new FileReader() .GetResource("AdventOfCode2020.Tests.Day12.PuzzleInput.txt"); var instructions = InstructionParser.ParseInstructions(input); var ship = new Ship(FacingDirection.East, new Position()); ship = instructions.Aggregate(ship, (current, instruction) => current.PerformInstruction(instruction)); _testOutputHelper.WriteLine(ship.GetManhanttanDistance().ToString()); }
private static IEnumerable <Instruction> ReadNodes(Type underlyingType) { var resourceProvider = new InflatableTranslator(); using (var stream = resourceProvider.GetInflationSourceStream(underlyingType)) { var reader = new XmlCompatibilityReader(stream); var runtimeTypeSource = new WpfRuntimeTypeSource(); var loader = new InstructionParser(runtimeTypeSource); var protoParser = new ProtoInstructionParser(runtimeTypeSource); return(loader.Parse(protoParser.Parse(reader))); } }
public void Example2(string input, int distance) { var instructions = InstructionParser.ParseInstructions(input.Replace("|", Environment.NewLine)); var waypoint = new Waypoint(FacingDirection.East, new Position { Horizontal = 10, Vertical = 1 }); var ship = new WaypointShip(FacingDirection.East, new Position(), waypoint); foreach (var instruction in instructions) { ship = ship.PerformInstruction(instruction); } Assert.Equal(distance, ship.GetManhanttanDistance()); }
public void TestFromFiles() { foreach (TestDescription description in Tests) { IParser parser = new InstructionParser(); PlanetDescription planetDescription = parser.Parse(description.Test); Queue<Robot> robots = new PlanetBuilder().BuildPlanet(planetDescription); StringBuilder allResults = new StringBuilder(); while (robots.Count > 0) { Robot robot = robots.Dequeue(); robot.ExecuteCommands(); string result = String.Format("{0} {1} {2}{3}", robot.CurrentPosition.X, robot.CurrentPosition.Y, robot.CurrentOrientation.ToString()[0], ((robot.IsLost) ? " LOST" : "")); allResults.Append(result.Trim()+"\r\n"); } Assert.AreEqual(allResults.ToString().Trim(), description.ExpectedResult.Trim()); } }
private static IEnumerable<Instruction> ReadNodes(Type underlyingType) { var resourceProvider = new InflatableTranslator(); using (var stream = resourceProvider.GetInflationSourceStream(underlyingType)) { var reader = new XmlCompatibilityReader(stream); var runtimeTypeSource = new WpfRuntimeTypeSource(); var loader = new InstructionParser(runtimeTypeSource); var protoParser = new ProtoInstructionParser(runtimeTypeSource); return loader.Parse(protoParser.Parse(reader)); } }