Covered LayerStructure in tests

PixiEditor/Models/DataHolders/Document/Document.Layers.cs

@@ -538,7 +538,7 @@ namespace PixiEditor.Models.DataHolders
             bool above = (bool)parameter[2];
 
             GuidStructureItem group = LayerStructure.GetGroupByGuid(groupGuid);
-            GuidStructureItem referenceLayergroup = LayerStructure.GetGroupByLayer(referenceLayerGuid);
+            GuidStructureItem referenceLayerGroup = LayerStructure.GetGroupByLayer(referenceLayerGuid);
 
             Layer referenceLayer = Layers.First(x => x.LayerGuid == referenceLayerGuid);
 
@@ -554,11 +554,11 @@ namespace PixiEditor.Models.DataHolders
 
             int newIndex = CalculateNewIndex(layerIndex, above, oldIndex);
 
-            LayerStructure.MoveGroup(groupGuid, group?.Parent?.GroupGuid, newIndex);
+            LayerStructure.MoveGroup(groupGuid, newIndex);
 
-            ReassignParent(group, referenceLayergroup);
+            ReassignParent(group, referenceLayerGroup);
 
-            LayerStructure.PostMoveReassignBounds(new GroupData(group?.Parent?.GroupGuid), new GroupData(group.GroupGuid));
+            LayerStructure.PostMoveReassignBounds(new GroupData(group?.Parent?.GroupGuid), new GroupData(group?.GroupGuid));
         }
 
         private void ReassignParent(GuidStructureItem folder, GuidStructureItem referenceLayerFolder)
