Example #1
0
        public static void sending_async_returns_a_waiting_task_which_is_complete_by_receive_a_value_async(Test t)
        {
            var ch  = new BufferedChannel <int>(1);
            var st1 = ch.SendAsync(1);
            var st2 = ch.SendAsync(2);

            if (st2.IsCompleted)
            {
                t.Fatal("second send should wait for a recevier");
            }
            var rt  = ch.ReceiveAsync();
            var rt2 = ch.ReceiveAsync();

            if (rt == null)
            {
                t.Fatal("ReceiveAsync returned null");
            }
            if (!rt2.IsCompleted)
            {
                t.Fatal("ReceiveAsync is not complete");
            }
            if (st2.Wait(100) == false || st2.IsCompleted == false)
            {
                t.Fatal("sending task did not complete, state is " + st2.Status);
            }
            if (rt2.Result != 2)
            {
                t.Fatal("received value (" + rt2.Result + ") is not what we sent (2)");
            }
        }
Example #2
0
        public static void receiving_async_returns_a_waiting_task_which_is_complete_by_sending_a_value_async(Test t)
        {
            var ch = new BufferedChannel <int>(3);
            var rt = ch.ReceiveAsync();

            if (rt == null)
            {
                t.Fatal("returned task was null");
            }
            if (rt.IsCompleted)
            {
                t.Fatal("returned task was complete");
            }
            var st = ch.SendAsync(2);

            if (st == null)
            {
                t.Fatal("SendAsync returned null");
            }
            if (!st.IsCompleted)
            {
                t.Fatal("SendAsync is not complete");
            }
            if (rt.Wait(100) == false || rt.IsCompleted == false)
            {
                t.Fatal("receiver task did not complete");
            }
            if (rt.Result != 2)
            {
                t.Fatal("received value (" + rt.Result + ") is not what we sent (2)");
            }
        }
Example #3
0
        public static void receiving_async_returns_a_waiting_task_which_is_complete_by_trying_to_send_a_value(Test t)
        {
            var ch = new BufferedChannel <int>(3);
            var rt = ch.ReceiveAsync();

            if (rt == null)
            {
                t.Fatal("returned task was null");
            }
            if (rt.IsCompleted)
            {
                t.Fatal("returned task was complete");
            }
            if (ch.TrySend(2) != true)
            {
                t.Fatal("failed to send when a receiver was waiting");
            }
            if (rt.Wait(100) == false || rt.IsCompleted == false)
            {
                t.Fatal("receiver task did not complete");
            }
            if (rt.Result != 2)
            {
                t.Fatal("received value (" + rt.Result + ") is not what we sent (2)");
            }
        }
Example #4
0
        public static void closing_the_channel_with_a_waiting_receiver_cancel_the_receivers_task(Test t)
        {
            var ch = new BufferedChannel <int>(3);
            var rt = ch.ReceiveAsync();

            if (rt == null)
            {
                t.Fatal("returned task was null");
            }
            if (rt.IsCompleted)
            {
                t.Fatal("returned task was complete already!");
            }
            ch.Close();
            try
            {
                if (!rt.Wait(100))
                {
                    t.Fatal("task did not completed");
                }
            }
            catch (AggregateException)
            {
                if (!rt.IsCanceled)
                {
                    t.Fatal("task is not cancelled");
                }
            }
        }
Example #5
0
        public static void receiving_async_returns_a_waiting_task(Test t)
        {
            var ch = new BufferedChannel <int>(3);
            var i  = ch.ReceiveAsync();

            if (i == null)
            {
                t.Fatal("returned task was null");
            }
            if (i.IsCompleted)
            {
                t.Fatal("returned task was complete");
            }
        }
Example #6
0
        public static void ReceiveAsync_on_a_closed_channel_return_cancelled_task(Test t)
        {
            var ch = new BufferedChannel <int>(3);

            ch.Close();
            var rt = ch.ReceiveAsync();

            if (rt == null)
            {
                t.Fatal("ReceiveAsync returned null");
            }
            if (!rt.IsCanceled)
            {
                t.Fatal("ReceiveAsync is not cancelled");
            }
        }