C# Parser.ParseArguments方法代码示例

        public void Errors_of_type_MutuallyExclusiveSetError_are_properly_formatted()
        {
            // Fixture setup
            var help = new StringWriter();
            var sut = new Parser(config => config.HelpWriter = help);

            // Exercize system
            sut.ParseArguments<FakeOptionsWithTwoRequiredAndSets>(
                new[] { "--weburl=value.com", "--ftpurl=value.org" });
            var result = help.ToString();

            // Verify outcome
            result.Length.Should().BeGreaterThan(0);
            var lines = result.ToNotEmptyLines().TrimStringArray();
            lines[0].Should().StartWithEquivalent("CommandLine");
            lines[1].ShouldBeEquivalentTo("Copyright (c) 2005 - 2015 Giacomo Stelluti Scala");
            lines[2].ShouldBeEquivalentTo("ERROR(S):");
            lines[3].ShouldBeEquivalentTo("Option: 'weburl' is not compatible with: 'ftpurl'.");
            lines[4].ShouldBeEquivalentTo("Option: 'ftpurl' is not compatible with: 'weburl'.");
            lines[5].ShouldBeEquivalentTo("--weburl     Required.");
            lines[6].ShouldBeEquivalentTo("--ftpurl     Required.");
            lines[7].ShouldBeEquivalentTo("-a");
            lines[8].ShouldBeEquivalentTo("--help       Display this help screen.");
            lines[9].ShouldBeEquivalentTo("--version    Display version information.");
            // Teardown
        }

        public void Failed_verb_parsing_prints_particular_help_screen()
        {
            string invokedVerb = null;
            object invokedVerbInstance = null;

            var options = new OptionsWithVerbsHelp();
            var testWriter = new StringWriter();
            ReflectionUtil.AssemblyFromWhichToPullInformation = Assembly.GetExecutingAssembly();
            var parser = new Parser(with => with.UseHelpWriter(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);
        }

        public static void Arguments_with_the_same_values_when_unknown_arguments_are_ignored()
        {
            var sameValues = new[] { "--stringvalue=test", "--shortandlong=test" };
            var sut = new Parser(parserSettings => { parserSettings.IgnoreUnknownArguments = true; });
            var result = sut.ParseArguments<Simple_Options>(sameValues);

            result.MapResult(_ => true, _ => false).Should().BeTrue();
        }

        public void Parsing_mutually_exclusive_options_and_required_option_fails()
        {
            var options = new OptionsWithMultipleSetAndOneOption();
            var parser = new Parser(new ParserSettings { MutuallyExclusive = true });
            var result = parser.ParseArguments(new string[] { "-g167", "--hue", "205" }, options);

            result.Should().BeFalse();
        }

        public void Parsing_one_mutually_exclusive_option_succeeds()
        {
            var options = new OptionsWithDefaultSet();
            var parser = new 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 Allow_single_dash_as_option_input_value()
        {
            var options = new SimpleOptions();
            var parser = new Parser();
            var result = parser.ParseArguments(new string[] { "--string", "-" }, options);

            result.Should().BeTrue();
            options.StringValue.Should().Be("-");
        }

        public void Between_value_options_order_matters()
        {
            var options = new SimpleOptionsWithValueOptionAndValueList();
            var parser = new Parser();
            var result = parser.ParseArguments(
                new string[] { "4321", "ofvalueoption", "-1234", "forvaluelist1", "forvaluelist2", "forvaluelist3" }, options);

            result.Should().BeFalse();
        }

        public void Parse_valid_unknown_arguments()
        {
            string[] args = { "--plugin", "addonX", "--filename", "input.dat" };
            var appOptions = new OptionsForAppWithPlugIns();
            var parser = new 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 Default_parsing_is_case_sensitive()
        {
            var parser = new 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");
        }

 [Test] public void PositionalsGroupsTestGroupFirst()
 {
     var parser = new Parser();
     var group = parser.AddArgumentGroup("xxx");
     group.AddArgument("foo");
     parser.AddArgument("bar");
     parser.AddArgument("baz");
     Asserter.AreEqual(new ParseResult {{"foo", "1"}, {"bar", "2"}, {"baz", "3"}},
         parser.ParseArguments("1 2 3".Split(new char[] {})));
 }

        public void Correct_input_not_activates_help()
        {
            var options = new MockOptions();
            var writer = new StringWriter();
            var parser = new Parser();
            var result = parser.ParseArguments(
                    new string[] { "-imath.xml", "-oresult.xml" }, options, writer);

            result.Should().BeTrue();;
            writer.ToString().Length.Should().Be(0);
        }

        public void Setting_help_writer_using_constructor()
        {
            var writer = new StringWriter();
            IParser parser = new 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 void Parsing_mutually_exclusive_options_and_required_option_succeeds()
        {
            var options = new OptionsWithMultipleSetAndOneOption();
            var parser = new 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 Allow_single_dash_as_non_option_value()
        {
            var options = new SimpleOptionsWithValueList();
            var parser = new 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 CommandOptions Process(string[] args)
        {
            var options = new CommandOptions();
            var parser = new Parser();

            if (!parser.ParseArguments(args, options))
            {
                throw new InvalidOperationException(options.GetUsage());
            }

            return options;
        }