facets 3.0.0 → 3.2.0

data/test/core/enumerable/test_none.rb

@@ -1,29 +0,0 @@
-covers 'facets/enumerable/none'
-
-test_case Enumerable do
-
-  method :none? do
-
-    test do
-      a = [nil, nil]
-      assert( a.none? )
-    end
-
-    test do
-      a = [false, false]
-      assert( a.none? )
-    end
-
-    test do
-      a = [true, false]
-      assert( ! a.none? )
-    end
-
-    test do
-      a = [nil, 1]
-      assert( ! a.none? )
-    end
-
-  end
-
-end

data/test/core/enumerable/test_occur.rb

@@ -1,40 +0,0 @@
-covers 'facets/enumerable/occur'
-
-test_case Enumerable do
-
-  method :occur do
-
-    # make an Enumerable class to test
-    eC = Class.new do
-      include Enumerable
-      def initialize(*a)
-        @a = a
-      end
-      def each(&b)
-        @a.each(&b)
-      end
-    end
-
-    test do
-      e = eC.new(:a,:b,:a)
-      e.occur(1).assert == [:b]
-    end
-
-    test do
-      e = eC.new(:a,:b,:a)
-      e.occur(2).assert == [:a]
-    end
-
-    test do
-      e = eC.new(:a,:b,:a)
-      e.occur(1..1).assert == [:b]
-    end
-
-    test do
-      e = eC.new(:a,:b,:a)
-      e.occur{ |n| n % 2 == 0 }.assert == [:a]
-    end
-
-  end
-
-end

data/test/core/enumerable/test_one.rb

@@ -1,34 +0,0 @@
-covers 'facets/enumerable/one'
-
-test_case Enumerable do
-
-  method :one? do
-
-    test do
-      a = [nil, true]
-      assert( a.one? )
-    end
-
-    test do
-      a = [true, false]
-      assert( a.one? )
-    end
-
-    test do
-      a = [true, true]
-      assert( ! a.one? )
-    end
-
-    test do
-      a = [true, 1]
-      assert( ! a.one? )
-    end
-
-    test do
-      a = [1, 1]
-      assert( ! a.one? )
-    end
-
-  end
-
-end

data/test/core/enumerable/test_only.rb

@@ -1,40 +0,0 @@
-covers 'facets/enumerable/only'
-
-test_case Enumerable do
-
-  # make an Enumerable class to test
-  eC = Class.new do
-    include Enumerable
-    def initialize(*a)
-      @a = a
-    end
-    def each(&b)
-      @a.each(&b)
-    end
-  end
-
-  method :only? do
-
-    test do
-      e = eC.new(false)
-      assert e.only?
-    end
-
-    test do
-      e = eC.new(1)
-      assert e.only?
-    end
-
-    test do
-      e = eC.new(false, false)
-      refute e.only?
-    end
-
-    test do
-      e = eC.new()
-      refute e.only?
-    end  
-
-  end
-
-end

data/test/core/enumerable/test_per.rb

@@ -1,19 +0,0 @@
-covers 'facets/enumerable/per'
-
-test_case Enumerable do
-
-  method :per do
-
-    test "map" do
-      e = [1,2,3].per.map
-
-      (e + 3).assert == [4,5,6]
-      (e - 1).assert == [0,1,2]
-
-      e.to_s.assert == ['1','2','3']
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_purge.rb

@@ -1,22 +0,0 @@
-covers 'facets/enumerable/purge'
-
-test_case Enumerable do
-
-  method :purge do
-
-    test do
-      [1, nil, 2].purge.assert == [1,2]
-    end
-
-    test "with trash arguments" do
-      (1..6).purge(3,4).assert == [1,2,5,6]
-    end
-
-    test "with block" do
-      (1..6).purge(0){ |n| n % 2 }.assert == [1,3,5]
-      (1..6).purge(1){ |n| n % 2 }.assert == [2,4,6]
-    end
-
-  end
-
-end

data/test/core/enumerable/test_recursively.rb

