public void WhenExecuteCommandWithValidTemplate_CommandManager_ShouldThrowException()
{
string templateName = "myTemplate";
var storedDataService = new StoredDataServiceMock()
{
ExistsTemplateReturn = true
};
var commandDefinition = new DeleteTemplateCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandNameParameter.GetInvokeName(),
templateName);
instance.ExecuteInputRequest(inputRequest);
var expected = templateName;
var actual = storedDataService.DeletedTemplate;
Assert.Equal(expected, actual);
}
private void OnPasswordRequested(JupyterRequestContext context, PasswordRequested passwordRequested)
{
var passReq = new InputRequest(passwordRequested.Prompt, password: true);
var clearTextPassword = context.JupyterMessageSender.Send(passReq);
passwordRequested.Content = new PasswordString(clearTextPassword);
}
/// <summary>
/// Solicita dois números e apresenta a média
/// </summary>
public static void Ex07()
{
var fstNumber = InputRequest.RequestInteger("Qual o 1º número?");
var sndNumber = InputRequest.RequestInteger("Qual o 2º número?");
Console.WriteLine($"A média entre {fstNumber} e {sndNumber} é {((double)(fstNumber + sndNumber)) / 2}");
}
public void WhenExecuteCommandWithValidPaths_CommandManager_ShouldRename()
{
var newPath = "myNewPath";
var oldPath = "myOldPath";
var storedDataService = new StoredDataServiceMock(false);
var fileServiceMock = new FileServiceMock();
var commandDefinition = new RenameFolderCommand(fileServiceMock);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathOldFolderParameter.GetInvokeName(),
oldPath,
commandDefinition.CommandPathNewFolderParameter.GetInvokeName(),
newPath);
instance.ExecuteInputRequest(inputRequest);
var expectedOldPath = oldPath;
var expectedONewPath = newPath;
var actualOldPath = fileServiceMock.RenamedOldFolder;
var actualNewPath = fileServiceMock.RenamedNewFolder;
Assert.Equal(expectedOldPath, actualOldPath);
Assert.Equal(expectedONewPath, actualNewPath);
}
public void WhenExecuteCommandWithPipelineNonValidPipelineName_CommandManager_ShouldThrowException()
{
string pipelinePath = "myPath";
string pipelineName = "myPipe NONVALID line";
var storedDataService = new StoredDataServiceMock()
{
ExistsPipelineReturn = false
};
var fileService = new FileServiceMock()
{
ExistsFileReturn = true
};
var commandDefinition = new AddPipelineCommand(storedDataService, fileService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathParameter.GetInvokeName(),
pipelinePath,
commandDefinition.CommandNameParameter.GetInvokeName(),
pipelineName);
Assert.Throws <InvalidStringFormatException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
/// <summary>
/// ex5 Criar um algoritmo que apresente todos os elementos únicos numa lista.
/// </summary>
private static void Ex5()
{
var l = InputRequest.GetIntList();
Console.WriteLine("\nValores do Array repetidos:");
Console.WriteLine(Unique(l));
}
public void setInputRequest(InputRequest req)
{
//latestInputRequest = req;
//lstQuestions.Enabled = lstAgents.Enabled = lstChoices.Enabled = true;
//lstQuestions.Items.Clear();
//lstChoices.Items.Clear();
//agentQuestionToAnswer = new Dictionary<Tuple<IAgent, int>, object>();
//agentRequest = new List<IAgent>();
//int i = 0;
//foreach (var a in req.MovementOptions)
//{
// agentLocationAnswer[a.Key] = latestInputRequest.MovementOptions[a.Key].Item1.nodeLocation;
// agentRequest.Add(a.Key);
// ++i;
// if (a.Key is Pursuer)
// lstAgents.Items.Add("Pursuer" + i.ToString());
// else
// lstAgents.Items.Add("Evader" + i.ToString());
//}
}
public void Evaluate(InputRequest req, HashSet <Rule> rules)
{
Parallel.ForEach(rules, rule => {
var requestsMatchingRule = req.dataStream.Where(e => e.signal == rule.operand);
if (requestsMatchingRule != null)
{
switch (rule.operatorExp)
{
case OperatorExp.NotMoreThan:
case OperatorExp.MoreThan:
printFailure(requestsMatchingRule.Where(e => e.value_type == "Integer").Where(e => Convert.ToDecimal(e.value) > Convert.ToDecimal(rule.value)).ToList());
break;
case OperatorExp.NotLessThan:
case OperatorExp.LessThan:
printFailure(requestsMatchingRule.Where(e => e.value_type == "Integer").Where(e => Convert.ToDecimal(e.value) < Convert.ToDecimal(rule.value)).ToList());
break;
case OperatorExp.NotEqual:
case OperatorExp.Equal:
printFailure(requestsMatchingRule.Where(e => e.value_type == "String").Where(e => Convert.ToString(e.value) == Convert.ToString(rule.value)).ToList());
break;
case OperatorExp.NotInFuture:
printFailure(requestsMatchingRule.Where(e => e.value_type == "Datetime").Where(e => DateTime.Parse(e.value) > DateTime.Now).ToList());
break;
case OperatorExp.NotInPast:
printFailure(requestsMatchingRule.Where(e => e.value_type == "Datetime").Where(e => DateTime.Parse(e.value) < DateTime.Now).ToList());
break;
}
}
});
}
public void WhenExecuteCommandWithRegisteredParameters_CommandManager_ShouldShowList()
{
var path1 = "my.path1";
var path2 = "my.path2";
var name1 = "myname1";
var name2 = "myname2";
var registeredPipelines = new List <RegisteredPipeline>()
{
new RegisteredPipeline(path1, name1, null),
new RegisteredPipeline(path2, name2, null)
};
var storedDataService = new StoredDataServiceMock()
{
GetPipelinesReturn = registeredPipelines
};
var commandDefinition = new ShowPipelinesCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
instance.OnLog += Instance_OnLog;
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName());
instance.ExecuteInputRequest(inputRequest);
var expected = registeredPipelines.ToDisplayList(
k => $"{k.PipelineName} => {k.Description} located at {k.Path}",
ShowPipelinesCommand.ListHeaderDisplay,
ShowPipelinesCommand.ListFirstCharLine);
var actual = _loggerServiceMock.Logs.First();
Assert.Equal(expected, actual);
}
public void WhenExecuteCommandKeyAndValue_CommandManager_ShouldCreateParameter()
{
string key = "my.param";
string value = "my value";
var storedDataService = new StoredDataServiceMock()
{
ReturnBoolExistsParameter = false
};
var commandDefinition = new AddParameterCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandKeyParameter.GetInvokeName(),
key,
commandDefinition.CommandValueParameter.GetInvokeName(),
value);
instance.ExecuteInputRequest(inputRequest);
var expectedKey = key;
var actualKey = storedDataService.AddedParameterKey;
Assert.Equal(expectedKey, actualKey);
var expectedValue = value;
var actualValue = storedDataService.AddedParameterValue;
Assert.Equal(expectedValue, actualValue);
}
public void WhenExecuteCommandWithAlreadyRegisteredParameter_CommandManager_ShouldThrowException()
{
string key = "my.param";
string value = "my value";
var storedDataService = new StoredDataServiceMock()
{
ReturnBoolExistsParameter = true
};
var commandDefinition = new AddParameterCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandKeyParameter.GetInvokeName(),
key,
commandDefinition.CommandValueParameter.GetInvokeName(),
value);
Assert.Throws <ParameterRepeatedException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public string RequestInput(InputRequest message, Message request)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
_sender.Send(
Message.Create(
message,
request.Header,
request.Identifiers,
request.MetaData,
request.Signature));
var msgReceived = _receiver.Receive();
var msgType = msgReceived.Header.MessageType;
if (msgType == JupyterMessageContentTypes.InputReply)
{
if (msgReceived.Content is InputReply inputReply)
{
return(inputReply.Value);
}
throw new InvalidOperationException(
$"The content of a '{msgType}' message should be a {nameof(InputReply)} object.");
}
throw new ArgumentOutOfRangeException($"Expecting an 'input_reply' message, but received '{msgType}'.");
}
internal void OnRequireInput(InputRequest inputRequest)
{
#if TEST
if (RequireInput != null)
#endif
RequireInput(inputRequest);
}
public override void setGameState(int currentRound, List <Point> O_c, IEnumerable <GameLogic.Utils.CapturedObservation> O_d)
{
prevO_c = O_c;
prevO_d = O_d;
Dictionary <string, List <Point> > markedLocations = new Dictionary <string, List <Point> >();
markedLocations.Add("Detected Evaders(O_c)", O_c);
markedLocations.Add("Prev. Killed Evaders (O_d)", O_d.Select(x => x.where).ToList());
pgui.markLocations(markedLocations.toPointFMarkings());
InputRequest req = new InputRequest();
foreach (Pursuer p in gm.A_P)
{
if (currentRound == 0)
{
//req.addMovementOption(p, new Location(intrusionCenterPoint),
// GameLogic.Utils.getAllPointsInArea(gm.r_e + 10).Select(x => new Location(x)).ToList());
req.addMovementOption(p, new Location(new Point(-1, -1)),
getPossibleNextLocations(new Location(Location.Type.Unset)));
}
else
{
req.addMovementOption(p, new Location(currentPursuersLocations[p]),
getPossibleNextLocations(new Location(currentPursuersLocations[p])));
}
}
pgui.setInputRequest(req);
}
public void WhenExecuteCommandWithValidTemplateConfig_CommandManager_ShouldExecuteReplaces()
{
var myAbsolutePath = @"c:\absolute\my\Path";
var myPath = @"my\Path";
var myTemplateName = "My template name";
var myNewPathName = "MySecondApp";
var myOldValue = "myOldValue";
var myNewVale = "myNewValue";
var fileService = new FileServiceMock()
{
DDTemplateConfigReturn = new DDTemplateConfig()
{
TemplateName = myTemplateName,
IgnorePathPatterns = new List <string>(),
ReplacePairs = new List <ReplacePair>()
{
new ReplacePair()
{
ApplyForDirectories = true,
ApplyForFileContents = true,
ApplyForFileNames = true,
ApplyForFilePattern = "*.*",
OldValue = myOldValue,
ReplaceDescription = "My replace description"
}
}
},
ExistsTemplateConfigFileReturn = true,
ExistsDirectoryReturn = true,
AbsoluteCurrentPathReturn = myAbsolutePath
};
var consoleInputs = new List <string>()
{
myNewPathName,
myNewVale
};
var commandDefinition = new TemplateCommand(fileService, _storedDataService);
var instance = new CommandManager(_loggerServiceMock, _storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathParameter.GetInvokeName(),
myPath);
instance.ExecuteInputRequest(inputRequest, consoleInputs);
//Assert.Equal(fileService.CreatedDirectory, myAbsolutePath);
Assert.Equal(fileService.ClonedDirectorySource, myPath);
Assert.Equal(fileService.ClonedDirectoryDestination, myAbsolutePath);
Assert.Equal(fileService.ReplacedStringInPathsNewValue, myNewVale);
Assert.Equal(fileService.ReplacedStringInPathsOldValue, myOldValue);
Assert.Equal(fileService.ReplacedFilesContentsPath, myAbsolutePath);
Assert.Equal(fileService.ReplacedFilesNamesPath, myAbsolutePath);
Assert.Equal(fileService.ReplacedSubDirectoriesPath, myAbsolutePath);
}
public static void Ex12()
{
var num = InputRequest.RequestInteger("Qual a dimensão do triângulo?");
var stars = num * 2 - 1;
var dimCounter = 0;
while (dimCounter < num)
{
var spaces = 0;
while (spaces != dimCounter)
{
Console.Write(" ");
spaces++;
}
var starCounter = 0;
while (stars != starCounter)
{
Console.Write("*");
starCounter++;
}
stars -= 2;
Console.WriteLine("");
dimCounter++;
}
}
public object Post([FromForm] InputRequestJson model)
{
if (ModelState.IsValid)
{
var path = _configuration.GetValue <string>("FolderLocation") + model.File.FileName;
using (var fileStream = new FileStream(path, FileMode.Create))
{
model.File.CopyTo(fileStream);
}
var jsonData = JsonConvert.DeserializeObject <Data>(model.data);
InputRequest request = new InputRequest
{
DateOfUpload = DateTime.ParseExact(jsonData.DateOfUpload, "dd/MM/yyyy", CultureInfo.InvariantCulture),
DocumentName = jsonData.DocumentName,
DocumentURI = jsonData.DocumentURI,
};
_context.Request.Add(request);
_context.SaveChanges();
return(new { Status = true });
}
else
{
return(new { Status = false, Message = string.Join("|", ModelState.Values.SelectMany(z => z.Errors).Select(z => z.ErrorMessage)) });
}
}
public void WhenExecuteCommandWithoutOldValueParameter_CommandManager_ShouldThrowException()
{
var path = "mypath";
var newValue = "myOldValue";
var storedDataService = new StoredDataServiceMock();
var fileServiceMock = new FileServiceMock();
var commandDefinition = new ReplaceFileContentCommand(fileServiceMock);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathParameter.GetInvokeName(),
path,
commandDefinition.CommandNewValueParameter.GetInvokeName(),
newValue);
Assert.Throws <InvalidParamsException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
/// <summary>
/// ex7 separar os números ímpares dos pares numa lista
/// </summary>
static void Ex7()
{
var l = InputRequest.GetIntList();
Console.WriteLine($"\nPares: {Even(l)}");
Console.WriteLine($"Ímpares: {Odd(l)}");
}
private static void AddToTotalizarCountAndOutput(ref string output, ref int counter, ref double total, string prefix)
{
counter++;
var fstNumber = InputRequest.RequestInteger($"Qual o {counter}º número?");
total += fstNumber;
}
public void WhenExecuteCommandRegisteredAlias_CommandManager_ShouldReturnZeroAliasMessage()
{
string myAliasDefinition1 = "myalias => mycommand";
string myAliasDefinition2 = "myalias2 => mycommand2";
var aliasList = new List <string>()
{
myAliasDefinition1, myAliasDefinition2
};
var storedDataService = new StoredDataServiceMock(aliasList);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.OnLog += Instance_OnLog;
var commandDefinition = new ShowAliasCommand(storedDataService);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName());
instance.ExecuteInputRequest(inputRequest);
var expected = aliasList.ToDisplayList(
ShowAliasCommand.HeaderForListingAlias,
ShowAliasCommand.FirstCharacterDefaultForListingAlias);
var actual = _loggerServiceMock.Logs.First();
Assert.Equal(expected, actual);
}
public void WhenExecuteCommandWithTemplateNameRepeated_CommandManager_ShouldThrowException()
{
string templatePath = "myPath";
string templateName = "myTemplate";
var storedDataService = new StoredDataServiceMock()
{
ExistsTemplateReturn = true
};
var fileService = new FileServiceMock();
var commandDefinition = new AddTemplateCommand(storedDataService, fileService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathParameter.GetInvokeName(),
templatePath,
commandDefinition.CommandNameParameter.GetInvokeName(),
templateName);
Assert.Throws <TemplateNameRepeatedException>(() =>
{
instance.ExecuteInputRequest(inputRequest);
});
}
public void WhenExecuteCommandWithParameter_CommandManager_ShouldDeleteParameter()
{
var key = "my.parameter";
var storedDataService = new StoredDataServiceMock()
{
ReturnBoolExistsParameter = true
};
var commandDefinition = new DeleteParameterCommand(storedDataService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandKeyParameter.GetInvokeName(),
key);
instance.ExecuteInputRequest(inputRequest);
var expected = key;
var actual = storedDataService.DeletedParameter;
Assert.Equal(expected, actual);
}
/// <summary>
/// ex3 Solicitar uma string e apresentar a contagem de palavras
/// </summary>
static void Ex3()
{
var s = InputRequest.RequestString("Escreve algo");
var l = s.Trim().Split(' ');
Console.WriteLine($"A string \"{@s}\" contém {l.Length} palavras");
}
public void WhenExecuteCommandWithValidFolder_CommandManager_ShouldZipDirectory()
{
var path = "myPath";
var storedDataService = new StoredDataServiceMock(false);
var fileServiceMock = new FileServiceMock()
{
IsFileReturn = true
};
var commandDefinition = new UnzipCommand(fileServiceMock);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandPathParameter.GetInvokeName(),
path);
instance.ExecuteInputRequest(inputRequest);
var expected = path;
var actual = fileServiceMock.UnzippedPath;
Assert.Equal(expected, actual);
}
/// <summary>
/// ex10 Solicitar uma string e apresentar o número de letras, números e caracteres especiais
/// </summary>
static void Ex10()
{
var s = InputRequest.RequestString("Escreve algo");
s = s.ToLower();
var letras = "abcdefghijklmnopqrstuvxwyz";
var numeros = "1234567890";
int l = 0, n = 0, e = 0;
foreach (var letra in s)
{
if (letras.Contains(letra))
{
l++;
}
else if (numeros.Contains(letra))
{
n++;
}
else
{
e++;
}
}
Console.WriteLine($"\nLetras: {l}");
Console.WriteLine($"Números: {n}");
Console.WriteLine($"Caracteres Especiais: {e}");
}
/// <summary>
/// ex1.6 Apresentar o fatorial de um número
/// </summary>
private static int Fact(int n = 0, int f = 1, bool s = true)
{
if (s)
{
var ns = InputRequest.RequestString("\nQual o número?");
if (!int.TryParse(ns, out n) || n < 0)
{
while (!int.TryParse(ns, out n) || n < 0)
{
ns = InputRequest.RequestString("Escolha um número diferente?");
}
}
if (n == 0)
{
Console.Write($"{n}! = 1\n");
}
else
{
Console.Write($"{n}! = { Fact(n, 1, false)}\n");
}
return(0);
}
else
{
if (n == 0)
{
return(f);
}
else
{
f *= n;
return(Fact(n - 1, f, false));
}
}
}
public static void Ex12()
{
var num = InputRequest.RequestInteger("Introduza o número");
var @char = InputRequest.RequestCharacter("Introduza um caracter");
PrintGrid(num, num, @char);
}
/// <summary>
/// Concats a number to the output with a prefix, and adds the inputted value to a totalizer
/// </summary>
/// <param name="counter">just a number to notify the number's position'</param>
/// <param name="total">the current total</param>
/// <param name="output">the current output</param>
/// <param name="prefix">the prefix that should be added</param>
private static void ConcatNumberAndAddToTotal(int counter, ref double total, ref string output, string prefix)
{
var temp = InputRequest.RequestDouble($"Introduza o {counter}º número");
total += temp;
output += prefix + temp;
}
public void WhenExecuteCommandCmd_CommandManager_ShouldExecuteCommand()
{
var cmd = "mycommand";
var storedDataService = new StoredDataServiceMock();
var promtpService = new PromptServiceMock();
var commandDefinition = new WindowsCmdCommand(promtpService);
var instance = new CommandManager(_loggerServiceMock, storedDataService, _cryptoServiceMock);
instance.RegisterCommand(commandDefinition);
var inputRequest = new InputRequest(
commandDefinition.GetInvocationCommandName(),
commandDefinition.CommandCmdParameter.GetInvokeName(),
cmd);
instance.ExecuteInputRequest(inputRequest);
var expected = cmd;
var actual = promtpService.RunCommandValue;
Assert.Equal(expected, actual);
}
