rubybreaker 0.0.1

data/test/integrated/tc_method_missing.rb

@@ -0,0 +1,30 @@
+require "test/unit"
+require_relative "../../lib/rubybreaker"
+
+class IntegratedMethodMissingTest < Test::Unit::TestCase
+  include RubyBreaker
+  include RubyBreaker::TestCase
+
+  class A
+    include RubyBreaker::Breakable
+
+    def method_missing(mname, *args, &blk)
+      method_name = mname.to_s
+      return method_name + "_" + args.join("_") 
+    end
+
+  end
+
+  # TODO: This must be fixed once variable length argument type is supported
+  # in auto-documentation.
+  def test_a_foo
+    a = A.new
+    a.foo(1,2)
+    meth_type = Runtime::Inspector.inspect_meth(A, :method_missing)
+    str = RubyBreaker::TypeUnparser.unparse(meth_type)
+    # puts str
+    assert_equal("method_missing(symbol[to_s], fixnum[to_s], fixnum[to_s]) -> string", str, "A#foo failed.")
+  end
+  
+end
+

data/test/integrated/tc_simple1.rb

@@ -0,0 +1,77 @@
+require "test/unit"
+require_relative "../../lib/rubybreaker"
+
+class IntegratedSimpleTest < Test::Unit::TestCase
+  include RubyBreaker
+  include RubyBreaker::TestCase
+
+  class A
+    include RubyBreaker::Breakable
+
+    def foo(x)
+      x.to_s
+    end
+    
+    def bar(x,y)
+      x.to_s
+      x.size
+      y.size
+    end
+    
+    def baz(x,b)
+      if b
+        x.size
+      else
+        x.to_s
+      end
+    end
+
+    def bazz()
+      self
+    end
+
+  end
+
+  class B
+    include RubyBreaker::Broken
+    typesig("baz(string[size], true_class) -> fixnum")
+    typesig("baz(string[to_s], false_class) -> string")
+    def baz(x,b); end
+  end
+
+  def test_simple1_a_foo
+    a = A.new
+    a.foo("test_simple1 >> string")
+    meth_type = Runtime::Inspector.inspect_meth(A, :foo)
+    str = RubyBreaker::TypeUnparser.unparse(meth_type)
+    # puts str
+    assert_equal("foo(string[to_s]) -> string", str, "A#foo failed.")
+  end
+  
+  def test_simple1_a_bar
+    a = A.new
+    a.bar("str1","str2")
+    meth_type = Runtime::Inspector.inspect_meth(A, :bar)
+    str = RubyBreaker::TypeUnparser.unparse(meth_type)
+    # puts str
+    assert_equal("bar(string[size, to_s], string[size]) -> fixnum", str, 
+                  "A#bar failed.")   
+  end
+  
+  def test_simple1_a_baz
+    a = A.new
+    a.baz("str1",true)
+    a.baz("str2",false)
+    a_meth_type = Runtime::Inspector.inspect_meth(A, :baz)
+    b_meth_type = Runtime::Inspector.inspect_meth(B, :baz)
+    assert(RubyBreaker::Typing.subtype_rel?(a_meth_type, b_meth_type))
+    assert(RubyBreaker::Typing.subtype_rel?(b_meth_type, a_meth_type))
+  end
+
+  def test_simple1_a_bazz
+    a = A.new
+    a.bazz()
+    a_meth_type = Runtime::Inspector.inspect_meth(A, :bazz)
+    assert(a_meth_type.ret_type.eql?(SelfType.new()))
+  end
+end

data/test/runtime/tc_obj_wrapper.rb