@@ -1,33 +0,0 @@
-covers 'facets/enumerable/recursively'
-
-test_case Enumerable do
-
-  method :recursively do
-
-    c = Class.new do
-      include Enumerable
-      def initialize(ary)
-        @ary = ary
-      end
-      def each(&b)
-        @ary.each(&b)
-      end
-    end
-
-    test "each" do
-      e = c.new [1,2,['a','b']]
-      a = []
-      e.recursively(Enumerable).each{ |v| a << v }
-      a.assert == [1,2,'a','b']
-    end
-
-    test "map" do
-      e = c.new [1,2,['a','b']]
-      a = e.recursively(Enumerable).map{ |v| v.succ }
-      a.assert == [2,3,['b','c']]
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_squeeze.rb

@@ -1,35 +0,0 @@
-covers 'facets/enumerable/squeeze'
-
-test_case Enumerable do
-
-  method :squeeze do
-
-    # make an Enumerable class to test
-    eC = Class.new do
-      include Enumerable
-      def initialize(*a)
-        @a = a
-      end
-      def each(&b)
-        @a.each(&b)
-      end
-    end
-
-    test 'example (default)' do
-      e = eC.new(1,2,2,3,3,2,1)
-      e.squeeze.assert == [1,2,3,2,1]
-    end
-
-    test 'sort.squeeze eq uniq (default)' do
-      e = eC.new(1,2,2,3,3,2,1)
-      e.sort.squeeze.assert == [1,2,3]
-    end
-
-    test 'example (with argument)' do
-      e = eC.new(1,2,2,3,3,2,1)
-      e.squeeze(*[3]).assert == [1,2,2,3,2,1]
-    end
-
-  end
-
-end

data/test/core/enumerable/test_sum.rb

@@ -1,40 +0,0 @@
-covers 'facets/enumerable/sum'
-
-test_case Enumerable do
-
-  method :sum do
-
-    test do
-      [1,2,3].sum.assert == 6
-    end
-
-    test 'with block' do
-      a = [1.0, 2.1, 3.2].sum(&:to_i)
-      a.assert == 6
-    end
-
-    test 'with identity' do
-      a = [].sum(9)
-      a.assert == 9
-
-      a = [1].sum(9)
-      a.assert == 10
-    end
-
-    test 'with identity and block' do
-      # notice identity is not effected by the block
-      a = [].sum(9.1, &:to_i)
-      a.assert == 9.1
-
-      a = [1.1].sum(9.1, &:to_i)
-      a.assert == 10.1
-    end
-
-    test 'with non-numeral addition' do
-      a = [[1],[2],[3]].sum([])
-      a.assert == [1,2,3]
-    end
-
-  end
-
-end

data/test/core/enumerable/test_take.rb

@@ -1,15 +0,0 @@
-covers 'facets/enumerable/take'
-
-test_case Enumerable do
-
-  method :take do
-
-    test 'is finite' do
-      infinite = (1..1/0.0) # infinite Enumerable
-      infinite.take(5).assert == [1,2,3,4,5]
-    end
-
-  end
-
-end
-

data/test/core/enumerable/test_uniq_by.rb

@@ -1,25 +0,0 @@
-covers 'facets/enumerable/uniq_by'
-
-test_case Enumerable do
-
-  method :uniq_by do
-
-    test do
-      e = [-5, -4, -3, -2, -1, 0]
-      r = (-5..5).to_a.uniq_by{ |i| i*i }
-      r.assert == e
-    end
-
-  end
-
-  #method :uniq_by! do
-  #  test do
-  #    e = [-5, -4, -3, -2, -1, 0]
-  #    r = (-5..5).to_a
-  #    r.uniq_by!{ |i| i*i }
-  #    r.assert == e 
-  #  end
-  #end
-
-end
-

data/test/core/enumerable/test_visit.rb

@@ -1,14 +0,0 @@
-covers 'facets/enumerable/visit'
-
-test_case Enumerable do
-
-  method :visit do
-
-    test do
-      r = [1, 2, 8..9].visit{ |x| x.succ }
-      r.assert == [2, 3, [9, 10]]
-    end  
-
-  end
-
-end

