require 'test/unit'
require 'spawn'

class TestSpawn < Test::Unit::TestCase
  def test_010_can_spawn
    x = spawn { }
    assert_kind_of Spawn::Process, x
  end

  def test_011_spawn_passes_self
    y = nil
    x = spawn { |p| y = p }
    x.join
    assert_same x, y
  end

  def test_020_new_process_has_empty_queue
    x = spawn { sleep }
    assert_equal [], x.queue
  end

  def test_030_sendmsg_adds_to_queue
    x = spawn { sleep }
    x.sendmsg :foo, 5
    assert_equal [[:foo, 5]], x.queue
    x << [:bar, "quux"]
    assert_equal [[:foo, 5], [:bar, "quux"]], x.queue
  end

  def test_040_recieve_blocks
    s = 0
    x = spawn { |process|
      s = 1
      process.recieve { }
      s = 2
    }
    sleep 0.2
    assert_equal s, 1
  end

  def test_050_recieve_returns_message
    r = nil
    x = spawn { |process|
      r = false
      msg = process.recieve
      r = msg
    }
    x << :foo
    x.join
    assert_equal [:foo], r
  end

  def test_060_recieve_with_block
    worked = false
    x = spawn { |process|
      process.recieve { |msg, *args|
        case msg
        when :work!
          worked = true
        end
      }
    }
    assert_equal false, worked
    x << :work!
    x.join
    assert_equal true, worked
  end

  def test_070_kernel_recieve
    worked = false
    x = spawn {
      recieve { |msg, *args|
        case msg
        when :work!
          worked = true
        end
      }
    }
    assert_equal false, worked
    x << :work!
    x.join
    assert_equal true, worked
  end

  def test_090_echo
    echo = spawn {
      loop {
        recieve { |process, *rest|
          process << rest
        }
      }
    }

    echo.sendmsg(Thread.current, :foo)
    echo.sendmsg(Thread.current, :bar)
    msg = recieve
    assert_equal [:foo], msg
    msg = recieve
    assert_equal [:bar], msg
  end

  def test_090_sync_echo
    echo = spawn {
      loop {
        recieve { |process, *rest|
          process << [process, rest]
        }
      }
    }

    r1 = echo.syncmsg(:foo)
    r2 = echo.syncmsg(:bar)
    assert_equal [:foo], r1
    assert_equal [:bar], r2
  end

  def test_095_sync_echo_with_distortion
    annoy = spawn {
      loop {
        Thread.main << :gah!
        sleep 0.02
      }
    }
    
    echo = spawn {
      loop {
        recieve { |process, *rest|
          process << [process, rest]
        }
      }
    }

    r1 = echo.syncmsg(:foo)
    r2 = echo.syncmsg(:bar)
    assert_equal [:foo], r1
    assert_equal [:bar], r2
  end

  def test_100_pingpong
  end
end