public void DictForCacheNotKept() { var loop1 = new Dictionary <object, object>() { { "a", 10 } }; var loop2 = new Dictionary <object, object>() { { "a", 20 } }; var loopdict = new ObjectValue(new Dictionary <object, object>[] { loop1, loop2 }); var dictEval = new Tuple <IExpression, IExpression>[] { new Tuple <IExpression, IExpression>(new StringValue("hi"), new VariableValue("a")) }; var dict = new DictionaryValue(dictEval); var lookup = new IndexerRefExpression(dict, new StringValue("hi")); var statement1 = new ExpressionStatement(lookup); var exprStatement = new ListOfStatementsExpression(new IStatement[] { statement1 }); var forLoop = new FunctionExpression("for", loopdict, exprStatement); var c = new RootContext(); var r = forLoop.Evaluate(c); Assert.AreEqual(20, r, "for loop with nothing in it"); }
public void ExecuteSingleExpressionNoSideEffects() { var l = new ListOfStatementsExpression(new IStatement[] { new AssignmentStatement("a", new IntegerValue(5)) }); RootContext c = new RootContext(); var r = l.Evaluate(c); Assert.IsFalse(c.GetVariableValueOrNull("a").Item1, "variable part fo context"); }
public void TestNoSttatements() { var l = new ListOfStatementsExpression(new IStatement[] { }); RootContext c = new RootContext(); var r = l.Evaluate(c); Assert.IsNull(r, "result when no statements"); }
public void ExecuteSingleExpression() { var l = new ListOfStatementsExpression(new IStatement[] { new ExpressionStatement(new IntegerValue(5)) }); RootContext c = new RootContext(); var r = l.Evaluate(c); Assert.AreEqual(5, r, "Result of eval"); }
public void ExecuteContextUpdatedWhileRunning() { var l = new ListOfStatementsExpression(new IStatement[] { new AssignmentStatement("a", new IntegerValue(5)), new ExpressionStatement(new FunctionExpression("+", new VariableValue("a"), new IntegerValue(5))) }); RootContext c = new RootContext(); var r = l.Evaluate(c); Assert.AreEqual(10, r, "value of result"); }
public void UpdateExistingVariables() { var l = new ListOfStatementsExpression(new IStatement[] { new AssignmentStatement("a", new IntegerValue(5)), }); RootContext c = new RootContext(); c.SetVariableValue("a", 6); l.Evaluate(c); var r = c.GetVariableValue("a"); Assert.AreEqual(5, r, "value of result"); }
public void CanExecuteStatemetnsTwice() { var l = new ListOfStatementsExpression(new IStatement[] { new AssignmentStatement("a", new FunctionExpression("+", new VariableValue("a"), new IntegerValue(5))), }); RootContext c = new RootContext(); c.SetVariableValue("a", 0); l.Evaluate(c); l.Evaluate(c); var r = c.GetVariableValue("a"); Assert.AreEqual(10, r, "value of result"); }
public void DictForEmpty() { var loopdict = new ObjectValue(new Dictionary <object, object>[] { }); var statement1 = new ExpressionStatement(new IntegerValue(5)); var exprStatement = new ListOfStatementsExpression(new IStatement[] { statement1 }); var forLoop = new FunctionExpression("for", loopdict, exprStatement); var c = new RootContext(); var r = forLoop.Evaluate(c); Assert.IsNull(r, "for loop with nothing in it"); }
public void ExecuteInDifferentContex() { var testExpr = new IntegerValue(1); var assign = new AssignmentStatement("b", new IntegerValue(10)); var statement = new ListOfStatementsExpression(new IStatement[] { assign }); var ctx = new RootContext(); ctx.SetVariableValue("a", 5); var ifStatement = new FunctionExpression("if", testExpr, statement); ifStatement.Evaluate(ctx); Assert.IsFalse(ctx.GetVariableValueOrNull("b").Item1); }
public void SimpleFalseStatement() { var testExpr = new IntegerValue(0); var assign = new AssignmentStatement("a", new IntegerValue(10)); var statement = new ListOfStatementsExpression(new IStatement[] { assign }); var ctx = new RootContext(); ctx.SetVariableValue("a", 5); var ifStatement = new FunctionExpression("if", testExpr, statement); ifStatement.Evaluate(ctx); Assert.AreEqual(5, ctx.GetVariableValue("a")); }
public void ArrayForOneResult() { var loop1 = new object[] { 10 }; var loopdict = new ObjectValue(loop1); var statement1 = new ExpressionStatement(new VariableValue("a")); var exprStatement = new ListOfStatementsExpression(new IStatement[] { statement1 }); var forLoop = new FunctionExpression("for", new VariableValue("a"), loopdict, exprStatement); var c = new RootContext(); var r = forLoop.Evaluate(c); Assert.AreEqual(10, r, "for loop with nothing in it"); }
public void DictForVarSet() { var loop1 = new Dictionary <object, object>() { { "a", 10 } }; var loopdict = new ObjectValue(new Dictionary <object, object>[] { loop1 }); var statement1 = new ExpressionStatement(new VariableValue("a")); var exprStatement = new ListOfStatementsExpression(new IStatement[] { statement1 }); var forLoop = new FunctionExpression("for", loopdict, exprStatement); var c = new RootContext(); var r = forLoop.Evaluate(c); Assert.AreEqual(10, r, "for loop with nothing in it"); }
/// <summary> /// Simple if statement. /// </summary> /// <param name="ctx"></param> /// <param name="logicalTest"></param> /// <param name="statements"></param> /// <returns></returns> public static object ifReserved(IScopeContext ctx, IExpression logicalTest, ListOfStatementsExpression statements) { // See if we have fired var testResult = logicalTest.Evaluate(ctx); if (testResult.GetType() != typeof(bool) && testResult.GetType() != typeof(int)) { throw new ArgumentException($"The test {logicalTest.ToString()} did not evaluate to an integer or a boolean"); } var shouldExecute = testResult.GetType() == typeof(bool) ? (bool)testResult : (int)testResult != 0; if (shouldExecute) { var newScope = new ScopeContext(ctx); return(statements.Evaluate(newScope)); } return(null); }
/// <summary> /// Loop over an array with a variable index. /// </summary> /// <param name="ctx"></param> /// <param name="loopControl"></param> /// <param name="statements"></param> /// <returns></returns> public static object forReserved(IScopeContext ctx, VariableValue loopIndex, IEnumerable <object> loopControl, ListOfStatementsExpression statements) { if (loopControl.Where(o => o == null).Any()) { throw new ArgumentNullException(string.Format("indexed for loop: Some of the objects we are looping over are null! Not allowed!")); } var indexList = loopControl.Select(i => new Dictionary <object, object>() { { loopIndex.VariableName, i } }); return(forReserved(ctx, indexList, statements)); }
/// <summary> /// Given a list of objects that are dictionarys, run the loop. Take the last result from each loop, and transform it into a /// list of values that gets passed back to the caller. /// </summary> /// <param name="ctx"></param> /// <param name="loopControl"></param> /// <param name="statements"></param> /// <returns></returns> public static IEnumerable <object> map(IScopeContext ctx, IEnumerable <object> loopControl, ListOfStatementsExpression statements) { return(loopControl.Select(iterLoopVars => { var dict = iterLoopVars as IDictionary <object, object>; if (dict == null) { throw new ArgumentException("For loop over dictionary items - every item must be a dictionary!"); } var newScope = new ScopeContext(ctx); foreach (var varDefined in dict) { newScope.SetVariableValueLocally(varDefined.Key.ToString(), varDefined.Value); } var v = statements.Evaluate(newScope); if (v == null) { throw new ArgumentNullException("Iteration of map returned null!"); } return v; })); }
/// <summary> /// Loop over the contents of an array /// </summary> /// <param name="ctx">The run context</param> /// <param name="indexName">Name of the variable we should be setting</param> /// <param name="mapOver">The array of objects we are going to loop over</param> /// <param name="statements">The statements to be executed.</param> /// <returns></returns> public static IEnumerable <object> map(IScopeContext ctx, VariableValue indexName, IEnumerable <object> mapOver, ListOfStatementsExpression statements) { var allDict = mapOver.Select(o => new Dictionary <object, object>() { { indexName.VariableName, o } }); return(map(ctx, allDict, statements)); }
public void CreateNoSttatements() { var l = new ListOfStatementsExpression(null); }
/// <summary> /// A regular for loop, using a list of dictionaries as the items we loop over. For each iteration, a dictionary is /// pulled off the loopControl sequence. The keys are all evaluated to strings, and then used as variable names that /// can be referenced in the body of the loop. They are set to the value of the dictionary value. /// </summary> /// <param name="ctx">Scope context for variable definitions, etc.</param> /// <param name="loopControl">A list of dictionaries that we used to set the loop variables</param> /// <param name="statements">The list of statements we will process</param> /// <returns></returns> /// <remarks>Because "for" is a reserved word, this function needs the "Reserved" tacked onto the end. During method /// resolution, the language core should take care of this.</remarks> public static object forReserved(IScopeContext ctx, IEnumerable <object> loopControl, ListOfStatementsExpression statements) { object result = null; foreach (var iterLoopVars in loopControl) { var dict = iterLoopVars as IDictionary <object, object>; if (dict == null) { throw new ArgumentException("For loop over dictionary items - every item must be a dictionary!"); } var newScope = new ScopeContext(ctx); foreach (var varDefined in dict) { newScope.SetVariableValueLocally(varDefined.Key.ToString(), varDefined.Value); } result = statements.Evaluate(newScope); } return(result); }