mirah 0.0.9-java → 0.0.10-java

data/test/jvm/test_jvm_compiler.rb

@@ -14,6 +14,13 @@
 # limitations under the License.
 
 class TestJVMCompiler < Test::Unit::TestCase
+  def assert_raise_java(type, message="")
+    ex = assert_raise(NativeException) do
+      yield
+    end
+    assert_equal type, ex.cause.class
+    assert_equal message, ex.cause.message.to_s
+  end
 
   def test_local
     cls, = compile("def foo; a = 1; a; end")
@@ -876,21 +883,13 @@ class TestJVMCompiler < Test::Unit::TestCase
     end
   end
 
-  def assert_throw(type, message="")
-    ex = assert_raise(NativeException) do
-      yield
-    end
-    assert_equal type, ex.cause.class
-    assert_equal message, ex.cause.message.to_s
-  end
-
   def test_raise
     cls, = compile(<<-EOF)
       def foo
         raise
       end
     EOF
-    assert_throw(java.lang.RuntimeException) do
+    assert_raise_java(java.lang.RuntimeException) do
       cls.foo
     end
 
@@ -899,7 +898,7 @@ class TestJVMCompiler < Test::Unit::TestCase
         raise "Oh no!"
       end
     EOF
-    ex = assert_throw(java.lang.RuntimeException, 'Oh no!') do
+    ex = assert_raise_java(java.lang.RuntimeException, 'Oh no!') do
       cls.foo
     end
 
@@ -908,7 +907,7 @@ class TestJVMCompiler < Test::Unit::TestCase
         raise IllegalArgumentException
       end
     EOF
-    ex = assert_throw(java.lang.IllegalArgumentException) do
+    ex = assert_raise_java(java.lang.IllegalArgumentException) do
       cls.foo
     end
 
@@ -918,7 +917,7 @@ class TestJVMCompiler < Test::Unit::TestCase
         raise Exception, "oops"
       end
     EOF
-    ex = assert_throw(java.lang.Exception, "oops") do
+    ex = assert_raise_java(java.lang.Exception, "oops") do
       cls.foo
     end
 
@@ -928,128 +927,9 @@ class TestJVMCompiler < Test::Unit::TestCase
         raise Throwable.new("darn")
       end
     EOF
-    ex = assert_throw(java.lang.Throwable, "darn") do
-      cls.foo
-    end
-  end
-
-  def test_rescue
-    cls, = compile(<<-EOF)
-      def foo
-        begin
-          puts "body"
-        rescue
-          puts "rescue"
-        end
-      end
-    EOF
-
-    output = capture_output do
-      cls.foo
-    end
-    assert_equal("body\n", output)
-
-    cls, = compile(<<-EOF)
-      def foo
-        begin
-          puts "body"
-          raise
-        rescue
-          puts "rescue"
-        end
-      end
-    EOF
-
-    output = capture_output do
-      cls.foo
-    end
-    assert_equal("body\nrescue\n", output)
-
-    cls, = compile(<<-EOF)
-      def foo(a:int)
-        begin
-          puts "body"
-          if a == 0
-            raise IllegalArgumentException
-          else
-            raise
-          end
-        rescue IllegalArgumentException
-          puts "IllegalArgumentException"
-        rescue
-          puts "rescue"
-        end
-      end
-    EOF
-
-    output = capture_output do
-      cls.foo(1)
-      cls.foo(0)
-    end
-    assert_equal("body\nrescue\nbody\nIllegalArgumentException\n", output)
-
-    cls, = compile(<<-EOF)
-      def foo(a:int)
-        begin
-          puts "body"
-          if a == 0
-            raise IllegalArgumentException
-          elsif a == 1
-            raise Throwable
-          else
-            raise
-          end
-        rescue IllegalArgumentException, RuntimeException
-          puts "multi"
-        rescue Throwable
-          puts "other"
-        end
-      end
-    EOF
-
-    output = capture_output do
-      cls.foo(0)
-      cls.foo(1)
-      cls.foo(2)
-    end
-    assert_equal("body\nmulti\nbody\nother\nbody\nmulti\n", output)
-
-    cls, = compile(<<-EOF)
-      def foo
-        begin
-          raise "foo"
-        rescue => ex
-          puts ex.getMessage
-        end
-      end
-    EOF
-
-    output = capture_output do
+    ex = assert_raise_java(java.lang.Throwable, "darn") do
       cls.foo
     end
-    assert_equal("foo\n", output)
-
-
-    cls, = compile(<<-EOF)
-      def foo(x:boolean)
-        throws Exception
-        if x
-          raise Exception, "x"
-        end
-      rescue Exception
-        "x"
-      else
-        raise Exception, "!x"
-      end
-    EOF
-
-    assert_equal "x", cls.foo(true)
-    begin
-      cls.foo(false)
-      fail
-    rescue java.lang.Exception => ex
-      assert_equal "java.lang.Exception: !x", ex.message
-    end
   end
 
   def test_ensure
@@ -1654,38 +1534,6 @@ class TestJVMCompiler < Test::Unit::TestCase
       cls.main(nil)
     end
   end
