mirah 0.1.2-java → 0.1.3-java

data/test/core/util/argument_processor_test.rb

@@ -15,50 +15,51 @@
 require 'test_helper'
 
 class ArgumentProcessorTest < Test::Unit::TestCase
-
+  java_import 'org.mirah.tool.MirahArguments'
   def test_arg_dash_v_prints_version_and_has_exit_0
-    state = Mirah::Util::CompilationState.new
-    processor = Mirah::Util::ArgumentProcessor.new state, ["-v"]
+    arg_processor = MirahArguments.new
 
     assert_output "Mirah v#{Mirah::VERSION}\n" do
-      processor.process
+      arg_processor.apply_args(["-v"])
     end
 
-    assert processor.exit?
-    assert_equal 0, processor.exit_status_code
+    assert arg_processor.exit?
+    assert_equal 0, arg_processor.exit_status
   end
 
 
   def test_on_invalid_arg_prints_error_and_exits_1
-    state = Mirah::Util::CompilationState.new
-    processor = Mirah::Util::ArgumentProcessor.new state, ["--some-arg"]
+    arg_processor = MirahArguments.new
 
-    assert_output "unrecognized flag: --some-arg\n" do
-      processor.process
+    assert_output "Unrecognized flag: --some-arg\n" do
+      arg_processor.apply_args(["--some-arg"])
     end
 
-    assert processor.exit?
-    assert_equal 1, processor.exit_status_code
+    assert arg_processor.exit?
+    assert_equal 1, arg_processor.exit_status
   end
 
-  def test_arg_bootclasspath_sets_bootclasspath_on_compilation_state
+  def test_arg_bootclasspath_sets_bootclasspath_with_absolute_paths
     path = "class:path"
-    state = Mirah::Util::CompilationState.new
-    processor = Mirah::Util::ArgumentProcessor.new state, ["--bootclasspath", path]
-    processor.process
+    arg_processor = MirahArguments.new
+    
+    arg_processor.apply_args ["--bootclasspath", path]
 
-    assert_equal path, state.bootclasspath
+    assert_equal path.split(":").map{|p|"file:%s" % File.expand_path(p) }.join(":"),
+                 arg_processor.real_bootclasspath.map{|u| u.to_s }.join(":")
   end
 
   def test_dash_h_prints_help_and_exits
-    state = Mirah::Util::CompilationState.new
-    processor = Mirah::Util::ArgumentProcessor.new state, ["-h"]
+    arg_processor = MirahArguments.new
 
-    assert_output processor.help_message + "\n" do
-      processor.process
+    usage_message = capture_output do
+      arg_processor.apply_args  ["-h"]
     end
 
-    assert processor.exit?
-    assert_equal 0, processor.exit_status_code
+    assert usage_message.include? 'mirahc [flags] <files or -e SCRIPT>'
+    assert usage_message.include? '-h, --help'
+
+    assert arg_processor.exit?
+    assert_equal 0, arg_processor.exit_status
   end
 end

data/test/core/util/class_loader_test.rb

@@ -15,20 +15,23 @@
 require 'test_helper'
 
 class ClassLoaderTest < Test::Unit::TestCase
+  java_import 'org.mirah.MirahClassLoader'
+  java_import 'org.mirah.IsolatedResourceLoader'
+
   FIXTURES = File.expand_path("#{__FILE__}/../../../fixtures/") +"/"
   A_CLASS = "#{FIXTURES}org/foo/A.class"
 
   def test_mirah_class_loader_find_class_in_map_successful
     class_map = {
-      'org.foo.A' => Mirah::Util::ClassLoader.binary_string(File.open(A_CLASS, 'rb') {|f| f.read })
+      'org.foo.A' => Mirah::Util.binary_string(File.open(A_CLASS, 'rb') {|f| f.read })
     }
