rdl 1.0.0.rc3 → 1.0.0.rc4

data/test/test_rdl.rb

@@ -0,0 +1,301 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestRDL < Minitest::Test
+
+  # Test wrapping with no types or contracts
+  def test_wrap
+    def m1(x) return x; end
+    def m2(x) return x; end
+    def m3(x) return x; end
+    def m4(x) return x; end
+    assert(not(RDL::Wrap.wrapped?(TestRDL, :m1)))
+    assert(not(RDL::Wrap.wrapped?(TestRDL, :m2)))
+    assert(not(RDL::Wrap.wrapped?(TestRDL, :m3)))
+    assert(not(RDL::Wrap.wrapped?(TestRDL, :m4)))
+    RDL::Wrap.wrap(TestRDL, :m1)
+    RDL::Wrap.wrap("TestRDL", :m2)
+    RDL::Wrap.wrap(:TestRDL, :m3)
+    RDL::Wrap.wrap(TestRDL, "m4")
+    assert(RDL::Wrap.wrapped?(TestRDL, :m1))
+    assert(RDL::Wrap.wrapped?(TestRDL, :m2))
+    assert(RDL::Wrap.wrapped?(TestRDL, :m3))
+    assert(RDL::Wrap.wrapped?(TestRDL, :m4))
+    assert_equal 3, m1(3)
+    assert_equal 3, m2(3)
+    assert_equal 3, m3(3)
+    assert_equal 3, m4(3)
+  end
+
+  def test_process_pre_post_args
+    ppos = RDL::Contract::FlatContract.new("Positive") { |x| x > 0 }
+    assert_equal ["TestRDL", :m1, ppos], RDL::Wrap.process_pre_post_args(self.class, "C", TestRDL, :m1, ppos)
+    assert_equal ["TestRDL", :m1, ppos], RDL::Wrap.process_pre_post_args(self.class, "C", TestRDL, "m1", ppos)
+    assert_equal ["[singleton]TestRDL", :m1, ppos], RDL::Wrap.process_pre_post_args(self.class, "C", TestRDL, "self.m1", ppos)
+    assert_equal ["TestRDL", :m1, ppos], RDL::Wrap.process_pre_post_args(self.class, "C", :m1, ppos)
+    assert_equal ["TestRDL", nil, ppos], RDL::Wrap.process_pre_post_args(self.class, "C", ppos)
+    klass1, meth1, c1 = RDL::Wrap.process_pre_post_args(self.class, "C", TestRDL, :m1) { |x| x > 0 }
+    assert_equal ["TestRDL", :m1], [klass1, meth1]
+    assert (c1.is_a? RDL::Contract::FlatContract)
+
+    klass2, meth2, c2 = RDL::Wrap.process_pre_post_args(self.class, "C", :m1) { |x| x > 0 }
+    assert_equal ["TestRDL", :m1], [klass2, meth2]
+    assert (c2.is_a? RDL::Contract::FlatContract)
+
+    klass3, meth3, c3 = RDL::Wrap.process_pre_post_args(self.class, "C") { |x| x > 0 }
+    assert_equal ["TestRDL", nil], [klass3, meth3]
+    assert (c3.is_a? RDL::Contract::FlatContract)
+    
+    assert_raises(ArgumentError) { RDL::Wrap.process_pre_post_args(self.class, "C") }
+    assert_raises(ArgumentError) { RDL::Wrap.process_pre_post_args(self.class, "C", 42) }
+    assert_raises(ArgumentError) { RDL::Wrap.process_pre_post_args(self.class, "C", 42) { |x| x > 0} }
+    assert_raises(ArgumentError) { RDL::Wrap.process_pre_post_args(self.class, "C", ppos) { |x| x > 0 } }
+    assert_raises(ArgumentError) { RDL::Wrap.process_pre_post_args(self.class, "C", :m1) }
+    assert_raises(ArgumentError) { RDL::Wrap.process_pre_post_args(self.class, "C", TestRDL) }
+    assert_raises(ArgumentError) { RDL::Wrap.process_pre_post_args(self.class, "C", TestRDL) { |x| x > 0 } }
+    assert_raises(ArgumentError) { RDL::Wrap.process_pre_post_args(self.class, "C", TestRDL, ppos) }
+    assert_raises(ArgumentError) { RDL::Wrap.process_pre_post_args(self.class, "C", TestRDL, :m1, ppos, 42) }
+  end
+
+  def test_pre_contract
+    pos = RDL::Contract::FlatContract.new("Positive") { |x| x > 0 }
+    def m5(x) return x; end
+    pre TestRDL, :m5, pos
+    assert_equal 3, m5(3)
+    assert_raises(RDL::Contract::ContractError) { m5(-1) }
+  end
+
+  def test_post_contract
+    neg = RDL::Contract::FlatContract.new("Negative") { |x| x < 0 }
+    def m6(x) return 3; end
+    post TestRDL, :m6, neg
+    assert_raises(RDL::Contract::ContractError) { m6(42) }
+  end
+
+  def test_pre_post_contract
+    pos = RDL::Contract::FlatContract.new("Positive") { |x| x > 0 }
+    ppos = RDL::Contract::FlatContract.new("Positive") { |r, x| r > 0 }
+    def m7(x) return x; end
+    pre TestRDL, :m7, pos
+    post TestRDL, :m7, ppos
+    assert_equal 3, m7(3)
+  end
+
+  def test_and_contract
+    pos = RDL::Contract::FlatContract.new("Positive") { |x| x > 0 }
+    five = RDL::Contract::FlatContract.new("Five") { |x| x == 5 }
+    gt = RDL::Contract::FlatContract.new("Greater Than 3") { |x| x > 3 }
+    def m8(x) return x; end
+    pre TestRDL, :m8, pos
+    pre TestRDL, :m8, gt
+    assert_equal 5, m8(5)
+    assert_equal 4, m8(4)
+    assert_raises(RDL::Contract::ContractError) { m8 3 }
+    def m9(x) return x; end
+    pre TestRDL, :m9, pos
+    pre TestRDL, :m9, gt
+    pre TestRDL, :m9, five
+    assert_equal 5, m9(5)
+    assert_raises(RDL::Contract::ContractError) { m9 4 }
+    assert_raises(RDL::Contract::ContractError) { m9 3 }
+
+    ppos = RDL::Contract::FlatContract.new("Positive") { |r, x| r > 0 }
+    pfive = RDL::Contract::FlatContract.new("Five") { |r, x| r == 5 }
+    pgt = RDL::Contract::FlatContract.new("Greater Than 3") { |r, x| r > 3 }
+    def m10(x) return x; end
+    post TestRDL, :m10, ppos
+    post TestRDL, :m10, pgt
+    assert_equal 5, m10(5)
+    assert_equal 4, m10(4)
+    assert_raises(RDL::Contract::ContractError) { m10 3 }
+    def m11(x) return x; end
+    post TestRDL, :m11, ppos
+    post TestRDL, :m11, pgt
+    post TestRDL, :m11, pfive
+    assert_equal 5, m11(5)
+    assert_raises(RDL::Contract::ContractError) { m11 4 }
+    assert_raises(RDL::Contract::ContractError) { m11 3 }
+  end
+
+  def test_deferred_wrap
+    pos = RDL::Contract::FlatContract.new("Positive") { |x| x > 0 }
+    pre TestRDL, :m12, pos
+    def m12(x) return x; end
+    assert_equal 3, m12(3)
+    assert_raises(RDL::Contract::ContractError) { m12(-1) }
+
+    ppos = RDL::Contract::FlatContract.new("Positive") { |r, x| r > 0 }
+    post TestRDL, :m13, ppos
+    def m13(x) return x; end
+    assert_equal 3, m13(3)
+    assert_raises(RDL::Contract::ContractError) { m13(-1) }
+
+    self.class.class_eval {
+      pre(pos)
+      def m14(x) return x; end
+    }
+    assert_equal 3, m14(3)
+    assert_raises(RDL::Contract::ContractError) { m14(-1) }
+
+    self.class.class_eval {
+      pre { |x| x > 0 }
+      def m15(x) return x; end
+    }
+    assert_equal 3, m15(3)
+    assert_raises(RDL::Contract::ContractError) { m15(-1) }
+
+    self.class.class_eval {
+      pre { |x| x > 0 }
+      post { |r, x| x > 0 }
+      def m17(x) return x; end
+    }
+    assert_equal 3, m17(3)
+    assert_raises(RDL::Contract::ContractError) { m17(-1) }
+
+    self.class.class_eval {
+      pre { |x| x > 0 }
+      post { |r, x| x < 0 }
+      def m18(x) return x; end
+    }
+    assert_raises(RDL::Contract::ContractError) { m18(-1) }
+
+    self.class.class_eval {
+      pre { |x| x > 0 }
+      pre { |x| x < 5 }
+      def m19(x) return x; end
+    }
+    assert_equal 3, m19(3)
+    assert_raises(RDL::Contract::ContractError) { m19(6) }
+    assert_raises(RDL::Contract::ContractError) { m19(-1) }
+
+    assert_raises(RuntimeError) {
+      self.class.class_eval <<-RUBY, __FILE__, __LINE__
+  pre { |x| x > 0 }
+  class Inner
+    def m20(x)
+      return x
+    end
+  end
+RUBY
+    }
+  end
+
+  def test_special_method_names
+    self.class.class_eval {
+      pre { |x| x > 0 }
+      def [](x) return x end
+    }
+    assert_equal 3, self[3]
+    assert_raises(RDL::Contract::ContractError) { self[-1] }
+    self.class.class_eval {
+      pre { |x| x > 0 }
+      def foo?(x) return x end
+    }
+    assert_equal 3, foo?(3)
+    assert_raises(RDL::Contract::ContractError) { foo?(-1) }
+    self.class.class_eval {
+      pre(:"bar!") { |x| x > 0 }
+      def bar!(x) return x end
+    }
+    assert_equal 3, bar!(3)
+    assert_raises(RDL::Contract::ContractError) { bar!(-1) }
+  end
+
+  def test_wrap_access_control
+    def m20(x) return x; end
+    def m21(x) return x; end
+    def m22(x) return x; end
+    self.class.class_eval { public(:m20) }
+    self.class.class_eval { protected(:m21) }
+    self.class.class_eval { private(:m22) }
+    RDL::Wrap.wrap(TestRDL, :m20)
+    RDL::Wrap.wrap(TestRDL, :m21)
+    RDL::Wrap.wrap(TestRDL, :m22)
+    assert (self.class.class_eval { public_method_defined? :m20 })
+    assert (self.class.class_eval { protected_method_defined? :m21 })
+    assert (self.class.class_eval { private_method_defined? :m22 })
+  end
+
+  def test_type_params
+    self.class.class_eval "class TP1; type_params [:t], :all? end"
+    assert_equal [[:t], [:~], :all?], RDL::Wrap.get_type_params(TestRDL::TP1)
+    self.class.class_eval "class TP2; type_params([:t], nil) { |t| true } end"
+    tp2 = RDL::Wrap.get_type_params(TestRDL::TP2)
+    assert_equal [:t], tp2[0]
+    assert_equal [:~], tp2[1]
+    assert_raises(RuntimeError) { self.class.class_eval "class TP1; type_params [:t], :all? end" }
+    self.class.class_eval "class TP3; type_params [:t, :u], :all? end"
+    assert_equal [[:t, :u], [:~, :~], :all?], RDL::Wrap.get_type_params(TestRDL::TP3)
+
+    self.class.class_eval "class TP4; type_params [:t, :u, :v], :all?, variance: [:+, :-, :~] end"
+    assert_equal [[:t, :u, :v], [:+, :-, :~], :all?], RDL::Wrap.get_type_params(TestRDL::TP4)
+    assert_raises(RuntimeError) { self.class.class_eval "class TP5; type_params([], :all?) { true } end" }
+    assert_raises(RuntimeError) { self.class.class_eval "class TP6; type_params [:t, :u], :all?, variance: [:+] end" }
+    assert_raises(RuntimeError) { self.class.class_eval "class TP7; type_params [:t, :u], :all?, variance: [:a, :b] end" }
+    assert_raises(RuntimeError) { self.class.class_eval "class TP8; type_params([:t], :all?) { |t| true } end" }
+    assert_raises(RuntimeError) { self.class.class_eval "class TP8; type_params [:t], 42 end" }
+  end
+
+  def test_wrap_new
+    self.class.class_eval "class B; def initialize(x); @x = x end; def get(); return @x end end"
+    pre("TestRDL::B", "self.new") { |x| x > 0 }
+    assert_equal 3, TestRDL::B.new(3).get
+    assert_raises(RDL::Contract::ContractError) { TestRDL::B.new(-3) }
+
+    self.class.class_eval "class C; pre { |x| x > 0 }; def initialize(x); @x = x end; def get(); return @x end end"
+    assert_equal 3, TestRDL::C.new(3).get
+    assert_raises(RDL::Contract::ContractError) { TestRDL::C.new(-3) }
+
+    self.class.class_eval "class D; def get(); return @x end end"
+    pre("TestRDL::D", "self.new") { |x| x > 0 }
+    self.class.class_eval "class D; def initialize(x); @x = x end end"
+    assert_equal 3, TestRDL::D.new(3).get
+    assert_raises(RDL::Contract::ContractError) { TestRDL::D.new(-3) }
+
+    skip "Can't defer contracts on new yet"
+    pre("TestRDL::E", "self.new") { |x| x > 0 }
+    self.class.class_eval "class E; def initialize(x); @x = x end end"
+    assert (TestRDL::E.new(3))
+    assert_raises(RDL::Contract::ContractError) { TestRDL::E.new(-3) }
+  end
+
+  def test_class_method
+    pos = RDL::Contract::FlatContract.new("Positive") { |x| x > 0 }
+    self.class.class_eval { def self.cm1(x) return x; end }
+    pre TestRDL, "self.cm1", pos
+    assert_equal 3, TestRDL.cm1(3)
+    assert_raises(RDL::Contract::ContractError) { TestRDL.cm1(-1) }
+
+    assert_raises(RuntimeError) { pre TestRDL, "TestRDL.cm1", pos }
+
+    pre TestRDL, "self.cm2", pos
+    self.class.class_eval { def self.cm2(x) return x; end }
+    assert_equal 3, TestRDL.cm2(3)
+    assert_raises(RDL::Contract::ContractError) { TestRDL.cm2(-1) }
+
+    self.class.class_eval {
+      pre { |x| x > 0 }
+      def self.cm3(x) return x; end
+    }
+    assert_equal 3, TestRDL.cm3(3)
+    assert_raises(RDL::Contract::ContractError) { TestRDL.cm3(-1) }
+  end
+
+  def test_cast
+    ntyp = RDL::Type::NilType.new
+    obj1 = 3.type_cast(ntyp)
+    assert (ntyp.member? obj1)
+    obj2 = 3.type_cast('nil')
+    assert (ntyp.member? obj2)
+  end
+
+  def test_pre_post_self
+    self.class.class_eval {
+      pre { |x| self.instance_of? TestRDL }
+      post { |r, x| self.instance_of? TestRDL }
+      def m23(x) return x; end
+    }
+    assert_equal 3, m23(3)
+  end
+  
+end

