duby 0.0.2-java → 0.0.3-java

data/test/test_compilation.rb

@@ -5,89 +5,103 @@ require 'jruby'
 
 class TestAst < Test::Unit::TestCase
   include Duby
-  
+
   class MockCompiler
     attr_accessor :calls
-    
+
     def initialize
       @calls = []
     end
     def compile(ast)
       ast.compile(self, true)
     end
-    
+
     def line(num)
       # ignore newlines
     end
-    
+
     def method_missing(sym, *args, &block)
       calls << [sym, *args]
       block.call if block
     end
   end
-  
+
+  class ClassComparison
+    def initialize(klass)
+      @class = klass
+    end
+
+    def ==(other)
+      other.kind_of?(@class)
+    end
+  end
+
+  def a(klass)
+    ClassComparison.new(klass)
+  end
+
   def setup
     @compiler = MockCompiler.new
   end
-  
+
   def test_fixnum
-    new_ast = AST.parse("1").body
-    
+    new_ast = AST.parse("1").body[0]
+
     new_ast.compile(@compiler, true)
-    
+
     assert_equal([[:fixnum, 1]], @compiler.calls)
   end
-  
+
   def test_string
-    new_ast = AST.parse("'foo'").body
-    
+    new_ast = AST.parse("'foo'").body[0]
+
     new_ast.compile(@compiler, true)
-    
+
     assert_equal([[:string, "foo"]], @compiler.calls)
   end
-  
+
   def test_float
-    new_ast = AST.parse("1.0").body
-    
+    new_ast = AST.parse("1.0").body[0]
+
     new_ast.compile(@compiler, true)
-    
+
     assert_equal([[:float, 1.0]], @compiler.calls)
   end
-  
+
   def test_boolean
-    new_ast = AST.parse("true").body
-    
+    new_ast = AST.parse("true").body[0]
+
     new_ast.compile(@compiler, true)
-    
+
     assert_equal([[:boolean, true]], @compiler.calls)
   end
-  
+
   def test_local
-    new_ast = AST.parse("a = 1").body
-    
+    new_ast = AST.parse("a = 1").body[0]
+
     new_ast.compile(@compiler, true)
-    
-    assert_equal([[:local_assign, "a", nil, true, AST.fixnum(nil, nil, 1)]], @compiler.calls)
+
+    assert_equal([[:local_assign, a(Duby::AST::StaticScope), "a", nil, true, AST.fixnum(nil, nil, 1)]], @compiler.calls)
   end
-  
+
   def test_local_typed
-    new_ast = AST.parse("a = 1").body
+    new_ast = AST.parse("a = 1").body[0]
     typer = Typer::Simple.new(:bar)
     new_ast.infer(typer)
     new_ast.compile(@compiler, true)
-    
-    assert_equal([[:local_assign, "a", AST.type(:fixnum), true, AST.fixnum(nil, nil, 1)]], @compiler.calls)
+
+    assert_equal([[:local_assign, a(Duby::AST::StaticScope), "a", AST.type(:fixnum), true, AST.fixnum(nil, nil, 1)]], @compiler.calls)
   end
 
   def test_return
-    new_ast = AST.parse("return 1").body
+    new_ast = AST.parse("return 1").body[0]
     new_ast.compile(@compiler, true)
 
     assert_equal([[:return, new_ast]], @compiler.calls)
   end
 
   def test_empty_array
-    new_ast = AST.parse("int[5]").body
+    new_ast = AST.parse("int[5]").body[0]
     new_ast.compile(@compiler, true)
 
     assert_equal(1, @compiler.calls.size)

data/test/test_env.rb

@@ -0,0 +1,42 @@
+require 'test/unit'
+require 'duby'
+
+class TestEnv < Test::Unit::TestCase
+  include Duby
+
+  def test_path_seperator
+    # Check that env var PATH_SEPERATOR is used
+    RbConfig::CONFIG['PATH_SEPARATOR'] = '*'
+    assert_equal('*', Duby::Env.path_seperator)
+
+    # Check that : (colon) is returned if no PATH_SEPERATOR env var set
+    RbConfig::CONFIG['PATH_SEPARATOR'] = ''
+    assert_equal(':', Duby::Env.path_seperator)
+  end
+
+  def test_encode_paths
+    RbConfig::CONFIG['PATH_SEPARATOR'] = ':'
+    
+    assert_equal('a:b:c', Duby::Env.encode_paths(['a','b','c']))
+    assert_equal('a', Duby::Env.encode_paths(['a']))
+    assert_equal('', Duby::Env.encode_paths([]))
+
+    RbConfig::CONFIG['PATH_SEPARATOR'] = ';'
+
+    assert_equal('a;b;c', Duby::Env.encode_paths(['a','b','c']))
+  end
+
+  def test_decode_paths
+    RbConfig::CONFIG['PATH_SEPARATOR'] = ':'
+
+    path_array = ['1','2']
+    assert_equal(['1','2','a','b','c','d'], Duby::Env.decode_paths('a:b:c:d', path_array))
+    assert_equal(['1','2','a','b','c','d'], path_array)
+
+    assert_equal(['a','b','c','d'], Duby::Env.decode_paths('a:b:c:d'))
+    assert_equal(['a'], Duby::Env.decode_paths('a'))
+
+    RbConfig::CONFIG['PATH_SEPARATOR'] = ';'
+    assert_equal(['a','b','c','d'], Duby::Env.decode_paths('a;b;c;d'))
+  end
+end