-    class_loader = Mirah::Util::ClassLoader.new nil, class_map
+    class_loader = MirahClassLoader.new nil, class_map
     cls = class_loader.load_class 'org.foo.A'
     assert_equal 'org.foo.A', cls.name
   end
 
   def test_mirah_class_loader_w_missing_class_raises_class_not_found
-    class_loader = Mirah::Util::ClassLoader.new nil, {}
+    class_loader = MirahClassLoader.new nil, {}
 
     begin
       klass = class_loader.find_class 'org.doesnt.exist.Class'
@@ -39,7 +42,7 @@ class ClassLoaderTest < Test::Unit::TestCase
   end
 
   def test_isolated_resource_loader_only_finds_resources_given_to_it
-    loader = Mirah::Util::IsolatedResourceLoader.new [java.net.URL.new("file:#{FIXTURES}")]
+    loader = IsolatedResourceLoader.new [java.net.URL.new("file:#{FIXTURES}")]
     url = loader.get_resource "my.properties"
     assert_not_nil url
   end

data/test/core/util/{compilation_state_test.rb → jvm_version_test.rb}

@@ -1,4 +1,4 @@
-# Copyright (c) 2013 The Mirah project authors. All Rights Reserved.
+# Copyright (c) 2014 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,25 +14,29 @@
 # limitations under the License.
 require 'test_helper'
 
-class CampilationStateTest < Test::Unit::TestCase
-  include Mirah::Util
+
+
+class JvmVersionTest < Test::Unit::TestCase
+  java_import 'org.mirah.jvm.compiler.JvmVersion'
+  java_import 'org.objectweb.asm.Opcodes'
+
   def test_defaults_to_current_java
-    state = CompilationState.new
+    jvm_version = JvmVersion.new
     spec_version = ENV_JAVA['java.specification.version']
-    assert_equal spec_version, state.target_jvm_version
-    assert_equal bitescript_const(spec_version), state.bytecode_version
+    assert_equal spec_version, jvm_version.version_string
+    assert_equal opcode(spec_version), jvm_version.bytecode_version
   end
-
-  %w[1.4 1.5 1.6 1.7 1.8].each do |version|
+  
+  supported_versions = %w[1.4 1.5 1.6 1.7 1.8]
+  supported_versions.each do |version|
     define_method  "test_setting_version_to_#{version.tr '.', '_'}" do
-      state = CompilationState.new
-      state.set_jvm_version version
-      assert_equal version, state.target_jvm_version
-      assert_equal bitescript_const(version), state.bytecode_version
-    end
+			jvm_version = JvmVersion.new version
+			assert_equal version, jvm_version.version_string
+			assert_equal opcode(version), jvm_version.bytecode_version
+		end
   end
 
-  def bitescript_const version
-    BiteScript.const_get("JAVA#{version.gsub('.', '_')}")
+  def opcode spec_version
+    Opcodes.const_get("V#{spec_version.sub('.','_')}")
   end
-end
+end

data/test/fixtures/org/foo/ImplicitClassRetAnno.java

@@ -0,0 +1,4 @@
+package org.foo;
+
+public @interface ImplicitClassRetAnno {
+}

data/test/fixtures/org/foo/IntAnno.java

@@ -0,0 +1,9 @@
+package org.foo;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface IntAnno {
+  String name();
+  int value();
+}

data/test/jvm/annotations_test.rb

@@ -38,21 +38,21 @@ class AnnotationsTest < Test::Unit::TestCase
   end
 
   def test_annotation_with_an_integer
-    jruby_method = Java::OrgJrubyAnno::JRubyMethod.java_class
-
     cls, = compile(<<-EOF)
-      import org.jruby.*
-      import org.jruby.anno.*
-      import org.jruby.runtime.*
-      import org.jruby.runtime.builtin.*
-
-      $JRubyMethod["name" => ["bar"], "optional" => 1]
-      def bar(baz:int)
+      import org.foo.IntAnno
+      class IntValAnnotation
+        $IntAnno[name: "bar", value: 1]
+        def bar
+        end
       end
