Welcome to your first lesson in this course dedicated to practicing Test Driven Development (TDD) using Java and JUnit. Test Driven Development is an effective approach that emphasizes writing tests before coding. This methodology helps you design your application with testing as a core element, ensuring each component behaves as expected. In this lesson, you'll learn the fundamentals of TDD along with the Red-Green-Refactor cycle, understanding their roles in creating robust and maintainable code.

This course involves hands-on practice, where you'll receive requirements through tests incrementally. Your task is to implement code that makes each test pass, mirroring a real-world TDD environment. Consider this course guide as your pair programmer, providing you with test-driven prompts to enhance your skills as you advance.

As a reminder, the Red-Green-Refactor cycle is central to TDD, guiding your development process:

• Red: Start by writing a failing test to define the next step.
• Green: Implement just enough code to pass the test, focusing on functionality.
• Refactor: Optimize the code for clarity and efficiency without changing its behavior.

Below, you’ll find the detailed requirements and corresponding test cases for the calculateDiscount function.

Each requirement focuses on a specific behavior the function must fulfill, guiding you through the TDD process step by step.

• Description: The function must correctly apply a percentage-based discount to an original price.
• Test Case:

  Java
  Copy to clipboard
  1@Test
  2public void testCalculateDiscountAppliesCorrectDiscount() {
  3    // Arrange
  4    Math math = new Math();
  5    double originalPrice = 100;
  6    double discountPercentage = 20;
  7    double expectedDiscountedPrice = 80;
  8
  9    // Act
  10    double result = math.calculateDiscount(originalPrice, discountPercentage);
  11
  12    // Assert
  13    assertEquals(expectedDiscountedPrice, result, 0.01);
  14}

  The test ensures that the function applies the discount correctly and tolerates minor floating-point deviations.

• Description: The function should return the original price when the discount percentage is 0.
• Test Case:

  Java
  Copy to clipboard
  1@Test
  2public void testCalculateDiscountReturnsOriginalPriceWhenDiscountIsZero() {
  3    // Arrange
  4    Math math = new Math();
  5    double originalPrice = 50;
  6    double discountPercentage = 0;
  7
  8    // Act
  9    double result = math.calculateDiscount(originalPrice, discountPercentage);
  10
  11    // Assert
  12    assertEquals(originalPrice, result, 0.01);
  13}

  This test checks that with a 0% discount, the function should correctly maintain the original price.

• Description: The function must accurately handle decimal percentages in discount calculations and round the result to two decimal places.
• Test Case:

  Java
  Copy to clipboard
  1@Test
  2public void testCalculateDiscountHandlesDecimalDiscountsCorrectly() {
  3    // Arrange
  4    Math math = new Math();
  5    double originalPrice = 100;
  6    double discountPercentage = 33.333;
  7    double expectedDiscountedPrice = 66.67;
  8
  9    // Act
  10    double result = math.calculateDiscount(originalPrice, discountPercentage);
  11
  12    // Assert
  13    assertEquals(expectedDiscountedPrice, result, 0.01);
  14}

  It tests the function's ability to handle decimal discounts and verify rounding to two decimal points for accuracy.

• Description: The function should not accept negative prices and must throw an error if encountered.
• Test Case:

  Java
  Copy to clipboard
  1@Test
  2public void testCalculateDiscountShouldThrowErrorForNegativePrices() {
  3    // Arrange
  4    Math math = new Math();
  5    double originalPrice = -50;
  6    double discountPercentage = 10;
  7
  8    // Act & Assert
  9    assertThrows(IllegalArgumentException.class, () -> {
  10        math.calculateDiscount(originalPrice, discountPercentage);
  11    });
  12}

  This test is crucial for validating that the function rejects invalid negative price inputs by raising an exception.

• Description: The function should not accept discount percentages greater than 100% and must throw an error in such cases.
• Test Case:

  Java
  Copy to clipboard
  1@Test
  2public void testCalculateDiscountThrowsErrorForDiscountsGreaterThan100Percent() {
  3    // Arrange
  4    Math math = new Math();
  5    double originalPrice = 100;
  6    double discountPercentage = 110;
  7
  8    // Act & Assert
  9    assertThrows(IllegalArgumentException.class, () -> {
  10        math.calculateDiscount(originalPrice, discountPercentage);
  11    });
  12}

  It examines the method’s behavior when provided with excessive discount percentages that logically exceed the threshold.

Looking ahead to the practice exercises, you will have the opportunity to ensure all tests pass while practicing the Red-Green-Refactor cycle using Java and JUnit. Your implementation may differ from the provided solutions, and that's perfectly acceptable. Each practice session will begin from a solution foundation, allowing you to compare your approach with the guided solution and develop your features to ensure test success.

As you undertake these exercises, remember to engage in the Red-Green-Refactor cycle. Each test I provide serves as the "Red" phase, marking the next step to achieve. Your task is to transition through the "Green" phase by making the tests pass and then enter the "Refactor" phase to enhance your code's clarity and maintainability while confirming that all tests remain successful.