Попов Захар

.gitignore

@@ -197,3 +197,4 @@ FakesAssemblies/
 *.opt
 
 *Solved.cs
+/TagCloud/Properties

FileSenderRailway/Result.cs

@@ -1,5 +1,8 @@
 using System;
+using System.Runtime.CompilerServices;
 
+[assembly: InternalsVisibleTo("TagCloud")]
+[assembly: InternalsVisibleTo("TagCloud.Tests")]
 namespace FileSenderRailway;
 
 public class None

TagCloud.Tests/CloudLayouterPaintersTest/CloudLayouterPainterTest.cs

@@ -0,0 +1,52 @@
+using FileSenderRailway;
+using FluentAssertions;
+using System.Drawing;
+using TagCloud.CloudLayouterPainters;
+
+namespace TagCloud.Tests.CloudLayouterPaintersTest
+{
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Проверка совместимости платформы", Justification = "<Ожидание>")]
+    internal class CloudLayouterPainterTest
+    {
+        private CloudLayouterPainter painter;
+
+        [SetUp]
+        public void SetUp()
+        {
+            painter = new CloudLayouterPainter(new Size(1, 1));
+        }
+
+        [Test]
+        public void Draw_ThrowsException_WithEmptyTags()
+        {
+            var expected = Result.Fail<Bitmap>("Список тегов пуст");
+            var actual = painter.Draw(new List<Tag>());
+            actual.Should().BeEquivalentTo(expected);
+        }
+
+        [Test]
+        public void Draw_ThrowsException_WithTagsAsNull()
+        {
+
+            var expected = Result.Fail<Bitmap>("Tags передан как null");
+            var actual = painter.Draw(null!);
+            actual.Should().BeEquivalentTo(expected);
+        }
+
+        [Test]
+        public void Draw_ThrowsException_WithTooSmallToFitImage()
+        {
+            var expected = Result
+                .Fail<Bitmap>("Все прямоугольники не помещаются на изображение");
+            var actual = painter
+                .Draw(
+                    new Tag[]
+                    {
+                        new Tag(
+                            "Test",
+                            new Rectangle(new Point(0, 0), new Size(100, 100)))
+                    });
+            actual.Should().BeEquivalentTo(expected);
+        }
+    }
+}

TagCloud.Tests/CloudLayouterTests/CircularCloudLayouterTests/CircularCloudLayouterMainRequirementsTest.cs

