mirah 0.1.4-java → 0.2.0-java

data/test/jvm/{string_extensions_test.rb → extensions/string_extensions_test.rb}

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+#
 # Copyright (c) 2013 The Mirah project authors. All Rights Reserved.
 # All contributing project authors may be found in the NOTICE file.
 #
@@ -55,18 +57,69 @@ class StringExtensionsTest < Test::Unit::TestCase
   end
 
   def test_string_match
+    cls, = compile(%q{puts 'byeby'.match(/b(.*)y/)[1]})
+    assert_run_output("yeb\n", cls)
+  end
+
+  def test_string_matches
     cls, = compile("def match; 'abcdef' =~ /d/; end")
     assert cls.match, 'failed to match string'
   end
 
-  def test_string_dont_match
-    cls, = compile("def dont_match; 'abcdef' =~ /g/; end")
-    refute cls.dont_match, 'mistakenly matched string'
+  def test_string_doesnt_match
+    cls, = compile("def doesnt_match; 'abcdef' =~ /g/; end")
+    refute cls.doesnt_match, 'mistakenly matched string'
   end
 
-  def test_string_match_wrong_type
+  def test_string_matches_wrong_type
     assert_raises Mirah::MirahError do
       compile("def match_wrong_type; 'abcdef' =~ 'd'; end")
     end
   end
+  
+  def test_string_to_int_invalid_number
+    cls, = compile(<<-EOF)
+      puts 'abc'.to_int
+    EOF
+    assert_raise_java Java::JavaLang::NumberFormatException do
+      cls.main nil
+    end
+  end
+
+  def test_string_to_int_valid_number
+    cls, = compile(<<-EOF)
+      puts '-987654321'.to_int
+    EOF
+    assert_run_output("-987654321\n", cls)
+  end
+
+  def test_string_to_int_too_big_number
+    cls, = compile(<<-EOF)
+      puts '-9876543210'.to_int
+    EOF
+    assert_raise_java Java::JavaLang::NumberFormatException do
+      cls.main nil
+    end
+  end
+  
+  def test_string_each_codepoint_1_block_argument
+    cls, = compile(%q{
+      "abc\u1234\U0010FFFF\u5678de𠀘f".each_codepoint do |codepoint|
+        puts codepoint
+      end
+    })
+    assert_run_output("97\n98\n99\n4660\n1114111\n22136\n100\n101\n131096\n102\n", cls)
+  end
+  
+  def test_string_each_codepoint_0_block_arguments
+    cls, = compile(%q{
+      count = 0
+      "abc\u1234\U0010FFFF\u5678de𠀘f".each_codepoint do
+        count+=1
+      end
+      puts count
+    })
+    assert_run_output("10\n", cls)
+  end
 end
+

data/test/jvm/generics_test.rb

@@ -27,9 +27,7 @@ class GenericsTest < Test::Unit::TestCase
       puts(foo.get(1).substring(2))
     EOF
 
-    assert_output("cond string\n") do
-      cls.main(nil)
-    end
+    assert_run_output("cond string\n", cls)
   end
 
   def test_generics_generic_payload
@@ -44,10 +42,20 @@ class GenericsTest < Test::Unit::TestCase
       puts(bar.get(0).get(1).substring(2))
     EOF
 
-    assert_output("cond string\n") do
-      cls.main(nil)
-    end
+    assert_run_output("cond string\n", cls)
   end
 
+  def test_generics_recursion
+    omit_if JVMCompiler::JVM_VERSION.to_f < 1.8
+
+    # Class signature for java.util.stream.Stream is recursive
+    #<T:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/stream/BaseStream<TT;Ljava/util/stream/Stream<TT;>;>;
+    cls, = compile(<<-EOF)
+      [10,5,8].stream.sorted.forEach { |i| puts i}
+    EOF
+    assert_run_output("5\n8\n10\n", cls)
+  end
+
+
 end
 

data/test/jvm/import_test.rb

@@ -64,6 +64,21 @@ class ImportTest < Test::Unit::TestCase
     assert_equal(["1", "2", "3"], list.to_a)
   end
 
+  def test_static_import_constants
+    cls, = compile(<<-EOF)
+      import java.awt.Color
+      import static java.awt.Color.*
+      def _red:Color
+        red
+      end
+      def _RED:Color
+        RED
+      end
+      puts _RED === _red
+    EOF
+    assert_run_output("true\n", cls)
+  end
+
   def test_static_import_nested_in_class
     cls, = compile(<<-EOF)
       import java.util.Arrays
