Game testing is a critical phase in the development of any video game, ensuring that the final product is polished, functional, and enjoyable for players. However, with the complexity of modern games, knowing what to test and how to structure testing tasks can be overwhelming. One effective method for organizing and executing game testing is the “When This, Then That” approach. This approach helps testers create clear, actionable tasks that ensure comprehensive coverage of all game elements. In this article, we’ll explore what to test in a game, how to apply the “When This, Then That” approach, and best practices for effective game testing.

What to Test in a Game?

Game testing involves evaluating a wide range of elements to ensure the game functions as intended and provides a seamless player experience. Below are the key areas to focus on when testing a game:

1. Functionality Testing

• Objective: Ensure all game features and mechanics work as intended.
• What to Test:
• Game controls (e.g., keyboard, mouse, controller inputs).
• Menus, buttons, and UI elements.
• Game mechanics (e.g., jumping, shooting, driving).
• Progression systems (e.g., level transitions, quest completion).
• Example: Test if the “Jump” button makes the character jump as expected.

2. Performance Testing

• Objective: Evaluate the game’s performance under various conditions.
• What to Test:
• Frame rate and stability.
• Load times for levels and assets.
• Memory usage and potential leaks.
• Performance on different hardware configurations.
• Example: Test if the game maintains a consistent 60 FPS during intense action scenes.

3. Compatibility Testing

• Objective: Ensure the game works across different platforms and devices.
• What to Test:
• Cross-platform functionality (e.g., PC, consoles, mobile).
• Screen resolutions and aspect ratios.
• Compatibility with different operating systems and drivers.
• Example: Test if the game runs smoothly on both Windows and macOS.

4. Localization Testing

• Objective: Verify that the game is properly adapted for different regions and languages.
• What to Test:
• Translated text and voiceovers.
• Cultural appropriateness of content.
• Date, time, and currency formats.
• Example: Test if the German translation fits within the UI without overflow.

5. Multiplayer and Network Testing

• Objective: Ensure smooth online gameplay and server stability.
• What to Test:
• Latency and synchronization in multiplayer modes.
• Server load and stability under stress.
• Matchmaking and lobby functionality.
• Example: Test if players can join a multiplayer match without delays.

6. Usability and Accessibility Testing

• Objective: Ensure the game is user-friendly and accessible to all players.
• What to Test:
• Intuitive UI/UX design.
• Accessibility features (e.g., colorblind modes, subtitles).
• Tutorials and onboarding processes.
• Example: Test if the game’s tutorial effectively teaches new players the basics.

7. Security Testing

• Objective: Identify vulnerabilities that could compromise the game or player data.
• What to Test:
• Protection against cheating and hacking.
• Secure storage of player data.
• Encryption of network communications.
• Example: Test if player accounts are secure from unauthorized access.

The “When This, Then That” Approach

The “When This, Then That” approach is a structured way to create test cases by defining a specific condition (When This) and the expected outcome (Then That). This method ensures clarity, repeatability, and thorough coverage of test scenarios.

How to Create Tasks Using the “When This, Then That” Approach

1. Identify the Scenario:
2. Define the specific condition or action to be tested.
3. Example: “When the player presses the ‘Attack’ button…”
4. Define the Expected Outcome:
5. Specify what should happen when the condition is met.
6. Example: “…then the character performs an attack animation.”
7. Document the Test Case:
8. Write the test case in a clear and concise format.
9. Example: “When the player presses the ‘Attack’ button, then the character performs an attack animation.”
10. Execute the Test:
11. Perform the action and observe the outcome.
12. Compare the actual result with the expected result.
13. Report the Findings:
14. Document any discrepancies or bugs.
15. Provide detailed steps to reproduce the issue.

Examples of “When This, Then That” Test Cases

1. Functionality Testing

• Test Case: When the player collects a power-up, then their health increases by 20%.
• Execution: Collect a power-up and check if the health bar updates correctly.

2. Performance Testing

• Test Case: When the game is running on a low-end PC, then the frame rate remains above 30 FPS.
• Execution: Run the game on a low-end PC and monitor the frame rate.

3. Localization Testing

• Test Case: When the game language is set to French, then all menu text is displayed in French.
• Execution: Change the language settings and verify the menu text.

4. Multiplayer Testing

• Test Case: When two players join a multiplayer match, then both players spawn in the correct locations.
• Execution: Join a match with another player and check spawn points.

5. Usability Testing

• Test Case: When a new player starts the game, then the tutorial explains the basic controls.
• Execution: Start a new game and verify the tutorial content.

Best Practices for Using the “When This, Then That” Approach

1. Be Specific: Clearly define the condition and expected outcome to avoid ambiguity.
2. Cover Edge Cases: Include test cases for unusual or unexpected player actions.
3. Prioritize Critical Scenarios: Focus on high-impact areas like core gameplay and performance.
4. Use Automation: Automate repetitive test cases to save time and improve efficiency.
5. Collaborate with Developers: Work closely with developers to ensure test cases align with design intentions.
6. Iterate and Improve: Continuously update test cases based on feedback and new findings.

Tools to Support Game Testing

1. TestRail: For organizing and managing test cases.
2. Jira: For tracking bugs and issues.
3. Unity Test Framework: For automated testing in Unity games.
4. OBS Studio: For recording gameplay and capturing bugs.
5. Postman: For testing game APIs and backend services.

Conclusion

Game testing is a multifaceted process that requires careful planning and execution. By understanding what to test and using the “When This, Then That” approach, testers can create clear, actionable tasks that ensure comprehensive coverage of all game elements. This structured method not only improves the efficiency of testing but also enhances communication between testers and developers, leading to a higher-quality final product.

In the competitive gaming industry, thorough testing is essential to delivering a polished and enjoyable experience for players. By adopting the strategies and best practices outlined in this article, you can ensure your game stands out and meets the expectations of your audience.