public void Build_two_actions_and_predicate_for_different_types() { string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Action <string> action1 = s => { updatedValue = s; }; Predicate <string> predicate1 = s => s.Length > 5 && s.Length < 15; var handler1 = PredicateAndHandler.CreateAction(action1, predicate: predicate1); stringHandler.Handlers.Add(handler1); typeHandlers.Add(stringHandler); var intHandler = new TypeHandler(typeof(int)); //Handle an int with one action Action <int> action2 = i => { updatedValue = i.ToString(); }; Predicate <int> predicate2 = i => i < 10; var handler2 = PredicateAndHandler.CreateAction(action2, predicate: predicate2); intHandler.Handlers.Add(handler2); typeHandlers.Add(intHandler); //Build the expression var builder = new MatchExpressionBuilder <object>(); var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(4, result.Arguments.Length, "Should contain the action and predicate delegates"); Assert.Same(action1, result.Arguments[0]); Assert.Same(predicate1, result.Arguments[1]); Assert.Same(action2, result.Arguments[2]); Assert.Same(predicate2, result.Arguments[3]); //Compile the expression and test it var lambda = (Func <object, Action <String>, Predicate <string>, Action <int>, Predicate <int>, bool>)result.LambdaExpression.Compile(); lambda("short", action1, predicate1, action2, predicate2); Assert.Null(updatedValue); lambda("longer value", action1, predicate1, action2, predicate2); Assert.Equal("longer value", updatedValue); lambda("12345678901234567890", action1, predicate1, action2, predicate2); Assert.Equal("longer value", updatedValue); lambda(2, action1, predicate1, action2, predicate2); Assert.Equal("2", updatedValue); lambda(4711, action1, predicate1, action2, predicate2); Assert.Equal("2", updatedValue); }
public void Build_with_exactly_15_arguments() { //15 is the maximum number of arguments without having to put actions/funcs/predicates in an object array. //This comes from BuildLambdaExpression builds a Func, and Funcs may only have 16 input args: Func<T1,...,T16,TResult> //T1-argument is reserved for the obligatory value argument, which leaves us with 15 arguments to be used for the //actions/funcs/predicates string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Action <string> actionString = s => { }; Predicate <string> predicateString = s => false; for (var i = 0; i < 7; i++) { stringHandler.Handlers.Add(PredicateAndHandler.CreateAction(actionString, predicate: predicateString)); } typeHandlers.Add(stringHandler); var intHandler = new TypeHandler(typeof(int)); //Handle an int with one action Action <int> actionInt = i => { updatedValue = i.ToString(); }; var handler2 = PredicateAndHandler.CreateAction(actionInt); intHandler.Handlers.Add(handler2); typeHandlers.Add(intHandler); //Build the expression var builder = new MatchExpressionBuilder <object>(); var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(15, result.Arguments.Length, "Should contain the action and predicate delegates"); var lastArgument = result.Arguments.Last(); Assert.IsNotType <object[]>(lastArgument); //Last argument should not be an object[] //Compile the expression and test it var lambda = (Func <object, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <int>, bool>) result.LambdaExpression.Compile(); lambda("some value", actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionInt); Assert.Equal(null, updatedValue); lambda(4711, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionInt); Assert.Equal("4711", updatedValue); }
public void Build_one_func_that_expects_base_type() { string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Func <object, bool> func = o => { var s = (string)o; if (s.Length > 5) { updatedValue = s; return(true); } return(false); }; var handler = PredicateAndHandler.CreateAction(func, handlerFirstArgumentShouldBeBaseType: true); stringHandler.Handlers.Add(handler); typeHandlers.Add(stringHandler); var builder = new MatchExpressionBuilder <object>(); //Build the expression var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(1, result.Arguments.Length, "Should only contain the action delegate"); Assert.Same(func, result.Arguments[0]); //Compile the expression and test it var lambda = (Func <object, Func <object, bool>, bool>)result.LambdaExpression.Compile(); lambda(4711, func); Assert.Equal(null, updatedValue); lambda("short", func); Assert.Equal(null, updatedValue); lambda("the value", func); Assert.Equal("the value", updatedValue); }
/// <summary> /// TBD /// </summary> /// <param name="predicateAndHandler">TBD</param> /// <param name="value">TBD</param> /// <param name="valueIsActionOrFunc">TBD</param> public Argument(PredicateAndHandler predicateAndHandler, object value, bool valueIsActionOrFunc) { _predicateAndHandler = predicateAndHandler; _value = value; _valueIsActionOrFunc = valueIsActionOrFunc; }
public void Build_three_funcs_for_two_different_types() { string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler1 = new TypeHandler(typeof(string)); Func <string, bool> func1 = s => { if (s.Length > 5) { updatedValue = s; return(true); } return(false); }; var handler1 = PredicateAndHandler.CreateFunc(func1); stringHandler1.Handlers.Add(handler1); typeHandlers.Add(stringHandler1); var intHandler = new TypeHandler(typeof(int)); //Handle an int with one action Func <int, bool> func2 = i => { if (i < 10) { updatedValue = i.ToString(); return(true); } return(false); }; var handler2 = PredicateAndHandler.CreateFunc(func2); intHandler.Handlers.Add(handler2); typeHandlers.Add(intHandler); var stringHandler2 = new TypeHandler(typeof(string)); Func <string, bool> func3 = s => { updatedValue = "func3:" + s; return(true); }; var handler3 = PredicateAndHandler.CreateFunc(func3); stringHandler2.Handlers.Add(handler3); typeHandlers.Add(stringHandler2); //Build the expression var builder = new MatchExpressionBuilder <object>(); var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(3, result.Arguments.Length, "Should contain the funcs"); Assert.Same(func1, result.Arguments[0]); Assert.Same(func2, result.Arguments[1]); Assert.Same(func3, result.Arguments[2]); //Compile the expression and test it var lambda = (Func <object, Func <String, bool>, Func <int, bool>, Func <String, bool>, bool>)result.LambdaExpression.Compile(); lambda("short", func1, func2, func3); Assert.Equal("func3:short", updatedValue); lambda("longer value", func1, func2, func3); Assert.Equal("longer value", updatedValue); lambda(2, func1, func2, func3); Assert.Equal("2", updatedValue); lambda(4711, func1, func2, func3); Assert.Equal("2", updatedValue); }
public Argument(PredicateAndHandler predicateAndHandler, object value, bool valueIsActionOrFunc) { _predicateAndHandler = predicateAndHandler; _value = value; _valueIsActionOrFunc = valueIsActionOrFunc; }