data/test/core/enumerator/lazy/test_squeeze.rb

@@ -1,33 +0,0 @@
-if defined?(Enumerator::Lazy)
-  covers 'facets/enumerator/lazy/squeeze'
-
-  test_case Enumerator::Lazy do
-
-    method :squeeze do
-
-      # make an Enumerable class to test
-      eC = Class.new do
-        include Enumerable
-        def initialize(*a)
-          @a = a
-        end
-        def each(&b)
-          @a.each(&b)
-        end
-      end
-
-      test 'example (default)' do
-        e = eC.new(1,2,2,3,3,2,1)
-        e.lazy.squeeze.to_a.assert == [1,2,3,2,1]
-      end
-
-      test 'example (with argument)' do
-        e = eC.new(1,2,2,3,3,2,1)
-        e.lazy.squeeze(*[3]).to_a.assert == [1,2,2,3,2,1]
-      end
-
-    end
-
-  end
-
-end

data/test/core/enumerator/test_fx.rb

@@ -1,16 +0,0 @@
-covers 'facets/enumerator/fx'
-
-test_case Enumerator do
-
-  method :fx do
-
-    test do
-      e = [1,2,3].to_enum
-      r = e.fx + 2
-      r.assert == [3,4,5]
-    end
-
-  end
-
-end
-

data/test/core/enumerator/test_new.rb

