module executor

import context
import time

fn test_many_producers_submit_bounded_work() {
    mut ex := new(queue_size: 16)!
    accepted := chan bool{cap: 16}
    ran := chan int{cap: 16}
    mut producers := []thread{}

    for i in 0 .. 16 {
        producers << spawn fn [mut ex, accepted, ran, i] () {
            ex.post_with_context(context.background(), fn [ran, i] () ! {
                ran <- i
            }) or {
                accepted <- false
                return
            }
            accepted <- true
        }()
    }

    for _ in 0 .. 16 {
        assert wait_for_bool(accepted, 'producer did not finish admission')
    }
    assert ex.drain_pending(16)! == 16

    mut total := 0
    for _ in 0 .. 16 {
        total += wait_for_int(ran, 'producer job did not run')
    }
    assert total == 120

    for producer in producers {
        producer.wait()
    }
    ex.stop()
    assert !ex.run_one()!
    ex.wait()!
}

fn test_stop_wakes_waiting_submitter_without_accepting_job() {
    mut ex := new(queue_size: 1)!
    attempting := chan bool{cap: 1}
    result := chan string{cap: 1}
    ran := chan bool{cap: 1}

    ex.try_post(fn () ! {})!
    submitter := spawn fn [mut ex, attempting, result, ran] () {
        attempting <- true
        ex.post_with_context(context.background(), fn [ran] () ! {
            ran <- true
        }) or {
            result <- err.msg()
            return
        }
        result <- 'accepted'
    }()

    assert wait_for_bool(attempting, 'waiting submitter did not start')
    ex.stop()
    msg := wait_for_string(result, 'waiting submitter was not woken by stop')
    assert msg == 'executor: executor is closed'
    assert_no_bool(ran, 'job was accepted after stop')
    submitter.wait()
}

fn wait_for_bool(signal chan bool, message string) bool {
    select {
        value := <-signal {
            return value
        }
        1 * time.second {
            assert false, message
        }
    }
    return false
}

fn wait_for_int(signal chan int, message string) int {
    select {
        value := <-signal {
            return value
        }
        1 * time.second {
            assert false, message
        }
    }
    return 0
}

fn wait_for_string(signal chan string, message string) string {
    select {
        value := <-signal {
            return value
        }
        1 * time.second {
            assert false, message
        }
    }
    return ''
}

fn assert_no_bool(signal chan bool, message string) {
    select {
        _ := <-signal {
            assert false, message
        }
        50 * time.millisecond {}
    }
}