rubybreaker 0.0.1

data/test/type/tc_unparser.rb

@@ -0,0 +1,276 @@
+# This test verifies type unparser for RubyBreaker types.
+
+dir = File.dirname(__FILE__)
+require "test/unit"
+require "#{dir}/../../lib/rubybreaker/type"
+
+class UnparserTest < Test::Unit::TestCase
+
+  include RubyBreaker
+  
+  class A; end
+  class B; end
+  class C; end
+  class D; end
+  class E; end
+
+  def test_nil_type()
+    t1 = NilType.new
+    str1 = TypeUnparser.unparse(t1)
+    # puts str1
+    assert_equal("nil",str1.strip())
+  end
+
+  def test_any_type()
+    t1 = AnyType.new
+    str1 = TypeUnparser.unparse(t1)
+    # puts str1
+    assert_equal("?",str1.strip())
+  end
+
+  def test_nominal_type()
+    t1 = NominalType.new(A)
+    str1 = TypeUnparser.unparse(t1)
+    # puts str1
+    assert_equal("a",str1)
+  end
+
+  def test_self_type()
+    t1 = SelfType.new()
+    str1 = TypeUnparser.unparse(t1)
+    # puts str1
+    assert_equal("self", str1)
+  end
+
+  def test_opt_type()
+    t1 = NominalType.new(A)
+    t2 = OptionalType.new(t1)
+    str2 = TypeUnparser.unparse(t2)
+    # puts str1
+    assert_equal("a?",str2)
+  end
+
+  def test_opt_or_type()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = OrType.new([t1, t2])
+    t4 = OptionalType.new(t3)
+    str4 = TypeUnparser.unparse(t4)
+    # puts str1
+    assert_equal("(a || b)?",str4)
+  end
+
+  def test_star_type()
+    t1 = NominalType.new(A)
+    t2 = VarLengthType.new(t1)
+    str2 = TypeUnparser.unparse(t2)
+    # puts str1
+    assert_equal("a*",str2)
+  end
+
+  def test_star_or_type()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = OrType.new([t1, t2])
+    t4 = VarLengthType.new(t3)
+    str4 = TypeUnparser.unparse(t4)
+    # puts str1
+    assert_equal("(a || b)*",str4)
+  end
+
+  def test_duck_type()
+    t1 = DuckType.new(["+"])
+    str1 = TypeUnparser.unparse(t1)
+    # puts str1
+    assert_equal("[+]",str1)
+  end
+  
+  def test_duck_type_more_meths()
+    t1 = DuckType.new(["+","foo","bar"])
+    str1 = TypeUnparser.unparse(t1)
+    #puts str1
+    assert_equal("[+, bar, foo]",str1)
+  end
+
+  def test_duck_type_symbolic_meths()
+    t1 = DuckType.new(["+","-","[]","[]="])
+    str1 = TypeUnparser.unparse(t1)
+    #puts str1
+    assert_equal("[+, -, [], []=]",str1)
+  end
+
+  def test_fusion_type()
+    t1 = FusionType.new(NominalType.new(A), ["+"])
+    str1 = TypeUnparser.unparse(t1)
+    # puts str1
+    assert_equal("a[+]",str1)
+  end
+
+  def test_fusion_type_more_meths()
+    t1 = FusionType.new(NominalType.new(A), ["+","foo","bar"])
+    str1 = TypeUnparser.unparse(t1)
+    # puts str1
+    assert_equal("a[+, bar, foo]",str1)
+  end
+  
+  def test_fusion_type_symbolic_meths()
+    t1 = FusionType.new(NominalType.new(A), ["+","-","[]","[]="])
+    str1 = TypeUnparser.unparse(t1)
+    # puts str1
+    assert_equal("a[+, -, [], []=]",str1)
+  end
+
+  def test_or_type()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = OrType.new([t1,t2])
+    str3 = TypeUnparser.unparse(t3)
+    # puts str3
+    assert_equal("a || b", str3)
+  end
+
+  def test_or_type_more_types()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = NominalType.new(C)
+    t4 = OrType.new([t1,t2,t3])
+    str4 = TypeUnparser.unparse(t4)
+    # puts str3
+    assert_equal("a || b || c", str4)
+  end
+
+  def test_block_type_no_blk()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = BlockType.new([t1],nil,t2)
+    str3 = TypeUnparser.unparse(t3)
+    # puts str3
+    assert_equal("|a| -> b",str3)
+  end
+
+  def test_block_type_more_args_no_blk()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = NominalType.new(C)
+    t4 = BlockType.new([t1,t2],nil,t3)
+    str4 = TypeUnparser.unparse(t4)
+    # puts str3
+    assert_equal("|a, b| -> c",str4)
+  end
+  
+  def test_block_type_ret_self()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = SelfType.new()
+    t4 = BlockType.new([t1,t2],nil,t3)
+    str4 = TypeUnparser.unparse(t4)
+    # puts str3
+    assert_equal("|a, b| -> self",str4)
+  end
+
+  def test_block_type()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = NominalType.new(C)
+    t4 = NominalType.new(D)
+    t5 = BlockType.new([t1],BlockType.new([t2],nil,t3),t4)
+    str5 = TypeUnparser.unparse(t5)
+    # puts str5
+    assert_equal("|a| {|b| -> c} -> d",str5)
+  end
+  
+  def test_block_type_more_args()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = NominalType.new(C)
+    t4 = NominalType.new(D)
+    t5 = NominalType.new(E)
+    t6 = BlockType.new([t1,t2],BlockType.new([t3],nil,t4),t5)
+    str6 = TypeUnparser.unparse(t6)
+    # puts str5
+    assert_equal("|a, b| {|c| -> d} -> e",str6)
+  end 
+
+  def test_block_type_or_args()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = NominalType.new(C)
+    t4 = NominalType.new(D)
+    t5 = NominalType.new(E)
+    t6 = BlockType.new([OrType.new([t1,t2])],BlockType.new([t3],nil,t4),t5)
+    str6 = TypeUnparser.unparse(t6)
+    # puts str5
+    assert_equal("|a || b| {|c| -> d} -> e",str6)
+  end
+
+  def test_method_type_no_blk()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = MethodType.new("m",[t1],nil,t2)
+    str3 = TypeUnparser.unparse(t3)
+    # puts str3
+    assert_equal("m(a) -> b", str3)
+  end
+  
+  def test_method_type_symbolic_methname()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = MethodType.new("==",[t1],nil,t2)
+    str3 = TypeUnparser.unparse(t3)
+    # puts str3
+    assert_equal("==(a) -> b", str3)
+  end
+
+  def test_method_type_more_args_no_blk()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = NominalType.new(C)
+    t4 = MethodType.new("m",[t1,t2],nil,t3)
+    str4 = TypeUnparser.unparse(t4)
+    # puts str3
+    assert_equal("m(a, b) -> c", str4)
+  end
+
+  def test_method_type_ret_self()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = SelfType.new()
+    t4 = MethodType.new("m",[t1,t2],nil,t3)
+    str4 = TypeUnparser.unparse(t4)
+    # puts str3
+    assert_equal("m(a, b) -> self", str4)
+  end
+
+  def test_method_type_or_args_no_blk()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = NominalType.new(C)
+    t4 = MethodType.new("m",[OrType.new([t1,t2])],nil,t3)
+    str4 = TypeUnparser.unparse(t4)
+    # puts str3
+    assert_equal("m(a || b) -> c", str4)
+  end
+
+  def test_method_type_with_blk()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = NominalType.new(C)
+    t4 = NominalType.new(D)
+    t5 = MethodType.new("m",[t1],BlockType.new([t2],nil,t3),t4)
+    str5 = TypeUnparser.unparse(t5)
+    # puts str5
+    assert_equal("m(a) {|b| -> c} -> d", str5)
+  end
+
+  def test_method_type_more_args_with_blk()
+    t1 = NominalType.new(A)
+    t2 = NominalType.new(B)
+    t3 = NominalType.new(C)
+    t4 = NominalType.new(D)
+    t5 = NominalType.new(E)
+    t6 = MethodType.new("m",[t1,t2],BlockType.new([t3],nil,t4),t5)
+    str6 = TypeUnparser.unparse(t6)
+    # puts str5
+    assert_equal("m(a, b) {|c| -> d} -> e", str6)
+  end
+end

