mirah 0.1.4-java → 0.2.0-java

data/test/jvm/cast_test.rb

@@ -12,67 +12,68 @@
 # 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.
+require 'test_helper'
 
 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 f2b; 1.0.as!(byte); end
+      def f2s; 1.0.as!(short); end
+      def f2c; 1.0.as!(char); end
+      def f2i; 1.0.as!(int); end
+      def f2l; 1.0.as!(long); end
+      def f2d; 1.0.as!(int); end
+
+      def i2b; 1.as!(byte); end
+      def i2s; 1.as!(short); end
+      def i2c; 1.as!(char); end
+      def i2l; 1.as!(long); end
+      def i2f; 1.as!(float); end
+      def i2d; 1.as!(int); end
+
+      def b2s; 1.as!(byte).as!(short); end
+      def b2c; 1.as!(byte).as!(char); end
+      def b2i; 1.as!(byte).as!(int); end
+      def b2l; 1.as!(byte).as!(long); end
+      def b2f; 1.as!(byte).as!(float); end
+      def b2d; 1.as!(byte).as!(double); end
+
+      def s2b; 1.as!(short).as!(byte); end
+      def s2c; 1.as!(short).as!(char); end
+      def s2i; 1.as!(short).as!(int); end
+      def s2l; 1.as!(short).as!(long); end
+      def s2f; 1.as!(short).as!(float); end
+      def s2d; 1.as!(short).as!(double); end
+
+      def c2b; 1.as!(char).as!(byte); end
+      def c2s; 1.as!(char).as!(short); end
+      def c2i; 1.as!(char).as!(int); end
+      def c2l; 1.as!(char).as!(long); end
+      def c2f; 1.as!(char).as!(float); end
+      def c2d; 1.as!(char).as!(double); end
+
+      def l2b; 1.as!(long).as!(byte); end
+      def l2c; 1.as!(long).as!(char); end
+      def l2i; 1.as!(long).as!(int); end
+      def l2l; 1.as!(long).as!(long); end
+      def l2f; 1.as!(long).as!(float); end
+      def l2d; 1.as!(long).as!(double); end
+
+      def d2b; 1.0.as!(byte); end
+      def d2s; 1.0.as!(short); end
+      def d2c; 1.0.as!(char); end
+      def d2i; 1.0.as!(int); end
+      def d2l; 1.0.as!(long); end
+      def d2f; 1.0.as!(float); end
 
       def hard_i2f(a:int)
-        float(if a < 0
+        if a < 0
           a *= -1
           a * 2
         else
           a * 2
-        end)
+        end.as! float
       end
     EOF
 
@@ -133,6 +134,22 @@ class CastTest < Test::Unit::TestCase
   end
 
   def test_array_cast
+    cls, = compile(<<-EOF)
+      def foo(a: Object)
+        bar(a.as!(String[]))
+      end
+
+      def bar(a: String[])
+        a[0]
+      end
+    EOF
+
+    assert_equal("foo", cls.foo(["foo", "bar"].to_java(:string)))
+  end
+
+
+  def test_warn_on_array_cast
+    # TODO
     cls, = compile(<<-EOF)
       def foo(a:Object)
         bar(String[].cast(a))
@@ -146,6 +163,20 @@ class CastTest < Test::Unit::TestCase
     assert_equal("foo", cls.foo(["foo", "bar"].to_java(:string)))
   end
 
+  def test_cast_array_as_primitive
+    cls, = compile(<<-EOF)
+      def foo(a:Object)
+        bar(a.as!(int[]))
+      end
+
+      def bar(a:int[])
+        a[0]
+      end
+    EOF
+
+    assert_equal(2, cls.foo([2, 3].to_java(:int)))
+  end
+
   def test_array_cast_primitive
     cls, = compile(<<-EOF)
       def foo(a:Object)
@@ -159,4 +190,46 @@ class CastTest < Test::Unit::TestCase
 
     assert_equal(2, cls.foo([2, 3].to_java(:int)))
   end
+  
+  def test_explicit_block_argument_cast_in_array_iteration
+     cls, = compile(<<-EOF)
+      def foo():int
+        list = [1,2,3]
+        m = 0
+        list.each do |x: int|
+          m += x
+        end
+        return m
+      end
+    EOF
+    assert_equal 6, cls.foo
+  end
+  
+  def test_explicit_call_cast_in_array_iteration
+     cls, = compile(<<-EOF)
+      def foo():int
+        list = [1,2,3]
+        m = 0
+        list.each do |x|
+          m = int(x) + m
+        end
+        return m
+      end
+    EOF
+    assert_equal 6, cls.foo
+  end
+
+  def test_explicit_as_macro_cast_in_array_iteration
+     cls, = compile(<<-EOF)
+      def foo():int
+        list = [1,2,3]
+        m = 0
+        list.each do |x|
+          m = x.as!(int) + m
+        end
+        return m
+      end
+    EOF
+    assert_equal 6, cls.foo
+  end
 end

data/test/jvm/closure_test.rb

