Exemple #1
0
def test_Cond_signal_generation():

    def test(i, m, c, running, awake):
        m.lock()
        running.send(True)
        c.wait()
        awake.send(i)
        m.unlock()

    @maintask
    def main():
        m = Mutex()
        c = Cond(m)
        n = 100
        running = makechan(n)
        awake = makechan(n)

        for i in range(n):
            go(test, i, m, c, running, awake)

            if i > 0:
                a = awake.recv()
                assert a == (i - 1), "wrong coroutine woke up: want %d, got %d" % (i-1, a)

            running.recv()
            with m:
                c.signal()

    run()
Exemple #2
0
def test_RWMutex_concurrent_readers():

    def reader(m, clocked, cunlock, cdone):
        m.rlock()
        clocked.send(True)
        cunlock.recv()
        m.runlock()
        cdone.send(True)

    def test_readers(num):
        m = RWMutex()
        clocked = makechan()
        cunlock = makechan()
        cdone = makechan()

        for i in range(num):
            go(reader, m, clocked, cunlock, cdone)

        for i in range(num):
            clocked.recv()

        for i in range(num):
            cunlock.send(True)

        for i in range(num):
            cdone.recv()

    @maintask
    def main():
        test_readers(1)
        test_readers(3)
        test_readers(4)

    run()
Exemple #3
0
def test_RLocker():
    wl = RWMutex()
    rl = wl.RLocker()
    wlocked = makechan(1)
    rlocked = makechan(1)

    n = 10

    def test():
        for i in range(n):
            rl.lock()
            rl.lock()
            rlocked.send(True)
            wl.lock()
            wlocked.send(True)

    @maintask
    def main():
        go(test)
        for i in range(n):
            rlocked.recv()
            rl.unlock()
            ret = select(wlocked.if_recv(), default)
            assert ret != wlocked.if_recv(), "RLocker didn't read-lock it"
            rl.unlock()
            wlocked.recv()
            ret = select(rlocked.if_recv(), default)
            assert ret != rlocked.if_recv(), "RLocker didn't respect the write lock"
            wl.unlock()

    run()
Exemple #4
0
def test_select_simple():
    rlist = []
    def fibonacci(c, quit):
        x, y = 0, 1
        while True:
            ret = select(c.if_send(x), quit.if_recv())
            if ret == c.if_send(x):
                x, y = y, x+y
            elif ret == quit.if_recv():
                return

    @maintask
    def main():
        c = makechan()
        quit = makechan()
        def f():
            for i in range(10):
                rlist.append(c.recv())
            print(rlist)
            quit.send(0)

        go(f)
        fibonacci(c, quit)

    run()

    assert rlist == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
Exemple #5
0
    def test_async_with_blocking_channel(self):

        def sender(c):
            unblocked_sent = 0
            for i in range(10):
                c.send(True)
                unblocked_sent += 1

            assert unblocked_sent == 10

            c.send(True)

        @maintask
        def main():
            c = makechan(10)

            go(sender, c)
            unblocked_recv = []
            for i in range(11):
                unblocked_recv.append(c.recv())


            assert len(unblocked_recv) == 11


        run()
Exemple #6
0
    def test_recv_counter(self):
        import random

        numbers = list(range(20))
        random.shuffle(numbers)

        rlist = []
        def counter(n, ch):
            ch.recv()
            rlist.append(n)

        @maintask
        def main():
            ch = makechan()

            for each in numbers:
                go(counter, each, ch)

            for each in numbers:
                ch.send(None)
        run()

        numbers.sort()
        rlist.sort()
        assert rlist == numbers
Exemple #7
0
def test_select_buffer():
    rlist = []
    def test(c, quit):
        x = 0
        while True:
            ret = select(c.if_send(x), quit.if_recv())
            if ret == c.if_send(x):
                x = x + 1
            elif ret == quit.if_recv():
                return

    @maintask
    def main():
        c = makechan(5, label="c")
        quit = makechan(label="quit")
        def f():
            for i in range(5):
                v = c.recv()
                rlist.append(v)
            quit.send(0)

        go(f)
        test(c, quit)
    run()

    assert rlist == [0, 1, 2, 3, 4]
