facets 3.0.0 → 3.2.0

data/test/core/integer/test_even.rb

@@ -1,24 +0,0 @@
-covers 'facets/integer/even'
-
-# NOTE: Can't test on Integer directly b/c Ruby 1.8.7 defines separate
-# methods for Fixnum. (huh?)
-test_case Fixnum do
-
-  method :even? do
-
-    test "even numbers are even" do
-      (-100..100).step(2) do |n|
-        n.even?.assert == true
-      end
-    end
-
-    test "odd numbers are not even" do
-      (-101..101).step(2) do |n|
-        n.even?.assert == false
-      end
-    end
-
-  end
-
-end
-

data/test/core/integer/test_factorial.rb

@@ -1,30 +0,0 @@
-covers 'facets/integer/factorial'
-
-test_case Integer do
-
-  method :factorial do
-
-    test do
-      0.factorial.assert == 1
-      1.factorial.assert == 1
-      2.factorial.assert == 2
-      3.factorial.assert == 6
-      4.factorial.assert == 24
-    end
-
-  end
-
-  method :fac do
-
-    test do
-      0.fac.assert == 1
-      1.fac.assert == 1
-      2.fac.assert == 2
-      3.fac.assert == 6
-      4.fac.assert == 24
-    end
-
-  end
-
-end
-

data/test/core/integer/test_multiple.rb

@@ -1,16 +0,0 @@
-covers 'facets/integer/multiple'
-
-test_case Integer do
-
-  method :multiple? do
-
-    test do
-      assert( ! 1.multiple?(2) )
-      assert(   2.multiple?(2) )
-      assert( ! 5.multiple?(3) )
-      assert(   6.multiple?(3) )
-    end
-
-  end
-
-end

data/test/core/integer/test_odd.rb

@@ -1,24 +0,0 @@
-covers 'facets/integer/odd'
-
-# NOTE: Can't test on Integer directly b/c Ruby 1.8.7 defines separate
-# methods for Fixnum. (huh?)
-test_case Fixnum do
-
-  method :odd? do
-
-    test "odd numbers are odd" do
-      (-101..101).step(2) do |n|
-        n.odd?.assert == true
-      end
-    end
-
-    test "odd numbers are not even" do
-      (-100..100).step(2) do |n|
-        n.odd?.assert == false
-      end
-    end
-
-  end
-
-end
-

data/test/core/integer/test_of.rb

@@ -1,36 +0,0 @@
-covers 'facets/integer/of'
-
-test_case Integer do
-
-  method :of do
-
-    test do
-      a = 4
-      b = a.of{ |i| i*2 }
-      b.assert == [0,2,4,6]
-    end
-
-  end
-
-  method :times_collect do
-
-    test do
-      a = 4
-      b = a.times_collect{ |i| i*2 }
-      b.assert == [0,2,4,6]
-    end
-
-  end
-
-  method :times_map do
-
-    test do
-      a = 4
-      b = a.times_map{ |i| i*2 }
-      b.assert == [0,2,4,6]
-    end
-
-  end
-
-end
-

data/test/core/integer/test_ordinal.rb

@@ -1,27 +0,0 @@
-covers 'facets/integer/ordinal'
-
-test_case Integer do
-
-  method :ordinal do
-
-    test do
-      1.ordinal.assert == '1st'
-      2.ordinal.assert == '2nd'
-      3.ordinal.assert == '3rd'
-      4.ordinal.assert == '4th'
-    end
-
-  end
-
-  method :ordinalize do
-
-    test do
-      1.ordinalize.assert == '1st'
-      2.ordinalize.assert == '2nd'
-      3.ordinalize.assert == '3rd'
-      4.ordinalize.assert == '4th'
-    end
-
-  end
-
-end

data/test/core/kernel/test_as.rb

@@ -1,74 +0,0 @@
-covers 'facets/kernel/as'
-
-test_case Kernel do
-
-  setup "class heirarchy" do
-    a = Class.new do
-      def x; "a.x"; end
-      def y; "a.y"; end
-    end
-    b = Class.new(a) do
-      def x; "b.x" end
-      def y; "b.y" end
-    end
-    c = Class.new(b) do
-      def x; "c.x"; end
-      define_method(:y){ as(a).x }
-    end
-    @a, @b, @c = a, b, c
-  end
-
-  method :as do 
-
-    test do
-      o = @c.new
-      o.x.assert == "c.x"
-      o.y.assert == "a.x"
-    end
-
-  end
-
-  method :send_as do
-
-    test do
-      s = "a"
-      def s.class; nil; end
-      s.class.refute == String
-      s.send_as(Object, :class).assert == String
-    end
-
-  end
-
-  #setup "class heirarchy" do
-  #  x = Class.new{ def x ; 1 ; end }
-  #  y = Class.new(x){ def x ; 2 ; end }
-  #  z = Class.new(y){ define_method(:x){ super_as(x) } }
-  #  z
-  #end
-
-  #method :super_as do |z|
-  #  o = z.new
-  #  o.x.assert == 1
-  #end
-
-end
-
-test_case As do
-
-  class_method :new do
-
-    setup do
-      @c = Class.new(String) do
-             def to_s; "denied"; end
-           end
-    end
-
-    test do
-      o = @c.new("hi")
-      o.to_s.assert == "denied"
-      As.new(o, String).to_s.assert == "hi"
-    end
-
-  end
-
-end