data/test/test_java_typer.rb

@@ -8,12 +8,12 @@ require 'duby/jvm/typer'
 
 class TestJavaTyper < Test::Unit::TestCase
   include Duby
-  
+
   def setup
     AST.type_factory = Duby::JVM::Types::TypeFactory.new
     @typer = Typer::JVM.new('foobar', nil)
     compiler = Duby::Compiler::JVM.new('foobar')
-    
+
     @java_typer = Typer::JavaTyper.new
   end
 
@@ -24,97 +24,81 @@ class TestJavaTyper < Test::Unit::TestCase
   def test_simple_overtyped_meta_method
     string_meta = AST::type('java.lang.String', false, true)
     string = AST::type('java.lang.String')
-    
+
     # integral types
     ['boolean', 'char', 'double', 'float', 'int', 'long'].each do |type_name|
       type = AST::type(type_name)
       return_type = @java_typer.method_type(@typer, string_meta, 'valueOf', [type])
       assert_equal(string, return_type, "valueOf(#{type}) should return #{string}")
     end
-    
+
     # char[]
     type = AST::type('char', true)
     return_type = @java_typer.method_type(@typer, string_meta, 'valueOf', [type])
     assert_equal(string, return_type)
-    
+
     # Object
     type = AST::type('java.lang.Object')
     return_type = @java_typer.method_type(@typer, string_meta, 'valueOf', [type])
     assert_equal(string, return_type)
   end
-  
+
   def test_non_overtyped_method
     string = AST::type('java.lang.String')
-    
+
     int = AST::type('int')
     return_type = @java_typer.method_type(@typer, string, 'length', [])
     assert_equal(int, return_type)
-    
+
     byte_array = AST::type('byte', true)
     return_type = @java_typer.method_type(@typer, string, 'getBytes', [])
     assert_equal(byte_array, return_type)
   end
-  
+
   def test_simple_overtyped_method
     string_meta = AST::type('java.lang.String', false, true)
     string = AST::type('java.lang.String')
-    
+
     return_type = @java_typer.method_type(@typer, string_meta, 'valueOf', [string])
     assert_equal(string, return_type)
   end
-  
+
   def test_primitive_conversion_method
     string = AST::type('java.lang.String')
     byte = AST::type('byte')
     char = AST::type('char')
     long = AST::type('long')
-    
+
     return_type = @java_typer.method_type(@typer, string, 'charAt', [byte])
     assert_equal(char, return_type)
-    
+
     assert_raise NoMethodError do
       @java_typer.method_type(@typer, string, 'charAt', [long])
     end
   end
-  
+
   include Duby::JVM::MethodLookup
-  
-  def test_complex_overtyped_method
-    printstream = java.io.PrintStream.java_class
-    object = java.lang.Object.java_class
-    string = java.lang.String.java_class
-    
-    # best match is Object
-    method = find_method(printstream, "println", [object], false)
-    assert_match('println(java.lang.Object)', method.to_s)
-    # best match is String
-    method = find_method(printstream, "println", [string], false)
-    assert_match('println(java.lang.String)', method.to_s)
-    # only match is Object
-    method = find_method(printstream, "println", [printstream], false)
-    assert_match('println(java.lang.Object)', method.to_s)
-  end
-  
+
   def test_is_more_specific
     object = java.lang.Object.java_class
     charseq = java.lang.CharSequence.java_class
     string = java.lang.String.java_class
-    
+
     assert @java_typer.is_more_specific?([string], [object])
     assert @java_typer.is_more_specific?([charseq], [object])
     assert @java_typer.is_more_specific?([string], [charseq])
   end
-  
+
   def test_primitive_convertible
-    boolean = Java::boolean.java_class
-    byte = Java::byte.java_class
-    short = Java::short.java_class
-    char = Java::char.java_class
-    int = Java::int.java_class
-    long = Java::long.java_class
-    float = Java::float.java_class
-    double = Java::double.java_class
-    
+    boolean = Duby::JVM::Types::Boolean
+    byte = Duby::JVM::Types::Byte
+    short = Duby::JVM::Types::Short
+    char = Duby::JVM::Types::Char
+    int = Duby::JVM::Types::Int
+    long = Duby::JVM::Types::Long
+    float = Duby::JVM::Types::Float
+    double = Duby::JVM::Types::Double
+
     assert !primitive_convertible?(boolean, byte)
     assert !primitive_convertible?(boolean, short)
     assert !primitive_convertible?(boolean, char)
@@ -123,16 +107,16 @@ class TestJavaTyper < Test::Unit::TestCase
     assert !primitive_convertible?(boolean, float)
     assert !primitive_convertible?(boolean, double)
     assert primitive_convertible?(boolean, boolean)
-    
+
     assert !primitive_convertible?(byte, boolean)
     assert primitive_convertible?(byte, byte)
     assert primitive_convertible?(byte, short)
