facets-glimmer 3.2.0

data/test/core/module/test_rename_method.rb

@@ -0,0 +1,34 @@
+covers 'facets/module/rename_method'
+
+test_case Module do
+
+  method :rename_method do
+
+    test do
+      c = Class.new do
+        def a; "A" ; end
+        rename_method :b, :a
+      end
+
+      c.new.refute.respond_to?(:a)
+      c.new.assert.respond_to?(:b)
+    end
+
+  end
+
+  method :rename do
+
+    test do
+      c = Class.new do
+        def c; "C" ; end
+        rename :d, :c
+      end
+
+      c.new.refute.respond_to?(:c)
+      c.new.assert.respond_to?(:d)
+    end
+
+  end
+
+end
+

data/test/core/module/test_revise.rb

@@ -0,0 +1,61 @@
+covers 'facets/module/revise'
+
+test_case Module do
+
+  method :revisal do
+
+    test do
+      m = Module.new do
+        def x ; 1 ; end
+      end
+
+      c = Class.new do
+        include m.revisal {
+          rename :y, :x
+        }
+      end
+
+      ic = c.new
+
+      ic.y.assert == 1
+      NoMethodError.assert.raised?{ ic.x }
+    end
+
+  end
+
+  method :revise do
+
+    test do
+      m = Module.new do
+        def x ; 1 ; end
+      end
+
+      c = Class.new do
+        include m.revise {
+          rename :y, :x
+        }
+      end
+
+      ic = c.new
+
+      ic.y.assert == 1
+      NoMethodError.assert.raised?{ ic.x }
+    end
+
+  end
+
+  method :remove do
+
+    test do
+      c = Class.new do
+        def the_removed_method ; 'not here' ; end
+        remove :the_removed_method
+      end
+
+      c.new.refute.respond_to?(:the_removed_method)
+    end
+
+  end
+
+end
+

data/test/core/module/test_set.rb

@@ -0,0 +1,30 @@
+covers 'facets/module/set'
+
+test_case Module do
+
+  method :set do
+
+    test do
+      c = Class.new do
+        set :x, 10
+      end
+
+      c.x.assert == 10
+    end
+
+    test do
+      h = 1
+      c = Class.new do
+        set :x do 
+          h += 1
+        end
+      end
+
+      c.x.assert == 2
+      c.x.assert == 3
+      c.x.assert == 4
+    end
+
+  end
+
+end

data/test/core/module/test_spacename.rb

@@ -0,0 +1,15 @@
+covers 'facets/module/spacename'
+
+test_case Module do
+
+  method :spacename do
+
+    test do
+      Lemon::TestCase.spacename.assert == 'Lemon'
+      Lemon.spacename.assert == ''  # should this be nil ?
+    end
+
+  end
+
+end
+

data/test/core/module/test_to_obj.rb

@@ -0,0 +1,20 @@
+covers 'facets/module/to_obj'
+
+test_case Module do
+
+  method :to_obj do
+
+    test do
+      m = Module.new do
+        def x; "x"; end
+        def y; "y"; end
+      end
+      o = m.to_obj
+      o.x.assert == "x"
+      o.y.assert == "y"
+    end
+
+  end
+
+end
+

data/test/core/module/test_wrap_method.rb

@@ -0,0 +1,32 @@
+covers 'facets/module/wrap_method'
+
+test_case Module do
+
+  method :wrap_method do
+
+    test do
+      c = Class.new do
+        def a; "A"; end
+        wrap_method(:a) { |old| old.call + "B" }
+      end
+
+      c.new.a.assert == "AB"
+    end
+
+  end
+
+  method :wrap do
+
+    test do
+      c = Class.new do
+        def b; "B"; end
+        wrap(:b) { |old| old.call + "C" }
+      end
+
+      c.new.b.assert == "BC"
+    end
+
+  end
+
+end
+

data/test/core/numeric/test_approx.rb

