Wrote some tests + edited azure pipelines

PixiEditor/Models/Controllers/BitmapManager.cs

@@ -120,7 +120,7 @@ namespace PixiEditor.Models.Controllers
 
         public void RemoveLayer(int layerIndex)
         {
-            if (ActiveDocument.Layers.Count <= 1) return;
+            if (ActiveDocument.Layers.Count == 0) return;
 
             bool wasActive = ActiveDocument.Layers[layerIndex].IsActive;
             ActiveDocument.Layers.RemoveAt(layerIndex);
@@ -221,7 +221,7 @@ namespace PixiEditor.Models.Controllers
         /// <returns></returns>
         public bool IsOperationTool()
         {
-            return SelectedTool is BitmapOperationTool;
+            return IsOperationTool(SelectedTool);
         }
 
         /// <summary>

PixiEditor/Models/Controllers/BitmapOperationsUtility.cs

@@ -75,7 +75,6 @@ namespace PixiEditor.Models.Controllers
         {
             if (Keyboard.IsKeyDown(Key.LeftShift) && !MouseCordsNotInLine(mouseMoveCords))
                 mouseMoveCords = GetSquareCoordiantes(mouseMoveCords);
-            ;
             if (!tool.RequiresPreviewLayer)
             {
                 LayerChange[] modifiedLayers = tool.Use(Manager.ActiveLayer, mouseMoveCords.ToArray(), color);

PixiEditor/Models/Controllers/Shortcuts/Shortcut.cs

@@ -1,6 +1,6 @@
 using System.Windows.Input;
 
-namespace PixiEditor.Models.Controllers
+namespace PixiEditor.Models.Controllers.Shortcuts
 {
     public class Shortcut
     {

PixiEditor/Models/Controllers/Shortcuts/ShortcutController.cs

@@ -2,7 +2,7 @@
 using System.Linq;
 using System.Windows.Input;
 
-namespace PixiEditor.Models.Controllers
+namespace PixiEditor.Models.Controllers.Shortcuts
 {
     public class ShortcutController
     {
@@ -15,7 +15,7 @@ namespace PixiEditor.Models.Controllers
             Shortcuts = new List<Shortcut>();
         }
 
-        public void KeyPressed(Key key)
+        public void KeyPressed(Key key, ModifierKeys modifiers)
         {
             if (!BlockShortcutExecution)
             {
@@ -23,7 +23,7 @@ namespace PixiEditor.Models.Controllers
                 if (shortcuts.Length < 1) return;
                 shortcuts = shortcuts.OrderByDescending(x => x.Modifier).ToArray();
                 for (int i = 0; i < shortcuts.Length; i++)
-                    if (Keyboard.Modifiers.HasFlag(shortcuts[i].Modifier))
+                    if (modifiers.HasFlag(shortcuts[i].Modifier))
                     {
                         shortcuts[i].Execute();
                         break;

PixiEditor/Models/Tools/BitmapPixelChanges.cs → PixiEditor/Models/DataHolders/BitmapPixelChanges.cs

@@ -22,11 +22,6 @@ namespace PixiEditor.Models.Tools
             WasBuiltAsSingleColored = false;
         }
 
-        public void UpdateChangedPixels(Dictionary<Coordinates, Color> changedPixels)
-        {
-            ChangedPixels = changedPixels;
-        }
-
         /// <summary>
         ///     Builds BitmapPixelChanges with only one color for specified coordinates
         /// </summary>

PixiEditor/Models/DataHolders/LayerChanges.cs → PixiEditor/Models/DataHolders/LayerChange.cs

@@ -1,24 +1,24 @@
-using PixiEditor.Models.Layers;
-using PixiEditor.Models.Tools;
-using PixiEditor.ViewModels;
-
-namespace PixiEditor.Models.DataHolders
-{
-    public class LayerChange
-    {
-        public BitmapPixelChanges PixelChanges { get; set; }
-        public int LayerIndex { get; set; }
-
-        public LayerChange(BitmapPixelChanges pixelChanges, int layerIndex)
-        {
-            PixelChanges = pixelChanges;
-            LayerIndex = layerIndex;
-        }
-
-        public LayerChange(BitmapPixelChanges pixelChanges, Layer layer)
-        {
-            PixelChanges = pixelChanges;
-            LayerIndex = ViewModelMain.Current.BitmapManager.ActiveDocument.Layers.IndexOf(layer);
-        }
-    }
+using PixiEditor.Models.Layers;
+using PixiEditor.Models.Tools;
+using PixiEditor.ViewModels;
+
+namespace PixiEditor.Models.DataHolders
+{
+    public class LayerChange
+    {
+        public BitmapPixelChanges PixelChanges { get; set; }
+        public int LayerIndex { get; set; }
+
+        public LayerChange(BitmapPixelChanges pixelChanges, int layerIndex)
+        {
+            PixelChanges = pixelChanges;
+            LayerIndex = layerIndex;
+        }
+
+        public LayerChange(BitmapPixelChanges pixelChanges, Layer layer)
+        {
+            PixelChanges = pixelChanges;
+            LayerIndex = ViewModelMain.Current.BitmapManager.ActiveDocument.Layers.IndexOf(layer);
+        }
+    }
 }

PixiEditor/Models/DataHolders/Tuple.cs

@@ -1,44 +0,0 @@
-using System;
-
-namespace PixiEditor.Models.DataHolders
-{
-    public class Tuple<T1, T2, T3> : IEquatable<object>
-    {
-        public T1 Item1 { get; set; }
-
-        public T2 Item2 { get; set; }
-
-        public T3 Item3 { get; set; }
-
-        public Tuple(T1 Item1, T2 Item2, T3 Item3)
-        {
-            this.Item1 = Item1;
-            this.Item2 = Item2;
-            this.Item3 = Item3;
-        }
-
-        public override bool Equals(object obj)
-        {
-            if (obj == null || obj as Tuple<T1, T2, T3> == null) //if the object is null or the cast fails
-                return false;
-
-            Tuple<T1, T2, T3> tuple = (Tuple<T1, T2, T3>) obj;
-            return Item1.Equals(tuple.Item1) && Item2.Equals(tuple.Item2) && Item3.Equals(tuple.Item3);
-        }
-
-        public override int GetHashCode()
-        {
-            return Item1.GetHashCode() ^ Item2.GetHashCode() ^ Item3.GetHashCode();
-        }
-
-        public static bool operator ==(Tuple<T1, T2, T3> tuple1, Tuple<T1, T2, T3> tuple2)
-        {
-            return tuple1.Equals(tuple2);
-        }
-
-        public static bool operator !=(Tuple<T1, T2, T3> tuple1, Tuple<T1, T2, T3> tuple2)
-        {
-            return !tuple1.Equals(tuple2);
-        }
-    }
-}

PixiEditor/Models/Images/ImageGenerator.cs

@@ -1,19 +0,0 @@
-using System.Windows.Controls;
-using System.Windows.Media;
-
-namespace PixiEditor.Models.Images
-{
-    public static class ImageGenerator
-    {
-        public static Image GenerateForPixelArts(int width, int height)
-        {
-            Image image = new Image();
-            RenderOptions.SetBitmapScalingMode(image, BitmapScalingMode.NearestNeighbor);
-            RenderOptions.SetEdgeMode(image, EdgeMode.Aliased);
-            image.Stretch = Stretch.Uniform;
-            image.Width = width;
-            image.Height = height;
-            return image;
-        }
-    }
-}

PixiEditor/Models/Position/Coordinates.cs

@@ -19,7 +19,6 @@
 
         public static bool operator ==(Coordinates c1, Coordinates c2)
         {
-            if (c1 == null || c2 == null) return false;
             return c2.X == c1.X && c2.Y == c1.Y;
         }
 

PixiEditor/Models/Tools/ShapeTool.cs

@@ -6,6 +6,7 @@ using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Tools.ToolSettings;
+using PixiEditor.Models.Tools.ToolSettings.Toolbars;
 
 namespace PixiEditor.Models.Tools
 {

PixiEditor/Models/Tools/ToolSettings/Toolbars/BasicShapeToolbar.cs

@@ -1,6 +1,6 @@
 using PixiEditor.Models.Tools.ToolSettings.Settings;
 
-namespace PixiEditor.Models.Tools.ToolSettings
+namespace PixiEditor.Models.Tools.ToolSettings.Toolbars
 {
     public class BasicShapeToolbar : BasicToolbar
     {

PixiEditor/Models/Tools/ToolSettings/Toolbars/BasicToolbar.cs

@@ -1,6 +1,6 @@
 using PixiEditor.Models.Tools.ToolSettings.Settings;
 
-namespace PixiEditor.Models.Tools.ToolSettings
+namespace PixiEditor.Models.Tools.ToolSettings.Toolbars
 {
     public class BasicToolbar : Toolbar
     {

PixiEditor/Models/Tools/Tools/EarserTool.cs

@@ -3,6 +3,7 @@ using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Tools.ToolSettings;
+using PixiEditor.Models.Tools.ToolSettings.Toolbars;
 
 namespace PixiEditor.Models.Tools.Tools
 {

PixiEditor/Models/Tools/Tools/LineTool.cs

@@ -7,6 +7,7 @@ using PixiEditor.Models.Enums;
 using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Tools.ToolSettings;
+using PixiEditor.Models.Tools.ToolSettings.Toolbars;
 
 namespace PixiEditor.Models.Tools.Tools
 {

PixiEditor/Models/Tools/Tools/PenTool.cs

@@ -5,6 +5,7 @@ using PixiEditor.Models.Enums;
 using PixiEditor.Models.Layers;
 using PixiEditor.Models.Position;
 using PixiEditor.Models.Tools.ToolSettings;
+using PixiEditor.Models.Tools.ToolSettings.Toolbars;
 
 namespace PixiEditor.Models.Tools.Tools
 {
@@ -25,7 +26,7 @@ namespace PixiEditor.Models.Tools.Tools
         {
             Coordinates startingCords = coordinates.Length > 1 ? coordinates[1] : coordinates[0];
             var pixels = Draw(startingCords, coordinates[0], color, (int) Toolbar.Settings[_toolSizeIndex].Value);
-            return new[] {new LayerChange(pixels, layer)};
+            return Only(pixels, layer);
         }
 
         public BitmapPixelChanges Draw(Coordinates startingCoords, Coordinates latestCords, Color color, int toolSize)

PixiEditor/PixiEditor.csproj

@@ -21,6 +21,8 @@
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DebugType>full</DebugType>
+    <DebugSymbols>true</DebugSymbols>
   </PropertyGroup>
 
   <ItemGroup>

PixiEditor/ViewModels/ViewModelMain.cs

@@ -11,6 +11,7 @@ using System.Windows.Media.Imaging;
 using Microsoft.Win32;
 using PixiEditor.Helpers;
 using PixiEditor.Models.Controllers;
+using PixiEditor.Models.Controllers.Shortcuts;
 using PixiEditor.Models.DataHolders;
 using PixiEditor.Models.Dialogs;
 using PixiEditor.Models.Enums;
@@ -488,7 +489,7 @@ namespace PixiEditor.ViewModels
 
         public void KeyDown(object parameter)
         {
-            ShortcutController.KeyPressed(((KeyEventArgs) parameter).Key);
+            ShortcutController.KeyPressed(((KeyEventArgs) parameter).Key, Keyboard.Modifiers);
         }
 
         private void MouseController_StoppedRecordingChanges(object sender, EventArgs e)

PixiEditor/Views/EditableTextBlock.xaml.cs

@@ -2,6 +2,7 @@
 using System.Windows.Controls;
 using System.Windows.Input;
 using PixiEditor.Models.Controllers;
+using PixiEditor.Models.Controllers.Shortcuts;
 
 namespace PixiEditor.Views
 {

PixiEditorTests/ModelsTests/ControllersTests/BitmapManagerTests.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows;
+using System.Windows.Media;
+using PixiEditor;
+using PixiEditor.Models.Controllers;
+using PixiEditor.Models.DataHolders;
+using PixiEditor.Models.Layers;
+using PixiEditor.Models.Position;
+using PixiEditor.Models.Tools;
+using PixiEditor.Models.Tools.Tools;
+using Xunit;
+
+namespace PixiEditorTests.ModelsTests.ControllersTests
+{
+    public class BitmapManagerTests
+    {
+
+        [Fact]
+        public void TestThatBitmapManagerSetsCorrectTool()
+        {
+             BitmapManager bitmapManager = new BitmapManager();
+             bitmapManager.SetActiveTool(new MockedPen());
+             Assert.Equal(ToolType.Pen, bitmapManager.SelectedTool.ToolType);
+        }
+
+        [Fact]
+        public void TestThatBitmapManagerAddsEmptyNewLayer()
+        {
+            string layerName = "TestLayer";
+            BitmapManager bitmapManager = new BitmapManager
+            {
+                ActiveDocument = new Document(10, 10)
+            };
+            bitmapManager.AddNewLayer(layerName);
+            Assert.Single(bitmapManager.ActiveDocument.Layers);
+            Assert.Equal(layerName, bitmapManager.ActiveDocument.ActiveLayer.Name);
+            Assert.Equal(0, bitmapManager.ActiveDocument.ActiveLayer.Width + bitmapManager.ActiveDocument.ActiveLayer.Height);
+        }
+
+        [Fact]
+        public void TestThatBitmapManagerRemovesLayer()
+        {
+            BitmapManager bitmapManager = new BitmapManager
+            {
+                ActiveDocument = new Document(10, 10)
+            };
+            bitmapManager.AddNewLayer("_");
+            bitmapManager.AddNewLayer("_1");
+            Assert.Equal(2,bitmapManager.ActiveDocument.Layers.Count);
+            bitmapManager.RemoveLayer(0);
+            Assert.Single(bitmapManager.ActiveDocument.Layers);
+        }
+
+        [Fact]
+        public void TestThatGeneratePreviewLayerGeneratesPreviewLayer()
+        {
+            BitmapManager bitmapManager = new BitmapManager
+            {
+                ActiveDocument = new Document(10, 10)
+            };
+            bitmapManager.GeneratePreviewLayer();
+            Assert.NotNull(bitmapManager.PreviewLayer);
+            Assert.Equal(0, bitmapManager.PreviewLayer.Width + bitmapManager.PreviewLayer.Height); //Size is zero
+            Assert.Equal(0, bitmapManager.PreviewLayer.OffsetX + bitmapManager.PreviewLayer.OffsetY); //Offset is zero
+            Assert.Equal(bitmapManager.ActiveDocument.Width,bitmapManager.PreviewLayer.MaxWidth);
+            Assert.Equal(bitmapManager.ActiveDocument.Height,bitmapManager.PreviewLayer.MaxHeight);
+        }
+
+        [Fact]
+        public void TestThatIsOperationToolWorks()
+        {
+            MockedPen pen = new MockedPen();
+            Assert.True(BitmapManager.IsOperationTool(pen));
+        }
+
+    }
+
+    public class MockedPen : BitmapOperationTool
+    {
+        public override LayerChange[] Use(Layer layer, Coordinates[] mouseMove, Color color)
+        {
+            PenTool pen = new PenTool()
+            {
+                Toolbar = null
+            };
+           return pen.Use(layer, mouseMove, color);
+        }
+
+        public override ToolType ToolType { get; } = ToolType.Pen;
+    }
+}

PixiEditorTests/ModelsTests/ControllersTests/ShortcutControllerTests.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Media.Effects;
+using PixiEditor.Helpers;
+using PixiEditor.Models.Controllers.Shortcuts;
+using Xunit;
+
+namespace PixiEditorTests.ModelsTests.ControllersTests
+{
+    public class ShortcutControllerTests
+    {
+
+        private ShortcutController GenerateStandardShortcutController(Key shortcutKey, ModifierKeys modifiers,RelayCommand shortcutCommand)
+        {
+            ShortcutController controller = new ShortcutController();
+            controller.Shortcuts.Add(new Shortcut(shortcutKey, shortcutCommand, 0, modifiers));
+            ShortcutController.BlockShortcutExecution = false;
+            return controller;
+        }
+
+        [StaTheory]
+        [InlineData(Key.A, ModifierKeys.None, Key.A, ModifierKeys.None)]
+        [InlineData(Key.A, ModifierKeys.Alt, Key.A, ModifierKeys.Alt)]
+        [InlineData(Key.B, ModifierKeys.Alt | ModifierKeys.Control, Key.B, ModifierKeys.Alt | ModifierKeys.Control)]
+        public void TestThatShortcutControllerExecutesShortcut(Key shortcutKey, ModifierKeys shortcutModifiers, Key clickedKey, ModifierKeys clickedModifiers)
+        {
+            int result = -1;
+            RelayCommand shortcutCommand = new RelayCommand((arg) =>
+            {
+                result = (int) arg;
+            });
+            var controller = GenerateStandardShortcutController(shortcutKey, shortcutModifiers, shortcutCommand);
+
+            controller.KeyPressed(clickedKey, clickedModifiers);
+            Assert.Equal(0, result);
+        }
+
+        [StaTheory]
+        [InlineData(Key.B, ModifierKeys.None, Key.A, ModifierKeys.None)]
+        [InlineData(Key.A, ModifierKeys.Alt, Key.A, ModifierKeys.None)]
+        [InlineData(Key.C, ModifierKeys.Alt | ModifierKeys.Control, Key.C, ModifierKeys.Alt | ModifierKeys.Windows)]
+        public void TestThatShortcutControllerNotExecutesShortcut(Key shortcutKey, ModifierKeys shortcutModifiers, Key clickedKey, ModifierKeys clickedModifiers)
+        {
+            int result = -1;
+            RelayCommand shortcutCommand = new RelayCommand((arg) =>
+            {
+                result = (int)arg;
+            });
+            var controller = GenerateStandardShortcutController(shortcutKey, shortcutModifiers, shortcutCommand);
+
+
+            controller.KeyPressed(clickedKey, clickedModifiers);
+            Assert.Equal(-1, result);
+        }
+
+        [StaFact]
+        public void TestThatShortcutControllerIsBlocked()
+        {
+            int result = -1;
+            RelayCommand shortcutCommand = new RelayCommand((arg) =>
+            {
+                result = (int)arg;
+            });
+
+            var controller = GenerateStandardShortcutController(Key.A, ModifierKeys.None, shortcutCommand);
+            ShortcutController.BlockShortcutExecution = true;
+
+            controller.KeyPressed(Key.A, ModifierKeys.None);
+            Assert.Equal(-1, result);
+        }
+
+        [StaFact]
+        public void TestThatShortcutControllerPicksCorrectShortcut()
+        {
+            int result = -1;
+            RelayCommand shortcutCommand = new RelayCommand((arg) =>
+            {
+                result = (int)arg;
+            });
+
+            var controller = GenerateStandardShortcutController(Key.A, ModifierKeys.None, shortcutCommand);
+            controller.Shortcuts.Add(new Shortcut(Key.A, shortcutCommand, 1, ModifierKeys.Control));
+
+            controller.KeyPressed(Key.A, ModifierKeys.Control);
+            Assert.Equal(1, result);
+        }
+    }
+}

PixiEditorTests/ModelsTests/PositionTests/CoordinatesCalculatorTests.cs

@@ -1,20 +0,0 @@
-using PixiEditor.Models.Position;
-using Xunit;
-
-namespace PixiEditorTests.ModelsTests.PositionTests
-{
-    public class CoordinatesCalculatorTests
-    {
-        [Theory]
-        [InlineData(0, 0, 3, 3, 1, 1)]
-        [InlineData(0, 0, 2, 2, 1, 1)]
-        [InlineData(5, 5, 7, 7, 6, 6)]
-        [InlineData(5, 5, 9, 9, 7, 7)]
-        public void TestGetCenter(int x1, int y1, int x2, int y2, int expectedX, int expectedY)
-        {
-            Coordinates center = CoordinatesCalculator.GetCenterPoint(new Coordinates(x1, y1), new Coordinates(x2, y2));
-            Assert.Equal(new Coordinates(expectedX, expectedY), center);
-        }
-
-    }
-}

PixiEditorTests/PixiEditorTests.csproj

@@ -6,7 +6,17 @@
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DebugType>full</DebugType>
+    <DebugSymbols>true</DebugSymbols>
+  </PropertyGroup>
+
   <ItemGroup>
+    <PackageReference Include="Codecov" Version="1.12.0" />
+    <PackageReference Include="coverlet.msbuild" Version="2.9.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
@@ -17,9 +27,11 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="Xunit.StaFact" Version="0.3.18" />
   </ItemGroup>
 
   <ItemGroup>
+    <Folder Include="ModelsTests\PositionTests\" />
     <Folder Include="ViewModelsTests\" />
   </ItemGroup>
 

PixiEditorTests/WorkspaceTests/ToolsTests/CoordinatesCalculatorTests.cs

@@ -34,5 +34,16 @@ namespace PixiEditorTests.WorkspaceTests.ToolsTests
             Assert.Equal(4, cords.Coords2.X);
             Assert.Equal(4, cords.Coords2.Y);
         }
+
+        [Theory]
+        [InlineData(0, 0, 3, 3, 1, 1)]
+        [InlineData(0, 0, 2, 2, 1, 1)]
+        [InlineData(5, 5, 7, 7, 6, 6)]
+        [InlineData(5, 5, 9, 9, 7, 7)]
+        public void TestGetCenter(int x1, int y1, int x2, int y2, int expectedX, int expectedY)
+        {
+            Coordinates center = CoordinatesCalculator.GetCenterPoint(new Coordinates(x1, y1), new Coordinates(x2, y2));
+            Assert.Equal(new Coordinates(expectedX, expectedY), center);
+        }
     }
 }

azure-pipelines.yml

@@ -28,4 +28,13 @@ steps:
   inputs:
     command: test
     projects: '**/*Tests/*.csproj'
-    arguments: '--configuration $(buildConfiguration) --collect "Code coverage"'
+    arguments: '--configuration $(buildConfiguration) --logger trx /p:CollectCoverage=true /p:CoverletOutputFormat=opencover"'
+
+  - task: PublishTestResults@2
+    condition: succeededOrFailed()
+    inputs:
+        testRunner: VSTest
+        testResultsFiles: '**/*.trx'
+  
+  - powershell: .\codecov.ps1 -token $(CODECOV_TOKEN)
+    displayName: Upload to Codecov.io

codecov.ps1

@@ -0,0 +1,10 @@
+param
+(
+  $token
+)
+$ver = (gci "$env:userprofile\.nuget\packages\codecov").Name
+$cmd = "$env:userprofile\.nuget\packages\codecov\$ver\tools\codecov.exe";
+$fName = ".\YourProjectName.Tests\coverage.opencover.xml";
+$arg1 = "-f ""$fName""";
+$arg2 = "-t $token";
+& $cmd $arg1 $arg2