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"); */ }
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(); }
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 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 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); }
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 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()); }
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 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 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)); }
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 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 void ShouldCreateTheCorrectInstructionTypes(string instructionBody, Type expectedInstructionType) { var instructionsList = scriptParser.Parse(instructionBody); Assert.IsNotNull(instructionsList); Assert.IsTrue(instructionsList.Count == 1); Assert.IsTrue(instructionsList.First().GetType() == expectedInstructionType); }
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 ParseInstructions() { var instructions = new List <string> { "6 3", "1 2 N", "LMLMLMLMM", "3 3 E", "MMRMMRMRRM", "1 2 N", "LMLMLMLMM" }; var roverPaths = InstructionParser.Parse(instructions); roverPaths.Count().Should().Be(3); Plateau.GetPlateauBounds().ShouldBeEquivalentTo(new Position(6, 3)); }
/// <summary> /// Compiles a given source to a list of instructions /// </summary> /// <param name="source">The source code</param> /// <returns>The instructions parsed out of the source.</returns> public static List <Instruction> Compile(string source) { var tokens = InstructionParser.Parse(source); var result = new List <Instruction>(); tokens.ForEach(token => { if (token is InstructionToken instructionToken) { result.Add(instructionToken.Instruction); } // TODO: Do further processing - Aka optimize and pre-process and labels. }); return(result); }
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()); } }
public void ParseTest() { InstructionParser.Parse("nop +0").Should().BeEquivalentTo(new NopInstruction(0)); InstructionParser.Parse("acc +1").Should().BeEquivalentTo(new AccInstruction(1)); InstructionParser.Parse("jmp +4").Should().BeEquivalentTo(new JmpInstruction(4)); }
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 SampleInstructionsGetParsed(string instruction, IBotInstruction parsed) { var parser = new InstructionParser(); Assert.Equal(parsed, parser.Parse(instruction)); }