Шагов Владислав

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;
@@ -13,17 +14,10 @@ public void CheckCurrentTsar()
 
         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(t => t.DeclaringType == typeof(Person) && t.Name == nameof(Person.Id)));
+        //избегаем падения теста при добавлении предков, не сравнивая Id любого объекта класса Person
     }
 
     [Test]
@@ -35,7 +29,9 @@ public void CheckCurrentTsar_WithCustomEquality()
             new Person("Vasili III of Russia", 28, 170, 60, null));
 
         // Какие недостатки у такого подхода? 
-        ClassicAssert.True(AreEqual(actualTsar, expectedTsar));
+        ClassicAssert.True(AreEqual(actualTsar, expectedTsar));//нет информации о провале в тесте, неизвестно, где ошибка
+        //Если добавить новое поле в Person придётся менять AreEqual, а не только данные для проверки.
+        //В моём варианте нужно добавить только поля не требующие проверки (что происходит реже)
     }
 
     private bool AreEqual(Person? actual, Person? expected)

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

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

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

@@ -1,31 +1,200 @@
-
+using FluentAssertions;
 using NUnit.Framework;
-using NUnit.Framework.Legacy;
 
 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 than precision";
+
     [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"));
+    [TestCase(-1)]
+    [TestCase(0)]
+    public void Should_ThrowException_WhenNotPositivePrecision(int precision)
+    {
+
+        var action = () => new NumberValidator(precision, 2, true);
+
+        action.Should().Throw<ArgumentException>()
+            .WithMessage(PrecisionExceptionMessage);
+    }
+
+    [Test]
+    [TestCase(1, 2)]
+    [TestCase(1, 1)]
+    public void Should_ThrowException_WhenPositivePrecisionLessOrEqualScale(int  precision, int scale)
+    {
+
+        var action = () => new NumberValidator(precision, scale, true);
+
+        action.Should().Throw<ArgumentException>()
+            .WithMessage(ScaleExceptionMessage);
+    }
+
+    [Test]
+    public void Should_ThrowException_WhenNegativeScale()
+    {
+        var action = () => new NumberValidator(1, -1, true);
+
+        action.Should().Throw<ArgumentException>()
+            .WithMessage(ScaleExceptionMessage);
+    }
+
+    [Test]
+    [TestCase(1, 0, true)]
+    [TestCase(5, 2, false)]
+    [TestCase(4, 3, true)]
+    public void ShouldNot_ThrowException_WhenValidParameters(int precision, int scale, bool onlyPositive)
+    {
+         var action = () => new NumberValidator(precision, scale, onlyPositive);
+
+         action.Should().NotThrow();
+    }
+
+    [Test]
+    [TestCase(4, 2, true, "12.34")]
+    [TestCase(4, 3, true, "+2.34")]
+    [TestCase(4, 3, true, "1.345")]
+    public void Should_BeTrue_WhenValidNumber(int precision, int scale, bool onlyPositive, string testNumber)
+    {
+        var testNum = new NumberValidator(4, 2, true);
+
+        var res = testNum.IsValidNumber("12.34");
+
+        res.Should().BeTrue();
+    }
+
+    [Test]
+    public void Should_BeFalse_WhenNegativeNumberWithOnlyPositiveTrue()
+    {
+        var testNum = new NumberValidator(4, 2, true);
+
+        var res = testNum.IsValidNumber("-2.34");
+
+        res.Should().BeFalse();
+    }
+
+    [Test]
+    public void Should_BeTrue_WhenNegativeNumberWithOnlyPositiveFalse()
+    {
+        var testNum = new NumberValidator(4, 2, false);
+
+        var res = testNum.IsValidNumber("-2.34");
+
+        res.Should().BeTrue();
+    }
+
+    [Test]
+    [TestCase(4, 2, true, "512.34")]
+    [TestCase(4, 3, true, "12.345")]
+    public void Should_BeFalse_WhenNumberLongerThanPrecision(int precision, int scale, bool onlyPositive, string testNumber)
+    {
+        var testNum = new NumberValidator(precision, scale, onlyPositive);
+
+        var res = testNum.IsValidNumber(testNumber);
+
+        res.Should().BeFalse();
+    }
+
+    [Test]
+    public void Should_BeFalse_WhenNumberWithFracLongerThanScaleButValidPrecision()
+    {
+        var testNum = new NumberValidator(5, 2, true);
+
+        var res = testNum.IsValidNumber("12.345");
+
+        res.Should().BeFalse();
+    }
+
+    [Test]
+    public void Should_BeFalse_WhenString()
+    {
+        var testNum = new NumberValidator(4, 2, true);
+
+        var res = testNum.IsValidNumber("ab.cd");
+
+        res.Should().BeFalse();
+    }
+
+    [Test]
+    public void Should_BeTrue_WhenInt()
+    {
+        var testNum = new NumberValidator(4, 2, true);
+
+        var res = testNum.IsValidNumber("52");
+
+        res.Should().BeTrue();
+    }
+
+    [Test]
+    [TestCase("")]
+    [TestCase(null)]
+    public void Should_BeFalse_WhenNullOrEmpty(string testNumber)
+    {
+        var testNum = new NumberValidator(4, 2, true);
+
+        var res = testNum.IsValidNumber(testNumber);
+
+        res.Should().BeFalse();
+    }
+
+    [Test]
+    [TestCase("12.43")]
+    [TestCase("12,43")]
+    public void Should_BeTrue_WhenDifferentSeparator(string testNumber)
+    {
+        var testNum = new NumberValidator(4, 2, true);
+
+        var res = testNum.IsValidNumber(testNumber);
+
+        res.Should().BeTrue();
+    }
+
+    [Test]
+    public void Should_BeFalse_WhenNumberWithinInt()
+    {
+        var testNum1 = new NumberValidator(4, 2, true).IsValidNumber(".5");
+        var testNum2 = new NumberValidator(4, 2, true).IsValidNumber(",5");
+
+        testNum1.Should().BeFalse();
+        testNum2.Should().BeFalse();
+    }
+
+    [Test]
+    [TestCase("1.")]
+    [TestCase("1,")]
+    public void Should_BeFalse_WhenNumberWithSeparatorButWithinFrac(string  testNumber)
+    {
+        var testNum = new NumberValidator(4, 2, true);
+
+        var res = testNum.IsValidNumber(testNumber);
+
+        res.Should().BeFalse();
+    }
+
+    [Test]
+    [TestCase("1.2.3")]
+    [TestCase("1,,3")]
+    public void Should_BeFalse_WhenIncorrectNum(string  testNumber)
+    {
+        var testNum = new NumberValidator(4, 2, true);
+
+        var res = testNum.IsValidNumber(testNumber);
+
+        res.Should().BeFalse();
+    }
+
+    [Test]
+    [TestCase(" 12")]
+    [TestCase("12 ")]
+    [TestCase("1 2")]
+    public void Should_BeFalse_WhenNumWithWhitespaces(string  testNumber)
+    {
+        var testNum = new NumberValidator(4, 2, true);
+        var res = testNum.IsValidNumber(testNumber);
+        res.Should().BeFalse();
+
     }
 }