Browse Source

Wrote bunch of tests

flabbet 5 years ago
parent
commit
df73b5b9f0

+ 1 - 1
PixiEditor/Models/Controllers/BitmapManager.cs

@@ -212,7 +212,7 @@ namespace PixiEditor.Models.Controllers
 
 
         public WriteableBitmap GetCombinedLayersBitmap()
         public WriteableBitmap GetCombinedLayersBitmap()
         {
         {
-            return BitmapUtils.CombineLayers(ActiveDocument.Layers.ToArray());
+            return BitmapUtils.CombineLayers(ActiveDocument.Layers.ToArray(), ActiveDocument.Width, ActiveDocument.Height);
         }
         }
 
 
         /// <summary>
         /// <summary>

+ 4 - 1
PixiEditor/Models/Controllers/BitmapOperationsUtility.cs

@@ -55,6 +55,9 @@ namespace PixiEditor.Models.Controllers
             }
             }
         }
         }
 
 
+        /// <summary>
+        ///     Applies pixels from preview layer to selected layer
+        /// </summary>
         public void StopAction()
         public void StopAction()
         {
         {
             if (_lastModifiedLayers == null) return;
             if (_lastModifiedLayers == null) return;
@@ -66,7 +69,7 @@ namespace PixiEditor.Models.Controllers
 
 
                BitmapChanged?.Invoke(this, new BitmapChangedEventArgs(_lastModifiedLayers[i].PixelChanges,
                BitmapChanged?.Invoke(this, new BitmapChangedEventArgs(_lastModifiedLayers[i].PixelChanges,
                     oldValues, _lastModifiedLayers[i].LayerIndex));
                     oldValues, _lastModifiedLayers[i].LayerIndex));
-                Manager.PreviewLayer.Clear();
+               Manager.PreviewLayer = null;
             }
             }
         }
         }
 
 

+ 25 - 9
PixiEditor/Models/Controllers/ClipboardController.cs