Exemple #8
0
def test_select_simple():
    rlist = []

    def fibonacci(c, quit):
        x, y = 0, 1
        while True:
            ret = select(c.if_send(x), quit.if_recv())
            if ret == c.if_send(x):
                x, y = y, x + y
            elif ret == quit.if_recv():
                return

    @maintask
    def main():
        c = makechan()
        quit = makechan()

        def f():
            for i in range(10):
                rlist.append(c.recv())
            print(rlist)
            quit.send(0)

        go(f)
        fibonacci(c, quit)

    run()

    assert rlist == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
Exemple #9
0
    def test_multiple_sender(self):
        rlist = []
        sent = []

        def f(c):
            c.send("ok")

        def f1(c):
            c.send("eof")

        def f2(c):
            while True:
                data = c.recv()
                sent.append(data)
                if data == "eof":
                    return
                rlist.append(data)

        @maintask
        def main():
            c = makechan()
            go(f, c)
            go(f1, c)
            go(f2, c)

        run()

        assert rlist == ['ok']
        assert len(sent) == 2
        assert "eof" in sent
Exemple #10
0
    def test_recv_counter(self):
        import random

        numbers = list(range(20))
        random.shuffle(numbers)

        rlist = []

        def counter(n, ch):
            ch.recv()
            rlist.append(n)

        @maintask
        def main():
            ch = makechan()

            for each in numbers:
                go(counter, each, ch)

            for each in numbers:
                ch.send(None)

        run()

        numbers.sort()
        rlist.sort()
        assert rlist == numbers
Exemple #11
0
def test_select_buffer():
    rlist = []

    def test(c, quit):
        x = 0
        while True:
            ret = select(c.if_send(x), quit.if_recv())
            if ret == c.if_send(x):
                x = x + 1
            elif ret == quit.if_recv():
                return

    @maintask
    def main():
        c = makechan(5, label="c")
        quit = makechan(label="quit")

        def f():
            for i in range(5):
                v = c.recv()
                rlist.append(v)
            quit.send(0)

        go(f)
        test(c, quit)

    run()

    assert rlist == [0, 1, 2, 3, 4]
Exemple #12
0
def test_cooperative():
    output = []

    def print_(*args):
        output.append(args)

    def Loop(i):
        for x in range(3):
            gosched()
            print_("schedule", i)

    @maintask
    def main():
        go(Loop, 1)
        go(Loop, 2)

    run()

    assert output == [
        ('schedule', 1),
        ('schedule', 2),
        ('schedule', 1),
        ('schedule', 2),
        ('schedule', 1),
        ('schedule', 2),
    ]
Exemple #13
0
def test_multiple_timer():
    r1 = []
    def f1(now, t, g):
        r1.append(now)
        g.ready()

    r2 = []
    def f2(now, t):
        r2.append(now)

    @maintask
    def main():
        T1 = 0.4 * SECOND
        T2 = 0.1 * SECOND
        t1 = Timer(f1, T1, args=(proc.current(),))
        t2 = Timer(f2, T2)

        now = nanotime()
        t1.start()
        t2.start()

        park()

        assert r1[0] > r2[0]

        assert (now + T1 - DELTA0) <= r1[0] <= (now + T1 + DELTA), r1[0]
        assert (now + T2 - DELTA0) <= r2[0] <= (now + T2 + DELTA), r2[0]

    run()
Exemple #14
0
def test_multiple_timer():
    r1 = []

    def f1(now, t, g):
        r1.append(now)
        g.ready()

    r2 = []

    def f2(now, t):
        r2.append(now)

    @maintask
    def main():
        T1 = 0.4 * SECOND
        T2 = 0.1 * SECOND
        t1 = Timer(f1, T1, args=(proc.current(), ))
        t2 = Timer(f2, T2)

        now = nanotime()
        t1.start()
        t2.start()

        park()

        assert r1[0] > r2[0]

        assert (now + T1 - DELTA0) <= r1[0] <= (now + T1 + DELTA), r1[0]
        assert (now + T2 - DELTA0) <= r2[0] <= (now + T2 + DELTA), r2[0]

    run()
