public void Mutate() { // Mutate source files foreach (var file in _projectInfo.GetAllFiles().Cast <FsharpFileLeaf>()) { _logger.LogDebug($"Mutating {file.RelativePath}"); // Mutate the syntax tree var treeroot = ((ParsedInput.ImplFile)file.SyntaxTree).Item.modules; var mutatedSyntaxTree = _orchestrator.Mutate(treeroot); // Add the mutated syntax tree for compilation var tree = (ParsedInput.ImplFile)file.SyntaxTree; var item = tree.Item; //we hardcode the lastcompiled flag to make the compile pass //this needs to be fixed in the FSharp.Compiler.SourceCodeServices package, or made dynamic as it now assumes the bottom of Program.fs is the entrypoint var lastcompiled = item.fileName.Equals("Program.fs") ? new Tuple <bool, bool>(true, true) : item.isLastCompiland; file.MutatedSyntaxTree = ParsedInput.NewImplFile(ParsedImplFileInput.NewParsedImplFileInput(item.fileName, item.isScript, item.qualifiedNameOfFile, item.scopedPragmas, item.hashDirectives, mutatedSyntaxTree, lastcompiled)); if (_options.DevMode) { _logger.LogTrace($"Mutated {file.RelativePath}:{Environment.NewLine}{mutatedSyntaxTree}"); } // Filter the mutants var allMutants = _orchestrator.GetLatestMutantBatch(); file.Mutants = allMutants; } _logger.LogDebug("{0} mutants created", _projectInfo.Mutants.Count()); CompileMutations(); }
public ICommand Create(User user, ParsedInput parsedInput, ITweetsRepository tweetsRepository, TextWriter textWriter) { switch (parsedInput.CommandType) { case CommandType.Read: { return new ReadCommand(user, tweetsRepository, textWriter, parsedInput); } case CommandType.Follow: { return new FollowCommand(user, new User(parsedInput.RequiredAction), textWriter); } case CommandType.Wall: { return new WallCommand(user, tweetsRepository, textWriter, parsedInput); } case CommandType.Post: default: { return new PostCommand(user, tweetsRepository, parsedInput, textWriter); } } }
public void Init() { playerInput = new ParsedInput("quit", new ArrayList()); thePlayer = new Player("greg"); handler = new CommandHandler(); quit = new QuitCommand(); }
public WallCommand(User user, ITweetsRepository tweetsRepository, TextWriter textWriter, ParsedInput parsedInput) { _user = user; _tweetsRepository = tweetsRepository; _textWriter = textWriter; _parsedInput = parsedInput; }
public PostCommand(User user, ITweetsRepository tweetsRepository, ParsedInput parsedInput, TextWriter textWriter) { _user = user; _tweetsRepository = tweetsRepository; _parsedInput = parsedInput; _textWriter = textWriter; }
public void ParseCommandName_Parsed() { var input = new ParsedInput("cmdName"); input.Elements.Count.Should().Be(1); ValidateCommandNode(input, "cmdName"); }
public Solution(string input) { var lines = Input.GetInputLines(input).ToArray(); var kvParser = new InputParser <string, string>("key:value"); modules = new List <ParsedInput>(); ParsedInput currentModule = new ParsedInput(); foreach (var line in lines) { if (string.IsNullOrWhiteSpace(line)) { modules.Add(currentModule); currentModule = new ParsedInput(); } var fields = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); for (int n = 0; n < fields.Length; n++) { var split = kvParser.Parse(fields[n]); currentModule.passportValues.Add(split.Item1, split.Item2); } } modules.Add(currentModule); }
protected bool Equals(ParsedInput other) { return(string.Equals(UserName, other.UserName) && string.Equals(Action, other.Action) && string.Equals(Message, other.Message) && string.Equals(FollowedUser, other.FollowedUser)); }
public void ResolveCommandWithArgumentAlias_Resolved() { var input = new ParsedInput("commandWithAlias -p"); var result = _resolver.Resolve(input); result.CommandInfo.Should().NotBeNull(); result.Errors.Count.Should().Be(0); }
public void ResolveCommandWithArgumentNameInvariantCase_Resolved() { var input = new ParsedInput("commandWithArgument --aRgOnE"); var result = _resolver.Resolve(input); result.CommandInfo.Should().NotBeNull(); result.Errors.Count.Should().Be(0); }
public void ResolveCommandWithMultipleArguments_Resolved() { var input = new ParsedInput("multipleArgumentsAndAliases --myProperty value1 -p \"value\" --Prop"); var result = _resolver.Resolve(input); result.CommandInfo.Should().NotBeNull(); result.Errors.Count.Should().Be(0); }
public FormattedInput ParseInput() { foreach (string line in this.RawInput) { ParsedInput.Add(Int32.Parse(line)); } return(this); }
/// <summary> /// Attempts to resolve a valid parsed input to a registered command /// </summary> /// <param name="input">The valid parsed input</param> /// <returns>A resolved command</returns> public ResolvedCommand Resolve(ParsedInput input) { // is input valid if (!input.IsValid) { throw new CommandResolutionException(input, "The provided input is invalid and cannot be resolved"); } // does cmd exist var cmdInfo = _registry.Commands.FirstOrDefault(c => c.Name.Equals(input.GetCommandElement().Value, StringComparison.OrdinalIgnoreCase)); if (cmdInfo == null) { return(new ResolvedCommand(input, CommandResolutionErrorType.CommandNotFound)); } // begin to accumulate errors var errors = new List <ResolveCommandError>(); // capture argument errors - unknown arguments, options with values var inputMap = new Dictionary <ArgumentInfo, ParsedInputElement>(); foreach (var node in input.Elements.Where(n => n.ElementType == InputElementType.ArgumentName || n.ElementType == InputElementType.ArgumentAlias)) { var argInfo = node.ElementType == InputElementType.ArgumentName ? cmdInfo.Arguments.SingleOrDefault(p => p.Name.Equals(node.Value, StringComparison.OrdinalIgnoreCase)) : cmdInfo.Arguments.SingleOrDefault(p => p.Alias.Equals(node.Value.Single())); CaptureArgumentErrors( errors, argInfo, node); if (argInfo != null) { if (!inputMap.ContainsKey(argInfo)) { inputMap.Add(argInfo, node); } else { errors.Add(new ResolveCommandError { Type = CommandResolutionErrorType.DuplicateArgument, Element = node, Message = $"Arguments \"{node.Raw}\" and \"{inputMap[argInfo].Raw}\" resolve the same argument property." }); } } } return(new ResolvedCommand(input, cmdInfo, new ReadOnlyDictionary <ArgumentInfo, ParsedInputElement>(inputMap), errors)); }
private void ValidateCommandNode(ParsedInput input, string cmdName, int index = 0) { ValidateInputNode( input.Elements.First(), cmdName, InputElementType.Command, index, null, cmdName); }
public void ActivateCommand_Activated() { var input = new ParsedInput("command"); var res = _resolver.Resolve(input); var act = _activator.Activate(res); act.Command.Should().NotBeNull(); act.Command.GetType().Should().Be <Command>(); }
// Reformats input and concatenates all parameter strings into one string. public override void ReformatInput(ParsedInput input) { if (input.Parameters.Length == 0) { return; } string[] a = new string[1]; a[0] = String.Join(" ", input.Parameters); input.Parameters = a; }
public void TestArgumentDetection() { ParsedInput userInput = theParser.Parse("quit"); Assert.IsTrue(userInput.Arguments.Count == 0); userInput = theParser.Parse("move west"); Assert.IsTrue(userInput.Arguments.Count == 1); userInput = theParser.Parse("move to the west"); Assert.IsTrue(userInput.Arguments.Count == 1); }
public void TestCommandDetection() { ParsedInput userInput = theParser.Parse("quit"); Assert.AreEqual(userInput.Command, "quit"); userInput = theParser.Parse("move west"); Assert.AreEqual(userInput.Command, "move"); userInput = theParser.Parse("greg"); Assert.AreEqual(userInput.Command, ""); }
public void ParseInputWithArgumentNoValue_Parsed() { var input = new ParsedInput("cmdName --param1"); input.Elements.Count.Should().Be(3); ValidateCommandNode(input, "cmdName"); ValidateEmptyNode(input, 1, " "); ValidateArgumentNode(input, 2, "param1"); }
public void ResolveCommandCaseInvariant_Resolved() { var input = new ParsedInput("cOmMaNd"); var result = _resolver.Resolve(input); result.Input.Should().NotBeNull(); result.CommandInfo.Should().NotBeNull(); result.Errors.Should().BeEmpty(); result.IsValid.Should().BeTrue(); result.CommandInfo.Type.Should().Be <Command>(); }
public void ResolveCommandWithArgumentAliasWrongCase_ResolvedWithErrors() { var input = new ParsedInput("commandWithAlias -P"); var result = _resolver.Resolve(input); result.CommandInfo.Should().NotBeNull(); result.Errors.Count.Should().Be(1); result.Errors.First().Type.Should().Be(CommandResolutionErrorType.ArgumentNotFound); result.Errors.First().Element.Raw.Should().Be("-P"); result.Errors.First().Message.Should().NotBeNull(); }
public Solution(string input) { var lines = Input.GetInputLines(input).ToArray(); modules = lines.Select(line => { var pi = new ParsedInput(line); return(pi); }).ToList(); }
public void ResolveCommandWithNameAttribute_Resolved() { var input = new ParsedInput("myCommand"); var result = _resolver.Resolve(input); result.Input.Should().NotBeNull(); result.CommandInfo.Should().NotBeNull(); result.Errors.Should().BeEmpty(); result.IsValid.Should().BeTrue(); result.CommandInfo.Type.Should().Be <CommandWithNameAttribute>(); }
public void InputParsing_SimpleCommand_TwoTokens() { const string input = "cd ../folder"; InputParseService parser = new InputParseService(); ParsedInput parsed = parser.Parse(input); Assert.Equal(input, parsed.RawInput); Assert.Equal(2, parsed.Tokens.Count); Assert.Equal("cd", parsed.Tokens[0]); Assert.Equal("../folder", parsed.Tokens[1]); }
public void ActivateAlias_Activated() { var input = new ParsedInput("withAlias -a 10"); var res = _resolver.Resolve(input); var act = _activator.Activate(res); act.Command.Should().NotBeNull(); act.Command.GetType().Should().Be <WithAlias>(); ((WithAlias)act.Command).ArgOne.Should().Be(10); }
public void ActivateIntArg_Activated() { var input = new ParsedInput("withIntArg --intArg 10"); var res = _resolver.Resolve(input); var act = _activator.Activate(res); act.Command.Should().NotBeNull(); act.Command.GetType().Should().Be <WithIntArg>(); ((WithIntArg)act.Command).IntArg.Should().Be(10); }
public void ActivateWithoutArgInput_Activated() { var input = new ParsedInput("withArgument"); var res = _resolver.Resolve(input); var act = _activator.Activate(res); act.Command.Should().NotBeNull(); act.Command.GetType().Should().Be <WithArgument>(); ((WithArgument)act.Command).ArgOne.Should().Be(0); }
public void ActivateOptionAbsent_Activated() { var input = new ParsedInput("withOption"); var res = _resolver.Resolve(input); var act = _activator.Activate(res); act.Command.Should().NotBeNull(); act.Command.GetType().Should().Be <WithOption>(); ((WithOption)act.Command).OptOne.IsPresent.Should().BeFalse(); }
public void ParseInputWithEmptyParameterName_UnexpectedElement() { var input = new ParsedInput("cmdName -- \"val\""); input.Elements.Count.Should().Be(5); ValidateCommandNode(input, "cmdName"); ValidateEmptyNode(input, 1, " "); ValidateUnexpectedNode(input, 2, "--", ""); ValidateEmptyNode(input, 3, " "); ValidateUnexpectedNode(input, 4, "\"val\"", "val"); }
public void ActivateMultipleArgs_Activated() { var input = new ParsedInput("MultipleArgs --argOne 10 --strArg \"hello world\""); var res = _resolver.Resolve(input); var act = _activator.Activate(res); act.Command.Should().NotBeNull(); act.Command.GetType().Should().Be <MultipleArgs>(); ((MultipleArgs)act.Command).ArgOne.Should().Be(10); ((MultipleArgs)act.Command).StrArg.Should().Be("hello world"); }
public void ParseInputWithArgumentValueWithSpaces_Parsed() { var input = new ParsedInput("cmdName --param1 val"); input.Elements.Count.Should().Be(5); ValidateCommandNode(input, "cmdName"); ValidateEmptyNode(input, 1, " "); ValidateArgumentNode(input, 2, "param1", 4); ValidateEmptyNode(input, 3, " "); ValidateArgumentValueNode(input, 4, "val", 2); }
public void Init() { playerInput = new ParsedInput("move", new ArrayList()); thePlayer = new Player("greg"); t127 = new Location("a lecture theatre", "T127", new NonPlayerCharacter("Johnny", "heyo", false)); gregsoffice = new Location("a spinning vortex of terror", "Greg's Office", new NonPlayerCharacter("Johnny", "heyo", false)); t127.GetExitCollection().AddExit("south", new Exit("you see a mound of paper to the south", gregsoffice)); gregsoffice.GetExitCollection().AddExit("north", new Exit("you see a bleak place to the north", t127)); thePlayer.CurrentLocation = t127; handler = new CommandHandler(); move = new MoveCommand(); }
public void InputParsing_CommandWithTwoComplexParameters_ThreeTokens() { const string input = "_command42 \"complex param '## $ ! | text' \" 'second complex param with \"inner text\"'"; InputParseService parser = new InputParseService(); ParsedInput parsed = parser.Parse(input); Assert.Equal(input, parsed.RawInput); Assert.Equal(3, parsed.Tokens.Count); Assert.Equal("_command42", parsed.Tokens[0]); Assert.Equal("\"complex param '## $ ! | text' \"", parsed.Tokens[1]); Assert.Equal("'second complex param with \"inner text\"'", parsed.Tokens[2]); }
public ParsedInput ParseInput(string consoleInput) { string operators = "+-*/%"; int numberOfOperators = 0; char operatorSymbol; foreach (char operatorS in operators) { if (consoleInput.IndexOf(operatorS) != -1) { numberOfOperators++; } throw new ArgumentException(); } if (numberOfOperators == 1) { int index; foreach(char operatorS in operators) { if (consoleInput.IndexOf(operatorS) != -1) { index = consoleInput.IndexOf(operatorS); operatorSymbol = consoleInput[index]; } throw new ArgumentException(); } string[] splitInput = consoleInput.Split(operatorS); int firstInt = int.Parse(splitInput[0]); int secondInt = int.Parse(splitInput[1]); ParsedInput parsed = new ParsedInput(); parsed.FirstInt = firstInt; parsed.SecondInt = secondInt; parsed.operatorS = operatorS; return parsed; /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// } { /* switch (Operation) { case '+': FirstInt = Convert.ToInt32(FirstInt); SecondInt = Convert.ToInt32(Console.ReadLine()); return FirstInt + SecondInt; case '-': return FirstInt - SecondInt; //break; case '*': return FirstInt * SecondInt; // break; case '/': return FirstInt / SecondInt; // break; case '%': return FirstInt % SecondInt; // break; default: throw new ArgumentException("incorrect format"); // break; } */ } throw new ArgumentException(); }