Пример #1
0
        public void Wait_DispatchTime()
        {
            TestRuntime.AssertXcodeVersion(8, 0);

            var called   = false;
            var callback = new Action(() => called = true);

            using (var db = new DispatchBlock(callback)) {
                using (var queue = new DispatchQueue("Background")) {
                    queue.Activate();
                    var rv = db.Wait(new DispatchTime(DispatchTime.Now, TimeSpan.FromSeconds(0.1)));
                    Assert.AreNotEqual(0, rv, "Timed Out");

                    queue.DispatchAsync(db);
                    rv = db.Wait(new DispatchTime(DispatchTime.Now, TimeSpan.FromSeconds(5)));
                    Assert.AreEqual(0, rv, "Timed Out 2");
                    Assert.IsTrue(called, "Called");
                }
            }
        }
Пример #2
0
        public void DispatchBarrierAsync()
        {
            TestRuntime.AssertSystemVersion(PlatformName.iOS, 8, 0, throwIfOtherPlatform: false);
            TestRuntime.AssertSystemVersion(PlatformName.MacOSX, 10, 10, throwIfOtherPlatform: false);

            using (var queue = new DispatchQueue("DispatchBarrierAsync")) {
                var called   = false;
                var callback = new Action(() => called = true);
                queue.DispatchBarrierAsync(callback);
                TestRuntime.RunAsync(TimeSpan.FromSeconds(5), () => { }, () => called);
                Assert.IsTrue(called, "Called");

                called = false;
                using (var dg = new DispatchBlock(callback)) {
                    queue.DispatchBarrierAsync(dg);
                    dg.Wait(TimeSpan.FromSeconds(5));
                }
                Assert.IsTrue(called, "Called DispatchBlock");
            }
        }
Пример #3
0
        public void Constructors()
        {
            TestRuntime.AssertXcodeVersion(8, 0);

            var called   = false;
            var callback = new Action(() => called = true);
            DispatchBlockFlags flags;

            Assert.Throws <ArgumentNullException> (() => new DispatchBlock(null), "ANE 1");
            Assert.Throws <ArgumentNullException> (() => new DispatchBlock(null, DispatchBlockFlags.AssignCurrent), "ANE 2");
            Assert.Throws <ArgumentNullException> (() => new DispatchBlock((Action)null, DispatchBlockFlags.AssignCurrent, DispatchQualityOfService.Background, 2), "ANE 3");
            Assert.Throws <ArgumentNullException> (() => new DispatchBlock((DispatchBlock)null, DispatchBlockFlags.AssignCurrent, DispatchQualityOfService.Background, 2), "ANE 4");
            // Invalid input results in NULL and an exception
            Assert.Throws <Exception> (() => new DispatchBlock(callback, (DispatchBlockFlags)12345678), "E 1");
            Assert.Throws <Exception> (() => new DispatchBlock(callback, (DispatchBlockFlags)12345678, DispatchQualityOfService.UserInteractive, 0), "E 2");
            Assert.Throws <Exception> (() => new DispatchBlock(callback, DispatchBlockFlags.None, (DispatchQualityOfService)12345678, 0), "E 3");
            Assert.Throws <Exception> (() => new DispatchBlock(callback, DispatchBlockFlags.None, DispatchQualityOfService.Default, 12345678), "E 4");

            called = false;
            using (var db = new DispatchBlock(callback)) {
                using (var queue = new DispatchQueue("Background")) {
                    queue.Activate();
                    queue.DispatchAsync(db);
                    var rv = db.Wait(new DispatchTime(DispatchTime.Now, TimeSpan.FromSeconds(5)));
                    Assert.AreEqual(0, rv, "Timed Out A");
                    Assert.IsTrue(called, "Called A");
                }
            }

            called = false;
            flags  = DispatchBlockFlags.None;
            using (var db = new DispatchBlock(callback, flags)) {
                using (var queue = new DispatchQueue("Background")) {
                    queue.Activate();
                    queue.DispatchAsync(db);
                    var rv = db.Wait(new DispatchTime(DispatchTime.Now, TimeSpan.FromSeconds(5)));
                    Assert.AreEqual(0, rv, "Timed Out " + flags);
                    Assert.IsTrue(called, "Called " + flags);
                }
            }

            called = false;
            flags  = DispatchBlockFlags.AssignCurrent;
            using (var db = new DispatchBlock(callback, flags)) {
                using (var queue = new DispatchQueue("Background")) {
                    queue.Activate();
                    queue.DispatchAsync(db);
                    var rv = db.Wait(new DispatchTime(DispatchTime.Now, TimeSpan.FromSeconds(5)));
                    Assert.AreEqual(0, rv, "Timed Out " + flags);
                    Assert.IsTrue(called, "Called " + flags);
                }
            }


            called = false;
            flags  = DispatchBlockFlags.Detached;
            using (var db = new DispatchBlock(callback, flags)) {
                using (var queue = new DispatchQueue("Background")) {
                    queue.Activate();
                    queue.DispatchAsync(db);
                    var rv = db.Wait(new DispatchTime(DispatchTime.Now, TimeSpan.FromSeconds(5)));
                    Assert.AreEqual(0, rv, "Timed Out " + flags);
                    Assert.IsTrue(called, "Called " + flags);
                }
            }

            called = false;
            flags  = DispatchBlockFlags.Detached;
            using (var db = new DispatchBlock(callback, flags, DispatchQualityOfService.Background, -8)) {
                using (var queue = new DispatchQueue("Background")) {
                    queue.Activate();
                    queue.DispatchAsync(db);
                    var rv = db.Wait(new DispatchTime(DispatchTime.Now, TimeSpan.FromSeconds(5)));
                    Assert.AreEqual(0, rv, "Timed Out Background 8" + flags);
                    Assert.IsTrue(called, "Called Background 8" + flags);
                }
            }
        }