Exemple #15
0
def test_WaitGroup():

    def test_waitgroup(wg1, wg2):
        n = 16
        wg1.add(n)
        wg2.add(n)
        exited = makechan(n)

        def f(i):
            wg1.done()
            wg2.wait()
            exited.send(True)

        for i in range(n):
            go(f, i)

        wg1.wait()

        for i in range(n):
            ret = select(exited.if_recv(), default)
            assert ret != exited.if_recv(), "WaitGroup released group too soon"
            wg2.done()

            for i in range(16):
                exited.recv()

    @maintask
    def main():
        wg1 = WaitGroup()
        wg2 = WaitGroup()
        for i in range(8):
            test_waitgroup(wg1, wg2)

    run()
Exemple #16
0
    def test_multiple_sender(self):
        rlist = []
        sent = []

        def f(c):
            c.send("ok")

        def f1(c):
            c.send("eof")

        def f2(c):
            while True:
                data = c.recv()
                sent.append(data)
                if data == "eof":
                    return
                rlist.append(data)

        @maintask
        def main():
            c = makechan()
            go(f, c)
            go(f1, c)
            go(f2, c)

        run()

        assert rlist == ['ok']
        assert len(sent) == 2
        assert "eof" in sent
Exemple #17
0
def test_sleep():
    @maintask
    def main():
        PERIOD = 0.1 * SECOND
        start = nanotime()
        sleep(PERIOD)
        diff = nanotime() - start
        assert PERIOD - DELTA0 <= diff <= PERIOD + DELTA

    run()
Exemple #18
0
def test_sleep():
    @maintask
    def main():
        PERIOD = 0.1 * SECOND
        start = nanotime()
        sleep(PERIOD)
        diff = nanotime() - start
        assert PERIOD - DELTA0 <= diff <= PERIOD + DELTA

    run()
Exemple #19
0
def test_WaitGroup_raises():

    @maintask
    def main():
        wg = WaitGroup()
        with raises(PanicError):
            wg.add(1)
            wg.done()
            wg.done()
    run()
Exemple #20
0
def test_RWMutex():

    activity = AtomicLong(0)

    def reader(rwm, num_iterations, activity, cdone):
        print("reader")
        for i in range(num_iterations):
            rwm.rlock()
            n = activity.add(1)
            assert n >= 1 and n < 10000, "rlock %d" % n

            for i in range(100):
                continue

            activity.add(-1)
            rwm.runlock()
        cdone.send(True)

    def writer(rwm, num_iterations, activity, cdone):
        for i in range(num_iterations):
            rwm.lock()
            n = activity.add(10000)
            assert n == 10000, "wlock %d" % n
            for i in range(100):
                continue
            activity.add(-10000)
            rwm.unlock()
        cdone.send(True)

    def hammer_rwmutex(num_readers, num_iterations):
        activity = AtomicLong(0)
        rwm = RWMutex()
        cdone = makechan()

        go(writer, rwm, num_iterations, activity, cdone)

        for i in range(int(num_readers / 2)):
            go(reader, rwm, num_iterations, activity, cdone)

        go(writer, rwm, num_iterations, activity, cdone)

        for i in range(num_readers):
            go(reader, rwm, num_iterations, activity, cdone)

        for i in range(2 + num_readers):
            cdone.recv()

    @maintask
    def main():
        n = 1000
        hammer_rwmutex(1, n)
        hammer_rwmutex(3, n)
        hammer_rwmutex(10, n)

    run()
Exemple #21
0
def test_Tick():
    rlist = []

    @maintask
    def main():
        ticker_chan = Tick(0.1 * SECOND)
        for i in range(3):
            rlist.append(ticker_chan.recv())

    run()

    assert len(rlist) == 3
Exemple #22
0
def test_Tick():
    rlist = []

    @maintask
    def main():
        ticker_chan = Tick(0.1 * SECOND)
        for i in range(3):
            rlist.append(ticker_chan.recv())

    run()

    assert len(rlist) == 3
Exemple #23
0
def test_run():
    output = []
    def print_(*args):
        output.append(args)

    def f(i):
        print_(i)

    go(f, 1)
    go(f, 2)
    run()

    assert output == [(1,), (2,)]
Exemple #24
0
    def test_simple_pipe(self):
        def pipe(X_in, X_out):
            foo = X_in.recv()
            X_out.send(foo)

        @maintask
        def main():
            X, Y = makechan(), makechan()
            go(pipe, X, Y)

            X.send(42)
            assert Y.recv() == 42
        run()
