Test Objectives:

• Ensuring the quality of the game.
• Identifying, documenting, and forwarding bugs to the developers.
• Testing technical functionalities, compatibilities and multiplayer features.
• Uncovering design flaws and identifying aesthetic inconsistencies.
• Verifying the implemented game mechanics for functionality and user-friendliness (usability).
• Fixing errors and performing retests (regression tests).
• Analyzing gameplay flow, balance, and overall enjoyment.
• Ultimate Goal: The game should be ready for release and contain no or as few errors as possible that could impair its functionality. It also should provide a enjoyable and fun experience for a wide player base.

Test Types:

Functionality Tests:

Testing specific functions of the game.

Example:

• Basic Horizontal Movement to the Left

  • Prerequisite: The game is started, and the character is standing still.
  • Action: Press the "A" key (←).
  • Expected Result: The player moves to the left as long as the path is clear.

  Bug Example: The player can walk through a wall at Location X, which should block the path unless Pressure Plate Y is activated.

  Reproduction: Go to Location X, do not activate Pressure Plate Y, and check if passing through is possible.

Document success or failure, and report any bugs to the developers. Retest after fixes have been applied.

Balancing and Usability Tests:

Assessing user-friendliness, game flow, and difficulty level.

• Goal: Ensure players can navigate the game intuitively and without excessive frustration.
• Execution: Initially conducted internally, later supplemented by beta tests with questionnaires or targeted player feedback.

Performance Tests:

Evaluating how the game is running with factors such as:

• Loading times (e.g., under 5 seconds).
• Stability (no crashes or memory leaks).
• Minimum FPS (e.g., 60 FPS on target hardware).

Explorative Tests:

Unscripted tests where testers play without a predefined plan to uncover unexpected bugs and weaknesses.

• Focus: Combining unusual actions, identifying terrain glitches, or detecting incorrect behaviors during atypical inputs.

Edge-Case Tests:

Testing extreme situations or unusual player actions, such as:

• Pressing all buttons simultaneously.
• Intentionally trying to "break" the game, doing stuff your not supposed to do (e.g., trying to push a box through a wall or trying to leave the level boundaries).

Compatibility Tests:

Verifying if the game runs on common hardware, operating systems, or browsers.

• Examples:
  • Ensuring functionality on various operating systems (Windows, macOS).
  • Browser tests (Chrome, Firefox, Edge, Safari).

Error Types:

Error types categorize the issues that occur based on their specific characteristics, the way they manifest, and the areas of the game they affect. Errors can belong to more than one Type.

Functional Errors:

Functions that do not work as intended, such as:

• Missing or incorrect control responses.
• Faulty collision detection (e.g., the player can walk through walls).

Physic Errors:

Physics behave the wrong way. (e.g. a Box flys against Gravity)

Graphical Errors:

Visual problems, such as:

• Missing or incorrect textures.
• Glitchy or inaccurate animations.
• Graphical artifacts, like flickering or distorted objects.

Audio Errors:

• Missing sounds (e.g., shooting noises).
• Incorrect sounds (e.g., wrong audio, distorted audio ).
• Volume problems (e.g., too loud or too quit).

Performance Errors:

Issues with game performance, such as:

• Low FPS (frames per second).
• Lags or delays.

Logic and Gameplay Errors:

Situations where certain actions or events don’t make sense from a story or gameplay perspective.

Error prioritization

Error prioritization ranks the issues based on their severity and impact on the game, helping to determine which errors need immediate attention and which can be addressed later.

Critical

Errors that break the game or make it unplayable. These include crashes, "gamebreaking" bugs, or situations where the player can no longer progress. Fixing These Errors is always first Priority.

High

These errors significantly affect important gameplay mechanics or features, without making the game completely unplayable.

Example: Important controls do not always work correctly

Should be fixed as soon as possible.

Normal

These errors disturb the gameplay experience, but the core functions are still usable.

Example: Textures load incorrectly, animations are inaccurate, an item behaves inconsistently.

Fixing is important, but not urgent.

Low

Errors that do not interfere with the game flow or appear only in rare cases.

Example: Typos in some Text, Menu.

Fixing should be done at some point but it is not urgent at all

Documentation

For all tests, reports and documentation will be created. These will be structured, versioned and uploaded to OpenProjekt or GitLab. Depending on the development progress, test cases and procedures will be adjusted.

For each test case, a report will be created that includes the following points:

• Test Type
• Test Name
• Description
• Results
• In case of errors: added Bug Report
• Possible screenshots/videos for documenting anomalies

Bug Report

Prioritisation: [Priority of the Bug]

Category: [Category of Bug]

Title: [Name of Bug]

Description:

[Description of what is wrong. expected behavior vs actual behavior.]

Visual Description:

[If necessary, attach screenshots or videos of the bug.]

Reproduction:

[Step to Step Description to Reproduce Bug]

Additional Infos:

[Add any other relevant information that doesn't fit the other categories.]

Testing Approach During the Development Process:

Pre-Alpha: Early Development and Prototyping Phase (Iteration 1-2)

Goal:

• Support the developer in ensuring core functionality.
• Core mechanics and pyhsics should working properly, even if they are not fully polished.
• The basic game prototype should run stable, with key challenges identified and documented.

Approach:

• Describe and document test cases.

• Test individual mechanics and functions, create reports, and provide feedback and improvement suggestions to the developer.

• Retest

• (Document and describe non-functional requirements, such as performance, usability, and compatibility.)

involved Persons:

Tester

Developer (while Developing)

maybe Gamedesigner (for changes in gamedesign)

Final Iteration:

Goals:

• Ensure that all menus, final features, and overall game presentation meet the quality standard required for release.

• Ensure that all levels are finished and providing the players a enjoyable experience.

• Verify that no major issues remain and that the game offers a polished, user-friendly experience.

• Conduct final compatibility tests, stress tests, and ensure all non-functional requirements are fulfilled.

Menu testing

Navigation: Test that all menu options are accessible and lead to the correct screens or functionalities.

Functionality: Verify that buttons working as intended

Error Handling: Test for potential edge cases, such as: Selecting an unavailable option.

Final gameplay testing

Gameflow: Ensure the game can be completed from start to finish without crashes or game-breaking bugs.

Features: Ensure that all Features of the game are working as intended. For example triggerplates, Storyteller-Alien, timelimit.

Sounddesign: Ensure sounddesign is working in the right way. For example: Correct volume, correct triggers.

Performance and optimization

Loading Times: Ensure that menus, levels load within an acceptable time frame.

For Example: found Bugs, Fixed vs unresolved issues, Final Feedback on gameplay, menus and overall Quality. Network Functions: Test if all network functions are working correct. For Example: Hosting and Joining of game sessions. Also test if the connection of a session remains stable while playing.

FPS Stability: Confirm stable performance (FPS, lags, etc) in all levels.

Testing of Levels: All levels will be thoroughly played and examined for potential errors.

Stress Testing, Edge Cases: Testing if game still is running stable even when under extreme conditions. For example spamming keys very fast. Basically trying to break the game.

Code Testing:

To test the game's code, so-called unit tests are used. Unit testing refers to testing individual, isolated components or functions of the code to ensure they work correctly. Each component is tested independently of other modules.

Goals of Unit Testing:

Verification of the functionality of small code units such as functions, methods, or classes.

Early detection of errors, which reduces the overall costs of error correction.

Approach: For each component to be tested, specific inputs are tested and compared with the expected results. Unit Testing

Once all final tests are complete:

Compile a Final QA Report to summarize the results of your tests.