data/test/typing/tc_rubytype.rb

@@ -0,0 +1,63 @@
+dir = File.dirname(__FILE__)
+require "test/unit"
+require "#{dir}/../../lib/rubybreaker/typing"
+
+
+class RubyTypeTest < Test::Unit::TestCase
+
+  module M1
+  end
+  
+  module M2
+    include M1
+  end
+  
+  module M3
+    include M2
+  end
+  
+  module M4
+  end
+  
+  module M5
+    include M2
+    include M4
+  end
+  
+  include RubyBreaker
+  
+  def test_subclass_1
+    cls1 = Fixnum
+    cls2 = Numeric
+    assert(RubyTypeUtils.subclass_rel?(cls1,cls2))
+    assert(!RubyTypeUtils.subclass_rel?(cls2,cls1))
+  end
+  
+  def test_subclass_2
+    cls1 = String
+    cls2 = Fixnum
+    assert(!RubyTypeUtils.subclass_rel?(cls1,cls2))
+    assert(!RubyTypeUtils.subclass_rel?(cls2,cls1))
+  end
+  
+  def test_subclass_3
+    cls1 = Array
+    mod1 = Enumerable
+    assert(RubyTypeUtils.subclass_rel?(cls1,mod1))
+    assert(!RubyTypeUtils.submodule_rel?(mod1,cls1))
+  end
+  
+  def test_subclass_4
+    assert(!RubyTypeUtils.submodule_rel?(M1,M2))
+    assert(RubyTypeUtils.submodule_rel?(M2,M1))
+    assert(RubyTypeUtils.submodule_rel?(M3,M1))
+    assert(!RubyTypeUtils.submodule_rel?(M1,M3))
+    assert(RubyTypeUtils.submodule_rel?(M5,M1))
+    assert(RubyTypeUtils.submodule_rel?(M5,M2))
+    assert(!RubyTypeUtils.submodule_rel?(M5,M3))
+    assert(RubyTypeUtils.submodule_rel?(M5,M4))
+  end
+
+  
+  
+end

