public IInterpreter StringToInt()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DebugThrowOnError = true, AllowInvalidMainResult = true
}
.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("s", null, StringLiteral.Create("2")),
VariableDeclaration.CreateStatement("i", NameFactory.Int64NameReference(), ExpressionFactory.GetOptionValue(
FunctionCall.Create(NameReference.Create(NameFactory.Int64NameReference(), NameFactory.ParseFunctionName),
NameReference.Create("s"))
)),
Return.Create(NameReference.Create("i"))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IErrorReporter ErrorForcingConst()
{
NameResolver resolver = null;
foreach (var mutability in Options.StrictMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DiscardingAnyExpressionDuringTests = true
}
.SetMutability(mutability));
var root_ns = env.Root;
NameReference rhs_value = NameReference.Create("a");
IExpression assign = Assignment.CreateStatement(NameReference.Create("x"), rhs_value);
VariableDeclaration decl = VariableDeclaration.CreateStatement("x",
NameFactory.StringPointerNameReference(TypeMutability.ForceConst), StringLiteral.Create("hi"),
env.Options.ReassignableModifier());
root_ns.AddBuilder(FunctionBuilder.Create("innocent",
NameFactory.UnitNameReference(),
Block.CreateStatement(
// this is ok, we are assigning literal here
decl,
VariableDeclaration.CreateStatement("a",
NameFactory.StringPointerNameReference(TypeMutability.ForceMutable),
StringLiteral.Create("no")),
// this is not ok, we are assigning mutable to const
assign,
ExpressionFactory.Readout("x")
)));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TypeMismatch, rhs_value));
}
return(resolver);
}
public IInterpreter FileExists()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DebugThrowOnError = true, AllowInvalidMainResult = true
}
.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("e", null, FunctionCall.Create(NameReference.Create(NameFactory.FileNameReference(),
NameFactory.FileExists), StringLiteral.Create(randomTextFilePath))),
IfBranch.CreateIf(NameReference.Create("e"), new[] { Return.Create(Int64Literal.Create("2")) },
IfBranch.CreateElse(new[] { Return.Create(Int64Literal.Create("-5")) }))
)));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter FileReadingLines()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DebugThrowOnError = true, AllowInvalidMainResult = true
}
.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Nat64NameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("lines", null,
ExpressionFactory.GetOptionValue(FunctionCall.Create(NameReference.Create(NameFactory.FileNameReference(), NameFactory.FileReadLines),
StringLiteral.Create(randomTextFilePath)))),
// first line is "It was" (without quotes)
VariableDeclaration.CreateStatement("first", null,
FunctionCall.Create(NameReference.Create("lines", NameFactory.PropertyIndexerName), NatLiteral.Create("0"))),
// 6
VariableDeclaration.CreateStatement("len", null,
NameReference.Create("first", NameFactory.IIterableCount)),
Return.Create(NameReference.Create("len"))
)));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(6UL, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter CommandLine()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Nat8NameReference(),
Block.CreateStatement(
ExpressionFactory.AssertEqual(StringLiteral.Create(Interpreter.Interpreter.CommandLineTestProgramPath),
NameReference.Create(NameFactory.CommandLineProgramPath)),
ExpressionFactory.AssertEqual(StringLiteral.Create(Interpreter.Interpreter.CommandLineTestArgument),
FunctionCall.Create(NameReference.Create(NameFactory.CommandLineArguments, NameFactory.AtFunctionName),
NatLiteral.Create("0"))),
Return.Create(Nat8Literal.Create("0"))
)).
Parameters(FunctionParameter.Create(NameFactory.CommandLineProgramPath,
NameFactory.StringPointerNameReference(TypeMutability.ReadOnly)),
FunctionParameter.Create(NameFactory.CommandLineArguments,
NameFactory.StringPointerNameReference(TypeMutability.ReadOnly), Variadic.Create(), null, isNameRequired: false)));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual((byte)0, result.RetValue.PlainValue);
}
return(interpreter);
}
