Сазонов Александр

cs/TagsCloudTests/CloudLayouterShould.cs

@@ -0,0 +1,114 @@
+using FluentAssertions;
+using System.Drawing;
+using FluentAssertions.Execution;
+using TagsCloudVisualization;
+using TagsCloudVisualization.Extensions;
+using TagsCloudVisualization.Interfaces;
+
+[assembly: Parallelizable(ParallelScope.Children)]
+
+namespace TagsCloudTests;
+
+[TestFixture]
+public class CloudLayouterShould
+{
+    private readonly Point _defaultCenter = new(0, 0);
+    private readonly Random _random = new();
+    private readonly ISizesGenerator _defaultSizesGenerator = new RandomSizesGenerator();
+
+    [Test]
+    [Repeat(5)]
+    public void PutNextRectangle_ReturnRectangleWithExpectedLocation_AfterFirstExecution()
+    {
+        var expectedCenter = new Point(_random.Next(-10, 10), _random.Next(-10, 10));
+        var rectangleSize = _defaultSizesGenerator
+            .GenerateSize()
+            .Take(1)
+            .First();
+        var cloudLayouter = new CircularCloudLayouter(expectedCenter);
+
+        var actualRectangle = cloudLayouter.PutNextRectangle(rectangleSize);
+
+        actualRectangle
+            .GetCentralPoint()
+            .Should()
+            .BeEquivalentTo(expectedCenter);
+    }
+
+    [TestCase(-1, 1)]
+    [TestCase(1, -1)]
+    [TestCase(0, 0)]
+    public void PutNextRectangle_ThrowArgumentOutOfRangeException_AfterExecutionWith(int width, int height)
+    {
+        var rectangleSize = new Size(width, height);
+        var circularCloudLayouter = new CircularCloudLayouter(_defaultCenter);
+
+        var executePutNewRectangle = () =>
+            circularCloudLayouter
+                .PutNextRectangle(rectangleSize);
+
+        executePutNewRectangle
+            .Should()
+            .Throw<ArgumentOutOfRangeException>();
+    }
+
+    [Test]
+    [Repeat(5)]
+    public void PutNextRectangle_ReturnRectangleThatNotIntersectsWithOther_AfterManyExecution()
+    {
+        var rectangleSizes = _defaultSizesGenerator
+            .GenerateSize()
+            .Take(_random.Next(10, 200));
+        var cloudLayouter = new CircularCloudLayouter(_defaultCenter);
+
+        var rectangles = rectangleSizes
+            .Select(size => cloudLayouter.PutNextRectangle(size))
+            .ToArray();
+
+        for (var i = 0; i < rectangles.Length; i++)
+        for (var j = i + 1; j < rectangles.Length; j++)
+            rectangles[i]
+                .IntersectsWith(rectangles[j])
+                .Should()
+                .BeFalse();
+    }
+
+    [Test]
+    [Repeat(20)]
+    public void PutNextRectangle_ReturnRectanglesInCircle_AfterManyExecution()
+    {
+        var rectangleSizes = _defaultSizesGenerator
+            .GenerateSize()
+            .Take(_random.Next(100, 200));
+        var circularCloudLayouter = new CircularCloudLayouter(_defaultCenter);
+
+        var rectanglesList = rectangleSizes
+            .Select(rectangleSize => circularCloudLayouter
+                .PutNextRectangle(rectangleSize))
+            .ToList();
+
+        var circleRadius = rectanglesList
+            .Select(rectangle => rectangle.GetCentralPoint())
+            .Max(pointOnCircle => pointOnCircle.GetDistanceTo(_defaultCenter));
+        var fromRectangleToCenterDistances =
+            rectanglesList
+                .Select(rectangle => rectangle
+                    .GetCentralPoint()
+                    .GetDistanceTo(_defaultCenter));
+
+        var sumRectanglesSquare = rectanglesList.Sum(rectangle => rectangle.Width * rectangle.Height);
+        var circleSquare = circleRadius * circleRadius * Math.PI;
+        var precision = circleSquare * 0.375;
+
+        using (new AssertionScope())
+        {
+            circleSquare
+                .Should()
+                .BeApproximately(sumRectanglesSquare, precision);
+            foreach (var distanceToCenter in fromRectangleToCenterDistances)
+                distanceToCenter
+                    .Should()
+                    .BeLessOrEqualTo(circleRadius);
+        }
+    }
+}

cs/TagsCloudTests/PointExtensionShould.cs

@@ -0,0 +1,40 @@
+using System.Drawing;
+using FluentAssertions;
+using TagsCloudVisualization.Extensions;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+public class PointExtensionShould
+{
+    [TestCase(0, 0, 1, 2)]
+    [TestCase(0, 0, 1, 0)]
+    [TestCase(3, 5, 0, 5)]
+    public void PointShiftTo_ReturnedMovedPoint_WhenSet(int pointX, int pointY, int shiftX, int shiftY)
+    {
+        var point = new Point(pointX, pointY);
+        var movementDirection = new Size(shiftX, shiftY);
+
+        var movedPoint = Point.Add(point, movementDirection);
+
+        MoveTo_CheckShift(point, movementDirection, movedPoint);
+    }
+
+    [Test]
+    public void MoveTo_ReturnedNotMovedPoint_WhenSetZeroDirection()
+    {
+        var point = new Point(5, 6);
+
+        MoveTo_CheckShift(point, new Size(0, 0), point);
+    }
+
+    private static void MoveTo_CheckShift(Point point, Size movementDirection, Point expectedPoint)
+    {
+        var movedPoint = point.MoveTo(movementDirection);
+
+        movedPoint
+            .Should()
+            .BeEquivalentTo(expectedPoint);
+    }
+}
+