+      method = IntValAnnotation.class.getMethod("bar")
+      anno = method.getAnnotation(IntAnno.class)
+      puts anno.value
     EOF
-    method_annotation = cls.java_class.java_method('bar', :int).annotation(jruby_method)
 
-    assert_equal 1, method_annotation.optional
+    assert_output "1\n" do
+      cls.main nil
+    end
   end
 
 end

data/test/jvm/blocks_test.rb

@@ -61,13 +61,13 @@ class BlocksTest < Test::Unit::TestCase
   def test_simple_block
     cls, = compile(<<-EOF)
       thread = Thread.new do
-        System.out.println "Hello"
+        puts "Hello"
       end
       begin
         thread.run
         thread.join
       rescue
-        System.out.println "Uh Oh!"
+        puts "Uh Oh!"
       end
     EOF
     assert_output("Hello\n") do
@@ -85,7 +85,7 @@ class BlocksTest < Test::Unit::TestCase
       end
 
       o = MyObservable.new
-      o.addObserver {|x, a| System.out.println a}
+      o.addObserver {|x, a| puts a}
       o.notifyObservers("Hello Observer")
     EOF
     assert_output("Hello Observer\n") do
@@ -98,14 +98,14 @@ class BlocksTest < Test::Unit::TestCase
       def foo
         a = "Hello"
         thread = Thread.new do
-          System.out.println a
+          puts a
         end
         begin
           a = a + " Closures"
           thread.run
           thread.join
         rescue
-          System.out.println "Uh Oh!"
+          puts "Uh Oh!"
         end
         return
       end
@@ -156,7 +156,7 @@ class BlocksTest < Test::Unit::TestCase
           String(a).compareToIgnoreCase(String(b))
         end
       end
-      list.each {|x| System.out.println x}
+      list.each {|x| puts x }
     EOF
 
     assert_output("a\nABC\nb\nCats\n") do
@@ -186,14 +186,14 @@ class BlocksTest < Test::Unit::TestCase
       import java.util.concurrent.Callable
       def foo c:Callable
         # throws Exception
-         System.out.println c.call
+         puts c.call
       end
       begin
       foo do
         "an object"
       end
       rescue
-        System.out.println "never get here"
+        puts "never get here"
       end
     EOF
     assert_output("an object\n") do
@@ -205,13 +205,13 @@ class BlocksTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       def foo(x:String):void
         thread = Thread.new do
-          System.out.println "Hello \#{x}"
+          puts "Hello \#{x}"
         end
         begin
           thread.run
           thread.join
         rescue
-          System.out.println "Uh Oh!"
+          puts "Uh Oh!"
         end
       end
 
@@ -231,7 +231,7 @@ class BlocksTest < Test::Unit::TestCase
         b.call
       end
       def bar
-        foo {System.out.println "Hi"}
+        foo {puts "Hi"}
       end
     EOF
     assert_output("Hi\n") do
@@ -251,7 +251,7 @@ class BlocksTest < Test::Unit::TestCase
   end
 
   def test_block_impling_interface_w_multiple_methods
-    assert_jraise java.lang.UnsupportedOperationException do
+   begin
       parse_and_type(<<-CODE)
         interface RunOrRun2 do
           def run:void;end
@@ -267,6 +267,10 @@ class BlocksTest < Test::Unit::TestCase
           1
         end
         CODE
+    rescue => ex
+      assert_match /multiple abstract/i, ex.message 
+    else
+      fail "No exception raised"
     end
   end
 

data/test/jvm/constructors_test.rb

@@ -16,7 +16,7 @@
 class ConstructorsTest < Test::Unit::TestCase
   def test_constructor
     cls, = compile(
-        "class InitializeTest;def initialize;System.out.println 'Constructed';end;end")
+        "class InitializeTest;def initialize;puts 'Constructed';end;end")
     assert_output("Constructed\n") do
       cls.new
     end
