public void GetArea_PositiveTestResult(double squareSide, double expectedArea)
        {
            FilmSquare actualFilmSquare = new FilmSquare(new List <double> {
                squareSide
            });

            Assert.AreEqual(expectedArea, actualFilmSquare.GetArea());
        }
        public void GetPerimeter_PositiveTestResult(double squareSide, double expectedPerimeter)
        {
            FilmSquare actualFilmSquare = new FilmSquare(new List <double> {
                squareSide
            });

            Assert.AreEqual(expectedPerimeter, actualFilmSquare.GetPerimeter());
        }
        public void FilmRectangle_CutFigureBiggerOriginal_OutOfAreaException(double firstSquareSide, double secondSquareSide)
        {
            FilmSquare actualFilmSquare = new FilmSquare(new List <double> {
                firstSquareSide
            });

            Assert.ThrowsException <OutOfAreaException>(() => new FilmSquare(new List <double> {
                secondSquareSide
            }, actualFilmSquare));
        }
Esempio n. 4
0
        public void GetArea_NewRectangle_GetArea()
        {
            var actual = 144;

            // act
            var expected = new FilmSquare(new List <double> {
                12
            });

            // assert;
            Assert.Equal(expected.GetArea(), actual);
        }
Esempio n. 5
0
        public void GetPerimeter_NewRectangle_GetPerimeter()
        {
            var actual = 48;

            // act
            var expected = new FilmSquare(new List <double> {
                12
            });

            // assert;
            Assert.Equal(expected.GetPerimeter(), actual);
        }
        public void FilmSquare_CutFigureSmallerOriginal_PositiveTestResult(double rectFirstSide, double rectSecondSide, double squareSide)
        {
            FilmRectangle filmRectangle = new FilmRectangle(new List <double> {
                rectFirstSide, rectSecondSide
            });
            FilmSquare expectedFilmSquare = new FilmSquare(new List <double> {
                squareSide
            }, filmRectangle);
            FilmSquare actualFilmSquare = new FilmSquare(new List <double> {
                squareSide
            });

            Assert.AreEqual(expectedFilmSquare, actualFilmSquare);
        }
Esempio n. 7
0
        public void Equals_TwoRectangle_Equals()
        {
            var actual = new FilmSquare(new List <double> {
                12
            });

            // act
            var expected = new FilmSquare(new List <double> {
                12
            });

            // assert;
            Assert.Equal(expected, actual);
        }
Esempio n. 8
0
        public void CreateNewFigire_NewAreaLessOldArea_CreateNewFigire()
        {
            var filmCircle = new FilmCircle(13);
            var actual     = new FilmSquare(new List <double> {
                5
            });

            // act
            var expected = new FilmSquare(filmCircle, new List <double> {
                5
            });

            // assert;
            Assert.Equal(expected, actual);
        }
Esempio n. 9
0
        public void CreateNewFigire_NewAreaLessOldArea_CreateNewFigire()
        {
            var paperTriangle = new FilmTriangle(new List <double> {
                12, 14, 15
            });
            var actual = new FilmSquare(new List <double> {
                5
            });

            // act
            var expected = new FilmSquare(paperTriangle, new List <double> {
                5
            });

            // assert;
            Assert.Equal(expected, actual);
        }
Esempio n. 10
0
        public void GetFilmFIgure_FigureIsInBox_GetFilmFIgure()
        {
            // arrange
            var figures = new IFigure[20];

            figures[0] = new PaperRectangle(new List <double> {
                4, 6
            }, Color.Black);
            figures[1] = new PaperTriangle(new List <double> {
                3, 4, 5
            }, Color.Red);
            figures[2] = new FilmRectangle(new List <double> {
                4, 6
            });
            figures[3] = new FilmTriangle(new List <double> {
                3, 4, 5
            });
            figures[4] = new PaperCircle(3, Color.Green);
            figures[5] = new FilmSquare(new List <double> {
                5
            });
            figures[6] = new FilmCircle(6);

            var actualFigures = new List <IFigure>();

            actualFigures.Add(new FilmRectangle(new List <double> {
                4, 6
            }));
            actualFigures.Add(new FilmTriangle(new List <double> {
                3, 4, 5
            }));
            actualFigures.Add(new FilmSquare(new List <double> {
                5
            }));
            actualFigures.Add(new FilmCircle(6));
            var expected = new Box(figures);

            // assert;
            Assert.Equal(expected.GetAllFilmFigures(), actualFigures);
        }