@@ -666,7 +666,7 @@ namespace PixiEditor.Models.DataHolders
 
         private void RemoveGroupsIfEmpty(Layer layer, GuidStructureItem layerGroup)
         {
-            if (LayerStructure.GroupContainsOnlyLayer(layer, layerGroup))
+            if (LayerStructure.GroupContainsOnlyLayer(layer.LayerGuid, layerGroup))
             {
                 if (layerGroup.Parent != null)
                 {

PixiEditor/Models/Layers/LayerStructure.cs

@@ -19,25 +19,26 @@ namespace PixiEditor.Models.Layers
     {
         public event EventHandler LayerStructureChanged;
 
-        public Document Owner { get; set; }
-
         public ObservableCollection<GuidStructureItem> Groups { get; set; }
 
-        public static bool GroupContainsOnlyLayer(Layer layer, GuidStructureItem layerGroup)
-        {
-            return layerGroup != null && layerGroup.Subgroups.Count == 0 && layerGroup.StartLayerGuid == layer.LayerGuid && layerGroup.EndLayerGuid == layer.LayerGuid;
-        }
+        private Document Owner { get; }
 
-        public GuidStructureItem GetGroupByGuid(Guid? groupGuid)
-        {
-            return GetGroupByGuid(groupGuid, Groups);
-        }
-
-        public GuidStructureItem GetGroupByLayer(Guid layerGuid)
+        /// <summary>
+        /// Checks whenever group contains only single layer and none subgroups.
+        /// </summary>
+        /// <param name="layerGuid">Guid of layer to check.</param>
+        /// <param name="layerGroup">Group to check.</param>
+        /// <returns>True if group contains single layer (EndLayerGuid and StartLayerGuid == layerGuid) and none subgroups.</returns>
+        public static bool GroupContainsOnlyLayer(Guid layerGuid, GuidStructureItem layerGroup)
         {
-            return GetGroupByLayer(layerGuid, Groups);
+            return layerGroup != null && layerGroup.Subgroups.Count == 0 && layerGroup.StartLayerGuid == layerGuid && layerGroup.EndLayerGuid == layerGuid;
         }
 
+        /// <summary>
+        /// Deep clones groups.
+        /// </summary>
+        /// <param name="groups">Groups to clone.</param>
+        /// <returns>ObservableCollection with cloned groups.</returns>
         public static ObservableCollection<GuidStructureItem> CloneGroups(ObservableCollection<GuidStructureItem> groups)
         {
             ObservableCollection<GuidStructureItem> outputGroups = new();
@@ -49,6 +50,26 @@ namespace PixiEditor.Models.Layers
             return outputGroups;
         }
 
+        /// <summary>
+        /// Finds <see cref="GuidStructureItem"/> (Group) by it's guid.
+        /// </summary>
+        /// <param name="groupGuid">Guid of group.</param>
+        /// <returns><see cref="GuidStructureItem"/> if group was found or null if not.</returns>
+        public GuidStructureItem GetGroupByGuid(Guid? groupGuid)
+        {
+            return GetGroupByGuid(groupGuid, Groups);
+        }
+
+        /// <summary>
+        ///  Finds parent group by layer guid.
+        /// </summary>
+        /// <param name="layerGuid">Guid of group to check.</param>
+        /// <returns><see cref="GuidStructureItem"/>if parent group was found or null if not.</returns>
+        public GuidStructureItem GetGroupByLayer(Guid layerGuid)
+        {
+            return GetGroupByLayer(layerGuid, Groups);
+        }
+
         public ObservableCollection<GuidStructureItem> CloneGroups()
         {
             return CloneGroups(Groups);
@@ -93,6 +114,12 @@ namespace PixiEditor.Models.Layers
             return group;
         }*/
 
+        /// <summary>
+        /// Adds a new group to layer structure taking into consideration nesting. Invokes LayerStructureChanged event.
+        /// </summary>
+        /// <param name="groupName">Name of a group.</param>
+        /// <param name="childLayer">Child layer of a new group.</param>
+        /// <returns>Newly created group (<see cref="GuidStructureItem"/>).</returns>
         public GuidStructureItem AddNewGroup(string groupName, Guid childLayer)
         {
             var parent = GetGroupByLayer(childLayer);
@@ -114,10 +141,15 @@ namespace PixiEditor.Models.Layers
         }
 
 #nullable enable
-        public void MoveGroup(Guid groupGuid, Guid? parentGroupGuid, int newIndex)
+        /// <summary>
+        /// Moves group and it's children from one index to another. This method makes changes in <see cref="Document"/> Layers.
+        /// </summary>
+        /// <param name="groupGuid">Group guid to move.</param>
+        /// <param name="newIndex">New group index, relative to <see cref="Document"/> Layers.</param>
+        public void MoveGroup(Guid groupGuid, int newIndex)
         {
             var group = GetGroupByGuid(groupGuid);
-            var parentGroup = GetGroupByGuid(parentGroupGuid);
+            var parentGroup = group.Parent;
             bool reverseOrder = true;
             int groupTopIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == group.EndLayerGuid));
             int groupBottomIndex = Owner.Layers.IndexOf(Owner.Layers.First(x => x.LayerGuid == group.StartLayerGuid));
@@ -176,12 +208,122 @@ namespace PixiEditor.Models.Layers
             return false;
         }
 
+        /// <summary>
+        /// Checks if layer is nested inside parent group.
+        /// </summary>
+        /// <param name="layerGuid">Layer GUID to check.</param>
+        /// <param name="parent">Parent of that group.</param>
+        /// <returns>True if layer is nested inside parent, false if not.</returns>
+        public bool IsChildOf(Guid layerGuid, GuidStructureItem parent)
+        {
+            var layerParent = GetGroupByLayer(layerGuid);
+
+            if (layerParent == parent)
+            {
+                return true;
+            }
+
+            return IsChildOf(layerParent, parent);
+        }
+
+        /// <summary>
+        /// Reassigns (removes) group data from parent group.
+        /// </summary>
+        /// <param name="parentGroup">Parent group to reassign data in.</param>
+        /// <param name="group">Group which data should be reassigned.</param>
+        public void PreMoveReassignBounds(GroupData parentGroup, GroupData group)
+        {
+            PreMoveReassignBounds(GetGroupByGuid(parentGroup.GroupGuid), GetGroupByGuid(group.GroupGuid));
+        }
+
+        /// <summary>
+        /// Reassigns (removes) layer data from parent group.
+        /// </summary>
+        /// <param name="parentGroup">Parent group to reassign data in.</param>
+        /// <param name="layer">Layer which data should be reassigned.</param>
         public void PreMoveReassignBounds(GroupData parentGroup, Guid layer)
         {
             PreMoveReassignBounds(GetGroupByGuid(parentGroup.GroupGuid), layer);
         }
 
-        protected void PreMoveReassignBounds(GuidStructureItem? parentGroup, Guid layer)
+        /// <summary>
+        /// Reassigns (adds) layer data to parent group.
+        /// </summary>
+        /// <param name="parentGroup">Parent group to reassign data in.</param>
+        /// <param name="layerGuid">Group which data should be reassigned.</param>
+        public void PostMoveReassignBounds(GroupData parentGroup, Guid layerGuid)
+        {
+            PostMoveReassignBounds(GetGroupByGuid(parentGroup.GroupGuid), layerGuid);
+        }
+
+        /// <summary>
+        /// Reassigns (adds) group data to parent group.
+        /// </summary>
+        /// <param name="parentGroup">Parent group to reassign data in.</param>
+        /// <param name="group">Group which data should be reassigned.</param>
+        public void PostMoveReassignBounds(GroupData parentGroup, GroupData group)
+        {
+            PostMoveReassignBounds(GetGroupByGuid(parentGroup.GroupGuid), GetGroupByGuid(group.GroupGuid));
+        }
+
+        /// <summary>
+        /// Assigns parent to a layer.
+        /// </summary>
+        /// <param name="layer">Layer to assign parent to.</param>
+        /// <param name="parent">Parent which should be assigned. Null indicates no parent.</param>
+        public void AssignParent(Guid layer, Guid? parent)
+        {
+            AssignParent(layer, parent.HasValue ? GetGroupByGuid(parent) : null);
+        }
+
+        /// <summary>
+        /// Gets all layers inside group, including nested groups.
+        /// </summary>
+        /// <param name="group">Group to get layers from.</param>
+        /// <returns>List of layers.</returns>
+        public List<Layer> GetGroupLayers(GuidStructureItem group)
+        {
+            List<Layer> layers = new();
+            var layerGuids = GetGroupLayerGuids(group);
+            foreach (var layerGuid in layerGuids)
+            {
+                layers.Add(Owner.Layers.First(x => x.LayerGuid == layerGuid));
+            }
+
+            return layers;
+        }
+
+        /// <summary>
+        /// Gets all layers inside group, including nested groups.
+        /// </summary>
+        /// <param name="group">Group to get layers from.</param>
+        /// <returns>List of layer guids.</returns>
+        private List<Guid> GetGroupLayerGuids(GuidStructureItem group)
+        {
+            Layer layerTop = Owner.Layers.First(x => x.LayerGuid == group.EndLayerGuid);
+            Layer layerBottom = Owner.Layers.First(x => x.LayerGuid == group.StartLayerGuid);
+
+            int indexTop = Owner.Layers.IndexOf(layerTop);
+            int indexBottom = Owner.Layers.IndexOf(layerBottom);
+
+            return GetLayersInOrder(new GroupData(indexTop, indexBottom));
+        }
+
+        private List<Guid> GetLayersInOrder(GroupData group)
+        {
+            List<Guid> layerGuids = new();
+            int minIndex = group.BottomIndex;
+            int maxIndex = group.TopIndex;
+
+            for (int i = minIndex; i <= maxIndex; i++)
+            {
+                layerGuids.Add(Owner.Layers[i].LayerGuid);
+            }
+
+            return layerGuids;
+        }
+
+        private void PreMoveReassignBounds(GuidStructureItem? parentGroup, Guid layer)
         {
             if (parentGroup != null)
             {
@@ -212,12 +354,7 @@ namespace PixiEditor.Models.Layers
             }
         }
 
-        public void PreMoveReassignBounds(GroupData parentGroup, GroupData group)
-        {
-            PreMoveReassignBounds(GetGroupByGuid(parentGroup.GroupGuid), GetGroupByGuid(group.GroupGuid));
-        }
-
-        protected void PreMoveReassignBounds(GuidStructureItem? parentGroup, GuidStructureItem group)
+        private void PreMoveReassignBounds(GuidStructureItem? parentGroup, GuidStructureItem group)
         {
             if (parentGroup != null)
             {
@@ -248,30 +385,7 @@ namespace PixiEditor.Models.Layers
             }
         }
 
-        /// <summary>
-        /// Checks if layer is nested inside parent group.
-        /// </summary>
-        /// <param name="layerGuid">Layer GUID to check.</param>
-        /// <param name="parent">Parent of that group.</param>
-        /// <returns>True if layer is nested inside parent, false if not.</returns>
-        public bool IsChildOf(Guid layerGuid, GuidStructureItem parent)
-        {
-            var layerParent = GetGroupByLayer(layerGuid);
-
-            if (layerParent == parent)
-            {
-                return true;
-            }
-
-            return IsChildOf(layerParent, parent);
-        }
-
-        public void PostMoveReassignBounds(GroupData parentGroup, Guid layerGuid)
-        {
-            PostMoveReassignBounds(GetGroupByGuid(parentGroup.GroupGuid), layerGuid);
-        }
-
-        protected void PostMoveReassignBounds(GuidStructureItem? parentGroup, Guid layerGuid)
+        private void PostMoveReassignBounds(GuidStructureItem? parentGroup, Guid layerGuid)
         {
             if (parentGroup != null)
             {
@@ -306,12 +420,7 @@ namespace PixiEditor.Models.Layers
             }
         }
 
-        public void PostMoveReassignBounds(GroupData parentGroup, GroupData group)
-        {
-            PostMoveReassignBounds(GetGroupByGuid(parentGroup.GroupGuid), GetGroupByGuid(group.GroupGuid));
-        }
-
-        protected void PostMoveReassignBounds(GuidStructureItem? parentGroup, GuidStructureItem group)
+        private void PostMoveReassignBounds(GuidStructureItem? parentGroup, GuidStructureItem group)
         {
             if (parentGroup != null)
             {
@@ -346,12 +455,7 @@ namespace PixiEditor.Models.Layers
             }
         }
 
-        public void AssignParent(Guid layer, Guid? parent)
-        {
-            AssignParent(layer, parent.HasValue ? GetGroupByGuid(parent) : null);
-        }
-
-        protected void AssignParent(Guid layer, GuidStructureItem? parent)
+        private void AssignParent(Guid layer, GuidStructureItem? parent)
         {
             var currentParent = GetGroupByLayer(layer);
             if (currentParent != null)
@@ -364,53 +468,6 @@ namespace PixiEditor.Models.Layers
             LayerStructureChanged?.Invoke(this, EventArgs.Empty);
         }
 
-        public List<Guid> GetLayersInOrder(GroupData group)
-        {
-            List<Guid> layerGuids = new();
-            int minIndex = group.BottomIndex;
-            int maxIndex = group.TopIndex;
-
-            for (int i = minIndex; i <= maxIndex; i++)
-            {
-                layerGuids.Add(Owner.Layers[i].LayerGuid);
-            }
-
-            return layerGuids;
-        }
-
-        /// <summary>
-        /// Gets all layers inside group, including nested groups.
-        /// </summary>
-        /// <param name="group">Group to get layers from.</param>
-        /// <returns>List of layer guids.</returns>
-        public List<Guid> GetGroupLayerGuids(GuidStructureItem group)
-        {
-            Layer layerTop = Owner.Layers.First(x => x.LayerGuid == group.EndLayerGuid);
-            Layer layerBottom = Owner.Layers.First(x => x.LayerGuid == group.StartLayerGuid);
-
-            int indexTop = Owner.Layers.IndexOf(layerTop);
-            int indexBottom = Owner.Layers.IndexOf(layerBottom);
-
-            return GetLayersInOrder(new GroupData(indexTop, indexBottom));
-        }
-
-        /// <summary>
-        /// Gets all layers inside group, including nested groups.
-        /// </summary>
-        /// <param name="group">Group to get layers from.</param>
-        /// <returns>List of layers.</returns>
-        public List<Layer> GetGroupLayers(GuidStructureItem group)
-        {
-            List<Layer> layers = new();
-            var layerGuids = GetGroupLayerGuids(group);
-            foreach (var layerGuid in layerGuids)
-            {
-                layers.Add(Owner.Layers.First(x => x.LayerGuid == layerGuid));
-            }
-
-            return layers;
-        }
-
         private void Group_GroupsChanged(object sender, EventArgs e)
         {
             LayerStructureChanged?.Invoke(this, EventArgs.Empty);

PixiEditorTests/ModelsTests/DataHoldersTests/LayerStructureTests.cs

@@ -51,7 +51,7 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
             Assert.Equal(0, doc.Layers.IndexOf(testLayer));
             Assert.Equal(1, doc.Layers.IndexOf(testLayer1));
 
-            doc.LayerStructure.MoveGroup(doc.LayerStructure.Groups[0].GroupGuid, null, 1);
+            doc.LayerStructure.MoveGroup(doc.LayerStructure.Groups[0].GroupGuid, 1);
 
             Assert.Equal(1, doc.Layers.IndexOf(testLayer));
             Assert.Equal(0, doc.Layers.IndexOf(testLayer1));
@@ -82,5 +82,162 @@ namespace PixiEditorTests.ModelsTests.DataHoldersTests
             Assert.True(ls.IsChildOf(testLayerGuid, ls.Groups[0]));
             Assert.True(ls.IsChildOf(testLayerGuid, ls.Groups[0].Subgroups[0]));
         }
+
+        [Fact]
+        public void TestThatGroupContainsOnlyLayerDetectsOnlySingleLayerCorrectly()
+        {
+            var doc = new Document(0, 0);
+            doc.Layers.Add(new Layer("layer"));
+            var guid = doc.Layers[0].LayerGuid;
+            doc.LayerStructure.AddNewGroup("layer group", guid);
+            Assert.True(LayerStructure.GroupContainsOnlyLayer(guid, doc.LayerStructure.Groups[0]));
+        }
+
+        [Fact]
+        public void TestThatGroupContainsOnlyLayerDetectsOnlySingleLayerThatIsNested()
+        {
+            var doc = new Document(0, 0);
+            doc.Layers.Add(new Layer("layer"));
+            var guid = doc.Layers[0].LayerGuid;
+            doc.LayerStructure.AddNewGroup("layer group", guid);
+            doc.LayerStructure.AddNewGroup("layer group nested", guid);
+            Assert.False(LayerStructure.GroupContainsOnlyLayer(guid, doc.LayerStructure.Groups[0]));
+            Assert.True(LayerStructure.GroupContainsOnlyLayer(guid, doc.LayerStructure.Groups[0].Subgroups[0]));
+        }
+
+        [Fact]
+        public void TestThatCloneReturnsSameLayerStructure()
+        {
+            Document doc = new(0, 0);
+            doc.Layers.Add(new("Test"));
+            doc.Layers.Add(new("Test2"));
+            LayerStructure structure = new(doc);
+            structure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+
+            var clone = structure.CloneGroups();
+
+            Assert.Equal(structure.Groups.Count, clone.Count);
+            Assert.Single(clone);
+            Assert.Equal(structure.Groups[0].GroupGuid, clone[0].GroupGuid);
+        }
+
+        [Fact]
+        public void TestThatGetGroupByGuidReturnsNullForNonExistingGroup()
+        {
+            Document doc = new(0, 0);
+            doc.Layers.Add(new("Test"));
+
+            Assert.Null(doc.LayerStructure.GetGroupByGuid(null));
+            Assert.Null(doc.LayerStructure.GetGroupByGuid(Guid.NewGuid()));
+        }
+
+        [Fact]
+        public void TestThatGetGroupByGuidReturnsGroupCorrectly()
+        {
+            Document doc = new(0, 0);
+            doc.Layers.Add(new("Test"));
+            var group = doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+
+            Assert.Equal(group.GroupGuid, doc.LayerStructure.GetGroupByGuid(group.GroupGuid).GroupGuid);
+        }
+
+        [Fact]
+        public void TestThatPreMoveReassignBoundsMakesNestedGroupEmptyAndRemovesItAndParent()
+        {
+            Document doc = new(0, 0);
+            doc.Layers.Add(new("Test"));
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+            var group1 = doc.LayerStructure.AddNewGroup("Test group nested", doc.Layers[0].LayerGuid);
+
+            doc.LayerStructure.PreMoveReassignBounds(new GroupData(group1.GroupGuid), doc.Layers[0].LayerGuid);
+
+            Assert.Empty(doc.LayerStructure.Groups);
+        }
+
+        [Fact]
+        public void TestThatPostMoveReassignBoundsAssignsNewLayerToGroup()
+        {
+            Document doc = new(0, 0);
+            doc.Layers.Add(new("Test"));
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+            var group1 = doc.LayerStructure.AddNewGroup("Test group nested", doc.Layers[0].LayerGuid);
+
+            doc.Layers.Add(new("Test 1"));
+
+            var firstLayer = doc.Layers[0];
+            var layer = doc.Layers[^1];
+
+            doc.LayerStructure.PostMoveReassignBounds(new GroupData(group1.GroupGuid), layer.LayerGuid);
+
+            Assert.Single(doc.LayerStructure.Groups);
+            Assert.Single(doc.LayerStructure.Groups[0].Subgroups);
+            Assert.Equal(layer.LayerGuid, doc.LayerStructure.Groups[0].Subgroups[0].EndLayerGuid);
+            Assert.Equal(firstLayer.LayerGuid, doc.LayerStructure.Groups[0].Subgroups[0].StartLayerGuid);
+            Assert.Equal(layer.LayerGuid, doc.LayerStructure.Groups[0].EndLayerGuid);
+            Assert.Equal(firstLayer.LayerGuid, doc.LayerStructure.Groups[0].StartLayerGuid);
+        }
+
+        [Fact]
+        public void TestThatAssignParentAssignsParent()
+        {
+            Document doc = new(0, 0);
+            doc.Layers.Add(new Layer("Test"));
+
+            var firstLayer = doc.Layers[0];
+
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+
+            doc.Layers.Add(new Layer("Test 1"));
+
+            var layer = doc.Layers[^1];
+
+            doc.LayerStructure.AssignParent(doc.Layers[^1].LayerGuid, doc.LayerStructure.Groups[0].GroupGuid);
+
+            Assert.Equal(layer.LayerGuid, doc.LayerStructure.Groups[0].EndLayerGuid);
+            Assert.Equal(firstLayer.LayerGuid, doc.LayerStructure.Groups[0].StartLayerGuid);
+        }
+
+        [Fact]
+        public void TestThatAssignParentDeAssignsParentOnNull()
+        {
+            Document doc = new(0, 0);
+            doc.Layers.Add(new Layer("Test"));
+
+            var firstLayer = doc.Layers[0];
+
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+
+            doc.Layers.Add(new Layer("Test 1"));
+
+            var layer = doc.Layers[^1];
+
+            doc.LayerStructure.AssignParent(layer.LayerGuid,  doc.LayerStructure.Groups[0].GroupGuid);
+            doc.LayerStructure.AssignParent(layer.LayerGuid, null);
+
+            Assert.Equal(firstLayer.LayerGuid, doc.LayerStructure.Groups[0].EndLayerGuid);
+            Assert.Equal(firstLayer.LayerGuid, doc.LayerStructure.Groups[0].StartLayerGuid);
+        }
+
+        [Fact]
+        public void TestThatGetGroupLayersReturnsAllLayersInGroup()
+        {
+            Document doc = new(0, 0);
+            doc.Layers.Add(new Layer("Test"));
+            doc.Layers.Add(new Layer("Test 1"));
+            doc.Layers.Add(new Layer("Test 2"));
+            doc.Layers.Add(new Layer("Test 3"));
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
+
+            doc.LayerStructure.AssignParent(doc.Layers[1].LayerGuid, doc.LayerStructure.Groups[0].GroupGuid);
+            doc.LayerStructure.AssignParent(doc.Layers[2].LayerGuid, doc.LayerStructure.Groups[0].GroupGuid);
+            doc.LayerStructure.AddNewGroup("Test group", doc.Layers[2].LayerGuid);
+
+            var layersInGroup = doc.LayerStructure.GetGroupLayers(doc.LayerStructure.Groups[0]);
+
+            Assert.Equal(3, layersInGroup.Count);
+            Assert.Contains(doc.Layers[0], layersInGroup);
+            Assert.Contains(doc.Layers[1], layersInGroup);
+            Assert.Contains(doc.Layers[2], layersInGroup);
+        }
     }
 }

PixiEditorTests/ModelsTests/LayerStructureTests/LayerStructureCloneTests.cs

@@ -1,29 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using PixiEditor.Models.DataHolders;
-using PixiEditor.Models.Layers;
-using Xunit;
-
-namespace PixiEditorTests.ModelsTests.LayerStructureTests
-{
-    public class LayerStructureCloneTests
-    {
-        public void TestThatCloneReturnsSameLayerStructure()
-        {
-            Document doc = new(0, 0);
-            doc.Layers.Add(new("Test"));
-            doc.Layers.Add(new("Test2"));
-            LayerStructure structure = new(doc);
-            structure.AddNewGroup("Test group", doc.Layers[0].LayerGuid);
-
-            var clone = structure.CloneGroups();
-
-            Assert.Equal(structure.Groups, clone);
-            Assert.Single(clone);
-            Assert.Equal(structure.Groups[0].GroupGuid, clone[0].GroupGuid);
-        }
-    }
-}