@@ -0,0 +1,26 @@
+covers 'facets/numeric/approx'
+
+test_case Numeric do
+
+  method :approx? do
+
+    test do
+      f = 10.006
+      assert( f.approx?(10, 0.1) )
+      assert( 100.4.approx?(100.6, 1) )
+    end
+
+  end
+
+  method :close? do
+
+    test do
+      f = 10.006
+      assert( f.close?(10, 0.1) )
+      assert( 100.4.close?(100.6, 1) )
+    end
+
+  end
+
+end
+

data/test/core/numeric/test_delimit.rb

@@ -0,0 +1,68 @@
+covers 'facets/numeric/delimit'
+
+test_case Numeric do
+
+  f0 = [ 0, 100, 1_000, 1_000_000 ]
+
+  method :delimit do
+
+    test "commas are default" do
+      fr = f0.map { |f| f.delimit }
+      fr.assert == %w( 0 100 1,000 1,000,000 )
+    end
+
+    test "delimiter can be anything" do
+      fr = f0.map { |f| f.delimit(:delimiter => "_") }
+      fr.assert == %w( 0 100 1_000 1_000_000 )
+    end
+
+    test "separator defaults to dot" do
+      fr = f0.map { |f| ( f + 0.1 ).delimit }
+      fr.assert == %w( 0.1 100.1 1,000.1 1,000,000.1 )
+    end
+
+    test "separator can be anything" do
+      fr = f0.map { |f| ( f + 0.1 ).delimit(:separator => "!") }
+      fr.assert == %w( 0!1 100!1 1,000!1 1,000,000!1 )
+    end
+
+
+  end
+
+end
+
+=begin
+test_case Float do
+
+  f1 = [ 10.1, 10.01, 10.9, 10.09, 10.5, 10.05, 10.49 ]
+
+  # method :round_at do
+  #
+  #   test "1" do
+  #     fr = f1.collect { |f| f.round_at(1) }
+  #     fr.assert == [10.1,10.0,10.9,10.1,10.5,10.1,10.5]
+  #   end
+  #
+  #   test "2" do
+  #     fr = f1.collect { |f| f.round_at(2) }
+  #     fr.assert == [10.1,10.01,10.9,10.09,10.5,10.05,10.49]
+  #   end
+  #
+  # end
+
+  method :round_to do
+
+    test "0.1" do
+      fr = f1.collect { |f| f.round_to(0.1) }
+      fr.assert == [10.1,10.0,10.9,10.1,10.5,10.1,10.5]
+    end
+
+    test "10" do
+      fr = f1.collect { |f| f.round_to(10) }
+      fr.assert == [10,10,10,10,10,10,10]
+    end
+
+  end
+
+end
+=end

data/test/core/numeric/test_distance.rb

@@ -0,0 +1,16 @@
+covers 'facets/numeric/distance'
+
+test_case Numeric do
+
+  method :distance do
+
+    test do
+      10.distance(6).assert == 4
+      10.distance(8).assert == 2
+       7.distance(9).assert == -2
+    end
+
+  end
+
+end
+

data/test/core/numeric/test_length.rb

@@ -0,0 +1,16 @@
+covers 'facets/numeric/length'
+
+test_case Numeric do
+
+  method :length do
+
+    test do
+      (0..10).each do |power|
+        power.length.assert == power
+      end
+    end
+
+  end
+
+end
+

data/test/core/numeric/test_round_to.rb

