public void ObservableMasterSlaveCollectionMultipleRedoCutoff(ObservableMasterSlaveCollection <int> list)
    {
        // ARRANGE
        EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;

        list.Add(15);
        list.Add(89);
        list.Add(3);
        list.Add(2);
        list.Add(57);

        // ACT
        list.Undo();
        list.Undo();
        list.Undo();
        list.Redo();

        list.Add(74);

        list.Redo();
        list.Redo();
        list.Redo();

        // ASSERT
        Assert.True(list.Contains(3));
        Assert.False(list.Contains(57));
        Assert.False(list.Contains(2));
        Assert.True(list.Contains(74));
    }
    public void ObservableMasterSlaveCollectionUndoMultipleOperations(ObservableMasterSlaveCollection <int> list)
    {
        // ARRANGE
        EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;

        list.Add(18);
        list.RemoveAt(1);
        list.Insert(
            3,
            5);
        list.Clear();
        list.Add(7);

        // Act & Assert groups
        Assert.True(list.Count == 1);
        Assert.True(list[0] == 7);

        // Level one
        list.Undo();
        Assert.True(list.Count == 0);

        // Level two
        list.Undo();
        Assert.True(list.Count == 6);
        Assert.True(list[3] == 5);

        // Level three
        list.Undo();
        Assert.True(list.Count == 5);
        Assert.True(list[3] == 4);

        // Level four
        list.Undo();
        Assert.True(list.Count == 6);
        Assert.True(list[1] == 7);

        // Level two
        list.Undo();
        Assert.True(list.Count == 5);
        Assert.False(list.Contains(18));

        // Redo
        list.Redo();
        list.Redo();
        list.Redo();
        list.Redo();
        Assert.True(list.Count == 0);
    }
    public void ObservableMasterSlaveCollectionRedoAtRemoveAtWithSlave(ObservableMasterSlaveCollection <int> list)
    {
        // ARRANGE
        EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;

        using (var slaveCollection = new ObservableList <int>
        {
            -1,
            -5,
            -12,
        })
        {
            list.SetSlaveList(slaveCollection);

            list.RemoveAt(2);
            Assert.True(list[2] == 23);
            list.Undo();
            Assert.True(list[2] == 19);

            // ACT
            list.Redo();

            // ASSERT
            Assert.True(list[2] == 23);

            Assert.True(list.Contains(-5));
        }
    }
    public void ObservableMasterSlaveCollectionUndoAtClearWithSlave(ObservableMasterSlaveCollection <int> list)
    {
        // ARRANGE
        EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;

        using (var slaveCollection = new ObservableList <int>
        {
            -1,
            -5,
            -12,
        })
        {
            list.SetSlaveList(slaveCollection);

            list.Clear();

            Assert.False(list.Contains(1));
            Assert.False(list.Contains(7));
            Assert.False(list.Contains(19));
            Assert.False(list.Contains(23));
            Assert.False(list.Contains(4));

            // ACT
            list.Undo();

            // ASSERT
            Assert.True(list.Contains(1));
            Assert.True(list.Contains(7));
            Assert.True(list.Contains(19));
            Assert.True(list.Contains(23));
            Assert.True(list.Contains(4));

            Assert.True(list.Contains(-5));
        }
    }
    public void ObservableMasterSlaveCollectionRedoAtClear(ObservableMasterSlaveCollection <int> list)
    {
        // ARRANGE
        EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;

        list.Clear();

        list.Undo();

        Assert.True(list.Contains(1));
        Assert.True(list.Contains(7));
        Assert.True(list.Contains(19));
        Assert.True(list.Contains(23));
        Assert.True(list.Contains(4));

        // ACT
        list.Redo();

        // ASSERT
        Assert.False(list.Contains(1));
        Assert.False(list.Contains(7));
        Assert.False(list.Contains(19));
        Assert.False(list.Contains(23));
        Assert.False(list.Contains(4));
    }
    public void ObservableMasterSlaveCollectionMultipleRedoCutoffWithSlave(
        ObservableMasterSlaveCollection <int> list)
    {
        // ARRANGE
        EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;

        using (var slaveCollection = new ObservableList <int>
        {
            -1,
            -5,
            -12,
        })
        {
            list.SetSlaveList(slaveCollection);

            list.Add(15);
            list.Add(89);
            list.Add(3);
            list.Add(2);
            list.Add(57);

            // ACT
            list.Undo();
            list.Undo();
            list.Undo();
            list.Redo();

            list.Add(74);

            list.Redo();
            list.Redo();
            list.Redo();

            // ASSERT
            Assert.True(list.Contains(3));
            Assert.False(list.Contains(57));
            Assert.False(list.Contains(2));
            Assert.True(list.Contains(74));

            Assert.True(list.Contains(-5));
        }
    }
    public void ObservableMasterSlaveCollectionUndoAtAdd(ObservableMasterSlaveCollection <int> list)
    {
        // ARRANGE
        EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;

        // ACT
        list.Add(6);

        Assert.True(list.Contains(6));

        list.Undo();

        // ASSERT
        Assert.False(list.Contains(6));
    }
    public void ObservableMasterSlaveCollectionRedoAtRemoveAt(ObservableMasterSlaveCollection <int> list)
    {
        // ARRANGE
        EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;

        list.RemoveAt(2);
        Assert.True(list[2] == 23);
        list.Undo();
        Assert.True(list[2] == 19);

        // ACT
        list.Redo();

        // ASSERT
        Assert.True(list[2] == 23);
    }
    public void ObservableMasterSlaveCollectionUndoMultipleOperationsWithSlave(
        ObservableMasterSlaveCollection <int> list)
    {
        // ARRANGE
        EnvironmentSettings.AlwaysSuppressCurrentSynchronizationContext = true;

        using (var slaveCollection = new ObservableList <int>
        {
            -1,
            -5,
            -12,
        })
        {
            list.SetSlaveList(slaveCollection);

            list.Add(18);
            list.RemoveAt(1);
            list.Insert(
                3,
                5);
            list.Clear();
            list.Add(7);

            // Act & Assert groups
            Assert.True(list.Count == 4);
            Assert.True(list[0] == 7);

            // Level one
            list.Undo();
            Assert.True(list.Count == 3);

            // Level two
            list.Undo();
            Assert.True(list.Count == 9);
            Assert.True(list[3] == 5);

            // Level three
            list.Undo();
            Assert.True(list.Count == 8);
            Assert.True(list[3] == 4);

            // Level four
            list.Undo();
            Assert.True(list.Count == 9);
            Assert.True(list[1] == 7);

            // Level two
            list.Undo();
            Assert.True(list.Count == 8);
            Assert.False(list.Contains(18));

            // Redo
            list.Redo();
            list.Redo();
            list.Redo();
            list.Redo();
            Assert.True(list.Count == 3);

            Assert.True(list.Contains(-5));
        }
    }