mirah 0.0.12-java → 0.1.0-java

data/test/jvm/cast_test.rb

@@ -0,0 +1,162 @@
+# Copyright (c) 2013 The Mirah project authors. All Rights Reserved.
+# All contributing project authors may be found in the NOTICE file.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class CastTest < Test::Unit::TestCase
+
+  def test_cast
+    cls, = compile(<<-EOF)
+      def f2b; byte(1.0); end
+      def f2s; short(1.0); end
+      def f2c; char(1.0); end
+      def f2i; int(1.0); end
+      def f2l; long(1.0); end
+      def f2d; int(1.0); end
+
+      def i2b; byte(1); end
+      def i2s; short(1); end
+      def i2c; char(1); end
+      def i2l; long(1); end
+      def i2f; float(1); end
+      def i2d; int(1); end
+
+      def b2s; short(byte(1)); end
+      def b2c; char(byte(1)); end
+      def b2i; int(byte(1)); end
+      def b2l; long(byte(1)); end
+      def b2f; float(byte(1)); end
+      def b2d; double(byte(1)); end
+
+      def s2b; byte(short(1)); end
+      def s2c; char(short(1)); end
+      def s2i; int(short(1)); end
+      def s2l; long(short(1)); end
+      def s2f; float(short(1)); end
+      def s2d; double(short(1)); end
+
+      def c2b; byte(char(1)); end
+      def c2s; short(char(1)); end
+      def c2i; int(char(1)); end
+      def c2l; long(char(1)); end
+      def c2f; float(char(1)); end
+      def c2d; double(char(1)); end
+
+      def l2b; byte(long(1)); end
+      def l2c; char(long(1)); end
+      def l2i; int(long(1)); end
+      def l2l; long(long(1)); end
+      def l2f; float(long(1)); end
+      def l2d; double(long(1)); end
+
+      def d2b; byte(1.0); end
+      def d2s; short(1.0); end
+      def d2c; char(1.0); end
+      def d2i; int(1.0); end
+      def d2l; long(1.0); end
+      def d2f; float(1.0); end
+
+      def hard_i2f(a:int)
+        float(if a < 0
+          a *= -1
+          a * 2
+        else
+          a * 2
+        end)
+      end
+    EOF
+
+    assert_equal 1, cls.b2s
+    assert_equal 1, cls.b2c
+    assert_equal 1, cls.b2i
+    assert_equal 1, cls.b2l
+    assert_equal 1.0, cls.b2f
+    assert_equal 1.0, cls.b2d
+
+    assert_equal 1, cls.s2b
+    assert_equal 1, cls.s2c
+    assert_equal 1, cls.s2i
+    assert_equal 1, cls.s2l
+    assert_equal 1.0, cls.s2f
+    assert_equal 1.0, cls.s2d
+
+    assert_equal 1, cls.c2b
+    assert_equal 1, cls.c2s
+    assert_equal 1, cls.c2i
+    assert_equal 1, cls.c2l
+    assert_equal 1.0, cls.c2f
+    assert_equal 1.0, cls.c2d
+
+    assert_equal 1, cls.i2b
+    assert_equal 1, cls.i2s
+    assert_equal 1, cls.i2c
+    assert_equal 1, cls.i2l
+    assert_equal 1.0, cls.i2f
+    assert_equal 1.0, cls.i2d
+
+    assert_equal 1, cls.f2b
+    assert_equal 1, cls.f2s
+    assert_equal 1, cls.f2c
+    assert_equal 1, cls.f2i
+    assert_equal 1, cls.f2l
+    assert_equal 1.0, cls.f2d
+
+    assert_equal 1, cls.d2b
+    assert_equal 1, cls.d2s
+    assert_equal 1, cls.d2c
+    assert_equal 1, cls.d2i
+    assert_equal 1, cls.d2l
+    assert_equal 1.0, cls.d2f
+
+    assert_equal 2.0, cls.hard_i2f(1)
+    assert_equal 4.0, cls.hard_i2f(-2)
+  end
+
+  def test_java_lang_cast
+    cls, = compile(<<-EOF)
+      def foo(a:Object)
+        Integer(a).intValue
+      end
+    EOF
+
+    assert_equal(2, cls.foo(java.lang.Integer.new(2)))
+  end
+
+  def test_array_cast
+    cls, = compile(<<-EOF)
+      def foo(a:Object)
+        bar(String[].cast(a))
+      end
+
+      def bar(a:String[])
+        a[0]
+      end
+    EOF
+
+    assert_equal("foo", cls.foo(["foo", "bar"].to_java(:string)))
+  end
+
+  def test_array_cast_primitive
+    cls, = compile(<<-EOF)
+      def foo(a:Object)
+        bar(int[].cast(a))
+      end
+
+      def bar(a:int[])
+        a[0]
+      end
+    EOF
+
+    assert_equal(2, cls.foo([2, 3].to_java(:int)))
+  end
+end

data/test/jvm/constructors_test.rb

