Test status (tests run / total # of tests):
| Output | Expected |
~~~~~~~~~~~~~~~~~~~~ |
|
Test hash |
|
~~~~~~~~~~~~~~~~~~~~ |
|
6 |
|
7 |
|
1 |
|
2 |
|
"hello" |
|
"good" |
|
test native JS hash |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test yield |
|
~~~~~~~~~~~~~~~~~~~~ |
|
three_times_yield |
|
1 |
|
2 |
|
3 |
|
-- |
|
three_times_block |
|
1 |
|
2 |
|
3 |
|
-- |
|
three_times_indirect |
|
1 |
|
2 |
|
3 |
|
1 |
|
2 |
|
3 |
|
-- |
|
three_times_yield2 |
|
1 |
|
3 |
|
4 |
|
loop |
|
2 |
|
4 |
|
6 |
|
8 |
|
10 |
|
["out", 10] |
|
-- |
|
loop2 |
|
2 |
|
4 |
|
6 |
|
8 |
|
10 |
|
["out", 10] |
|
-- |
|
while-loop |
|
2 |
|
4 |
|
6 |
|
8 |
|
10 |
|
---- |
|
10 |
|
9 |
|
8 |
|
7 |
|
6 |
|
5 |
|
4 |
|
3 |
|
2 |
|
1 |
|
-- |
|
"test_proc" |
|
0 |
|
#<LocalJumpError: break from proc-closure> |
|
"before" |
|
"return_in_block before" |
|
4 |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test lebewesen |
|
~~~~~~~~~~~~~~~~~~~~ |
|
miau, ich bin Leni |
|
wau wau |
|
ich jage Leni |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test expr |
|
~~~~~~~~~~~~~~~~~~~~ |
|
1 |
|
true |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test simple output |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Hello World from RubyJS |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test if |
|
~~~~~~~~~~~~~~~~~~~~ |
|
OK |
|
OK |
|
OK |
|
OK |
|
"a" |
|
"a" |
|
true |
|
"b" |
|
false |
|
nil |
|
"a" |
|
"a" |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test class |
|
~~~~~~~~~~~~~~~~~~~~ |
|
true |
|
false |
|
false |
|
false |
|
false |
|
true |
|
false |
|
true |
|
true |
|
true |
|
true |
|
true |
|
true |
|
true |
|
false |
|
true |
|
true |
|
false |
|
"String" |
|
"NilClass" |
|
true |
|
true |
|
String |
|
T_TestClass::A |
|
T_TestClass::B |
|
T_TestClass::C |
|
T_TestClass::D |
|
T_TestClass::X |
|
"T_TestClass::X" |
|
"T_TestClass::A" |
|
"T_TestClass::B" |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test case |
|
~~~~~~~~~~~~~~~~~~~~ |
|
OKAY |
|
true |
|
true |
|
OK |
|
OKAY |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test splat |
|
~~~~~~~~~~~~~~~~~~~~ |
|
[] |
|
[] |
|
[1] |
|
[1] |
|
[1] |
|
[1, 2] |
|
[1, 2] |
|
[1, 2] |
|
[1, 1, 2] |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test string |
|
~~~~~~~~~~~~~~~~~~~~ |
|
"hello" |
|
"hallo\b\t\n" |
|
"hallo\\leute" |
|
"\"super\"" |
|
1 |
|
3 |
|
nil |
|
2 |
|
8 |
|
"h" |
|
"ha" |
|
"hallo" |
|
"0000000010" |
|
"10" |
|
"()(x" |
|
"1000000000" |
|
"10" |
|
"x()("
|
|
"abc 3 def" |
|
"\"hallo\",4.5" |
|
"harro" |
|
"harro" |
|
"harro" |
|
"hablah blaho" |
|
"ll" |
|
"ll" |
|
"ll" |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test inspect |
|
~~~~~~~~~~~~~~~~~~~~ |
|
[{"Hello"=>"Rubyconf"}]
|
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test regexp |
|
~~~~~~~~~~~~~~~~~~~~ |
|
"okay" |
|
2 |
|
"ll" |
|
nil |
|
nil |
|
"ll" |
|
"o" |
|
nil |
|
nil |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test args |
|
~~~~~~~~~~~~~~~~~~~~ |
|
0 |
|
1 |
|
"hallo" |
|
[] |
|
-- |
|
1 |
|
2 |
|
"hallo" |
|
[] |
|
-- |
|
1 |
|
2 |
|
9 |
|
[] |
|
-- |
|
1 |
|
2 |
|
9 |
|
[5] |
|
-- |
|
1 |
|
2 |
|
9 |
|
[5, 6] |
|
-- |
|
1 |
|
2 |
|
9 |
|
[5, 6, 7, 8, 9, 10, 11, 12] |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test array |
|
~~~~~~~~~~~~~~~~~~~~ |
|
"b" |
|
["a", "c"] |
|
nil |
|
test native JS array mapping |
|
[1, 2, nil, [nil, nil, 4]] |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test eql |
|
~~~~~~~~~~~~~~~~~~~~ |
|
true |
|
false |
|
false |
|
true |
|
false |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test send |
|
~~~~~~~~~~~~~~~~~~~~ |
|
send |
|
1 |
|
2 |
|
nil |
|
"in B" |
|
1 |
|
2 |
|
nil |
|
respond_to? |
|
true |
|
true |
|
true |
|
false |
|
false |
|
method_missing |
|
false |
|
"mm: blah_blah, 123" |
|
catched!!! |
|
"goood" |
|
class Method |
|
#<Method: String#to_s> |
|
"hallo" |
|
#<Method: Array#+> |
|
[1, 2, 3, 2, 3] |
|
#<Method: Array#+> |
|
[1, 2, 3] |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test range |
|
~~~~~~~~~~~~~~~~~~~~ |
|
0 |
|
2 |
|
0..2 |
|
"0..2" |
|
"0...2" |
|
0 |
|
1 |
|
2 |
|
3 |
|
4 |
|
0 |
|
1 |
|
2 |
|
3 |
|
true |
|
false |
|
false |
|
false |
|
true |
|
true |
|
false |
|
[] |
|
[-5, -4, -3, -2, -1] |
|
0 |
|
0 |
|
4 |
|
4 |
|
false |
|
1 |
|
1 |
|
5 |
|
5 |
|
true |
|
true |
|
false |
|
false |
|
true |
|
true |
|
true |
|
false |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test massign |
|
~~~~~~~~~~~~~~~~~~~~ |
|
1 |
|
2 |
|
-- |
|
1 |
|
2 |
|
-- |
|
1 |
|
2 |
|
nil |
|
-- |
|
1 |
|
2 |
|
3 |
|
-- |
|
swap |
|
1 |
|
2 |
|
2 |
|
1 |
|
-- |
|
splat1 |
|
1 |
|
2 |
|
nil |
|
[] |
|
-- |
|
splat2 |
|
1 |
|
[2] |
|
-- |
|
splat3 |
|
1 |
|
[2, 3, 4, 5] |
|
-- |
|
splat with globals |
|
nil |
|
nil |
|
1 |
|
2 |
|
-- |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test new |
|
~~~~~~~~~~~~~~~~~~~~ |
|
test |
|
~~~~~~~~~~~~~~~~~~~~ |
|
Test exception |
|
~~~~~~~~~~~~~~~~~~~~ |
|
"before block" |
|
"in block" |
|
"after block" |
|
"block" |
|
"else" |
|
#<RuntimeError: test> |
|
before begin |
|
before raise |
|
#<Exception: blah> |
|
yes |
|
ensure |
|
after begin |
|
-- |
|
abc |
|
#<RuntimeError: r> |
|
b |
|
e |
|
#<ArgumentError: wrong number of arguments (1 for 0)> |
|
require 'common'
#
# file: test/test_hash.rb
#
module T_TestHash
class TestHash
if $RUBYJS
def hash
`var el = {}; el["1"] = null; return el`
end
else
def hash
{"1" => nil}
end
end
def test
h = {"a" => 6, "b" => 7, "1" => 1, 1 => 2, "1,2" => "hello", [1,2] => "good"}
p h["a"]
p h["b"]
p h["1"]
p h[1]
p h["1,2"]
p h[[1,2]]
puts "test native JS hash"
a = hash()
#p a
end
def self.main
new.test
end
end
end
#
# file: test/test_yield.rb
#
module T_TestYield
class TestYield
def three_times_yield
yield 1
yield 2
yield 3
end
def test_three_times_yield
puts "three_times_yield"
three_times_yield {|i| p i }
puts "--"
end
def three_times_block(&block)
block.call(1)
block.call(2)
block.call(3)
end
def test_three_times_block
puts "three_times_block"
three_times_block {|i| p i }
puts "--"
end
def three_times_indirect(&block)
three_times_yield(&block)
three_times_block(&block)
end
def test_three_times_indirect
puts "three_times_indirect"
three_times_indirect {|i| p i}
puts "--"
end
def three_times_yield2
p yield(1)
p yield(2)
p yield(3)
end
def test_three_times_yield2
puts "three_times_yield2"
three_times_yield2 {|i|
if i == 1
i
else
next i+1
end
}
end
def loop
while true
yield
end
p "not reached"
end
def loop2(&block)
while true
block.call
end
p "not reached"
end
def test_loop
puts "loop"
i = 0
res = loop do
i += 1
next if i % 2 == 1
p i
break "out", i if i > 8
end
p res
puts "--"
end
def test_loop2
puts "loop2"
i = 0
res = loop2 do
i += 1
next if i % 2 == 1
p i
break "out", i if i > 8
end
p res
puts "--"
end
def test_while_loop
puts "while-loop"
i = 0
while true
i += 1
next if i % 2 == 1
p i
break if i > 8
end
puts "----"
while i > 0
p i
i -= 1
end
puts "--"
end
def return_in_block(&block)
p "return_in_block before"
block.call
p "return_in_block after"
end
def test_return_in_block
p "before"
return_in_block { return 4 }
p "after (NOT)"
end
def test_proc
p "test_proc"
a = proc { return 0 }
p a.call
a = Proc.new { break 3 }
p a.call
end
def test
test_three_times_yield
test_three_times_block
test_three_times_indirect
test_three_times_yield2
test_loop
test_loop2
test_while_loop
begin
test_proc
rescue LocalJumpError => e
p e
end
p test_return_in_block()
end
def self.main
new.test
end
end
end
#
# file: test/test_lebewesen.rb
#
module T_TestLebewesen
class TestLebewesen
def self.main
leni = Katze.new("AA-BB", "Leni")
flocki = Katze.new("AC-DC", "Flocki")
bello = Hund.new("AA-ZZ")
leni.miau
bello.wau
bello.jage(leni)
end
end
class Lebewesen
def initialize(dns)
@dns = dns
end
end
class Katze < Lebewesen
attr_reader :name
def initialize(dns, name)
super(dns)
@name = name
end
def miau
puts "miau, ich bin " + @name
end
end
class Hund < Lebewesen
def wau
puts "wau wau"
end
def jage(katze)
puts "ich jage " + katze.name
end
end
end
#
# file: test/test_expr.rb
#
module T_TestExpr
class TestExpr
def test
i = if true then 1 else 2 end
p i
i = true or return
p i
end
def self.main
new.test
end
end
end
#
# file: test/test_simple_output.rb
#
module T_TestSimpleOutput
class TestSimpleOutput
def self.main()
puts "Hello World from RubyJS"
end
end
end
#
# file: test/test_if.rb
#
module T_TestIf
class TestIf
def test
puts "OK" if true
puts "NOT OK" if false
puts "OK" unless false
puts "NOT OK" unless true
puts "OK" if true and true and (true or false) and (!false)
puts "OK" if 5 < 6 and 6 < 7
# test the "||" operator
p(false || "a") # => "a"
p(nil || "a") # => "a"
p(true || "a") # => true
p("b" || "a") # => "b"
# test the "&&" operator
p(false && "a") # => false
p(nil && "a") # => nil
p(true && "a") # => "a"
p("b" && "a") # => "a"
end
def self.main
new.test
end
end
end
#
# file: test/test_class.rb
#
module T_TestClass
module X
end
class A
include X
end
class B < A
end
class C < B
end
class D
end
class TestClass
def self.main
p A.new.instance_of?(A) # => true
p A.new.instance_of?(B) # => false
p B.new.instance_of?(A) # => false
p A.new.instance_of?(X) # => false
p B.new.instance_of?(X) # => false
p A.new.kind_of?(A) # => true
p A.new.kind_of?(B) # => false
p B.new.kind_of?(A) # => true
p A.new.kind_of?(X) # => true
p B.new.kind_of?(X) # => true
p C.new.kind_of?(X) # => true
p C.new.kind_of?(A) # => true
p C.new.kind_of?(B) # => true
p C.new.kind_of?(C) # => true
p C.new.kind_of?(D) # => false
p C.new.kind_of?(Object) # => true
p C.new.kind_of?(Kernel) # => true
p C.new.kind_of?(Class) # => false
p ("hallo".class.name)
p (nil.class.name)
p (nil.instance_of?(NilClass))
p ("hallo".instance_of?(String))
p ("hallo".class)
p A
p B
p C
p D
p X
p X.name
p A.name
p B.name
end
end
end
#
# file: test/test_case.rb
#
module T_TestCase
class TestCase
def test
case 1+1
when 1, 3
puts "NOT OKAY"
when 2
puts "OKAY"
else
puts "NOT OKAY"
end
p (Array === [])
p (RuntimeError === RuntimeError.new)
case 1
when Fixnum
puts "OK"
when 1
puts "OK"
end
case 4
when 0..3
puts "NOT OKAY"
when 1...4
puts "NOT OKAY"
when 2..4
puts "OKAY"
end
end
def self.main
new.test
end
end
end
#
# file: test/test_splat.rb
#
module T_TestSplat
class TestSplat
def m(*args)
p args
end
def self.main
obj = new()
obj.m
obj.m(*[])
obj.m(1)
obj.m(*[1])
obj.m(1,*[])
obj.m(1,2)
obj.m(*[1,2])
obj.m(1,*[2])
obj.m(1,*[1,2])
end
end
end
#
# file: test/test_string.rb
#
module T_TestString
class TestString
def test
# inspect
p "hello"
p "hallo\b\t\n"
p "hallo\\leute"
p '"super"'
# index
p "hello".index('e')
p "hello".index('lo')
p "hello".index('a')
p "hello hello".index('ll')
p "hello hello".index('ll', 3)
# []
p "hallo"[0,1]
p "hallo"[0,2]
p "hallo"[0,5]
p ("10".rjust(10, "0"))
p ("10".rjust(1, "blah"))
p ("x".rjust(4, "()"))
p ("10".ljust(10, "0"))
p ("10".ljust(1, "blah"))
p ("x".ljust(4, "()"))
# string interpolation
p "abc #{ 1 + 2 } def"
@a = "hallo".inspect
@b = 4.5
p "#{@a},#{@b}"
# gsub
s = "hallo".gsub("l", "r")
p s
s = "hallo".gsub(/ll/, "rr")
p s
s = "hallo".gsub(/l/) { "r" }
p s
s = "hallo".gsub(/ll/) { "blah blah" }
p s
"hallllllo".gsub(/(l)l/) {|i| p i }
end
def self.main
new.test
end
end
end
#
# file: test/test_inspect.rb
#
module T_TestInspect
class TestInspect
def test
o = [{"Hello"=>'Rubyconf'}]
puts o.inspect
end
def self.main
new.test
end
end
end
#
# file: test/test_regexp.rb
#
module T_TestRegexp
class TestRegexp
def test
p "okay" if "hallo" =~ /ll/
pos = "hallo" =~ /ll/
p pos
"hallo" =~ /(ll)/
p $1
p $2
p $3
"hallo" =~ /a(ll)(o)/
p $1
p $2
p $3
p $4
end
def self.main
new.test
end
end
end
#
# file: test/test_args.rb
#
module T_TestArgs
class TestArgs
def m(a, b=1, c="hallo", *args)
p a
p b
p c
p args
end
def self.main
obj = new()
obj.m(0)
puts "--"
obj.m(1,2)
puts "--"
obj.m(1,2,9)
puts "--"
obj.m(1,2,9,5)
puts "--"
obj.m(1,2,9,5,6)
puts "--"
obj.m(1,2,9,5,6,7,8,9,10,11,12)
end
end
end
#
# file: test/test_array.rb
#
module T_TestArray
class TestArray
if $RUBYJS
def array
[1, 2, `null`, [`null`, `null`, 4]]
end
else
def array
[1, 2, nil, [nil, nil, 4]]
end
end
def test
# delete
a = [ "a", "b", "b", "b", "c" ]
p a.delete("b") #=> "b"
p a #=> ["a", "c"]
p a.delete("z") #=> nil
puts "test native JS array mapping"
p array()
end
def self.main
new.test
end
end
end
#
# file: test/test_eql.rb
#
module T_TestEql
class TestEql
def self.main
p "a".eql?("a") # => true
p "a".eql?(1) # => false
p "1".eql?(1) # => false
p [1,2].eql?([1,2]) # => true
p 1.eql?("1") # => false
end
end
end
#
# file: test/test_send.rb
#
module T_TestSend
class A
def a_method(a,b)
p a, b
end
end
class B < A
def a_method(b, a)
p "in B"
super
end
def c_method(b)
end
end
class C
def method_missing(id, *args, &block)
p "mm: #{id}, #{args}"
end
end
class TestSend
def self.main
puts "send"
p A.new.send("a_method", 1, 2)
p B.new.send("a_method", 1, 2)
puts "respond_to?"
p A.new.respond_to?(:a_method)
p A.new.respond_to?(:to_s)
p A.new.respond_to?(:inspect)
p A.new.respond_to?(:b_method)
p A.new.respond_to?(:c_method)
puts "method_missing"
p C.new.respond_to?(:blah_blah)
C.new.blah_blah(1,2,3)
begin
A.new.blah_blah
puts "FAILURE?"
rescue NoMethodError
puts "catched!!!"
end
begin
A.not_a_method
rescue NoMethodError
p "goood"
end
puts "class Method"
m = "hallo".method(:to_s)
p m
p m.call
a = [1,2,3]
m = a.method(:+)
p m
p m.call([2,3])
p m
p a
end
end
end
#
# file: test/test_range.rb
#
module T_TestRange
class TestRange
def test
a = Range.new(0,2)
p a.first
p a.last
p a
p ((0..2).to_s)
p ((0...2).to_s)
(0..4).each do |i| p i end
(0...4).each do |i| p i end
(-1..-4).each do |i| p i end
p ((0..4).include?(4))
p ((0..4).include?(5))
p ((0...4).include?(5))
p ((0...4).include?(4))
p ((0...4).include?(3))
p ((0...4).include?(0))
p ((0...4).include?(-1))
p ((-1..-5).to_a)
p ((-5..-1).to_a)
r = Range.new(0, 4)
p r.first
p r.begin
p r.last
p r.end
p r.exclude_end?
r = 1...5
p r.first
p r.begin
p r.last
p r.end
p r.exclude_end?
p (false == false)
p (false == true)
p (true == false)
p (true == true)
p ((0..2) == (0..2))
p ((0..2) == Range.new(0,2))
p ((0..2) == (0...2))
end
def self.main
new.test
end
end
end
#
# file: test/test_massign.rb
#
module T_TestMassign
class TestMassign
def self.main
a, b = 1, 2
p a
p b
puts "--"
a, b = 1, 2, 3
p a
p b
puts "--"
c = 5
a, b, c = 1, 2
p a
p b
p c
puts "--"
@a, b, @c = 1, 2, 3
p @a
p b
p @c
puts "--"
puts "swap"
# swap
a, b = 1, 2
p a
p b
a, b = b, a
p a
p b
puts "--"
puts "splat1"
a, b, c, *d = 1, 2
p a
p b
p c
p d
puts "--"
puts "splat2"
a, *b = 1, 2
p a
p b
puts "--"
puts "splat3"
a, *b = 1, 2, 3, 4, 5
p a
p b
puts "--"
puts "splat with globals"
p $a
p $b
$a, $b = 1, 2
p $a
p $b
puts "--"
#TODO: a, b = 1 (to_ary)
end
end
end
#
# file: test/test_new.rb
#
module T_TestNew
class TestNew
def initialize
end
def test
puts "test"
end
def self.main()
new().test
end
end
end
#
# file: test/test_exception.rb
#
module T_TestException
class TestException
def self.main
p "before block"
begin
p "in block"
end
p "after block"
###
begin
p "block"
rescue
p "rescue"
rescue Exception => a
p "another rescue"
p a
else
p "else"
end
p RuntimeError.new("test")
puts "before begin"
begin
puts "before raise"
raise Exception, "blah"
puts "after raise"
rescue
puts "noooo"
rescue Exception => a
p a
puts "yes"
ensure
puts "ensure"
end
puts "after begin"
puts "--"
begin
puts "abc"
raise "r"
rescue
p $!
puts "b"
ensure
puts "e"
end
#
# Test arity checks
#
begin
p("hallo".to_s(2))
rescue ArgumentError => a
p a
end
end
end
end
class TestSuite
def self.main
begin
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test hash'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestHash::TestHash.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test yield'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestYield::TestYield.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test lebewesen'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestLebewesen::TestLebewesen.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test expr'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestExpr::TestExpr.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test simple output'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestSimpleOutput::TestSimpleOutput.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test if'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestIf::TestIf.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test class'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestClass::TestClass.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test case'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestCase::TestCase.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test splat'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestSplat::TestSplat.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test string'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestString::TestString.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test inspect'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestInspect::TestInspect.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test regexp'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestRegexp::TestRegexp.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test args'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestArgs::TestArgs.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test array'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestArray::TestArray.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test eql'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestEql::TestEql.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test send'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestSend::TestSend.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test range'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestRange::TestRange.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test massign'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestMassign::TestMassign.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test new'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestNew::TestNew.main
puts '~~~~~~~~~~~~~~~~~~~~'
puts 'Test exception'
puts '~~~~~~~~~~~~~~~~~~~~'
T_TestException::TestException.main
rescue Exception => a
p "unhandled exception"
p a
end
end
end
TestSuite.main unless $RUBYJS