public void Race()
        {
            for (int i = 0; i < TestHelper.RACE_LOOPS; i++)
            {
                var subj = new PublishSubject <int>();

                var o = subj.Cache();

                var to1 = o.Test();

                var to2 = new TestObserver <int>();

                TestHelper.Race(
                    () =>
                {
                    for (int j = 0; j < 1000; j++)
                    {
                        subj.OnNext(j);
                    }
                    subj.OnCompleted();
                },
                    () =>
                {
                    while (to1.ItemCount < 250)
                    {
                        ;
                    }
                    o.Subscribe(to2);
                }
                    );

                to1.AssertValueCount(1000)
                .AssertNoError()
                .AssertCompleted();

                var list = to1.Items;
                for (int j = 0; j < 1000; j++)
                {
                    Assert.AreEqual(j, list[j]);
                }

                to2
                .AwaitDone(TimeSpan.FromSeconds(5))
                .AssertValueCount(1000)
                .AssertNoError()
                .AssertCompleted();

                list = to2.Items;
                for (int j = 0; j < 1000; j++)
                {
                    Assert.AreEqual(j, list[j]);
                }
            }
        }
        public void Dispose_Upfront()
        {
            var subj = new PublishSubject <int>();

            var src = subj.Cache();

            Assert.False(subj.HasObservers);

            src.Test(true).AssertEmpty();

            Assert.False(subj.HasObservers);
        }
        public void Take()
        {
            var subj = new PublishSubject <int>();

            var src = subj.Cache();

            var to1 = src.Take(1).Test();

            subj.OnNext(1);

            to1.AssertResult(1);

            subj.OnNext(2);

            var to2 = src.Take(1).Test();

            to2.AssertResult(1);
        }
        public void Dispose_Upfront_NonEmpty()
        {
            var subj = new PublishSubject <int>();

            var src = subj.Cache();

            var to1 = src.Test();

            Assert.True(subj.HasObservers);

            var to2 = src.Test(true).AssertEmpty();

            var to3 = src.Test().Cancel();

            subj.OnCompleted();

            to1.AssertResult();

            to2.AssertEmpty();

            to3.AssertEmpty();
        }