cs/TagsCloudTests/PointGeneratorShould.cs

@@ -0,0 +1,70 @@
+using System.Drawing;
+using FluentAssertions;
+using TagsCloudVisualization;
+using TagsCloudVisualization.Extensions;
+using TagsCloudVisualization.Interfaces;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+public class PointGeneratorShould
+{
+    private readonly Point _defaultCenter = new(1, 1);
+    private readonly Random _random = new();
+
+    [Test]
+    public void GetNewPoint_ReturnCenter_AfterFirstExecution()
+    {
+        var pointGenerator = new SpiralPointGenerator(_defaultCenter);
+        using var newPointIterator = pointGenerator
+            .GeneratePoint()
+            .GetEnumerator();
+        newPointIterator.MoveNext();
+        var point = newPointIterator.Current;
+
+        point
+            .Should()
+            .BeEquivalentTo(_defaultCenter);
+    }
+
+    [TestCase(0)]
+    [TestCase(-1)]
+    public void ThrowArgumentOutOfRangeException_AfterExecutionWith(double radiusStep)
+    {
+        var pointGeneratorCreate = () => new SpiralPointGenerator(_defaultCenter, radiusStep);
+
+        pointGeneratorCreate
+            .Should()
+            .Throw<ArgumentOutOfRangeException>();
+    }
+
+    [Test]
+    [Repeat(20)]
+    public void GetNewPoint_ReturnPointWithGreaterRadius_AfterManyExecutions()
+    {
+        var newPointGenerator = new SpiralPointGenerator(_defaultCenter);
+        var countOfPoints = _random.Next(10, 200);
+        var points = newPointGenerator
+            .GeneratePoint()
+            .Take(countOfPoints)
+            .ToArray();
+
+        var distances = points
+            .Select(p => p.GetDistanceTo(_defaultCenter))
+            .ToArray();
+        var angles = points
+            .Select(p => Math.Atan2(p.Y - _defaultCenter.Y, p.X - _defaultCenter.X))
+            .ToArray();
+
+        distances
+            .Zip(distances.Skip(1), (a, b) => a <= b)
+            .All(x => x)
+            .Should()
+            .BeTrue();
+        angles
+            .Zip(angles.Skip(1), (a, b) => a <= b || Math.Abs(a - b) < 0.1)
+            .All(x => x)
+            .Should()
+            .BeTrue();
+    }
+}

cs/TagsCloudTests/RectangleExtensionShould.cs

@@ -0,0 +1,26 @@
+using System.Drawing;
+using FluentAssertions;
+using TagsCloudVisualization.Extensions;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+public class RectangleExtensionShould
+{
+    [Test]
+    [Repeat(5)]
+    public void GetCentralPoint_ReturnExpectedCenter_AfterExecutionWithRandomRectangle()
+    {
+        var rectangleLocation = new Point(0, 0);
+        var random = new Random();
+        var rectangleSize = new Size(random.Next(1, 100), random.Next(1, 100));
+        var rectangle = new Rectangle(rectangleLocation, rectangleSize);
+        var expectedCentralPoint = new Point(rectangleLocation.X + rectangleSize.Width / 2,
+            rectangleLocation.Y - rectangleSize.Height / 2);
+
+        rectangle
+            .GetCentralPoint()
+            .Should()
+            .Be(expectedCentralPoint);
+    }
+}

cs/TagsCloudTests/TagCloudCreatorShould.cs

@@ -0,0 +1,34 @@
+using System.Drawing;
+using FluentAssertions;
+using TagsCloudVisualization;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+public class TagCloudCreatorShould
+{
+    private readonly Point _defaultCenter = new(0, 0);
+    private readonly Random _random = new();
+
+    [Test]
+    [Repeat(5)]
+    public void Create_ReturnTagCloudEquivalentToConstructor_AfterExecution()
+    {
+        var sizesGenerator = new RandomSizesGenerator();
+        var rectangleSizes = sizesGenerator
+            .GenerateSize()
+            .Take(_random.Next(10, 200))
+            .ToArray();
+        var currCloudLayouter = new CircularCloudLayouter(_defaultCenter);
+        var expectedCloudLayouter = new CircularCloudLayouter(_defaultCenter);
+        var defaultTagCloud = new TagCloud(currCloudLayouter);
+        foreach (var rectangleSize in rectangleSizes)
+            defaultTagCloud.AddNextRectangleWith(rectangleSize);
+
+        var expectedTagCloud = TagCloudCreator.Create(rectangleSizes, expectedCloudLayouter);
+
+        defaultTagCloud
+            .Should()
+            .BeEquivalentTo(expectedTagCloud);
+    }
+}