mirah 0.1.2-java → 0.1.3-java

data/test/jvm/generics_test.rb

@@ -14,12 +14,8 @@
 # limitations under the License.
 
 require 'test_helper'
-require 'jvm/bytecode_test_helper'
-class TestGenerics < Test::Unit::TestCase
 
-  def parse_and_type code, name=tmp_script_name
-    parse_and_resolve_types name, code
-  end
+class GenericsTest < Test::Unit::TestCase
 
   def test_generics_calls_collections
     cls, = compile(<<-EOF)
@@ -28,7 +24,7 @@ class TestGenerics < Test::Unit::TestCase
       foo = ArrayList.new()
       foo.add("first string")
       foo.add("second string")
-      System.out.println(foo.get(1).substring(2))
+      puts(foo.get(1).substring(2))
     EOF
 
     assert_output("cond string\n") do
@@ -45,7 +41,7 @@ class TestGenerics < Test::Unit::TestCase
       foo.add("second string")
       bar = ArrayList.new()
       bar.add(foo)
-      System.out.println(bar.get(0).get(1).substring(2))
+      puts(bar.get(0).get(1).substring(2))
     EOF
 
     assert_output("cond string\n") do

data/test/jvm/import_test.rb

@@ -78,4 +78,18 @@ class ImportTest < Test::Unit::TestCase
     assert_equal(["1", "2", "3"], list.to_a)
   end
 
+  def test_static_import_late_resolve
+    cls, = compile(<<-EOF)
+      import static StaticImports2.*
+      doFoo()
+
+      class StaticImports2
+        def self.doFoo
+          puts :hi
+        end
+      end
+    EOF
+    assert_output("hi\n") { cls.main(nil) }
+  end
+
 end

data/test/jvm/interface_test.rb

@@ -83,31 +83,16 @@ class InterfaceTest < Test::Unit::TestCase
       EOF
   end
 
-  def test_interface_implementation_with_array_params_requires_type_information
+  def test_interface_implementation_with_array_params_doesnt_requires_type_information
     interface, a_impl = compile(<<-EOF)
-        interface InterfaceWithArrays
-          def arr(messages:String[]):int; end
-        end
-
-        class ExplicitArrImpl implements InterfaceWithArrays
-          def blah(s:String[]) s.length ; end
-          def arr(messages:String[]) blah messages ; end
-        end
-      EOF
-    
-    # this is the current behavior. I think we should fix it. nh
-    error = assert_raises Mirah::MirahError do
-      interface, a_impl = compile(<<-EOF)
-        interface InterfaceWithArrays
-          def arr(messages:String[]):int; end
-        end
+      interface InterfaceWithArrays
+        def arr(messages:String[]):int; end
+      end
 
-        class ImplicitArrImpl implements InterfaceWithArrays
-          def blah(s:String[]) s.length ; end
-          def arr(messages) blah messages ; end
-        end
-      EOF
-    end
-    assert_equal "Cannot find instance method blah(java.lang.String) on ImplicitArrImpl", error.message
+      class ImplicitArrImpl implements InterfaceWithArrays
+        def blah(s:String[]) s.length ; end
+        def arr(messages) blah messages ; end
+      end
+    EOF
   end
 end

data/test/jvm/jvm_commands_test.rb

@@ -16,19 +16,37 @@ require 'test_helper'
 
 
 class JVMCommandsTest < Test::Unit::TestCase
+
   def test_dash_e_eval
     assert_output "1\n" do
-      Mirah::Commands::Run.new(['-e','puts 1']).execute
+      Mirah.run('-e','puts 1')
     end
   end
 
+  def test_force_verbose_has_logging
+    out = capture_output do
+      Mirah.run('-V', '-e','puts 1')
+    end
+    assert out.include? "Finished class DashE"
+  end
+
   def test_runtime_classpath_modifications
     assert_output "1234\n" do