@@ -57,14 +57,14 @@ class ConstructorsTest < Test::Unit::TestCase
     sc_a, sc_b = compile(<<-EOF)
       class SC_A
         def initialize(a:int)
-          System.out.println "A"
+          puts "A"
         end
       end
 
       class SC_B < SC_A
         def initialize
           super(0)
-          System.out.println "B"
+          puts "B"
         end
       end
     EOF
@@ -77,14 +77,14 @@ class ConstructorsTest < Test::Unit::TestCase
     sc_a, sc_b = compile(<<-EOF)
       class SuperCA
         def initialize(a: int)
-          System.out.println "A \#{a}"
+          puts "A \#{a}"
         end
       end
 
       class SuperCB < SuperCA
         def initialize a: int
           super
-          System.out.println "B \#{a}"
+          puts "B \#{a}"
         end
       end
     EOF
@@ -105,7 +105,7 @@ class ConstructorsTest < Test::Unit::TestCase
         end
       EOF
     end
-    assert_equal "Cannot find instance method initialize() on SuperCA", error.message
+    assert_match /Can.*t find.* method (SuperCA\.)?initialize\(\)/, error.message
   end
 
 
@@ -118,7 +118,7 @@ class ConstructorsTest < Test::Unit::TestCase
         end
       EOF
     end
-    assert_equal "Cannot find instance method initialize(java.lang.String) on java.util.ArrayList", error.message
+    assert_match /Can.*t find( instance)? method (java.util.ArrayList\.)?initialize\(java.lang.String\)/, error.message
   end
 
   def test_empty_constructor
@@ -141,7 +141,7 @@ class ConstructorsTest < Test::Unit::TestCase
             t.join
           rescue InterruptedException
           end
-          System.out.println 'ok'
+          puts 'ok'
         end
       end
     EOF

data/test/jvm/enumerable_test.rb

@@ -13,6 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'test_helper'
+
 class EnumerableTest < Test::Unit::TestCase
   def test_for_in_int_array
     cls, = compile(<<-EOF)
@@ -44,7 +46,7 @@ class EnumerableTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       def foo(a:Iterable)
         a.each do |x|
-          System.out.println x
+          puts x
         end
       end
     EOF
@@ -63,7 +65,7 @@ class EnumerableTest < Test::Unit::TestCase
       import java.util.ArrayList
       def foo(a:ArrayList)
         a.each do |x|
-          System.out.println x
+          puts x
         end
       end
     EOF
@@ -80,7 +82,7 @@ class EnumerableTest < Test::Unit::TestCase
   def test_each_int_arry
     cls, = compile(<<-EOF)
       def foo(a:int[])
-        a.each {|x| x += 1;System.out.println x; redo if x == 2}
+        a.each {|x| x += 1;puts x; redo if x == 2}
       end
     EOF
 
@@ -114,7 +116,7 @@ class EnumerableTest < Test::Unit::TestCase
   def test_downto
     cls, = compile(<<-EOF)
       def foo(i:int)
-        i.downto(1) {|x| System.out.println x }
+        i.downto(1) {|x| puts x }
       end
     EOF
 
@@ -126,7 +128,7 @@ class EnumerableTest < Test::Unit::TestCase
   def test_upto
     cls, = compile(<<-EOF)
       def foo(i:int)
-        i.upto(3) {|x| System.out.println x }
+        i.upto(3) {|x| puts x }
       end
     EOF
 
@@ -138,7 +140,7 @@ class EnumerableTest < Test::Unit::TestCase
   def test_times_with_arg
     cls, = compile(<<-EOF)
       def foo(i:int)
-        i.times {|x| System.out.println x }
+        i.times {|x| puts x }
       end
     EOF
 
@@ -150,7 +152,7 @@ class EnumerableTest < Test::Unit::TestCase
   def test_times_without_arg
     cls, = compile(<<-EOF)
       def foo(i:int)
