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