示例#1
0
        /// <summary>
        /// Initialize command-line argument parser and parse given
        /// command-line arguments.
        /// </summary>
        /// <param name="arguments">
        /// Array of strings representing command-line arguments to parse.
        /// </param>
        /// <returns>
        /// True if help should be printed, false otherwise.
        /// </returns>
        static bool ParseArguments(string[] arguments)
        {
            DefineSwitches();

            s_parser = new ArgumentParser(arguments, Switches);

            s_parser.Parse();

            if (s_parser.IsParsed(SwitchNames.Help) ||
                s_parser.NoneParsed(SwitchNames.ProjectFiles,
                SwitchNames.SolutionFiles, SwitchNames.SourceFiles))
            {
                return true;
            }

            return false;
        }
示例#2
0
		public void ParseUndefinedSwitch()
		{
			const string Name1 = "arg1";
			const string Name2 = "arg2";
			const string UndefinedName = "arg3";

			string[] arguments = new string[]
			{
				Switch.GetPrefixedName(Name1),
				Switch.GetPrefixedName(UndefinedName),
				Switch.GetPrefixedName(Name2)
			};

			SwitchCollection switches = new SwitchCollection();

			switches.Add(Name1);
			switches.Add(Name2);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.IsFalse(parser.IsParsed(Name1));
			Assert.IsFalse(parser.IsParsed(Name2));
			Assert.IsFalse(parser.IsParsed(UndefinedName));

			Assert.Throws<ParsingException>(delegate { parser.Parse(); });

			Assert.IsFalse(parser.IsParsed(Name2));
			Assert.IsFalse(parser.IsParsed(UndefinedName));

			Assert.IsTrue(parser.IsParsed(Name1));
		}
示例#3
0
		public void NumberSwitchesParsedProperty()
		{
			const string Name1 = "arg1";
			const string Name2 = "arg2";

			string[] arguments = new string[]
			{
				Switch.GetPrefixedName(Name1),
				Switch.GetPrefixedName(Name2)
			};

			SwitchCollection switches = new SwitchCollection();

			switches.Add(Name1);
			switches.Add(Name2);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.AreEqual(NoSwitches, parser.NumberSwitchesParsed);
			Assert.AreEqual(NoSwitches, m_emptyParser.NumberSwitchesParsed);

			parser.Parse();

			Assert.AreEqual(switches.Count, parser.NumberSwitchesParsed);

			Assert.IsTrue(parser.IsParsed(Name1));
			Assert.IsTrue(parser.IsParsed(Name2));
		}
示例#4
0
		public void ParseSwitchWithMissingArguments()
		{
			const string Name1 = "arg1";
			const string Name2 = "arg2";

			string[] arguments = new string[]
			{
				Switch.GetPrefixedName(Name1),
				Switch.GetPrefixedName(Name2)
			};

			SwitchCollection switches = new SwitchCollection();

			switches.Add(Name1);
			switches.Add(Name2, NoLongName, NoDescription, HasArguments, !IsRequired);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.IsFalse(parser.IsParsed(Name1));
			Assert.IsFalse(parser.IsParsed(Name2));

			Assert.Throws<ParsingException>(delegate { parser.Parse(); });

			Assert.IsTrue(parser.IsParsed(Name1));
			Assert.IsTrue(parser.IsParsed(Name2));
		}
示例#5
0
		public void ParseTwice()
		{
			const string Name1 = "arg1";
			const string Name2 = "arg2";

			string[] arguments = new string[]
			{
				Switch.GetPrefixedName(Name1),
				Switch.GetPrefixedName(Name2)
			};

			SwitchCollection switches = new SwitchCollection();

			switches.Add(Name1);
			switches.Add(Name2);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.IsFalse(parser.IsParsed(Name1));
			Assert.IsFalse(parser.IsParsed(Name2));

			parser.Parse();

			// No exceptions should be thrown on second successive call.
			Assert.DoesNotThrow(delegate { parser.Parse(); });

			Assert.IsTrue(parser.IsParsed(Name1));
			Assert.IsTrue(parser.IsParsed(Name2));
		}