-    assert primitive_convertible?(byte, char)
+    assert !primitive_convertible?(byte, char)
     assert primitive_convertible?(byte, int)
     assert primitive_convertible?(byte, long)
     assert primitive_convertible?(byte, float)
     assert primitive_convertible?(byte, double)
-    
+
     assert !primitive_convertible?(short, boolean)
     assert !primitive_convertible?(short, byte)
     assert !primitive_convertible?(short, char)
@@ -141,7 +125,7 @@ class TestJavaTyper < Test::Unit::TestCase
     assert primitive_convertible?(short, long)
     assert primitive_convertible?(short, float)
     assert primitive_convertible?(short, double)
-    
+
     assert !primitive_convertible?(char, boolean)
     assert !primitive_convertible?(char, byte)
     assert !primitive_convertible?(char, short)
@@ -150,7 +134,7 @@ class TestJavaTyper < Test::Unit::TestCase
     assert primitive_convertible?(char, long)
     assert primitive_convertible?(char, float)
     assert primitive_convertible?(char, double)
-    
+
     assert !primitive_convertible?(int, boolean)
     assert !primitive_convertible?(int, byte)
     assert !primitive_convertible?(int, short)
@@ -159,16 +143,16 @@ class TestJavaTyper < Test::Unit::TestCase
     assert primitive_convertible?(int, long)
     assert primitive_convertible?(int, float)
     assert primitive_convertible?(int, double)
-    
+
     assert !primitive_convertible?(long, boolean)
     assert !primitive_convertible?(long, byte)
     assert !primitive_convertible?(long, short)
     assert !primitive_convertible?(long, char)
     assert !primitive_convertible?(long, int)
     assert primitive_convertible?(long, long)
-    assert !primitive_convertible?(long, float)
+    assert primitive_convertible?(long, float)
     assert primitive_convertible?(long, double)
-    
+
     assert !primitive_convertible?(float, boolean)
     assert !primitive_convertible?(float, byte)
     assert !primitive_convertible?(float, short)
@@ -177,7 +161,7 @@ class TestJavaTyper < Test::Unit::TestCase
     assert !primitive_convertible?(float, long)
     assert primitive_convertible?(float, float)
     assert primitive_convertible?(float, double)
-    
+
     assert !primitive_convertible?(double, boolean)
     assert !primitive_convertible?(double, byte)
     assert !primitive_convertible?(double, short)

data/test/test_javac_compiler.rb

@@ -7,6 +7,9 @@ require 'jruby'
 require 'stringio'
 require File.join(File.dirname(__FILE__), 'test_jvm_compiler')
 
+# make sure . is in CLASSPATH
+$CLASSPATH << '.'
+
 class TestJavacCompiler < TestJVMCompiler
   import javax.tools.ToolProvider
   import java.util.Arrays
@@ -37,7 +40,7 @@ class TestJavacCompiler < TestJVMCompiler
     File.unlink(*@tmp_classes)
     @tmp_classes.clear
     AST.type_factory = Duby::JVM::Types::TypeFactory.new
-    transformer = Duby::Transform::Transformer.new
+    transformer = Duby::Transform::Transformer.new(Duby::CompilationState.new)
     ast  = AST.parse(code, name, true, transformer)
     name = "script" + System.nano_time.to_s
     typer = Typer::JVM.new(name, transformer)

data/test/test_jvm_compiler.rb

@@ -10,12 +10,12 @@ unless Duby::AST.macro "__gloop__"
     Duby::AST::Loop.new(parent, parent.position, true, false) do |loop|
       init, condition, check_first, pre, post = fcall.args_node.child_nodes.to_a
       loop.check_first = check_first.kind_of?(Duby::AST::JRubyAst::TrueNode)
-      
+
       nil_t = Duby::AST::JRubyAst::NilNode
       loop.init = transformer.transform(init, loop) unless init.kind_of?(nil_t)
       loop.pre = transformer.transform(pre, loop) unless pre.kind_of?(nil_t)
       loop.post = transformer.transform(post, loop) unless post.kind_of?(nil_t)
-      
+
       body = transformer.transform(fcall.iter_node, loop).body
       body.parent = loop
       [
@@ -54,27 +54,29 @@ class TestJVMCompiler < Test::Unit::TestCase
     @tmp_classes.clear
     AST.type_factory = Duby::JVM::Types::TypeFactory.new
     name = "script" + System.nano_time.to_s
-    transformer = Duby::Transform::Transformer.new
+    transformer = Duby::Transform::Transformer.new(Duby::CompilationState.new)
     ast  = AST.parse(code, name, true, transformer)
     typer = Typer::JVM.new(name, transformer)
     ast.infer(typer)
     typer.resolve(true)
     compiler = Compiler::JVM.new(name)
     compiler.compile(ast)
-    classes = []
-    loader = org.jruby.util.JRubyClassLoader.new(
-        JRuby.runtime.jruby_class_loader)
+    classes = {}
+    loader = DubyClassLoader.new(JRuby.runtime.jruby_class_loader, classes)
     compiler.generate do |name, builder|
       bytes = builder.generate
       open("#{name}", "w") do |f|
         f << bytes
       end
-      cls = loader.define_class(name[0..-7], bytes.to_java_bytes)
-      classes << JavaUtilities.get_proxy_class(cls.name)
-      @tmp_classes << "#{name}"
+      classes[name[0..-7]] = bytes
     end
 
-    classes
+    classes.keys.map do |name|
+      cls = loader.load_class(name)
+      proxy = JavaUtilities.get_proxy_class(cls.name)
+      @tmp_classes << "#{name}.class"
+      proxy
+    end
   end
 
   def test_local
@@ -119,7 +121,7 @@ class TestJVMCompiler < Test::Unit::TestCase
     cls, = compile("def foo; a = 6.0; b = 3.0; a / b; end")
     assert_equal(2.0, cls.foo)
   end
-  
+
   def test_rem
     cls, = compile("def foo; a = 7; b = 3; a % b; end")
     assert_equal(1, cls.foo)
@@ -184,7 +186,7 @@ class TestJVMCompiler < Test::Unit::TestCase
     cls, = compile("def foo; a = boolean[2]; a.length; end")
     assert_equal(Fixnum, cls.foo.class)
     assert_equal(2, cls.foo)
-    
+
     cls, = compile("def foo; a = byte[2]; a; end")
     assert_equal(Java::byte[].java_class, cls.foo.class.java_class)
     assert_equal([0,0], cls.foo.to_a)
@@ -255,7 +257,7 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal(Java::int[].java_class, array.class.java_class)
     assert_equal([0,0,0,0], array.to_a)
   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)
