mirah 0.1.0.pre-java → 0.1.1-java

data/test/jvm/example_test.rb

@@ -0,0 +1,39 @@
+# 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.
+
+# these are here to make sure the examples still run.
+#
+class ExampleTest < Test::Unit::TestCase
+  def compile_ex name
+    filename = File.dirname(__FILE__) + "/../../examples/#{name}.mirah"
+    compile(open(filename).read).first
+  end
+
+  def example_test name, output
+    cls = compile_ex name
+    assert_output(output) { cls.main nil }
+  end
+
+  {
+    'simple_class' => "constructor\nHello, \nMirah\n",
+    'macros/square' => "2.0\n8.0\n",
+    'macros/square_int' => "2.0\n8.0\n",
+    'macros/string_each_char' => "l\na\na\nt\n \nd\ne\n \nl\ne\ne\ne\nu\nw\n \nn\ni\ne\nt\n \ni\nn\n \nz\ni\nj\nn\n \nh\ne\nm\np\ni\ne\n \ns\nt\na\na\nn\n"
+  }.each do |example,output|
+    define_method "test_#{example}" do
+      example_test example, output
+    end
+  end
+end

data/test/jvm/factory_test.rb

@@ -19,4 +19,10 @@ class FactoryTest < Test::Unit::TestCase
     factory.bootclasspath = File.expand_path("#{__FILE__}/../../fixtures/") +"/"
     assert factory.bootstrap_loader.get_resource 'org/foo/A.class'
   end
+
+  def test_nil_classpath_is_ok
+    factory = Mirah::JVM::Types::TypeFactory.new
+    factory.classpath = nil
+  end
+
 end

data/test/jvm/generics_test.rb

@@ -17,11 +17,6 @@ require 'test_helper'
 require 'jvm/bytecode_test_helper'
 class TestGenerics < Test::Unit::TestCase
 
-  def setup
-    super
-    clear_tmp_files
-  end
-
   def parse_and_type code, name=tmp_script_name
     parse_and_resolve_types name, code
   end

data/test/jvm/import_test.rb

