Example #1
0
        public void TestMultipleAsynchronousUpdates()
        {
            using (
                ParticleSystem <SimpleParticle> system = new ParticleSystem <SimpleParticle>(10)
                ) {
                using (WaitAffector waitAffector = new WaitAffector()) {
                    for (int index = 0; index < 40; ++index)
                    {
                        system.AddParticle(new SimpleParticle());
                    }
                    system.Affectors.Add(waitAffector);

                    DummyCallbackReceiver receiver = new DummyCallbackReceiver();
                    for (int run = 0; run < 3; ++run)
                    {
                        waitAffector.Halt();
                        IAsyncResult asyncResult = system.BeginUpdate(
                            2, 4, receiver.Callback, receiver
                            );
                        try {
                            Assert.IsNotNull(asyncResult.AsyncWaitHandle);
                            Assert.AreSame(asyncResult.AsyncState, receiver);
                            Assert.IsFalse(asyncResult.CompletedSynchronously);
                        }
                        finally {
                            waitAffector.Continue();
                            system.EndUpdate(asyncResult);
                        }

                        Assert.IsTrue(receiver.CallbackEvent.WaitOne(1000));
                        Assert.AreEqual(run + 1, receiver.CallbackCallCount);
                    }
                }
            }
        }
Example #2
0
        public void TestMultipleAsynchronousPrunes()
        {
            using (
                ParticleSystem <SimpleParticle> system = new ParticleSystem <SimpleParticle>(10)
                ) {
                DummyCallbackReceiver receiver = new DummyCallbackReceiver();
                for (int run = 0; run < 3; ++run)
                {
                    IAsyncResult asyncResult = system.BeginPrune(
                        delegate(ref SimpleParticle particle) { return(false); },
                        receiver.Callback, receiver
                        );
                    try {
                        Assert.IsNotNull(asyncResult.AsyncWaitHandle);
                        Assert.AreSame(asyncResult.AsyncState, receiver);
                        Assert.IsFalse(asyncResult.CompletedSynchronously);
                    }
                    finally {
                        system.EndPrune(asyncResult);
                    }

                    Assert.IsTrue(receiver.CallbackEvent.WaitOne(1000));
                    Assert.AreEqual(run + 1, receiver.CallbackCallCount);
                }
            }
        }