mirah 0.1.4-java → 0.2.0-java

data/test/jvm/extensions/hash_extensions_test.rb

@@ -0,0 +1,56 @@
+# 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 HashExtensionsTest < Test::Unit::TestCase
+
+  def test_hash_each_untyped
+    cls, = compile(%q{
+    	res = java::util::TreeSet.new # stable sort order of the results
+    	
+      {
+        a: "b",
+        "c" => "d",
+        "e" => 3,
+        [4] => "h"
+      }.each do |k,v|
+        res.add("#{v},#{k}")
+      end
+      	
+      res.each do |r|
+      	puts r
+      end
+    })
+    assert_run_output("3,e\nb,a\nd,c\nh,[4]\n", cls)
+  end
+
+  def test_hash_each_typed
+    cls, = compile(%q{
+    	res = java::util::TreeSet.new # stable sort order of the results
+
+      {
+        "a" => 3,
+        "b" => 2
+      }.each do |k:String,v:int|
+        res.add("#{v+1},#{k}")
+      end
+
+      res.each do |r|
+      	puts r
+      end
+    })
+    assert_run_output("3,b\n4,a\n", cls)
+  end
+end
+

data/test/jvm/extensions/list_extensions_test.rb

@@ -0,0 +1,143 @@
+class ListExtensionsTest < Test::Unit::TestCase
+  def test_empty_q
+    cls, = compile(<<-EOF)
+      x = []
+      puts x.empty?
+    EOF
+    assert_run_output("true\n", cls)
+  end
+
+  def test_bracket_getter
+    cls, = compile(<<-EOF)
+      x = [1,2]
+      puts x[0]
+    EOF
+    assert_run_output("1\n", cls)
+  end
+
+  def test_bracket_assignment
+    cls, = compile(<<-EOF)
+      import java.util.ArrayList
+      x = ArrayList.new
+      x[0]= "2"
+      puts x
+    EOF
+    assert_run_output("[2]\n", cls)
+  end
+  
+  def test_sort_with_block
+    cls, = compile(<<-EOF)
+      puts ([3,1,2].sort do |o0:Comparable,o1:Comparable|
+        -o0.compareTo(o1)
+      end)
+    EOF
+    assert_run_output("[3, 2, 1]\n", cls)
+  end
+
+  def test_sort_bang_with_block
+    cls, = compile(<<-EOF)
+      puts ([3,1,2].sort! do |o0:Comparable,o1:Comparable|
+        -o0.compareTo(o1)
+      end)
+    EOF
+    assert_run_output("[3, 2, 1]\n", cls)
+  end
+
+  def test_sort_with_comparator
+    cls, = compile(<<-EOF)
+      class Co implements java::util::Comparator
+        def compare(o0:Object,o1:Object)
+          compare(Comparable(o0),Comparable(o1))
+        end
+        def compare(o0:Comparable,o1:Comparable)
+          -o0.compareTo(o1)
+        end
+      end
+      puts [3,1,2].sort(Co.new)
+    EOF
+    assert_run_output("[3, 2, 1]\n", cls)
+  end
+
+  def test_sort_bang_with_comparator
+    cls, = compile(<<-EOF)
+      class Co implements java::util::Comparator
+        def compare(o0:Object,o1:Object)
+          compare(Comparable(o0),Comparable(o1))
+        end
+        def compare(o0:Comparable,o1:Comparable)
+          -o0.compareTo(o1)
+        end
+      end
+      puts [3,1,2].sort!(Co.new)
+    EOF
+    assert_run_output("[3, 2, 1]\n", cls)
+  end
+
+  def test_sort_without_comparator
+    cls, = compile(<<-EOF)
+      puts [5,1,3].sort
+    EOF
+    assert_run_output("[1, 3, 5]\n", cls)
+  end
+
+  def test_first
+    cls, = compile(<<-EOF)
+      puts [5,1,3].first
+    EOF
+    assert_run_output("5\n", cls)
+  end
+
+  def test_empty_list_first
+    cls, = compile(<<-EOF)
+      puts [].first
+    EOF
+    assert_run_output("null\n", cls)
+  end
+
+  def test_last
+    cls, = compile(<<-EOF)
+      puts [5,1,3].last
+    EOF
+    assert_run_output("3\n", cls)
+  end
+
+  def test_empty_list_last
+    cls, = compile(<<-EOF)
+      puts [].last
+    EOF
+    assert_run_output("null\n", cls)
+  end
+
+  def test_first!
+    cls, = compile(<<-EOF)
+      puts [5,1,3].first!
+    EOF
+    assert_run_output("5\n", cls)
+  end
+
+  def test_empty_list_first!
+    cls, = compile(<<-EOF)
+      puts [].first!
+    EOF
+    assert_raise_java(java.lang.IndexOutOfBoundsException) do
+      cls.main nil
+    end
+  end
+
+  def test_last!
+    cls, = compile(<<-EOF)
+      puts [5,1,3].last!
+    EOF
+    assert_run_output("3\n", cls)
+  end
+
+  def test_empty_list_last!
+    cls, = compile(<<-EOF)
+      puts [].last!
+    EOF
+    assert_raise_java(java.lang.ArrayIndexOutOfBoundsException) do
+      cls.main nil
+    end
+  end
+
+end

