Попов Захар

README.md

@@ -1,35 +1,38 @@
-# Test Driven Development
+Примеры работ с разными параметрами:
+1. 
+- Число прямоугольников = 100;
+- Ширина прямоугольников от 30 до 70 пикселей;
+- Высота прямоугольников от 20 до 50 пикселей.
 
-Пройдя блок, ты:
+![circularCloudLayouter](https://github.com/user-attachments/assets/7f83aa24-c3be-4c38-a042-6c67ea48f026)
 
-- Узнаешь, почему полезно писать тесты вместе с кодом
-- Скорее всего поймешь, что никогда раньше не писал тесты в стиле TDD по-настоящему :-)
-- Получишь опыт парного TDD.
-- Станешь считать стиль TDD естественным и удобным в работе
+2. 
+- Число прямоугольников = 10000;
+- Ширина прямоугольников от 30 до 70 пикселей;
+- Высота прямоугольников от 20 до 50 пикселей.
 
+![circularCloudLayouter](https://github.com/user-attachments/assets/fa3162c6-1428-465b-821e-fc748274c106)
 
-## Необходимые знания
+3. 
+- Число прямоугольников = 100;
+- Ширина прямоугольников от 30 до 700 пикселей;
+- Высота прямоугольников от 20 до 500 пикселей.
 
-Понадобится знание C# или JS
+![circularCloudLayouter](https://github.com/user-attachments/assets/5cf95ab5-fb7e-457f-8842-530b99b4be0d)
 
-Рекомендуется пройти блок [Тестирование](https://github.com/kontur-courses/testing)
+4. 
+- Число прямоугольников = 10;
+- Ширина прямоугольников от 30 до 700 пикселей;
+- Высота прямоугольников от 20 до 500 пикселей.
 
+![circularCloudLayouter](https://github.com/user-attachments/assets/839af33d-aaba-4259-a111-2218710a45df)
 
-## Самостоятельная подготовка
+5. 
+- Число прямоугольников = 10;
+- Ширина прямоугольников от 30 до 700 пикселей;
+- Высота прямоугольников от 20 до 500 пикселей.
 
-Посмотри [видеодемонстрацию TDD](https://www.youtube.com/watch?v=lLTv2JSrCBY) (10 минут)
+![circularCloudLayouter](https://github.com/user-attachments/assets/9f0ac478-2ca5-4522-b9b1-a2764f2f4493)
 
-
-## Очная встреча
-
-~ 3.5 часа
-
-
-[Инструкция для дистанционного формата](https://docs.google.com/document/d/18YYaIoyWfNzf1HXT_DCWnsqJA_3yoNkjetj_E4omMY8/edit?usp=sharing)
-
-
-## Закрепление материала
-
-1. Выполни задание [Облако тегов](HomeExercise.md)
-2. Спецзадание __TDD__  
-Выполни ещё какую-нибудь ближайшую задачу в стиле TDD. Рабочую задачу, если уже работаешь, или учебную, если ещё учишься.
+Принцип расположения прямоугольников:
+Прямоугольники ставятся на окружности увеличивающегося радиуса с центром в точке, совпадающей с центром первого поставленного прямоугольника.

cs/TagsCloudVisualization.Tests/CircularCloudLayouterMainRequirementsTests.cs

@@ -0,0 +1,138 @@
+using FluentAssertions;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TagsCloudVisualization.Tests
+{
+    [TestFixture]
+    internal class CircularCloudLayouterMainRequirementsTests
+    {
+        private Point _center;
+        private Rectangle[] _rectangles;
+        private string _failedTestsDirectory = "FailedTest";
+
+        [OneTimeSetUp]
+        public void Init()
+        {
+            Directory.CreateDirectory(_failedTestsDirectory);
+        }
+
+        [SetUp]
+        public void SetUp()
+        {
+            _center = new Point(400, 400);
+            var minRectangleWidth = 30;
+            var maxRectangleWidth = 70;
+            var minRectangleHeight = 20;
+            var maxRectangleHeight = 50;
+            var rectanglesCount = 1000;
+
+            _rectangles = new Rectangle[rectanglesCount];
+            var circularCloudLayouter = new CircularCloudLayouter(_center);
+            for (int i = 0; i < rectanglesCount; i++)
+            {
+                var nextRectangleSize = CircularCloudLayouterWorker.GetNextRectangleSize(
+                    minRectangleWidth,
+                    maxRectangleWidth,
+                    minRectangleHeight,
+                    maxRectangleHeight);
+                _rectangles[i] = circularCloudLayouter.PutNextRectangle(nextRectangleSize);
+            }
+        }
+
+        [TestCase(1.1, ExpectedResult = true)]
+        [Repeat(10)]
+        public bool ShouldPlaceRectanglesInCircle(double goodAspectRatio)
+        {
+            var boundingBoxSize = GetBoundingBoxSize();
+            var actualAspectRatio =
+                (double)Math.Max(boundingBoxSize.Width, boundingBoxSize.Height)
+                / Math.Min(boundingBoxSize.Width, boundingBoxSize.Height);
+            return actualAspectRatio <= goodAspectRatio;
+        }
+
+        [TestCase(0.1, ExpectedResult = true)]
+        [Repeat(10)]
+        public bool ShouldPlaceRectanglesNearCenter(double percentFromBoundingBoxMaxSize)
+        {
+            var centerX = _rectangles.Average(r => r.Left + r.Width / 2.0);
+            var centerY = _rectangles.Average(r => r.Top + r.Height / 2.0);
+            var actualCenter = new Point((int)centerX, (int)centerY);
+
+            var distance = Math.Sqrt(Math.Pow(actualCenter.X - _center.X, 2)
+                                     + Math.Pow(actualCenter.Y - _center.Y, 2));
+
+            var boundingBoxSize = GetBoundingBoxSize();
+
+            var maxAllowedDistance = Math.Max(boundingBoxSize.Width, boundingBoxSize.Height)
+                                     * percentFromBoundingBoxMaxSize;
+
+            return maxAllowedDistance >= distance;
+        }
+
+        [Test]
+        [Repeat(10)]
+        public void ShouldPlaceRectanglesWithoutOverlap()
+        {
+            for (var i = 0; i < _rectangles.Length; i++)
+            {
+                for (var j = i + 1; j < _rectangles.Length; j++)
+                {
+                    Assert.That(
+                        _rectangles[i].IntersectsWith(_rectangles[j]) == false,
+                        $"Прямоугольники пересекаются:\n" +
+                        $"{_rectangles[i].ToFormatedString()}\n" +
+                        $"{_rectangles[j].ToFormatedString()}");
+                }
+            }
+        }
+
+
+        [TestCase(0.55, ExpectedResult = true)]
+        [Repeat(10)]
+        public bool ShouldPlaceRectanglesTightly(double tight)
+        {
+            var boundingBoxSize = GetBoundingBoxSize();
+            var boundingBoxArea = boundingBoxSize.Width * boundingBoxSize.Height;
+            var filledArea = _rectangles.Sum(r => r.Width * r.Height);
+            return ((double)filledArea / boundingBoxArea) >= tight;
+        }
+
+        [TearDown]
+        public void Cleanup()
+        {
+            if (TestContext.CurrentContext.Result.FailCount == 0)
+            {
+                return;
+            }
+
+            var name = $"{TestContext.CurrentContext.Test.Name}.png";
+            var path = Path.Combine(_failedTestsDirectory, name);
+            ImageSaver.SaveFile(CircularCloudLayouterPainter.Draw(_rectangles), path);
+            Console.WriteLine($"Tag cloud visualization saved to file {path}");
+        }
+
+        [OneTimeTearDown]
+        public void OneTimeCleanup()
+        {
+            if (Directory.Exists(_failedTestsDirectory)
+                && Directory.GetFiles(_failedTestsDirectory).Length == 0)
+            {
+                Directory.Delete(_failedTestsDirectory);
+            }
+        }
+
+        private Size GetBoundingBoxSize()
+        {
+            var minX = _rectangles.Min(r => r.Left);
+            var minY = _rectangles.Min(r => r.Top);
+            var maxX = _rectangles.Max(r => r.Right);
+            var maxY = _rectangles.Max(r => r.Bottom);
+            return new Size(maxX - minX, maxY - minY);
+        }
+    }
+}

cs/TagsCloudVisualization.Tests/CircularCloudLayouterPainterTests.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using static System.Net.Mime.MediaTypeNames;
+
+namespace TagsCloudVisualization.Tests
+{
+    [TestFixture]
+    internal class CircularCloudLayouterPainterTests
+    {
+        private int _defaultPadding = 10;
+
+        [Test]
+        public void Draw_ThrowsArgumentException_OnEmptyRectangleList()
+        {
+            Assert.Throws<ArgumentException>(
+                () => CircularCloudLayouterPainter.Draw(new List<Rectangle>()));
+        }
+
+        [TestCase(null, ExpectedResult = true)]
+        [TestCase(100, ExpectedResult = true)]
+        public bool Draw_CalculatesImageSizeCorrectly(int? padding)
+        {
+            var correctPadding = padding ?? _defaultPadding;
+            var rectangles = new List<Rectangle>()
+            {
+                new Rectangle(new Point(0, 0), new Size(10, 10))
+            };
+
+            var image = CircularCloudLayouterPainter.Draw(rectangles, padding);
+            return image.Height == rectangles[0].Height + 2 * correctPadding
+                   && image.Width == rectangles[0].Width + 2 * correctPadding;
+        }
+    }
+}

cs/TagsCloudVisualization.Tests/CircularCloudLayouterTests.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TagsCloudVisualization.Tests
+{
+    [TestFixture]
+    internal class CircularCloudLayouterTests
+    {
+        [TestCase(0, 100)]
+        [TestCase(-1, 100)]
+        [TestCase(100, 0)]
+        [TestCase(100, -1)]
+        public void PutNextRectangle_ThrowsArgumentException_OnAnyNegativeOrZeroSize(
+            int width,
+            int height)
+        {
+            var size = new Size(width, height);
+            Assert.Throws<ArgumentException>(
+                () => new CircularCloudLayouter(new Point()).PutNextRectangle(size));
+        }
+    }
+}

cs/TagsCloudVisualization.Tests/CircularCloudLayouterWorkerTests.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TagsCloudVisualization.Tests
+{
+    [TestFixture]
+    internal class CircularCloudLayouterWorkerTests
+    {
+        [TestCase(0, 100)]
+        [TestCase(-1, 100)]
+        [TestCase(100, 0)]
+        [TestCase(100, -1)]
+        public void GetNextRectangleSize_ThrowsArgumentException_OnAnyNegativeOrZeroSize(int width, int height)
+        {
+            Assert.Throws<ArgumentException>(
+                () => CircularCloudLayouterWorker.GetNextRectangleSize(width, width, height, height));
+        }
+
+        [TestCase(50, 25, 25, 50)]
+        [TestCase(25, 50, 50, 25)]
+        public void GetNextRectangleSize_ThrowsArgumentException_OnNonConsecutiveSizeValues(
+            int minWidth,
+            int maxWidth,
+            int minHeight,
+            int maxHeight)
+        {
+            Assert.Throws<ArgumentException>(
+                () => CircularCloudLayouterWorker.GetNextRectangleSize(minWidth, maxWidth, minHeight, maxHeight));
+        }
+    }
+}

cs/TagsCloudVisualization.Tests/ImageSaverTest.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TagsCloudVisualization.Tests
+{
+    [TestFixture]
+    internal class ImageSaverTest
+    {
+        private string _directoryPath = "TempFilesForTests";
+
+        [OneTimeSetUp]
+        public void Init()
+        {
+            Directory.CreateDirectory(_directoryPath);
+        }
+
+        [TestCase("Test.png")]
+        public void SaveFile_ArgumentNullException_WithNullBitmap(string filename)
+        {
+            var path = Path.Combine(_directoryPath, filename);
+            Assert.Throws<ArgumentNullException>(() => ImageSaver.SaveFile(null, path));
+        }
+
+        [TestCase(null)]
+        [TestCase("")]
+        [TestCase(" ")]
+        public void SaveFile_ThrowsArgumentException_WithInvalidFilename(string filename)
+        {
+            var dummyImage = new Bitmap(1, 1);
+            Assert.Throws<ArgumentException>(() => ImageSaver.SaveFile(dummyImage, filename));
+        }
+
+        [TestCase("Test.png", ExpectedResult = true)]
+        public bool SaveFile_SavesFile(string filename)
+        {
+            var dummyImage = new Bitmap(1, 1);
+            var path = Path.Combine(_directoryPath, filename);
+
+            File.Delete(path);
+            ImageSaver.SaveFile(dummyImage, path);
+            return File.Exists(path);
+        }
+
+
+        [OneTimeTearDown]
+        public void OneTimeCleanup()
+        {
+            if (Directory.Exists(_directoryPath))
+            {
+                Directory.Delete(_directoryPath, true);
+            }
+        }
+    }
+}

cs/TagsCloudVisualization.Tests/RectangleExtensions.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TagsCloudVisualization.Tests
+{
+    internal static class RectangleExtensions
+    {
+        public static string ToFormatedString(this Rectangle rectangle)
+        {
+            return $"X={rectangle.X}, Y={rectangle.Y}, Width={rectangle.Width}, Height={rectangle.Height}";
+        }
+    }
+}