public void Get_MapContainsConversion_ReturnsConversion()
{
var expected = new Mock <IConversion <int, string> >().Object;
var underTest = new ConversionMap <int>();
underTest.Set(expected);
var actual = underTest.Get <string>().Value;
Assert.Equal(expected, actual);
}
public void Set_MapContainsConversion_Throws()
{
var underTest = new ConversionMap <int>();
underTest.Set(new Mock <IConversion <int, string> >().Object);
var ex = Assert.Throws <ArgumentException>(() =>
{
underTest.Set(new Mock <IConversion <int, string> >().Object);
});
Assert.Equal("conversion", ex.ParamName);
}
private static T BindImpl <T>(string moduleName, string methodName, MethodBase method, bool instanceFunction, BindCallFactory callFactory)
{
// TODO: clean up everything below this line
var arguments = GetArguments(method, instanceFunction).ToArray();
var errorPrefix = string.Format("{0}{1}{2}: ", moduleName ?? "", moduleName != null ? "." : "", methodName);
var parameters = new List <ParameterExpression>
{
Expression.Parameter(typeof(MondState), "state"),
Expression.Parameter(typeof(MondValue[]), "arguments")
};
if (instanceFunction)
{
parameters.Insert(1, Expression.Parameter(typeof(MondValue), "instance"));
}
var argumentsParam = parameters[instanceFunction ? 2 : 1];
Func <int, Expression> argumentIndex = i => Expression.ArrayIndex(argumentsParam, Expression.Constant(i));
var statements = new List <Expression>();
var returnLabel = Expression.Label(typeof(MondValue));
// argument count check
var argLength = Expression.Condition(Expression.Equal(argumentsParam, Expression.Constant(null)), Expression.Constant(0), Expression.PropertyOrField(argumentsParam, "Length"));
var requiredArgLength = arguments.Count(a => a.Index >= 0);
var argLengthError = string.Format("{0}must be called with {1} argument{2}", errorPrefix, requiredArgLength, requiredArgLength != 1 ? "s" : "");
statements.Add(Expression.IfThen(Expression.NotEqual(argLength, Expression.Constant(requiredArgLength)), Throw(argLengthError)));
// argument type checks
for (var i = 0; i < arguments.Length; i++)
{
var arg = arguments[i];
if (arg.Index < 0 || arg.Type == typeof(MondValue) || arg.Type == typeof(MondState))
{
continue;
}
statements.Add(TypeCheck(errorPrefix, i + 1, argumentIndex(arg.Index), arg.Type));
}
// call
var callArgs = new List <Expression>();
foreach (var arg in arguments)
{
if (arg.Type == typeof(MondState))
{
callArgs.Add(parameters[0]);
continue;
}
if (arg.Type == typeof(MondValue))
{
if (instanceFunction && arg.Name == "instance")
{
callArgs.Add(parameters[1]);
}
else
{
callArgs.Add(argumentIndex(arg.Index));
}
continue;
}
var input = argumentIndex(arg.Index);
Func <Expression, Expression> inputConversion;
if (ConversionMap.TryGetValue(arg.Type, out inputConversion))
{
input = inputConversion(input);
}
callArgs.Add(Expression.Convert(input, arg.Type));
}
statements.Add(callFactory(parameters, callArgs, returnLabel));
// end / default return
statements.Add(Expression.Label(returnLabel, Expression.Constant(MondValue.Undefined)));
var block = Expression.Block(statements);
return(Expression.Lambda <T>(block, parameters).Compile());
}
public void Get_MapDoesNotContainConversion_ReturnsNone()
{
var underTest = new ConversionMap <int>();
Assert.False(underTest.Get <string>().Exists);
}
