Ситдиков Сергей

Testing/Basic/Homework/1. ObjectComparison/ObjectComparison.cs

@@ -1,4 +1,5 @@
-using NUnit.Framework;
+using FluentAssertions;
+using NUnit.Framework;
 using NUnit.Framework.Legacy;
 
 namespace HomeExercise.Tasks.ObjectComparison;
@@ -10,20 +11,13 @@ public class ObjectComparison
     public void CheckCurrentTsar()
     {
         var actualTsar = TsarRegistry.GetCurrentTsar();
-
+        
         var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
             new Person("Vasili III of Russia", 28, 170, 60, null));
 
-        // Перепишите код на использование Fluent Assertions.
-        ClassicAssert.AreEqual(actualTsar.Name, expectedTsar.Name);
-        ClassicAssert.AreEqual(actualTsar.Age, expectedTsar.Age);
-        ClassicAssert.AreEqual(actualTsar.Height, expectedTsar.Height);
-        ClassicAssert.AreEqual(actualTsar.Weight, expectedTsar.Weight);
-
-        ClassicAssert.AreEqual(expectedTsar.Parent!.Name, actualTsar.Parent!.Name);
-        ClassicAssert.AreEqual(expectedTsar.Parent.Age, actualTsar.Parent.Age);
-        ClassicAssert.AreEqual(expectedTsar.Parent.Height, actualTsar.Parent.Height);
-        ClassicAssert.AreEqual(expectedTsar.Parent.Parent, actualTsar.Parent.Parent);
+        actualTsar.Should().BeEquivalentTo(expectedTsar, options => options
+            .Excluding(x => x.DeclaringType == typeof(Person) && x.Name == nameof(Person.Id))
+            .IgnoringCyclicReferences());
     }
 
     [Test]
@@ -36,6 +30,16 @@ public void CheckCurrentTsar_WithCustomEquality()
 
         // Какие недостатки у такого подхода? 
         ClassicAssert.True(AreEqual(actualTsar, expectedTsar));
+
+        // Недостаток такого подхода заключается в том, что мы добавялем метод,
+        // который работает неизвестно как и его надо посмотреть,
+        // чтобы понять, как именно сравниваются экзмепляры класса.
+        // Также добавление новых полей в Person приведет к тому,
+        // что метод проверит только ранее указанные поля,
+        // новые придется вводить в ручную,
+        // в моем решении проверяются все поля за исключением поля Id, что не мешает расширяемости.
+        // И мое решение короче, в одну строку, и понятно что делается по названию методов
+        // Такой подход не работает правильно с циклическими ссылками и не отображает сообщения об ошибке, непонятно что именно не так
     }
 
     private bool AreEqual(Person? actual, Person? expected)

Testing/Basic/Homework/1. ObjectComparison/TsarRegistry.cs

@@ -4,8 +4,7 @@ public class TsarRegistry
 {
     public static Person GetCurrentTsar()
     {
-        return new Person(
-            "Ivan IV The Terrible", 54, 170, 70,
-            new Person("Vasili III of Russia", 28, 170, 60, null));
+        return new Person("Ivan IV The Terrible", 54, 170, 70,
+            new Person("Vasili III of Russia", 28, 170, 60,null));
     }
 }

Testing/Basic/Homework/2. NumberValidator/NumberValidator.cs

@@ -17,7 +17,7 @@ public NumberValidator(int precision, int scale = 0, bool onlyPositive = false)
         if (precision <= 0)
             throw new ArgumentException("precision must be a positive number");
         if (scale < 0 || scale >= precision)
-            throw new ArgumentException("precision must be a non-negative number less or equal than precision");
+            throw new ArgumentException("scale must be a non-negative number less or equal than precision");
         numberRegex = new Regex(@"^([+-]?)(\d+)([.,](\d+))?$", RegexOptions.IgnoreCase);
     }
 

Testing/Basic/Homework/2. NumberValidator/NumberValidatorTests.cs