示例#6
0
		public void ParseSwitchWithArguments()
		{
			const string Name1 = "name1";
			const string Name2 = "name2";
			const string Value1 = "value1";
			const string Value2 = "value2";

			string[] arguments = new string[]
			{
				Switch.GetPrefixedName(Name1),
				Value1,
				Value2,
				Switch.GetPrefixedName(Name2)
			};

			string[] argumentNames = new string[] { "arg1", "arg2" };

			string[] values = new string[] { Value1, Value2 };

			SwitchCollection switches = new SwitchCollection();

			switches.Add(Name1, NoLongName, NoDescription, IsRequired, argumentNames);
			switches.Add(Name2);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.IsFalse(parser.IsParsed(Name1));
			Assert.IsFalse(parser.IsParsed(Name2));

			parser.Parse();

			Assert.AreEqual(values, parser.GetValues(Name1));

			Assert.IsTrue(parser.IsParsed(Name1));
			Assert.IsTrue(parser.IsParsed(Name2));
		}
示例#7
0
		public void ParseSwitchWithExcessArguments()
		{
			const string Name1 = "name1";
			const string Name2 = "name2";
			const string Value1 = "value1";
			const string Value2 = "value2";
			const string Value3 = "value3";

			string[] arguments = new string[]
			{
				Switch.GetPrefixedName(Name1),
				Value1,
				Value2,
				Switch.GetPrefixedName(Name2)
			};

			string[] argumentNames = new string[] { "arg1", "arg2" };

			string[] enoughValues = new string[] { Value1, Value2 };

			string[] excessValues = new string[] { Value1, Value2, Value3 };

			SwitchCollection switches = new SwitchCollection();

			switches.Add(Name1, NoLongName, NoDescription, IsRequired, argumentNames);
			switches.Add(Name2);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.IsFalse(parser.IsParsed(Name1));
			Assert.IsFalse(parser.IsParsed(Name2));

			// No exceptions should be thrown. Excess arguments should be ignored.
			Assert.DoesNotThrow(delegate { parser.Parse(); });

			Assert.AreEqual(enoughValues, parser.GetValues(Name1));

			Assert.AreNotEqual(excessValues, parser.GetValues(Name1));

			Assert.IsTrue(parser.IsParsed(Name1));
			Assert.IsTrue(parser.IsParsed(Name2));
		}
示例#8
0
		public void Parse()
		{
			const string Name1 = "arg1";
			const string Name2 = "arg2";

			string[] arguments = new string[]
			{
				Switch.GetPrefixedName(Name1),
				Switch.GetPrefixedName(Name2)
			};

			SwitchCollection switches = new SwitchCollection();

			switches.Add(Name1);
			switches.Add(Name2);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.IsFalse(parser.IsParsed(EmptyName));
			Assert.IsFalse(parser.IsParsed(Name1));
			Assert.IsFalse(parser.IsParsed(Name2));
			Assert.IsFalse(parser.IsParsed(NoName));
			Assert.IsFalse(m_emptyParser.IsParsed(EmptyName));
			Assert.IsFalse(m_emptyParser.IsParsed(Name1));
			Assert.IsFalse(m_emptyParser.IsParsed(Name2));
			Assert.IsFalse(m_emptyParser.IsParsed(NoName));

			parser.Parse();

			Assert.IsFalse(parser.IsParsed(EmptyName));
			Assert.IsFalse(parser.IsParsed(NoName));

			Assert.IsTrue(parser.IsParsed(Name1));
			Assert.IsTrue(parser.IsParsed(Name2));
		}