@@ -0,0 +1,188 @@
+using FluentAssertions;
+using System.Drawing;
+using TagCloud.CloudLayouterPainters;
+using TagCloud.CloudLayouters.CircularCloudLayouter;
+using TagCloud.CloudLayouterWorkers;
+using TagCloud.ImageSavers;
+using TagCloud.Tests.Extensions;
+
+namespace TagCloud.Tests.CloudLayouterTests.CircularCloudLayouterTests
+{
+    [TestFixture]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Interoperability", "CA1416:Проверка совместимости платформы", Justification = "<Ожидание>")]
+    internal class CircularCloudLayouterMainRequirementsTest
+    {
+        private Point center = new Point();
+        private Rectangle[] rectangles;
+        private List<Tag> tags;
+        private readonly string failedTestsDirectory = "FailedTest";
+
+        private readonly ImageSaver imageSaver = new ImageSaver();
+        private readonly CloudLayouterPainter cloudLayouterPainter
+            = new CloudLayouterPainter(new Size(5000, 5000));
+
+        [OneTimeSetUp]
+        public void Init()
+        {
+            Directory.CreateDirectory(failedTestsDirectory);
+        }
+
+        [SetUp]
+        public void SetUp()
+        {
+            var minRectangleWidth = 30;
+            var maxRectangleWidth = 70;
+            var minRectangleHeight = 20;
+            var maxRectangleHeight = 50;
+            var rectanglesCount = 1000;
+
+            tags = new List<Tag>();
+            var circularCloudLayouter = new CircularCloudLayouter();
+
+            var randomWorker = new RandomCloudLayouterWorker(
+                minRectangleWidth,
+                maxRectangleWidth,
+                minRectangleHeight,
+                maxRectangleHeight);
+            foreach (var rectangleProperty in randomWorker
+                .GetNextRectangleProperties().GetValueOrThrow().Take(rectanglesCount))
+            {
+                tags.Add(
+                    new Tag(
+                        rectangleProperty.word,
+                        circularCloudLayouter.PutNextRectangle(rectangleProperty.size)
+                        .GetValueOrThrow()));
+            }
+            rectangles = tags.Select(x => x.Rectangle).ToArray();
+        }
+
+        [TestCase(0.7, 1000)]
+        [Repeat(10)]
+        public void ShouldPlaceRectanglesInCircle(double expectedCoverageRatio, int gridSize)
+        {
+            var maxRadius = rectangles.Max(
+                x => x.GetMaxDistanceFromPointToRectangleAngles(center));
+            var step = 2 * maxRadius / gridSize;
+
+            var occupancyGrid = GetOccupancyGrid(gridSize, maxRadius, step);
+
+            var actualCoverageRatio = GetOccupancyGridRatio(occupancyGrid, maxRadius, step);
+            actualCoverageRatio.Should().BeGreaterThanOrEqualTo(expectedCoverageRatio);
+        }
+
+        [TestCase(15)]
+        [Repeat(10)]
+        public void ShouldPlaceCenterOfMassOfRectanglesNearCenter(int tolerance)
+        {
+            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));
+
+            distance.Should().BeLessThanOrEqualTo(tolerance);
+        }
+
+        [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]),
+                        Is.EqualTo(false),
+                        $"Прямоугольники пересекаются:\n" +
+                        $"{rectangles[i].ToString()}\n" +
+                        $"{rectangles[j].ToString()}");
+                }
+            }
+        }
+
+        [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(cloudLayouterPainter.Draw(tags).GetValueOrThrow(), 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 (int start, int end) GetGridIndexesInterval(
+            int rectangleStartValue,
+            int rectangleCorrespondingSize,
+            double maxRadius,
+            double step)
+        {
+            var start = (int)((rectangleStartValue - center.X + maxRadius) / step);
+            var end = (int)((rectangleStartValue
+                + rectangleCorrespondingSize - center.X + maxRadius) / step);
+            return (start, end);
+        }
+
+        private bool[,] GetOccupancyGrid(int gridSize, double maxRadius, double step)
+        {
+            var result = new bool[gridSize, gridSize];
+            foreach (var rect in rectangles)
+            {
+                var xInterval = GetGridIndexesInterval(rect.X, rect.Width, maxRadius, step);
+                var yInterval = GetGridIndexesInterval(rect.Y, rect.Height, maxRadius, step);
+                for (var x = xInterval.start; x <= xInterval.end; x++)
+                {
+                    for (var y = yInterval.start; y <= yInterval.end; y++)
+                    {
+                        result[x, y] = true;
+                    }
+                }
+            }
+            return result;
+        }
+
+        private double GetOccupancyGridRatio(bool[,] occupancyGrid, double maxRadius, double step)
+        {
+            var totalCellsInsideCircle = 0;
+            var coveredCellsInsideCircle = 0;
+            for (var x = 0; x < occupancyGrid.GetLength(0); x++)
+            {
+                for (var y = 0; y < occupancyGrid.GetLength(0); y++)
+                {
+                    var cellCenterX = x * step - maxRadius + center.X;
+                    var cellCenterY = y * step - maxRadius + center.Y;
+
+                    var distance = Math.Sqrt(
+                        Math.Pow(cellCenterX - center.X, 2) + Math.Pow(cellCenterY - center.Y, 2));
+
+                    if (distance > maxRadius)
+                    {
+                        continue;
+                    }
+
+                    totalCellsInsideCircle += 1;
+                    if (occupancyGrid[x, y])
+                    {
+                        coveredCellsInsideCircle += 1;
+                    }
+                }
+            }
+            return (double)coveredCellsInsideCircle / totalCellsInsideCircle;
+        }
+    }
+}

TagCloud.Tests/CloudLayouterTests/CircularCloudLayouterTests/CircularCloudLayouterTest.cs

@@ -0,0 +1,26 @@
+using FileSenderRailway;
+using FluentAssertions;
+using System.Drawing;
+using TagCloud.CloudLayouters.CircularCloudLayouter;
+
+namespace TagCloud.Tests.CloudLayouterTests.CircularCloudLayouterTests
+{
+    [TestFixture]
+    internal class CircularCloudLayouterTest
+    {
+        [TestCase(0, 100)]
+        [TestCase(-1, 100)]
+        [TestCase(100, 0)]
+        [TestCase(100, -1)]
+        public void PutNextRectangle_ThrowsException_OnAnyNegativeOrZeroSize(
+            int width,
+            int height)
+        {
+            var size = new Size(width, height);
+            var expected = Result.Fail<Rectangle>(
+                "Размеры прямоугольника не могут быть меньше либо равны нуля");
+            var actual = new CircularCloudLayouter().PutNextRectangle(size);
+            actual.Should().BeEquivalentTo(expected);
+        }
+    }
+}

