public void Evaluate_CanEvaluateMap()
{
string input = @"
let map = fn(arr, f) {
let iter = fn(arr, accumulated) {
if (len(arr) == 0) {
accumulated
} else {
iter(rest(arr), push(accumulated, f(first(arr))));
}
};
iter(arr, []);
};
map([2,3], fn(x) { x * 2 });
";
ArrayObject actual = this.AssertAndCast <ArrayObject>(this.subject.Evaluate(input, this.environment));
Assert.Equal(2, actual.Elements.Count);
IntegerObject intResult = this.AssertAndCast <IntegerObject>(actual.Elements[0]);
Assert.Equal(4, intResult.Value);
intResult = this.AssertAndCast <IntegerObject>(actual.Elements[1]);
Assert.Equal(6, intResult.Value);
}
public IObject EvalIntegerInfixExpression(string op, IntegerObject left, IntegerObject right, Enviroment enviroment)
{
var leftValue = left.Value;
var rightValue = right.Value;
switch (op)
{
case "+":
return(new IntegerObject(leftValue + rightValue));
case "-":
return(new IntegerObject(leftValue - rightValue));
case "*":
return(new IntegerObject(leftValue * rightValue));
case "/":
return(new IntegerObject(leftValue / rightValue));
case "<":
return(this.ToBooleanObject(leftValue < rightValue));
case ">":
return(this.ToBooleanObject(leftValue > rightValue));
case "==":
return(this.ToBooleanObject(leftValue == rightValue));
case "!=":
return(this.ToBooleanObject(leftValue != rightValue));
}
return(this.Null);
}
public void IntegerObjectsShouldNotBeEquals()
{
IntegerObject io1 = new IntegerObject(1);
IntegerObject io2 = new IntegerObject(2);
Assert.AreNotEqual(io1, io2);
Assert.AreNotEqual(io1.GetHashCode(), io2.GetHashCode());
}
public void Get_WhenValuePresent_CanReturnValue()
{
IObject obj = new IntegerObject(5);
var subject = new RuntimeEnvironment();
subject.Set("a", obj);
Assert.Equal(obj, subject.Get("a"));
}
public void Evaluate_CanEvaluateFunction(string input, int expected)
{
IObject actual = this.subject.Evaluate(input, this.environment);
Assert.NotNull(actual);
IntegerObject intObj = this.AssertAndCast <IntegerObject>(actual);
Assert.Equal(expected, intObj.Value);
}
public void Evaluate_CanEvalIntegerExpressions(string input, int expected)
{
IObject actual = this.subject.Evaluate(input, this.environment);
Assert.NotNull(actual);
IntegerObject intResult = this.AssertAndCast <IntegerObject>(actual);
Assert.Equal(expected, intResult.Value);
}
public void Get_WhenValueIsNotPresent_SearchesParents()
{
IObject obj = new IntegerObject(5);
var subject = new RuntimeEnvironment();
subject.Set("a", obj);
subject = subject.Extend();
subject = subject.Extend();
Assert.Equal(obj, subject.Get("a"));
}
public void Get_WhenShadowingOuterValue_ReturnsCorrectValue()
{
IObject obj = new IntegerObject(10);
var subject = new RuntimeEnvironment();
subject.Set("a", new IntegerObject(5));
subject = subject.Extend();
subject = subject.Extend();
subject.Set("a", obj);
Assert.Equal(obj, subject.Get("a"));
}
public void ObtainIntegerNumberWithSign(string fragment, int?expected)
{
/// 7.3.3 Numeric Objects
byte[] bytes = System.Text.UTF8Encoding.UTF8.GetBytes(fragment);
Tokenizer feed = new Tokenizer(new MemoryStream(bytes));
Objectizer objectizer = new Objectizer(feed);
IntegerObject actual = (IntegerObject)objectizer.NextObject();
Assert.Equal(expected, actual.IntValue);
}
public void Evaluate_CanEvaluateClosures()
{
string input = @"
let newAdder = fn(x) {
fn(y) { x + y };
};
let addTwo = newAdder(2);
let addThree = newAdder(3);
addTwo(3);
";
IObject actual = this.subject.Evaluate(input, this.environment);
IntegerObject intObj = this.AssertAndCast <IntegerObject>(actual);
Assert.Equal(5, intObj.Value);
}
public void Evaluate_CanEvaluateHashIndexing()
{
string input = @"
let two = ""two"";
let h = {
""one"": 10 - 9,
two: 1 + 1,
""thr"" + ""ee"": 6/ 2,
4: 4,
true: 5,
false: 6
};
h[1 + 3];
";
IntegerObject actual = this.AssertAndCast <IntegerObject>(this.subject.Evaluate(input, this.environment));
Assert.Equal(4, actual.Value);
}
