Яценко Ирина

cs/HomeExercises/NumberValidatorTests.cs

@@ -8,27 +8,127 @@ namespace HomeExercises
 	public class NumberValidatorTests
 	{
 		[Test]
-		public void Test()
+		public void NumberValidator_WhenPassNegativePrecision_ShouldThrowsArgumentException()
 		{
-			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));
-
-			Assert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0.0"));
-			Assert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0"));
-			Assert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0.0"));
-			Assert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("00.00"));
-			Assert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("-0.00"));
-			Assert.IsTrue(new NumberValidator(17, 2, true).IsValidNumber("0.0"));
-			Assert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("+0.00"));
-			Assert.IsTrue(new NumberValidator(4, 2, true).IsValidNumber("+1.23"));
-			Assert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("+1.23"));
-			Assert.IsFalse(new NumberValidator(17, 2, true).IsValidNumber("0.000"));
-			Assert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("-1.23"));
-			Assert.IsFalse(new NumberValidator(3, 2, true).IsValidNumber("a.sd"));
+			TestDelegate testDelegate = () => new NumberValidator(-1, 2, true);
+
+			Assert.Throws<ArgumentException>(testDelegate);
 		}
-	}
+
+		[Test]
+		public void NumberValidator_WhenPassNegativeScale_ShouldThrowsArgumentException()
+		{
+			TestDelegate testDelegate = () => new NumberValidator(1, -2);
+
+			Assert.Throws<ArgumentException>(testDelegate);
+		}
+
+		[Test]
+		public void NumberValidator_WhenPassValidArguments_ShouldDoesNotThrows()
+		{
+			TestDelegate testDelegate = () => new NumberValidator(1, 0, true);
+
+			Assert.DoesNotThrow(testDelegate);
+		}
+
+		[Test]
+		public void NumberValidator_WhenPrecisionIsEqualToTheScale_ShouldReturnFalse()
+		{
+			TestDelegate testDelegate = () => new NumberValidator(2, 2, true);
+
+			Assert.Throws<ArgumentException>(testDelegate);
+		}
+
+		[Test]
+		public void IsValidNumber_WhenPassOnlyPositiveIsFalseButNumbersDoesNotHaveNegativeSign_ShouldReturnTrue()
+		{
+			var validator = new NumberValidator(17, 2);
+
+			var numberIsValid = validator.IsValidNumber("1.0");
+
+			Assert.True(numberIsValid);
+		}
+
+		[Test]
+		public void IsValidNumber_WhenLettersInsteadOfNumber_ShouldReturnFalse()
+		{
+			var validator = new NumberValidator(3, 2, true);
+
+			var numberIsValid = validator.IsValidNumber("a.sd");
+
+			Assert.IsFalse(numberIsValid);
+		}
+
+		[Test]
+		public void IsValidNumber_WhenSymbolsInsteadOfNumber_ShouldReturnFalse()
+		{
+			var validator = new NumberValidator(3, 2, true);
+
+			var numberIsValid = validator.IsValidNumber("2.!");
+
+			Assert.IsFalse(numberIsValid);
+		}
+
+		[Test]
+		public void IsValidNumber_WhenFractionalPartIsMissing_ShouldReturnTrue()
+		{
+			var validator = new NumberValidator(17, 2, true);
+
+			var numberIsValid = validator.IsValidNumber("0");
+
+			Assert.IsTrue(numberIsValid);
+		}
+
+		[Test]
+		public void IsValidNumber_WhenNumberIsNull_ShouldReturnFalse()
+		{
+			var validator = new NumberValidator(17, 2, true);
+
+			var numberIsValid = validator.IsValidNumber(null!);
+
+			Assert.IsFalse(numberIsValid);
+		}
+
+		[Test]
+		public void IsValidNumber_WhenPassNumberIsEmpty_ShouldReturnFalse()
+		{
+			var validator = new NumberValidator(3, 2, true);
+
+			var numberIsValid = validator.IsValidNumber("");
+
+			Assert.IsFalse(numberIsValid);
+		}
+
+		[Test]
+		public void IsValidNumber_WhenIntPartWithNegativeSignMoreThanPrecision_ShouldReturnFalse()
+		{
+			var validator = new NumberValidator(3, 2, true);
+
+			var numberIsValid = validator.IsValidNumber("-0.00");
+
+			Assert.IsFalse(numberIsValid);
+		}
+
+		[Test]
+		public void IsValidNumber_WhenIntPartWithPositiveSignMoreThanPrecision_ShouldReturnFalse()
+		{
+			var validator = new NumberValidator(3, 2, true);
+
+			var numberIsValid = validator.IsValidNumber("+1.23");
+
+			Assert.IsFalse(numberIsValid);
+		}
+
+		[Test]
+		public void IsValidNumber_WhenFractionalPartMoreThanScale_ShouldReturnFalse()
+		{
+			var validator = new NumberValidator(17, 2, true);
+
+			var numberIsValid = validator.IsValidNumber("0.000");
+
+			Assert.IsFalse(numberIsValid);
+		}
+    }
 
 	public class NumberValidator
 	{

cs/HomeExercises/ObjectComparison.cs

@@ -3,81 +3,83 @@
 
 namespace HomeExercises
 {
-	public class ObjectComparison
-	{
-		[Test]
-		[Description("Проверка текущего царя")]
-		[Category("ToRefactor")]
-		public void CheckCurrentTsar()
-		{
-			var actualTsar = TsarRegistry.GetCurrentTsar();
+    public class ObjectComparison
+    {
+        [Test]
+        [Description("Проверка текущего царя")]
+        [Category("ToRefactor")]
+        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));
+	        var expectedTsar = new Person("Ivan IV The Terrible", 54, 170, 70,
+		        new Person("Vasili III of Russia", 28, 170, 60, null));
 
-			// Перепишите код на использование Fluent Assertions.
-			Assert.AreEqual(actualTsar.Name, expectedTsar.Name);
-			Assert.AreEqual(actualTsar.Age, expectedTsar.Age);
-			Assert.AreEqual(actualTsar.Height, expectedTsar.Height);
-			Assert.AreEqual(actualTsar.Weight, expectedTsar.Weight);
+	        // Перепишите код на использование Fluent Assertions.
+	        actualTsar.Should()
+		        .BeEquivalentTo(expectedTsar, x => x
+			        .Excluding(x => x.Id)
+			        .Excluding(x => x.Parent!.Id));
+        }
 
-			Assert.AreEqual(expectedTsar.Parent!.Name, actualTsar.Parent!.Name);
-			Assert.AreEqual(expectedTsar.Parent.Age, actualTsar.Parent.Age);
-			Assert.AreEqual(expectedTsar.Parent.Height, actualTsar.Parent.Height);
-			Assert.AreEqual(expectedTsar.Parent.Parent, actualTsar.Parent.Parent);
-		}
+        [Test]
+        [Description("Альтернативное решение. Какие у него недостатки?")]
+        public void CheckCurrentTsar_WithCustomEquality()
+        {
+	        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));
 
