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 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; }