
Discover why software testing matters for Java developers as you design and implement testing procedures, from unit and integration tests to test driven development, end-to-end tests, and acceptance tests.
Assess your software testing skill level with guided questions and learn to implement a high quality tic tac toe game in Java using tdd, bdd, and key testing frameworks.
Designed for Java developers and architects, this course outlines software testing procedures and prerequisites, taught by Hamadi Sy, to help write high quality software and set up the environment.
Set up the development environment by downloading and unzipping the zip, then install and test MongoDB, WildFly, Eclipse, and the tic tac toe code base.
Configure Eclipse and import the initial Maven project, install the testing plugin and Wildfly server tools, then build to create a deployable war file for Wildfly.
Deploy and test the tic tac toe initial web app by configuring WildFly 27+ and MongoDB from Eclipse, then deploy, run, and verify in localhost 8080.
Summarize the setup of the Java testing environment for the tictactoe game, including Maven, WildFly, Eclipse, JDK, TestNG, and MongoDB, importing and building the Maven project, and deploying to WildFly.
Explore how lack of software testing leads to costly consequences, including safety failures and reputational damage, through case studies like Therac 25, Knight Capital Group, and the millennium bug.
Learn how software testing ensures requirements coverage, delivers fast feedback in agile development, and builds quality—secure, intuitive, maintainable, economical, portable, and reliable—through quality assurance rather than after-the-fact quality checking.
Learn how software testing lowers long-term costs by preventing failures before release, using automated tests, early testing, and focusing on usability, maintainability, efficiency, portability, and reliability.
Define the motivation for unit testing, outline unit testing concepts, mocking external dependencies, and test driven development with tools such as JUnit, TestNG, Hamcrest, AssertJ, Mockito, JMockit, and JaCoCo.
Learn how to implement unit tests for a tic tac toe move class using JUnit, including setting up the project, adding tests, and running assertions with Maven.
Learn to write JUnit tests that verify constructor-set fields id, x, y, and axis values (horizontal 1, vertical 2); use @Before/@After to centralize setup.
Explore JUnit unit testing basics, including asserting allowed characters with containsAll and size checks, using rules like temporary folder and TestName, and understanding beforeclass and afterclass execution.
TicTacToeGameRoundTest
Learn to use hamcrest with JUnit for readable assertions, import matchers, and write custom hamcrest matchers like MyHamcrestMatcher; explore contains, containsInAnyOrder, and hasSize.
Explore using AssertJ as an alternative to Hamcrest for unit testing, including Maven setup and the fluent assertThat API to test TicTacToeGameMove, checking size and contents X and O.
Implement a MongoDB-backed TicTacToeGameState wrapper using Jongo to perform create, read, update, and delete operations, with safe exception handling, and prepare for Mockito-based tests.
Test the game's persistence layer by mocking MongoDB interactions with Mockito, using JUnit and hamcrest to verify save and clear operations, and prepare for future integration.
TicTacToeGameStateTest
Learn to measure code coverage with EclEmma and JaCoCo in Eclipse and Maven, generate HTML reports, view highlighted coverage details, and compare workflows for Java unit testing.
Master unit testing basics with mocks and given-when-then, and apply JUnit, TestNG, Hamcrest, AssertJ, Mockito, eclEmma, and Jacoco to test game move and state coverage.
Apply test driven development by writing tests before code, using red green refactoring to guarantee test coverage, executable documentation, and quality checking while implementing tic tac toe.
Apply test-driven development to implement a 3x3 tic tac toe game using JUnit and Hamcrest, ensuring valid coordinates and single-field updates through red-green-refactor.
Implement the second requirement in test driven development by tracking the next player. Enforce the first move is x, implement getNextPlayer, and alternate between x and o.
Apply test-driven development to implement the third requirement: track the game result by checking horizontal and vertical lines and returning a winner or in-progress state via isWin.
Implement R3 to track the game result for diagonal wins and draws by iterating cells, validating lastPlayer, and using red and green phases.
Implement the fourth requirement to persist game moves using a mock database wrapper, verify state initialization in the constructor, and ensure the save method is called and throws on failure.
Implement r4 save to database by unit testing move saves, with an auto-incremented id, lastPlayer, and a clear call at instantiation, while mocking database calls.
Apply test driven development to finish the game backend, verify coverage with the EclEmma tool in Eclipse, and discuss regression testing, equals and hashCode, and Lombok benefits.
Learn how test driven development writes tests before implementation, with red green refactoring and mocked database calls, for executable requirements and high test coverage.
Explore integration testing motivation, strategies (top-down, bottom-up, ad hoc), and how components within a subsystem interact, test configurations, and environments while validating mocks and real databases for a game.
Integrate a MongoDB database into a test-driven tic tac toe game, validating persisted moves with an integration test and achieving full test coverage.
Explore smoke testing for UI and database integration by deploying a Java application, verifying the web page is reachable, and confirming database connectivity.
Explore integration testing by evaluating interactions between subsystems, using top-down, bottom-up, and ad hoc strategies; perform smoke and sanity tests and verify database and website availability after deployment.
Learn the motivation and main purpose of system testing, differentiate it from unit and integration testing, and implement GUI-based system tests using selenium to validate functional requirements.
Implement a graphical user interface with JSF to support system testing of a tic-tac-toe game, using a 3x3 grid, action listeners, backing bean logic, and user messages.
TicTacToeGameUiTest
Run a gui based system test with selenium to verify a tic tac toe game, manage database and wildfly, and extend tests for horizontal, vertical, diagonal lines and end-to-end testing.
Explore end-to-end testing, validating the data flow from the UI to the database, including server configuration, log review, and manual checks beyond automated tests.
Learn non-functional testing across usability, maintainability, efficiency, portability, and reliability, using personas, reviews, cross-browser checks, and automated performance and stress tests to ensure fault tolerance.
Define system testing as verifying user requirements through functional testing, contrasted with unit and integration tests. Demonstrate a jsf-based browser GUI and selenium-based system testing, with next acceptance testing.
Explore acceptance testing: define stakeholders and acceptance criteria, use behavior driven development to write executable, readable stories and scenarios, and validate with Selenide and Selenium frameworks like Cucumber and JBehave.
Implement bdd acceptance tests using cucumber and selenium in a maven project, configure the cucumber runner and features, implement steps, and generate cucumber reports.
Implement bdd acceptance tests with cucumber and selenium, using given/when steps and cucumber before hooks, then deploy the game, start MongoDB, and verify green reports.
narrative, scenario, step
Demonstrates a bdd acceptance test with jbehave and selenide, producing html reports, simulating failures, and adopting selenide for cleaner browser interactions in cucumber tests with htmlUnit.
Explore acceptance testing to show sponsors features work before release, using BDD with stories and given, when, then steps to produce executable criteria exportable as HTML or PDF.
Master software testing fundamentals from unit to acceptance tests, with mocking and stubbing, TDD and BDD, and tools like JUnit, TestNG, Selenium, Selenide, Maven, and CI.
Master the art of software quality assurance by developing a robust Tic-Tac-Toe application from the ground up using Java and Test-Driven-Development. This comprehensive course bridges the gap between basic coding and professional-grade engineering by focusing on the industry's most critical testing methodologies. You will not only learn how to write code but how to ensure its reliability and maintainability through rigorous verification processes.
Your quality assurance toolkit will encompass the following essential software testing methodologies:
- Test Driven Development (TDD)
- Behavior Driven Development (BDD)
- Unit testing
- Integration testing
- Smoke testing
- System testing
- End-To-End testing
- Regression testing
- Acceptance testing
- Non functional tests
You will gain comprehensive, hands-on experience with the following industry-leading testing frameworks:
- Junit
- Hamcrest
- Mockito
- Selenide
- Cucumber
- JaCoCo
You will broaden your technical versatility by gaining hands-on experience with these widely-used alternative frameworks:
- TestNG
- AssertJ
- Jmockit
- Selenium
- Jbehave
- EclEmma
Beyond the technical implementation, this course empowers you to:
- Articulate complex testing concepts and quality criteria persuasively to stakeholders.
- Understand the economic and technical necessity of automated software testing.
- Build a professional portfolio that demonstrates a deep commitment to software quality assurance craftsmanship.
Elevate your engineering career by mastering professional testing strategies and building a high-quality portfolio that proves your technical excellence.