@@ -0,0 +1,81 @@
+# 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 ImportTest < Test::Unit::TestCase
+
+  def test_quote_import
+    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; def foo; ArrayList.new; end; foo")
+    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
+  end
+
+  def test_alias_import_as_syntax
+    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
+  end
+
+  def test_alias_import_comma_syntax
+    cls, = compile("import 'AL', 'java.util.ArrayList'; def foo; AL.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_star
+    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_static_import
+    cls, = compile(<<-EOF)
+      import static java.util.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
+        import static 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
+
+end

data/test/jvm/interface_test.rb

@@ -0,0 +1,113 @@
+# 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 InterfaceTest < Test::Unit::TestCase
+  def test_interface
+    cls, = compile(<<-EOF)
+      import 'java.util.concurrent.Callable'
+      def foo(a:Callable)
+        a.call
+      end
+    EOF
+    result = cls.foo {0}
+    assert_equal 0, result
+    m = cls.java_class.java_method 'foo', java.util.concurrent.Callable
+  end
+
+  def test_interface_declaration
+    interface = compile('interface A; end').first
+    assert(interface.java_class.interface?)
+    assert_equal('A', interface.java_class.name)
+
+    a, b = compile('interface A; end; interface B < A; 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
+      end
+
+      interface B
+      end
+
+      interface C < A, B
+      end
+    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)
+  end
+
+  def test_interface_override_return_type
+    assert_raise_kind_of Mirah::MirahError do
+      compile(<<-EOF)
+        interface AnInterface
+          def a:int; end
+        end
+
+        class AImpl implements AnInterface
+          def a
+            "foo"
+          end
+        end
+      EOF
+    end
+  end
+
+  def test_interface_implementation_with_non_array_params_doesnt_require_type_information
+    interface, a_impl = compile(<<-EOF)
+        interface InterfaceWithStrings
+          def arr(message:String):int; end
+        end
+
+        class StringImpl implements InterfaceWithStrings
+          def blah(s:String) s.length ; end
+          def arr(message) blah message ; end
+        end
+      EOF
+  end
+
+  def test_interface_implementation_with_array_params_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
+
+        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
+  end
+end

data/test/jvm/java_typer_test.rb

@@ -28,12 +28,15 @@ class JavaTyperTest < Test::Unit::TestCase
   def setup
     @types = Mirah::JVM::Types::TypeFactory.new
     @scopes = SimpleScoper.new {|scoper, node| Mirah::AST::StaticScope.new(node, scoper)}
-    @typer = Mirah::Typer::Typer.new(@types, @scopes, nil)
+    @typer = Mirah::Typer::Typer.new(@types, @scopes, nil, nil)
     @mirah = Mirah::Transform::Transformer.new(Mirah::Util::CompilationState.new, @typer)
   end
 
-  def inferred_type(node)
-    type = @typer.infer(node, false).resolve
+  def inferred_type(node, expression=false)
+    if node.kind_of? Java::MirahLangAst::Script
+      node = node.body
+    end
+    type = @typer.infer(node, expression).resolve
     if type.name == ':error'
       catch(:exit) do
         process_errors([type])
@@ -42,10 +45,21 @@ class JavaTyperTest < Test::Unit::TestCase
     type
   end
 
+  def assert_errors_including(message, ast)
+    @typer.infer(ast, false)
+    actual_errors = []
+    process_inference_errors(@typer, [ast]) do |errors|
+      actual_errors += errors.map {|e| e.message.map{|m| m[0]}.join("\n")}
+    end
+    fail("no errors") if actual_errors.empty?
+    assert actual_errors.any?{|error| error =~ message },
+           "no errors with message \"#{message}\" in #{actual_errors}"
+  end
+
   def method_type(target, name, args)
     target = @types.cache_and_wrap(target)
     args = args.map {|arg| @types.cache_and_wrap(arg) }
-    call = CallFuture.new(@types, nil, target, name, args, nil, nil)
+    call = CallFuture.new(@types, nil, target, true, name, args, nil, nil)
     @types.getMethodType(call).return_type
   end
 
@@ -212,6 +226,14 @@ class JavaTyperTest < Test::Unit::TestCase
     assert_equal(@types.type(nil, 'byte'), method_type(ary, "[]", [int]).resolve)
   end
 
+
+  def test_primitive_not_convertible_to_array_with_same_component_type
+    ary = @types.type(nil, 'byte', true)
+    byte = @types.type(nil, 'byte')
+
+    assert !primitive_convertible?(byte, ary)
+  end
+
   def test_int
     ast = parse("#{1 << 16}")
     assert_equal(@types.type(nil, 'int'), inferred_type(ast))
@@ -221,17 +243,41 @@ class JavaTyperTest < Test::Unit::TestCase
     ast = parse("#{1 << 33}")
     assert_equal(@types.type(nil, 'long'), inferred_type(ast))
   end
-
-  def test_dynamic_assignability
-    ast = parse("a = 1; a = dynamic('foo')")
-    assert_equal true, inferred_type(ast).isError
-
-    ast = parse("a = Object.new; a = dynamic('foo')")
-    assert_equal 'java.lang.Object', inferred_type(ast).name
+  
+  def test_char
+    ast = parse("?a")
+    assert_equal(@types.type(nil, 'char'), inferred_type(ast))
   end
 
   def test_static_method
     ast = parse("class Foo;def self.bar; 1; end; end; Foo.bar")
     assert_equal(@types.type(nil, 'int'), inferred_type(ast))
   end
+
+  def test_if_with_raise_has_non_raise_type
+    ast = parse("if true; 1; else; raise 'error'; end")
+    assert_equal(@types.type(nil, 'int'), inferred_type(ast))
+  end
+
+  def test_rescue_with_raise_in_rescue_has_body_type
+    ast = parse("1 + begin; 1; rescue; raise 'error'; end")
+    assert_equal(@types.type(nil, 'int'), inferred_type(ast))
+  end
+
+  def test_rescue_with_else_and_raise_in_rescue_has_else_type
+    ast = parse("1 + begin; ''; rescue; raise 'error'; else 1 end")
+    assert_equal(@types.type(nil, 'int'), inferred_type(ast))
+  end
+
+  def test_type_cycle
+    ast = parse(<<-EOF)
+      def foo(a:String):Object
+        nil
+      end
+
+      a = "x"
+      a = foo(a)
+    EOF
+    assert_errors_including(/Cannot assign .*Object.* to .*String/, ast)
+  end
 end

data/test/jvm/jvm_commands_test.rb

@@ -0,0 +1,24 @@
+# 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.
+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
+    end
+  end
+end

data/test/jvm/jvm_compiler_test.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2010 The Mirah project authors. All Rights Reserved.
+# 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");
@@ -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")
@@ -147,10 +140,9 @@ class JVMCompilerTest < Test::Unit::TestCase
     cls, = compile("def foo; a = char[2]; a; end")
     assert_equal(Java::char[].java_class, cls.foo.class.java_class)
     assert_equal([0,0], cls.foo.to_a)
-    # Pending char constants or casts
-    # cls, = compile("def foo; a = char[2]; a[0] = 1; a[0]; end")
-    # assert_equal(Fixnum, cls.foo.class)
-    # assert_equal(1, cls.foo)
+
+    cls, = compile("def foo; a = char[2]; a[0] = ?x; a[0]; end")
+    assert_equal(?x.ord, cls.foo)
 
     cls, = compile("def foo; a = int[2]; a; end")
     assert_equal(Java::int[].java_class, cls.foo.class.java_class)
@@ -206,29 +198,6 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal([nil, nil], cls.foo.to_a)
   end
 
-  def test_string_concat
-    cls, = compile("
-      def str_str; a = 'a'; b = 'b'; a + b; end
-      def str_boolean; a = 'a'; b = false; a + b; end
-      def str_float; a = 'a'; b = float(1.0); a + b; end
-      def str_double; a = 'a'; b = 1.0; a + b; end
-      def str_byte; a = 'a'; b = byte(1); a + b; end
-      def str_short; a = 'a'; b = short(1); a + b; end
-      def str_char; a = 'a'; b = char(123); a + b; end
-      def str_int; a = 'a'; b = 1; a + b; end
-      def str_long; a = 'a'; b = long(1); a + b; end
-    ")
-    assert_equal("ab", cls.str_str)
-    assert_equal("afalse", cls.str_boolean)
-    assert_equal("a1.0", cls.str_float)
-    assert_equal("a1.0", cls.str_double)
-    assert_equal("a1", cls.str_byte)
-    assert_equal("a1", cls.str_short)
-    assert_equal("a{", cls.str_char)
-    assert_equal("a1", cls.str_int)
-    assert_equal("a1", cls.str_long)
-  end
-
   def test_void_selfcall
     cls, = compile("import 'System', 'java.lang.System'; def foo; System.gc; end; foo")
     assert_nothing_raised {cls.foo}
@@ -266,61 +235,18 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   end
 
-  def test_import
-    cls, = compile("import 'java.util.ArrayList'; def foo; ArrayList.new; end; foo")
-    assert_equal java.util.ArrayList.java_class, cls.foo.java_class
-
-    cls, = compile("import 'AL', 'java.util.ArrayList'; def foo; AL.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)
-        a.call
-      end
-    EOF
-    result = cls.foo {0}
-    assert_equal 0, result
-    m = cls.java_class.java_method 'foo', java.util.concurrent.Callable
-  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("System.out.println '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("System.out.println 'blah'", 'class-dash-test.mirah')
+    foo, = compile("System.out.println 'blah'", :name => 'class-dash-test.mirah')
     assert_equal('ClassDashTest', foo.java_class.name)
   end
 
@@ -351,7 +277,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_unless_fixnum
     cls, = compile(<<-EOF)
-      def foo(a:fixnum)
+      def foo(a:int)
         values = boolean[5]
         values[0] = true unless a < 0
         values[1] = true unless a <= 0
@@ -385,7 +311,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_if_fixnum
     cls, = compile(<<-EOF)
-      def foo(a:fixnum)
+      def foo(a:int)
         if a < -5
           -6
         elsif a <= 0
@@ -462,7 +388,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_trailing_conditions
     cls, = compile(<<-EOF)
-      def foo(a:fixnum)
+      def foo(a:int)
         return '+' if a > 0
         return '0' unless a < 0
         '-'
@@ -489,25 +415,25 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_loop
     cls, = compile(
-        'def foo(a:fixnum);while a > 0; a -= 1; System.out.println ".";end;end')
+        'def foo(a:int);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; System.out.println ".";end while a > 0;end')
+        'def foo(a:int);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; System.out.println ".";end;end')
+        'def foo(a:int);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; System.out.println ".";end until a <= 0;end')
+        'def foo(a:int);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)})
@@ -518,7 +444,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
     # TODO: loop doesn't work unless you're explicitly in a class
     # cls, = compile(<<-EOF)
-    #   def bar(a:fixnum)
+    #   def bar(a:int)
     #     loop do
     #       a += 1
     #       break if a > 2
@@ -530,7 +456,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
     loopy, = compile(<<-EOF)
     class Loopy
-      def bar(a:fixnum)
+      def bar(a:int)
         loop do
           a += 1
           break if a > 2
@@ -701,7 +627,7 @@ class JVMCompilerTest < Test::Unit::TestCase
   def test_fields
     cls, = compile(<<-EOF)
       class FieldTest
-        def initialize(a:fixnum)
+        def initialize(a:int)
           @a = a
         end
 
@@ -709,7 +635,7 @@ class JVMCompilerTest < Test::Unit::TestCase
           @a
         end
 
-        def self.set_b(b:fixnum)
+        def self.set_b(b:int)
           @@b = b
         end
 
@@ -791,58 +717,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; end').first
-    assert(interface.java_class.interface?)
-    assert_equal('A', interface.java_class.name)
-
-    a, b = compile('interface A; end; interface B < A; 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
+  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
+    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
+    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)
-  end
-
-  def test_interface_override_return_type
-    assert_raise Mirah::MirahError do
-      compile(<<-EOF)
-        interface A
-          def a: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
@@ -895,153 +815,6 @@ class JVMCompilerTest < Test::Unit::TestCase
     end
   end
 
-  def test_ensure
-    cls, = compile(<<-EOF)
-      def foo
-        1
-      ensure
-        System.out.println "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
-        System.out.println "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
-          System.out.println "Hi"
-        end while false
-      end
-    EOF
-    output = capture_output 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
     cls, = compile(<<-EOF)
       def foo
@@ -1440,7 +1213,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_super
     cls, = compile(<<-EOF)
-      class Foo
+      class SuperEqual
         def equals(other:Object); super(other); end
       end
     EOF
@@ -1501,43 +1274,6 @@ class JVMCompilerTest < Test::Unit::TestCase
     cls.make_one(nil)
   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)