@@ -271,7 +273,7 @@ class TestJVMCompiler < Test::Unit::TestCase
     cls, = compile("import 'System', 'java.lang.System'; def foo; System.gc; end; foo")
     assert_nothing_raised {cls.foo}
   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
@@ -279,11 +281,11 @@ class TestJVMCompiler < Test::Unit::TestCase
     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
@@ -293,6 +295,16 @@ class TestJVMCompiler < Test::Unit::TestCase
     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'
@@ -305,7 +317,7 @@ class TestJVMCompiler < Test::Unit::TestCase
     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
@@ -325,7 +337,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       System.setOut(saved_output)
     end
   end
-  
+
   def assert_output(expected, &block)
     assert_equal(expected, capture_output(&block))
   end
@@ -338,6 +350,14 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal("Hello World!\n", output)
   end
 
+  def test_print
+    cls, = compile("def foo;print 'Hello World!';end")
+    output = capture_output do
+      cls.foo
+    end
+    assert_equal("Hello World!", output)
+  end
+
   def test_constructor
     cls, = compile(
         "class InitializeTest;def initialize;puts 'Constructed';end;end")
@@ -349,7 +369,7 @@ class TestJVMCompiler < Test::Unit::TestCase
   def test_method
     # TODO auto generate a constructor
     cls, = compile(
-      "class MethodTest; def initialize; ''; end; def foo; 'foo';end;end")
+      "class MethodTest; def foo; 'foo';end;end")
     instance = cls.new
     assert_equal(cls, instance.class)
     assert_equal('foo', instance.foo)
@@ -513,7 +533,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       end
     EOF
     assert_equal([2, 2], cls.foo.to_a)
-    
+
   end
 
   def test_loop
@@ -522,19 +542,19 @@ class TestJVMCompiler < Test::Unit::TestCase
     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')
     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')
     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')
     assert_equal(".\n", capture_output{cls.foo(0)})
@@ -558,7 +578,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       end
     EOF
     assert_equal(1, cls.foo)
-    
+
     cls, = compile <<-EOF
       def foo
         a = 0
@@ -707,7 +727,7 @@ class TestJVMCompiler < Test::Unit::TestCase
         def initialize(a => :fixnum)
           @a = a
         end
-        
+
         def a
           @a
         end
@@ -720,29 +740,29 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal(1, first.a)
     assert_equal(2, second.a)
   end
-  
+
   def test_object_intrinsics
     cls, = compile(<<-EOF)
       import 'java.lang.Object'
       def nil(a => :Object)
         a.nil?
       end
-      
+
       def equal(a => Object, b => Object)
         a == b
       end
     EOF
-    
+
     assert(cls.nil(nil))
     assert(!cls.nil("abc"))
-    
+
     a = "foobar".to_java_string
     b = java.lang.Object.new
     assert(cls.equal(a, a))
     assert(cls.equal(b, b))
     assert(!cls.equal(a, b))
   end
-  
+
   def test_implements
     script, cls = compile(<<-EOF)
       import java.lang.Iterable
@@ -755,69 +775,69 @@ class TestJVMCompiler < Test::Unit::TestCase
 
     assert_include java.lang.Iterable.java_class, cls.java_class.interfaces
   end
-  
+
   def test_argument_widening
     cls, = compile(<<-EOF)
-      def Byte(a => :byte)
-        Short(a)
+      def _Byte(a => :byte)
+        _Short(a)
       end
-    
-      def Short(a => :short)
-        Int(a)
+
+      def _Short(a => :short)
+        _Int(a)
       end
-    
-      def Int(a => :int)
-        Long(a)
+
+      def _Int(a => :int)
+        _Long(a)
       end
-    
-      def Long(a => :long)
-        Float(a)
+
+      def _Long(a => :long)
+        _Float(a)
       end
-    
-      def Float(a => :float)
-        Double(a)
+
+      def _Float(a => :float)
+        _Double(a)
       end
