public void AlternameName()
 {
     CommandLineParser parser = new CommandLineParser(typeof(CommandLineArgs),
                                                      new string[] {"/Database", "TestDb", "/s", "TestServer"});
     CommandLineArgs args = (CommandLineArgs) parser.Parse();
     Assert.AreEqual("TestServer", args.Server);
 }
Beispiel #2
0
        public void Parse()
        {
            string[]  parameterArray = new string[] { "/Database", "TestDb", "/server", "TestServer" };
            ArrayList parameters     = new ArrayList(parameterArray);

            CommandLineParser parser = new CommandLineParser(typeof(CommandLineArgs), (string[])parameters.ToArray(typeof(string)));
            CommandLineArgs   args   = (CommandLineArgs)parser.Parse();

            Assert.AreEqual("TestDb", args.Database);
            Assert.AreEqual("TestServer", args.Server);
            Assert.AreEqual(true, args.Check);

            parameters.Add("/Check-");
            parser = new CommandLineParser(typeof(CommandLineArgs), (string[])parameters.ToArray(typeof(string)));
            args   = (CommandLineArgs)parser.Parse();
            Assert.AreEqual(false, args.Check);
        }
 public void List()
 {
     CommandLineParser parser = new CommandLineParser(typeof(CommandLineArgs),
                                                      new string[] {"/Database", "TestDb", "/Excludes", "Tasks,Resources"});
     CommandLineArgs args = (CommandLineArgs) parser.Parse();
     Assert.IsNotNull(args.Excludes);
     Assert.AreEqual(2, args.Excludes.Count);
 }
 public void ValueNotSpecifiedIndex()
 {
     CommandLineParser parser = new CommandLineParser(typeof(CommandLineArgs),
                                                      new string[] {"/Server"});
     parser.Parse();
 }
 public void PlaceNotSpecfied()
 {
     CommandLineParser parser = new CommandLineParser(typeof(CommandLineArgsTwoPlace),
                                                      new string[] {"Test"});
     parser.Parse();
 }
 public void PlaceOptional()
 {
     CommandLineParser parser = new CommandLineParser(typeof(CommandLineArgsTwoPlace),
                                                      new string[] {"Test", "Other"});
     CommandLineArgsTwoPlace cmd = (CommandLineArgsTwoPlace) parser.Parse();
     Assert.AreEqual("Default", cmd.Third);
 }
 public void Place()
 {
     CommandLineParser parser = new CommandLineParser(typeof(CommandLineArgsPlace),
                                                      new string[] {"Data", "/Database", "TestDb"});
     CommandLineArgsPlace args = (CommandLineArgsPlace) parser.Parse();
     Assert.AreEqual("Data", args.Compare);
     Assert.AreEqual("TestDb", args.Database);
 }
        public void Parse()
        {
            string[] parameterArray = new string[] {"/Database", "TestDb", "/server", "TestServer"};
            ArrayList parameters = new ArrayList(parameterArray);

            CommandLineParser parser = new CommandLineParser(typeof(CommandLineArgs), (string[]) parameters.ToArray(typeof(string)));
            CommandLineArgs args = (CommandLineArgs) parser.Parse();
            Assert.AreEqual("TestDb", args.Database);
            Assert.AreEqual("TestServer", args.Server);
            Assert.AreEqual(true, args.Check);

            parameters.Add("/Check-");
            parser = new CommandLineParser(typeof(CommandLineArgs), (string[]) parameters.ToArray(typeof(string)));
            args = (CommandLineArgs) parser.Parse();
            Assert.AreEqual(false, args.Check);
        }
 public void Optional()
 {
     CommandLineParser parser = new CommandLineParser(typeof(CommandLineArgs),
                                                      new string[] {"/Database", "TestDb"});
     CommandLineArgs args = (CommandLineArgs) parser.Parse();
     Assert.AreEqual("Default", args.Server);
 }
 public void NonOptional()
 {
     CommandLineParser parser = new CommandLineParser(typeof(CommandLineArgs),
                                                      new string[] {"/Server", "TestServer"});
     parser.Parse();
 }
Beispiel #11
0
        private static int Main(string[] args)
        {
            ControlEventHandler eventHandler = new ControlEventHandler(Handler);

            SetConsoleCtrlHandler(eventHandler, true);

            Discovery dis       = new Discovery();
            Assembly  assembly  = Assembly.GetExecutingAssembly();
            string    directory = Path.GetDirectoryName(assembly.Location);

            foreach (string file in Directory.GetFiles(directory, "*.dll"))
            {
                dis.AddAssembly(file);
            }
            string exeName     = Path.GetFileNameWithoutExtension(Assembly.GetEntryAssembly().CodeBase);
            Type   commandType = dis.GetClass(typeof(NamedAttribute), new NamedAttribute(exeName));

            if (commandType == null)
            {
                WriteOutput(string.Format("Coult not find Command '{0}' to execute", exeName));
                return(-4);
            }
            CommandLineParser parser = new CommandLineParser(commandType, args);

            if (args.Length == 0 || args[0] == "/?" || args[0] == "--help")
            {
                Console.WriteLine(parser.Usage);
                return(-1);
            }
            if (args.Length == 1 && (args[0] == "/v" || args[0] == "-v" || args[0] == "--v"))
            {
                Version ver = Assembly.GetExecutingAssembly().GetName().Version;
                Console.WriteLine(exeName + " version " + ver.ToString());
                return(0);
            }
            try
            {
                ICommand com = (ICommand)parser.Parse();
                if (com is Commandlet)
                {
                    commandlet = (Commandlet)com;
                    commandlet.ExecutableName      = exeName;
                    commandlet.ExecutableDirectory = directory;
                }
                com.Execute();
                if (com.Outputs != null)
                {
                    foreach (object res in com.Outputs)
                    {
                        WriteOutput(res.ToString());
                    }
                }
                if (com.Result != null)
                {
                    return(Int32.Parse(com.Result));
                }
                else
                {
                    return(0);
                }
            }
            catch (CommandLineArgumentException ex)
            {
                WriteOutput(ex.Message + "\r\n");
                WriteOutput(parser.Usage);
                return(-1);
            }
            catch (ApplicationException ex)
            {
                WriteOutput(ex.Message);
                return(-3);
            }
            catch (Exception ex)
            {
                commandlet.Exception(ex);
                while (ex != null)
                {
                    WriteOutput(ex.Message + "\r\n" + ex.StackTrace);
                    ex = ex.InnerException;
                }
                return(-2);
            }
        }