public void Parse_verbs_create_instance() { string invokedVerb = null; object invokedVerbInstance = null; var options = new OptionsWithVerbs(); options.AddVerb.Should().BeNull(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] {"add", "-p", "untracked.bin"} , options, (verb, subOptions) => { invokedVerb = verb; invokedVerbInstance = subOptions; }); result.Should().BeTrue(); invokedVerb.Should().Be("add"); invokedVerbInstance.Should().BeOfType<AddSubOptions>(); // Parser has built instance for us options.AddVerb.Should().NotBeNull(); options.AddVerb.CreationProof.Should().NotHaveValue(); options.AddVerb.Patch.Should().BeTrue(); options.AddVerb.FileName[0].Should().Be("untracked.bin"); }
public void Failed_verb_parsing_prints_particular_help_screen() { string invokedVerb = null; object invokedVerbInstance = null; var options = new OptionsWithVerbsHelp(); var testWriter = new StringWriter(); ReflectionHelper.AssemblyFromWhichToPullInformation = Assembly.GetExecutingAssembly(); var parser = new CommandLine.Parser(with => with.HelpWriter = testWriter); var result = parser.ParseArguments(new string[] { "clone", "--no_hardlinks" }, options, (verb, subOptions) => { invokedVerb = verb; invokedVerbInstance = subOptions; }); result.Should().BeFalse(); var helpText = testWriter.ToString(); Console.WriteLine(helpText); var lines = helpText.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); // Verify just significant output lines[5].Trim().Should().Be("--no-hardlinks Optimize the cloning process from a repository on a local"); lines[6].Trim().Should().Be("filesystem by copying files."); lines[7].Trim().Should().Be("-q, --quiet Suppress summary message."); invokedVerb.Should().Be("clone"); invokedVerbInstance.Should().Be(null); }
static void Main(string[] args) { Console.WriteLine("MetadataGenerator " + args.ToAggregateString(" ")); var parser = new CommandLine.Parser(ps => { ps.MutuallyExclusive = true; ps.HelpWriter = Console.Out; }); if (!parser.ParseArguments(args, Options)) { return; } var assemblyName = GetAssemblyName(Options.InputFile); if (!File.Exists(assemblyName)) { Console.WriteLine("The specified file {0} cannot be found", assemblyName); return; } var dbContextTypes = GetDbContextTypesFromAssembly(assemblyName); if (dbContextTypes.Length == 1 || Options.TypeName != null) { if (Options.TypeName != null) { try { var type = dbContextTypes.SingleOrDefault(t => t.Name == Options.TypeName || t.FullName == Options.TypeName); if (type != null) { ProcessType(type, Options.OutputFile ?? Options.TypeName + ".json"); } else { Console.WriteLine("The type specified {0} can not be found in the assembly {1}", Options.TypeName, assemblyName); } } catch (InvalidOperationException) { Console.WriteLine("There are several types named {0} in the assembly {1}", Options.TypeName, assemblyName); } catch (Exception ex) { Console.WriteLine(ex); } } else { var type = dbContextTypes.First(); ProcessType(type, Options.OutputFile ?? type.FullName + ".json"); } } else { // Hadle multitype scenario. //foreach (var type in dbContextTypes) { //} } }
public void Parsing_two_mutually_exclusive_options_fails() { var parser = new CommandLine.Parser(new ParserSettings { MutuallyExclusive = true }); var options = new OptionsWithDefaultSet(); var result = parser.ParseArguments(new string[] { "-i", "1", "--file=mystuff.xml" }, options); result.Should().BeFalse(); }
public void Parsing_mutually_exclusive_options_and_required_option_fails() { var options = new OptionsWithMultipleSetAndOneOption(); var parser = new CommandLine.Parser(new ParserSettings { MutuallyExclusive = true }); var result = parser.ParseArguments(new string[] { "-g167", "--hue", "205" }, options); result.Should().BeFalse(); }
public void Passing_no_value_to_a_nullable_integer_option_fails() { var options = new NullableTypesOptions(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "-int" }, options); result.Should().BeFalse(); }
public void Parse_string_array_option_using_short_name() { var options = new SimpleOptionsWithArray(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "-z", "alfa", "beta", "gamma" }, options); result.Should().BeTrue(); base.ElementsShouldBeEqual(new string[] { "alfa", "beta", "gamma" }, options.StringArrayValue); }
public void Allow_single_dash_as_option_input_value() { var options = new SimpleOptions(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "--string", "-" }, options); result.Should().BeTrue(); options.StringValue.Should().Be("-"); }
public void Parsing_one_mutually_exclusive_option_succeeds() { var options = new OptionsWithDefaultSet(); var parser = new CommandLine.Parser(new ParserSettings {MutuallyExclusive = true}); var result = parser.ParseArguments(new string[] { "--file=mystuff.xml" }, options); result.Should().BeTrue(); options.FileName.Should().Be("mystuff.xml"); }
public void Value_list_with_max_elem_outside_bounds() { var options = new OptionsWithValueListMaximumThree(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments( new string[] { "file.a", "file.b", "file.c", "file.d" }, options); result.Should().BeFalse(); }
public void Parse_string_array_option_using_long_name_with_equal_sign() { var options = new SimpleOptionsWithArray(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "--strarr=apple", "kiwi" }, options); result.Should().BeTrue(); base.ElementsShouldBeEqual(new string[] { "apple", "kiwi" }, options.StringArrayValue); }
public void Between_value_options_order_matters() { var options = new SimpleOptionsWithValueOptionAndValueList(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments( new string[] { "4321", "ofvalueoption", "-1234", "forvaluelist1", "forvaluelist2", "forvaluelist3" }, options); result.Should().BeFalse(); }
public void Default_parsing_is_case_sensitive() { var parser = new CommandLine.Parser(); var options = new MixedCaseOptions(); var result = parser.ParseArguments(new string[] { "-a", "alfa", "--beta-OPTION", "beta" }, options); result.Should().BeTrue(); options.AlfaValue.Should().Be("alfa"); options.BetaValue.Should().Be("beta"); }
public void Parse_string_option() { var options = new SimpleOptions(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "-s", "something" }, options); result.Should().BeTrue(); options.StringValue.Should().Be("something"); Console.WriteLine(options); }
public void Parsing_two_mutually_exclusive_options_in_two_set_succeeds() { var options = new OptionsWithMultipleSet(); var parser = new CommandLine.Parser(new ParserSettings { MutuallyExclusive = true }); var result = parser.ParseArguments(new string[] { "-g167", "--hue", "205" }, options); result.Should().BeTrue(); options.Green.Should().Be((byte)167); options.Hue.Should().Be((short)205); }
public void Parse_valid_unknown_arguments() { string[] args = { "--plugin", "addonX", "--filename", "input.dat" }; var appOptions = new OptionsForAppWithPlugIns(); var parser = new CommandLine.Parser(new ParserSettings { IgnoreUnknownArguments = true, CaseSensitive = true }); var result1 = parser.ParseArguments(args, appOptions); result1.Should().BeTrue(); appOptions.PlugInName.Should().Be("addonX"); var plugInXOptions = new OptionsOfPlugInX(); var result2 = parser.ParseArguments(args, plugInXOptions); result2.Should().BeTrue(); plugInXOptions.InputFileName.Should().Be("input.dat"); plugInXOptions.ReadOffset.Should().Be(10L); }
public void Parsing_mutually_exclusive_options_and_required_option_succeeds() { var options = new OptionsWithMultipleSetAndOneOption(); var parser = new CommandLine.Parser(new ParserSettings { MutuallyExclusive = true }); var result = parser.ParseArguments(new string[] { "-g100", "-h200", "-cRgbColorSet" }, options); result.Should().BeTrue(); options.Green.Should().Be((byte)100); options.Hue.Should().Be((short)200); options.DefaultColorSet.Should().Be(ColorSet.RgbColorSet); }
public void Correct_input_not_activates_help() { var options = new MockOptions(); var writer = new StringWriter(); var parser = new CommandLine.Parser(with => with.HelpWriter = writer); var result = parser.ParseArguments( new string[] { "-imath.xml", "-oresult.xml" }, options); result.Should().BeTrue();; writer.ToString().Length.Should().Be(0); }
public void Setting_help_writer_using_constructor() { var writer = new StringWriter(); var parser = new CommandLine.Parser(new ParserSettings(writer)); var options = new SimpleOptionsWithHelpOption(); bool success = parser.ParseArguments(new string[] {"--help"}, options); success.Should().BeFalse(); writer.ToString().Should().Be("MockOptions::GetUsage()"); }
public static int Main(string[] args) { var options = new Options(); var parser = new CommandLine.Parser(settings => { settings.CaseSensitive = true; settings.HelpWriter = System.Console.Out; }); try { if (parser.ParseArguments(args, options)) { // Validate the arguments. options.ValidateOptions(); try { var message = string.Format("Processing file {0}...", options.InputFile); System.Console.WriteLine(message); Trace.TraceInformation(message); var processor = new FileProcessor(options); processor.Process(); message = string.Format("Done processing file {0}.", options.InputFile); System.Console.WriteLine(message); Trace.TraceInformation(message); } catch (Exception ex) { Trace.TraceError(string.Format("Exception occurred while trying to process the file. Exception: {0} {1}", ex.Message, ex.StackTrace)); System.Console.Error.WriteLine("An error occurred while trying to process the file."); return (int)ExitCode.Errored; } } } catch (ArgumentNullException ex) { Trace.TraceError(string.Format("ArgumentNullException occurred while trying to parse arguments passed to the program. Exception: {0} {1}", ex.Message, ex.StackTrace)); System.Console.Error.WriteLine("An error occurred while trying to parse the arguments passed to the application."); return (int)ExitCode.ArgumentError; } catch (InvalidArgumentException ex) { Trace.TraceError(string.Format("InvalidArgumentException occurred while trying to parse arguments passed to the program. Exception: {0} {1}", ex.Message, ex.StackTrace)); System.Console.Error.WriteLine("The following argument is invalid: {0} Error: {1}", ex.InvalidParameterName, ex.Message); return (int)ExitCode.ArgumentError; } return (int)ExitCode.Success; }
public void Allow_single_dash_as_non_option_value() { var options = new SimpleOptionsWithValueList(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "-sparser.xml", "-", "--switch" }, options); result.Should().BeTrue(); options.StringValue.Should().Be("parser.xml"); options.BooleanValue.Should().BeTrue(); options.Items.Count.Should().Be(1); options.Items[0].Should().Be("-"); }
public void Parse_string_integer_bool_options() { var options = new SimpleOptions(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments( new string[] { "-s", "another string", "-i100", "--switch" }, options); result.Should().BeTrue(); options.StringValue.Should().Be("another string"); options.IntegerValue.Should().Be(100); options.BooleanValue.Should().BeTrue(); Console.WriteLine(options); }
public void Explicit_help_activation() { var options = new MockOptions(); var writer = new StringWriter(); var parser = new CommandLine.Parser(with => with.HelpWriter = writer); var result = parser.ParseArguments( new string[] { "--help" }, options); result.Should().BeFalse(); string helpText = writer.ToString(); (helpText.Length > 0).Should().BeTrue(); }
public void Value_option_attribute_values_are_not_mandatory() { var options = new SimpleOptionsWithValueOption(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments( new string[] { "--switch" }, options); result.Should().BeTrue(); options.BooleanValue.Should().BeTrue(); options.StringItem.Should().BeNull(); options.IntegerItem.Should().Be(0); options.NullableDoubleItem.Should().NotHaveValue(); }
public void Value_list_with_max_elem_inside_bounds() { var options = new OptionsWithValueListMaximumThree(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "file.a", "file.b", "file.c" }, options); result.Should().BeTrue(); options.InputFilenames[0].Should().Be("file.a"); options.InputFilenames[1].Should().Be("file.b"); options.InputFilenames[2].Should().Be("file.c"); options.OutputFile.Should().BeNull(); options.Overwrite.Should().BeFalse(); Console.WriteLine(options); }
public void Value_option_attribute_isolates_non_option_values() { var options = new SimpleOptionsWithValueOption(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments( new string[] { "--switch", "file.ext", "1000", "0.1234", "-s", "out.ext" }, options); result.Should().BeTrue(); options.BooleanValue.Should().BeTrue(); options.StringItem.Should().Be("file.ext"); options.IntegerItem.Should().Be(1000); options.NullableDoubleItem.Should().Be(0.1234D); options.StringValue.Should().Be("out.ext"); }
public void Bad_input_activates_help() { var options = new MockOptions(); var writer = new StringWriter(); var parser = new CommandLine.Parser(with => with.HelpWriter = writer); var result = parser.ParseArguments( new string[] { "math.xml", "-oresult.xml" }, options); result.Should().BeFalse(); string helpText = writer.ToString(); (helpText.Length > 0).Should().BeTrue(); Console.Write(helpText); }
public void Parse_nullable_double_option() { var options = new NullableTypesOptions(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "-d9.999" }, options); result.Should().BeTrue(); options.DoubleValue.Should().Be(9.999); options = new NullableTypesOptions(); parser = new CommandLine.Parser(); result = parser.ParseArguments(new string[] { }, options); result.Should().BeTrue(); options.DoubleValue.Should().NotHaveValue(); }
public void Value_option_takes_precedence_on_value_list_regardless_declaration_order() { var options = new SimpleOptionsWithValueOptionAndValueList(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments( new string[] { "ofvalueoption", "-1234", "4321", "forvaluelist1", "forvaluelist2", "forvaluelist3" }, options); result.Should().BeTrue(); options.StringItem.Should().Be("ofvalueoption"); options.NullableInteger.Should().Be(-1234); options.UnsignedIntegerItem.Should().Be(4321U); options.Items[0].Should().Be("forvaluelist1"); options.Items[1].Should().Be("forvaluelist2"); options.Items[2].Should().Be("forvaluelist3"); }
public void Parse_nullable_enumeration_option() { var options = new NullableTypesOptions(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "--enum=ReadWrite" }, options); result.Should().BeTrue(); options.EnumValue.Should().Be(FileAccess.ReadWrite); options = new NullableTypesOptions(); parser = new CommandLine.Parser(); result = parser.ParseArguments(new string[] { }, options); result.Should().BeTrue(); options.EnumValue.Should().BeNull(); }
public void Parse_nullable_integer_option() { var options = new NullableTypesOptions(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "-i", "99" }, options); result.Should().BeTrue(); options.IntegerValue.Should().Be(99); options = new NullableTypesOptions(); parser = new CommandLine.Parser(); result = parser.ParseArguments(new string[] { }, options); result.Should().BeTrue(); options.IntegerValue.Should().NotHaveValue(); }
public void Value_list_attribute_isolates_non_option_values() { var options = new SimpleOptionsWithValueList(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments( new string[] { "--switch", "file1.ext", "file2.ext", "file3.ext", "-s", "out.ext" }, options); result.Should().BeTrue(); options.Items[0].Should().Be("file1.ext"); options.Items[1].Should().Be("file2.ext"); options.Items[2].Should().Be("file3.ext"); options.StringValue.Should().Be("out.ext"); options.BooleanValue.Should().BeTrue(); Console.WriteLine(options); }
public void Should_use_property_name_as_long_name_if_omitted() { // Given var options = new OptionsWithImplicitLongName(); var parser = new CommandLine.Parser(); var arguments = new[] { "--offsets", "-2", "-1", "0", "1", "2" }; // When var result = parser.ParseArguments(arguments, options); // Than result.Should().Be(true); options.Offsets.Should().HaveCount(c => c == 5); options.Offsets.Should().ContainInOrder(new[] { -2, -1, 0, 1, 2 }); }
public void Should_use_property_name_as_long_name_if_omitted() { // Given var options = new OptionsWithImplicitLongName(); var parser = new CommandLine.Parser(); var arguments = new[] { "--segments", "header.txt:body.txt:footer.txt" }; // When var result = parser.ParseArguments(arguments, options); // Than result.Should().Be(true); options.Segments.Should().HaveCount(c => c == 3); options.Segments.Should().ContainInOrder(new[] { "header.txt", "body.txt", "footer.txt" }); }
static void Main(string[] args) { var procname = System.Diagnostics.Process.GetCurrentProcess().ProcessName; Console.WriteLine(procname + ' ' + string.Join(" ", args)); var parser = new CommandLine.Parser(ps => { ps.MutuallyExclusive = true; ps.HelpWriter = Console.Out; }); if (!parser.ParseArguments(args, Options)) { return; } var assemblyName = GetAssemblyName(Options.InputFile); if (!File.Exists(assemblyName)) { Console.WriteLine("The specified file {0} cannot be found", assemblyName); return; } string outfile = GetFilePath(); // TODO: how to get this from the command line? EntityDescriptor descriptor; if (assemblyName.Contains("Northwind")) { descriptor = new NorthwindEntityDescriptor(); } else { descriptor = new EntityDescriptor(); } var metadata = Generator.Generate(assemblyName, descriptor); var json = ToJson(metadata); if (outfile != null) { Console.WriteLine("Writing to " + outfile); File.WriteAllText(outfile, json); } else { Console.WriteLine(json); } Console.WriteLine("Done"); }
public void Parse_option_list() { var options = new SimpleOptionsWithOptionList(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "-k", "string1:stringTwo:stringIII", "-s", "test-file.txt" }, options); result.Should().BeTrue(); options.SearchKeywords[0].Should().Be("string1"); Console.WriteLine(options.SearchKeywords[0]); options.SearchKeywords[1].Should().Be("stringTwo"); Console.WriteLine(options.SearchKeywords[1]); options.SearchKeywords[2].Should().Be("stringIII"); Console.WriteLine(options.SearchKeywords[2]); options.StringValue.Should().Be("test-file.txt"); Console.WriteLine(options.StringValue); }
public void TestPrintHelpThrowParsExceptionIfBadVerb() { // https://github.com/commandlineparser/commandline/blob/master/src/CommandLine/Error.cs var commandLineParser = new CommandLine.Parser(); var parser = commandLineParser.ParseArguments <Options.DefaultJob>(new string[] { }); CommandLineParser parserObj = new CommandLineParser(new OptionConverter(new JsonDeserializer()), commandLineParser, new ParserUsage(), new VerbFormater()); ParserUsage helpUsage = new ParserUsage(); List <CommandLine.Error> errs = new List <CommandLine.Error>(); CommandLine.Error err = new CommandLineWrapError(CommandLine.ErrorType.BadVerbSelectedError); errs.Add(err); ParseException ex = Assert.Throws <ParseException>(() => helpUsage.PrintHelp(parser, errs, new string[] {})); Assert.IsNotNull(ex); commandLineParser.Dispose(); }
public void Should_fail_gracefully_when_no_getusage_is_defined() { string invokedVerb = null; object invokedVerbInstance = null; var options = new OptionsWithVerbsNoHelp2(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new[] { "with", "--must" }, options, (verb, subOptions) => { invokedVerb = verb; invokedVerbInstance = subOptions; }); result.Should().BeFalse(); invokedVerb.Should().Be("with"); invokedVerbInstance.Should().BeNull(); }
public void Should_use_property_name_as_long_name_if_omitted() { // Given var options = new OptionsWithImplicitLongName(); var parser = new CommandLine.Parser(); var arguments = new[] { "--download", "something", "--up-load", "this", "-b", "1024" }; // When var result = parser.ParseArguments(arguments, options); // Than result.Should().Be(true); options.Download.Should().Be("something"); options.Upload.Should().Be("this"); options.Bytes.Should().Be(1024); }
public void Should_correctly_parse_two_consecutive_arrays() { // Given var options = new OptionsWithTwoArrays(); var parser = new CommandLine.Parser(); var argumets = new[] { "--source", @"d:/document.docx", "--output", @"d:/document.xlsx", "--headers", "1", "2", "3", "4", // first array "--content", "5", "6", "7", "8", "--verbose" // second array }; // When var result = parser.ParseArguments(argumets, options); // Than result.Should().BeTrue(); options.Headers.Should().HaveCount(c => c == 4); options.Headers.Should().ContainInOrder(new uint[] { 1, 2, 3, 4 }); options.Content.Should().HaveCount(c => c == 4); options.Content.Should().ContainInOrder(new uint[] { 5, 6, 7, 8 }); }
public void Parse_string_option_and_nullable_value_types() { var options = new NullableTypesOptions(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "--string", "alone" }, options); result.Should().BeTrue(); options.StringValue.Should().Be("alone"); options = new NullableTypesOptions(); parser = new CommandLine.Parser(); result = parser.ParseArguments( new string[] { "-d1.789", "--int", "10099", "-stogether", "--enum", "Read" }, options); result.Should().BeTrue(); options.DoubleValue.Should().Be(1.789D); options.IntegerValue.Should().Be(10099); options.StringValue.Should().Be("together"); options.EnumValue.Should().Be(FileAccess.Read); }
public void Parse_different_arrays_together__combination_one() { var options = new SimpleOptionsWithArray(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "-z", "one", "two", "three", "four", "-y", "1", "2", "3", "4", "-q", "0.1", "0.2", "0.3", "0.4" }, options); result.Should().BeTrue(); base.ElementsShouldBeEqual(new string[] { "one", "two", "three", "four" }, options.StringArrayValue); base.ElementsShouldBeEqual(new int[] { 1, 2, 3, 4 }, options.IntegerArrayValue); base.ElementsShouldBeEqual(new double[] { .1, .2, .3, .4 }, options.DoubleArrayValue); options = new SimpleOptionsWithArray(); parser = new CommandLine.Parser(); result = parser.ParseArguments(new string[] { "-y", "1", "2", "3", "4", "-z", "one", "two", "three", "four", "-q", "0.1", "0.2", "0.3", "0.4" }, options); result.Should().BeTrue(); base.ElementsShouldBeEqual(new int[] { 1, 2, 3, 4 }, options.IntegerArrayValue); base.ElementsShouldBeEqual(new string[] { "one", "two", "three", "four" }, options.StringArrayValue); base.ElementsShouldBeEqual(new double[] { .1, .2, .3, .4 }, options.DoubleArrayValue); options = new SimpleOptionsWithArray(); parser = new CommandLine.Parser(); result = parser.ParseArguments(new string[] { "-q", "0.1", "0.2", "0.3", "0.4", "-y", "1", "2", "3", "4", "-z", "one", "two", "three", "four" }, options); result.Should().BeTrue(); base.ElementsShouldBeEqual(new double[] { .1, .2, .3, .4 }, options.DoubleArrayValue); base.ElementsShouldBeEqual(new int[] { 1, 2, 3, 4 }, options.IntegerArrayValue); base.ElementsShouldBeEqual(new string[] { "one", "two", "three", "four" }, options.StringArrayValue); }
public void Invoke_render_parsing_errors_text() { var sw = new StringWriter(); var options = new OptionsForErrorsScenario(); var parser = new CommandLine.Parser(new ParserSettings { MutuallyExclusive = true, CaseSensitive = true, HelpWriter = sw }); var result = parser.ParseArguments(new string[] { "--option-b", "hello", "-cWORLD" }, options); result.Should().BeFalse(); var outsw = sw.ToString(); Console.WriteLine(outsw); var lines = outsw.Split(new string[] { Environment.NewLine }, StringSplitOptions.None); lines[0].Should().Be("--option-b option violates format."); lines[1].Should().Be("-c/--option-c option violates format."); lines[2].Should().Be("-a required option is missing."); }
static int Main(string[] args) { var options = new Options(); var parser_options = new CommandLine.ParserSettings { MutuallyExclusive = true }; var parser = new CommandLine.Parser(parser_options); var isValid = parser.ParseArguments(args, options); if (!isValid) { Console.WriteLine(CommandLine.Text.HelpText.AutoBuild(options).ToString()); return -1; } DataUtils.PrintHubLabel( options.SMTSerial, options.ZPLFile, options.PrinterAddres ); return 0; }
private void DoCoreTestForIndex(string[] args) { var options = new OptionsWithVerbsHelp(); var testWriter = new StringWriter(); ReflectionHelper.AssemblyFromWhichToPullInformation = Assembly.GetExecutingAssembly(); var parser = new CommandLine.Parser(with => with.HelpWriter = testWriter); var result = parser.ParseArguments(args, options, (_, __) => { }); result.Should().BeFalse(); var helpText = testWriter.ToString(); Console.WriteLine(helpText); var lines = helpText.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries); // Verify just significant output lines[5].Trim().Should().Be("add Add file contents to the index."); lines[6].Trim().Should().Be("commit Record changes to the repository."); lines[7].Trim().Should().Be("clone Clone a repository into a new directory."); }
static void Main(string[] args) { var parser = new CommandLine.Parser(opt => { opt.MutuallyExclusive = true; opt.HelpWriter = Console.Error; }); var options = new Options(); if (parser.ParseArguments(args, options)) { if (string.IsNullOrEmpty(options.Pattern) && string.IsNullOrEmpty(options.PatternFile)) { Console.Error.WriteLine(options.GetUsage()); Environment.Exit(-1); } string pattern = !string.IsNullOrEmpty(options.Pattern) ? options.Pattern : File.ReadAllText(options.PatternFile); Regex re = new Regex(pattern); using (TextReader tr = (!string.IsNullOrEmpty(options.InputFile) ? new StreamReader(options.InputFile) : Console.In)) { using (TextWriter tw = (!string.IsNullOrEmpty(options.OutputFile) ? new StreamWriter(options.OutputFile) : Console.Out)) { string line; while (null != (line = tr.ReadLine())) { bool matchResult = re.IsMatch(line); matchResult = options.InvertResults ? !matchResult : matchResult; if (matchResult) { tw.WriteLine(line); } } } } } }
static int Main(string[] args) { var options = new Options(); var parser_options = new CommandLine.ParserSettings { MutuallyExclusive = true }; var parser = new CommandLine.Parser(parser_options); var isValid = parser.ParseArguments(args, options); if (!isValid) { Console.WriteLine(CommandLine.Text.HelpText.AutoBuild(options).ToString()); return(-1); } Console.WriteLine("Parameters used:"); string propname = "com_dut"; save_property(propname, options.Com_DUT); string valuestr = Properties.Settings.Default[propname].ToString(); if (valuestr == null || valuestr == string.Empty) { Console.WriteLine(CommandLine.Text.HelpText.AutoBuild(options).ToString()); Console.WriteLine(propname.ToUpper() + " not specified"); return(-1); } Console.WriteLine(propname.ToUpper() + ": " + valuestr); string com_dut = valuestr; propname = "com_ble"; save_property(propname, options.com_ble); valuestr = Properties.Settings.Default[propname].ToString(); if (valuestr == null || valuestr == string.Empty) { Console.WriteLine(CommandLine.Text.HelpText.AutoBuild(options).ToString()); Console.WriteLine(propname.ToUpper() + " not specified"); return(-1); } Console.WriteLine(propname.ToUpper() + ": " + valuestr); string com_ble = valuestr; // Don't allow lower case serials options.SMT_Serial = options.SMT_Serial.ToUpper(); Console.WriteLine("SMT Serial: " + options.SMT_Serial); Diags.Customers customer = Diags.Customers.IRIS; if (options.Customer_Amazon) { customer = Diags.Customers.Amazon; } else if (options.Customer_Centralite) { customer = Diags.Customers.Centralite; } Console.WriteLine("Costumer: " + customer.ToString()); Console.WriteLine("HW Version: " + options.HW_Version); string tester = DataUtils.OperatorName(options.Tester); int tester_id = DataUtils.OperatorId(tester); Console.WriteLine("Tester: " + tester); Console.WriteLine(); // For debug //Console.WriteLine("Press Enter to continue"); //Console.ReadLine(); Console.WriteLine("Run Tests..."); try { using ( Diags diags = new Diags ( dut_port_name: com_dut, ble_port_name: com_ble, smt_serial: options.SMT_Serial, customer: customer, hw_version: options.HW_Version, tester: tester, hub_ip_addr: options.Hub_IP ) ) { diags.LogFolder = Properties.Settings.Default.Log_Folder; Directory.CreateDirectory(diags.LogFolder); diags.Status_Event += Diags_Status_Event; diags.Program_Radios = options.Program_Radios; diags.BLETestDisable = options.BLETestDisabeld; diags.Run(); } } catch (Exception ex) { Console.WriteLine(); Console.WriteLine(ex.Message); Console.WriteLine(); Console.WriteLine(ex.StackTrace); if (ex is System.Data.Entity.Validation.DbEntityValidationException) { var exd = (System.Data.Entity.Validation.DbEntityValidationException)ex; foreach (var eves in exd.EntityValidationErrors) { Console.WriteLine(eves.Entry.Entity.ToString()); foreach (var eve in eves.ValidationErrors) { Console.WriteLine(eve.ErrorMessage); } } } else if (ex is System.Data.Entity.Infrastructure.DbUpdateException) { var exd = (System.Data.Entity.Infrastructure.DbUpdateException)ex; Console.WriteLine(exd.InnerException.InnerException.Message); } return(-1); } finally { Diags.Set_all_relays(false); } Console.WriteLine("All Tests Passed"); return(0); }
public static int Main(string[] args) { try { ArgumentOptions options = new ArgumentOptions(); var parser = new CommandLine.Parser(config => config.HelpWriter = Console.Out); if (parser.ParseArguments(args, options)) { if (!string.IsNullOrEmpty(options.Config)) { configPath = options.Config; } if (Directory.Exists(configPath)) { Config config = Config.Load(configPath); Output(string.Format("[{0}] Started Server Maintenance Process.", DateTime.Now)); using (TeknikEntities db = new TeknikEntities()) { // Scan all the uploads for viruses, and remove the bad ones if (options.ScanUploads && config.UploadConfig.VirusScanEnable) { ScanUploads(config, db); } // Warns all the invalid accounts via email if (options.WarnAccounts) { WarnInvalidAccounts(config, db); } // Cleans all inactive users if (options.CleanUsers) { CleanAccounts(config, db, options.DaysBeforeDeletion); } // Cleans the email for unused accounts if (options.CleanEmails) { CleanEmail(config, db); } // Cleans all the git accounts that are unused if (options.CleanGit) { CleanGit(config, db); } // Generates a file for all of the user's last seen dates if (options.GenerateLastSeen) { GenerateLastSeen(config, db, options.LastSeenFile); } // Generates a file for all of the invalid accounts if (options.GenerateInvalid) { GenerateInvalidAccounts(config, db, options.InvalidFile); } // Generates a file for all of the accounts to be cleaned if (options.GenerateCleaning) { GenerateCleaningList(config, db, options.CleaningFile, options.DaysBeforeDeletion); } } Output(string.Format("[{0}] Finished Server Maintenance Process.", DateTime.Now)); return(0); } else { string msg = string.Format("[{0}] Config File does not exist.", DateTime.Now); File.AppendAllLines(errorFile, new List <string> { msg }); Output(msg); } } else { Output(options.GetUsage()); } } catch (Exception ex) { string msg = string.Format("[{0}] Exception: {1}", DateTime.Now, ex.GetFullMessage(true)); File.AppendAllLines(errorFile, new List <string> { msg }); Output(msg); } return(-1); }
public void Parse_different_arrays_together__combination_two() { var options = new SimpleOptionsWithArray(); var parser = new CommandLine.Parser(); var result = parser.ParseArguments(new string[] { "-z", "one", "two", "three", "four", "-y", "1", "2", "3", "4", "-q", "0.1", "0.2", "0.3", "0.4", "--string=after" }, options); result.Should().BeTrue(); base.ElementsShouldBeEqual(new string[] { "one", "two", "three", "four" }, options.StringArrayValue); base.ElementsShouldBeEqual(new int[] { 1, 2, 3, 4 }, options.IntegerArrayValue); base.ElementsShouldBeEqual(new double[] { .1, .2, .3, .4 }, options.DoubleArrayValue); options.StringValue.Should().Be("after"); options = new SimpleOptionsWithArray(); parser = new CommandLine.Parser(); result = parser.ParseArguments(new string[] { "--string", "before", "-y", "1", "2", "3", "4", "-z", "one", "two", "three", "four", "-q", "0.1", "0.2", "0.3", "0.4" }, options); result.Should().BeTrue(); options.StringValue.Should().Be("before"); base.ElementsShouldBeEqual(new int[] { 1, 2, 3, 4 }, options.IntegerArrayValue); base.ElementsShouldBeEqual(new string[] { "one", "two", "three", "four" }, options.StringArrayValue); base.ElementsShouldBeEqual(new double[] { .1, .2, .3, .4 }, options.DoubleArrayValue); options = new SimpleOptionsWithArray(); parser = new CommandLine.Parser(); result = parser.ParseArguments(new string[] { "-q", "0.1", "0.2", "0.3", "0.4", "-y", "1", "2", "3", "4", "-s", "near-the-center", "-z", "one", "two", "three", "four" }, options); result.Should().BeTrue(); base.ElementsShouldBeEqual(new double[] { .1, .2, .3, .4 }, options.DoubleArrayValue); base.ElementsShouldBeEqual(new int[] { 1, 2, 3, 4 }, options.IntegerArrayValue); options.StringValue.Should().Be("near-the-center"); base.ElementsShouldBeEqual(new string[] { "one", "two", "three", "four" }, options.StringArrayValue); options = new SimpleOptionsWithArray(); parser = new CommandLine.Parser(); result = parser.ParseArguments(new string[] { "--switch", "-z", "one", "two", "three", "four", "-y", "1", "2", "3", "4", "-i", "1234", "-q", "0.1", "0.2", "0.3", "0.4", "--string", "I'm really playing with the parser!" }, options); result.Should().BeTrue(); options.BooleanValue.Should().BeTrue(); base.ElementsShouldBeEqual(new string[] { "one", "two", "three", "four" }, options.StringArrayValue); base.ElementsShouldBeEqual(new int[] { 1, 2, 3, 4 }, options.IntegerArrayValue); options.IntegerValue.Should().Be(1234); base.ElementsShouldBeEqual(new double[] { .1, .2, .3, .4 }, options.DoubleArrayValue); options.StringValue.Should().Be("I'm really playing with the parser!"); }
static void Main(string[] args) { var options = new Parameters.Options(); var parser = new CommandLine.Parser(); if (!parser.ParseArguments(args, options)) { System.Console.WriteLine("Command line parameters wrong..."); System.Console.WriteLine(options.GetUsage()); System.Environment.Exit(1); } var parseOptions = new Options { MinifyJson = options.Minify, ExcludeUntisIdZero = options.ExcludeZero, DateThreshold = options.UseThreshold ? new DateTimeOffset(DateTime.Today, DateTimeOffset.Now.Offset) : null as DateTimeOffset? }; var input = Path.GetFullPath(options.InputFile); var output = string.IsNullOrEmpty(options.OutputFile) ? null : Path.GetFullPath(options.OutputFile); var csv = string.Empty; if (!File.Exists(input)) { System.Console.WriteLine(string.Format("File {0} does not exist", input)); System.Environment.Exit(1); } if (options.Verbose) { System.Console.WriteLine(string.Format("reading file {0}", input)); } using (var reader = new StreamReader(input, Encoding.Default)) // Untis files are stored in ANSI format { csv = reader.ReadToEnd(); } if (options.Verbose) { System.Console.WriteLine("parsing file..."); } var json = string.Empty; if (options.Type == "substitutions") { json = UntisJson.ParseSubstitutionsAsJson(csv, parseOptions); } else if (options.Type == "exams") { json = UntisJson.ParseExamAsJson(csv, parseOptions); } else { System.Console.WriteLine("Unknown input type specified"); System.Environment.Exit(1); } if (options.Verbose) { System.Console.WriteLine("Parsing finished."); System.Console.WriteLine("Writing output..."); } if (!string.IsNullOrEmpty(output)) { using (var writer = new StreamWriter(output)) { writer.Write(json); } } else { System.Console.WriteLine(json); } if (options.Verbose) { System.Console.WriteLine("Finished."); } }
static void Main(string[] args) { Console.WriteLine("MetadataGenerator " + args.ToAggregateString(" ")); var parser = new CommandLine.Parser(ps => { ps.MutuallyExclusive = true; ps.HelpWriter = Console.Out; }); if (!parser.ParseArguments(args, Options)) { return; } var assemblyName = GetAssemblyName(Options.InputFile); if (!File.Exists(assemblyName)) { Console.WriteLine("The specified file {0} cannot be found", assemblyName); return; } var dbContextTypes = GetDbContextTypesFromAssembly(assemblyName); if (dbContextTypes.Length == 1 || Options.TypeName != null) { if (Options.TypeName != null) { try { var type = dbContextTypes.SingleOrDefault(t => t.Name == Options.TypeName || t.FullName == Options.TypeName); if (type != null) { ProcessType(type, Options.OutputFile ?? Options.TypeName + ".json"); } else { Console.WriteLine("The type specified {0} can not be found in the assembly {1}", Options.TypeName, assemblyName); } } catch (InvalidOperationException) { Console.WriteLine("There are several types named {0} in the assembly {1}", Options.TypeName, assemblyName); } catch (Exception ex) { Console.WriteLine(ex); } } else { var type = dbContextTypes.First(); ProcessType(type, Options.OutputFile ?? type.FullName + ".json"); } } else { // Handle multitype scenario. foreach (var type in dbContextTypes) { //if (type.FullName.Contains("BaseCtx")) continue; ProcessType(type, Options.OutputFile ?? $"{type.FullName}.json"); } } }
static int Main(string[] args) { //Console.WriteLine("Press Enter to continue"); //Console.Read(); _log.Info("App started"); var options = new Options(); var parser_options = new CommandLine.ParserSettings { MutuallyExclusive = true }; var parser = new CommandLine.Parser(parser_options); var isValid = parser.ParseArguments(args, options); if (!isValid) { Console.WriteLine(CommandLine.Text.HelpText.AutoBuild(options).ToString()); return(-1); } // Don't allow lower case serial options.SMT_Serial = options.SMT_Serial.ToUpper(); Console.WriteLine("SMT Serial: " + options.SMT_Serial); Console.WriteLine("Host: " + options.Host); Console.WriteLine(); // Check board was passed diags try { using (CLStoreEntities cx = new CLStoreEntities()) { LowesHub h = cx.LowesHubs.Where(lh => lh.smt_serial == options.SMT_Serial).OrderByDescending(lh => lh.date).First(); string info = string.Format("Hub {0} last diags {1}", h.MacAddress.MAC.ToString("X"), h.date.ToString()); _log.Info(info); } } catch (Exception ex) { _log.Fatal("Problem retrieving Hub diag info\r\n\r\n" + ex.Message + "\r\n" + ex.StackTrace); return(-3); } if (options.CalibrateLEDs) { BatteryTest batcal = new BatteryTest(options.Host, options.SMT_Serial); char save_option = 'n'; while (true) { Console.WriteLine("Getting LEDs values...\r\n"); double[] values = batcal.GetLEDsValues(); int i = 0; Console.WriteLine("Red On : {0}", values[i++].ToString("G2")); Console.WriteLine("Green On : {0}", values[i++].ToString("G2")); Console.WriteLine("Yellow On: {0}", values[i++].ToString("G2")); Console.WriteLine(); Console.WriteLine("Red Off : {0}", values[i++].ToString("G2")); Console.WriteLine("Green Off : {0}", values[i++].ToString("G2")); Console.WriteLine("Yellow Off: {0}", values[i++].ToString("G2")); i = 0; Properties.Settings.Default.LED_Red_On_Val = values[i++]; Properties.Settings.Default.LED_Green_On_Val = values[i++]; Properties.Settings.Default.LED_Yellow_On_Val = values[i++]; Properties.Settings.Default.LED_Red_Off_Val = values[i++]; Properties.Settings.Default.LED_Green_Off_Val = values[i++]; Properties.Settings.Default.LED_Yellow_Off_Val = values[i++]; Console.WriteLine("Save Values? (y/n/r):"); save_option = Convert.ToChar(Console.Read()); if (save_option != 'r') { break; } } if (save_option == 'y') { Properties.Settings.Default.Save(); } } try { if (!options.NoJigMode) { BatteryTest battery_test = new BatteryTest(options.Host, options.SMT_Serial); battery_test.InvalidateEnabled = !options.DisableInvalidate; battery_test.Status_Event += Battery_test_Status_Event; battery_test.LogFolder = Properties.Settings.Default.Log_Folder; Directory.CreateDirectory(battery_test.LogFolder); battery_test.LED_Red.OnVal = Properties.Settings.Default.LED_Red_On_Val; battery_test.LED_Red.OffVal = Properties.Settings.Default.LED_Red_Off_Val; battery_test.LED_Green.OnVal = Properties.Settings.Default.LED_Green_On_Val; battery_test.LED_Green.OffVal = Properties.Settings.Default.LED_Green_Off_Val; battery_test.LED_Yellow.OnVal = Properties.Settings.Default.LED_Yellow_On_Val; battery_test.LED_Yellow.OffVal = Properties.Settings.Default.LED_Yellow_Off_Val; battery_test.Run(); } else { BatteryTestNoJig batery_test = new BatteryTestNoJig(options.Host, options.SMT_Serial); batery_test.InvalidateEnabled = !options.DisableInvalidate; batery_test.Status_Event += Baterytest_Status_Event; batery_test.LogFolder = Properties.Settings.Default.Log_Folder; Directory.CreateDirectory(batery_test.LogFolder); batery_test.Run(); } } catch (Exception ex) { _log.Fatal(ex.Message + "\r\n" + ex.StackTrace); return(-2); } finally { if (!options.NoJigMode) { BatteryJig.Set_all_relays(false); } } _log.Info("All Tests Passed"); if (!options.PrintLabelDisabled) { _log.Info("Printing label..."); try { DataUtils.PrintHubLabel( options.SMT_Serial, Properties.Settings.Default.ZPL_Lable_File, Properties.Settings.Default.Printer_Address); } catch (Exception ex) { _log.Fatal(ex.Message + "\r\n" + ex.StackTrace); return(-2); } finally { } } return(0); }
static int Main(string[] args) { var options = new Options(); var parser = new CommandLine.Parser(s => { s.MutuallyExclusive = false; }); var isValid = parser.ParseArguments(args, options); if (!isValid) { Console.WriteLine(CommandLine.Text.HelpText.AutoBuild(options).ToString()); return(-1); } try { _board_serial = options.BoardSerial; _top_margin = options.TopMargin; _left_margin = options.LeftMargin; _font_name = options.FontName; _font_size = options.FontSize; // Set printer string name = ""; foreach (string printer in PrinterSettings.InstalledPrinters) { if (printer == options.PrinterName) { name = printer; break; } } if (string.IsNullOrEmpty(name)) { Console.WriteLine(options.PrinterName + " printer not found. Make sure printer is installed..."); return(-1); } PrintDocument pdoc = new PrintDocument(); pdoc.PrinterSettings.PrinterName = name; pdoc.PrintPage += Pdoc_PrintPage; // Set Paper pdoc.PrintController = new StandardPrintController(); name = ""; foreach (PaperSize ps in pdoc.PrinterSettings.PaperSizes) { //string sz = string.Format("{0} ({1:0.000} x {2:0.000})", ps.PaperName, (float)ps.Width / 100, (float)ps.Height / 100); if (ps.PaperName == options.PaperName) { name = ps.PaperName; pdoc.DefaultPageSettings.PaperSize = ps; break; } } if (string.IsNullOrEmpty(name)) { Console.WriteLine(options.PaperName + " paper not found"); return(-1); } pdoc.Print(); } catch (Exception ex) { Console.WriteLine(ex.Message + "\r\n" + ex.StackTrace); return(-2); } return(0); }