begin
  $fiber_test_activity = __FILE__

  assert('Fiber.new') do
    f = Fiber.new{}
    assert_kind_of Fiber, f
  end

  assert('Fiber#resume') do
    f = Fiber.new{|x| x }
    assert_equal 2, f.resume(2)
  end

  assert('Fiber#transfer') do
    ary = []
    f2 = nil
    f1 = Fiber.new{
      ary << f2.transfer(:foo)
      :ok
    }
    f2 = Fiber.new{
      ary << f1.transfer(:baz)
      :ng
    }
    assert_equal(:ok, f1.transfer)
    assert_equal([:baz], ary)
    assert_false f1.alive?
  end

  assert('Fiber#alive?') do
    f = Fiber.new{ Fiber.yield }
    f.resume
    assert_true f.alive?
    f.resume
    assert_false f.alive?
  end

  assert('Fiber#==') do
    root = Fiber.current
    assert_equal root, root
    assert_equal root, Fiber.current
    assert_false root != Fiber.current
    f = Fiber.new {
      assert_false root == Fiber.current
    }
    f.resume
    assert_false f == root
    assert_true f != root
  end

  assert('Fiber.yield') do
    f = Fiber.new{|x| Fiber.yield x }
    assert_equal 3, f.resume(3)
    assert_true f.alive?
  end

  assert('FiberError') do
    assert_equal StandardError, FiberError.superclass
  end

  assert('Fiber iteration') do
    f1 = Fiber.new{
      [1,2,3].each{|x| Fiber.yield(x)}
    }
    f2 = Fiber.new{
      [9,8,7].each{|x| Fiber.yield(x)}
    }
    a = []
    3.times {
      a << f1.resume
      a << f2.resume
    }
    assert_equal [1,9,2,8,3,7], a
  end

  assert('Fiber with splat in the block argument list') {
    assert_equal([1], Fiber.new{|*x|x}.resume(1))
  }

  assert('Fiber raises on resume when dead') do
    assert_raise(FiberError) do
      f = Fiber.new{}
      f.resume
      assert_false f.alive?
      f.resume
    end
  end

  assert('Yield raises when called on root fiber') do
    assert_raise(FiberError) { Fiber.yield }
  end

  assert('Double resume of Fiber') do
    f1 = Fiber.new {}
    f2 = Fiber.new {
      f1.resume
      assert_raise(FiberError) { f2.resume }
      Fiber.yield 0
    }
    assert_equal 0, f2.resume
    f2.resume
    assert_false f1.alive?
    assert_false f2.alive?
  end

  assert('Recursive resume of Fiber') do
    f1, f2 = nil, nil
    f1 = Fiber.new { assert_raise(FiberError) { f2.resume } }
    f2 = Fiber.new {
      f1.resume
      Fiber.yield 0
    }
    f3 = Fiber.new {
      f2.resume
    }
    assert_equal 0, f3.resume
    f2.resume
    assert_false f1.alive?
    assert_false f2.alive?
    assert_false f3.alive?
  end

  assert('Root fiber resume') do
    root = Fiber.current
    assert_raise(FiberError) { root.resume }
    f = Fiber.new {
      assert_raise(FiberError) { root.resume }
    }
    f.resume
    assert_false f.alive?
  end

  assert('Fiber without block') do
    assert_raise(ArgumentError) { Fiber.new }
  end


  assert('Transfer to self.') do
    result = []
    f = Fiber.new { result << :start; f.transfer; result << :end }
    f.transfer
    assert_equal [:start, :end], result

    result = []
    f = Fiber.new { result << :start; f.transfer; result << :end }
    f.resume
    assert_equal [:start, :end], result
  end

  assert('Resume transferred fiber') do
    f = Fiber.new {
      assert_raise(FiberError) { f.resume }
    }
    f.transfer
  end

  assert('Root fiber transfer.') do
    result = nil
    root = Fiber.current
    f = Fiber.new {
      result = :ok
      root.transfer
    }
    f.transfer
    assert_true f.alive?
    assert_equal :ok, result
  end

  assert('Break nested fiber with root fiber transfer') do
    root = Fiber.current

    result = nil
    f2 = nil
    f1 = Fiber.new {
      root.transfer(f2.transfer)
      result = :f1
    }
    f2 = Fiber.new {
      result = :to_root
      root.transfer :from_f2
      result = :f2
    }
    assert_equal :from_f2, f1.transfer
    assert_equal :to_root, result
    assert_equal :f2, f2.transfer
    assert_equal :f2, result
    assert_false f2.alive?
    assert_equal nil, f1.transfer
    assert_equal :f1, f1.transfer
    assert_equal :f1, result
    assert_false f1.alive?
  end

  assert('CRuby Fiber#transfer test.') do
    ary = []
    f2 = nil
    f1 = Fiber.new{
      ary << f2.transfer(:foo)
      :ok
    }
    f2 = Fiber.new{
      ary << f1.transfer(:baz)
      :ng
    }
    assert_equal :ok, f1.transfer
    assert_equal [:baz], ary
  end
ensure
  $fiber_test_activity = nil
end