data/test/test_rdl_type.rb

@@ -0,0 +1,70 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestRDLType < Minitest::Test
+  def test_single_type_contract
+    def m1(x) return x; end
+    type TestRDLType, :m1, "(Fixnum) -> Fixnum"
+    assert_equal 5, m1(5)
+    assert_raises(RDL::Type::TypeError) { m1("foo") }
+
+    self.class.class_eval {
+      type :m2, "(Fixnum) -> Fixnum"
+      def m2(x) return x; end
+    }
+    assert_equal 5, m2(5)
+    assert_raises(RDL::Type::TypeError) { m2("foo") }
+
+    self.class.class_eval {
+      type "(Fixnum) -> Fixnum"
+      def m3(x) return x; end
+    }
+    assert_equal 5, m3(5)
+    assert_raises(RDL::Type::TypeError) { m3("foo") }
+  end
+
+  def test_intersection_type_contract
+    self.class.class_eval {
+      type "(Fixnum) -> Fixnum"
+      type "(String) -> String"
+      def m4(x) return x; end
+    }
+    assert_equal 5, m4(5)
+    assert_equal "foo", m4("foo")
+    assert_raises(RDL::Type::TypeError) { m4(:foo) }
+
+    self.class.class_eval {
+      type "(Fixnum) -> Fixnum"
+      type "(String) -> String"
+      def m5(x) return 42; end
+    }
+    assert_equal 42, m5(3)
+    assert_raises(RDL::Type::TypeError) { m5("foo") }
+
+    self.class.class_eval {
+      type "(Fixnum) -> Fixnum"
+      type "(Fixnum) -> String"
+      def m6(x) if x > 10 then :oops elsif x > 5 then x else "small" end end
+    }
+    assert_equal 8, m6(8)
+    assert_equal "small", m6(1)
+    assert_raises(RDL::Type::TypeError) { m6(42) }
+  end
+
+  def test_fixnum_type_contract
+    self.class.class_eval {
+      type "(0) -> Fixnum"
+      def m7(x) return x; end
+    }
+    assert_equal 0, m7(0)
+    assert_raises(RDL::Type::TypeError) { m7(1) }
+  end
+
+  def test_wrap_new_inherited
+    self.class.class_eval "class NI_A; def initialize(x); @x = x; end; end; class NI_B < NI_A; end"
+    type "TestRDLType::NI_A", "self.new", "(Fixnum) -> TestRDLType::NI_A"
+    assert (TestRDLType::NI_B.new(3))
+    assert_raises(RDL::Type::TypeError) { TestRDLType::NI_B.new("3") }
+  end
+
+end

