public void Union(AssemblyReferences obj)
{
Guard.AgainstNullArgument("obj", obj);
PathReferences.UnionWith(obj.PathReferences);
Assemblies.UnionWith(obj.Assemblies);
}
public ScriptResult Execute(string code, string[] scriptArgs, AssemblyReferences references, IEnumerable<string> namespaces,
ScriptPackSession scriptPackSession)
{
var debugLine = code.Substring(0, code.IndexOf(".lol\"") + 5);
code = code.Replace(debugLine, string.Empty).TrimStart();
var compiler = new LOLCodeCodeProvider();
var cparam = new CompilerParameters
{
GenerateInMemory = true,
MainClass = "Program",
OutputAssembly = "lolcode.dll"
};
cparam.ReferencedAssemblies.AddRange(references.PathReferences != null ? references.PathReferences.ToArray() : new string[0]);
var results = compiler.CompileAssemblyFromSource(cparam, code);
var x = results.CompiledAssembly.GetReferencedAssemblies();
var startupType = results.CompiledAssembly.GetType("Program", true, true);
var instance = Activator.CreateInstance(startupType, false);
var entryPoint = results.CompiledAssembly.EntryPoint;
var result = entryPoint.Invoke(instance, new object[] { });
return new ScriptResult(result);
}
public void Union(AssemblyReferences obj)
{
Guard.AgainstNullArgument("obj", obj);
PathReferences.UnionWith(obj.PathReferences);
Assemblies.UnionWith(obj.Assemblies);
}
public ScriptResult Execute(string code, string[] scriptArgs, AssemblyReferences references, IEnumerable<string> namespaces,
ScriptPackSession scriptPackSession)
{
Guard.AgainstNullArgument("references", references);
Guard.AgainstNullArgument("scriptPackSession", scriptPackSession);
references.PathReferences.UnionWith(scriptPackSession.References);
SessionState<Evaluator> sessionState;
if (!scriptPackSession.State.ContainsKey(SessionKey))
{
Logger.Debug("Creating session");
var context = new CompilerContext(new CompilerSettings
{
AssemblyReferences = references.PathReferences.ToList()
}, new ConsoleReportPrinter());
var evaluator = new Evaluator(context);
var allNamespaces = namespaces.Union(scriptPackSession.Namespaces).Distinct();
var host = _scriptHostFactory.CreateScriptHost(new ScriptPackManager(scriptPackSession.Contexts), scriptArgs);
MonoHost.SetHost((ScriptHost)host);
evaluator.ReferenceAssembly(typeof(MonoHost).Assembly);
evaluator.InteractiveBaseClass = typeof(MonoHost);
sessionState = new SessionState<Evaluator>
{
References = new AssemblyReferences(references.PathReferences, references.Assemblies),
Namespaces = new HashSet<string>(),
Session = evaluator
};
ImportNamespaces(allNamespaces, sessionState);
scriptPackSession.State[SessionKey] = sessionState;
}
else
{
Logger.Debug("Reusing existing session");
sessionState = (SessionState<Evaluator>)scriptPackSession.State[SessionKey];
var newReferences = sessionState.References == null ? references : references.Except(sessionState.References);
foreach (var reference in newReferences.PathReferences)
{
Logger.DebugFormat("Adding reference to {0}", reference);
sessionState.Session.LoadAssembly(reference);
}
sessionState.References = new AssemblyReferences(references.PathReferences, references.Assemblies);
var newNamespaces = sessionState.Namespaces == null ? namespaces : namespaces.Except(sessionState.Namespaces);
ImportNamespaces(newNamespaces, sessionState);
}
Logger.Debug("Starting execution");
var result = Execute(code, sessionState.Session);
Logger.Debug("Finished execution");
return result;
}
public AssemblyReferences Except(AssemblyReferences obj)
{
Guard.AgainstNullArgument("obj", obj);
var deltaObject = new AssemblyReferences
{
PathReferences = new HashSet<string>(PathReferences.Except(obj.PathReferences)),
Assemblies = new HashSet<Assembly>(Assemblies.Except(obj.Assemblies))
};
return deltaObject;
}
public ScriptExecutor(IFileSystem fileSystem, IFilePreProcessor filePreProcessor, IScriptEngine scriptEngine, ILog logger)
{
References = new AssemblyReferences();
AddReferences(DefaultReferences);
Namespaces = new Collection<string>();
ImportNamespaces(DefaultNamespaces);
FileSystem = fileSystem;
FilePreProcessor = filePreProcessor;
ScriptEngine = scriptEngine;
Logger = logger;
}
public AssemblyReferences Except(AssemblyReferences obj)
{
Guard.AgainstNullArgument("obj", obj);
var deltaObject = new AssemblyReferences
{
PathReferences = new HashSet <string>(PathReferences.Except(obj.PathReferences)),
Assemblies = new HashSet <Assembly>(Assemblies.Except(obj.Assemblies))
};
return(deltaObject);
}
public void ShouldReturnAssembliesFromExecutor()
{
var assemblies = new AssemblyReferences(new List<string> {"path1", "path2"},
new List<Assembly> {typeof(string).Assembly});
_repl.SetupGet(x => x.References).Returns(assemblies);
var cmd = new ReferencesCommand();
var result = cmd.Execute(_repl.Object, null);
var expected = new List<string> {typeof (string).Assembly.FullName, "path1", "path2"};
((IEnumerable<string>)result).ToList().ShouldEqual(expected);
}
public ScriptExecutor(IFileSystem fileSystem, IFilePreProcessor filePreProcessor, IScriptEngine scriptEngine, ILog logger)
{
Guard.AgainstNullArgument("fileSystem", fileSystem);
Guard.AgainstNullArgumentProperty("fileSystem", "BinFolder", fileSystem.BinFolder);
Guard.AgainstNullArgumentProperty("fileSystem", "DllCacheFolder", fileSystem.DllCacheFolder);
References = new AssemblyReferences();
AddReferences(DefaultReferences);
Namespaces = new Collection<string>();
ImportNamespaces(DefaultNamespaces);
FileSystem = fileSystem;
FilePreProcessor = filePreProcessor;
ScriptEngine = scriptEngine;
Logger = logger;
}
public void ShouldSetIsCompleteSubmissionToFalseIfCodeIsMissingCurlyBracket(
[NoAutoProperties] RoslynReplEngine engine, ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "class test {";
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences(new[] { "System" });
// Act
var result = engine.Execute(
Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.IsCompleteSubmission.ShouldBeFalse();
}
public void ShouldInitializeScriptLibraryWrapperHost(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
Mock<IScriptPackManager> manager,
[NoAutoProperties] RoslynScriptEngine engine,
ScriptPackSession scriptPackSession
)
{
// Arrange
const string Code = "var theNumber = 42; //this should compile";
var refs = new AssemblyReferences(new[] { "System" });
scriptHostFactory.Setup(s => s.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>()))
.Returns(new ScriptHost(manager.Object, null));
// Act
engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
ScriptLibraryWrapper.ScriptHost.ShouldNotEqual(null);
}
public void ShouldCompileWhenUsingClassesFromAPassedAssemblyInstance(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] RoslynScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "var x = new ScriptCs.Tests.TestMarkerClass();";
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>()))
.Returns<IScriptPackManager, ScriptEnvironment>((p, q) => new ScriptHost(p, q));
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences(new[] { Assembly.GetExecutingAssembly() }, new[] { "System" });
// Act
var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.CompileExceptionInfo.ShouldBeNull();
result.ExecuteExceptionInfo.ShouldBeNull();
}
public ScriptResult Execute(string code, string[] scriptArgs, AssemblyReferences references, IEnumerable<string> namespaces,
ScriptPackSession scriptPackSession)
{
try
{
var def = Compiler.Compile("code", code, false, false, false);
using (var exeStream = new MemoryStream())
{
AssemblyFactory.SaveAssembly(def, exeStream);
var exeBytes = exeStream.ToArray();
var assembly = Assembly.Load(exeBytes);
assembly.EntryPoint.Invoke(null, new object[] { new string[0] });
}
}
catch (CompilerException e)
{
throw new Exception("Error compiling", e);
}
return new ScriptResult();
}
public void ShouldReturnReturnValueIfCodeExecutionReturnsValue(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] RoslynScriptEngine engine,
ScriptPackSession scriptPackSession)
{
const string Code = "\"Hello\" //this should return \"Hello\"";
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences(new[] { "System" });
// Act
var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.ReturnValue.ShouldEqual("Hello");
}
public void ShouldNotReturnReturnValueIfCodeExecutionDoesNotReturnValue(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] RoslynScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "var theNumber = 42; //this should not return a value";
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences(new[] { "System" });
// Act
var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.ReturnValue.ShouldBeNull();
}
public void ShouldReturnAScriptResult(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] RoslynTestScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
var code = string.Empty;
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences(new[] { "System" });
// Act
var result = engine.Execute(code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.ShouldBeType<ScriptResult>();
}
public void ShouldReturnExecuteExceptionIfCodeExecutionThrowsException(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] RoslynScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "throw new System.Exception(); //this should throw an Exception";
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences(new[] { "System" });
// Act
var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.ExecuteExceptionInfo.ShouldNotBeNull();
}
public void ShouldReturnExecuteExceptionIfCodeExecutionThrowsException(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] MonoScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "throw new System.Exception(); //this should throw an Exception";
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>()))
.Returns<IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));
var session = new SessionState<Evaluator> { Session = new Evaluator(new CompilerContext(new CompilerSettings(), new ConsoleReportPrinter())) };
scriptPackSession.State[MonoScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences(new[] { "System" });
// Act
var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.ExecuteExceptionInfo.ShouldNotBeNull();
}
public void ShouldReturnCompileExceptionIfCodeDoesNotCompile(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] RoslynScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "this shold not compile";
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences();
refs.PathReferences.Add("System");
// Act
var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.CompileExceptionInfo.ShouldNotBeNull();
}
public ScriptExecutor(
IFileSystem fileSystem,
IFilePreProcessor filePreProcessor,
IScriptEngine scriptEngine,
ILogProvider logProvider,
IScriptLibraryComposer composer)
{
Guard.AgainstNullArgument("fileSystem", fileSystem);
Guard.AgainstNullArgumentProperty("fileSystem", "BinFolder", fileSystem.BinFolder);
Guard.AgainstNullArgumentProperty("fileSystem", "DllCacheFolder", fileSystem.DllCacheFolder);
Guard.AgainstNullArgument("filePreProcessor", filePreProcessor);
Guard.AgainstNullArgument("scriptEngine", scriptEngine);
Guard.AgainstNullArgument("logProvider", logProvider);
Guard.AgainstNullArgument("composer", composer);
References = new AssemblyReferences(DefaultReferences);
Namespaces = new Collection<string>();
ImportNamespaces(DefaultNamespaces);
FileSystem = fileSystem;
FilePreProcessor = filePreProcessor;
ScriptEngine = scriptEngine;
_log = logProvider.ForCurrentType();
#pragma warning disable 618
Logger = new ScriptCsLogger(_log);
#pragma warning restore 618
ScriptLibraryComposer = composer;
}
public AssemblyReferences Except(AssemblyReferences obj)
{
Guard.AgainstNullArgument("obj", obj);
return(new AssemblyReferences(PathReferences.Except(obj.PathReferences), Assemblies.Except(obj.Assemblies)));
}
public void ShouldAddNewReferencesIfTheyAreProvided(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] MonoTestScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "var a = 0;";
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>()))
.Returns<IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));
var session = new SessionState<Evaluator> { Session = new Evaluator(new CompilerContext( new CompilerSettings(), new ConsoleReportPrinter())) };
scriptPackSession.State[MonoScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences();
refs.PathReferences.Add("System");
// Act
engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
((SessionState<Evaluator>)scriptPackSession.State[MonoScriptEngine.SessionKey]).References.PathReferences.Count().ShouldEqual(1);
}
public void ShouldSetIsPendingClosingCharToTrueIfCodeIsMissingSquareBracket(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] RoslynScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "var x = new[1] { 1 }; var y = x[0";
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>()))
.Returns<IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences();
refs.PathReferences.Add("System");
// Act
var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.IsPendingClosingChar.ShouldBeTrue();
result.ExpectingClosingChar.ShouldEqual(']');
}
public void ShouldNotMarkSubmissionsAsIncompleteWhenRunningScript(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] RoslynScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "class test {";
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences(new[] { "System" });
engine.FileName = "test.csx";
// Act
var result = engine.Execute(
Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.IsCompleteSubmission.ShouldBeTrue();
result.CompileExceptionInfo.ShouldNotBeNull();
}
public AssemblyReferences Except(AssemblyReferences references)
{
Guard.AgainstNullArgument("references", references);
return(new AssemblyReferences(Assemblies.Except(references.Assemblies), Paths.Except(references.Paths)));
}
public void ShouldNotReturnReturnValueIfCodeExecutionDoesNotReturnValue(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] MonoScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "var theNumber = 42; //this should not return a value";
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>()))
.Returns<IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));
var session = new SessionState<Evaluator> { Session = new Evaluator(new CompilerContext( new CompilerSettings(), new ConsoleReportPrinter())) };
scriptPackSession.State[MonoScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences();
refs.PathReferences.Add("System");
// Act
var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.ReturnValue.ShouldBeNull();
}
public void ShouldReturnReturnValueIfCodeExecutionReturnsValue(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] MonoScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Mono doesn't support comments after evals as well as Roslyn
const string Code = "\"Hello\""; //this should return \"Hello\"";
// Arrange
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>()))
.Returns<IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));
var session = new SessionState<Evaluator> { Session = new Evaluator(new CompilerContext( new CompilerSettings(), new ConsoleReportPrinter())) };
scriptPackSession.State[MonoScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences();
refs.PathReferences.Add("System");
// Act
var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.ReturnValue.ShouldEqual("Hello");
}
public void ShouldReturnAScriptResult(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] MonoScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
var code = string.Empty;
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>()))
.Returns<IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));
var session = new SessionState<Evaluator> { Session = new Evaluator(new CompilerContext( new CompilerSettings(), new ConsoleReportPrinter())) };
scriptPackSession.State[MonoScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences();
refs.PathReferences.Add("System");
// Act
var result = engine.Execute(code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.ShouldBeType<ScriptResult>();
}
public void ShouldAddNewReferencesIfTheyAreProvided(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] RoslynTestScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "var a = 0;";
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences(new[] { "System" });
// Act
engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
((SessionState<Session>)scriptPackSession.State[RoslynScriptEngine.SessionKey]).References.Paths.Count().ShouldEqual(1);
}
public ScriptResult Execute(string code, string[] scriptArgs, AssemblyReferences references, IEnumerable<string> namespaces, ScriptPackSession scriptPackSession)
{
if (scriptPackSession == null)
{
throw new ArgumentNullException("scriptPackSession");
}
if (references == null)
{
throw new ArgumentNullException("references");
}
_log.Debug("Starting to create execution components");
_log.Debug("Creating script host");
var executionReferences = new AssemblyReferences(references.Assemblies, references.Paths);
executionReferences.Union(scriptPackSession.References);
ScriptResult scriptResult;
SessionState<ScriptState> sessionState;
var isFirstExecution = !scriptPackSession.State.ContainsKey(SessionKey);
if (isFirstExecution)
{
var host = _scriptHostFactory.CreateScriptHost(
new ScriptPackManager(scriptPackSession.Contexts), scriptArgs);
ScriptLibraryWrapper.SetHost(host);
_log.Debug("Creating session");
var hostType = host.GetType();
ScriptOptions = ScriptOptions.AddReferences(hostType.Assembly);
var allNamespaces = namespaces.Union(scriptPackSession.Namespaces).Distinct();
foreach (var reference in executionReferences.Paths)
{
_log.DebugFormat("Adding reference to {0}", reference);
ScriptOptions = ScriptOptions.AddReferences(reference);
}
foreach (var assembly in executionReferences.Assemblies)
{
_log.DebugFormat("Adding reference to {0}", assembly.FullName);
ScriptOptions = ScriptOptions.AddReferences(assembly);
}
foreach (var @namespace in allNamespaces)
{
_log.DebugFormat("Importing namespace {0}", @namespace);
ScriptOptions = ScriptOptions.AddNamespaces(@namespace);
}
sessionState = new SessionState<ScriptState> { References = executionReferences, Namespaces = new HashSet<string>(allNamespaces) };
scriptPackSession.State[SessionKey] = sessionState;
scriptResult = Execute(code, host, sessionState);
}
else
{
_log.Debug("Reusing existing session");
sessionState = (SessionState<ScriptState>)scriptPackSession.State[SessionKey];
if (sessionState.References == null)
{
sessionState.References = new AssemblyReferences();
}
if (sessionState.Namespaces == null)
{
sessionState.Namespaces = new HashSet<string>();
}
var newReferences = executionReferences.Except(sessionState.References);
foreach (var reference in newReferences.Paths)
{
_log.DebugFormat("Adding reference to {0}", reference);
ScriptOptions = ScriptOptions.AddReferences(reference);
sessionState.References = sessionState.References.Union(new[] { reference });
}
foreach (var assembly in newReferences.Assemblies)
{
_log.DebugFormat("Adding reference to {0}", assembly.FullName);
ScriptOptions = ScriptOptions.AddReferences(assembly);
sessionState.References = sessionState.References.Union(new[] { assembly });
}
var newNamespaces = namespaces.Except(sessionState.Namespaces);
foreach (var @namespace in newNamespaces)
{
_log.DebugFormat("Importing namespace {0}", @namespace);
ScriptOptions = ScriptOptions.AddNamespaces(@namespace);
sessionState.Namespaces.Add(@namespace);
}
if (string.IsNullOrWhiteSpace(code))
{
return ScriptResult.Empty;
}
scriptResult = Execute(code, sessionState.Session, sessionState);
}
return scriptResult;
//todo handle namespace failures
//https://github.com/dotnet/roslyn/issues/1012
}
public void ShouldReturnExecuteExceptionIfCodeExecutionThrowsException(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] RoslynScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "throw new System.Exception(); //this should throw an Exception";
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>()))
.Returns<IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences();
refs.PathReferences.Add("System");
// Act
var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.ExecuteExceptionInfo.ShouldNotBeNull();
}
public void ShouldReturnReturnValueIfCodeExecutionReturnsValue(
[Frozen] Mock<IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] RoslynScriptEngine engine,
ScriptPackSession scriptPackSession)
{
const string Code = "\"Hello\" //this should return \"Hello\"";
// Arrange
scriptHostFactory.Setup(f => f.CreateScriptHost(It.IsAny<IScriptPackManager>(), It.IsAny<string[]>()))
.Returns<IScriptPackManager, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));
var session = new SessionState<Session> { Session = new ScriptEngine().CreateSession() };
scriptPackSession.State[RoslynScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences();
refs.PathReferences.Add("System");
// Act
var result = engine.Execute(Code, new string[0], refs, Enumerable.Empty<string>(), scriptPackSession);
// Assert
result.ReturnValue.ShouldEqual("Hello");
}
public virtual void Reset()
{
References = new AssemblyReferences(DefaultReferences);
Namespaces.Clear();
ImportNamespaces(DefaultNamespaces);
ScriptPackSession.State.Clear();
}
public ScriptResult Execute(string code, string[] scriptArgs, AssemblyReferences references, IEnumerable<string> namespaces, ScriptPackSession scriptPackSession)
{
Guard.AgainstNullArgument("scriptPackSession", scriptPackSession);
Guard.AgainstNullArgument("references", references);
Logger.Debug("Starting to create execution components");
Logger.Debug("Creating script host");
var executionReferences = new AssemblyReferences(references.PathReferences, references.Assemblies);
executionReferences.PathReferences.UnionWith(scriptPackSession.References);
SessionState<Session> sessionState;
if (!scriptPackSession.State.ContainsKey(SessionKey))
{
var host = _scriptHostFactory.CreateScriptHost(new ScriptPackManager(scriptPackSession.Contexts), scriptArgs);
Logger.Debug("Creating session");
var hostType = host.GetType();
ScriptEngine.AddReference(hostType.Assembly);
var session = ScriptEngine.CreateSession(host, hostType);
var allNamespaces = namespaces.Union(scriptPackSession.Namespaces).Distinct();
foreach (var reference in executionReferences.PathReferences)
{
Logger.DebugFormat("Adding reference to {0}", reference);
session.AddReference(reference);
}
foreach (var assembly in executionReferences.Assemblies)
{
Logger.DebugFormat("Adding reference to {0}", assembly.FullName);
session.AddReference(assembly);
}
foreach (var @namespace in allNamespaces)
{
Logger.DebugFormat("Importing namespace {0}", @namespace);
session.ImportNamespace(@namespace);
}
sessionState = new SessionState<Session> { References = executionReferences, Session = session, Namespaces = new HashSet<string>(allNamespaces) };
scriptPackSession.State[SessionKey] = sessionState;
}
else
{
Logger.Debug("Reusing existing session");
sessionState = (SessionState<Session>)scriptPackSession.State[SessionKey];
if (sessionState.References == null)
{
sessionState.References = new AssemblyReferences();
}
if (sessionState.Namespaces == null)
{
sessionState.Namespaces = new HashSet<string>();
}
var newReferences = executionReferences.Except(sessionState.References);
foreach (var reference in newReferences.PathReferences)
{
Logger.DebugFormat("Adding reference to {0}", reference);
sessionState.Session.AddReference(reference);
sessionState.References.PathReferences.Add(reference);
}
foreach (var assembly in newReferences.Assemblies)
{
Logger.DebugFormat("Adding reference to {0}", assembly.FullName);
sessionState.Session.AddReference(assembly);
sessionState.References.Assemblies.Add(assembly);
}
var newNamespaces = namespaces.Except(sessionState.Namespaces);
foreach (var @namespace in newNamespaces)
{
Logger.DebugFormat("Importing namespace {0}", @namespace);
sessionState.Session.ImportNamespace(@namespace);
sessionState.Namespaces.Add(@namespace);
}
}
Logger.Debug("Starting execution");
var result = Execute(code, sessionState.Session);
Logger.Debug("Finished execution");
return result;
}