@@ -10,17 +10,19 @@ using PixiEditor.ViewModels;
 
 
 namespace PixiEditor.Models.Controllers
 namespace PixiEditor.Models.Controllers
 {
 {
-    public class ClipboardController
+    public static class ClipboardController
     {
     {
         /// <summary>
         /// <summary>
         ///     Copies selection to clipboard in PNG, Bitmap and DIB formats.
         ///     Copies selection to clipboard in PNG, Bitmap and DIB formats.
         /// </summary>
         /// </summary>
         /// <param name="layers">Layers where selection is</param>
         /// <param name="layers">Layers where selection is</param>
         /// <param name="selection"></param>
         /// <param name="selection"></param>
-        public void CopyToClipboard(Layer[] layers, Coordinates[] selection)
+        /// <param name="originalImageWidth">Output </param>
+        /// <param name="originalImageHeight"></param>
+        public static void CopyToClipboard(Layer[] layers, Coordinates[] selection, int originalImageWidth, int originalImageHeight)
         {
         {
             Clipboard.Clear();
             Clipboard.Clear();
-            WriteableBitmap combinedBitmaps = BitmapUtils.CombineLayers(layers);
+            WriteableBitmap combinedBitmaps = BitmapUtils.CombineLayers(layers, originalImageWidth, originalImageHeight);
             using (var pngStream = new MemoryStream())
             using (var pngStream = new MemoryStream())
             {
             {
                 DataObject data = new DataObject();
                 DataObject data = new DataObject();
@@ -37,9 +39,22 @@ namespace PixiEditor.Models.Controllers
             }
             }
         }
         }
 
 
-        public void PasteFromClipboard()
+        /// <summary>
+        ///     Pastes image from clipboard into new layer.
+        /// </summary>
+        public static void PasteFromClipboard()
         {
         {
-            DataObject dao = (DataObject) Clipboard.GetDataObject();
+            WriteableBitmap image = GetImageFromClipboard();
+            if (image != null) AddImageToLayers(image);
+        }
+
+        /// <summary>
+        ///     Gets image from clipboard, supported PNG, Dib and Bitmap
+        /// </summary>
+        /// <returns>WriteableBitmap</returns>
+        public static WriteableBitmap GetImageFromClipboard()
+        {
+            DataObject dao = (DataObject)Clipboard.GetDataObject();
             WriteableBitmap finalImage = null;
             WriteableBitmap finalImage = null;
             if (dao.GetDataPresent("PNG"))
             if (dao.GetDataPresent("PNG"))
                 using (MemoryStream pngStream = dao.GetData("PNG") as MemoryStream)
                 using (MemoryStream pngStream = dao.GetData("PNG") as MemoryStream)
@@ -56,22 +71,23 @@ namespace PixiEditor.Models.Controllers
             else if (dao.GetDataPresent(DataFormats.Bitmap))
             else if (dao.GetDataPresent(DataFormats.Bitmap))
                 finalImage = new WriteableBitmap((dao.GetData(DataFormats.Bitmap) as BitmapSource)!);
                 finalImage = new WriteableBitmap((dao.GetData(DataFormats.Bitmap) as BitmapSource)!);
 
 
-            if (finalImage != null) AddImageToLayers(finalImage);
+            return finalImage;
         }
         }
 
 
-        public bool IsImageInClipboard()
+        public static bool IsImageInClipboard()
         {
         {
             DataObject dao = (DataObject) Clipboard.GetDataObject();
             DataObject dao = (DataObject) Clipboard.GetDataObject();
+            if (dao == null) return false;
             return dao.GetDataPresent("PNG") || dao.GetDataPresent(DataFormats.Dib) ||
             return dao.GetDataPresent("PNG") || dao.GetDataPresent(DataFormats.Dib) ||
                    dao.GetDataPresent(DataFormats.Bitmap);
                    dao.GetDataPresent(DataFormats.Bitmap);
         }
         }
 
 
-        private void AddImageToLayers(WriteableBitmap image)
+        private static void AddImageToLayers(WriteableBitmap image)
         {
         {
             ViewModelMain.Current.BitmapManager.AddNewLayer("Image", image);
             ViewModelMain.Current.BitmapManager.AddNewLayer("Image", image);
         }
         }
 
 
-        public BitmapSource BitmapSelectionToBmpSource(WriteableBitmap bitmap, Coordinates[] selection)
+        public static BitmapSource BitmapSelectionToBmpSource(WriteableBitmap bitmap, Coordinates[] selection)
         {
         {
             int offsetX = selection.Min(x => x.X);
             int offsetX = selection.Min(x => x.X);
             int offsetY = selection.Min(x => x.Y);
             int offsetY = selection.Min(x => x.Y);

+ 1 - 4
PixiEditor/Models/Images/BitmapUtils.cs

@@ -31,11 +31,8 @@ namespace PixiEditor.Models.Images
                 BitmapSizeOptions.FromEmptyOptions());
                 BitmapSizeOptions.FromEmptyOptions());
         }
         }
 
 
-        public static WriteableBitmap CombineLayers(Layer[] layers)
+        public static WriteableBitmap CombineLayers(Layer[] layers, int width, int height)
         {
         {
-            int width = ViewModelMain.Current.BitmapManager.ActiveDocument.Width;
-            int height = ViewModelMain.Current.BitmapManager.ActiveDocument.Height;
-
             WriteableBitmap finalBitmap = BitmapFactory.New(width, height);
             WriteableBitmap finalBitmap = BitmapFactory.New(width, height);
 
 
             using (finalBitmap.GetBitmapContext())
             using (finalBitmap.GetBitmapContext())

+ 1 - 1
PixiEditor/Models/Layers/Layer.cs

@@ -170,7 +170,7 @@ namespace PixiEditor.Models.Layers
         }
         }
 
 
         /// <summary>
         /// <summary>
-        ///     Returns pixel color by x and y coordinates relative to document using (x - OffsetX) formula.
+        ///     Returns pixel color of x and y coordinates relative to document using (x - OffsetX) formula.
         /// </summary>
         /// </summary>
         /// <param name="x">Viewport relative X</param>
         /// <param name="x">Viewport relative X</param>
         /// <param name="y">Viewport relative Y</param>
         /// <param name="y">Viewport relative Y</param>

+ 8 - 0
PixiEditor/Models/Position/CoordinatesCalculator.cs

@@ -43,6 +43,14 @@ namespace PixiEditor.Models.Position
             return new Coordinates(x, y);
             return new Coordinates(x, y);
         }
         }
 
 