@@ -92,7 +107,29 @@ class ImportTest < Test::Unit::TestCase
         end
       end
     EOF
-    assert_output("hi\n") { cls.main(nil) }
+    assert_run_output("hi\n", cls)
+  end
+
+  def test_static_import_in_closure
+    cls, = compile(%q[
+      class StaticImportInClosure
+        def baz
+          b = 3
+          perform do
+            import static java.lang.Math.*
+            b = max(-9,-8)
+          end
+          b
+        end
+        
+        def perform(runnable:Runnable)
+          runnable.run
+        end
+      end
+      
+      puts StaticImportInClosure.new.baz
+    ])
+    assert_run_output("-8\n", cls)
   end
 
 end

data/test/jvm/interface_test.rb

@@ -109,4 +109,21 @@ class InterfaceTest < Test::Unit::TestCase
       end
     EOF
   end
+
+  def test_interface_with_default_method_compiles_on_java_8
+    omit_if JVMCompiler::JVM_VERSION.to_f < 1.8
+
+    cls, = compile(<<-'EOF', java_version: '1.8')
+      interface DefaultMe
+        def act(messages:String):void
+          puts "#{messages} all the things!"
+        end
+      end
+
+      class WithDefault implements DefaultMe
+      end
+      WithDefault.new.act("default")
+    EOF
+    assert_run_output "default all the things!\n", cls
+  end
 end

data/test/jvm/jvm_commands_test.rb

@@ -49,4 +49,13 @@ class JVMCommandsTest < Test::Unit::TestCase
                               )
     end
   end
+
+  def test_encoding
+    assert_output "default utf8 encoding test\n" do
+      Mirah.run(File.dirname(__FILE__)+"/../fixtures/utf8_test.mirah")
+    end
+    assert_output "cp1251 encoding test\n" do
+      Mirah.run('-encoding','cp1251',File.dirname(__FILE__)+"/../fixtures/cp1251_test.mirah")
+    end
+  end
 end

data/test/jvm/jvm_compiler_test.rb

@@ -271,12 +271,68 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_class_name_from_file_with_underscore
     foo, = compile("puts 'blah'", :name => 'class_name_test.mirah')
-    assert_equal('ClassNameTest', foo.java_class.name)
+    assert_equal('ClassNameTestTopLevel', foo.java_class.name)
   end
 
   def test_class_name_from_file_with_dash
     foo, = compile("puts 'blah'", :name => 'class-dash-test.mirah')
-    assert_equal('ClassDashTest', foo.java_class.name)
+    assert_equal('ClassDashTestTopLevel', foo.java_class.name)
+  end
+
+  def test_class_name_from_file_used_within_source_match
+    cls, = compile(%q{
+
+      package array_subclass_test
+      
+      class Subclass < Superclass2
+        def self.run
+          ArraySubclassTest.new.baz
+        end
+      end
+      
+      class ArraySubclassTest
+      
+        def baz()
+          bar(Subclass[3])
+        end
+      
+        def bar(foo:Superclass2[])
+          "Success"
+        end
+      end
+      
+      class Superclass2
+      end
+    }, :name => 'Superclass2.mirah')
+    assert_equal('Success', cls.run)
+  end
+
+  def test_class_name_from_file_used_within_source_mismatch
+    cls, = compile(%q{
+
+      package array_subclass_test
+      
+      class Subclass < Superclass2
+        def self.run
+          ArraySubclassTest.new.baz
+        end
+      end
+      
+      class ArraySubclassTest
+      
+        def baz()
+          bar(Subclass[3])
+        end
+      
+        def bar(foo:Superclass2[])
+          "Success"
+        end
+      end
+      
+      class Superclass2
+      end
+    }, :name => 'Superclass3.mirah')
+    assert_equal('Success', cls.run)
   end
 
   def test_puts
@@ -287,6 +343,35 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_equal("Hello World!\n", output)
   end
 
+  def test_puts_classmethod_no_args
+    cls, = compile(%q{
+      def foo
+        puts
+        puts
+      end
+    })
+    output = capture_output do
+      cls.foo
+    end
+    assert_equal("\n\n", output)
+  end
+
+  def test_puts_instancemethod_no_args
+    cls, = compile(%q{
+      class Foo
+        def foo
+          puts
+          puts
+          puts
+        end
+      end
+    })
+    output = capture_output do
+      cls.new.foo
+    end
+    assert_equal("\n\n\n", output)
+  end
+
   def test_print
     cls, = compile("def foo;print 'Hello World!';end")
     output = capture_output do
