Esempio n. 1
0
 public void Test_02_DecimalInput()
 {
     // For input of width 14.25 m, depth 19.5 m, height 3.5 m
     // Floor area = 14.25 x 19.5 = 277.875 m^2
     // Paint volume = (2 x 14.25 x 3.5) + (2 x 19.5 x 3.5) = 99.75 + 136.5 = 236.25 => 23.625 litres
     // Room volume = 14.25 x 19.5 x 3.5 = 972.5625 m^3
     Program.RoomResults expectedResults = new Program.RoomResults(277.875, 23.625, 972.5625);
     Program.RoomResults testResults     = Program.CalculateResults(14.25, 19.5, 3.5, new System.Collections.Generic.List <double[]>());
     Assert.AreEqual(expectedResults.FloorArea, testResults.FloorArea);
     Assert.AreEqual(expectedResults.PaintVolume, testResults.PaintVolume);
     Assert.AreEqual(expectedResults.RoomVolume, testResults.RoomVolume);
 }
Esempio n. 2
0
 public void Test_01_IntegerInput()
 {
     // For input of width 2 m, depth 3 m, height 4 m
     // Floor area = 2 x 3 = 6 m^2
     // Paint volume = (2 x 4 x 2) + (2 x 4 x 3) = 16 + 24 = 40 => 4 litres
     // Room volume = 2 x 3 x 4 = 24 m^3
     Program.RoomResults expectedResults = new Program.RoomResults(6, 4, 24);
     Program.RoomResults testResults     = Program.CalculateResults(2, 3, 4, new System.Collections.Generic.List <double[]>());
     Assert.AreEqual(expectedResults.FloorArea, testResults.FloorArea);
     Assert.AreEqual(expectedResults.PaintVolume, testResults.PaintVolume);
     Assert.AreEqual(expectedResults.RoomVolume, testResults.RoomVolume);
 }
Esempio n. 3
0
        public void Test_05_IntegerWindows()
        {
            // For input of width 2 m, depth 3 m, height 4 m
            // Windows: (2m x 1m), (3m x 2m)
            // Floor area = 2 x 3 = 6 m^2
            // Paint volume = (2 x 4 x 2) + (2 x 4 x 3) - (2 x 1) - (3 x 2) = 16 + 24 - 2 - 6 = 40 - 8 = 32 => 3.2 litres
            // Room volume = 2 x 3 x 4 = 24 m^3
            List <double[]> windows = new List <double[]>
            {
                new double[] { 2, 1 },
                new double[] { 3, 2 }
            };

            Program.RoomResults expectedResults = new Program.RoomResults(6, 3.2, 24);
            Program.RoomResults testResults     = Program.CalculateResults(2, 3, 4, windows);
            Assert.AreEqual(expectedResults.FloorArea, testResults.FloorArea);
            Assert.AreEqual(expectedResults.PaintVolume, testResults.PaintVolume);
            Assert.AreEqual(expectedResults.RoomVolume, testResults.RoomVolume);
        }