-      Mirah::Commands::Run.new(['-c', FIXTURE_TEST_DEST,
+      Mirah.run('-cp', FIXTURE_TEST_DEST,
+                                '-e',
+                                  'import org.foo.LowerCaseInnerClass
+                                  puts LowerCaseInnerClass.inner.field'
+                              )
+    end
+  end
+
+  def test_dash_c_is_deprecated
+    assert_output "WARN: option -c is deprecated.\n1234\n" do
+      Mirah.run('-c', FIXTURE_TEST_DEST,
                                 '-e',
                                   'import org.foo.LowerCaseInnerClass
-                                  puts LowerCaseInnerClass.inner.field']
-                              ).execute
+                                  puts LowerCaseInnerClass.inner.field'
+                              )
     end
   end
 end

data/test/jvm/jvm_compiler_test.rb

@@ -34,6 +34,14 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal(3.0, cls.foo)
   end
 
+  def test_unary_negation
+    cls, = compile("def foo; a = 1; -a; end")
+    assert_equal(-1, cls.foo)
+
+    cls, = compile("def foo; a = 1; 1 + -a; end")
+    assert_equal(0, cls.foo)
+  end
+
   def test_subtraction
     cls, = compile("def foo; a = 3; b = 2; a - b; end")
     assert_equal(1, cls.foo)
@@ -101,6 +109,25 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal(6, cls.foo)
   end
 
+  def test_negate
+    cls, = compile("def foo; a = 5; -a; end")
+    assert_equal(-5, cls.foo)
+    cls, = compile("def foo; a = 7.5; -a; end")
+    assert_equal(-7.5, cls.foo)
+  end
+
+  def test_nan
+    cls, = compile("def foo(a:double); if a < 0 then 1 else 2 end; end")
+    assert_equal(1, cls.foo(-1))
+    assert_equal(2, cls.foo(0))
+    assert_equal(2, cls.foo(java.lang.Double::NaN))
+
+    cls, = compile("def foo(a:double); a > 0 ? 1 : 2; end")
+    assert_equal(1, cls.foo(1))
+    assert_equal(2, cls.foo(-1))
+    assert_equal(2, cls.foo(java.lang.Double::NaN))
+  end
+
   def test_return
     cls, = compile("def foo; return 1; end")
     assert_equal(1, cls.foo)
@@ -193,9 +220,11 @@ class JVMCompilerTest < Test::Unit::TestCase
   end
 
   def test_object_array
-    cls, = compile("import java.lang.Object;def foo; a = Object[2];end")
-    assert_equal(Java::JavaLang::Object[].java_class, cls.foo.class.java_class)
-    assert_equal([nil, nil], cls.foo.to_a)
+    pend_on_jruby("1.7.13") do
+      cls, = compile("import java.lang.Object;def foo; a = Object[2];end")
+      assert_equal(Java::JavaLang::Object[].java_class, cls.foo.class.java_class)
+      assert_equal([nil, nil], cls.foo.to_a)
+    end
   end
 
   def test_void_selfcall
@@ -218,12 +247,12 @@ class JVMCompilerTest < Test::Unit::TestCase
     a, b = compile(<<-EOF)
       class VoidBase
         def foo:void
-          System.out.println "foo"
+          puts "foo"
         end
       end
       class VoidChain < VoidBase
         def bar:void
-          System.out.println "bar"
+          puts "bar"
         end
 
         def self.foobar
@@ -241,12 +270,12 @@ class JVMCompilerTest < Test::Unit::TestCase
   end
 
   def test_class_name_from_file_with_underscore
-    foo, = compile("System.out.println 'blah'", :name => 'class_name_test.mirah')
+    foo, = compile("puts 'blah'", :name => 'class_name_test.mirah')
     assert_equal('ClassNameTest', foo.java_class.name)
   end
 
   def test_class_name_from_file_with_dash
-    foo, = compile("System.out.println 'blah'", :name => 'class-dash-test.mirah')
+    foo, = compile("puts 'blah'", :name => 'class-dash-test.mirah')
     assert_equal('ClassDashTest', foo.java_class.name)
   end
 
@@ -415,25 +444,25 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_loop
     cls, = compile(
-        'def foo(a:int);while a > 0; a -= 1; System.out.println ".";end;end')
+        'def foo(a:int);while a > 0; a -= 1; puts ".";end;end')
     assert_equal('', capture_output{cls.foo(0)})
     assert_equal(".\n", capture_output{cls.foo(1)})
     assert_equal(".\n.\n", capture_output{cls.foo(2)})
 
     cls, = compile(
-        'def foo(a:int);begin;a -= 1; System.out.println ".";end while a > 0;end')
+        'def foo(a:int);begin;a -= 1; puts ".";end while a > 0;end')
     assert_equal(".\n", capture_output{cls.foo(0)})
     assert_equal(".\n", capture_output{cls.foo(1)})
     assert_equal(".\n.\n", capture_output{cls.foo(2)})
 
     cls, = compile(
-        'def foo(a:int);until a <= 0; a -= 1; System.out.println ".";end;end')
+        'def foo(a:int);until a <= 0; a -= 1; puts ".";end;end')
     assert_equal('', capture_output{cls.foo(0)})
     assert_equal(".\n", capture_output{cls.foo(1)})
     assert_equal(".\n.\n", capture_output{cls.foo(2)})
 
     cls, = compile(
-        'def foo(a:int);begin;a -= 1; System.out.println ".";end until a <= 0;end')
+        'def foo(a:int);begin;a -= 1; puts ".";end until a <= 0;end')
     assert_equal(".\n", capture_output{cls.foo(0)})
     assert_equal(".\n", capture_output{cls.foo(1)})
     assert_equal(".\n.\n", capture_output{cls.foo(2)})
