static void Main(string[] args)
{
var ddNode = new DDNode(DrCmdConst.TypeSettings, new DDType(DrCmdConst.TypeSettings));
ddNode.Attributes.Add(DrCmdSettings.ApplicationDescription, "It's test application.");
ddNode.Add(GetCommandHelp());
ddNode.Add(GetCommandRUN());
var cmd = new DrCmdParser(ddNode);
Console.Write(cmd.GetHelp(true));
Console.WriteLine();
do
{
Console.WriteLine("Specify arguments: ");
var line = Console.ReadLine();
ddNode.Attributes.Add(DrCmdSettings.Arguments, line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries), ResolveConflict.OVERWRITE);
SerialyzeToXml(ddNode);
} while (!ParseSample(cmd));
}
private static bool ParseSample(DrCmdParser cmd)
{
try
{
var res = cmd.Parse();
Console.WriteLine();
Console.Write(res.Name);
if (res.HasAttributes)
{
Console.Write(": ");
}
foreach (var a in res.Attributes)
{
Console.Write(a.Key + "='" + a.Value + "', ");
}
Console.WriteLine();
return(true);
}
catch (Exception e)
{
Console.WriteLine(GetExceptionAsString(e));
return(false);
}
}
static void Main(string[] args)
{
var ddNode = new DDNode(DrCmdConst.TypeSettings, DrCmdConst.TypeSettings);
ddNode.Attributes.Add("ApplicationDescription", "It's test application.");
ddNode.Add(GetCommandHelp());
ddNode.Add(GetCommandRUN());
var cmd = new DrCmdParser(ddNode);
Console.Write( cmd.GetHelp(true));
Console.WriteLine();
DDNode resDdNode ;
do
{
Console.WriteLine("Specify arguments: ");
var line = Console.ReadLine();
ddNode.Attributes.Add(DrCmdSettings.Arguments, line.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries), ResolveConflict.OVERWRITE);
SerialyzeToXml(ddNode);
} while (!ParseSample(cmd));
}
public void TestSplitOptionsAndTheirValuesByArgumentsCommnadNameOnlyValidCaseSensetive()
{
var args = "COMMAND";
var root = GetInitialParametrs(true, false, args);
var cmdParser = new DrCmdParser(root);
var result = cmdParser.Parse();
ValidateOptionParser(result, GetResultCOMMANDWithoutValue());
}
public void TestSplitOptionsAndTheirValuesByArgumentsCommnadNameOnlyIncorrectCaseSensetive()
{
var args = "CoMMAND";
var root = GetInitialParametrs(true, false, args);
var cmdParser = new DrCmdParser(root);
try
{
var result = cmdParser.Parse();
Assert.Fail("Case sensetive parameter doesnt' work correctly.");
}
catch (AssertFailedException e)
{
throw;
}
catch (ArgumentException argExc)
{
// it's true
}
}
public void TestSingleValue_SpecifiedMoreThanOne()
{
var args = new[] { "COMMAND", "-alias", "val1", "val2", "val3" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.Type, DrCmdOptionType.Required.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, DrCmdValueType.Single.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.Aliases, "alias", ResolveConflict.OVERWRITE);
var cmdParser = new DrCmdParser(root);
try
{
var result = cmdParser.Parse();
Assert.Fail("The incorrect arguments is not catched - 'Sigle value has more than one values'.");
}
catch (AssertFailedException e)
{ throw; }
catch (ArgumentException e)
{/* it's ok*/}
}
public void TestRestrictionList_ValueNumericIsSpecified()
{
var args = new[] { "COMMAND", "-t1", "123232", "777", "-test2", "-test3", "value for test 3" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, DrCmdValueType.Required.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, new[] { DrCmdValueType.Required.ToString(), DrCmdValueType.ListOfRestriction.ToString(), DrCmdValueType.AllowNumeric.ToString() }, ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.RestrictionList, Enum.GetNames(typeof(TestValue)), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.RestrictionListAsNumeric, TestValue.val1.GetFlags(), ResolveConflict.OVERWRITE);
var cmdParser = new DrCmdParser(root);
var result = cmdParser.Parse();
var expected = new DDNode("COMMAND");
expected.Attributes.Add("t1", new[] { "123232", "777" });
expected.Attributes.Add("test2", string.Empty);
expected.Attributes.Add("test3", new[] { "value for test 3" });
expected.Attributes.Add("test4", string.Empty);
ValidateOptionParser(result, expected);
}
public void TestRestrictionList_ValueNumericAndAllowNumericHaveDifferentElementCount()
{
var args = new[] { "COMMAND", "-t1", "1", "-test2", "-test3", "value for test 3" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, DrCmdValueType.Required.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, new[] { DrCmdValueType.AllowNumeric.ToString(), DrCmdValueType.ListOfRestriction.ToString() }, ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.RestrictionList, Enum.GetNames(typeof(TestValue)), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.RestrictionListAsNumeric, new int[] { 1, 2 }, ResolveConflict.OVERWRITE);
try
{
var cmdParser = new DrCmdParser(root);
Assert.Fail("The incorrect argument type is not catched - 'Number of items in lists RestrictionList and RestrictionListAsNumeric is different.'.");
}
catch (AssertFailedException e)
{ throw; }
catch (FormatException)
{/* it's ok*/}
}
public void TestGetSelectedCommandNameFromArgumentsCommnadNameIsNotSpecifiedException()
{
var root = GetInitialParametrs(string.Empty);
var cmdParser = new DrCmdParser(root);
try
{
var result = cmdParser.Parse();
Assert.Fail("The incorrect arguments is not catched 'Command name is not specified.'");
}
catch (AssertFailedException e)
{
throw;
}
catch (ArgumentException nullExc)
{
// it's ok
}
}
public void TestGetSelectedCommandNameFromArgumentsCommnadNameEmptyException()
{
var root = GetInitialParametrs("\"\"");
var cmdParser = new DrCmdParser(root);
root.Attributes.Add(DrCmdSettings.RemoveStartEndQuotas, true, ResolveConflict.OVERWRITE);
try
{
var result = cmdParser.Parse();
Assert.Fail("The incorrect arguments is not catched 'Command name is double quotas.'");
}
catch (AssertFailedException e)
{
throw;
}
catch (ArgumentException nullExc)
{
// it's ok
}
}
public void TestDisabledOption_SpecifyDisabledOption()
{
var args = new[] { "COMMAND", "-t1","-test2", "val1", "val2", "val3"};
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.Enabled, false, ResolveConflict.OVERWRITE);
try
{
var cmdParser = new DrCmdParser(root);
cmdParser.Parse();
Assert.Fail("The incorrect arguments is not catched - 'disabled option is specified'.");
}
catch (AssertFailedException e)
{ throw; }
catch (ArgumentException e)
{/* it's ok*/}
}
public void TestCheckSettingsUnknowArguments_UnknowArgument()
{
var args = new[] { "COMMAND", "-test2", "val1", "val2", "val3", "-UnknowArgument" };
var root = GetInitialParametrs(args);
try
{
var cmdParser = new DrCmdParser(root);
cmdParser.Parse();
Assert.Fail("The incorrect arguments is not catched - 'unknow agument is specified'.");
}
catch (AssertFailedException e)
{ throw; }
catch (ArgumentException e)
{/* it's ok*/}
}
public void TestCheckSettingsUnknowArguments_AllowUnknowArguments()
{
var args = new[] { "COMMAND", "-UnknowArgument", "-test2", "val1", "val2", "val3"};
var root = GetInitialParametrs(false, true, args);
var cmdParser = new DrCmdParser(root);
var result = cmdParser.Parse();
var expected = new DDNode("COMMAND");
expected.Attributes.Add("t1", string.Empty);
expected.Attributes.Add("test2", new[] { "val1", "val2", "val3" });
expected.Attributes.Add("test3", string.Empty);
expected.Attributes.Add("test4", string.Empty);
ValidateOptionParser(result, expected);
}
public void TestCheckIncongruousTypeOfValue_SingleVsList()
{
var args = new[] { "COMMAND", "-t1", "-test2", "val1", "val2", "val3" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, new[] { DrCmdValueType.Single.ToString(), DrCmdValueType.List.ToString() }, ResolveConflict.OVERWRITE);
try
{
var cmdParser = new DrCmdParser(root);
Assert.Fail("The incorrect arguments is not catched - 'Incongruous types of value for option are specified: Single and List'.");
}
catch (AssertFailedException e)
{ throw; }
catch (FormatException e)
{/* it's ok*/}
}
public void TestCheckDisableCommand_CommandIsDisabled()
{
var args = new[] { "COMMAND", "-t1", "-test2", "val1", "val2", "val3", "-t1" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND").Attributes.Replace(DrCmdCommandSettings.Enabled, false);
try
{
var cmdParser = new DrCmdParser(root);
cmdParser.Parse();
Assert.Fail("The incorrect arguments is not catched - 'command is вшыфидув'.");
}
catch (AssertFailedException e)
{ throw; }
catch (ArgumentException e)
{/* it's ok*/}
}
public void TestVerifyValueRestrictionsType_ForbiddenValueTypeWithAnotherType()
{
var args = new[] { "COMMAND", "-test2", "val1", "val2", "val3" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.Type, DrCmdOptionType.Required.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, new[] { DrCmdValueType.Forbidden.ToString(), DrCmdValueType.Optional.ToString() }, ResolveConflict.OVERWRITE);
try
{
var cmdParser = new DrCmdParser(root);
Assert.Fail("The incorrect arguments is not catched - 'Forbidden value type is specified with another type'.");
}
catch (AssertFailedException e)
{ throw; }
catch (FormatException e)
{/* it's ok*/}
}
public void TestRestrictionList_ValueIsSpecifiedCaseSensitive()
{
var args = new[] { "COMMAND", "-t1", "Val1", "vAl2", "val3", "-test2", "-test3", "value for test 3" };
var root = GetInitialParametrs(true, false, args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, DrCmdValueType.Required.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, new[] { DrCmdValueType.Required.ToString(), DrCmdValueType.ListOfRestriction.ToString(), DrCmdValueType.AllowNumeric.ToString() }, ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.RestrictionList, Enum.GetNames(typeof(TestValue)), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.RestrictionListAsNumeric, TestValue.val1.GetFlags(), ResolveConflict.OVERWRITE);
try
{
var cmdParser = new DrCmdParser(root);
var result = cmdParser.Parse();
Assert.Fail("The incorrect argument type is not catched - 'RestrictionList, specified value is incorrected because case sensitive is enabled'.");
}
catch (AssertFailedException e)
{ throw; }
catch (ArgumentException)
{/* it's ok*/}
}
public void TestGetSettingsArgumentsSupportSpaceInValue()
{
var args = new[] { "\"CoMMAND\"", "-t1", "-test2", "-test3", "\"val1 val2 val3\"", "-test4" };
var root = GetInitialParametrs(args);
root.Attributes.Add(DrCmdSettings.RemoveStartEndQuotas, true, ResolveConflict.OVERWRITE);
var cmdParser = new DrCmdParser(root);
var result = cmdParser.Parse();
var expected = new DDNode("COMMAND");
expected.Attributes.Add("t1", string.Empty);
expected.Attributes.Add("test2", string.Empty);
expected.Attributes.Add("test3", new[] { "val1 val2 val3" });
expected.Attributes.Add("test4", string.Empty);
ValidateOptionParser(result, expected);
}
public void TestRestrictionList_ValueNumericIsNotAllow()
{
var args = new[] { "COMMAND", "-t1", "1", "-test2", "-test3", "value for test 3" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, DrCmdValueType.Required.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, new[] { DrCmdValueType.Required.ToString(), DrCmdValueType.ListOfRestriction.ToString() }, ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.RestrictionList, Enum.GetNames(typeof(TestValue)), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.RestrictionListAsNumeric, TestValue.val1.GetFlags(), ResolveConflict.OVERWRITE);
try
{
var cmdParser = new DrCmdParser(root);
var result = cmdParser.Parse();
Assert.Fail("The incorrect argument type is not catched - 'RestrictionList, specified value is number but number is not allowed in the ValueType for this option'.");
}
catch (AssertFailedException e)
{ throw; }
catch (ArgumentException)
{/* it's ok*/}
}
public void TestGetValueType()
{
var args = new[] { "COMMAND", "-t1", "val1", "val2", "val3" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, new[] { DrCmdValueType.Required.ToString(), "Incorrect" }, ResolveConflict.OVERWRITE);
try
{
var cmdParser = new DrCmdParser(root);
Assert.Fail("The incorrect option type is not catched.");
}
catch (AssertFailedException e)
{
throw;
}
catch (Exception)
{
// it's ok
}
}
public void TestSingleValue_IsNotSpecified()
{
var args = new[] { "COMMAND", "-t1", "-test2", "val1", "val2", "val3", "-test3", "value for test 3" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, DrCmdValueType.Single.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/test3").Attributes.Add(DrCmdOptionSettings.ValueType, DrCmdValueType.Single.ToString(), ResolveConflict.OVERWRITE);
var cmdParser = new DrCmdParser(root);
var result = cmdParser.Parse();
var expected = new DDNode("COMMAND");
expected.Attributes.Add("t1", string.Empty);
expected.Attributes.Add("test2", new[] { "val1", "val2", "val3" });
expected.Attributes.Add("test3", new[] { "value for test 3" });
expected.Attributes.Add("test4", string.Empty);
ValidateOptionParser(result, expected);
}
public void TestGetValueTypeCaseInsensitive()
{
var args = "RuN -LogFile val1".Split(new[] { ' ' });
var root = GetInitialParametrs(args);
root.GetNode("RUN/LogFile").Attributes.Add(DrCmdOptionSettings.ValueType, new[] { DrCmdValueType.Required.ToString().ToUpper(), DrCmdValueType.Required.ToString().ToLower() }, ResolveConflict.OVERWRITE);
var cmdParser = new DrCmdParser(root);
var result = cmdParser.Parse();
var expected = new DDNode("RUN");
expected.Attributes.Add("LogFile", new[] { "val1" });
expected.Attributes.Add("m", String.Empty);
ValidateOptionParser(result, expected);
}
public void TestSplitOptionsAndTheirValuesByArgumentsCheckThrowValueWithoutOption()
{
var args = "CoMMAND test".Split(new[] { ' ' });
var root = GetInitialParametrs(args);
var cmdParser = new DrCmdParser(root);
try
{
var result = cmdParser.Parse();
Assert.Fail("Contains the value of the option without declaring itself options.");
}
catch (AssertFailedException e)
{
throw;
}
catch (ArgumentException argExc)
{
// it's true
}
}
public void TestOptionIsSpecifiedMoreThanOnce_SpecifyOptionTwise()
{
var args = new[] { "COMMAND", "-t1", "-test2", "val1", "val2", "val3" , "-t1"};
var root = GetInitialParametrs(args);
try
{
var cmdParser = new DrCmdParser(root);
cmdParser.Parse();
Assert.Fail("The incorrect arguments is not catched - 'option is specified twise'.");
}
catch (AssertFailedException e)
{ throw; }
catch (ArgumentException e)
{/* it's ok*/}
}
public void TestSplitOptionsAndTheirValuesByArgumentsCommnadNameOnlyIncorrectIgnoreCase()
{
var args = "c0mmand";
var root = GetInitialParametrs(args);
var cmdParser = new DrCmdParser(root);
try
{
var result = cmdParser.Parse();
Assert.Fail("The incorrect arguments is not catched 'Command name is incorrect.'");
}
catch (AssertFailedException e)
{
throw;
}
catch (ArgumentException argExc)
{
// it's true
}
}
public void TestOptionIsSpecifiedMoreThanOnce_SpecifyOptionTwiseByAlias()
{
var args = new[] { "COMMAND", "-t1", "-test2", "val1", "val2", "val3", "-Test1Alias" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.Aliases, new[] { "Test1Alias" }, ResolveConflict.OVERWRITE);
try
{
var cmdParser = new DrCmdParser(root);
cmdParser.Parse();
Assert.Fail("The incorrect arguments is not catched - 'option is specified twise'.");
}
catch (AssertFailedException e)
{ throw; }
catch (ArgumentException e)
{/* it's ok*/}
}
public void TestSplitOptionsAndTheirValuesByArgumentsCommnadNameOnlyValidIgnoreCase()
{
var args = "command";
var root = GetInitialParametrs(args);
var cmdParser = new DrCmdParser(root);
var result = cmdParser.Parse();
ValidateOptionParser(result, GetResultCOMMANDWithoutValue());
}
public void TestRequiredOption_SpecifiedByAlias()
{
var args = new[] { "COMMAND", "-alias", "val1", "val2", "val3" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.Type, DrCmdOptionType.Required.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.Aliases, "alias", ResolveConflict.OVERWRITE);
var cmdParser = new DrCmdParser(root);
var result = cmdParser.Parse();
var expected = new DDNode("COMMAND");
expected.Attributes.Add("t1", new[] { "val1", "val2", "val3" });
expected.Attributes.Add("test2", string.Empty);
expected.Attributes.Add("test3", string.Empty);
expected.Attributes.Add("test4", string.Empty);
ValidateOptionParser(result, expected);
}
public void TestRequiredValue_IsNotSpecified()
{
var args = new[] { "COMMAND", "-alias" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.Type, DrCmdOptionType.Required.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, DrCmdValueType.Required.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.Aliases, "alias", ResolveConflict.OVERWRITE);
var cmdParser = new DrCmdParser(root);
try
{
var result = cmdParser.Parse();
Assert.Fail("The incorrect arguments is not catched - 'Required value without value'.");
}
catch (AssertFailedException e)
{ throw; }
catch (ArgumentException e)
{/* it's ok*/}
}
public void TestRestrictionList_AsNumericIncorrectType()
{
var args = new[] { "COMMAND", "-t1", "Val1", "vAl2", "val3", "-test2", "-test3", "value for test 3" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, DrCmdValueType.Required.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, new[] { DrCmdValueType.Required.ToString(), DrCmdValueType.ListOfRestriction.ToString(), DrCmdValueType.AllowNumeric.ToString() }, ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.RestrictionList, Enum.GetNames(typeof(TestValue)), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.RestrictionListAsNumeric, new byte[] { 0x1, 0x2, 0x3 }, ResolveConflict.OVERWRITE);
try
{
var cmdParser = new DrCmdParser(root);
Assert.Fail("The incorrect argument type is not catched - 'RestrictionListAsNumeric type is byte[]'.");
}
catch (AssertFailedException e)
{ throw; }
catch (FormatException)
{/* it's ok*/}
}
private static bool ParseSample(DrCmdParser cmd)
{
try
{
var res =cmd.Parse();
Console.WriteLine();
Console.Write(res.Name );
if (res.HasAttributes) Console.Write(": ");
foreach (var a in res.Attributes)
{
Console.Write(a.Key + "='" + a.Value + "', ");
}
Console.WriteLine();
return true;
}
catch (Exception e)
{
Console.WriteLine( GetExceptionAsString(e));
return false;
}
}
public void TestVerifyValueRestrictionsType_ForbiddenValueType()
{
var args = new[] { "COMMAND", "-t1", "-test2", "val1", "val2", "val3" };
var root = GetInitialParametrs(args);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.Type, DrCmdOptionType.Required.ToString(), ResolveConflict.OVERWRITE);
root.GetNode("COMMAND/t1").Attributes.Add(DrCmdOptionSettings.ValueType, new[] { DrCmdValueType.Forbidden.ToString() }, ResolveConflict.OVERWRITE);
var cmdParser = new DrCmdParser(root);
var result = cmdParser.Parse();
var expected = new DDNode("COMMAND");
expected.Attributes.Add("test2", new[] { "val1", "val2", "val3" });
expected.Attributes.Add("t1", string.Empty);
expected.Attributes.Add("test3", string.Empty);
expected.Attributes.Add("test4", string.Empty);
ValidateOptionParser(result, expected);
}