@@ -16,12 +16,12 @@
 class ConstructorsTest < Test::Unit::TestCase
   def test_constructor
     cls, = compile(
-        "class InitializeTest;def initialize;puts 'Constructed';end;end")
+        "class InitializeTest;def initialize;System.out.println 'Constructed';end;end")
     assert_output("Constructed\n") do
       cls.new
     end
   end
-  
+
   def test_constructor_chaining
     foo, = compile(<<-EOF)
       class Foo5
@@ -57,18 +57,17 @@ class ConstructorsTest < Test::Unit::TestCase
     sc_a, sc_b = compile(<<-EOF)
       class SC_A
         def initialize(a:int)
-          puts "A"
+          System.out.println "A"
         end
       end
 
       class SC_B < SC_A
         def initialize
           super(0)
-          puts "B"
+          System.out.println "B"
         end
       end
     EOF
-
     assert_output("A\nB\n") do
       sc_b.new
     end
@@ -85,8 +84,19 @@ class ConstructorsTest < Test::Unit::TestCase
 
   def test_inexact_constructor
     # FIXME: this is a stupid test
-    cls, = compile(
-        "class EmptyEmpty; def self.empty_empty; t = Thread.new(Thread.new); t.start; begin; t.join; rescue InterruptedException; end; puts 'ok'; end; end")
+    cls, = compile(<<-EOF)
+      class EmptyEmpty
+        def self.empty_empty
+          t = Thread.new(Thread.new)
+          t.start
+          begin
+            t.join
+          rescue InterruptedException
+          end
+          System.out.println 'ok'
+        end
+      end
+    EOF
     assert_output("ok\n") do
       cls.empty_empty
     end
@@ -100,7 +110,7 @@ class ConstructorsTest < Test::Unit::TestCase
         end
       end
 
-      print DefaultConstructable.new.foo
+      System.out.print DefaultConstructable.new.foo
     EOF
 
     assert_output("foo") do

data/test/jvm/enumerable_test.rb

@@ -14,7 +14,7 @@
 # limitations under the License.
 
 class EnumerableTest < Test::Unit::TestCase
-  def test_for
+  def test_for_in_int_array
     cls, = compile(<<-EOF)
       def foo
         a = int[3]
@@ -25,6 +25,7 @@ class EnumerableTest < Test::Unit::TestCase
         count
       end
     EOF
+    assert_equal(3, cls.foo)
 
     cls, = compile(<<-EOF)
       def foo(a:int[])
@@ -37,11 +38,13 @@ class EnumerableTest < Test::Unit::TestCase
     EOF
 
     assert_equal(9, cls.foo([2, 3, 4].to_java(:int)))
+  end
 
+  def test_each_iterable
     cls, = compile(<<-EOF)
       def foo(a:Iterable)
         a.each do |x|
-          puts x
+          System.out.println x
         end
       end
     EOF
@@ -53,12 +56,14 @@ class EnumerableTest < Test::Unit::TestCase
       list << "3"
       cls.foo(list)
     end
+  end
 
+  def test_each_arraylist
     cls, = compile(<<-EOF)
       import java.util.ArrayList
       def foo(a:ArrayList)
         a.each do |x|
-          puts x
+          System.out.println x
         end
       end
     EOF
@@ -70,10 +75,12 @@ class EnumerableTest < Test::Unit::TestCase
       list << "3"
       cls.foo(list)
     end
+  end
 
+  def test_each_int_arry
     cls, = compile(<<-EOF)
       def foo(a:int[])
-        a.each {|x| x += 1;puts x; redo if x == 2}
+        a.each {|x| x += 1;System.out.println x; redo if x == 2}
       end
     EOF
 
@@ -82,7 +89,7 @@ class EnumerableTest < Test::Unit::TestCase
     end
   end
 
-  def test_all
+  def test_all_int_array
     cls, = compile(<<-EOF)
       def foo(a:int[])
         a.all? {|x| x % 2 == 0}
@@ -91,7 +98,9 @@ class EnumerableTest < Test::Unit::TestCase
 
     assert_equal(false, cls.foo([2, 3, 4].to_java(:int)))
     assert_equal(true, cls.foo([2, 0, 4].to_java(:int)))
+  end
 
+  def test_all_string_array
     cls, = compile(<<-EOF)
       def foo(a:String[])
         a.all?
@@ -105,7 +114,7 @@ class EnumerableTest < Test::Unit::TestCase
   def test_downto
     cls, = compile(<<-EOF)
       def foo(i:int)
-        i.downto(1) {|x| puts x }
+        i.downto(1) {|x| System.out.println x }
       end
     EOF
 
@@ -117,7 +126,7 @@ class EnumerableTest < Test::Unit::TestCase
   def test_upto
     cls, = compile(<<-EOF)
       def foo(i:int)
-        i.upto(3) {|x| puts x }
+        i.upto(3) {|x| System.out.println x }
       end
     EOF
 
@@ -129,7 +138,7 @@ class EnumerableTest < Test::Unit::TestCase
   def test_times
     cls, = compile(<<-EOF)
       def foo(i:int)
-        i.times {|x| puts x }
+        i.times {|x| System.out.println x }
       end
     EOF
 
@@ -139,7 +148,7 @@ class EnumerableTest < Test::Unit::TestCase
 
     cls, = compile(<<-EOF)
       def foo(i:int)