data/test/test_type_contract.rb

@@ -0,0 +1,187 @@
+require 'minitest/autorun'
+require_relative '../lib/rdl.rb'
+
+class TestTypeContract < Minitest::Test
+  include RDL::Type
+  include RDL::Contract
+
+  def setup
+    @p = Parser.new
+  end
+  
+  def test_flat
+    tnil = NilType.new
+    cnil = tnil.to_contract
+    assert (cnil.check self, nil)
+    assert_raises(TypeError) { cnil.check self, true }
+    tfixnum = NominalType.new :Fixnum
+    cfixnum = tfixnum.to_contract
+    assert (cfixnum.check self, 42)
+    assert (cfixnum.check self, nil)
+    assert_raises(TypeError) { cfixnum.check self, "42" }
+  end
+
+  def test_proc
+    t1 = @p.scan_str "(nil) -> nil"
+    p1 = t1.to_contract.wrap(self) { |x| nil }
+    assert_nil p1.call(nil)
+    assert_raises(TypeError) { p1.call(42) }
+    p1b = t1.to_contract.wrap(self) { |x| 42 }
+    assert_raises(TypeError) { p1b.call(nil) }
+
+    t2 = @p.scan_str "(Fixnum, Fixnum) -> Fixnum"
+    p2 = t2.to_contract.wrap(self) { |x, y| x }
+    assert_equal 42, p2.call(42, 43)
+    assert_equal 42, p2.call(42, nil)
+    assert_raises(TypeError) { p2.call(42, 43, 44) }
+    assert_raises(TypeError) { p2.call(42, 43, 44, 45) }
+    assert_raises(TypeError) { p2.call(42) }
+    assert_raises(TypeError) { p2.call }
+
+    t3 = @p.scan_str "() -> nil"
+    p3 = t3.to_contract.wrap(self) { nil }
+    assert_nil p3.call
+    assert_raises(TypeError) { p3.call(42) }
+    
+    t4 = @p.scan_str "(Fixnum, ?Fixnum) -> Fixnum"
+    p4 = t4.to_contract.wrap(self) { |x| x }
+    assert_equal 42, p4.call(42)
+    assert_equal 42, p4.call(42, 43)
+    assert_raises(TypeError) { p4.call(42, 43, 44) }
+    assert_raises(TypeError) { p4.call }
+
+    t5 = @p.scan_str "(Fixnum, *Fixnum) -> Fixnum"
+    p5 = t5.to_contract.wrap(self) { |x| x }
+    assert_equal 42, p5.call(42)
+    assert_equal 42, p5.call(42, 43)
+    assert_equal 42, p5.call(42, 43, 44)
+    assert_equal 42, p5.call(42, 43, 44, 45)
+    assert_raises(TypeError) { p5.call }
+    assert_raises(TypeError) { p5.call("42") }
+    assert_raises(TypeError) { p5.call(42, "43") }
+    assert_raises(TypeError) { p5.call(42, 43, "44") }
+    assert_raises(TypeError) { p5.call(42, 43, 44, "45") }
+
+    t6 = @p.scan_str "(Fixnum, ?Fixnum, ?Fixnum, *Fixnum) -> Fixnum"
+    p6 = t6.to_contract.wrap(self) { |x| x }
+    assert_equal 42, p6.call(42)
+    assert_equal 42, p6.call(42, 43)
+    assert_equal 42, p6.call(42, 43, 44)
+    assert_equal 42, p6.call(42, 43, 44, 45)
+    assert_equal 42, p6.call(42, 43, 44, 45, 46)
+    assert_raises(TypeError) { p6.call }
+    assert_raises(TypeError) { p6.call("42") }
+    assert_raises(TypeError) { p6.call(42, "43") }
+    assert_raises(TypeError) { p6.call(42, 43, "44") }
+    assert_raises(TypeError) { p6.call(42, 43, 44, "45") }
+    assert_raises(TypeError) { p6.call(42, 43, 44, 45, "46") }
+
+    t7 = @p.scan_str "(?Fixnum) -> nil"
+    p7 = t7.to_contract.wrap(self) { nil }
+    assert_nil p7.call
+    assert_nil p7.call(42)
+    assert_raises(TypeError) { p7.call("42") }
+    assert_raises(TypeError) { p7.call(42, 43) }
+    assert_raises(TypeError) { p7.call(42, 43, 44) }
+
+    t8 = @p.scan_str "(*Fixnum) -> nil"
+    p8 = t8.to_contract.wrap(self) { nil }
+    assert_nil p8.call
+    assert_nil p8.call(42)
+    assert_nil p8.call(42, 43)
+    assert_nil p8.call(42, 43, 44)
+    assert_raises(TypeError) { p8.call("42") }
+    assert_raises(TypeError) { p8.call(42, "43") }
+    assert_raises(TypeError) { p8.call(42, 43, "44") }
+
+    t9 = @p.scan_str "(Fixnum arg1, ?Fixnum arg2) -> Fixnum"
+    p9 = t9.to_contract.wrap(self) { |x| x }
+    assert_equal 42, p9.call(42)
+    assert_equal 42, p9.call(42, 43)
+    assert_raises(TypeError) { p9.call(42, 43, 44) }
+    assert_raises(TypeError) { p9.call }
+
+    t10 = @p.scan_str "(?Fixnum, String) -> Fixnum"
+    p10 = t10.to_contract.wrap(self) { |*args| 42 }
+    assert_equal 42, p10.call("44")
+    assert_equal 42, p10.call(43, "44")
+    assert_raises(TypeError) { p10.call() }
+    assert_raises(TypeError) { p10.call(43, "44", 45) }
+  end
+
+  def test_proc_names
+    t1 = @p.scan_str "(x: Fixnum) -> Fixnum"
+    p1 = t1.to_contract.wrap(self) { |x:| x }
+    assert_equal 42, p1.call(x: 42)
+    assert_raises(TypeError) { p1.call(x: "42") }
+    assert_raises(TypeError) { p1.call() }
+    assert_raises(TypeError) { p1.call(x: 42, y: 42) }
+    assert_raises(TypeError) { p1.call(y: 42) }
+    assert_raises(TypeError) { p1.call(42) }
+    assert_raises(TypeError) { p1.call(42, x: 42) }
+    t2 = @p.scan_str "(x: Fixnum, y: String) -> Fixnum"
+    p2 = t2.to_contract.wrap(self) { |x:,y:| x }
+    assert_equal 42, p2.call(x: 42, y: "33")
+    assert_raises(TypeError) { p2.call() }
+    assert_raises(TypeError) { p2.call(x: 42) }
+    assert_raises(TypeError) { p2.call(x: "42", y: "33") }
+    assert_raises(TypeError) { p2.call(42, "43") }
+    assert_raises(TypeError) { p2.call(42, x: 42, y: "33") }
+    assert_raises(TypeError) { p2.call(x: 42, y: "33", z: 44) }
+    t3 = @p.scan_str "(Fixnum, y: String) -> Fixnum"
+    p3 = t3.to_contract.wrap(self) { |x, y:| x }
+    assert_equal 42, p3.call(42, y:"43")
+    assert_raises(TypeError) { p3.call(42) }
+    assert_raises(TypeError) { p3.call(42, y: 43) }
+    assert_raises(TypeError) { p3.call() }
+    assert_raises(TypeError) { p3.call(42, 43, y: 44) }
+    assert_raises(TypeError) { p3.call(42, y: 43, z: 44) }
+    t4 = @p.scan_str "(Fixnum, x: Fixnum, y: String) -> Fixnum"
+    p4 = t4.to_contract.wrap(self) { |a, x:, y:| a }
+    assert_equal 42, p4.call(42, x: 43, y: "44")
+    assert_raises(TypeError) { p4.call(42, x: 43) }
+    assert_raises(TypeError) { p4.call(42, y: "43") }
+    assert_raises(TypeError) { p4.call() }
+    assert_raises(TypeError) { p4.call(42, 43, x: 44, y: "45") }
+    assert_raises(TypeError) { p4.call(42, x: 43, y: "44", z: 45) }
+    t5 = @p.scan_str "(x: Fixnum, y: ?String) -> Fixnum"
+    p5 = t5.to_contract.wrap(self) { |x:, **ys| x }
+    assert_equal 42, p5.call(x: 42, y: "43")
+    assert_equal 42, p5.call(x: 42)
+    assert_raises(TypeError) { p5.call() }
+    assert_raises(TypeError) { p5.call(x: 42, y: 43) }
+    assert_raises(TypeError) { p5.call(x: 42, y: 43, z: 44) }
+    assert_raises(TypeError) { p5.call(3, x: 42, y: 43) }
+    assert_raises(TypeError) { p5.call(3, x: 42) }
+    t6 = @p.scan_str "(x: ?Fixnum, y: String) -> Fixnum"
+    p6 = t6.to_contract.wrap(self) { |y:, **xs| 42 }
+    assert_equal 42, p6.call(x: 43, y: "44")
+    assert_equal 42, p6.call(y: "44")
+    assert_raises(TypeError) { p6.call() }
+    assert_raises(TypeError) { p6.call(x: "43", y: "44") }
+    assert_raises(TypeError) { p6.call(42, x: 43, y: "44") }
+    assert_raises(TypeError) { p6.call(x: 43, y: "44", z: 45) }
+    t7 = @p.scan_str "(x: ?Fixnum, y: ?String) -> Fixnum"
+    p7 = t7.to_contract.wrap(self) { |**args| 42 }
+    assert_equal 42, p7.call()
+    assert_equal 42, p7.call(x: 43)
+    assert_equal 42, p7.call(y: "44")
+    assert_equal 42, p7.call(x: 43, y: "44")
+    assert_raises(TypeError) { p7.call(x: "43", y: "44") }
+    assert_raises(TypeError) { p7.call(41, x: 43, y: "44") }
+    assert_raises(TypeError) { p7.call(x: 43, y: "44", z: 45) }
+    t8 = @p.scan_str "(?Fixnum, x: ?Symbol, y: ?String) -> Fixnum"
+    p8 = t8.to_contract.wrap(self) { |*args| 42 }
+    assert_equal 42, p8.call()
+    assert_equal 42, p8.call(43)
+    assert_equal 42, p8.call(x: :foo)
+    assert_equal 42, p8.call(43, x: :foo)
+    assert_equal 42, p8.call(y: "foo")
+    assert_equal 42, p8.call(43, y: "foo")
+    assert_equal 42, p8.call(x: :foo, y: "foo")
+    assert_equal 42, p8.call(43, x: :foo, y: "foo")
+    assert_raises(TypeError) { p8.call(43, 44, x: :foo, y: "foo") }
+    assert_raises(TypeError) { p8.call(43, x: "foo", y: "foo") }
+    assert_raises(TypeError) { p8.call(43, x: :foo, y: "foo", z: 44) }
+  end
+end