mirah 0.0.12-java → 0.1.0-java

data/{lib/mirah/typer/base.rb → test/jvm/jvm_commands_test.rb}

@@ -12,17 +12,13 @@
 # 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'
 
-module Mirah
-  module Typer
-    class Base
-      include Mirah
 
-      def log(message); Typer.log(message); end
-
-      def to_s
-        name
-      end
+class JVMCommandsTest < Test::Unit::TestCase
+  def test_dash_e_eval
+    assert_output "1\n" do
+      Mirah::Commands::Run.new(['-e','puts 1']).execute
     end
   end
-end
+end

data/test/jvm/jvm_compiler_test.rb

@@ -14,13 +14,6 @@
 # limitations under the License.
 
 class JVMCompilerTest < 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")
@@ -238,7 +231,7 @@ class JVMCompilerTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       import java.io.*
       def foo
-        throws IOException
+        # throws IOException
         OutputStreamWriter.new(
             System.out).write("Hello ").write("there\n").flush
       end
@@ -248,15 +241,13 @@ class JVMCompilerTest < Test::Unit::TestCase
 
     a, b = compile(<<-EOF)
       class VoidBase
-        def foo
-          returns void
-          puts "foo"
+        def foo:void
+          System.out.println "foo"
         end
       end
       class VoidChain < VoidBase
-        def bar
-          returns void
-          puts "bar"
+        def bar:void
+          System.out.println "bar"
         end
 
         def self.foobar
@@ -268,67 +259,21 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   end
 
-  def test_import
-    cls, = compile("import 'AL', 'java.util.ArrayList'; def foo; AL.new; end; foo")
-    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
-
-    cls, = compile("import 'java.util.ArrayList'; def foo; ArrayList.new; end; foo")
-    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
-  end
-
-  def test_no_quote_import
-    cls, = compile("import java.util.ArrayList as AL; def foo; AL.new; end; foo")
-    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
-
-    cls, = compile("import java.util.ArrayList; def foo; ArrayList.new; end; foo")
-    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
-  end
-
-  def test_imported_decl
-    cls, = compile("import 'java.util.ArrayList'; def foo(a:ArrayList); a.size; end")
-    assert_equal 0, cls.foo(java.util.ArrayList.new)
-  end
-
-  def test_import_package
-    cls, = compile(<<-EOF)
-      import java.util.*
-      def foo
-        ArrayList.new
-      end
-    EOF
-    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
-  end
-
-  def test_interface
-    cls, = compile(<<-EOF)
-      import 'java.util.concurrent.Callable'
-      def foo(a:Callable)
-        throws Exception
-        a.call
-      end
-    EOF
-    result = cls.foo {0}
-    assert_equal 0, result
-    m = cls.java_class.java_method 'foo', java.util.concurrent.Callable
-    assert_equal([java.lang.Exception.java_class], m.exception_types)
-
-  end
-
   def test_class_decl
     foo, = compile("class ClassDeclTest;end")
     assert_equal('ClassDeclTest', foo.java_class.name)
   end
-  
+
   def test_class_name_from_file_with_underscore
-    foo, = compile("puts 'blah'", 'class_name_test.mirah')
+    foo, = compile("System.out.println 'blah'", :name => 'class_name_test.mirah')
     assert_equal('ClassNameTest', foo.java_class.name)
   end
-  
+
   def test_class_name_from_file_with_dash
-    foo, = compile("puts 'blah'", 'class-dash-test.mirah')
+    foo, = compile("System.out.println 'blah'", :name => 'class-dash-test.mirah')
     assert_equal('ClassDashTest', foo.java_class.name)
   end
-  
+
   def test_puts
     cls, = compile("def foo;puts 'Hello World!';end")
     output = capture_output do
@@ -478,29 +423,6 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal '-', cls.foo(-1)
   end
 
-
-  def test_local_decl
-    cls, = compile(<<-EOF)
-      import 'java.lang.String'
-      a = :fixnum
-      b = :int
-      c = :long
-      d = :float
-      e = :string
-      f = String
-      puts a
-      puts b
-      puts c
-      puts d
-      puts e
-      puts f
-    EOF
-    output = capture_output do
-      cls.main([].to_java(:string))
-    end
-    assert_equal("0\n0\n0\n0.0\nnull\nnull\n", output)
-  end
-
   def test_multi_assign
     cls, = compile(<<-EOF)
       def foo