data/test/core/kernel/test_ask.rb

@@ -1,9 +0,0 @@
-covers 'facets/kernel/ask'
-
-test_case Kernel do
-
-  # requires user input
-  method :ask do
-  end
-
-end

data/test/core/kernel/test_assign.rb

@@ -1,61 +0,0 @@
-covers 'facets/kernel/assign'
-
-test_case Kernel do
-
-  method :assign do
-
-    setup do
-      @c = Struct.new(:name, :address, :zip)
-    end
-
-    test "with arguments" do
-      bob = @c.new
-
-      bob.assign(:name, "Bob Sawyer")
-      bob.assign(:address, "123 Maple, Anytown NC")
-      bob.assign(:zip, 12345)
-
-      bob.name.assert == "Bob Sawyer"
-      bob.address.assert == "123 Maple, Anytown NC"
-      bob.zip.assert == 12345
-    end
-
-    test "with hash" do
-      bob = @c.new
-
-      x = { :name => "Bob Sawyer", :address => "123 Maple, Anytown NC", :zip => 12345 }
-
-      bob.assign(x)
-
-      bob.name.assert == x[:name]
-      bob.address.assert == x[:address]
-      bob.zip.assert == x[:zip]
-    end
-
-    test "with associative array" do
-      bob = @c.new
-
-      x = [[:name, "Bob Sawyer"], [:address, "123 Maple, Anytown NC"], [:zip, 12345]]
-
-      bob.assign(x)
-
-      bob.name.assert == "Bob Sawyer"
-      bob.address.assert == "123 Maple, Anytown NC"
-      bob.zip.assert == 12345
-    end
-
-    #test "with block" do
-    #  bob = @c.new
-    #
-    #  x = lambda {|s| s.name = "Bob Sawyer"; s.address = "123 Maple, Anytown NC"; s.zip = 12345 }
-    #
-    #  bob.assign(&x)
-    #
-    #  bob.name.assert == "Bob Sawyer"
-    #  bob.address.assert == "123 Maple, Anytown NC"
-    #  bob.zip.assert == 12345
-    #end
-
-  end
-
-end

data/test/core/kernel/test_assign_from.rb

@@ -1,48 +0,0 @@
-covers 'facets/kernel/assign_from'
-
-test_case Kernel do
-
-  c = Struct.new(:name, :address, :zip)
-
-  method :assign_from do
-
-    test do
-      bob = c.new("Bob Sawyer", "123 Maple, Anytown NC", 12345)
-      joe = c.new("Joe Pitare")
-
-      joe.assign_from(bob, :address, :zip)
-
-      joe.name.assert == "Joe Pitare"
-      joe.address. == "123 Maple, Anytown NC"
-      joe.zip.assert == 12345
-    end
-
-  end
-
-  method :assign_from do
-
-    c1 = Class.new do
-      attr_accessor :a
-      attr_accessor :b
-    end
-
-    c2 = Class.new do
-      attr_accessor :a
-      attr_accessor :b
-    end
-
-    test do
-      o1 = c1.new
-      o1.a = 1
-      o1.b = 2
-
-      o2 = c2.new
-      o2.assign_from(o1, :a, :b)
-
-      o2.a.assert == 1
-      o2.b.assert == 2
-    end
-
-  end
-
-end

data/test/core/kernel/test_attr_singleton.rb

@@ -1,51 +0,0 @@
-covers 'facets/kernel/attr_singleton'
-
-test_case Kernel do
-
-  c = Class.new do
-    def initialize
-      attr_singleton_reader :foo #=> "FOO"
-      attr_singleton_writer :bar #=> "BAR"
-      attr_singleton_accessor :baz #=> "BAZ"
-      @foo = "FOO"
-      self.bar = "BAR"
-      self.baz = "BAZ"
-    end
-    def get_bar
-      @bar
-    end
-  end
-
-  method :attr_singleton_reader do
-
-    test do
-      t = c.new
-      t.foo.assert == "FOO"
-    end
-
-  end
-
-  method :attr_singleton_writer do
-
-    test do
-      t = c.new
-      t.get_bar.assert == "BAR"
-      t.bar = "BAR2"
-      t.get_bar.assert == "BAR2"
-    end
-
-  end
-
-  method :attr_singleton_accessor do
-
-    test do
-      t = c.new
-      t.baz.assert == "BAZ"
-      t.baz = "BAZ2"
-      t.baz.assert == "BAZ2"
-    end
-
-  end
-
-end
-

data/test/core/kernel/test_blank.rb