-        i.times { puts "Hi" }
+        i.times { System.out.println "Hi" }
       end
     EOF
 
@@ -151,85 +160,101 @@ class EnumerableTest < Test::Unit::TestCase
   def test_general_loop
     cls, = compile(<<-EOF)
       def foo(x:boolean)
-        a = ""
-        __gloop__(nil, x, true, nil, nil) {a += "<body>"}
-        a
+        a = StringBuilder.new
+        while x
+          a.append "<body>"
+        end
+        a.toString
       end
     EOF
     assert_equal("", cls.foo(false))
 
     cls, = compile(<<-EOF)
       def foo
-        a = ""
-        __gloop__(nil, false, false, nil, nil) {a += "<body>"}
-        a
+        a = StringBuilder.new
+        begin
+          a.append "<body>"
+        end while false
+        a.toString
       end
     EOF
     assert_equal("<body>", cls.foo)
 
     cls, = compile(<<-EOF)
       def foo(x:boolean)
-        a = ""
-        __gloop__(a += "<init>", x, true, a += "<pre>", a += "<post>") do
-          a += "<body>"
+        a = StringBuilder.new
+        while x
+          init {a.append "<init>"}
+          pre {a.append "<pre>"}
+          post {a.append "<post>"}
+          a.append "<body>"
         end
-        a
+        a.toString
       end
     EOF
     assert_equal("<init>", cls.foo(false))
 
     cls, = compile(<<-EOF)
       def foo
-        a = ""
-        __gloop__(a += "<init>", false, false, a += "<pre>", a += "<post>") do
-          a += "<body>"
-        end
-        a
+        a = StringBuilder.new
+        begin
+          init {a.append "<init>"}
+          pre {a.append "<pre>"}
+          post {a.append "<post>"}
+          a.append "<body>"
+        end while false
+        a.toString
       end
     EOF
     assert_equal("<init><pre><body><post>", cls.foo)
 
     cls, = compile(<<-EOF)
       def foo
-        a = ""
-        __gloop__(a += "<init>", false, false, a += "<pre>", a += "<post>") do
-          a += "<body>"
+        a = StringBuilder.new
+        begin
+          init {a.append "<init>"}
+          pre {a.append "<pre>"}
+          post {a.append "<post>"}
+          a.append "<body>"
           redo if a.length < 20
-        end
-        a
+        end while false
+        a.toString
       end
     EOF
     assert_equal( "<init><pre><body><body><post>", cls.foo)
 
     cls, = compile(<<-EOF)
       def foo
-        a = ""
-        __gloop__(a += "<init>", a.length < 20, true, a += "<pre>", a += "<post>") do
+        a = StringBuilder.new
+        while a.length < 20
+          init {a.append "<init>"}
+          pre {a.append "<pre>"}
+          post {a.append "<post>"}
           next if a.length < 17
-          a += "<body>"
+          a.append "<body>"
         end
-        a
+        a.toString
       end
     EOF
     assert_equal("<init><pre><post><pre><body><post>", cls.foo)
   end
 
-  
+
     def test_each
     cls, = compile(<<-EOF)
       def foo
-        [1,2,3].each {|x| puts x}
+        [1,2,3].each {|x| System.out.println x}
       end
     EOF
     assert_output("1\n2\n3\n") do
       cls.foo
     end
   end
-  
+
   def test_each_without_block_arguments
     cls, = compile(<<-EOF)
       def foo
-        [1,2,3].each { puts :thrice }
+        [1,2,3].each { System.out.println :thrice }
       end
     EOF
     assert_output("thrice\nthrice\nthrice\n") do
@@ -242,8 +267,8 @@ class EnumerableTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       import java.lang.Integer
       def foo
-        puts [1,2,3].any?
-        puts [1,2,3].any? {|x| Integer(x).intValue > 3}
+        System.out.println [1,2,3].any?
+        System.out.println [1,2,3].any? {|x| Integer(x).intValue > 3}
       end
     EOF
     assert_output("true\nfalse\n") do
@@ -255,13 +280,22 @@ class EnumerableTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       import java.lang.Integer
       def foo
-        puts [1,2,3].all?
-        puts [1,2,3].all? {|x| Integer(x).intValue > 3}
+        System.out.println [1,2,3].all?
+        System.out.println [1,2,3].all? {|x| Integer(x).intValue > 3}
       end
     EOF
     assert_output("true\nfalse\n") do
       cls.foo
     end
+
+    cls, = compile(<<-EOF)
+      def foo
+        System.out.println [1,2,3].all? {|x| x.intValue > 3}
+      end
+    EOF
+    assert_output("false\n") do
+      cls.foo
+    end
   end
 
   def test_mirah_iterable
@@ -291,14 +325,13 @@ class EnumerableTest < Test::Unit::TestCase
         end
 
         def self.test(x:String)
-          MyIterator.new(x).each {|y| puts y}
+          MyIterator.new(x).each {|y| System.out.println y}
         end
       end
     EOF
-    
+
     assert_output("Hi\n") do
       cls.test("Hi")
     end
   end
-
 end