Triangle Type Tests (Equilateral, Isosceles, ...)

gistfile1.cs

    using System;
    using System.Linq;
    using NUnit.Framework;

    /// <summary>
    /// Write a function that takes three integer lengths corresponding to the sides of a triangle, and returns the type of triangle (eg, Equilateral, Isosceles, etc) that can be created out of those values.
    /// You must handle the following cases:
    /// - No triangle may be formed from those 3 lengths
    /// - Any invalid parameters passed in
    /// </summary>
    [TestFixture]
    public class TriangleTests
    {
        public enum TriangleType
        {
            Spiky,
            SpikyIsosceles,
            Equilateral,
            Right,
            RightIsosceles,
            Obtuse,
            ObtuseIsosceles
        }

        public static TriangleType ParseTriangle(int p1, int p2, int p3)
        {
            return ParseTriangleType(new[] { p1, p2, p3 });
        }

        private static TriangleType ParseTriangleType(int[] triangleEdges)
        {
            if (triangleEdges.Any(e => e <= 0))
            {
                throw new Exception("Triangle is invalid.");
            }
            var orderedListOfEdges = triangleEdges.OrderByDescending(e => e).ToArray();
            return ParseTriangleType(orderedListOfEdges[0], orderedListOfEdges[1], orderedListOfEdges[2]);
        }

        private static TriangleType ParseTriangleType(int baseEdge, int edge2, int edge3)
        {
            if (baseEdge > edge2 + edge3)
            {
                throw new Exception("Triangle is invalid.");
            }

            if (baseEdge == edge2 && baseEdge == edge3)
            {
                return TriangleType.Equilateral;
            }

            var baseEdgeSquare = baseEdge * baseEdge;
            var otherEdgeSquareSum = (edge2 * edge2) + (edge3 * edge3);
            bool isIsosceles = edge2 == edge3 || baseEdge == edge2;

            if (baseEdgeSquare < otherEdgeSquareSum)
            {
                return isIsosceles ? TriangleType.SpikyIsosceles : TriangleType.Spiky;
            }
            else if (baseEdgeSquare == otherEdgeSquareSum)
            {
                return isIsosceles ? TriangleType.RightIsosceles : TriangleType.Right;
            }
            else
            {
                return isIsosceles ? TriangleType.ObtuseIsosceles : TriangleType.Obtuse;
            }
        }

        [Test]
        public void Spiky()
        {
            Assert.AreEqual(TriangleType.Spiky, ParseTriangle(18, 19, 20));
        }

        [Test]
        public void SpikyIsosceles()
        {
            Assert.AreEqual(TriangleType.SpikyIsosceles, ParseTriangle(3, 4, 4));
        }

        [Test]
        public void Equilateral()
        {
            Assert.AreEqual(TriangleType.Equilateral, ParseTriangle(4, 4, 4));
        }

        [Test]
        public void Right()
        {
            Assert.AreEqual(TriangleType.Right, ParseTriangle(3, 4, 5));
        }

        [Test]
        public void Obtuse()
        {
            Assert.AreEqual(TriangleType.Obtuse, ParseTriangle(3, 2, 4));
        }

        [Test]
        public void ObtuseIsosceles()
        {
            Assert.AreEqual(TriangleType.ObtuseIsosceles, ParseTriangle(10, 10, 18));
        }

        [Test, ExpectedException]
        public void Error1()
        {
            Assert.AreEqual(TriangleType.Obtuse, ParseTriangle(3, 40, 4));
        }

        [Test, ExpectedException]
        public void Error2()
        {
            Assert.AreEqual(TriangleType.Obtuse, ParseTriangle(-4, 4, 4));
        }
    }