-    
-      def Double(a => :double)
+
+      def _Double(a => :double)
         a
       end
       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
     script, interface = compile('interface A do; end')
     assert(interface.java_class.interface?)
     assert_equal('A', interface.java_class.name)
-    
+
     script, 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)
-    
+
     script, a, b, c = compile(<<-EOF)
       interface A do
       end
-      
+
       interface B do
       end
-      
+
       interface C < A, B do
       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)
-    
+
     assert_raise Duby::Typer::InferenceError do
       compile(<<-EOF)
         interface A do
@@ -825,7 +845,7 @@ class TestJVMCompiler < Test::Unit::TestCase
             returns :int
           end
         end
-      
+
         class Impl; implements A
           def a
             "foo"
@@ -891,7 +911,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       cls.foo
     end
   end
-  
+
   def test_rescue
     cls, = compile(<<-EOF)
       def foo
@@ -1080,7 +1100,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       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
@@ -1132,33 +1152,33 @@ class TestJVMCompiler < Test::Unit::TestCase
     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
         @foo
       end
-      
+
       def foo=(foo:int)
         @foo = foo
       end
     EOF
-    
+
     assert_equal(0, cls.foo)
     assert_equal(2, cls.foo_set(2))
     assert_equal(2, cls.foo)
   end
-  
+
   def test_null_is_false
     cls, = compile("def foo(a:String);if a;true;else;false;end;end")
     assert_equal(true, cls.foo("a"))
     assert_equal(false, cls.foo(nil))
   end
-  
+
   def test_for
     cls, = compile(<<-EOF)
       def foo
@@ -1170,7 +1190,7 @@ class TestJVMCompiler < Test::Unit::TestCase
         count
       end
     EOF
-    
+
     cls, = compile(<<-EOF)
       def foo(a:int[])
         count = 0
@@ -1190,7 +1210,7 @@ class TestJVMCompiler < Test::Unit::TestCase
         end
       end
     EOF
-    
+
     assert_output("1\n2\n3\n") do
       list = java.util.ArrayList.new
       list << "1"
@@ -1247,6 +1267,52 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal(false, cls.foo(["a", nil, "b"].to_java(:string)))
   end
 
+  def test_downto
+    cls, = compile(<<-EOF)
+      def foo(i:int)
+        i.downto(1) {|x| puts x }
+      end
+    EOF
+
+    assert_output("3\n2\n1\n") do
+      cls.foo(3)
+    end
+  end
+
+  def test_upto
+    cls, = compile(<<-EOF)
+      def foo(i:int)
+        i.upto(3) {|x| puts x }
+      end
+    EOF
+
+    assert_output("1\n2\n3\n") do
+      cls.foo(1)
+    end
+  end
+
+  def test_times
+    cls, = compile(<<-EOF)
+      def foo(i:int)
+        i.times {|x| puts x }
+      end
+    EOF
+
+    assert_output("0\n1\n2\n") do
+      cls.foo(3)
+    end
+
+    cls, = compile(<<-EOF)
+      def foo(i:int)
+        i.times { puts "Hi" }
+      end
+    EOF
+
+    assert_output("Hi\nHi\nHi\n") do
+      cls.foo(3)
+    end
+  end
+
   def test_general_loop
     cls, = compile(<<-EOF)
       def foo(x:boolean)
@@ -1256,7 +1322,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       end
     EOF
     assert_equal("", cls.foo(false))
-    
+
     cls, = compile(<<-EOF)
       def foo
         a = ""
@@ -1265,7 +1331,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       end
     EOF
     assert_equal("<body>", cls.foo)
-    
+
     cls, = compile(<<-EOF)
       def foo(x:boolean)
         a = ""
@@ -1276,7 +1342,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       end
     EOF
     assert_equal("<init>", cls.foo(false))
-    
+
     cls, = compile(<<-EOF)
       def foo
         a = ""
@@ -1287,7 +1353,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       end
     EOF
     assert_equal("<init><pre><body><post>", cls.foo)
-    
+
     cls, = compile(<<-EOF)
       def foo
         a = ""
@@ -1299,7 +1365,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       end
     EOF
     assert_equal( "<init><pre><body><body><post>", cls.foo)
-    
+
     cls, = compile(<<-EOF)
       def foo
         a = ""
@@ -1312,24 +1378,24 @@ class TestJVMCompiler < Test::Unit::TestCase
     EOF
     assert_equal("<init><pre><post><pre><body><post>", cls.foo)
   end
-  
+
   def test_if_expr
     cls, = compile(<<-EOF)
       def foo(a:int)
         return 1 if a == 1
       end
-      
+
       def bar(a:int)
         return 1 unless a == 1
       end
     EOF
-    
+
     assert_equal(0, cls.foo(0))
     assert_equal(1, cls.foo(1))
     assert_equal(1, cls.bar(0))
     assert_equal(0, cls.bar(1))
   end
-  
+
   def test_and
     cls, = compile(<<-EOF)
       def bool(n:String, x:boolean)
@@ -1340,21 +1406,21 @@ class TestJVMCompiler < Test::Unit::TestCase
       def foo(a:boolean, b:boolean)
         return bool('a', a) && bool('b', b)
       end
-      
+
       def str(n:String, x:String)
         puts n
         x
       end