@@ -517,25 +439,25 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_loop
     cls, = compile(
-        'def foo(a:fixnum);while a > 0; a -= 1; puts ".";end;end')
+        'def foo(a:fixnum);while a > 0; a -= 1; System.out.println ".";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:fixnum);begin;a -= 1; puts ".";end while a > 0;end')
+        'def foo(a:fixnum);begin;a -= 1; System.out.println ".";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:fixnum);until a <= 0; a -= 1; puts ".";end;end')
+        'def foo(a:fixnum);until a <= 0; a -= 1; System.out.println ".";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:fixnum);begin;a -= 1; puts ".";end until a <= 0;end')
+        'def foo(a:fixnum);begin;a -= 1; System.out.println ".";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)})
@@ -736,11 +658,11 @@ class JVMCompilerTest < Test::Unit::TestCase
         def a
           @a
         end
-        
+
         def self.set_b(b:fixnum)
           @@b = b
         end
-        
+
         def b
           @@b
         end
@@ -752,7 +674,7 @@ class JVMCompilerTest < Test::Unit::TestCase
     second = cls.new(2)
     assert_equal(1, first.a)
     assert_equal(2, second.a)
-    
+
     cls.set_b 0
     assert_equal(0, first.b)
     assert_equal(0, second.b)
@@ -785,14 +707,12 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_implements
     cls, = compile(<<-EOF)
-      import java.lang.Iterable
-      class Foo; implements Iterable
+      class ImplementsTest implements Iterable
         def iterator
           nil
         end
       end
     EOF
-
     assert_include java.lang.Iterable.java_class, cls.java_class.interfaces
   end
 
@@ -821,58 +741,52 @@ class JVMCompilerTest < Test::Unit::TestCase
       def _Double(a:double)
         a
       end
-      EOF
+    EOF
 
-      assert_equal(1.0, cls._Byte(1))
-      assert_equal(127.0, cls._Byte(127))
-      assert_equal(128.0, cls._Short(128))
-      assert_equal(32767.0, cls._Short(32767))
-      assert_equal(32768.0, cls._Int(32768))
-      assert_equal(2147483648.0, cls._Long(2147483648))
+    assert_equal(1.0, cls._Byte(1))
+    assert_equal(127.0, cls._Byte(127))
+    assert_equal(128.0, cls._Short(128))
+    assert_equal(32767.0, cls._Short(32767))
+    assert_equal(32768.0, cls._Int(32768))
+    assert_equal(2147483648.0, cls._Long(2147483648))
   end
 
-  def test_interface_declaration
-    interface = compile('interface A do; end').first
-    assert(interface.java_class.interface?)
-    assert_equal('A', interface.java_class.name)
-
-    a, b = compile('interface A do; end; interface B < A do; end')
-    assert_include(a, b.ancestors)
-    assert_equal('A', a.java_class.name)
-    assert_equal('B', b.java_class.name)
-
-    a, b, c = compile(<<-EOF)
-      interface A do
+  def test_argument_boxing
+    [ [:short], [:int,:integer], [:long], [:byte]].each do |types|
+      primitive, full = types.first, types.last
+      begin
+        cls, = compile(<<-EOF)
+        def to_#{primitive}(a:#{full.to_s.capitalize}):void
+          puts a
+        end
+        to_#{primitive} #{primitive}(1)
+        EOF
+        assert_output("1\n") { cls.main nil}
+      rescue => e
+        raise "#{primitive} #{e.message}"
       end
-
-      interface B do
+    end
+    %w[float double].each do |type|
+      begin
+      cls, = compile(<<-EOF)
+        def to_#{type}(a:#{type.to_s.capitalize}):void
+          puts a
+        end
+        to_#{type} #{type}(1)
+        EOF
+      assert_output("1.0\n") { cls.main nil}
+      rescue => e
+        raise "#{type} #{e.message}"
       end
+    end
 
-      interface C < A, B do
+    cls, = compile(<<-EOF)
+      def to_character(a:Character):void
+        puts a
       end
+      to_character char(65)
     EOF
-
-    assert_include(a, c.ancestors)
-    assert_include(b, c.ancestors)
-    assert_equal('A', a.java_class.name)
-    assert_equal('B', b.java_class.name)
-    assert_equal('C', c.java_class.name)
-
-    assert_raise Mirah::Typer::InferenceError do
-      compile(<<-EOF)
-        interface A do
-          def a
-            returns :int
-          end
-        end
-
-        class Impl; implements A
-          def a
-            "foo"
-          end
-        end
-      EOF
-    end
+    assert_output("A\n") { cls.main nil}
   end
 
   def test_raise
