Learn Test Driven Development in Java

Practice test-driven development in Java by driving a calculator from an accumulator with a default value of zero to a stack-based decimal calculator using red-green-refactor cycles.

Master tdd cycle red green refactor through refactoring and readability improvements, splitting tests by initial state, and driving a calculator and operand stack with focused, descriptive test methods.

Apply test driven development to extend a calculator by adding add and subtract operations, refactor duplicates into a binary operation base class, and implement a dynamic, string-based operation execution.

Explore the solid design principles in object oriented programming through the solid acronym, learn how these five principles keep code clean, maintainable, and easy to extend, and simplify writing tests.

Apply the single responsibility principle by separating circle geometry from rendering, creating a circle class for geometry and a separate rendering class, improving maintainability and testability.

Explore the open/closed principle from SOLID: design classes open for extension but closed for modification, using a UI element interface to add new shapes with minimal changes.

Apply the Liskov substitution principle by replacing a supertype with a subtype without changing program properties, illustrated by a rectangle and square example.

explains the interface segregation principle by advocating small, specific interfaces over a single large one, reducing coupling, improving testability, and clarifying contracts for email and phone gateways.

Apply the dependency inversion principle by introducing interfaces to decouple high level classes from low level implementations, enabling flexible, test driven development and maintainable code.

Explore test anti-patterns such as the singleton and learn how its uncontrolled instantiation and shared state harms test isolation. Replace singletons with interfaces to improve testability and clarify class interactions.

Identify the world test anti-pattern where tests need extensive setup and tightly coupled components. Break dependencies, reduce setup, and test only the needed data to keep tests readable and fast.

Identify the completely mocks anti-pattern, where tests pass but don't validate actual application behavior. Define clear boundaries and scope by specifying which classes and dependencies are tested.

Expose the exceptional test anti-pattern where no assertions exist beyond catching exceptions. Emphasize precise assertions that reveal a method's visible effects and counter false code coverage inferences.

Identify anti-patterns where tests pass most of the time but hide real issues. Isolate concurrency concerns, mock external resources, and break multithreaded code into independent tests to ensure reliable feedback.

Identify the one big test anti-pattern, and split tests into smaller, self-contained cases that each verify a distinct functionality, avoiding interleaving method calls and excessive assertions.

Identify the slow test anti-pattern and keep tests fast to run and fast to fail, avoiding network dependencies or two minute timeouts so developers run tests frequently.

Identify the second class test anti-pattern and keep test code as well-structured and readable as the application code through refactoring in test-driven development.