private static void CheckTriangle(double side1, double side2, double side3, double expected)
{
double area = AreaCalculator.CalculateTriangleArea(side1, side2, side3);
Assert.IsFalse(double.IsNaN(area));
AssertKindaEqual(expected, area);
area = AreaCalculator.CalculateTriangleArea(side1, side3, side2);
Assert.IsFalse(double.IsNaN(area));
AssertKindaEqual(expected, area);
area = AreaCalculator.CalculateTriangleArea(side2, side1, side3);
Assert.IsFalse(double.IsNaN(area));
AssertKindaEqual(expected, area);
area = AreaCalculator.CalculateTriangleArea(side2, side3, side1);
Assert.IsFalse(double.IsNaN(area));
AssertKindaEqual(expected, area);
area = AreaCalculator.CalculateTriangleArea(side3, side1, side2);
Assert.IsFalse(double.IsNaN(area));
AssertKindaEqual(expected, area);
area = AreaCalculator.CalculateTriangleArea(side3, side2, side1);
Assert.IsFalse(double.IsNaN(area));
AssertKindaEqual(expected, area);
}
public void ValidAreaCalculation()
{
Triangle tr1 = new Triangle(3, 4, 5);
Triangle tr2 = new Triangle(2, 3, 3);
Circle c1 = new Circle(22);
Circle c2 = new Circle(11);
IAreaCalculatable[] figures = { tr1, tr2, c1, c2 };
List <double> result = new List <double>();
List <double> expected = new List <double> {
6, 2.828, 1520.53, 380.132
};
foreach (var figure in figures)
{
result.Add(AreaCalculator.GetArea(figure));
}
double prec = 0.01;
for (int i = 0; i < expected.Count; i++)
{
Assert.AreEqual(expected[i], result[i], prec, "Wrong Answer!");
}
}
public void SimpleAreaCalculatorTest()
{
// Arrange
var figure1 = new TestFigure();
var figure2 = new TestFigure();
var figure3 = new TestFigure();
var figure1Calculator = new Mock <ITryAreaCalculator>(MockBehavior.Default);
figure1Calculator.Setup(it => it.TryCalculateArea(figure1)).Returns(1);
var figure2Calculator = new Mock <ITryAreaCalculator>(MockBehavior.Default);
figure2Calculator.Setup(it => it.TryCalculateArea(figure2)).Returns(2);
var figure3Calculator = new Mock <ITryAreaCalculator>(MockBehavior.Default);
figure3Calculator.Setup(it => it.TryCalculateArea(figure3)).Returns(0);
var areaCalculator = new AreaCalculator();
areaCalculator.Calculators.Add(figure1Calculator.Object);
areaCalculator.Calculators.Add(figure2Calculator.Object);
areaCalculator.Calculators.Add(figure3Calculator.Object);
// Act
var figure1Area = areaCalculator.CalculateArea(figure1);
var figure2Area = areaCalculator.CalculateArea(figure2);
var figure3Area = areaCalculator.CalculateArea(figure3);
// Assert
Assert.AreEqual(1, figure1Area);
Assert.AreEqual(2, figure2Area);
Assert.AreEqual(0, figure3Area);
}
private static void CheckCircle(double radius, double expected)
{
double actual = AreaCalculator.CalculateCircleArea(radius);
Assert.IsFalse(double.IsNaN(actual));
AssertKindaEqual(expected, actual);
}
public void NoCalculatorTest()
{
// Arrange
var withCalculator = new TestFigure();
var withoutCalculator = new TestFigure();
var firstCalculator = new Mock <ITryAreaCalculator>(MockBehavior.Default);
firstCalculator.Setup(it => it.TryCalculateArea(withCalculator)).Returns(1);
var areaCalculator = new AreaCalculator();
areaCalculator.Calculators.Add(firstCalculator.Object);
// Act
var calculatedArea = areaCalculator.CalculateArea(withCalculator);
// Assert
Assert.AreEqual(1, calculatedArea);
TestDelegate calculateWithoutCalculator = () => areaCalculator.CalculateArea(withoutCalculator);
var exception = Assert.Throws <AreaCalculationException>(calculateWithoutCalculator);
Assert.AreEqual(withoutCalculator, exception.Figure);
}
public void PriorityUsageTest()
{
// Arrange
var figure = new TestFigure();
var withoutPriority = new Mock <ITryAreaCalculator>(MockBehavior.Strict);
withoutPriority.Setup(it => it.TryCalculateArea(figure))
.Throws(new AssertionException("Should not be called"));
const double ExpectedArea = 10;
var withPriority = new Mock <ITryAreaCalculatorWithPriority>(MockBehavior.Strict);
withPriority.Setup(it => it.TryCalculateArea(figure)).Returns(ExpectedArea);
withPriority.Setup(it => it.GetPriority(figure)).Returns(1);
var areaCalculator = new AreaCalculator();
areaCalculator.Calculators.Add(withoutPriority.Object);
areaCalculator.Calculators.Add(withPriority.Object);
// Act
var calculatedArea = areaCalculator.CalculateArea(figure);
// Assert
Assert.AreEqual(ExpectedArea, calculatedArea);
}
public void Day06a_Test()
{
var input = "1, 1\r\n1, 6\r\n8, 3\r\n3, 4\r\n5, 5\r\n8, 9";
var output = AreaCalculator.GetSizeOfLargestArea(input);
output.Should().Be(17);
}
public void Day06a()
{
var input = File.ReadAllText(".\\Content\\Day06.txt");
var output = AreaCalculator.GetSizeOfLargestArea(input);
output.Should().Be(4398);
}
public void Day06b_Test()
{
var input = "1, 1\r\n1, 6\r\n8, 3\r\n3, 4\r\n5, 5\r\n8, 9";
var output = AreaCalculator.GetSizeOfAreaSurroundedBy(input, 32);
output.Should().Be(16);
}
public void Day06b()
{
var input = File.ReadAllText(".\\Content\\Day06.txt");
var output = AreaCalculator.GetSizeOfAreaSurroundedBy(input, 10000);
output.Should().Be(39560);
}
public void CircleArea()
{
double radius = 1.0;
double result = AreaCalculator.CircleArea(radius);
Assert.True(Math.Abs(result - Math.PI) < double.Epsilon);
}
static void Main(string[] args)
{
//Variables
int areaType = 0;
int squareLength = 0;
int triangleBase = 0;
int triangleHeight = 0;
int rectangleWidth = 0;
int rectangleLength = 0;
int hexagonSide = 0;
Console.WriteLine("Welcome to ACME Inc. - Area Calculator Program");
do
{
Console.WriteLine("Please insert a number that matches what type of area you want to calculate, (1=Square, 2=Triangle, 3=Rectangle, 4=Hexagon)");
areaType = int.Parse(Console.ReadLine());
//Square
if (areaType == 1)
{
Console.WriteLine("Square area calculator:");
Console.WriteLine("Please insert a value of the length of one side");
squareLength = int.Parse(Console.ReadLine());
Console.WriteLine("The area is: {0} ", AreaCalculator.AreaCalc(areaType, squareLength, 0));
}
//Triangle
if (areaType == 2)
{
Console.WriteLine("Triangle area calculator:");
Console.WriteLine("Please insert a value of the Base of the triangle");
triangleBase = int.Parse(Console.ReadLine());
Console.WriteLine("Please insert a value of height of the triangle");
triangleHeight = int.Parse(Console.ReadLine());
Console.WriteLine("The area is: {0} ", AreaCalculator.AreaCalc(areaType, triangleBase, triangleHeight));
}
//Rectangle
if (areaType == 3)
{
Console.WriteLine("Rectangle area calculator:");
Console.WriteLine("Please insert a value of width of the rectangle");
rectangleWidth = int.Parse(Console.ReadLine());
Console.WriteLine("Please insert a value of length of the rectangle");
rectangleLength = int.Parse(Console.ReadLine());
Console.WriteLine("The area is: {0} ", AreaCalculator.AreaCalc(areaType, rectangleWidth, rectangleLength));
}
//Hexagon
if (areaType == 4)
{
Console.WriteLine("Hexagon Area Calculator:");
Console.WriteLine("Please insert a value of the side of the hexagon");
hexagonSide = int.Parse(Console.ReadLine());
Console.WriteLine("The area is: {0} ", AreaCalculator.AreaCalc(areaType, hexagonSide, 0));
}
Console.WriteLine("If you want to exit the program, insert any number greater than 4.");
} while (areaType <= 4);
Console.WriteLine("Thank you for using ACME Inc. - Area Calculator Program.");
}
public void IsValidCalculation()
{
var triangle = new Triangle(5, 12, 13);
Assert.StrictEqual(30, AreaCalculator.CalculateAreaOf(ref triangle));
triangle = new Triangle(0.5, 1.2, 1.3);
Assert.StrictEqual(0.3, AreaCalculator.CalculateAreaOf(ref triangle));
}
public void SixFor2X3Rectangle()
{
var myRectangle = new Rectangle {
Height = 2, Width = 3
};
Assert.AreEqual(6, AreaCalculator.CalculateRectArea(myRectangle));
}
public static void Main(string[] args)
{
var square = new Square(4);
var calculator = new AreaCalculator();
var area = calculator.Calculate(square);
Console.WriteLine($"Square with a side of 4 has an area of {area}");
}
public void TwentyFor4X5RectangleFromSquare()
{
Rectangle newRectangle = new Square();
newRectangle.Width = 4;
newRectangle.Height = 5;
Assert.AreEqual(20, AreaCalculator.CalculateRectArea(newRectangle));
}
public void ToStringTest()
{
//Arrange
AreaCalculator calcTest = new AreaCalculator();
//Act /Assert
Assert.That(calcTest.ToString(), Is.EqualTo("circle,1 triangle_3s,3 "));
}
public void AreaCalculatorTest()
{
//Arrange /Act
AreaCalculator calcTest = new AreaCalculator();
//Assert
Assert.IsNotNull(calcTest.ToString());
}
public void Execute()
{
int w = 4, h = 5;
Rectangle rect = new Square(w, h);
AreaCalculator calc = new AreaCalculator();
Console.WriteLine("prostokąt o wymiarach {0} na {1} ma pole {2}",
w, h, calc.CalculateArea(rect));
}
public void TestSquare3X3()
{
var s = new Square
{
Height = 3
};
Assert.AreEqual(9, AreaCalculator.CalculateArea(s));
}
public static void AreaCalculator()
{
Console.WriteLine("Enter the square side:");
var side = double.Parse(Console.ReadLine());
var calcLibrary = new AreaCalculator();
Console.WriteLine($"Area = {calcLibrary.SquareAreaCalculator(side)}");
Console.ReadKey();
}
public void IsCircleSizeEqual()
{
var radius = 10;
var ExpectedASize = Math.PI * Math.Pow(radius, 2);
var circle = new CircleShape(radius);
var aSize = AreaCalculator.GetAreaSize(circle);
Assert.AreEqual(ExpectedASize, aSize);
}
public void CalculateSquareAreaTest()
{
double triangleArea = 64;
Shape square = new Square(8);
Calculator calculator = new AreaCalculator();
Assert.AreEqual(triangleArea, Math.Round(calculator.Calculate(square), 2));
}
public void CalculateRectangleAreaTest()
{
double triangleArea = 256;
Shape rectangle = new Rectangle(32, 8);
Calculator calculator = new AreaCalculator();
Assert.AreEqual(triangleArea, Math.Round(calculator.Calculate(rectangle), 2));
}
public void CalculateTriangleAreaTest()
{
double triangleArea = 2143.2;
Shape triangle = new Triangle(125, 55, 88.88);
Calculator calculator = new AreaCalculator();
Assert.AreEqual(triangleArea, Math.Round(calculator.Calculate(triangle), 2));
}
public void CalculateCircleAreaTest()
{
double circleArea = 94.985;
Shape circle = new Circle(5.5);
Calculator calculator = new AreaCalculator();
Assert.AreEqual(circleArea, calculator.Calculate(circle));
}
public void AddNewShapeTest()
{
//Arrange
AreaCalculator calcTest = new AreaCalculator();
NewShape newShapeTest = new NewShape();
//Act /Assert
Assert.True(calcTest.AddShape(newShapeTest) == true);
}
public void AddExistingShapeTest()
{
//Arrange
Circle circleTest = new Circle();
AreaCalculator calcTest = new AreaCalculator();
//Act /Assert
Assert.True(calcTest.AddShape(circleTest) == false);
}
public void TestRechthoek5bij3()
{
Rectangle rectangle = new Rectangle {
Height = 5, Width = 3
};
int result = AreaCalculator.CalculateArea(rectangle);
Assert.AreEqual(15, result);
}
public void Testvierkant3bij3()
{
Square square = new Square {
Height = 3
};
int result = AreaCalculator.CalculateArea(square);
Assert.AreEqual(9, result);
}