2023-04-05 21:26:31 +00:00
|
|
|
|
using System.Drawing;
|
|
|
|
|
using NUnit.Framework;
|
2022-06-01 12:46:22 +00:00
|
|
|
|
using X10D.Drawing;
|
|
|
|
|
|
|
|
|
|
namespace X10D.Tests.Drawing;
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[TestFixture]
|
2023-08-22 16:32:47 +00:00
|
|
|
|
internal class CircleFTests
|
2022-06-01 12:46:22 +00:00
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void Area_ShouldBePiRadiusRadius_GivenUnitCircle()
|
|
|
|
|
{
|
|
|
|
|
var unitCircle = CircleF.Unit;
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(unitCircle.Area, Is.EqualTo(MathF.PI));
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void Circumference_ShouldBe2PiRadius_GivenUnitCircle()
|
|
|
|
|
{
|
|
|
|
|
var unitCircle = CircleF.Unit;
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(unitCircle.Circumference, Is.EqualTo(2 * MathF.PI).Within(1e-6f));
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void CompareTo_ShouldBeNegativeOne_GivenUnitCircleAndEmpty()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(CircleF.Empty.CompareTo(CircleF.Unit), Is.EqualTo(-1));
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void CompareTo_ShouldBeOne_GivenUnitCircleAndEmpty()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(CircleF.Unit.CompareTo(CircleF.Empty), Is.EqualTo(1));
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 14:36:45 +00:00
|
|
|
|
public void CompareTo_ShouldBeNegativeOne_GivenEmptyCircleAndUnitCircleAsObject()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(CircleF.Empty.CompareTo((object)CircleF.Unit), Is.EqualTo(-1));
|
2022-06-01 14:36:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 14:36:45 +00:00
|
|
|
|
public void CompareTo_ShouldBeOne_GivenNull()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(CircleF.Unit.CompareTo(null), Is.EqualTo(1));
|
2022-06-01 14:36:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void CompareTo_ShouldBeZero_GivenUnitCircle()
|
|
|
|
|
{
|
|
|
|
|
var unitCircle = CircleF.Unit;
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(unitCircle.CompareTo(unitCircle), Is.Zero);
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 14:36:45 +00:00
|
|
|
|
public void CompareTo_ShouldThrowArgumentException_GivenInvalidType()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.Throws<ArgumentException>(() => _ = CircleF.Unit.CompareTo(new object()));
|
2022-06-01 14:36:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void Diameter_ShouldBe2_GivenUnitCircle()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(CircleF.Unit.Diameter, Is.EqualTo(2.0f).Within(1e-6f));
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void Equals_ShouldBeTrue_GivenTwoUnitCircles()
|
|
|
|
|
{
|
|
|
|
|
var unitCircle1 = CircleF.Unit;
|
|
|
|
|
var unitCircle2 = CircleF.Unit;
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.Multiple(() =>
|
|
|
|
|
{
|
|
|
|
|
Assert.That(unitCircle2, Is.EqualTo(unitCircle1));
|
|
|
|
|
Assert.That(unitCircle1, Is.EqualTo(unitCircle2));
|
|
|
|
|
Assert.That(unitCircle1 == unitCircle2);
|
|
|
|
|
Assert.That(unitCircle2 == unitCircle1);
|
|
|
|
|
});
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2023-03-28 15:09:35 +00:00
|
|
|
|
public void Equals_ShouldBeTrue_GivenUnitCirclesAsObjects()
|
|
|
|
|
{
|
|
|
|
|
CircleF unitCircle1 = CircleF.Unit;
|
|
|
|
|
object unitCircle2 = CircleF.Unit;
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.Multiple(() =>
|
|
|
|
|
{
|
|
|
|
|
Assert.That(unitCircle2, Is.EqualTo(unitCircle1));
|
|
|
|
|
Assert.That(unitCircle1, Is.EqualTo(unitCircle2));
|
|
|
|
|
});
|
2023-03-28 15:09:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void Equals_ShouldBeFalse_GivenDifferentCircles()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.Multiple(() =>
|
|
|
|
|
{
|
|
|
|
|
Assert.That(CircleF.Empty, Is.Not.EqualTo(CircleF.Unit));
|
|
|
|
|
Assert.That(CircleF.Unit, Is.Not.EqualTo(CircleF.Empty));
|
2023-04-05 22:18:14 +00:00
|
|
|
|
|
|
|
|
|
Assert.That(CircleF.Empty != CircleF.Unit);
|
|
|
|
|
Assert.That(CircleF.Unit != CircleF.Empty);
|
2023-04-05 21:26:31 +00:00
|
|
|
|
});
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2023-03-28 15:09:35 +00:00
|
|
|
|
public void Equals_ShouldBeFalse_GivenDifferentObjects()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(CircleF.Empty, Is.Not.EqualTo(null));
|
2023-04-05 22:18:14 +00:00
|
|
|
|
Assert.That(CircleF.Empty.Equals(null), Is.False);
|
2023-03-28 15:09:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void GetHashCode_ShouldBeCorrect_GivenEmptyCircle()
|
|
|
|
|
{
|
|
|
|
|
// this test is pretty pointless, it exists only for code coverage purposes
|
|
|
|
|
int hashCode = CircleF.Empty.GetHashCode();
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(CircleF.Empty.GetHashCode(), Is.EqualTo(hashCode));
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void GetHashCode_ShouldBeCorrect_GivenUnitCircle()
|
|
|
|
|
{
|
|
|
|
|
// this test is pretty pointless, it exists only for code coverage purposes
|
|
|
|
|
int hashCode = CircleF.Unit.GetHashCode();
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(CircleF.Unit.GetHashCode(), Is.EqualTo(hashCode));
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 14:36:45 +00:00
|
|
|
|
public void op_Explicit_ShouldReturnEquivalentCircle_GivenCircle()
|
|
|
|
|
{
|
|
|
|
|
CircleF unitCircle = CircleF.Unit;
|
|
|
|
|
Circle converted = (Circle)unitCircle;
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.Multiple(() =>
|
|
|
|
|
{
|
|
|
|
|
Assert.That(converted, Is.EqualTo((Circle)unitCircle));
|
2023-04-05 22:18:14 +00:00
|
|
|
|
Assert.That(converted == (Circle)unitCircle);
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(converted.Radius, Is.EqualTo(unitCircle.Radius));
|
|
|
|
|
Assert.That((PointF)converted.Center, Is.EqualTo(unitCircle.Center));
|
|
|
|
|
});
|
2022-06-01 14:36:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 14:36:45 +00:00
|
|
|
|
public void op_GreaterThan_True_GivenUnitAndEmptyCircle()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(CircleF.Unit, Is.GreaterThan(CircleF.Empty));
|
|
|
|
|
Assert.That(CircleF.Unit, Is.GreaterThanOrEqualTo(CircleF.Empty));
|
2023-04-05 22:18:14 +00:00
|
|
|
|
|
|
|
|
|
Assert.That(CircleF.Unit > CircleF.Empty);
|
|
|
|
|
Assert.That(CircleF.Unit >= CircleF.Empty);
|
2022-06-01 14:36:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 14:36:45 +00:00
|
|
|
|
public void op_Implicit_ShouldReturnEquivalentCircle_GivenCircle()
|
|
|
|
|
{
|
|
|
|
|
Circle unitCircle = Circle.Unit;
|
|
|
|
|
CircleF converted = unitCircle;
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.Multiple(() =>
|
|
|
|
|
{
|
|
|
|
|
Assert.That(converted, Is.EqualTo((CircleF)unitCircle));
|
2023-04-05 22:18:14 +00:00
|
|
|
|
Assert.That(converted == unitCircle);
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(converted.Radius, Is.EqualTo(unitCircle.Radius));
|
|
|
|
|
Assert.That(converted.Center, Is.EqualTo((PointF)unitCircle.Center));
|
|
|
|
|
});
|
2022-06-01 14:36:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 14:36:45 +00:00
|
|
|
|
public void op_LessThan_True_GivenEmptyAndUnitCircle()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.Multiple(() =>
|
|
|
|
|
{
|
|
|
|
|
Assert.That(CircleF.Empty, Is.LessThan(CircleF.Unit));
|
|
|
|
|
Assert.That(CircleF.Empty, Is.LessThanOrEqualTo(CircleF.Unit));
|
2023-04-05 22:18:14 +00:00
|
|
|
|
|
|
|
|
|
Assert.That(CircleF.Empty < CircleF.Unit);
|
|
|
|
|
Assert.That(CircleF.Empty <= CircleF.Unit);
|
2023-04-05 21:26:31 +00:00
|
|
|
|
});
|
2022-06-01 14:36:45 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void Radius_ShouldBe0_GivenEmptyCircle()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(CircleF.Empty.Radius, Is.EqualTo(0.0f).Within(1e-6f));
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-05 21:26:31 +00:00
|
|
|
|
[Test]
|
2022-06-01 12:46:22 +00:00
|
|
|
|
public void Radius_ShouldBe1_GivenUnitCircle()
|
|
|
|
|
{
|
2023-04-05 21:26:31 +00:00
|
|
|
|
Assert.That(CircleF.Unit.Radius, Is.EqualTo(1.0f).Within(1e-6f));
|
2022-06-01 12:46:22 +00:00
|
|
|
|
}
|
|
|
|
|
}
|