@@ -1,103 +0,0 @@
-covers 'facets/kernel/blank'
-
-# NOTE: Using x.assert.blank? here caused AE some issues
-# b/c of problems with Assertor. Basically Assertor needs
-# to subclass BasicObject, but Ruby 1.9 has constant lookup
-# issues with BasicObject that need address. So in this case
-# we'll just use the old-school `assert foo` syntax.
-
-test_case Kernel do
-
-  method :blank? do
-    test do
-      refute Object.new.blank?
-    end
-  end
-
-end
-
-test_case NilClass do
-
-  method :blank? do
-    test do
-      assert nil.blank?
-    end
-  end
-
-end
-
-test_case FalseClass do
-
-  method :blank? do
-    test do
-      assert false.blank?
-    end
-  end
-
-end
-
-test_case TrueClass do
-
-  method :blank? do
-    test do
-      refute true.blank?
-    end
-  end
-
-end
-
-test_case Array do
-
-  method :blank? do
-    test do
-      assert [].blank?
-      refute [1].blank?
-    end
-  end
-
-end
-
-test_case Hash do
-
-  method :blank? do
-    test do
-      assert( {}.blank? )
-      refute( {:a=>1}.blank? )
-    end
-  end
-
-end
-
-test_case String do
-
-  method :blank? do
-    test do
-      refute "xyz".blank?
-      assert "   ".blank?
-    end
-  end
-
-end
-
-test_case Numeric do
-
-  method :blank? do
-    test do
-      refute 0.blank?
-    end
-  end
-
-  method :blank? do
-    test do
-      refute 10.blank?
-    end
-  end
-
-  method :blank? do
-    test do
-      refute 10.0.blank?
-    end
-  end
-
-end
-

data/test/core/kernel/test_callstack.rb

@@ -1,21 +0,0 @@
-covers 'facets/kernel/callstack'
-
-test_case Kernel do
-
-  method :call_stack do
-
-    test do
-      call_stack
-    end
-
-  end
-
-  method :callstack do
-
-    test do
-      callstack
-    end
-
-  end
-
-end

data/test/core/kernel/test_class.rb

@@ -1,14 +0,0 @@
-covers 'facets/kernel/__class__'
-
-test_case Kernel do
-
-  method :__class__ do
-
-    test do
-      o = Object.new
-      o.__class__.assert == o.class
-    end
-
-  end
-
-end

data/test/core/kernel/test_complete.rb

@@ -1,19 +0,0 @@
-covers 'facets/kernel/complete'
-
-test_case Kernel do
-
-  method :complete do
-
-    test do
-      a = []
-      i = 0
-      complete do
-        i += 1
-        i == 3 ? nil : a << i
-      end
-      a.assert == [1,2]
-    end
-
-  end
-
-end

data/test/core/kernel/test_constant.rb

@@ -1,18 +0,0 @@
-covers 'facets/kernel/constant'
-
-test_case Kernel do
-
-  method :constant do
-
-    test do
-      c = ::Lemon::TestCase.name
-      constant(c).assert == ::Lemon::TestCase
-
-      c = "TestCase"
-      ::Lemon.constant(c).assert == ::Lemon::TestCase
-    end
-
-  end
-
-end
-

data/test/core/kernel/test_d.rb

@@ -1,10 +0,0 @@
-covers 'facets/kernel/d'
-
-test_case Kernel do
-
-  # TODO: how to test #d silently? Need to redirect $stderr.
-
-  method :d do
-  end
-
-end

data/test/core/kernel/test_deep_clone.rb

@@ -1,31 +0,0 @@
-covers 'facets/kernel/deep_clone'
-
-test_case Kernel do
-
-  method :deep_clone do
-
-    setup "a class with reference to another class" do
-      xC = Class.new do
-        attr_reader :x
-        def initialize
-          @x = 1
-        end
-      end
-
-      @c = Class.new do
-        attr_reader :y
-        define_method(:initialize) do
-          @y = xC.new
-        end
-      end
-    end
-
-    test do
-      o = @c.new
-      d = o.deep_clone
-      d.y.x.assert == 1
-    end
-
-  end
-
-end

data/test/core/kernel/test_deep_copy.rb

@@ -1,15 +0,0 @@
-covers 'facets/kernel/deep_copy'
-
-test_case Kernel do
-
-  method :deep_copy do
-
-    test do
-      o = "This is a weak test."
-      d = o.deep_copy
-      d.assert == "This is a weak test."
-    end
-
-  end
-
-end

data/test/core/kernel/test_dir.rb

@@ -1,24 +0,0 @@
-covers 'facets/kernel/__dir__'
-
-test_case Kernel do
-
-  # TODO: can't test b/c somehow Lemon intefers with the call stack
-  # which __DIR__ uses to locate the current running file.
-
-  method :__DIR__ do
-
-    omit "issue with call stack" do
-
-      test "relative directory" do
-        __DIR__.assert == File.dirname(__FILE__)
-      end
-
-      test  "relative directory joins with arguments" do
-        __DIR__('tmp').assert == File.join(File.dirname(__FILE__), 'tmp')
-      end
-
-    end
-
-  end
-
-end