Exemple #25
0
    def test_simple_pipe(self):
        def pipe(X_in, X_out):
            foo = X_in.recv()
            X_out.send(foo)

        @maintask
        def main():
            X, Y = makechan(), makechan()
            go(pipe, X, Y)

            X.send(42)
            assert Y.recv() == 42

        run()
Exemple #26
0
def test_After():
    rlist = []

    @maintask
    def main():
        PERIOD = 0.1 * SECOND
        now = nanotime()
        c = After(PERIOD)
        rlist.append(c.recv())

        diff = nanotime() - rlist[0]
        assert PERIOD - DELTA0 <= diff <= PERIOD + DELTA

    run()
Exemple #27
0
def test_Ticker():
    rlist = []

    @maintask
    def main():
        ticker = Ticker(0.1 * SECOND)
        for i in range(3):
            rlist.append(ticker.c.recv())

        ticker.stop()

    run()

    assert len(rlist) == 3
Exemple #28
0
def test_Ticker():
    rlist = []

    @maintask
    def main():
        ticker = Ticker(0.1 * SECOND)
        for i in range(3):
            rlist.append(ticker.c.recv())

        ticker.stop()

    run()

    assert len(rlist) == 3
Exemple #29
0
def test_After():
    rlist = []

    @maintask
    def main():
        PERIOD = 0.1 * SECOND
        now = nanotime()
        c = After(PERIOD)
        rlist.append(c.recv())

        diff = nanotime() - rlist[0]
        assert PERIOD - DELTA0 <= diff <= PERIOD + DELTA

    run()
Exemple #30
0
def test_run():
    output = []

    def print_(*args):
        output.append(args)

    def f(i):
        print_(i)

    go(f, 1)
    go(f, 2)
    run()

    assert output == [(1, ), (2, )]
Exemple #31
0
def test_Timer_reset():
    rlist = []

    @maintask
    def main():
        PERIOD = 10 * SECOND
        t = Timer(PERIOD)
        now = nanotime()
        t.reset(0.1 * SECOND)

        rlist.append(t.c.recv())

        diff = nanotime() - rlist[0]
        assert PERIOD - DELTA0 <= diff <= PERIOD + DELTA

    run()
Exemple #32
0
def test_Timer_reset():
    rlist = []

    @maintask
    def main():
        PERIOD = 10 * SECOND
        t = Timer(PERIOD)
        now = nanotime()
        t.reset(0.1 * SECOND)

        rlist.append(t.c.recv())

        diff = nanotime() - rlist[0]
        assert PERIOD - DELTA0 <= diff <= PERIOD + DELTA

    run()
Exemple #33
0
def test_Cond_broadcast():
    m = Mutex()
    c = Cond(m)
    n = 200
    running = makechan(n)
    awake = makechan(n)
    exit = False

    def test(i):
        m.lock()
        while not exit:
            running.send(i)
            c.wait()
            awake.send(i)
        m.unlock()

    @maintask
    def main():
        for i in range(n):
            go(test, i)

        for i in range(n):
            for i in range(n):
                running.recv()
            if i == n -1:
                m.lock()
                exit = True
                m.unlock()

            ret = select(awake.if_recv(), default)
            assert ret != awake.if_recv(), "coroutine not asleep"

            m.lock()
            c.broadcast()
            m.unlock()

            seen = {}
            for i in range(n):
                g = awake.recv()
                assert g not in seen, "coroutine woke up twice"
                seen[g] = True

        ret = select(running.if_recv(), default)
        assert ret != running.if_recv(), "coroutine did not exist"
        c.broadcast()

    run()
Exemple #34
0
def test_run_class():
    output = []
    def print_(*args):
        output.append(args)

    class Test(object):

        def __call__(self, i):
            print_(i)

    t = Test()

    go(t, 1)
    go(t, 2)
    run()

    assert output == [(1,), (2,)]
Exemple #35
0
    def test_send_exception(self):
        def exp_sender(chan):
            chan.send_exception(Exception, 'test')

        def exp_recv(chan):
            try:
                val = chan.recv()
            except Exception as exp:
                assert exp.__class__ is Exception
                assert str(exp) == 'test'

        @maintask
        def main():
            chan = makechan()
            go(exp_recv, chan)
            go(exp_sender, chan)
        run()