+        /// <summary>
+        ///     Calculates coordinates of rectangle by edge points x1, y1, x2, y2
+        /// </summary>
+        /// <param name="x1">Top left x point</param>
+        /// <param name="y1">Top left y position</param>
+        /// <param name="x2">Bottom right x position</param>
+        /// <param name="y2">Bottom right Y position</param>
+        /// <returns></returns>
         public static Coordinates[] RectangleToCoordinates(int x1, int y1, int x2, int y2)
         public static Coordinates[] RectangleToCoordinates(int x1, int y1, int x2, int y2)
         {
         {
             x2++;
             x2++;

+ 5 - 0
PixiEditor/Models/Tools/BitmapOperationTool.cs

@@ -15,5 +15,10 @@ namespace PixiEditor.Models.Tools
         {
         {
             return new[] { new LayerChange(changes, layer) };
             return new[] { new LayerChange(changes, layer) };
         }
         }
+
+        protected LayerChange[] Only(BitmapPixelChanges changes, int layerIndex)
+        {
+            return new[] { new LayerChange(changes, layerIndex) };
+        }
     }
     }
 }
 }

+ 1 - 4
PixiEditor/ViewModels/ViewModelMain.cs

@@ -127,7 +127,6 @@ namespace PixiEditor.ViewModels
                 }
                 }
             };
             };
             UndoManager.SetMainRoot(this);
             UndoManager.SetMainRoot(this);
-            ClipboardController = new ClipboardController();
             SetActiveTool(ToolType.Move);
             SetActiveTool(ToolType.Move);
             BitmapManager.PrimaryColor = PrimaryColor;
             BitmapManager.PrimaryColor = PrimaryColor;
             Current = this;
             Current = this;
@@ -278,8 +277,6 @@ namespace PixiEditor.ViewModels
             }
             }
         }
         }
 
 
