public async Task It_writes_parallel_console_writes_to_separate_buffers()
        {
            var writer = new MultiplexingTextWriter();

            var barrier = new Barrier(10);

            var outputs = await Task.WhenAll(Enumerable.Range(1, 10).Select(i =>
            {
                return(Task.Run(async() =>
                {
                    using var _ = writer.EnsureInitializedForCurrentAsyncContext();

                    barrier.SignalAndWait();

                    writer.Write($"Hello from {i}");
                    writer.Write('\n');

                    await Task.Yield();

                    barrier.SignalAndWait();

                    await writer.WriteLineAsync($"Goodbye from {i}");

                    barrier.SignalAndWait();

                    return (i, text: writer.ToString());
                }));
            }));

            foreach (var output in outputs)
            {
                output.text.Should().Be($"Hello from {output.i}\nGoodbye from {output.i}{NewLine}");
            }
        }
        public void Disposal_of_inner_contexts_doe_not_dispose_writer()
        {
            var innerWriter = new TestWriter();
            var writer      = new MultiplexingTextWriter(() => innerWriter);

            using var outer = writer.EnsureInitializedForCurrentAsyncContext();
            writer.Write("outer");
            var inner = writer.EnsureInitializedForCurrentAsyncContext();

            writer.Write(inner);

            inner.Dispose();

            writer.Writers.Count().Should().Be(1);
            innerWriter.Disposed.Should().BeFalse();
        }
        public void Write_operations_on_MultiplexingStringWriter_are_observable_and_produce_one_event_per_top_level_write_invocation(
            Action <TextWriter> write,
            string expectedValue)
        {
            var writer = new MultiplexingTextWriter();

            using var _ = writer.EnsureInitializedForCurrentAsyncContext();

            using var events = writer.GetObservable().ToSubscribedList();

            write(writer);

            events.Should()
            .ContainSingle()
            .Which
            .Should()
            .Be(expectedValue);
        }
        public void Initialization_per_context_is_idempotent()
        {
            var writer = new MultiplexingTextWriter(() => new TestWriter());

            using var outer = writer.EnsureInitializedForCurrentAsyncContext();
            writer.Write("hi!");
            writer.Writers.Count().Should().Be(1);

            using var inner = writer.EnsureInitializedForCurrentAsyncContext();

            writer.Writers
            .Should()
            .ContainSingle()
            .Which
            .As <TestWriter>()
            .Disposed
            .Should()
            .BeFalse();
        }