public void TestReplaceVariablesIndexFunctionCall()
{
var functionDefinition = UserFunctionDefinitionExpression.ParseForTest("function func(i) => 6");
var functionCall = new FunctionCallExpression("func", new ExpressionBase[] { new IntegerConstantExpression(2) });
var value = new IntegerConstantExpression(98);
var variable = new VariableExpression("variable");
var dict = new DictionaryExpression();
dict.Add(new IntegerConstantExpression(6), value);
var scope = new InterpreterScope();
scope.AssignVariable(variable, dict);
scope.AddFunction(functionDefinition);
var expr = new IndexedVariableExpression(variable, functionCall);
ExpressionBase result;
Assert.That(expr.ReplaceVariables(scope, out result), Is.True);
Assert.That(result, Is.InstanceOf <IntegerConstantExpression>());
Assert.That(((IntegerConstantExpression)result).Value, Is.EqualTo(98));
}
private FunctionDefinitionExpression Parse(string input)
{
var def = UserFunctionDefinitionExpression.ParseForTest(input);
Assert.That(def, Is.Not.Null);
return((FunctionDefinitionExpression)def);
}
public void TestReplaceVariablesMethodCall()
{
var functionDefinition = UserFunctionDefinitionExpression.ParseForTest("function func(i) { j = i }");
var functionCall = new FunctionCallExpression("func", new ExpressionBase[] { new IntegerConstantExpression(2) });
var value1 = new IntegerConstantExpression(98);
var expr = new DictionaryExpression();
expr.Add(functionCall, value1);
var scope = new InterpreterScope();
scope.AddFunction(functionDefinition);
ExpressionBase result;
Assert.That(expr.ReplaceVariables(scope, out result), Is.False);
Assert.That(result, Is.InstanceOf <ParseErrorExpression>());
var parseError = (ParseErrorExpression)result;
while (parseError.InnerError != null)
{
parseError = parseError.InnerError;
}
Assert.That(parseError.Message, Is.EqualTo("func did not return a value"));
}
public void TestParseErrorInsideDefinition()
{
var tokenizer = new PositionalTokenizer(Tokenizer.CreateTokenizer("function func() { j = }"));
tokenizer.Match("function");
var expr = UserFunctionDefinitionExpression.Parse(tokenizer);
Assert.That(expr, Is.InstanceOf <ParseErrorExpression>());
Assert.That(((ParseErrorExpression)expr).Message, Is.EqualTo("Unexpected end of script"));
}
public void TestParseErrorInsideDefinitionExpressionTokenizer()
{
var group = new ExpressionGroup();
var tokenizer = new ExpressionTokenizer(Tokenizer.CreateTokenizer("function func() { j = }"), group);
tokenizer.Match("function");
var expr = UserFunctionDefinitionExpression.Parse(tokenizer);
Assert.That(expr, Is.InstanceOf <FunctionDefinitionExpression>());
Assert.That(group.ParseErrors.Count(), Is.EqualTo(2));
Assert.That(group.ParseErrors.First().Message, Is.EqualTo("Unexpected character: }"));
}
public void TestFunctionCall()
{
var scope = new InterpreterScope();
var array = new ArrayExpression();
scope.DefineVariable(new VariableDefinitionExpression("arr"), array);
scope.AddFunction(UserFunctionDefinitionExpression.ParseForTest(
"function happy(val) => val + \"rama\""
));
Assert.That(Evaluate("length(happy(\"banana\"))", scope), Is.EqualTo(10));
}
public void TestReplaceVariablesLogicalFunctionCall()
{
var functionDefinition = UserFunctionDefinitionExpression.ParseForTest("function func(i) => byte(i) == 1");
var functionCall = new FunctionCallExpression("func", new ExpressionBase[] { new IntegerConstantExpression(2) });
var value1 = new IntegerConstantExpression(98);
var expr = new DictionaryExpression();
expr.Add(functionCall, value1);
var scope = new InterpreterScope(AchievementScriptInterpreter.GetGlobalScope());
scope.AddFunction(functionDefinition);
ExpressionBase result;
Assert.That(expr.ReplaceVariables(scope, out result), Is.False);
Assert.That(result, Is.InstanceOf <ParseErrorExpression>());
Assert.That(((ParseErrorExpression)result).Message, Is.EqualTo("Dictionary key must evaluate to a constant"));
}
private FunctionDefinitionExpression Parse(string input, string expectedError = null)
{
var tokenizer = new PositionalTokenizer(Tokenizer.CreateTokenizer(input));
tokenizer.Match("function");
var expr = UserFunctionDefinitionExpression.Parse(tokenizer);
if (expectedError != null)
{
Assert.That(expr, Is.InstanceOf <ParseErrorExpression>());
var error = (ParseErrorExpression)expr;
var formattedErrorMessage = string.Format("{0}:{1} {2}", error.Location.Start.Line, error.Location.Start.Column, error.Message);
Assert.That(formattedErrorMessage, Is.EqualTo(expectedError));
return(null);
}
else
{
Assert.That(expr, Is.InstanceOf <FunctionDefinitionExpression>());
return((FunctionDefinitionExpression)expr);
}
}
public void TestReplaceVariablesFunctionCall()
{
var functionDefinition = UserFunctionDefinitionExpression.ParseForTest("function func(i) => 6");
var functionCall = new FunctionCallExpression("func", new ExpressionBase[] { new IntegerConstantExpression(2) });
var value1 = new IntegerConstantExpression(98);
var expr = new DictionaryExpression();
expr.Add(functionCall, value1);
var scope = new InterpreterScope();
scope.AddFunction(functionDefinition);
ExpressionBase result;
Assert.That(expr.ReplaceVariables(scope, out result), Is.True);
Assert.That(result, Is.InstanceOf <DictionaryExpression>());
var dictResult = (DictionaryExpression)result;
Assert.That(dictResult.Count, Is.EqualTo(1));
Assert.That(dictResult[0].Key, Is.EqualTo(new IntegerConstantExpression(6)));
Assert.That(dictResult[0].Value, Is.EqualTo(value1));
}
private void AddHappyFunction(InterpreterScope scope)
{
scope.AddFunction(UserFunctionDefinitionExpression.ParseForTest(
"function happy(num1) => num1"
));
}
