mirah 0.0.10-java → 0.0.11-java

data/test/jvm/{test_jvm_compiler.rb → jvm_compiler_test.rb~}

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class TestJVMCompiler < Test::Unit::TestCase
+class JVMCompilerTest < Test::Unit::TestCase
   def assert_raise_java(type, message="")
     ex = assert_raise(NativeException) do
       yield
@@ -345,14 +345,6 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal("Hello World!", output)
   end
 
-  def test_constructor
-    cls, = compile(
-        "class InitializeTest;def initialize;puts 'Constructed';end;end")
-    assert_output("Constructed\n") do
-      cls.new
-    end
-  end
-
   def test_method
     # TODO auto generate a constructor
     cls, = compile(
@@ -1396,57 +1388,6 @@ class TestJVMCompiler < Test::Unit::TestCase
     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
-    sc_a, sc_b = compile(<<-EOF)
-      class SC_A
-        def initialize(a:int)
-          puts "A"
-        end
-      end
-
-      class SC_B < SC_A
-        def initialize
-          super(0)
-          puts "B"
-        end
-      end
-    EOF
-
-    assert_output("A\nB\n") do
-      sc_b.new
-    end
-  end
 
   def test_literal_array
     cls, = compile(<<-EOF)
@@ -1503,15 +1444,6 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal java.lang.String.java_class.array_class, cls.split.class.java_class
   end
 
-  def test_empty_constructor
-    foo, = compile(<<-EOF)
-      class Foo6
-        def initialize; end
-      end
-    EOF
-    foo.new
-  end
-
   def test_same_field_name
     cls, = compile(<<-EOF)
       class A1
@@ -1546,15 +1478,6 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert !obj.equals(cls.new)
   end
 
-  def test_inexact_constructor
-    # FIXME: this is a stupid test
-    cls, = compile(
-        "class EmptyEmpty; def self.empty_empty; t = Thread.new(Thread.new); t.start; begin; t.join; rescue InterruptedException; end; puts 'ok'; end; end")
-    assert_output("ok\n") do
-      cls.empty_empty
-    end
-  end
-
   def test_method_lookup_with_overrides
     cls, = compile(<<-EOF)
       class Bar; implements Runnable
@@ -1570,132 +1493,6 @@ class TestJVMCompiler < Test::Unit::TestCase
     # 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 {|x, 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
-
-    cls, = compile(<<-EOF)
-      def run(x:Runnable)
-        x.run
-      end
-      def foo
-        a = 1
-        run {a += 1}
-        a
-      end
-    EOF
-    assert_equal(2, cls.foo)
-  end
-
-  def test_block_with_method_def
-    cls, = compile(<<-EOF)
-      import java.util.ArrayList
-      import java.util.Collections
-      list = ArrayList.new(["a", "ABC", "Cats", "b"])
-      Collections.sort(list) do
-        def equals(a:Object, b:Object)
-          String(a).equalsIgnoreCase(String(b))
-        end
-        def compare(a:Object, b:Object)
-          String(a).compareToIgnoreCase(String(b))
-        end
-      end
-      list.each {|x| puts x}
-    EOF
-
-    assert_output("a\nABC\nb\nCats\n") do
-      cls.main(nil)
-    end
-  end
-
-  def test_block_with_abstract_from_object
-    # Comparator interface also defines equals(Object) as abstract,
-    # but it can be inherited from Object. We test that here.
-    cls, = compile(<<-EOF)
-      import java.util.ArrayList
-      import java.util.Collections
-      list = ArrayList.new(["a", "ABC", "Cats", "b"])
-      Collections.sort(list) do |a, b|
-        String(a).compareToIgnoreCase(String(b))
-      end
-      list.each {|x| puts x}
-    EOF
-
-    assert_output("a\nABC\nb\nCats\n") do
-      cls.main(nil)
-    end
-  end
-  
-  def test_block_with_no_arguments_and_return_value
-    cls, = compile(<<-EOF)
-      import java.util.concurrent.Callable
-      def foo c:Callable
-        throws Exception
-         puts c.call
-      end
-      begin
-      foo do
-        "an object"
-      end
-      rescue
-        puts "never get here"
-      end
-    EOF
-    assert_output("an object\n") do
-      cls.main(nil)
-    end
-  end
-
-
   def test_optional_args
     cls, = compile(<<-EOF)
       def foo(a:int, b:int = 1, c:int = 2)
@@ -1854,6 +1651,15 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal(2, cls.foo(1))
   end
 
+  def test_string_interpolation_method_calls
+    cls, = compile <<-CODE
+      print "apples \#{'oranges'}".replace('apples', 'oranges')
+    CODE
+    assert_output "oranges oranges" do
+      cls.main nil
+    end
+  end
+
   def test_self_dot_static_methods
     cls, = compile(<<-EOF)
       class ClassWithStatics
@@ -1904,22 +1710,6 @@ class TestJVMCompiler < Test::Unit::TestCase
     assert_equal("java.lang.Character$UnicodeBlock", subset.java_class.name)
   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
-
   def test_class_literal
     cls, = compile(<<-EOF)
       def foo
@@ -2349,10 +2139,43 @@ class TestJVMCompiler < Test::Unit::TestCase
       puts c
     EOF
   end
+<<<<<<< HEAD:test/jvm/jvm_compiler_test.rb
 
   def test_missing_class_with_block_raises_inference_error
     assert_raises Typer::InferenceError do
       compile("Interface Implements_Go do; end")
     end
   end
+  
+  def test_bool_equality
+    cls, = compile("puts true == false")
+    assert_output("false\n") do
+      cls.main(nil)
+    end
+  end
+  
+  def test_bool_inequality
+    cls, = compile("puts true != false")
+    assert_output("true\n") do
+=======
+
+  def test_add_args_in_macro
+    cls, = compile(<<-EOF)
+      macro def foo(a)
+        import duby.lang.compiler.Node
+        quote { bar "1", `Node(a.child_nodes.get(0)).child_nodes`, "2"}
+      end
+
+      def bar(a:String, b:String, c:String, d:String)
+        puts "\#{a} \#{b} \#{c} \#{d}"
+      end
+
+      foo(["a", "b"])
+    EOF
+
+    assert_output("1 a b 2\n") do
+>>>>>>> parser_support:test/test_jvm_compiler.rb
+      cls.main(nil)
+    end
+  end
 end

data/test/jvm/{test_macros.rb → macros_test.rb}

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class TestMacros < Test::Unit::TestCase
+class MacrosTest < Test::Unit::TestCase
   def test_defmacro
     cls, = compile(<<-EOF)
       defmacro bar(x) do
@@ -157,4 +157,4 @@ class TestMacros < Test::Unit::TestCase
     end
 
   end
-end
+end

data/test/jvm/{test_main_method.rb → main_method_test.rb}

@@ -1,4 +1,4 @@
-class TestMainMethod < Test::Unit::TestCase
+class MainMethodTest < Test::Unit::TestCase
   def test_main_generation_for_file_with_class_of_same_name
     code = <<-EOC
       class WithMain
@@ -12,4 +12,4 @@ class TestMainMethod < Test::Unit::TestCase
       main_class.main(nil)
     end
   end
-end
+end

data/test/jvm/{test_rescue.rb → rescue_test.rb}

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-class TestRescue < Test::Unit::TestCase
+class RescueTest < Test::Unit::TestCase
 
   def test_rescue
     cls, = compile(<<-EOF)
@@ -130,6 +130,22 @@ class TestRescue < Test::Unit::TestCase
       cls.foo(false)
     end
     assert_equal "java.lang.Exception: !x", ex.message
+
+    cls, = compile(<<-EOF)
+      def foo:long
+        begin
+          return bar
+        rescue Exception => e
+          return long(0)
+        end
+      end
+
+      def bar
+        long(1)
+      end
+    EOF
+
+    assert_equal 1, cls.foo
   end
 
   def test_empty_rescues
@@ -148,5 +164,20 @@ class TestRescue < Test::Unit::TestCase
       end
       nil
     EOF
+
+    cls, = compile(<<-EOF)
+      def empty_with_ensure
+        begin
+          i = 0
+          while i < 10
+            i += 1
+          end
+        rescue
+        ensure
+          puts 'ensuring'
+        end
+        ""
+      end
+    EOF
   end
-end
+end

data/test/plugins/{test_gwt.rb → gwt_test.rb}

@@ -15,7 +15,7 @@
 
 require 'test_helper'
 
-class TestGWT < Test::Unit::TestCase
+class GWTTest < Test::Unit::TestCase
   include Mirah::AST
 
   def test_jsni_static
@@ -66,4 +66,4 @@ class TestGWT < Test::Unit::TestCase
     arg_size = new_ast.arguments.args.size
     assert_equal(arg_size, 2)
   end
-end
+end

data/test/test_helper.rb

@@ -17,3 +17,43 @@ require 'test/unit'
 require 'mirah'
 require 'jruby'
 require 'turn'
+
+module CommonAssertions
+  import java.lang.System
+  import java.io.PrintStream
+
+  def assert_include(value, array, message=nil)
+    message = build_message message, '<?> does not include <?>', array, value
+    assert_block message do
+      array.include? value
+    end
+  end
+  
+  def capture_output
+    saved_output = System.out
+    saved_stdout = $stdout
+    saved_stderr = $stderr
+    output = StringIO.new
+    System.setOut(PrintStream.new(output.to_outputstream))
+    $stdout = output
+    $stderr = output
+    begin
+      yield
+      output.rewind
+      output.read
+    ensure
+      System.setOut(saved_output)
+      $stdout = saved_stdout
+      $stderr = saved_stderr
+    end
+  end
+
+  def assert_output(expected, &block)
+    assert_equal(expected, capture_output(&block))
+  end
+
+end
+
+class Test::Unit::TestCase
+  include CommonAssertions
+end