# File lib/syn_flow.rb, line 292
    def make_simple_factory
      f = SynFlowFactory.new
      f << [1, :a, 2] \
        << [6, :f, 4] \
        << SynFlowFactory::Transition.new(3, :c, 4)
      f << { 2 => { :e => 6, :b => 3 },
             4 => { :d => 5 },
             5 => { :g => 1 }
           }
      f.initial = 1
      return f
    end

# File lib/syn_flow.rb, line 260
    def test_aa_simple_transition
      assert_equal(T.new(:a, :b, :c), T.new(:a, :b, :c))
      assert_not_equal(T.new(:b, :a, :c), T.new(:a, :b, :d))
    end

# File lib/syn_flow.rb, line 265
    def test_ab_simple_transition_set
      s = TSet.new
      s << T.new(:a, :b, :c) << T.new(:b, :a, :d) << [:e, :f, :g]
      assert(s.include?(:a, :b))
      assert(s.include?(T.new(:a, :b, :c)))
      assert(s.include?(:b, :a, :d))
      assert(s.include?([:e, :f]))
    end

# File lib/syn_flow.rb, line 274
    def test_ac_bad_transition_set
      s = TSet.new
      s << T.new(:a, :b, :c) << T.new(:b, :a, :d)
      assert(! s.include?(T.new(:b, :b, :c)))
      assert(! s.include?(:a, :d, :c))
      assert(! s.include?([:c, :b]))
    end

# File lib/syn_flow.rb, line 305
    def test_ad_simple_factory
      f = nil
      assert_nothing_raised do
        f = make_simple_factory
      end
      transitions =
       [[1, :a, 2],
        [6, :f, 4],
        [3, :c, 4],
        [2, :e, 6],
        [2, :b, 3],
        [4, :d, 5],
        [5, :g, 1]]
      transitions.each do |s, l, d|
        assert(f.transitions.include?(s, l, d))
      end

      assert(! f.transitions.include?(1, :a, 3))
      assert(! f.transitions.include?(2, :a))
      assert(! f.transitions.include?(1, :a, 1))

      assert(f.initial?(1))
      assert(! f.initial?(2))
    end

# File lib/syn_flow.rb, line 330
    def test_ba_simple_flow
      f = make_simple_factory
      m = nil
      assert_nothing_raised { m = f.new_flow }
      assert_nothing_raised do
        Timeout.timeout(2) do
          assert_equal(1, m.state)
          m << :a
          assert_equal(2, m.state)
          m << :b
          assert_equal(3, m.state)
          m << :c
          assert_equal(4, m.state)
          m << :d
          assert_equal(5, m.state)
          m << :g
          assert_equal(1, m.state)
        end
      end
    end

# File lib/syn_flow.rb, line 351
    def test_bb_simple_loop
      f = make_simple_factory
      f << [6, :e, 6]
      m = f.new_flow
      assert_nothing_raised do
        Timeout.timeout(2) do
          assert_equal(1, m.state)
          m << :a
          assert_equal(2, m.state)
          m << :e
          assert_equal(6, m.state)
          m << :e
          assert_equal(6, m.state)
          m << :f
          assert_equal(4, m.state)
        end
      end
    end

# File lib/syn_flow.rb, line 370
    def test_bc_simple_try_advance
      f = make_simple_factory
      m = f.new_flow
      assert_nothing_raised do
        Timeout.timeout(2) do
          assert(m.try_advance(:a))
          assert_equal(2, m.state)
          m << :b
          assert_equal(3, m.state)
          assert(! m.try_advance(:e))
          assert_equal(3, m.state)
          m << :c
          assert_equal(4, m.state)
        end
      end
    end

# File lib/syn_flow.rb, line 387
    def test_c_avanced_flow
      f = make_simple_factory
      m = f.new_flow
      th = Thread.new { sleep ; m << :e }
      assert_raise(Timeout::Error) do
        Timeout.timeout(0.2) do
          th.wakeup
          th.join
        end
      end
      assert_nothing_raised do
        Timeout.timeout(2) do
          m << :a
          sleep 0.1
          assert_equal(6, m.state)
        end
      end
      assert_nothing_raised do
        Timeout.timeout(2) do
          m << :f
          assert_equal(4, m.state)
          m << :d
          assert_equal(5, m.state)
          m << :g
          assert_equal(1, m.state)
        end
      end
    end

# File lib/syn_flow.rb, line 416
    def test_d_multi_threads
      f = make_simple_factory
      m = f.new_flow

      assert_nothing_raised do
        Timeout.timeout(5) do
          t = []
          t << Thread.new { m << :d }
          t << Thread.new { m << :c }
          t << Thread.new { m << :a }
          t << Thread.new { m << :b }
          t.each { |t| t.join }
        end
      end
      assert_equal(5, m.state)
    end

# File lib/syn_flow.rb, line 436
    def test_e_with_block
      f = make_simple_factory
      m = f.new_flow

      assert_nothing_raised do
        Timeout.timeout(5) do
          t1 = Thread.new do
            sleep
            m << :a
            sleep
          end
          t2 = Thread.new do
            m << :e
            t1.raise E
          end
          t1.wakeup
          t2.join
          assert_raise(E) { t1.join }
        end
      end
      assert_equal(6, m.state)
    end

# File lib/syn_flow.rb, line 459
    def test_f_dumpable
      f = make_simple_factory
      m = f.new_flow

      assert_nothing_raised do
        Marshal.load(Marshal.dump(m))
      end
      assert_nothing_raised do
        Marshal.load(Marshal.dump(f))
      end
    end