示例#9
0
		public void ParseNoSwitches()
		{
			const string ArgumentName1 = "arg1";
			const string ArgumentName2 = "arg2";
			const string Name1 = "name1";
			const string Name2 = "name2";

			string[] arguments = new string[]
			{
				ArgumentName1,
				ArgumentName2
			};

			SwitchCollection switches = new SwitchCollection();

			switches.Add(Name1);
			switches.Add(Name2);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.IsFalse(parser.IsParsed(ArgumentName1));
			Assert.IsFalse(parser.IsParsed(ArgumentName2));
			Assert.IsFalse(parser.IsParsed(Name1));
			Assert.IsFalse(parser.IsParsed(Name2));

			parser.Parse();

			Assert.IsFalse(parser.IsParsed(ArgumentName1));
			Assert.IsFalse(parser.IsParsed(ArgumentName2));
			Assert.IsFalse(parser.IsParsed(Name1));
			Assert.IsFalse(parser.IsParsed(Name2));
		}
示例#10
0
		public void NoneParsed()
		{
			const string Name1 = "arg1";
			const string Name2 = "arg2";
			const string Name3 = "arg3";
			const string Name4 = "arg4";
			const string Name5 = "arg5";

			string[] arguments = new string[]
			{
				Switch.GetPrefixedName(Name1),
				Switch.GetPrefixedName(Name2)
			};

			string[] switchNames1 = new string[] { Name1 };
			string[] switchNames2 = new string[] { Name1, Name2 };
			string[] switchNames3 = new string[] { Name1, Name2, Name3 };
			string[] switchNames4 = new string[] { Name2, Name3, Name4 };
			string[] switchNames5 = new string[] { Name4, Name5 };

			SwitchCollection switches = new SwitchCollection();

			switches.Add(switchNames2);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.IsTrue(parser.NoneParsed(switchNames1));
			Assert.IsTrue(parser.NoneParsed(switchNames2));
			Assert.IsTrue(parser.NoneParsed(switchNames3));
			Assert.IsTrue(parser.NoneParsed(switchNames4));
			Assert.IsTrue(parser.NoneParsed(switchNames5));
			Assert.IsTrue(m_emptyParser.NoneParsed(switchNames1));
			Assert.IsTrue(m_emptyParser.NoneParsed(switchNames2));
			Assert.IsTrue(m_emptyParser.NoneParsed(switchNames3));

			parser.Parse();

			Assert.IsFalse(parser.NoneParsed(switchNames1));
			Assert.IsFalse(parser.NoneParsed(switchNames2));
			Assert.IsFalse(parser.NoneParsed(switchNames3));
			Assert.IsFalse(parser.NoneParsed(switchNames4));
			
			Assert.IsTrue(parser.NoneParsed(switchNames5));
		}
示例#11
0
		public void GetValues()
		{
			const string Name1 = "name1";
			const string Name2 = "name2";
			const int NumberArguments = 2;
			const string Value1 = "value1";
			const string Value2 = "value2";
			const string Value3 = "value3";
			const string Value4 = "value4";

			string[] arguments = new string[]
			{
				Switch.GetPrefixedName(Name1),
				Value1, Value2,
				Switch.GetPrefixedName(Name2),
				Value3, Value4
			};

			SwitchCollection switches = new SwitchCollection();

			switches.Add(Name1, NoLongName, NoDescription, NumberArguments, IsRequired);
			switches.Add(Name2, NoLongName, NoDescription, NumberArguments, IsRequired);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.IsNull(parser.GetValues(EmptyName));
			Assert.IsNull(parser.GetValues(Name1));
			Assert.IsNull(parser.GetValues(Name2));
			Assert.IsNull(parser.GetValues(NoName));
			Assert.IsNull(m_emptyParser.GetValues(EmptyName));
			Assert.IsNull(m_emptyParser.GetValues(Name1));
			Assert.IsNull(m_emptyParser.GetValues(Name2));
			Assert.IsNull(m_emptyParser.GetValues(NoName));

			parser.Parse();

			Assert.AreEqual(new string[] { Value1, Value2 }, parser.GetValues(Name1));
			Assert.AreEqual(new string[] { Value3, Value4 }, parser.GetValues(Name2));

			Assert.IsNull(parser.GetValues(EmptyName));
			Assert.IsNull(parser.GetValues(NoName));
		}
