public void PreviousAndNext()
        {
            var manager = new PlaylistManager();
            manager.AddAndReplaceItems(threeItems);

            Assert.IsFalse(manager.CanPreviousItem);
            Assert.IsFalse(manager.CanNextItem);

            AssertHelper.PropertyChangedEvent(manager, x => x.CanNextItem, () => manager.CurrentItem = threeItems[0]);
            Assert.IsFalse(manager.CanPreviousItem);
            Assert.IsTrue(manager.CanNextItem);

            AssertHelper.PropertyChangedEvent(manager, x => x.CanPreviousItem, () => manager.NextItem());
            Assert.AreEqual(threeItems[1], manager.CurrentItem);
            Assert.IsTrue(manager.CanPreviousItem);
            Assert.IsTrue(manager.CanNextItem);

            AssertHelper.PropertyChangedEvent(manager, x => x.CanNextItem, () => manager.NextItem());
            Assert.AreEqual(threeItems[2], manager.CurrentItem);
            Assert.IsTrue(manager.CanPreviousItem);
            Assert.IsFalse(manager.CanNextItem);

            AssertHelper.PropertyChangedEvent(manager, x => x.CanNextItem, () => manager.PreviousItem());
            Assert.AreEqual(threeItems[1], manager.CurrentItem);
            Assert.IsTrue(manager.CanPreviousItem);
            Assert.IsTrue(manager.CanNextItem);
        }
        public void PreviousAndNextWithShuffle()
        {
            var randomService = new MockRandomService();
            int randomNumber = 0;
            int lastMaxValue = -1;
            randomService.NextRandomNumberStub = maxValue =>
            {
                lastMaxValue = maxValue;
                return randomNumber;
            };

            var manager = new PlaylistManager(3, randomService);
            manager.AddAndReplaceItems(threeItems);
            manager.Shuffle = true;

            Assert.IsFalse(manager.CanPreviousItem);
            Assert.IsFalse(manager.CanNextItem);

            AssertHelper.PropertyChangedEvent(manager, x => x.CanNextItem, () => manager.CurrentItem = threeItems[0]);
            Assert.IsFalse(manager.CanPreviousItem);
            Assert.IsTrue(manager.CanNextItem);

            randomNumber = 1;
            AssertHelper.PropertyChangedEvent(manager, x => x.CanPreviousItem, () => manager.NextItem());
            Assert.AreEqual(1, lastMaxValue);
            Assert.AreEqual(threeItems[2], manager.CurrentItem);
            Assert.IsTrue(manager.CanPreviousItem);
            Assert.IsTrue(manager.CanNextItem);

            randomNumber = 0;
            AssertHelper.PropertyChangedEvent(manager, x => x.CanNextItem, () => manager.NextItem());
            Assert.AreEqual(0, lastMaxValue);
            Assert.AreEqual(threeItems[1], manager.CurrentItem);
            Assert.IsTrue(manager.CanPreviousItem);
            Assert.IsFalse(manager.CanNextItem);

            AssertHelper.PropertyChangedEvent(manager, x => x.CanNextItem, () => manager.PreviousItem());
            Assert.AreEqual(threeItems[2], manager.CurrentItem);
            Assert.IsTrue(manager.CanPreviousItem);
            Assert.IsTrue(manager.CanNextItem);

            AssertHelper.PropertyChangedEvent(manager, x => x.CanPreviousItem, () => manager.PreviousItem());
            Assert.AreEqual(threeItems[0], manager.CurrentItem);
            Assert.IsFalse(manager.CanPreviousItem);
            Assert.IsTrue(manager.CanNextItem);
        }
        public void NextWithShuffleAndRepeatAndOneItem()
        {
            var manager = new PlaylistManager();
            manager.AddAndReplaceItems(threeItems.Take(1));
            manager.Shuffle = true;
            manager.Repeat = true;
            manager.CurrentItem = threeItems[0];

            manager.NextItem();
            Assert.AreEqual(threeItems[0], manager.CurrentItem);
        }
        public void PreviousAndNextWithClear()
        {
            var manager = new PlaylistManager();
            manager.AddAndReplaceItems(threeItems);
            manager.CurrentItem = threeItems[1];

            Assert.IsTrue(manager.CanPreviousItem);
            AssertHelper.PropertyChangedEvent(manager, x => x.CanPreviousItem, () => manager.ClearItems());
            Assert.IsFalse(manager.CanPreviousItem);
            AssertHelper.ExpectedException<InvalidOperationException>(() => manager.PreviousItem());

            manager.AddAndReplaceItems(threeItems);
            manager.CurrentItem = threeItems[1];

            Assert.IsTrue(manager.CanNextItem);
            AssertHelper.PropertyChangedEvent(manager, x => x.CanNextItem, () => manager.ClearItems());
            Assert.IsFalse(manager.CanNextItem);
            AssertHelper.ExpectedException<InvalidOperationException>(() => manager.NextItem());
        }
        public void PreviousAndNextWithRepeat()
        {
            var manager = new PlaylistManager();
            manager.AddAndReplaceItems(threeItems);
            manager.Repeat = true;
            manager.CurrentItem = threeItems[0];

            for (int i = 0; i < 5; i++)
            {
                Assert.AreEqual(threeItems[i % 3], manager.CurrentItem);
                Assert.IsTrue(manager.CanNextItem);
                manager.NextItem();
            }

            manager.Shuffle = true;

            for (int i = 0; i < 5; i++)
            {
                Assert.IsTrue(manager.CanNextItem);
                manager.NextItem();
            }
        }
        public void ResetNextWithShuffle()
        {
            var manager = new PlaylistManager();
            manager.AddAndReplaceItems(threeItems);
            manager.Shuffle = true;
            manager.CurrentItem = threeItems[0];

            for (int i = 0; i < 2; i++)
            {
                Assert.IsTrue(manager.CanNextItem);
                manager.NextItem();
            }

            Assert.IsFalse(manager.CanNextItem);

            manager.Reset();

            for (int i = 0; i < 2; i++)
            {
                Assert.IsTrue(manager.CanNextItem);
                manager.NextItem();
            }

            Assert.IsFalse(manager.CanNextItem);
        }