# File lib/core_ex/enumerable.rb, line 172
    def each_pair_checker ( enum, ref )
      j = 0
      enum.each_pair do |i, x|
        assert_equal(j, i)
        j += 1
        assert_equal(ref.next, x)
      end
    end

# File lib/core_ex/enumerable.rb, line 102
    def setup
      @r = 0 .. 10
      @a = @r.to_a
      @s = @a.to_set
      @ak = 'a' .. 'k'
      @h = Hash[*(@r.zip(@ak).flatten)]
    end

# File lib/core_ex/enumerable.rb, line 158
    def test_average
      assert_equal 10, [0, 20].average
      assert_equal 10, [10, 10].average
      assert_equal 10, [0, 10, 20].average
      assert_equal '2.0', [2, 2, 2, 3, 1, 4, 0].average.to_s
    end

# File lib/core_ex/enumerable.rb, line 181
    def test_each_pair
      each_pair_checker(@a, Generator.new(@a))
      each_pair_checker(@s, Generator.new(@s))
      each_pair_checker(@r, Generator.new(@r))
      y = @h.fold([], :each_pair) { |accu, x| [x] + accu }
      assert_equal(@h.keys.reverse, y)
    end

# File lib/core_ex/enumerable.rb, line 110
    def test_fold
      [[@r, @a], [@a, @a], [@s, @s.to_a]].each do |enum, ref|
        y = enum.fold([]) { |accu, x| accu << x }
        assert_equal(ref, y, enum.class)
        y = enum.fold([]) { |accu, x| [x] + accu }
        assert_equal(ref.reverse, y, enum.class)
        y = enum.fold([]) { |accu, x| accu << x ; 42 }
        assert_equal(42, y, enum.class)
      end

      y = @h.fold([[], []]) do |accu, x|
        [ [x.first] + accu.first, [x.last] + accu.last ]
      end
      assert_equal(@h.keys.reverse, y.first)
      assert_equal(@h.values.reverse, y.last)
    end

# File lib/core_ex/enumerable.rb, line 127
    def test_foldi
      [@r, @a, @s, @h].each do |enum|
        ref = @a
        y = enum.foldi([]) { |accu, x, i| accu << i }
        assert_equal(ref, y, enum.class)
        y = enum.foldi([]) { |accu, x, i| [i] + accu }
        assert_equal(ref.reverse, y, enum.class)
        y = enum.foldi([]) { |accu, x, i| accu << i ; 42 }
        assert_equal(42, y, enum.class)
      end
    end

# File lib/core_ex/enumerable.rb, line 203
    def test_group_sequences_by
      list = [1, 2, 3, 4, 5, 8, 9, 3, 4, 5, 2, 1, 3, 4, 5]
      seqs = list.group_sequences_by { |x, y| y - x == 1 }
      assert_equal [[1, 2, 3, 4, 5], [8, 9], [3, 4, 5], [2], [1],
                    [3, 4, 5]], seqs
    end

# File lib/core_ex/enumerable.rb, line 146
    def test_prod
      @r = 1 .. 10
      @a = @r.to_a
      @s = @a.to_set
      @ak = 'a' .. 'k'
      @h = Hash[*(@r.zip(@ak).flatten)]
      assert_equal(3628800, @a.prod)
      assert_equal(3628800, @r.prod)
      assert_equal(3628800, @s.prod)
      assert_equal(3628800, @h.keys.prod)
    end

# File lib/core_ex/enumerable.rb, line 189
    def test_rec_fold
      h = { 1 => { 2 => 3 }, 4 => { 5 => 6 } }
      y = h.rec_fold([]) { |accu, *a| [a] + accu }
      assert_equal([[6], [5], [4], [3], [2], [1]], y)
      y = @h.rec_fold([]) { |accu, *a| [a] + accu }
      assert_equal([["k"], [10], ["e"], [4], ["j"], [9], ["d"], [3], ["i"],
                    [8], ["c"], [2], ["h"], [7], ["b"], [1], ["g"], [6], ["a"],
                    [0], ["f"], [5]], y)

      a = [1, [2,3], [[[4], 5]]]
      y = a.rec_fold(0) { |accu, x| accu + x }
      assert_equal(a.flatten.sum, y)
    end

# File lib/core_ex/enumerable.rb, line 165
    def test_standard_deviation
      assert_equal 10, [0, 20].standard_deviation
      assert_equal 0, [10, 10].standard_deviation
      assert_equal '8.16496580927726', [0, 10, 20].standard_deviation.to_s
      assert_equal '1.19522860933439', [2, 2, 2, 3, 1, 4, 0].standard_deviation.to_s
    end

# File lib/core_ex/enumerable.rb, line 139
    def test_sum
      assert_equal(55, @a.sum)
      assert_equal(55, @r.sum)
      assert_equal(55, @s.sum)
      assert_equal(55, @h.keys.sum)
    end