@@ -1,4 +1,5 @@
 
+using FluentAssertions;
 using NUnit.Framework;
 using NUnit.Framework.Legacy;
 
@@ -7,25 +8,184 @@ namespace HomeExercise.Tasks.NumberValidator;
 [TestFixture]
 public class NumberValidatorTests
 {
+    private const string PrecisionExceptionMessage = "precision must be a positive number";
+    private const string ScaleExceptionMessage = "scale must be a non-negative number less or equal than precision";
+
+    [TestCase(1, 2)]
+    [TestCase(1, 1)]
+    public void ConstructorShould_ThrowException_WhenPositivePrecisionLessOrEqualScale(int  precision, int scale)
+    {
+        var createValidator = () => new NumberValidator(precision, scale, true);
+
+        createValidator
+            .Should()
+            .Throw<ArgumentException>()
+            .WithMessage(ScaleExceptionMessage);
+    }
+
+    [Test]
+    public void ConstructorShould_ThrowException_WhenNegativeScale()
+    {
+        var createValidator = () => new NumberValidator(1, -1, true);
+
+        createValidator
+            .Should()
+            .Throw<ArgumentException>()
+            .WithMessage(ScaleExceptionMessage);
+    }
+
+    [Test]
+    [TestCase(1, 0, true)]
+    [TestCase(5, 2, false)]
+    [TestCase(4, 3, true)]
+    public void ConstructorShould_NotThrowException_WhenValidParameters(int precision, int scale, bool onlyPositive)
+    {
+         var createValidator = () => new NumberValidator(precision, scale, onlyPositive);
+
+         createValidator
+             .Should()
+             .NotThrow();
+    }
+
+    [TestCase(4, 2, true, "12.34")]
+    [TestCase(4, 3, true, "+1.23")]
+    [TestCase(5, 4, true, "1.2345")]
+    public void IsValidNumberShould_BeTrue_WhenValidNumber(int precision, int scale, bool onlyPositive, string testNumber)
+    {
+        var validator = new NumberValidator(precision, scale, onlyPositive);
+
+        validator.IsValidNumber(testNumber)
+            .Should()
+            .BeTrue(because: $"values is ({precision}, {scale}, onlyPositive: {onlyPositive}, testNumber: {testNumber})");
+    }
+
     [Test]
-    public void Test()
-    {
-        Assert.Throws<ArgumentException>(() => new NumberValidator(-1, 2, true));
-        Assert.DoesNotThrow(() => new NumberValidator(1, 0, true));
-        Assert.Throws<ArgumentException>(() => new NumberValidator(-1, 2, false));
-        Assert.DoesNotThrow(() => new NumberValidator(1, 0, true));
-
-        ClassicAssert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0.0"));
-        ClassicAssert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0"));
-        ClassicAssert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0.0"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("00.00"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("-0.00"));
-        ClassicAssert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0.0"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("+0.00"));
-        ClassicAssert.IsTrue(new NumberValidator(4, 2, true).IsValidNumber("+1.23"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("+1.23"));
-        ClassicAssert.IsFalse(new NumberValidator(17, 2, true).IsValidNumber("0.000"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("-1.23"));
-        ClassicAssert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("a.sd"));
+    public void IsValidNumberShould_BeFalse_WhenNegativeNumberWithOnlyPositiveTrue()
+    {
+        var validator = new NumberValidator(4, 2, true);
+
+        validator.IsValidNumber("-2.34")
+            .Should()
+            .BeFalse();
+    }
+
+    [Test]
+    public void IsValidNumberShould_BeTrue_WhenNegativeNumberWithOnlyPositiveFalse()
+    {
+        var validator = new NumberValidator(4, 2, false);
+
+        validator.IsValidNumber("-2.34")
+            .Should()
+            .BeTrue();
+    }
+
+    [TestCase(4, 2, true, "512.34")]
+    [TestCase(4, 3, true, "12.345")]
+    public void IsValidNumberShould_BeFalse_WhenNumberLongerThanPrecision(int precision, int scale, bool onlyPositive, string testNumber)
+    {
+        var validator = new NumberValidator(precision, scale, onlyPositive);
+
+        validator.IsValidNumber(testNumber)
+            .Should()
+            .BeFalse();
+    }
+
+    [Test]
+    public void IsValidNumberShould_BeFalse_WhenNumberWithFracLongerThanScaleButValidPrecision()
+    {
+        var validator = new NumberValidator(5, 2, true);
+
+        validator.IsValidNumber("12.345")
+            .Should()
+            .BeFalse();
+    }
+
+    [TestCase("aaa")]
+    [TestCase("ab.cd")]
+    [TestCase("./wqq")]
+    public void IsValidNumberShould_BeFalse_WhenString(string testNumber)
+    {
+        var validator = new NumberValidator(4, 2, true);
+
+        validator.IsValidNumber(testNumber)
+            .Should()
+            .BeFalse();
+    }
+
+    [Test]
+    public void IsValidNumberShould_BeTrue_WhenInt()
+    {
+        var validator = new NumberValidator(4, 2, true);
+
+        validator.IsValidNumber("12")
+            .Should()
+            .BeTrue();
+    }
+
+    [TestCase("")]
+    [TestCase(null)]
+    public void IsValidNumberShould_BeFalse_WhenNullOrEmpty(string testNumber)
+    {
+        var validator = new NumberValidator(4, 2, true);
+
+        validator.IsValidNumber(testNumber)
+            .Should()
+            .BeFalse();
+    }
+
+    [TestCase("12.3")]
+    [TestCase("12,3")]
+    public void IsValidNumberShould_BeTrue_WhenDifferentSeparator(string testNumber)
+    {
+        var validator = new NumberValidator(4, 2, true);
+
+        validator.IsValidNumber(testNumber)
+            .Should()
+            .BeTrue();
+    }
+
+    [TestCase("1.")]
+    [TestCase("1,")]
+    public void IsValidNumberShould_BeFalse_WhenNumberWithinInt(string testNumber)
+    {
+        var validator = new NumberValidator(4, 2, true);
+
+        validator.IsValidNumber(testNumber)
+            .Should()
+            .BeFalse();
+    }
+
+    [TestCase("1.")]
+    [TestCase("1,")]
+    public void Should_BeFalse_WhenNumberWithSeparatorButWithinFrac(string testNumber)
+    {
+        var validator = new NumberValidator(4, 2, true);
+
+        validator.IsValidNumber(testNumber)
+            .Should()
+            .BeFalse();
+    }
+
+    [TestCase("1.2.3")]
+    [TestCase("1,222,3")]
+    public void Should_BeFalse_WhenIncorrectNum(string  testNumber)
+    {
+        var validator = new NumberValidator(4, 2, true);
+
+        validator.IsValidNumber(testNumber)
+            .Should()
+            .BeFalse();
+    }
+
+    [TestCase("    12")]
+    [TestCase("12    ")]
+    [TestCase("1   2")]
+    public void Should_BeFalse_WhenNumWithWhitespaces(string  testNumber)
+    {
+        var validator = new NumberValidator(4, 2, true);
+
+        validator.IsValidNumber(testNumber)
+            .Should()
+            .BeFalse(because: $"value is {testNumber}");
     }
 }

Testing/Testing.sln.DotSettings.user

@@ -0,0 +1,4 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=ec5dcdba_002Dbdbe_002D43f6_002D8ebb_002D6331fdf6338d/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" IsActive="True" Name="All tests from 1. ObjectComparison" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;&#xD;
+  &lt;Project Location="C:\Users\sega2\Study\kONTIR\shpora-testing\Testing\Basic" Presentation="&amp;lt;Basic&amp;gt;" /&gt;&#xD;
+&lt;/SessionState&gt;</s:String></wpf:ResourceDictionary>