@@ -881,7 +795,7 @@ class JVMCompilerTest < Test::Unit::TestCase
         raise
       end
     EOF
-    assert_raise_java(java.lang.RuntimeException) do
+    assert_raise_java(java.lang.Exception) do
       cls.foo
     end
 
@@ -890,7 +804,7 @@ class JVMCompilerTest < Test::Unit::TestCase
         raise "Oh no!"
       end
     EOF
-    ex = assert_raise_java(java.lang.RuntimeException, 'Oh no!') do
+    ex = assert_raise_java(java.lang.Exception, 'Oh no!') do
       cls.foo
     end
 
@@ -905,7 +819,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
     cls, = compile(<<-EOF)
       def foo
-        throws Exception
+        # throws Exception
         raise Exception, "oops"
       end
     EOF
@@ -915,160 +829,14 @@ class JVMCompilerTest < Test::Unit::TestCase
 
     cls, = compile(<<-EOF)
       def foo
-        throws Throwable
+        # throws Throwable
         raise Throwable.new("darn")
       end
     EOF
-    ex = assert_raise_java(java.lang.Throwable, "darn") do
-      cls.foo
-    end
-  end
 
-  def test_ensure
-    cls, = compile(<<-EOF)
-      def foo
-        1
-      ensure
-        puts "Hi"
-      end
-    EOF
-    output = capture_output do
-      assert_equal(1, cls.foo)
-    end
-    assert_equal "Hi\n", output
-
-    cls, = compile(<<-EOF)
-      def foo
-        return 1
-      ensure
-        puts "Hi"
-      end
-    EOF
-    output = capture_output do
-      assert_equal(1, cls.foo)
-    end
-    assert_equal "Hi\n", output
-
-    cls, = compile(<<-EOF)
-      def foo
-        begin
-          break
-        ensure
-          puts "Hi"
-        end while false
-      end
-    EOF
-    output = capture_output do
+    assert_raise_java(java.lang.Throwable, "darn") do
       cls.foo
     end
-    assert_equal "Hi\n", output
-  end
-
-  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_set
@@ -1092,6 +860,7 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal(true, cls.foo("a"))
     assert_equal(false, cls.foo(nil))
   end
+
   def test_if_expr
     cls, = compile(<<-EOF)
       def foo(a:int)
@@ -1112,7 +881,7 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_and
     cls, = compile(<<-EOF)
       def bool(n:String, x:boolean)
-        puts n
+        System.out.println n
         x
       end
 
@@ -1121,7 +890,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       end
 
       def str(n:String, x:String)
-        puts n
+        System.out.println n
         x
       end
 
@@ -1231,7 +1000,7 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_or
     cls, = compile(<<-EOF)
       def bool(n:String, x:boolean)
-        puts n
+        System.out.println n
         x
       end
 
@@ -1240,7 +1009,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       end
 
       def str(n:String, x:String)
-        puts n
+        System.out.println n
         x
       end
 
@@ -1388,10 +1157,9 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal([nil, "x", nil], f.a.to_a)
   end
 
-
   def test_literal_array
     cls, = compile(<<-EOF)
-      def foo; puts "hello"; nil; end
+      def foo; System.out.println "hello"; nil; end
       def expr
         [foo]
       end
@@ -1433,7 +1201,7 @@ class JVMCompilerTest < Test::Unit::TestCase
         /foo/.split('barfoobaz')
       end
       def puts
-        puts split
+        System.out.println split
       end
     EOF
 
@@ -1458,17 +1226,18 @@ class JVMCompilerTest < Test::Unit::TestCase
         end
       end
 
-      puts A1.new.foo("Hi")
-      puts B1.new.foo("There")
+      System.out.println A1.new.foo("Hi")
+      System.out.println B1.new.foo("There")
     EOF
 
     assert_output("Hi\nThere\n") do
       cls.main(nil)
     end
   end
+
   def test_super
     cls, = compile(<<-EOF)
-      class Foo
+      class SuperEqual
         def equals(other:Object); super(other); end
       end
     EOF
@@ -1480,7 +1249,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_method_lookup_with_overrides
     cls, = compile(<<-EOF)
-      class Bar; implements Runnable
+      class Bar implements Runnable
         def foo(x:Bar)
           Thread.new(x)
         end
