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);
}