-        public ClipboardController ClipboardController { get; set; }
-
         private void CenterContent(object property)
         private void CenterContent(object property)
         {
         {
             BitmapManager.ActiveDocument.CenterContent();
             BitmapManager.ActiveDocument.CenterContent();
@@ -447,7 +444,7 @@ namespace PixiEditor.ViewModels
         private void Copy(object parameter)
         private void Copy(object parameter)
         {
         {
             ClipboardController.CopyToClipboard(BitmapManager.ActiveDocument.Layers.ToArray(),
             ClipboardController.CopyToClipboard(BitmapManager.ActiveDocument.Layers.ToArray(),
-                ActiveSelection.SelectedPoints.ToArray());
+                ActiveSelection.SelectedPoints.ToArray(), BitmapManager.ActiveDocument.Width, BitmapManager.ActiveDocument.Height);
         }
         }
 
 
         public void SelectAll(object parameter)
         public void SelectAll(object parameter)

+ 3 - 3
PixiEditorTests/WorkspaceTests/ColorsTests/ExtendedColorTests.cs → PixiEditorTests/ModelsTests/ColorsTests/ExtendedColorTests.cs

@@ -1,9 +1,9 @@
-using PixiEditor.Models.Colors;
-using System;
+using System;
 using System.Windows.Media;
 using System.Windows.Media;
+using PixiEditor.Models.Colors;
 using Xunit;
 using Xunit;
 
 
-namespace PixiEditorTests.WorkspaceTests.ColorsTests
+namespace PixiEditorTests.ModelsTests.ColorsTests
 {
 {
     public class ExtendedColorTests
     public class ExtendedColorTests
     {
     {

+ 7 - 9
PixiEditorTests/ModelsTests/ControllersTests/BitmapManagerTests.cs

@@ -10,6 +10,7 @@ using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Tools;
 using PixiEditor.Models.Tools;
 using PixiEditor.Models.Tools.Tools;
 using PixiEditor.Models.Tools.Tools;
+using PixiEditor.Models.Tools.ToolSettings;
 using Xunit;
 using Xunit;
 
 
 namespace PixiEditorTests.ModelsTests.ControllersTests
 namespace PixiEditorTests.ModelsTests.ControllersTests
@@ -21,7 +22,7 @@ namespace PixiEditorTests.ModelsTests.ControllersTests
         public void TestThatBitmapManagerSetsCorrectTool()
         public void TestThatBitmapManagerSetsCorrectTool()
         {
         {
              BitmapManager bitmapManager = new BitmapManager();
              BitmapManager bitmapManager = new BitmapManager();
-             bitmapManager.SetActiveTool(new MockedPen());
+             bitmapManager.SetActiveTool(new MockedSinglePixelPen());
              Assert.Equal(ToolType.Pen, bitmapManager.SelectedTool.ToolType);
              Assert.Equal(ToolType.Pen, bitmapManager.SelectedTool.ToolType);
         }
         }
 
 
@@ -71,21 +72,18 @@ namespace PixiEditorTests.ModelsTests.ControllersTests
         [Fact]
         [Fact]
         public void TestThatIsOperationToolWorks()
         public void TestThatIsOperationToolWorks()
         {
         {
-            MockedPen pen = new MockedPen();
-            Assert.True(BitmapManager.IsOperationTool(pen));
+            MockedSinglePixelPen singlePixelPen = new MockedSinglePixelPen();
+            Assert.True(BitmapManager.IsOperationTool(singlePixelPen));
         }
         }
 
 
     }
     }
 
 
-    public class MockedPen : BitmapOperationTool
+    public class MockedSinglePixelPen : BitmapOperationTool
     {
     {
         public override LayerChange[] Use(Layer layer, Coordinates[] mouseMove, Color color)
         public override LayerChange[] Use(Layer layer, Coordinates[] mouseMove, Color color)
         {
         {
-            PenTool pen = new PenTool()
-            {
-                Toolbar = null
-            };
-           return pen.Use(layer, mouseMove, color);
+            return Only(
+                BitmapPixelChanges.FromSingleColoredArray(new[] {new Coordinates(0, 0)}, Colors.Black),0);
         }
         }
 
 
         public override ToolType ToolType { get; } = ToolType.Pen;
         public override ToolType ToolType { get; } = ToolType.Pen;

+ 50 - 0
PixiEditorTests/ModelsTests/ControllersTests/BitmapOperationsUtilityTests.cs

@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+using System.Windows.Media;
+using PixiEditor.Models.Controllers;
+using PixiEditor.Models.DataHolders;
+using PixiEditor.Models.Layers;
+using PixiEditor.Models.Position;
+using PixiEditor.Models.Tools;
+using Xunit;
+
+namespace PixiEditorTests.ModelsTests.ControllersTests
+{
+    public class BitmapOperationsUtilityTests
+    {
+
+        [Fact]
+        public void TestThatBitmapOperationsUtilityDeletesPixels()
+        {
+            BitmapOperationsUtility util = new BitmapOperationsUtility(new BitmapManager());
+
+            Layer testLayer = new Layer("test layer", 10, 10);
+            Coordinates[] cords = {new Coordinates(0, 0), new Coordinates(1, 1)};
+            BitmapPixelChanges pixels = BitmapPixelChanges.FromSingleColoredArray(cords, Colors.Black);
+            testLayer.ApplyPixels(pixels);
+
+            util.DeletePixels(new []{testLayer}, cords);
+
+            Assert.Equal(0, testLayer.GetPixel(0, 0).A);
+            Assert.Equal(0, testLayer.GetPixel(1, 1).A);
+        }
+
+        [StaFact]
+        public void TestThatBitmapOperationsUtilityExecutesPenToolProperly()
+        {
+            BitmapManager manager = new BitmapManager
+            {
+                ActiveDocument = new Document(10, 10),
+                PrimaryColor = Colors.Black,
+            };
+            manager.AddNewLayer("Test layer", 10, 10);
+
+            BitmapOperationsUtility util = new BitmapOperationsUtility(manager);
+
+            List<Coordinates> mouseMove = new List<Coordinates>(new [] {new Coordinates(0,0)});
+
+            util.ExecuteTool(new Coordinates(0,0), mouseMove, new MockedSinglePixelPen());
+            Assert.Equal(manager.ActiveLayer.GetPixel(0,0), Colors.Black);
+        }
+
+    }
+}

+ 128 - 0
PixiEditorTests/ModelsTests/ControllersTests/ClipboardControllerTests.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using PixiEditor.Models.Controllers;
+using PixiEditor.Models.Layers;
+using PixiEditor.Models.Position;
+using Xunit;
+
+namespace PixiEditorTests.ModelsTests.ControllersTests
+{
+    public class ClipboardControllerTests
+    {
+        private Color testColor = Colors.Coral;
+
+        [StaFact]
+        public void TestThatClipboardControllerIgnoresNonImageDataInClipboard()
+        {
+            Clipboard.Clear();
+            Clipboard.SetText("Text data");
+            var img = ClipboardController.GetImageFromClipboard();
+            Assert.Null(img);
+        }
+
+        [StaFact]
+        public void TestThatIsImageInClipboardWorksForDib()
+        {
+            Clipboard.Clear();
+            Clipboard.SetImage(BitmapFactory.New(10, 10));
+            Assert.True(ClipboardController.IsImageInClipboard());
+        }
+
+        [StaFact]
+        public void TestThatClipboardControllerSavesImageToClipboard()
+        {
+            Layer testLayer = new Layer("test layer", 10, 10);
+            ClipboardController.CopyToClipboard(new []{testLayer}, CoordinatesCalculator.RectangleToCoordinates(0,0, 9,9), 10, 10);
+            Assert.True(ClipboardController.IsImageInClipboard());
+        }
+
+        [StaFact]
+        public void TestThatCopyToClipboardWithSelectionSavesCorrectBitmap()
+        {
+            Clipboard.Clear();
+
+            Layer testLayer = new Layer("test layer", 10, 10);
+            Layer testLayer2 = new Layer("test layer", 10, 10);
+            testLayer.ApplyPixel(new Coordinates(4,4), testColor);
+            testLayer2.ApplyPixel(new Coordinates(5,5), testColor);
+
+            ClipboardController.CopyToClipboard(new []{testLayer, testLayer2}, 
+                new []{new Coordinates(4,4), new Coordinates(5,5)}, 10, 10);
+
+            var img = Clipboard.GetImage(); // Using default Clipboard get image to avoid false positives from faulty ClipboardController GetImage
+
+            Assert.True(ClipboardController.IsImageInClipboard());
+            Assert.NotNull(img);
+            Assert.Equal(2, img.PixelWidth);
+            Assert.Equal(2, img.PixelHeight);
+
+            var bmp = new WriteableBitmap(img);
+            Assert.Equal(testColor, bmp.GetPixel(0, 0));
+            Assert.Equal(testColor, bmp.GetPixel(1, 1));
+        }
+
+        [StaFact]
+        public void TestThatClipboardControllerGetsCorrectImageInDibFormatFromClipboard()
+        {
+            Clipboard.Clear();
+            var bmp = BitmapFactory.New(10, 10);
+            bmp.SetPixel(4, 4, testColor);
+            Clipboard.SetImage(bmp);
+
+            var img = ClipboardController.GetImageFromClipboard();
+            Assert.NotNull(img);
+            Assert.Equal(10, img.PixelWidth);
+            Assert.Equal(10, img.PixelHeight);
+            Assert.Equal(testColor, bmp.GetPixel(4, 4));
+        }
+
+        [StaFact]
+        public void TestThatClipboardControllerGetsCorrectImageInPngFormatFromClipboard()
+        {
+            Clipboard.Clear();
+            var bmp = BitmapFactory.New(10, 10);
+            bmp.SetPixel(4,4, testColor);
+            using (var pngStream = new MemoryStream())
+            {
+                DataObject data = new DataObject();
+
+                PngBitmapEncoder encoder = new PngBitmapEncoder();
+                encoder.Frames.Add(BitmapFrame.Create(bmp));
+                encoder.Save(pngStream);
+                data.SetData("PNG", pngStream, false); //PNG, supports transparency
+                Clipboard.SetDataObject(data, true);
+            }
+
+            var img = ClipboardController.GetImageFromClipboard();
+            Assert.NotNull(img);
+            Assert.Equal(10, img.PixelWidth);
+            Assert.Equal(10, img.PixelHeight);
+            Assert.Equal(testColor, bmp.GetPixel(4,4));
+        }
+
+        [StaFact]
+        public void TestThatClipboardControllerGetsCorrectImageInBitmapFormatFromClipboard()
+        {
+            Clipboard.Clear();
+            var bmp = BitmapFactory.New(10, 10);
+            bmp.SetPixel(4, 4, testColor);
+
+            DataObject data = new DataObject();
+            data.SetData(DataFormats.Bitmap, bmp, false); //PNG, supports transparency
+            Clipboard.SetDataObject(data, true);
+
+            var img = ClipboardController.GetImageFromClipboard();
+            Assert.NotNull(img);
+            Assert.Equal(10, img.PixelWidth);
+            Assert.Equal(10, img.PixelHeight);
+            Assert.Equal(testColor, bmp.GetPixel(4, 4));
+        }
+
+        
+    }
+}

+ 80 - 0
PixiEditorTests/ModelsTests/ControllersTests/MouseMovementControllerTests.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using PixiEditor.Models.Controllers;
+using PixiEditor.Models.Position;
+using Xunit;
+
+namespace PixiEditorTests.ModelsTests.ControllersTests
+{
+    public class MouseMovementControllerTests
+    {
+        [Fact]
+        public void TestThatStartRecordingMouseMovChangesStartsRecordingAndInvokesEvent()
+        {
+            bool eventInvoked = false;
+            MouseMovementController controller = new MouseMovementController();
+            controller.StartedRecordingChanges += (sender, e) => eventInvoked = true;
+
+            controller.StartRecordingMouseMovementChanges(false);
+
+            Assert.True(controller.IsRecordingChanges);
+            Assert.True(eventInvoked);
+            Assert.False(controller.ClickedOnCanvas);
+        }
+
+        [Fact]
+        public void TestThatRecordMouseMovementChangeRecordsMouseMovementChange()
+        {
+            MouseMovementController controller = new MouseMovementController();
+            controller.StartRecordingMouseMovementChanges(false);
+            controller.RecordMouseMovementChange(new Coordinates(5,5));
+
+            Assert.NotEmpty(controller.LastMouseMoveCoordinates);
+            Assert.Equal(new Coordinates(5,5),controller.LastMouseMoveCoordinates[0]);
+            Assert.True(controller.IsRecordingChanges);
+        }
+
+        [Fact]
+        public void TestThatMouseMovedRaisesEvent()
+        {
+            bool eventRaised = false;
+            Coordinates position = new Coordinates(5,5);
+            MouseMovementEventArgs args = new MouseMovementEventArgs(new Coordinates());
+
+            MouseMovementController controller = new MouseMovementController();
+            controller.MousePositionChanged += (s, e) =>
+            {
+                eventRaised = true;
+                args = e;
+            };
+
+            controller.MouseMoved(position);
+
+            Assert.True(eventRaised);
+            Assert.Equal(position, args.NewPosition);
+        }
+
+        [Fact]
+        public void TestStopRecordingChangesStopsRecording()
+        {
+            MouseMovementController controller = new MouseMovementController();
+
+            controller.StartRecordingMouseMovementChanges(true);
+            controller.StopRecordingMouseMovementChanges();
+
+            Assert.False(controller.IsRecordingChanges);
+            Assert.False(controller.ClickedOnCanvas);
+        }
+
+        [Fact]
+        public void TestThatRecordChangesNotRecords()
+        {
+            MouseMovementController controller = new MouseMovementController();
+            controller.RecordMouseMovementChange(new Coordinates(5,10));
+
+            Assert.False(controller.IsRecordingChanges);
+            Assert.Empty(controller.LastMouseMoveCoordinates);
+        }
+    }
+}

+ 1 - 1
PixiEditorTests/WorkspaceTests/ToolsTests/CoordinatesCalculatorTests.cs → PixiEditorTests/ModelsTests/PositionTests/CoordinatesCalculatorTests.cs

@@ -1,7 +1,7 @@
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Position;
 using Xunit;
 using Xunit;
 
 
-namespace PixiEditorTests.WorkspaceTests.ToolsTests
+namespace PixiEditorTests.ModelsTests.PositionTests
 {
 {
     public class CoordinatesCalculatorTests
     public class CoordinatesCalculatorTests
     {
     {

+ 0 - 1
PixiEditorTests/PixiEditorTests.csproj

@@ -28,7 +28,6 @@
   </ItemGroup>
   </ItemGroup>
 
 
   <ItemGroup>
   <ItemGroup>
-    <Folder Include="ModelsTests\PositionTests\" />
     <Folder Include="ViewModelsTests\" />
     <Folder Include="ViewModelsTests\" />
   </ItemGroup>
   </ItemGroup>