public void Test_String_ljust()
{
var instance = new String("hello");
var callSite = CreateCallSite("ljust", ArgumentKind.Simple);
Assert.That(callSite.Call(instance, new Fixnum(4)).ToString(), Is.EqualTo("hello"));
Assert.That(callSite.Call(instance, new Fixnum(5)).ToString(), Is.EqualTo("hello"));
Assert.That(callSite.Call(instance, new Fixnum(10)).ToString(), Is.EqualTo("hello "));
var length = new Fixnum(9);
var padding = new String("1234");
callSite = CreateCallSite("ljust", ArgumentKind.Simple, ArgumentKind.Simple);
Assert.That(
callSite.Call(instance, length, padding).ToString(),
Is.EqualTo("hello1234")
);
length = new Fixnum(11);
Assert.That(
callSite.Call(instance, length, padding).ToString(),
Is.EqualTo("hello123412")
);
}
public override Expression Compile()
{
var constant = (ConstantExpression)Value.Accept(Compiler);
var number = constant.Value;
if (number is Fixnum)
{
number = new Fixnum(-(long)(Fixnum)number);
}
else if (number is Float)
{
number = new Float(-(double)(Float)number);
}
else if (number is Complex)
{
throw new NotImplementedException();
//number = ((Complex) number).Conjugate();
}
else
{
throw new NotImplementedException();
//number = -(Rational) number;
}
return(Constant(number, typeof(iObject)));
}
[Test] // [] [start, length] [range] first last slice slice!
public void TestIndexerGetter()
{
var fixnum0 = new Fixnum(0);
var str = new String("string");
var nil = new NilClass();
var emptyArray = new Array();
Assert.That(emptyArray[0], Is.EqualTo(nil));
var array = new Array(fixnum0, str); // a = [0, "string"]
// []
Assert.That(array[0], Is.EqualTo(fixnum0)); // a[0] => 0
Assert.That(array[1], Is.EqualTo(str)); // a[1] => "string"
Assert.That(array[2], Is.EqualTo(nil)); // a[2] => nil
Assert.That(array[-2], Is.EqualTo(fixnum0)); // a[-2] => 0
Assert.That(array[-1], Is.EqualTo(str)); // a[-1] => "string"
Assert.That(array[-3], Is.EqualTo(nil)); // a[-3] => "string"
// TODO
// a[0, 3] => [0, "string"]
// a[-2, 1] => [0]
// a[0..5] => [0, "string"]
// a[0...1] => [0]
Assert.That(array.First, Is.EqualTo(fixnum0)); // a.first => 0
Assert.That(array.Last, Is.EqualTo(str)); // a.last => "string"
// TODO
// slice!
}
[Test] // []= [start, length]= [range]=
public void TestIndexerSetter()
{
var fixnum1 = new Fixnum(1);
var str = new String("string");
var nil = new NilClass();
var emptyArray = new Array();
emptyArray[0] = fixnum1;
Assert.That(emptyArray[0], Is.EqualTo(fixnum1));
emptyArray = new Array();
emptyArray[1] = fixnum1;
Assert.That(emptyArray[0], Is.EqualTo(nil));
Assert.That(emptyArray[1], Is.EqualTo(fixnum1));
emptyArray = new Array();
Assert.Throws <IndexError>(() => { emptyArray[-2] = fixnum1; });
var array = new Array(fixnum1, str);
array[0] = str;
array[1] = new NilClass();
Assert.That(array[0], Is.EqualTo(str));
Assert.That(array[1], Is.EqualTo(nil));
array[-1] = str;
array[-2] = new NilClass();
Assert.That(array[-1], Is.EqualTo(str));
Assert.That(array[-2], Is.EqualTo(nil));
Assert.Throws <IndexError>(() => { emptyArray[-3] = fixnum1; });
}
public void TestCreate([Random(long.MinValue, long.MaxValue, 1)] long value)
{
var fixnum = new Fixnum(value);
Assert.That(fixnum.Value, Is.EqualTo(value));
Assert.That(fixnum.Id, Is.EqualTo(value << 1 | 1));
}
[Test] // * join
public void TestMultiply()
{
// [1, 2, 3] * 3 = [1, 2, 3, 1, 2, 3, 1, 2, 3]
var fixnum1 = new Fixnum(1);
var fixnum2 = new Fixnum(2);
var fixnum3 = new Fixnum(3);
var array = new Array(fixnum1, fixnum2, fixnum3);
var result = array * fixnum3;
var expectedResult = new Array(fixnum1, fixnum2, fixnum3, fixnum1, fixnum2, fixnum3, fixnum1, fixnum2, fixnum3);
Assert.That(result.Count, Is.EqualTo(9));
Assert.That(result, Is.EqualTo(expectedResult));
// [1, 2, 3] * "," = "1,2,3"
var result2 = array * new String(",");
Assert.That(result2, Is.EqualTo(new String("1,2,3")));
result2 = array.Join();
Assert.That(result2, Is.EqualTo(new String("123")));
// [1, 2, 3].join(",") = "1,2,3"
result2 = array.Join(new String(","));
Assert.That(result2, Is.EqualTo(new String("1,2,3")));
// TODO move to fixnum 1 * [1, 2, 3] = TypeError
// Assert.Throws<TypeError>(() => { var a = fixnum1 * array; });
// [1, 2, 3] *= 3
array *= fixnum3;
Assert.That(array, Is.EqualTo(expectedResult));
}
public void TestToStringError()
{
var fixnum = new Fixnum(10000);
Assert.Throws <ArgumentError>(() => { fixnum.ToString(1); });
Assert.Throws <ArgumentError>(() => { fixnum.ToString(37); });
}
public void TestSend([Random(1L, long.MaxValue, 3)] long value)
{
var positive = new Fixnum(value);
var negative = new Fixnum(-value);
var result = Object.Send(negative, new Symbol("abs"));
Assert.That(result, Is.EqualTo(positive));
}
public void TestFreeze()
{
var fixnum = new Fixnum();
Assert.IsTrue(fixnum.Frozen);
Assert.That(fixnum.Freeze(), Is.EqualTo(fixnum));
Assert.IsTrue(fixnum.Frozen);
}
public void TestClass([Random(long.MinValue, long.MaxValue, 1)] long value)
{
var fixnum = new Fixnum(value);
Assert.That(fixnum.Class, Is.EqualTo(Class.FIXNUM));
Assert.That(fixnum.EffectiveClass, Is.EqualTo(Class.FIXNUM));
Assert.Throws <TypeError>(() => { var singletonClass = fixnum.SingletonClass; });
Assert.IsFalse(fixnum.HasSingletonClass);
}
public void TestResultBoxing()
{
var callSite = new CallSite(new Symbol("to_s"));
const int integer = 100;
var fixnum = new Fixnum(integer);
var stringValue = new String(fixnum.Value.ToString());
Assert.That(callSite.Call(fixnum), Is.EqualTo(stringValue));
}
public void TestEquals([Random(0L, 10000L, 3)] long rawValue)
{
var float1 = new Float(rawValue);
var fixnum = new Fixnum(rawValue);
Assert.IsTrue(float1.Equals(new Float(rawValue)));
Assert.IsTrue(float1.Equals(fixnum));
Assert.IsFalse(float1.Equals(new Float(rawValue + 1)));
Assert.IsFalse(float1.Equals(null));
Assert.IsFalse(float1.Equals(new String(rawValue.ToString())));
}
public void TestInclude()
{
var fixnum0 = new Fixnum(0);
var range = new Range(fixnum0, new Fixnum(2));
Assert.True(range.Include(fixnum0));
Assert.False(range.Include(new Fixnum(5)));
range = new Range(new String("a"), new String("z"));
Assert.True(range.Include(new String("g")));
Assert.False(range.Include(new String("1")));
}
public void TestEquals([Random(0L, 10000L, 3)] long value)
{
var fixnum = new Fixnum(value);
var floatObject = new Float(value);
Assert.IsTrue(fixnum.Equals(new Fixnum(value)));
Assert.IsTrue(fixnum.Equals(floatObject));
Assert.IsFalse(fixnum.Equals(new Fixnum(value + 1)));
Assert.IsFalse(fixnum.Equals(null));
Assert.IsFalse(fixnum.Equals(new String(value.ToString())));
}
public void TestIsA()
{
var fixnum = new Fixnum();
Assert.IsTrue(fixnum.IsA(Class.FIXNUM));
Assert.IsTrue(fixnum.IsA(Class.INTEGER));
Assert.IsTrue(fixnum.IsA(Class.NUMERIC));
Assert.IsTrue(fixnum.IsA(Class.OBJECT));
Assert.IsTrue(fixnum.IsA(Class.BASIC_OBJECT));
Assert.IsFalse(fixnum.IsA(Class.STRING));
Assert.IsFalse(fixnum.IsA(Class.FLOAT));
}
[Test] // compact compact!
public void TestCompact()
{
var nil = new NilClass();
var fixnum0 = new Fixnum(0);
var array = new Array(nil, nil);
var newArray = array.Compact();
Assert.That(newArray.Count, Is.EqualTo(0));
Assert.That(array.Count, Is.EqualTo(2));
array.CompactSelf();
Assert.That(array.Count, Is.EqualTo(0));
}
public void TestToString()
{
var emptyHash = new Hash();
var fixnum0 = new Fixnum(0);
var symbol = new Symbol("symbol");
Assert.That(emptyHash.ToString, Is.EqualTo("{}"));
var hash = new Hash();
hash[symbol] = fixnum0;
Assert.That(hash.ToString, Is.EqualTo("{:symbol=>0}"));
}
[Test] // &
public void TestAnd()
{
// [1, 1, 3, 5] & [1, 2, 3] = [1, 3]
var fixnum1 = new Fixnum(1);
var fixnum3 = new Fixnum(3);
var array = new Array(fixnum1, fixnum1, fixnum3, new Fixnum(5));
var otherArray = new Array(fixnum1, new Fixnum(2), fixnum3);
var expectedResult = new Array(fixnum1, fixnum3);
var result = array.AndAlso(otherArray);
Assert.That(result.Count, Is.EqualTo(2));
Assert.That(result, Is.EqualTo(expectedResult));
}
[Test] // push
public void TestPush()
{
var fixnum1 = new Fixnum(1);
var str = new String("string");
var nil = new NilClass();
var emptyArray = new Array();
Assert.That(emptyArray.Push(fixnum1), Is.EqualTo(new Array(fixnum1)));
var array = new Array(fixnum1, str, nil);
Assert.That(array.Push(fixnum1), Is.EqualTo(new Array(fixnum1, str, nil, fixnum1)));
}
public void TestGetter()
{
var emptyHash = new Hash();
var fixnum0 = new Fixnum(0);
var symbol = new Symbol("symbol");
Assert.That(emptyHash[fixnum0], Is.EqualTo(null));
var hash = new Hash {
[symbol] = fixnum0
};
Assert.That(hash[symbol], Is.EqualTo(fixnum0));
}
public void TestToString()
{
Assert.That(new Fixnum().ToString(), Is.EqualTo("0"));
Assert.That(new Fixnum(-100).ToString(16), Is.EqualTo("-64"));
var fixnum = new Fixnum(257);
Assert.That(fixnum.ToString(), Is.EqualTo("257"));
Assert.That(fixnum.ToString(2), Is.EqualTo("100000001"));
Assert.That(fixnum.ToString(8), Is.EqualTo("401"));
Assert.That(fixnum.ToString(16), Is.EqualTo("101"));
Assert.That(fixnum.ToString(13), Is.EqualTo("16a"));
Assert.That(fixnum.ToString(36), Is.EqualTo("75"));
}
[Test] // inspet
public void TestInspect()
{
// [1, "string", nil].to_s = "[1, \"string\", nil]"
var fixnum1 = new Fixnum(1);
var str = new String("string");
var nil = new NilClass();
var emptyArray = new Array();
Assert.That(emptyArray.Inspect, Is.EqualTo("[]"));
var array = new Array(fixnum1, str, nil);
Assert.That(array.Inspect, Is.EqualTo("[1, \"string\", nil]"));
}
[Test] // replace
public void TestReplace()
{
// [1, 2, 3].replace(['a', 'b', 'c']) = ['a', 'b', 'c']
var a = new String("a");
var b = new String("b");
var c = new String("c");
var fixnum1 = new Fixnum(1);
var fixnum2 = new Fixnum(2);
var fixnum3 = new Fixnum(3);
var array = new Array(fixnum1, fixnum2, fixnum3);
var otherArray = new Array(a, b, c);
array.Replace(otherArray);
Assert.That(array, Is.EqualTo(otherArray));
}
public void TestToArray()
{
var emptyHash = new Hash();
var emptyArray = new Array();
var fixnum0 = new Fixnum(0);
var symbol = new Symbol("symbol");
Assert.That(emptyHash.ToArray, Is.EqualTo(emptyArray));
var hash = new Hash();
var array = new Array();
array.Push(new Array(symbol, fixnum0));
hash[symbol] = fixnum0;
Assert.That(hash.ToArray, Is.EqualTo(array));
}
public void TestCreate()
{
var fixnum3 = new Fixnum(3);
Assert.That(new Array(), Is.Not.Null);
Assert.That(new Array(new iObject[0]), Is.Not.Null);
var array = new Array((int)fixnum3.Value, new Hash());
Assert.That(array, Is.Not.Null);
Assert.That(array.Count, Is.EqualTo((int)fixnum3.Value));
array = new Array((int)fixnum3.Value);
Assert.That(array, Is.Not.Null);
Assert.That(array.Count, Is.EqualTo((int)fixnum3.Value));
}
[Test] // reverse reverse!
public void TestReverse()
{
// [1, 2, 3].reverse = [3, 2, 1]
var a = new String("a");
var b = new String("b");
var c = new String("c");
var fixnum1 = new Fixnum(1);
var fixnum2 = new Fixnum(2);
var fixnum3 = new Fixnum(3);
var array = new Array(fixnum1, fixnum2, fixnum3);
var expectedResult = new Array(fixnum3, fixnum2, fixnum1);
var result = array.Reverse();
Assert.That(result, Is.EqualTo(expectedResult));
array.ReverseSelf();
Assert.That(array, Is.EqualTo(expectedResult));
}
[Test] // <<
public void TestAdd()
{
// [ 1, 2 ] << "c" << "d" << [ 3, 4 ] => [ 1, 2, "c", "d", [ 3, 4 ] ]
var fixnum1 = new Fixnum(1);
var fixnum2 = new Fixnum(2);
var fixnum3 = new Fixnum(3);
var fixnum4 = new Fixnum(4);
var c = new String("c");
var d = new String("d");
var array1 = new Array(fixnum1, fixnum2);
var array2 = new Array(fixnum3, fixnum4);
var expected = new Array(fixnum1, fixnum2, c, d, array2);
Assert.That(array1.Add(c).Add(d).Add(array2), Is.EqualTo(expected));
// TODO Assert.Throws<ArgumentError> (() => `a.<<*[1, 2, 3]` )
}
[Test] // -
public void TestMinus()
{
// [ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ] #=> [ 3, 3, 5 ]
var fixnum1 = new Fixnum(1);
var fixnum2 = new Fixnum(2);
var fixnum3 = new Fixnum(3);
var fixnum4 = new Fixnum(4);
var fixnum5 = new Fixnum(5);
var array = new Array(fixnum1, fixnum1, fixnum2, fixnum2, fixnum3, fixnum3, fixnum4, fixnum5);
var otherArray = new Array(fixnum1, fixnum2, fixnum4);
var expectedResult = new Array(fixnum3, fixnum3, fixnum5);
var result = array - otherArray;
Assert.That(result, Is.EqualTo(expectedResult));
Assert.Throws <TypeError>(() => { var a = array + (Array)null; }); // [1, 2, 3] - nil
Assert.Throws <TypeError>(() => { var a = (Array)null + array; }); // nil - [1, 2, 3]
}
public void TestIf()
{
var actual = Eval("if true then :a end");
iObject expected = new Symbol("a");
Assert.That(actual, Is.EqualTo(expected));
actual = Eval("if false then :a else 'b' end");
expected = new String("b");
Assert.That(actual, Is.EqualTo(expected));
actual = Eval("if true then :a else 'b' end");
expected = new Symbol("a");
Assert.That(actual, Is.EqualTo(expected));
actual = Eval("'a' if nil");
expected = new NilClass();
Assert.That(actual, Is.EqualTo(expected));
actual = Eval("'a' if :a");
expected = new String("a");
Assert.That(actual, Is.EqualTo(expected));
actual = Eval("if false then 1 elsif true then 2 else 3 end");
expected = new Fixnum(2);
Assert.That(actual, Is.EqualTo(expected));
actual = Eval("unless false then 10 end");
expected = new Fixnum(10);
Assert.That(actual, Is.EqualTo(expected));
actual = Eval("unless nil then 10 else 20 end");
expected = new Fixnum(10);
Assert.That(actual, Is.EqualTo(expected));
actual = Eval("unless true then 10 else 20 end");
expected = new Fixnum(20);
Assert.That(actual, Is.EqualTo(expected));
actual = Eval("10 unless nil");
expected = new Fixnum(10);
Assert.That(actual, Is.EqualTo(expected));
}
[Test] // +
public void TestPlus()
{
// [1, 2, 3] + [4, 5] = [1, 2, 3, 4, 5]
var fixnum1 = new Fixnum(1);
var fixnum2 = new Fixnum(2);
var fixnum3 = new Fixnum(3);
var fixnum4 = new Fixnum(4);
var fixnum5 = new Fixnum(5);
var array = new Array(fixnum1, fixnum2, fixnum3);
var otherArray = new Array(fixnum4, fixnum5);
var expectedResult = new Array(fixnum1, fixnum2, fixnum3, fixnum4, fixnum5);
var result = array + otherArray;
Assert.That(result, Is.EqualTo(expectedResult));
// [4, 5] + [1, 2, 3] = [4, 5, 1, 2, 3]
expectedResult = new Array(fixnum4, fixnum5, fixnum1, fixnum2, fixnum3);
result = otherArray + array;
Assert.That(result, Is.EqualTo(expectedResult));
Assert.Throws <TypeError>(() => { var a = array + (Array)null; }); // [1, 2, 3] + nil
Assert.Throws <TypeError>(() => { var a = (Array)null + array; }); // nil + [1, 2, 3]
}