Exemple #36
0
def test_run_class():
    output = []

    def print_(*args):
        output.append(args)

    class Test(object):
        def __call__(self, i):
            print_(i)

    t = Test()

    go(t, 1)
    go(t, 2)
    run()

    assert output == [(1, ), (2, )]
Exemple #37
0
    def test_send_exception(self):
        def exp_sender(chan):
            chan.send_exception(Exception, 'test')

        def exp_recv(chan):
            try:
                val = chan.recv()
            except Exception as exp:
                assert exp.__class__ is Exception
                assert str(exp) == 'test'

        @maintask
        def main():
            chan = makechan()
            go(exp_recv, chan)
            go(exp_sender, chan)

        run()
Exemple #38
0
def test_construction():
    output = []
    def print_(*args):
        output.append(args)

    def aCallable(value):
        print_("aCallable:", value)

    go(aCallable, 'Inline using setup')

    run()
    assert output == [("aCallable:", 'Inline using setup')]


    del output[:]
    go(aCallable, 'Inline using ()')

    run()
    assert output == [("aCallable:", 'Inline using ()')]
Exemple #39
0
def test_cooperative():
    output = []
    def print_(*args):
        output.append(args)

    def Loop(i):
        for x in range(3):
            gosched()
            print_("schedule", i)

    @maintask
    def main():
        go(Loop, 1)
        go(Loop, 2)
    run()

    assert output == [('schedule', 1), ('schedule', 2),
                      ('schedule', 1), ('schedule', 2),
                      ('schedule', 1), ('schedule', 2),]
Exemple #40
0
def test_construction():
    output = []

    def print_(*args):
        output.append(args)

    def aCallable(value):
        print_("aCallable:", value)

    go(aCallable, 'Inline using setup')

    run()
    assert output == [("aCallable:", 'Inline using setup')]

    del output[:]
    go(aCallable, 'Inline using ()')

    run()
    assert output == [("aCallable:", 'Inline using ()')]
Exemple #41
0
    def test_async_channel(self):
        @maintask
        def main():
            c = makechan(100)

            unblocked_sent = 0
            for i in range(100):
                c.send(True)
                unblocked_sent += 1

            assert unblocked_sent == 100

            unblocked_recv = []
            for i in range(100):
                unblocked_recv.append(c.recv())

            assert len(unblocked_recv) == 100

        run()
Exemple #42
0
def test_simple_timer():
    def _func(now, t, rlist, g):
        rlist.append(now)
        g.ready()

    @maintask
    def main():
        rlist = []
        period = 0.1 * SECOND
        t = Timer(_func, period, args=(rlist, proc.current()))
        now = nanotime()
        t.start()
        park()
        delay = rlist[0]

        assert (now + period - DELTA0) <= delay <= (now + period +
                                                    DELTA), delay

    run()
Exemple #43
0
    def test_wait_two(self):
        """
        A tasklets/channels adaptation of the test_wait_two from the
        logic object space
        """
        def sleep(X, Y):
            dprint('twt_S ==== 1')
            value = X.recv()
            dprint('twt_S ==== 2')
            Y.send((X, value))
            dprint('twt_S ==== 3')

        def wait_two(X, Y, Ret_chan):
            Barrier = makechan()
            go(sleep, X, Barrier)
            go(sleep, Y, Barrier)
            dprint('twt_W ==== 1')
            ret = Barrier.recv()
            dprint('twt_W ==== 2')
            if ret[0] == X:
                Ret_chan.send((1, ret[1]))
            else:
                Ret_chan.send((2, ret[1]))
            dprint('twt_W ==== 3')

        @maintask
        def main():
            X, Y = makechan(), makechan()
            Ret_chan = makechan()

            go(wait_two, X, Y, Ret_chan)

            dprint('twt ==== 1')
            Y.send(42)

            dprint('twt ==== 2')
            X.send(42)
            dprint('twt ==== 3')
            value = Ret_chan.recv()
            dprint('twt ==== 4')
            assert value == (2, 42)

        run()
Exemple #44
0
def test_simple_timer():

    def _func(now, t, rlist, g):
        rlist.append(now)
        g.ready()

    @maintask
    def main():
        rlist = []
        period = 0.1 * SECOND
        t = Timer(_func, period, args=(rlist, proc.current()))
        now = nanotime()
        t.start()
        park()
        delay = rlist[0]

        assert (now + period - DELTA0) <= delay <= (now + period + DELTA), delay

    run()