@@ -0,0 +1,76 @@
+covers 'facets/numeric/round_to'
+
+test_case Numeric do
+
+  f0 = [ 0, 10, 15, 105 ]
+
+  # method :round_at do
+  #
+  #   test "1" do
+  #     fr = f0.collect{ |f| f.round_at(1) }
+  #     fr.assert == [0,10,15,105]
+  #   end
+  #
+  #   test "2" do
+  #     fr = f0.collect { |f| f.round_at(2) }
+  #     fr.assert == [0,10,15,105]
+  #   end
+  #
+  # end
+
+  method :round_to do
+
+    test "0.1" do
+      fr = f0.collect { |f| f.round_to(0.1) }
+      fr.assert == [0,10,15,105]
+    end
+
+    test "10" do
+      fr = f0.collect { |f| f.round_to(10) }
+      fr.assert == [0,10,20,110]
+    end
+
+  end
+
+  #method :round_off do
+  #  test do
+  #    1.2.round_off.assert == 1.0
+  #    1.8.round_off.assert == 2.0
+  #  end
+  #end
+
+end
+
+test_case Float do
+
+  f1 = [ 10.1, 10.01, 10.9, 10.09, 10.5, 10.05, 10.49 ]
+
+  # method :round_at do
+  #
+  #   test "1" do
+  #     fr = f1.collect { |f| f.round_at(1) }
+  #     fr.assert == [10.1,10.0,10.9,10.1,10.5,10.1,10.5]
+  #   end
+  #
+  #   test "2" do
+  #     fr = f1.collect { |f| f.round_at(2) }
+  #     fr.assert == [10.1,10.01,10.9,10.09,10.5,10.05,10.49]
+  #   end
+  #
+  # end
+
+  method :round_to do
+
+    test "0.1" do
+      fr = f1.collect { |f| f.round_to(0.1) }
+      fr.assert == [10.1,10.0,10.9,10.1,10.5,10.1,10.5]
+    end
+
+    test "10" do
+      fr = f1.collect { |f| f.round_to(10) }
+      fr.assert == [10,10,10,10,10,10,10]
+    end
+
+  end
+
+end

data/test/core/numeric/test_spacing.rb

@@ -0,0 +1,17 @@
+covers 'facets/numeric/spacing'
+
+test_case Numeric do
+
+  method :spacing do
+
+    test do
+      samples = [-10.5, -3, 3, 1.0e14, 10000, 14.5e10]
+      samples.each do |numeric_item|
+        numeric_item.spacing.assert == numeric_item.to_s.size
+        numeric_item.spacing.assert.kind_of?(Integer)
+      end
+    end
+
+  end
+
+end

data/test/core/object/test_dup.rb

@@ -0,0 +1,115 @@
+covers 'facets/object/dup'
+
+# TODO: Improve object/dup tests.
+
+test_case Object do
+  setup "ordinary object" do
+    @o = Object.new
+  end
+
+  method :dup? do
+    test { assert @o.dup? }
+  end
+
+  method :clone? do
+    test { assert @o.clone? }
+  end
+
+  method :dup! do
+    test { assert @o.dup! }
+  end
+
+  method :try_dup do |o|
+    test { assert @o.try_dup }
+  end
+end
+
+test_case TrueClass do
+  method :dup? do
+    test { refute true.dup? }
+  end
+
+  method :clone? do
+    test { refute true.clone? }
+  end
+
+  method :dup! do
+    test { assert true.dup! }
+  end
+
+  method :try_dup do
+    test { assert true.try_dup }
+  end
+end
+
+test_case FalseClass do
+  method :dup? do
+    test { refute false.dup? }
+  end
+
+  method :clone? do
+    test { refute false.clone? }
+  end
+
+  method :dup! do
+    test { false.dup!.assert == false }
+  end
+
+  method :try_dup do
+    test { false.try_dup.assert == false }
+  end
+end
+
+test_case NilClass do
+  method :dup? do
+    test { refute nil.dup? }
+  end
+
+  method :clone? do
+    test { refute nil.clone? }
+  end
+
+  method :dup! do
+    test { nil.dup!.assert == nil }
+  end
+
+  method :try_dup do
+    test { nil.try_dup.assert == nil }
+  end
+end
+
+test_case Symbol do
+  method :dup? do
+    test { refute :a.dup? }
+  end
+
+  method :clone? do
+    test { refute :a.clone? }
+  end
+
+  method :dup! do
+    test { :a.dup!.assert == :a }
+  end
+
+  method :try_dup do
+    test { :a.try_dup.assert == :a }
+  end
+end
+
+test_case Numeric do
+  method :dup? do
+    test { refute 1.dup? }
+  end
+
+  method :clone? do
+    test { refute 1.clone? }
+  end
+
+  method :dup! do
+    test { 1.dup!.assert == 1 }
+  end
+
+  method :try_dup do
+    test { 1.try_dup.assert == 1 }
+  end
+end