@@ -1496,7 +1265,7 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_optional_args
     cls, = compile(<<-EOF)
       def foo(a:int, b:int = 1, c:int = 2)
-        puts a; puts b; puts c
+        System.out.println a; System.out.println b; System.out.println c
       end
       foo(0)
       foo(0,0)
@@ -1509,7 +1278,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_field_read
     cls, = compile(<<-EOF)
-      puts System.out.getClass.getName
+      System.out.println System.out.getClass.getName
     EOF
     assert_output("java.io.PrintStream\n") do
       cls.main([].to_java :String)
@@ -1529,101 +1298,10 @@ class JVMCompilerTest < Test::Unit::TestCase
     cls.make_one(nil)
   end
 
-  def test_block_with_duby_interface
-    cls, interface = compile(<<-EOF)
-      interface MyProc do
-        def call; returns :void; end
-      end
-      def foo(b:MyProc)
-        b.call
-      end
-      def bar
-        foo {puts "Hi"}
-      end
-    EOF
-    assert_output("Hi\n") do
-      cls.bar
-    end
-  end
-
-  def test_duby_iterable
-    cls, = compile(<<-EOF)
-      import java.util.Iterator
-      class MyIterator; implements Iterable, Iterator
-        def initialize(x:Object)
-          @next = x
-        end
-
-        def hasNext
-          @next != nil
-        end
-
-        def next
-          result = @next
-          @next = nil
-          result
-        end
-
-        def iterator
-          self
-        end
-
-        def remove
-          raise UnsupportedOperationException
-        end
-
-        def self.test(x:String)
-          MyIterator.new(x).each {|y| puts y}
-        end
-      end
-    EOF
-    
-    assert_output("Hi\n") do
-      cls.test("Hi")
-    end
-  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)))
-
-    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
-
   def test_string_interpolation
     cls, = compile(<<-EOF)
       def foo(name:String)
-        print "Hello \#{name}."
+        System.out.print "Hello \#{name}."
       end
     EOF
 
@@ -1633,7 +1311,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
     cls, = compile(<<-EOF)
       def foo(x:int)
-        print "\#{x += 1}"
+        System.out.print "\#{x += 1}"
         x
       end
     EOF
@@ -1680,9 +1358,9 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_evaluation_order
     cls, = compile(<<-EOF)
       def call(a:int, b:int, c:int)
-        print "\#{a}, \#{b}, \#{c}"
+        System.out.print "\#{a}, \#{b}, \#{c}"
       end
-      
+
       def test_call(a:int)
         call(a, if a < 10;a+=1;a;else;a;end, a)
       end
@@ -1702,7 +1380,7 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_inner_class
     cls, = compile(<<-EOF)
       def foo
-        Character.UnicodeBlock.ARROWS
+        Character::UnicodeBlock.ARROWS
       end
     EOF
 
@@ -1710,6 +1388,18 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal("java.lang.Character$UnicodeBlock", subset.java_class.name)
   end
 
+  def test_lowercase_inner_class
+    cls, = compile(<<-EOF)
+      import org.foo.LowerCaseInnerClass
+
+      def foo
+        LowerCaseInnerClass.inner.field
+      end
+    EOF
+
+    assert_equal(1234, cls.foo)
+  end
+
   def test_class_literal
     cls, = compile(<<-EOF)
       def foo
@@ -1725,46 +1415,10 @@ class JVMCompilerTest < Test::Unit::TestCase
       def string(x:Object)
         x.kind_of?(String)
       end
-
-      def dynamic(c:Class, o:Object)
-        o.kind_of?(c)
-      end
     EOF
 
     assert_equal(true, cls.string("foo"))
     assert_equal(false, cls.string(2))
-    assert_equal(true, cls.dynamic(java.lang.String, "foo"))
-    assert_equal(true, cls.dynamic(java.lang.Object, "foo"))
-    assert_equal(false, cls.dynamic(java.lang.Object, nil))
-  end
-
-  def test_static_import
-    cls, = compile(<<-EOF)
-      import java.util.Arrays
-      include Arrays
-      def list(x:Object[])
-        asList(x)
-      end
-    EOF
-
-    o = ["1", "2", "3"].to_java(:object)
-    list = cls.list(o)
-    assert_kind_of(Java::JavaUtil::List, list)
-    assert_equal(["1", "2", "3"], list.to_a)
-
-    cls, = compile(<<-EOF)
-      import java.util.Arrays
-      class StaticImports
-        include Arrays
-        def list(x:Object[])
-          asList(x)
-        end
-      end
-    EOF
-
-    list = cls.new.list(o)
-    assert_kind_of(Java::JavaUtil::List, list)
-    assert_equal(["1", "2", "3"], list.to_a)
   end
 
   # TODO: need a writable field somewhere...