-		[Test]
-		[Description("Альтернативное решение. Какие у него недостатки?")]
-		public void CheckCurrentTsar_WithCustomEquality()
-		{
-			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));
+	        // Какие недостатки у такого подхода? 
+	        //Данный подход делает класс труднорасширяемым, ведь при добавлении новых полей в класс Person
+	        //нужно переписывать и метод сравнения для всех этих полей, так же новые поля cможет добавить
+	        //другой разработчик, который не знает о таком методе сравнения, что приведет к новым, неотловоенным ошибкам - 
+	        //новые поля не будут сравниваться.
+	        //В моем решении (CheckCurrentTsar), такой ошибки не возникнет и класс Person сможет без ошибок расширяться
+	        //при условии, что сравниваться будут все поля, кроме Id (так же и их Parent), так как код написан не перебиранием
+	        //всех полей для сравнения, а сравнением объекта в целом с исключением его Id.
+	        Assert.True(AreEqual(actualTsar, expectedTsar));
+        }
 
-			// Какие недостатки у такого подхода? 
-			Assert.True(AreEqual(actualTsar, expectedTsar));
-		}
+        private bool AreEqual(Person? actual, Person? expected)
+        {
+            if (actual == expected) return true;
+            if (actual == null || expected == null) return false;
+            return
+                actual.Name == expected.Name
+                && actual.Age == expected.Age
+                && actual.Height == expected.Height
+                && actual.Weight == expected.Weight
+                && AreEqual(actual.Parent, expected.Parent);
+        }
+    }
 
-		private bool AreEqual(Person? actual, Person? expected)
-		{
-			if (actual == expected) return true;
-			if (actual == null || expected == null) return false;
-			return
-				actual.Name == expected.Name
-				&& actual.Age == expected.Age
-				&& actual.Height == expected.Height
-				&& actual.Weight == expected.Weight
-				&& AreEqual(actual.Parent, expected.Parent);
-		}
-	}
+    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));
+        }
+    }
 
-	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));
-		}
-	}
+    public class Person
+    {
+        public static int IdCounter = 0;
+        public int Age, Height, Weight;
+        public string Name;
+        public Person? Parent;
+        public int Id;
 
-	public class Person
-	{
-		public static int IdCounter = 0;
-		public int Age, Height, Weight;
-		public string Name;
-		public Person? Parent;
-		public int Id;
-
-		public Person(string name, int age, int height, int weight, Person? parent)
-		{
-			Id = IdCounter++;
-			Name = name;
-			Age = age;
-			Height = height;
-			Weight = weight;
-			Parent = parent;
-		}
-	}
+        public Person(string name, int age, int height, int weight, Person? parent)
+        {
+            Id = IdCounter++;
+            Name = name;
+            Age = age;
+            Height = height;
+            Weight = weight;
+            Parent = parent;
+        }
+    }
 }