@@ -1628,6 +1364,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
@@ -1649,35 +1397,6 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal(false, cls.string(2))
   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...
 #  def test_field_write
 #    cls, = compile(<<-EOF)
@@ -1712,25 +1431,8 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal('Static Hello', output)
   end
 
-  def test_loop_in_ensure
-    cls, = compile(<<-EOF)
-    begin
-      System.out.println "a"
-      begin
-        System.out.println "b"
-        break
-      end while false
-      System.out.println "c"
-    ensure
-      System.out.println "ensure"
-    end
-    EOF
-
-    assert_output("a\nb\nc\nensure\n") { cls.main(nil) }
-  end
-
   def test_return_type
-    assert_raise Mirah::MirahError do
+    assert_raise_kind_of Mirah::MirahError do
       compile(<<-EOF)
         class ReturnsA
           def a:int
@@ -1740,7 +1442,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       EOF
     end
 
-    assert_raise Mirah::MirahError do
+    assert_raise_kind_of Mirah::MirahError do
       compile(<<-EOF)
         class ReturnsB
           def self.a:String
@@ -1923,7 +1625,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 
     cls, = compile(<<-EOF)
       a = nil
-      System.out.println a
+      System.out.println Object(a)
     EOF
 
     assert_output("null\n") do
@@ -1960,7 +1662,7 @@ class JVMCompilerTest < Test::Unit::TestCase
     end
   end
 
