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))); }