Wrote some more tests

PixiEditor/Models/DataHolders/Document.cs

@@ -385,48 +385,6 @@ namespace PixiEditor.Models.DataHolders
             }
         }
 
-        private void MoveLayerProcess(object[] parameter)
-        {
-            int layerIndex = (int)parameter[0];
-            int amount = (int)parameter[1];
-            MoveLayerIndexBy(layerIndex, amount);
-        }
-
-        private void RestoreLayerProcess(object[] parameters)
-        {
-            RestoreLayersProcess((Layer[])parameters[0], (UndoLayer[])parameters[1]);
-        }
-
-        private void RestoreLayersProcess(Layer[] layers, UndoLayer[] layersData)
-        {
-            for (int i = 0; i < layers.Length; i++)
-            {
-                Layer layer = layers[i];
-
-                Layers.Insert(layersData[i].LayerIndex, layer);
-                if (layer.IsActive)
-                {
-                    SetActiveLayer(Layers.IndexOf(layer));
-                }
-            }
-        }
-
-        private void RemoveLayerProcess(object[] parameters)
-        {
-            if (parameters != null && parameters.Length > 0 && parameters[0] is Guid layerGuid)
-            {
-                Layer layer = Layers.First(x => x.LayerGuid == layerGuid);
-                int index = Layers.IndexOf(layer);
-                bool wasActive = layer.IsActive;
-                Layers.Remove(layer);
-
-                if (wasActive)
-                {
-                    SetNextLayerAsActive(index);
-                }
-            }
-        }
-
         /// <summary>
         ///     Resizes all document layers using NearestNeighbor interpolation.
         /// </summary>
@@ -517,6 +475,48 @@ namespace PixiEditor.Models.DataHolders
                     "Center content"));
         }
 
+        private void MoveLayerProcess(object[] parameter)
+        {
+            int layerIndex = (int)parameter[0];
+            int amount = (int)parameter[1];
+            MoveLayerIndexBy(layerIndex, amount);
+        }
+
+        private void RestoreLayerProcess(object[] parameters)
+        {
+            RestoreLayersProcess((Layer[])parameters[0], (UndoLayer[])parameters[1]);
+        }
+
+        private void RestoreLayersProcess(Layer[] layers, UndoLayer[] layersData)
+        {
+            for (int i = 0; i < layers.Length; i++)
+            {
+                Layer layer = layers[i];
+
+                Layers.Insert(layersData[i].LayerIndex, layer);
+                if (layer.IsActive)
+                {
+                    SetActiveLayer(Layers.IndexOf(layer));
+                }
+            }
+        }
+
+        private void RemoveLayerProcess(object[] parameters)
+        {
+            if (parameters != null && parameters.Length > 0 && parameters[0] is Guid layerGuid)
+            {
+                Layer layer = Layers.First(x => x.LayerGuid == layerGuid);
+                int index = Layers.IndexOf(layer);
+                bool wasActive = layer.IsActive;
+                Layers.Remove(layer);
+
+                if (wasActive)
+                {
+                    SetNextLayerAsActive(index);
+                }
+            }
+        }
+
         private void SetAsActiveOnClick(object obj)
         {
             XamlAccesibleViewModel.BitmapManager.MouseController.StopRecordingMouseMovementChanges();

PixiEditorTests/ModelsTests/DataHoldersTests/DocumentTests.cs

@@ -145,5 +145,142 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
             Assert.Equal(midWidth, manager.ActiveDocument.Layers[1].OffsetX);
             Assert.Equal(midHeight, manager.ActiveDocument.Layers[1].OffsetY);
         }
+
+        [Fact]
+        public void TestThatSetNextActiveLayerSetsLayerBelow()
+        {
+            Document doc = new Document(10, 10);
+            doc.Layers.Add(new PixiEditor.Models.Layers.Layer("Test"));
+            doc.Layers.Add(new PixiEditor.Models.Layers.Layer("Test 2"));
+
+            doc.SetActiveLayer(1);
+
+            doc.SetNextLayerAsActive(1);
+
+            Assert.False(doc.Layers[1].IsActive);
+            Assert.True(doc.Layers[0].IsActive);
+        }
+
+        [Fact]
+        public void TestThatAddNewLayerAddsUndoChange()
+        {
+            Document document = new Document(10, 10);
+
+            document.AddNewLayer("Test");
+            document.AddNewLayer("Test2");
+
+            Assert.Single(document.UndoManager.UndoStack);
+        }
+
+        [Fact]
+        public void TestThatAddNewLayerUndoProcessWorks()
+        {
+            Document document = new Document(10, 10);
+
+            document.AddNewLayer("Test");
+            document.AddNewLayer("Test2");
+
+            document.UndoManager.Undo();
+
+            Assert.Single(document.Layers);
+        }
+
+        [Fact]
+        public void TestThatAddNewLayerRedoProcessWorks()
+        {
+            Document document = new Document(10, 10);
+
+            document.AddNewLayer("Test");
+            document.AddNewLayer("Test2");
+
+            document.UndoManager.Undo();
+            document.UndoManager.Redo();
+
+            Assert.Equal(2, document.Layers.Count);
+        }
+
+        [Fact]
+        public void TestThatRemoveLayerUndoProcessWorks()
+        {
+            Document document = new Document(10, 10);
+
+            document.AddNewLayer("Test");
+            document.AddNewLayer("Test2");
+
+            document.RemoveLayer(1);
+
+            document.UndoManager.Undo();
+
+            Assert.Equal(2, document.Layers.Count);
+        }
+
+        [Fact]
+        public void TestThatRemoveLayerRedoProcessWorks()
+        {
+            Document document = new Document(10, 10);
+
+            document.AddNewLayer("Test");
+            document.AddNewLayer("Test2");
+
+            document.RemoveLayer(1);
+
+            document.UndoManager.Undo();
+            document.UndoManager.Redo();
+
+            Assert.Single(document.Layers);
+        }
+
+        [Theory]
+        [InlineData(2, 0, 1)]
+        [InlineData(2, 1, -1)]
+        [InlineData(3, 1, 1)]
+        [InlineData(3, 2, -2)]
+        [InlineData(10, 9, -5)]
+        public void TestThatMoveLayerIndexByWorks(int layersAmount, int index, int amount)
+        {
+            Document document = new Document(10, 10);
+            for (int i = 0; i < layersAmount; i++)
+            {
+                document.AddNewLayer("Layer " + i);
+            }
+
+            Guid oldGuid = document.Layers[index].LayerGuid;
+            document.MoveLayerIndexBy(index, amount);
+
+            Assert.Equal(oldGuid, document.Layers[index + amount].LayerGuid);
+        }
+
+        [Fact]
+        public void TestThatMoveLayerIndexByUndoProcessWorks()
+        {
+            Document document = new Document(10, 10);
+
+            document.AddNewLayer("Test");
+            document.AddNewLayer("Test2");
+
+            document.MoveLayerIndexBy(0, 1);
+
+            document.UndoManager.Undo();
+
+            Assert.Equal("Test2", document.Layers[1].Name);
+            Assert.Equal("Test", document.Layers[0].Name);
+        }
+
+        [Fact]
+        public void TestThatMoveLayerIndexByRedoProcessWorks()
+        {
+            Document document = new Document(10, 10);
+
+            document.AddNewLayer("Test");
+            document.AddNewLayer("Test2");
+
+            document.MoveLayerIndexBy(0, 1);
+
+            document.UndoManager.Undo();
+            document.UndoManager.Redo();
+
+            Assert.Equal("Test", document.Layers[1].Name);
+            Assert.Equal("Test2", document.Layers[0].Name);
+        }
     }
 }