#  _____         _
# |_   _|__  ___| |_
#   | |/ _ \/ __| __|
#   | |  __/\__ \ |_
#   |_|\___||___/\__|
#
# for lib/facets/more/taskable.rb
#
# Extracted Tue Jun 20 15:12:27 EDT 2006
# Unit Tools Reap Test Extractor
#

require 'facets/more/taskable.rb'


  require 'test/unit'

  class TCTask < Test::Unit::TestCase

    module M
      task :m1 => [ :c1 ] do @x << "m1" end
      task :m2 => [ :c2 ] do @x << "m2" end
      task :m3 => [ :c3 ] do @x << "m3" end
      task :m4 => [ :c1, :c2, :c3 ] do @x << "m4" end
      task :m5 do @x << 'm5' end
    end

    class B
      attr :x
      def initialize ; @x = [] ; end

      task :b1 do @x << "b1" end
      task :b2 => [ :b1 ]
    end

    class C
      include M
      attr :x
      def initialize ; @x = [] ; end

      task :c1 do @x << "c1" end
      task :c2 => [ :c1, :c1 ] do @x << "c2" end
      task :c3 => [ :c1, :c2 ] do @x << "c3" end
      task :c4 => [ :m1 ] do @x << "c4" end
      task :c5 => [ :c5 ] do @x << "c5" end
      task :c6 => [ :c7 ] do @x << "c6" end
      task :c7 => [ :c6 ] do @x << "c7" end
    end

    class D < C
      task :d1 => [ :c1 ] do @x << "d1" ; end
      task :d2 => [ :m1 ] do @x << "d2" ; end
    end

    module N
      include M
    end

    class E
      include N
      attr :x
      def initialize ; @x = [] ; end

      task :e1 => [ :c1 ] do @x << "e1" ; end
      task :e2 => [ :m1 ] do @x << "e2" ; end
      task :e3 => [ :m5 ] do @x << "e3" ; end
    end

    module O
      attr :x
      task :o1 do (@x||=[]) << "o1" end
      task :o2 => [ :o1 ] do (@x||=[]) << "o2" end
    end

    # TODO Appearently extending does play well with inheritor?
    # F = Module.new { extend O }

    # tests

    def test_B1
      b = B.new ; b.b1
      assert_equal( [ 'b1' ], b.x )
    end

    def test_B2
      b = B.new ; b.b2
      assert_equal( [ 'b1' ], b.x )
    end

    def test_C1
      c = C.new ; c.c1
      assert_equal( [ 'c1' ], c.x )
    end

    def test_C2
      c = C.new ; c.c2
      assert_equal( [ 'c1', 'c2' ], c.x )
    end

    def test_C3
      c = C.new ; c.c3
      assert_equal( [ 'c1', 'c2', 'c3' ], c.x )
    end

    def test_C4
      c = C.new ; c.c4
      assert_equal( [ 'c1', 'm1', 'c4' ], c.x )
    end

    def test_M1
      c = C.new ; c.m1
      assert_equal( [ 'c1', 'm1' ], c.x )
    end

    def test_M2
      c = C.new ; c.m2
      assert_equal( [ 'c1', 'c2', 'm2' ], c.x )
    end

    def test_M3
      c = C.new ; c.m3
      assert_equal( [ 'c1', 'c2', 'c3', 'm3' ], c.x )
    end

    def test_M4
      c = C.new ; c.m4
      assert_equal( [ 'c1', 'c2', 'c3', 'm4' ], c.x )
    end

    def test_D1
      d = D.new ; d.d1
      assert_equal( [ 'c1', 'd1' ], d.x )
    end

    def test_D2
      d = D.new ; d.d2
      assert_equal( [ 'c1', 'm1', 'd2' ], d.x )
    end

    def test_E1
      e = E.new
      assert_raises( RuntimeError ) { e.e1 }
      #assert_equal( [ 'c1', 'e1' ], e.x )
    end

    def test_E2
      e = E.new
      assert_raises( RuntimeError ) { e.e2 }
      #assert_equal( [ 'c1', 'm1', 'e2' ], e.x )
    end

    def test_E3
      e = E.new ; e.e3
      assert_equal( [ 'm5', 'e3' ], e.x )
    end

    # def test_F1
    #   F.o1
    #   assert_equal( [ 'o1' ], F.x )
    # end
    #
    # def test_F2
    #   F.o2
    #   assert_equal( [ 'o1', 'o1', 'o2' ], F.x )
    # end

  end