In software development, ensuring code quality and reliability is critical, especially in large-scale and mission-critical applications. Two foundational practices to achieve this are unit testing and debugging.
• Unit Testing allows developers to test individual units/components of a program to verify that each part functions correctly in isolation.
• Debugging is the process of identifying, analyzing, and fixing bugs or defects in software.
This chapter introduces both concepts, with a strong emphasis on JUnit, the most popular unit testing framework in the Java ecosystem.

Unit Testing is a software testing method where individual units or components of a software are tested independently to ensure that each part functions as expected.
Key Characteristics
• Focuses on smallest testable parts of an application (methods or functions).
• Performed by developers during development.
• Automatable and repeatable.
• Supports Test-Driven Development (TDD).

• Catches bugs early in the development cycle.
• Facilitates refactoring with confidence.
• Helps ensure code correctness.
• Supports agile and continuous integration (CI) practices.
• Documents expected behavior of code.

A unit test typically contains:
• Setup: Preparing the environment or test data.
• Execution: Running the method or unit under test.
• Assertion: Checking the result against the expected output.
• Teardown (optional): Cleaning up after the test.

What is JUnit?
JUnit is a widely used open-source framework for writing and running tests in Java. It is part of the xUnit family of frameworks and supports annotations, assertions, and test runners.
Key Features
• Simple to use.
• Supports annotations like @Test, @BeforeEach, @AfterEach, etc.
• Integration with build tools like Maven and Gradle.
• Works well with IDEs and CI tools like Jenkins.

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
public class CalculatorTest {
@Test
public void testAddition() {
Calculator calc = new Calculator();
assertEquals(5, calc.add(2, 3), "2 + 3 should equal 5");
}
}

TDD is a development approach where you write tests first, then write code to pass those tests.
Cycle
1. Red – Write a failing test.
2. Green – Write minimum code to pass the test.
3. Refactor – Improve the code while keeping the test green.

JUnit allows testing a method with multiple sets of parameters.

@ParameterizedTest
@ValueSource(ints = {1, 2, 3})
void testEvenNumbers(int number) {
assertTrue(number % 2 != 0);
}

Sometimes, components depend on external systems (DB, APIs). Mocking replaces those with dummy implementations.

@Mock
UserRepository userRepository;
@Test
void testFindUser() {
when(userRepository.findById(1)).thenReturn(new User(1, "Alice"));
assertEquals("Alice", userRepository.findById(1).getName());
}

Definition
Code coverage measures the percentage of code executed by your tests.
Tools
• JaCoCo (Java Code Coverage)
• Cobertura
• SonarQube
Goal: Aim for high coverage but not 100% blindly. Some code like error logging may not need to be tested.

What is Debugging?
Debugging is the systematic process of detecting, analyzing, and fixing bugs or issues in software.
Common Debugging Techniques
• Print statements (e.g., System.out.println)
• Logging frameworks (e.g., Log4j, SLF4J)
• IDE Debuggers (breakpoints, watches, stack trace analysis)
• Binary search to narrow down problem areas
• Rubber duck debugging (explain problem aloud)

Basic Steps
1. Set breakpoints in code.
2. Run in debug mode.
3. Use step over, step into, step out features.
4. Watch variables and call stack.
5. Evaluate expressions during runtime.

Testing Best Practices
• Write tests for both positive and negative cases.
• Keep test cases isolated and repeatable.
• Use meaningful test names.
• Keep tests in a separate test directory.
• Run tests in CI pipelines.

Debugging Best Practices
• Reproduce bugs consistently.
• Use version control to compare changes.
• Log important events and exceptions.
• Don't panic—be systematic.

In this chapter, we explored two vital pillars of software quality—unit testing and debugging. We learned:
• The principles and benefits of unit testing, especially using JUnit.
• The structure of tests, common assertions, and annotations.
• The role of TDD and mocking in modern development.
• How to perform effective debugging using IDE tools and techniques.
• Best practices that improve both testing efficiency and debugging clarity.