public void GetByNumber_FigureIsInBox_GetByNumberAndRemoveInBox()
{
// 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 PaperCircle(3, Color.Green);
figures[3] = new PaperSquare(new List <double> {
5
}, Color.Green);
var actualResult = 3;
var expectedBox = new Box(figures);
// act
expectedBox.GetByNumber(3);
// assert;
Assert.Equal(expectedBox.ShowCountFigures(), actualResult);
}
public void GetAllCircle_FigureIsInBox_GetAllCircle()
{
// 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 PaperCircle(3, Color.Green);
figures[3] = new PaperSquare(new List <double> {
5
}, Color.Green);
figures[4] = new FilmCircle(6);
var actualFigures = new List <IFigure>();
actualFigures.Add(new PaperCircle(3, Color.Green));
actualFigures.Add(new FilmCircle(6));
var expected = new Box(figures);
// assert;
Assert.Equal(expected.GetAllCircle(), actualFigures);
}
public void SaveFiguresToXmlFileUsingXmlWriterAndGetFiguresFromXmlFileUsingXmlReader_FigureIsInBox_GetFIgure()
{
// arrange
string path = @"..\..\..\Figures.xml";
var figures = new IFigure[20];
figures[0] = new PaperCircle(5, Color.Red);
figures[1] = new FilmRectangle(new List <double> {
11, 18
});
figures[2] = new PaperSquare(new List <double> {
8
}, Color.Green);
figures[3] = new FilmTriangle(new List <double> {
9, 11, 4
});
var actualBox = new Box(figures);
actualBox.SaveFiguresToXmlFileUsingXmlWriter(path);
var expected = new Box();
expected.GetFiguresFromXmlFileUsingXmlReader(path);
// assert;
Assert.Equal(expected, actualBox);
}
/// <summary>
/// Reads the file.
/// </summary>
/// <param name="file">The file.</param>
/// <returns>List of shapes.</returns>
public List <IShape> ReadFile(string file)
{
List <IShape> shapes = new List <IShape>();
using (XmlReader reader = XmlReader.Create(file))
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name.Equals("circle"))
{
Circle circle;
if (reader.GetAttribute("material").Equals("paper"))
{
circle = new PaperCircle(
double.Parse(reader.GetAttribute("radius")),
(Color)Enum.Parse(typeof(Color), reader.GetAttribute("color")));
}
else
{
circle = new MembraneCircle(double.Parse(reader.GetAttribute("radius")));
}
shapes.Add(circle);
}
if (reader.Name.Equals("square"))
{
Square square;
if (reader.GetAttribute("material").Equals("paper"))
{
square = new PaperSquare(double.Parse(reader.GetAttribute("side")), (Color)Enum.Parse(typeof(Color), reader.GetAttribute("color")));
}
else
{
square = new MembraneSquare(double.Parse(reader.GetAttribute("side")));
}
shapes.Add(square);
}
if (reader.Name.Equals("rectangle"))
{
Rectangle rectangle;
if (reader.GetAttribute("material").Equals("paper"))
{
rectangle = new PaperRectangle(double.Parse(reader.GetAttribute("firstSide")),
double.Parse(reader.GetAttribute("secondSide")),
(Color)Enum.Parse(typeof(Color), reader.GetAttribute("color")));
}
else
{
rectangle = new MembraneRectangle(
double.Parse(reader.GetAttribute("firstSide")),
double.Parse(reader.GetAttribute("secondSide")));
}
shapes.Add(rectangle);
}
}
}
}
return(shapes);
}
public void AddFigure_FigureIsInBox_AddNewFigure()
{
// 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 PaperCircle(3, Color.Green);
figures[3] = new PaperSquare(new List <double> {
5
}, Color.Green);
var figure = new FilmCircle(6);
var actualResult = new Box(figures);
actualResult.AddFigure(figure);
var expected = new Box(figures);
// act
expected.AddFigure(figure);
// assert;
Assert.Equal(expected, actualResult);
}
public void GetPerimeter_PositiveTestResult(double squareSide, Colors color, double expectedPerimeter)
{
PaperSquare actualPaperSquare = new PaperSquare(new List <double> {
squareSide
}, color);
Assert.AreEqual(expectedPerimeter, actualPaperSquare.GetPerimeter());
}
public void TestGetPerimeterOfSquare(double side, double expectedArea)
{
Square paperSquare = new PaperSquare(side);
Square membraneSquare = new MembraneSquare(side);
Assert.AreEqual(expectedArea, paperSquare.GetPerimeter());
Assert.AreEqual(expectedArea, membraneSquare.GetPerimeter());
}
public void CreatingSquareMustReturnObject(double side)
{
Square paperSquare = new PaperSquare(side);
Square membraneSquare = new MembraneSquare(side);
Assert.IsNotNull(paperSquare);
Assert.IsNotNull(membraneSquare);
}
public void PaintOverFigure_IsPaintedException(double squareSide, Colors actualColor, Colors newFirstColor, Colors newSecondColor)
{
PaperSquare actualPaperSquare = new PaperSquare(new List <double> {
squareSide
}, actualColor);
actualPaperSquare.PaintOverFigure(newFirstColor);
Assert.ThrowsException <IsPaintedException>(() => actualPaperSquare.PaintOverFigure(newSecondColor));
}
public void PaintOverFigure_PositiveTestResult(double squareSide, Colors actualColor, Colors newColor, Colors expectedColor)
{
PaperSquare actualPaperSquare = new PaperSquare(new List <double> {
squareSide
}, actualColor);
actualPaperSquare.PaintOverFigure(newColor);
Assert.AreEqual(expectedColor, actualPaperSquare.Color);
}
public void PaperRectangle_CutFigureBiggerOriginal_OutOfAreaException(double firstSquareSide, Colors color, double secondSquareSide)
{
PaperSquare actualPaperSquare = new PaperSquare(new List <double> {
firstSquareSide
}, color);
Assert.ThrowsException <OutOfAreaException>(() => new PaperSquare(new List <double> {
secondSquareSide
}, actualPaperSquare));
}
public void TestPaintNonePaperShapes(double radius, double squareSide, double rectangleFirstSide, double rectangleSecondSide, Color color)
{
PaperCircle paperCircle = new PaperCircle(radius);
PaperRectangle paperRectangle = new PaperRectangle(rectangleFirstSide, rectangleSecondSide);
PaperSquare paperSquare = new PaperSquare(squareSide);
Assert.ThrowsException <UnableToPaintException>(() => paperCircle.Paint(color));
Assert.ThrowsException <UnableToPaintException>(() => paperSquare.Paint(color));
Assert.ThrowsException <UnableToPaintException>(() => paperRectangle.Paint(color));
}
public void GetArea_NewRectangle_GetArea()
{
var actual = 144;
// act
var expected = new PaperSquare(new List <double> {
12
}, Color.Black);
// assert;
Assert.Equal(expected.GetArea(), actual);
}
public void TestPaintPaperShapes(double radius, double squareSide, double rectangleFirstSide, double rectangleSecondSide, Color color)
{
PaperCircle paperCircle = new PaperCircle(radius);
PaperRectangle paperRectangle = new PaperRectangle(rectangleFirstSide, rectangleSecondSide);
PaperSquare paperSquare = new PaperSquare(squareSide);
paperCircle.Paint(color);
paperSquare.Paint(color);
paperRectangle.Paint(color);
Assert.AreEqual(color, paperCircle.GetColor());
Assert.AreEqual(color, paperSquare.GetColor());
Assert.AreEqual(color, paperRectangle.GetColor());
}
public void PaperSquare_CutFigureSmallerOriginal_PositiveTestResult(double rectFirstSide, double rectSecondSide, Colors color, double squareSide)
{
PaperRectangle PaperRectangle = new PaperRectangle(new List <double> {
rectFirstSide, rectSecondSide
}, color);
PaperSquare expectedPaperSquare = new PaperSquare(new List <double> {
squareSide
}, PaperRectangle);
PaperSquare actualPaperSquare = new PaperSquare(new List <double> {
squareSide
}, color);
Assert.AreEqual(expectedPaperSquare, actualPaperSquare);
}
public void Equals_TwoRectangle_Equals()
{
var actual = new PaperSquare(new List <double> {
12
}, Color.Green);
// act
var expected = new PaperSquare(new List <double> {
12
}, Color.Green);
// assert;
Assert.Equal(expected, actual);
}
public void СhangeСolor_NewColor_СhangeСolor()
{
var expected = new PaperSquare(new List <double> {
12
}, Color.Black);
expected.СhangeСolor(Color.Green);
// act
var actual = new PaperSquare(new List <double> {
12
}, Color.Green);
// assert;
Assert.Equal(expected, actual);
}
public void CreateNewFigire_NewAreaLessOldArea_CreateNewFigire()
{
var paperCircle = new PaperCircle(13, Color.Black);
var actual = new PaperSquare(new List <double> {
5
}, Color.Black);
// act
var expected = new PaperSquare(paperCircle, new List <double> {
5
}, paperCircle.Color);
// assert;
Assert.Equal(expected, actual);
}
public void TestGetAllCirclesFromBox(double radius, double newRadius, double side, int numberOfCircles)
{
Box box = new Box();
Circle firstCircle = new MembraneCircle(radius);
Circle secondCircle = new PaperCircle(newRadius);
Square square = new PaperSquare(side);
Assert.AreEqual(0, box.GetAllCircles().Count);
box.AddShape(firstCircle);
box.AddShape(secondCircle);
box.AddShape(square);
Assert.IsTrue(new List <Circle>()
{
firstCircle, secondCircle
}.SequenceEqual(box.GetAllCircles()));
Assert.AreEqual(numberOfCircles, box.GetAllCircles().Count);
}
/// <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);
}
/// <summary>
/// Reads the file.
/// </summary>
/// <param name="file">The file.</param>
/// <returns>List of shapes.</returns>
public List <IShape> ReadFile(string file)
{
List <IShape> shapes = new List <IShape>();
using (StreamReader streamReader = new StreamReader(file))
{
XmlDocument document = new XmlDocument();
document.Load(streamReader);
XmlNode root = document.SelectSingleNode("/shapes");
XmlNodeList nodeList = root.SelectNodes("*");
foreach (XmlNode node in nodeList)
{
if (node.Name.Equals("circle"))
{
Circle circle;
if (node.Attributes.GetNamedItem("material").Value.Equals("paper"))
{
circle = new PaperCircle(
double.Parse(node.Attributes.GetNamedItem("radius").Value),
(Color)Enum.Parse(typeof(Color), node.Attributes.GetNamedItem("color").Value));
}
else
{
circle = new MembraneCircle(double.Parse(node.Attributes.GetNamedItem("radius").Value));
}
shapes.Add(circle);
}
if (node.Name.Equals("square"))
{
Square square;
if (node.Attributes.GetNamedItem("material").Value.Equals("paper"))
{
square = new PaperSquare(
double.Parse(node.Attributes.GetNamedItem("side").Value),
(Color)Enum.Parse(typeof(Color), node.Attributes.GetNamedItem("color").Value));
}
else
{
square = new MembraneSquare(double.Parse(node.Attributes.GetNamedItem("side").Value));
}
shapes.Add(square);
}
if (node.Name.Equals("rectangle"))
{
Rectangle rectangle;
if (node.Attributes.GetNamedItem("material").Value.Equals("paper"))
{
rectangle = new PaperRectangle(
double.Parse(node.Attributes.GetNamedItem("firstSide").Value),
double.Parse(node.Attributes.GetNamedItem("secondSide").Value),
(Color)Enum.Parse(typeof(Color), node.Attributes.GetNamedItem("color").Value));
}
else
{
rectangle = new MembraneRectangle(
double.Parse(node.Attributes.GetNamedItem("firstSide").Value),
double.Parse(node.Attributes.GetNamedItem("secondSide").Value));
}
shapes.Add(rectangle);
}
}
}
return(shapes);
}
/// <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);
}
