public void FindDefaultFunctionType_TypedCloudEventFunction()
{
var expected = typeof(StringCloudEventFunction);
var actual = FunctionEnvironment.FindDefaultFunctionType(typeof(StringCloudEventFunction));
Assert.Equal(expected, actual);
}
public void FindDefaultFunctionType_NoFunctionTypes() =>
Assert.Throws <ArgumentException>(() => FunctionEnvironment.FindDefaultFunctionType(
typeof(FunctionEnvironmentTest),
typeof(ConfigurationVariableProviderTest),
typeof(TestHttpFunctionBase), // Abstract, doesn't count
typeof(INamedHttpFunction) // Interface, doesn't count
));
/// <summary>
/// Creates a FunctionEnvironment using the given command line and environment variables, and this
/// (test) assembly.
/// </summary>
/// <param name="variables">The environment variables to emulator, in "Name=Value" format</param>
/// <returns>The function environment</returns>
private static FunctionEnvironment CreateEnvironment(string[] commandLine, string[] variables)
{
var variableDictionary = variables.ToDictionary(v => v.Split('=')[0], v => v.Split('=')[1]);
var provider = ConfigurationVariableProvider.FromDictionary(variableDictionary);
return(FunctionEnvironment.Create(typeof(FunctionEnvironmentTest).Assembly, commandLine, provider));
}
public void FunctionReturnTests()
{
VariableEnvironment variables = new VariableEnvironment();
FunctionEnvironment functionEnvironment = new FunctionEnvironment();
variables.DeclareVariable("abc", BogieLangType.BOOL);
variables.DefineVariable("abc", true);
string txt = "return abc";
AntlrInputStream inputStream = new AntlrInputStream(txt);
BogieLangLexer lexer = new BogieLangLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
BogieLangParser parser = new BogieLangParser(commonTokenStream);
BogieLangParser.FunctionReturnContext functionReturnContext = parser.functionReturn();
BogieLangBaseVisitor <object> visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(functionReturnContext);
FunctionReturn functionReturn = FunctionReturn.Compile(functionReturnContext);
Assert.True((bool)functionReturn.Execute(functionEnvironment, variables) == true);
variables.Clear();
txt = "return 10.0";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
functionReturnContext = parser.functionReturn();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(functionReturnContext);
functionReturn = FunctionReturn.Compile(functionReturnContext);
Assert.True((double)functionReturn.Execute(functionEnvironment, variables) == 10.0);
}
public void IfTests()
{
VariableEnvironment variables = new VariableEnvironment();
FunctionEnvironment functionEnvironment = new FunctionEnvironment();
string txt = "if(true){}";
AntlrInputStream inputStream = new AntlrInputStream(txt);
BogieLangLexer lexer = new BogieLangLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
BogieLangParser parser = new BogieLangParser(commonTokenStream);
BogieLangParser.IfControlContext ifControlContext = parser.ifControl();
BogieLangBaseVisitor <object> visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(ifControlContext);
IfControl ifControl = IfControl.Compile(ifControlContext);
Assert.True(ifControl.Execute(functionEnvironment, variables) == null);
txt = "if(true){int b=0}";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
ifControlContext = parser.ifControl();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(ifControlContext);
ifControl = IfControl.Compile(ifControlContext);
Assert.True(ifControl.Execute(functionEnvironment, variables) == null);
Assert.True(!variables.IsVariableDeclared("b"));
}
private async Task AssertHttpFunctionType <T>(FunctionEnvironment environment) where T : IHttpFunction
{
Assert.Equal(typeof(T), environment.FunctionType);
var context = new DefaultHttpContext();
await ExecuteRequest(environment, context);
Assert.Equal(typeof(T), context.Items[TestHttpFunctionBase.TypeKey]);
}
public void FindDefaultFunctionType_SingleFunctionType()
{
var expected = typeof(DefaultFunction);
var actual = FunctionEnvironment.FindDefaultFunctionType(
typeof(FunctionEnvironmentTest),
typeof(ConfigurationVariableProviderTest),
typeof(TestHttpFunctionBase), // Abstract, doesn't count
typeof(INamedHttpFunction), // Interface, doesn't count
typeof(DefaultFunction));
Assert.Equal(expected, actual);
}
/// <summary>
/// Executes the given request in a function environment. The context will be populated
/// with a default service provider.
/// </summary>
private async Task ExecuteRequest(FunctionEnvironment environment, HttpContext context)
{
var services = new ServiceCollection();
// Normally ASP.NET Core provides logging for everything, so it's natural to depend on it.
// Our adapters may need logging, so let's make sure it's available.
services.AddSingleton <ILoggerFactory>(new LoggerFactory());
services.AddLogging();
environment.ConfigureServices(services);
var providerFactory = new DefaultServiceProviderFactory();
var provider = providerFactory.CreateServiceProvider(services);
using (var scope = provider.CreateScope())
{
context.RequestServices = scope.ServiceProvider;
await environment.Execute(context);
}
}
public async Task Integration()
{
var environment = FunctionEnvironment.Create(
typeof(DependencyInjectionTest).Assembly,
new[] { typeof(DependencyTestFunction).FullName },
ConfigurationVariableProvider.FromDictionary(new Dictionary <string, string>()));
var services = new ServiceCollection();
environment.ConfigureServices(services);
var providerFactory = new DefaultServiceProviderFactory();
var provider = providerFactory.CreateServiceProvider(services);
// Execute two requests, and remember the dependencies we saw in each of them.
var request1Deps = await MakeRequestAsync();
var request2Deps = await MakeRequestAsync();
// We should get dependencies on every call
Assert.NotNull(request1Deps.dep1);
Assert.NotNull(request1Deps.dep2);
Assert.NotNull(request2Deps.dep1);
Assert.NotNull(request2Deps.dep2);
// Dependency1 is registered as a singleton, so we should have the same value in both requests.
Assert.Same(request1Deps.dep1, request2Deps.dep1);
// Dependency2 is registered as a scoped service, so we should have different values in each request.
Assert.NotSame(request1Deps.dep2, request2Deps.dep2);
async Task <(object dep1, object dep2)> MakeRequestAsync()
{
using (var scope = provider.CreateScope())
{
var context = new DefaultHttpContext {
RequestServices = scope.ServiceProvider
};
await environment.Execute(context);
return(context.Items[Dependency1Key], context.Items[Dependency2Key]);
}
}
}
public OrchestrationConfiguration MapCommand <T>(string orchestrationName, Func <ICommand, TimeSpan> orchestrationTimeout = null)
where T : IProviderCommand
{
if (string.IsNullOrEmpty(orchestrationName))
{
throw new ArgumentException("Cannot be null or empty.", nameof(orchestrationName));
}
if (!FunctionEnvironment.FunctionExists(orchestrationName))
{
throw new ArgumentOutOfRangeException(nameof(orchestrationName), $"Could not find orchstration by name '{orchestrationName}'");
}
orchestrations[typeof(T)] = new OrchestrationSettings()
{
OrchestrationName = orchestrationName,
OrchstrationTimeout = orchestrationTimeout ?? OrchestrationSettings.DefaultOrchestrationTimeout
};
return(this);
}
public void WhileTests()
{
VariableEnvironment variables = new VariableEnvironment();
FunctionEnvironment functionEnvironment = new FunctionEnvironment();
variables.DeclareVariable("loop", BogieLangType.BOOL);
variables.DefineVariable("loop", true);
string txt = "while(loop){loop = false}";
AntlrInputStream inputStream = new AntlrInputStream(txt);
BogieLangLexer lexer = new BogieLangLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
BogieLangParser parser = new BogieLangParser(commonTokenStream);
BogieLangParser.WhileControlContext whileControlContext = parser.whileControl();
BogieLangBaseVisitor <object> visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(whileControlContext);
WhileControl whileControl = WhileControl.Compile(whileControlContext);
Assert.True(whileControl.Execute(functionEnvironment, variables) == null);
Assert.True((bool)variables["loop"].Value == false);
txt = " while(loop){loop = false int b=0}";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
whileControlContext = parser.whileControl();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(whileControlContext);
whileControl = WhileControl.Compile(whileControlContext);
Assert.True(whileControl.Execute(functionEnvironment, variables) == null);
Assert.True((bool)variables["loop"].Value == false);
Assert.True(!variables.IsVariableDeclared("b"));
}
public void VarDefinitionTests()
{
VariableEnvironment variables = new VariableEnvironment();
FunctionEnvironment functionEnvironment = new FunctionEnvironment();
variables.DeclareVariable("var", BogieLangType.INTEGER);
string txt = "var=123";
AntlrInputStream inputStream = new AntlrInputStream(txt);
BogieLangLexer lexer = new BogieLangLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
BogieLangParser parser = new BogieLangParser(commonTokenStream);
BogieLangParser.VarDefinitionContext varDefinitionContext = parser.varDefinition();
BogieLangBaseVisitor <object> visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(varDefinitionContext);
VarDefinition varDefinition = VarDefinition.Compile(varDefinitionContext);
varDefinition.Execute(functionEnvironment, variables);
Assert.True(variables["var"].BogieLangType == BogieLangType.INTEGER);
Assert.True(variables["var"].Value is int);
Assert.True((int)variables["var"].Value == 123);
}
public void FindDefaultFunctionType_MultipleFunctionTypes() =>
Assert.Throws <ArgumentException>(() => FunctionEnvironment.FindDefaultFunctionType(
typeof(DefaultFunction),
typeof(EventIdRememberingFunction)));
public override int Eval(RuntimeEnvironment runtimeEnvironment, FunctionEnvironment functionEnvironment)
{
return _value;
}
public override Type Check(TypeCheckingEnvironment typeCheckingEnvironment, FunctionEnvironment functionEnvironment)
{
return _type;
}
public override int Eval(RuntimeEnvironment runtimeEnvironment, FunctionEnvironment functionEnvironment)
{
return runtimeEnvironment.GetVariable(_name).Value;
}
public override int Eval(RuntimeEnvironment runtimeEnvironment, FunctionEnvironment functionEnvironment)
{
return(_value);
}
public void FindDefaultFunctionType_MultipleCloudEventTypesFunction() =>
Assert.Throws <ArgumentException>(() => FunctionEnvironment.FindDefaultFunctionType(
typeof(MultipleCloudEventTypes)));
public override Type Check(TypeCheckingEnvironment typeCheckingEnvironment, FunctionEnvironment functionEnvironment)
{
return(typeCheckingEnvironment.GetVariable(_name));
}
public void BodyTests()
{
VariableEnvironment variables = new VariableEnvironment();
FunctionEnvironment functionEnvironment = new FunctionEnvironment();
string txt = "int b=true";
AntlrInputStream inputStream = new AntlrInputStream(txt);
BogieLangLexer lexer = new BogieLangLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
BogieLangParser parser = new BogieLangParser(commonTokenStream);
BogieLangParser.BodyContext bodyContext = parser.body();
BogieLangBaseVisitor <object> visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(bodyContext);
Body body = Body.Compile(bodyContext);
try
{
body.Execute(functionEnvironment, variables);
Assert.True(false);
}
catch (Exception e)
{
Assert.True(true);//todo: test for a specific exception types once they are created
}
variables.Clear();
txt = "int b=098";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
bodyContext = parser.body();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(bodyContext);
body = Body.Compile(bodyContext);
body.Execute(functionEnvironment, variables);
Assert.True(variables["b"].BogieLangType == BogieLangType.INTEGER);
Assert.True(variables["b"].Identifer == "b");
Assert.True((int)variables["b"].Value == 98);
txt = "abc=123";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
bodyContext = parser.body();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(bodyContext);
body = Body.Compile(bodyContext);
try
{
Assert.True(body.Execute(functionEnvironment, variables) == null);
Assert.True(false);
}
catch
{
Assert.True(true);//todo: test for specific exception types once they are created
}
variables.DeclareVariable("abc", BogieLangType.INTEGER);
txt = "abc=123";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
bodyContext = parser.body();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(bodyContext);
body = Body.Compile(bodyContext);
body.Execute(functionEnvironment, variables);
Assert.True(variables["abc"].BogieLangType == BogieLangType.INTEGER);
Assert.True(variables["abc"].Identifer == "abc");
Assert.True((int)variables["abc"].Value == 123);
txt = "return 0";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
bodyContext = parser.body();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(bodyContext);
body = Body.Compile(bodyContext);
Assert.True(body.Execute(functionEnvironment, variables) is int);
Assert.True((int)body.Execute(functionEnvironment, variables) == 0);
txt = "if(1){int b}";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
bodyContext = parser.body();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(bodyContext);
body = Body.Compile(bodyContext);
body.Execute(functionEnvironment, variables);
txt = "if(true){int b}";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
bodyContext = parser.body();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(bodyContext);
body = Body.Compile(bodyContext);
body.Execute(functionEnvironment, variables);
}
public abstract Type Check(TypeCheckingEnvironment typeCheckingEnvironment, FunctionEnvironment functionEnvironment);
public abstract int Eval(RuntimeEnvironment runtimeEnvironment, FunctionEnvironment functionEnvironment);
abstract public Type Check(TypeCheckingEnvironment typeCheckingEnvironment, FunctionEnvironment functionEnvironment);
public void FunctionDefinitionTests()
{
VariableEnvironment variableEnvironment = new VariableEnvironment();
FunctionEnvironment functionEnvironment = new FunctionEnvironment();
string txt = "void funcName(){}";
AntlrInputStream inputStream = new AntlrInputStream(txt);
BogieLangLexer lexer = new BogieLangLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
BogieLangParser parser = new BogieLangParser(commonTokenStream);
BogieLangParser.FunctionDefinitionContext functionDefinitionContext = parser.functionDefinition();
BogieLangBaseVisitor <object> visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(functionDefinitionContext);
FunctionDefinition functionDefinition = FunctionDefinition.Compile(functionDefinitionContext);
functionEnvironment.FunctionDefinitions.Add("funcName", functionDefinition);
functionDefinition.Execute(functionEnvironment, variableEnvironment);
functionEnvironment.Clear();
variableEnvironment.DeclaredVariables = new Dictionary <string, BogieLangTypeInstance>()
{
{ "abc", new BogieLangTypeInstance()
{
BogieLangType = BogieLangType.INTEGER, Identifer = "abc", Value = 1
} },
{ "str", new BogieLangTypeInstance()
{
BogieLangType = BogieLangType.STRING, Identifer = "str", Value = "string"
} },
{ "lol", new BogieLangTypeInstance()
{
BogieLangType = BogieLangType.VOID, Identifer = "lol", Value = null
} }
};
txt = "void funcName(int abc,string str,void lol){}";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
functionDefinitionContext = parser.functionDefinition();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(functionDefinitionContext);
functionDefinition = FunctionDefinition.Compile(functionDefinitionContext);
functionEnvironment.FunctionDefinitions.Add("funcName", functionDefinition);
functionDefinition.Execute(functionEnvironment, variableEnvironment);
txt = "int funcName(int abc,string str,bool b){int intvar" +
"\n intvar=123" +
"\nintvar=1" +
"\nreturn funcCall(b)" +
"\n}";
string txt2 = "\nint funcCall(bool b)" +
"\n{" +
"\nif(b)" +
"\n{" +
"\n return 100" +
"\n}" +
"\nreturn 0" +
"}";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
functionDefinitionContext = parser.functionDefinition();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(functionDefinitionContext);
FunctionDefinition functionDefinition1 = FunctionDefinition.Compile(functionDefinitionContext);
inputStream = new AntlrInputStream(txt2);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
functionDefinitionContext = parser.functionDefinition();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(functionDefinitionContext);
FunctionDefinition functionDefinition2 = FunctionDefinition.Compile(functionDefinitionContext);
variableEnvironment.Clear();
functionEnvironment.Clear();
variableEnvironment.DeclaredVariables = new Dictionary <string, BogieLangTypeInstance>()
{
{ "abc", new BogieLangTypeInstance()
{
BogieLangType = BogieLangType.INTEGER, Identifer = "abc", Value = 1
} },
{ "str", new BogieLangTypeInstance()
{
BogieLangType = BogieLangType.STRING, Identifer = "str", Value = "string"
} },
{ "b", new BogieLangTypeInstance()
{
BogieLangType = BogieLangType.BOOL, Identifer = "b", Value = true
} }
};
functionEnvironment.DefineFunction("funcName", functionDefinition1);
functionEnvironment.DefineFunction("funcCall", functionDefinition2);
Assert.True((int)functionDefinition1.Execute(functionEnvironment, variableEnvironment) == 100);
}
abstract public int Eval(RuntimeEnvironment runtimeEnvironment, FunctionEnvironment functionEnvironment);
public void ExpressionTests()
{
VariableEnvironment variableEnvironment = new VariableEnvironment();
FunctionEnvironment functionEnvironment = new FunctionEnvironment();
string txt = "1";
AntlrInputStream inputStream = new AntlrInputStream(txt);
BogieLangLexer lexer = new BogieLangLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
BogieLangParser parser = new BogieLangParser(commonTokenStream);
BogieLangParser.ExpressionContext expressionContext = parser.expression();
BogieLangBaseVisitor <object> visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(expressionContext);
Expression expression = Expression.Compile(expressionContext, null);
Assert.True(expression.Execute(functionEnvironment, new VariableEnvironment()) is int);
Assert.True(expression.ParentExpression == null);
Assert.True((int)expression.Execute(functionEnvironment, new VariableEnvironment()) == 1);
txt = "1.0";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
expressionContext = parser.expression();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(expressionContext);
expression = Expression.Compile(expressionContext, null);
Assert.True(expression.Execute(functionEnvironment, new VariableEnvironment()) is double);
Assert.True(expression.ParentExpression == null);
Assert.True((double)expression.Execute(functionEnvironment, new VariableEnvironment()) == 1.0);
txt = "false";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
expressionContext = parser.expression();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(expressionContext);
expression = Expression.Compile(expressionContext, null);
Assert.True(expression.Execute(functionEnvironment, new VariableEnvironment()) is bool);
Assert.True(expression.ParentExpression == null);
Assert.True((bool)expression.Execute(functionEnvironment, new VariableEnvironment()) == false);
txt = "\"asd899asd\"";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
expressionContext = parser.expression();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(expressionContext);
expression = Expression.Compile(expressionContext, null);
Assert.True(expression.Execute(functionEnvironment, new VariableEnvironment()) is string);
Assert.True((string)expression.Execute(functionEnvironment, new VariableEnvironment()) == "asd899asd");
txt = "VarName";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
expressionContext = parser.expression();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(expressionContext);
expression = Expression.Compile(expressionContext, null);
variableEnvironment.DeclareVariable(txt, BogieLangType.INTEGER);
variableEnvironment.DefineVariable(txt, 1);
Assert.True(expression.Execute(functionEnvironment, variableEnvironment) is int);
Assert.True(expression.ParentExpression == null);
Assert.True((int)expression.Execute(functionEnvironment, variableEnvironment) == 1);
}
public override Type Check(TypeCheckingEnvironment typeCheckingEnvironment, FunctionEnvironment functionEnvironment)
{
return(_type);
}
public void AddTests()
{
VariableEnvironment variableEnvironment = new VariableEnvironment();
FunctionEnvironment functionEnvironment = new FunctionEnvironment();
string txt = "1+1";
AntlrInputStream inputStream = new AntlrInputStream(txt);
BogieLangLexer lexer = new BogieLangLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
BogieLangParser parser = new BogieLangParser(commonTokenStream);
BogieLangParser.ExpressionContext expressionContext = parser.expression();
BogieLangBaseVisitor <object> visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(expressionContext);
Expression expression = Expression.Compile(expressionContext, null);
Assert.True(expression.ParentExpression == null);
Assert.True(expression.SubExpression.ParentExpression == expression);
Assert.True((int)expression.Execute(functionEnvironment, variableEnvironment) == 2);
txt = "1+1+1";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
expressionContext = parser.expression();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(expressionContext);
expression = Expression.Compile(expressionContext, null);
Assert.True(expression.ParentExpression == null);
Assert.True(expression.SubExpression.ParentExpression == expression);
Assert.True(expression.SubExpression.SubExpression.ParentExpression == expression.SubExpression);
Assert.True((int)expression.Execute(functionEnvironment, variableEnvironment) == 3);
txt = "1+1.1";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
expressionContext = parser.expression();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(expressionContext);
expression = Expression.Compile(expressionContext, null);
Assert.True(expression.ParentExpression == null);
Assert.True(expression.SubExpression.ParentExpression == expression);
Assert.True((double)expression.Execute(functionEnvironment, variableEnvironment) == 2.1);
txt = "1+\"one\"";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
expressionContext = parser.expression();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(expressionContext);
expression = Expression.Compile(expressionContext, null);
Assert.True(expression.ParentExpression == null);
Assert.True(expression.SubExpression.ParentExpression == expression);
Assert.True((string)expression.Execute(functionEnvironment, variableEnvironment) == "1one");
txt = "1+true";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
expressionContext = parser.expression();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(expressionContext);
expression = Expression.Compile(expressionContext, null);
Assert.True(expression.ParentExpression == null);
Assert.True(expression.SubExpression.ParentExpression == expression);
Assert.True((int)expression.Execute(functionEnvironment, variableEnvironment) == 2);
txt = "1+1.1+true+\"str\"";
inputStream = new AntlrInputStream(txt);
lexer = new BogieLangLexer(inputStream);
commonTokenStream = new CommonTokenStream(lexer);
parser = new BogieLangParser(commonTokenStream);
expressionContext = parser.expression();
visitor = new BogieLangBaseVisitor <object>();
visitor.Visit(expressionContext);
expression = Expression.Compile(expressionContext, null);
Assert.True(expression.ParentExpression == null);
Assert.True(expression.SubExpression.ParentExpression == expression);
Assert.True(expression.SubExpression.SubExpression.ParentExpression == expression.SubExpression);
Assert.True(expression.SubExpression.SubExpression.SubExpression.ParentExpression == expression.SubExpression.SubExpression);
Assert.True((string)expression.Execute(functionEnvironment, variableEnvironment) == "3.1str");
}
public override int Eval(RuntimeEnvironment runtimeEnvironment, FunctionEnvironment functionEnvironment)
{
return(runtimeEnvironment.GetVariable(_name).Value);
}
public override Type Check(TypeCheckingEnvironment typeCheckingEnvironment, FunctionEnvironment functionEnvironment)
{
return typeCheckingEnvironment.GetVariable(_name);
}