@@ -1788,7 +1442,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       class Append
         class << self
           def hi
-            print 'Static Hello'
+            System.out.print 'Static Hello'
           end
         end
       end
@@ -1801,80 +1455,8 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal('Static Hello', output)
   end
 
-  def test_hashes
-    cls, = compile(<<-EOF)
-      def foo1
-        {a:"A", b:"B"}
-      end
-      def foo2
-        return {a:"A", b:"B"}
-      end
-    EOF
-
-    map = cls.foo1
-    assert_equal("A", map["a"])
-    assert_equal("B", map["b"])
-    map = cls.foo2
-    assert_equal("A", map["a"])
-    assert_equal("B", map["b"])
-
-    cls, = compile(<<-'EOF')
-      def set(b:Object)
-        map = { }
-        map["key"] = b
-        map["key"]
-      end
-    EOF
-
-    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
-      puts "a"
-      begin
-        puts "b"
-        break
-      end while false
-      puts "c"
-    ensure
-      puts "ensure"
-    end
-    EOF
-
-    assert_output("a\nb\nc\nensure\n") { cls.main(nil) }
-  end
-
   def test_return_type
-    assert_raise Mirah::Typer::InferenceError do
+    assert_raise_kind_of Mirah::MirahError do
       compile(<<-EOF)
         class ReturnsA
           def a:int
@@ -1884,7 +1466,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       EOF
     end
 
-    assert_raise Mirah::Typer::InferenceError do
+    assert_raise_kind_of Mirah::MirahError do
       compile(<<-EOF)
         class ReturnsB
           def self.a:String
@@ -1899,10 +1481,10 @@ class JVMCompilerTest < Test::Unit::TestCase
     abstract_class, concrete_class = compile(<<-EOF)
       abstract class Abstract
         abstract def foo:void; end
-        def bar; puts "bar"; end
+        def bar; System.out.println "bar"; end
       end
       class Concrete < Abstract
-        def foo; puts :foo; end
+        def foo; System.out.println :foo; end
       end
     EOF
 
@@ -1919,7 +1501,7 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_return_void
     script, = compile(<<-EOF)
       def foo:void
-        puts :hi
+        System.out.println :hi
         return
       end
     EOF
@@ -1930,15 +1512,15 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_package
     script, cls = compile(<<-EOF)
       package foo
-      
-      # package foo.bar {
-      #   class PackagedBar
-      #     def self.dosomething
-      #       "bar"
-      #     end
-      #   end
-      # }
-      
+
+      package foo.bar {
+        class PackagedBar
+          def self.dosomething
+            "bar"
+          end
+        end
+      }
+
       def dosomething
         "foo"
       end
@@ -1948,9 +1530,8 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal('foo', package)
     assert_equal('foo', script.dosomething)
 
-    # TODO move package to the parser so we can support blocks
-    # assert_equal('bar', cls.dosomething)
-    # assert_equal("foo.bar.PackagedBar", cls.java_class.name)
+    assert_equal('bar', cls.dosomething)
+    assert_equal("foo.bar.PackagedBar", cls.java_class.name)
   end
 
   def test_not
@@ -1976,52 +1557,16 @@ class JVMCompilerTest < Test::Unit::TestCase
         begin
           raise "Foo"
         rescue => b
-          puts a
-          puts b.getMessage
+          System.out.println a
+          System.out.println b.getMessage
         end
-        puts b
+        System.out.println b
       end
     EOF
 
     assert_output("1\nFoo\n2\n") { cls.foo }
   end
 
-  def test_scoped_self_through_method_call
-    cls, = compile(<<-EOF)
-      class ScopedSelfThroughMethodCall
-        def emptyMap
-          {}
-        end
-
-        def foo
-          emptyMap["a"] = "A"
-        end
-      end
-    EOF
-
-    # just make sure it can execute
-    m = cls.new.foo
-  end
-
-  def test_self_call_preserves_scope
-    cls, = compile(<<-EOF)
-      class SelfCallPreservesScope
-        def key
-          "key"
-        end
-        
-        def foo
-          map = {}
-          map[key] = "value"
-          map
-        end
-      end
-    EOF
-
-    map = cls.new.foo
-    assert_equal("value", map["key"])
-  end
-
   def test_wide_nonexpressions
     script, cls1, cls2 = compile(<<-EOF)
       class WideA