Esempio n. 4
0
        public void Test_06_DecimalWindows()
        {
            // For input of width 14.25 m, depth 19.5 m, height 3.5 m
            // Windows: (3.75m x 2.125m), (5.5m x 2.625m)
            // Paint volume = (2 x 4 x 2) + (2 x 4 x 3) - (2 x 1) - (3 x 2) = 16 + 24 - 2 - 6 = 40 - 8 = 32 => 3.2 litres
            // Floor area = 14.25 x 19.5 = 277.875 m^2
            // Paint volume = (2 x 14.25 x 3.5) + (2 x 19.5 x 3.5) - (3.75 x 2.125) - (5.5 x 2.625) = 99.75 + 136.5 - 7.96875 - 14.4375 = 236.25 - 22.40625 = 213.84375 => 21.384375 litres
            // Room volume = 14.25 x 19.5 x 3.5 = 972.5625 m^3
            List <double[]> windows = new List <double[]>
            {
                new double[] { 3.75, 2.125 },
                new double[] { 5.5, 2.625 }
            };

            Program.RoomResults expectedResults = new Program.RoomResults(277.875, 21.384375, 972.5625);
            Program.RoomResults testResults     = Program.CalculateResults(14.25, 19.5, 3.5, windows);
            Assert.AreEqual(expectedResults.FloorArea, testResults.FloorArea, 1e-10);
            Assert.AreEqual(expectedResults.PaintVolume, testResults.PaintVolume, 1e-10);
            Assert.AreEqual(expectedResults.RoomVolume, testResults.RoomVolume, 1e-10);
        }
        public void Test_16_AreaCalcTriangle()
        {
            // Coordinates of triangle: (-4,0), (0,10), (11,0)
            // Room height: 2m
            // Area of triangle (manual calculation): 75m^2
            // Volume = 150m^3
            // Perimeter = 36.64m -> Wall Area = 73.28m^2 -> Paint needed = 7.328 litres
            List <double[]> coords = new List <double[]>()
            {
                new double[] { -4, 0 },
                new double[] { 0, 10 },
                new double[] { 11, 0 }
            };

            Program.RoomResults expectedResults = new Program.RoomResults(75, 7.328, 150);
            Program.RoomResults testResults     = Program.CalculateCustomResults(coords, 36.64, 2, new List <double[]>());
            Assert.AreEqual(expectedResults.FloorArea, testResults.FloorArea);
            Assert.AreEqual(expectedResults.PaintVolume, testResults.PaintVolume);
            Assert.AreEqual(expectedResults.RoomVolume, testResults.RoomVolume);
        }
        public void Test_15_AreaCalcRectangle()
        {
            // Coordinates of rectangle: (0,0), (0,10), (15,10), (15,0)
            // Room height: 2m
            // Area of rectangle (manual calculation): 150m^2
            // Volume = 300m^3
            // Perimeter = 50m -> Wall Area = 100m^2 -> Paint needed = 10 litres
            List <double[]> coords = new List <double[]>()
            {
                new double[] { 0, 0 },
                new double[] { 0, 10 },
                new double[] { 15, 10 },
                new double[] { 15, 0 }
            };

            Program.RoomResults expectedResults = new Program.RoomResults(150, 10, 300);
            Program.RoomResults testResults     = Program.CalculateCustomResults(coords, 50, 2, new List <double[]>());
            Assert.AreEqual(expectedResults.FloorArea, testResults.FloorArea);
            Assert.AreEqual(expectedResults.PaintVolume, testResults.PaintVolume);
            Assert.AreEqual(expectedResults.RoomVolume, testResults.RoomVolume);
        }
        public void Test_17_AreaCalcPolygon()
        {
            // Coordinates of polygon: (0,0), (8,0), (10,4), (8,8), (0,8), (-2,4)
            // Room height: 2m
            // Area of polygon (manual calculation): 80m^2
            // Volume = 160m^3
            // Perimeter = 32.97m -> Wall Area = 65.94m^2 -> Paint needed = 6.594 litres
            List <double[]> coords = new List <double[]>()
            {
                new double[] { 0, 0 },
                new double[] { 8, 0 },
                new double[] { 10, 4 },
                new double[] { 8, 8 },
                new double[] { 0, 8 },
                new double[] { -2, 4 }
            };

            Program.RoomResults expectedResults = new Program.RoomResults(80, 6.594, 160);
            Program.RoomResults testResults     = Program.CalculateCustomResults(coords, 32.97, 2, new List <double[]>());
            Assert.AreEqual(expectedResults.FloorArea, testResults.FloorArea);
            Assert.AreEqual(expectedResults.PaintVolume, testResults.PaintVolume);
            Assert.AreEqual(expectedResults.RoomVolume, testResults.RoomVolume);
        }