public void ReturnsACorrectChild_WhenATriangleWithCorrectPathIsPresent()
{
var triangle = new Triangle(TriangleNodeData.triangleNodesCorrect);
var child = TriangleHelper.ChooseSuitableChild(triangle, 0, 0);
Assert.That(child.NodeValue, Is.EqualTo(8));
}
public void CalculateTheArea_returnNewNumber_Test()
{
const double expected = 0.968246;
var actual = TriangleHelper.CalculateArea(_triangle);
Assert.AreEqual(expected, Math.Round(actual, 6));
}
public void ReturnsAGreaterValueChild_WhenATriangleWithTwoCorrectChildrenIsPresent()
{
var triangle = new Triangle(TriangleNodeData.triangleNodesTwoConcurrentChildren);
var child = TriangleHelper.ChooseSuitableChild(triangle, 0, 0);
Assert.That(child.NodeValue, Is.EqualTo(12));
}
public void CalculateThePerimeter_returnNewNumber_Test()
{
const int expected = 5;
var actual = TriangleHelper.CalculatePerimeter(_triangle);
Assert.AreEqual(expected, actual);
}
public void AnySideLongerthanSumOfOtherSidesTriangleReturnsFalse(int a, int b, int c)
{
//arange
var triangleHelper = new TriangleHelper();
var result = triangleHelper.IsTriangle(a, b, c);
Assert.False(result, "Triangle with any side longer than the sum of the other two sides should be false");
}
public void ReturnsNull_WhenATriangleWithoutACorrectPathIsPresent()
{
var triangle = new Triangle(TriangleNodeData.triangleNodesNoPath);
var child = TriangleHelper.ChooseSuitableChild(triangle, 0, 0);
Assert.That(child, Is.Null);
}
internal List <SlicePoint2D> GetModelPointsWithParentLine(List <SliceLine2D> polylines, int pixelY, bool bleeding)
{
var intersecting = GetIntersecting2dYLines(pixelY, polylines);
var points = TriangleHelper.GetIntersectingPoints(pixelY, intersecting);
points.Sort();
return(points);
}
public void GetTriangle_GivenCoordinates_ReturnsTriangles(ICollection <Coordinate> coordinates, int row, int column)
{
// Act
var result = TriangleHelper.GetTriangle(coordinates);
// Assert
Assert.Equal(row, result.Row);
Assert.Equal(column, result.Column);
}
public void CalculateAngleFromTriangleSides_CalculatesSuccessfully()
{
double aLength = 5;
double bLength = 9;
double cLength = 8;
var calcResult = TriangleHelper.CalculateAngleFromTriangleSides(aLength, bLength, cLength, 1);
Assert.AreEqual(62.2, calcResult);
}
/// <summary>
/// Cache variable called _validNumbers holds all paths
/// found after iteration. This method sumarize all items
/// from path and convert a path into string output legible
/// </summary>
private (int max, string path) GetPathNumbersFromCache()
{
return(((int max, string path))
_validNumbers
.Select(items => (
max: items.Sum(),
path: TriangleHelper.ConvertPathIntoLegibleOutput(items)))
.OrderByDescending(r => r.max)
.FirstOrDefault());
}
public void NoSidesSameReturnScalene()
{
//arange
var triangleHelper = new TriangleHelper();
//act
var result = triangleHelper.GetTriangleType(5, 4, 3);
//assert
Assert.True(result.Equals(TriangleType.Scalene), "Triangle with no equal sides is scalene");
}
public void TwoSidesSameReturnIsocoles()
{
//arange
var triangleHelper = new TriangleHelper();
//act
var result = triangleHelper.GetTriangleType(5, 5, 3);
//assert
Assert.True(result.Equals(TriangleType.Isocoles), "Triangle with two equal sides is isocoles");
}
public void ThreeSidesSameReturnEquilateral()
{
//arange
var triangleHelper = new TriangleHelper();
//act
var result = triangleHelper.GetTriangleType(5, 5, 5);
//assert
Assert.True(result.Equals(TriangleType.Equilateral), "Triangle with sides is equilateral");
}
public void ValidTriangleReturnsTrue(int a, int b, int c)
{
//arange
var triangleHelper = new TriangleHelper();
//act
var result = triangleHelper.IsTriangle(a, b, c);
//assert
Assert.True(result, "Triangle with valid sides should be true");
}
public void AnyZeroSideReturnsFalse(int a, int b, int c)
{
//arange
var triangleHelper = new TriangleHelper();
//act
var result = triangleHelper.IsTriangle(a, b, c);
//assert
Assert.False(result, "Triangle with a side equal to zero should be false");
}
bool DefineTypeCondition(BulletController.BulletType bulletType)
{
if (controller is NumberController)
{
return(!NumberHelper.HasDamage(bulletType, controller.GetNumber()));
}
else
{
return(!TriangleHelper.HasDamage(bulletType, controller.GetNumber()));
}
}
public Triangle Get(Coordinate topEdge, Coordinate rightEdge, Coordinate leftEdge)
{
var input = new List <Coordinate>
{
topEdge,
rightEdge,
leftEdge
};
return(TriangleHelper.GetTriangle(input));
}
public void IsSumOfTheAnglesATriangleWithNulls()
{
double?angleA = null;
double?angleB = 45;
double?angleC = 90;
Assert.Throws <ArgumentNullException>(() => TriangleHelper.IsSumOfTheAnglesATriangle(angleA, angleB, angleC));
angleA = 20;
Assert.False(TriangleHelper.IsSumOfTheAnglesATriangle(angleA, angleB, angleC), $"A:{angleA}, B:{angleB}, C:{angleC}");
angleA = 45;
Assert.True(TriangleHelper.IsSumOfTheAnglesATriangle(angleA, angleB, angleC), $"A:{angleA}, B:{angleB}, C:{angleC}");
}
public void AreaFail2()
{
var a = 5.08d;
var b = 33.94d;
var c = 8.91d;
var(area, e) = TriangleHelper.Area(a, b, c);
Console.WriteLine($"Error:{e.ToString()}\r\nAnswer:{area.ToString(PrecisionArea)}");
Assert.AreEqual(Errors.WrongSides, e);
Assert.AreEqual((-1).ToString(PrecisionArea), area.ToString(PrecisionArea));
}
private void ShowDetails(Triangle triangle)
{
if (triangle == null)
{
_view.ShowMessageTriangleDoesNotExist();
return;
}
var perimeter = TriangleHelper.CalculatePerimeter(triangle);
var area = TriangleHelper.CalculateArea(triangle);
_view.ShowTriangleDetails(triangle, perimeter, area);
}
public void GetCoordinates_GivenRowAndColumn_ReturnsCoordinates(int row, int column, ICollection <Coordinate> expectedCoordinates)
{
// Act
var result = TriangleHelper.GetCoordinates(row, column);
// Assert
Assert.Equal(expectedCoordinates.Count, result.Count());
for (int i = 0; i < expectedCoordinates.Count; i++)
{
Assert.Equal(expectedCoordinates.ElementAt(i).X, result.ElementAt(i).X);
Assert.Equal(expectedCoordinates.ElementAt(i).Y, result.ElementAt(i).Y);
}
}
public void AreaOk2()
{
var a = 5.08d;
var b = 3.94d;
var c = 8.91d;
var etalon = 3.1025589091d;
var(area, e) = TriangleHelper.Area(a, b, c);
Console.WriteLine($"Error:{e.ToString()}\r\nAnswer:{area.ToString(PrecisionArea)}\r\nEtalon:{etalon.ToString(PrecisionArea)}");
Assert.AreEqual(Errors.None, e);
Assert.AreEqual(etalon.ToString(PrecisionArea), area.ToString(PrecisionArea));
}
public void AreaOk1()
{
var a = 3d;
var b = 4d;
var c = 5d;
var etalon = 6d;
var(area, e) = TriangleHelper.Area(a, b, c);
Console.WriteLine($"Error:{e.ToString()}\r\nAnswer:{area.ToString(PrecisionArea)}\r\nEtalon:{etalon.ToString(PrecisionArea)}");
Assert.AreEqual(Errors.None, e);
Assert.AreEqual(etalon.ToString(PrecisionArea), area.ToString(PrecisionArea));
}
public void Test_Convert_Array_From_Input_String()
{
var input =
@"215
192 124
117 269 442
218 836 347 235";
var array = TriangleHelper.ConvertStringToArrayOfArray(input);
Assert.IsNotNull(array);
Assert.Greater(array.Length, 0);
Assert.AreEqual(4, array.Length);
Console.WriteLine($"Input: \n\r{input}");
}
public IEnumerable <Coordinate> Get(char row, int column)
{
if (!Char.IsLetter(row))
{
throw new ArgumentException($"The {nameof(row)} argument does not contain a valid letter.");
}
if (column < 0)
{
throw new ArgumentException($"The {nameof(column)} argument is invalid. Please provide positive integers.");
}
// Get the ASCII value of a character, -64 to normalize the integer to base 1
var rowIntegerRepresentation = Char.ToUpper(row) - 64;
return(TriangleHelper.GetCoordinates(rowIntegerRepresentation, column));
}
public (int MaxSum, string Path) Search(string input)
{
var triangle = TriangleHelper.ConvertStringToArrayOfArray(input);
if (!triangle.Any())
{
return(0, string.Empty);
}
arrayNum = new int?[triangle.Length];
FindValidChilds(triangle);
var tuples = GetPathNumbersFromCache();
return(tuples.max, tuples.path);
}
/// <summary>
/// Calculates all internal angles for the polygon, moving from the first vertex to the next.
/// </summary>
/// <param name="numDigits">If you'd like a cap on the number of digits calculated, you can pass it here.</param>
/// <returns>List of all calculated angles in the polygon.</returns>
public List <double> CalculateAngles(int?numDigits = null)
{
List <double> calcAngles = new List <double>();
for (var i = 0; i < this.Vertices.Count; i++)
{
var leftVertex = i == 0 ? this.Vertices.Last() : this.Vertices[i - 1];
var rightVertex = this.Vertices[(i + 1) % this.Vertices.Count];
var thisVertex = this.Vertices[i];
calcAngles.Add(TriangleHelper.CalculateAngleFromTriangleSides(CoordinateHelper.CalculateLengthOfLine(leftVertex, thisVertex),
CoordinateHelper.CalculateLengthOfLine(rightVertex, thisVertex),
CoordinateHelper.CalculateLengthOfLine(leftVertex, rightVertex),
numDigits));
}
return(calcAngles);
}
public void Pythagorean()
{
double?sideA = 10;
double?sideB = 20;
double?sideC;
double?expected = 22.360679774997898;
Assert.Equal(expected, TriangleHelper.Pythagorean(sideA, sideB, null));
sideA = 15;
sideC = 25;
expected = 20;
Assert.Equal(expected, TriangleHelper.Pythagorean(sideA, null, sideC));
sideB = 5;
sideC = 25;
expected = 24.494897427831781;
Assert.Equal(expected, TriangleHelper.Pythagorean(null, sideB, sideC));
}
// Go bottom up, choose the child and merge the path memory with traversing up
private void CalculateTriangleSumData(Triangle triangle)
{
var currentTriangleSize = triangle.TriangleSize;
for (var i = currentTriangleSize - 2; i >= 0; i--)
{
var currentOneDimensionSize = triangle.TriangleNodes[i].Length;
for (var j = 0; j < currentOneDimensionSize; j++)
{
var chosenChild = TriangleHelper.ChooseSuitableChild(triangle, i, j);
if (chosenChild != null)
{
MergeMemory(triangle.TriangleNodes[i][j], chosenChild);
}
}
}
}
public void SinesAndCosines(string testName, TriangleData expected, double?angleA, double?angleB, double?angleC, double?sideA, double?sideB, double?sideC)
{
// Act
var actual = TriangleHelper.SinesAndCosines(angleA, angleB, angleC, sideA, sideB, sideC);
// Assert
Assert.NotNull(testName);
Assert.NotNull(actual);
Assert.Equal(expected.A, actual.A);
Assert.Equal(expected.B, actual.B);
Assert.Equal(expected.C, actual.C);
Assert.Equal(expected.a, actual.a);
Assert.Equal(expected.b, actual.b);
Assert.Equal(expected.c, actual.c);
Assert.Equal(expected.ToString(), actual.ToString());
}
