示例#1
0
        public Command(string[] _args)
        {
            uo = new UrlOperations(this);
            args = _args;
            //create parser
            parser = new CMDLineParser();

            if(_args.Length != 0){
                urlOpt = parser.AddStringParameter("-url", "adress of the website", true);
                if("get".Equals(_args[0]) || "test".Equals(_args[0])){
                    if("get".Equals(_args[0])){
                        getOpt=true;
                        saveOpt = parser.AddStringParameter("-save", "save the content of the website", false);
                    }
                    if("test".Equals(_args[0])){
                        testOpt=true;
                        timesOpt = parser.AddIntParameter("-times", "number of time to load the website", true);
                        avgOpt = parser.AddBoolSwitch("-avg", "average time to load the website");
                    }
                    try{
                        //parse the command line
                        parser.Parse(args);
                    } catch (CMDLineParser.CMDLineParserException ex){
                        getHelp();
                        Console.WriteLine("Error: " + ex.Message);
                        return;
                    }
                    //replace argument list with remaining arguments
                    args = parser.RemainingArgs();
                } else {
                    getHelp();
                  	Console.WriteLine("Error: Missing Required option: 'get' or 'set'");
                  	return;
                }
            }
        }
示例#2
0
        public WorkInstruction(string[] CommandlineArguments)
        {
            //Set default values
            this.Execute = false;
            this.GenerateReport = false;
            this.DestinationFilepath = "";
            this.DestinationFormat = OutputFormatEnum.Unknown;

            CMDLineParser parser = new CMDLineParser();
            parser.throwInvalidOptionsException = true;

            //Add -Help option
            CMDLineParser.Option HelpOption = parser.AddBoolSwitch("-Help", "Displays help");
            HelpOption.AddAlias("/?");

            //Add -Run option
            CMDLineParser.Option RunOption = parser.AddBoolSwitch("-Run", "Required. Execute all files in compilation path");

            //Add -Path parameter
            CompilationPathOption PathParameter = new CompilationPathOption("-Path", "Compilation path to load scripts from", false);
            parser.AddOption(PathParameter);

            //Add -Format parameter
            ReportFormatOption FormatParameter = new ReportFormatOption("-Format", "Format of the report that should be generated (HTML, XML, JSON)", false);
            parser.AddOption(FormatParameter);

            //Add -Filename parameter
            FilenameOption FilenameParameter = new FilenameOption("-Filename", "Filename of the generated report", false);
            parser.AddOption(FilenameParameter);

            //Add -Text parameter
            CMDLineParser.Option TextParameter = parser.AddStringParameter("-Text", "Additional text to be included in generated report", false);
            //FilenameParameter.AddAlias("/Text");

            bool commandLineParsed = false;

            try
            {
                parser.Parse(CommandlineArguments);
                commandLineParsed = true;
            }
            catch (CMDLineParser.CMDLineParserException ex)
            {
                //That didn't worked...
                Console.WriteLine(ex.Message);
                Console.WriteLine("Use /? for help");
                Console.WriteLine();
            }

            if (commandLineParsed)
            {
                if (HelpOption.isMatched)
                {
                    Console.WriteLine(parser.HelpMessage());
                }
                else
                {
                    if (RunOption.isMatched == false)
                    {
                        //No -Run command, nothing to do.
                        Console.WriteLine("Missing -RUN option");
                        Console.WriteLine(parser.HelpMessage());
                    }
                    else
                    {
                        this.Execute = true;

                        //Check for PATH parameter is set and use default path if not
                        this.CompilationPath = OptionIsMatchedAndNotEmpty(PathParameter) ? PathParameter.Value.ToString() : Xteq5UIConstant.DefaultCompilationFolder;

                        //Check for FILENAME parameter if we should generate a report. Only if this is set, check the additonal parameters for the report
                        if (OptionIsMatchedAndNotEmpty(FilenameParameter))
                        {
                            this.GenerateReport = true;
                            this.DestinationFilepath = FilenameParameter.Value.ToString();

                            //Check for the FORMAT parameter and use HTML if not set
                            string reportFormatString = OptionIsMatchedAndNotEmpty(FormatParameter) ? FormatParameter.Value.ToString() : "HTML";

                            //This direct cast without any error checking is OK because FORMATPARAMETER already tried to parse it and will only be set if the value is OK
                            this.DestinationFormat = OutputFormatConverter.ParseReportFormat(reportFormatString);

                            this.UserText = OptionIsMatchedAndNotEmpty(TextParameter) ? TextParameter.Value.ToString() : "";

                        }

                        //All done!

                    }
                }
            }
        }
        /// <summary>
        /// Run Test Cases for CMDLineParser
        /// </summary>
        public static void RunTests()
        {
            Console.WriteLine("\nStarting CMDLineParser tests:\n");
            //create parser
            CMDLineParser parser = new CMDLineParser();
            parser.throwInvalidOptionsException = false;

            //add Options
            #region addOptions
            CMDLineParser.Option DebugOption = parser.AddBoolSwitch("-Debug", "Print Command Line Parser Debug information");
            DebugOption.AddAlias("/Debug");
            CMDLineParser.Option OptionOpenfolder = parser.AddBoolSwitch("/openfolder", "Open files in folder if path is a folder");
            OptionOpenfolder.AddAlias("-openfolder");
            CMDLineParser.Option UserNameOpt = parser.AddStringParameter("-User="******"User Name", true);
            UserNameOpt.AddAlias("-U");
            CMDLineParser.NumberOption DoubleOpt = parser.AddDoubleParameter("-DoubleNum", "A Double", false);
            NumberFormatInfo numberformat = (new CultureInfo("de-DE", false)).NumberFormat;
            CMDLineParser.NumberOption FormatedNumOpt = parser.AddDoubleParameter("-NegNum", "A negativ Number", false, numberformat);
            CMDLineParser.Option IntNumOpt = parser.AddIntParameter("-IntNum", "A Integer Number", false);

            //Test creation of an invalid option - Throws exception
            string test = "Test creation of an invalid option";
            string testcomment = " - " + test + " - :";
            try
            {
                CMDLineParser.Option InvalidOpt = parser.AddStringParameter("-Option Nr1", "Invalid Option", false);
                Console.WriteLine("\nTestFailed: " + testcomment);
            }
            catch (CMDLineParser.CMDLineParserException ex)
            {

                Console.WriteLine("\nTestOK: " + testcomment + "Caught Error: " + ex.Message);
            }
            #endregion

            //do tests and write results to the console window
            #region Tests
            //test missing required opt -U
            String[] testmissingreqopt = { "/Debug" }; //missing required opt -U
            TestException("missing required opt -U", parser, testmissingreqopt, typeof(CMDLineParser.MissingRequiredOptionException));

            //test neg. integer
            String[] test1 = { "-UChris", "-NegNum", "-13,56", "-IntNum", "-123", "/Debug" };
            TestOption("test neg. integer", parser, test1, IntNumOpt);

            //test Double Option
            double val = -10113.56;
            String[] testDoubleOptPoint = { "-UChris", "-DoubleNum", "-10113.56" }; //test formated double
            String[] testDoubleOptComma = { "-UChris", "-DoubleNum", "-10113,56" }; //test formated double
            TestOptionValue("testDoubleOpt-dec.point", parser, testDoubleOptPoint, DoubleOpt, val);
            TestOptionValue("testDoubleOpt-dec.comma", parser, testDoubleOptComma, DoubleOpt, val);

            //test formated (globalized) double
            String[] test2 = { "-UChris", "-NegNum", "-10.113,56", "-IntNum", "123", "/Debug" }; //test formated double
            TestOption("test formated double", parser, test2, FormatedNumOpt);

            //test wrong int format
            String[] test3 = { "-UChris", "-IntNum", "123.00", "/Debug" }; //test wrong int format
            TestException("test wrong int format", parser, test3, typeof(CMDLineParser.ParameterConversionException));

            //test InvalidOptionsException
            String[] test4 = { "-UChris", "-Inv", "-IntNum", "-123", "/Debug", "/Inv2" }; //invalid options found
            parser.throwInvalidOptionsException = true;
            TestException("invalid options found", parser, test4, typeof(CMDLineParser.InvalidOptionsException));
            //parser.Debug();

            //test custom (subclassed) option
            String[] testDate = { "-Date", "2001-11-22" }; //test custom (subclassed) option

            // New parser instance
            CMDLineParser parser2 = new CMDLineParser();

            parser2.throwInvalidOptionsException = true;
            PastDateOption DateOpt = new PastDateOption("-Date", "A test Date", false);
            parser2.AddOption(DateOpt);
            TestOption("test custom (subclassed) option", parser2, testDate, DateOpt);
            //parser2.Debug();

            //Test missing parseValue method
            MissingMethodOption missMethOpt = new MissingMethodOption("-missing", "test opt", false);
            parser2.AddOption(missMethOpt);
            string[] testmiss = { "-missing", "123" };
            TestException("Test missing parseValue method", parser2, testmiss, typeof(CMDLineParser.ParameterConversionException));

            //test 'help'
            parser2.AddHelpOption();
            parser2.isConsoleApplication = true;
            parser2.throwInvalidOptionsException = false;
            String[] testh = { "-?" };
            TestOption("test help", parser2, testh, null);

            //test generic DefaultOption ( using Convert.ChangeType..)
            //one of the two methods will fail depend on your system settings
            double dval = -10113.56;
            String[] testDefOpt1 = { "/Debug", "-NegNum", "-10113.56"}; //test formated double
            String[] testDefOpt2 = { "/Debug", "-NegNum", "-10113,56"}; //test formated double

            DefaultOption defnumop = new DefaultOption("-NegNum", "Test default Option", typeof(double), false);
            parser2.AddOption(defnumop);
            TestOptionValue("defnumop - dec.point", parser2, testDefOpt1, defnumop, dval);
            TestOptionValue("defnumop - dec.comma", parser2, testDefOpt2, defnumop, dval);

            #endregion

            parser2.Debug();

            //showCulturinfos();
        }