Esempio n. 11
0
        public void ShowByNumber_FigureIsInBox_ShowFigure()
        {
            // arrange
            var figures = new IFigure[20];

            figures[0] = new FilmRectangle(new List <double> {
                4, 6
            });
            figures[1] = new FilmTriangle(new List <double> {
                3, 4, 5
            });
            figures[2] = new FilmCircle(3);
            figures[3] = new FilmSquare(new List <double> {
                5
            });
            var actualResult = figures[1];
            var expectedBox  = new Box(figures);

            // act
            var expected = expectedBox.ShowByNumber(1);

            // assert;
            Assert.Equal(expected, actualResult);
        }
        /// <summary>
        /// Method reads figures from an xml file using StreamReader.
        /// </summary>
        /// <param name="path">path</param>
        /// <returns>IFigure[]</returns>
        public static IFigure[] GetFromFile(string path)
        {
            var figures = new IFigure[_sizeArray];
            var sides   = new List <double>();

            object color      = null;
            string material   = null;
            string figureName = null;
            string content    = null;

            double radius = 0;
            int    count  = 0;

            string patternMaterial = @"(Paper|Film)([A-z]*)";
            string patternNumber   = @"(\d+|\d.+)\<";
            string patternColor    = @">([A-z]*)<";
            var    regex           = new Regex(patternMaterial);

            using (var streamReader = new StreamReader(path))
            {
                while ((content = streamReader.ReadLine()) != null)
                {
                    if (!Enum.TryParse(typeof(FigureType), content.Trim('<', '>', '/', '\t', ' '), out object figureType))
                    {
                        continue;
                    }

                    regex = new Regex(patternMaterial);
                    foreach (Match match in regex.Matches(figureType.ToString()))
                    {
                        material   = match.Groups[1].Value;
                        figureName = match.Groups[2].Value;
                    }

                    content = streamReader.ReadLine();
                    regex   = new Regex(patternNumber);

                    if (figureName != _circleFigure)
                    {
                        foreach (Match match in regex.Matches(content))
                        {
                            sides = match.Groups[1].Value.Split(' ').Select(obj => double.Parse(obj)).ToList();
                        }
                    }
                    else
                    {
                        foreach (Match match in regex.Matches(content))
                        {
                            double.TryParse(match.Groups[1].Value, out radius);
                        }
                    }

                    if (material == _paperMaterial)
                    {
                        content = streamReader.ReadLine();
                        regex   = new Regex(patternColor);
                        foreach (Match match in regex.Matches(content))
                        {
                            color = Enum.Parse(typeof(Color), match.Groups[1].Value);
                        }
                    }

                    switch (figureType)
                    {
                    case FigureType.PaperCircle:
                        figures[count] = new PaperCircle(radius, (Color)color);
                        break;

                    case FigureType.PaperRectangle:
                        figures[count] = new PaperRectangle(sides, (Color)color);
                        break;

                    case FigureType.PaperSquare:
                        figures[count] = new PaperSquare(sides, (Color)color);
                        break;

                    case FigureType.PaperTriangle:
                        figures[count] = new PaperTriangle(sides, (Color)color);
                        break;

                    case FigureType.FilmCircle:
                        figures[count] = new FilmCircle(radius);
                        break;

                    case FigureType.FilmRectangle:
                        figures[count] = new FilmRectangle(sides);
                        break;

                    case FigureType.FilmSquare:
                        figures[count] = new FilmSquare(sides);
                        break;

                    case FigureType.FilmTriangle:
                        figures[count] = new FilmTriangle(sides);
                        break;

                    default:
                        break;
                    }
                    count++;
                    if (count == figures.Length - 1)
                    {
                        return(figures);
                    }
                    content = streamReader.ReadLine();
                }
            }

            return(figures);
        }
Esempio n. 13
0
        /// <summary>
        /// Method reads figures from an xml file using XmlReader.
        /// </summary>
        /// <param name="path">path</param>
        /// <returns>IFigure[]</returns>
        public static IFigure[] GetFromFile(string path)
        {
            var figures = new IFigure[_sizeArray];
            var sides   = new List <double>();

            using var xmlReader = new XmlTextReader(path);
            object color      = null;
            string material   = null;
            string figureName = null;

            double radius = 0;
            int    count  = 0;

            string patternMaterial = @"(Paper|Film)([A-z]*)";
            string patternNumber   = @"(\d+|\d.+)\<";

            var regex = new Regex(patternNumber);

            while (xmlReader.Read())
            {
                if (!Enum.TryParse(typeof(FigureType), xmlReader.Name, out object figureType))
                {
                    continue;
                }

                regex = new Regex(patternMaterial);
                foreach (Match match in regex.Matches(figureType.ToString()))
                {
                    material   = match.Groups[1].Value;
                    figureName = match.Groups[2].Value;
                }

                xmlReader.Read();
                xmlReader.Read();

                if (figureName != _circleFigure)
                {
                    sides = new List <double>();

                    if ((xmlReader.NodeType == XmlNodeType.Element) && (xmlReader.Name == nameof(IPolygonFigure.Sides)))
                    {
                        sides = xmlReader.ReadElementString().Split(' ').Select(obj => double.Parse(obj)).ToList();
                    }
                }
                else
                if ((xmlReader.NodeType == XmlNodeType.Element) && (xmlReader.Name == nameof(ICircle.Radius)))
                {
                    radius = double.Parse(xmlReader.ReadElementString());
                }

                if (material == _paperMaterial)
                {
                    xmlReader.Read();

                    if ((xmlReader.NodeType == XmlNodeType.Element) && (xmlReader.Name == nameof(IPaper.Color)))
                    {
                        color = Enum.Parse(typeof(Color), xmlReader.ReadElementString());
                    }
                }

                switch (figureType)
                {
                case FigureType.PaperCircle:
                    figures[count] = new PaperCircle(radius, (Color)color);
                    break;

                case FigureType.PaperRectangle:
                    figures[count] = new PaperRectangle(sides, (Color)color);
                    break;

                case FigureType.PaperSquare:
                    figures[count] = new PaperSquare(sides, (Color)color);
                    break;

                case FigureType.PaperTriangle:
                    figures[count] = new PaperTriangle(sides, (Color)color);
                    break;

                case FigureType.FilmCircle:
                    figures[count] = new FilmCircle(radius);
                    break;

                case FigureType.FilmRectangle:
                    figures[count] = new FilmRectangle(sides);
                    break;

                case FigureType.FilmSquare:
                    figures[count] = new FilmSquare(sides);
                    break;

                case FigureType.FilmTriangle:
                    figures[count] = new FilmTriangle(sides);
                    break;
                }
                count++;
                if (count == figures.Length - 1)
                {
                    return(figures);
                }
                xmlReader.Read();
            }

            return(figures);
        }