@@ -857,7 +886,7 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_and
     cls, = compile(<<-EOF)
       def bool(n:String, x:boolean)
-        System.out.println n
+        puts n
         x
       end
 
@@ -866,7 +895,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       end
 
       def str(n:String, x:String)
-        System.out.println n
+        puts n
         x
       end
 
@@ -976,7 +1005,7 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_or
     cls, = compile(<<-EOF)
       def bool(n:String, x:boolean)
-        System.out.println n
+        puts n
         x
       end
 
@@ -985,7 +1014,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       end
 
       def str(n:String, x:String)
-        System.out.println n
+        puts n
         x
       end
 
@@ -1097,45 +1126,48 @@ class JVMCompilerTest < Test::Unit::TestCase
   end
 
   def test_op_elem_assign
-    foo, = compile(<<-EOF)
-      class Foo4
-        def initialize
-          @i = -1
-        end
+    pend_on_jruby("1.7.13") do
 
-        def i
-          @i += 1
-        end
+      foo, = compile(<<-EOF)
+        class Foo4
+          def initialize
+            @i = -1
+          end
 
-        def a
-          @a
-        end
+          def i
+            @i += 1
+          end
 
-        def a=(a:String[])
-          @a = a
-        end
+          def a
+            @a
+          end
 
-        def foo(x:String)
-          a[i] ||= x
-        end
+          def a=(a:String[])
+            @a = a
+          end
 
-        def bar(x:String)
-          a[i] &&= x
+          def foo(x:String)
+            a[i] ||= x
+          end
+
+          def bar(x:String)
+            a[i] &&= x
+          end
         end
-      end
-    EOF
+      EOF
 
-    f = foo.new
-    f.a_set([nil, nil, nil].to_java(:string))
-    assert_equal(nil, f.bar("x"))
-    assert_equal([nil, nil, nil], f.a.to_a)
-    assert_equal("x", f.foo("x"))
-    assert_equal([nil, "x", nil], f.a.to_a)
+      f = foo.new
+      f.a_set([nil, nil, nil].to_java(:string))
+      assert_equal(nil, f.bar("x"))
+      assert_equal([nil, nil, nil], f.a.to_a)
+      assert_equal("x", f.foo("x"))
+      assert_equal([nil, "x", nil], f.a.to_a)
+    end
   end
 
   def test_literal_array
     cls, = compile(<<-EOF)
-      def foo; System.out.println "hello"; nil; end
+      def foo; puts "hello"; nil; end
       def expr
         [foo]
       end
@@ -1177,7 +1209,7 @@ class JVMCompilerTest < Test::Unit::TestCase
         /foo/.split('barfoobaz')
       end
       def puts
-        System.out.println split
+        puts split
       end
     EOF
 
@@ -1202,8 +1234,8 @@ class JVMCompilerTest < Test::Unit::TestCase
         end
       end
 
-      System.out.println A1.new.foo("Hi")
-      System.out.println B1.new.foo("There")
+      puts A1.new.foo("Hi")
+      puts B1.new.foo("There")
     EOF
 
     assert_output("Hi\nThere\n") do
@@ -1241,7 +1273,7 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_optional_args
     cls, = compile(<<-EOF)
       def foo(a:int, b:int = 1, c:int = 2)
-        System.out.println a; System.out.println b; System.out.println c
+        puts a; puts b; puts c
       end
       foo(0)
       foo(0,0)
@@ -1254,7 +1286,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_field_read
     cls, = compile(<<-EOF)
