public async Task InvokeAsync_DerivedEventArgsWithFaultedBackgroundTasks_ShouldCompleteFaulted()
        {
            // Arrange.
            var error = new Exception();

            DerivedEvent += (sender, e) => e.RegisterBackgroundTask(Task.CompletedTask);
            DerivedEvent += (sender, e) => e.RegisterBackgroundTask(async cancellationToken =>
            {
                await Task.Yield();

                cancellationToken.ThrowIfCancellationRequested();
            });
            DerivedEvent += (sender, e) => e.RegisterBackgroundTask(async cancellationToken =>
            {
                await Task.Yield();

                throw error;
            });

            using (var cancellationSource = new CancellationTokenSource())
            {
                cancellationSource.Cancel();

                // Act.
                var args   = new DerivedEventArgs(cancellationSource.Token);
                var thrown = await Assert.ThrowsAsync <Exception>(() => DerivedEvent.InvokeAsync(this, args));

                // Assert.
                Assert.Equal(error, thrown);
            }
        }
        public async Task InvokeAsync_DerivedEventArgsWithSucceededBackgroundTasks_ShouldCompleteSucceeded()
        {
            // Arrange.
            DerivedEvent += (sender, e) => e.RegisterBackgroundTask(Task.CompletedTask);

            // Act.
            var args = new DerivedEventArgs(CancellationToken.None);
            await DerivedEvent.InvokeAsync(this, args);
        }
Beispiel #3
0
        public static void GotDerivedEvent()
        {
            var x    = new RaisingClass();
            var args = new DerivedEventArgs();

            var evt = Assert.RaisesAny <EventArgs>(
                h => x.Completed += h,
                h => x.Completed -= h,
                () => x.RaiseWithArgs(args));

            Assert.NotNull(evt);
            Assert.Equal(x, evt.Sender);
            Assert.Equal(args, evt.Arguments);
        }
Beispiel #4
0
        public static async Task GotDerivedEvent()
        {
            var x    = new RaisingClass();
            var args = new DerivedEventArgs();

            var evt = await Assert.RaisesAnyAsync <EventArgs>(
                h => x.Completed += h,
                h => x.Completed -= h,
                () => Task.Run(() => x.RaiseWithArgs(args)));

            Assert.NotNull(evt);
            Assert.Equal(x, evt.Sender);
            Assert.Equal(args, evt.Arguments);
        }
Beispiel #5
0
        public static void GotDerivedEvent()
        {
            var x = new RaisingClass();
            var args = new DerivedEventArgs();

            var evt = Assert.RaisesAny<EventArgs>(
                h => x.Completed += h,
                h => x.Completed -= h,
                () => x.RaiseWithArgs(args));

            Assert.NotNull(evt);
            Assert.Equal(x, evt.Sender);
            Assert.Equal(args, evt.Arguments);
        }
Beispiel #6
0
        public static async Task GotDerivedEvent()
        {
            var x = new RaisingClass();
            var args = new DerivedEventArgs();

            var evt = await Assert.RaisesAnyAsync<EventArgs>(
                h => x.Completed += h,
                h => x.Completed -= h,
                () => Task.Run(() => x.RaiseWithArgs(args)));

            Assert.NotNull(evt);
            Assert.Equal(x, evt.Sender);
            Assert.Equal(args, evt.Arguments);
        }