TagCloud.Tests/CloudLayouterWorkersTests/NormalizedFrequencyBasedCloudLayouterWorkerTest.cs

@@ -0,0 +1,70 @@
+using FileSenderRailway;
+using FluentAssertions;
+using System.Drawing;
+using TagCloud.CloudLayouterWorkers;
+
+namespace TagCloud.Tests.CloudLayouterWorkersTests
+{
+    internal class NormalizedFrequencyBasedCloudLayouterWorkerTest
+    {
+        private readonly Dictionary<string, double> normalizedValues
+            = new Dictionary<string, double>
+            {
+                { "three", 0.625 },
+                { "one", 0.25 },
+                { "two", 0.2917 },
+                { "four", 1.0 },
+            };
+
+        [TestCase(0, 100)]
+        [TestCase(-1, 100)]
+        [TestCase(100, 0)]
+        [TestCase(100, -1)]
+        public void GetNextRectangleSize_ThrowsException_OnAnyNegativeOrZeroSize(
+            int width,
+            int height)
+        {
+            var expected = Result
+                .Fail<IEnumerable<(string word, Size size)>>
+                    ($"Переданное числовое значение должно быть больше 0: \"{(width <= 0 ? width : height)}\"");
+
+            var worker = new NormalizedFrequencyBasedCloudLayouterWorker(
+                width,
+                height,
+                normalizedValues);
+            var actual = worker.GetNextRectangleProperties();
+            actual.Should().BeEquivalentTo(expected);
+        }
+
+        [TestCase(100, 25, false)]
+        [TestCase(100, 25, true)]
+        public void GetNextRectangleSize_WorksCorrectly(int width, int height, bool isSortedOrder)
+        {
+            var index = 0;
+            string[]? keys = null;
+            if (isSortedOrder)
+            {
+                keys = normalizedValues
+                    .OrderByDescending(x => x.Value).Select(x => x.Key).ToArray();
+            }
+            else
+            {
+                keys = normalizedValues.Keys.ToArray();
+            }
+
+            var worker = new NormalizedFrequencyBasedCloudLayouterWorker(
+                width,
+                height,
+                normalizedValues,
+                isSortedOrder);
+            foreach (var rectangleSize in worker
+                .GetNextRectangleProperties().GetValueOrThrow())
+            {
+                var currentValue = normalizedValues[keys[index]];
+                var expected = new Size((int)(currentValue * width), (int)(currentValue * height));
+                index += 1;
+                rectangleSize.size.Should().BeEquivalentTo(expected);
+            }
+        }
+    }
+}

TagCloud.Tests/CloudLayouterWorkersTests/RandomCloudLayouterWorkerTest.cs

@@ -0,0 +1,45 @@
+using FileSenderRailway;
+using FluentAssertions;
+using System.Drawing;
+using TagCloud.CloudLayouterWorkers;
+
+namespace TagCloud.Tests.CloudLayouterWorkersTests
+{
+    [TestFixture]
+    internal class CircularCloudLayouterWorkerTests
+    {
+        [TestCase(0, 100)]
+        [TestCase(-1, 100)]
+        [TestCase(100, 0)]
+        [TestCase(100, -1)]
+        public void GetNextRectangleSize_ThrowsException_OnAnyNegativeOrZeroSize(
+            int width,
+            int height)
+        {
+            var expected = Result
+                .Fail<IEnumerable<(string word, Size size)>>
+                    ($"Переданное числовое значение должно быть больше 0: \"{(width <= 0 ? width : height)}\"");
+
+            var worker = new RandomCloudLayouterWorker(width, width, height, height);
+            var actual = worker.GetNextRectangleProperties();
+            actual.Should().BeEquivalentTo(expected);
+        }
+
+        [TestCase(50, 25, 25, 50)]
+        [TestCase(25, 50, 50, 25)]
+        public void GetNextRectangleSize_ThrowsException_OnNonConsecutiveSizeValues(
+            int minWidth,
+            int maxWidth,
+            int minHeight,
+            int maxHeight)
+        {
+            var expected = Result
+                .Fail<IEnumerable<(string word, Size size)>>
+                    ("Минимальное значение не может быть больше максимального");
+
+            var worker = new RandomCloudLayouterWorker(minWidth, maxWidth, minHeight, maxHeight);
+            var actual = worker.GetNextRectangleProperties();
+            actual.Should().BeEquivalentTo(expected);
+        }
+    }
+}