facets 3.1.0 → 3.2.0

data/test/standard/test_multipliers.rb

@@ -1,141 +0,0 @@
-covers 'facets/multipliers'
-
-test_case Fixnum do
-
-  method :deka do
-    test do
-      1.deka.assert == 10
-    end
-  end
-
-  method :hecto do
-    test do
-      1.hecto.assert == 100
-    end
-  end
-
-  method :kilo do
-    test do
-      1.kilo.assert == 1000
-    end
-  end
-
-  method :mega do
-    test do
-      1.mega.assert == 1000000
-    end
-  end
-
-  method :giga do
-    test do
-      1.giga.assert == 1000000000
-    end
-  end
-
-  method :tera do
-    test do
-      1.tera.assert == 1000000000000
-    end
-  end
-
-  method :peta do
-    test do
-      1.peta.assert == 1000000000000000
-    end
-  end
-
-  method :exa do
-    test do
-      1.exa.assert == 1000000000000000000
-    end
-  end
-
-  # Fractional
-
-  method :deci do
-    test do
-      1.deci.assert == 0.1
-    end
-  end
-
-  method :centi do
-    test do
-      1.centi.assert == 0.01
-    end
-  end
-
-  method :milli do
-    test do
-      1.milli.assert == 0.001
-    end
-  end
-
-  method :micro do
-    test do
-      1.micro.assert == 0.000001
-    end
-  end
-
-  method :nano do
-    test do
-      1.nano.assert == 0.000000001
-    end
-  end
-
-  method :pico do
-    test do
-      1.pico.assert == 0.000000000001
-    end
-  end
-
-  method :femto do
-    test do
-      1.femto.assert == 0.000000000000001
-    end
-  end
-
-  method :atto do
-    test do
-      1.atto.assert == 0.000000000000000001
-    end
-  end
-
-  # SI Binary
-
-  method :kibi do
-    test do
-      1.kibi.assert == 1024
-    end
-  end
-
-  method :mebi do
-    test do
-      1.mebi.assert == 1024**2
-    end
-  end
-
-  method :gibi do
-    test do
-      1.gibi.assert == 1024**3
-    end
-  end
-
-  method :tebi do
-    test do
-      1.tebi.assert == 1024**4
-    end
-  end
-
-  method :pebi do
-    test do
-      1.pebi.assert == 1024**5
-    end
-  end
-
-  method :exbi do
-    test do
-      1.exbi.assert == 1024**6
-    end
-  end
-
-end

data/test/standard/test_ostruct.rb