@@ -766,7 +851,7 @@ class JVMCompilerTest < Test::Unit::TestCase
         end
         to_#{primitive} #{primitive}(1)
         EOF
-        assert_output("1\n") { cls.main nil}
+        assert_run_output("1\n", cls)
       rescue => e
         raise "#{primitive} #{e.message}"
       end
@@ -779,7 +864,7 @@ class JVMCompilerTest < Test::Unit::TestCase
         end
         to_#{type} #{type}(1)
         EOF
-      assert_output("1.0\n") { cls.main nil}
+      assert_run_output("1.0\n", cls)
       rescue => e
         raise "#{type} #{e.message}"
       end
@@ -791,7 +876,22 @@ class JVMCompilerTest < Test::Unit::TestCase
       end
       to_character char(65)
     EOF
-    assert_output("A\n") { cls.main nil}
+    assert_run_output("A\n", cls)
+  end
+
+  def test_return_boxing_and_unboxing
+    cls, = compile(<<-EOF)
+      def box:Boolean
+        return true
+      end
+
+      def unbox:boolean
+        return Boolean.new(false)
+      end
+
+    EOF
+    assert_equal(true, cls.box)
+    assert_equal(false, cls.unbox)
   end
 
   def test_raise
@@ -859,11 +959,42 @@ class JVMCompilerTest < Test::Unit::TestCase
     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))
