public static void ToManyInputsFailure()
{
string[] args = { "1", "2", "3", "4" };
string actual = TriangleFunctions.ValidInputs(args);
Assert.AreEqual(actual, "Please enter ONLY 3 valid positive integers");
}
public static void LargeNumberFailure()
{
string [] args = { "1", "2", "300000000000000000000000000000000000000000000000000000000" };
string actual = TriangleFunctions.ValidInputs(args);
Assert.AreEqual(actual, "Please enter 3 valid positive integers: OverflowException");
}
public static void NonIntegerInputFailureBeforeLargeNumberFailure()
{
string[] args = { "A", "2", "3000000000000000000000000000000000000000000000" };
string actual = TriangleFunctions.ValidInputs(args);
Assert.AreEqual(actual, "Please enter 3 valid positive integers: FormatException");
}
public void GenerateCoordinatesTest()
{
for (int i = 0; i < (validTriangleNames.Length - 1); i++)
{
Assert.AreEqual(TriangleFunctions.GenerateCoordinates(validTriangleNames[i].ToCharArray()), validCoordinates[i]);
}
}
public static void NoInputsFailure()
{
string[] args = {};
string actual = TriangleFunctions.ValidInputs(args);
Assert.AreEqual(actual, "Please enter 3 valid positive integers");
}
public void ConvertNumberToLetterTest()
{
Assert.AreEqual(TriangleFunctions.ConvertNumberToLetter(10), 'A');
Assert.AreEqual(TriangleFunctions.ConvertNumberToLetter(20), 'B');
Assert.AreEqual(TriangleFunctions.ConvertNumberToLetter(30), 'C');
Assert.AreEqual(TriangleFunctions.ConvertNumberToLetter(40), 'D');
Assert.AreEqual(TriangleFunctions.ConvertNumberToLetter(50), 'E');
Assert.AreEqual(TriangleFunctions.ConvertNumberToLetter(60), 'F');
}
public ActionResult GetTriangleName(string coordinates)
{
if (TriangleFunctions.VerifyCoordinates(coordinates))
{
Triangle triangle = new Triangle(coordinates);
return(Ok(triangle));
}
else
{
return(BadRequest("Invalid Triangle Coordinates"));
}
}
public ActionResult GetCoordinates(string triangleName)
{
if (TriangleFunctions.VerifyTriangleName(triangleName.ToCharArray()))
{
Triangle triangle = new Triangle(triangleName);
return(Ok(triangle));
}
else
{
return(BadRequest("Invalid Triangle Name"));
}
}
/// <summary>
/// Generates a Triangle from a valid TriangleName or valid set of Coordinates
/// </summary>
/// <param name="input"></param>
public Triangle(string input)
{
if (input.Length < 4)
{
this.TriangleName = input;
this.Coordinates = TriangleFunctions.GenerateCoordinates(input.ToCharArray());
}
else
{
this.Coordinates = input;
this.TriangleName = TriangleFunctions.GenerateTriangleName(input);
}
}
public void ConvertLetterToNumberTest()
{
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('a'), 1);
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('A'), 1);
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('b'), 2);
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('B'), 2);
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('c'), 3);
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('C'), 3);
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('d'), 4);
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('D'), 4);
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('e'), 5);
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('E'), 5);
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('f'), 6);
Assert.AreEqual(TriangleFunctions.ConvertLetterToNumber('F'), 6);
}
public void VerifyCoordinates()
{
string[] invalidCoordinates = new string[] { "(21,0),(11,0),(21,10)", // All x coordinate + 1
"(20,11),(20,1),(30,11)", // All y coordinate + 1
"(32,0),(22,0),(32,10)", // All x coordinate + 2
"(30,12),(30,2),(40,12)", // All y coordinate + 2
"(43,0),(33,0),(43,10)", // All x coordinate + 3
"(40,13),(40,3),(50,13)", // All y coordinate + 3
"(54,0),(44,0),(54,10)", // All x coordinate + 4
"(50,14),(50,4),(60,14)", // All y coordinate + 4
"(65,0),(55,0),(65,10)", // All x coordinate + 5
"(0,25),(0,15),(10,25)", // All y coordinate + 5
"(16,10),(6,10),(16,20)", // All x coordinate + 6
"(10,26),(10,16),(20,26)", // All y coordinate + 6
"(27,10),(17,10),(27,20)", // All x coordinate + 7
"(20,27),(20,17),(30,27)", // All y coordinate + 7
"(38,10),(28,10),(38,20)", // All x coordinate + 8
"(30,28),(30,18),(40,28)", // All y coordinate + 8
"(49,10),(39,10),(49,20)", // All x coordinate + 9
"(40,29),(40,19),(50,29)", // All y coordinate + 9
"((0,10),(40,10),(50,20)", // X1 valid char invalid position
"(50,2)),(50,10),(60,20)", // Y1 valid char invalid position
"(60,10),(5),10),(60,20)", // X2 valid char invalid position
"(0,30),(0,2(),(10,30)", // Y2 valid char invalid position
"(10,20),(0,20),(1),30)", // X3 valid char invalid position
"(10,30),(10,20),(20,(0)", // X4 valid char invalid position
"(20,20),,(10,2),(20,30)", // extra comma
"(200,30),(20,20),(30,30)", // X1 too large (valid chars)
"(30,200),(20,20),(30,30)", // Y1 too large (valid chars)
"(30,30),(300,20),(40,30)", // X2 too large (valid chars)
"(40,20),(30,200),(40,30)", // Y2 too large (valid chars)
"(40,30),(40,20),(500,30)", // X3 too large (valid chars)
"(50,20),(40,20),(50,300)" }; // Y3 too large (valid chars)
foreach (var validCoordinate in validCoordinates)
{
Assert.IsTrue(TriangleFunctions.VerifyCoordinates(validCoordinate));
}
foreach (var invalidCoordinate in invalidCoordinates)
{
Assert.IsFalse(TriangleFunctions.VerifyCoordinates(invalidCoordinate));
}
}
public void VerifyTriangleNameTest()
{
string[] invalidTriangleNames = new string[] { "g1", "g2", "g3", "g4", "g5", "g6", "g7", "g8", "g9", "g10", "g11", "g12",
"A01", "a20", "a21", "A22", "A30", "d41", "C50", "F62", "d71", "b81", "E92",
"G1", "G2", "G3", "G4", "G5", "G6", "G7", "G8", "G9", "G10", "G11", "G12",
"A", "ab", "ABC", "a111", "1A1", "1a", "11A", "aa1", "A00", "a01", "AAA",
"b", "BC", "bcd", "B111", "1b1", "1B", "11b", "BB1", "b00", "B01", "bbb",
"C", "cd", "CDE", "c111", "1C1", "1c", "11C", "cc1", "C00", "c01", "CCC",
"d", "DE", "def", "D111", "1d1", "1D", "11d", "DD1", "d00", "D01", "ddd",
"E", "eB", "EFG", "e111", "1E1", "1e", "11E", "ee1", "E00", "e01", "EEE",
"f", "FG", "fgh", "F111", "1f1", "1F", "11f", "FF1", "f00", "F01", "fff",
"A0", "a13", "B0", "b13", "C0", "c13", "D0", "d13", "E0", "e13", "F0", "f13" };
foreach (var validTriangleName in validTriangleNames)
{
Assert.IsTrue(TriangleFunctions.VerifyTriangleName(validTriangleName.ToCharArray()));
}
foreach (var invalidTriangleName in invalidTriangleNames)
{
Assert.IsFalse(TriangleFunctions.VerifyTriangleName(invalidTriangleName.ToCharArray()));
}
}
public static void InvalidTest()
{
string actual = TriangleFunctions.TriType(-1, 2, 3);
Assert.AreEqual(actual, "Error: Invalid side lengths");
}
public static void ScaleneTest()
{
string actual = TriangleFunctions.TriType(1, 2, 3);
Assert.AreEqual(actual, "Scalene");
}
public static void IsoscelesTest()
{
string actual = TriangleFunctions.TriType(1, 2, 2);
Assert.AreEqual(actual, "Isosceles");
}
public void GenerateTriangleName()
{
string[] validTriangleNamesCapsOnly = new string[] { "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "A10", "A11", "A12",
"B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "B10", "B11", "B12",
"C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "C10", "C11", "C12",
"D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9", "D10", "D11", "D12",
"E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9", "E10", "E11", "E12",
"F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12" };
string[] validCoordinates = new string[] { "(0,10),(0,0),(10,10)", // A1
"(10,0),(0,0),(10,10)", // A2
"(10,10),(10,0),(20,10)", // A3
"(20,0),(10,0),(20,10)", // A4
"(20,10),(20,0),(30,10)", // A5
"(30,0),(20,0),(30,10)", // A6
"(30,10),(30,0),(40,10)", // A7
"(40,0),(30,0),(40,10)", // A8
"(40,10),(40,0),(50,10)", // A9
"(50,0),(40,0),(50,10)", // A10
"(50,10),(50,0),(60,10)", // A11
"(60,0),(50,0),(60,10)", // A12
"(0,20),(0,10),(10,20)", // B1
"(10,10),(0,10),(10,20)", // B2
"(10,20),(10,10),(20,20)", // B3
"(20,10),(10,10),(20,20)", // B4
"(20,20),(20,10),(30,20)", // B5
"(30,10),(20,10),(30,20)", // B6
"(30,20),(30,10),(40,20)", // B7
"(40,10),(30,10),(40,20)", // B8
"(40,20),(40,10),(50,20)", // B9
"(50,10),(40,10),(50,20)", // B10
"(50,20),(50,10),(60,20)", // B11
"(60,10),(50,10),(60,20)", // B12
"(0,30),(0,20),(10,30)", // C1
"(10,20),(0,20),(10,30)", // C2
"(10,30),(10,20),(20,30)", // C3
"(20,20),(10,20),(20,30)", // C4
"(20,30),(20,20),(30,30)", // C5
"(30,20),(20,20),(30,30)", // C6
"(30,30),(30,20),(40,30)", // C7
"(40,20),(30,20),(40,30)", // C8
"(40,30),(40,20),(50,30)", // C9
"(50,20),(40,20),(50,30)", // C10
"(50,30),(50,20),(60,30)", // C11
"(60,20),(50,20),(60,30)", // C12
"(0,40),(0,30),(10,40)", // D1
"(10,30),(0,30),(10,40)", // D2
"(10,40),(10,30),(20,40)", // D3
"(20,30),(10,30),(20,40)", // D4
"(20,40),(20,30),(30,40)", // D5
"(30,30),(20,30),(30,40)", // D6
"(30,40),(30,30),(40,40)", // D7
"(40,30),(30,30),(40,40)", // D8
"(40,40),(40,30),(50,40)", // D9
"(50,30),(40,30),(50,40)", // D10
"(50,40),(50,30),(60,40)", // D11
"(60,30),(50,30),(60,40)", // D12
"(0,50),(0,40),(10,50)", // E1
"(10,40),(0,40),(10,50)", // E2
"(10,50),(10,40),(20,50)", // E3
"(20,40),(10,40),(20,50)", // E4
"(20,50),(20,40),(30,50)", // E5
"(30,40),(20,40),(30,50)", // E6
"(30,50),(30,40),(40,50)", // E7
"(40,40),(30,40),(40,50)", // E8
"(40,50),(40,40),(50,50)", // E9
"(50,40),(40,40),(50,50)", // E10
"(50,50),(50,40),(60,50)", // E11
"(60,40),(50,40),(60,50)", // E12
"(0,60),(0,50),(10,60)", // F1
"(10,50),(0,50),(10,60)", // F2
"(10,60),(10,50),(20,60)", // F3
"(20,50),(10,50),(20,60)", // F4
"(20,60),(20,50),(30,60)", // F5
"(30,50),(20,50),(30,60)", // F6
"(30,60),(30,50),(40,60)", // F7
"(40,50),(30,50),(40,60)", // F8
"(40,60),(40,50),(50,60)", // F9
"(50,50),(40,50),(50,60)", // F10
"(50,60),(50,50),(60,60)", // F11
"(60,50),(50,50),(60,60)" }; // F12
for (int i = 0; i < (validTriangleNamesCapsOnly.Length - 1); i++)
{
Assert.AreEqual(TriangleFunctions.GenerateTriangleName(validCoordinates[i]), validTriangleNamesCapsOnly[i]);
}
}
public static void Main(string[] args)
{
Console.WriteLine(TriangleFunctions.ValidInputs(args));
Console.ReadLine();
}
public static void EquilateralTest()
{
string actual = TriangleFunctions.TriType(1, 1, 1);
Assert.AreEqual(actual, "Equilateral");
}