@@ -1,191 +0,0 @@
-covers 'facets/ostruct'
-
-test_case OpenStruct do
-
-  method :merge! do
-    test do
-      o = OpenStruct.new(:a => 1)
-      h = { :b => 2 }
-      o.merge!(h)
-      o.b.assert == 2
-    end
-
-    test do
-      o = OpenStruct.new( { :a => 1 } )
-      h = { :b => 2 }
-      o.merge!(h)
-      o.b.assert == 2
-    end
-  end
-
-  method :__merge__ do
-    test do
-      o = OpenStruct.new( { :a => 1 } )
-      h = { :b => 2 }
-      q = o.__merge__( h )
-      q.a.assert == 1
-      q.b.assert == 2
-    end
-
-    test do
-      o1 = OpenStruct.new( { :a => 1 } )
-      o2 = OpenStruct.new( { :b => 2 } )
-      q = o1.__merge__( o2 )
-      q.a.assert == 1
-      q.b.assert == 2
-    end
-
-    test "with_hash" do
-      o = OpenStruct.new( { :a => 1 } )
-      h = { :b => 2 }
-      q = o.__merge__(h)
-      q.a.assert == 1
-      q.b.assert == 2
-    end
-
-    test "two open structs" do
-      o1 = OpenStruct.new( { :a => 1 } )
-      o2 = OpenStruct.new( { :b => 2 } )
-      q = o1.__merge__(o2)
-      q.a.assert == 1
-      q.b.assert == 2
-    end
-  end
-
-  # @deprecated
-  #method :instance_delegate do
-  #  test "store" do
-  #    o = OpenStruct.new(:a => 1)
-  #    o.instance_delegate.store(:a,1)
-  #    o.a.assert == 1
-  #  end
-  #
-  #  test "update" do
-  #    o = OpenStruct.new
-  #    o.instance_delegate.update(:a=>1)
-  #    o.a.assert == 1
-  #  end
-  #end
-
-  method :[] do
-    test do
-      o = OpenStruct.new( { :a => 1 } )
-      o[:a].assert == 1
-    end
-  end
-
-  method :[]= do
-    test do
-      o = OpenStruct.new( { :a => 1 } )
-      o[:b] = 2
-      o.b.assert == 2
-    end
-  end
-
-  class_method :new do
-    test "old functionality" do
-      o = OpenStruct.new
-      o.foo.assert.nil?
-      o.foo = :bar
-      o.foo.assert ==:bar
-      o.delete_field(:foo)
-      o.foo.assert.nil?
-
-      o1 = OpenStruct.new(:x => 1, :z => 2)
-      o1.x.assert == 1
-      o1.z.assert == 2
-
-      o2 = OpenStruct.new(:x => 1, :z => 2)
-      o1.assert == o2
-    end
-
-    test "via block" do
-      person = OpenStruct.new do |p|
-        p.name = 'John Smith'
-        p.gender  = :M
-        p.age     = 71
-      end
-      person.name.assert == 'John Smith'
-      person.gender.assert ==:M
-      person.age.assert == 71
-      person.address.assert ==nil
-    end
-
-    test "via hash and block" do
-      person = OpenStruct.new(:gender => :M, :age => 71) do |p|
-        p.name = 'John Smith'
-      end
-      person.name.assert == 'John Smith'
-      person.gender.assert == :M
-      person.age.assert == 71
-      person.address.assert == nil
-    end
-
-    test "subclass via block" do
-      person_class = Class.new(OpenStruct)
-      person = person_class.new do |p|
-        p.name = 'John Smith'
-        p.gender  = :M
-        p.age     = 71
-      end
-      person.name.assert == 'John Smith'
-      person.gender.assert == :M
-      person.age.assert == 71
-      person.address.assert == nil
-    end
-
-    test "subclass via hash and block" do
-      person_class = Class.new(OpenStruct)
-      person = person_class.new(:gender => :M, :age => 71) do |p|
-        p.name = 'John Smith'
-      end
-      person.name.assert == 'John Smith'
-      person.gender.assert == :M
-      person.age.assert == 71
-      person.address.assert ==nil
-    end
-  end
-
-end
-
-test_case Hash do
-
-  method :to_ostruct do
-
-    test do
-      a = { :a => 1, :b => 2, :c => 3 }
-      ao = a.to_ostruct
-      ao.a.assert == a[:a]
-      ao.b.assert == a[:b]
-      ao.c.assert == a[:c]
-    end
-
-  end
-
-  method :to_ostruct_recurse do
-
-    test do
-      a = { :a => 1, :b => 2, :c => { :x => 4 } }
-      ao = a.to_ostruct_recurse
-      ao.a.assert == a[:a]
-      ao.b.assert == a[:b]
-      ao.c.x.assert == a[:c][:x]
-    end
-
-    test "with recursion" do
-      a = {}
-      a[:a] = a
-      ao = a.to_ostruct_recurse
-      ao.a.assert == ao
-    end
-
-    test "advanced usage" do
-      h = { 'a' => { 'b' => 1 } }
-      o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
-      o.a['b'].assert == 1
-      Hash.assert === o.a
-    end
-
-  end
-
-end

data/test/standard/test_random.rb