@@ -0,0 +1,73 @@
+dir = File.dirname(__FILE__)
+require "test/unit"
+require "#{dir}/../../lib/rubybreaker/runtime"
+
+class ObjectWrapperTest < Test::Unit::TestCase
+  include RubyBreaker
+
+  def foo(x)
+    x.to_s
+    x.to_f
+  end
+
+  def bar(x)
+    x.to_s
+    x.to_s
+    x.to_f
+    x.to_s
+  end
+
+  def test_empty()
+    x = 42
+    wrapped_x = Runtime::ObjectWrapper.new(x)
+    type = wrapped_x.__rubybreaker_type()
+    str = TypeUnparser.unparse(type)
+    assert_equal("fixnum[]",str)
+  end
+
+  def test_simple_foo()
+    x = 42
+    wrapped_x = Runtime::ObjectWrapper.new(x)
+    Runtime::GLOBAL_MONITOR_SWITCH.turn_on()
+    foo(wrapped_x)
+    Runtime::GLOBAL_MONITOR_SWITCH.turn_off()
+    type = wrapped_x.__rubybreaker_type()
+    str = TypeUnparser.unparse(type)
+    assert_equal("fixnum[to_f, to_s]",str)
+  end
+
+  def test_simple_bar()
+    x = 42
+    wrapped_x = Runtime::ObjectWrapper.new(x)
+    Runtime::GLOBAL_MONITOR_SWITCH.turn_on()
+    bar(wrapped_x)
+    Runtime::GLOBAL_MONITOR_SWITCH.turn_off()
+    type = wrapped_x.__rubybreaker_type()
+    str = TypeUnparser.unparse(type)
+    assert_equal("fixnum[to_f, to_s]",str)
+  end
+
+  def test_object_id()
+    x = 42
+    wrapped_x = Runtime::ObjectWrapper.new(x)
+    bar(wrapped_x)
+    assert_equal(x.object_id, wrapped_x.object_id)
+  end
+
+  def test_equal()
+    x = 42
+    wrapped_x = Runtime::ObjectWrapper.new(x)
+    assert(wrapped_x == wrapped_x)
+    assert(wrapped_x.equal?(wrapped_x))
+    assert(wrapped_x.eql?(wrapped_x))
+    assert(42 == wrapped_x)
+    assert(wrapped_x == 42)
+    assert(42.equal?(wrapped_x))
+    assert(wrapped_x.equal?(42))
+    assert(42.eql?(wrapped_x))
+    assert(wrapped_x.eql?(42))
+    assert_equal(42, wrapped_x)
+    assert_equal(42, wrapped_x)
+  end
+
+end

data/test/runtime/tc_typesig_parser.rb

@@ -0,0 +1,33 @@
+# This test verifies type signature parser for RubyBreaker. 
+
+dir = File.dirname(__FILE__)
+
+require "test/unit"
+require "#{dir}/../../lib/rubybreaker/runtime"
+
+class TypeSigTest < Test::Unit::TestCase
+  include RubyBreaker
+  
+  class A
+    include RubyBreaker::Broken
+    typesig("foo(fixnum) -> fixnum")
+    typesig("bar(fixnum) -> self")
+  end
+
+  def test_typesig_a_foo
+    foo_type = Runtime::Inspector.inspect_meth(TypeSigTest::A,:foo)
+    foo_type_str = TypeUnparser.unparse(foo_type)
+    assert_equal("foo(fixnum) -> fixnum", foo_type_str,
+                 "foo(fixnum) -> fixnum failed")
+  end
+
+  def test_typesig_a_bar
+    bar_type = Runtime::Inspector.inspect_meth(TypeSigTest::A,:bar)
+    bar_type_str = TypeUnparser.unparse(bar_type)
+    assert_equal(A, bar_type.ret_type.mod)
+    assert_equal("bar(fixnum) -> self", bar_type_str,
+                 "bar(fixnum) -> self failed")
+  end
+
+
+end

data/test/ts_integrated.rb

@@ -0,0 +1,4 @@
+
+require "test/unit"
+require_relative "integrated/tc_method_missing"
+require_relative "integrated/tc_simple1"

data/test/ts_runtime.rb

@@ -0,0 +1,5 @@
+
+require "test/unit"
+require_relative "runtime/tc_obj_wrapper"
+require_relative "runtime/tc_typesig_parser"
+

data/test/ts_type.rb

@@ -0,0 +1,5 @@
+
+require "test/unit"
+require_relative "type/tc_comparer"
+require_relative "type/tc_parser"
+require_relative "type/tc_unparser"

data/test/ts_typing.rb

@@ -0,0 +1,4 @@
+
+require "test/unit"
+require_relative "typing/tc_rubytype"
+require_relative "typing/tc_typing"