-        i.times { System.out.println "Hi" }
+        i.times { puts "Hi" }
       end
     EOF
 
@@ -248,7 +250,7 @@ class EnumerableTest < Test::Unit::TestCase
   def test_each
     cls, = compile(<<-EOF)
       def foo
-        [1,2,3].each {|x| System.out.println x}
+        [1,2,3].each {|x| puts x}
       end
     EOF
     assert_output("1\n2\n3\n") do
@@ -259,7 +261,7 @@ class EnumerableTest < Test::Unit::TestCase
   def test_each_without_block_arguments
     cls, = compile(<<-EOF)
       def foo
-        [1,2,3].each { System.out.println :thrice }
+        [1,2,3].each { puts :thrice }
       end
     EOF
     assert_output("thrice\nthrice\nthrice\n") do
@@ -271,8 +273,8 @@ class EnumerableTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       import java.lang.Integer
       def foo
-        System.out.println [1,2,3].any?
-        System.out.println [1,2,3].any? {|x| Integer(x).intValue > 3}
+        puts [1,2,3].any?
+        puts [1,2,3].any? {|x| Integer(x).intValue > 3}
       end
     EOF
     assert_output("true\nfalse\n") do
@@ -284,8 +286,8 @@ class EnumerableTest < Test::Unit::TestCase
     cls, = compile(<<-EOF)
       import java.lang.Integer
       def foo
-        System.out.println [1,2,3].all?
-        System.out.println [1,2,3].all? {|x| Integer(x).intValue > 3}
+        puts [1,2,3].all?
+        puts [1,2,3].all? {|x| Integer(x).intValue > 3}
       end
     EOF
     assert_output("true\nfalse\n") do
@@ -295,7 +297,7 @@ class EnumerableTest < Test::Unit::TestCase
   def test_all_with_block_with_no_cast
     cls, = compile(<<-EOF)
       def foo
-        System.out.println [1,2,3].all? {|x| x.intValue > 3}
+        puts [1,2,3].all? {|x| x.intValue > 3}
       end
     EOF
     assert_output("false\n") do
@@ -303,17 +305,39 @@ class EnumerableTest < Test::Unit::TestCase
     end
   end
 
-  def test_map
+  def test_map_empty_literal
     cls, = compile(<<-EOF)
-      def foo
-        System.out.println [1,2,3].map {|x:Integer| x.intValue + 1}
-        System.out.println [1,2,3].map {|x| x}
-        System.out.println [1].map { 'a' }
-        System.out.println [].map { 'b' }
-      end
+       puts [].map { 'b' }
     EOF
-    assert_output("[2, 3, 4]\n[1, 2, 3]\n[a]\n[]\n") do
-      cls.foo
+    assert_output "[]\n" do
+      cls.main(nil)
+    end
+  end
+
+  def test_map_to_different_type
+    cls, = compile(<<-EOF)
+      puts [1].map { 'a' }
+    EOF
+    assert_output "[a]\n" do
+      cls.main(nil)
+    end
+  end
+
+def test_map_identity
+    cls, = compile(<<-EOF)
+      puts [1,2,3].map {|x| x}
+    EOF
+    assert_output("[1, 2, 3]\n") do
+      cls.main(nil)
+    end
+  end
+
+  def test_map_with_type_declaration
+    cls, = compile(<<-EOF)
+      puts [1,2,3].map {|x:Integer| x.intValue + 1}
+    EOF
+    assert_output("[2, 3, 4]\n") do
+      cls.main(nil)
     end
   end
 
@@ -454,7 +478,7 @@ class EnumerableTest < Test::Unit::TestCase
         end
 
         def self.test(x:String)
-          MyIterator.new(x).each {|y| System.out.println y}
+          MyIterator.new(x).each {|y| puts y}
         end
       end
     EOF