@@ -1,241 +0,0 @@
-covers 'facets/random'
-
-test_case Random do
-
-  class_method :letter do
-    test do
-      100.times { |i| /[a-zA-z]/.assert =~ Random.letter }
-    end
-  end
-
-end
-
-test_case Range do
-
-  # helper method
-  def assert_at_rand_table(table)
-    table.each do |x, y|
-      20.times do
-        x.at_rand.assert == y
-      end
-    end
-  end
-
-  # helper method
-  def assert_random_range(range)
-    20.times do 
-      range.assert.include?( range.at_rand )
-    end
-  end
-
-  method :at_rand do
-
-    test "within range" do
-      list = [ 1..4, 1...4, 1.5..2.5, 1.5...2.5, -4..-1, -4...-1,
-               -2.5..-1.5, -2.5...-1.5, 'a'..'d', 'a'...'d' ]
-      list.each{ |rng| assert_random_range(rng) }
-    end
-
-    test "within range special cases" do
-      assert_at_rand_table(
-        (5..5)       => 5,
-        (5...5)      => nil,
-        (5..-1)      => nil,
-        (5.0..5.0)   => 5.0,
-        (5.0...5.0)  => nil,
-        (5.0...-1.0) => nil
-      )
-    end
-
-    test "reverse ranges" do
-      assert_at_rand_table(
-        (4..1) => nil,
-        (4...1) => nil,
-        (-1..-4) => nil,
-        (-1...-4) => nil
-      )
-      #assert((1..4).include?((4..1).at_rand))
-      #assert((-4...-1).include?((-1...-4).at_rand))
-      #assert((-4..-1).include?((-1..-4).at_rand))
-    end
-
-    # I'd rather it return the first sentinel than +nil+.
-    # Really, ruby should be raising an error as an invalid range value.
-    test "exclusive range" do
-      (5...5).at_rand.assert == nil
-      #expect RangeError do
-      #  (5...5).at_rand
-      #end
-    end
-
-  end
-
-end
-
-test_case Array do
-
-  method :at_rand do
-    test do
-      a = [1,2,3,4,5]
-      20.times{ a.assert.include?( a.at_rand ) }
-    end
-  end
-
-  method :at_rand! do
-    test do
-      a = ['a','b','c']
-      a.at_rand!.length.assert == 1
-      a.length.assert == 2
-    end
-  end
-
-  method :pick do
-    test do
-      a = ['a','b','c']
-      a.pick(3).length.assert == 3
-      a.length.assert == 3
-      a = ['a','b','c']
-      a.pick(4).length.assert == 3
-      a.length.assert == 3
-    end
-  end
-
-  method :pick! do
-    test do
-      a = ['a','b','c']
-      a.pick!(3).length.assert == 3
-      a.length.assert == 0
-      a = ['a','b','c']
-      a.pick!(4).length.assert == 3
-      a.length.assert == 0
-    end
-  end
-
-  method :rand_index do
-    test do
-      10.times {
-        i = [1,2,3].rand_index
-        (0..2).assert.include?(i)
-      }
-    end
-  end
-
-  method :rand_subset do
-    test do
-      10.times {
-        a = [1,2,3,4].rand_subset
-        a.size.assert <= 4
-      }
-    end
-  end
-
-  method :shuffle do
-    test do
-      a = [1,2,3,4,5]
-      b = a.shuffle
-      b.sort.assert == a
-    end
-  end
-
-  method :shuffle! do
-    test do
-      a = [1,2,3,4,5]
-      b = a.dup
-      b.shuffle!
-      b.sort.assert == a
-    end
-  end
-
-end
-
-test_case Hash do
-
-  method :rand_key do
-    test do
-      h = { :a=>1, :b=>2, :c=>3 }
-      10.times { h.keys.assert.include?( h.rand_key ) }
-    end
-  end
-
-  method :rand_pair do
-    test do
-      h = { :a=>1, :b=>2, :c=>3 }
-      10.times { k,v = *h.rand_pair; h[k].assert == v }
-    end
-  end
-
-  method :rand_value do
-    test do
-      h = { :a=>1, :b=>2, :c=>3 }
-      10.times { h.values.assert.include?( h.rand_value ) }
-    end
-  end
-
-  method :shuffle do
-    test do
-      h = {:a=>1, :b=>2, :c=>3 }
-      h.shuffle
-    end
-  end
-
-  method :shuffle! do
-    test do
-      h = {:a=>1, :b=>2, :c=>3 }
-      h.shuffle!
-    end
-  end
-
-end
-
-test_case String do
-
-  method :at_rand do
-    test do
-      a = '12345'
-      20.times{ a.assert.include?( a.at_rand ) }
-    end
-  end
-
-  method :at_rand! do
-    test do
-      x = 'ab'
-      r = x.at_rand!
-      assert( r == 'a' || r == 'b' )
-      assert( x == 'a' || x == 'b' )
-    end
-  end
-
-  method :rand_index do
-    test do
-      10.times{ (0..2).assert.include?( 'abc'.rand_index ) }
-    end
-  end
-
-  method :rand_byte do
-    test do
-      2.times do
-        s = 'ab'
-        r = s.rand_byte
-        if RUBY_VERSION > '1.9'
-          assert( r == 'a' || r == 'b' )
-        else
-          assert( r == 97 || r == 98 )
-        end
-      end
-    end
-  end
-
-  method :shuffle do
-    test do
-      "abc 123".shuffle
-      #"abc 123".shuffle!
-    end
-  end
-
-  method :shuffle! do
-    test do
-      "abc 123".shuffle!
-    end
-  end
-
-end