Exemple #45
0
    def test_wait_two(self):
        """
        A tasklets/channels adaptation of the test_wait_two from the
        logic object space
        """
        def sleep(X, Y):
            dprint('twt_S ==== 1')
            value = X.recv()
            dprint('twt_S ==== 2')
            Y.send((X, value))
            dprint('twt_S ==== 3')

        def wait_two(X, Y, Ret_chan):
            Barrier = makechan()
            go(sleep, X, Barrier)
            go(sleep, Y, Barrier)
            dprint('twt_W ==== 1')
            ret = Barrier.recv()
            dprint('twt_W ==== 2')
            if ret[0] == X:
                Ret_chan.send((1, ret[1]))
            else:
                Ret_chan.send((2, ret[1]))
            dprint('twt_W ==== 3')

        @maintask
        def main():
            X, Y = makechan(), makechan()
            Ret_chan = makechan()

            go(wait_two, X, Y, Ret_chan)

            dprint('twt ==== 1')
            Y.send(42)

            dprint('twt ==== 2')
            X.send(42)
            dprint('twt ==== 3')
            value = Ret_chan.recv()
            dprint('twt ==== 4')
            assert value == (2, 42)

        run()
Exemple #46
0
def test_Mutex():

    def hammer_mutex(m, loops, cdone):
        for i in range(loops):
            m.lock()
            m.unlock()

        cdone.send(True)

    @maintask
    def main():
        m = Mutex()
        c = makechan()
        for i in range(10):
            go(hammer_mutex, m, 1000, c)

        for i in range(10):
            c.recv()

    run()
Exemple #47
0
    def test_async_channel(self):

        @maintask
        def main():
            c = makechan(100)

            unblocked_sent = 0
            for i in range(100):
                c.send(True)
                unblocked_sent += 1

            assert unblocked_sent == 100

            unblocked_recv = []
            for i in range(100):
                unblocked_recv.append(c.recv())

            assert len(unblocked_recv) == 100

        run()
Exemple #48
0
def test_repeat():
    r = []

    def f(now, t, g):
        if len(r) == 3:
            t.stop()
            g.ready()
        else:
            r.append(now)

    @maintask
    def main():
        t = Timer(f, 0.01 * SECOND, 0.01 * SECOND, args=(proc.current(), ))
        t.start()
        park()

        assert len(r) == 3
        assert r[2] > r[1]
        assert r[1] > r[0]

    run()
Exemple #49
0
def test_simple():
    rlist = []

    def f():
        rlist.append('f')

    def g():
        rlist.append('g')
        gosched()

    @maintask
    def main():
        rlist.append('m')
        cg = go(g)
        cf = go(f)
        gosched()
        rlist.append('m')

    run()

    assert rlist == 'm g f m'.split()
Exemple #50
0
def test_repeat():
    r = []
    def f(now, t, g):
        if len(r) == 3:
            t.stop()
            g.ready()
        else:
            r.append(now)


    @maintask
    def main():
        t = Timer(f, 0.01 * SECOND, 0.01 * SECOND, args=(proc.current(),))
        t.start()
        park()

        assert len(r) == 3
        assert r[2] > r[1]
        assert r[1] > r[0]

    run()
Exemple #51
0
def test_multiple_sleep():
    T1 = 0.4 * SECOND
    T2 = 0.1 * SECOND

    r1 = []
    def f1():
        sleep(T1)
        r1.append(nanotime())

    r2 = []
    def f2():
        sleep(T2)
        r2.append(nanotime())

    go(f1)
    go(f2)
    now = nanotime()
    run()
    assert r1[0] > r2[0]
    assert (now + T1 - DELTA0) <= r1[0] <= (now + T1 + DELTA), r1[0]
    assert (now + T2 - DELTA0) <= r2[0] <= (now + T2 + DELTA), r2[0]
Exemple #52
0
def test_AfterFunc():
    rlist = []

    @maintask
    def main():
        i = 10
        c = makechan()

        def f():
            i -= 1
            if i >= 0:
                AfterFunc(0, f)
                sleep(1 * SECOND)
            else:
                c.send(True)

        AfterFunc(0, f)
        c.recv()

        assert i == 0

    run()