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);
}
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 IntegrationTest()
{
// Arrange
var circle = new Circle(1);
var customFigure = new TestFigure();
var innerComposite = new CompositeFigure(new FigureBase[] { circle, customFigure });
var emptyComposite = new CompositeFigure(Array.Empty <FigureBase>());
var triangle = new ThreeLinesTriangle(2.5, 3, 4);
var composite = new CompositeFigure(new FigureBase[] { innerComposite, emptyComposite, triangle });
var circle2 = new Circle(2);
var customCalculatorNotUsed = new Mock <ITryAreaCalculator>(MockBehavior.Default);
customCalculatorNotUsed.Setup(it => it.TryCalculateArea(customFigure))
.Throws(new AssertionException("Should not be called"));
var customCalculator = new Mock <ITryAreaCalculatorWithPriority>(MockBehavior.Default);
customCalculator.Setup(it => it.TryCalculateArea(customFigure)).Returns(15.2);
customCalculator.Setup(it => it.GetPriority(customFigure)).Returns(100);
var areaCalculator = new AreaCalculator();
areaCalculator.Calculators.Add(new CompositeAreaCalculator(areaCalculator));
areaCalculator.Calculators.Add(new TriangleAreaCalculator());
areaCalculator.Calculators.Add(new RightAngleTriangleCalculator());
areaCalculator.Calculators.Add(new CircleAreaCalculator());
areaCalculator.Calculators.Add(customCalculatorNotUsed.Object);
areaCalculator.Calculators.Add(customCalculator.Object);
// Act
var compositeArea = areaCalculator.CalculateArea(composite);
var triangleArea = areaCalculator.CalculateArea(triangle);
var circle2Area = areaCalculator.CalculateArea(circle2);
// Assert
const double ExpectedTriangleArea = 3.7453095666446585;
var expectedCompositeArea = Math.PI + 15.2 + ExpectedTriangleArea;
Assert.AreEqual(expectedCompositeArea, compositeArea, DoubleEquality.Epsilon);
Assert.AreEqual(ExpectedTriangleArea, triangleArea, DoubleEquality.Epsilon);
Assert.AreEqual(4 * Math.PI, circle2Area, DoubleEquality.Epsilon);
}
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 Testvierkant3bij3()
{
Square square = new Square {
Height = 3
};
int result = AreaCalculator.CalculateArea(square);
Assert.AreEqual(9, result);
}
public void TestRechthoek5bij3()
{
Rectangle rectangle = new Rectangle {
Height = 5, Width = 3
};
int result = AreaCalculator.CalculateArea(rectangle);
Assert.AreEqual(15, result);
}
public void TestMethod4()
{
AreaCalculator newshape = new AreaCalculator();
Assert.AreEqual(5 * 6 * Math.PI, newshape.CalculateArea(new Ellipse(5, 6)));
//This solution goes beyond to make both the Ellipse and the Circle classes implement a 'Shape' interface that declares the 'Area' method.
//We also have the end client (AreaCalculator) that can never know what type it is being created for; it only knows that a shape is being passed.
//This way, the classes are all loosely coupled and compliant with the LSP, OCP, SRP, ISP and DIP.
}
public void TestSquare3X3()
{
var s = new Square
{
Height = 3
};
Assert.AreEqual(9, AreaCalculator.CalculateArea(s));
}
static void Main(string[] args)
{
Rectangle rect = new Square();
rect.Width = 10;
rect.Height = 20;
var result = AreaCalculator.CalculateArea(rect);
Console.WriteLine($"{result} is incorrect as the code invoked the CalculateArea.CalculateArea(Recangle rect) method");
}
public void TestRectangleArea()
{
var r = new Rectangle
{
Height = 2,
Width = 3
};
Assert.AreEqual(6, AreaCalculator.CalculateArea(r));
}
public void Calculate_Area_ReturnsArea()
{
//Arrange
IAreaCalculator _calculator = new AreaCalculator();
//Act
decimal area = _calculator.CalculateArea(12, 6);
//Assert
Assert.IsTrue(area > 0);
}
public void Test4X5SquareArea()
{
Rectangle r = new Square();
r.Height = 5;
r.Width = 4;
// FAILED!!!
// Assert.AreEqual failed. Expected:<20>. Actual:<16>.
Assert.AreEqual(20, AreaCalculator.CalculateArea(r));
}
public void CalculateArea_RectanglefromSquare()
{
//This is a violation of LSP since square is not substituble for its parent rectangle. This test will fail.
LSPRectangle newRectangle = new LSPSquare();
newRectangle.Height = 4;
newRectangle.Width = 6;
var result = AreaCalculator.CalculateArea(newRectangle);
Assert.AreEqual(24, result);
}
static void Main(string[] args)
{
// Creator
Console.WriteLine(">Creator");
B b = new B();
b.useA();
// Information expert
Console.WriteLine("\n>Information Expert");
Car car = new Car();
car.run();
car.dispalySpeed();
// Controller
Console.WriteLine("\n>Controller");
OneClickBuyHandler oneClickBuyHandler = new OneClickBuyHandler();
oneClickBuyHandler.oneClickBuy(new List <string> {
"item1", "item2"
});
// Polymorphism
Console.WriteLine("\nPolymorphism");
List <IAnimal> animals = new List <IAnimal> {
new Cat(), new Dog(), new Doge()
};
foreach (IAnimal animal in animals)
{
animal.eats();
Console.WriteLine(animal.makeSound() + "\n");
}
// Protected Variations (Demeter's Law)
Console.WriteLine("\n>Protected Variations (Demeter's Law)");
Dinner dinner = new Dinner();
dinner.cook();
//
int w = 4, h = 5;
Rectangle rect = new Square()
{
Width = w, Height = h
};
AreaCalculator calc = new AreaCalculator();
Console.WriteLine("prostokąt o wymiarach {0} na {1} ma pole {2}", w, h, calc.CalculateArea(rect));
}
public void TestofeenvierkantdoorkangaanalseenRechthoek()
{
Rectangle rectangle = new Square();
rectangle.Height = 4;
rectangle.Width = 6;
var result = AreaCalculator.CalculateArea(rectangle);
Assert.AreEqual(24, result);
// nee is 36 omdat je in Square aabgeeft dat de Height en Width
// dezelfde is dus als je dan 6 * 6 doet om de area van een rechthoek te vinden klopt het niet en is het niet volgens Liskov
}
public void Calculate_Volume_ReturnsArea_Logic_Test()
{
//Arrange
IAreaCalculator _calculator = new AreaCalculator();
decimal length = 15, width = 20;
//Act
decimal volume = _calculator.CalculateArea(length, width);
//Assert
Assert.IsTrue(volume == (length * width), "Area correctly calculated");
}
public static void Main()
{
int w = 4, h = 5, size = 7;
Shape rect = new Rectangle()
{
Width = w, Height = h
};
Shape square = new Square()
{
Size = size
};
AreaCalculator calc = new AreaCalculator();
Console.WriteLine(
"Prostokąt o wymiarach {0} na {1} ma pole {2}",
w, h, calc.CalculateArea(rect)
);
Console.WriteLine(
"Kwadrat o wymiarach {0} na {0} ma pole {1}",
size, calc.CalculateArea(square)
);
}
static void Main(string[] args)
{
IMessenger volEnglishMessenger = new VolEnglishMessenger();
IMessenger areaEnglishMessenger = new AreaEnglishMessenger();
IAreaCalculator areaCalc = new AreaCalculator();
IVolumeCalculator volumeCalc = new VolumeCalculator();
IShapeFactory sf = new ShapeFactory();
IList <IArea> iArea = new List <IArea>();
iArea.Add((IArea)sf.CreateShape("Circle", 1));
IList <IVolume> iVolume = new List <IVolume>();
iVolume.Add((IVolume)sf.CreateShape("Cube", 5));
areaEnglishMessenger.Message(areaCalc.CalculateArea(iArea));
volEnglishMessenger.Message(volumeCalc.CalculateVolume(iVolume));
Console.ReadKey();
}
public void Calculate_Area_ReturnsDecimalAreas()
{
//Arrange
IAreaCalculator _calculator = new AreaCalculator();
int precision = 0;
//Act
decimal area = _calculator.CalculateArea(12.000000000000001m, 6.97m);
//Checks how many decimal places the calculation is accurate too
while (area * (decimal)Math.Pow(10, precision) !=
Math.Round(area * (decimal)Math.Pow(10, precision)))
{
precision++;
}
//Assert
Assert.IsTrue(precision >= 10, "Accurate to at least {0} decimal places", precision);
}
public void ShowDemo()
{
var myRectangle = new Rectangle {
Height = 2, Width = 3
};
var result = AreaCalculator.CalculateArea(myRectangle);
Assert.AreEqual(6, result);
var mySquare = new Square {
Height = 3
};
result = AreaCalculator.CalculateArea(mySquare);
Assert.AreEqual(9, result);
Rectangle newRectangle = new Square();
newRectangle.Height = 4;
newRectangle.Width = 6;
result = AreaCalculator.CalculateArea(newRectangle);
Assert.AreEqual(24, result);
}
public void CalculatorsOrderPreserveTest()
{
// Arrange
var figure = new TestFigure();
var firstCalculator = new Mock <ITryAreaCalculator>(MockBehavior.Strict);
firstCalculator.Setup(it => it.TryCalculateArea(figure)).Returns(1);
var secondCalculator = new Mock <ITryAreaCalculator>(MockBehavior.Strict);
secondCalculator.Setup(it => it.TryCalculateArea(figure)).Returns(2);
var areaCalculator = new AreaCalculator();
areaCalculator.Calculators.Add(firstCalculator.Object);
areaCalculator.Calculators.Add(secondCalculator.Object);
// Act
var calculatedArea = areaCalculator.CalculateArea(figure);
// Assert
Assert.AreEqual(1, calculatedArea);
}
public void TestMethod3()
{
AreaCalculator newshape = new AreaCalculator();
Assert.AreEqual(5 * 5 * Math.PI, newshape.CalculateArea(new Circle(5)));
}