data/test/jvm/extensions/lock_extensions_test.rb

@@ -0,0 +1,43 @@
+# Copyright (c) 2015 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.
+
+require 'test_helper'
+
+class LockExtensionsTest < Test::Unit::TestCase
+
+	def test_synchronize_happy
+    cls, = compile(<<-EOF)
+      import java.util.concurrent.locks.ReentrantLock
+      lock = ReentrantLock.new
+      lock.synchronize do
+        puts "synchronized. Yay!"
+      end
+    EOF
+    assert_run_output("synchronized. Yay!\n", cls)
+  end
+
+  def test_synchronize_lock_unlocks_after_exception
+    cls, = compile(<<-EOF)
+      import java.util.concurrent.locks.ReentrantLock
+      lock = ReentrantLock.new
+      begin
+        lock.synchronize { raise "wut" }
+      rescue
+      end
+      Thread.new { puts lock.tryLock }.start.join
+    EOF
+    assert_run_output("true\n", cls)
+  end
+end

data/test/jvm/extensions/numeric_operators_test.rb

@@ -0,0 +1,86 @@
+# Copyright (c) 2015 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.
+
+require 'test_helper'
+
+class NumericOperatorsTest < Test::Unit::TestCase
+
+  OPERATORS = ['+', '-', '/', '*', '%', '>', '<', '!=', '==', '>=', '<=']
+  # Note! signed right shift is not supported due to parser issue:
+  # macro def >>>(n);end
+  # wont parse
+  BITWISE_OPERATORS = ['&', '|', '&', '^']
+  SHIFT_OPERATORS = ['>>', '<<']
+  # mirah fixnum constants defaults to int
+  FIXNUM_TYPES = ['Integer', 'Short', 'Byte', 'Long']
+  # need to cast constants to primitives
+  FLOAT_TYPES = ['Float', 'Double']
+
+  def self.define_test_methods(cast, i, numeric_class, operator , assert)
+    define_method "test_#{numeric_class}_left_arithmetic_#{i}".to_sym do
+      cls, = compile(<<-EOF)
+          puts #{numeric_class}.new(#{cast}(5)) #{operator} #{cast}(7)
+      EOF
+      assert_run_output("#{assert}\n", cls)
+    end
+    define_method "test_#{numeric_class}_right_arithmetic_#{i}".to_sym do
+      cls, = compile(<<-EOF)
+          puts #{cast}(5) #{operator} #{numeric_class}.new(#{cast}(7))
+      EOF
+      assert_run_output("#{assert}\n", cls)
+    end
+  end
+
+  def self.define_shift_test_methods(cast, i, numeric_class, operator , assert)
+    define_method "test_#{numeric_class}_left_arithmetic_#{i}".to_sym do
+      cls, = compile(<<-EOF)
+          puts #{numeric_class}.new(#{cast}(5)) #{operator} 7
+      EOF
+      assert_run_output("#{assert}\n", cls)
+    end
+    define_method "test_#{numeric_class}_right_arithmetic_#{i}".to_sym do
+      cls, = compile(<<-EOF)
+          puts 5 #{operator} #{numeric_class}.new(#{cast}(7)).intValue
+      EOF
+      assert_run_output("#{assert}\n", cls)
+    end
+  end
+
+  FIXNUM_TYPES.each do |numeric_class|
+    test_num = 0
+    cast = ('Integer' == numeric_class ? 'int' : numeric_class.downcase)
+    (OPERATORS + BITWISE_OPERATORS).each do |operator|
+      assert = eval "5#{operator}7"
+      define_test_methods(cast, test_num+=1, numeric_class, operator, assert)
+    end
+    SHIFT_OPERATORS.each do |operator|
+      assert = eval "5#{operator}7"
+      define_shift_test_methods(cast, test_num+=1, numeric_class, operator, assert)
+    end
+  end
+
+  # have to
+  FLOAT_TYPES.each do |numeric_class|
+    OPERATORS.each_with_index do |operator, i|
+      cast = numeric_class.downcase
+      assert = eval "5.0#{operator}7.0"
+      if numeric_class == 'Float' and operator == '/'
+        assert = '0.71428573'
+      end
+      define_test_methods(cast, i, numeric_class, operator, assert)
+    end
+  end
+
+end

