public bool ShouldRunCounter(CommandLineArgumentsParser parser, out NotRunReason notRunReason) { notRunReason = NotRunReason.None; if (!parser.IsValidNumberOfArguments()) { notRunReason = NotRunReason.InvalidNumberOfArguments; return(false); } if (parser.IsHelp()) { notRunReason = NotRunReason.Help; return(false); } var path = parser.GetPath(); var pathType = PathTypeDetection.GetPathType(path); if (pathType == PathType.Undefined) { notRunReason = NotRunReason.PathDoesNotExist; return(false); } return(true); }
public void ParsingThrowsExceptionWhenNoArguments() { var parser = new CommandLineArgumentsParser(); var args = new string[] { }; Assert.Throws <ArgumentException>(() => parser.Parse(args)); }
public CommandArgument(CommandLineArgumentsParser parser) { _parser = parser; Password = GetValueOrDefault(parser, PasswordField, "God bless me"); Action = GetValueOrDefault(parser, ActionField, "e"); OriginalFile = GetValueOrDefault(parser, OriginalFileField, ""); EncryptedFileName = GetValueOrDefault(parser, EncryptedFileField, ""); DecryptedFileName = GetValueOrDefault(parser, DecryptedFileField, ""); }
private ParsedArguments GetResultsForArgs( string[] args) { var parser = new CommandLineArgumentsParser(); ParsedArguments result = parser.ParseArgs(args); return(result); }
public void Parser_PerformSum_Invalid_Command() { // arrange // act var parser = new CommandLineArgumentsParser(); var args = "S x1 y1 x2 y2 x3 y3"; // assert Assert.ThrowsException <ParserException>(() => parser.Parse(args)); }
public void Parser_InsertNumber_Invalid_Command() { // arrange // act var parser = new CommandLineArgumentsParser(); var args = "N x1 y1 v1"; // assert Assert.ThrowsException <ParserException>(() => parser.Parse(args)); }
public void Parser_CreateNewSpreadSheet_Invalid_Command() { // arrange // act var parser = new CommandLineArgumentsParser(); var args = "C w h"; // assert Assert.ThrowsException <ParserException>(() => parser.Parse(args)); }
public void ParsingThrowsExceptionWhenOnlyOneArgument() { var parser = new CommandLineArgumentsParser(); var args = new string[] { CommandLineArguments.Keys.Compress, }; Assert.Throws <ArgumentException>(() => parser.Parse(args)); }
/// <summary> /// Signals the external command line args. /// </summary> /// <param name="args">The args.</param> /// <returns>The Boolean.</returns> /// <remarks>...</remarks> public override bool SignalExternalCommandLineArgs(IList <string> args) { var parser = CommandLineArgumentsParser.Parse(args.ToArray()); if (Settings.IsProMode) { } return(base.SignalExternalCommandLineArgs(args)); }
public void Parser_Invalid_Command_Spaces() { // arrange // act var parser = new CommandLineArgumentsParser(); var args = " C -2 -2 "; // assert Assert.ThrowsException <ParserException>(() => parser.Parse(args)); }
public void ParsingThrowsExceptionWhenDDSFileHasInvalidExtension() { var parser = new CommandLineArgumentsParser(); var args = new string[] { CommandLineArguments.Keys.Compress, "file.bmp", "file.txt" }; Assert.Throws <ArgumentException>(() => parser.Parse(args)); }
public void ParsingThrowsExceptionWhenFormatMissing() { var parser = new CommandLineArgumentsParser(); var args = new string[] { CommandLineArguments.Keys.Compress, "file.bmp", "file.dds" }; Assert.Throws <ArgumentException>(() => parser.Parse(args)); }
public void Parser_Quit_Command() { // arrange var parser = new CommandLineArgumentsParser(); var args = "Q"; // act var result = parser.Parse(args); // assert Assert.IsInstanceOfType(result.Command, typeof(QuitCommand)); Assert.IsInstanceOfType(result.Validator, typeof(QuitValidator)); }
private static async Task <CommandResult> RunCommandPipelineAsync(ReadOnlyCollection <string> commandLineArguments, Assembly commandAssembly, IServiceProvider provider, CancellationToken stoppingToken) { CommandLineArguments args = CommandLineArgumentsParser.Parse(commandLineArguments); Type type = CommandSelector.SelectCommand(commandAssembly, args); using CommandBase instance = CommandActivator.ConstructCommand(provider, type); CommandArgumentsBinder.BindArguments(instance, args); CommandOptionsBinder.BindOptions(instance, args); CommandResult result = await CommandExecutor.InvokeAsync(instance, stoppingToken); return(result); }
public void Parser_PerformSum_Command() { // arrange var parser = new CommandLineArgumentsParser(); var args = "S 1 1 2 1 3 1"; // act var result = parser.Parse(args); // assert Assert.IsInstanceOfType(result.Command, typeof(PerformSumCommand)); Assert.IsInstanceOfType(result.Validator, typeof(PerformSumValidator)); }
public void Parser_CreateNewSpreadSheet_Command() { // arrange var parser = new CommandLineArgumentsParser(); var args = "C 1 1"; // act var result = parser.Parse(args); // assert Assert.IsInstanceOfType(result.Command, typeof(CreateNewSpreadSheetCommand)); Assert.IsInstanceOfType(result.Validator, typeof(CreateNewSpreadSheetValidator)); }
public void ParsingThrowsExceptionWhenTooManyArguments() { var parser = new CommandLineArgumentsParser(); var args = new string[] { CommandLineArguments.Keys.Compress, CommandLineArguments.Keys.Decompress, CommandLineArguments.Keys.Overwrite, "file.bmp", "file.dds" }; Assert.Throws <ArgumentException>(() => parser.Parse(args)); }
public void ParsingThrowsExceptionWhenUnknownFormat() { const char UnknownFormat = '9'; var parser = new CommandLineArgumentsParser(); var args = new string[] { $"{CommandLineArguments.Keys.Compress}{UnknownFormat}", "file.bmp", "file.dds" }; Assert.Throws <ArgumentException>(() => parser.Parse(args)); }
public void Parse_AllArgumentsAreValid_ReturnParameters() { var parameters = new FileReaderWriterParameters(String.Empty, string.Empty, new List <int>() { 1 }); var args = new[] { string.Empty, string.Empty, "1" }; var result = CommandLineArgumentsParser.Parse(args); Assert.That(result.InputPath, Is.EqualTo(parameters.InputPath)); Assert.That(result.OutputPath, Is.EqualTo(parameters.OutputPath)); Assert.That(result.Lines, Is.EqualTo(parameters.Lines)); }
public void ParsingCompressOption(char key, Type compressionFormatType) { var parser = new CommandLineArgumentsParser(); var args = new string[] { $"{CommandLineArguments.Keys.Compress}{key}", "file.bmp", "file.dds" }; var result = parser.Parse(args); Assert.AreEqual(ImageOperation.Compress, result.Operation); Assert.IsNotNull(result.Format); Assert.AreEqual(compressionFormatType, result.Format.GetType()); Assert.AreEqual("file.bmp", result.BMPFileName); Assert.AreEqual("file.dds", result.DDSFileName); }
public void ParseDecompressOption() { var parser = new CommandLineArgumentsParser(); var args = new string[] { CommandLineArguments.Keys.Decompress, "file.bmp", "file.dds" }; var result = parser.Parse(args); Assert.AreEqual(ImageOperation.Decompress, result.Operation); Assert.IsNull(result.Format); Assert.IsFalse(result.Overwrite); Assert.AreEqual("file.bmp", result.BMPFileName); Assert.AreEqual("file.dds", result.DDSFileName); }
public void ParseOverwriteOption() { var parser = new CommandLineArgumentsParser(); var args = new string[] { $"{CommandLineArguments.Keys.Compress}{CommandLineArguments.Keys.BC1Format}", CommandLineArguments.Keys.Overwrite, "file.bmp", "file.dds" }; var result = parser.Parse(args); Assert.AreEqual(ImageOperation.Compress, result.Operation); Assert.IsNotNull(result.Format); Assert.IsTrue(result.Overwrite); Assert.AreEqual("file.bmp", result.BMPFileName); Assert.AreEqual("file.dds", result.DDSFileName); }
static int Main(string[] args) { var parameterPool = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase) { { Constants.SolutionsDirectoryParameterName, Constants.SolutionsDirectory }, { Constants.PackagesDirectoryParameterName, Constants.PackagesDirectory }, { Constants.SolutionStorageConnectionStringParameterName, Constants.SolutionStorageConnectionString } }; InformationPrinter info = new InformationPrinter(parameterPool); if (args.Length == 0) { info.PrintUsage(); return(1); } if (args[0].Equals("help", StringComparison.InvariantCultureIgnoreCase)) { if (args.Length == 2) { info.PrintCommandDescription(args[1]); } else { info.PrintAvailableCommands(); } return(0); } var clArgsParser = new CommandLineArgumentsParser(args); var command = clArgsParser.Command; var phaseSequence = PhaseListProvider.GetPhaseSequence(command); clArgsParser.Parameters.ToList().ForEach(p => parameterPool[p.Key] = p.Value); var phaseSequenceExecutor = new PhaseSequenceExecutor(phaseSequence, parameterPool); phaseSequenceExecutor.Run(); return(0); }
public static void Main(string[] args) { try { var commandLineArgumentsParser = new CommandLineArgumentsParser(); ParsedArguments parsedArguments = commandLineArgumentsParser.ParseArgs(args); var printScreenFactory = new PrintScreenFactory(); var config = new CommandLineArgsConfiguration(parsedArguments); var factory = new DbmsFactory(config.DbType, config.DbConnectionString); var databaseSchemaVersion = new DatabaseSchemaVersionManager(factory, config.DbDeltaSet, config.CurrentDbVersion, config.TableName, config.ChangeOwner); var directoryInfo = new DirectoryInfo(parsedArguments.GetScriptFilesFolderOrDefaultFolder()); TextWriter outputPrintStream = printScreenFactory.GetDoPrintStream(parsedArguments); var dbmsSyntax = factory.CreateDbmsSyntax(config.ChangeOwner); var useTransaction = config.UseTransaction; TextWriter undoOutputPrintStream = printScreenFactory.GetUndoPrintStream(parsedArguments); var toPrintStreamDeployer = new ToPrintStreamDeployer(databaseSchemaVersion, directoryInfo, outputPrintStream, dbmsSyntax, useTransaction, undoOutputPrintStream); toPrintStreamDeployer.DoDeploy(LastVersionChangeToApply); printScreenFactory.ClosePrintStream(outputPrintStream); printScreenFactory.ClosePrintStream(undoOutputPrintStream); } catch (DbDeployException ex) { Console.Error.WriteLine(ex.Message); Environment.Exit(1); } catch (Exception ex) { Console.Error.WriteLine("Failed to apply changes: " + ex); Console.Error.WriteLine(ex.StackTrace); Environment.Exit(2); } }
public static void Main(string[] args) { var parser = new CommandLineArgumentsParser(args); var printer = new Printer(); var validator = new ArgumentsValidator(); NotRunReason reason; if (validator.ShouldRunCounter(parser, out reason)) { var path = parser.GetPath(); var pathType = PathTypeDetection.GetPathType(path); var fileExtensions = parser.GetFileExtensions(); var linesCounter = new PathLinesCounter(pathType, fileExtensions); var count = linesCounter.GetCount(path); printer.PrintLinesOfCode(count); } else { printer.Print(reason, parser); } }
static void Main(string[] args) { ICommandLineArgumentsParser parser = new CommandLineArgumentsParser(); IPrinter printer = new Printer.Printer(); var spreadSheet = new SpreadSheet(); while (true) { Console.Write("enter command: "); var input = Console.ReadLine(); try { var parseResult = parser.Parse(input); var command = parseResult.Command; var validator = parseResult.Validator; command.ExecuteCommand(spreadSheet, validator); printer.Print(spreadSheet); } catch (Exception ex) { Console.WriteLine(ex.Message); } } }
private static CommandLineArguments Parse(params string[] args) { return(CommandLineArgumentsParser.Parse(Array.AsReadOnly(args))); }
public void CannotParseNull() { Assert.Throws <ArgumentNullException>("args", () => CommandLineArgumentsParser.Parse(null)); }
private string GetValueOrDefault(CommandLineArgumentsParser parser, string field, string defaultVal) { return(parser[field] ?? defaultVal); }
public void Parse_OneOfLineNumberIsNotPositive_ThrowArgumentsException() { var args = new[] { string.Empty, string.Empty, "-1" }; Assert.That(() => CommandLineArgumentsParser.Parse(args), Throws.ArgumentException); }