data/test/type/tc_comparer.rb

@@ -0,0 +1,211 @@
+# This test verifies type signature parser for RubyBreaker. 
+
+dir = File.dirname(__FILE__)
+
+require "test/unit"
+require "#{dir}/../../lib/rubybreaker/type"
+
+class ComparerTest < Test::Unit::TestCase
+
+  include RubyBreaker
+
+  # This function is a helper to compose an error message for comparison
+  # test.
+  def msg(lhs,rhs,should_fail=false)
+    subtype = TypeUnparser.unparse(lhs)
+    supertype = TypeUnparser.unparse(rhs)
+    str = "#{subtype} = #{supertype}"
+    if should_fail
+      str = str + " did not fail"
+    else
+      str = str + " failed"
+    end
+    return str
+  end
+  
+  def test_nil_any
+    t1 = NilType.new()
+    t2 = AnyType.new()
+    t3 = NilType.new()
+    assert(!t1.eql?(t2), msg(t1,t2,true))
+    assert(!t2.eql?(t1), msg(t2,t1,true))
+    assert(t1.eql?(t3), msg(t1,t3))
+    assert(t3.eql?(t1), msg(t3,t1))
+  end
+
+  def test_nominal
+    t1 = NominalType.new(Fixnum)
+    t2 = NominalType.new(Numeric)
+    t3 = NominalType.new(String)
+    t4 = NominalType.new(String)
+    assert(!t1.eql?(t2), msg(t1, t2, true))
+    assert(!t1.eql?(t3), msg(t1, t3, true))
+    assert(!t2.eql?(t3), msg(t2, t3, true))
+    assert(t3.eql?(t4), msg(t3, t4))
+  end
+
+  def test_optional_varlength
+    t1 = NominalType.new(Fixnum)
+    t2 = NominalType.new(Numeric)
+    t3 = NominalType.new(String)
+    t4 = OptionalType.new(t1)
+    t5 = OptionalType.new(t1)
+    t6 = OptionalType.new(t2)
+    t7 = OptionalType.new(t3)
+    t8 = VarLengthType.new(t1)
+    t9 = VarLengthType.new(t1)
+    t10 = VarLengthType.new(t2)
+    t11 = VarLengthType.new(t3)
+    assert(t4.eql?(t5), msg(t4, t5))
+    assert(!t4.eql?(t6), msg(t4, t6, true))
+    assert(t8.eql?(t9), msg(t8, t9))
+    assert(!t8.eql?(t10), msg(t8, t10, true))
+    assert(!t7.eql?(t11), msg(t7, t11, true))
+  end
+
+	def test_self
+		t1 = SelfType.new()
+		t2 = SelfType.new()
+		t3 = NominalType.new(Fixnum)
+		assert(t1.eql?(t2), msg(t1, t2))
+		assert(!t1.eql?(t3), msg(t1, t3, true))
+	end
+
+  def test_duck
+    t1 = DuckType.new([:foo, :bar])
+    t2 = DuckType.new([:bar, :foo])
+    t3 = DuckType.new([:foo, :bar, :baz])
+    t4 = DuckType.new([:bar])
+    assert(t1.eql?(t2), msg(t1, t2))
+    assert(!t1.eql?(t3), msg(t1, t3, true))
+    assert(!t1.eql?(t4), msg(t1, t4, true))
+  end
+
+  def test_fusion
+    t1 = FusionType.new(NominalType.new(Fixnum), [:to_s, :to_f])
+    t2 = FusionType.new(NominalType.new(Fixnum), [:to_f, :to_s])
+		t3 = FusionType.new(NominalType.new(String), [:to_s, :to_f])
+		t4 = DuckType.new([:to_s, :to_f])
+		t5 = NominalType.new(Fixnum)
+		assert(t1.eql?(t2), msg(t1, t2))
+		assert(!t1.eql?(t3), msg(t1, t3, true))
+		assert(!t1.eql?(t4), msg(t1, t4, true))
+		assert(!t1.eql?(t5), msg(t1, t5, true))
+  end
+
+	def test_block_no_arg
+		t1 = NominalType.new(String)
+		t2 = NominalType.new(String)
+		t3 = NominalType.new(Fixnum)
+		t4 = BlockType.new([],nil,t1) 
+		t5 = BlockType.new([],nil,t2)
+		t6 = BlockType.new([],nil,t3)
+		assert(t4.eql?(t5), msg(t4, t5))
+		assert(!t4.eql?(t6), msg(t4, t6, true))
+	end
+  
+	def test_block_one_arg
+		t1 = NominalType.new(String)
+		t2 = NominalType.new(String)
+		t3 = NominalType.new(Fixnum)
+		t4 = BlockType.new([t1],nil,t3) 
+		t5 = BlockType.new([t2],nil,t3)
+		t6 = BlockType.new([],nil,t3)
+		assert(t4.eql?(t5), msg(t4, t5))
+		assert(!t4.eql?(t6), msg(t4, t6, true))
+	end
+
+	def test_block_more_args
+		t1 = NominalType.new(String)
+		t2 = NominalType.new(String)
+		t3 = NominalType.new(Fixnum)
+		t4 = OptionalType.new(NominalType.new(Object))
+		t5 = VarLengthType.new(NominalType.new(String))
+		t6 = NominalType.new(BasicObject)
+		t7 = BlockType.new([t1,t4,t5],nil,t3)
+    t8 = BlockType.new([t2,t4,t5],nil,t3)
+    t9 = BlockType.new([t1,t5,t4],nil,t3)
+    t10 = BlockType.new([t1,t4],nil,t3)
+    t11 = BlockType.new([],nil,t3)
+    t12 = BlockType.new([t1,t4,t5],BlockType.new([t1,t4,t5],nil,t3),t3)
+    assert(t7.eql?(t8), msg(t7, t8))
+    assert(!t7.eql?(t9), msg(t7, t9, true))
+    assert(!t7.eql?(t10), msg(t7, t10, true))
+    assert(!t7.eql?(t11), msg(t7, t11, true))
+    assert(!t7.eql?(t12), msg(t7, t12, true))
+	end
+
+	def test_method_no_arg
+		t1 = NominalType.new(String)
+		t2 = NominalType.new(String)
+		t3 = NominalType.new(Fixnum)
+		t4 = MethodType.new(:foo,[],nil,t1) 
+		t5 = MethodType.new(:foo,[],nil,t2)
+		t6 = MethodType.new(:bar,[],nil,t2)
+		t7 = MethodType.new(:foo,[],nil,t3)
+		assert(t4.eql?(t5), msg(t4, t5))
+		assert(!t4.eql?(t6), msg(t4, t6, true))
+		assert(!t4.eql?(t7), msg(t4, t7, true))
+	end
+  
+	def test_method_one_arg
+		t1 = NominalType.new(String)
+		t2 = NominalType.new(String)
+		t3 = NominalType.new(Fixnum)
+		t4 = MethodType.new(:foo, [t1],nil,t3) 
+		t5 = MethodType.new(:foo, [t2],nil,t3)
+		t6 = MethodType.new(:foo, [],nil,t3)
+		assert(t4.eql?(t5), msg(t4, t5))
+		assert(!t4.eql?(t6), msg(t4, t6, true))
+	end
+
+	def test_method_one_arg_with_blk
+		t1 = NominalType.new(String)
+		t2 = NominalType.new(String)
+		t3 = NominalType.new(Fixnum)
+		t4 = BlockType.new([t1],nil,t3) 
+		t5 = BlockType.new([t2],nil,t3)
+		t6 = BlockType.new([],nil,t3)
+    t7 = MethodType.new(:foo, [t1], t4, t3)
+    t8 = MethodType.new(:foo, [t2], t5, t3)
+    t9 = MethodType.new(:bar, [t1], t4, t3)
+    t10 = MethodType.new(:foo, [t1], t6, t3)
+		assert(t7.eql?(t8), msg(t7, t8))
+		assert(!t7.eql?(t9), msg(t7, t9, true))
+		assert(!t7.eql?(t10), msg(t7, t10, true))
+	end
+
+	def test_method_more_args
+		t1 = NominalType.new(String)
+		t2 = NominalType.new(String)
+		t3 = NominalType.new(Fixnum)
+		t4 = OptionalType.new(NominalType.new(Object))
+		t5 = VarLengthType.new(NominalType.new(String))
+		t6 = NominalType.new(BasicObject)
+		t7 = MethodType.new(:foo, [t1,t4,t5],nil,t3)
+    t8 = MethodType.new(:foo, [t2,t4,t5],nil,t3)
+    t9 = MethodType.new(:foo, [t1,t5,t4],nil,t3)
+    t10 = MethodType.new(:foo, [t1,t4],nil,t3)
+    t11 = MethodType.new(:foo, [],nil,t3)
+    t12 = MethodType.new(:foo, [t1,t4,t5],BlockType.new([t1,t4,t5],nil,t3),t3)
+    assert(t7.eql?(t8), msg(t7, t8))
+    assert(!t7.eql?(t9), msg(t7, t9, true))
+    assert(!t7.eql?(t10), msg(t7, t10, true))
+    assert(!t7.eql?(t11), msg(t7, t11, true))
+    assert(!t7.eql?(t12), msg(t7, t12, true))
+	end
+
+  def test_method_lists
+		t1 = NominalType.new(String)
+		t2 = NominalType.new(String)
+		t3 = NominalType.new(Fixnum)
+		t4 = MethodType.new(:foo,[],nil,t1) 
+		t5 = MethodType.new(:foo,[],nil,t2)
+		t6 = MethodType.new(:bar,[],nil,t2)
+		t7 = MethodType.new(:foo,[],nil,t3)
+    t8 = MethodListType.new([t4,t6])
+    t9 = MethodListType.new([t5,t7])
+    assert(!t8.eql?(t9), msg(t8, t9, true))
+  end
+
+end

