ISTQB CTFL v4.0 Practice Test 16
Question 150
A foundation-level tester investigates: A small agile team carries testing to the final release day because it treats every sprint as a separate mini-waterfall. Which TWO complementary steps together provide the most appropriate response and a direct test of its effectiveness? Select TWO answers.
- Add appropriate automated checks at pipeline stages and enforce deployment quality gates while retaining exploratory and other necessary manual work.
- Adapt test levels, timing, feedback and documentation to the lifecycle, testing relevant work products as soon as they are available.
- Compare the delivery model, earliest available test basis, actual test start dates and defect feedback delay.
- Assume the same late single test phase is optimal for every sequential, iterative or incremental software lifecycle.
- Inspect early review outputs, recurring defect patterns, agreed improvement tasks and later evidence that the tasks reduced rework.
Explanation
Correct Answers
B:This is the appropriate testing Recommended action: Adapt test levels, timing, feedback and documentation to the lifecycle, testing relevant work products as soon as they are available. The case involves A small agile team carries testing to the final release day because it treats every sprint as a separate mini-waterfall.
C:This check addresses the issue: Compare the delivery model, earliest available test basis, actual test start dates and defect feedback delay. The test should distinguish observed facts from the assumption that assume the same late single test phase is optimal for every sequential, iterative or incremental software lifecycle. The intended testing outcome is: Each increment or development stage receives timely suitable testing and risk feedback before dependent work accumulates.
Incorrect Answers
A:This is a misconception related to a different testing issue, namely DevOps continuous testing and quality gates, and is not the most direct assumption behind this case. Here, A small agile team carries testing to the final release day because it treats every sprint as a separate mini-waterfall.
D:This shortcut is unsafe: Assume the same late single test phase is optimal for every sequential, iterative or incremental software lifecycle. It neglects the relevant behavior: Testing must fit the chosen SDLC and should occur throughout development rather than only after all implementation ends. In this scenario: A foundation-level tester investigates: A small agile team carries testing to the final release day because it treats every sprint as a separate mini-waterfall.
E:This is a misconception related to a different testing issue, namely Shift-left testing and retrospectives, and is not the most direct assumption behind this case. Here, A small agile team carries testing to the final release day because it treats every sprint as a separate mini-waterfall.
Question 151
A test analyst considers this real project scenario: A developer writes all feature code before drafting a unit test and calls the process test-driven development. Which testing action BEST addresses the stated issue? Select ONE best answer.
- Test the complete system against its requirements, and separately verify interfaces and data exchanges with other systems at system integration level.
- For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
- Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
- Use component tests for isolated units and component integration tests for interfaces and interactions among components.
Explanation
Correct Answer
B:This is the appropriate testing action: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green. The case involves A developer writes all feature code before drafting a unit test and calls the process test-driven development.
Incorrect Answers
A:This is an appropriate consideration for a different situation (System and system integration test levels), but it does not directly resolve the one given here. Here, A developer writes all feature code before drafting a unit test and calls the process test-driven development. The necessary control or test is: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
C:This shortcut is unsafe: Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code. It neglects the relevant behavior: Test-first development uses executable expectations to guide work; the order and feedback cycle distinguish TDD from retroactive unit testing.
D:This is an appropriate consideration for a different situation (Component and component integration test levels), but it does not directly resolve the one given here. Here, A developer writes all feature code before drafting a unit test and calls the process test-driven development. The necessary control or test is: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
Question 152
In a software test-design exercise, the following case arises: A developer writes all feature code before drafting a unit test and calls the process test-driven development. Which principle of software testing BEST explains the problem? Select ONE best answer.
- Test-first development uses executable expectations to guide work; the order and feedback cycle distinguish TDD from retroactive unit testing.
- Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
- Maintenance testing responds to changes or changed environments, and impact analysis informs appropriate regression scope.
- DevOps feedback benefits from continuous testing and automation but tools need meaningful criteria and do not eliminate other testing activities.
Explanation
Correct Answer
A:This is the relevant underlying rule: Test-first development uses executable expectations to guide work; the order and feedback cycle distinguish TDD from retroactive unit testing. In the situation described, A developer writes all feature code before drafting a unit test and calls the process test-driven development.
Incorrect Answers
B:That option would assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code, but it addresses a different concern. The practical response is to for TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
C:This is an appropriate consideration for a different situation (Maintenance testing and change impact analysis), but it does not directly resolve the one given here.
D:This is an appropriate consideration for a different situation (DevOps continuous testing and quality gates), but it does not directly resolve the one given here.
Question 153
A release manager requests independent testing evidence: A developer writes all feature code before drafting a unit test and calls the process test-driven development. Which specific test or review evidence MOST directly establishes what happened? Select ONE best answer.
- Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
- Inspect commits and observed red/green results, incremental code changes and behavior retained through refactoring.
- Review changed artifacts, dependency graph, retired features, prior incident patterns and selected test coverage for affected behavior.
- Compare the delivery model, earliest available test basis, actual test start dates and defect feedback delay.
Explanation
Correct Answer
B:This directly verifies the issue: Inspect commits and observed red/green results, incremental code changes and behavior retained through refactoring. The test should distinguish observed facts from the assumption that assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
Incorrect Answers
A:This shortcut is unsafe: Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code. It neglects the relevant behavior: Test-first development uses executable expectations to guide work; the order and feedback cycle distinguish TDD from retroactive unit testing. For the scenario (A developer writes all feature code before drafting a unit test and calls the process test-driven development.), the required evidence is: Inspect commits and observed red/green results, incremental code changes and behavior retained through refactoring.
C:This is an appropriate consideration for a different situation (Maintenance testing and change impact analysis), but it does not directly resolve the one given here. Here, A developer writes all feature code before drafting a unit test and calls the process test-driven development.
D:This is an appropriate consideration for a different situation (SDLC model influence on test activities), but it does not directly resolve the one given here.
Question 154
A software quality workshop reviews this situation: A developer writes all feature code before drafting a unit test and calls the process test-driven development. Which observed result BEST demonstrates that the testing activity met its stated objective? Select ONE best answer.
- Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
- The original failure no longer occurs and impacted related workflows continue to behave correctly after the change.
- Small tests fail for missing behavior before implementation and pass after minimal changes without regressions during refactoring.
- The calculation is correct by itself and its component interface exchanges valid data with dependent software.
Explanation
Correct Answer
C:This is the observable acceptance result: Small tests fail for missing behavior before implementation and pass after minimal changes without regressions during refactoring. It follows from the testing approach: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
Incorrect Answers
A:This shortcut is unsafe: Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
B:This is an appropriate consideration for a different situation (Confirmation testing and regression testing), but it does not directly resolve the one given here. Here, A developer writes all feature code before drafting a unit test and calls the process test-driven development. The necessary control or test is: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
D:This is an appropriate consideration for a different situation (Component and component integration test levels), but it does not directly resolve the one given here. Here, A developer writes all feature code before drafting a unit test and calls the process test-driven development.
Question 155
A defect investigation documents this situation: A developer writes all feature code before drafting a unit test and calls the process test-driven development. Which misleading assumption about test-first development and tdd feedback MOST directly contributes to this problem and should be rejected? Select ONE best answer.
- Assume passing every isolated unit test automatically proves that data contracts between components are correct.
- Assume shift-left means replacing all late system tests with early reviews and that retrospectives are complete without follow-up actions.
- Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
- Assume the same late single test phase is optimal for every sequential, iterative or incremental software lifecycle.
Explanation
Correct Answer
C:The correct principle is: Test-first development uses executable expectations to guide work; the order and feedback cycle distinguish TDD from retroactive unit testing.
Incorrect Answers
A:This is a misconception related to a different testing issue, namely Component and component integration test levels, and is not the most direct assumption behind this case. Here, A developer writes all feature code before drafting a unit test and calls the process test-driven development.
B:This is a misconception related to a different testing issue, namely Shift-left testing and retrospectives, and is not the most direct assumption behind this case. Here, A developer writes all feature code before drafting a unit test and calls the process test-driven development.
D:This is a misconception related to a different testing issue, namely SDLC model influence on test activities, and is not the most direct assumption behind this case. Here, A developer writes all feature code before drafting a unit test and calls the process test-driven development.
Question 156
A tester and product owner review the following behavior: A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle. Which testing action BEST addresses the stated issue? Select ONE best answer.
- Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
- For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
- Add appropriate automated checks at pipeline stages and enforce deployment quality gates while retaining exploratory and other necessary manual work.
- Run confirmation tests for the reported defect and risk-based regression tests for unaffected behavior potentially impacted by the change.
Explanation
Correct Answer
B:This is the appropriate testing action: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green. The case involves A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.
Incorrect Answers
A:This shortcut is unsafe: Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code. It neglects the relevant behavior: Test-first development uses executable expectations to guide work; the order and feedback cycle distinguish TDD from retroactive unit testing. For the scenario (A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.), the required evidence is: Inspect commits and observed red/green results, incremental code changes and behavior retained through refactoring.
C:This is an appropriate consideration for a different situation (DevOps continuous testing and quality gates), but it does not directly resolve the one given here. Here, A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle. The necessary control or test is: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
D:This is an appropriate consideration for a different situation (Confirmation testing and regression testing), but it does not directly resolve the one given here. Here, A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle. The necessary control or test is: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
Question 157
During test preparation, a team encounters the following issue: A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle. Which principle of software testing BEST explains the problem? Select ONE best answer.
- System testing evaluates the integrated system; system integration testing focuses on interactions between systems and external services.
- Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
- Test-first development uses executable expectations to guide work; the order and feedback cycle distinguish TDD from retroactive unit testing.
- Functional tests ask what the system does; nonfunctional tests evaluate how well it behaves under selected quality characteristics.
Explanation
Correct Answer
C:This is the relevant underlying rule: Test-first development uses executable expectations to guide work; the order and feedback cycle distinguish TDD from retroactive unit testing. In the situation described, A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.
Incorrect Answers
A:This is an appropriate consideration for a different situation (System and system integration test levels), but it does not directly resolve the one given here. Here, A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle. The necessary control or test is: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
B:This shortcut is unsafe: Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code. For the scenario (A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.), the required evidence is: Inspect commits and observed red/green results, incremental code changes and behavior retained through refactoring.
D:This is an appropriate consideration for a different situation (Functional and nonfunctional test types), but it does not directly resolve the one given here. Here, A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle. The necessary control or test is: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
Question 158
During iteration planning and quality review, this issue appears: A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle. Which specific test or review evidence MOST directly establishes what happened? Select ONE best answer.
- Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
- Review changed artifacts, dependency graph, retired features, prior incident patterns and selected test coverage for affected behavior.
- Inspect commits and observed red/green results, incremental code changes and behavior retained through refactoring.
- Inspect the original failing reproduction, changed components, dependencies and results from relevant previously passing tests.
Explanation
Correct Answer
C:This check addresses the issue: Inspect commits and observed red/green results, incremental code changes and behavior retained through refactoring. The test should distinguish observed facts from the assumption that assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
Incorrect Answers
A:It neglects the relevant behavior: Test-first development uses executable expectations to guide work; the order and feedback cycle distinguish TDD from retroactive unit testing. For the scenario (A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.), the required evidence is: Inspect commits and observed red/green results, incremental code changes and behavior retained through refactoring.
B:This is an appropriate consideration for a different situation (Maintenance testing and change impact analysis), but it does not directly resolve the one given here. Here, A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.
D:This is an appropriate consideration for a different situation (Confirmation testing and regression testing), but it does not directly resolve the one given here. Here, A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.
Question 159
A project team is deciding how to test this condition: A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle. Which observed result BEST demonstrates that the testing activity met its stated objective? Select ONE best answer.
- Functional outcomes are correct and prioritized quality characteristics meet explicitly defined measurable thresholds.
- Small tests fail for missing behavior before implementation and pass after minimal changes without regressions during refactoring.
- Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
- Each increment or development stage receives timely suitable testing and risk feedback before dependent work accumulates.
Explanation
Correct Answer
B:This is the observable acceptance result: Small tests fail for missing behavior before implementation and pass after minimal changes without regressions during refactoring. It follows from the testing approach: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green. The case is: A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.
Incorrect Answers
A:This is an appropriate consideration for a different situation (Functional and nonfunctional test types), but it does not directly resolve the one given here. Here, A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.
C:This shortcut is unsafe: Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code. It neglects the relevant behavior: Test-first development uses executable expectations to guide work; the order and feedback cycle distinguish TDD from retroactive unit testing. In this scenario: how to test this condition: A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.
D:This is an appropriate consideration for a different situation (SDLC model influence on test activities), but it does not directly resolve the one given here. Here, A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle. The necessary control or test is: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
Question 160
A foundation-level tester investigates: A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle. Which TWO complementary steps together provide the most appropriate response and a direct test of its effectiveness? Select TWO answers.
- For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green.
- Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code.
- Compare the delivery model, earliest available test basis, actual test start dates and defect feedback delay.
- Inspect commits and observed red/green results, incremental code changes and behavior retained through refactoring.
- Add appropriate automated checks at pipeline stages and enforce deployment quality gates while retaining exploratory and other necessary manual work.
Explanation
Correct Answers
A:This is the appropriate testing Recommended action: For TDD, write a small test expressing desired behavior, observe failure, implement the minimum change, then refactor while tests remain green. The case involves A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.
D:This check addresses the issue: Inspect commits and observed red/green results, incremental code changes and behavior retained through refactoring. The test should distinguish observed facts from the assumption that assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code. The intended testing outcome is: Small tests fail for missing behavior before implementation and pass after minimal changes without regressions during refactoring.
Incorrect Answers
B:This shortcut is unsafe: Assume adding unit tests after implementing a feature is automatically the same practice as writing tests before the production code. It neglects the relevant behavior: Test-first development uses executable expectations to guide work; the order and feedback cycle distinguish TDD from retroactive unit testing. In this scenario: n-level tester investigates: A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.
C:This is a misconception related to a different testing issue, namely SDLC model influence on test activities, and is not the most direct assumption behind this case. Here, A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.
E:This is a misconception related to a different testing issue, namely DevOps continuous testing and quality gates, and is not the most direct assumption behind this case. Here, A team commits tests that were never observed failing before implementation and treats green results as proof of the red-green-refactor cycle.