-      
+
       def bar(a:String, b:String)
         return str('a', a) && str('b', b)
       end
     EOF
-    
+
     assert_output("a\n") { assert_equal(false, cls.foo(false, true)) }
     assert_output("a\nb\n") { assert_equal(false, cls.foo(true, false)) }
     assert_output("a\nb\n") { assert_equal(true, cls.foo(true, true)) }
-    
+
     assert_output("a\n") { assert_equal(nil, cls.bar(nil, "B")) }
     assert_output("a\nb\n") { assert_equal(nil, cls.bar("A", nil)) }
     assert_output("a\nb\n") { assert_equal("B", cls.bar("A", "B")) }
@@ -1363,15 +1429,15 @@ class TestJVMCompiler < Test::Unit::TestCase
       def s
         @s
       end
-      
+
       def s=(s:String)
         @s = s
       end
-      
+
       def b
         @b
       end
-      
+
       def b=(b:boolean)
         @b = b
       end
@@ -1379,7 +1445,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       def foo(x:boolean)
         @b &&= x
       end
-            
+
       def bar(x:String)
         @s &&= x
       end
@@ -1396,7 +1462,7 @@ class TestJVMCompiler < Test::Unit::TestCase
     cls.b_set(true)
     assert_equal(true, cls.foo(true))
     assert_equal(true, cls.b)
-    
+
     cls.s_set(nil)
     assert_equal(nil, cls.bar(nil))
     assert_equal(nil, cls.s)
@@ -1408,41 +1474,41 @@ class TestJVMCompiler < Test::Unit::TestCase
     cls.s_set("S")
     assert_equal("x", cls.bar("x"))
     assert_equal("x", cls.s)
-    
+
     foo, = compile(<<-EOF)
       class Foo2
         def initialize
           @count = 0
         end
-        
+
         def count
           @count
         end
-        
+
         def a
           @a
         end
-        
+
         def a=(a:String)
           @count += 1
           @a = a
         end
-        
+
         def foo(f:Foo2, x:String)
           f.a &&= x
         end
       end
     EOF
-    
+
     f = foo.new
     assert_equal(nil, f.foo(f, 'x'))
     assert_equal(0, f.count)
-    
+
     f = foo.new
     f.a_set("A")
     assert_equal(nil, f.foo(f, nil))
     assert_equal(2, f.count)
-    
+
     f = foo.new
     f.a_set("A")
     assert_equal('x', f.foo(f, 'x'))
@@ -1459,21 +1525,21 @@ class TestJVMCompiler < Test::Unit::TestCase
       def foo(a:boolean, b:boolean)
         return bool('a', a) || bool('b', b)
       end
-      
+
       def str(n:String, x:String)
         puts n
         x
       end
-      
+
       def bar(a:String, b:String)
         return str('a', a) || str('b', b)
       end
     EOF
-    
+
     assert_output("a\n") { assert_equal(true, cls.foo(true, false)) }
     assert_output("a\nb\n") { assert_equal(false, cls.foo(false, false)) }
     assert_output("a\nb\n") { assert_equal(true, cls.foo(false, true)) }
-    
+
     assert_output("a\n") { assert_equal("A", cls.bar("A", nil)) }
     assert_output("a\nb\n") { assert_equal(nil, cls.bar(nil, nil)) }
     assert_output("a\nb\n") { assert_equal("B", cls.bar(nil, "B")) }
@@ -1482,15 +1548,15 @@ class TestJVMCompiler < Test::Unit::TestCase
       def s
         @s
       end
-      
+
       def s=(s:String)
         @s = s
       end
-      
+
       def b
         @b
       end
-      
+
       def b=(b:boolean)
         @b = b
       end
@@ -1498,7 +1564,7 @@ class TestJVMCompiler < Test::Unit::TestCase
       def foo(x:boolean)
         @b ||= x
       end
-            
+
       def bar(x:String)
         @s ||= x
       end
@@ -1515,7 +1581,7 @@ class TestJVMCompiler < Test::Unit::TestCase
     cls.b_set(true)
     assert_equal(true, cls.foo(false))
     assert_equal(true, cls.b)
-    
+
     cls.s_set(nil)
     assert_equal(nil, cls.bar(nil))
     assert_equal(nil, cls.s)
@@ -1533,34 +1599,34 @@ class TestJVMCompiler < Test::Unit::TestCase
         def initialize
           @count = 0
         end
-        
+
         def count
           @count
         end
-        
+
         def a
           @a
         end
-        
+
         def a=(a:String)
           @count += 1
           @a = a
         end
-        
+
         def foo(f:Foo3, x:String)
           f.a ||= x
         end
       end
     EOF
-    
+
     f = foo.new
     assert_equal('x', f.foo(f, 'x'))
     assert_equal(1, f.count)
-    
+
     f = foo.new
     assert_equal(nil, f.foo(f, nil))
     assert_equal(1, f.count)
-    
+
     f = foo.new
     f.a_set("A")
     assert_equal("A", f.foo(f, nil))
@@ -1571,26 +1637,26 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal("A", f.foo(f, 'X'))
     assert_equal(1, f.count)
   end
-  
+
   def test_op_elem_assign
     foo, = compile(<<-EOF)
       class Foo4
         def initialize
           @i = -1
         end