data/test/type/tc_parser.rb

@@ -0,0 +1,219 @@
+# This test verifies type signature parser for RubyBreaker. 
+
+dir = File.dirname(__FILE__)
+
+require "test/unit"
+require "#{dir}/../../lib/rubybreaker/type"
+
+class GrammarTest < Test::Unit::TestCase
+
+  include RubyBreaker
+  
+  def setup
+    @parser = Runtime::TypeSigParser::PARSER
+  end
+  
+  def teardown
+  end
+
+  def test_symbol_method_names
+    meth_names = [:"===", :"<=>", :"[]=", 
+                  :"==", :"!=", :"<<", :">>", :"[]", :"**",
+                  :"<=", :">=", :"-@", :"=~", 
+                  :"<", :">", :"&", :"|", :"*", :"/",
+                  :"%", :"+", :"-", :"^"] 
+    meth_names.each do |meth_name|
+      type = @parser.parse("#{meth_name}() -> basic_object").value
+      str = TypeUnparser.unparse(type)
+      assert_equal("#{meth_name}() -> basic_object", str)
+    end
+  end
+  
+  def test_method_type_no_arg_no_blk
+    type = @parser.parse("foo() -> basic_object").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo() -> basic_object", str)
+  end
+  
+  def test_method_type_nil_ret
+    type = @parser.parse("foo() -> nil").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo() -> nil", str)
+  end
+  
+  def test_method_type_self_ret
+    type = @parser.parse("foo() -> self").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo() -> self", str)
+  end
+
+  def test_method_type_any_type1
+    type = @parser.parse("foo() -> ?").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo() -> ?", str)
+  end
+  
+  # def test_method_type_any_type2
+  #   type = @parser.parse("foo() -> []").value
+  #   str = TypeUnparser.unparse(type)
+  #   #puts str
+  #   assert_equal("foo() -> ?", str)
+  # end
+  
+  def test_method_type_one_arg_no_blk
+    type = @parser.parse("foo(fixnum) -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo(fixnum) -> fixnum",str)
+  end
+  
+  def test_method_type_two_args_no_blk
+    type = @parser.parse("foo(fixnum,string) -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo(fixnum, string) -> fixnum",str)
+  end
+  
+  def test_method_type_or_args_no_blk
+    type = @parser.parse("foo(fixnum || string) -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo(fixnum || string) -> fixnum",str)
+  end
+
+  def test_method_type_one_arg_empty_blk
+    type = @parser.parse("foo(fixnum) { } -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo(fixnum) -> fixnum",str)
+  end
+
+  def test_method_type_opt_arg_empty_blk
+    type = @parser.parse("foo(fixnum?) { } -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    assert_equal("foo(fixnum?) -> fixnum",str)
+  end
+
+  def test_method_type_opt_or_arg_empty_blk
+    type = @parser.parse("foo((fixnum || string)?) { } -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    assert_equal("foo((fixnum || string)?) -> fixnum",str)
+  end
+
+  def test_method_type_varlen_or_arg_empty_blk
+    type = @parser.parse("foo((fixnum || string)*) { } -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    assert_equal("foo((fixnum || string)*) -> fixnum",str)
+  end
+
+  def test_method_type_opt_args_empty_blk
+    type = @parser.parse("foo(string, symbol?, fixnum?) { } -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    assert_equal("foo(string, symbol?, fixnum?) -> fixnum",str)
+  end
+  
+  def test_method_type_varlen_arg_empty_blk
+    type = @parser.parse("foo(fixnum*) { } -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    assert_equal("foo(fixnum*) -> fixnum",str)
+  end
+
+  def test_method_type_opt_args_varlen_arg_empty_blk
+    sig = "foo(string, symbol?, fixnum?, string*) { } -> fixnum"
+    type = @parser.parse(sig).value
+    str = TypeUnparser.unparse(type)
+    assert_equal("foo(string, symbol?, fixnum?, string*) -> fixnum",str)
+  end
+
+  def test_method_type_one_arg_blk
+    type = @parser.parse("foo(fixnum) {|fixnum| -> string} -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo(fixnum) {|fixnum| -> string} -> fixnum",str)
+  end
+
+  def test_method_type_blk_two_args
+    sig = "foo() {|fixnum,string| -> string} -> fixnum"
+    type = @parser.parse(sig).value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo() {|fixnum, string| -> string} -> fixnum",str)
+  end
+  
+  def test_method_blk_two_args
+    sig = "foo(fixnum) {|fixnum,float| -> string} -> fixnum"
+    type = @parser.parse(sig).value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo(fixnum) {|fixnum, float| -> string} -> fixnum",str)  
+  end
+  
+  def test_method_type_blk_three_args_opt_args
+    sig = "foo() {|fixnum,string?, float?| -> string} -> fixnum"
+    type = @parser.parse(sig).value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo() {|fixnum, string?, float?| -> string} -> fixnum",str)
+  end
+
+  def test_method_type_blk_three_args_varlen_arg
+    sig = "foo() {|fixnum,string, float*| -> string} -> fixnum"
+    type = @parser.parse(sig).value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo() {|fixnum, string, float*| -> string} -> fixnum",str)
+  end
+
+  def test_method_type_blk_three_args_opt_varlen_args
+    sig = "foo() {|fixnum,string?, float*| -> string} -> fixnum"
+    type = @parser.parse(sig).value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo() {|fixnum, string?, float*| -> string} -> fixnum",str)
+  end
+
+  def test_method_duck_arg
+    type = @parser.parse("foo([m1]) -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo([m1]) -> fixnum",str)    
+  end
+
+  def test_method_duck_arg_more_methods
+    type = @parser.parse("foo([m1,m2,m3?]) -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo([m1, m2, m3?]) -> fixnum",str)    
+  end
+  
+  def test_method_fusion_arg
+    type = @parser.parse("foo(fixnum[to_s]) -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo(fixnum[to_s]) -> fixnum",str)    
+  end
+  
+  def test_method_fusion_arg_more_methods
+    type = @parser.parse("foo(fixnum[to_s,to_i]) -> fixnum").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo(fixnum[to_i, to_s]) -> fixnum",str)    
+  end
+  
+  def test_space_around
+    type = @parser.parse("    foo() -> nil ").value
+    str = TypeUnparser.unparse(type)
+    #puts str
+    assert_equal("foo() -> nil", str)
+  end
+
+  def test_parse_fail_no_methname
+    type = @parser.parse("() -> nil")
+    assert_equal(nil, type, "Type signature without a method name")
+  end
+
+end