-
-  def test_annotations
-    deprecated = java.lang.Deprecated.java_class
-    cls, = compile(<<-EOF)
-      $Deprecated
-      def foo
-        'foo'
-      end
-    EOF
-
-    assert_not_nil cls.java_class.java_method('foo').annotation(deprecated)
-    assert_nil cls.java_class.annotation(deprecated)
-
-    script, cls = compile(<<-EOF)
-      $Deprecated
-      class Annotated
-      end
-    EOF
-    assert_not_nil cls.java_class.annotation(deprecated)
-
-    cls, = compile(<<-EOF)
-      class AnnotatedField
-        def initialize
-          $Deprecated
-          @foo = 1
-        end
-      end
-    EOF
-
-    assert_not_nil cls.java_class.declared_fields[0].annotation(deprecated)
-  end
-
   def test_super
     cls, = compile(<<-EOF)
       class Foo
@@ -2191,6 +2039,33 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal("foo", cls.set("foo"))
   end
 
+  def test_hash_with_value_from_static_method
+    cls, = compile(<<-EOF)
+      def foo1
+        {a: a, b:"B"}
+      end
+      def a
+        return "A"
+      end
+    EOF
+    assert_equal("A", cls.foo1["a"])
+  end
+
+  def test_hash_with_value_from_instance_method
+    cls, = compile(<<-EOF)
+      class HashTesty
+        def foo1
+          {a: a, b:"B"}
+        end
+        def a
+          return "A"
+        end
+      end
+    EOF
+    assert_equal("A", cls.new.foo1["a"])
+  end
+
+
   def test_loop_in_ensure
     cls, = compile(<<-EOF)
     begin
@@ -2246,11 +2121,8 @@ class TestJVMCompiler < Test::Unit::TestCase
       a.foo
       a.bar
     end
-    begin
+    assert_raise_java java.lang.InstantiationException do
       abstract_class.new
-      fail "Expected InstantiationException"
-    rescue java.lang.InstantiationException
-      # expected
     end
   end
 
@@ -2478,29 +2350,9 @@ class TestJVMCompiler < Test::Unit::TestCase
     EOF
   end
 
-  def test_empty_rescues
-    cls, = compile(<<-EOF)
-      begin
-      rescue
-        nil
-      end
-    EOF
-
-    cls, = compile(<<-EOF)
-      begin
-        ""
-      rescue
-        nil
-      end
-      nil
-    EOF
-  end
-  
   def test_missing_class_with_block_raises_inference_error
     assert_raises Typer::InferenceError do
       compile("Interface Implements_Go do; end")
     end
   end
-
-
 end

data/test/jvm/test_macros.rb

@@ -144,4 +144,17 @@ class TestMacros < Test::Unit::TestCase
     end
   end
 
+  def test_method_def_after_macro_def_with_same_name_raises_error
+    assert_raises Mirah::InferenceError do
+      compile(<<-EOF)
+        macro def foo
+          quote { puts :z }
+        end
+        def foo
+          :bar
+        end
+      EOF
+    end
+
+  end
 end

data/test/jvm/test_rescue.rb

@@ -0,0 +1,152 @@
+# Copyright (c) 2010 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 TestRescue < Test::Unit::TestCase
+
+  def test_rescue
+    cls, = compile(<<-EOF)
+      def foo
+        begin
+          puts "body"
+        rescue
+          puts "rescue"
+        end
+      end
+    EOF
+
+    output = capture_output do
+      cls.foo
+    end
+    assert_equal("body\n", output)
+
+    cls, = compile(<<-EOF)
+      def foo
+        begin
+          puts "body"
+          raise
+        rescue
+          puts "rescue"
+        end
+      end
+    EOF
+
+    output = capture_output do
+      cls.foo
+    end
+    assert_equal("body\nrescue\n", output)
+
+    cls, = compile(<<-EOF)
+      def foo(a:int)
+        begin
+          puts "body"
+          if a == 0
+            raise IllegalArgumentException
+          else
+            raise
+          end
+        rescue IllegalArgumentException
+          puts "IllegalArgumentException"
+        rescue
+          puts "rescue"
+        end
+      end
+    EOF
+
+    output = capture_output do
+      cls.foo(1)
+      cls.foo(0)
+    end
+    assert_equal("body\nrescue\nbody\nIllegalArgumentException\n", output)
+
+    cls, = compile(<<-EOF)
+      def foo(a:int)
+        begin
+          puts "body"
+          if a == 0
+            raise IllegalArgumentException
+          elsif a == 1
+            raise Throwable
+          else
+            raise
+          end
+        rescue IllegalArgumentException, RuntimeException
+          puts "multi"
+        rescue Throwable
+          puts "other"
+        end
+      end
+    EOF
+
+    output = capture_output do
+      cls.foo(0)
+      cls.foo(1)
+      cls.foo(2)
+    end
+    assert_equal("body\nmulti\nbody\nother\nbody\nmulti\n", output)
+
+    cls, = compile(<<-EOF)
+      def foo
+        begin
+          raise "foo"
+        rescue => ex
+          puts ex.getMessage
+        end
+      end
+    EOF
+
+    output = capture_output do
+      cls.foo
+    end
+    assert_equal("foo\n", output)
+
+
+    cls, = compile(<<-EOF)
+      def foo(x:boolean)
+        throws Exception
+        if x
+          raise Exception, "x"
+        end
+      rescue Exception
+        "x"
+      else
+        raise Exception, "!x"
+      end
+    EOF
+
+    assert_equal "x", cls.foo(true)
+    ex = assert_raise NativeException do
+      cls.foo(false)
+    end
+    assert_equal "java.lang.Exception: !x", ex.message
+  end
+
+  def test_empty_rescues
+    cls, = compile(<<-EOF)
+      begin
+      rescue
+        nil
+      end
+    EOF
+
+    cls, = compile(<<-EOF)
+      begin
+        ""
+      rescue
+        nil
+      end
+      nil
+    EOF
+  end
+end