public void TestRunScriptWithScriptState()
{
// run a script using another scripts end state as the starting state (globals)
var result = CSharpScript.Run("int X = 100;");
var result2 = CSharpScript.Run("X + X", result);
Assert.Equal(200, result2.ReturnValue);
}
public void ShouldNotMarkSubmissionsAsIncompleteWhenRunningScript(
[Frozen] Mock <IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] CSharpScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "class test {";
var session = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.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 void ShouldCompileWhenUsingClassesFromAPassedAssemblyInstance(
[Frozen] Mock <IScriptHostFactory> scriptHostFactory,
[Frozen] 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, string[]>((p, q) => new ScriptHost(p, new ScriptEnvironment(q)));
var engine = new CSharpScriptEngine(scriptHostFactory.Object, new TestLogProvider());
var session = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.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 void TestRunScriptWithGlobals()
{
var result = CSharpScript.Run("X + Y", new Globals {
X = 1, Y = 2
});
Assert.Equal(3, result.ReturnValue);
}
public void TestCreateMethodDelegate()
{
// create a delegate to a method declared in the script
var state = CSharpScript.Run("int Times(int x) { return x * x; }");
var fn = state.CreateDelegate<Func<int, int>>("Times");
var result = fn(5);
Assert.Equal(25, result);
}
public void TestGetScriptVariableAfterRunningScript()
{
var result = CSharpScript.Run("int x = 100;");
var globals = result.Variables.Names.ToList();
Assert.Equal(1, globals.Count);
Assert.Equal(true, globals.Contains("x"));
Assert.Equal(true, result.Variables.ContainsVariable("x"));
Assert.Equal(100, (int)result.Variables["x"].Value);
}
private void ExecuteCommand(CSharpScript script, TwitchChat.User user = null, String arguments = "")
{
try
{
script.Run(State, user, arguments);
}
catch (Exception ex)
{
}
}
public Task <ScriptResult> ExecuteAsync(string code)
{
return(Task.Run(() =>
{
var result = CSharpScript.Run(code, state);
state = result;
return new ScriptResult
{
ReturnValue = result.ReturnValue
};
}));
}
public void Execute()
{
SourceText text;
if (GetCurrentDocument().TryGetText(out text))
{
CSharpScript.Run(text.ToString(),
ScriptOptions.Default
.AddNamespaces(_assemblyTypes.Select(x => x.Namespace))
.AddReferences(_assemblyTypes.Select(x => x.Assembly)));
}
}
public void TestRunDynamicVoidScriptWithoutTerminatingSemicolon()
{
var result = CSharpScript.Run(@"
class SomeClass
{
public void Do()
{
}
}
dynamic d = new SomeClass();
d.Do()"
, ScriptOptions.Default.WithReferences(MscorlibRef, SystemRef, SystemCoreRef, CSharpRef));
}
public void ShouldReturnOnlyLastValueOfVariablesDeclaredManyTimes([NoAutoProperties] CSharpReplEngine engine, ScriptPackSession scriptPackSession)
{
var session = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.SessionKey] = session;
engine.Execute("int x = 1;", new string[0], new AssemblyReferences(), Enumerable.Empty <string>(), scriptPackSession);
engine.Execute("int x = 2;", new string[0], new AssemblyReferences(), Enumerable.Empty <string>(), scriptPackSession);
engine.GetLocalVariables(scriptPackSession).ShouldEqual(new Collection <string> {
"System.Int32 x"
});
}
public void TestBranchingSubscripts()
{
// run script to create declaration of M
var result1 = CSharpScript.Run("int M(int x) { return x + x; }");
// run second script starting from first script's end state
// this script's new declaration should hide the old declaration
var result2 = CSharpScript.Run("int M(int x) { return x * x; } M(5)", result1);
Assert.Equal(25, result2.ReturnValue);
// run third script also starting from first script's end state
// it should not see any declarations made by the second script.
var result3 = CSharpScript.Run("M(5)", result1);
Assert.Equal(10, result3.ReturnValue);
}
//todo: filip: this feature is not supported in Roslyn 1.0.0-rc2: see https://github.com/dotnet/roslyn/issues/1012
//[Theory, ScriptCsAutoData]
public void ShouldReturnInvalidNamespacesIfCS0241Encountered(
[Frozen] Mock <IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] CSharpScriptEngine engine,
ScriptPackSession scriptPackSession)
{
var session = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.SessionKey] = session;
// Act
var result = engine.Execute(string.Empty, new string[0], new AssemblyReferences(), new[] { "foo" }, scriptPackSession);
// Assert
result.CompileExceptionInfo.ShouldNotBeNull();
result.InvalidNamespaces.ShouldContain("foo");
}
public void ShouldReturn0VariablesAfterReset([NoAutoProperties] CSharpReplEngine engine, ScriptPackSession scriptPackSession)
{
var session = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.SessionKey] = session;
engine.Execute("int x = 1;", new string[0], new AssemblyReferences(), Enumerable.Empty <string>(),
scriptPackSession);
engine.Execute(@"var y = ""www"";", new string[0], new AssemblyReferences(), Enumerable.Empty <string>(),
scriptPackSession);
scriptPackSession.State[CommonScriptEngine.SessionKey] = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
engine.GetLocalVariables(scriptPackSession).ShouldBeEmpty();
}
public void TestRepl()
{
string[] submissions = new[]
{
"int x = 100;",
"int y = x * x;",
"x + y"
};
object input = null;
ScriptState result = null;
foreach (var submission in submissions)
{
result = CSharpScript.Run(submission, input);
input = result;
}
Assert.Equal(10100, result.ReturnValue);
}
public void ShouldSetIsCompleteSubmissionToFalseIfCodeIsMissingCurlyBracket(
[NoAutoProperties] CSharpReplEngine engine, ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "class test {";
var session = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.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 ShouldReturnReturnValueIfCodeExecutionReturnsValue(
[Frozen] Mock <IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] CSharpScriptEngine engine,
ScriptPackSession scriptPackSession)
{
const string Code = "\"Hello\" //this should return \"Hello\"";
var session = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.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] CSharpScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "var theNumber = 42; //this should not return a value";
var session = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.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 ShouldAddNewReferencesIfTheyAreProvided(
[Frozen] Mock <IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] CSharpTestScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "var a = 0;";
var session = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.SessionKey] = session;
var refs = new AssemblyReferences(new[] { "System" });
// Act
engine.Execute(Code, new string[0], refs, Enumerable.Empty <string>(), scriptPackSession);
// Assert
((SessionState <ScriptState>)scriptPackSession.State[CommonScriptEngine.SessionKey]).References.Paths.Count().ShouldEqual(1);
}
public void ShouldReturnExecuteExceptionIfCodeExecutionThrowsException(
[Frozen] Mock <IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] CSharpScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
const string Code = "throw new System.Exception(); //this should throw an Exception";
var session = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.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 ShouldReturnAScriptResult(
[Frozen] Mock <IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] CSharpTestScriptEngine engine,
ScriptPackSession scriptPackSession)
{
// Arrange
var code = string.Empty;
var session = new SessionState <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.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 ShouldReuseExistingSessionIfProvided(
[Frozen] Mock <IScriptHostFactory> scriptHostFactory,
[NoAutoProperties] CSharpTestScriptEngine 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 <ScriptState> {
Session = CSharpScript.Run("")
};
scriptPackSession.State[CommonScriptEngine.SessionKey] = session;
// Act
engine.Execute(Code, new string[0], new AssemblyReferences(), Enumerable.Empty <string>(), scriptPackSession);
// Assert
engine.Session.ShouldEqual(session.Session);
}
public void TestRunScript()
{
var result = CSharpScript.Run("1 + 2");
Assert.Equal(3, result.ReturnValue);
}
protected override ScriptState GetScriptState(string code, object globals)
{
return(CSharpScript.Run(code, ScriptOptions, globals));
}
protected override ScriptState ExecuteScript(string text, ScriptOptions options)
{
return(CSharpScript.Run(text, options, new FiddlerScriptGlobals()));
}
public void TestRunVoidScript()
{
var result = CSharpScript.Run("Console.WriteLine(0);");
}