@@ -1,21 +0,0 @@
-covers 'facets/enumerator'
-
-test_case Enumerator do
-
-  class_method :new do
-
-    test "with block" do
-      # This example taken from ri19 Enumerator.new
-      fib = Enumerator.new do |y|
-       a = b = 1
-        loop {
-          y << a
-          a, b = b, a + b
-        }
-      end
-      fib.take(10).assert == [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
-    end
-
-  end
-
-end

data/test/core/enumerator_tc.rb

@@ -1,40 +0,0 @@
-covers 'facets/enumerator'
-
-test_case Enumerator::Yielder do
-
-  class_method :new do
-
-    test do
-      y = Enumerator::Yielder.new{ |x| x + 1 }
-    end
-
-  end
-
-  method :yield do
-
-    test do
-      y = Enumerator::Yielder.new{ |x| x + 1 }
-      y.yield(1).assert == 2
-    end
-
-  end
-
-  method :<< do
-
-    test do
-      a = []
-      y = Enumerator::Yielder.new{ |x| a << x + 1 }
-      y << 1
-      a.assert == [2]
-    end
-
-    test do
-      a = []
-      y = Enumerator::Yielder.new{ |x,y| a << x + y }
-      y.<<(1,2)
-      a.assert == [3]
-    end
-
-  end
-
-end

data/test/core/exception/test_detail.rb

@@ -1,15 +0,0 @@
-covers 'facets/exception/detail'
-
-test_case Exception do
-
-  method :detail do
-
-    test "at least it runs" do
-      err = ArgumentError.new("example error")
-      err.detail
-    end
-
-  end
-
-end
-

data/test/core/exception/test_raised.rb

@@ -1,15 +0,0 @@
-covers 'facets/exception/raised'
-
-test_case Exception do
-
-  class_method :raised? do
-
-    test do
-      NameError.raised? do
-        supercalafragalistic
-      end
-    end
-
-  end
-
-end

data/test/core/exception/test_suppress.rb

@@ -1,16 +0,0 @@
-covers 'facets/exception/suppress'
-
-test_case Exception do
-
-  class_method :suppress do
-
-    test do
-      NameError.suppress do
-        supercalafragalistic
-      end
-    end
-
-  end
-
-end
-

data/test/core/file/test_append.rb

@@ -1,22 +0,0 @@
-covers 'facets/file/append'
-
-test_case File do
-
-  class_method :append do
-
-    setup do
-      require 'fileutils'
-      @test_file = 'tmp/append.txt'
-      FileUtils.rm(@test_file) if File.exist?(@test_file)
-    end
-
-    test do
-      File.append(@test_file, "line 1\n")
-      File.read(@test_file).assert == "line 1\n"
-      File.append(@test_file, "line 2\n")
-      File.read(@test_file).assert == "line 1\nline 2\n"
-    end
-
-  end
-
-end

data/test/core/file/test_create.rb

@@ -1,17 +0,0 @@
-covers 'facets/file/create'
-
-test_case File do
-
-  class_method :create do
-
-    test_file = 'tmp/rewrite.txt'
-    test_data = 'This is a test!'
-
-    test do
-      File.create(test_file, test_data)
-      File.read(test_file).assert == test_data
-    end
-
-  end
-
-end

data/test/core/file/test_ext.rb

@@ -1,31 +0,0 @@
-covers 'facets/file/ext'
-
-test_case File do
-
-  class_method :ext do
-
-    test "typical filename" do
-      s = 'file.txt'
-      File.ext(s).assert == 'txt'
-      File.ext(s, 'old').assert == 'file.old'
-      File.ext(s, '').assert == 'file'
-    end
-
-    test "no extension" do
-      s = 'file'
-      File.ext(s).assert == ''
-      File.ext(s, 'txt').assert == 'file.txt'
-      File.ext(s, '').assert == 'file'
-    end 
-
-    test "non-standard extensions" do
-      s = '.profile'
-      File.ext(s).assert == ''
-      File.ext(s, 'new').assert == '.profile.new'
-      File.ext(s, '').assert == '.profile'
-    end
-
-  end
-
-end
-

data/test/core/file/test_null.rb

@@ -1,14 +0,0 @@
-covers 'facets/file/null'
-
-test_case File do
-
-  class_method :null do
-
-    test do
-      assert File.null
-    end
-
-  end
-
-end
-

data/test/core/file/test_read_binary.rb

@@ -1,19 +0,0 @@
-covers 'facets/file/read_binary'
-
-test_case File do
-
-  # TODO: Is this even really testable?
-  class_method :read_binary do
-
-    test_file = 'tmp/read_binary.txt'
-    test_data = "line 1\nline 2\nline 3"
-
-    test do
-      File.open(test_file, 'w'){ |f| f << test_data }
-      File.read_binary(test_file).assert == test_data
-    end
-
-  end
-
-end
-

data/test/core/file/test_read_list.rb

@@ -1,16 +0,0 @@
-covers 'facets/file/read_list'
-
-test_case File do
-
-  class_method :read_list do
-
-    test_file = 'tmp/read_list.txt'
-
-    test do
-      File.open(test_file, 'w'){ |f| f << "line 1\nline 2\n#line 3" }
-      File.read_list(test_file).assert == ['line 1', 'line 2']
-    end
-
-  end
-
-end

data/test/core/file/test_rewrite.rb

@@ -1,35 +0,0 @@
-covers 'facets/file/rewrite'
-
-test_case File do
-
-  test_data = 'This is a test!'
-
-  class_method :rewrite do
-
-    setup do
-      @test_file = 'tmp/rewrite.txt'
-      File.open(@test_file, 'w'){ |w| w << test_data }
-    end
-
-    test do
-      File.rewrite(@test_file){ |s| s.reverse }
-      File.read(@test_file).assert == test_data.reverse
-    end
-
-  end
-
-  class_method :rewrite! do
-
-    setup do
-      @test_file = 'tmp/rewrite.txt'
-      File.open(@test_file, 'w'){ |w| w << test_data }
-    end
-
-    test do
-      File.rewrite!(@test_file){ |s| s.reverse! }
-      File.read(@test_file).assert == test_data.reverse
-    end
-
-  end
-
-end

data/test/core/file/test_rootname.rb

@@ -1,13 +0,0 @@
-covers 'facets/file/rootname'
-
-test_case File do
-
-  class_method :rootname do
-
-    test do
-      File.rootname('test/core/file').assert == 'test'
-    end
-
-  end
-
-end