@@ -0,0 +1,242 @@
+# Copyright (c) 2010-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 ClosureTest < Test::Unit::TestCase
+
+  def test_interface_defined_after_used
+    cls, = compile(%q{
+      class FooTest1
+        def self.main(argv:String[]):void
+          FooB.new.action do
+            puts "executed foo1"
+          end
+        end
+      end
+      
+      class FooB
+        def action(foo_param:Foo_Interface):void
+          foo_param.anymethod
+        end
+      end 
+      
+      interface Foo_Interface
+        def anymethod():void; end
+      end
+      
+      class FooTest2
+        def self.main(argv:String[]):void
+          FooB.new.action do
+            puts "executed foo2"
+          end
+        end
+      end
+      FooTest2.main(String[0])
+      FooTest1.main(String[0])
+    })
+    assert_run_output("executed foo2\nexecuted foo1\n", cls)
+  end
+  
+  def test_super_is_not_synthesized_when_not_necessary
+    cls, = compile(%q{
+      class Bar
+        def initialize(val:int)
+          puts "bar"
+        end
+      end
+      
+      class Foo < Bar
+        attr_accessor baz:String
+        
+        def initialize(val:int)
+          super
+          foo = 5
+          puts "foo"
+          perform do
+            puts foo
+          end
+        end
+        
+        def perform(runnable:Runnable)
+          runnable.run
+        end
+      end
+      Foo.new(3)
+    })
+    assert_run_output("bar\nfoo\n5\n", cls)
+  end
+
+  def test_lambda_and_other_closures_coexist
+    cls, = compile(%q[
+      class Foo
+      
+        def anymethod()
+          foo = 5
+          perform do
+            puts "1: #{foo}"
+          end
+          a = lambda(Runnable) do
+            puts "2: #{foo}"
+          end
+          perform(a)
+        end
+        
+        def perform(runnable:Runnable)
+          runnable.run
+        end
+      end
+      Foo.new.anymethod
+    ])
+    assert_run_output("1: 5\n2: 5\n", cls)
+  end
+
+  def test_doubly_nested_lambda
+    cls, = compile(%q[
+      class Foo
+        abstract def test(param:String); end
+      end
+      
+      class Bar < Foo
+        def test(param)
+          y = 5
+          x = lambda(Runnable) do
+            puts "so: #{param}"
+            z = lambda(Runnable) do
+              puts "hey you #{y}"
+            end
+            z.run
+          end
+          x.run
+        end
+      end
+      
+      Bar.new.test("bar")
+    ])
+    assert_run_output("so: bar\nhey you 5\n", cls)
+  end
+
+  def test_direct_invoke_on_lambda
+    cls, = compile(%q[
+      lambda(Runnable) do
+        puts "abc"
+      end.run
+    ])
+    assert_run_output("abc\n", cls)
+  end
+
+  def test_lambda_contains_methods
+    cls, = compile(%q[
+      foo = 3
+      
+      lambda(Runnable) do
+        def run
+          puts foo
+        end
+      end.run
+    ])
+    assert_run_output("3\n", cls)
+  end
+  
+  def test_closure_over_array_parameter
+    cls, = compile(%q{
+      def bar(param:byte[])
+        runnable = lambda(Runnable) do
+          puts param[0]
+        end
+        
+        runnable.run
+      end
+      
+      bar(byte[1])
+    })
+    assert_run_output("0\n", cls)
+  end
+  
+  def test_closure_with_typed_parameter
+    cls, = compile(%q{
+      class Bar
+      end
+      
+      interface Foo
+        def action(bar:Bar); end
+      end
+      
+      class FooCaller
+      
+        def with_foo(foo:Foo):void
+          foo.action(Bar.new)
+        end
+      
+        def call_with_foo
+          with_foo do |bar:Bar|
+            puts "Closure called."
+          end
+        end
+      end
+      
+      FooCaller.new.call_with_foo
+    })
+    assert_run_output("Closure called.\n", cls)
+  end
+
+  def test_deep_nested_runnable_with_binding
+    cls, = compile(%q{
+         class TestBuilder
+           def self.create(b: Runnable):void
+             b.run()
+           end
+
+           def self.main(args:String[]):void
+             level_0 = "level_0"
+             b = create do
+               level_1="level_1"
+               TestBuilder.create do
+                 level_2="level_2"
+                 TestBuilder.create do
+                   level_3="level_3"
+                   puts "#{level_0} #{level_1} #{level_2} #{level_3}"
+                  end
+                 TestBuilder.create do
+                   level_2="level_2_3"
+                   puts "#{level_0} #{level_1} #{level_2}"
+                 end
+                 puts "#{level_0} #{level_1} #{level_2}"
+               end
+             end
+           end
+         end
+
+         TestBuilder.main(String[0])
+    })
+    assert_run_output("level_0 level_1 level_2 level_3\nlevel_0 level_1 level_2_3\nlevel_0 level_1 level_2_3\n", cls)
+  end
+  
+  def test_closure_with_assignment_in_rescue
+    cls, = compile(%q{
+      foo = nil
+      t = Thread.new do
+        begin
+          raise Exception
+        rescue => e
+          foo = Integer.new(3)
+        end
+      end
+      t.start
+      t.join
+      puts foo
+    })
+    assert_run_output("3\n", cls)
+  end
+end
+

data/test/jvm/constructors_test.rb

@@ -161,8 +161,6 @@ class ConstructorsTest < Test::Unit::TestCase
       System.out.print DefaultConstructable.new.foo
     EOF
 
-    assert_output("foo") do
-      script.main(nil)
-    end
+    assert_run_output("foo", script)
   end
 end