public void OperatorAdd()
{
_left = 10;
_right = 5;
Assert.AreEqual(_left + _right, MondValue.Number(10 + 5));
_left = "abc";
_right = "def";
Assert.AreEqual(_left + _right, MondValue.String("abc" + "def"));
_left = "abc";
_right = 123;
Assert.AreEqual(_left + _right, MondValue.String("abc" + 123));
_left = 123;
_right = "abc";
Assert.AreEqual(_left + _right, MondValue.String(123 + "abc"));
_left = MondValue.Null;
_right = "abc";
Assert.AreEqual(_left + _right, MondValue.String("null" + "abc")); // TODO: this shouldn't be allowed imo
_left = MondValue.Null;
_right = MondValue.Null;
Assert.Throws <MondRuntimeException>(() => { _left += _right; });
}
public MondValue ParseValue()
{
var token = Take();
switch (token.Type)
{
case TokenType.True:
return(MondValue.True);
case TokenType.False:
return(MondValue.False);
case TokenType.Null:
return(MondValue.Null);
case TokenType.Undefined:
return(MondValue.Undefined);
case TokenType.String:
return(MondValue.String(token.Value));
case TokenType.Number:
double number;
if (!double.TryParse(token.Value, out number))
{
throw new MondRuntimeException(DeserializePrefix + "invalid number '{0}'", token.Value);
}
return(MondValue.Number(number));
case TokenType.ObjectStart:
return(ParseObject());
case TokenType.ArrayStart:
return(ParseArray());
default:
throw new MondRuntimeException(DeserializePrefix + "expected Value but got {0}", token.Type);
}
}
public void Slice()
{
var state = new MondState();
var arr = MondValue.Array();
var str = MondValue.String("HelloWorld");
arr.ArrayValue.AddRange(new MondValue[] { 1, 2, 3, 4, 5 });
Assert.True(str.Slice(1, 3, 1).Equals(MondValue.String("ell")));
Assert.True(arr.Slice().Enumerate(state).SequenceEqual(arr.Enumerate(state)), "clone");
Assert.True(arr.Slice(step: -1).Enumerate(state).SequenceEqual(new MondValue[] { 5, 4, 3, 2, 1 }), "reverse");
Assert.True(arr.Slice(1, 3).Enumerate(state).SequenceEqual(new MondValue[] { 2, 3, 4 }), "range");
Assert.True(arr.Slice(3, 1).Enumerate(state).SequenceEqual(new MondValue[] { 4, 3, 2 }), "reverse range");
Assert.True(arr.Slice(0, 0).Enumerate(state).SequenceEqual(new MondValue[] { 1 }), "same start and end");
Assert.True(arr.Slice(-4, -2).Enumerate(state).SequenceEqual(new MondValue[] { 2, 3, 4 }), "negative range");
Assert.True(arr.Slice(-2, -4).Enumerate(state).SequenceEqual(new MondValue[] { 4, 3, 2 }), "negative range reverse");
Assert.True(arr.Slice(step: 2).Enumerate(state).SequenceEqual(new MondValue[] { 1, 3, 5 }), "skip");
Assert.True(arr.Slice(step: -2).Enumerate(state).SequenceEqual(new MondValue[] { 5, 3, 1 }), "skip negative");
Assert.Throws <MondRuntimeException>(() => arr.Slice(-6, 0, "out of bounds 1"));
Assert.Throws <MondRuntimeException>(() => arr.Slice(0, 5, "out of bounds 2"));
Assert.Throws <MondRuntimeException>(() => arr.Slice(step: 0), "invalid step");
Assert.Throws <MondRuntimeException>(() => arr.Slice(4, 0, 1), "invalid range");
Assert.Throws <MondRuntimeException>(() => arr.Slice(0, 4, -1), "invalid range negative");
Assert.Throws <MondRuntimeException>(() => MondValue.Undefined.Slice(), "slice non-array");
var empty = MondValue.Array();
Assert.True(!empty.Slice().Enumerate(state).Any(), "clone empty");
}
public void Contains()
{
var arr = MondValue.Array();
arr.ArrayValue.AddRange(new MondValue[] { 1, 2, 3, 4, 5 });
Assert.True(arr.Contains(3));
Assert.False(arr.Contains(10));
var str = MondValue.String("hello world");
Assert.True(str.Contains("hello"));
Assert.False(str.Contains("asdf"));
var obj = MondValue.Object(new MondState());
obj["__in"] = new MondFunction((state, args) => args[1].Type == MondValueType.Number);
Assert.True(obj.Contains(3));
Assert.False(obj.Contains("hello"));
Assert.Throws <MondRuntimeException>(() => MondValue.False.Contains(0));
}
public int Visit(StringExpression expression)
{
MondValue.String(expression.Value).Serialize(_writer);
return(0);
}