-  def test_field_setter_wit_nil
+  def test_field_setter_with_nil
     cls, = compile(<<-EOF)
       import mirah.lang.ast.*
       a = Arguments.new
@@ -1971,4 +1673,118 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_output("OK") { cls.main(nil) }
   end
 
+  def test_assign_int_to_double
+    cls, = compile(<<-EOF)
+      def foo
+        a = 1.0
+        a = 0
+      end
+    EOF
+    
+    assert_equal(0.0, cls.foo)
+  end
+
+  def test_assign_int_to_double_with_additional_assign_is_int
+    cls, = compile(<<-EOF)
+      def foo
+        a = 1.0
+        b = a = 0
+      end
+    EOF
+    assert(cls.foo.is_a? Fixnum)
+    assert_equal(0, cls.foo)
+  end
+
+  def test_assign_int_to_double_with_additional_assign_and_specified_return_as_double_is_double
+    cls, = compile(<<-EOF)
+      def foo : double
+        a = 1.0
+        b = a = 0
+      end
+    EOF
+    assert(cls.foo.is_a? Float)
+    assert_equal(0, cls.foo)
+  end
+
+  def test_return_int_when_specified_return_as_double_is_double
+    cls, = compile(<<-EOF)
+      def foo : double
+        0
+      end
+    EOF
+    assert(cls.foo.is_a? Float)
+    assert_equal(0, cls.foo)
+  end
+
+  def test_assign_int_to_double_in_closure
+    cls, = compile(<<-EOF)
+      def bar(r:Runnable); r.run; end
+
+      def foo
+        a = 1.0
+        bar do
+          a = 0
+        end
+        a
+      end
+    EOF
+
+    assert_equal(0.0, cls.foo)
+  end
+
+  def test_array_literals_are_modifiable
+    cls, = compile(<<-EOF)
+      def foo
+        arr = [1,2]
+        arr.add(3)
+        arr[2]
+      end
+    EOF
+
+    assert_equal(3, cls.foo)
+  end
+
+  def test_static_method_inheritance
+    cls, = compile(<<-EOF)
+      class Parent
+        def self.my_method
+          'ran my method'
+        end
+      end
+
+      class Child < Parent
+      end
+
+      puts Child.my_method
+    EOF
+
+    assert_output "ran my method\n" do
+      cls.main(nil)
+    end
+  end
+
+  def test_static_field_inheritance_lookup_with_dot
+    cls, = compile(<<-EOF)
+      import java.util.GregorianCalendar
+      puts GregorianCalendar.AM
+    EOF
+
+    assert_output "0\n" do
+      cls.main(nil)
+    end
+  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
+    EOF
+
+    assert_output "0\n" do
+      cls.main(nil)
+    end
+    }
+  end
+
 end