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 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); } }
/// <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); }
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); } }
public void InvalidateParameter() { //AggregateNumbers aggregateNos = new AggregateNumbers(); CommandLineArguments parser = new CommandLineArguments(); try { //add parameters parser.Parameter(ArgumentType.Required, null, ArgumentValueType.String, "i", "File containing numbers to add"); Assert.Fail(); } catch (ArgumentNullException ex) { ApplicationLog.WriteLine("Successfully caught ArgumentNullException : " + ex.Message); } }
/// <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> /// 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) { 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> /// 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); } }
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); }
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> /// 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); } }
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); } }
/// <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); } }
/// <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); } }
/// <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 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); } }
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); } }
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); } }
private static void AddParameters(CommandLineArguments parser) { parser.Parameter(ArgumentType.Optional, "Help", ArgumentValueType.Bool, "h", "Show the help information with program options and a description of program operation."); parser.Parameter(ArgumentType.Optional, "Verbose", ArgumentValueType.Bool, "v", "Display Verbose logging during processing"); parser.Parameter(ArgumentType.Optional, "Mumreference", ArgumentValueType.Bool, "", "Compute all MUM candidates in reference [default]"); parser.Parameter(ArgumentType.Optional, "Mum", ArgumentValueType.Bool, "", "Compute Maximal Unique Matches, strings that are unique in both the reference and query sets"); parser.Parameter(ArgumentType.Optional, "MaxMatch", ArgumentValueType.Bool, "", "Compute all maximal matches ignoring uniqueness"); parser.Parameter(ArgumentType.Optional, "NoAmbiguity", ArgumentValueType.Bool, "n", "Disallow ambiguity character matches and only match A, T, C, or G (case insensitive)"); parser.Parameter(ArgumentType.Optional, "Length", ArgumentValueType.Int, "l", "Minimum match length [20]"); parser.Parameter(ArgumentType.Optional, "Both", ArgumentValueType.Bool, "b", "Compute forward and reverse complement matches"); parser.Parameter(ArgumentType.Optional, "ReverseOnly", ArgumentValueType.Bool, "r", "Compute only reverse complement matches"); parser.Parameter(ArgumentType.Optional, "DisplayQueryLength", ArgumentValueType.Bool, "d", "Show the length of the query sequence"); parser.Parameter(ArgumentType.Optional, "ShowMatchingString", ArgumentValueType.Bool, "s", "Show the matching substring in the output"); parser.Parameter(ArgumentType.Optional, "C", ArgumentValueType.Bool, "c", "Report the query position of a reverse complement match relative to the forward strand of the query sequence"); parser.Parameter(ArgumentType.Optional, "OutputFile", ArgumentValueType.String, "o", "Output file"); parser.Parameter(ArgumentType.Optional, "PerformLISOnly", ArgumentValueType.Bool, "p", "Perform LIS only on input list of MUMs"); parser.Parameter(ArgumentType.DefaultArgument, "FileList", ArgumentValueType.MultipleUniqueStrings, "", "Query file(s) containing the query strings"); }
/// <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 InvalidateParameterForNullParameterName() { CommandLineArguments commandLineArguments = new CommandLineArguments(); try { commandLineArguments.Parameter(ArgumentType.Optional, null, ArgumentValueType.OptionalInt, "ParameterForNullParameterName", ""); Assert.Fail("CommandLineArguments P2: Not validated parameter Method for null value"); } catch (Exception ex) { ApplicationLog.WriteLine("CommandLineArguments P2: Successfully validated Parameter Method for null value:", ex.Message); } try { commandLineArguments.Parameter(ArgumentType.Optional, null, ArgumentValueType.Bool, "ParameterForNullParameterName", ""); Assert.Fail("CommandLineArguments P2: Not validated parameter Method for bool value"); } catch (Exception ex) { ApplicationLog.WriteLine("CommandLineArguments P2: Successfully validated Parameter Method for bool value:", ex.Message); } }
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); } }