public override void Setup()
{
base.Setup();
runner = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
}
public override void Setup()
{
// Specify some of the requirements of IDE.
fsr = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
}
internal static ProtoCore.Core DebugRunnerRunOnly(string code, out RuntimeCore runtimeCore)
{
ProtoCore.Core core;
DebugRunner fsr;
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.GCTempVarsOnDebug = false;
string testPath = @"..\..\..\test\Engine\ProtoTest\ImportFiles\";
options.IncludeDirectories.Add(testPath);
core = new ProtoCore.Core(options);
core.Compilers.Add(ProtoCore.Language.Associative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.Imperative, new ProtoImperative.Compiler(core));
fsr = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
//Run
fsr.PreStart(code);
DebugRunner.VMState vms = null;
vms = fsr.Run();
runtimeCore = fsr.runtimeCore;
return(core);
}
internal static ProtoCore.Core DebugRunnerRunOnly(string code)
{
ProtoCore.Core core;
DebugRunner fsr;
ProtoScript.Config.RunConfiguration runnerConfig;
string testPath = @"..\..\..\Scripts\Debugger\";
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
core = new ProtoCore.Core(options);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
runnerConfig = new ProtoScript.Config.RunConfiguration();
runnerConfig.IsParrallel = false;
fsr = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
//Run
fsr.PreStart(code, runnerConfig);
DebugRunner.VMState vms = null;
vms = fsr.Run();
return(core);
}
public void TestCyclicPointer01()
{
DebugRunner fsr = new DebugRunner(core);
// Execute and verify the main script in a debug session
fsr.PreStart(
@"
class Obj
{
x : var;
constructor Obj()
{
x = null;
}
}
p = Obj.Obj();
p.x = p; // Assign the member x to its own 'this' pointer. This creates a cycle
m = p.x;
");
DebugRunner.VMState vms = fsr.StepOver();
vms = fsr.StepOver();
vms = fsr.StepOver();
// Test the heap contains a cycle
Assert.IsTrue(ProtoCore.Utils.HeapUtils.IsHeapCyclic(core));
}
public void InheritedClassDoingConstructionCall()
{
var type = assemblyWeaver.Assembly.GetType("InheritedClassDoingConstructionCall");
var message = DebugRunner.CaptureDebug(() => Activator.CreateInstance(type));
Assert.AreEqual(1, message.Count);
Assert.IsTrue(message[0].StartsWith("InheritedClassDoingConstructionCall.ctor "), message[0]);
}
public void MethodWithReturn()
{
var type = assemblyWeaver.Assembly.GetType("MiscMethods");
var instance = (dynamic)Activator.CreateInstance(type);
var message = DebugRunner.CaptureDebug(() => instance.MethodWithReturn());
Assert.AreEqual(1, message.Count);
Assert.IsTrue(message.First().StartsWith("MiscMethods.MethodWithReturn "));
}
public void GenericClassWithMethod()
{
var type = assemblyWeaver.Assembly.GetType("GenericClassWithMethod`1[[System.String, mscorlib]]");
var instance = (dynamic)Activator.CreateInstance(type);
var message = DebugRunner.CaptureDebug(() => instance.Method());
Assert.AreEqual(1, message.Count);
Assert.IsTrue(message.First().StartsWith("GenericClassWithMethod`1.Method "));
}
public void ClassWithAttribute()
{
var type = assemblyWeaver.Assembly.GetType("ClassWithAttribute");
var instance = (dynamic)Activator.CreateInstance(type);
var message = DebugRunner.CaptureDebug(() => instance.Method());
Assert.AreEqual(1, message.Count);
Assert.IsTrue(message.First().StartsWith("ClassWithAttribute.Method "));
}
public void ClassWithConstructor()
{
var type = assemblyWeaver.Assembly.GetType("ClassWithConstructor");
var message = DebugRunner.CaptureDebug(() => Activator.CreateInstance(type));
Assert.AreEqual(2, message.Count);
Assert.IsTrue(message[0].StartsWith("ClassWithConstructor.cctor "));
Assert.IsTrue(message[1].StartsWith("ClassWithConstructor.ctor "));
}
public override void Setup()
{
// Specify some of the requirements of IDE.
runnerConfig = new ProtoScript.Config.RunConfiguration();
runnerConfig.IsParrallel = false;
fsr = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
}
public override void Setup()
{
base.Setup();
runconfig = new ProtoScript.Config.RunConfiguration();
runconfig.IsParrallel = false;
runner = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
}
public void InheritedClass()
{
var type = assemblyWeaver.Assembly.GetType("InheritedClass");
var message = DebugRunner.CaptureDebug(() => Activator.CreateInstance(type));
Assert.AreEqual(1, message.Count);
var first = message.First();
Assert.IsTrue(first.StartsWith("InheritedClass.ctor "), first);
}
public void ClassWithAsyncMethodWithFastPath(bool recurse)
{
var type = assemblyWeaver.Assembly.GetType("ClassWithAsyncMethod");
var instance = (dynamic)Activator.CreateInstance(type);
var message = DebugRunner.CaptureDebug(() =>
{
var task = (Task)instance.MethodWithFastPathAsync(recurse);
task.Wait();
});
Assert.AreEqual(recurse ? 2 : 1, message.Count);
Assert.IsTrue(message.First().StartsWith("ClassWithAsyncMethod.MethodWithFastPathAsync "));
}
public void ClassWithAsyncMethod()
{
var type = assemblyWeaver.Assembly.GetType("ClassWithCompilerGeneratedTypes");
var instance = (dynamic)Activator.CreateInstance(type);
var message = DebugRunner.CaptureDebug(() =>
{
var task = (Task)instance.AsyncMethod();
task.Wait();
});
Assert.AreEqual(1, message.Count);
Assert.IsTrue(message.First().StartsWith("ClassWithCompilerGeneratedTypes.AsyncMethod "));
}
public void ClassWithYieldMethod()
{
var type = assemblyWeaver.Assembly.GetType("ClassWithCompilerGeneratedTypes");
var instance = (dynamic)Activator.CreateInstance(type);
var message = DebugRunner.CaptureDebug(() =>
{
var task = (IEnumerable <string>)instance.YieldMethod();
task.ToList();
});
Assert.AreEqual(0, message.Count);
//TODO: support yield
//Assert.IsTrue(message.First().StartsWith("ClassWithCompilerGeneratedTypes.YieldMethod "));
}
public void Setup()
{
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
core_ = new ProtoCore.Core(options);
core_.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core_));
core_.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core_));
runconfig_ = new ProtoScript.Config.RunConfiguration();
runconfig_.IsParrallel = false;
runner_ = new DebugRunner(core_);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
}
public void Setup()
{
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
core = new ProtoCore.Core(options);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
runnerConfig = new ProtoScript.Config.RunConfiguration();
runnerConfig.IsParrallel = false;
fsr = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
}
private bool SetupDebugRunner(string scriptPath)
{
if (string.IsNullOrEmpty(scriptPath))
{
return(false); // No script to execute.
}
if (File.Exists(scriptPath) == false)
{
return(false); // File does not exist.
}
Logger.LogInfo("SetupDebugRunner", "Init");
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
SetupCommonRunner(true);
RunConfiguration runnerConfig = new RunConfiguration();
runnerConfig.IsParrallel = false;
#if DEBUG
var dumpBytecCodeFlag = this.core.Options.DumpByteCode;
var verboseFlag = this.core.Options.Verbose;
var prevAsmOutput = this.core.AsmOutput;
this.core.Options.DumpByteCode = true;
this.core.Options.Verbose = true;
this.ByteCodeStream = new MemoryStream();
this.core.AsmOutput = new StreamWriter(this.ByteCodeStream);
#endif
debugRunner = new DebugRunner(this.core);
bool startSucceeded = debugRunner.LoadAndPreStart(scriptPath, runnerConfig);
#if DEBUG
this.core.Options.DumpByteCode = dumpBytecCodeFlag;
this.core.Options.Verbose = verboseFlag;
this.core.AsmOutput.Close();
this.core.AsmOutput = prevAsmOutput == null ? Console.Out : prevAsmOutput;
#endif
Logger.LogPerf("SetupDebugRunner", sw.ElapsedMilliseconds + " ms");
return(startSucceeded);
}
internal static ProtoCore.Core DebugRunnerStepOver(string code, out RuntimeCore runtimeCore)
{
//Internal setup
ProtoCore.Core core;
DebugRunner fsr;
ProtoScript.Config.RunConfiguration runnerConfig;
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
options.GCTempVarsOnDebug = false;
string testPath = @"..\..\..\test\Engine\ProtoTest\ImportFiles\";
options.IncludeDirectories.Add(testPath);
core = new ProtoCore.Core(options);
core.Compilers.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Compiler(core));
core.Compilers.Add(ProtoCore.Language.kImperative, new ProtoImperative.Compiler(core));
runnerConfig = new ProtoScript.Config.RunConfiguration();
runnerConfig.IsParrallel = false;
fsr = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
CLRModuleType.ClearTypes();
//Run
fsr.PreStart(code, runnerConfig);
DebugRunner.VMState vms = null;
while (!fsr.isEnded)
{
vms = fsr.StepOver();
}
runtimeCore = fsr.runtimeCore;
return(core);
}
public void ClassWithAsyncMethod()
{
var type = assemblyWeaver.Assembly.GetType("ClassWithAsyncMethod");
var instance = (dynamic)Activator.CreateInstance(type);
DebugRunner.CaptureDebug(() =>
{
var task = (Task)instance.MethodWithAwaitAsync();
task.Wait();
});
var methodBases = GetMethodInfoField();
Assert.AreEqual(1, methodBases.Count);
var methodBase = methodBases.First();
Assert.AreEqual(methodBase.Name, "MethodWithAwaitAsync");
}
public void ClassWithAsyncMethodThatThrowsException()
{
var type = assemblyWeaver.Assembly.GetType("ClassWithAsyncMethod");
var instance = (dynamic)Activator.CreateInstance(type);
var message = DebugRunner.CaptureDebug(() =>
{
try
{
var task = (Task)instance.MethodWithAwaitAndExceptionAsync();
task.Wait();
}
catch (Exception)
{
// Expected
}
});
Assert.AreEqual(1, message.Count);
Assert.IsTrue(message.First().StartsWith("ClassWithAsyncMethod.MethodWithAwaitAndExceptionAsync "));
}
public void ClassWithAsyncMethodWithFastPath(bool recurse)
{
var type = assemblyWeaver.Assembly.GetType("ClassWithAsyncMethod");
var instance = (dynamic)Activator.CreateInstance(type);
DebugRunner.CaptureDebug(() =>
{
var task = (Task)instance.MethodWithFastPathAsync(recurse);
task.Wait();
});
var methodBases = GetMethodInfoField();
// Interceptor can't deal with 2 test cases
//Assert.AreEqual(recurse ? 2 : 1, methodBases.Count);
var methodBase = methodBases.Last();
Assert.AreEqual("MethodWithFastPathAsync", methodBase.Name);
}
private void CleanUpRunners()
{
Logger.LogInfo("DetachFromDebugger", "Detach");
// Clear up all watch related data members.
this.workerParams.CurrentVmState = null;
this.currentWatchedMirror = null;
this.currentWatchedStackValue = null;
if (null != scriptRunner)
{
scriptRunner = null;
}
if (null != debugRunner)
{
debugRunner.Shutdown();
debugRunner = null;
}
if (null != internalWorker)
{
// @TODO(Ben): Perhaps cancellation is needed?
internalWorker = null;
}
//Fix DG-1464973 Sprint25: rev 3444 : Multiple import issue - dispose core after execution
//Core Cleanup should happen only after execution has finished,
//DebugRunner is ShutDown.
if (null != this.core)
{
this.core.Cleanup();
this.core = null;
}
workerParams.ResetStates();
SetExecutionState(ExecutionStateChangedEventArgs.States.None);
}
public void ClassWithAsyncMethodThatThrowsException()
{
var type = assemblyWeaver.Assembly.GetType("ClassWithAsyncMethod");
var instance = (dynamic)Activator.CreateInstance(type);
DebugRunner.CaptureDebug(() =>
{
try
{
var task = (Task)instance.MethodWithAwaitAndExceptionAsync();
task.Wait();
}
catch (Exception)
{
// Expected
}
});
var methodBases = GetMethodInfoField();
var methodBase = methodBases.Last();
Assert.AreEqual(methodBase.Name, "MethodWithAwaitAndExceptionAsync");
}
internal static void DebugRunnerStepIn(string includePath, string code, /*string logFile*/ Dictionary <int, List <string> > map, bool watchNestedMode = false)
{
//Internal setup
ProtoCore.Core core;
DebugRunner fsr;
ProtoScript.Config.RunConfiguration runnerConfig;
// Specify some of the requirements of IDE.
var options = new ProtoCore.Options();
options.ExecutionMode = ProtoCore.ExecutionMode.Serial;
options.SuppressBuildOutput = false;
options.GCTempVarsOnDebug = false;
// Cyclic dependency threshold is lowered from the default (2000)
// as this causes the test framework to be painfully slow
options.kDynamicCycleThreshold = 5;
// Pass the absolute path so that imported filepaths can be resolved
// in "FileUtils.GetDSFullPathName()"
if (!String.IsNullOrEmpty(includePath))
{
includePath = Path.GetDirectoryName(includePath);
options.IncludeDirectories.Add(includePath);
}
core = new ProtoCore.Core(options);
// Use the InjectionExecutive to overload POP and POPM
// as we still need the symbol names and line nos. in debug mode for comparisons
core.ExecutiveProvider = new InjectionExecutiveProvider();
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
runnerConfig = new ProtoScript.Config.RunConfiguration();
runnerConfig.IsParrallel = false;
fsr = new DebugRunner(core);
DLLFFIHandler.Register(FFILanguage.CSharp, new CSModuleHelper());
//Run
fsr.PreStart(code, runnerConfig);
//StreamReader log = new StreamReader(logFile);
//bool isPrevBreakAtPop = false;
int lineAtPrevBreak = -1;
string symbolName = null;
DebugRunner.VMState vms = null;
while (!fsr.isEnded)
{
vms = fsr.LastState;
OpCode opCode = OpCode.NONE;
DebugInfo debug = null;
if (vms != null)
{
// check if previous break is a POP
// if so, get the line no. and LHS
opCode = fsr.CurrentInstruction.opCode;
debug = fsr.CurrentInstruction.debug;
if (opCode == ProtoCore.DSASM.OpCode.POP)
{
//isPrevBreakAtPop = true;
lineAtPrevBreak = vms.ExecutionCursor.StartInclusive.LineNo;
}
}
DebugRunner.VMState currentVms = fsr.Step();
//if (isPrevBreakAtPop)
if (debug != null)
{
// Do not do the verification for imported DS files, for which the FilePath is non null
if (debug.Location.StartInclusive.SourceLocation.FilePath == null)
{
if (opCode == ProtoCore.DSASM.OpCode.POP)
{
VerifyWatch_Run(lineAtPrevBreak, core.DebugProps.CurrentSymbolName, core, map, watchNestedMode);
}
// if previous breakpoint was at a CALLR
else if (opCode == ProtoCore.DSASM.OpCode.CALLR)
{
if (core.DebugProps.IsPopmCall)
{
int ci = (int)currentVms.mirror.MirrorTarget.rmem.GetAtRelative(ProtoCore.DSASM.StackFrame.kFrameIndexClass).opdata;
VerifyWatch_Run(InjectionExecutive.callrLineNo, core.DebugProps.CurrentSymbolName, core, map, watchNestedMode, ci);
}
}
}
}
//isPrevBreakAtPop = false;
}
core.Cleanup();
}