data/test/jvm/extensions/object_extensions_test.rb

@@ -0,0 +1,122 @@
+# Copyright (c) 2015 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 ObjectExtensionsTest < Test::Unit::TestCase
+
+  def test_tap
+    cls, = compile(%q[
+      def taptest
+        StringBuilder.new("abc").tap do |sb|
+          sb.append("xyz")
+          StringBuilder.new("ijk")
+        end
+      end
+    ])
+    assert_equal("abcxyz", cls.taptest.toString)
+  end
+  
+  def test_equals_each_side_is_evaluated_exactly_once
+    cls, = compile(%q[
+      def foo
+        puts "foo"
+        "1"
+      end
+      
+      def bar
+        puts "bar"
+        "2"
+      end
+
+      puts foo==bar
+      puts nil==bar # right side is always evaluated exactly once, even in the presence of nil on the other side
+      puts bar==nil # left  side is always evaluated exactly once, even in the presence of nil on the other side
+    ])
+    assert_run_output("foo\nbar\nfalse\nbar\nfalse\nbar\nfalse\n", cls)
+  end
+  
+  def test_equals_method_is_evaluated_as_necessary
+    cls, = compile(%q[
+      class Foo
+        attr_accessor counter:int
+        def equals(o:Object)
+          self.counter += 1
+          true
+        end
+      end
+      
+      class Bar < Foo
+      end
+      
+      class Baz < Foo
+      end
+      
+      bar = Bar.new
+      baz = Baz.new
+      puts bar==baz
+      puts bar.counter
+      puts baz.counter
+      puts nil==bar
+      puts bar.counter
+      puts bar==nil
+      puts bar.counter
+      puts bar==bar
+      puts bar.counter
+    ])
+    assert_run_output("true\n1\n0\nfalse\n1\ntrue\n2\ntrue\n3\n", cls)
+  end
+  
+  def test_equals_method_is_evaluated_exactly_once_even_on_identical_objects
+    cls, = compile(%q[
+      class NaN
+        def equals(o:Object)
+          false
+        end
+      end
+      
+      nan = NaN.new
+      puts nan==nan
+    ])
+    assert_run_output("false\n", cls)
+  end
+
+  def test_boxing_for_equals
+    cls, = compile(%q[
+      puts true==true
+      puts false==true
+      puts nil==true
+
+      obj = Boolean true
+      puts obj == true
+      puts obj == false
+
+      b = true
+      puts obj == b
+      puts obj == 1
+      puts true == obj
+    ])
+    assert_run_output("true\nfalse\nfalse\ntrue\nfalse\ntrue\nfalse\ntrue\n", cls)
+  end
+
+  def test_boxing_for_numerics
+    cls, = compile(%q[
+      puts 1==Long.new(1)
+      puts Long(nil)==Long.new(1)
+      puts 1==Long.new(2)
+      puts nil == Long.new(2)
+    ])
+    assert_run_output("true\nfalse\nfalse\nfalse\n", cls)
+  end
+
+end