data/test/core/object/test_object_state.rb

@@ -0,0 +1,75 @@
+covers 'facets/object/object_state'
+
+test_case Object do
+  method :object_state do
+    test do
+      c = Class.new do
+        def initialize(a,b)
+          @a, @b = a, b
+        end
+      end
+      o = c.new(1,2)
+      s = o.object_state
+      s.assert == {:a=>1, :b=>2}
+    end
+  end
+end
+
+test_case Struct do
+  method :object_state do
+    test do
+      c = Struct.new(:a, :b)
+      o = c.new(1,2)
+      s = o.object_state
+      s.assert == {:a=>1, :b=>2}
+    end
+  end
+end
+
+test_case Array do
+  method :object_state do
+    test do
+      a = [1,2,3,4]
+      s = a.object_state
+      s.assert == a
+    end
+  end
+end
+
+test_case Hash do
+  method :object_state do
+    test do
+      h = {:a=>1,:b=>2,:c=>3}
+      s = h.object_state
+      s.assert == h
+    end
+  end
+end
+
+test_case String do
+  method :object_state do
+    test do
+      t = "test string"
+      s = t.object_state
+      s.assert == t
+    end
+  end
+end
+
+#test_case Kernel do
+#
+#  method :object_state do
+#    test do
+#      c = Class.new do
+#        def initialize(a,b)
+#          @a, @b = a, b
+#        end
+#      end
+#      o = c.new(1,2)
+#      s = o.object_state
+#      s.assert == {:a=>1, :b=>2}
+#    end
+#  end
+#
+#end
+

data/test/core/object/test_try_dup.rb

@@ -0,0 +1,59 @@
+covers 'facets/object/try_dup'
+
+test_case Object do
+  method :try_dup do
+    test do
+      obj1 = Object.new
+      obj2 = obj1.try_dup
+      obj2.equal?(obj1).assert == false
+    end
+  end
+
+  method :dup! do
+    test "is an alias for #try_dup" do
+      obj1 = Object.new
+      obj2 = obj1.dup!
+      obj2.equal?(obj1).assert == false
+    end
+  end
+end
+
+test_case TrueClass do
+  method :try_dup do
+    test do
+      true.try_dup.assert == true
+    end
+  end
+end
+
+test_case FalseClass do
+  method :try_dup do
+    test do
+      false.try_dup.assert == false
+    end
+  end
+end
+
+test_case NilClass do
+  method :try_dup do
+    test do
+      nil.try_dup.assert == nil
+    end
+  end
+end
+
+test_case Numeric do
+  method :try_dup do
+    test do
+      10.try_dup.assert == 10
+    end
+  end
+end
+
+test_case Symbol do
+  method :try_dup do
+    test do
+      :A.try_dup.assert == :A
+    end
+  end
+end

data/test/core/proc/test_bind.rb

@@ -0,0 +1,29 @@
+covers 'facets/proc/bind'
+
+test_case Proc do
+
+  # Not sure why this is thread critical?
+  method :bind do
+    test "thread critial" do
+      a = 2
+      tproc = lambda { |x| x + a }
+      99.times {
+        tmethod = tproc.bind(self) #to_method
+        tmethod.call(1).assert == 3
+      }
+
+      meths = (
+        Object.instance_methods +
+        Object.public_instance_methods +
+        Object.private_instance_methods +
+        Object.protected_instance_methods
+      )
+      meths = meths.select{ |s| s.to_s =~ /^_bind_/ }
+      #meths = Symbol.all_symbols.select { |s| s.to_s =~ /^_bind_/ }  # why?
+
+      meths.size.assert == 0
+    end
+
+  end
+
+end