public void Read_NonAsciiChars()
{
IInputReader stream = CreateInputStream("éすå");
Assert.AreEqual('é', stream.Read());
Assert.AreEqual('す', stream.Read());
Assert.AreEqual('å', stream.Read());
}
public void Should_Parse_Empty_String_As_Empty_CommandName(string consoleInput)
{
_mockInputReader.Read().Returns(consoleInput);
var input = _parser.Parse();
input.CommandName.Should().BeEmpty();
input.CommandParameters.Should().BeEmpty();
}
public void Read_ReadsCharAtPosition()
{
IInputReader stream = CreateInputStream("abc");
stream.Read();
char result = (char)stream.Read();
Assert.AreEqual('b', result);
}
public bool ShowModal(string message, string acceptText, string denyText)
{
_logger.Log(message);
string answer = _reader.Read();
if (answer == denyText)
{
return(false);
}
return(true);
}
public void GetPosition_ReadNewLine()
{
IInputReader stream = CreateInputStream("abc\nxyz");
stream.Read();
stream.Read();
stream.Read();
stream.Read();
Position position = stream.GetPosition();
Assert.AreEqual(2, position.Line, "Line");
Assert.AreEqual(1, position.Column, "Column");
}
public override void Tick()
{
if (canRead)
{
inputReader.Read();
}
}
public void EndOfStream_NoCharsLeftToRead_ReturnsTrue()
{
IInputReader stream = CreateInputStream("a");
stream.Read();
Assert.IsTrue(stream.EndOfStream);
}
public void EndOfStream_CharsLeftToRead_ReturnsFalse()
{
IInputReader stream = CreateInputStream("abc");
stream.Read();
Assert.IsFalse(stream.EndOfStream);
}
public void Read_EndOfString_ReturnsCharNull()
{
IInputReader stream = CreateInputStream("");
char result = stream.Read();
Assert.AreEqual('\0', result);
}
public void Read_NewReader_ReturnsFirstChar()
{
IInputReader stream = CreateInputStream("abc");
char result = (char)stream.Read();
Assert.AreEqual('a', result);
}
public override void Tick()
{
if (canMove)
{
playerInputReader.Read();
playerMovement.Tick();
}
}
public void Seek_UpdatesPosition()
{
IInputReader stream = CreateInputStream("abc");
Position position = stream.GetPosition();
stream.Read();
stream.Read();
stream.Seek(position);
Position newPosition = stream.GetPosition();
Assert.AreEqual(position, newPosition);
char result = (char)stream.Read();
Assert.AreEqual('a', result);
}
public void CreateCams()
{
var input = _reader.Read(_config.InputPath);
var aCamTriangles = _triangleConverter.Convert(input.ACam).ToList();
var bCamTriangles = _triangleConverter.Convert(input.BCam).ToList();
_writer.Write(aCamTriangles, _config.ACamPath);
_writer.Write(bCamTriangles, _config.BCamPath);
}
public void GetPosition_Read_DoesNotUpdateReturnedPosition()
{
IInputReader stream = CreateInputStream("abc");
Position position = stream.GetPosition();
stream.Read();
Assert.AreEqual(1, position.Line, "Line");
Assert.AreEqual(1, position.Column, "Column");
}
public IEither <char, ParseError> Parse(IInputReader input)
{
if (input.EndOfStream)
{
return(ParseResult.Error <char>(input, "Unexpected end of input"));
}
char c = input.Read();
return(ParseResult.Success(c));
}
private static void RunBusinessLogic()
{
var data = _reader.Read();
var clearData = _cleaner.Clean(data);
var warehouseItems = clearData.Select(datum => _warehouseItemDtoMapper.Map(datum)).ToList();
_warehouseFillerRepo.Fill(warehouseItems);
var report = _reportGenerator.GenerateReport(_warehouseRepo.GetAll());
Console.WriteLine(report);
}
public void Execute()
{
var input = inputReader.Read();
logger.Log("Cache Invalidation Started");
var urls = input.UrlsSeparatedByComma.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
new CacheInvalidator(logger, input.ApiKey, input.ApiSecret, input.NotificationEmail)
.InvalidateCache(urls);
logger.Log("Cache Invalidation Submission Completed");
}
static void Main(string[] args)
{
_inputReader = new InputReader();
_outputWriter = new OutputWriter();
_equationFormer = new EquationFormer();
while (true)
{
var input = _inputReader.Read();
var result = _equationFormer.GetCanonicalForm(input);
_outputWriter.Write(result.ToString());
}
}
private void _getFileInput()
{
var path = _fileInput.GetFileInput();
var extension = Path.GetExtension(path);
// Get input reader based on extension of given path
InputReaderFactory inputReaderFactory = new InputReaderFactory();
IInputReader inputReader = inputReaderFactory.GetInputReader(extension);
// Get node and edge list from input reader
inputReader.Read(path);
_nodes = inputReader.CreateNodeList();
_edges = inputReader.CreateEdgeList();
}
public Artifacts RunOnInputReader(IInputReader inputReader, IDiagnostics diagnostics)
{
try
{
var input = inputReader.Read();
var preprocessed = this.preprocessor.PreprocessInput(input, diagnostics);
var tokens = this.lexer.Scan(preprocessed, diagnostics);
var tokensFiltered = tokens.Where(x => !KjuAlphabet.Whitespace.Equals(x.Category));
var tree = this.parser.Parse(tokensFiltered, diagnostics);
var ast = this.parseTreeToAstConverter.GenerateAst(tree, diagnostics);
this.nameResolver.Run(ast, diagnostics);
this.typeChecker.Run(ast, diagnostics);
this.returnChecker.Run(ast, diagnostics);
this.variableAndFunctionBuilder.BuildFunctionsAndVariables(ast);
var functionsIR = this.intermediateGenerator.CreateIR(ast);
if (!functionsIR.Any(x => x.Key.MangledName == "_ZN3KJU3kjuEv"))
{
diagnostics.Add(new Diagnostic(
DiagnosticStatus.Error,
NoEntryPointDiagnosticType,
"No kju function",
new List <Range> {
}));
throw new CompilerException("No kju function", new Exception());
}
var dataSectionHeader = this.asmHeaderGenerator.GenerateDataSectionHeader();
var dataSection = this.dataTypeLayoutGenerator.GenerateDataLayouts(ast).Prepend(dataSectionHeader);
var asmHeader = this.asmHeaderGenerator.GenerateHeader();
var functionsAsm = functionsIR.SelectMany(x => this.functionToAsmGenerator.ToAsm(x.Key, x.Value))
.ToList();
var asm = functionsAsm.Prepend(asmHeader).Concat(dataSection).ToList();
return(new Artifacts(ast, asm));
}
catch (Exception ex) when(
ex is PreprocessorException ||
ex is LexerException ||
ex is ParseException ||
ex is ParseTreeToAstConverterException ||
ex is NameResolverException ||
ex is TypeCheckerException ||
ex is ReturnCheckerException ||
ex is FunctionBodyGeneratorException)
{
throw new CompilerException("Compilation failed.", ex);
}
}
public void Start()
{
string[] inputLines = _inputReader.Read();
var warehouses = _inputParser.Parse(inputLines);
foreach (var warehouse in warehouses)
{
Console.WriteLine($"{warehouse.Name} (total {warehouse.Materials.Sum(x => x.Quantity)})");
foreach (var material in warehouse.Materials)
{
Console.WriteLine($"{material.Id}: {material.Quantity}");
}
Console.WriteLine();
}
}
public IInput Parse()
{
var inputString = _reader.Read();
if (string.IsNullOrEmpty(inputString) || string.IsNullOrWhiteSpace(inputString))
{
return(new ConsoleInput(string.Empty, string.Empty));
}
var inputParts = inputString.Split(' ');
if (inputParts.Length >= 2)
{
return(new ConsoleInput(inputParts[0], inputParts[1]));
}
return(new ConsoleInput(inputString, string.Empty));
}
public void Run(IEnumerable <string> filepaths)
{
var imageTotalCounter = 0;
var tableTotalCounter = 0;
foreach (var filepath in filepaths)
{
var file = new MarkdownFile()
{
FilePath = filepath
};
_inputReader.Read(file);
_markdownChecker.Check(file);
imageTotalCounter += file.ImageCount;
tableTotalCounter += file.TableCount;
}
_outputWriter.Send(Utility.GetTotalImageCount(imageTotalCounter));
_outputWriter.Send(Utility.GetTotalTableCount(tableTotalCounter));
}
public void Run()
{
_writer.Write("Enter a command. (Hit ENTER to exit)");
while (true)
{
var input = _reader.Read();
if (string.IsNullOrEmpty(input))
{
break;
}
try
{
_commandHandler.ExecuteCommand(input);
}
catch (Exception e)
{
_writer.Write(e.Message);
}
}
}
public async Task Run()
{
Console.WriteLine("Starting Application");
// Start Emulator to Listen incoming Commands;
var emulatorListen = _emulator.ListenCommand();
// Start Command Sender to Listen Input Commands
var commandListen = _commandSender.Start();
// Start Logger to Listen Logs
var logListen = _logger.Listen();
// Listen to Inputs
var inputListen = _input.Read();
await emulatorListen;
await commandListen;
await logListen;
await inputListen;
Console.WriteLine("Closing Application...");
}
public string ReadInput(string path)
{
return(_inputReader.Read(path));
}
public void Should_Print_Exit_Command()
{
_inputReader.Read().Returns("e");
_shell.Start();
_printer.Received(1).Print("Application terminated");
}
private string GetInput()
{
return(_inputReader.Read());
}
public override void Tick()
{
gameStateInputReader?.Read();
}
private void Update()
{
inputReader?.Read();
}
