public static IEnumerable <ActionMap> GetActionsMapsFromTargetObject(object target, bool onlyWithAttribute = false, bool usePrefixInAllMethods = false, string prefix = null)
{
var argumentMapper = new ArgumentMapper();
var actionMapper = new ActionMapper(argumentMapper);
return(actionMapper.Map(target, onlyWithAttribute, usePrefixInAllMethods, prefix));
}
public void NotUsedRequiredArgumentErrorTest()
{
var commandTestClass = new ArgumentTestClass();
var dictionary = new Dictionary <string, string>();
var argumentMapper = new ArgumentMapper <ArgumentTestClass>();
argumentMapper.Invoking(x => x.Map(commandTestClass, dictionary)).ShouldThrow <MissingCommandLineArgumentException>();
}
public void NoCommandUsageErrorTest()
{
var commandTestClass = new CommandTestClass();
var dictionary = new Dictionary <string, string>();
var argumentMapper = new ArgumentMapper <CommandTestClass>();
argumentMapper.Invoking(x => x.Map(commandTestClass, dictionary)).ShouldThrow <CommandLineArgumentException>().WithMessage(
"The command 'Backup|Init|Restore' must be used.");
}
public void TestTableViewForListObject()
{
var mapper = new ArgumentMapper();
var maps = mapper.Map(new CommandTableView());
var table = TableView.ToTableView <ArgumentMap>(maps);
table.Build();
this.Compare(table.ToString(), TestHelper.GetCurrentMethodName());
}
/// <summary>
/// Constructs a new generic backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="backendType">The backend type.</param>
/// <param name="backendFlags">The backend flags.</param>
/// <param name="argumentMapper">The argument mapper to use.</param>
protected Backend(
Context context,
BackendType backendType,
BackendFlags backendFlags,
ArgumentMapper argumentMapper)
: base(context, backendType, backendFlags, argumentMapper)
{
IntrinsicProvider = context.IntrinsicManager.CreateProvider <TDelegate>(this);
}
public void ShouldThrowFormatExceptionOnArgumentTypeMismatch()
{
var args = new[]
{
"--key3=3.14" //Decimal value won't map to Integer property
};
var target = ArgumentMapper.Map<TestTarget>(args);
}
public void ShouldThrowArgumentExceptionWhenEnumValueIsInvalid()
{
var args = new[]
{
"--key6=Foo"
};
var target = ArgumentMapper.Map<TestTarget>(args);
}
public void ShouldSetDefaultWhenArgumentsNotProvided()
{
var args1 = new[] {"--key2=value2"};
var target1 = ArgumentMapper.Map<TestTarget>(args1);
Assert.AreEqual("Foo", target1.Key1);
var args2 = new[] { "--key1=value1" };
var target2 = ArgumentMapper.Map<TestTarget>(args2);
Assert.AreEqual("Bar", target2.Key2);
}
public void SingleCommandUsageTest()
{
var commandTestClass = new CommandTestClass();
var dictionary = new Dictionary <string, string> {
{ "Backup", "true" }
};
var argumentMapper = new ArgumentMapper <CommandTestClass>();
var result = argumentMapper.Map(commandTestClass, dictionary);
Assert.AreEqual(result.TheCommand, TestCommandType.Backup);
}
public void MultipleSameCommandUsageErrorTest()
{
var commandTestClass = new CommandTestClass();
var dictionary = new Dictionary <string, string> {
{ "Backup", "true" }, { "B", "true" }
};
var argumentMapper = new ArgumentMapper <CommandTestClass>();
argumentMapper.Invoking(x => x.Map(commandTestClass, dictionary)).ShouldThrow <CommandLineArgumentException>().WithMessage(
"Multiple aruments for 'Backup'-command is not allowed.");
}
/// <summary>
/// Constructs a new IL backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="warpSize">The current warp size.</param>
/// <param name="argumentMapper">The argument mapper.</param>
internal ILBackend(
Context context,
int warpSize,
ArgumentMapper argumentMapper)
: base(
context,
new ILABI(context.TypeContext, RuntimePlatform),
argumentMapper)
{
WarpSize = warpSize;
}
public void IntArgumentTest()
{
var unmapTestImnstance = new UnmapTestClass {
IntArgument = 1234
};
var argumentMapper = new ArgumentMapper <UnmapTestClass>();
var unMap = argumentMapper.UnMap(unmapTestImnstance);
Assert.AreEqual(@"IntArgument=""1234""", unMap);
}
public void CommandTest()
{
var unmapTestImnstance = new UnmapTestClass {
TheCommand = TestCommandType.Restore
};
var argumentMapper = new ArgumentMapper <UnmapTestClass>();
var unMap = argumentMapper.UnMap(unmapTestImnstance);
Assert.AreEqual(@"-Restore", unMap);
}
public void ShouldMapArgumentsToEnumProperties()
{
var args = new[]
{
"--key6=Enum3"
};
var target = ArgumentMapper.Map<TestTarget>(args);
Assert.AreEqual(TestArgumentEnum.Enum3, target.Key6);
}
public void NamedArgumentTest()
{
var unmapTestImnstance = new UnmapTestClass {
NamedArgument = "dödl"
};
var argumentMapper = new ArgumentMapper <UnmapTestClass>();
var unMap = argumentMapper.UnMap(unmapTestImnstance);
Assert.AreEqual(@"MyArg=""dödl""", unMap);
}
public void ShouldMapArgumentsToDateTimeProperties()
{
var args = new[]
{
"--key7=7/4/1776"
};
var target = ArgumentMapper.Map<TestTarget>(args);
Assert.AreEqual(new DateTime(1776, 07, 4), target.Key7);
}
public void ShouldMapArgumentsToDecimalProperties()
{
var args = new[]
{
"--key5=3.14"
};
var target = ArgumentMapper.Map<TestTarget>(args);
Assert.AreEqual(3.14M, target.Key5);
}
public void ShouldMapArgumentsToIntegerProperties()
{
var args = new[]
{
"--key3=99"
};
var target = ArgumentMapper.Map<TestTarget>(args);
Assert.AreEqual(99, target.Key3);
}
public void ShouldMapArgumentsToBooleanProperties()
{
var args = new[]
{
"--key8=True"
};
var target = ArgumentMapper.Map<TestTarget>(args);
Assert.IsTrue(target.Key8);
}
public void NoOptionTest()
{
var unmapTestImnstance = new UnmapTestClass {
SimpleOption = false
};
var argumentMapper = new ArgumentMapper <UnmapTestClass>();
var unMap = argumentMapper.UnMap(unmapTestImnstance);
Assert.AreEqual(@"", unMap);
}
public void NullTest()
{
var unmapTestImnstance = new UnmapTestClass()
{
NamedArgument = null, SimpleOption = false, TheCommand = TestCommandType.None, SimpleArgument = null
};
var argumentMapper = new ArgumentMapper <UnmapTestClass>();
var unMap = argumentMapper.UnMap(unmapTestImnstance);
Assert.AreEqual("", unMap);
}
public void ArgumentTest()
{
var unmapTestImnstance = new UnmapTestClass()
{
SimpleArgument = "TEstArg"
};
var argumentMapper = new ArgumentMapper <UnmapTestClass>();
var unMap = argumentMapper.UnMap(unmapTestImnstance);
Assert.AreEqual(@"SimpleArgument=""TEstArg""", unMap);
}
/// <summary>
/// Constructs a new generic backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="backendType">The backend type.</param>
/// <param name="backendFlags">The backend flags.</param>
/// <param name="argumentMapper">The argument mapper to use.</param>
protected CodeGeneratorBackend(
Context context,
BackendType backendType,
BackendFlags backendFlags,
ArgumentMapper argumentMapper)
: base(
context,
backendType,
backendFlags,
argumentMapper)
{
}
public void TrimmedArgumentTest()
{
var commandTestClass = new ArgumentTestClass();
var dictionary = new Dictionary <string, string> {
{ "TrimmedArgument", "\"UntrimmedValue\"" }, { "RequiredArgument", "RequiredArgumentValue" }
};
var argumentMapper = new ArgumentMapper <ArgumentTestClass>();
var result = argumentMapper.Map(commandTestClass, dictionary);
Assert.AreEqual(result.TrimmedArgument, "UntrimmedValue");
}
public void FullArgumentsTest()
{
var unmapTestImnstance = new UnmapTestClass()
{
TheCommand = TestCommandType.Backup, SimpleArgument = "TheArgument", SimpleOption = true
};
var argumentMapper = new ArgumentMapper <UnmapTestClass>();
var unMap = argumentMapper.UnMap(unmapTestImnstance);
Assert.AreEqual(@"-Backup SimpleArgument=""TheArgument"" -so", unMap);
}
public void LargeNumberTest()
{
var unmapTestImnstance = new UnmapTestClass()
{
LargeNumber = long.MaxValue
};
var argumentMapper = new ArgumentMapper <UnmapTestClass>();
var unMap = argumentMapper.UnMap(unmapTestImnstance);
Assert.AreEqual(string.Format("LargeNumber=\"{0}\"", long.MaxValue), unMap);
}
public void NamedArgumentAliasTest()
{
var commandTestClass = new ArgumentTestClass();
var dictionary = new Dictionary <string, string> {
{ "AliasName1", "TheNameValue" }, { "RequiredArgument", "RequiredArgumentValue" }
};
var argumentMapper = new ArgumentMapper <ArgumentTestClass>();
var result = argumentMapper.Map(commandTestClass, dictionary);
Assert.AreEqual(result.NamedArgument, "TheNameValue");
}
/// <summary>
/// Constructs a new generic backend.
/// </summary>
/// <param name="context">The context to use.</param>
/// <param name="capabilities">The supported capabilities.</param>
/// <param name="backendType">The backend type.</param>
/// <param name="argumentMapper">The argument mapper to use.</param>
protected CodeGeneratorBackend(
Context context,
CapabilityContext capabilities,
BackendType backendType,
ArgumentMapper argumentMapper)
: base(
context,
capabilities,
backendType,
argumentMapper)
{
}
public void CaseSensitiveArgumentTest()
{
var target = new ArgumentMapper <Arguments>();
var dictionary = new Dictionary <string, string>(StringComparer.InvariantCulture)
{
{ "first", "45" }
};
var result = target.Map(dictionary);
result.First.Should().NotBe(45);
dictionary.Count.Should().Be(1);
}
public void ShouldMapArgumentsToStringProperties()
{
var args = new []
{
"--key1=value1",
"--key2=value2"
};
var target = ArgumentMapper.Map<TestTarget>(args);
Assert.AreEqual("value1", target.Key1);
Assert.AreEqual("value2", target.Key2);
}