public void TestBasicParsing()
{
ArgumentsBasicTarget target = new ArgumentsBasicTarget();
CommandLineParser parser = new CommandLineParser(typeof(ArgumentsBasic), null, CommandLineParserFlags.Default);
string[] args = new string[]
{
"-arg1:valueForArg1",
"-a2:One",
"-arg2:Two",
"-arg3:Alpha",
"-arg3:Beta",
"-arg4+",
"-arg5:10",
"-arg7:a=1;b=2",
"-arg8:blah.txt",
"-arg9:blah.txt",
"something.txt"
};
parser.ParseAndSetTarget(args, target);
Assert.AreEqual(target.Arg1, "valueForArg1");
CollectionAssert.AreEqual(new string[] { "One", "Two" }, target.Arg2);
CollectionAssert.AreEqual(new string[] { "Alpha", "Beta" }, target.Arg3);
Assert.AreEqual(true, target.Arg4);
Assert.AreEqual(10, target.Arg5);
Assert.AreEqual(false, target.Arg6);
CollectionAssert.AreEquivalent(new KeyValuePair<string, string>[]
{ new KeyValuePair<string, string>("a", "1"), new KeyValuePair<string, string>("b", "2") }, target.Arg7.Parameters);
Assert.AreEqual("blah.txt", target.Arg8.ToString());
Assert.AreEqual("blah.txt", target.Arg9.ToString());
Assert.AreEqual(11, parser.ArgumentCount);
Assert.AreEqual(" -arg1:valueForArg1 -arg2:One -arg2:Two -arg3:Alpha -arg3:Beta -arg4 -arg5:10 -arg7:a=1;b=2 -arg8:blah.txt -arg9:blah.txt something.txt", parser.Arguments);
}
public void TestBadCommandArgument()
{
string[] args = { "start", "-arg1" };
CommandLineParser parser = new CommandLineParser(typeof(ArgumentsWithCommand));
parser.Parse(args);
}
public void TestBadCommand()
{
ArgumentsWithCommand target = new ArgumentsWithCommand();
CommandLineParser parser = new CommandLineParser(target.GetType());
string[] args = { "unknown" };
parser.Parse(args);
}
public void TestUsage()
{
CommandLineParser parser = new CommandLineParser(typeof(ArgumentsBasic), CommandLineParserFlags.Default);
string usage = parser.Usage;
Assert.IsTrue(Regex.IsMatch(usage,
@"Syntax:\s*.+? \[switches\] <default>\r\n\r\nDescription:\s*.*\r\n\r\nSwitches:\r\n\r\n(^(/\w+)|(\s+).*\r\n)+(.*\r\n)+",
RegexOptions.Multiline | RegexOptions.ExplicitCapture));
parser.CommandName = "AnythingYouWant";
Assert.AreEqual(parser.CommandName, "AnythingYouWant");
// Test multiple default arguments
parser = new CommandLineParser(typeof(ArgumentsMultiDefaultNoArgs), null, CommandLineParserFlags.Default);
Assert.IsTrue(Regex.IsMatch(parser.Usage,
@"Syntax:\s*.+? <file> \[<file> \.\.\.\]",
RegexOptions.Multiline | RegexOptions.ExplicitCapture));
// Test command based command line
parser = new CommandLineParser(typeof(ArgumentsWithCommand));
// Capture the value or it's really hard to debug...
usage = parser.GetUsage(null, 79);
Debug.WriteLine(usage);
Assert.IsTrue(Regex.IsMatch(usage,
@"Syntax:\s*.+? <command> \.\.\.\r\n\r\nDescription:\s*.+\r\n\r\nCommands:\r\n\r\n((^ \w+\s+\S+\r\n)|(^\s+.+\r\n))+(^\s+.+)",
RegexOptions.Multiline | RegexOptions.ExplicitCapture));
// Get usage for individual command
usage = parser.GetUsage("start", 79);
Debug.WriteLine(usage);
Assert.IsTrue(Regex.IsMatch(usage,
@"Syntax:\s*.+? start \[switches\] <default>\r\n\r\nDescription:\s*.+\r\n(^\s+.+\r\n)+\r\nSwitches:\r\n\r\n((^ \w+\s+\S+\r\n)|(^\s+.+\r\n))+(^\s+.+)",
RegexOptions.Multiline | RegexOptions.ExplicitCapture));
ArgumentsWithCommand target = new ArgumentsWithCommand();
string[] args = { "help", "unknown" };
parser.ParseAndSetTarget(args, target);
Assert.AreEqual("help", target.Command);
Assert.AreEqual("unknown", target.Default);
try
{
parser.GetUsage(target.Default);
}
catch (Exception e)
{
Assert.IsInstanceOf(typeof(CommandLineArgumentException), e);
}
}
public void TestUnprocessedArgs()
{
ArgumentsUnprocessedPart target = new ArgumentsUnprocessedPart();
CommandLineParser parser = new CommandLineParser(
typeof(ArgumentsUnprocessedPart));
string[] args = new string[]
{
"/arg:blah", "thing", "gomez", "/morestuff"
};
parser.ParseAndSetTarget(args, target);
Assert.AreEqual("blah", target.Arg);
Assert.AreEqual("thing", target.Default);
CollectionAssert.AreEqual(new string[] { "gomez", "/morestuff" }, target.Unprocessed);
}
public void TestParsingFromResources()
{
ArgumentsFromResources target = new ArgumentsFromResources();
CommandLineParser parser = new CommandLineParser(
typeof(ArgumentsFromResources), typeof(CommandLineParserTestsResources));
string[] args = new string[] { "-a:file.txt" };
parser.ParseAndSetTarget(args, target);
Assert.AreEqual("file.txt", target.File);
Assert.IsTrue(Regex.IsMatch(parser.Usage,
@"Syntax:\s+.+? \[switches\]\r\n\r\nSwitches:\r\n\r\n(^ -\w+.*)",
RegexOptions.Multiline | RegexOptions.ExplicitCapture));
}
public void TestMultiDefaultArgs()
{
ArgumentsMultiDefaultNoArgs target = new ArgumentsMultiDefaultNoArgs();
CommandLineParser parser = new CommandLineParser(typeof(ArgumentsMultiDefaultNoArgs), null, CommandLineParserFlags.Default);
string[] args = new string[] { "one", "two"};
parser.ParseAndSetTarget(args, target);
CollectionAssert.AreEqual(new string[] { "one", "two" }, target.Default);
}
public void TestLogoBanner()
{
Regex regex = new Regex(
@"^Command Line Program\. (Debug|Release) Version \d+\.\d+\.\d+\.\d+\r\nCopyright \(c\) John Lyon-Smith\.\r\n",
RegexOptions.Multiline | RegexOptions.ExplicitCapture);
CommandLineParser parser = new CommandLineParser(typeof(ArgumentsBasic), null, CommandLineParserFlags.Default);
string logoBanner = parser.LogoBanner;
Assert.IsTrue(regex.IsMatch(logoBanner));
parser.Copyright = "Copyright (c) Another Corporation";
parser.Title = "Another Command Line Program";
parser.Configuration = "Release";
parser.Version = "2.0.0.0";
logoBanner = parser.LogoBanner;
regex = new Regex(
@"^.+?\. Release Version \d+\.\d+\.\d+\.\d+\r\nCopyright \(c\) .+?\.\r\n",
RegexOptions.Multiline | RegexOptions.ExplicitCapture);
Assert.IsTrue(regex.IsMatch(logoBanner));
// A parser with no attributes to get the code coverage
parser = new CommandLineParser(typeof(ArgumentsForLogoBanner));
logoBanner = parser.LogoBanner;
regex = new Regex(
@"^.+?\. (Debug|Release) Version \d+\.\d+\.\d+\.\d+\r\nCopyright \(c\) .+?\.\r\n",
RegexOptions.Multiline | RegexOptions.ExplicitCapture);
Assert.IsTrue(regex.IsMatch(logoBanner));
}
public void TestGetTarget()
{
ArgumentsBasicTarget target = new ArgumentsBasicTarget();
CommandLineParser parser = new CommandLineParser(typeof(ArgumentsBasic), null, CommandLineParserFlags.Default);
target.Arg1 = "valueForArg1";
target.Arg2 = new string[] { "One", "Two" };
List<string> arg3 = new List<string>();
arg3.Add("Alpha");
arg3.Add("Beta");
target.Arg3 = arg3;
target.Arg4 = true;
target.Arg5 = 10;
target.Arg6 = false;
CustomType arg7 = new CustomType();
arg7.Parameters.Add("a", "1");
arg7.Parameters.Add("b", "2");
target.Arg7 = arg7;
target.Arg8 = new FileInfo("blah.txt");
target.Arg9 = new ParsedPath("blah.txt", PathType.File);
target.Default = "something.txt";
parser.GetTargetArguments(target);
// NOTE: Not setting arguments #10 and #11
Assert.AreEqual(13, parser.ArgumentCount);
Assert.AreEqual(" -arg1:valueForArg1 -arg2:One -arg2:Two -arg3:Alpha -arg3:Beta -arg4 -arg5:10 -arg7:a=1;b=2 -arg8:blah.txt -arg9:blah.txt -arg11:0 something.txt", parser.Arguments);
}
public void TestCommands()
{
ArgumentsWithCommand target = new ArgumentsWithCommand();
CommandLineParser parser = new CommandLineParser(typeof(ArgumentsWithCommand));
string[] args1 = new string[]
{
"start",
"default",
"/arg2:blah"
};
parser.ParseAndSetTarget(args1, target);
Assert.AreEqual("start", target.Command);
Assert.AreEqual("default", target.Default);
CollectionAssert.AreEquivalent(new string[] {"blah"}, target.Arg2);
}
public void TestCaseSensitiveParsing()
{
ArgumentsCaseSensitive target = new ArgumentsCaseSensitive();
CommandLineParser parser = new CommandLineParser(typeof(ArgumentsCaseSensitive), null, CommandLineParserFlags.CaseSensitive);
string[] args = new string[]
{
"/Tp:valueForArg1",
"/TP:valueForArg2",
};
parser.ParseAndSetTarget(args, target);
Assert.AreEqual(target.Arg1, "valueForArg1");
Assert.AreEqual(target.Arg2, "valueForArg2");
}
bool IProcessCommandLine.ProcessCommandLine(string[] args)
{
runningFromCommandLine = true;
CommandLineParser parser = new CommandLineParser(typeof(CsrTool), typeof(CsrResources));
try
{
parser.ParseAndSetTarget(args, this);
}
catch (CommandLineArgumentException e)
{
Output.Error(e.Message);
return false;
}
return true;
}
public void TestNullable()
{
ArgumentsBasicTarget target = new ArgumentsBasicTarget();
CommandLineParser parser = new CommandLineParser(typeof(ArgumentsBasic), null, CommandLineParserFlags.Default);
string[] args = new string[]
{
"-arg12:10"
};
parser.ParseAndSetTarget(args, target);
Assert.AreEqual(10, target.Arg12);
}
