public async Task InvokeMethodInterpreterRecursivityStackoverflowAsync()
{
var parser = new BaZicParser();
var inputCode =
@"EXTERN FUNCTION Main(args[])
FirstMethod(1000) # A Stackoverflow must never happen if FirstMethod is ASYNC.
END FUNCTION
ASYNC FUNCTION FirstMethod(num)
IF num > 1 THEN
RETURN FirstMethod(num - 1)
END IF
RETURN num
END FUNCTION";
var interpreter = new BaZicInterpreter(parser.Parse(inputCode, false).Program);
await interpreter.StartDebugAsync(true);
var expected1 = "[Log] End of the execution of the method 'FirstMethod'. Returned value : 0 (System.Int32)";
var result = interpreter.GetStateChangedHistoryString();
Assert.IsTrue(result.Contains(expected1));
Assert.AreEqual(null, interpreter.ProgramResult);
await TestUtilities.TestAllRunningMode(null, inputCode);
}
/// <inheritdoc/>
internal override object Run()
{
var declarations = BaZicInterpreter.MethodDeclarations.Where(m => string.Compare(m.Name.Identifier, Expression.MethodName.Identifier, StringComparison.Ordinal) == 0);
if (declarations.Count() == 0)
{
BaZicInterpreter.ChangeState(this, new MethodNotFoundException(Expression.MethodName.Identifier, L.BaZic.Runtime.Interpreters.Expressions.InvokeMethodInterpreter.FormattedMethodNotFound(Expression.MethodName)), Expression);
return(null);
}
else if (declarations.Count() > 1)
{
BaZicInterpreter.ChangeState(this, new MethodNotFoundException(Expression.MethodName.Identifier, L.BaZic.Runtime.Interpreters.Expressions.InvokeMethodInterpreter.FormattedSeveralMethods(Expression.MethodName)), Expression);
return(null);
}
// If the invocation is made manually by the user (outisde of the execution flow).
if (_failIfNotExtern)
{
if (!declarations.Single().IsExtern)
{
BaZicInterpreter.ChangeState(this, new MethodNotFoundException(Expression.MethodName.Identifier, L.BaZic.Runtime.Interpreters.Expressions.InvokeMethodInterpreter.FormattedMethodNotFound(Expression.MethodName)), Expression);
return(null);
}
if (!declarations.Single().IsAsync&& Expression.Await)
{
Expression.Await = false;
}
}
var methodInterpreter = new MethodInterpreter(BaZicInterpreter, ParentInterpreter, declarations.Single(), Expression, _executionFlowId);
return(methodInterpreter.Invoke());
}
public async Task BinaryOperatorInterpreterAddition()
{
var parser = new BaZicParser();
var inputCode =
@"EXTERN FUNCTION Main(args[])
VARIABLE var1 = 2 + 3 # Should be 5
VARIABLE var2 = ""2"" + 3 # Should be 23
VARIABLE var3 = 2 + 3.0 # Should be 5
VARIABLE var4 = ""Hello"" + true # Should be HelloTrue
END FUNCTION";
var interpreter = new BaZicInterpreter(parser.Parse(inputCode, true).Program);
await interpreter.StartDebugAsync(true);
var result = interpreter.GetStateChangedHistoryString();
Assert.IsNull(interpreter.Error);
Assert.IsTrue(result.Contains("[Log] Variable 'var1' declared. Default value : 5 (System.Int32)"));
Assert.IsTrue(result.Contains("[Log] Variable 'var2' declared. Default value : 23 (System.String)"));
Assert.IsTrue(result.Contains("[Log] Variable 'var3' declared. Default value : 5 (System.Double)"));
Assert.IsTrue(result.Contains("[Log] Variable 'var4' declared. Default value : HelloTrue (System.String)"));
inputCode =
@"EXTERN FUNCTION Main(args[])
VARIABLE var4 = true + false # Should fail
END FUNCTION";
interpreter = new BaZicInterpreter(parser.Parse(inputCode, true).Program);
await interpreter.StartDebugAsync(true);
result = interpreter.GetStateChangedHistoryString();
Assert.IsTrue(result.Contains("[Error] Unexpected and unmanaged error has been detected : Operator '+' cannot be applied to operands of type 'bool' and 'bool'"));
}
public async Task ProgramInterpreterInvokeExternMethod3()
{
var parser = new BaZicParser();
var inputCode =
@"EXTERN FUNCTION Main(args[])
AWAIT MethodAsync(345, 5.0)
END FUNCTION
EXTERN FUNCTION Method1(arg)
RETURN arg
END FUNCTION
ASYNC FUNCTION MethodAsync(value, timeToWait)
VARIABLE var1 = AWAIT System.Threading.Tasks.Task.Delay(System.TimeSpan.FromSeconds(timeToWait))
RETURN value
END FUNCTION";
using (var interpreter = new BaZicInterpreter(parser.Parse(inputCode, false).Program))
{
var t = interpreter.StartDebugAsync(true);
var result = await interpreter.InvokeMethod(true, "Method1", true, 123);
Assert.AreEqual(123, result);
// Idle is expected because InvokeMethod waits that the main
// thread (used by Main()) is free before running. So the async
// function is complete before reaching this assert.
Assert.AreEqual(BaZicInterpreterState.Idle, interpreter.State);
await interpreter.Stop();
Assert.AreEqual(BaZicInterpreterState.Stopped, interpreter.State);
}
}
public async Task BaZicInterpreterWithUiProgramBadControlAccessorUse()
{
var parser = new BaZicParser();
var inputCode =
@"
EXTERN FUNCTION Main(args[])
Button1.Content = ""Hello""
END FUNCTION";
var xamlCode = @"
<Window xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation"" Name=""Window"">
<Grid>
<Button Name=""Button1""/>
</Grid>
</Window>";
var bazicProgram = (BaZicUiProgram)parser.Parse(inputCode, xamlCode, optimize: true).Program;
var interpreter = new BaZicInterpreter(bazicProgram);
await interpreter.StartDebugAsync(true);
var exception = interpreter.Error.Exception;
Assert.AreEqual("The variable 'Button1' does not exist or is not accessible.", exception.Message);
}
private EntryPointMethod GetEntryPointMethod()
{
var entryPoints = _program.Methods.OfType <EntryPointMethod>().ToList();
if (entryPoints.Count == 0)
{
BaZicInterpreter.ChangeState(this, new MissingEntryPointMethodException());
return(null);
}
else if (entryPoints.Count > 1)
{
BaZicInterpreter.ChangeState(this, new SeveralEntryPointMethodException(), entryPoints.Last());
return(null);
}
var entryPoint = entryPoints.Single();
if (entryPoint.Arguments.Count != 1)
{
BaZicInterpreter.ChangeState(this, new BadArgumentException(L.BaZic.Parser.Statements.UniqueArgumentEntryPoint), entryPoint);
return(null);
}
else if (!entryPoint.Arguments.Single().IsArray)
{
BaZicInterpreter.ChangeState(this, new BadArgumentException(L.BaZic.Parser.Statements.EntryPointArgumentArrayExpected), entryPoint.Arguments.Single());
return(null);
}
return(entryPoint);
}
/// <summary>
/// Retrieves the parent interpreter of the current executed method.
/// </summary>
/// <param name="includeThis">(optional) Defines whether the search must include the current interpreter.</param>
/// <param name="throwIfNotFound">(optional) Defines whether an error must be thrown if the parent interpreter is not found.</param>
/// <returns>The parent <see cref="MethodInterpreter"/></returns>
internal MethodInterpreter GetParentMethodInterpreter(bool includeThis = false, bool throwIfNotFound = true)
{
if (includeThis && this is MethodInterpreter thisMethodInterpreter)
{
return(thisMethodInterpreter);
}
var parentInterpreter = ParentInterpreter;
while (parentInterpreter != null)
{
if (parentInterpreter is MethodInterpreter methodInterpreter)
{
return(methodInterpreter);
}
parentInterpreter = parentInterpreter.ParentInterpreter;
}
if (throwIfNotFound)
{
BaZicInterpreter.ChangeState(this, new InternalException(L.BaZic.Runtime.Interpreters.Interpreter.ParentMethodNotFound));
}
return(null);
}
public async Task ProgramInterpreterInvokeExternMethod4()
{
var parser = new BaZicParser();
var inputCode =
@"EXTERN FUNCTION Main(args[])
END FUNCTION
EXTERN FUNCTION Method1(arg)
RETURN arg
END FUNCTION";
using (var interpreter = new BaZicInterpreter(parser.Parse(inputCode, false).Program))
{
var tempFile = Path.Combine(Path.GetTempPath(), "BaZic_Bin", Path.GetFileNameWithoutExtension(Path.GetTempFileName()) + ".exe");
var errors = await interpreter.Build();
Assert.IsNull(errors);
var result = await interpreter.InvokeMethod(true, "Method1", true, 123);
Assert.AreEqual(123, result);
Assert.AreEqual(BaZicInterpreterState.Idle, interpreter.State);
}
}
/// <summary>
/// Assigns the specified value to a property.
/// </summary>
/// <param name="propertyReference">The reference to the property to set.</param>
/// <param name="value">The value to assign.</param>
private void AssignProperty(PropertyReferenceExpression propertyReference, object value)
{
if (string.IsNullOrWhiteSpace(propertyReference.PropertyName?.Identifier))
{
BaZicInterpreter.ChangeState(this, new NullValueException(L.BaZic.Runtime.Interpreters.Expressions.PropertyReferenceInterpreter.UndefinedName), propertyReference);
}
var targetObjectValue = ParentInterpreter.RunExpression(propertyReference.TargetObject);
if (ParentInterpreter.IsAborted)
{
return;
}
if (targetObjectValue == null)
{
BaZicInterpreter.ChangeState(this, new NullValueException(L.BaZic.Runtime.Interpreters.Expressions.PropertyReferenceInterpreter.NullValue), propertyReference);
return;
}
if (propertyReference.TargetObject is ClassReferenceExpression && targetObjectValue is Type)
{
BaZicInterpreter.Reflection.SetStaticProperty((Type)targetObjectValue, propertyReference.PropertyName.Identifier, value);
}
else if (targetObjectValue is FrameworkElement)
{
BaZicInterpreter.ProgramInterpreter.UIDispatcher.Invoke(() =>
{
BaZicInterpreter.Reflection.SetProperty(targetObjectValue, propertyReference.PropertyName.Identifier, value);
}, System.Windows.Threading.DispatcherPriority.Background);
}
else
{
BaZicInterpreter.Reflection.SetProperty(targetObjectValue, propertyReference.PropertyName.Identifier, value);
}
}
public async Task ProgramInterpreterTestEntryPointMethod()
{
var parser = new BaZicParser();
var inputCode =
@"FUNCTION Method1()
END FUNCTION";
using (var interpreter = new BaZicInterpreter(parser.Parse(inputCode, false).Program))
{
await interpreter.StartDebugAsync(true);
Assert.AreEqual(BaZicInterpreterState.Idle, interpreter.State);
}
inputCode =
@"EXTERN FUNCTION Main(args[])
END FUNCTION
EXTERN FUNCTION Main(args[])
END FUNCTION";
using (var interpreter = new BaZicInterpreter(parser.Parse(inputCode, true).Program))
{
await interpreter.StartDebugAsync(true);
Assert.IsInstanceOfType(interpreter.Error.Exception, typeof(SeveralEntryPointMethodException));
}
}
public async Task ProgramInterpreterInvokeExternMethod5()
{
var parser = new BaZicParser();
var inputCode =
@"EXTERN FUNCTION Main(args[])
END FUNCTION
FUNCTION Method1(arg)
RETURN arg
END FUNCTION";
using (var interpreter = new BaZicInterpreter(parser.Parse(inputCode, false).Program))
{
var tempFile = Path.Combine(Path.GetTempPath(), "BaZic_Bin", Path.GetFileNameWithoutExtension(Path.GetTempFileName()) + ".exe");
var errors = await interpreter.Build();
Assert.IsNull(errors);
var result = await interpreter.InvokeMethod(true, "Method1", true, 123);
Assert.AreEqual(null, result);
Assert.AreEqual("Unexpected and unmanaged error has been detected : The method 'Method1' does not exist in the type 'BaZicProgramReleaseMode.Program'.", interpreter.Error.Exception.Message);
Assert.AreEqual(BaZicInterpreterState.StoppedWithError, interpreter.State);
}
}
public async Task BaZicCompile()
{
var inputCode =
@"EXTERN FUNCTION Main(args[])
VARIABLE var1 = 1
VARIABLE Var1 = 2
VARIABLE result = var1 + Var1
System.Console.WriteLine(result.ToString())
RETURN result
END FUNCTION";
using (var interpreter = new BaZicInterpreter(inputCode, false))
{
var mscorlib = AssemblyInfoHelper.GetAssemblyDetailsFromNameOrLocation(typeof(object).Assembly.FullName);
var baZicCoreTest = AssemblyInfoHelper.GetAssemblyDetailsFromNameOrLocation(typeof(LogMock).Assembly.Location);
interpreter.SetDependencies(mscorlib, baZicCoreTest);
var tempFile = Path.Combine(Path.GetTempPath(), "BaZic_Bin", Path.GetFileNameWithoutExtension(Path.GetTempFileName()) + ".exe");
var errors = await interpreter.Build(Core.Enums.BaZicCompilerOutputType.ConsoleApp, tempFile);
Assert.IsNull(errors);
Assert.IsTrue(File.Exists(tempFile));
Assert.IsTrue(File.Exists(tempFile.Replace(".exe", ".pdb")));
Assert.IsTrue(File.Exists(Path.Combine(Path.GetTempPath(), "BaZic_Bin", "BaZic.Core.Tests.dll")));
File.Delete(tempFile);
File.Delete(tempFile.Replace(".exe", ".pdb"));
File.Delete(Path.Combine(Path.GetTempPath(), "BaZic_Bin", "BaZic.Core.Tests.dll"));
Directory.Delete(Path.Combine(Path.GetTempPath(), @"BaZic_Bin"), true);
}
}
public async Task ProgramInterpreterInvokeExternMethod7()
{
var parser = new BaZicParser();
var inputCode =
@"EXTERN FUNCTION Main(args[])
END FUNCTION
EXTERN ASYNC FUNCTION Method1(arg)
VARIABLE var1 = AWAIT System.Threading.Tasks.Task.Delay(System.TimeSpan.FromSeconds(3.0))
RETURN arg
END FUNCTION";
using (var interpreter = new BaZicInterpreter(parser.Parse(inputCode, false).Program))
{
var errors = await interpreter.Build();
Assert.IsNull(errors);
var t = interpreter.StartReleaseAsync(true);
var result = (Task)interpreter.InvokeMethod(true, "Method1", true, 123);
Assert.AreEqual(TaskStatus.WaitingForActivation, result.Status);
await Task.Delay(5000);
Assert.AreEqual(TaskStatus.RanToCompletion, result.Status);
Assert.AreEqual(123, ((dynamic)result).Result);
Assert.AreEqual(BaZicInterpreterState.Idle, interpreter.State);
await interpreter.Stop();
Assert.AreEqual(BaZicInterpreterState.Stopped, interpreter.State);
}
}
/// <summary>
/// Execute the statements of the block.
/// </summary>
internal void Run()
{
_executionCursor = 0;
while (_executionCursor < _statements.Count)
{
RunStatement(_statements[_executionCursor]);
BaZicInterpreter.AttemptPauseIfRequired(this);
if (IsAborted || State.ExitMethod || State.ExitIteration || State.ExitBlockBecauseOfLabelJump)
{
break;
}
_executionCursor++;
}
var parentMethodInterpreter = GetParentMethodInterpreter();
foreach (var variable in Variables)
{
if (parentMethodInterpreter.DebugCallInfo.Variables.Remove(variable))
{
variable.Dispose();
}
}
}
/// <summary>
/// Look for the specified variable currently in memory based on its unique ID.
/// </summary>
/// <param name="variableId">The unique ID that represents the variable.</param>
/// <param name="variableName">The friendly name of the variable.</param>
/// <param name="throwIfNotFound">(optional) Indicates whether an exception must be thrown if the variable is not found. By default, this argument is True.</param>
/// <param name="searchInParents">Defines whether finding a variable can be performed in the parent interpreters.</param>
/// <returns>Returns the variable if it has been found, otherwise, null or throws an exception.</returns>
internal Variable GetVariable(Guid variableId, string variableName, bool throwIfNotFound = true, bool searchInParents = true)
{
var interpreter = this;
do
{
var variable = interpreter.Variables.FirstOrDefault(v => v.Id == variableId);
if (variable != null)
{
return(variable);
}
if (searchInParents)
{
interpreter = interpreter.ParentInterpreter;
}
} while (searchInParents && interpreter != null);
if (throwIfNotFound)
{
BaZicInterpreter.ChangeState(this, new VariableNotFoundException(variableName));
}
return(null);
}
/// <summary>
/// Set the value of the specified variable currently in memory based on its unique ID.
/// </summary>
/// <param name="variableRef">The reference to the variable to set.</param>
/// <param name="value">The value to give to the variable</param>
internal void SetVariable(VariableReferenceExpression variableRef, object value)
{
var variable = GetVariable(variableRef.VariableDeclarationID, variableRef.Name.Identifier, true);
if (IsAborted)
{
return;
}
var valueInfo = ValueInfo.GetValueInfo(value);
if (!valueInfo.IsNull)
{
if (variable.IsArray && !valueInfo.IsArray)
{
BaZicInterpreter.ChangeState(this, new NotAssignableException(L.BaZic.Runtime.Interpreters.Interpreter.FormattedArrayExpected(variableRef.Name)), variableRef);
return;
}
else if (!variable.IsArray && valueInfo.IsArray)
{
BaZicInterpreter.ChangeState(this, new NotAssignableException(L.BaZic.Runtime.Interpreters.Interpreter.FormattedNotArrayExpected(variableRef.Name)), variableRef);
return;
}
}
variable.SetValue(value, valueInfo);
if (BaZicInterpreter.Verbose)
{
VerboseLog(L.BaZic.Runtime.Interpreters.Interpreter.FormattedVariableSetted(variable.Name, variable));
}
}
/// <inheritdoc/>
internal override void Run()
{
if (!ParentInterpreter.State.IsInIteration)
{
BaZicInterpreter.ChangeState(this, new IncoherentStatementException(L.BaZic.Runtime.Interpreters.Statements.BreakInterpreter.Illegal), Statement);
}
ParentInterpreter.State.ExitIteration = true;
}
public async Task PropertyReferenceInterpreter()
{
var parser = new BaZicParser();
var inputCode =
@"EXTERN FUNCTION Main(args[])
VARIABLE var1 = ""Hello"".Length
END FUNCTION";
var interpreter = new BaZicInterpreter(parser.Parse(inputCode, true).Program);
await interpreter.StartDebugAsync(true);
var expectedLogs = @"[State] Ready
[State] Preparing
[Log] Reference assembly 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' loaded in the application domain.
[Log] Reference assembly 'System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' loaded in the application domain.
[Log] Reference assembly 'System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' loaded in the application domain.
[Log] Reference assembly 'System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' loaded in the application domain.
[Log] Reference assembly 'Microsoft.CSharp, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' loaded in the application domain.
[Log] Reference assembly 'PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35' loaded in the application domain.
[Log] Reference assembly 'PresentationCore, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35' loaded in the application domain.
[Log] Reference assembly 'WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35' loaded in the application domain.
[Log] Declaring global variables.
[Log] Program's entry point detected.
[State] Running
[Log] Preparing to invoke the method 'Main'.
[Log] Executing the argument values of the method.
[Log] Executing an expression of type 'ArrayCreationExpression'.
[Log] The expression returned the value 'BaZicProgramReleaseMode.ObservableDictionary' (BaZicProgramReleaseMode.ObservableDictionary (length: 0)).
[Log] Invoking the synchronous method 'Main'.
[Log] Variable 'args' declared. Default value : {Null}
[Log] Variable 'args' value set to : BaZicProgramReleaseMode.ObservableDictionary (BaZicProgramReleaseMode.ObservableDictionary (length: 0))
[Log] Registering labels.
[Log] Executing a statement of type 'VariableDeclaration'.
[Log] Executing an expression of type 'PropertyReferenceExpression'.
[Log] Getting the property ''Hello' (type:System.String).Length'.
[Log] Executing an expression of type 'PrimitiveExpression'.
[Log] The expression returned the value 'Hello' (System.String).
[Log] The expression returned the value '5' (System.Int32).
[Log] Variable 'var1' declared. Default value : 5 (System.Int32)
[Log] End of the execution of the method 'Main'. Returned value : ({Null})
[State] Idle
";
Assert.AreEqual(expectedLogs, interpreter.GetStateChangedHistoryString());
inputCode =
@"EXTERN FUNCTION Main(args[])
VARIABLE var1 = ""Hello"".length
END FUNCTION";
interpreter = new BaZicInterpreter(parser.Parse(inputCode, true).Program);
await interpreter.StartDebugAsync(true);
Assert.AreEqual("Unable to access to the property 'length' of the type 'System.String'.", interpreter.StateChangedHistory.Last().Error.Exception.InnerException.Message);
}
public async Task ProgramInterpreterInvokeExternMethodUI12()
{
var parser = new BaZicParser();
var inputCode =
@"
VARIABLE globVar = 1
EXTERN FUNCTION Main(args[])
END FUNCTION
EXTERN FUNCTION Method1()
DO WHILE TRUE
LOOP
END FUNCTION";
var xamlCode = @"
<Window xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation"" Name=""Window1"">
<StackPanel>
<Button Name=""Button1"" Content=""Hello""/>
</StackPanel>
</Window>";
using (var interpreter = new BaZicInterpreter(inputCode, xamlCode))
{
var t = interpreter.StartDebugAsync(true);
t = interpreter.InvokeMethod(true, "Method1", true);
await Task.Delay(3000);
Assert.AreEqual(BaZicInterpreterState.Running, interpreter.State);
await interpreter.Stop();
Assert.AreEqual(BaZicInterpreterState.Stopped, interpreter.State);
}
using (var interpreter = new BaZicInterpreter(inputCode, xamlCode))
{
var errors = await interpreter.Build();
Assert.IsNull(errors);
var t = interpreter.StartReleaseAsync(true);
t = interpreter.InvokeMethod(true, "Method1", true);
await Task.Delay(10000);
Assert.AreEqual(BaZicInterpreterState.Running, interpreter.State);
await interpreter.Stop();
Assert.AreEqual(BaZicInterpreterState.Stopped, interpreter.State);
}
}
public async Task VariableReferenceInterpreter()
{
var parser = new BaZicParser();
var inputCode =
@"EXTERN FUNCTION Main(args[])
VARIABLE var1 = 1
VARIABLE var2 = var1
RETURN var2
END FUNCTION";
var interpreter = new BaZicInterpreter(parser.Parse(inputCode, true).Program);
await interpreter.StartDebugAsync(true);
var expectedLogs = @"[State] Ready
[State] Preparing
[Log] Reference assembly 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' loaded in the application domain.
[Log] Reference assembly 'System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' loaded in the application domain.
[Log] Reference assembly 'System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' loaded in the application domain.
[Log] Reference assembly 'System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' loaded in the application domain.
[Log] Reference assembly 'Microsoft.CSharp, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' loaded in the application domain.
[Log] Reference assembly 'PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35' loaded in the application domain.
[Log] Reference assembly 'PresentationCore, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35' loaded in the application domain.
[Log] Reference assembly 'WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35' loaded in the application domain.
[Log] Declaring global variables.
[Log] Program's entry point detected.
[State] Running
[Log] Preparing to invoke the method 'Main'.
[Log] Executing the argument values of the method.
[Log] Executing an expression of type 'ArrayCreationExpression'.
[Log] The expression returned the value 'BaZicProgramReleaseMode.ObservableDictionary' (BaZicProgramReleaseMode.ObservableDictionary (length: 0)).
[Log] Invoking the synchronous method 'Main'.
[Log] Variable 'args' declared. Default value : {Null}
[Log] Variable 'args' value set to : BaZicProgramReleaseMode.ObservableDictionary (BaZicProgramReleaseMode.ObservableDictionary (length: 0))
[Log] Registering labels.
[Log] Executing a statement of type 'VariableDeclaration'.
[Log] Executing an expression of type 'PrimitiveExpression'.
[Log] The expression returned the value '1' (System.Int32).
[Log] Variable 'var1' declared. Default value : 1 (System.Int32)
[Log] Executing a statement of type 'VariableDeclaration'.
[Log] Executing an expression of type 'VariableReferenceExpression'.
[Log] The expression returned the value '1' (System.Int32).
[Log] Variable 'var2' declared. Default value : 1 (System.Int32)
[Log] Executing a statement of type 'ReturnStatement'.
[Log] Executing an expression of type 'VariableReferenceExpression'.
[Log] The expression returned the value '1' (System.Int32).
[Log] Return : 1 (System.Int32)
[Log] A Return statement or Break statement or Exception has been detected or thrown. Exiting the current block of statements.
[Log] End of the execution of the method 'Main'. Returned value : 1 (System.Int32)
[State] Idle
";
Assert.AreEqual(expectedLogs, interpreter.GetStateChangedHistoryString());
await TestUtilities.TestAllRunningMode("1", inputCode);
}
/// <summary>
/// Invoke a public method accessible from outside of the interpreter (EXTERN FUNCTION).
/// </summary>
/// <param name="executionFlowId">A GUID that defines in which callstack is linked.</param>
/// <param name="methodName">The name of the method.</param>
/// <param name="awaitIfAsync">Await if the method is maked as asynchronous.</param>
/// <param name="args">The arguments to pass to the method.</param>
/// <returns>Returns the result of the invocation (a <see cref="Task"/> in the case of a not awaited asynchronous method, or the value returned by the method).</returns>
internal object InvokeMethod(Guid executionFlowId, string methodName, bool awaitIfAsync, Code.AbstractSyntaxTree.Expression[] args)
{
InitializeGlobalState();
BaZicInterpreter.CheckState(BaZicInterpreterState.Idle, BaZicInterpreterState.Stopped, BaZicInterpreterState.StoppedWithError);
var invokeExpression = new InvokeMethodExpression(methodName, awaitIfAsync).WithParameters(args);
BaZicInterpreter.ChangeState(this, new BaZicInterpreterStateChangeEventArgs(BaZicInterpreterState.Running));
return(new InvokeMethodInterpreter(BaZicInterpreter, this, invokeExpression, executionFlowId, true).Run());
}
public async Task MethodInterpreterAwait()
{
var parser = new BaZicParser();
var inputCode =
@"EXTERN FUNCTION Main(args[])
AWAIT Main(NEW [1, 2, 3])
END FUNCTION";
var interpreter = new BaZicInterpreter(parser.Parse(inputCode, true).Program);
await interpreter.StartDebugAsync(true);
Assert.AreEqual("Unable to await the method 'Main' because it is not marked as asynchronous.", interpreter.Error.Exception.Message);
}
public async Task InvokeCoreMethodInterpreter3()
{
var parser = new BaZicParser();
var inputCode =
@"EXTERN FUNCTION Main(args[])
VARIABLE var1 = 123.toString()
END FUNCTION";
var interpreter = new BaZicInterpreter(parser.Parse(inputCode, true).Program);
await interpreter.StartDebugAsync(true);
Assert.AreEqual("The method 'toString' does not exist in the type 'System.Int32'.", interpreter.StateChangedHistory.Last().Error.Exception.InnerException.Message);
}
public async Task BaZicInterpreterAssembliesLoad()
{
var program = new BaZicProgram();
program.WithAssemblies("FakeAssembly, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
var interpreter = new BaZicInterpreter(program);
await interpreter.StartDebugAsync(true);
var exception = (LoadAssemblyException)interpreter.Error.Exception;
Assert.AreEqual("FakeAssembly, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", exception.AssemblyPath);
Assert.AreEqual("Could not load file or assembly 'FakeAssembly, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' or one of its dependencies. The system cannot find the file specified.", exception.InnerException.Message);
}
/// <inheritdoc/>
internal override void Run()
{
var expression = ParentInterpreter.RunExpression(Statement.Expression);
var exception = expression as Exception;
if (exception == null)
{
BaZicInterpreter.ChangeState(this, new BadTypeException(L.BaZic.Runtime.Interpreters.Statements.ThrowInterpreter.FormattedExceptionExpected(typeof(Exception).FullName)));
return;
}
throw exception;
}
public async Task BaZicInterpreterDebugInformation()
{
var parser = new BaZicParser();
var inputCode =
@"
VARIABLE globVar = ""Hello""
EXTERN FUNCTION Main(args[])
RETURN SimpleRecursivity(5)
END FUNCTION
FUNCTION SimpleRecursivity(num)
IF num < 1 THEN
BREAKPOINT
RETURN num
ELSE
RETURN SimpleRecursivity(num - 1)
END IF
END FUNCTION";
var interpreter = new BaZicInterpreter(parser.Parse(inputCode, true).Program);
var t = interpreter.StartDebugAsync(true);
await Task.Delay(2000);
var debugInfo = interpreter.DebugInfos;
Assert.IsNull(debugInfo);
Assert.AreEqual(BaZicInterpreterState.Pause, interpreter.State);
interpreter = new BaZicInterpreter(parser.Parse(inputCode, false).Program);
t = interpreter.StartDebugAsync(true);
Assert.IsNull(interpreter.DebugInfos);
await Task.Delay(2000);
debugInfo = interpreter.DebugInfos;
Assert.IsNotNull(debugInfo);
Assert.AreEqual(BaZicInterpreterState.Pause, interpreter.State);
Assert.AreEqual(7, debugInfo.CallStack.Count);
Assert.AreEqual(1, debugInfo.GlobalVariables.Count);
Assert.AreEqual("SimpleRecursivity", debugInfo.CallStack.First().InvokeMethodExpression.MethodName.Identifier);
Assert.AreEqual("num", debugInfo.CallStack.First().Variables.Single().Name);
Assert.AreEqual(0, debugInfo.CallStack.First().Variables.Single().Value);
Assert.AreEqual(5, debugInfo.CallStack[5].Variables.Single().Value);
}
internal static async Task RunDebugOptimizedVerbose(List <string> resultReceiver, string inputBaZicCode, string xamlCode, params object[] args)
{
using (var interpreter = new BaZicInterpreter(inputBaZicCode, xamlCode, optimize: true))
{
interpreter.SetDependencies("PresentationCore, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
await interpreter.StartDebugAsync(true, args);
if (interpreter.Error != null)
{
throw interpreter.Error.Exception;
}
resultReceiver.Add(interpreter.ProgramResult?.ToString());
}
}
public async Task BinaryOperatorInterpreterDivision()
{
var parser = new BaZicParser();
var inputCode =
@"EXTERN FUNCTION Main(args[])
VARIABLE var1 = 2 / 0 # Should fail
END FUNCTION";
var interpreter = new BaZicInterpreter(parser.Parse(inputCode, true).Program);
await interpreter.StartDebugAsync(true);
var result = interpreter.GetStateChangedHistoryString();
Assert.IsTrue(result.Contains("[Error] Attempted to divide by zero."));
}
/// <inheritdoc/>
internal override object Run()
{
var parentBlockInterpreter = ParentInterpreter as BlockInterpreter;
if (parentBlockInterpreter == null)
{
BaZicInterpreter.ChangeState(this, new InternalException(L.BaZic.Runtime.Interpreters.Expressions.ExceptionInterpreter.BlockExpected), Expression);
}
if (parentBlockInterpreter.CaughtException == null)
{
BaZicInterpreter.ChangeState(this, new IncoherentStatementException(L.BaZic.Runtime.Interpreters.Expressions.ExceptionInterpreter.TryCatchExpected), Expression);
}
return(parentBlockInterpreter.CaughtException);
}
public async Task ProgramInterpreterInvokeExternMethod11()
{
var parser = new BaZicParser();
var inputCode =
@"
VARIABLE globVar = 1
EXTERN FUNCTION Main(args[])
DO WHILE TRUE
LOOP
END FUNCTION
EXTERN FUNCTION Method1()
RETURN TRUE
END FUNCTION";
using (var interpreter = new BaZicInterpreter(parser.Parse(inputCode, false).Program))
{
var t = interpreter.StartDebugAsync(true);
t = interpreter.InvokeMethod(true, "Method1", true);
await Task.Delay(3000);
Assert.AreEqual(BaZicInterpreterState.Running, interpreter.State);
await interpreter.Stop();
Assert.AreEqual(BaZicInterpreterState.Stopped, interpreter.State);
}
using (var interpreter = new BaZicInterpreter(parser.Parse(inputCode, false).Program))
{
var t = interpreter.StartReleaseAsync(true);
t = interpreter.InvokeMethod(true, "Method1", true);
await Task.Delay(10000);
Assert.AreEqual(BaZicInterpreterState.Running, interpreter.State);
await interpreter.Stop();
Assert.AreEqual(BaZicInterpreterState.Stopped, interpreter.State);
}
}