data/test/standard/test_shellwords.rb

@@ -1,74 +0,0 @@
-covers 'facets/shellwords'
-
-test_case Shellwords do
-
-  class_method :shellwords do
-
-    test do
-      cmd = "ruby my_prog.rb | less"
-      Shellwords.shellwords(cmd).assert.instance_of?(Array)
-      Shellwords.shellwords(cmd).length.assert == 4
-    end
-
-    test "unmatched double quote" do
-      bad_cmd = 'one two "three'
-      expect ArgumentError do
-        Shellwords.shellwords(bad_cmd)
-      end
-    end
-
-    test "unmatched single quote" do
-      bad_cmd = "one two 'three"
-      expect ArgumentError do
-        Shellwords.shellwords(bad_cmd)
-      end
-    end
-
-    test "unmatched quotes" do
-      bad_cmd = "one '"'"''""'""
-      expect ArgumentError do
-        Shellwords.shellwords(bad_cmd)
-      end
-    end
-
-  end
-
-end
-
-test_case Array do
-
-  method :shellwords do
-    test do
-      e = ["a", "b"]
-      a = ["a", "b"].shellwords
-      a.assert == e
-    end
-
-    test do
-      e = ["-d", "a", "b"]
-      a = ["a", "b", {:d=>true}].shellwords
-      a.assert == e
-    end
-  end
-
-end
-
-test_case Hash do
-
-  method :shellwords do
-    test do
-      e = ['--debug']
-      a = {:debug=>true}.shellwords
-      a.assert == e
-    end
-
-    test do
-      e = ['--name="jim"', '--debug']
-      a = {:debug=>true, :name=>"jim"}.shellwords
-      a.each do |x|
-        e.assert.include?(x)
-      end
-    end
-  end
-
-end

data/test/standard/test_thread.rb

@@ -1,24 +0,0 @@
-covers 'facets/thread.rb'
-
-test_case Array do
-
-  method :threaded_map do
-    test do
-      r = [1,2,3].threaded_map{ |e| e + 1 }
-      r.assert == [2,3,4]
-    end
-  end
-
-  method :threaded_map_send do
-    test do
-      r = [1,2,3].threaded_map_send(:+, 1)
-      r.assert == [2,3,4]
-    end
-
-    test "with_block" do
-      r = [[1,2,3],[2,3,4],[3,4,5]].threaded_map_send(:select){ |x| x > 2 }
-      r.assert == [[3],[3,4],[3,4,5]]
-    end
-  end
-
-end

data/test/standard/test_timer.rb

@@ -1,62 +0,0 @@
-covers 'facets/timer'
-
-test_case Timer do
-
-  class_method :time do
-    test "can keep time of a block" do
-      Timer.time do |timer|
-        timer.total_time.round.assert == 0
-        sleep 1
-        timer.total_time.round.assert == 1
-      end
-    end
-
-    test "can be stopped" do
-      Timer.time do |timer|
-        sleep 0.4
-        timer.stop
-        sleep 0.6
-        timer.total_time.round.assert == 0
-      end
-    end
-
-    test "timer can be started again" do
-      Timer.time do |timer|
-        timer.stop
-        sleep 0.5
-        timer.total_time.round.assert == 0
-        timer.start
-        sleep 1
-        timer.total_time.round.assert == 1
-      end
-    end
-  end
-
-  method :start do
-    test "out of time" do
-      t = Timer.new(0.5)
-      expect Timeout::Error do
-        t.start
-        sleep 1
-        t.stop
-      end
-    end
-
-    test "in time" do
-      t = Timer.new(2)
-      t.start
-      sleep 0.5
-      t.stop
-    end
-  end
-
-  method :stop do
-    test "in time" do
-      t = Timer.new(2)
-      t.start
-      sleep 0.5
-      t.stop
-    end
-  end
-
-end