+  
+  def test_promotion_to_boolean
+    cases = [
+      [ "String",  "a"  => true, nil   => false ],
+      [ "boolean", true => true, false => false ],
+      [ "byte",    1    => true, 0     => true  ],
+      [ "short",   1    => true, 0     => true  ],
+      [ "int",     1    => true, 0     => true  ],
+      [ "long",    1    => true, 0     => true  ],
+      [ "char",    1    => true, 0     => true  ],
+      [ "float",   1.0  => true, 0.0   => true  ],
+      [ "double",  1.0  => true, 0.0   => true  ],
+    ].each do |type, cases|
+      cls, = compile(%Q[
+        class Foo
+          def self.foo(a:#{type})
+            if a
+              true
+            else
+              false
+            end
+          end
+          def self.foo_inverted(a:#{type})
+            unless a
+              true
+            else
+              false
+            end
+          end
+        end
+      ])
+      cases.each do |input,boolean_value|
+        assert_equal( boolean_value, cls.foo(input))
+        assert_equal(!boolean_value, cls.foo_inverted(input))
+      end
+    end
   end
 
   def test_if_expr
@@ -1238,9 +1369,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       puts B1.new.foo("There")
     EOF
 
-    assert_output("Hi\nThere\n") do
-      cls.main(nil)
-    end
+    assert_run_output("Hi\nThere\n", cls)
   end
 
   def test_super
@@ -1279,18 +1408,14 @@ class JVMCompilerTest < Test::Unit::TestCase
       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
+    assert_run_output("0\n1\n2\n0\n0\n2\n0\n0\n0\n", cls)
   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
+    assert_run_output("java.io.PrintStream\n", cls)
   end
 
   def test_array_arguments
@@ -1341,9 +1466,7 @@ class JVMCompilerTest < Test::Unit::TestCase
     cls, = compile <<-CODE
       print "apples \#{'oranges'}".replace('apples', 'oranges')
     CODE
-    assert_output "oranges oranges" do
-      cls.main nil
-    end
+    assert_run_output("oranges oranges", cls)
   end
 
   def test_self_dot_static_methods
@@ -1440,9 +1563,7 @@ class JVMCompilerTest < Test::Unit::TestCase
 #    EOF
 #    raise
 #    cls.main([].to_java :string)
-#    assert_output("3.0\n") do
-#      cls.main([].to_java :string)
-#    end
+#    assert_run_output("3.0\n", cls)
 #  end
 
   def test_class_append_self
@@ -1485,6 +1606,19 @@ class JVMCompilerTest < Test::Unit::TestCase
     end
   end
 
+  def test_native
+    cls, = compile(<<-EOF)
+      class Foo
+        native def foo; end
+      end
+    EOF
+
+    assert_raise_java java.lang.UnsatisfiedLinkError do
+      a = cls.new
+      a.foo
+    end
+  end
+
   def test_abstract
     abstract_class, concrete_class = compile(<<-EOF)
       abstract class Abstract
@@ -1506,6 +1640,54 @@ class JVMCompilerTest < Test::Unit::TestCase
     end
   end
 
+  def test_synchronized
+    cls, = compile(<<-EOF)
+      class Synchronized
+        attr_accessor locked:boolean
+        
+        synchronized def lock_and_unlock:void
+          puts "Locking."
+          Thread.sleep(100)
+          self.locked = true
+          puts "Waiting."
+          self.wait
+          puts "Unlocking."
+          self.locked = false
+        end
+        
+        synchronized def locked?
+          self.locked
+        end
+        
+        synchronized def notify_synchronized:void
+          puts "Notifying."
+          self.notify
+          puts "Notified."
+        end
+        
+        def trigger:void
+          while ! locked?
+            Thread.sleep(10)
+          end
+          self.notify_synchronized
+        end
+        
+        def start_trigger
+          s = self
+          Thread.new do
+            s.trigger
+          end.start
+        end
+      end
+    EOF
+
+    assert_output("Locking.\nWaiting.\nNotifying.\nNotified.\nUnlocking.\n") do
+      a = cls.new
+      a.start_trigger
+      a.lock_and_unlock
+    end
+  end
+
   def test_return_void
     script, = compile(<<-EOF)
       def foo:void
@@ -1629,9 +1811,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       puts java::util::Arrays.toString(String[5])
     EOF
 
-    assert_output("[null, null, null, null, null]\n") do
-      cls.main(nil)
-    end
+    assert_run_output("[null, null, null, null, null]\n", cls)
   end
 
   def test_getClass_on_object_array
@@ -1639,9 +1819,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       puts Object[0].getClass.getName
     EOF
 
-    assert_output("[Ljava.lang.Object;\n") do
-      cls.main(nil)
-    end
+    assert_run_output("[Ljava.lang.Object;\n", cls)
   end
 
   def test_nil_assign
@@ -1660,9 +1838,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       puts Object(a)
     EOF
 
-    assert_output("null\n") do
-      cls.main(nil)
-    end
+    assert_run_output("null\n", cls)
   end
 
   def test_long_generation
@@ -1672,6 +1848,41 @@ class JVMCompilerTest < Test::Unit::TestCase
     EOF
   end
 
+
+  def test_inconvertible_classes_cause_cast_error
+    pend "waiting on better error picking" do
+      ex = assert_raise Mirah::MirahError  do
+        compile(<<-EOF)
+        class A;end
+        class B;end
+        def f(a:A): B
+          B(a)
+        end
+        EOF
+      end
+      assert_equal("Cannot cast A to B.", ex.message)
+    end
+  end
+
+  def test_inconvertible_default_classes_cause_cast_error
+    pend "waiting on better error picking" do
+      ex = assert_raise Mirah::MirahError  do
+        compile(<<-EOF)
+        import java.lang.Integer
+        java.lang.Integer("a string")
+        EOF
+      end
+      assert_equal("Cannot cast java.lang.Integer to java.lang.String.", ex.message)
+    end
+  end
+
+  def test_casting_up_should_work
+    cls, = compile(<<-EOF)
+    puts Object("a string")
+    EOF
+    assert_run_output("a string\n", cls)
+  end
+
   def test_missing_class_with_block_raises_inference_error
     # TODO(ribrdb): What is this test for?
     ex = assert_raise Mirah::MirahError  do
@@ -1682,15 +1893,165 @@ class JVMCompilerTest < Test::Unit::TestCase
 
   def test_bool_equality
     cls, = compile("puts true == false")
-    assert_output("false\n") do
-      cls.main(nil)
-    end
+    assert_run_output("false\n", cls)
   end
 
   def test_bool_inequality
     cls, = compile("puts true != false")
-    assert_output("true\n") do
-      cls.main(nil)
+    assert_run_output("true\n", cls)
+  end
+
+  def test_double_equals_calls_equals_when_first_arg_not_nil
+    cls, = compile(<<-EOF)
+      class DoubleEqualsCalling
+        def equals(other)
+          puts "called"
+          true
+        end
+      end
+      DoubleEqualsCalling.new == nil
+    EOF
+    assert_run_output("called\n", cls)
+  end
+
+  def test_double_equals_does_not_call_equals_when_first_arg_nil
+    cls, = compile(<<-EOF)
+      class DoubleEqualsCalling2
+        def equals(other)
+          puts "called"
+          true
+        end
+      end
+      nil == DoubleEqualsCalling2.new
+    EOF
+    assert_run_output("", cls)
+  end
+
+  def test_double_equals_nil_literal_equals_nil_literal
+    cls, = compile(<<-EOF)
+      puts nil == nil
+    EOF
+    assert_run_output("true\n", cls)
+  end
+
+  def test_double_equals_nil_ref_equals_nil_literal
+    cls, = compile(<<-EOF)
+      a = nil
+      puts a == nil
+    EOF
+    assert_run_output("true\n", cls)
+  end
+
+  def test_double_equals_cast_nil_ref_equals_nil_literal
+    cls, = compile(<<-EOF)
+      a = Object(nil)
+      puts a == nil
+    EOF
+    assert_run_output("true\n", cls)
+  end
+
+  def test_double_equals_compare_to_self_in_a_equals_method_def_has_warning
+    cls = nil
+    output = capture_output do
+      cls, = compile(<<-EOF)
+        class DoubleEqualsSelf
+          def equals(other)
+            other == self
+          end
+        end
+        puts DoubleEqualsSelf.new == nil
+      EOF
+    end
+    assert_include(
+      "WARNING: == is now an alias for Object#equals(), === is now used for identity.\n" +
+      "This use of == with self in equals() definition may cause a stack overflow in next release!",
+      output)
+    assert_run_output("false\n", cls)
+  end
+
+  def test_double_equals_compare_to_self_in_a_equals_method_def_warning_includes_source
+    cls = nil
+    output = capture_output do
+      cls, = compile(<<-EOF)
+        class DoubleEqualsSelf
+          def equals(other)
+            other == self
+          end
+        end
+        puts DoubleEqualsSelf.new == nil
+      EOF
+    end
+    assert_include(
+"          def equals(other)
+            other == self
+          end", output)
+    assert_run_output("false\n", cls)
+  end
+
+  def test_double_equals_self_compare_to_other_in_a_equals_method_def_has_warning
+    cls = nil
+    output = capture_output do
+      cls, = compile(<<-EOF)
+        class SelfDoubleEqualsOther
+          def equals(other)
+            self == other
+          end
+        end
+        puts SelfDoubleEqualsOther.new == nil
+      EOF
+    end
+    assert_include(
+      "WARNING: == is now an alias for Object#equals(), === is now used for identity.\n" +
+      "This use of == with self in equals() definition may cause a stack overflow in next release!",
+      output)
+    assert_run_output("false\n", cls)
+  end
+
+  def test_triple_equals_with_ints
+    cls, = compile(<<-EOF)
+      puts 1 === 1
+      puts 1 === 2
+      puts 1 !== 2
+      puts 1 !== 1
+    EOF
+    assert_run_output("true\nfalse\ntrue\nfalse\n", cls)
+  end
+
+  def test_triple_equals_with_objects
+    cls, = compile(<<-EOF)
+      a = Object.new
+      b = Object.new
+      puts a === a
+      puts a === b
+      puts a !== b
+      puts a !== a
+    EOF
+    assert_run_output("true\nfalse\ntrue\nfalse\n", cls)
+  end
+
+  def test_triple_equals_with_arrays
+    cls, = compile(<<-EOF)
+      a = Object[1]
+      b = Object[1]
+      puts a === a
+      puts a === b
+      puts a !== b
+      puts a !== a
+    EOF
+    assert_run_output("true\nfalse\ntrue\nfalse\n", cls)
+  end
+
+  def test_double_equals_with_arrays
+    pend "arrays are tricky" do
+      cls, = compile(<<-EOF)
+        a = Object[1]
+        b = Object[1]
+        puts a == a
+        puts a == b
+        puts a != b
+        puts a != a
+      EOF
+      assert_run_output("true\true\nfalse\nfalse\n", cls)
     end
   end
 
@@ -1704,7 +2065,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       print "OK"
     EOF
     
-    assert_output("OK") { cls.main(nil) }
+    assert_run_output("OK", cls)
   end
 
   def test_assign_int_to_double
@@ -1792,9 +2153,7 @@ class JVMCompilerTest < Test::Unit::TestCase
       puts Child.my_method
     EOF
 
-    assert_output "ran my method\n" do
-      cls.main(nil)
-    end
+    assert_run_output("ran my method\n", cls)
   end
 
   def test_incompatible_meta_change
@@ -1831,6 +2190,44 @@ class JVMCompilerTest < Test::Unit::TestCase
     assert_output("0\n") { cls.foo(nil)}
     assert_output("2\n") { cls.foo(arg.new)}
   end
+  
+  def test_local_method_conflict2
+    cls, arg = compile(%q{
+      
+      class Foo1
+        
+        def equals(o:Foo1)
+          self===o
+        end
+      end
+      
+      class Bar
+        attr_reader   foo1:Foo1
+        attr_reader   foo2:Foo2
+        
+        def foo1method(foo1:Foo1)
+          puts (@foo1==foo1)
+          @foo1 = foo1
+        end
+        
+        def foo2method(foo2:Foo2)
+          puts (@foo2==foo2)
+          @foo2 = foo2
+        end
+      end
+      
+      class Foo2
+        
+        def equals(o:Foo2)
+          self===o
+        end
+      end
+      
+      Bar.new.foo1method(Foo1.new)
+      Bar.new.foo2method(Foo2.new)
+    })
+    assert_run_output("false\nfalse\n", cls)
+  end
 
   def test_incompatible_return_type_error_message
     e = assert_raise_kind_of Mirah::MirahError do
@@ -1843,4 +2240,132 @@ class JVMCompilerTest < Test::Unit::TestCase
     end
     assert_equal "Invalid return type double, expected int",e.message
   end
+
+  def test_inner_interface
+    cls, arg = compile(%q{
+      
+      class Foo1
+        
+        interface Bar
+          def baz:String; end
+        end
+        
+        class Foo2 implements Bar
+          def baz
+            "BAZ"
+          end
+        end
+      end
+      
+
+      puts Foo2.new.baz
+    })
+    assert_run_output("BAZ\n", cls)
+  end
+  
+  def test_line_number_increase_by_multiline_sstring_literal
+    e = assert_raise_kind_of Mirah::MirahError do
+      cls, arg = compile(%q{
+        class Foo
+          CONST = 'a
+        
+        
+        
+          b'
+        end
+        
+        
+        ERROR_SHOULD_BE_HERE
+      })
+    end
+    assert_equal 11,e.diagnostic.getLineNumber
+  end
+  
+  def test_line_number_increase_by_multiline_dstring_literal
+    e = assert_raise_kind_of Mirah::MirahError do
+      cls, arg = compile(%q{
+        class Foo
+          CONST = "a
+        
+        
+        
+          b"
+        end
+        
+        
+        ERROR_SHOULD_BE_HERE
+      })
+    end
+    assert_equal 11,e.diagnostic.getLineNumber
+  end
+
+  def test_late_superclass
+    cls, arg = compile(%q{
+      package subclass_test
+      
+      class TestSubclassAsMethodParameter
+        def bar(b:SuperClass)
+          "baz"
+        end
+      
+        def foo
+          a = SubClass.new
+          bar(a)
+        end 
+      end
+      
+      class SubClass < SuperClass
+      end
+      
+      class SuperClass
+      end
+      
+      puts TestSubclassAsMethodParameter.new.foo
+    })
+    assert_run_output("baz\n", cls)
+  end
+  
+  def test_late_superinterface
+    cls, arg = compile(%q{
+      package late_superinterface
+      
+      interface Interface2 < Interface1
+      end
+      
+      interface Interface3 < Interface2
+      end
+      
+      interface Interface1
+      end
+    })
+  end
+
+  def test_init_before_use_in_loop
+    cls, arg = compile(%q{
+      macro def loop_with_init(block:Block)
+        i = block.arguments.required(0).name.identifier
+        last = gensym
+        quote do
+          while `i` < `last`
+            init { `i` = 0; `last` = 4}
+            post { `i` = `i` + 1 }
+            `block.body`
+          end
+        end
+      end
+      loop_with_init do |i|
+        print i
+      end
+    })
+    assert_run_output("0123", cls)
+  end
+
+  def test_filename_shows_up_in_exception_upon_syntax_error
+    begin
+      foo, = compile("puts('foo',)", name: 'somespecificfilename.mirah')
+      assert false
+    rescue => e
+      assert e.message.match(/somespecificfilename/)
+    end
+  end
 end