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

cs/TagsCloudTests/CloudLayouterShould.cs

@@ -0,0 +1,121 @@
+using FluentAssertions;
+using NUnit.Framework.Interfaces;
+using System.Drawing;
+using TagsCloudVisualization;
+using TagsCloudVisualization.Extensions;
+using TagsCloudVisualization.Interfaces;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+[Parallelizable(scope: ParallelScope.All)]
+public class CloudLayouterShould
+{
+    private readonly Point _defaultCenter = new(0, 0);
+    private readonly Random _random = new();
+
+    public virtual ICloudLayouter GetCloudLayouter(Point center) =>
+        new CircularCloudLayouter(center);
+
+    [Test]
+    [Repeat(5)]
+    public void PutNextRectangle_ReturnRectangleWithExpectedLocation_AfterFirstExecution()
+    {
+        var expectedCenter = new Point(_random.Next(-10, 10), _random.Next(-10, 10));
+        var rectangleWidth = _random.Next(5, 100);
+        var rectangleSize = new Size(rectangleWidth, rectangleWidth / 2);
+        var cloudLayouter = GetCloudLayouter(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 seenRectangles = new HashSet<Rectangle>();
+        var rectangleSizes = GetSizes(_random.Next(10, 100), _random.Next(100, 200));
+        var cloudLayouter = GetCloudLayouter(_defaultCenter);
+
+        var rectangleList = rectangleSizes
+            .Select(size => cloudLayouter.PutNextRectangle(size));
+
+        foreach (var rectangle in rectangleList)
+        {
+            seenRectangles.Add(rectangle);
+            rectangleList
+                .Where(rect => !seenRectangles.Contains(rect))
+                .All(rect => rect.IntersectsWith(rectangle))
+                .Should().BeFalse();
+        }
+    }
+
+    [Test]
+    [Repeat(5)]
+    public void PutNextRectangle_ReturnLastRectanglesWithCloseRadius_AfterManyExecution()
+    {
+        var largestSide = _random.Next(100, 200);
+        var rectangleSizes = GetSizes(_random.Next(5, 10), largestSide);
+        var radii = new List<double>();
+        var circularCloudLayouter = new CircularCloudLayouter(_defaultCenter);
+        var lastIndex = (int)(largestSide * 0.9);
+        var expectedDifference = (int)(largestSide * 0.05);
+
+        foreach (var rectangleSize in rectangleSizes)
+        {
+            var currSquare = circularCloudLayouter.PutNextRectangle(rectangleSize);
+            var squareCenter = currSquare.GetCentralPoint();
+            radii.Add(Math.Round(squareCenter.GetDistanceTo(_defaultCenter)));
+        }
+
+        for (var i = lastIndex; i < largestSide; i++)
+        {
+            (radii[i] - radii[i - 1]).Should().BeLessOrEqualTo(expectedDifference);
+        }
+    }
+
+    [Test]
+    [Repeat(5)]
+    public void PutNextRectangle_ReturnRectangleWithMaximumDensity_AfterManyExecution()
+    {
+        var rectangleWidth = _random.Next(5, 1000);
+        var rectangleSize = new Size(rectangleWidth, rectangleWidth / 2);
+        var diagonal = Math.Sqrt(Math.Pow(rectangleSize.Height, 2) + Math.Pow(rectangleSize.Width, 2));
+        var circularCloudLayouter = new CircularCloudLayouter(_defaultCenter);
+        var radii = new List<double>();
+        var rectangleCount = _random.Next(10, 200);
+
+        for (var i = 0; i < rectangleCount; i++)
+        {
+            var currSquare = circularCloudLayouter.PutNextRectangle(rectangleSize);
+            var squareCenter = currSquare.GetCentralPoint();
+            radii.Add(Math.Round(squareCenter.GetDistanceTo(_defaultCenter)));
+        }
+
+        var radiusDifferences = radii
+            .Skip(1)
+            .Zip(radii, (current, previous) => current - previous);
+        foreach (var difference in radiusDifferences)
+            difference.Should().BeLessOrEqualTo(diagonal);
+    }
+
+    private static IEnumerable<Size> GetSizes(int lowest, int largest) =>
+        Enumerable.Range(lowest, largest)
+            .Select(number => new Size(number, number / 2))
+            .Reverse();
+}

cs/TagsCloudTests/PointExtensionShould.cs

@@ -0,0 +1,39 @@
+using System.Drawing;
+using FluentAssertions;
+using TagsCloudVisualization.Extensions;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+[Parallelizable(scope: ParallelScope.All)]
+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);
+    }
+
+    public 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,60 @@
+using System.Drawing;
+using FluentAssertions;
+using TagsCloudVisualization;
+using TagsCloudVisualization.Extensions;
+using TagsCloudVisualization.Interfaces;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+[Parallelizable(scope: ParallelScope.All)]
+public class PointGeneratorShould
+{
+    private readonly Point _defaultCenter = new(1, 1);
+    private readonly Random _random = new();
+
+    public virtual IPointGenerator GetPointGenerator(Point center) =>
+        new SpiralPointGenerator(center);
+
+    [Test]
+    public void GetNewPoint_ReturnCenter_AfterFirstExecution()
+    {
+        var pointGenerator = GetPointGenerator(_defaultCenter);
+        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(5)]
+    public void GetNewPoint_ReturnPointWithGreaterRadius_AfterManyExecutions()
+    {
+        const double radiusStep = 0.02;
+        const double radiusCheckPeriod = 1 / radiusStep;
+        var newPointGenerator = new SpiralPointGenerator(_defaultCenter, radiusStep);
+        var pointIterator = newPointGenerator.GeneratePoint().GetEnumerator();
+        var prevSpiralRadius = 0;
+        var pointsCount = radiusCheckPeriod * _random.Next(10, 100);
+
+        for (var i = 1; i <= pointsCount; i++)
+        {
+            pointIterator.MoveNext();
+            var currPoint = pointIterator.Current;
+            if (i % radiusCheckPeriod != 0) continue;
+            var currSpiralRadius = (int)currPoint.GetDistanceTo(_defaultCenter);
+            currSpiralRadius.Should().BeGreaterThanOrEqualTo(prevSpiralRadius);
+            prevSpiralRadius = currSpiralRadius;
+        }
+    }
+}

cs/TagsCloudTests/RectangleExtensionShould.cs

@@ -0,0 +1,25 @@
+using System.Drawing;
+using FluentAssertions;
+using TagsCloudVisualization.Extensions;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+[Parallelizable(scope: ParallelScope.All)]
+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,30 @@
+using System.Drawing;
+using FluentAssertions;
+using TagsCloudVisualization;
+
+namespace TagsCloudTests;
+
+[TestFixture]
+[Parallelizable(ParallelScope.All)]
+public class TagCloudCreatorShould
+{
+    private readonly Point _defaultCenter = new(0, 0);
+    private readonly Random _random = new();
+
+    [Test]
+    [Repeat(5)]
+    public void Create_ReturnTagCloudEquivalentToConstructor_AfterExecution()
+    {
+        var rectangleSizes = Enumerable.Range(_random.Next(2, 10), _random.Next(20, 100)).
+            Select(width => new Size(width, width / 2)).Reverse();
+        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);
+    }
+}