public void InvalidateParse()
{
AggregateNumbers aggregateNos = new AggregateNumbers();
CommandLineArguments parser = new CommandLineArguments();
//add parameters
parser.Parameter(ArgumentType.Required, "InputFile", ArgumentValueType.String, "i", "File containing numbers to add");
parser.Parameter(ArgumentType.Required, "ResultFile", ArgumentValueType.String, "r", "File to store output");
string outputfileName = Path.GetTempFileName().Replace(Path.GetTempPath(), "");
//pass parameter without value
try
{
string[] args = { "/InputFile:", "/ResultFile:" + outputfileName };
parser.Parse(args, aggregateNos);
Assert.Fail();
}
catch (ArgumentParserException ex)
{
ApplicationLog.WriteLine("CommandLineArguments P2: Successfully caught InvalidArgumentValueException : " + ex.Message);
}
//pass invalid starting character
try
{
string[] args = { "*/ResultFile:" + outputfileName };
parser.Parse(args, aggregateNos);
Assert.Fail();
}
catch (ArgumentParserException ex)
{
ApplicationLog.WriteLine("CommandLineArguments P2: Successfully caught ArgumentNullException : " + ex.Message);
}
}
public void ValidateGetEnumerator()
{
AggregateNumbers aggregateNos = new AggregateNumbers();
CommandLineArguments parser = new CommandLineArguments();
//add parameters
parser.Parameter(ArgumentType.Required, "InputFile", ArgumentValueType.String, "i", "File containing numbers to add");
parser.Parameter(ArgumentType.Required, "ResultFile", ArgumentValueType.String, "r", "File to store output");
string inputfileName = Path.GetTempFileName().Replace(Path.GetTempPath(), "");
string outputfileName = Path.GetTempFileName().Replace(Path.GetTempPath(), "");
string[] args = { "-InputFile:" + inputfileName, "-ResultFile:" + outputfileName };
parser.Parse(args, aggregateNos);
IEnumerator parsedVals = parser.GetEnumerator();
Assert.IsNotNull(parsedVals);
string current = string.Empty;
int count = 0;
parser.Reset();
while (parser.MoveNext())
{
current = parser.Current.ToString();
ApplicationLog.WriteLine(current);
count++;
}
Assert.AreEqual(2, count);
}
public static VennToolArguments ProcessCommandLineArguments(string[] args)
{
VennToolArguments parsedArgs = new VennToolArguments();
CommandLineArguments parser = new CommandLineArguments();
// Add parameters
parser.Parameter(ArgumentType.DefaultArgument, "regionArray", ArgumentValueType.MultipleInts, "",
"Values 3 or 7 values for regions in chart, [A B AB] or [A B C AB AC BC ABC]");
parser.Parameter(ArgumentType.Optional, "xl", ArgumentValueType.String, "", "XL OutputFile");
parser.Parameter(ArgumentType.Optional, "polar", ArgumentValueType.Bool, "", "Write result using polar coordinates");
parser.Parameter(ArgumentType.Optional, "presort", ArgumentValueType.Bool, "", "PreSort .BED files prior to processing");
parser.Parameter(ArgumentType.Optional, "Verbose", ArgumentValueType.Bool, "v", "Display Verbose output during processing");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "h", "Print the help information.");
try
{
parser.Parse(args, parsedArgs);
}
catch(ArgumentParserException ex)
{
Console.Error.WriteLine(ex.Message);
DisplayHelpScreen();
Environment.Exit(-1);
}
if (parsedArgs.Help)
{
DisplayHelpScreen();
Environment.Exit(-1);
}
/*
* Do any and all follow-up command line argument validation required
*/
if ((parsedArgs.regionArray == null)
|| ((parsedArgs.regionArray.Length != 3) && (parsedArgs.regionArray.Length != 7)))
{
Console.Error.WriteLine("\nProcessCommandLineArguments failed to find the expected number of arguments. [3 or 7]");
Environment.Exit(-1);
}
if (parsedArgs.Verbose)
{
Console.WriteLine(parsedArgs.Verbose);
Console.Write("RegionArray Size: {0}\n [", parsedArgs.regionArray.Length);
for (int i = 0; i < parsedArgs.regionArray.Length; ++i)
{
if (i == 0)
Console.Write(parsedArgs.regionArray[i]);
else
Console.Write(", {0}", parsedArgs.regionArray[i]);
}
Console.WriteLine("]");
}
return parsedArgs;
}
/// <summary>
/// Parses NUCmer command line parameters.
/// </summary>
/// <param name="args">The arguments.</param>
private static void Alignment(string[] args)
{
NucmerArguments arguments = new NucmerArguments();
CommandLineArguments parser = new CommandLineArguments();
// Add Nucmer parameters
parser.Parameter(ArgumentType.DefaultArgument, "FilePath", ArgumentValueType.MultipleUniqueStrings, "", "File path");
parser.Parameter(ArgumentType.Optional, "Mum", ArgumentValueType.Bool, "m", "Use anchor matches that are unique in both the reference and query.");
parser.Parameter(ArgumentType.Optional, "MumReference", ArgumentValueType.Bool, "r", "Use anchor matches that are unique in the reference but not necessarily unique in the query (default behavior).");
parser.Parameter(ArgumentType.Optional, "MaxMatch", ArgumentValueType.Bool, "x", "Use all anchor matches regardless of their uniqueness.");
parser.Parameter(ArgumentType.Optional, "BreakLength", ArgumentValueType.Int, "b", "Distance an alignment extension will attempt to extend poor scoring regions before giving up (default 200).");
parser.Parameter(ArgumentType.Optional, "MinCluster", ArgumentValueType.Int, "c", "Minimum cluster length (default 65).");
parser.Parameter(ArgumentType.Optional, "DiagFactor", ArgumentValueType.Int, "d", "Maximum diagonal difference factor for clustering, i.e. diagonal difference / match separation (default 0.12).");
parser.Parameter(ArgumentType.Optional, "Forward", ArgumentValueType.Bool, "f", "Use only the forward strand of the query sequence.");
parser.Parameter(ArgumentType.Optional, "MaxGap", ArgumentValueType.Int, "g", "Maximum gap between two adjacent matches in a cluster (default 90).");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "h", "Print the help information.");
parser.Parameter(ArgumentType.Optional, "MinMatch", ArgumentValueType.Int, "l", "Minimum length of an maximal exact match (default 20).");
parser.Parameter(ArgumentType.Optional, "OutputFile", ArgumentValueType.String, "o", "Output file");
parser.Parameter(ArgumentType.Optional, "Reverse", ArgumentValueType.Bool, "e", "Use only the reverse complement of the query sequence.");
parser.Parameter(ArgumentType.Optional, "NotExtend", ArgumentValueType.Bool, "n", "Toggle the outward extension of alignments from their anchoring clusters." +
"Setting this flag will prevent alignment extensions but still align the DNA between clustered matches and create the .delta file.");
parser.Parameter(ArgumentType.Optional, "Verbose", ArgumentValueType.Bool, "v", "Display verbose logging during processing.");
parser.Parameter(ArgumentType.Optional, "FixedSeparation", ArgumentValueType.Bool, "s", "Maximum fixed diagonal difference.");
if (args.Length > 1)
{
try
{
parser.Parse(args, arguments);
}
catch (ArgumentException ex)
{
DisplayErrorMessage(ex.Message);
DisplayErrorMessage(Resources.NUCmerUtilHelp);
}
if (arguments.Help)
{
DisplayErrorMessage(Resources.NUCmerUtilHelp);
}
else if (arguments.FilePath.Length == 2)
{
arguments.Align();
}
else
{
DisplayErrorMessage(Resources.NUCmerUtilHelp);
}
}
else
{
DisplayErrorMessage(Resources.NUCmerUtilHelp);
}
}
/// <summary>
/// Parses ScaffoldGeneration command line parameters.
/// </summary>
/// <param name="args">The arguments.</param>
private static void ScaffoldGeneration(string[] args)
{
ScaffoldArguments arguments = new ScaffoldArguments();
CommandLineArguments parser = new CommandLineArguments();
// Add scaffold parameters
parser.Parameter(ArgumentType.DefaultArgument, "FilePath", ArgumentValueType.MultipleUniqueStrings, "", "File path");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "h", "Print the help information.");
parser.Parameter(ArgumentType.Optional, "OutputFile", ArgumentValueType.String, "o", "Output file");
parser.Parameter(ArgumentType.Optional, "Verbose", ArgumentValueType.Bool, "v", "Display verbose logging during processing.");
parser.Parameter(ArgumentType.Optional, "KmerLength", ArgumentValueType.Int, "k", "Length of k-mer");
parser.Parameter(ArgumentType.Optional, "Redundancy", ArgumentValueType.Int, "r", "Number of paired read required to connect two contigs.");
parser.Parameter(ArgumentType.Optional, "Depth", ArgumentValueType.Int, "d", "Depth for graph traversal.");
parser.Parameter(ArgumentType.Optional, "CloneLibraryName", ArgumentValueType.String, "n", "Clone Library Name");
parser.Parameter(ArgumentType.Optional, "MeanLengthOfInsert", ArgumentValueType.Int, "i", "Mean Length of clone library.");
parser.Parameter(ArgumentType.Optional, "StandardDeviationOfInsert", ArgumentValueType.Int, "sd", "Standard Deviation of Clone Library.");
if (args.Length > 1)
{
try
{
parser.Parse(args, arguments);
}
catch (ArgumentParserException ex)
{
DisplayErrorMessage(ex.Message);
DisplayErrorMessage(Resources.ScaffoldUtilHelp);
Environment.Exit(-1);
}
if (arguments.Help)
{
DisplayErrorMessage(Resources.ScaffoldUtilHelp);
}
else if (arguments.FilePath.Length == 2)
{
arguments.GenerateScaffolds();
}
else
{
DisplayErrorMessage(Resources.ScaffoldUtilHelp);
}
}
else
{
DisplayErrorMessage(Resources.ScaffoldUtilHelp);
}
}
public void ValidateCommandLineArguments()
{
AggregateNumbers aggregateNos = new AggregateNumbers();
CommandLineArguments parser = new CommandLineArguments();
//add parameters
parser.Parameter(ArgumentType.Required, "InputFile", ArgumentValueType.String, "i", "File containing numbers to add");
parser.Parameter(ArgumentType.Required, "ResultFile", ArgumentValueType.String, "r", "File to store output");
string inputfileName = Path.GetTempFileName().Replace(Path.GetTempPath(), "");
string outputfileName = Path.GetTempFileName().Replace(Path.GetTempPath(), "");
string[] args = { "-InputFile:" + inputfileName , "-ResultFile:" + outputfileName };
parser.Parse(args, aggregateNos);
Assert.IsNotNull(parser);
Assert.IsTrue(aggregateNos.InputFile.Contains(inputfileName));
Assert.IsTrue(aggregateNos.ResultFile.Contains(outputfileName));
}
/// <summary>
/// Parses RepeatResolver command line parameters.
/// </summary>
/// <param name="args">The arguments.</param>
private static void RepeatResolver(string[] args)
{
LayoutRefinementArguments arguments = new LayoutRefinementArguments();
CommandLineArguments parser = new CommandLineArguments();
// Add parameters
parser.Parameter(ArgumentType.DefaultArgument, "FilePath", ArgumentValueType.MultipleUniqueStrings, "", "File path");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "h", "Print the help information.");
parser.Parameter(ArgumentType.Optional, "OutputFile", ArgumentValueType.String, "o", "Output file");
parser.Parameter(ArgumentType.Optional, "Verbose", ArgumentValueType.Bool, "v", "Display verbose logging during processing.");
if (args.Length > 1)
{
try
{
parser.Parse(args, arguments);
}
catch (ArgumentException ex)
{
Output.WriteLine(OutputLevel.Error, ex.Message);
Output.WriteLine(OutputLevel.Required, Resources.LayoutRefinementUtilHelp);
return;
}
if (arguments.Help || arguments.FilePath.Length != 2)
{
Output.WriteLine(OutputLevel.Required, Resources.LayoutRefinementUtilHelp);
}
else
{
if (arguments.Verbose)
Output.TraceLevel = OutputLevel.Information | OutputLevel.Verbose;
else
Output.TraceLevel = OutputLevel.Information;
arguments.RefineLayout();
}
}
else
{
Output.WriteLine(OutputLevel.Required, Resources.LayoutRefinementUtilHelp);
}
}
/// <summary>
/// ConvertFileFormat method that will call the appropriate class to perform
/// file conversion, this class using the command line parser to parse
/// command line options and then calls the FileFormatConverter.convertFile method
/// which does the work
/// </summary>
/// <param name="args"></param>
private static void ConvertFileFormat(string[] args)
{
var ffc = new FileFormatConverter();
var parser = new CommandLineArguments();
//add parameters
parser.Parameter(
ArgumentType.DefaultArgument,
"FileList",
ArgumentValueType.MultipleUniqueStrings,
"",
"Input and Output files.");
if (args.Length > 0)
{
try
{
parser.Parse(args, ffc);
}
catch (ArgumentException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(Resources.UsageHelp);
Environment.Exit(-1);
}
if (ffc.FileList.Length != 2)
{
Console.WriteLine(GetUsageMessage(ffc));
}
else
{
ffc.InputFile = ffc.FileList[0];
ffc.OutputFile = ffc.FileList[1];
ffc.ConvertFile();
}
}
else
{
Console.WriteLine(GetUsageMessage(ffc));
}
}
/// <summary>
/// Parses RepeatResolver command line parameters.
/// </summary>
/// <param name="args">The arguments.</param>
private static void RepeatResolver(string[] args)
{
RepeatResolutionArguments arguments = new RepeatResolutionArguments();
CommandLineArguments parser = new CommandLineArguments();
// Add parameters
parser.Parameter(ArgumentType.DefaultArgument, "FilePath", ArgumentValueType.MultipleUniqueStrings, "", "File path");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "h", "Print the help information.");
parser.Parameter(ArgumentType.Optional, "OutputFile", ArgumentValueType.String, "o", "Output file.");
parser.Parameter(ArgumentType.Optional, "Verbose", ArgumentValueType.Bool, "v", "Display verbose logging during processing.");
if (args.Length > 1)
{
try
{
parser.Parse(args, arguments);
}
catch (ArgumentException ex)
{
DisplayErrorMessage(ex.Message);
DisplayErrorMessage(Resources.RepeatResolutionUtilHelp);
Environment.Exit(-1);
}
if (arguments.Help)
{
DisplayErrorMessage(Resources.RepeatResolutionUtilHelp);
}
else if (arguments.FilePath.Length == 2)
{
arguments.ResolveAmbiguity();
}
else
{
DisplayErrorMessage(Resources.RepeatResolutionUtilHelp);
}
}
else
{
DisplayErrorMessage(Resources.RepeatResolutionUtilHelp);
}
}
/// <summary>
/// Parses ConsensusGeneration command line parameters.
/// </summary>
/// <param name="args">The arguments.</param>
private static void ConsensusGeneration(string[] args)
{
ConsensusArguments arguments = new ConsensusArguments();
CommandLineArguments parser = new CommandLineArguments();
// Add the parameters
parser.Parameter(ArgumentType.DefaultArgument, "FilePath", ArgumentValueType.MultipleUniqueStrings, "", "File path");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "h", "Print the help information.");
parser.Parameter(ArgumentType.Optional, "OutputFile", ArgumentValueType.String, "o", "Output file.");
parser.Parameter(ArgumentType.Optional, "Verbose", ArgumentValueType.Bool, "v", "Display verbose logging during processing.");
if (args.Length > 1)
{
try
{
parser.Parse(args, arguments);
}
catch (ArgumentException ex)
{
Output.WriteLine(OutputLevel.Error, ex.Message);
Output.WriteLine(OutputLevel.Required, Resources.ConsensusUtilHelp);
Environment.Exit(-1);
}
if (arguments.Help || arguments.FilePath.Length != 2)
{
Output.WriteLine(OutputLevel.Required, Resources.ConsensusUtilHelp);
}
else
{
arguments.GenerateConsensus();
}
}
else
{
Output.WriteLine(OutputLevel.Required, Resources.ConsensusUtilHelp);
}
}
/// <summary>
/// Assemble function.
/// </summary>
/// <param name="args">Arguments to Assemble.</param>
private static void Assemble(string[] args)
{
AssembleArguments options = new AssembleArguments();
CommandLineArguments parser = new CommandLineArguments();
AddParameters(parser);
if (args.Length > 0)
{
try
{
parser.Parse(args, options);
}
catch (ArgumentParserException ex)
{
Output.WriteLine(OutputLevel.Error, ex.Message);
Output.WriteLine(OutputLevel.Required, Resources.AssembleHelp);
Environment.Exit(-1);
}
if (options.Help || options.FilePath == null)
{
Output.WriteLine(OutputLevel.Required, Resources.AssembleHelp);
}
else
{
if (options.Verbose)
Output.TraceLevel = OutputLevel.Information | OutputLevel.Verbose;
else
Output.TraceLevel = OutputLevel.Information;
options.AssembleSequences();
}
}
else
{
Output.WriteLine(OutputLevel.Required, Resources.AssembleHelp);
}
}
/// <summary>
/// Parse command line arguments for Sequence Item Possible Occurence
/// </summary>
/// <param name="args">Array of command line arguments.</param>
private static void SeqPossibleOccurence(string[] args)
{
SequenceCoverage options = new SequenceCoverage();
CommandLineArguments parser = new CommandLineArguments();
// Add the parameters
parser.Parameter(ArgumentType.Optional, "SAMInput", ArgumentValueType.Bool, "S", "Input is SAM format");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "", "");
try
{
parser.Parse(args, options);
}
catch (ArgumentParserException ex)
{
DisplayErrorMessage(ex.Message);
DisplayErrorMessage(Resources.DNAPossibleOccurenceHelp);
Environment.Exit(-1);
}
if (options.Help)
{
DisplayErrorMessage(Resources.DNAPossibleOccurenceHelp);
}
else
{
options.DisplaySequenceItemOccurences(args[0], true);
}
}
/// <summary>
/// Parse command line arguments for Length anomaly regions command
/// </summary>
/// <param name="args">Array of command line arguments.</param>
private static void LengthAnomalyOption(string[] args)
{
LengthAnomaly options = new LengthAnomaly();
if (args.Length > 2)
{
CommandLineArguments parser = new CommandLineArguments();
// Add the parameters
parser.Parameter(ArgumentType.Optional, "SAMInput", ArgumentValueType.Bool, "S", "Input is SAM format");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "", "");
try
{
parser.Parse(args, options);
}
catch (ArgumentParserException ex)
{
DisplayErrorMessage(ex.Message);
DisplayErrorMessage(Resources.LengthAnomalyHelp);
Environment.Exit(-1);
}
if (options.Help)
{
DisplayErrorMessage(Resources.LengthAnomalyHelp);
}
else
{
options.LengthAnamoly(args[0],
float.Parse(args[1]), float.Parse(args[2]));
}
}
else
{
DisplayErrorMessage(Resources.LengthAnomalyHelp);
}
}
/// <summary>
/// Parse command line arguments for Orphan regions command
/// </summary>
/// <param name="args">Array of command line arguments.</param>
private static void OrphanRegionOption(string[] args)
{
Orphans options = new Orphans();
CommandLineArguments parser = new CommandLineArguments();
// Add the parameters
parser.Parameter(ArgumentType.Optional, "SAMInput", ArgumentValueType.Bool, "S", "Input is SAM format");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "", "");
try
{
parser.Parse(args, options);
}
catch (ArgumentParserException ex)
{
DisplayErrorMessage(ex.Message);
DisplayErrorMessage(Resources.OrphanRegionsHelp);
Environment.Exit(-1);
}
if (options.Help)
{
DisplayErrorMessage(Resources.OrphanRegionsHelp);
}
else
{
options.DisplayOrpanChromosomes(args[0]);
}
}
/// <summary>
/// Parse command line arguments for sort command
/// </summary>
/// <param name="args">Array of command line arguments.</param>
private static void SortOption(string[] args)
{
Sort options = new Sort();
CommandLineArguments parser = new CommandLineArguments();
// Add the parameters
parser.Parameter(ArgumentType.DefaultArgument, "InputFilename", ArgumentValueType.String, "", "File Paths");
parser.Parameter(ArgumentType.Optional, "SortByReadName", ArgumentValueType.Bool, "n", "Sort by read name");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "", "");
parser.Parameter(ArgumentType.Optional, "OutputFilename", ArgumentValueType.String, "o", "Output file name");
if (args.Length > 0)
{
try
{
parser.Parse(args, options);
}
catch (ArgumentParserException ex)
{
DisplayErrorMessage(ex.Message);
DisplayErrorMessage(Resources.SortHelp);
Environment.Exit(-1);
}
if (options.Help)
{
DisplayErrorMessage(Resources.SortHelp);
}
else
{
options.DoSort();
}
}
else
{
DisplayErrorMessage(Resources.SortHelp);
}
}
/// <summary>
/// Parse command line arguments for Merge command
/// </summary>
/// <param name="args">Array of command line arguments.</param>
private static void MergeOption(string[] args)
{
Merge options = new Merge();
CommandLineArguments parser = new CommandLineArguments();
//Add the parameters
parser.Parameter(ArgumentType.Optional, "SortByReadName", ArgumentValueType.Bool, "n", "Sort by read name");
parser.Parameter(ArgumentType.Optional, "HeaderFile", ArgumentValueType.String, "h", "Copy the Header from this file");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "", "");
parser.Parameter(ArgumentType.Optional, "OutputFilename", ArgumentValueType.String, "o", "Output file name");
parser.Parameter(ArgumentType.DefaultArgument, "FilePaths", ArgumentValueType.MultipleUniqueStrings, "", "File Paths");
if (args != null && args.Length >= 2)
{
try
{
parser.Parse(args, options);
}
catch (ArgumentParserException ex)
{
DisplayErrorMessage(ex.Message);
DisplayErrorMessage(Resources.MergeHelp);
Environment.Exit(-1);
}
if (options.Help)
{
DisplayErrorMessage(Resources.MergeHelp);
}
else
{
options.DoMerge();
}
}
else
{
DisplayErrorMessage(Resources.MergeHelp);
}
}
public void InvalidateParseWithEmptyParam()
{
try
{
AggregateNumbers aggregateNos = new AggregateNumbers();
CommandLineArguments parser = new CommandLineArguments();
//add parameters
parser.Parameter(ArgumentType.Required, "bValue", ArgumentValueType.Bool, "bv", "bool");
parser.Parameter(ArgumentType.Required, "iValue", ArgumentValueType.Int, "iv", "int");
string[] args = { "-:true", "-iValue:5" };
parser.Parse(args, aggregateNos);
Assert.Fail();
}
catch (ArgumentSyntaxException ex)
{
ApplicationLog.Write("Successfully caught ArgumentSyntaxException : " + ex.Message);
}
}
/// <summary>
/// Process the command line arguments.
/// </summary>
/// <param name="args">commandline arguments.</param>
/// <returns>Command line options.</returns>
private static CommandLineOptions ProcessCommandLine(string[] args)
{
CommandLineOptions filterReadsParams = new CommandLineOptions();
CommandLineArguments parser = new CommandLineArguments();
// Add parameters
parser.Parameter(ArgumentType.DefaultArgument, "Filename", ArgumentValueType.String, "", "Input fasta file to filter reads.");
parser.Parameter(ArgumentType.Optional, "AmbiguousOutputFile", ArgumentValueType.String, "a", "Filtered ambiguous reads output file");
parser.Parameter(ArgumentType.Optional, "OutputFile", ArgumentValueType.String, "o", "Output file");
parser.Parameter(ArgumentType.Optional, "FilterAmbiguousReads", ArgumentValueType.Bool, "fa", "Filter ambiguous reads");
parser.Parameter(ArgumentType.Optional, "Verbose", ArgumentValueType.Bool, "v", "Display Verbose logging");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "h", "Show the help information with program options and a description of program operation.");
try
{
parser.Parse(args, filterReadsParams);
}
catch (Exception e)
{
Console.Error.WriteLine("\nException while processing Command Line arguments [{0}]", e.Message);
Console.Error.WriteLine(Properties.Resource.FilterReadsUtilHelp);
Environment.Exit(-1);
}
if (filterReadsParams.OutputFile != null)
{ // redirect stdout
FileStream fsConsoleOut = new FileStream(filterReadsParams.OutputFile, FileMode.Create);
StreamWriter swConsoleOut = new StreamWriter(fsConsoleOut);
Console.SetOut(swConsoleOut);
swConsoleOut.AutoFlush = true;
}
return (filterReadsParams);
}
/// <summary>
/// Parse command line arguments for view command.
/// </summary>
/// <param name="args">Array of command line arguments.</param>
private static void ViewOption(string[] args)
{
View options = new View();
CommandLineArguments parser = new CommandLineArguments();
// Add the parameters
parser.Parameter(ArgumentType.Optional, "BAMOutput", ArgumentValueType.Bool, "b", "Output BAM");
parser.Parameter(ArgumentType.Optional, "Header", ArgumentValueType.Bool, "h", "Print header for the SAM output");
parser.Parameter(ArgumentType.Optional, "HeaderOnly", ArgumentValueType.Bool, "H", "Print header only (no alignments)");
parser.Parameter(ArgumentType.Optional, "SAMInput", ArgumentValueType.Bool, "S", "Input is SAM format");
parser.Parameter(ArgumentType.Optional, "UnCompressedBAM", ArgumentValueType.Bool, "u", "Uncompressed BAM output");
parser.Parameter(ArgumentType.Optional, "FlagInHex", ArgumentValueType.Bool, "x", "Output FLAG in HEX");
parser.Parameter(ArgumentType.Optional, "FlagAsString", ArgumentValueType.Bool, "X", "Output FLAG in string");
parser.Parameter(ArgumentType.Optional, "ReferenceNamesAndLength", ArgumentValueType.String, "t",
"List of reference names and lengths in a tab limited file rest all field will be ignored.");
parser.Parameter(ArgumentType.Optional, "ReferenceSequenceFile", ArgumentValueType.String, "T", "Reference sequence file");
parser.Parameter(ArgumentType.Optional, "OutputFilename", ArgumentValueType.String, "o", "Output file name");
parser.Parameter(ArgumentType.Optional, "FlagRequired", ArgumentValueType.Int, "f", "Required flag");
parser.Parameter(ArgumentType.Optional, "FilteringFlag", ArgumentValueType.Int, "F", "Filtering flag");
parser.Parameter(ArgumentType.Optional, "QualityMinimumMapping", ArgumentValueType.Int, "q", "Minimum mapping quality");
parser.Parameter(ArgumentType.Optional, "Library", ArgumentValueType.String, "l", "Only output reads in library");
parser.Parameter(ArgumentType.Optional, "ReadGroup", ArgumentValueType.String, "r", "Only output reads in read group");
parser.Parameter(ArgumentType.Optional, "Region", ArgumentValueType.String, "R",
"A region can be presented, for example, in the following format:\n" +
" ‘chr2’ (the whole chr2),\n" +
" ‘chr2:1000000’ (region starting from 1,000,000bp)\n" +
" or ‘chr2:1,000,000-2,000,000’\n" +
" (region between 1,000,000 and 2,000,000bp including the end points).\n" +
" The coordinate is 1-based.\n");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "?", "");
parser.Parameter(ArgumentType.DefaultArgument, "InputFilePath", ArgumentValueType.String, "", "Input SAM/BAM file path");
if (args.Length > 0)
{
try
{
parser.Parse(args, options);
}
catch (ArgumentParserException ex)
{
DisplayErrorMessage(ex.Message);
DisplayErrorMessage(Resources.ViewHelp);
Environment.Exit(-1);
}
if (options.Help)
{
DisplayErrorMessage(Resources.ViewHelp);
}
else
{
options.ViewResult();
}
}
else
{
DisplayErrorMessage(Resources.ViewHelp);
}
}
public void InvalidateParseForNullArguments()
{
AggregateNumbers aggregateNos = new AggregateNumbers();
CommandLineArguments parser = new CommandLineArguments();
try
{
parser.Parse(null, aggregateNos);
Assert.Fail("CommandLineArguments P2: Not validated parameter Method for null value");
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine("CommandLineArguments P2: Successfully validated Parameter Method for null value:", ex.Message);
}
}
/// <summary>
/// Assemble With Scaffolding.
/// </summary>
/// <param name="args">Arguments to Scaffolding.</param>
private static void AssembleWithScaffolding(string[] args)
{
AssembleWithScaffoldArguments options = new AssembleWithScaffoldArguments();
CommandLineArguments parser = new CommandLineArguments();
// add assemble related parameters.
AddAssembleParameters(parser);
// Add scaffold parameters
parser.Parameter(ArgumentType.Optional, "CloneLibraryName", ArgumentValueType.String, "n", "Clone Library Name");
parser.Parameter(ArgumentType.Optional, "MeanLengthOfInsert", ArgumentValueType.Int, "m", "Mean Length of clone library.");
parser.Parameter(ArgumentType.Optional, "StandardDeviationOfInsert", ArgumentValueType.Int, "s", "Standard Deviation of Clone Library.");
parser.Parameter(ArgumentType.Optional, "Redundancy", ArgumentValueType.Int, "b", "Number of paired read required to connect two contigs.");
parser.Parameter(ArgumentType.Optional, "Depth", ArgumentValueType.Int, "f", "Depth for graph traversal.");
if (args.Length > 0)
{
try
{
parser.Parse(args, options);
}
catch (ArgumentParserException ex)
{
Output.WriteLine(OutputLevel.Error, ex.Message);
Output.WriteLine(OutputLevel.Required, Resources.AssembleWithScaffoldHelp);
Environment.Exit(-1);
}
if (options.Help)
{
Output.WriteLine(OutputLevel.Required, Resources.AssembleWithScaffoldHelp);
}
else
{
if (!options.ForceKmer)
ValidateKmerLength(options.KmerLength, options.AllowKmerLengthEstimation);
if (options.Verbose)
Output.TraceLevel = OutputLevel.Information | OutputLevel.Verbose;
else if (!options.Quiet)
Output.TraceLevel = OutputLevel.Information;
options.AssembleSequences();
}
}
else
{
Output.WriteLine(OutputLevel.Required, Resources.AssembleWithScaffoldHelp);
}
}
public void InvalidateParseWithMissingRequiredParam()
{
try
{
AggregateNumbers aggregateNos = new AggregateNumbers();
CommandLineArguments parser = new CommandLineArguments();
//add parameters
parser.Parameter(ArgumentType.Required, "bValue", ArgumentValueType.Bool, "bv", "bool");
parser.Parameter(ArgumentType.Required, "iValue", ArgumentValueType.Int, "iv", "int");
parser.Parameter(ArgumentType.Required, "bArrValues", ArgumentValueType.Bool, "bmv", "boolArrValues");
parser.Parameter(ArgumentType.Required, "fValue", ArgumentValueType.Int, "fv", "float");
parser.Parameter(ArgumentType.Required, "dValue", ArgumentValueType.Int, "dv", "double");
parser.Parameter(ArgumentType.DefaultArgument, "usValues", ArgumentValueType.MultipleUniqueStrings, "usv", "Unique strings");
//not including the first required param
string[] args = { "-iValue:5", "-bArrValues:true" ,"false",
"-fValue:3.45", "-dValue:78.9876", "Str1", "Str2","Str3"};
parser.Parse(args, aggregateNos);
Assert.Fail();
}
catch (RequiredArgumentMissingException ex)
{
ApplicationLog.WriteLine("Successfully caught RequiredArgumentMissingException : " + ex.Message);
}
}
public void InvalidateParseWithDuplicateString()
{
try
{
AggregateNumbers aggregateNos = new AggregateNumbers();
CommandLineArguments parser = new CommandLineArguments();
//add parameters
parser.Parameter(ArgumentType.Required, "bValue", ArgumentValueType.Bool, "bv", "bool");
parser.Parameter(ArgumentType.Required, "iValue", ArgumentValueType.Int, "iv", "int");
parser.Parameter(ArgumentType.Required, "fValue", ArgumentValueType.Int, "fv", "float");
parser.Parameter(ArgumentType.Required, "dValue", ArgumentValueType.Int, "dv", "double");
parser.Parameter(ArgumentType.DefaultArgument, "usValues", ArgumentValueType.MultipleUniqueStrings, "usv", "Unique strings");
string[] args = { "-bValue:true", "-iValue:5", "-fValue:3.45", "-dValue:78.9876", "Str1", "Str2","Str1"};
parser.Parse(args, aggregateNos);
}
catch (DuplicateArgumentValueException ex)
{
ApplicationLog.WriteLine("Successfully caught DuplicateArgumentValueException : " + ex.Message);
}
}
public void InvalidateParseWithWrongParamName()
{
try
{
AggregateNumbers aggregateNos = new AggregateNumbers();
CommandLineArguments parser = new CommandLineArguments();
//add parameters
parser.Parameter(ArgumentType.Required, "bValue", ArgumentValueType.Bool, "bv", "bool");
parser.Parameter(ArgumentType.Required, "iValue", ArgumentValueType.Int, "iv", "int");
parser.Parameter(ArgumentType.Required, "bArrValues", ArgumentValueType.Bool, "bmv", "boolArrValues");
//pass char in integer array
string[] args = { "/wrongname:true", "/iValue:5", "/bArrValues:true", "false" };
parser.Parse(args, aggregateNos);
Assert.Fail();
}
catch (ArgumentParserException ex)
{
ApplicationLog.Write("Successfully caught ArgumentNotFoundException : " + ex.Message);
}
}
public void ValidateTypesInParameter()
{
AggregateNumbers aggregateNos = new AggregateNumbers();
CommandLineArguments parser = new CommandLineArguments();
//add parameters
parser.Parameter(ArgumentType.Required, "bValue", ArgumentValueType.Bool, "bv", "bool");
parser.Parameter(ArgumentType.Required, "iValue", ArgumentValueType.Int, "iv", "int");
parser.Parameter(ArgumentType.Required, "fValue", ArgumentValueType.Int, "fv", "float");
parser.Parameter(ArgumentType.Required, "dValue", ArgumentValueType.Int, "dv", "double");
parser.Parameter(ArgumentType.DefaultArgument, "usValues", ArgumentValueType.MultipleUniqueStrings, "usv", "Unique strings");
string[] args = { "-bValue:true", "-iValue:5", "-fValue:3.45", "-dValue:78.9876", "Str1", "Str2","Str3"};
parser.Parse(args, aggregateNos);
Assert.IsNotNull(parser);
}
/// <summary>
/// Parse command line arguments for index command.
/// </summary>
/// <param name="args">Array of command line arguments.</param>
private static void IndexOption(string[] args)
{
Index options = new Index();
CommandLineArguments parser = new CommandLineArguments();
// Add the parameters
parser.Parameter(ArgumentType.DefaultArgument, "InputFilename", ArgumentValueType.String, "", "Input BAM file name");
parser.Parameter(ArgumentType.Optional, "OutputFilename", ArgumentValueType.String, "o", "Output file name");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "", "");
if (args.Length > 0)
{
try
{
parser.Parse(args, options);
}
catch (ArgumentParserException ex)
{
DisplayErrorMessage(ex.Message);
DisplayErrorMessage(Resources.IndexHelp);
Environment.Exit(-1);
}
if (options.Help)
{
DisplayErrorMessage(Resources.IndexHelp);
}
else
{
options.GenerateIndexFile();
}
}
else
{
DisplayErrorMessage(Resources.IndexHelp);
}
}
static CommandLineOptions ProcessCommandLine(string[] args)
{
CommandLineOptions myArgs = new CommandLineOptions();
CommandLineArguments parser = new CommandLineArguments();
AddParameters(parser);
try
{
parser.Parse(args, myArgs);
}
catch (Exception e)
{
Console.Error.WriteLine("\nException while processing Command Line arguments [{0}]", e.Message);
Environment.Exit(-1);
}
if (myArgs.help)
{
Console.WriteLine(Resources.MumUtilHelp);
Environment.Exit(-1);
}
/*
* Process all the arguments for 'semantic' correctness
*/
if ((myArgs.maxmatch && myArgs.mum)
|| (myArgs.maxmatch && myArgs.mumreference)
|| (myArgs.mum && myArgs.mumreference)
)
{
Console.Error.WriteLine("\nError: only one of -maxmatch, -mum, -mumreference options can be specified.");
Environment.Exit(-1);
}
if (!myArgs.mumreference && !myArgs.mum && !myArgs.maxmatch)
{
myArgs.mumreference = true;
}
if ((myArgs.fileList == null) || (myArgs.fileList.Length < 2))
{
Console.Error.WriteLine("\nError: A reference file and at least 1 query file are required.");
Environment.Exit(-1);
}
if ((myArgs.length <= 0) || (myArgs.length >= (8 * 1024))) // TODO: What are real reasonable mum length limits?
{
Console.Error.WriteLine("\nError: mum length must be between 1 and 1024.");
Environment.Exit(-1);
}
if (myArgs.both && myArgs.reverseOnly)
{
Console.Error.WriteLine("\nError: only one of -both or -reverseOnly options can be specified.");
Environment.Exit(-1);
}
if (myArgs.c && (!myArgs.both && !myArgs.reverseOnly))
{
Console.Error.WriteLine("\nError: c requires one of either /b or /r options.");
Environment.Exit(-1);
}
if (myArgs.outputFile != null)
{ // redirect stdout
fsConsoleOut = new FileStream(myArgs.outputFile, FileMode.Create);
swConsoleOut = new StreamWriter(fsConsoleOut);
Console.SetOut(swConsoleOut);
swConsoleOut.AutoFlush = true;
}
return (myArgs);
}
/// <summary>
/// Parse command line arguments for Import command
/// </summary>
/// <param name="args">Array of command line arguments.</param>
private static void ImportOption(string[] args)
{
Import options = new Import();
CommandLineArguments parser = new CommandLineArguments();
// Add the parameters
parser.Parameter(ArgumentType.DefaultArgument, "InputFilename", ArgumentValueType.String, "", "Input filename");
parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "", "");
parser.Parameter(ArgumentType.Optional, "ReferenceListFile", ArgumentValueType.String, "r", "Tab delimited file");
parser.Parameter(ArgumentType.Optional, "OutputFilename", ArgumentValueType.String, "o", "Output file name");
if (args != null && args.Length > 0)
{
try
{
parser.Parse(args, options);
}
catch (ArgumentParserException ex)
{
DisplayErrorMessage(ex.Message);
DisplayErrorMessage(Resources.ImportHelp);
Environment.Exit(-1);
}
if (options.Help)
{
DisplayErrorMessage(Resources.ImportHelp);
}
else
{
options.DoImport();
}
}
else
{
DisplayErrorMessage(Resources.ImportHelp);
}
}
private static CommandLineOptions ProcessCommandLine(string[] args)
{
CommandLineOptions myArgs = new CommandLineOptions();
CommandLineArguments parser = new CommandLineArguments();
AddParameters(parser);
try
{
parser.Parse(args, myArgs);
}
catch (ArgumentParserException e)
{
Console.Error.WriteLine("\nException while processing Command Line arguments [{0}]", e.Message);
Console.Error.WriteLine(Resources.LisUtilHelp);
Environment.Exit(-1);
}
if (myArgs.Help)
{
Console.WriteLine(Resources.LisUtilHelp);
Environment.Exit(-1);
}
/*
* Process all the arguments for 'semantic' correctness
*/
if (!myArgs.PerformLISOnly)
{
if ((myArgs.MaxMatch && myArgs.Mum)
|| (myArgs.MaxMatch && myArgs.Mumreference)
|| (myArgs.Mum && myArgs.Mumreference))
{
Console.Error.WriteLine("\nError: only one of -maxmatch, -mum, -mumreference options can be specified.");
Environment.Exit(-1);
}
if (!myArgs.Mumreference && !myArgs.Mum && !myArgs.MaxMatch)
{
myArgs.Mumreference = true;
}
}
if (myArgs.FileList == null || myArgs.FileList.Length == 0)
{
Console.Error.WriteLine("\nError: Atleast one input file needed.");
Environment.Exit(-1);
}
if (myArgs.FileList.Length < 2 && !myArgs.PerformLISOnly)
{
Console.Error.WriteLine("\nError: A reference file and at least 1 query file are required.");
Environment.Exit(-1);
}
if (myArgs.FileList.Length < 1 && myArgs.PerformLISOnly)
{
Console.Error.WriteLine("\nError: A file containing list of MUMs required.");
Environment.Exit(-1);
}
if ((myArgs.Length <= 2) || (myArgs.Length >= (8 * 1024)))
{
// TODO: What are real reasonable mum length limits?
Console.Error.WriteLine("\nError: mum length must be between 10 and 1024.");
Environment.Exit(-1);
}
if (myArgs.Both && myArgs.ReverseOnly)
{
Console.Error.WriteLine("\nError: only one of -both or -reverseOnly options can be specified.");
Environment.Exit(-1);
}
if (myArgs.C && (!myArgs.Both && !myArgs.ReverseOnly))
{
Console.Error.WriteLine("\nError: c requires one of either /b or /r options.");
Environment.Exit(-1);
}
if (myArgs.OutputFile != null)
{ // redirect stdout
fileStreamConsoleOut = new FileStream(myArgs.OutputFile, FileMode.Create);
streamWriterConsoleOut = new StreamWriter(fileStreamConsoleOut);
Console.SetOut(streamWriterConsoleOut);
streamWriterConsoleOut.AutoFlush = true;
}
return (myArgs);
}
public void InvalidateParseForNullArgumentsNo()
{
CommandLineArguments parser = new CommandLineArguments();
//add parameters
parser.Parameter(ArgumentType.Required, "InputFile", ArgumentValueType.String, "i", "File containing numbers to add");
parser.Parameter(ArgumentType.Required, "ResultFile", ArgumentValueType.String, "r", "File to store output");
string inputfileName = Path.GetTempFileName().Replace(Path.GetTempPath(), "");
string outputfileName = Path.GetTempFileName().Replace(Path.GetTempPath(), "");
string[] args = { "/InputFile:" + inputfileName, "/ResultFile:" + outputfileName };
try
{
parser.Parse(args, null);
Assert.Fail("CommandLineArguments P2: Not validated parameter Method for null value");
}
catch (ArgumentNullException ex)
{
ApplicationLog.WriteLine("CommandLineArguments P2: Successfully validated Parameter Method for null value:", ex.Message);
}
}