Welcome to the first lesson of our course on Test Driven Development (TDD) in Java using JUnit. TDD is an iterative software development process where tests are written prior to developing the actual functionality. This approach helps developers focus on the requirements first, leading to more reliable and maintainable code.

In this lesson, we'll introduce you to the essential elements of TDD, including the Red-Green-Refactor cycle, which serves as the core structure of this methodology. We'll be utilizing tools specially suited for Java: JUnit, a popular testing framework that is robust and integrates well with Java. These tools are excellent for defining and running tests in Java. Let's start by investigating TDD’s core components with a hands-on example.

The TDD process begins with writing a test that fails, marking the "Red" phase. This step allows you to crystallize what the code should achieve before writing the actual implementation. Let's write a test for a sum method that should eventually add two numbers.

Create a file named MathTest.java in the tests directory:

Java
Copy to clipboard
1public class MathTest {
2
3    @Test
4    public void testSumAddsTwoNumbersCorrectly() {
5        Math math = new Math();
6        assertEquals(5, math.sum(2, 3));
7    }
8}

This test script:

• Uses @Test to denote a single test case.
• Instantiates a Math class.
• Calls the sum method and checks if the result equals 5.
• assertEquals(expected, actual) verifies that the actual result matches the expected value.

This immediate failure highlights the importance of the "Red" phase in TDD, as it confirms that our test is effectively identifying missing features and setting clear implementation goals.

Expected output:

error
Copy to clipboard
1MathTest.java:10: error: cannot find symbol
2        assertEquals(5, math.sum(2, 3));
3                            ^
4  symbol:   method sum(int,int)
5  location: variable math of type Math
61 error

This is a normal failure, illustrating that our test is effectively identifying unimplemented features.

Our next objective is to write the simplest code possible to make the test pass — the "Green" step. In TDD, this means implementing minimal functionality to satisfy the test conditions. Let’s define the sum method in a new file Math.java under the src directory:

Java
Copy to clipboard
1public class Math {
2    public int sum(int a, int b) {
3        return 5;
4    }
5}

This version seems superficial since it doesn't actually add two numbers, but it highlights the TDD focus on passing the test with minimal implementation. By doing so, we've met the test condition.

Re-running the test will produce the following result:

Java
Copy to clipboard
1> Task :test
2
3MathTest > testSumAddsTwoNumbersCorrectly() PASSED

Seeing the test pass confirms our code meets the given test scenario. Future test cases will guide us to refine the implementation.

The last step, "Refactor," involves refining the code while ensuring existing behavior remains unchanged. In this instance, our sum function is quite efficient, but we can improve our test readability by separating the execution from the assertion. This involves extracting the output of the sum function into a variable:

Java
Copy to clipboard
1public class MathTest {
2
3    @Test
4    public void testSumAddsTwoNumbersCorrectly() {
5        Math math = new Math();
6        int result = math.sum(2, 3);
7        assertEquals(5, result);
8    }
9}

This small refactoring illustrates how minor adjustments can enhance clarity, as it isolates the act (execution) from the assert (verification). When dealing with more complex functions, refactoring might involve breaking down a function, renaming variables for clarity, or improving test readability. Our Red-Green-Refactor cycle for this example is now complete.

In this lesson, we've explored the basic principles of TDD using the Red-Green-Refactor workflow with Java and JUnit. Let's recap:

• Red: Start by writing a test that initially fails.
• Green: Add minimal code to pass the test.
• Refactor: Improve the code, ensuring all tests still pass.

As you practice TDD in upcoming exercises, you’ll reinforce your understanding and gain the ability to craft robust, maintainable Java code. Remember to apply these concepts in your coding routine to boost code quality and reliability.

With this foundation, you’re prepared to tackle more complex scenarios in future lessons. Continue honing your skills to excel in TDD practices using Java.