@@ -2029,18 +1574,18 @@ class JVMCompilerTest < Test::Unit::TestCase
           2.5
         end
       end
-      
+
       class WideB < WideA
         def a
           super
           3.5
         end
       end
-      
+
       def self.b
         1.5
       end
-      
+
       1.5
       WideA.new.a
       WideB.new.a
@@ -2050,27 +1595,6 @@ class JVMCompilerTest < Test::Unit::TestCase
     script.main(nil)
   end
 
-  def test_parameter_used_in_block
-    cls, = compile(<<-EOF)
-      def foo(x:String):void
-        thread = Thread.new do
-          puts "Hello \#{x}"
-        end
-        begin
-          thread.run
-          thread.join
-        rescue
-          puts "Uh Oh!"
-        end
-      end
-      
-      foo('there')
-    EOF
-    assert_output("Hello there\n") do
-      cls.main(nil)
-    end
-  end
-
   def test_colon2
     cls, = compile(<<-EOF)
       def foo
@@ -2091,22 +1615,22 @@ class JVMCompilerTest < Test::Unit::TestCase
     entry = java.util.HashMap.new(:a => 1).entrySet.iterator.next
     assert_equal(entry, cls.foo(entry))
   end
-  
+
   def test_covariant_arrays
     cls, = compile(<<-EOF)
-      puts java::util::Arrays.toString(String[5])
+      System.out.println java::util::Arrays.toString(String[5])
     EOF
-    
+
     assert_output("[null, null, null, null, null]\n") do
       cls.main(nil)
     end
   end
-  
+
   def test_getClass_on_object_array
     cls, = compile(<<-EOF)
-      puts Object[0].getClass.getName
+      System.out.println Object[0].getClass.getName
     EOF
-    
+
     assert_output("[Ljava.lang.Object;\n") do
       cls.main(nil)
     end
@@ -2125,7 +1649,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
     cls, = compile(<<-EOF)
       a = nil
-      puts a
+      System.out.println a
     EOF
 
     assert_output("null\n") do
@@ -2136,27 +1660,69 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_long_generation
     cls, = compile(<<-EOF)
       c = 2_000_000_000_000
-      puts c
+      System.out.println c
     EOF
   end
 
   def test_missing_class_with_block_raises_inference_error
-    assert_raises Typer::InferenceError do
+    # TODO(ribrdb): What is this test for?
+    ex = assert_raise Mirah::MirahError  do
       compile("Interface Implements_Go do; end")
     end
+    assert_equal("Cannot find class Implements_Go", ex.message)
   end
-  
+
   def test_bool_equality
-    cls, = compile("puts true == false")
+    cls, = compile("System.out.println true == false")
     assert_output("false\n") do
       cls.main(nil)
     end
   end
-  
+
   def test_bool_inequality
-    cls, = compile("puts true != false")
+    cls, = compile("System.out.println true != false")
     assert_output("true\n") do
       cls.main(nil)
     end
   end
+
+  def test_field_setter_wit_nil
+    cls, = compile(<<-EOF)
+      import mirah.lang.ast.*
+      a = Arguments.new
+      a.block = nil
+      print "OK"
+    EOF
+    
+    assert_output("OK") { cls.main(nil) }
+  end
+
+
+  def test_dynamic_works_ok_for_types_widenable_to_object
+    cls, = compile(<<-EOF)
+      def dyno qux:dynamic
+        puts qux
+      end
+      dyno 1
+      dyno "hello"
+      dyno ["im","an","array"]
+    EOF
+    assert_output("1\nhello\n[im, an, array]\n") { cls.main(nil) }
+  end
+
+
+  def test_dynamic_fails_reasonably_on_pre_1_7_target
+    ex = assert_raises MirahError do
+      compile(<<-EOF, :java_version => '1.6')
+        def dyno qux:dynamic
+          puts qux
+          qux.toString
+        end
+        dyno 1
+        dyno "hello"
+        dyno ["im","an","array"]
+      EOF
+    end
+    assert_equal "Target JVM version: 1.6 doesn't support invoke dynamic", ex.message
+  end
 end