public void For360DegreesTest()
{
const double expected = Angle.RadiansFor360Degrees;
NUnitHelper.AssertRadians(expected,
Angle.For360Degrees.Radians);
}
public void For45DegreesTest()
{
const double expected = Math.PI / 4.0;
NUnitHelper.AssertRadians(expected,
Angle.For45Degrees.Radians);
}
public void DegreesTest()
{
Angle actual = Angle.For45Degrees;
NUnitHelper.AssertRadians(45.0,
actual.Degrees);
}
public void For270DegreesTest()
{
const double expected = 2.0 * Math.PI * 0.75;
NUnitHelper.AssertRadians(expected,
Angle.For270Degrees.Radians);
}
public void ConvertRadiansToDegreesForZeroTest()
{
double actual = Angle.ConvertRadiansToDegrees(Angle.RadiansForZeroDegrees);
NUnitHelper.AssertDegrees(0.0,
actual);
}
public void ConvertRadiansToDegreesCallsNormalizeRadiansTest()
{
double actual = Angle.ConvertRadiansToDegrees(Angle.RadiansFor45Degrees + Angle.RadiansFor360Degrees);
NUnitHelper.AssertDegrees(45.0,
actual);
}
public void RadiansFor360DegreesTest()
{
const double expected = 2.0 * Math.PI;
NUnitHelper.AssertRadians(expected,
BaseAngle.RadiansFor360Degrees);
}
public void NormalizeRadiansForNegative45Test()
{
double actual = Angle.NormalizeRadians(-Angle.RadiansFor45Degrees);
NUnitHelper.AssertRadians(Angle.RadiansFor315Degrees,
actual);
}
public void NormalizeRadiansForZeroTest()
{
double actual = Angle.NormalizeRadians(Angle.RadiansForZeroDegrees);
NUnitHelper.AssertRadians(Angle.RadiansForZeroDegrees,
actual);
}
public void CreateTwoTangentsTest()
{
var line1 = new Line(m_OuterCircleZeroTangentPointOne,
m_OuterCircleOneTangentPointOne);
var line2 = new Line(m_OuterCircleZeroTangentPointTwo,
m_OuterCircleOneTangentPointTwo);
m_LinesCalculator.CreateTwoTangents();
var expectedOuter = new List <ILine>
{
line1,
line2
};
NUnitHelper.AssertSequenceEqual(expectedOuter,
m_LinesCalculator.OuterTangents,
"OuterTangents");
NUnitHelper.AssertSequenceEqual(expectedOuter,
m_LinesCalculator.Tangents,
"Tangents");
Assert.AreEqual(0,
m_LinesCalculator.InnerTangents.Count(),
"InnerTangents");
}
public void RadiansForZeroDegreesTest()
{
const double expected = 0.0;
NUnitHelper.AssertRadians(expected,
Angle.RadiansForZeroDegrees);
}
public void ConvertDegreesToRadiansForZeroTest()
{
double actual = BaseAngle.ConvertDegreesToRadians(0.0);
NUnitHelper.AssertDegrees(BaseAngle.RadiansForZeroDegrees,
actual);
}
public void NormalizeRadiansForNegative405Test()
{
double actual = Angle.NormalizeRadians(BaseAngle.RadiansFor45Degrees + BaseAngle.RadiansFor360Degrees);
NUnitHelper.AssertRadians(BaseAngle.RadiansFor45Degrees,
actual);
}
public void Constructor_SetsLengthClockwise_WhenCalled()
{
NUnitHelper.AssertIsEquivalent(471.23889803846896,
m_Sut.LengthClockwise,
Constants.EpsilonDistance,
"LengthClockwise");
}
public void Constructor_SetsLengthCounterClockwise_WhenCalled()
{
NUnitHelper.AssertIsEquivalent(157.07963267948966,
m_Sut.LengthCounterClockwise,
Constants.EpsilonDistance,
"LengthCounterClockwise");
}
public void RadiansTest()
{
Angle actual = Angle.For45Degrees;
NUnitHelper.AssertRadians(Angle.RadiansFor45Degrees,
actual.Radians);
}
public void ConvertRadiansToDegreesFor45DegreesTest()
{
double actual = BaseAngle.ConvertRadiansToDegrees(BaseAngle.RadiansFor45Degrees);
NUnitHelper.AssertDegrees(45.0,
actual);
}
public void RadiansFor315DegreesTest()
{
const double expected = 2.0 * Math.PI * 0.75 + Math.PI / 4.0;
NUnitHelper.AssertRadians(expected,
Angle.RadiansFor315Degrees);
}
public void RadiansFor90DegreesTest()
{
const double expected = Math.PI / 2.0;
NUnitHelper.AssertRadians(expected,
Angle.RadiansFor90Degrees);
}
public void RadiansFor225DegreesTest()
{
const double expected = Math.PI + Math.PI / 4.0;
NUnitHelper.AssertRadians(expected,
BaseAngle.RadiansFor225Degrees);
}
public void ConvertDegreesToRadiansFor45DegreesTest()
{
double actual = Angle.ConvertDegreesToRadians(45.0);
NUnitHelper.AssertDegrees(Angle.RadiansFor45Degrees,
actual);
}
public void ConvertDegreesToRadiansForZeroPlusHalfEpsilonTest()
{
const double degrees = 0.0 + SelkieConstants.EpsilonDegrees / 2.0;
double actual = BaseAngle.ConvertDegreesToRadians(degrees);
NUnitHelper.AssertDegrees(0.0,
actual);
}
public void ConvertDegreesToRadiansForZeroPlusEpsilonTest()
{
const double expected = 0.0 + SelkieConstants.EpsilonDegrees;
double actual = BaseAngle.ConvertDegreesToRadians(expected);
NUnitHelper.AssertDegrees(expected,
actual);
}
public void Constructor_SetsLength_WhenCalled()
{
// Arrange
// Act
// Assert
NUnitHelper.AssertIsEquivalent(12.34,
m_Sut.Length);
}
public void NormalizeRadiansForZeroMinusHalfEpsilonTest()
{
const double expected = Angle.RadiansFor360Degrees - Angle.EpsilonRadians / 2.0;
double actual = Angle.NormalizeRadians(0.0 - Angle.EpsilonRadians / 2.0);
NUnitHelper.AssertRadians(expected,
actual);
}
public void ConvertDegreesToRadiansForZeroMinusEpsilonTest()
{
const double expected = Angle.RadiansFor360Degrees;
double actual = Angle.ConvertDegreesToRadians(0.0 - Angle.EpsilonDegrees);
NUnitHelper.AssertDegrees(expected,
actual);
}
public void NormalizeRadiansForZeroPlusHalfEpsilonTest()
{
const double degrees = 0.0 + Angle.EpsilonRadians / 2.0;
double actual = Angle.NormalizeRadians(degrees);
NUnitHelper.AssertRadians(0.0,
actual);
}
public void NormalizeRadiansForZeroPlusEpsilonTest()
{
const double expected = 0.0 + Angle.EpsilonRadians;
double actual = Angle.NormalizeRadians(expected);
NUnitHelper.AssertRadians(expected,
actual);
}
public void ConvertDegreesToRadiansForZeroMinusHalfEpsilonTest()
{
const double degrees = 0.0 - Angle.EpsilonDegrees / 2.0;
double actual = Angle.ConvertDegreesToRadians(degrees);
NUnitHelper.AssertDegrees(0.0,
actual);
}
public void NormalizeRadiansForZeroMinusEpsilonTest()
{
const double expected = Angle.RadiansFor360Degrees - Angle.EpsilonDegrees;
double actual = Angle.NormalizeRadians(Angle.RadiansForZeroDegrees - Angle.EpsilonDegrees);
NUnitHelper.AssertDegrees(expected,
actual);
}