-        
+
         def i
           @i += 1
         end
-        
+
         def a
           @a
         end
-        
+
         def a=(a:String[])
           @a = a
         end
-        
+
         def foo(x:String)
           a[i] ||= x
         end
@@ -1600,7 +1666,7 @@ class TestJVMCompiler < Test::Unit::TestCase
         end
       end
     EOF
-    
+
     f = foo.new
     f.a_set([nil, nil, nil].to_java(:string))
     assert_equal(nil, f.bar("x"))
@@ -1608,38 +1674,38 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal("x", f.foo("x"))
     assert_equal([nil, "x", nil], f.a.to_a)
   end
-  
+
   def test_constructor_chaining
     foo, = compile(<<-EOF)
       class Foo5
         def initialize(s:String)
           initialize(s, "foo")
         end
-        
+
         def initialize(s:String, f:String)
           @s = s
           @f = f
         end
-        
+
         def f
           @f
         end
-        
+
         def s
           @s
         end
       end
     EOF
-    
+
     instance = foo.new("S")
     assert_equal("S", instance.s)
     assert_equal("foo", instance.f)
-    
+
     instance = foo.new("foo", "bar")
     assert_equal("foo", instance.s)
     assert_equal("bar", instance.f)
   end
-  
+
   def test_super_constructor
     cls, a, b = compile(<<-EOF)
       class SC_A
@@ -1647,7 +1713,7 @@ class TestJVMCompiler < Test::Unit::TestCase
           puts "A"
         end
       end
-      
+
       class SC_B < SC_A
         def initialize
           super(0)
@@ -1655,7 +1721,7 @@ class TestJVMCompiler < Test::Unit::TestCase
         end
       end
     EOF
-    
+
     assert_output("A\nB\n") do
       b.new
     end
@@ -1682,6 +1748,40 @@ class TestJVMCompiler < Test::Unit::TestCase
     end
   end
 