data/test/typing/tc_typing.rb

@@ -0,0 +1,219 @@
+dir = File.dirname(__FILE__)
+require "test/unit"
+require "#{dir}/../../lib/rubybreaker/type"
+require "#{dir}/../../lib/rubybreaker/typing"
+
+class TypingTest < Test::Unit::TestCase
+
+  include RubyBreaker
+
+  class A
+    include RubyBreaker::Broken
+    typesig("foo(fixnum) -> fixnum")
+    typesig("bar(fixnum) {|fixnum| -> string} -> string")
+    typesig("baz(fixnum, string?) -> fixnum")
+    typesig("bazz(fixnum, string*) -> fixnum")
+  end
+
+  # This function is a helper to compose an error message for subtyping
+  # test.
+  def msg(lhs,rhs,should_fail=false)
+    subtype = lhs.unparse()
+    supertype = rhs.unparse()
+    str = "#{subtype} <: #{supertype}"
+    if should_fail
+      str = str + " did not fail"
+    else
+      str = str + " failed"
+    end
+    return str
+  end
+
+  def test_any()
+    t1 = AnyType.new
+    t2 = NilType.new
+    assert(t1.subtype_of?(t2), msg(t1,t2))
+    assert(!t2.subtype_of?(t1), msg(t2,t1,true))
+  end 
+
+  def test_nil()
+    t1 = NilType.new
+    t2 = NilType.new
+    t3 = NominalType.new(Fixnum)
+    assert(t1.subtype_of?(t2), msg(t1,t2))
+    assert(t2.subtype_of?(t1), msg(t1,t2))
+    assert(!t3.subtype_of?(t2), msg(t3,t2,true))
+    assert(!t2.subtype_of?(t3), msg(t3,t2,true))
+  end
+
+  def test_nominal()
+    t1 = NominalType.new(Fixnum)
+    t2 = NominalType.new(Numeric)
+    t3 = NominalType.new(Object)
+    t4 = NominalType.new(String)
+    assert(t1.subtype_of?(t2), msg(t1,t2))
+    assert(!t2.subtype_of?(t1), msg(t2,t1,true))
+    assert(t1.subtype_of?(t3), msg(t1,t3))
+    assert(!t3.subtype_of?(t1), msg(t3,t1,true))
+    assert(!t1.subtype_of?(t4), msg(t1,t4,true))
+    assert(!t4.subtype_of?(t1), msg(t4,t1,true))
+  end
+
+	def test_self()
+		SelfType.set_self(Fixnum)
+		t1 = SelfType.new()
+		t2 = SelfType.new()
+		SelfType.set_self(String)
+		t3 = SelfType.new()
+		t4 = NominalType.new(Numeric)
+		t5 = NominalType.new(String)
+		t6 = DuckType.new([:to_s])
+		assert(t1.subtype_of?(t2), msg(t1,t2))
+		assert(t2.subtype_of?(t1), msg(t2,t1))
+		assert(t1.subtype_of?(t3), msg(t1, t3))
+		assert(t3.subtype_of?(t1), msg(t3, t1))
+		assert(t1.subtype_of?(t4), msg(t1, t4))
+		assert(!t4.subtype_of?(t1), msg(t4, t1, true))
+		assert(!t1.subtype_of?(t5), msg(t1, t5, true))
+		assert(!t5.subtype_of?(t1), msg(t5, t1, true))
+		assert(t1.subtype_of?(t6), msg(t1, t5))
+		assert(!t6.subtype_of?(t1), msg(t5, t1, true))
+	end
+
+  def test_duck_types_id()
+    t1 = DuckType.new([:foo,:baz]) 
+    t2 = DuckType.new([:baz,:foo])
+    assert(t1.subtype_of?(t2),msg(t1,t2))
+  end
+
+  def test_duck_types()
+    t1 = DuckType.new([:foo,:bar,:baz])
+    t2 = DuckType.new([:foo,:baz]) 
+    assert(t1.subtype_of?(t2),msg(t1,t2))
+    assert(!t2.subtype_of?(t1),msg(t2,t1,true))
+  end
+
+  def test_fusion_types()
+    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])
+    assert(t1.subtype_of?(t2), msg(t1, t2))
+    assert(t2.subtype_of?(t1), msg(t1, t2))
+    # XXX: The following assert will succeed because Fixnum and String are
+    # not Broken at this point.
+    assert(t1.subtype_of?(t3), msg(t1, t3, true))
+  end
+
+  def test_duck_fusion_types()
+    t1 = DuckType.new([:to_s, :to_f])
+    t2 = FusionType.new(NominalType.new(Fixnum), [:to_f, :to_s])
+    # Again, this works because Fixnum is not Broken yet 
+    assert(t1.subtype_of?(t2), msg(t1, t2))
+    assert(t2.subtype_of?(t1), msg(t1, t2))
+  end
+  
+  def test_duck_nominal_types()
+    t1 = DuckType.new([:to_s, :to_f])
+    t2 = NominalType.new(Fixnum)
+    t3 = NominalType.new(Symbol)
+    assert(!t1.subtype_of?(t2), msg(t1, t2, true))
+    assert(!t1.subtype_of?(t3), msg(t1, t3, true))
+    assert(t2.subtype_of?(t1), msg(t2, t1))
+    assert(!t3.subtype_of?(t1), msg(t3, t1, true))
+  end
+
+  def test_nominal_and_other_types()
+    t1 = NominalType.new(Fixnum)
+    t2 = FusionType.new(NominalType.new(Fixnum), [:to_s, :to_f])
+    t3 = FusionType.new(NominalType.new(String), [:to_s, :to_f])
+    t4 = DuckType.new([:to_s, :to_f])
+    t5 = DuckType.new([:to_s, :to_f, :foo])
+    assert(t1.subtype_of?(t2), msg(t1, t2))
+    assert(!t2.subtype_of?(t1), msg(t2, t1, true))
+    assert(t1.subtype_of?(t3), msg(t1, t3))
+    assert(!t3.subtype_of?(t1), msg(t3, t1, true))
+    assert(t1.subtype_of?(t4), msg(t1, t4))
+    assert(!t4.subtype_of?(t1), msg(t4, t1, true))
+    assert(!t1.subtype_of?(t5), msg(t1, t5, true))
+    assert(!t5.subtype_of?(t1), msg(t5, t1, true))
+  end
+
+  def test_blk_types_id()
+    t1 = NominalType.new(Fixnum)
+    t2 = NominalType.new(String)
+    t3 = BlockType.new([t1],nil,t2)
+    t4 = BlockType.new([t1],nil,t2)
+    assert(t3.subtype_of?(t4),msg(t3,t4))
+    assert(t4.subtype_of?(t3),msg(t4,t3))
+  end
+
+  def test_blk_types_no_blk_ret_type_diff()
+    t1 = NominalType.new(Fixnum)
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = NominalType.new(Object)
+    t5 = BlockType.new([t1],nil,t2)
+    t6 = BlockType.new([t3],nil,t4)
+    assert(t5.subtype_of?(t6),msg(t5,t6))
+    assert(!t6.subtype_of?(t5),msg(t6,t5,true))
+  end
+
+  def test_blk_types_no_blk_one_arg()
+    t1 = NominalType.new(Object)
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = NominalType.new(Object)
+    t5 = BlockType.new([t1],nil,t2)
+    t6 = BlockType.new([t3],nil,t4)
+    assert(t5.subtype_of?(t6),msg(t5,t6))
+    assert(!t6.subtype_of?(t5),msg(t6,t5,true))
+  end
+
+  def test_blk_types_no_blk_opt_arg()
+    t1 = OptionalType.new(NominalType.new(Object))
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = NominalType.new(Object)
+    t5 = BlockType.new([t1],nil,t2)
+    t6 = BlockType.new([t3],nil,t4)
+    assert(t5.subtype_of?(t6),msg(t5,t6))
+    assert(!t6.subtype_of?(t5),msg(t6,t5,true))
+  end
+
+  def test_blk_types_no_blk_both_opt_arg()
+    t1 = OptionalType.new(NominalType.new(Object))
+    t2 = NominalType.new(String)
+    t3 = OptionalType.new(NominalType.new(Fixnum))
+    t4 = NominalType.new(Object)
+    t5 = BlockType.new([t1],nil,t2)
+    t6 = BlockType.new([t3],nil,t4)
+    assert(t5.subtype_of?(t6),msg(t5,t6))
+    assert(!t6.subtype_of?(t5),msg(t6,t5,true))
+  end
+
+  def test_blk_types_no_blk_varlen_arg()
+    t1 = VarLengthType.new(NominalType.new(Object))
+    t2 = NominalType.new(String)
+    t3 = NominalType.new(Fixnum)
+    t4 = NominalType.new(Object)
+    t5 = BlockType.new([t1],nil,t2)
+    t6 = BlockType.new([t3],nil,t4)
+    assert(t5.subtype_of?(t6),msg(t5,t6))
+    assert(!t6.subtype_of?(t5),msg(t6,t5,true))
+  end
+
+  def test_blk_types_no_blk_both_varlen_arg()
+    t1 = VarLengthType.new(NominalType.new(Object))
+    t2 = NominalType.new(String)
+    t3 = VarLengthType.new(NominalType.new(Fixnum))
+    t4 = NominalType.new(Object)
+    t5 = BlockType.new([t1],nil,t2)
+    t6 = BlockType.new([t3],nil,t4)
+    assert(t5.subtype_of?(t6),msg(t5,t6))
+    assert(!t6.subtype_of?(t5),msg(t6,t5,true))
+  end
+
+  def test_broken_nominal()
+  end
+
+end

data/webpage/footer.html

@@ -0,0 +1,5 @@
+
+	</div>
+  </center>
+</body>
+</html>