Unit 2 1
Unit 2 1
• Analyse the input parameters of the system under test and identify different
sets or ranges of input values that should produce the same behaviour.
Determine valid and invalid classes: • Divide the input classes into
two categories: valid and invalid.
• Valid equivalence classes represent inputs that the system should accept
and process correctly, while invalid equivalence classes represent inputs
that the system should reject or handle with error.
• Pay special attention to boundary values, which are the minimum and
maximum values for each input class.
• Test cases using these boundary values are more likely to expose errors
since boundaries are often where systems behave differently.
Consider combinations:
• Document the selected test cases, including the input values, expected
results, and any additional information necessary for executing the tests.
Execute tests:
• Execute the test cases against the system under test, observing the actual
behaviour and comparing it with the expected results.
• Iterate: If differences or failures are found, iterate on the test cases to refine
them. This might involve adjusting the inputs, adding new test cases, or
modifying existing ones to better represent the equivalence classes.
• Refine: Refine the test cases based on the feedback and observations from
the previous iteration. This may include updating boundary values, adding
edge cases, or adjusting the representation of equivalence classes to
improve test coverage and effectiveness.
Slice-Based Testing
• Slice-based testing is a method where instead of testing the entire
software at once, it's divided into smaller parts, called slices, and each
slice is tested individually.
• The software is split into smaller parts or slices, usually based on
functionality or modules.
• Each slice is tested separately to ensure it works correctly on its own.
• This approach makes testing more manageable, speeds up feedback,
allows parallel testing, and improves overall test coverage.
• In essence, slice-based testing simplifies testing by breaking down the
software into smaller, testable units, leading to better quality and
efficiency in the testing process.