+  def test_literal_regexp
+    cls, = compile(<<-EOF)
+      def expr
+        /foo/
+      end
+      def matches
+        expr.matcher('barfoobaz').find
+      end
+    EOF
+
+    val = cls.expr
+    assert_equal java.util.regex.Pattern, val.class
+    assert_equal 'foo', val.to_s
+
+    assert cls.matches
+  end
+
+  def test_array_return_type
+    cls, = compile(<<-EOF)
+      def split
+        /foo/.split('barfoobaz')
+      end
+      def puts
+        puts split
+      end
+    EOF
+
+    assert_nothing_raised do
+      result = capture_output {cls.puts}
+      assert result =~ /\[Ljava\.lang\.String;@[a-f0-9]+/
+    end
+    assert_equal java.lang.String.java_class.array_class, cls.split.class.java_class
+  end
+
   def test_empty_constructor
     foo, = compile(<<-EOF)
       class Foo6
@@ -1694,19 +1794,17 @@ class TestJVMCompiler < Test::Unit::TestCase
   def test_same_field_name
     cls, = compile(<<-EOF)
       class A1
-        def initialize; end
         def foo(bar:String)
           @bar = bar
         end
       end
 
       class B1
-        def initialize; end
         def foo(bar:String)
           @bar = bar
         end
       end
-      
+
       puts A1.new.foo("Hi")
       puts B1.new.foo("There")
     EOF
@@ -1744,13 +1842,12 @@ class TestJVMCompiler < Test::Unit::TestCase
       end
     EOF
 
-    assert_not_nil cls.java_class.declared_fields[0].annotation(deprecated)    
+    assert_not_nil cls.java_class.declared_fields[0].annotation(deprecated)
   end
 
   def test_super
     cls, = compile(<<-EOF)
       class Foo
-        def initialize; end
         def equals(other:Object); super(other); end
       end
     EOF
@@ -1759,6 +1856,7 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert obj.equals(obj)
     assert !obj.equals(cls.new)
   end
+
   def test_inexact_constructor
     # FIXME: this is a stupid test
     cls, = compile(
@@ -1767,4 +1865,337 @@ class TestJVMCompiler < Test::Unit::TestCase
       cls.empty_empty
     end
   end
+
+  def test_method_lookup_with_overrides
+    cls, = compile(<<-EOF)
+      class Bar; implements Runnable
+        def foo(x:Bar)
+          Thread.new(x)
+        end
+        def run
+        end
+      end
+    EOF
+
+    # Just make sure this compiles.
+    # It shouldn't get confused by the Thread(String) constructor.
+  end
+
+  def test_block
+    cls, = compile(<<-EOF)
+      thread = Thread.new do
+        puts "Hello"
+      end
+      begin
+        thread.run
+        thread.join
+      rescue
+        puts "Uh Oh!"
+      end
+    EOF
+    assert_output("Hello\n") do
+      cls.main([].to_java :string)
+    end
+
+    script, cls = compile(<<-EOF)
+      import java.util.Observable
+      class MyObservable < Observable
+        def initialize
+          super
+          setChanged
+        end
+      end
+
+      o = MyObservable.new
+      o.addObserver {|o, a| puts a}
+      o.notifyObservers("Hello Observer")
+    EOF
+    assert_output("Hello Observer\n") do
+      script.main([].to_java :string)
+    end
+
+    cls, = compile(<<-EOF)
+      def foo
+        a = "Hello"
+        thread = Thread.new do
+          puts a
+        end
+        begin
+          a = a + " Closures"
+          thread.run
+          thread.join
+        rescue
+          puts "Uh Oh!"
+        end
+        return
+      end
+    EOF
+    assert_output("Hello Closures\n") do
+      cls.foo
+    end
+  end
+
+  def test_each
+    cls, = compile(<<-EOF)
+      def foo
+        [1,2,3].each {|x| puts x}
+      end
+    EOF
+    assert_output("1\n2\n3\n") do
+      cls.foo
+    end
+  end
+
+  def test_any
+    cls, = compile(<<-EOF)
+      import java.lang.Integer
+      def foo
+        puts [1,2,3].any?
+        puts [1,2,3].any? {|x| Integer(x).intValue > 3}
+      end
+    EOF
+    assert_output("true\nfalse\n") do
+      cls.foo
+    end
+  end
+
+  def test_all
+    cls, = compile(<<-EOF)
+      import java.lang.Integer
+      def foo
+        puts [1,2,3].all?
+        puts [1,2,3].all? {|x| Integer(x).intValue > 3}
+      end
+    EOF
+    assert_output("true\nfalse\n") do
+      cls.foo
+    end
+  end
+
+  def test_optional_args
+    cls, = compile(<<-EOF)
+      def foo(a:int, b:int = 1, c:int = 2)
+        puts a; puts b; puts c
+      end
+      foo(0)
+      foo(0,0)
+      foo(0,0,0)
+    EOF
+    assert_output("0\n1\n2\n0\n0\n2\n0\n0\n0\n") do
+      cls.main([].to_java :string)
+    end
+  end
+
+  def test_field_read
+    cls, = compile(<<-EOF)
+      puts System.out.getClass.getName
+    EOF
+    assert_output("java.io.PrintStream\n") do
+      cls.main([].to_java :String)
+    end
+  end
+
+  def test_array_arguments
+    cls, = compile(<<-EOF)
+      class ArrayArg
+        def initialize(foo:byte[]); end
+
+        def self.make_one(foo:byte[])
+          ArrayArg.new(foo)
+        end
+      end
+    EOF
+    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
+    script, 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_string_concat
+    cls, = compile(<<-EOF)
+      def foo(name:String)
+        print "Hello \#{name}."
+      end
+    EOF
+
+    assert_output("Hello Fred.") do
+      cls.foo "Fred"
+    end
+
+    cls, = compile(<<-EOF)
+      def foo(x:int)
+        print "\#{x += 1}"
+        x
+      end
+    EOF
+
+    assert_output("2") do
+      assert_equal(2, cls.foo(1))
+    end
+
+    cls, = compile(<<-EOF)
+      def foo(a:int)
+        "\#{a += 1}"
+        a
+      end
+    EOF
+    assert_equal(2, cls.foo(1))
+  end
+
+  def test_self_dot_static_methods
+    cls, = compile(<<-EOF)
+      class ClassWithStatics
+        def self.a
+          b
+        end
+        def self.b
+          print "b"
+        end
+      end
+    EOF
+
+    assert_output("b") do
+      cls.a
+    end
+  end
+
+  def test_evaluation_order
+    cls, = compile(<<-EOF)
+      def call(a:int, b:int, c:int)
+        print "\#{a}, \#{b}, \#{c}"
+      end
+      
+      def test_call(a:int)
+        call(a, if a < 10;a+=1;a;else;a;end, a)
+      end
+
+      def test_string(a:int)
+        "\#{a}, \#{if a < 10;a += 1;a;else;a;end}, \#{a}"
+      end
+    EOF
+
+    assert_output("1, 2, 2") do
+      cls.test_call(1)
+    end
+
+    assert_equal("2, 3, 3", cls.test_string(2))
+  end
+
+  def test_inner_class
+    cls, = compile(<<-EOF)
+      def foo
+        Character.UnicodeBlock.ARROWS
+      end
+    EOF
+
+    subset = cls.foo
+    assert_equal("java.lang.Character$UnicodeBlock", subset.java_class.name)
+  end
+
+  def test_defmacro
+    cls, = compile(<<-EOF)
+      defmacro bar(x) do
+        x
+      end
+      
+      def foo
+        bar("bar")
+      end
+    EOF
+
+    assert_equal("bar", cls.foo)
+    assert(!cls.respond_to?(:bar))
+  end
+
+  def test_default_constructor
+    script, cls = compile(<<-EOF)
+      class DefaultConstructable
+        def foo
+          "foo"
+        end
+      end
+
+      print DefaultConstructable.new.foo
+    EOF
+
+    assert_output("foo") do
+      script.main(nil)
+    end
+  end
+
+  # TODO: need a writable field somewhere...
+#  def test_field_write
+#    cls, = compile(<<-EOF)
+#      old_pi = Math.PI
+#      Math.PI = 3.0
+#      puts Math.PI
+#      Math.PI = old_pi
+#      puts Math.PI
+#    EOF
+#    raise
+#    cls.main([].to_java :string)
+#    assert_output("3.0\n") do
+#      cls.main([].to_java :string)
+#    end
+#  end
 end