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