示例#12
0
		public void GetValueWithInvalidArgumentNumber()
		{
			const int Argument0 = 0;
			const int Argument1 = 1;
			const int Argument2 = 2;
			const string ArgumentName = "arg1";
			const string Name = "name1";
			const string Value = "value1";

			string[] arguments = new string[]
			{
				Switch.GetPrefixedName(Name),
				Value
			};

			SwitchCollection switches = new SwitchCollection();

			switches.Add(Name, NoLongName, NoDescription, IsRequired, ArgumentName);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.IsNull(parser.GetValue(EmptyName, Argument0));
			Assert.IsNull(parser.GetValue(EmptyName, Argument1));
			Assert.IsNull(parser.GetValue(EmptyName, Argument2));
			Assert.IsNull(parser.GetValue(Name, Argument0));
			Assert.IsNull(parser.GetValue(Name, Argument1));
			Assert.IsNull(parser.GetValue(Name, Argument2));
			Assert.IsNull(parser.GetValue(NoName, Argument0));
			Assert.IsNull(parser.GetValue(NoName, Argument1));
			Assert.IsNull(parser.GetValue(NoName, Argument2));
			Assert.IsNull(m_emptyParser.GetValue(EmptyName, Argument0));
			Assert.IsNull(m_emptyParser.GetValue(EmptyName, Argument1));
			Assert.IsNull(m_emptyParser.GetValue(EmptyName, Argument2));
			Assert.IsNull(m_emptyParser.GetValue(NoName, Argument0));
			Assert.IsNull(m_emptyParser.GetValue(NoName, Argument1));
			Assert.IsNull(m_emptyParser.GetValue(NoName, Argument2));

			parser.Parse();

			Assert.AreEqual(Value, parser.GetValue(Name, Argument1));

			Assert.IsNull(parser.GetValue(EmptyName, Argument0));
			Assert.IsNull(parser.GetValue(EmptyName, Argument1));
			Assert.IsNull(parser.GetValue(EmptyName, Argument2));
			Assert.IsNull(parser.GetValue(Name, Argument0));
			Assert.IsNull(parser.GetValue(Name, Argument2));
			Assert.IsNull(parser.GetValue(NoName, Argument0));
			Assert.IsNull(parser.GetValue(NoName, Argument1));
			Assert.IsNull(parser.GetValue(NoName, Argument2));
		}
示例#13
0
		public void GetValue()
		{
			const string ArgumentName1 = "arg1";
			const string ArgumentName2 = "arg2";
			const string Name1 = "name1";
			const string Name2 = "name2";
			const string Value1 = "value1";
			const string Value2 = "value2";

			string[] arguments = new string[]
			{
				Switch.GetPrefixedName(Name1),
				Value1,
				Switch.GetPrefixedName(Name2),
				Value2
			};

			SwitchCollection switches = new SwitchCollection();

			switches.Add(Name1, NoLongName, NoDescription, IsRequired, ArgumentName1);
			switches.Add(Name2, NoLongName, NoDescription, IsRequired, ArgumentName2);

			ArgumentParser parser = new ArgumentParser(arguments, switches);

			Assert.IsNull(parser.GetValue(EmptyName));
			Assert.IsNull(parser.GetValue(Name1));
			Assert.IsNull(parser.GetValue(Name2));
			Assert.IsNull(parser.GetValue(NoName));
			Assert.IsNull(m_emptyParser.GetValue(EmptyName));
			Assert.IsNull(m_emptyParser.GetValue(NoName));

			parser.Parse();

			Assert.AreEqual(Value1, parser.GetValue(Name1));
			Assert.AreEqual(Value2, parser.GetValue(Name2));

			Assert.IsNull(parser.GetValue(EmptyName));
			Assert.IsNull(parser.GetValue(NoName));
		}
示例#14
0
		public void Initialize()
		{
			m_emptyParser = new ArgumentParser(new string[NoElements], new SwitchCollection());

			m_emptyParser.Parse();
		}