-      System.out.println System.out.getClass.getName
+      puts System.out.getClass.getName
     EOF
     assert_output("java.io.PrintStream\n") do
       cls.main([].to_java :String)
@@ -1457,10 +1489,10 @@ class JVMCompilerTest < Test::Unit::TestCase
     abstract_class, concrete_class = compile(<<-EOF)
       abstract class Abstract
         abstract def foo:void; end
-        def bar; System.out.println "bar"; end
+        def bar; puts "bar"; end
       end
       class Concrete < Abstract
-        def foo; System.out.println :foo; end
+        def foo; puts :foo; end
       end
     EOF
 
@@ -1477,7 +1509,7 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_return_void
     script, = compile(<<-EOF)
       def foo:void
-        System.out.println :hi
+        puts :hi
         return
       end
     EOF
@@ -1533,10 +1565,10 @@ class JVMCompilerTest < Test::Unit::TestCase
         begin
           raise "Foo"
         rescue => b
-          System.out.println a
-          System.out.println b.getMessage
+          puts a
+          puts b.getMessage
         end
-        System.out.println b
+        puts b
       end
     EOF
 
@@ -1594,7 +1626,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_covariant_arrays
     cls, = compile(<<-EOF)
-      System.out.println java::util::Arrays.toString(String[5])
+      puts java::util::Arrays.toString(String[5])
     EOF
 
     assert_output("[null, null, null, null, null]\n") do
@@ -1604,7 +1636,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_getClass_on_object_array
     cls, = compile(<<-EOF)
-      System.out.println Object[0].getClass.getName
+      puts Object[0].getClass.getName
     EOF
 
     assert_output("[Ljava.lang.Object;\n") do
@@ -1625,7 +1657,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
     cls, = compile(<<-EOF)
       a = nil
-      System.out.println Object(a)
+      puts Object(a)
     EOF
 
     assert_output("null\n") do
@@ -1636,7 +1668,7 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_long_generation
     cls, = compile(<<-EOF)
       c = 2_000_000_000_000
-      System.out.println c
+      puts c
     EOF
   end
 
@@ -1649,14 +1681,14 @@ class JVMCompilerTest < Test::Unit::TestCase
   end
 
   def test_bool_equality
-    cls, = compile("System.out.println true == false")
+    cls, = compile("puts true == false")
     assert_output("false\n") do
       cls.main(nil)
     end
   end
 
   def test_bool_inequality
-    cls, = compile("System.out.println true != false")
+    cls, = compile("puts true != false")
     assert_output("true\n") do
       cls.main(nil)
     end
@@ -1664,9 +1696,11 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_field_setter_with_nil
     cls, = compile(<<-EOF)
-      import mirah.lang.ast.*
-      a = Arguments.new
-      a.block = nil
+      class FieldSetter
+        attr_accessor field: String
+      end
+      a = FieldSetter.new
+      a.field = nil
       print "OK"
     EOF
     
@@ -1763,28 +1797,39 @@ class JVMCompilerTest < Test::Unit::TestCase
     end
   end
 
-  def test_static_field_inheritance_lookup_with_dot
+  def test_incompatible_meta_change
     cls, = compile(<<-EOF)
-      import java.util.GregorianCalendar
-      puts GregorianCalendar.AM
-    EOF
+      class A < B
+        def foo(a:Object)
+          a.kind_of?(A)
+        end
+      end
 
-    assert_output "0\n" do
-      cls.main(nil)
-    end
+      class B
+      end
+    EOF
+    
+    a = cls.new
+    assert(a.foo(a))
   end
 
-  def test_static_field_inheritance_lookup_with_double_colon
-    pend("double colon is treated special for lookup") {
-    cls, = compile(<<-EOF)
-      import java.util.GregorianCalendar
-      puts GregorianCalendar::AM
+  def test_local_method_conflict
+    cls, arg = compile(<<-EOF)
+      def a; ArgType.new; end
+      def foo(a:ArgType):void
+        x = Object[ a ? a.bar : 0]
+        puts x.length
+      end
+      
+      class ArgType
+        def bar
+          2
+        end
+      end
     EOF
 
-    assert_output "0\n" do
-      cls.main(nil)
-    end
-    }
+    assert_output("0\n") { cls.foo(nil)}
+    assert_output("2\n") { cls.foo(arg.new)}
   end
 
 end